* @throws CIFSException if an error occurs retrieving the buffer size
     */
    int getMaximumBufferSize() throws CIFSException;

    /**
     * Checks if SMB message signing is active for this session
     * @return whether the session uses SMB signing
     * @throws CIFSException if a general CIFS error occurs
     * @throws SmbException if an SMB-specific error occurs
     */
    boolean areSignaturesActive() throws CIFSException;

        assertFalse(result);
        verify(negotiationResponse).canReuse(null, false);
    }

    @Test
    @DisplayName("Test signing state combinations")
    void testSigningStateCombinations() {
        // Test all combinations of signing states

        // Signing disabled
        when(negotiationResponse.isSigningEnabled()).thenReturn(false);
        when(negotiationResponse.isSigningRequired()).thenReturn(false);

     * @param name the server name or address
     * @param port the port number
     * @param exclusive whether to acquire an unshared connection
     * @param forceSigning whether to enforce SMB signing
     * @return a connected transport
     * @throws UnknownHostException if the host cannot be resolved
     * @throws IOException if an I/O error occurs
     */

    class NegotiationConstants {

        @Test
        @DisplayName("Signing enabled flag should be 0x0001")
        void testSigningEnabledFlag() {
            assertEquals(0x0001, Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED, "Signing enabled flag must be 0x0001");
        }

        @Test
        @DisplayName("Signing required flag should be 0x0002")
        void testSigningRequiredFlag() {

                            && !conn.getNegotiateResponse().isSigningRequired()) {
                        // if signing is not enforced, dont use connections that have signing enforced
                        // for purposes that dont require it.
                        if (log.isTraceEnabled()) {
                            log.debug("Cannot reuse, signing enforced on connection " + conn);
                        }
                        continue;

     * SMB2 header length in bytes
     */
    public static final int SMB2_HEADER_LENGTH = 64;

    /**
     * SMB2 negotiate flag indicating signing is enabled
     */
    public static final int SMB2_NEGOTIATE_SIGNING_ENABLED = 0x0001;

    /**
     * SMB2 negotiate flag indicating signing is required
     */
    public static final int SMB2_NEGOTIATE_SIGNING_REQUIRED = 0x0002;

    /**

        default -> getNTLMResponse(password, challenge);
        };
    }

    /**
     * Returns the signing key for SMB signing.
     *
     * @param challenge the server challenge bytes
     * @return the signing key
     * @throws SmbException if an error occurs generating the signing key
     */
    public byte[] getSigningKey(final byte[] challenge) throws SmbException {
        switch (LM_COMPATIBILITY) {

    /**
     * Indicates datagram authentication.
     */
    int NTLMSSP_NEGOTIATE_DATAGRAM_STYLE = 0x00000040;

    /**
     * Indicates that the LAN Manager session key should be used for
     * signing and sealing authenticated communication.
     */
    int NTLMSSP_NEGOTIATE_LM_KEY = 0x00000080;

    /**
     * ??? According to spec this is a reserved bit and must be set to zero
     */

        assertFalse(transport.isSigningEnforced());
        verify(transport).isSigningOptional();
        verify(transport).isSigningEnforced();
    }

    // Error propagation: signing checks may throw SmbException
    @Test
    @DisplayName("signing checks propagate SmbException")
    void signingChecks_throw() throws Exception {
        doThrow(new SmbException("opt error")).when(transport).isSigningOptional();

    /**
     * Whether the server requires encrypted passwords.
     */
    public boolean encryptedPasswords;
    /**
     * Whether message signing is enabled.
     */
    public boolean signaturesEnabled;
    /**
     * Whether message signing is required.
     */
    public boolean signaturesRequired;
    /**
     * Maximum number of virtual circuits.
     */
    public int maxNumberVcs;
    /**