elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (Moderadores: Novlucker, seba123neo, kub0x, Eleкtro)
| | | |-+  Modificar el array de byte[]
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Modificar el array de byte[]  (Leído 587 veces)
Meta


Desconectado Desconectado

Mensajes: 2.915



Ver Perfil WWW
Modificar el array de byte[]
« en: 30 Diciembre 2016, 02:42 »

Hola:

Tengo hecho un mini programa en consola C#.
Código
  1. using System;
  2. using System.IO; // No olvidar.
  3. using System.Diagnostics;
  4.  
  5. namespace Byte_Hex_ocultos_2
  6. {
  7.    class Program
  8.    {
  9.  
  10.        byte[] rawData = {
  11.    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
  12.    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
  13. };
  14.  
  15. static void Main(string[] args)
  16.        {
  17.            Console.Title = "Imagen oculto.";
  18.            new Program();
  19.        }
  20.  
  21.        public Program()
  22.        {
  23.            Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
  24.            File.WriteAllBytes("fotón.jpg", rawData);
  25.            Console.WriteLine("¡Hecho! ¿Deseas ver la foto? Sí / No");
  26.            string input = Console.ReadLine();
  27.  
  28.            if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
  29.                (input == "Sí".ToLower()) || (input == "S".ToLower()))
  30.            {
  31.                Console.WriteLine("Mostrando imagen...");
  32.                Process.Start("fotón.jpg");
  33.                Console.WriteLine("Imagen cargada.");
  34.            }
  35.  
  36.            else
  37.            {
  38.                Console.WriteLine("Saliendo...");
  39.            }
  40.        }
  41.    }
  42. }

Justo abajo hay un array tipo byte[] indicaco justo abajo.
Código
  1. byte[] rawData = {
  2.    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
  3.    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
  4. };

Estos son pocos byte para probar, en realidad pueden ser millones.
Quiero hacer de alguna manera, modificar a mi antojo cada byte[] del array, por ejemplo, hacerlo de forma básica para probar como curiosidad, lograr desplazar cada bit una vez a la derecha. Esto lo hará otro programa en C#. En el indicado arriba tiene que usar la misma fórmula pero al revés, los byte del array ahora tienen que moverlo a la izquierda una vez para que tengan su posición normal.

Así de paso no es tan fácil detectar lo que hay en el archivo de C#.

¿Alguna idea?

Les dejo el enlace de descarga del proyecto completo, solo tienes que ejecutarlo con Visual Community 2015 y pueden ver que foro tengo escondido, pueden mostrarlo por aquí si les pica la atención.

Descargar

Felices fiestas 2016.


« Última modificación: 30 Diciembre 2016, 02:46 por Meta » En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
crack81

Desconectado Desconectado

Mensajes: 218



Ver Perfil
Re: Modificar el array de byte[]
« Respuesta #1 en: 30 Diciembre 2016, 03:48 »

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".

Bueno si eso o alguna otra a mi me da igual  :xD
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
  1. for (int i = 0; i < rawData.Length; i++)
  2. {
  3.    rawData[i] = (byte)(rawData[i] ^ 10);
  4. }

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.



« Última modificación: 30 Diciembre 2016, 03:51 por crack81 » En línea

Si C/C++ es el padre de los lenguajes entonces ASM es dios.
Meta


Desconectado Desconectado

Mensajes: 2.915



Ver Perfil WWW
Re: Modificar el array de byte[]
« Respuesta #2 en: 30 Diciembre 2016, 04:43 »

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  :xD
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
  1. for (int i = 0; i < rawData.Length; i++)
  2. {
  3.    rawData[i] = (byte)(rawData[i] ^ 10);
  4. }

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.



Muy buena lo del XOR. Quiero hacerlo al revés con tu código.
¿Cómo sería?

El programa me funciona tal como me lo haz contado.
Código
  1. using System;
  2. using System.IO; // No olvidar.
  3.  
  4. namespace Byte_Hex_ocultos_6
  5. {
  6.    class Program
  7.    {
  8. byte[] rawData = {
  9.    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
  10.    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43
  11. };        
  12. static void Main(string[] args)
  13.        {
  14.            Console.Title = "Imagen oculto.";
  15.            Program variable = new Program();
  16.            variable.Cosas();
  17.        }
  18.  
  19.        public void Cosas()
  20.        {
  21.            Console.WriteLine("Escribiendo archivo desde el arreglo de bytes");
  22.            // ##############################################
  23.  
  24.            for (int i = 0; i < rawData.Length; i++)
  25.            {
  26.                rawData[i] = (byte)(rawData[i] ^ 10);
  27.            }
  28.  
  29.            // ##############################################
  30.            File.WriteAllBytes("fot&#243;n.jpg", rawData); // Crea un archivo nuevo.
  31.            Console.WriteLine("&#161;Hecho! &#191;Deseas ver la foto? S&#237; / No");
  32.            string input = Console.ReadLine();
  33.  
  34.            if ((input == "Yes".ToLower()) || (input == "Y".ToLower()) ||
  35.                (input == "S&#237;".ToLower()) || (input == "S".ToLower()))
  36.            {
  37.                Console.WriteLine("Mostrando imagen...");
  38.                //Process.Start("fot&#243;n.jpg");
  39. File.WriteAllBytes("fot&#243;n.jpg", rawData_XOR10); // Crea un archivo nuevo.
  40.                Console.WriteLine("Imagen cargada.");
  41.            }
  42.  
  43.            else
  44.            {
  45.                Console.WriteLine("Saliendo...");
  46.            }
  47.        }
  48.    }
  49. }


He puesto otra variable con elXOR 10 ya codificado en vez de poner la original, la foto,claro. Ya sería.
Código
  1. byte[] rawData_XOR10 = {
  2.    0xF5, 0xD2, 0xF5, 0xEA, 0x0A, 0x1A, 0x40, 0x4C, 0x43, 0x4C, 0x0A, 0x0B,
  3.    0x0B, 0x0B, 0x0A, 0x42, 0x0A, 0x42, 0x0A, 0x0A, 0xF5, 0xD1, 0x0A, 0x49,

Quiero probar el efecto contario, si no me equivoco..
Código
  1.    for (int i = 0; i < rawData_XOR10.Length; i++)
  2.    {
  3.        rawData_XOR10[i] = (byte)(rawData_XOR10[i] ^ -10);
  4.    }

Lo de desplazamiento de byte tienes que tener en cuenta el bit de acarreo, por eso pasa lo que dices. No es lo mismo (0)11111111 que al desplazar un bit a la derecha (1)01111111. Es más complejo de lo que aparenta porque cada byte con su bit de acarreo y programarlo es más complicado de lo que uno pienza. Estoy acostumbrado al asm de los PIC.

Estoy haciendo pruebas gracias a ti y aprendiendo. ;)

Para curiosos.
https://msdn.microsoft.com/es-es/library/zkacc7k1.aspx
https://www.youtube.com/watch?v=tPfTZbEzcmM

Felices fiestas.
« Última modificación: 30 Diciembre 2016, 05:21 por Meta » En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
crack81

Desconectado Desconectado

Mensajes: 218



Ver Perfil
Re: Modificar el array de byte[]
« Respuesta #3 en: 30 Diciembre 2016, 05:57 »

Hola a lo mejor no me he sabido explicar bien, cuando usas xor 10 no es necesario poner xor -10 basta con volver a poner xor 10 para hacer efecto.

Revista la documentacion sobre el operador xor https://es.wikipedia.org/wiki/Disyunci%C3%B3n_exclusiva aplica para cuaquier lenguaje de programacion

Ejemplo
Supongamos que usamos la letra A  el equivalente numerico en la tabla ASCII es el 65 cuando usamos el XOR lo que estamos haciendo es es convertir ese 65 a binario el cual seria

01000001

si le aplicamos el XOR 10 lo que estariamos haciendo seria esto

01000001  ===> 65
00001010  ===> 10
------------
01001011  ===> el cual seria el numero 11

ese 11 seria el numero "cifrado" si quisieramos obtener el valor original valdria tomar el equivalente del 11 en binario y volver a aplicar el XOR 10

01001011   ===>11
00001010   ===>10
-------------
01000001 ===== Nos regresa el 65 ===> A

si te fijas nos regreso el valor original


Esto mismo aplicalo a arreglo de bytes o string  que al final siguen siendo numeros y tiene un funcionamiento similar


Tablas ASCII http://www.elcodigoascii.com.ar/
Aqui un ejemplo mas detallado sobre los operadores de bit http://www.conoce3000.com/html/espaniol/Libros/PascalConFreePascal/Cap03-06-Operadores%20para%20digitos%20binarios%20(bits%20-%20digitos%20binarios).php        

cabe aclarar que esta orientado al lenguaje Object Pascal pero la teoria aplica para cualquier lenguaje.








« Última modificación: 30 Diciembre 2016, 06:07 por crack81 » En línea

Si C/C++ es el padre de los lenguajes entonces ASM es dios.
Meta


Desconectado Desconectado

Mensajes: 2.915



Ver Perfil WWW
Re: Modificar el array de byte[]
« Respuesta #4 en: 30 Diciembre 2016, 07:21 »

Buenas:

Muy buena explicación. Funciona a la perfección.

Muchas gracias mi muy distinguido amigo. ;)
« Última modificación: 31 Diciembre 2016, 03:04 por Meta » En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Meta


Desconectado Desconectado

Mensajes: 2.915



Ver Perfil WWW
Re: Modificar el array de byte[]
« Respuesta #5 en: 14 Enero 2017, 12:46 »

Hola de nuevo:

Urgando en mi grupo de amigos con esto.
Código
  1.    for (int i = 0; i < rawData.Length; i++)
  2.    {
  3.        rawData[i] = (byte)(rawData[i] ^ 10);
  4.    }

En el cual estoy agradecido porque funciona de maravilla. Si hago un programa para cifrar de C# una foto, usando el mismo efecto puede desemcriptarlo.

  • Hago tres programas de C#.
  • Programa 1 de C# para cifrar cualquier archivo, es este caso una imagen.
  • Meto la escriptación en el .hex de Arduino ya explicado atrás.
  • Programa 2 de C# capturo los datos de Arduino por el puerto serie/USB.
  • Programa 3 de C# lo desemcripta.

Cuidado una cosa, al menos no he caido antes y lo comento por aquí mismo. ;)
Si cifra una imagen con el programa 1 de C#, lo cifra, si lo vuelve hacer, se descompila y se recupera la imagen. MEnudo fallo y no me di cuenta.
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Meta


Desconectado Desconectado

Mensajes: 2.915



Ver Perfil WWW
Re: Modificar el array de byte[]
« Respuesta #6 en: 15 Marzo 2017, 10:40 »

Hola de nuevo:

He hecho este programa. Arduino ulsa un botón y este programa de C# lo descodifica como dijeron arriba. Como puedes ver, el archivo viene desde Arduino por el puerto serie/USB.

¿Existe la manera de usar la descodificación de la foto?

C#:
Código
  1. using System;
  2. using System.Text;
  3. using System.IO.Ports;
  4. using System.IO;
  5. using System.Diagnostics;
  6. using System.Threading;
  7.  
  8. namespace Recibir_archivo_desde_Arduino_consola_06
  9. {
  10.    class Program
  11.    {
  12.        static int cantidadBytes;
  13.        static StringBuilder sb = new StringBuilder();
  14.  
  15.        static void Main(string[] args)
  16.        {
  17.            string COM = "";
  18.  
  19.            // Tamaño ventana consola.
  20.            Console.WindowWidth = 55; // X. Ancho.
  21.            Console.WindowHeight = 18; // Y. Alto.
  22.            Console.Title = "Recoger foto desde Arduino y crearlo en el disco duro"; // Título de la ventana.
  23.  
  24.            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
  25.            SerialPort Puerto_serie = new SerialPort();
  26.  
  27.            // Configuración.
  28.            Console.Write(@"
  29. Introduzca un número para seleccionar puerto COM.
  30. Por ejemplo el 4, sería COM4.
  31.  
  32. Puerto: ");
  33.            COM = Console.ReadLine(); // Escribir el número del puerto.
  34.            Console.Clear();
  35.  
  36.            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
  37.  
  38.  
  39.            Puerto_serie.BaudRate = 115200; // Baudios. 115200.
  40.            Puerto_serie.Parity = Parity.None; // Paridad.
  41.            Puerto_serie.DataBits = 8; // Bits de datos.
  42.            Puerto_serie.StopBits = StopBits.One; // Bits de parada.
  43.            Puerto_serie.Handshake = Handshake.None; // Control de flujo.
  44.  
  45.            // Establecer la lectura / escritura de los tiempos de espera.
  46.            Puerto_serie.ReadTimeout = -1; // 500.
  47.            Puerto_serie.WriteTimeout = -1; // 500.
  48.  
  49.            try
  50.            {
  51.                Puerto_serie.Open(); // Abrir el puerto serie.
  52.            }
  53.  
  54.            catch (IOException)
  55.            {
  56.                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
  57.                Console.CursorVisible = false;
  58.                Console.SetCursorPosition(16, 6);
  59.                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
  60.                o no lo encuentra.");
  61.                Console.ReadKey(); // Pulse cualquier tecla para salir.
  62.            }
  63.  
  64.            catch (UnauthorizedAccessException e)
  65.            {
  66.                Console.WriteLine(e);
  67.            }
  68.            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
  69.  
  70.            Console.WriteLine("Esperando datos desde Arduino... \n");
  71.            Console.ReadKey();
  72.            Puerto_serie.Close(); // Cerrar puerto.
  73.        }
  74.  
  75.        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
  76.        {
  77.            try
  78.            {
  79.                SerialPort sp = (SerialPort)sender;
  80.                string indata = sp.ReadExisting();
  81.                string[] data = indata.Split('A');
  82.                cantidadBytes = int.Parse(data[0]);
  83.  
  84.  
  85.                switch (data[1].ToString())
  86.                {
  87.                    case "1":
  88.                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
  89.                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: JPG");
  90.                        break;
  91.  
  92.                    case "2":
  93.                        Console.WriteLine("Tamaño: " + cantidadBytes + " Bytes.");
  94.                        Console.WriteLine("Foto: " + data[1] + ". Tipo de archivo: PNG.");
  95.                        break;
  96.  
  97.                    default:
  98.                        Console.WriteLine("Cosas raras en 'data': " + data.ToString()); // Por si hal algún error.
  99.                        break;
  100.                }
  101.  
  102.                int contador = 0;
  103.                byte[] datosArray = new byte[cantidadBytes];
  104.  
  105.                //byte[] miBuffer = Encoding.ASCII.GetBytes("OK1");
  106.                //sp.Write(miBuffer, 0, miBuffer.Length); // Envía OK1 a Arduino.
  107.  
  108.                switch (indata)
  109.                {
  110.                    case "17729A1":
  111.                        Thread.Sleep(100); // Retardo.
  112.                        byte[] miBuffer = Encoding.ASCII.GetBytes("OK1"); // Codificación ASCII.
  113.                        sp.Write(miBuffer, 0, miBuffer.Length); // Envía OK1 al puerto serie.
  114.                        break;
  115.  
  116.                    case "2065A2":
  117.                        Thread.Sleep(100); // Retardo.
  118.                        byte[] miBuffer2 = Encoding.ASCII.GetBytes("OK2"); // Codificación ASCII.
  119.                        sp.Write(miBuffer2, 0, miBuffer2.Length); // Envía OK2 al puerto serie.
  120.                        break;
  121.  
  122.                    default:
  123.                        Console.WriteLine("Cosas raras en 'indata': " + indata.ToString()); // Por si hal algún error.
  124.                        break;
  125.                }
  126.  
  127.                while (true)
  128.                {
  129.  
  130.                    contador += sp.Read(datosArray, contador, datosArray.Length - contador);
  131.  
  132.                    Console.SetCursorPosition(10, 6);
  133.                    Console.Write("Datos recibidos:  {0}", contador + " Bytes.");
  134.                    Console.WriteLine("                   ");
  135.  
  136.                    if ((contador == cantidadBytes) && (contador == 17729))
  137.                    {
  138.                        Mensaje1();
  139.                        File.WriteAllBytes("fotón.jpg", datosArray); // Crear archivo en el disco duro.
  140.                        Mensaje2();
  141.                        Process.Start("fotón.jpg"); // Ejecutar visualizador de imágenes.
  142.                        Mensaje3();
  143.                        break; // Garantiza que el ciclo termine.
  144.                    }
  145.  
  146.                    if ((contador == cantidadBytes) && (contador == 2065))
  147.                    {
  148.                        Mensaje1();
  149.                        File.WriteAllBytes("fotón.png", datosArray); // Crear archivo en el disco duro.
  150.                        Mensaje2();
  151.                        Process.Start("fotón.png"); // Ejecutar visualizador de imágenes.
  152.                        Mensaje3();
  153.                        break; // Garantiza que el ciclo termine.
  154.                    }
  155.                }
  156.  
  157.                void Mensaje1()
  158.                {
  159.                    Console.WriteLine();
  160.                    Console.WriteLine("Creando archivo al disco duro...");
  161.                }
  162.  
  163.                void Mensaje2()
  164.                {
  165.                    Console.WriteLine();
  166.                    Console.WriteLine("Archivo creado. Ejecutando imagen.");
  167.                }
  168.  
  169.                void Mensaje3()
  170.                {
  171.                    Console.WriteLine();
  172.                    Console.WriteLine("Imagen ejecutada.");
  173.                    Console.WriteLine();
  174.                    Console.WriteLine("Cabecera recibida: " + indata + "\n");
  175.                    Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
  176.                    Console.WriteLine("FIN DE PROGRAMA.");
  177.                    Console.ForegroundColor = ConsoleColor.Gray; // Letras grises otra vez.
  178.                }
  179.            }
  180.  
  181.            catch (FormatException)
  182.            {
  183.                // System.FormatException: 'La cadena de entrada no tiene el formato correcto.'
  184.            }
  185.        }
  186.    }
  187. }
  188.  

Saludos.
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
->Duda Con Array Of Byte
Programación Visual Basic
NsTeam 1 1,114 Último mensaje 8 Julio 2009, 04:34
por LeandroA
ayuda con code de visual basic array byte a hexa « 1 2 »
Programación Visual Basic
Fucko 10 2,962 Último mensaje 15 Junio 2011, 06:09
por Fucko
Ejecución desde un byte array
Análisis y Diseño de Malware
xoftfox 3 1,248 Último mensaje 9 Febrero 2014, 21:40
por Yoel Alejandro
es posible concatenar un array byte? « 1 2 »
Programación C/C++
Belial & Grimoire 14 2,684 Último mensaje 15 Febrero 2014, 18:58
por x64core
Una mano con este codigo. (array de byte dinamico)
.NET
70N1 4 988 Último mensaje 23 Septiembre 2014, 13:37
por Eleкtro
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines