How to fix RangeError: offset is out of bounds (buffer index exceeds length) in Node.js

const buffer = Buffer.from([0x01, 0x02, 0x03, 0x04]);

// Bad: No validation
// const value = buffer.readUInt32LE(5); // RangeError!

// Good: Validate first
const offset = 0;
const bytesNeeded = 4; // UInt32 requires 4 bytes

if (offset >= 0 && offset + bytesNeeded <= buffer.length) {
  const value = buffer.readUInt32LE(offset);
  console.log('Value:', value);
} else {
  console.error('Buffer too small or invalid offset');
}

function safeReadUInt32LE(buffer, offset) {
  if (!Buffer.isBuffer(buffer)) {
    throw new TypeError('First argument must be a Buffer');
  }

  if (typeof offset !== 'number' || offset < 0) {
    throw new RangeError('Offset must be a non-negative number');
  }

  if (offset + 4 > buffer.length) {
    throw new RangeError(
      `Cannot read UInt32 at offset ${offset}: buffer length is ${buffer.length}`
    );
  }

  return buffer.readUInt32LE(offset);
}

// Usage
try {
  const value = safeReadUInt32LE(myBuffer, 10);
  console.log('Read value:', value);
} catch (error) {
  console.error('Failed to read:', error.message);
}

function parseDataPacket(buffer) {
  // Expected structure:
  // - 4 bytes: packet length
  // - 2 bytes: message type
  // - N bytes: payload

  const MIN_HEADER_SIZE = 6;

  if (buffer.length < MIN_HEADER_SIZE) {
    throw new Error(`Invalid packet: expected at least ${MIN_HEADER_SIZE} bytes, got ${buffer.length}`);
  }

  const packetLength = buffer.readUInt32LE(0);
  const messageType = buffer.readUInt16LE(4);

  // Validate declared length matches actual buffer
  if (buffer.length < packetLength) {
    throw new Error(`Incomplete packet: expected ${packetLength} bytes, got ${buffer.length}`);
  }

  const payload = buffer.slice(6, packetLength);

  return {
    length: packetLength,
    type: messageType,
    payload: payload
  };
}

function processDataStream(buffer) {
  let offset = 0;
  const results = [];

  while (offset < buffer.length) {
    try {
      // Try to read a 4-byte value
      if (offset + 4 <= buffer.length) {
        const value = buffer.readUInt32LE(offset);
        results.push(value);
        offset += 4;
      } else {
        // Not enough bytes remaining for UInt32
        console.warn(`Skipping ${buffer.length - offset} remaining bytes`);
        break;
      }
    } catch (error) {
      console.error(`Error at offset ${offset}:`, error.message);
      break;
    }
  }

  return results;
}

// Bad: Off-by-one error
function parseRecordsBad(buffer) {
  const recordSize = 8;
  const recordCount = Math.floor(buffer.length / recordSize);

  for (let i = 0; i <= recordCount; i++) { // Bug: <= should be <
    const offset = i * recordSize;
    const id = buffer.readUInt32LE(offset); // May exceed bounds on last iteration
    const value = buffer.readUInt32LE(offset + 4);
  }
}

// Good: Correct boundary check
function parseRecordsGood(buffer) {
  const recordSize = 8;
  const recordCount = Math.floor(buffer.length / recordSize);

  for (let i = 0; i < recordCount; i++) {
    const offset = i * recordSize;

    // Extra safety check
    if (offset + recordSize <= buffer.length) {
      const id = buffer.readUInt32LE(offset);
      const value = buffer.readUInt32LE(offset + 4);
      console.log(`Record ${i}: id=${id}, value=${value}`);
    }
  }
}