How to reliably regex a Base64String

Question

So basically I'm writing an application that looks for PNG files in a binary file. It does this by reading in an entire binary in file into a byte array and then converting it to a string using the Convert.ToBase64String method and then using a regex that matches a PNG's header information and end chunk to find the images. Problem is using the ToBase64String method generates wildly different outputs depending on the length of the byte array and the documentation on MSDN doesn't seem to elaborate on it. Anyways here's an example of what I mean.

 byte[] somebytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

 Console.WriteLine(Convert.ToBase64String(somebytes));

The output in this case is "AQIDBAUGBwg=" now if I skip a byte...

 byte[] somebytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

 somebytes = somebytes.Skip(1).ToArray();

 Console.WriteLine(Convert.ToBase64String(somebytes));

The output is now "AgMEBQYHCA==" so almost every character has changed from the previous example.

So am I hopelessly following the wrong path here for regexing a binary file or is there a method (maybe by padding?) I can guarantee more consistency across these conversion?

Update: Based on the feedback I've gathered it seems I should just move away from the Regex solution and manually search for the start and end byte sequences manually myself. Not sure why I'm being downvoted as I just wanted to understand why my other solution did work and there doesn't seem to be any other posts on this topic. Anyways thanks everyone for the quick feedback. I'll post the algorithm I used for finding images when I'm done in case it might benefit someone else.

Answer 1

You confirmed in the comments that you are trying to pull resources from a C# structured file (EXE or DLL). You can use reflection methods to pull them out: GetManifestResourceStream, GetManifestResourceNames, GetManifestResourceInfo is a good starting point.

Answer 2

As promised here is the logic I've written to find the images in the binary in the event it might help someone else. However, I may ultimately use SledgeHammers method but it was important to me that I'm able to handle it using this method as well.

public class BinarySearch
{
    public static IEnumerable<byte[]> Match(byte[] source, byte[] beginningSequence, byte[] endSequence)
    {
        int index = 0;

        IList<byte[]> matches = new List<byte[]>();

        while (index < source.Length)
        {
            var startIndex = FindSequence(source, beginningSequence, index);

            if (startIndex >= 0)
            {
                var endIndex = FindSequence(source, endSequence, startIndex + beginningSequence.Length);

                if (endIndex >= 0)
                {
                    var length = (endIndex - startIndex) + endSequence.Length;
                    var buffer = new byte[length];

                    Array.Copy(source, startIndex, buffer, 0, length);

                    matches.Add(buffer);

                    index = endIndex + endSequence.Length;
                }
                else
                {
                    index = source.Length;
                }
            }
            else
            {
                index = source.Length;
            }
        }

        return matches;
    }

    private static int FindSequence(byte[] bytes, byte[] sequence, int startIndex = 0)
    {
        int currentIndex = startIndex;
        int sequenceIndex = 0;
        bool found = false;

        while (!found && currentIndex < bytes.Length)
        {
            if (bytes[currentIndex] == sequence[sequenceIndex])
            {
                if (sequenceIndex == (sequence.Length - 1))
                {
                    found = true;
                }
                else
                {
                    sequenceIndex++;
                }
            }
            else
            {
                currentIndex -= sequenceIndex;
                sequenceIndex = 0;
            }

            currentIndex++;
        }

        return found ? (currentIndex - sequence.Length) : -1;
    }
}

Here's an example of it's usage for PNG files.

var imageHeaderStart = new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00 };

var imageEOF = new byte[] { 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 };

var matches = BinarySearch.Match(binaryData, imageHeaderStart, imageEOF);

I'll add a link to the Github project upon it's completion in case anyone is interested in my 'complete' implementation.