Поиск и изменение HEX в файле

FileStream fs = new FileStream("1.dll", FileMode.Open);
            int hexIn;
            String hex="";
            
          
            for (int i = 0; (hexIn = fs.ReadByte()) != -1; i++)
            {   
                    hex += string.Format("{0:X2}", hexIn);
            }

public static byte[] StringToByteArray(string hex)
        {
            return Enumerable.Range(0, hex.Length)
                             .Where(x => x % 2 == 0)
                             .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                             .ToArray();
        }

File.WriteAllBytes("2.dll", StringToByteArray(hex));

using System;
using System.Collections.Generic;
 
    internal static class FindPatterns
    {
        public static uint Find(byte[] data, byte[] patternBytes, string mask)
        {
            if ((data == null) || (data.Length == 0))
            {
                throw new ArgumentNullException("data");
            }
            if ((patternBytes == null) || (patternBytes.Length == 0))
            {
                throw new ArgumentNullException("patternBytes");
            }
            if (mask == string.Empty)
            {
                throw new ArgumentNullException("mask");
            }
            if (patternBytes.Length != mask.Length)
            {
                throw new ArgumentException("Pattern and Mask lengths must be the same.");
            }
            int length = patternBytes.Length;
            int num2 = data.Length - length;
            for (int i = 0; i < num2; i++)
            {
                bool flag = true;
                for (int j = 0; j < length; j++)
                {
                    if (((mask[j] == 'x') && (patternBytes[j] != data[i + j])) || ((mask[j] == '!') && (patternBytes[j] == data[i + j])))
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    return (uint)i;
                }
            }
            return -1;
        }
 
        public static uint[] FindAll(byte[] data, byte[] patternBytes, string mask)
        {
            List<uint> list = new List<uint>();
            for (int i = 0; i < (data.Length - patternBytes.Length); i++)
            {
                bool flag = true;
                for (int j = 0; j < patternBytes.Length; j++)
                {
                    if (((mask[j] == 'x') && (patternBytes[j] != data[i + j])) || ((mask[j] == '!') && (patternBytes[j] == data[i + j])))
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    list.Add((uint)i);
                }
            }
            return list.ToArray();
        }
    }

var data = File.ReadAllBytes(...);
uint offset = FindPatterns.Find(data, new byte[] { 0x31, 0x31, 0x33, 0x34 }, "xxxx");
// после перезаписываете в файле по найденным смещениям новые байты...
using (FileStream fStream = File.Open(path, FileMode.Open))
{
    byte[] newBytes = new byte[] { 0x31, 0x35, 0x30, 0x30 };
    fStream.Position = offset;
    fStream.Write(newBytes, 0, newBytes.Length);
}

        static void Main(string[] args)
        {
            byte[] sourceBytes = StringHexToByteArray("31313334");
            byte[] targetBytes = StringHexToByteArray("31353030");
            
            BinaryReplace("tmp.dll", sourceBytes, "tmp_patched.dll", targetBytes);
        }
 
        public static void BinaryReplace(string sourceFile, byte[] sourceSeq, string targetFile, byte[] targetSeq)
        {
            FileStream sourceStream = File.OpenRead(sourceFile);
            FileStream targetStream = File.Create(targetFile);
            
            try
            {
                int b;
                long foundSeqOffset = -1;
                int searchByteCursor = 0;
 
                while ((b=sourceStream.ReadByte()) != -1)
                {
                    if (sourceSeq[searchByteCursor] == b)
                    {
                        if (searchByteCursor == sourceSeq.Length - 1)
                        {
                            targetStream.Write(targetSeq, 0, targetSeq.Length);
                            searchByteCursor = 0;
                            foundSeqOffset = -1;
                        }
                        else 
                        {
                            if (searchByteCursor == 0)
                            {
                                foundSeqOffset = sourceStream.Position - 1;
                            }
 
                            ++searchByteCursor;
                        }
                    }
                    else
                    {
                        if (searchByteCursor == 0)
                        {
                            targetStream.WriteByte((byte) b);
                        }
                        else
                        {
                            targetStream.WriteByte(sourceSeq[0]);
                            sourceStream.Position = foundSeqOffset + 1;
                            searchByteCursor = 0;
                            foundSeqOffset = -1;
                        }
                    }
                }
            }
            finally
            {
                sourceStream.Dispose();
                targetStream.Dispose();
            }
        }
 
        public static byte[] StringHexToByteArray(String hex)
        {
            int NumberChars = hex.Length;
            byte[] bytes = new byte[NumberChars / 2];
            for (int i = 0; i < NumberChars; i += 2)
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            return bytes;
        }