org.ietf.jgss
接口 GSSContext

public interface GSSContext

此接口将封装 GSS-API 安全上下文，并提供可通过上下文提供的安全服务。安全上下文是使用本地获取的凭据在同位体之间创建的。在一对同位体之间可能会同时存在多个上下文，它们使用一套相同或不同的凭据。GSS-API 的执行方式与基础传输协议无关，而是取决于其对传输标记的应用程序的调用，这些标记由同位体之间的安全上下文生成。

如果调用者使用默认的 GSSManager 实例实例化上下文，则可保证 Kerberos v5 GSS-API 机制可用于上下文创建。此机制由 Oid "1.2.840.113554.1.2.2" 标识，并在 RFC 1964 中被进行定义。

在初始化上下文创建阶段之前，上下文初始化程序会请求已创建的上下文所需要的特定特征。并非所有的基础机制都支持调用者所需要的全部特征。在创建上下文之后，调用者可以通过多种查询方法来检查由该上下文提供的实际特征和服务。当使用由默认的 GSSManager 实例提供的 Kerberos v5 GSS-API 机制时，所有的可选服务都可本地提供。它们是相互验证、凭据委托、机密性和完整性保护、以及 per-message 重放检测和排序。注意，在 GSS-API 中，消息完整性是消息机密性的先决条件。

上下文创建必须在这样一个环路中进行：初始端调用 initSecContext，接受端调用 acceptSecContext，直到创建好该上下文。同时，在此环路中，initSecContext 和 acceptSecContext 方法将产生应用程序发送给同位体的标记。同位体将根据情况将任何这样的标记作为输入传递给它的 acceptSecContext 或 initSecContext。

在上下文创建阶段，可能会调用 isProtReady 方法来确定是否可以将该上下文用于 wrap 和 getMIC 的 per-message 操作。这将允许应用程序在尚未完全创建的上下文上使用 per-message 操作。

在上下文创建好或 isProtReady 方法返回 true后，可调用查询例程来确定已创建上下文的实际特征和服务。还可以通过使用 wrap 和 getMIC 的 per-message 方法来启动应用程序，以获取对应用程序提供的数据的加密操作。

当不再需要上下文时，应用程序必须调用 dispose 来释放该上下文可能正在使用的任何系统资源。

安全上下文一般都维护有关它所处理的标记的排序和重放检测方面的信息。因此，将标记呈现给此上下文以进行处理的顺序非常重要。还要注意的是，此接口中的任何方法都不同步。因此，除非已经实施了某些应用程序级的同步，否则建议不要在几个线程之间共享 GSSContext。

最后一点是，不同的机制提供商可能会对使用 GSS-API 上下文提出不同的安全限制。这些将由机制提供商记入文档。应用程序需要确保是否具有适当的权限在机制层中进行此类检查。

下面呈现的示例代码演示了使用 GSSContext 接口初始化同位体的情况。它呈现了在 GSSContext 对象上的不同操作，其中包括：对象初始化、所需标志的设置、上下文创建、对实际上下文标志的查询、对应用程序数据的 per-message 操作和最终的上下文删除。

    // 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();

 

从以下版本开始：

1.4

---

字段摘要
static int	DEFAULT_LIFETIME           一个表示默认的上下文生存期的生存期常量。
static int	INDEFINITE_LIFETIME           一个表示不确定的上下文生存期的生存期常量。

 

方法摘要
byte[]	acceptSecContext(byte[] inToken, int offset, int len)           由上下文接受端在收到同位体的标记后调用。
void	acceptSecContext(InputStream inStream, OutputStream outStream)           由上下文接受端调用，以处理来自使用流的同位体的标记。
void	dispose()           释放存储在上下文对象中并且使上下文无效的系统资源和加密信息。
byte[]	export()           导出此上下文，以便使其他进程能够导入它。
boolean	getAnonymityState()           确定是否会向上下文接受端对上下文初始端进行匿名验证。
boolean	getConfState()           确定数据机密性是否可用于上下文。
boolean	getCredDelegState()           确定是否在此上下文上启用凭据委托。
GSSCredential	getDelegCred()           获取上下文初始端委托给上下文接受端的凭据。
boolean	getIntegState()           确定数据完整性是否可用于上下文。
int	getLifetime()           确定此上下文剩余的生存期是多长。
Oid	getMech()           确定什么机制正用于此上下文。
byte[]	getMIC(byte[] inMsg, int offset, int len, MessageProp msgProp)           返回包含所提供消息的加密消息完整性代码 (MIC) 的标记，以便传输到同位体应用程序。
void	getMIC(InputStream inStream, OutputStream outStream, MessageProp msgProp)           使用流来产生包含所提供消息的加密 MIC 的标记，以便传输到同位体应用程序。
boolean	getMutualAuthState()           确定是否在此上下文上启用了相互验证。
boolean	getReplayDetState()           确定是否针对此上下文中的 per-message 安全服务启用了重放检测。
boolean	getSequenceDetState()           确定是否针对本上下文中的 per-message 安全服务启用了序列检查。
GSSName	getSrcName()           返回上下文初始端的名称。
GSSName	getTargName()           返回上下文接受端的名称。
int	getWrapSizeLimit(int qop, boolean confReq, int maxTokenSize)           用来确定可以传输给 wrap 的消息的大小限制。
byte[]	initSecContext(byte[] inputBuf, int offset, int len)           由上下文初始端调用，以启动上下文创建阶段，处理由同位体的 acceptSecContext 方法生成的任何标记。
int	initSecContext(InputStream inStream, OutputStream outStream)           由上下文初始端调用，以启动上下文的创建阶段，处理由使用流的同位体的 acceptSecContext 方法生成的任何标记。
boolean	isEstablished()           用来在上下文创建期间确定上下文的状态。
boolean	isInitiator()           确定它是否为上下文初始端。
boolean	isProtReady()           确定上下文是否已为要在其上使用的 per message 准备就绪。
boolean	isTransferable()           确定通过使用 export 方法，该上下文是否可以传输给其他进程。
void	requestAnonymity(boolean state)           请求不要将初始端的身份泄露给接受端。
void	requestConf(boolean state)           请求针对 wrap 方法启用数据机密性。
void	requestCredDeleg(boolean state)           请求在上下文创建期间将初始端的凭据委托给接受端。
void	requestInteg(boolean state)           请求针对 wrap 和 getMIC 方法启用数据完整性。
void	requestLifetime(int lifetime)           请求上下文以秒为单位的生存期。
void	requestMutualAuth(boolean state)           要求相互验证在上下文创建期间完成。
void	requestReplayDet(boolean state)           请求在上下文创建之后针对 per-message 安全服务启用重放检测。
void	requestSequenceDet(boolean state)           请求在上下文创建之后针对 per-message 安全服务启用序列检查。
void	setChannelBinding(ChannelBinding cb)           设置在上下文创建期间使用的通道绑定。
byte[]	unwrap(byte[] inBuf, int offset, int len, MessageProp msgProp)           用来处理在上下文的另一方由 wrap 方法生成的标记。
void	unwrap(InputStream inStream, OutputStream outStream, MessageProp msgProp)           使用流来处理在上下文的另一方由 wrap 方法生成的标记。
void	verifyMIC(byte[] inToken, int tokOffset, int tokLen, byte[] inMsg, int msgOffset, int msgLen, MessageProp msgProp)           通过提供的消息，检查包含在标记参数中的加密的 MIC。
void	verifyMIC(InputStream tokStream, InputStream msgStream, MessageProp msgProp)           通过提供的消息，使用流来验证包含在标记参数中的加密的 MIC。
byte[]	wrap(byte[] inBuf, int offset, int len, MessageProp msgProp)           将 per-message 安全服务应用于已创建的安全上下文。
void	wrap(InputStream inStream, OutputStream outStream, MessageProp msgProp)           将 per-message 安全服务应用于已创建的使用流的安全上下文。

 

字段详细信息

DEFAULT_LIFETIME

static final int DEFAULT_LIFETIME

一个表示默认的上下文生存期的生存期常量。此值被设置为 0。

另请参见：

常量字段值

---

INDEFINITE_LIFETIME

static final int INDEFINITE_LIFETIME

一个表示不确定的上下文生存期的生存期常量。在 Java 中必须将此值设置为最大整数值 -- Integer.MAX_VALUE。

另请参见：

常量字段值

方法详细信息

initSecContext

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

由上下文初始端调用，以启动上下文创建阶段，处理由同位体的 acceptSecContext 方法生成的任何标记。此方法会返回一个应用程序需要发送给同位体、以便由其 acceptSecContext 方法进行处理的输出标记。应用程序可以调用 isEstablished 来确定在上下文的这一方是否完成了上下文创建阶段。如果从 isEstablished 中返回的值是 false，则指示希望为 initSecContext 提供更多的标记。完成上下文创建后，可通过 get 方法查询可用的上下文选项。

注意，有可能出现这样一种情况：initSecContext 方法为同位体返回一个标记，isEstablished 也返回 true。这表示，需要将标记发送给同位体，但该上下文的本地端现已完全创建。

有些机制提供商可能会要求调用者授予初始化安全上下文的权限。失败的权限检查可以导致从此方法中抛出 SecurityException。

参数：

inputBuf - 由同位体生成的标记。由于尚未从该同位体中接收到标记，因此在初次调用时此参数将被忽略。

offset - inputBuf 中标记开始处的偏移量。

len - 该标记的长度。

返回：

包含发送给同位体标记的 byte[]。 null 指示未生成任何标记。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN 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.FAILURE

GSSException

---

initSecContext

int initSecContext(InputStream inStream,
                   OutputStream outStream)
                   throws GSSException

由上下文初始端调用，以启动上下文的创建阶段，处理由使用流的同位体的 acceptSecContext 方法生成的任何标记。此方法将向 OutpuStream 写入输出标记，应用程序需要将此标记发送到同位体以便通过其 acceptSecContext 调用进行处理。一般情况下，应用程序会通过在 OutputStream 上调用 flush 方法来确保封装这两个同位体之间的连接。应用程序可以通过此方法返回的值确定是否向 OutputStream 写入了标记。如果返回的值是 0，则表示没有写入任何值。应用程序可以调用 isEstablished 来确定在上下文的这一方是否完成了上下文创建阶段。如果从 isEstablished 中返回的值是 false，则指示希望为 initSecContext 提供更多的标记。完成上下文创建后，可通过 get 方法查询可用的上下文选项。

注意，有可能出现这样一种情况：initSecContext 方法为同位体返回一个标记，isEstablished 也返回 true。这表示，需要将标记发送给同位体，但该上下文的本地端现已完全创建。

GSS-API 验证标记包括确定的始端和终端。此方法将尝试每次调用时读取其中的一个标记，并且在仅有部分标记可用时阻塞流。在所有其他方面，此方法等同于基于字节数组的 initSecContext。

有些机制提供商可能会要求调用者授予初始化安全上下文的权限。失败的权限检查可能会导致从此方法中抛出 SecurityException。

以下示例代码演示了使用此方法的方式：

     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 - 一个包含由同位体生成的标记的 InputStream。由于尚未（不会）从该同位体的该点接收到标记，因此在初次调用时此参数将被忽略。

outStream - 将向其中写入输出标记的 OutputStream。在上下文创建的最终阶段，可能不需要写入字节。

返回：

将作为标记的一部分发送给同位体、写入到 OutputStream 的字节数。0 值指示不需要发送标记。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN 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.FAILURE

GSSException

---

acceptSecContext

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

由上下文接受端在收到同位体的标记后调用。此方法会返回一个输出标记，应用程序将把该标记发送到同位体、以便通过其 initSecContext 调用进行进一步处理。

应用程序可以通过调用 isEstablished 来确定是否完成了此同位体的上下文创建阶段。如果从 isEstablished 中返回的值是 false，则指示希望为此方法提供更多的标记。完成上下文创建后，可通过 get 方法查询可用的上下文选项。

注意，有可能出现这样一种情况：acceptSecContext 为同位体返回一个标记，isEstablished 也返回 true。这表示，需要将标记发送给同位体，但该上下文的本地端现已完全创建。

有些机制提供商可能会要求调用者授予接受安全上下文的权限。失败的权限检查可能会导致从此方法中抛出 SecurityException。

以下示例代码演示了使用此方法的方式：

     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 - 由同位体生成的标记。

offset - inToken 中标记开始处的偏移量。

len - 该标记的长度。

返回：

包含发送给同位体标记的 byte[]。 null 指示未生成任何标记。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN 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.FAILURE

GSSException

---

acceptSecContext

void acceptSecContext(InputStream inStream,
                      OutputStream outStream)
                      throws GSSException

由上下文接受端调用，以处理来自使用流的同位体的标记。此方法将向 OutputStream 写入输出标记，应用程序需要将此标记发送到同位体以便通过其 initSecContext 方法进行处理。一般情况下，应用程序会通过在 OutputStream 上调用 flush 方法来确保封装这两个同位体之间的连接。应用程序可以调用 isEstablished 来确定在上下文的这一方是否完成了上下文创建阶段。如果从 isEstablished 中返回的值为 false，则指示希望为 acceptSecContext 提供更多的标记。完成上下文创建后，可通过 get 方法查询可用的上下文选项。

注意，有可能出现这样一种情况：acceptSecContext 为同位体返回一个标记，isEstablished 也返回 true。这表示，需要将标记发送给同位体，但该上下文的本地端现已完全创建。

GSS-API 验证标记包括确定的起始端和终端。此方法将尝试每调用一次读取其中的一个标记，并且在仅有部分标记可用时阻塞流。在所有其他方面，此方法等同于基于字节数组的 acceptSecContext。

有些机制提供商可能会要求调用者授予接受安全上下文的权限。失败的权限检查可能会导致从此方法中抛出 SecurityException。

以下示例代码演示了使用此方法的方式：

     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 - 一个包含由同位体生成的标记的 InputStream。

outStream - 将向其中写入输出标记的 OutputStream。在上下文创建的最终阶段，可能不需要写入字节。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN 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.FAILURE

GSSException

---

isEstablished

boolean isEstablished()

用来在上下文创建期间确定上下文的状态。

返回：

如果它是在调用者上完全创建的上下文，并且不再需要来自同位体的标记，则返回 true。

---

dispose

void dispose()
             throws GSSException

释放存储在上下文对象中并且使上下文无效的系统资源和加密信息。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#FAILURE GSSException.FAILURE}

GSSException

---

getWrapSizeLimit

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

用来确定可以传输给 wrap 的消息的大小限制。如果以相同的 confReq 和 qop 参数呈现给 wrap 方法，则将返回最大的消息大小，这会导致输出标记只包含 maxTokenSize 个字节。

此调用主要供那些通过影响最大消息大小的协议进行通信的应用程序使用。它使应用程序能够在实施保护之前将消息进行分段。

在调用 getWrapSizeLimit 时，推荐实现 GSS-API，但不要求检测无效的 QOP 值。此例程可保证只有最大消息大小，而不是针对消息保护的特定 QOP 值的可用性。

参数：

qop - 将要求 wrap 提供的保护级别。

confReq - 如果要求 wrap 提供保密性，则为 true，否则为 false。

maxTokenSize - 由 wrap 发出的标记所需的最大大小。

返回：

针对给定的输出标记大小的输入标记的最大大小

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}、 GSSException.BAD_QOP、 GSSException.FAILURE

GSSException

---

wrap

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

将 per-message 安全服务应用于已创建的安全上下文。该方法将通过它返回一个带有应用程序提供的数据和加密的 MIC 的标记。如果需要机密性（保密性），则可以对数据进行加密。

MessageProp 对象可以通过应用程序进行实例化，并可用来指定一个选择加密算法的 QOP 值，和可选地对消息进行加密的私密服务。在调用中使用的基础机制可能无法提供私密服务。但它将设置在此 MessageProp 对象中提供的实际私密服务，调用者会在该调用返回后对其进行查询。如果机制不能提供请求的 QOP，则它将抛出带有 BAD_QOP 代码的 GSSException。

由于某些应用程序级的协议希望使用 wrap 发出的标记来提供 "secure framing"（安全分帧），所以实现应该支持包装零长度的消息。

应用程序将负责将标记发送到同位体。

参数：

inBuf - 要保护的应用程序数据。

offset - inBuf 中数据开始处的偏移量。

len - 数据的长度

msgProp - MessageProp 的实例，应用程序使用它来设置需要的 QOP 和私密状态。将需要的 QOP 设置为 0，以便请求默认的 QOP。从此方法返回后，此对象将包含基础机制应用于消息的实际私密状态。

返回：

包含将发送给同位体的标记的 byte[]。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}、 GSSException.BAD_QOP、 GSSException.FAILURE

GSSException

---

wrap

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

将 per-message 安全服务应用于已创建的使用流的安全上下文。该方法将通过它返回一个带有应用程序提供的数据和加密的 MIC 的标记。如果需要机密性（保密性），则可以对数据进行加密。此方法等同于基于字节数组的 wrap 方法。

应用程序将负责将标记发送到同位体。一般情况下，应用程序会通过在 OutputStream 上调用 flush 方法来确保封装这两个同位体之间的连接。

MessageProp 对象可以通过应用程序进行实例化，并可用来指定一个选择加密算法的 QOP 值，和可选地对消息进行加密的私密服务。在调用中使用的基础机制可能无法提供私密服务。但它将设置在此 MessageProp 对象中提供的实际私密服务，调用者会在该调用返回后对其进行查询。如果机制不能提供请求的 QOP，则它将抛出带有 BAD_QOP 代码的 GSSException。

由于某些应用程序级的协议希望使用 wrap 发出的标记来提供 "secure framing"（安全分帧），所以实现应该支持包装零长度的消息。

参数：

inStream - 一个包含受保护的应用程序数据的 InputStream。将使用 inStream 中提供的所有数据。

outStream - 向其写入受保护消息的 OutputStream。

msgProp - MessageProp 的实例，应用程序使用它来设置需要的 QOP 和保密状态。将需要的 QOP 设置为 0，以便请求默认的 QOP。从此方法返回后，此对象将包含基础机制应用于消息的实际私密状态。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}、 GSSException.BAD_QOP、 GSSException.FAILURE

GSSException

---

unwrap

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

用来处理在上下文的另一方由 wrap 方法生成的标记。该方法将由同位体应用程序提供的消息返回到其 wrap 调用，同时验证为该消息嵌入的 MIC。

MessageProp 对象将由应用程序实例化，并由基础机制使用，以便返回给调用者一些信息，如 QOP、是否对消息应用了机密性，以及其他一些增补消息状态信息。

由于某些应用程序级的协议希望使用 wrap 发出的标记来提供 "secure framing"（安全分帧），所以实现必须支持包装和不包装零长度的消息。

参数：

inBuf - 包含从同位体接收的包装标记的字节数组。

offset - 标记开始处的偏移量。

len - 标记的长度

msgProp - 从此方法返回后，此对象将包括所应用的 QOP、消息的保密状态、和说明该标记是否为复制的、旧的、超出序列的或在 gap 后进入的标记的增补信息。

返回：

包含从输入标记中展开的消息的 byte[]。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}、 GSSException.BAD_MIC、 GSSException.CONTEXT_EXPIRED、 GSSException.FAILURE

GSSException

---

unwrap

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

使用流来处理在上下文的另一方由 wrap 方法生成的标记。该方法将由同位体应用程序提供的消息返回到其 wrap 调用，同时验证为该消息嵌入的 MIC。

MessageProp 对象将由应用程序实例化，并由基础机制使用，以便返回给调用者一些信息，如 QOP、是否对消息应用了机密性，以及其他一些增补消息状态信息。

由于某些应用程序级的协议希望使用 wrap 发出的标记来提供 "secure framing"（安全分帧），所以实现必须支持包装和不包装零长度的消息。

此方法读取的输入标记的格式在将要使用的基础机制的规范中定义。此方法将尝试每调用一次读取其中的一个标记。如果机制标记包含确定的始端和终端，则在仅有部分标记可用时，此方法将阻塞 InputStream。如果标记的始端和终端不是确定的，则该方法会尝试将所有的可用字节视为标记的一部分。

与前面介绍的可能出现的阻塞行为不同，此方法等同于基于字节数组的 unwrap 方法。

参数：

inStream - 一个包含由同位体生成的包装标记的 InputStream。

outStream - 向其写入应用程序消息的 OutputStream。

msgProp - 从方法返回后，此对象将包括所用的 QOP、消息的保密状态和说明该标记是否为复制的、旧的、超出序列或在 gap 后进入的标记的增补信息。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#DEFECTIVE_TOKEN GSSException.DEFECTIVE_TOKEN}、 GSSException.BAD_MIC、 GSSException.CONTEXT_EXPIRED、 GSSException.FAILURE

GSSException

---

getMIC

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

返回包含所提供消息的加密消息完整性代码 (MIC) 的标记，以便传输到同位体应用程序。与将用户消息封装在返回的标记中的包装不同，在输出标记中仅返回消息 MIC。

注意，保密性只能应用于 wrap 调用。

由于某些应用程序级的协议希望使用 getMIC 发出的标记来提供 "secure framing"（安全分帧），所以实现必须支持从零长度消息中导出 MIC。

参数：

inMsg - 在其上生成 MIC 的消息。

offset - inMsg 中消息开始处的偏移量。

len - 消息的长度

msgProp - MessageProp 的一个实例，应用程序使用它来设置需要的 QOP。在 msgProp 中将需要的 QOP 设置为 0，以便请求默认的 QOP。还可以通过为 msgProp 传入 null 来请求默认的 QOP。

返回：

包含将发送给同位体标记的 byte[]。

抛出：

GSSException，包含以下主要错误代码：{@link - GSSException#CONTEXT_EXPIRED GSSException.CONTEXT_EXPIRED}、 GSSException.BAD_QOP、 GSSException.FAILURE

GSSException

---

getMIC

void getMIC(