所有已知的子接口：: ExtendedGSSContext

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 机制时，所有可选服务都将在本地可用。它们是相互身份验证、凭证委托、机密性和完整性保护以及每条消息的重放检测和排序。请注意，在 GSS-API 中，消息完整性是消息机密性的先决条件。

上下文建立发生在一个循环中，发起者调用initSecContext ，接受者调用acceptSecContext ，直到上下文建立。在此循环中，initSecContext 和 acceptSecContext 方法生成应用程序发送给对等方的令牌。对等方视情况将任何此类令牌作为输入传递给其 acceptSecContext 或 initSecContext。

在上下文建立阶段，可以调用isProtReady 方法来确定上下文是否可以用于wrap 和getMIC 的每消息操作。这允许应用程序在尚未完全建立的上下文中使用每条消息操作。

在建立上下文或 isProtReady 方法返回 true 之后，可以调用查询例程来确定已建立上下文的实际特征和服务。应用程序还可以开始使用 wrap 和 getMIC 的每条消息方法来获取对应用程序提供的数据的加密操作。

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

安全上下文通常维护有关其处理的令牌的排序和重放检测信息。因此，将任何标记呈现给此上下文进行处理的顺序可能很重要。另请注意，此接口中的所有方法都不是同步的。因此，不建议在多个线程之间共享一个GSSContext，除非某些应用程序级同步已到位。

最后，不同的机制提供者可能会对使用 GSS-API 上下文施加不同的安全限制。这些将由机制提供者记录。如果在机制层进行此类检查，应用程序将需要确保它具有适当的权限。

GSSContext 的基于流的方法已在 Java SE 11 中弃用。这些方法也已从 RFC 8353：通用安全服务 API 版本 2：Java 绑定更新中删除，原因如下（请参阅第 11 节）：“使用输入和输出流作为传达方式的 GSSContext 的重载方法RFC 5653 第 5.15 节中描述的身份验证和每消息 GSS-API 令牌已在此更新中删除，因为有线协议应由应用程序而不是库定义。当令牌没有时，也无法正确实现这些方法自我框架（无法确定结束），或者图书馆不知道令牌格式（例如，作为与另一个 GSS 图书馆交谈的桥梁）”。这些方法包括 initSecContext(InputStream, OutputStream) 、acceptSecContext(InputStream, OutputStream) 、wrap(InputStream, OutputStream, MessageProp) 、unwrap(InputStream, OutputStream, MessageProp) 、getMIC(InputStream, OutputStream, MessageProp) 和 verifyMIC(InputStream, InputStream, MessageProp) 。

下面给出的示例代码演示了 GSSContext 接口对发起对等方的用法。介绍了对 GSSContext 对象的不同操作，包括：对象实例化、所需标志的设置、上下文建立、实际上下文标志的查询、对应用程序数据的每条消息操作，以及最后的上下文删除。

  // 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];
  byte[] outToken;

  // Loop while there still is a token to be processed

  while (!context.isEstablished()) {

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

   outToken = context.wrap(appMsg, 0, appMsg.length, mProp);

   sendToken(outToken);

   // perform unwrap on an incoming application message, and check
   // its privacy state and supplementary information
   inToken = readToken();

   mProp = new MessageProp(0, true);

   appMsg = context.unwrap(inToken, 0, inToken.length, mProp);

   System.out.println("Was it encrypted? " + mProp.getPrivacy());
   System.out.println("Duplicate Token? " + mProp.isDuplicateToken());
   System.out.println("Old Token? " + mProp.isOldToken());
   System.out.println("Unsequenced Token? " + mProp.isUnseqToken());
   System.out.println("Gap Token? " + mProp.isGapToken());

   // the application determines if the privacy state and supplementary
   // information are acceptable

   // release the local-end of the context
   context.dispose();

自从：: 1.4

字段摘要

字段

修饰符和类型

Field

描述

static final int

DEFAULT_LIFETIME

表示默认上下文生命周期的生命周期常量。

static final int

INDEFINITE_LIFETIME

表示不确定的上下文生命周期的生命周期常量。
方法总结

修饰符和类型

方法

描述

byte[]

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

在从对等方接收到令牌时由上下文接受器调用。

void

acceptSecContext(InputStream inStream, OutputStream outStream)

已弃用。
基于流的方法已从 RFC 8353 中删除。

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)

已弃用。
基于流的方法已从 RFC 8353 中删除。

boolean

getMutualAuthState()

确定是否在此上下文中启用相互身份验证。

boolean

getReplayDetState()

确定是否为此上下文中的每条消息安全服务启用重播检测。

boolean

getSequenceDetState()

确定是否为此上下文中的每条消息安全服务启用序列检查。

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)

已弃用。
基于流的方法已从 RFC 8353 中删除。

boolean

isEstablished()

在上下文建立期间使用以确定上下文的状态。

boolean

isInitiator()

确定这是否是上下文发起者。

boolean

isProtReady()

确定上下文是否已准备好对其使用每条消息操作。

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)

请求在上下文建立后为每条消息安全服务启用重放检测。

void

requestSequenceDet(boolean state)

请求在上下文建立后为每条消息安全服务启用序列检查。

void

setChannelBinding(ChannelBinding cb)

设置要在上下文建立期间使用的通道绑定。

byte[]

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

用于处理上下文另一端的 wrap 方法生成的标记。

void

unwrap(InputStream inStream, OutputStream outStream, MessageProp msgProp)

已弃用。
基于流的方法已从 RFC 8353 中删除。

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)

已弃用。
基于流的方法已从 RFC 8353 中删除。

byte[]

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

在已建立的安全上下文上应用每条消息的安全服务。

void

wrap(InputStream inStream, OutputStream outStream, MessageProp msgProp)

已弃用。
基于流的方法已从 RFC 8353 中删除。

字段详细信息
- 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 - 包含以下主要错误代码：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
- initSecContext
  
  @Deprecated (since ="11") int initSecContext(InputStream inStream, OutputStream outStream) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 initSecContext(byte[], int, int) 。
  由上下文发起者调用以开始上下文创建阶段并处理由对等方的 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 - 包含以下主要错误代码：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
- 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 - 包含以下主要错误代码：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
- acceptSecContext
  
  @Deprecated (since ="11") void acceptSecContext(InputStream inStream, OutputStream outStream) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 acceptSecContext(byte[], int, int) 。
  由上下文接受器调用以使用流处理来自对等方的令牌。它可能会向 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 - 包含以下主要错误代码：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
- isEstablished
  
  boolean isEstablished()
  
  在上下文建立期间使用以确定上下文的状态。
  
  返回：
  
  true 如果这是调用方完全建立的上下文并且不需要来自对等方的更多令牌。
- dispose
  
  void dispose() throws GSSException
  
  释放存储在上下文对象中的任何系统资源和加密信息并使上下文无效。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- getWrapSizeLimit
  
  int getWrapSizeLimit(int qop, boolean confReq, int maxTokenSize) throws GSSException
  
  用于确定可以传递给 wrap 的消息大小的限制。返回最大消息大小，如果将其呈现给具有相同 confReq 和 qop 参数的 wrap 方法，将导致输出令牌包含不超过 maxTokenSize 字节。
  此调用旨在供通过强加最大消息大小的协议进行通信的应用程序使用。它使应用程序能够在应用保护之前对消息进行分段。
  
  建议使用 GSS-API 实现，但不需要在调用 getWrapSizeLimit 时检测无效的 QOP 值。此例程仅保证最大消息大小，而不保证用于消息保护的特定 QOP 值的可用性。
  
  参数：
  
  qop - 将要求提供保护等级。
  
  confReq - true 如果 wrap 将被要求提供隐私，false 否则。
  
  maxTokenSize - wrap 发出的令牌所需的最大大小。
  
  返回：
  
  给定输出标记大小的输入标记的最大大小
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.CONTEXT_EXPIRED 、GSSException.BAD_QOP 、GSSException.FAILURE
- wrap
  
  byte[] wrap(byte[] inBuf, int offset, int len, MessageProp msgProp) throws GSSException
  
  在已建立的安全上下文上应用每条消息的安全服务。该方法将返回一个令牌，其中包含应用程序提供的数据和一个加密 MIC。如果要求保密（隐私），数据可能会被加密。
  MessageProp 对象由应用程序实例化，用于指定选择加密算法的 QOP 值，以及可选地加密消息的隐私服务。调用中使用的底层机制可能无法提供隐私服务。它设置了它在这个 MessageProp 对象中提供的实际隐私服务，调用者应该在返回时查询该对象。如果该机制无法提供请求的 QOP，它会抛出带有 BAD_QOP 代码的 GSSException。
  
  由于某些应用程序级协议可能希望使用 wrap 发出的令牌来提供“安全框架”，因此实现应支持零长度消息的包装。
  
  应用程序将负责将令牌发送给对等方。
  
  参数：
  
  inBuf - 要保护的应用程序数据。
  
  offset - inBuf 中数据开始的偏移量。
  
  len - 数据的长度
  
  msgProp - MessageProp 的实例，应用程序使用它来设置所需的 QOP 和隐私状态。将所需 QOP 设置为 0 以请求默认 QOP。从该方法返回后，该对象将包含底层机制应用于消息的实际隐私状态。
  
  返回：
  
  一个 byte[] 包含要发送给对等方的令牌。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.CONTEXT_EXPIRED 、GSSException.BAD_QOP 、GSSException.FAILURE
- wrap
  
  @Deprecated (since ="11") void wrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 wrap(byte[], int, int, MessageProp) 。
  
  使用流在已建立的安全上下文上应用每消息安全服务。该方法将返回一个令牌，其中包含应用程序提供的数据和一个加密 MIC。如果要求保密（隐私），数据可能会被加密。该方法等同于基于字节数组的wrap 方法。
  应用程序将负责将令牌发送给对等方。通常，应用程序将通过在封装两个对等点之间的连接的 OutputStream 上调用 flush 方法来确保这一点。
  
  MessageProp 对象由应用程序实例化，用于指定选择加密算法的 QOP 值，以及可选地加密消息的隐私服务。调用中使用的底层机制可能无法提供隐私服务。它设置了它在这个 MessageProp 对象中提供的实际隐私服务，调用者应该在返回时查询该对象。如果该机制无法提供请求的 QOP，它会抛出带有 BAD_QOP 代码的 GSSException。
  
  由于某些应用程序级协议可能希望使用 wrap 发出的令牌来提供“安全框架”，因此实现应支持零长度消息的包装。
  
  参数：
  
  inStream - 包含要保护的应用程序数据的 InputStream。使用 inStream 中可用的所有数据。
  
  outStream - 将受保护消息写入的 OutputStream。
  
  msgProp - MessageProp 的实例，应用程序使用它来设置所需的 QOP 和隐私状态。将所需 QOP 设置为 0 以请求默认 QOP。从该方法返回后，该对象将包含底层机制应用于消息的实际隐私状态。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.CONTEXT_EXPIRED 、GSSException.BAD_QOP 、GSSException.FAILURE
- unwrap
  
  byte[] unwrap(byte[] inBuf, int offset, int len, MessageProp msgProp) throws GSSException
  
  用于处理上下文另一端的 wrap 方法生成的标记。该方法会将对等应用程序提供的消息返回到其包装调用，同时验证该消息的嵌入式 MIC。
  MessageProp 对象由应用程序实例化，并由底层机制用于向调用方返回信息，例如 QOP、机密性是否应用于消息以及其他补充消息状态信息。
  
  由于某些应用程序级协议可能希望使用 wrap 发出的令牌来提供“安全框架”，因此实现应支持零长度消息的包装和解包。
  
  参数：
  
  inBuf - 包含从对等方接收到的包装令牌的字节数组。
  
  offset - 令牌开始的偏移量。
  
  len - 令牌的长度
  
  msgProp - 从方法返回时，此对象将包含应用的 QOP、消息的隐私状态以及说明令牌是否重复、旧、乱序或在间隔后到达的补充信息。
  
  返回：
  
  一个 byte[] 包含从输入令牌中解包的消息。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.DEFECTIVE_TOKEN 、GSSException.BAD_MIC 、GSSException.CONTEXT_EXPIRED 、GSSException.FAILURE
- unwrap
  
  @Deprecated (since ="11") void unwrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 unwrap(byte[], int, int, MessageProp) 。
  
  使用流处理上下文另一端的 wrap 方法生成的标记。该方法会将对等应用程序提供的消息返回到其包装调用，同时验证该消息的嵌入式 MIC。
  MessageProp 对象由应用程序实例化，并由底层机制用于向调用方返回信息，例如 QOP、机密性是否应用于消息以及其他补充消息状态信息。
  
  由于某些应用程序级协议可能希望使用 wrap 发出的令牌来提供“安全框架”，因此实现应支持零长度消息的包装和解包。
  
  此方法读取的输入令牌的格式在将要使用的底层机制的规范中定义。此方法将尝试在每次调用时读取这些标记之一。如果机制令牌包含明确的开始和结束，如果只有部分令牌可用，则此方法可能会在 InputStream 上阻塞。如果令牌的开始和结尾不确定，则该方法将尝试将所有可用字节视为令牌的一部分。
  
  除了上述可能的阻塞行为外，此方法等效于基于字节数组的 unwrap 方法。
  
  参数：
  
  inStream - 一个 InputStream，其中包含对等方生成的包装令牌。
  
  outStream - 将应用程序消息写入的 OutputStream。
  
  msgProp - 从方法返回时，此对象将包含应用的 QOP、消息的隐私状态以及说明令牌是否重复、旧、乱序或在间隔后到达的补充信息。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.DEFECTIVE_TOKEN 、GSSException.BAD_MIC 、GSSException.CONTEXT_EXPIRED 、GSSException.FAILURE
- getMIC
  
  byte[] getMIC(byte[] inMsg, int offset, int len, MessageProp msgProp) throws GSSException
  
  返回包含所提供消息的加密消息完整性代码 (MIC) 的令牌，以便传输到对等应用程序。与 wrap 将用户消息封装在返回的令牌中不同，输出令牌中只返回消息 MIC。
  请注意，隐私只能通过 wrap 调用应用。
  
  由于某些应用程序级协议可能希望使用 getMIC 发出的令牌来提供“安全框架”，因此实现应支持从零长度消息派生 MIC。
  
  参数：
  
  inMsg - 生成 MIC 的消息。
  
  offset - inMsg 中消息开始处的偏移量。
  
  len - 消息的长度
  
  msgProp - MessageProp 的实例，应用程序使用它来设置所需的 QOP。将所需的 QOP 设置为 msgProp 中的 0 以请求默认 QOP。或者为 msgProp 传入 null 以请求默认 QOP。
  
  返回：
  
  一个 byte[] 包含要发送给对等方的令牌。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.CONTEXT_EXPIRED 、GSSException.BAD_QOP 、GSSException.FAILURE
- getMIC
  
  @Deprecated (since ="11") void getMIC(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 getMIC(byte[], int, int, MessageProp) 。
  
  使用流为提供的消息生成包含加密 MIC 的令牌，以便传输到对等应用程序。与 wrap 将用户消息封装在返回的令牌中不同，输出令牌中只产生消息 MIC。该方法等同于基于字节数组的getMIC 方法。请注意，隐私只能通过 wrap 调用应用。
  由于某些应用程序级协议可能希望使用 getMIC 发出的令牌来提供“安全框架”，因此实现应支持从零长度消息派生 MIC。
  
  参数：
  
  inStream - 包含用于生成 MIC 的消息的 InputStream。使用 inStream 中可用的所有数据。
  
  outStream - 将输出令牌写入的 OutputStream。
  
  msgProp - MessageProp 的实例，应用程序使用它来设置所需的 QOP。将所需的 QOP 设置为 msgProp 中的 0 以请求默认 QOP。或者为 msgProp 传入 null 以请求默认 QOP。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.CONTEXT_EXPIRED 、GSSException.BAD_QOP 、GSSException.FAILURE
- verifyMIC
  
  void verifyMIC(byte[] inToken, int tokOffset, int tokLen, byte[] inMsg, int msgOffset, int msgLen, MessageProp msgProp) throws GSSException
  
  通过提供的消息验证令牌参数中包含的加密 MIC。
  MessageProp 对象由应用程序实例化，并由底层机制用于向调用方返回信息，例如指示应用于消息的保护强度的 QOP 和其他补充消息状态信息。
  
  由于某些应用程序级协议可能希望使用 getMIC 发出的令牌来提供“安全框架”，因此实现应支持通过零长度消息计算和验证 MIC。
  
  参数：
  
  inToken - 对等方的 getMIC 方法生成的令牌。
  
  tokOffset - inToken 中令牌开始的偏移量。
  
  tokLen - 令牌的长度。
  
  inMsg - 用于验证加密 MIC 的应用程序消息。
  
  msgOffset - inMsg 中消息开始的偏移量。
  
  msgLen - 消息的长度。
  
  msgProp - 从方法返回时，此对象将包含应用的 QOP 和补充信息，说明令牌是否重复、旧、乱序或在间隔后到达。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.DEFECTIVE_TOKEN GSSException.BAD_MIC GSSException.CONTEXT_EXPIRED GSSException.FAILURE
- verifyMIC
  
  @Deprecated (since ="11") void verifyMIC(InputStream tokStream, InputStream msgStream, MessageProp msgProp) throws GSSException
  
  已弃用。
  基于流的方法已从 RFC 8353 中删除。请改用 verifyMIC(byte[], int, int, byte[], int, int, MessageProp) 。
  
  使用流通过提供的消息验证令牌参数中包含的加密 MIC。该方法等同于基于字节数组的verifyMIC 方法。 MessageProp 对象由应用程序实例化，并由底层机制用于向调用方返回信息，例如指示应用于消息的保护强度的 QOP 和其他补充消息状态信息。
  由于某些应用程序级协议可能希望使用 getMIC 发出的令牌来提供“安全框架”，因此实现应支持通过零长度消息计算和验证 MIC。
  
  此方法读取的输入令牌的格式在将要使用的底层机制的规范中定义。此方法将尝试在每次调用时读取这些标记之一。如果机制令牌包含明确的开始和结束，如果只有部分令牌可用，则此方法可能会在 InputStream 上阻塞。如果令牌的开始和结尾不确定，则该方法将尝试将所有可用字节视为令牌的一部分。
  
  除了上述可能的阻塞行为外，此方法等效于基于字节数组的 verifyMIC 方法。
  
  参数：
  
  tokStream - 一个 InputStream，包含由对等方的 getMIC 方法生成的令牌。
  
  msgStream - 一个 InputStream，其中包含用于验证加密 MIC 的应用程序消息。使用 msgStream 中可用的所有数据。
  
  msgProp - 从方法返回时，此对象将包含应用的 QOP 和补充信息，说明令牌是否重复、旧、乱序或在间隔后到达。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.DEFECTIVE_TOKEN GSSException.BAD_MIC GSSException.CONTEXT_EXPIRED GSSException.FAILURE
- export
  
  byte[] export() throws GSSException
  
  导出此上下文，以便另一个进程可以导入它。提供以支持多个进程之间的工作共享。此例程通常由上下文接受器使用，在单个进程接收传入连接请求并接受其上的安全上下文的应用程序中，然后将已建立的上下文传递给一个或多个其他进程以进行消息交换。
  此方法停用安全上下文并创建一个进程间令牌，当传递给另一个进程中的 GSSManager.createContext 时，将重新激活第二个进程中的上下文。任何时候只能激活给定上下文的一个实例；上下文导出器随后尝试访问导出的安全上下文将失败。
  
  实现可能会限制可以导入进程间令牌的进程集，作为本地安全策略的功能，或者作为实现决策的结果。例如，某些实现可能会限制上下文仅在同一帐户下运行的进程之间或属于同一进程组的进程之间传递。
  
  进程间令牌可能包含安全敏感信息（例如加密密钥）。虽然鼓励机制避免将此类敏感信息放置在进程间令牌中，或者在将令牌返回给应用程序之前对其进行加密，但在典型的 GSS-API 实现中，这可能是不可能的。因此，应用程序必须注意保护进程间令牌，并确保令牌传输到的任何进程都是可信的。
  
  实现不需要支持安全上下文的进程间传输。调用 isTransferable 方法将指示上下文对象是否可传输。
  
  在不可导出的上下文中调用此方法将导致抛出此异常，错误代码为 GSSException.UNAVAILABLE 。
  返回：
  
  包含导出上下文的 byte[]
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.UNAVAILABLE 、GSSException.CONTEXT_EXPIRED 、GSSException.NO_CONTEXT 、GSSException.FAILURE
  
  参见：
  
  GSSManager.createContext(byte[])
- requestMutualAuth
  
  void requestMutualAuth(boolean state) throws GSSException
  
  请求在上下文建立期间完成相互认证。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。
  并非所有机制都支持相互身份验证，有些机制可能需要相互身份验证，即使应用程序不需要。因此，应用程序应检查请求是否已通过 getMutualAuthState 方法得到满足。
  参数：
  
  state - 一个boolean，指示是否应使用相互身份验证。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getMutualAuthState()
- requestReplayDet
  
  void requestReplayDet(boolean state) throws GSSException
  
  请求在上下文建立后为每条消息安全服务启用重放检测。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。在上下文建立期间，重放检测不是一个选项，而是底层机制功能的函数。
  并非所有机制都支持重播检测，某些机制可能需要重播检测，即使应用程序不需要。因此，应用程序应检查请求是否已通过 getReplayDetState 方法得到满足。如果启用重播检测，则 MessageProp.isDuplicateToken 和 MessageProp.isOldToken 方法将为传递给 unwrap 方法或 verifyMIC 方法的 MessageProp 对象返回有效结果。
  参数：
  
  state - 一个boolean，指示是否应在已建立的上下文中启用重放检测。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getReplayDetState()
- requestSequenceDet
  
  void requestSequenceDet(boolean state) throws GSSException
  
  请求在上下文建立后为每条消息安全服务启用序列检查。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。在上下文建立过程中，序列检查不是一个选项，而是底层机制能力的一个函数。
  并非所有机制都支持序列检查，某些机制可能需要序列检查，即使应用程序不需要。因此，应用程序应该检查请求是否被 getSequenceDetState 方法接受。如果启用序列检查，则 MessageProp.isDuplicateToken 、MessageProp.isOldToken 、MessageProp.isUnseqToken 和 MessageProp.isGapToken 方法将为传递给 unwrap 方法或 verifyMIC 方法的 MessageProp 对象返回有效结果。
  参数：
  
  state - 一个boolean，指示是否应在已建立的上下文中启用序列检查。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getSequenceDetState()
- requestCredDeleg
  
  void requestCredDeleg(boolean state) throws GSSException
  
  请求在上下文建立期间将发起者的凭据委托给接受者。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。并非所有机制都支持凭证委托。因此，需要委派的应用程序应该检查请求是否被 getCredDelegState 方法接受。如果应用程序指示不得使用委托，则该机制将尊重请求并且不会发生委托。这是一般规则的一个例外，即一种机制可以启用服务，即使它没有被请求。
  参数：
  
  state - 一个boolean，指示是否应委托凭据。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getCredDelegState()
- requestAnonymity
  
  void requestAnonymity(boolean state) throws GSSException
  
  要求不向接受者透露发起者的身份。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。并非所有机制都支持发起者匿名。因此，应用程序应该检查请求是否被 getAnonymityState 方法接受。
  参数：
  
  state - 一个boolean，指示是否应将发起者作为匿名主体向接受者进行身份验证。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getAnonymityState()
- requestConf
  
  void requestConf(boolean state) throws GSSException
  
  请求为 wrap 方法启用数据机密性。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。并非所有机制都支持机密性，即使应用程序不请求它，其他机制也可能启用它。应用程序可以检查请求是否被 getConfState 方法接受。如果启用了机密性，则该机制只会尊重传递给 wrap 方法的 MessageProp 对象中的隐私请求。
  启用保密性也会自动启用完整性。
  参数：
  
  state - 一个boolean，指示是否应启用机密性。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getConfState()
  
  getIntegState()
  
  requestInteg(boolean)
  
  MessageProp
- requestInteg
  
  void requestInteg(boolean state) throws GSSException
  
  请求为 wrap 和 getMIC 方法启用数据完整性。此请求只能在上下文发起者端进行，并且必须在第一次调用 initSecContext 之前完成。并非所有机制都支持完整性，即使应用程序不请求它，其他机制也可能启用它。应用程序可能会检查请求是否被 getIntegState 方法接受。
  禁用完整性也会自动禁用机密性。
  参数：
  
  state - 一个boolean，指示是否应启用完整性。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getIntegState()
- requestLifetime
  
  void requestLifetime(int lifetime) throws GSSException
  
  请求上下文的生命周期（以秒为单位）。此方法只能在上下文启动器端调用，并且必须在第一次调用 initSecContext 之前完成。
  上下文的实际生命周期将取决于底层机制的能力，应用程序应调用 getLifetime 方法来确定这一点。
  参数：
  
  lifetime - 所需的上下文生命周期（以秒为单位）。使用 INDEFINITE_LIFETIME 请求无限期生命周期，使用 DEFAULT_LIFETIME 请求默认生命周期。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  getLifetime()
- setChannelBinding
  
  void setChannelBinding(ChannelBinding cb) throws GSSException
  
  设置要在上下文建立期间使用的通道绑定。此方法可以在上下文发起者和上下文接受者端调用，但必须在上下文建立开始之前调用。这意味着发起者必须在第一次调用 initSecContext 之前调用它，接受者必须在第一次调用 acceptSecContext 之前调用它。
  
  参数：
  
  cb - 要使用的通道绑定。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- getCredDelegState
  
  boolean getCredDelegState()
  
  确定是否在此上下文中启用凭据委派。它可以被上下文发起者和上下文接受者调用。要获得确定的答案，必须仅在上下文建立完成后调用此方法。请注意，如果发起者请求不允许委派，则 requestCredDeleg 方法将尊重该请求，并且此方法将从该点开始在发起者一方返回 false。
  返回：
  
  如果启用委托，则为 true，否则为 false。
  
  参见：
  
  requestCredDeleg(boolean)
- getMutualAuthState
  
  boolean getMutualAuthState()
  
  确定是否在此上下文中启用相互身份验证。它可以被上下文发起者和上下文接受者调用。要获得确定的答案，必须仅在上下文建立完成后调用此方法。请求相互身份验证的发起者可以在上下文完成后调用此方法，如果其请求未得到满足，则可以处置上下文。
  返回：
  
  如果启用相互身份验证，则为 true，否则为 false。
  
  参见：
  
  requestMutualAuth(boolean)
- getReplayDetState
  
  boolean getReplayDetState()
  
  确定是否为此上下文中的每条消息安全服务启用重播检测。它可以被上下文发起者和上下文接受者调用。要获得确定的答案，必须仅在上下文建立完成后调用此方法。请求重放检测的发起者可以在上下文完成后调用此方法，并在其请求未得到满足的情况下处置上下文。
  返回：
  
  如果启用重播检测，则为 true，否则为 false。
  
  参见：
  
  requestReplayDet(boolean)
- getSequenceDetState
  
  boolean getSequenceDetState()
  
  确定是否为此上下文中的每条消息安全服务启用序列检查。它可以被上下文发起者和上下文接受者调用。要获得确定的答案，必须仅在上下文建立完成后调用此方法。请求序列检查的发起者可以在上下文完成后调用此方法，如果其请求未得到满足，则可以处置上下文。
  返回：
  
  如果启用序列检查，则为 true，否则为 false。
  
  参见：
  
  requestSequenceDet(boolean)
- getAnonymityState
  
  boolean getAnonymityState()
  
  确定上下文发起者是否匿名向上下文接受者进行身份验证。上下文发起者和上下文接受者都可以随时调用它。 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. 在接受方，调用此方法可确定到目前为止由 acceptSecContext 处理的任何令牌是否泄露了发起者的身份。
  返回：
  
  如果上下文发起者仍然是匿名的，则为 true，否则为 false。
  
  参见：
  
  requestAnonymity(boolean)
- isTransferable
  
  boolean isTransferable() throws GSSException
  
  确定上下文是否可以通过使用 export 方法转移到其他进程。此调用仅在完全建立的上下文中有效。
  
  返回：
  
  如果可以导出此上下文，则为 true，否则为 false。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- isProtReady
  
  boolean isProtReady()
  
  确定上下文是否已准备好对其使用每条消息操作。某些机制可能允许在上下文完全建立之前使用每条消息操作。
  
  返回：
  
  如果 wrap 、 unwrap 、 getMIC 和 verifyMIC 等方法可以在上下文建立的当前阶段用于此上下文，则为 true ，否则为 false 。
- getConfState
  
  boolean getConfState()
  
  确定数据机密性是否在上下文中可用。此方法可由上下文发起者和上下文接受者调用，但只能在 isProtReady 或 isEstablished 之一返回 true 之后调用。如果此方法返回 true ，那么 getIntegState 也会
  返回：
  
  如果保密服务可用，则为 true，否则为 false。
  
  参见：
  
  requestConf(boolean)
- getIntegState
  
  boolean getIntegState()
  
  确定数据完整性是否在上下文中可用。此方法可以由上下文发起者和上下文接受者调用，但只能在 isProtReady 或 isEstablished 之一返回 true 之后调用。如果 getConfState 返回 true，此方法将始终返回 true。
  返回：
  
  如果完整性服务可用，则为 true，否则为 false。
  
  参见：
  
  requestInteg(boolean)
- getLifetime
  
  int getLifetime()
  
  确定此上下文的剩余生命周期是多少。它可以被上下文发起者和上下文接受者调用，但对于一个明确的答案，它应该只在 isEstablished 返回 true 之后调用。
  返回：
  
  以秒为单位的剩余寿命
  
  参见：
  
  requestLifetime(int)
- getSrcName
  
  GSSName getSrcName() throws GSSException
  
  返回上下文启动器的名称。此调用仅在 isProtReady 或 isEstablished 之一返回 true 后有效。
  返回：
  
  GSSName，它是一个包含上下文发起者名称的 MN。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
  
  参见：
  
  GSSName
- getTargName
  
  GSSName getTargName() throws GSSException
  
  返回上下文接受器的名称。此调用仅在 isProtReady 或 isEstablished 之一返回 true 后有效。
  
  返回：
  
  一个 GSSName，它是一个包含上下文接受器名称的 MN。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- getMech
  
  Oid getMech() throws GSSException
  
  确定用于此上下文的机制。可以在上下文完全建立之前调用此方法，但返回的机制可能会在协商机制情况下的连续调用中发生变化。
  
  返回：
  
  正在使用的机制的 Oid
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- getDelegCred
  
  GSSCredential getDelegCred() throws GSSException
  
  获取上下文发起者委托给上下文接受者的凭据。它应该只在上下文接受者一方调用，并且一旦上下文完全建立。调用者可以使用方法 getCredDelegState 来确定是否有任何委托凭证。
  
  返回：
  
  包含发起者委托凭据的 GSSCredential，或者 null 没有委托凭据。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE
- isInitiator
  
  boolean isInitiator() throws GSSException
  
  确定这是否是上下文发起者。这可以在上下文发起者和上下文接受者端调用。
  
  返回：
  
  如果这是上下文发起者，则为 true；如果是上下文接受者，则为 false。
  
  抛出：
  
  GSSException - 包含以下主要错误代码：GSSException.FAILURE

接口 GSSContext

字段摘要

方法总结

字段详细信息

DEFAULT_LIFETIME

INDEFINITE_LIFETIME

方法详情

initSecContext

initSecContext

acceptSecContext

acceptSecContext

isEstablished

dispose

getWrapSizeLimit

wrap

wrap

unwrap

unwrap

getMIC

getMIC

verifyMIC

verifyMIC

export

requestMutualAuth

requestReplayDet

requestSequenceDet

requestCredDeleg

requestAnonymity

requestConf

requestInteg

requestLifetime

setChannelBinding

getCredDelegState

getMutualAuthState

getReplayDetState

getSequenceDetState

getAnonymityState

isTransferable

isProtReady

getConfState

getIntegState

getLifetime

getSrcName

getTargName

getMech

getDelegCred

isInitiator