软件包  org.ietf.jgss

Interface GSSContext

  • All Known Subinterfaces:
    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上下文设置不同的安全限制。 这些将由机制提供商记录。 如果在机制层中进行此类检查,应用程序将需要确保它具有适当的权限。

    基于流的方法GSSContext已在Java SE 11中弃用 。由于以下原因,这些方法也已从RFC 8353: Generic Security Service API Version 2: Java Bindings Update中删除(参见第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];
    
        // 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)
      已过时。
      基于流的方法已从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对等方的 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)
      请求为 wrapgetMIC方法启用数据完整性。
      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方法生成的任何令牌。 此方法可能会返回一个输出令牌,应用程序需要将该令牌发送给对等方,以便通过其acceptSecContext方法进行处理。 应用程序可以调用isEstablished来确定上下文建立阶段是否在上下文的这一侧完成。 false的返回值isEstablished表示预计将向initSecContext提供更多令牌。 完成上下文建立后,可以通过get方法查询可用的上下文选项。

        请注意, initSecContext方法可能会为对等方返回一个令牌,而trueisEstablished返回true 这表示需要将令牌发送给对等体,但现在完全建立了上下文的本地端。

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

        参数
        inputBuf - 对等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调用进行处理。 通常,应用程序将通过调用确保此flush上的方法OutputStream ,它封装了两个对等体之间的连接。 应用程序可以根据此方法的返回值确定是否将令牌写入OutputStream。 返回值0表示未写入任何令牌。 应用程序可以调用isEstablished来确定上下文建立阶段是否在上下文的这一侧完成。 的返回值falseisEstablished表明更多的标记,预计将被供应到initSecContext 完成上下文建立后,可以通过get方法查询可用的上下文选项。

        请注意, initSecContext方法可能会为对等方返回令牌,而trueisEstablished返回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_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来确定该对等方是否完成了上下文建立阶段。 的返回值falseisEstablished表明更多的标记,预计将要提供给该方法。 完成上下文建立后,可以通过get方法查询可用的上下文选项。

        请注意, acceptSecContext可能会为对等acceptSecContext返回令牌,而trueisEstablished返回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 - 对等 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方法进行处理。 通常,应用程序将通过调用确保此flush上的方法OutputStream ,它封装了两个对等体之间的连接。 应用程序可以调用isEstablished来确定上下文建立阶段是否在上下文的这一侧完成。 的返回值falseisEstablished表明更多的标记,预计将被供应到acceptSecContext 完成上下文建立后,可以通过get方法查询可用的上下文选项。

        请注意, acceptSecContext可能会为对等acceptSecContext返回令牌,而trueisEstablished返回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_TOKENGSSException.BAD_MICGSSException.NO_CREDGSSException.CREDENTIALS_EXPIREDGSSException.BAD_BINDINGSGSSException.OLD_TOKENGSSException.DUPLICATE_TOKENGSSException.BAD_MECHGSSException.FAILURE
      • isEstablished

        boolean isEstablished()
        在上下文建立期间用于确定上下文的状态。
        结果
        true如果这是呼叫方的完全建立的上下文,则不需要来自对等方的更多令牌。
      • getWrapSizeLimit

        int getWrapSizeLimit​(int qop,
                             boolean confReq,
                             int maxTokenSize)
                      throws GSSException
        用于确定可以传递给wrap的消息大小的限制。 返回最大消息大小,如果使用相同的confReqqop参数提供给wrap方法,将导致输出标记包含不超过maxTokenSize个字节。

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

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

        参数
        qop - 将要求提供保护包装的级别。
        confReq - true如果要求包装提供隐私, false
        maxTokenSize - 包装发出的令牌所需的最大大小。
        结果
        给定输出令牌大小的输入令牌的最大大小
        异常
        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方法。

        应用程序将负责将令牌发送给对等方。 通常,应用程序将通过调用确保此flush上的方法OutputStream ,它封装了两个对等体之间的连接。

        MessageProp对象由应用程序实例化,用于指定选择加密算法的QOP值,以及可选地加密消息的隐私服务。 呼叫中使用的基础机制可能无法提供隐私服务。 它设置它在此MessageProp对象中提供的实际隐私服务,然后调用者应在返回时进行查询。 如果该机制无法提供所请求的QOP,则会抛出带有BAD_QOP代码的GSSException。

        由于某些应用程序级协议可能希望使用由wrap发出的令牌来提供“安全框架”,因此实现应该支持包含零长度消息。

        参数
        inStream - 包含要保护的应用程序数据的InputStream。 使用inStream中可用的所有数据。
        outStream - 用于将受保护消息写入的OutputStream。
        msgProp - 应用程序用于设置所需QOP和隐私状态的MessageProp实例。 将所需的QOP设置为0以请求默认QOP。 从此方法返回时,此对象将包含底层机制应用于消息的实际隐私状态。
        异常
        GSSException -包含以下主要错误代码: GSSException.CONTEXT_EXPIREDGSSException.BAD_QOPGSSException.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_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方法生成的令牌。 该方法将对等应用程序提供的消息返回到其包装调用,同时验证该消息的嵌入式MIC。

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

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

        此方法读取的输入标记的格式在将使用的基础机制的规范中定义。 此方法将尝试每次调用读取其中一个标记。 如果机制令牌包含明确的开始和结束,则此方法可能会阻止InputStream如果只有部分令牌可用)。 如果令牌的开头和结尾不是确定的,则该方法将尝试将所有可用字节视为令牌的一部分。

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

        参数
        inStream - 包含对等方生成的包装令牌的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(用于将用户消息封装在返回的令牌中)不同,在输出令牌中仅返回消息MIC。

        请注意,隐私只能通过包装调用来应用。

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

        参数
        inMsg - 生成MIC的消息。
        offset - 消息开始的inMsg内的偏移量。
        len - 消息的长度
        msgProp - 应用程序用于设置所需QOP的MessageProp实例。 设置需要的QOP到0msgProp来请求默认QOP。 或者,传入null以获取msgProp以请求默认QOP。
        结果
        包含要发送给对等方的令牌的byte []。
        异常
        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不同,只在输出令牌中生成消息MIC。 此方法相当于基于字节数组的getMIC方法。 请注意,隐私只能通过包装调用来应用。

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

        参数
        inStream - 包含生成MIC的消息的InputStream。 使用inStream中可用的所有数据。
        outStream - 用于将输出标记写入的OutputStream。
        msgProp - 应用程序用于设置所需QOP的MessageProp的实例。 设置需要的QOP到0msgProp来请求默认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 - peer的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.
        使用流来验证令牌参数中包含的加密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.UNAVAILABLEGSSException.CONTEXT_EXPIREDGSSException.NO_CONTEXTGSSException.FAILURE
        另请参见:
        GSSManager.createContext(byte[])
      • requestMutualAuth

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

        并非所有机制都支持相互身份验证,某些机制可能需要相互身份验证,即使应用程序没有。 因此,应用程序应检查请求是否符合getMutualAuthState方法。

        参数
        state - 一个布尔值,指示是否应使用相互身份验证。
        异常
        GSSException - 包含以下主要错误代码: GSSException.FAILURE
        另请参见:
        getMutualAuthState()
      • requestReplayDet

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

        并非所有机制都支持重放检测,并且某些机制可能需要重放检测,即使应用程序没有。 因此,应用程序应检查请求是否符合getReplayDetState方法。 如果启用了重放检测,则MessageProp.isDuplicateTokenMessageProp.isOldToken方法将返回传递给unwrap方法或verifyMIC方法的MessageProp对象的有效结果。

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

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

        并非所有机制都支持序列检查,并且某些机制可能需要序列检查,即使应用程序没有。 因此,应用程序应检查请求是否符合getSequenceDetState方法。 如果序列检查已启用,则MessageProp.isDuplicateTokenMessageProp.isOldTokenMessageProp.isUnseqTokenMessageProp.isGapToken方法将返回有效的结果MessageProp即到传递的对象unwrap方法或verifyMIC方法。

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

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

        void requestAnonymity​(boolean state)
                       throws GSSException
        要求不向接收方披露发起人的身份。 此请求只能在上下文发起方一方进行,并且必须在第一次调用initSecContext之前完成。 并非所有机制都支持发起者的匿名性。 因此,应用程序应检查请求是否符合getAnonymityState方法。
        参数
        state - 一个布尔值,指示是否应将启动器作为匿名主体对接受者进行身份验证。
        异常
        GSSException - 包含以下主要错误代码: GSSException.FAILURE
        另请参见:
        getAnonymityState()
      • requestConf

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

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

        参数
        state - 一个布尔值,指示是否应启用机密性。
        异常
        GSSException - 包含以下主要错误代码: GSSException.FAILURE
        另请参见:
        getConfState()getIntegState()requestInteg(boolean)MessageProp
      • requestInteg

        void requestInteg​(boolean state)
                   throws GSSException
        请求为wrapgetMIC方法启用数据完整性。 此请求只能在上下文发起方一方进行,并且必须在第一次调用initSecContext之前完成。 并非所有机制都支持完整性,即使应用程序没有请求它,其他机制也可能启用它。 应用程序可能会检查请求是否符合getIntegState方法。

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

        参数
        state - 一个布尔值,指示是否应启用完整性。
        异常
        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()
        确定上下文启动器是否对上下文接受器进行匿名身份验证。 它可以由上下文发起者和上下文接受者在任何时候调用。 在发起者方面,对该方法的调用确定是否已在迄今为止由initSecContext生成的任何上下文建立令牌中公开了发起者的身份。 绝对必须匿名身份验证的启动器应在每次调用initSecContext后调用此方法,以确定是否应将生成的令牌发送到对等方或中止上下文。 在接受方,对此方法的调用确定到目前为止由acceptSecContext处理的任何令牌是否泄露了发起者的身份。
        结果
        如果上下文启动器仍然是匿名的,则返回true,否则返回false。
        另请参见:
        requestAnonymity(boolean)
      • isTransferable

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

        boolean isProtReady()
        确定上下文是否已准备好对其使用的每个消息操作。 一些机制可以允许在完全建立上下文之前使用每消息操作。
        结果
        如果类似的方法真 wrapunwrapgetMICverifyMIC可以用此背景下,在上下文创建的当前阶段使用,否则为false。
      • getConfState

        boolean getConfState()
        确定上下文中是否可以使用数据机密性。 上下文启动器和上下文接受器都可以调用此方法,但仅在isProtReadyisEstablished之一返回true 如果此方法返回true ,则getIntegState true如此
        结果
        如果可用保密服务,则为true,否则为false。
        另请参见:
        requestConf(boolean)
      • getIntegState

        boolean getIntegState()
        确定上下文中是否可以使用数据完整性。 上下文启动器和上下文接受器都可以调用此方法,但仅在isProtReadyisEstablished之一之后返回true 如果getConfState返回true,则此方法将始终返回true
        结果
        如果提供完整性服务,则为true,否则为false。
        另请参见:
        requestInteg(boolean)
      • getLifetime

        int getLifetime()
        确定此上下文的剩余生命周期。 它可以由上下文启动器和上下文接受器调用,但是对于确定的答案,只有在isEstablished返回true后才应调用它。
        结果
        剩余的生命周期以秒为单位
        另请参见:
        requestLifetime(int)
      • 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