buffer = new byte[BUFFER_SIZE];
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create instance with Configuration, hash algorithms and salt")
        void testConstructorWithConfigHashAlgosAndSalt() {
            int[] hashAlgos = { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 };
            byte[] salt = { 0x01, 0x02, 0x03, 0x04 };

    /**
     * Validates if the compression algorithm is known.
     *
     * @param algorithm the algorithm to validate
     * @return true if the algorithm is known
     */
    private boolean isValidCompressionAlgorithm(int algorithm) {
        return algorithm == COMPRESSION_NONE || algorithm == COMPRESSION_LZ77 || algorithm == COMPRESSION_LZ77_HUFFMAN

				found = true
				break
			}
		}
		if !found {
			logger.Fatal(fmt.Errorf("unknown algorithm %q passed to --sftp=%s\nValid algorithms: %v", algo, arg, strings.Join(allowed, ", ")), "unable to start SFTP server")
		}
	}
	if len(filteredAlgos) == 0 {
		logger.Fatal(fmt.Errorf("no valid algorithms passed to --sftp=%s\nValid algorithms: %v", arg, strings.Join(allowed, ", ")), "unable to start SFTP server")
	}
	return filteredAlgos
}

    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {
        int[] algorithms = context.getCompressionAlgorithms();
        assertNotNull(algorithms);
        assertEquals(3, algorithms.length);
        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZ77));

    private byte[] salt;

    /**
     * Constructs a preauth integrity negotiate context with the specified parameters.
     *
     * @param config the SMB configuration
     * @param hashAlgos the supported hash algorithms
     * @param salt the salt value for preauth integrity
     */
    public PreauthIntegrityNegotiateContext(final Configuration config, final int[] hashAlgos, final byte[] salt) {
        this.hashAlgos = hashAlgos;

     *
     * @param algorithm the compression algorithm to check
     * @return true if the algorithm is supported
     */
    boolean isAlgorithmSupported(int algorithm);

    /**
     * Gets the list of supported compression algorithms.
     *
     * @return array of supported algorithm constants
     */
    int[] getSupportedAlgorithms();

    /**

/**
 * 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.

        }
    }

    @Override
    public byte[] decompress(byte[] compressedData, int algorithm) throws CIFSException {
        if (compressedData == null) {
            throw new CIFSException("Compressed data cannot be null");
        }
        return decompress(compressedData, 0, compressedData.length, algorithm);
    }

    @Override

    /**
     * Gets the name of a hash algorithm.
     *
     * @param algorithm the algorithm constant
     * @return the algorithm name
     */
    public static String getHashAlgorithmName(int algorithm) {
        switch (algorithm) {
        case HASH_ALGO_SHA512:
            return "SHA-512";
        default:
            return "Unknown(0x" + Integer.toHexString(algorithm) + ")";
        }
    }

    /**

## Install `passlib` { #install-passlib }

PassLib is a great Python package to handle password hashes.

It supports many secure hashing algorithms and utilities to work with them.

The recommended algorithm is "Bcrypt".

Make sure you create a [virtual environment](../../virtual-environments.md){.internal-link target=_blank}, activate it, and then install PassLib with Bcrypt:

<div class="termy">