¿Es posible detectar el ejecutable empaquetado?

Hay muchas formas conocidas de identificar empacadores. El empaquetador UPX 'más común' y sus variaciones suelen estar marcadas como 'sospechosas' por los motores antivirus debido a una detección de firmas en el Ej.

Hay un par de herramientas útiles llamadas:

• RDG Packer Detector que detecta empacadores específicos según la comprobación de firmas (probablemente de la misma forma en que AV lo hace

• PEiD detecta los empacadores, cryptors y compiladores más comunes para archivos PE, además de permitir el desmontaje (disponible para descargar a través de softpedia)

• Un comprobador de firma de la firma simple en Python para que juegues con él (no estás seguro de dónde agarrarlo la base de datos de ( intenta aquí? )

También hay una lista aquí de un par de variaciones de empacadores

Una vez que detectes el tipo de empacador, puedes usar el desempaquetador automático (si ya hay uno disponible) o puedes comenzar a desempaquetarlo manualmente.

  

¿Las herramientas antivirus existentes son buenas para detectar si un ejecutable   ha sido embalado con un empaquetador personalizado?

No, no realmente, buscarán firmas (como las herramientas anteriores). Si alguna vez pasa tiempo en los foros de blackhat, las personas anuncian 'FUD Crypters / Packers', lo que significa que generalmente modifican la forma en que funcionan sus empacadores para que los AV no recojan las firmas por un tiempo, lo que permite que el malware se escape.

Según Symantect (como se cita en este documento )

  

Symantec ha recopilado una gran cantidad de empacadores, más de 2000 variantes en más de 200 familias.

El documento mencionado anteriormente también contiene mucha información sobre las técnicas utilizadas, las técnicas contrarias empleadas y más que responderán a la segunda parte de su pregunta.

Hay algunos artículos científicos que proporcionan posibles técnicas para detectar ejecutables empaquetados automáticamente.

Por ejemplo, Perdisci, Lanzi y Lee link aplican el reconocimiento de patrones para distinguir los archivos empaquetados de los archivos no empaquetados . Las características que utilizan para el reconocimiento de patrones dan una idea de cómo funciona:

Número de secciones estándar y no estándar
Los ejecutables empaquetados a menudo no siguen los nombres estándar.

Número de secciones ejecutables
Los ejecutables empaquetados a menudo no tienen ninguna sección ejecutable.

Número de secciones legibles / grabables / ejecutables
El ejecutable empaquetado necesita al menos una sección que sea legible, grabable y ejecutable. La sección ejecutable de los archivos no empaquetados no necesita ser grabable.

Número de entradas en el IAT
Un ejecutable empaquetado generalmente tiene menos importaciones.

Encabezado de PE, código, datos y entropía de archivos
El código cifrado se verá como aleatorio.

Lyda y Hamrock describen una técnica que solo usa entropía. enlace

si desea hacer esto mediante programación, debe usar esta forma / función (o similar) para detectar la firma del empaquetador / protector o compilador en el PE y luego comparar esta firma con una lista de firmas que existen en una base de datos de firmas conocidas (por ejemplo, "userdb.txt" de PEiD).

#include <Windows.h>
#include <iostream>
using namespace std;
IMAGE_DOS_HEADER Dos_Header;
IMAGE_FILE_HEADER Pe_Header;
IMAGE_OPTIONAL_HEADER Opt_Header;
IMAGE_SECTION_HEADER ImgSection;
DWORD sections = 0, Count = 0;
void Get_Sign(LPSTR szFileName, DWORD Lenght);
int main() {
Get_Sign(
  "C:\Program Files (x86)\NoVirusThanks\Smart PC Locker Pro\NSPL.exe" /* used in this example ! */
  , 399);
system("pause");
return 0;
} /* */
void Get_Sign(LPSTR szFileName, DWORD Lenght)
// Lenght=399 by defult
{
DWORD i;
HANDLE hFile;
unsigned char Buff;
DWORD Signature = 0;
DWORD EP, IVA, RAW, UNL, Offset;
DWORD BytRet;
hFile = CreateFileA((LPCSTR) szFileName, GENERIC_READ, FILE_SHARE_READ,
  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
  cout << "Error in opening file\n";
  exit(0);
}
else {
  ReadFile(hFile, &Dos_Header, sizeof(IMAGE_DOS_HEADER), &BytRet, NULL);
  if (Dos_Header.e_magic = IMAGE_DOS_SIGNATURE) {
   SetFilePointer(hFile, Dos_Header.e_lfanew, NULL, 0);
   ReadFile(hFile, &Signature, sizeof(Signature), &BytRet, NULL);
   if (Signature == IMAGE_NT_SIGNATURE) {
    ReadFile(hFile, &Pe_Header, sizeof(Pe_Header), &BytRet, NULL);
    sections = Pe_Header.NumberOfSections;
    if (Pe_Header.SizeOfOptionalHeader > 0) {
     ReadFile(hFile, &Opt_Header, sizeof(Opt_Header),
      &BytRet, NULL);
     EP = Opt_Header.AddressOfEntryPoint;
     for (Count = 1; Count <= sections; Count++) {
      ReadFile(hFile, &ImgSection, sizeof(ImgSection),
       &BytRet, NULL);
      if (EP < ImgSection.VirtualAddress +
       ImgSection.SizeOfRawData)
       break;
     }
     IVA = ImgSection.VirtualAddress;
     RAW = ImgSection.PointerToRawData;
     UNL = Opt_Header.SizeOfUninitializedData;
     Offset = EP - IVA + RAW;
     // get size of  uninitialized data
     // UNL = IVA - UNL;
     // Offset = EP - UNL + RAW;
     // get offset of signatures to read
    }
    for (i = Offset; i <= (Offset + Lenght); i++) {
     SetFilePointer(hFile, i, NULL, 0);
     ReadFile(hFile, &Buff, sizeof(Buff), &BytRet, NULL);
     printf("%X", Buff);
    }
    cout << endl << endl;
   }
  }
}
}

(Disculpe si mi inglés es malo)