final int start = dstIndex;

        this.dataOffset = dstIndex - this.headerStart + 26; // 26 = off from here to pad

        this.pad = (this.dataOffset - this.headerStart) % 4;
        this.pad = this.pad == 0 ? 0 : 4 - this.pad;
        this.dataOffset += this.pad;

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        SMBUtil.writeInt4(this.offset, dst, dstIndex);

        }

        return bufferIndex - start;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        pad = pad1 = 0;
        final int n;

        if (parameterCount > 0) {
            bufferIndex += pad = parameterOffset - (bufferIndex - headerStart);
            System.arraycopy(buffer, bufferIndex, txn_buf, bufParameterStart + parameterDisplacement, parameterCount);

        bufferIndex += 4;

        final int pad = bufferIndex - (getHeaderStart() + securityBufferOffset);
        this.blob = new byte[securityBufferLength];
        System.arraycopy(buffer, getHeaderStart() + securityBufferOffset, this.blob, 0, securityBufferLength);
        bufferIndex += pad;
        bufferIndex += securityBufferLength;

        return bufferIndex - start;
    }

        final int start = dstIndex;

        dataOffset = dstIndex - headerStart + 26; // 26 = off from here to pad

        pad = (dataOffset - headerStart) % 4;
        pad = pad == 0 ? 0 : 4 - pad;
        dataOffset += pad;

        writeInt2(fid, dst, dstIndex);
        dstIndex += 2;
        writeInt4(offset, dst, dstIndex);
        dstIndex += 4;

        final int i = inData[inIndex] & 0xff;
        outData[outIndex] = ENCODE_TABLE[i >> 2];
        outData[outIndex + 1] = ENCODE_TABLE[i << 4 & 0x3f];
        outData[outIndex + 2] = PAD;
        outData[outIndex + 3] = PAD;
    }

    private static void encode1pad(final byte[] inData, final int inIndex, final char[] outData, final int outIndex) {

     */
    public Smb2TransformHeader(final byte[] nonce, final int originalMessageSize, final int flags, final long sessionId) {
        if (nonce.length == 12) {
            // For CCM cipher, pad nonce to 16 bytes with zeros
            System.arraycopy(nonce, 0, this.nonce, 0, 12);
            // Last 4 bytes remain zero-initialized
        } else if (nonce.length == 16) {

        // Context handle (20 bytes) - this is both input and output (modified)
        if (contextHandle != null) {
            buf.writeOctetArray(contextHandle, 0, Math.min(contextHandle.length, 20));
            // Pad with zeros if context handle is shorter than 20 bytes
            for (int i = contextHandle.length; i < 20; i++) {
                buf.enc_ndr_small(0);
            }
        } else {

        final int length = string.length();
        if (length == 0) {
            return new byte[0];
        }
        final int pad = string.charAt(length - 2) == '=' ? 2 : string.charAt(length - 1) == '=' ? 1 : 0;
        final int size = length * 3 / 4 - pad;
        final byte[] buffer = new byte[size];
        int block;
        int i = 0;
        int index = 0;
        while (i < length) {

        assertArrayEquals(machineId, actualMachineId);
    }

    /**
     * Test with customData and machineId that are not exactly 8 and 32 bytes respectively.
     * The constructor requires exact sizes, so we need to pad them manually.
     */
    @Test
    void testAvSingleHostCustomDataMachineIdConstructor_ShorterInputs() {
        // Prepare padded arrays
        byte[] customData = new byte[8];
        customData[0] = 0x01;

    /**
     * This is an alternative to the <code>java.lang.Integer.toHexString</code>
     * method. It is an efficient relative that also will pad the left side so
     * that the result is <code>size</code> digits.
     *
     * @param val the integer value to convert to hexadecimal