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

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  cuando compilo sale virus
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: cuando compilo sale virus  (Leído 5,173 veces)
Tusanjamon

Desconectado Desconectado

Mensajes: 4


Ver Perfil
cuando compilo sale virus
« en: 29 Enero 2023, 12:04 pm »

Hola soy nuevo.

queria preguntarles si a alguno tambien le pasa o porque pasa esto:

baje un programa para descomprimir un archivo rom de ps1 o psx. poque esta en fomato .ecm
y se descomprime con unecm.exe la cosa es que tambien vino el archivo .C con el codigo y me parecio mas bueno compilarlo y usar mi propia compilacion ya que uno compilado de internet podria tener virus.

asi que baje este compilador de mingw (dicen que es un conocido compilador para linux adaptado para windows.) de Github:
https://www.virustotal.com/gui/url/5a05e85ab02931efc59efdc0b51dbadb9b00b27d96035a6987abded699b0d702?nocache=1

de paso tambien examine los dos archivos. el .exe y el C:

unecm.exe:
https://www.virustotal.com/gui/file/45f597a50d868f2fce11877f52983b2097cf6b9ac569c35122cc3fdc28d03705?nocache=1

unecm.c
https://www.virustotal.com/gui/file/f3b90e3082502bb26c9e790222ab2d1c9b3d19860b0a3442f52e87498e920f77?nocache=1

todo limpio. pero igual queria compilarlo yo XD.

listo sale el unecm.exe mio. y al pasarlo por virustotal me dice que tiene 3 virus:
https://www.virustotal.com/gui/file/433f5fc7b3ad9f1a650e898316a1e80303652e538bbbd404b59cf062df0ad5ac?nocache=1


porque?. por las dudas subi la carpeta bin del compilador con mas de 50 .exe y dll. en un zip a viurstotal por si al compilar le metían el virus pero esta limpio también:
https://www.virustotal.com/gui/file/1e5ecc7f677d7f80aac712f5fe386ecb66a7f2fc8d527f4060e10d38879e5ad7?nocache=1



dejo e codigo de unecm.C:

Código:
/***************************************************************************/
/*
** UNECM - Decoder for ECM (Error Code Modeler) format.
** Version 1.0
** Copyright (C) 2002 Neill Corlett
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
/***************************************************************************/
/*
** Portability notes:
**
** - Assumes a 32-bit or higher integer size
** - No assumptions about byte order
** - No assumptions about struct packing
** - No unaligned memory access
*/
/***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/***************************************************************************/

void banner(void) {
  fprintf(stderr,
    "UNECM - Decoder for Error Code Modeler format v1.0\n"
    "Copyright (C) 2002 Neill Corlett\n\n"
  );
}

/***************************************************************************/

/* Data types */
#define ecc_uint8 unsigned char
#define ecc_uint16 unsigned short
#define ecc_uint32 unsigned

/* LUTs used for computing ECC/EDC */
static ecc_uint8 ecc_f_lut[256];
static ecc_uint8 ecc_b_lut[256];
static ecc_uint32 edc_lut[256];

/* Init routine */
static void eccedc_init(void) {
  ecc_uint32 i, j, edc;
  for(i = 0; i < 256; i++) {
    j = (i << 1) ^ (i & 0x80 ? 0x11D : 0);
    ecc_f_lut[i] = j;
    ecc_b_lut[i ^ j] = i;
    edc = i;
    for(j = 0; j < 8; j++) edc = (edc >> 1) ^ (edc & 1 ? 0xD8018001 : 0);
    edc_lut[i] = edc;
  }
}

/***************************************************************************/
/*
** Compute EDC for a block
*/
ecc_uint32 edc_partial_computeblock(
        ecc_uint32  edc,
  const ecc_uint8  *src,
        ecc_uint16  size
) {
  while(size--) edc = (edc >> 8) ^ edc_lut[(edc ^ (*src++)) & 0xFF];
  return edc;
}

void edc_computeblock(
  const ecc_uint8  *src,
        ecc_uint16  size,
        ecc_uint8  *dest
) {
  ecc_uint32 edc = edc_partial_computeblock(0, src, size);
  dest[0] = (edc >>  0) & 0xFF;
  dest[1] = (edc >>  8) & 0xFF;
  dest[2] = (edc >> 16) & 0xFF;
  dest[3] = (edc >> 24) & 0xFF;
}

/***************************************************************************/
/*
** Compute ECC for a block (can do either P or Q)
*/
static void ecc_computeblock(
  ecc_uint8 *src,
  ecc_uint32 major_count,
  ecc_uint32 minor_count,
  ecc_uint32 major_mult,
  ecc_uint32 minor_inc,
  ecc_uint8 *dest
) {
  ecc_uint32 size = major_count * minor_count;
  ecc_uint32 major, minor;
  for(major = 0; major < major_count; major++) {
    ecc_uint32 index = (major >> 1) * major_mult + (major & 1);
    ecc_uint8 ecc_a = 0;
    ecc_uint8 ecc_b = 0;
    for(minor = 0; minor < minor_count; minor++) {
      ecc_uint8 temp = src[index];
      index += minor_inc;
      if(index >= size) index -= size;
      ecc_a ^= temp;
      ecc_b ^= temp;
      ecc_a = ecc_f_lut[ecc_a];
    }
    ecc_a = ecc_b_lut[ecc_f_lut[ecc_a] ^ ecc_b];
    dest[major              ] = ecc_a;
    dest[major + major_count] = ecc_a ^ ecc_b;
  }
}

/*
** Generate ECC P and Q codes for a block
*/
static void ecc_generate(
  ecc_uint8 *sector,
  int        zeroaddress
) {
  ecc_uint8 address[4], i;
  /* Save the address and zero it out */
  if(zeroaddress) for(i = 0; i < 4; i++) {
    address[i] = sector[12 + i];
    sector[12 + i] = 0;
  }
  /* Compute ECC P code */
  ecc_computeblock(sector + 0xC, 86, 24,  2, 86, sector + 0x81C);
  /* Compute ECC Q code */
  ecc_computeblock(sector + 0xC, 52, 43, 86, 88, sector + 0x8C8);
  /* Restore the address */
  if(zeroaddress) for(i = 0; i < 4; i++) sector[12 + i] = address[i];
}

/***************************************************************************/
/*
** Generate ECC/EDC information for a sector (must be 2352 = 0x930 bytes)
** Returns 0 on success
*/
void eccedc_generate(ecc_uint8 *sector, int type) {
  ecc_uint32 i;
  switch(type) {
  case 1: /* Mode 1 */
    /* Compute EDC */
    edc_computeblock(sector + 0x00, 0x810, sector + 0x810);
    /* Write out zero bytes */
    for(i = 0; i < 8; i++) sector[0x814 + i] = 0;
    /* Generate ECC P/Q codes */
    ecc_generate(sector, 0);
    break;
  case 2: /* Mode 2 form 1 */
    /* Compute EDC */
    edc_computeblock(sector + 0x10, 0x808, sector + 0x818);
    /* Generate ECC P/Q codes */
    ecc_generate(sector, 1);
    break;
  case 3: /* Mode 2 form 2 */
    /* Compute EDC */
    edc_computeblock(sector + 0x10, 0x91C, sector + 0x92C);
    break;
  }
}

/***************************************************************************/

unsigned mycounter;
unsigned mycounter_total;

void resetcounter(unsigned total) {
  mycounter = 0;
  mycounter_total = total;
}

void setcounter(unsigned n) {
  if((n >> 20) != (mycounter >> 20)) {
    unsigned a = (n+64)/128;
    unsigned d = (mycounter_total+64)/128;
    if(!d) d = 1;
    fprintf(stderr, "Decoding (%02d%%)\r", (100*a) / d);
  }
  mycounter = n;
}

int unecmify(
  FILE *in,
  FILE *out
) {
  unsigned checkedc = 0;
  unsigned char sector[2352];
  unsigned type;
  unsigned num;
  fseek(in, 0, SEEK_END);
  resetcounter(ftell(in));
  fseek(in, 0, SEEK_SET);
  if(
    (fgetc(in) != 'E') ||
    (fgetc(in) != 'C') ||
    (fgetc(in) != 'M') ||
    (fgetc(in) != 0x00)
  ) {
    fprintf(stderr, "Header not found!\n");
    goto corrupt;
  }
  for(;;) {
    int c = fgetc(in);
    int bits = 5;
    if(c == EOF) goto uneof;
    type = c & 3;
    num = (c >> 2) & 0x1F;
    while(c & 0x80) {
      c = fgetc(in);
      if(c == EOF) goto uneof;
      num |= ((unsigned)(c & 0x7F)) << bits;
      bits += 7;
    }
    if(num == 0xFFFFFFFF) break;
    num++;
    if(num >= 0x80000000) goto corrupt;
    if(!type) {
      while(num) {
        int b = num;
        if(b > 2352) b = 2352;
        if(fread(sector, 1, b, in) != b) goto uneof;
        checkedc = edc_partial_computeblock(checkedc, sector, b);
        fwrite(sector, 1, b, out);
        num -= b;
        setcounter(ftell(in));
      }
    } else {
      while(num--) {
        memset(sector, 0, sizeof(sector));
        memset(sector + 1, 0xFF, 10);
        switch(type) {
        case 1:
          sector[0x0F] = 0x01;
          if(fread(sector + 0x00C, 1, 0x003, in) != 0x003) goto uneof;
          if(fread(sector + 0x010, 1, 0x800, in) != 0x800) goto uneof;
          eccedc_generate(sector, 1);
          checkedc = edc_partial_computeblock(checkedc, sector, 2352);
          fwrite(sector, 2352, 1, out);
          setcounter(ftell(in));
          break;
        case 2:
          sector[0x0F] = 0x02;
          if(fread(sector + 0x014, 1, 0x804, in) != 0x804) goto uneof;
          sector[0x10] = sector[0x14];
          sector[0x11] = sector[0x15];
          sector[0x12] = sector[0x16];
          sector[0x13] = sector[0x17];
          eccedc_generate(sector, 2);
          checkedc = edc_partial_computeblock(checkedc, sector + 0x10, 2336);
          fwrite(sector + 0x10, 2336, 1, out);
          setcounter(ftell(in));
          break;
        case 3:
          sector[0x0F] = 0x02;
          if(fread(sector + 0x014, 1, 0x918, in) != 0x918) goto uneof;
          sector[0x10] = sector[0x14];
          sector[0x11] = sector[0x15];
          sector[0x12] = sector[0x16];
          sector[0x13] = sector[0x17];
          eccedc_generate(sector, 3);
          checkedc = edc_partial_computeblock(checkedc, sector + 0x10, 2336);
          fwrite(sector + 0x10, 2336, 1, out);
          setcounter(ftell(in));
          break;
        }
      }
    }
  }
  if(fread(sector, 1, 4, in) != 4) goto uneof;
  fprintf(stderr, "Decoded %ld bytes -> %ld bytes\n", ftell(in), ftell(out));
  if(
    (sector[0] != ((checkedc >>  0) & 0xFF)) ||
    (sector[1] != ((checkedc >>  8) & 0xFF)) ||
    (sector[2] != ((checkedc >> 16) & 0xFF)) ||
    (sector[3] != ((checkedc >> 24) & 0xFF))
  ) {
    fprintf(stderr, "EDC error (%08X, should be %02X%02X%02X%02X)\n",
      checkedc,
      sector[3],
      sector[2],
      sector[1],
      sector[0]
    );
    goto corrupt;
  }
  fprintf(stderr, "Done; file is OK\n");
  return 0;
uneof:
  fprintf(stderr, "Unexpected EOF!\n");
corrupt:
  fprintf(stderr, "Corrupt ECM file!\n");
  return 1;
}

/***************************************************************************/

int main(int argc, char **argv) {
  FILE *fin, *fout;
  char *infilename;
  char *outfilename;
  banner();
  /*
  ** Initialize the ECC/EDC tables
  */
  eccedc_init();
  /*
  ** Check command line
  */
  if((argc != 2) && (argc != 3)) {
    fprintf(stderr, "usage: %s ecmfile [outputfile]\n", argv[0]);
    return 1;
  }
  /*
  ** Verify that the input filename is valid
  */
  infilename = argv[1];
  if(strlen(infilename) < 5) {
    fprintf(stderr, "filename '%s' is too short\n", infilename);
    return 1;
  }
  if(strcasecmp(infilename + strlen(infilename) - 4, ".ecm")) {
    fprintf(stderr, "filename must end in .ecm\n");
    return 1;
  }
  /*
  ** Figure out what the output filename should be
  */
  if(argc == 3) {
    outfilename = argv[2];
  } else {
    outfilename = malloc(strlen(infilename) - 3);
    if(!outfilename) abort();
    memcpy(outfilename, infilename, strlen(infilename) - 4);
    outfilename[strlen(infilename) - 4] = 0;
  }
  fprintf(stderr, "Decoding %s to %s.\n", infilename, outfilename);
  /*
  ** Open both files
  */
  fin = fopen(infilename, "rb");
  if(!fin) {
    perror(infilename);
    return 1;
  }
  fout = fopen(outfilename, "wb");
  if(!fout) {
    perror(outfilename);
    fclose(fin);
    return 1;
  }
  /*
  ** Decode
  */
  unecmify(fin, fout);
  /*
  ** Close everything
  */
  fclose(fout);
  fclose(fin);
  return 0;
}

no se mucho yo pero creo que solo trabaja sobre el mismo archivo. o sea lo descomprime. tambien tengo el codigo del que comprime por si lo quieren. iba a ponerlo pero no queria desvirtuar.

entonces, esta limpio el codigo?, no le doy bola a virustotal?.
 porque uno sale limpio y el otro con virus..?

note que el .exe bajado de internet es de 7.50 KB Size. mientras el que sale cuando compilo yo:
80.87 KB Size.
y el archivo .c es de 10.39 KB Size. los compilados suelen agrandar su tamaño o achicarse?..



En línea

fary


Desconectado Desconectado

Mensajes: 1.061



Ver Perfil WWW
Re: cuando compilo sale virus
« Respuesta #1 en: 29 Enero 2023, 13:13 pm »

Los Av dan falsos positivos también, simplemente el Av te esta diciendo que ese programa hace algo que no le gusta.


En línea

Un byte a la izquierda.
Danielㅤ


Desconectado Desconectado

Mensajes: 1.667


🔵🔵🔵🔵🔵🔵🔵


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #2 en: 29 Enero 2023, 14:41 pm »

Hola, si el código fuente del exe está bien entonces cuando lo compiles a ejecutable no tendrá virus y podes estar tranquilo.

Como dice el compañero fary ese aviso del antivirus es un FP (Falso Positivo), hay cosas que los antivirus la detectan como un malware por ejemplo el uso de una librería o alguna instrucción al sistema o intento de lectura de archivos del sistema o parte del código ofuscado, etc.

En cuanto al peso del exe dependiendo del complicador si es posible porque por ejemplo un compilador no solo puede compilarlo a exe sino también que le puede aplicar compresión para que pese menos o crear un único archivo ejecutable sin los archivos dependientes dentro del mismo directorio para que sea solo el exe y esto haría que pese más porque los archivos externos estarían dentro del exe.

Otra razón por la que un antivirus te lo puede detectar como malware es porque ese exe no está firmado.


Saludos
« Última modificación: 29 Enero 2023, 14:43 pm por Danielㅤ » En línea

Tusanjamon

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #3 en: 29 Enero 2023, 16:21 pm »

le pregunte a chatGPT y me dijo esto:

Citar
Es posible que el archivo .exe compilado contenga un virus, aunque el código fuente no lo contenga. Esto puede ser causado por varias razones, como el uso de un compilador infectado o la inclusión de bibliotecas maliciosas en el proceso de compilación. Es importante asegurarse de que se está utilizando un compilador confiable y actualizado, y escanear el archivo compilado con un software antivirus antes de ejecutarlo. También es recomendable utilizar un compilador oficial y descargarlo de una fuente confiable.

nose, es mucha la diferencia de tamaño entre los dos archivos compilados.
voy a probar con otro compilador. cual me recomiendan y de donde bajarlo..?
En línea

fary


Desconectado Desconectado

Mensajes: 1.061



Ver Perfil WWW
Re: cuando compilo sale virus
« Respuesta #4 en: 29 Enero 2023, 16:49 pm »

Seguramente el compilador te este enlazando más librerías que las que usas y por eso pesa mas el ejecutable. No creo que sea un virus sinceramente, aunque claro que puedes tener infectado el compilador.
En línea

Un byte a la izquierda.
RayR

Desconectado Desconectado

Mensajes: 239


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #5 en: 29 Enero 2023, 19:17 pm »

Viendo el código, no hace nada raro, así que probablemente, como ya te dijeron, se trate de un falso positivo. La diferencia de tamaños no tiene nada de extraño, y depende del compilador usado, las opciones de compilación, etc. Por ejemplo, tan sólo con los análisis de VirusTotal, se puede ver que tú estás compilando para 64 bits, mientras que el .exe original fue compilado para 32 y con un compilador viejísimo (según el reporte, fue compilado en 2002...) así que no tiene el menor sentido comparar los tamaños.

Dicho lo anterior, si lo compilas, por ejemplo, con las opciones  -Os -s, debería reducir de forma importante el tamaño, y es posible que el falso positivo (si lo fuera) desaparezca.
En línea

Tusanjamon

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #6 en: 30 Enero 2023, 02:25 am »

tenias razon!

https://www.virustotal.com/gui/file/5d7a63eb7e51af66267d3769e653b24abf5f25a20a0d1ff6f4cae56a5a7452cf?nocache=1
limpio y con menos tamaño: 40.50 KB Size

gracias! gracias a todos!
En línea

Tachikomaia


Desconectado Desconectado

Mensajes: 1.180


Superhacker (es broma xD )


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #7 en: 30 Enero 2023, 04:01 am »

¿Podrías explicarme algunas cosas?
Dices que descargaste un rom de PS1, pero que yo sepa son de extensión iso ¿y además te vino con un código en C? ¿el juego como si estuviera programado en C o qué?
En línea

Tusanjamon

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #8 en: 30 Enero 2023, 04:29 am »

no. los roms son .iso pero se comprimen con .ecm primero para poder comprimirlos mas con rar o zip despues.




ya que esta dejo el codigo que use para compilarlo. como me dijo la inteligencia artificial. cuando le pregunte como compilo C con python...  ;D

Código:
import subprocess

source_file = "unecm.c" # Nombre del archivo fuente C
output_file = "unecm" # Nombre del archivo ejecutable generado

subprocess.run(["gcc", "-Os", "-s", "-o", output_file, source_file])

el "-OS", "-s" se lo agrege hoy por la sugerencia que me hicieron aca y funciona. compila con menos tamaño y sin que salten los antivirus.
« Última modificación: 30 Enero 2023, 08:31 am por Eternal Idol » En línea

RayR

Desconectado Desconectado

Mensajes: 239


Ver Perfil
Re: cuando compilo sale virus
« Respuesta #9 en: 30 Enero 2023, 20:09 pm »

Creo que conviene aclarar por si acaso. Aunque -Os y -s pueden reducir bastante el tamaño de los binarios, tienen sus desventajas. Compilar optimizando para reducir el tamaño puede reducir también el rendimiento (al menos en comparación con -O2 y -O3, que optimizan para velocidad de ejecución sin importar el tamaño), y en particular -s quita información que puede ser útil (aunque no indispensable en este caso para la ejecución del programa).

Aquí las puse porque podían servir para verificar que era un falso positivo y como un ejemplo de cómo las opciones de compilación influyen en el tamaño del ejecutable, pero en general sólo habría que usar ésas, y en especial -s, cuando hay una necesidad específica para hacerlo y se sabe lo que hace; de lo contrario no es muy recomendable.
« Última modificación: 30 Enero 2023, 20:32 pm por RayR » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
error cuando compilo- dev c++
Programación C/C++
kiara_luna 1 3,602 Último mensaje 15 Agosto 2011, 13:32 pm
por Dark Invader
Cuando compilo mi aplicación, no funciona. « 1 2 3 »
.NET (C#, VB.NET, ASP)
Eleкtro 21 10,527 Último mensaje 23 Noviembre 2012, 00:27 am
por Pablo Videla
Mi programa no se abre cuando lo compilo desde cmd
Java
VintageChanel 6 5,364 Último mensaje 24 Enero 2015, 03:36 am
por Usuario Invitado
MOVIDO: Mi programa no se abre cuando lo compilo desde cmd
Programación General
Eleкtro 0 1,579 Último mensaje 21 Enero 2015, 06:52 am
por Eleкtro
error en poo cuando compilo
Programación C/C++
sytem200 2 2,113 Último mensaje 20 Junio 2019, 07:09 am
por jmpesp
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines