private final DialectVersion dialect;
    private byte[] encryptionKey;
    private byte[] decryptionKey;
    private final AtomicLong nonceCounter = new AtomicLong(0);
    private final SecureRandom secureRandom = new SecureRandom();

    // Secure key management
    private SecureKeyManager keyManager;
    private String sessionId;
    private volatile boolean closed = false;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.security.SecureRandom;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;

    private CIFSContext mockContext;
    private SecureRandom mockRandom;
    private Smb2NegotiateRequest request;
    private byte[] testMachineId = new byte[16];
    private byte[] testSalt = new byte[32];

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        mockRandom = mock(SecureRandom.class);

        // Initialize test data

        void testDataIntegrity() throws SMBProtocolDecodingException {
            // Create complex test data
            int[] hashAlgos = new int[20];
            byte[] salt = new byte[64];
            SecureRandom random = new SecureRandom();

            for (int i = 0; i < hashAlgos.length; i++) {
                hashAlgos[i] = random.nextInt(65536);
            }
            random.nextBytes(salt);

    @Test
    @DisplayName("Random access should delegate to underlying configuration")
    void testRandomDelegation() {
        // Given
        SecureRandom expectedRandom = new SecureRandom();
        when(mockDelegate.getRandom()).thenReturn(expectedRandom);

        // When
        SecureRandom result = delegatingConfig.getRandom();

        // Then
        assertSame(expectedRandom, result, "Should return delegated random");

    private final Map<String, SecretKey> sessionKeys = new ConcurrentHashMap<>();
    private final Map<String, byte[]> rawKeys = new ConcurrentHashMap<>();
    private final SecureRandom secureRandom = new SecureRandom();
    private KeyStore keyStore;
    private char[] keyStorePassword;
    private volatile boolean closed = false;

    /**
     * Create a secure key manager without KeyStore
     */

## 4. Data Structures

### 4.1 Lease Key Structure
```java
package jcifs.internal.smb2.lease;

import java.security.SecureRandom;
import java.util.Arrays;

public class Smb2LeaseKey {
    private final byte[] key;  // 16-byte lease key
    private static final SecureRandom random = new SecureRandom();
    
    public Smb2LeaseKey() {
        this.key = new byte[16];
        random.nextBytes(this.key);
    }
    

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.security.SecureRandom;
import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Random;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.security.SecureRandom;
import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;