Package org.ietf.jgss

Interface GSSContext

所有已知的子接口:
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,直到建立上下文。在此循环中,initSecContextacceptSecContext方法生成应用程序发送到对等方的令牌。对等方将任何此类令牌作为输入传递给其相应的acceptSecContextinitSecContext

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

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

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

安全上下文通常会维护有关其处理的令牌的排序和重放检测信息。因此,将任何令牌呈现给此上下文以进行处理的顺序可能很重要。还请注意,此接口中的所有方法都不是同步的。因此,除非应用程序级别的同步机制已经就位,否则不建议在多个线程之间共享GSSContext

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

从Java SE 11开始,GSSContext的基于流的方法已被弃用。这些方法也已从RFC 8353:通用安全服务API版本2:Java绑定更新中删除,原因如下(请参见第11节):“在此更新中,已删除了使用输入和输出流作为传输身份验证和每条消息GSS-API令牌的手段的GSSContext的重载方法,如RFC 5653的第5.15节所述,因为线协议应由应用程序定义,而不是库。当令牌没有自我帧(无法确定结束位置)或库不了解令牌格式(例如,作为与另一个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对象的不同操作,包括:对象实例化、设置所需标志、建立上下文、查询实际上下文标志、对应用程序数据执行每条消息操作,最后删除上下文。

    // 使用默认凭据和实现特定的默认机制创建上下文
    GSSManager manager = ...
    GSSName targetName = ...
    GSSContext context = manager.createContext(targetName, null, null,
                                           GSSContext.INDEFINITE_LIFETIME);

    // 在建立上下文之前设置所需的上下文选项
    context.requestConf(true);
    context.requestMutualAuth(true);
    context.requestReplayDet(true);
    context.requestSequenceDet(true);

    // 在对等方之间建立上下文

    byte[] inToken = new byte[0];
    byte[] outToken;

    // 只要仍有要处理的令牌,就循环

    while (!context.isEstablished()) {

        outToken = context.initSecContext(inToken, 0, inToken.length);

        // 如果生成了输出令牌,则发送输出令牌
        if (outToken != null) {
            sendToken(outToken);
        }

        if (!context.isEstablished()) {
            inToken = readToken();
        }
    }

     // 显示上下文信息
     System.out.println("剩余生存时间(秒)= "
                                          + context.getLifetime());
     System.out.println("上下文机制 = " + context.getMech());
     System.out.println("发起者 = " + context.getSrcName());
     System.out.println("接受者 = " + context.getTargName());

     if (context.getConfState()) {
         System.out.println("机密性(即隐私)可用");
     }

     if (context.getIntegState()) {
         System.out.println("完整性可用");
     }

     // 对应用程序提供的消息appMsg执行QOP = 0的wrap,并请求隐私服务
     byte[] appMsg = ...

     MessageProp mProp = new MessageProp(0, true);

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

     sendToken(outToken);

     // 对传入的应用程序消息执行unwrap,并检查其隐私状态和补充信息
     inToken = readToken();

     mProp = new MessageProp(0, true);

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

     System.out.println("是否加密? " + mProp.getPrivacy());
     System.out.println("重复令牌? " + mProp.isDuplicateToken());
     System.out.println("旧令牌? " + mProp.isOldToken());
     System.out.println("未排序令牌? " + mProp.isUnseqToken());
     System.out.println("间隙令牌? " + mProp.isGapToken());

     // 应用程序确定隐私状态和补充信息是否可接受

     // 释放上下文的本地端
     context.dispose();

 
自从:
1.4
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    代表默认上下文生存时间的生存时间常量。
    static final int
    代表无限上下文生存时间的生存时间常量。
  • Method Summary

    Modifier and Type
    Method
    Description
    byte[]
    acceptSecContext(byte[] inToken, int offset, int len)
    在接收到对等方令牌时由上下文接受者调用。
    void
    acceptSecContext(InputStream inStream, OutputStream outStream)
    已弃用。
    基于流的方法已从RFC 8353中删除。
    void
    释放上下文对象中存储的任何系统资源和加密信息,并使上下文无效。
    byte[]
    export()
    导出此上下文,以便另一个进程可以导入它。
    boolean
    确定上下文发起者是否匿名地对上下文接受者进行了身份验证。
    boolean
    确定上下文中是否可用数据机密性。
    boolean
    确定此上下文上是否启用了凭据委托。
    获取上下文发起者委托给上下文接受者的凭据。
    boolean
    确定上下文中是否可用数据完整性。
    int
    确定此上下文的剩余生存时间。
    Oid
    确定此上下文使用的机制。
    byte[]
    getMIC(byte[] inMsg, int offset, int len, MessageProp msgProp)
    返回包含供传输到对等应用程序的消息的加密消息完整性代码(MIC)的令牌。
    void
    getMIC(InputStream inStream, OutputStream outStream, MessageProp msgProp)
    已弃用。
    基于流的方法已从RFC 8353中删除。
    boolean
    确定此上下文上是否启用了相互认证。
    boolean
    确定是否为此上下文启用了用于每条消息安全服务的重放检测。
    boolean
    确定是否为此上下文启用了用于每条消息安全服务的序列检查。
    返回上下文发起者的名称。
    返回上下文接受者的名称。
    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
    用于在上下文建立期间确定上下文的状态。
    boolean
    确定是否为上下文的发起者。
    boolean
    确定上下文是否准备好用于其上的每个消息操作。
    boolean
    确定上下文是否可通过使用export方法转移给其他进程。
    void
    requestAnonymity(boolean state)
    请求不向接受者披露发起者的身份。
    void
    requestConf(boolean state)
    请求为wrap方法启用数据机密性。
    void
    requestCredDeleg(boolean state)
    请求在上下文建立期间将发起者的凭据委派给接受者。
    void
    requestInteg(boolean state)
    请求为wrapgetMIC方法启用数据完整性。
    void
    requestLifetime(int lifetime)
    请求上下文的生存期(以秒为单位)。
    void
    requestMutualAuth(boolean state)
    请求在上下文建立期间执行相互认证。
    void
    requestReplayDet(boolean state)
    请求在上下文建立后为每个消息安全服务启用重放检测。
    void
    requestSequenceDet(boolean state)
    请求在上下文建立后为每个消息安全服务启用序列检查。
    void
    设置在上下文建立期间使用的通道绑定。
    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中删除。
  • Field Details

    • DEFAULT_LIFETIME

      static final int DEFAULT_LIFETIME
      表示默认上下文生存期的生存期常量。此值设置为0。
      参见:
    • INDEFINITE_LIFETIME

      static final int INDEFINITE_LIFETIME
      表示无限上下文生存期的生存期常量。此值必须设置为Java中的最大整数值 - Integer.MAX_VALUE
      参见:
  • Method Details

    • initSecContext

      byte[] initSecContext(byte[] inputBuf, int offset, int len) throws GSSException
      由上下文发起者调用以开始上下文创建阶段,并处理对等方acceptSecContext方法生成的任何令牌。此方法可能返回一个输出令牌,应用程序需要将其发送给对等方以供其acceptSecContext方法处理。应用程序可以调用isEstablished来确定此上下文的建立阶段在此上下文的一侧是否已完成。从isEstablished返回false表示需要提供更多令牌给initSecContext。完成上下文建立后,可以通过获取方法查询可用的上下文选项。

      请注意,initSecContext方法可能为对等方生成一个令牌,并且isEstablished也返回true。这表示需要将令牌发送给对等方,但本地端的上下文现在已完全建立。

      某些机制提供程序可能要求调用者被授予启动安全上下文的权限。权限检查失败可能会导致从此方法抛出SecurityException

      参数:
      inputBuf - 对等方生成的令牌。在第一次调用时,此参数将被忽略,因为尚未从对等方接收到令牌。
      offset - 令牌在inputBuf中开始的偏移量。
      len - 令牌的长度。
      返回:
      包含要发送给对等方的令牌的byte[]。 null表示未生成任何令牌。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.NO_CREDGSSException.CREDENTIALS_EXPIREDGSSException.BAD_BINDINGSGSSException.OLD_TOKENGSSException.DUPLICATE_TOKENGSSException.BAD_NAMETYPEGSSException.BAD_MECHGSSException.FAILURE
    • initSecContext

      @Deprecated(since="11") int initSecContext(InputStream inStream, OutputStream outStream) throws GSSException
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use initSecContext(byte[], int, int) instead.
      由上下文发起者调用以开始上下文创建阶段,并使用流处理对等方acceptSecContext方法生成的任何令牌。此方法可能向OutpuStream写入一个输出令牌,应用程序需要将其发送给对等方以供其acceptSecContext调用处理。通常,应用程序会通过调用封装两个对等方之间连接的OutputStream上的flush方法来确保这一点。应用程序可以从此方法的返回值确定是否向OutputStream写入了令牌。返回值为0表示未写入任何令牌。应用程序可以调用isEstablished来确定此上下文的建立阶段在此上下文的一侧是否已完成。从isEstablished返回false表示需要提供更多令牌给initSecContext。完成上下文建立后,可以通过获取方法查询可用的上下文选项。

      请注意,initSecContext方法可能为对等方生成一个令牌,并且isEstablished也返回true。这表示需要将令牌发送给对等方,但本地端的上下文现在已完全建立。

      GSS-API身份验证令牌包含明确的开始和结束。此方法将尝试在每次调用时读取其中一个令牌,并且如果令牌的部分可用,则可能在流上阻塞。在其他方面,此方法与基于字节数组的initSecContext等效。

      某些机制提供程序可能要求调用者被授予启动安全上下文的权限。权限检查失败可能会导致从此方法抛出SecurityException

      以下示例代码演示了如何使用此方法:

           InputStream is ...
           OutputStream os ...
           GSSContext context ...
      
           // 在仍有令牌需要处理时循环
      
           while (!context.isEstablished()) {
      
               context.initSecContext(is, os);
      
               // 如果生成了输出令牌,则发送
               os.flush();
           }
       
      参数:
      inStream - 包含对等方生成的令牌的InputStream。在第一次调用时,此参数将被忽略,因为此时尚未或将不会从对等方接收到令牌。
      outStream - 将写入输出令牌的OutputStream。在上下文建立的最后阶段,可能不会写入任何字节。
      返回:
      作为要发送给对等方的令牌的一部分写入OutputStream的字节数。值为0表示不需要发送任何令牌。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.NO_CREDGSSException.CREDENTIALS_EXPIREDGSSException.BAD_BINDINGSGSSException.OLD_TOKENGSSException.DUPLICATE_TOKENGSSException.BAD_NAMETYPEGSSException.BAD_MECHGSSException.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 ...
      
           // 循环处理仍有令牌要处理的情况
      
           while (!context.isEstablished()) {
               inToken = readToken();
               outToken = context.acceptSecContext(inToken, 0,
                                                   inToken.length);
               // 如果生成了输出令牌,则发送
               if (outToken != null)
                   sendToken(outToken);
           }
       
      参数:
      inToken - 对等方生成的令牌。
      offset - 令牌在inToken中开始的偏移量。
      len - 令牌的长度。
      返回:
      包含要发送给对等方的令牌的byte[]。 null表示未生成任何令牌。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.NO_CREDGSSException.CREDENTIALS_EXPIREDGSSException.BAD_BINDINGSGSSException.OLD_TOKENGSSException.DUPLICATE_TOKENGSSException.BAD_MECHGSSException.FAILURE
    • acceptSecContext

      @Deprecated(since="11") void acceptSecContext(InputStream inStream, OutputStream outStream) throws GSSException
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use acceptSecContext(byte[], int, int) instead.
      由上下文接受者调用以使用流处理来自对等方的令牌。它可能会将输出令牌写入OutputStream,应用程序需要将其发送给对等方以供其initSecContext方法处理。通常,应用程序会通过调用封装两个对等方之间连接的OutputStream上的flush方法来确保这一点。应用程序可以调用isEstablished来确定此上下文在此上下文的一侧是否已完成建立阶段。从isEstablished返回false表示期望向acceptSecContext提供更多令牌。在上下文建立完成后,可以通过get方法查询可用的上下文选项。

      请注意,acceptSecContext可能为对等方返回一个令牌,并且isEstablished也返回true。这表示需要将令牌发送给对等方,但是本地端的上下文现在已完全建立。

      GSS-API身份验证令牌包含明确定义的开始和结束。此方法将尝试在每次调用时读取其中一个令牌,并且如果仅部分令牌可用,则可能在流上阻塞。在其他方面,此方法与基于字节数组的acceptSecContext等效。

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

      以下示例代码演示了如何使用此方法:

           InputStream is ...
           OutputStream os ...
           GSSContext context ...
      
           // 循环处理仍有令牌要处理的情况
      
           while (!context.isEstablished()) {
      
               context.acceptSecContext(is, os);
      
               // 如果生成了输出令牌,则发送
               os.flush();
           }
       
      参数:
      inStream - 包含对等方生成的令牌的InputStream。
      outStream - 将写入输出令牌的OutputStream。在上下文建立的最后阶段,可能不会写入任何字节。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.NO_CREDGSSException.CREDENTIALS_EXPIREDGSSException.BAD_BINDINGSGSSException.OLD_TOKENGSSException.DUPLICATE_TOKENGSSException.BAD_MECHGSSException.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的消息大小限制。返回的最大消息大小,如果使用相同的confReqqop参数呈现给wrap方法,将导致包含不超过maxTokenSize字节的输出令牌。

      此调用适用于通过强制最大消息大小的协议进行通信的应用程序。它使应用程序能够在应用保护之前对消息进行分段。

      建议但不要求GSS-API实现在调用getWrapSizeLimit时检测无效的QOP值。此例程仅保证最大消息大小,而不保证消息保护的特定QOP值的可用性。

      参数:
      qop - wrap将被要求提供的保护级别。
      confReq - 如果wrap将被要求提供隐私,则为true,否则为false
      maxTokenSize - wrap发出的令牌的期望最大大小。
      返回:
      给定输出令牌大小的输入令牌的最大大小
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.CONTEXT_EXPIREDGSSException.BAD_QOPGSSException.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 - 应用程序用于设置所需QOP和隐私状态的MessageProp实例。将所需的QOP设置为0以请求默认QOP。从此方法返回后,此对象将包含底层机制对消息应用的实际隐私状态。
      返回:
      包含要发送给对等方的令牌的byte[]。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.CONTEXT_EXPIREDGSSException.BAD_QOPGSSException.FAILURE
    • wrap

      @Deprecated(since="11") void wrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use wrap(byte[], int, int, MessageProp) instead.
      使用流在已建立的安全上下文上应用每条消息的安全服务。该方法将返回一个令牌,其中包含应用程序提供的数据和对其的加密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_EXPIREDGSSException.BAD_QOPGSSException.FAILURE
    • unwrap

      byte[] unwrap(byte[] inBuf, int offset, int len, MessageProp msgProp) throws GSSException
      用于处理由上下文另一侧的wrap方法生成的令牌。该方法将返回对等应用程序提供给其wrap调用的消息,同时验证该消息的嵌入MIC。

      MessageProp对象由应用程序实例化,并由底层机制用于向调用者返回信息,例如QOP,消息是否应用了机密性以及其他补充消息状态信息。

      由于一些应用级协议可能希望使用由wrap发出的令牌提供“安全帧”,因此实现应支持对零长度消息进行包装和解包。

      参数:
      inBuf - 包含从对等方接收到的wrap令牌的字节数组。
      offset - 令牌开始的偏移量。
      len - 令牌的长度
      msgProp - 从方法返回时,此对象将包含应用的QOP,消息的隐私状态,以及指示令牌是否为重复、旧、无序或在间隙之后到达的补充信息。
      返回:
      包含从输入令牌解包的消息的字节数组。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.CONTEXT_EXPIREDGSSException.FAILURE
    • unwrap

      @Deprecated(since="11") void unwrap(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use unwrap(byte[], int, int, MessageProp) instead.
      使用流处理由上下文另一侧的wrap方法生成的令牌。该方法将返回对等应用程序提供给其wrap调用的消息,同时验证该消息的嵌入MIC。

      MessageProp对象由应用程序实例化,并由底层机制用于向调用者返回信息,例如QOP,消息是否应用了机密性以及其他补充消息状态信息。

      由于一些应用级协议可能希望使用由wrap发出的令牌提供“安全帧”,因此实现应支持对零长度消息进行包装和解包。

      此方法读取的输入令牌的格式在将要使用的底层机制的规范中定义。此方法将尝试在每次调用时读取其中一个令牌。如果机制令牌包含明确定义的开始和结束,则如果仅部分令牌可用,则此方法可能会在InputStream上阻塞。如果令牌的开始和结束不明确定,则方法将尝试将所有可用字节视为令牌的一部分。

      除了上述可能的阻塞行为外,此方法等效于基于字节数组的unwrap方法。

      参数:
      inStream - 包含对等方生成的wrap令牌的InputStream。
      outStream - 用于写入应用程序消息的OutputStream。
      msgProp - 从方法返回时,此对象将包含应用的QOP,消息的隐私状态,以及指示令牌是否为重复、旧、无序或在间隙之后到达的补充信息。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.DEFECTIVE_TOKENGSSException.BAD_MICGSSException.CONTEXT_EXPIREDGSSException.FAILURE
    • getMIC

      byte[] getMIC(byte[] inMsg, int offset, int len, MessageProp msgProp) throws GSSException
      返回一个包含所提供消息的加密消息完整性代码(MIC)的令牌,用于传输给对等应用程序。与wrap不同,wrap将用户消息封装在返回的令牌中,而getMIC仅在输出令牌中返回消息MIC。

      请注意,隐私只能通过wrap调用应用。

      由于一些应用级协议可能希望使用由getMIC发出的令牌提供“安全帧”,因此实现应支持从零长度消息派生MIC。

      参数:
      inMsg - 要在其上生成MIC的消息。
      offset - 消息开始的偏移量。
      len - 消息的长度
      msgProp - 一个MessageProp的实例,应用程序用于设置所需的QOP。在msgProp中将所需的QOP设置为0以请求默认QOP。或者,将null传递给msgProp以请求默认QOP。
      返回:
      包含要发送给对等方的令牌的字节数组。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.CONTEXT_EXPIREDGSSException.BAD_QOPGSSException.FAILURE
    • getMIC

      @Deprecated(since="11") void getMIC(InputStream inStream, OutputStream outStream, MessageProp msgProp) throws GSSException
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use getMIC(byte[], int, int, MessageProp) instead.
      使用流生成一个包含所提供消息的加密消息完整性代码(MIC)的令牌,用于传输给对等应用程序。与wrap不同,wrap将用户消息封装在返回的令牌中,而getMIC仅在输出令牌中生成消息MIC。此方法等效于基于字节数组的getMIC方法。请注意,隐私只能通过wrap调用应用。

      由于一些应用级协议可能希望使用由getMIC发出的令牌提供“安全帧”,因此实现应支持从零长度消息派生MIC。

      参数:
      inStream - 包含要在其上生成MIC的消息的InputStream。将使用inStream中可用的所有数据。
      outStream - 用于写入输出令牌的OutputStream。
      msgProp - 一个MessageProp的实例,应用程序用于设置所需的QOP。在msgProp中将所需的QOP设置为0以请求默认QOP。或者,将null传递给msgProp以请求默认QOP。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.CONTEXT_EXPIREDGSSException.BAD_QOPGSSException.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
      Deprecated.
      The stream-based methods have been removed from RFC 8353. Use verifyMIC(byte[], int, int, byte[], int, int, MessageProp) instead.
      使用流来验证token参数中包含的加密MIC,以供应用消息。此方法等同于基于字节数组的verifyMIC方法。MessageProp对象由应用程序实例化,并由底层机制用于向调用者返回信息,例如指示应用于消息的保护强度的QOP以及其他补充消息状态信息。

      由于一些应用级协议可能希望使用由getMIC发出的令牌提供“安全帧”,因此实现应支持在零长度消息上计算和验证MIC。

      此方法读取的输入令牌格式在将要使用的底层机制的规范中定义。此方法将尝试在每次调用时读取其中一个令牌。如果机制令牌包含明确定的开始和结束,如果仅部分令牌可用,则此方法可能会在InputStream上阻塞。如果令牌的开始和结束不明确,则该方法将尝试将所有可用字节视为令牌的一部分。

      除了上述可能的阻塞行为外,此方法等同于基于字节数组的verifyMIC方法。

      参数:
      tokStream - 包含对等方的getMIC方法生成的令牌的InputStream。
      msgStream - 包含要验证加密MIC的应用消息的InputStream。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
      参见:
    • requestMutualAuth

      void requestMutualAuth(boolean state) throws GSSException
      请求在上下文建立期间执行相互认证。此请求只能在上下文发起方的一侧进行,并且必须在第一次调用initSecContext之前完成。

      并非所有机制都支持相互认证,有些机制可能要求即使应用程序不需要,也必须进行相互认证。因此,应用程序应检查请求是否得到满足,使用getMutualAuthState方法。

      参数:
      state - 一个布尔值,指示是否应使用相互认证。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.FAILURE
      参见:
    • requestReplayDet

      void requestReplayDet(boolean state) throws GSSException
      请求在上下文建立后为每个消息安全服务启用重放检测。此请求只能在上下文发起方的一侧进行,并且必须在第一次调用initSecContext之前完成。在上下文建立期间,重放检测不是一个选项,而是底层机制能力的功能。

      并非所有机制都支持重放检测,有些机制可能要求即使应用程序不需要,也必须进行重放检测。因此,应用程序应检查请求是否得到满足,使用getReplayDetState方法。如果启用了重放检测,则MessageProp.isDuplicateTokenMessageProp.isOldToken方法将为传递给unwrap方法或verifyMIC方法的MessageProp对象返回有效结果。

      参数:
      state - 一个布尔值,指示是否应在建立的上下文中启用重放检测。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.FAILURE
      参见:
    • requestSequenceDet

      void requestSequenceDet(boolean state) throws GSSException
      请求在上下文建立后为每个消息安全服务启用序列检查。此请求只能在上下文发起方的一侧进行,并且必须在第一次调用initSecContext之前完成。在上下文建立期间,序列检查不是一个选项,而是底层机制能力的功能。

      并非所有机制都支持序列检查,有些机制可能要求即使应用程序不需要,也必须进行序列检查。因此,应用程序应检查请求是否得到满足,使用getSequenceDetState方法。如果启用了序列检查,则MessageProp.isDuplicateTokenMessageProp.isOldTokenMessageProp.isUnseqTokenMessageProp.isGapToken方法将为传递给unwrap方法或verifyMIC方法的MessageProp对象返回有效结果。

      参数:
      state - 一个布尔值,指示是否应在建立的上下文中启用序列检查。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.FAILURE
      参见:
    • requestCredDeleg

      void requestCredDeleg(boolean state) throws GSSException
      请求在上下文建立期间将发起者的凭据委派给接受者。此请求只能在上下文发起者一侧进行,必须在第一次调用initSecContext之前完成。并非所有机制都支持凭据委派。因此,希望委派的应用程序应检查使用getCredDelegState方法是否得到了满足。如果应用程序指示不得使用委派,则机制将遵守该请求,委派将不会发生。这是一个例外,即使未请求,机制也可能启用服务。
      参数:
      state - 一个布尔值,指示是否应该委派凭据。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
      参见:
    • requestAnonymity

      void requestAnonymity(boolean state) throws GSSException
      请求不向接受者披露发起者的身份。此请求只能在上下文发起者一侧进行,必须在第一次调用initSecContext之前完成。并非所有机制都支持发起者的匿名性。因此,应用程序应检查使用getAnonymityState方法是否得到了满足。
      参数:
      state - 一个布尔值,指示发起者是否应被认证为匿名主体。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
      参见:
    • requestConf

      void requestConf(boolean state) throws GSSException
      请求为wrap方法启用数据机密性。此请求只能在上下文发起者一侧进行,必须在第一次调用initSecContext之前完成。并非所有机制都支持机密性,其他机制可能会在应用程序未请求时启用它。应用程序可以检查使用getConfState方法是否得到了满足。如果启用了机密性,则机制只会在传递给wrap方法的MessageProp对象中请求隐私时才会遵守请求。

      启用机密性也将自动启用完整性。

      参数:
      state - 一个布尔值,指示是否应启用机密性。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
      参见:
    • requestInteg

      void requestInteg(boolean state) throws GSSException
      请求为wrapgetMIC方法启用数据完整性。此请求只能在上下文发起者一侧进行,必须在第一次调用initSecContext之前完成。并非所有机制都支持完整性,其他机制可能会在应用程序未请求时启用它。应用程序可以检查使用getIntegState方法是否得到了满足。

      禁用完整性也将自动禁用机密性。

      参数:
      state - 一个布尔值,指示是否应启用完整性。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
      参见:
    • requestLifetime

      void requestLifetime(int lifetime) throws GSSException
      请求上下文的生命周期(以秒为单位)。此方法只能在上下文发起者一侧调用,必须在第一次调用initSecContext之前完成。

      上下文的实际生命周期取决于底层机制的能力,应用程序应调用getLifetime方法来确定这一点。

      参数:
      lifetime - 以秒为单位的所需上下文生命周期。使用INDEFINITE_LIFETIME请求无限生命周期,使用DEFAULT_LIFETIME请求默认生命周期。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
      参见:
    • setChannelBinding

      void setChannelBinding(ChannelBinding cb) throws GSSException
      设置在上下文建立期间使用的通道绑定。此方法可以在上下文发起者和上下文接受者两侧调用,但必须在上下文建立开始之前调用。这意味着发起者必须在第一次调用initSecContext之前调用它,接受者必须在第一次调用acceptSecContext之前调用它。
      参数:
      cb - 要使用的通道绑定。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
    • getCredDelegState

      boolean getCredDelegState()
      确定此上下文是否启用了凭据委派。上下文发起者和上下文接受者都可以调用此方法。要得到明确答案,必须在上下文建立完成后才能调用此方法。请注意,如果发起者请求不允许委派,则requestCredDeleg方法将遵守该请求,此方法将从那时起在发起者一侧返回false
      返回:
      如果启用了委派,则为true,否则为false。
      参见:
    • getMutualAuthState

      boolean getMutualAuthState()
      确定此上下文是否启用了双向认证。上下文发起者和上下文接受者都可以调用此方法。要得到明确答案,必须在上下文建立完成后才能调用此方法。请求双向认证的发起者可以在上下文完成后调用此方法,并在其请求未被满足时丢弃上下文。
      返回:
      如果启用了双向认证,则为true,否则为false。
      参见:
    • getReplayDetState

      boolean getReplayDetState()
      确定此上下文是否为每条消息的安全服务启用了重放检测。上下文发起者和上下文接受者都可以调用此方法。要得到明确答案,必须在上下文建立完成后才能调用此方法。请求重放检测的发起者可以在上下文完成后调用此方法,并在其请求未被满足时丢弃上下文。
      返回:
      如果启用了重放检测,则为true,否则为false。
      参见:
    • getSequenceDetState

      boolean getSequenceDetState()
      确定此上下文是否为每条消息的安全服务启用了序列检查。上下文发起者和上下文接受者都可以调用此方法。要得到明确答案,必须在上下文建立完成后才能调用此方法。请求序列检查的发起者可以在上下文完成后调用此方法,并在其请求未被满足时丢弃上下文。
      返回:
      如果启用了序列检查,则为true,否则为false。
      参见:
    • getAnonymityState

      boolean getAnonymityState()
      确定上下文发起者是否匿名认证给上下文接受者。上下文发起者和上下文接受者都可以调用此方法,在任何时候。在发起者一侧,调用此方法将确定发起者的身份是否已在此前由initSecContext生成的任何上下文建立令牌中披露。绝对必须匿名认证的发起者应在每次调用initSecContext后调用此方法,以确定生成的令牌应发送到对等方还是上下文应中止。在接受者一侧,调用此方法将确定到目前为止由acceptSecContext处理的任何令牌是否泄露了发起者的身份。
      返回:
      如果上下文发起者仍然匿名,则为true,否则为false。
      参见:
    • isTransferable

      boolean isTransferable() throws GSSException
      确定上下文是否可以通过export方法传输到其他进程。此调用仅在完全建立的上下文上有效。
      返回:
      如果此上下文可以导出,则为true,否则为false。
      抛出:
      GSSException - 包含以下主要错误代码: GSSException.FAILURE
    • isProtReady

      boolean isProtReady()
      确定上下文是否准备好用于每条消息操作。某些机制可能允许在上下文完全建立之前使用每条消息操作。
      返回:
      如果可以在当前上下文建立阶段使用诸如wrapunwrapgetMICverifyMIC等方法,则返回true;否则返回false。
    • getConfState

      boolean getConfState()
      确定上下文中是否提供数据机密性。此方法可由上下文发起方和上下文接受方调用,但只能在isProtReadyisEstablished之一返回true后调用。如果此方法返回truegetIntegState也将返回true
      返回:
      如果提供机密性服务,则返回true;否则返回false。
      另请参阅:
    • getIntegState

      boolean getIntegState()
      确定上下文中是否提供数据完整性。此方法可由上下文发起方和上下文接受方调用,但只能在isProtReadyisEstablished之一返回true后调用。如果getConfState返回true,则此方法将始终返回true
      返回:
      如果提供完整性服务,则返回true;否则返回false。
      另请参阅:
    • getLifetime

      int getLifetime()
      确定此上下文的剩余生存期。上下文发起方和上下文接受方均可调用此方法,但要获得明确答案,应仅在isEstablished返回true后调用。
      返回:
      以秒为单位的剩余生存期
      另请参阅:
    • getSrcName

      GSSName getSrcName() throws GSSException
      返回上下文发起方的名称。只有在isProtReadyisEstablished之一返回true后,此调用才有效。
      返回:
      包含上下文发起方名称的GSSName。
      抛出:
      GSSException - 包含以下主要错误代码:GSSException.FAILURE
      另请参阅:
    • getTargName

      GSSName getTargName() throws GSSException
      返回上下文接受方的名称。只有在isProtReadyisEstablished之一返回true后,此调用才有效。
      返回:
      包含上下文接受方名称的GSSName。
      抛出:
      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