public interface GSSContext
 If the caller instantiates the context using the default
 GSSManager instance, then the Kerberos v5 GSS-API mechanism
 is guaranteed to be available for context establishment. This mechanism
 is identified by the Oid "1.2.840.113554.1.2.2" and is defined in RFC
 1964.
 Before the context establishment phase is initiated, the context
 initiator may request specific characteristics desired of the
 established context. Not all underlying mechanisms support all
 characteristics that a caller might desire. After the context is
 established, the caller can check the actual characteristics and services
 offered by that context by means of various query methods. When using
 the Kerberos v5 GSS-API mechanism offered by the default
 GSSManager instance, all optional services will be
 available locally. They are mutual authentication, credential
 delegation, confidentiality and integrity protection, and per-message
 replay detection and sequencing. Note that in the GSS-API, message integrity
 is a prerequisite for message confidentiality.
 The context establishment occurs in a loop where the
 initiator calls initSecContext
 and the acceptor calls acceptSecContext until the context is established. While in this loop
 the initSecContext and acceptSecContext
 methods produce tokens that the application sends over to the peer. The
 peer passes any such token as input to its acceptSecContext
 or initSecContext as the case may be.
 During the context establishment phase, the isProtReady method may be called to determine if the
 context can be used for the per-message operations of wrap and getMIC.  This allows applications to use
 per-message operations on contexts which aren't yet fully
 established.
 After the context has been established or the isProtReady
 method returns true, the query routines can be invoked to
 determine the actual characteristics and services of the established
 context.  The application can also start using the per-message methods
 of wrap and
 getMIC to obtain
 cryptographic operations on application supplied data.
 When the context is no longer needed, the application should call
 dispose to release any system resources the context
 may be using.
 A security context typically maintains sequencing and replay detection
 information about the tokens it processes. Therefore, the sequence in
 which any tokens are presented to this context for processing can be
 important. Also note that none of the methods in this interface are
 synchronized. Therefore, it is not advisable to share a
 GSSContext among several threads unless some application
 level synchronization is in place.
Finally, different mechanism providers might place different security restrictions on using GSS-API contexts. These will be documented by the mechanism provider. The application will need to ensure that it has the appropriate permissions if such checks are made in the mechanism layer.
 The example code presented below demonstrates the usage of the
 GSSContext interface for the initiating peer.  Different
 operations on the GSSContext object are presented,
 including: object instantiation, setting of desired flags, context
 establishment, query of actual context flags, per-message operations on
 application data, and finally context deletion.
    // Create a context using default credentials
    // and the implementation specific default mechanism
    GSSManager manager ...
    GSSName targetName ...
    GSSContext context = manager.createContext(targetName, null, null,
                                           GSSContext.INDEFINITE_LIFETIME);
    // set desired context options prior to context establishment
    context.requestConf(true);
    context.requestMutualAuth(true);
    context.requestReplayDet(true);
    context.requestSequenceDet(true);
    // establish a context between peers
    byte []inToken = new byte[0];
    // Loop while there still is a token to be processed
    while (!context.isEstablished()) {
        byte[] outToken
            = context.initSecContext(inToken, 0, inToken.length);
        // send the output token if generated
        if (outToken != null)
            sendToken(outToken);
        if (!context.isEstablished()) {
            inToken = readToken();
    }
     // display context information
     System.out.println("Remaining lifetime in seconds = "
                                          + context.getLifetime());
     System.out.println("Context mechanism = " + context.getMech());
     System.out.println("Initiator = " + context.getSrcName());
     System.out.println("Acceptor = " + context.getTargName());
     if (context.getConfState())
             System.out.println("Confidentiality (i.e., privacy) is available");
     if (context.getIntegState())
             System.out.println("Integrity is available");
     // perform wrap on an application supplied message, appMsg,
     // using QOP = 0, and requesting privacy service
     byte [] appMsg ...
     MessageProp mProp = new MessageProp(0, true);
     byte []tok = context.wrap(appMsg, 0, appMsg.length, mProp);
     sendToken(tok);
     // release the local-end of the context
     context.dispose();
 | Modifier and Type | Field and Description | 
|---|---|
| static int | DEFAULT_LIFETIMEA lifetime constant representing the default context lifetime. | 
| static int | INDEFINITE_LIFETIMEA lifetime constant representing indefinite context lifetime. | 
| Modifier and Type | Method and Description | 
|---|---|
| byte[] | acceptSecContext(byte[] inToken,
                int offset,
                int len)Called by the context acceptor upon receiving a token from the
 peer. | 
| void | acceptSecContext(InputStream inStream,
                OutputStream outStream)Called by the context acceptor to process a token from the peer using
 streams. | 
| void | dispose()Releases any system resources and cryptographic information stored in
 the context object and invalidates the context. | 
| byte[] | export()Exports this context so that another process may
 import it.. | 
| boolean | getAnonymityState()Determines if the context initiator is
 anonymously authenticated to the context acceptor. | 
| boolean | getConfState()Determines if data confidentiality is available
 over the context. | 
| boolean | getCredDelegState()Determines if credential delegation is enabled on
 this context. | 
| GSSCredential | getDelegCred()Obtains the credentials delegated by the context
 initiator to the context acceptor. | 
| boolean | getIntegState()Determines if data integrity is available
 over the context. | 
| int | getLifetime()Determines what the remaining lifetime for this
 context is. | 
| Oid | getMech()Determines what mechanism is being used for this
 context. | 
| byte[] | getMIC(byte[] inMsg,
      int offset,
      int len,
      MessageProp msgProp)Returns a token containing a cryptographic Message Integrity Code
 (MIC) for the supplied message,  for transfer to the peer
 application. | 
| void | getMIC(InputStream inStream,
      OutputStream outStream,
      MessageProp msgProp)Uses streams to produce a token containing a cryptographic MIC for
 the supplied message, for transfer to the peer application. | 
| boolean | getMutualAuthState()Determines if mutual authentication is enabled on
 this context. | 
| boolean | getReplayDetState()Determines if replay detection is enabled for the
 per-message security services from this context. | 
| boolean | getSequenceDetState()Determines if sequence checking is enabled for the
 per-message security services from this context. | 
| GSSName | getSrcName()Returns the name of the context initiator. | 
| GSSName | getTargName()Returns the name of the context acceptor. | 
| int | getWrapSizeLimit(int qop,
                boolean confReq,
                int maxTokenSize)Used to determine limits on the size of the message
 that can be passed to  wrap. | 
| byte[] | initSecContext(byte[] inputBuf,
              int offset,
              int len)Called by the context initiator to start the context creation
 phase and process any tokens generated
 by the peer's  acceptSecContextmethod. | 
| int | initSecContext(InputStream inStream,
              OutputStream outStream)Called by the context initiator to start the context creation
 phase and process any tokens generated
 by the peer's  acceptSecContextmethod using
 streams. | 
| boolean | isEstablished()Used during context establishment to determine the state of the
 context. | 
| boolean | isInitiator()Determines if this is the context initiator. | 
| boolean | isProtReady()Determines if the context is ready for per message operations to be
 used over it. | 
| boolean | isTransferable()Determines if the context is transferable to other processes
 through the use of the  exportmethod. | 
| void | requestAnonymity(boolean state)Requests that the initiator's identity not be
 disclosed to the acceptor. | 
| void | requestConf(boolean state)Requests that data confidentiality be enabled
 for the  wrapmethod. | 
| void | requestCredDeleg(boolean state)Requests that the initiator's credentials be
 delegated to the acceptor during context establishment. | 
| void | requestInteg(boolean state)Requests that data integrity be enabled
 for the  wrapandgetMICmethods. | 
| void | requestLifetime(int lifetime)Requests a lifetime in seconds for the
 context. | 
| void | requestMutualAuth(boolean state)Requests that mutual authentication be done during
 context establishment. | 
| void | requestReplayDet(boolean state)Requests that replay detection be enabled for the
 per-message security services after context establishment. | 
| void | requestSequenceDet(boolean state)Requests that sequence checking be enabled for the
 per-message security services after context establishment. | 
| void | setChannelBinding(ChannelBinding cb)Sets the channel bindings to be used during context
 establishment. | 
| byte[] | unwrap(byte[] inBuf,
      int offset,
      int len,
      MessageProp msgProp)Used to process tokens generated by the  wrapmethod on
 the other side of the context. | 
| void | unwrap(InputStream inStream,
      OutputStream outStream,
      MessageProp msgProp)Uses streams to process tokens generated by the  wrapmethod on the other side of the context. | 
| void | verifyMIC(byte[] inToken,
         int tokOffset,
         int tokLen,
         byte[] inMsg,
         int msgOffset,
         int msgLen,
         MessageProp msgProp)Verifies the cryptographic MIC, contained in the token parameter,
 over the supplied message. | 
| void | verifyMIC(InputStream tokStream,
         InputStream msgStream,
         MessageProp msgProp)Uses streams to verify the cryptographic MIC, contained in the token
 parameter, over the supplied message. | 
| byte[] | wrap(byte[] inBuf,
    int offset,
    int len,
    MessageProp msgProp)Applies per-message security services over the established security
 context. | 
| void | wrap(InputStream inStream,
    OutputStream outStream,
    MessageProp msgProp)Applies per-message security services over the established security
 context using streams. | 
static final int DEFAULT_LIFETIME
static final int INDEFINITE_LIFETIME
Integer.MAX_VALUE.byte[] initSecContext(byte[] inputBuf,
                      int offset,
                      int len)
               throws GSSException
acceptSecContext method.
 This method may return an output token which the application will need
 to send to the peer for processing by its acceptSecContext
 method. The application can call isEstablished to determine if the context establishment phase is
 complete on this side of the context.  A return value of
 false from isEstablished indicates that
 more tokens are expected to be supplied to
 initSecContext.  Upon completion of the context
 establishment, the available context options may be queried through
 the get methods.
 Note that it is possible that the initSecContext method
 return a token for the peer, and isEstablished return
 true also. This indicates that the token needs to be sent
 to the peer, but the local end of the context is now fully
 established.
 Some mechanism providers might require that the caller be granted
 permission to initiate a security context. A failed permission check
 might cause a SecurityException
 to be thrown from this method.
inputBuf - token generated by the peer. This parameter is ignored
 on the first call since no token has been received from the peer.offset - the offset within the inputBuf where the token begins.len - the length of the token.null indicates that no token is generated.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.NO_CRED,
   GSSException.CREDENTIALS_EXPIRED,
   GSSException.BAD_BINDINGS,
   GSSException.OLD_TOKEN,
   GSSException.DUPLICATE_TOKEN,
   GSSException.BAD_NAMETYPE,
   GSSException.BAD_MECH,
   GSSException.FAILUREint initSecContext(InputStream inStream, OutputStream outStream) throws GSSException
acceptSecContext method using
 streams. This method may write an output token to the
 OutpuStream, which the application will
 need to send to the peer for processing by its
 acceptSecContext call. Typically, the application would
 ensure this by calling the  flush
 method on an OutputStream that encapsulates the
 connection between the two peers. The application can
 determine if a token is written to the OutputStream from the return
 value of this method. A return value of 0 indicates that
 no token was written. The application can call
 isEstablished to determine if the context
 establishment phase is complete on this side of the context. A
 return  value of false from isEstablished
 indicates that more tokens are expected to be supplied to
 initSecContext.
 Upon completion of the context establishment, the available context
 options may be queried through the get methods.
 Note that it is possible that the initSecContext method
 return a token for the peer, and isEstablished return
 true also. This indicates that the token needs to be sent
 to the peer, but the local end of the context is now fully
 established.
 The GSS-API authentication tokens contain a definitive start and
 end. This method will attempt to read one of these tokens per
 invocation, and may block on the stream if only part of the token is
 available.  In all other respects this method is equivalent to the
 byte array based initSecContext.
 Some mechanism providers might require that the caller be granted
 permission to initiate a security context. A failed permission check
 might cause a SecurityException
 to be thrown from this method.
The following example code demonstrates how this method might be used:
     InputStream is ...
     OutputStream os ...
     GSSContext context ...
     // Loop while there is still a token to be processed
     while (!context.isEstablished()) {
         context.initSecContext(is, os);
         // send output token if generated
         os.flush();
     }
 inStream - an InputStream that contains the token generated by
 the peer. This parameter is ignored on the first call since no token
 has been or will be received from the peer at that point.outStream - an OutputStream where the output token will be
 written. During the final stage of context establishment, there may be
 no bytes written.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.NO_CRED,
   GSSException.CREDENTIALS_EXPIRED,
   GSSException.BAD_BINDINGS,
   GSSException.OLD_TOKEN,
   GSSException.DUPLICATE_TOKEN,
   GSSException.BAD_NAMETYPE,
   GSSException.BAD_MECH,
   GSSException.FAILUREbyte[] acceptSecContext(byte[] inToken,
                        int offset,
                        int len)
                 throws GSSException
initSecContext call.
 The application can call isEstablished to
 determine if the context establishment phase is complete for this
 peer.  A return value of false from
 isEstablished indicates that more tokens are expected to
 be supplied to this method.    Upon completion of the context
 establishment, the available context options may be queried through
 the get methods.
 Note that it is possible that acceptSecContext return a
 token for the peer, and isEstablished return
 true also.  This indicates that the token needs to be
 sent to the peer, but the local end of the context is now fully
 established.
 Some mechanism providers might require that the caller be granted
 permission to accept a security context. A failed permission check
 might cause a SecurityException
 to be thrown from this method.
The following example code demonstrates how this method might be used:
     byte[] inToken;
     byte[] outToken;
     GSSContext context ...
     // Loop while there is still a token to be processed
     while (!context.isEstablished()) {
         inToken = readToken();
         outToken = context.acceptSecContext(inToken, 0,
                                             inToken.length);
         // send output token if generated
         if (outToken != null)
             sendToken(outToken);
     }
 inToken - token generated by the peer.offset - the offset within the inToken where the token begins.len - the length of the token.null indicates that no token is generated.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.NO_CRED,
   GSSException.CREDENTIALS_EXPIRED,
   GSSException.BAD_BINDINGS,
   GSSException.OLD_TOKEN,
   GSSException.DUPLICATE_TOKEN,
   GSSException.BAD_MECH,
   GSSException.FAILUREvoid acceptSecContext(InputStream inStream, OutputStream outStream) throws GSSException
OutputStream, which the application
 will need to send to the peer for processing by its
 initSecContext method.  Typically, the application would
 ensure this by calling the  flush
 method on an OutputStream that encapsulates the
 connection between the two peers. The application can call
 isEstablished to determine if the context
 establishment phase is complete on this side of the context. A
 return  value of false from isEstablished
 indicates that more tokens are expected to be supplied to
 acceptSecContext.
 Upon completion of the context establishment, the available context
 options may be queried through the get methods.
 Note that it is possible that acceptSecContext return a
 token for the peer, and isEstablished return
 true also.  This indicates that the token needs to be
 sent to the peer, but the local end of the context is now fully
 established.
 The GSS-API authentication tokens contain a definitive start and
 end. This method will attempt to read one of these tokens per
 invocation, and may block on the stream if only part of the token is
 available. In all other respects this method is equivalent to the byte
 array based acceptSecContext.
 Some mechanism providers might require that the caller be granted
 permission to accept a security context. A failed permission check
 might cause a SecurityException
 to be thrown from this method.
The following example code demonstrates how this method might be used:
     InputStream is ...
     OutputStream os ...
     GSSContext context ...
     // Loop while there is still a token to be processed
     while (!context.isEstablished()) {
         context.acceptSecContext(is, os);
         // send output token if generated
         os.flush();
     }
 inStream - an InputStream that contains the token generated by
 the peer.outStream - an OutputStream where the output token will be
 written. During the final stage of context establishment, there may be
 no bytes written.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.NO_CRED,
   GSSException.CREDENTIALS_EXPIRED,
   GSSException.BAD_BINDINGS,
   GSSException.OLD_TOKEN,
   GSSException.DUPLICATE_TOKEN,
   GSSException.BAD_MECH,
   GSSException.FAILUREboolean isEstablished()
true if this is a fully established context on
 the caller's side and no more tokens are needed from the peer.void dispose()
      throws GSSException
GSSException - containing the following
 major error codes:
   GSSException.FAILUREint getWrapSizeLimit(int qop,
                     boolean confReq,
                     int maxTokenSize)
              throws GSSException
wrap. Returns the maximum
 message size that, if presented to the wrap method with
 the same confReq and qop parameters, will
 result in an output token containing no more
 than maxTokenSize bytes.This call is intended for use by applications that communicate over protocols that impose a maximum message size. It enables the application to fragment messages prior to applying protection.
 GSS-API implementations are recommended but not required to detect
 invalid QOP values when getWrapSizeLimit is called.
 This routine guarantees only a maximum message size, not the
 availability of specific QOP values for message protection.
qop - the level of protection wrap will be asked to provide.confReq - true if wrap will be asked to provide
 privacy, false  otherwise.maxTokenSize - the desired maximum size of the token emitted by
 wrap.GSSException - containing the following
 major error codes:
   GSSException.CONTEXT_EXPIRED,
   GSSException.BAD_QOP,
   GSSException.FAILUREbyte[] wrap(byte[] inBuf,
            int offset,
            int len,
            MessageProp msgProp)
     throws GSSException
The MessageProp object is instantiated by the application and used to specify a QOP value which selects cryptographic algorithms, and a privacy service to optionally encrypt the message. The underlying mechanism that is used in the call may not be able to provide the privacy service. It sets the actual privacy service that it does provide in this MessageProp object which the caller should then query upon return. If the mechanism is not able to provide the requested QOP, it throws a GSSException with the BAD_QOP code.
Since some application-level protocols may wish to use tokens emitted by wrap to provide "secure framing", implementations should support the wrapping of zero-length messages.
The application will be responsible for sending the token to the peer.
inBuf - application data to be protected.offset - the offset within the inBuf where the data begins.len - the length of the datamsgProp - instance of MessageProp that is used by the
 application to set the desired QOP and privacy state. Set the
 desired QOP to 0 to request the default QOP. Upon return from this
 method, this object will contain the the actual privacy state that
 was applied to the message by the underlying mechanism.GSSException - containing the following major error codes:
   GSSException.CONTEXT_EXPIRED,
   GSSException.BAD_QOP,
   GSSException.FAILUREvoid wrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
wrap method.
 The application will be responsible for sending the token to the
 peer.  Typically, the application would
 ensure this by calling the  flush
 method on an OutputStream that encapsulates the
 connection between the two peers.
The MessageProp object is instantiated by the application and used to specify a QOP value which selects cryptographic algorithms, and a privacy service to optionally encrypt the message. The underlying mechanism that is used in the call may not be able to provide the privacy service. It sets the actual privacy service that it does provide in this MessageProp object which the caller should then query upon return. If the mechanism is not able to provide the requested QOP, it throws a GSSException with the BAD_QOP code.
Since some application-level protocols may wish to use tokens emitted by wrap to provide "secure framing", implementations should support the wrapping of zero-length messages.
inStream - an InputStream containing the application data to be
 protected. All of the data that is available in
 inStream is used.outStream - an OutputStream to write the protected message
 to.msgProp - instance of MessageProp that is used by the
 application to set the desired QOP and privacy state. Set the
 desired QOP to 0 to request the default QOP. Upon return from this
 method, this object will contain the the actual privacy state that
 was applied to the message by the underlying mechanism.GSSException - containing the following
 major error codes:
   GSSException.CONTEXT_EXPIRED,
   GSSException.BAD_QOP,
   GSSException.FAILUREbyte[] unwrap(byte[] inBuf,
              int offset,
              int len,
              MessageProp msgProp)
       throws GSSException
wrap method on
 the other side of the context. The method will return the message
 supplied by the peer application to its wrap call, while at the same
 time verifying the embedded MIC for that message.The MessageProp object is instantiated by the application and is used by the underlying mechanism to return information to the caller such as the QOP, whether confidentiality was applied to the message, and other supplementary message state information.
Since some application-level protocols may wish to use tokens emitted by wrap to provide "secure framing", implementations should support the wrapping and unwrapping of zero-length messages.
inBuf - a byte array containing the wrap token received from
 peer.offset - the offset where the token begins.len - the length of the tokenmsgProp - upon return from the method, this object will contain
 the applied QOP, the privacy state of the message, and supplementary
 information stating if the token was a duplicate, old, out of
 sequence or arriving after a gap.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.CONTEXT_EXPIRED,
   GSSException.FAILUREvoid unwrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
wrap
 method on the other side of the context. The method will return the
 message supplied by the peer application to its wrap call, while at
 the same time verifying the embedded MIC for that message.The MessageProp object is instantiated by the application and is used by the underlying mechanism to return information to the caller such as the QOP, whether confidentiality was applied to the message, and other supplementary message state information.
Since some application-level protocols may wish to use tokens emitted by wrap to provide "secure framing", implementations should support the wrapping and unwrapping of zero-length messages.
 The format of the input token that this method
 reads is defined in the specification for the underlying mechanism that
 will be used. This method will attempt to read one of these tokens per
 invocation. If the mechanism token contains a definitive start and
 end this method may block on the InputStream if only
 part of the token is available. If the start and end of the token
 are not definitive then the method will attempt to treat all
 available bytes as part of the token.
 Other than the possible blocking behavior described above, this
 method is equivalent to the byte array based unwrap method.
inStream - an InputStream that contains the wrap token generated
 by the peer.outStream - an OutputStream to write the application message
 to.msgProp - upon return from the method, this object will contain
 the applied QOP, the privacy state of the message, and supplementary
 information stating if the token was a duplicate, old, out of
 sequence or arriving after a gap.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN,
   GSSException.BAD_MIC,
   GSSException.CONTEXT_EXPIRED,
   GSSException.FAILUREbyte[] getMIC(byte[] inMsg,
              int offset,
              int len,
              MessageProp msgProp)
       throws GSSException
Note that privacy can only be applied through the wrap call.
Since some application-level protocols may wish to use tokens emitted by getMIC to provide "secure framing", implementations should support derivation of MICs from zero-length messages.
inMsg - the message to generate the MIC over.offset - offset within the inMsg where the message begins.len - the length of the messagemsgProp - an instance of MessageProp that is used
 by the application to set the desired QOP.  Set the desired QOP to
 0 in msgProp to request the default
 QOP. Alternatively pass in null for msgProp
 to request the default QOP.GSSException - containing the following
 major error codes:
   GSSException.CONTEXT_EXPIRED,
   GSSException.BAD_QOP,
   GSSException.FAILUREvoid getMIC(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
getMIC method.
 Note that privacy can only be applied through the wrap call.Since some application-level protocols may wish to use tokens emitted by getMIC to provide "secure framing", implementations should support derivation of MICs from zero-length messages.
inStream - an InputStream containing the message to generate the
 MIC over. All of the data that is available in
 inStream is used.outStream - an OutputStream to write the output token to.msgProp - an instance of MessageProp that is used
 by the application to set the desired QOP.  Set the desired QOP to
 0 in msgProp to request the default
 QOP. Alternatively pass in null for msgProp
 to request the default QOP.GSSException - containing the following
 major error codes:
   GSSException.CONTEXT_EXPIRED,
   GSSException.BAD_QOP,
   GSSException.FAILUREvoid verifyMIC(byte[] inToken,
               int tokOffset,
               int tokLen,
               byte[] inMsg,
               int msgOffset,
               int msgLen,
               MessageProp msgProp)
        throws GSSException
The MessageProp object is instantiated by the application and is used by the underlying mechanism to return information to the caller such as the QOP indicating the strength of protection that was applied to the message and other supplementary message state information.
Since some application-level protocols may wish to use tokens emitted by getMIC to provide "secure framing", implementations should support the calculation and verification of MICs over zero-length messages.
inToken - the token generated by peer's getMIC method.tokOffset - the offset within the inToken where the token
 begins.tokLen - the length of the token.inMsg - the application message to verify the cryptographic MIC
 over.msgOffset - the offset in inMsg where the message begins.msgLen - the length of the message.msgProp - upon return from the method, this object will contain
 the applied QOP and supplementary information stating if the token
 was a duplicate, old, out of sequence or arriving after a gap.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN
   GSSException.BAD_MIC
   GSSException.CONTEXT_EXPIRED
   GSSException.FAILUREvoid verifyMIC(InputStream tokStream, InputStream msgStream, MessageProp msgProp) throws GSSException
verifyMIC method.
 The MessageProp object is instantiated by the application and is used
 by the underlying mechanism to return information to the caller such
 as the QOP indicating the strength of protection that was applied to
 the message and other supplementary message state information.Since some application-level protocols may wish to use tokens emitted by getMIC to provide "secure framing", implementations should support the calculation and verification of MICs over zero-length messages.
 The format of the input token that this method
 reads is defined in the specification for the underlying mechanism that
 will be used. This method will attempt to read one of these tokens per
 invocation. If the mechanism token contains a definitive start and
 end this method may block on the InputStream if only
 part of the token is available. If the start and end of the token
 are not definitive then the method will attempt to treat all
 available bytes as part of the token.
 Other than the possible blocking behavior described above, this
 method is equivalent to the byte array based verifyMIC method.
tokStream - an InputStream containing the token generated by the
 peer's getMIC method.msgStream - an InputStream containing the application message to
 verify the cryptographic MIC over. All of the data
 that is available in msgStream is used.msgProp - upon return from the method, this object will contain
 the applied QOP and supplementary information stating if the token
 was a duplicate, old, out of sequence or arriving after a gap.GSSException - containing the following
 major error codes:
   GSSException.DEFECTIVE_TOKEN
   GSSException.BAD_MIC
   GSSException.CONTEXT_EXPIRED
   GSSException.FAILUREbyte[] export()
       throws GSSException
 This method deactivates the security context and creates an
 interprocess token which, when passed to GSSManager.createContext in
 another process, will re-activate the context in the second process.
 Only a single instantiation of a given context may be active at any
 one time; a subsequent attempt by a context exporter to access the
 exported security context will fail.
The implementation may constrain the set of processes by which the interprocess token may be imported, either as a function of local security policy, or as a result of implementation decisions. For example, some implementations may constrain contexts to be passed only between processes that run under the same account, or which are part of the same process group.
The interprocess token may contain security-sensitive information (for example cryptographic keys). While mechanisms are encouraged to either avoid placing such sensitive information within interprocess tokens, or to encrypt the token before returning it to the application, in a typical GSS-API implementation this may not be possible. Thus the application must take care to protect the interprocess token, and ensure that any process to which the token is transferred is trustworthy.
 Implementations are not required to support the inter-process
 transfer of security contexts.  Calling the isTransferable method will indicate if the context object is
 transferable.
 Calling this method on a context that
 is not exportable will result in this exception being thrown with
 the error code GSSException.UNAVAILABLE.
GSSException - containing the following
 major error codes:
   GSSException.UNAVAILABLE,
   GSSException.CONTEXT_EXPIRED,
   GSSException.NO_CONTEXT,
   GSSException.FAILUREGSSManager.createContext(byte[])void requestMutualAuth(boolean state)
                throws GSSException
initSecContext.
 Not all mechanisms support mutual authentication and some mechanisms
 might require mutual authentication even if the application
 doesn't. Therefore, the application should check to see if the
 request was honored with the getMutualAuthState method.
state - a boolean value indicating whether mutual
 authentication should be used or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetMutualAuthState()void requestReplayDet(boolean state)
               throws GSSException
initSecContext. During context establishment replay
 detection is not an option and is a function of the underlying
 mechanism's capabilities.
 Not all mechanisms support replay detection and some mechanisms
 might require replay detection even if the application
 doesn't. Therefore, the application should check to see if the
 request was honored with the getReplayDetState method. If replay detection is enabled then the
 MessageProp.isDuplicateToken and MessageProp.isOldToken methods will return
 valid results for the MessageProp object that is passed
 in to the unwrap method or the verifyMIC
 method.
state - a boolean value indicating whether replay detection
 should be enabled over the established context or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetReplayDetState()void requestSequenceDet(boolean state)
                 throws GSSException
initSecContext. During context establishment sequence
 checking is not an option and is a function of the underlying
 mechanism's capabilities.
 Not all mechanisms support sequence checking and some mechanisms
 might require sequence checking even if the application
 doesn't. Therefore, the application should check to see if the
 request was honored with the getSequenceDetState method. If sequence checking is enabled then the
 MessageProp.isDuplicateToken,
 MessageProp.isOldToken,
 MessageProp.isUnseqToken, and
 MessageProp.isGapToken methods will return
 valid results for the MessageProp object that is passed
 in to the unwrap method or the verifyMIC
 method.
state - a boolean value indicating whether sequence checking
 should be enabled over the established context or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetSequenceDetState()void requestCredDeleg(boolean state)
               throws GSSException
initSecContext.
 Not all mechanisms support credential delegation. Therefore, an
 application that desires delegation should check to see if the
 request was honored with the getCredDelegState method. If the application indicates that
 delegation must not be used, then the mechanism will honor the
 request and delegation will not occur. This is an exception
 to the general rule that a mechanism may enable a service even if it
 is not requested.state - a boolean value indicating whether the credentials
 should be delegated or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetCredDelegState()void requestAnonymity(boolean state)
               throws GSSException
initSecContext.
 Not all mechanisms support anonymity for the initiator. Therefore, the
 application should check to see if the request was honored with the
 getAnonymityState method.state - a boolean value indicating if the initiator should
 be authenticated to the acceptor as an anonymous principal.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetAnonymityState()void requestConf(boolean state)
          throws GSSException
wrap method. This request can only be made on
 the context initiator's side and it has to be done prior to the
 first call to initSecContext.
 Not all mechanisms support confidentiality and other mechanisms
 might enable it even if the application doesn't request
 it. The application may check to see if the request was honored with
 the getConfState method. If confidentiality
 is enabled, only then will the mechanism honor a request for privacy
 in the MessageProp
 object that is passed in to the wrap method.Enabling confidentiality will also automatically enable integrity.
state - a boolean value indicating whether confidentiality
 should be enabled or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetConfState(), 
getIntegState(), 
requestInteg(boolean), 
MessagePropvoid requestInteg(boolean state)
           throws GSSException
wrap and getMICmethods. This
 request can only be made on the context initiator's side and it has
 to be done prior to the first call to initSecContext.
 Not all mechanisms support integrity and other mechanisms
 might enable it even if the application doesn't request
 it. The application may check to see if the request was honored with
 the getIntegState method.Disabling integrity will also automatically disable confidentiality.
state - a boolean value indicating whether integrity
 should be enabled or not.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetIntegState()void requestLifetime(int lifetime)
              throws GSSException
initSecContext.
 The actual lifetime of the context will depend on the capabilities of
 the underlying mechanism and the application should call the getLifetime method to determine this.
lifetime - the desired context lifetime in seconds. Use
 INDEFINITE_LIFETIME to request an indefinite lifetime
 and DEFAULT_LIFETIME to request a default lifetime.GSSException - containing the following
 major error codes:
   GSSException.FAILUREgetLifetime()void setChannelBinding(ChannelBinding cb) throws GSSException
initSecContext and the acceptor must call it before the
 first call to acceptSecContext.cb - the channel bindings to use.GSSException - containing the following
 major error codes:
   GSSException.FAILUREboolean getCredDelegState()
requestCredDeleg method will honor that
 request and this method will return false on the
 initiator's side from that point onwards. requestCredDeleg(boolean)boolean getMutualAuthState()
requestMutualAuth(boolean)boolean getReplayDetState()
requestReplayDet(boolean)boolean getSequenceDetState()
requestSequenceDet(boolean)boolean getAnonymityState()
initSecContext. An initiator that absolutely must be
 authenticated anonymously should call this method after each call to
 initSecContext to determine if the generated token
 should be sent to the peer or the context aborted. On the
 acceptor side, a call to this method determines if any of the tokens
 processed by acceptSecContext thus far have divulged
 the identity of the initiator.requestAnonymity(boolean)boolean isTransferable()
                throws GSSException
export method.  This call
 is only valid on fully established contexts.GSSException - containing the following
 major error codes:
   GSSException.FAILUREboolean isProtReady()
wrap, unwrap,
 getMIC, and verifyMIC can be used with
 this context at the current stage of context establishment, false
 otherwise.boolean getConfState()
isProtReady or isEstablished return true. If this method returns
 true, so will getIntegStaterequestConf(boolean)boolean getIntegState()
isProtReady or isEstablished return true. This method will always
 return true if getConfState
 returns true.requestInteg(boolean)int getLifetime()
isEstablished returns
 true.requestLifetime(int)GSSName getSrcName() throws GSSException
isProtReady or isEstablished return true.GSSException - containing the following
 major error codes:
   GSSException.FAILUREGSSNameGSSName getTargName() throws GSSException
isProtReady or isEstablished return true.GSSException - containing the following
 major error codes:
   GSSException.FAILUREOid getMech() throws GSSException
GSSException - containing the following
 major error codes:
   GSSException.FAILUREGSSCredential getDelegCred() throws GSSException
getCredDelegState to determine if there are
 any delegated credentials.null is no credentials
 were delegated.GSSException - containing the following
 major error codes:
   GSSException.FAILUREboolean isInitiator()
             throws GSSException
GSSException - containing the following
 major error codes:
   GSSException.FAILURE Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2025, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.