Foro de elhacker.net

1.  Hola bueno lo que necesito es simple, Quiero tomar un fichero binario y transformarlo en texto... luego cuando tengo el texto quiero transformarlo a exe.

2.  Quisiera saber también como leer este fichero en Binario.

tomar un fichero en binario y volverlo a texto? no tiene sentido, pero si quieres hacerlo, agarras el binario, buscas un sistema de texto (por ejemplo ascii), sabiendo que ascii es 1 byte por letra, lees el byte y lo pasas a su valor char como hace notepad...

de texto transformarlo a .exe no tiene sentido ya....

como leer el fichero en binario, puedes usar programas como ollydbg o algun editor/lector hexadecimal...

Claro que tiene mucho sentido, para lo que estoy realizando. Eso busco. pero digamos cuando leo el archivo y lo paso a texto pasa que se pierden bytes o algo. y no pesa igual que el archivo exe entonces mi duda es.... Si esto se puede realizar es que lo necesito urgente! voy a intentar con algunos código en internet si conoces alguna fuente puedes pasarme la por favor

explicame lo que haces porque no tiene sentido XD

no, no se pierden bytes... es una conversion directa y exacta por ejemplo si el byte es 41(hex) eso se verá como una "A" en texto... pero como el archivo no está diseñado para ser visto como texto tendrás muchos simbolos raros.... (intenta agarrar un .exe pequeño, de unos pocos kb y cambiarle la extension a .txt para que veas que no tiene ningún tipo de sentido)

la cosa es que ese texto contiene exactamente lo mismo que el archivo, solo que tu lo estás visualizando como texto y no corriendo como ejecutable... así que con cambiarle a .exe basta para que sea nuevamente ejecutable

Vamos a aclarar conceptos.

Un carácter ocupa 8 bits.... o un byte... esto nos da 256 combinaciones posibles. Un archivo binario simplemente almacena información utilizando el catálogo completo de 256 combinaciones. Es un archivo que no puede ser leído por una persona. Nuestro alfabeto no tiene 256 caracteres... además este formato es dependiente de la máquina.

Un archivo de texto reduce el espectro de caracteres a utilizar, además procura almacenar la información de tal forma que pueda ser leída con más o menos facilidad por cualquiera que lo abra. Normalmente la información almacenada en estos archivos es independiente de la máquina que los genere.

Un archivo de texto no deja de ser, por tanto, un archivo binario que utiliza un espectro reducido de caracteres para ser más legible... por tanto no hay una conversión directa entre un archivo binario y uno de texto.

Un ejecutable no es sino un conjunto de instrucciones interpretables por la máquina y sistema operativo correspondientes. Esta información es dependiente tanto de la máquina como del sistema operativo.

Como es de entender no hay una relación clara de conversión entre los 3 formatos.

Me da la sensación de que no tienes muy claro qué es lo que quieres conseguir.

Como ya te dijeron si quieres leer un ejecutable en plano es una tontería pasarlo a texto. Quizás te interese buscar sobre desensambladores, hay programas que en algunos lenguajes son capaces de conseguir el código fuente del programa. También hay programas que sacan las strings del programa omitiendo todo lo que es la parte de código.

Saludos

Y no sera algo como esto lo que busca:
http://www.elhacker.net/base64.html

Ok gracias a todos;

Para mi si tiene sentido pasarlo a texto.
No necesito des ensamblarlo.

Voy a realizar pruebas en mi LAB y voy a traer código

si, eso pensaba... capaz que esté buscando algún tipo de des-ofuscador... sino realmente no es muy entendible jejej

me vino a la memoria el norton comander (o la excelente versión creada para linux el midnight comander, creo que es el primera cosa que instalo apenas levanto la red!)

quien no habrá mirado un ejecutable y cambiar de ascii a hex con f4 no? jajajaa

esperemos que nos dé más datos sobre que busca, si ya sabe lo que busca, saludos!

Si lo que necesitas es mostrar los valores enteros/Hex a representacion de cadena y escribirlos en un txt entonces puede usar
sprint en un bucle para cada entero/hex.

Listo mire tengo este código simple:

#include<stdio.h>
 
int main(){
	FILE *file;
	unsigned char buffer;
 
	//file = fopen("Prueba.txt","r+");
	file = fopen("HolaMundo.exe","r+");
	if(file!=NULL){
		//printf("Archivo Abierto con exito.");
		//fread(&buffer,1,1,file);
		//printf("%c",buffer);
 
			int linea = 1;
			while (fread(&buffer, 1, 1, file) == 1) // expecting 1 
																 // element of size
																 // BUFFER_SIZE
			{
				// process buffer
 
				// print format
				if(linea>=1 && linea<=8)
					printf(" %c",buffer);
				if(linea==8)
					printf(" - ");
				if(linea>=9 && linea<=15)
					printf(" %c",buffer);
				if(linea==16){
					printf("\n");
					linea=0;
				}
				linea++;
			}
			if (feof(file))
			{
			  // hit end of file
			}
			else
			{
			  // some other error interrupted read
			}
 
 
 
		fclose(file);
	}else{
		printf("Apertura del Fichero no fue exitosa.");
	}
 
	getchar();
	return 0;
}
 

Bueno el código expuesto puede leer archivos de texto plano y los va a leer perfectamente. ya lo probé.

A la hora de leer un archivo *.exe tengo el pequeño que lo lee mal.
(http://s14.postimg.org/tbxbmr9pd/Output.png)

Como pueden ver es absurda la salida, si pueden leer en la salida se puede leer algo como:
This program can be run in dos mode
Este programa puede ser corrido en dos modo


Pero cuando lo abro con notepad++ y lo guardo como txt si realizo lo que necesito,  el problema es que no necesito abrirlo con notepad++ sino necesito hacer un programa que lo haga...


NOTA: que se parece absurdo transformar un exe a texto. pero es que realmente lo necesito.

La salida esta bien, así es como son representados los caracteres en ANSI-ASCII.
Los ejecutable no tiene nada que ver con la codificacion de caracteres. Podes abrir algun ejecutable con un editor hexadecimal
y se mostrara la representación en hexadecimal y la codificación que tenga establecida generalmente ANSI-ASCII. para hacerlo
así como ellos podes usar sprintf pasando byte por byte.

¡Buenas!

No intentes utilizar la función feof para saber si has llegado al final de un archivo binario. Te puede dar falsos positivos, y la mayor parte de las veces te los dará (no me preguntes porqué), y no podrás leer el contenido del archivo.

Primero tienes que saber el tamaño, en bytes, del fichero (utilizando por ejemplo ftell y fseek), y luego empiezas a leer datos desde el principio hasta alcanzar el numero de bytes que tenga el fichero.

Si no conoces las fuciónes anteriores en www.cplusplus.com encontraras mas información.

¡Saludos!

La salida esta mal ya que no representa lo que necesito, estoy viendo el mismo contenido del "exe" en el notepad++

También se hex y binario, y ASCII code

Se lo que necesito pero no se como hacerlo.



Gracias por tu información voy hacer la prueba de lo que me dices!! Muchas gracias!!

Como ya te comentaron un archivo es una secuencia de bytes, imprimir el valor de cada uno literalmente (65, 97, etc. en base 10 o cualquier otra base) o como un carácter de algún juego de caracteres (por ejemplo en ASCII A, a, etc.) es cuestión del usuario.


En el caso de C basta con abrir el archivo en modo binario "rb" y leer los caracteres con funciónes como fread, fgetc, etc. pero no estoy seguro si eso es lo que buscas.

Con todo un ejemplo sencillo (un "poor man's hex viewer") en C:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
 
#define NOM_ACHIVO  "main.exe"
#define NUM_COLS  16
 
int main(void)
{
   FILE *in;
   unsigned char ch[NUM_COLS];
   size_t nc;
   size_t i;
 
   if ((in = fopen(NOM_ACHIVO, "rb")) == NULL){
      perror(NOM_ACHIVO);
      return EXIT_FAILURE;
   }
 
   while ((nc = fread(ch, 1, NUM_COLS, in)) != 0){
      for (i = 0; i < NUM_COLS; i++)
         if (i < nc)
            printf(" %02x", ch[i]);
         else
            printf("   ");
 
      printf("  |  ");
 
      for (i = 0; i < nc; i++)
         if (ispunct(ch[i]) || isalnum(ch[i]))
            putchar(ch[i]);
         else
            putchar(' ');
 
      printf("  |\n");
   }
   fclose(in);
 
   return EXIT_SUCCESS;
}

La idea es imprimir valores hexadecimales (lo usual) y también como texto (cuando sea posible).

Un saludo

Gracias por publicar tu código: rir3760
Gracias la ayuda brindada me ayudo a resolver el problema: do-while

Ya tengo mi solución también, para quien la necesite:

#include<stdio.h>
 
int main(){
	FILE * pFile;
	FILE * newFile;
	long size;
 
	pFile = fopen ("Hola.exe","rb");
	newFile = fopen("EXE.exe","w+b");
 
	if (pFile==NULL && newFile==NULL) perror ("Error opening file");
	else
	{
		printf("Leyendo archivo\n");
		fseek ( pFile , 0 , SEEK_END );
		size=ftell (pFile);
		printf("Total de bytes: %d\n",size);
 
		fseek ( pFile , 0 , SEEK_SET );
		unsigned char buffer;
		for(int i = 0; i < size ; i++ ){
			fread(&buffer,1,1,pFile);
			//printf("%c",buffer);
			fwrite(&buffer, 1, sizeof(buffer), newFile);
		}
 
	}
 
	fclose (pFile);
	getchar();
	return 0;
}
 

hola <<<-Underwar->>> no te tira error de segmentación? también veo que debería haber un warning por la variable size, fue declarado long int pero lo visualizas como entero (línea 17)

saludos

La respuesta es no. Que compilador estas usando ??

Nota: Falta cerrar el Fichero: newFile

fclose (newFile);

 solo miré el código, pero en g++ lo deberías visualizar como %li.; si justamente por la falta del cierre de newfile es que te preguntaba si no te tiraba error. saludos

Depende del sistema que se este usando pero:
int     : 4 bytes
long   : 4 bytes

En lo mas profundo son siempre lo mismo

Debes cambiar la condicion del if:

if (pFile==NULL && newFile==NULL)
   perror ("Error opening file");

Ya que el mensaje de error solo se presentara si la apertura de ambos archivos falla (se debe sustituir "&&" por "||").

Y si piensas leer caracter por caracter puedes utilizar las funciones fgetc y fputc. Por ejemplo:

#include <stdio.h>
 
int main(void)
{
   FILE * pFile;
   FILE * newFile;
   int ch;
 
   if ((pFile = fopen("Hola.exe", "rb")) == NULL)
      perror("Hola.exe");
   else if ((newFile = fopen("EXE.exe", "wb")) == NULL)
      perror("EXE.exe");
   else
      while ((ch = fgetc(pFile)) != EOF)
         fputc(ch, newFile);
 
   if (pFile != NULL)
      fclose(pFile);
   if (newFile != NULL) 
      fclose(newFile);
 
   return 0;
}

Sin embargo el programa lo unico que hace es una copia del archivo original, para el caso mejor utiliza una funcion cortesia del SO (en MS Windows puedes utilizar CopyFile (http://msdn.microsoft.com/en-us/library/windows/desktop/aa363851%28v=vs.85%29.aspx) y CopyFileEx).

Un saludo

Gracias: rir3760, Tu solución también funciona.

No estoy buscando crear una copia del archivo original.