using System;
using System.IO; // No olvidar.
using System.Diagnostics;
 
namespace Byte_Hex_ocultos_2
{
    class Program
    {
 
        byte[] rawData = {
    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};
 
static void Main(string[] args)
        {
            Console.Title = "Imagen oculto.";
            new Program();
        }
 
        public Program()
        {
            Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
            File.WriteAllBytes("fotón.jpg", rawData);
            Console.WriteLine("¡Hecho! ¿Deseas ver la foto? Sí / No");
            string input = Console.ReadLine();
 
            if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
                (input == "Sí".ToLower()) || (input == "S".ToLower()))
            {
                Console.WriteLine("Mostrando imagen...");
                Process.Start("fotón.jpg");
                Console.WriteLine("Imagen cargada.");
            }
 
            else
            {
                Console.WriteLine("Saliendo...");
            }
        }
    }
}

byte[] rawData = {
    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};

Para mi que tu quieres guardar malware o alguna cosa rara en tu programa y parace  te estas haciendo una especie de shellcode para guardarlos y que estén cifrados  o alguna cosa rara  y descifrarlos  en tiempo de ejecución de tu "programa".

Que risas cogí.  Curiosidad como se hace, para lo que sospechas, hay ya hechos de forma fácil y muy eficiente.
Eso si, quiero ocultar información dentro de otra información, nada de malware o lo que se te pase por la cabeza.

Bueno si eso o alguna otra a mi me da igual 
Una alternativa "simple" es que le aplicas un xor a todo ese arreglo de bits y ya cuando lo quieres "descifrar" se lo vuelves a aplicar

Supongamos que a tu arreglo originalmente le aplicaste un xor 10 pues bastaria con le volvieras a aplicar ese xor 10  asi:

Código

for (int i = 0; i < rawData.Length; i++)
{
    rawData[i] = (byte)(rawData[i] ^ 10);
}

Asi tu archivo o imagen seria restaurado a su estado original, quien tenga duda de la foto vea este enlace: https://i.gyazo.com/6762c171d0871999e12d04c5b627df69.png

PD: Aplicar desplazamiento de bit sin cuidado va a terminar dejando el archivo corrupto aunque se aplique el desplazamiento inverso.

using System;
using System.IO; // No olvidar.
 
namespace Byte_Hex_ocultos_6
{
    class Program
    {
byte[] rawData = {
    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
};        
static void Main(string[] args)
        {
            Console.Title = "Imagen oculto.";
            Program variable = new Program();
            variable.Cosas();
        }
 
        public void Cosas()
        {
            Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
            // ##############################################
 
            for (int i = 0; i < rawData.Length; i++)
            {
                rawData[i] = (byte)(rawData[i] ^ 10);
            }
 
            // ##############################################
            File.WriteAllBytes("fot&#243;n.jpg", rawData); // Crea un archivo nuevo.
            Console.WriteLine("&#161;Hecho! &#191;Deseas ver la foto? S&#237; / No");
            string input = Console.ReadLine();
 
            if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
                (input == "S&#237;".ToLower()) || (input == "S".ToLower()))
            {
                Console.WriteLine("Mostrando imagen...");
                //Process.Start("fot&#243;n.jpg");
File.WriteAllBytes("fot&#243;n.jpg", rawData_XOR10); // Crea un archivo nuevo.
                Console.WriteLine("Imagen cargada.");
            }
 
            else
            {
                Console.WriteLine("Saliendo...");
            }
        }
    }
}

byte[] rawData_XOR10 = {
    0xF5, 0xD2, 0xF5, 0xEA, 0x0A, 0x1A, 0x40, 0x4C, 0x43, 0x4C, 0x0A, 0x0B,
    0x0B, 0x0B, 0x0A, 0x42, 0x0A, 0x42, 0x0A, 0x0A, 0xF5, 0xD1, 0x0A, 0x49,

    for (int i = 0; i < rawData_XOR10.Length; i++)
    {
        rawData_XOR10[i] = (byte)(rawData_XOR10[i] ^ -10);
    }

using System;
using System.Text;
using System.IO.Ports;
using System.IO;
using System.Diagnostics;
using System.Threading;
 
namespace Recibir_archivo_desde_Arduino_consola_06
{
    class Program
    {
        static int cantidadBytes;
        static StringBuilder sb = new StringBuilder();
 
        static void Main(string[] args)
        {
            string COM = "";
 
            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X. Ancho.
            Console.WindowHeight = 18; // Y. Alto.
            Console.Title = "Recoger foto desde Arduino y crearlo en el disco duro"; // Título de la ventana.
 
            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort();
 
            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.
 
Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();
 
            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
 
 
            Puerto_serie.BaudRate = 115200; // Baudios. 115200.
            Puerto_serie.Parity = Parity.None; // Paridad.
            Puerto_serie.DataBits = 8; // Bits de datos.
            Puerto_serie.StopBits = StopBits.One; // Bits de parada.
            Puerto_serie.Handshake = Handshake.None; // Control de flujo.
 
            // Establecer la lectura / escritura de los tiempos de espera.
            Puerto_serie.ReadTimeout = -1; // 500.
            Puerto_serie.WriteTimeout = -1; // 500.
 
            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }
 
            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }
 
            catch (UnauthorizedAccessException e)
            {
                Console.WriteLine(e);
            }
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
 
            Console.WriteLine("Esperando datos desde Arduino... \n");
            Console.ReadKey();
            Puerto_serie.Close(); // Cerrar puerto.
        }
 
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                SerialPort sp = (SerialPort)sender;
                string indata = sp.ReadExisting();
                string[] data = indata.Split('A');
                cantidadBytes = int.Parse(data[0]);
 
 
                switch (data[1].ToString())
                {
                    case "1":
                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: JPG");
                        break;
 
                    case "2":
                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: PNG.");
                        break;
 
                    default:
                        Console.WriteLine("Cosas raras en 'data': " + data.ToString()); // Por si hal algún error.
                        break;
                }
 
                int contador = 0;
                byte[] datosArray = new byte[cantidadBytes];
 
                //byte[] miBuffer = Encoding.ASCII.GetBytes("OK1");
                //sp.Write(miBuffer, 0, miBuffer.Length); // Envía OK1 a Arduino.
 
                switch (indata)
                {
                    case "17729A1":
                        Thread.Sleep(100); // Retardo.
                        byte[] miBuffer = Encoding.ASCII.GetBytes("OK1"); // Codificación ASCII.
                        sp.Write(miBuffer, 0, miBuffer.Length); // Envía OK1 al puerto serie.
                        break;
 
                    case "2065A2":
                        Thread.Sleep(100); // Retardo.
                        byte[] miBuffer2 = Encoding.ASCII.GetBytes("OK2"); // Codificación ASCII.
                        sp.Write(miBuffer2, 0, miBuffer2.Length); // Envía OK2 al puerto serie.
                        break;
 
                    default:
                        Console.WriteLine("Cosas raras en 'indata': " + indata.ToString()); // Por si hal algún error.
                        break;
                }
 
                while (true)
                {
 
                    contador += sp.Read(datosArray, contador, datosArray.Length - contador);
 
                    Console.SetCursorPosition(10, 6);
                    Console.Write("Datos recibidos:  {0}", contador + " Bytes.");
                    Console.WriteLine("                   ");
 
                    if ((contador == cantidadBytes) && (contador == 17729))
                    {
                        Mensaje1();
                        File.WriteAllBytes("fotón.jpg", datosArray); // Crear archivo en el disco duro.
                        Mensaje2();
                        Process.Start("fotón.jpg"); // Ejecutar visualizador de imágenes.
                        Mensaje3();
                        break; // Garantiza que el ciclo termine.
                    }
 
                    if ((contador == cantidadBytes) && (contador == 2065))
                    {
                        Mensaje1();
                        File.WriteAllBytes("fotón.png", datosArray); // Crear archivo en el disco duro.
                        Mensaje2();
                        Process.Start("fotón.png"); // Ejecutar visualizador de imágenes.
                        Mensaje3();
                        break; // Garantiza que el ciclo termine.
                    }
                }
 
                void Mensaje1()
                {
                    Console.WriteLine();
                    Console.WriteLine("Creando archivo al disco duro...");
                }
 
                void Mensaje2()
                {
                    Console.WriteLine();
                    Console.WriteLine("Archivo creado. Ejecutando imagen.");
                }
 
                void Mensaje3()
                {
                    Console.WriteLine();
                    Console.WriteLine("Imagen ejecutada.");
                    Console.WriteLine();
                    Console.WriteLine("Cabecera recibida: " + indata + "\n");
                    Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
                    Console.WriteLine("FIN DE PROGRAMA.");
                    Console.ForegroundColor = ConsoleColor.Gray; // Letras grises otra vez.
                }
            }
 
            catch (FormatException)
            {
                // System.FormatException: 'La cadena de entrada no tiene el formato correcto.'
            }
        }
    }
}