/**
     * Checks whether the server has SMB message signing enabled.
     *
     * @return whether the server has signing enabled
     */
    boolean isSigningEnabled();

    /**
     * Checks whether the server requires SMB message signing.
     *
     * @return whether the server requires signing
     */
    boolean isSigningRequired();

    /**

     */
    int encode(byte[] dst, int dstIndex);

    /**
     * Sets the signing digest for this message.
     *
     * @param digest the signing digest to set
     */
    void setDigest(SMBSigningDigest digest);

    /**
     * Gets the signing digest for this message.
     *
     * @return the signing digest
     */
    SMBSigningDigest getDigest();

    /**

    private boolean bypass = false;
    private int updates;
    private int signSequence;

    /**
     * Constructs a new signing digest with the specified MAC signing key.
     *
     * @param macSigningKey the MAC signing key for message authentication
     * @param bypass whether to bypass MAC signing
     * @throws SmbException if MD5 algorithm is not available
     */

    }

    /**
     * Test that signing is properly configured
     */
    @Test
    public void testSigningConfiguration() throws CIFSException {
        BaseConfiguration config = new BaseConfiguration(true);

        // Verify IPC signing is enforced (this is a security requirement)
        assertTrue("IPC signing should be enforced for security", config.isIpcSigningEnforced());
    }

    @DisplayName("Test isSigningEnforced returns true when signing is enforced")
    void testIsSigningEnforcedReturnsTrue() {
        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true);

        // When
        boolean result = negotiationRequest.isSigningEnforced();

        // Then
        assertTrue(result, "isSigningEnforced should return true when signing is enforced");

    /**
     * Checks if message signing is supported but not mandatory.
     *
     * @return whether signatures are supported but not required
     * @throws SmbException if an error occurs checking signing status
     */
    boolean isSigningOptional() throws SmbException;

    /**
     * Checks if message signing is mandatory for this connection.
     *

package jcifs.internal;

/**
 * Interface for SMB message signing and verification operations.
 * Provides cryptographic signing capabilities for SMB protocol messages to ensure
 * message integrity and authenticity using MAC (Message Authentication Code) algorithms.
 *
 * @author mbechler
 */
public interface SMBSigningDigest {

    /**
     * Performs MAC signing of the SMB. This is done as follows.

 * with the server, including security requirements like message signing.
 *
 * @author mbechler
 */
public interface SmbNegotiationRequest {

    /**
     * Checks whether SMB message signing is enforced by the client.
     *
     * @return whether SMB signing is enforced
     */
    boolean isSigningEnforced();

     * @param doSigning whether to enable message signing
     */
    public NtlmContext(final NtlmPasswordAuthentication auth, final boolean doSigning) {
        this.auth = auth;
        this.ntlmsspFlags =
                ntlmsspFlags | NtlmFlags.NTLMSSP_REQUEST_TARGET | NtlmFlags.NTLMSSP_NEGOTIATE_NTLM2 | NtlmFlags.NTLMSSP_NEGOTIATE_128;
        if (doSigning) {
            this.ntlmsspFlags |=

        assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());
        // Signing key may or may not be generated depending on flags negotiation
        // The context negotiates flags with server, so we can't guarantee signing key
    }

    @Test
    void testInitSecContext_state2_withoutSigning() throws Exception {