Foro de elhacker.net

Hola!! Como va?
Bueno, estoy trabajando en un virus que está funcionando bien, el problema es que estoy tratando de hacerlo indetectable (más indetectable por ahora tengo un 5/42) pero ya no se como.
Lo está detectando por heurística, se que no es por emulación de código sino probablemente por firmas.
Hay alguna manera de obfuscarlo sin necesidad de recurrir a un crypter con su stub??
Gracias!!

¿Tienes el código fuente? ¿Qué detecciones te saltan?

Si, tengo, me saltan estas:
BitDefender    Gen:Trojan.Heur.RP.huW@auQStQj
DrWeb    MULDROP.Trojan
Emsisoft    Gen:Trojan.Heur.RP.huW@auQStQj (B)
F-Secure    Gen:Trojan.Heur.RP.huW@auQStQj
GData    Gen:Trojan.Heur.RP.huW@auQStQj
MicroWorld-eScan    Gen:Trojan.Heur.RP.huW@auQStQj
Symantec    Suspicious.Cloud.5

Osea, este es el que más salta, tiene un diseño modular el virus, este es el núcleo, el que menos quiero que se pueda detectar. Los otros tienen 1, 2, 0 y 5 detecciones.

creo que cambiando la versión info salen esas firma. la verdad no recuerdo bien.

La qué??? Version info??

si si eso de la CompanyName-ProductName-ProductVersion etc. no estoy seguro.

Hola esa opción de editar la info del ejecutable no se si te servirá, hice esa prueba con el server del Darkcomet, modificando toda la info con PE Explorer y sólo cambia la identificación, entonces la heurística le caza una porción de código. Sin la info lo detecta como amenaza genérica.
Hay varios tutoriales, mira este de Lostdead, edita el server con el hexa buscando la firma detectada:
http://www.hackxcrack.es/forum/index.php?topic=1512.0

Si no quieres utilizar crypter creo te tocará modificar código. No se si estará desactualizado pero el SignatureZero funcionaba bastante bien para detectar las firmas.
No se si te servirá, Karcrack te orientará mucho mejor.

Saludos.

Sería de utilidad saber más sobre el ejecutable, importaciones y secciones por ejemplo. Apostaría que utilizas ShellExecute() o derivados.

Teniendo el código fuente es cuestión de buscar caminos alternativos.

La mayoría de los imports están hechas de manera dinámica y los strings que se le pasa a las funciones getprocaddress y getmodulehandle están cifrados.
Contame de esos caminos alternativos...
Para mi está detectando cosas como que por ejemplo se instala como servicio, o que modifica el registro.

PD: probé AVDevil y también ZeroDetection pero ninguno me dió buen resultado, estoy tratando de hacerlo pasar contra el F-Protect utilizando el Coranti, que es un AV que tiene varios engines de AV en uno.

Olvídate de la evadir la detección parcheando firmas, si tienes el código trabaja con él. ¿En que lenguaje lo has programado? Si todas las cadenas están cifradas... ¿Que cifrado usas?

Está en C++. El cifrado es un XOR que hice yo, las cadenas no se pueden ver en el binario, pero en cuanto arranca el programa se descifran para poder trabajar con ella y se cargan en el stack.

Los AVs ya aplican a las cadenas XORs con diferentes valores. Podrías probar a eliminar las cadenas y compilar a ver si saltan las mismas detecciones. De ser así el problema es el cifrado, de no ser así es la forma en que lo aplicas. C es muy explícito a la hora de generar binarios y un bucle en el que vas leyendo byte por byte hace saltar las heurísticas.

Saludos

Siendo que son heurísticas las detecciones y no de emulación de código dudo mucho que esté identificando los strings. Es más que nada para evitar que se vea toda la información del ejecutable simplemente abriéndolo con un editor de texto. De todas maneras puedo hacer un cifrado más complejo. Aparte no es un xor simple sinó múltiple. Es decir, se pasa varias veces.

Okay, encontré 3 funciones que si las saco, sólo hacen saltar el symantec (que es increíblemente sensible y da muchísimos falsos positivos), lo que mucho no me importa.
Ahora supongo que tengo que identificar cómo hacer que no hagan saltar el AV.

Okay, seguí buscando y encontré que las 3 funciones hacen una llamda a CopyFile() (La cual está cargada estáticamente) y si saco la llamada a dicha función se convierte indetectable.
Voy a probar cargándola dinámicamente y sino, haciendo una función custom!
Alguna otra sugerencia??
Saludos
APOKLIPTICO.

PD: Llamando CopyFile() como dinámica, no la detecta. Estos anti virus son patéticos...

Pensé que harías uso o de alguna función de ejecución como ShellExecuteEx() o alguna de copiado por la detección de "MULDROP" de Dr.Web.
Aún no tratándose de emulación de código los AVs aplican cifrados simples sobre cadenas ofuscadas durante un análisis heurístico.

Me alegro que hayas podido quitarte las detecciones, teniendo el código fuente el sistema es simple; ir quitando trozos y ver que lo hacía saltar.

El tema del cifrado XOR es que no es simple, osea, para alguien haciendo criptoanálisis con un ataque known-plaintext (que se puede obtener observando la memoria del programa cargado) va a obtener un keystream que quizas puede utilizar para conseguir la semilla del generador lineal congruencial que utilizo como PRNG, o simplemente hacer un ataque fuerza bruta con el espacio de llaves (que son solo 32 bits asi que tardaría unos pocos segundos).
Pero para un simple AV y con limitado tiempo de procesador?? Olvidate...

Es raro que simplemente detectando el import de CopyFile() te haga saltar el anti virus, no hay programas legítimos que lo utilicen?? En cuanto al symantec, me aparece como suspicious. Se podrá hacer algo para evitar su detección???

Los AVs no aplican el proceso de descifrado sobre cada ejecutable ni sobre el ejecutable entero, solo sobre aquellos sospechosos. Además, en un cifrado XOR normal el tamaño de la clave es de 8 bytes. Algo perfectamente asumible.

Respecto al uso de CopyFile()... no hace saltar por sí solo la detección sino un conjunto de patrones distintos, como podría ser detectar una función de [des]cifrado o que no haya imports de kernel32 o que sólo haya una sección en el PE...

Que tal, estoy tratando de evitar la detección por emulación de código durante el escaneo profundo. Esta función hace saltar el AV, específicamente cuando trata de abrir la clave "HKLM\Software\Microsoft\Security Center".

int VulnRegs(char *szSubkey, char *pszRegVals, DWORD *pData)
{
    HKEY hHandle = NULL;
    int iReturn = doRegOpenKeyEx(HKEY_LOCAL_MACHINE, szSubkey, 0, KEY_WRITE, &hHandle);
    if(iReturn != ERROR_SUCCESS) return iReturn;
    int iCounter = 0;
    do
    {
        doRegSetValueEx(hHandle, pszRegVals, 0, REG_DWORD, (const BYTE*)&pData[iCounter], sizeof(DWORD));
        do{ pszRegVals++;} while(pszRegVals[0] != '\0');
        pszRegVals++;
        iCounter++;
    }while(pszRegVals[0] != '\0');
    doRegCloseKey(hHandle);
    return ERROR_SUCCESS;
}

Como puedo reemplazarla??

Si se trata de una detección proactiva te detecta el acceso a la clave de registro, no la forma en qué lo haces.

Mmh, no creo que sea el caso...
El tema es que la detección ocurre cuando le pongo escaneo manual, es decir con el menu contextual.

Pensaba que te referías a proactiva. Siendo un escaneo manual aplicará un nivel más paranoico de heurística o emulación. ¿Qué AV es? ¿Has probado a eliminar constantes como HKEY_LOCAL_MACHINE?

El tema es que me parece que cuando escaneas, el emulador se toma todo el tiempo del mundo para emularlo. El problema es que mi sistema anti-emulacion se basa en hacer que el emulador tarde demasiado tiempo en analizarlo y lo descarte. Debería hacer algo que el emulador no pueda emular y entonces detectarlo de esa manera...

Tu "cifrado" que lo tienes por no simple, te digo que sí es simple. Vamos, yo diría que muy simple.

No es polimórfico, es simple cifrado. Además, aún siendo cifrado, no son distintas capas de cifrado una sobre otra, sino sólo una. ¿Me equivoco o te entendí mal? Pero es que aunque fueran varias capas de cifrado, cosa que no es tu caso, de poco te iba a servir ante los emuladores: lo pillan aún con varias capas.

Resumen: Tu cifrado es simple: una sóla capa. Es cifrado, no polimorfismo: o sea tu operación es siempre la misma: XOR en tu caso (además la clásica y más usada). Y lo único que varías es la clave con que cifras esa XOR, que aunque fuera de 32 bits es totalmente pobre ante un emulador.

Te repito que un emulador te lo pilla rápido. Los emuladores no analizan todo el fichero, sino sólo partes sospechosas. A veces ni siquiera necesitan descifrar todo el fichero (la parte que esté cifrada), ni si quiera todo tu virus, sino tan sólo una parte. Y con eso solo ya saltan.


Y finalmente: te diría que para mí el que te lo detecten es por:

1. Tu propia rutina de cifrado, que es el típico bucle loop XOR de los antiguos virus cifrados simples, (rutina por cierto que hoy día ya casi ni se utiliza (o al menos sola), de lo vieja y conocida que es). Eso mismo: tu rutina, ya les hace saltar. O sea lo que utilizas para que no te detecten, eso mismo les sirve para detectarte, al menos ya como código sospechoso.

2. Y aún más seguro: En tu código, ya plano descifrado, debe haber unas cuantas cadenas=patterns que corresponden a otros malwares, más si lo tienes escrito en C, ya que C utiliza=compila según qué trozos de código, de la misma manera siempre igual. Mira como cada AV te da como distintos malware tu virus= te lo confunde con distintos otros programas malware.


Puedes probar a:

1. Quítale tu rutina de cifrado XOR. Deja tu código plano.

2. Comenta y Descomenta, trozos de tu código, y luego compila, ..., y luego pásale los AVs, ..., prueba... , y es posible que veas que alterando tu código plano, o sea quitando o poniendo según qué partes, los AVs te seguirán saltando o te dejarán de saltar.


Además: ¿hablas de virus? O sea que tu programa INFECTA otros programas. ¿? ¿Y en C? Lo dudo. No lo veo. Explica un poco qué tipo de programa es el tuyo. O es simplemente un worm sencillo en C que se automanda por email, ¿o qué?

Otras cosas que comentabas, que no te siente mal, perdona pero se ve que no tienes nivel, no al menos el suficiente. Por ejemplo cuando dices que las funciones de las DLL que importas las tienes encriptadas. ¿Y qué? ¿Que las sacas dinámicamente? Eso no es nada nuevo, técnica que tiene al menos 10 años.
Y además eso no tiene relación directa con no ser detectado. La detección está en primer lugar en tu código ejecutable, aún antes de ser ejecutado. Y si te lo emulan, al ejecutarse, antes de llegar a ejecutarse las funciones de tu virus como el de obtener las API de las DLL que necesites, están muchas otras cosas, como por ejemplo tu rutina de cifrado, que a todas luces parece un: "¡hey Antivirus, que soy un virus!": o sea más que esconder código, llama la atención como rutina  sospechosa.


Mira: el tema de la cifrado, polimorfismo, metamorfismo, ..., no es sencillo.
Si pretendes hacer una rutina de cifrado, que haga que tu código, de momento, pase desapercibido sin ser detectado, tendrás que estudiar bastante más, yo diría que mucho más, que el nivel que tienes con tu bucle XOR.

Como ejemplo, aquí tienes un artículo COJONUDO sobre el tema:
http://www.thehackademy.net/madchat/vxdevl/papers/avers/x-raying.pdf

Y aún siendo COJONUDO, a la vez te digo que ya está algo desfasado.

Aún así si lo lees=estudias, comprobarás que virus mucho más complejos que el tuyo, pero mucho más complejos, como el Magistr, (ya por cierto viejo, muy viejo), tenían técnicas de cifrado polimórfica que le dan 1000 vueltas a la tuya, y aún así fueron cogidos=detectados al poco de salir.

Un saludo. Y no por ello te desanimes. Está genial que estés en este tema. Muchos ingenieros informáticos con título, no saben ni hacer un volcado de memoria. Son ignorantes con título. Lo suyo es la administración empresarial usando un ordenador: las bases de datos, SQL, Visual Basic, etcs: patético.

Así que tú dale y ánimo con el SISTEMA y con cómo funcionan las máquinas, que es lo que realmente es la ingeniería informática, en este caso particularizando en el área de la seguridad.

Esa idea está muy bien. Yo mismo la pensé hace tiempo. Pero en mi opinión, para llevarla a la práctica, en primer lugar has de generar código polimórfico. Si es sólo cifrado=código fijo, entonces no tardarán nada en pillar tu rutina y se la saltarán de inmediato, incluso desde el primer momento en que hagas tus pruebas en tu casa con los AV probando en tu ordenador.

Y en segundo lugar, siendo polimórfica=variable=distinta cada vez, debes crear: bucles, llamadas, etcs, ..., lo suficientemente complejas en su estructura como para que el emulador "se las trague" y las emule pensando que es código legítimo, porque de lo contrario no te las va a emular, y por tanto no perderá ese tiempo que quieres que pierda con tus rutinas de sistema anti-emulación.


La idea que dices es la complejidad temporal. Los emuladores tienen un quantum=fracción de tiempo, para emular cada fichero que consideran sospechoso. Si mientras emulan, ese quantum es superado, y a la vez no han dado con una identificación positiva como que ese fichero es sospechoso, entonces lo dejan y pasan al siguiente. La técnica es atacar la complejidad temporal del emulador. Y para ello como dices, hacer que dé vueltas y vueltas en tu rutina, hasta que "se aburra", y deje el fichero. Pero eso no es fácil de implementar. Prueba y verás. Si no sabes hacer código polimórfico, entonces en mi opinión poco puedes hacer. Y para hacer código polimórfico, has de programar en Ensamblador, el C no te sirve para nada para eso. Saludos.

Despues de leer esto, voy a poner el punto newbie xD. Si nada mas empezar, hago algo como esto:

call delta
delta:
pop ebp
sub ebp,delta

El clasico delta, significa deteccion segura no?

Sí ;-) significa detección segura, o más bien saltar alarma de código sospechoso.

Pero es que antes de llegar al delta offset, que eso está dentro de tu código del virus, el antivirus y sus módulos como el emulador, ya te han chequeado unas cuantas cosas antes: como por ejemplo en qué sección (primera, última, ...) (.text, .data, .rsrc, ...) del ejecutable (infectado) se está ejecutando tu código, qué atributos tiene esa sección, si hay alguna rutina de descifrado, ..., etcs.

O sea tu delta offset sería uno de los últimos datos que el antivirus vería para concluir que ahí en ese ejecutable hay algo muy sospechoso.

Ese truco lo he sacado de manuales antiguos, obviamente, pero hay alguna version mas moderna?

@Ferleg.
El cifrado es XOR pero no es con una clave estática, sino que es con una clave que se utiliza como seed del generador pseudoaleatorio y luego se utiliza el keystream que genera el mismo para hacer XOR. Es exactamente lo mismo que hace cualquier cifrado simétrico, lo único que cambia es la complejidad del PRNG.

Estoy seguro que la rutina de cifrado no lo hace saltar porque lo utilizo en otros programas y no lo detecta, eso estoy seguro.

Los anti virus no son tan complejos y realmente reemplazando rutinas se hacen indetectables. No necesito un virus que sea completamente indetectable para siempre, simplemente uno que sea indetectable por heuristica y emulación de código. Estoy realmente bastante cerca y sólo me falta una pequeña cosa.

APOKLIPTICO: No lo pillas. Estás utilizando cifrado, simple no, muy simple. Aunque tú sigas diciendo que es compleja y hables de clave seed, PRNG, y etcs.

Estás muy equivocado cuando dices que los antivirus no son tan complejos. Por poner un ejemplo, los emuladores de código que usan los AV son de lo más complejo que te puedes echar a la cara.

Dices que no necesitas un virus que sea completamente indetectable para siempre. No desde luego que no. Porque no existen.

Y dices que uno simplemente que sea indetectable por heurística y emulación de código. Pues para eso empieza por estudiar polimorfismo y técnicas como EPO, etcs. Porque con tu rutina XOR no tienes ni para empezar.

Y si te da por pensar que digo estupideces, pues ¿por qué no demuestras lo que dices con hechos?: O sea puedes poner en el post el código ASM de cifrado que genera tu rutina de cifrado XOR, y ya veremos lo "compleja" que es. Y si no sabes ASM (por cierto mal si quieres hacer virus (serios) ), entonces pon al menos el código fuente de tu rutina C que realiza la cifrado.

Y ya para terminar, como estoy casi seguro que al final dirás "ya lo conseguí", pues puedes mandarme el EXE de tu virus, y yo le meto el debugger y veré el nivel de tu super rutina de cifrado XOR con su seed y su PRNG y sus etcs, además de comprobar que realmente es indetectable por los AVs.

Te digo que el nivel que aplicas de cifrado es pobre si lo que quieres hacer es un virus como dices que sea indetectable por heurística y emulación de código.
Pero bueno, tú sigue con tus planteamientos. Eso sí: seguro que ni pones en el post el código ASM de cifrado que genera tu rutina XOR, ni pones el código fuente C de la función con la que haces la cifrado, ni tampoco me mandarás el EXE si lo terminas y dices que ya nadie lo detecta. ¿Sí o no?

a qué antivirus te refieres?
yo no soy hacker  :P, pero quiero tu seguridAD?

p.d. creo que panda de español lo justo.....

Mirá, te habla el moderador del área de criptografía. Te digo, más allá de la clave corta y que el PRNG no es criptográficamente apropiado, sirve perfectamente para lo que se le pide. Cifra los strings. Sin emulación de código no se va a poder saber el contenido de los strings. Es decir, es necesario que se ejecute la rutina que descifra los strings y luego ver el contenido de los mismos mirando la memoria. El XOR se utiliza en todos los cifrados simétricos actuales, incluido el AES, RC4, Blowfish, Twofish, Serpent, etc. El cifrado es más que suficiente ya que va a resistir que se le pasen XOR básicos para descifrarlos. El código no está cifrado ni obfuscado, pero tampoco me interesa que lo esté. Prefiero que el anti virus vea el programa como uno inofensivo, no que detecte el código obfuscado o cifrado.

No voy a subir la rutina de cifrado, aunque ya con lo que te dije deberías poder hacerla vos mismo. Una seed hardcodeada de 32 bits, un generador pseudoaleatorio básico LCG y el keystream aplicado con un XOR al plaintext.
El virus es indetectable por heurística e incluso en su gran parte por emulación de código.
Todo bien, pero no te voy a mandar el ejecutable, no tengo nada que probarle a nadie.

Saludos
APOKLIPTICO.

@ferleg, antes de despreciar las rutinas de encriptacion de APOKLIPTICO te recomiendo dos cosas:

1) Pasarte por el area de Criptografia, en Seguridad.
2) Demostrarnos tu lo que eres capaz de hacer.

Saludos.

Para 0xDani:

De los códigos que yo haya hecho no te voy a decir nombres concretos. Tú puedes pensar lo que quieras. Pero en general tan sólo te digo que he hecho motores polimórficos, EPO, anti-debugging, ..., y todo precisamente en el área de la programación de virus-antivirus.

No creo que sea yo precisamente quien me tenga que pasar por ninguna área de criptografía, cuando me están intentando colar una rutina xor con una "seed" (vaya novedad) y un PRNG (Pseudo Random Number Generator) (vaya otra gran novedad), como compleja rutina de cifrado.

Os di un link de un artículo (lo siento no estaba en español, era en inglés), sobre cifrado de virus, y además cifrado de la buena y compleja, empleada en algunos de los virus más complejos en cuanto a cifrado se refiere: W32.Magistr, W95.Perenast, W32.Efish, etcs : polimórficos todos, alguno incluso metamórfico.

http://www.thehackademy.net/madchat/vxdevl/papers/avers/x-raying.pdf
 
Si me queréis decir que vuestro nivel en criptografía y vuestras rutinas de cifrado superan el de ese artículo, os felicito y me como mis palabras.


Para APOKLIPTICO:

De lo último que un AV va a mirar son los strings que estés utilizando. Y lo primero que va a mirar es tu código binario. Y es en ese código binario donde primero compara patrones (cadenas de malware conocidas), y después (si lo considera) aplica emulación.

Te quiero decir con esto que cifrar tus strings es muy poca medida contra un AV.
Por mucho que cifres tus strings (por ejemplo las APIs de las DLLs que utilices), en la emulación serán descifrados (tu propio virus las descifra para utilizarlas, por mucho que estén en la pila o en Hong-Kong ¿lo pillas?, y todo en tiempo de emulación AV sin que se ejecute realmente tu virus), y si tu código binario es sospechoso: (abrir ficheros, que sean ejecutables, manipular la memoria, ...), el AV saltará.

Si intentas cifrar/cifrar algo, que sea todo tu código en todo caso, no tanto sólo unos strings que haya en él.

Por cierto, sigues hablando de tu "virus", estoy confundido, por eso te pregunté: ¿un virus en C? ¿o sea que tu programa infecta otros programas?

También podrías empezar por definir qué hace tu virus: si infecta qué infecta, cómo se propaga, si es residente o de acción directa, ... Porque si resulta que no hace ni la mitad de lo anterior, pues normal que tan sólo cifrando unos strings no sea detectado como programa sospechoso.

Esto se está saliendo del tema. Primer aviso.

La complejidad del cifrado no es tan importante. A los AVs les es más fácil detectar una rutina que haga un bucle de lectura/escritura que probar a crackear la contraseña que tengas en tu XOR.
Por otro lado los AVs buscan patrones a la hora de realizar llamadas. Ciertas APIs tienen parámetros muy particulares y es fácil "taggear" una combinación de pushes particular.

ferleg, APOKLIPTICO utiliza el término "virus" para referise a malware en general. Entiendo que sin replicación. Procura exponer tu opinión sin ofender y respetando al resto de participantes, sin importar tus conocimientos.

No hace falta que me des más avisos. Me voy del foro, ya veo lo que hay aquí.

Si se me permite hacer dos últimos comentarios:

1.
Me dice burbu_1 que Panda de españoles lo justo.
Bueno, si tus opiniones sobre el tema virus-antivirus están tan fundadas como tu comentario... mejor no digo más.
Tan sólo esto: échale un vistazo, te vendrá bien actualizar tus conocimientos:
http://es.wikipedia.org/wiki/Panda_Security

2.
Karcrack: ¿utilizar la palabra virus para un código que no se replica? ¿virus para referirse a malware genérico? Pensé que aquí se hablaba con propiedad y conocimientos, dado que esto se supone es un sitio que se hace llamar "elhacker". Y segundo: ¿la complejidad del cifrado no es tan importante? Vale, vale... lo que tú digas. Aquí lo dejo.

Lo último: perdonad si he sido hiriente o similar. No era esa mi intención.

Mi respeto sincero para todos. Un saludo.

Sigamos la conversación por privado si lo deseas, aunque veo que tus cualidades aquí se desaprovecharían. No podemos medirnos con tu capacidad y precisión lingüística. Comprenderé si deseas irte.

Cualquier otro mensaje fuera de tema será eliminado.

Aaanyways.
Cifrar los strings es más que nada una pequeña barrera a un antivirus que pueda llegar a buscar cadenas específicas en la sección data del ejecutable. También para un análisis manual ayuda. Aparte cifré también las APIs que utilizo que se cargan de forma dinámica, ya que he probado que linkeándolas estáticamente salta el anti-virus. Se que lo mejor sería un código que se automodifique, pero no tengo interés en hacerlo ya que no es necesario, siendo que mi Virus (es un worm con propagación por pipes y SMB, sin infección de ejecutables), no es detectado por la mayoría de los anti-virus (es detectado como sospechoso por el cloud de Symantec y la emulación de código del Kaspersky lo detecta como "sospechoso" y pregunta qué hacer).

En cuanto al cifrado, lo repito, todos los cifrados simétricos actuales se basan en un generador pseudoaleatorio o PRNG, que debe de ser uno apropiado para la criptografía, es decir que cumpla ciertas reglas. Algunos también tienen otros pasos, pero la base es esa, un PRNG que genera un flujo de datos para los cifrados de stream y los de bloque, utilizan en general una red de Feistel o variaciones de la misma. Pero siendo que el objetivo del cifrado es obfuscar los strings para evitar un posible análisis estático, cumple su función.

Por lo general, antes de cifrar se aplica algún tipo de compresión, para evitar evidenciar redundancias (y obtener mejor cifrado) y después se cifra.

Una opción simple de compresión podría ser LZW con un número no común de bits por bloque comprimido, o con alguna otra característica no estándar.

Otra opción menos simple pero más estándar y probablemente más detectable sin un buen cifrado, sería el algoritmo DEFLATE (el que se usa en los ZIP clásicos).

Y agregar código paso a paso para determinar qué es lo que activa la detección.

Para qué habría de comprimir los strings?? No hace falta, es más que suficiente con el cifrado que apliqué. La realidad es que tampoco me interesa que los niveles de entropía sean tan altos. Prefiero que estén bajos así no se asume que hay compresión o cifrado.

Buenas noticias: Logré que mi malware sea indetectable completamente excepto por el symantec, que ya lo voy a atacar, pero tengo que conseguirme una copia aunque sea de prueba.

Saludos y gracias!!

¿Al final que resultó hacer saltar la detección? Si Symantec te detecta por firmas será fácil detectarlo.

Mucha suerte ;)

Bueno, hice bajar la entropía de las secciones para que no la vean como comprimida o cifrada los AV, todavía hay análisis que pueden hacer que lo vean como comprimida o cifrada, pero a priori funcionó para virustotal, sólo tengo 1/46 :).

Sí, tuve un problema similar hace tiempo con Avira. Estadísticamente no encontraba suficientes 0s y pensaba que estaba cifrado/comprimido. Basto con añadir 1kb de 0s en el EOF y solucionado :)

Subiendo tus creaciones a VT? WTF? Si, sabemos que terminaran ahí pero eso solo hace
que en unos dias sea detectado tu malware, si estas haciendo tu version final del malware es un problema,
Bueno escribo mi experiencia tambíen, hace unos meses necesitaba un programita un poco indetectable, que tenia que llevar
cargado otro de ~600kb, no encontraba la forma de que lo llevara cargado sin ser detectado porque eran muchos bytes, en la
sección de recursos y con ese tamaño me lo detectaban muchos antivirus ( 7/37 ), luego hice un programa para que me añadiera una sección nueva con los permisos de la sección de datos y almacenar allí los ~600kb , ahora me lo detectaban ( 3/37 ), todo
cifrado por supuesto.

como siempre los más jodidos de remover: Avira,Kaspersky,Dr.web. más especialmente en Avira que su ratio de detección se basa bastante en ScanTime, tan solo un poco de corrupcion en el PE y ya es detectado como malware ( por ejemplo cambiar los
persimos de la sección de codigo, etc ) así que hice muchos intentos, al final encontre la solucion, agregar los KB's a la sección
de datos, hice un codigo que modificaba la sección de datos, realinaba la cabecera de las secciones, ajustaba los valores de la
ultima sección ( .reloc ) y ahora mi programa era detectado por 0/37  ::)

Luego en tiempo de ejecución era otra problema con Kaspersky pero se puede saltar tambíen  ;D.

PD: por cierto yo no recomiendo nada a AVIRA (premium ) como antivirus personal, es muy facil de saltar, una vez que lo saltas en ScanTime, en tiempo
de ejecucion ya puedes hacer cualquiera cosa sin deteccion adicional, incluso cargar un Driver y jugar un poco con el mismo antivirus  :silbar:  ;-)