// Add some dummy security data at offset 64 from start
        buffer[64] = (byte) 0x4E; // NTLMSSP signature start
        buffer[65] = (byte) 0x54;
        buffer[66] = (byte) 0x4C;
        buffer[67] = (byte) 0x4D;
        buffer[68] = (byte) 0x53;
        buffer[69] = (byte) 0x53;
        buffer[70] = (byte) 0x50;
        buffer[71] = (byte) 0x00;

        return buffer;
    }

                SecureKeyManager.secureWipe(keyCopy);
            }
        }
    }

    private static byte[] longToBytes(final long value) {
        final byte[] bytes = new byte[8];
        for (int i = 0; i < 8; i++) {
            bytes[i] = (byte) (value >>> 8 * (7 - i));
        }
        return bytes;
    }

    /**
     * Check if key rotation is needed based on configurable usage limits
     *

        assertNotNull(resp.getNotifyInformation());
        assertEquals(0, resp.getNotifyInformation().size());
    }

    @Test
    @DisplayName("Should write empty bytes to wire format")
    void testWriteBytesWireFormat() {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);

        // Then

     * @param outputOffset the offset in the output buffer
     * @param algorithm the compression algorithm that was used
     * @return the number of bytes written to the output buffer
     * @throws CIFSException if decompression fails
     */
    int decompress(byte[] compressedData, int offset, int length, byte[] outputBuffer, int outputOffset, int algorithm)
            throws CIFSException;

    /**

        // Encrypt first message - should work
        byte[] plaintext1 = "Message before rotation".getBytes();
        byte[] encrypted1 = assertDoesNotThrow(() -> context.encryptMessage(plaintext1, 1L));
        assertNotNull(encrypted1);

        // Encrypt larger message to trigger rotation
        byte[] largeMessage = new byte[150]; // Exceed 100 byte limit
        Arrays.fill(largeMessage, (byte) 'A');

            this.andxCommand = (byte) 0xFF;
            this.andx = null;

            dst[start + ANDX_COMMAND_OFFSET] = (byte) 0xFF;
            dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
            // dst[start + ANDX_OFFSET_OFFSET] = (byte)0x00;
            // dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;

    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        if (this.compressionAlgorithms == null) {
            return 0;
        }

        int start = dstIndex;

        // Compression count (2 bytes)
        SMBUtil.writeInt2(this.compressionAlgorithms.length, dst, dstIndex);
        dstIndex += 2;

        // Padding (2 bytes)
        SMBUtil.writeInt2(0, dst, dstIndex);

     * instead of send/receive.
     *
     * @return threshold in bytes
     */
    int getRdmaReadWriteThreshold();

    /**
     * Get maximum RDMA send size
     *
     * @return max send size in bytes
     */
    int getRdmaMaxSendSize();

    /**
     * Get maximum RDMA receive size
     *
     * @return max receive size in bytes
     */
    int getRdmaMaxReceiveSize();

    /**

     *
     * @return a cryptographically secure random salt
     */
    public byte[] generatePreauthSalt() {
        byte[] salt = new byte[SALT_SIZE];
        secureRandom.nextBytes(salt);
        log.debug("Generated new preauth salt of {} bytes", salt.length);
        return salt;
    }

    /**
     * Initializes preauth integrity context for a new session.
     *

            log.debug("Data too small for compression ({} bytes), returning uncompressed", length);
            byte[] result = new byte[length];
            System.arraycopy(data, offset, result, 0, length);
            return result;
        }
        if (length > MAX_COMPRESSION_SIZE) {
            throw new CIFSException("Data too large for compression: " + length + " bytes");
        }

        switch (algorithm) {