}

            log.info("Created {} channels for session {}", channelGroup.getChannelCount(), sessionId);
            return channelGroup;

        } catch (Exception e) {
            sessionChannels.remove(sessionId);
            throw new CIFSException("Failed to create channels for session " + sessionId, e);
        }
    }

    /**

import jcifs.internal.smb2.nego.Smb2NegotiateResponse;
import jcifs.internal.smb2.persistent.PersistentHandleManager;
import jcifs.internal.smb2.session.Smb2LogoffRequest;
import jcifs.internal.smb2.session.Smb2SessionSetupRequest;
import jcifs.internal.smb2.session.Smb2SessionSetupResponse;
import jcifs.internal.witness.WitnessClient;
import jcifs.internal.witness.WitnessNotification;
import jcifs.internal.witness.WitnessRegistration;

        // Generate unique session ID for key management
        this.sessionId = String.format("smb-enc-%d-%d", System.currentTimeMillis(), secureRandom.nextLong());

        if (keyManager != null) {
            // Store keys securely
            String encKeyId = sessionId + "-enc";
            String decKeyId = sessionId + "-dec";

    @Test
    @DisplayName("Test session finalization")
    public void testSessionFinalization() throws CIFSException {
        String sessionId = "test-session-4";
        byte[] salt = preauthService.generatePreauthSalt();

        preauthService.initializeSession(sessionId, salt, PreauthIntegrityService.HASH_ALGO_SHA512);
        assertNotNull(preauthService.getCurrentPreauthHash(sessionId));

        PreauthIntegrityContext context = sessionContexts.get(sessionId);
        if (context == null) {
            if (enforceIntegrity) {
                throw new CIFSException("No preauth integrity context found for session: " + sessionId);
            }
            log.warn("No preauth integrity context for session {}, skipping validation", sessionId);

        // Simulate session already in use by adding a session
        Field sessionsField = SmbTransportImpl.class.getDeclaredField("sessions");
        sessionsField.setAccessible(true);
        @SuppressWarnings("unchecked")
        List<Object> sessions = (List<Object>) sessionsField.get(first);
        sessions.add(new Object()); // Add one session to reach the limit

            Arrays.fill(this.password, '\0');
            this.password = null;
        }
        // Also remove from secure key manager if we have a session
        if (this.sessionId != null) {
            keyManager.removeSessionKey(this.sessionId);
            this.sessionId = null;
        }
    }

    /**
     * Check if the authentication has expired based on TTL
     *

    }

    /**
     * Gets the session identifier for this message.
     *
     * @return the sessionId
     */
    public long getSessionId() {
        return this.sessionId;
    }

    /**
     * @param sessionId
     *            the sessionId to set
     */
    @Override
    public final void setSessionId(final long sessionId) {
        this.sessionId = sessionId;
        if (this.next != null) {

            context.rotateKeys(newKey, newKey);
        });
    }

    @Test
    @DisplayName("Should perform automatic key rotation when session key is provided")
    void testAutomaticKeyRotation() throws Exception {
        // Given - Create context with session key for rotation support
        byte[] sessionKey = new byte[16];
        byte[] preauthHash = new byte[64];
        new SecureRandom().nextBytes(sessionKey);

    /** Connection timeout in milliseconds for establishing SMB connections */
    protected int smbConnectionTimeout = SmbConstants.DEFAULT_CONN_TIMEOUT;
    /** Session timeout in milliseconds for SMB sessions */
    protected int smbSessionTimeout = SmbConstants.DEFAULT_SO_TIMEOUT;
    /** Whether idle timeout is disabled for connections */
    protected boolean idleTimeoutDisabled = false;