// Given
        byte[] sessionKey1 = new byte[16];
        byte[] sessionKey2 = new byte[16];
        new SecureRandom().nextBytes(sessionKey1);
        new SecureRandom().nextBytes(sessionKey2);
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        // When
        byte[] signingKey1 = Smb3KeyDerivation.deriveSigningKey(dialect, sessionKey1, preauthIntegrity);

        void testDifferentSessionKeys() throws GeneralSecurityException {
            byte[] sessionKey1 = new byte[16];
            Arrays.fill(sessionKey1, (byte) 0x11);

            byte[] sessionKey2 = new byte[16];
            Arrays.fill(sessionKey2, (byte) 0x22);

            Smb2SigningDigest digest1 = new Smb2SigningDigest(sessionKey1, Smb2Constants.SMB2_DIALECT_0202, null);

        this.cipherId = cipherId;
        this.dialect = dialect;
        this.keyManager = keyManager;
        this.sessionKey = sessionKey != null ? sessionKey.clone() : null;
        this.preauthIntegrityHash = preauthHash != null ? preauthHash.clone() : null;

        // Generate unique session ID for key management

     */
    public byte[] getSessionKey() {
        return sessionKey;
    }

    /**
     * Sets the session key.
     *
     * @param sessionKey The session key.
     */
    public void setSessionKey(final byte[] sessionKey) {
        this.sessionKey = sessionKey;
    }

    @Override
    public byte[] toByteArray() {
        try {

        void testSessionKeyRetrieval() throws CIFSException {
            // When: Getting session key
            byte[] sessionKey = handle.getSessionKey();

            // Then: Should return expected session key
            assertNotNull(sessionKey);
            assertArrayEquals(new byte[] { 1, 2, 3, 4 }, sessionKey);
        }

        @Test
        @DisplayName("Should handle max values configuration")

    private int negotiatedFlags2;
    private int maxMpxCount;
    private int snd_buf_size;
    private int recv_buf_size;
    private int tx_buf_size;

    private int capabilities;
    private final int sessionKey = 0x00000000;
    private boolean useUnicode;

    /**
     * Creates a new SMB1 negotiate response.
     *
     * @param ctx the CIFS context
     */
    public SmbComNegotiateResponse(final CIFSContext ctx) {

     */
    public Smb2SigningDigest(final byte[] sessionKey, final int dialect, final byte[] preauthIntegrityHash)
            throws GeneralSecurityException {
        switch (dialect) {
        case Smb2Constants.SMB2_DIALECT_0202:
        case Smb2Constants.SMB2_DIALECT_0210:
            this.algorithmName = "HmacSHA256";
            this.provider = null;
            this.signingKey = sessionKey.clone();
            break;

     */
    public byte[] getEncryptedSessionKey() {
        return this.sessionKey;
    }

    /**
     * Sets the session key.
     *
     * @param sessionKey
     *            The session key.
     */
    public void setEncryptedSessionKey(final byte[] sessionKey) {
        this.sessionKey = sessionKey;
    }

    /**

        }

        @Test
        @DisplayName("createEncryptionContext selects AES-CCM for SMB 3.0 and AES-GCM for SMB 3.1.1")
        void createEncryptionContext_happyDialects() throws Exception {
            byte[] sessionKey = new byte[16];
            byte[] preauth = new byte[16];

            // SMB 3.0 -> AES-128-CCM
            setField(transport, "smb2", true);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            // Combine session key with channel-specific data
            byte[] sessionKey = getSessionKey();
            if (sessionKey != null) {
                baos.write(sessionKey);
            }
            baos.write(channel.getLocalInterface().getAddress().getAddress());
            baos.write(channel.getRemoteInterface().getAddress().getAddress());