}
        snd_buf_size = Math.min(snd_buf_size, server.maxBufferSize);
        capabilities &= server.capabilities;
        if ((server.capabilities & CAP_EXTENDED_SECURITY) == CAP_EXTENDED_SECURITY) {
            capabilities |= CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if ((capabilities & SmbConstants.CAP_UNICODE) == 0) {
            // server doesn't want unicode

        return bufferIndex - start;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        if ((server.capabilities & CAP_EXTENDED_SECURITY) == 0) {
            server.encryptionKey = new byte[server.encryptionKeyLength];
            System.arraycopy(buffer, bufferIndex, server.encryptionKey, 0, server.encryptionKeyLength);

    }

    @Test
    void testReadBytesWireFormat_ExtendedSecurity() {
        // Setup server data for this scenario
        serverData.capabilities = SmbConstants.CAP_EXTENDED_SECURITY;
        response.byteCount = 16; // GUID length

        // Prepare byte array with a GUID
        byte[] guid = new byte[16];
        for (int i = 0; i < 16; i++) {
            guid[i] = (byte) i;

    int CAP_LOCK_AND_READ = 0x0100;
    /** NT find capability */
    int CAP_NT_FIND = 0x0200;
    /** DFS capability */
    int CAP_DFS = 0x1000;
    /** Extended security capability */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /** Read-only file attribute */
    int ATTR_READONLY = 0x01;
    /** Hidden file attribute */
    int ATTR_HIDDEN = 0x02;

    /**
     * Large write operations are supported capability.
     */
    int CAP_LARGE_WRITEX = 0x8000;
    /**
     * Extended security exchanges are supported capability.
     */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /**
     * File is marked read-only
     */
    int ATTR_READONLY = 0x01;
    /**
     * File is marked hidden
     */

        this.capabilities &= this.server.scapabilities;
        if ((this.server.scapabilities & SmbConstants.CAP_EXTENDED_SECURITY) == SmbConstants.CAP_EXTENDED_SECURITY) {
            this.capabilities |= SmbConstants.CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if (ctx.getConfig().isUseUnicode() || ctx.getConfig().isForceUnicode()) {

        assertEquals(0x0010, SmbConstants.CAP_NT_SMBS);
        assertEquals(0x0040, SmbConstants.CAP_STATUS32);
        assertEquals(0x1000, SmbConstants.CAP_DFS);
        assertEquals(0x80000000, SmbConstants.CAP_EXTENDED_SECURITY);
    }

    /**
     * Test file attribute constants.
     */
    @Test
    @DisplayName("File attribute constants are correct")
    void fileAttributesTest() {

                if (auth == NtlmPasswordAuthentication.ANONYMOUS) {
                    lmHash = new byte[0];
                    ntHash = new byte[0];
                    capabilities &= ~SmbConstants.CAP_EXTENDED_SECURITY;
                } else if (session.transport.server.encryptedPasswords) {
                    lmHash = auth.getAnsiHash(session.transport.server.encryptionKey);

    }

    @Test
    public void testReadBytesWireFormatWithExtendedSecurity() {
        response.getServerData().scapabilities = SmbConstants.CAP_EXTENDED_SECURITY;
        // Use reflection to set protected byteCount field
        int byteCountValue = 16 + 10; // guid + token
        setByteCount(response, byteCountValue);
        byte[] buffer = new byte[byteCountValue];

        assertEquals(0x1000, SmbConstants.CAP_DFS);
        assertEquals(0x4000, SmbConstants.CAP_LARGE_READX);
        assertEquals(0x8000, SmbConstants.CAP_LARGE_WRITEX);
        assertEquals(0x80000000, SmbConstants.CAP_EXTENDED_SECURITY);
    }

    @Test
    @DisplayName("Should define file attribute constants")
    void testFileAttributes() {
        assertEquals(0x01, SmbConstants.ATTR_READONLY);