Finding specific small byte arrays in large binary files

You should be aware, that if you have a search pattern like:

byte[] pattern = { 0x00, 0x01, 0x02, 0x03 };

and a file sequence as

..., 0x00, 0x00, 0x01, 0x02, 0x03,...

Then it won't be found, because the first 0x00 will increment searchPosition to 1, so the second 0x00 will test false in if(latestbyte == searchPattern[searchPosition].

The solution is to reset the searchPosition whenever the latestbyte equals searchPattern[0]:

while(true) //Loop until we reach the end of the file
{
    var latestbyte = stream.ReadByte();
    if(latestbyte == -1) break; //We have reached the end of the file

    if (latestbyte == searchPattern[0])
      searchPosition = 0;

    if(latestbyte == searchPattern[searchPosition]
    {
        searchPosition++;
        if(searchPosition == searchPattern.Length)
        {
            searchResults.Add(stream.Position);
            searchPosition = 0;
        }
    }
}

OBS: This is only working for search patterns with bytes, that are all different (see Firdas comment).

The position of the found pattern, you add to the result is actually the position of the last byte in the pattern. Maybe the start position is more interesting:

searchResults.Add(stream.Position - searchPattern.Length);

As Sylvain suggests you can improve performance a bit by reading larger chunks of bytes and evaluate them in turn successively:

List<long> GetPatternPositions(string path, byte[] pattern)
{
  using (FileStream stream = new FileStream(path, FileMode.Open))
  {
    List<long> searchResults = new List<long>(); //The results as offsets within the file
    int patternPosition = 0; //Track of how much of the array has been matched
    long filePosition = 0;
    long bufferSize = Math.Min(stream.Length, 100_000);

    byte[] buffer = new byte[bufferSize];
    int readCount = 0;

    while ((readCount = stream.Read(buffer, 0, buffer.Length)) > 0)
    {
      for (int i = 0; i < readCount; i++)
      {
        byte currentByte = buffer[i];

        if (currentByte == pattern[0])
          patternPosition = 0;

        if (currentByte == pattern[patternPosition])
        {
          patternPosition++;
          if (patternPosition == pattern.Length)
          {
            searchResults.Add(filePosition + 1 - pattern.Length);
            patternPosition = 0;
          }
        }
        filePosition++;
      }
    }

    return searchResults;
  }
}

The improvement is not that impressive, but maybe you can experiment with the bufferSize to optimize it?

This is not a full review, but longer description of an idea. Let me use Henrik's answer as a start and improve it by taking advantage of the length of the pattern - 4 bytes. We can merge it to single uint variable and match it as a whole. The basis of the loop would look like this:

uint pattern = 0x00010203; // Big Endian
uint view = 0; // bytes shifted into this for easy compare
//...
for (int i = 0; i < readCount; i++) // see Henrik's answer
{
    view = (view << 8) | buffer[i]; // shift-in next byte
    if(view == pattern && filePosition >= 3) // make sure we already got at least 4 bytes
        searchResults.Add(filePosition - 3);

This also avoids problems with patterns containing same bytes and can easily be upgraded to match multiple patterns (one of) at once.

P.S.: A cast to uint could be needed in some places, compiler would tell.