GSSContext JDK 1.6)

public byte acceptSecContext (byte[] inToken, int offset, int len) throws GSSException

Called by the context acceptor upon receiving a token from the peer.

Called by the context acceptor upon receiving a token from the peer. This method may return an output token which the application will need to send to the peer for further processing by its 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);
     }

Returns: a byte[] containing the token to be sent to the peer. null indicates that no token is generated.
Parameters:
- inToken - token generated by the peer.
- offset - the offset within the inToken where the token begins.
- len - the length of the token.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#NO_CRED GSSException.NO_CRED}, {@link GSSException#CREDENTIALS_EXPIRED GSSException.CREDENTIALS_EXPIRED}, {@link GSSException#BAD_BINDINGS GSSException.BAD_BINDINGS}, {@link GSSException#OLD_TOKEN GSSException.OLD_TOKEN}, {@link GSSException#DUPLICATE_TOKEN GSSException.DUPLICATE_TOKEN}, {@link GSSException#BAD_MECH GSSException.BAD_MECH}, {@link GSSException#FAILURE GSSException.FAILURE}

public void acceptSecContext (InputStream inStream, OutputStream outStream) throws GSSException

Called by the context acceptor to process a token from the peer using streams.

Called by the context acceptor to process a token from the peer using streams. It may write an output token to the 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();
     }

Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#NO_CRED GSSException.NO_CRED}, {@link GSSException#CREDENTIALS_EXPIRED GSSException.CREDENTIALS_EXPIRED}, {@link GSSException#BAD_BINDINGS GSSException.BAD_BINDINGS}, {@link GSSException#OLD_TOKEN GSSException.OLD_TOKEN}, {@link GSSException#DUPLICATE_TOKEN GSSException.DUPLICATE_TOKEN}, {@link GSSException#BAD_MECH GSSException.BAD_MECH}, {@link GSSException#FAILURE GSSException.FAILURE}

public void dispose () throws GSSException

Releases any system resources and cryptographic information stored in the context object and invalidates the context.

public byte export () throws GSSException

Exports this context so that another process may import it..

Exports this context so that another process may import it.. Provided to support the sharing of work between multiple processes. This routine will typically be used by the context-acceptor, in an application where a single process receives incoming connection requests and accepts security contexts over them, then passes the established context to one or more other processes for message exchange.

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.
Returns: a byte[] containing the exported context
Throws:
- GSSException - containing the following major error codes: {@link GSSException#UNAVAILABLE GSSException.UNAVAILABLE}, {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}, {@link GSSException#NO_CONTEXT GSSException.NO_CONTEXT}, {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSManager.createContext(byte[]),

public boolean getAnonymityState ()

Determines if the context initiator is anonymously authenticated to the context acceptor.

Determines if the context initiator is anonymously authenticated to the context acceptor. It can be called by both the context initiator and the context acceptor, and at any time. On the initiator side, a call to this method determines if the identity of the initiator has been disclosed in any of the context establishment tokens that might have been generated thus far by 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.

Returns: true if the context initiator is still anonymous, false otherwise.
See Also: GSSContext.requestAnonymity(boolean),

public boolean getConfState ()

Determines if data confidentiality is available over the context.

Determines if data confidentiality is available over the context. This method can be called by both the context initiator and the context acceptor, but only after one of isProtReady or isEstablished return true. If this method returns true, so will getIntegState

Returns: true if confidentiality services are available, false otherwise.
See Also: GSSContext.requestConf(boolean),

public boolean getCredDelegState ()

Determines if credential delegation is enabled on this context.

Determines if credential delegation is enabled on this context. It can be called by both the context initiator and the context acceptor. For a definitive answer this method must be called only after context establishment is complete. Note that if an initiator requests that delegation not be allowed the requestCredDeleg method will honor that request and this method will return false on the initiator's side from that point onwards.

Returns: true if delegation is enabled, false otherwise.
See Also: GSSContext.requestCredDeleg(boolean),

public GSSCredential getDelegCred () throws GSSException

Obtains the credentials delegated by the context initiator to the context acceptor.

Obtains the credentials delegated by the context
initiator to the context acceptor. It should be called only on the
context acceptor's side, and once the context is fully
established. The caller can use the method getCredDelegState to determine if there are
any delegated credentials.
Returns: a GSSCredential containing the initiator's delegated credentials, or null is no credentials were delegated.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}

public boolean getIntegState ()

Determines if data integrity is available over the context.

Determines if data integrity is available over the context. This method can be called by both the context initiator and the context acceptor, but only after one of isProtReady or isEstablished return true. This method will always return true if getConfState returns true.

Returns: true if integrity services are available, false otherwise.
See Also: GSSContext.requestInteg(boolean),

public int getLifetime ()

Determines what the remaining lifetime for this context is.

public Oid getMech () throws GSSException

Determines what mechanism is being used for this context.

public byte getMIC (byte[] inMsg, int offset, int len, MessageProp msgProp) throws GSSException

Returns a token containing a cryptographic Message Integrity Code (MIC) for the supplied message, for transfer to the peer application.

public void getMIC (InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException

Uses streams to produce a token containing a cryptographic MIC for the supplied message, for transfer to the peer application.

public boolean getMutualAuthState ()

Determines if mutual authentication is enabled on this context.

public boolean getReplayDetState ()

Determines if replay detection is enabled for the per-message security services from this context.

public boolean getSequenceDetState ()

Determines if sequence checking is enabled for the per-message security services from this context.

public GSSName getSrcName () throws GSSException

Returns the name of the context initiator.

Returns the name of the context initiator. This call is valid only
after one of isProtReady or isEstablished return true.
Returns: a GSSName that is an MN containing the name of the context initiator.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSName,

public GSSName getTargName () throws GSSException

Returns the name of the context acceptor.

Returns the name of the context acceptor. This call is valid only
after one of isProtReady or isEstablished return true.
Returns: a GSSName that is an MN containing the name of the context acceptor.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}

public int getWrapSizeLimit (int qop, boolean confReq, int maxTokenSize) throws GSSException

Used to determine limits on the size of the message that can be passed to wrap.

Used to determine limits on the size of the message that can be passed to 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.

Returns: the maximum size of the input token for the given output token size
Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}, {@link GSSException#BAD_QOP GSSException.BAD_QOP}, {@link GSSException#FAILURE GSSException.FAILURE}

public byte initSecContext (byte[] inputBuf, int offset, int len) throws GSSException

Called by the context initiator to start the context creation phase and process any tokens generated by the peer's acceptSecContext method.

Called by the context initiator to start the context creation phase and process any tokens generated by the peer's 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.

Returns: a byte[] containing the token to be sent to the peer. null indicates that no token is generated.
Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#NO_CRED GSSException.NO_CRED}, {@link GSSException#CREDENTIALS_EXPIRED GSSException.CREDENTIALS_EXPIRED}, {@link GSSException#BAD_BINDINGS GSSException.BAD_BINDINGS}, {@link GSSException#OLD_TOKEN GSSException.OLD_TOKEN}, {@link GSSException#DUPLICATE_TOKEN GSSException.DUPLICATE_TOKEN}, {@link GSSException#BAD_NAMETYPE GSSException.BAD_NAMETYPE}, {@link GSSException#BAD_MECH GSSException.BAD_MECH}, {@link GSSException#FAILURE GSSException.FAILURE}

public int initSecContext (InputStream inStream, OutputStream outStream) throws GSSException

Called by the context initiator to start the context creation phase and process any tokens generated by the peer's acceptSecContext method using streams.

Called by the context initiator to start the context creation phase and process any tokens generated by the peer's 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();
     }

Returns: the number of bytes written to the OutputStream as part of the token to be sent to the peer. A value of 0 indicates that no token needs to be sent.
Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#NO_CRED GSSException.NO_CRED}, {@link GSSException#CREDENTIALS_EXPIRED GSSException.CREDENTIALS_EXPIRED}, {@link GSSException#BAD_BINDINGS GSSException.BAD_BINDINGS}, {@link GSSException#OLD_TOKEN GSSException.OLD_TOKEN}, {@link GSSException#DUPLICATE_TOKEN GSSException.DUPLICATE_TOKEN}, {@link GSSException#BAD_NAMETYPE GSSException.BAD_NAMETYPE}, {@link GSSException#BAD_MECH GSSException.BAD_MECH}, {@link GSSException#FAILURE GSSException.FAILURE}

public boolean isEstablished ()

Used during context establishment to determine the state of the context.

Used during context establishment to determine the state of the
context.
Returns: true if this is a fully established context on the caller's side and no more tokens are needed from the peer.

public boolean isInitiator () throws GSSException

Determines if this is the context initiator.

public boolean isProtReady ()

Determines if the context is ready for per message operations to be used over it.

Determines if the context is ready for per message operations to be
used over it. Some mechanisms may allow the usage of the
per-message operations before the context is fully established.
Returns: true if methods like wrap, unwrap, getMIC, and verifyMIC can be used with this context at the current stage of context establishment, false otherwise.

public boolean isTransferable () throws GSSException

Determines if the context is transferable to other processes through the use of the export method.

public void requestAnonymity (boolean state) throws GSSException

Requests that the initiator's identity not be disclosed to the acceptor.

Requests that the initiator's identity not be disclosed to the acceptor. 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 anonymity for the initiator. Therefore, the application should check to see if the request was honored with the getAnonymityState method.

Parameters:
- state - a boolean value indicating if the initiator should be authenticated to the acceptor as an anonymous principal.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getAnonymityState(),

public void requestConf (boolean state) throws GSSException

Requests that data confidentiality be enabled for the wrap method.

Requests that data confidentiality be enabled for the 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.

Parameters:
- state - a boolean value indicating whether confidentiality should be enabled or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getConfState(), GSSContext.getIntegState(), GSSContext.requestInteg(boolean), MessageProp,

public void requestCredDeleg (boolean state) throws GSSException

Requests that the initiator's credentials be delegated to the acceptor during context establishment.

Requests that the initiator's credentials be delegated to the acceptor during context establishment. 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 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.

Parameters:
- state - a boolean value indicating whether the credentials should be delegated or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getCredDelegState(),

public void requestInteg (boolean state) throws GSSException

Requests that data integrity be enabled for the wrap and getMICmethods.

Requests that data integrity be enabled for the 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.

Parameters:
- state - a boolean value indicating whether integrity should be enabled or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getIntegState(),

public void requestLifetime (int lifetime) throws GSSException

Requests a lifetime in seconds for the context.

Requests a lifetime in seconds for the context. This method can only be called on the context initiator's side and it has to be done prior to the first call to initSecContext.

The actual lifetime of the context will depend on the capabilites of the underlying mechanism and the application should call the getLifetime method to determine this.

Parameters:
- lifetime - the desired context lifetime in seconds. Use INDEFINITE_LIFETIME to request an indefinite lifetime and DEFAULT_LIFETIME to request a default lifetime.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getLifetime(),

public void requestMutualAuth (boolean state) throws GSSException

Requests that mutual authentication be done during context establishment.

Requests that mutual authentication be done during context establishment. 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 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.

Parameters:
- state - a boolean value indicating whether mutual authentication shouls be used or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getMutualAuthState(),

public void requestReplayDet (boolean state) throws GSSException

Requests that replay detection be enabled for the per-message security services after context establishemnt.

Requests that replay detection be enabled for the per-message security services after context establishemnt. 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. 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.

Parameters:
- state - a boolean value indicating whether replay detection should be enabled over the established context or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getReplayDetState(),

public void requestSequenceDet (boolean state) throws GSSException

Requests that sequence checking be enabled for the per-message security services after context establishemnt.

Requests that sequence checking be enabled for the per-message security services after context establishemnt. 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. 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.

Parameters:
- state - a boolean value indicating whether sequence checking should be enabled over the established context or not.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}
See Also: GSSContext.getSequenceDetState(),

public void setChannelBinding (ChannelBinding cb) throws GSSException

Sets the channel bindings to be used during context establishment.

Sets the channel bindings to be used during context
establishment. This method can be called on both
the context initiator's and the context acceptor's side, but it must
be called before context establishment begins. This means that an
initiator must call it before the first call to
initSecContext and the acceptor must call it before the
first call to acceptSecContext.
Parameters:
- cb - the channel bindings to use.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#FAILURE GSSException.FAILURE}

public byte unwrap (byte[] inBuf, int offset, int len, MessageProp msgProp) throws GSSException

Used to process tokens generated by the wrap method on the other side of the context.

Used to process tokens generated by the 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.

Returns: a byte[] containing the message unwrapped from the input token.
Parameters:
- inBuf - a byte array containing the wrap token received from peer.
- offset - the offset where the token begins.
- len - the length of the token
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}, {@link GSSException#FAILURE GSSException.FAILURE}

public void unwrap (InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException

Uses streams to process tokens generated by the wrap method on the other side of the context.

Uses streams to process tokens generated by the 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 behaviour described above, this method is equivalent to the byte array based unwrap method.

Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}, {@link GSSException#BAD_MIC GSSException.BAD_MIC}, {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}, {@link GSSException#FAILURE GSSException.FAILURE}

public void verifyMIC (byte[] inToken, int tokOffset, int tokLen, byte[] inMsg, int msgOffset, int msgLen, MessageProp msgProp) throws GSSException

Verifies the cryptographic MIC, contained in the token parameter, over the supplied message.

public void verifyMIC (InputStream tokStream, InputStream msgStream, MessageProp msgProp) throws GSSException

Uses streams to verify the cryptographic MIC, contained in the token parameter, over the supplied message.

Uses streams to verify the cryptographic MIC, contained in the token parameter, over the supplied message. This method is equivalent to the byte array based 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 behaviour described above, this method is equivalent to the byte array based verifyMIC method.

Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN} {@link GSSException#BAD_MIC GSSException.BAD_MIC} {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED} {@link GSSException#FAILURE GSSException.FAILURE}

public byte wrap (byte[] inBuf, int offset, int len, MessageProp msgProp) throws GSSException

Applies per-message security services over the established security context.

public void wrap (InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException

Applies per-message security services over the established security context using streams.

Applies per-message security services over the established security context using streams. The method will return a token with the application supplied data and a cryptographic MIC over it. The data may be encrypted if confidentiality (privacy) was requested. This method is equivalent to the byte array based 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.

Parameters:
- 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.
Throws:
- GSSException - containing the following major error codes: {@link GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}, {@link GSSException#BAD_QOP GSSException.BAD_QOP}, {@link GSSException#FAILURE GSSException.FAILURE}