Julio 27

Port forwarding on Linux with nc (netcat)

A naive try would be something like this:

$ nc -l 8082 | nc remote_host 80

Yes, it does forward the request from local port 8082 to remote_host:80, but the response is dumped to stdout, not routed back to the client as expected.

Using a named pipe makes it work:

$ mkfifo backpipe
$ nc -l 8082 0<backpipe | nc remote_host 80 1>backpipe

Use tee to get a glimpse of the response through the pipe (I wasn’t able to find a way to dump the request):

$ nc -k -l 8082 0<backpipe | nc localhost 80 | tee backpipe
HTTP/1.1 200 OK
Date: Fri, 30 Sep 2011 22:11:27 GMT
Server: Apache/2.2.16 (Unix)
Last-Modified: Sat, 20 Nov 2004 20:16:24 GMT
ETag: "2d0945-2c-3e9564c23b600"
Accept-Ranges: bytes
Content-Length: 44
Content-Type: text/html

<html><body><h1>It works!</h1></body></html>

The GNU netcat has a different syntax than the stock nc. It also supports different switches.

  1. To listen to port 1234:
    $ netcat -l -p 1234
    
  2. To make bash a server on port 1234:
    $ netcat -l -p 1234 -e /bin/bash
    
  3. Forward local port 8082 to remote port 80:
    $ ./netcat -L 192.168.80.143:80 -p 8082
    
  4. Port forwarding with hex dump:
    $ ./netcat -L 192.168.80.143:80 -p 8082 -x
    Received 174 bytes from the socket
    00000000  47 45 54 20  2F 20 48 54  54 50 2F 31  2E 31 0D 0A  GET / HTTP/1.1..
    00000010  55 73 65 72  2D 41 67 65  6E 74 3A 20  63 75 72 6C  User-Agent: curl
    00000020  2F 37 2E 32  31 2E 30 20  28 78 38 36  5F 36 34 2D  /7.21.0 (x86_64-
    00000030  72 65 64 68  61 74 2D 6C  69 6E 75 78  2D 67 6E 75  redhat-linux-gnu
    00000040  29 20 6C 69  62 63 75 72  6C 2F 37 2E  32 31 2E 30  ) libcurl/7.21.0
    00000050  20 4E 53 53  2F 33 2E 31  32 2E 31 30  2E 30 20 7A   NSS/3.12.10.0 z
    00000060  6C 69 62 2F  31 2E 32 2E  35 20 6C 69  62 69 64 6E  lib/1.2.5 libidn
    00000070  2F 31 2E 31  38 20 6C 69  62 73 73 68  32 2F 31 2E  /1.18 libssh2/1.
    00000080  32 2E 34 0D  0A 48 6F 73  74 3A 20 36  37 2E 31 33  2.4..Host: 67.13
    00000090  30 2E 36 39  2E 31 34 33  3A 38 30 38  32 0D 0A 41  0.69.143:8082..A
    000000A0  63 63 65 70  74 3A 20 2A  2F 2A 0D 0A  0D 0A        ccept: */*....  
    Sent 276 bytes to the socket
    00000000  48 54 54 50  2F 31 2E 31  20 32 30 30  20 4F 4B 0D  HTTP/1.1 200 OK.
    00000010  0A 44 61 74  65 3A 20 46  72 69 2C 20  33 30 20 53  .Date: Fri, 30 S
    00000020  65 70 20 32  30 31 31 20  32 32 3A 33  32 3A 30 35  ep 2011 22:32:05
    00000030  20 47 4D 54  0D 0A 53 65  72 76 65 72  3A 20 41 70   GMT..Server: Ap
    00000040  61 63 68 65  2F 32 2E 32  2E 31 36 20  28 55 6E 69  ache/2.2.16 (Uni
    00000050  78 29 0D 0A  4C 61 73 74  2D 4D 6F 64  69 66 69 65  x)..Last-Modifie
    00000060  64 3A 20 53  61 74 2C 20  32 30 20 4E  6F 76 20 32  d: Sat, 20 Nov 2
    00000070  30 30 34 20  32 30 3A 31  36 3A 32 34  20 47 4D 54  004 20:16:24 GMT
    00000080  0D 0A 45 54  61 67 3A 20  22 32 64 30  39 34 35 2D  ..ETag: "2d0945-
    00000090  32 63 2D 33  65 39 35 36  34 63 32 33  62 36 30 30  2c-3e9564c23b600
    000000A0  22 0D 0A 41  63 63 65 70  74 2D 52 61  6E 67 65 73  "..Accept-Ranges
    000000B0  3A 20 62 79  74 65 73 0D  0A 43 6F 6E  74 65 6E 74  : bytes..Content
    000000C0  2D 4C 65 6E  67 74 68 3A  20 34 34 0D  0A 43 6F 6E  -Length: 44..Con
    000000D0  74 65 6E 74  2D 54 79 70  65 3A 20 74  65 78 74 2F  tent-Type: text/
    000000E0  68 74 6D 6C  0D 0A 0D 0A  3C 68 74 6D  6C 3E 3C 62  html....<html><b
    000000F0  6F 64 79 3E  3C 68 31 3E  49 74 20 77  6F 72 6B 73  ody><h1>It works
    00000100  21 3C 2F 68  31 3E 3C 2F  62 6F 64 79  3E 3C 2F 68  !</h1></body></h
    00000110  74 6D 6C 3E                                         tml>           
    
Category: TIPS AND TRICKS | Los comentarios están deshabilitados en Port forwarding on Linux with nc (netcat)
Julio 21

Creando firmas de virus para ClamAV

ClamAv es un antivirus opensource y multiplataforma creado por Tomasz Kojm muy utilizado en los servidores de correo Linux. Este antivirus es desarrollado por la comunidad, y su utilidad práctica depende de que su base de datos de firmas sea lo suficientemente grande y actualizado. Para ello es necesario que voluntarios contribuyan activamente aportando firmas.
El presente artículo pretende describir de manera sencilla cómo crear firmas de virus para ClamAV y contribuir con ellas a la comunidad.


Los archivos de firma de ClamAV habituales son main.cvd y daily.cvd. En realidad son archivos comprimidos que contienen los auténticos ficheros de firmas. Para obtener información sobre el archivo podemos usar la utilidad sigtool con la opción -i.


sigtool -i daily.cvd

Si queremos ver los ficheros de firmas podemos usar esta misma utilidad con la opción -u para desempaquetar el archivo.


sigtool -u daily.cvd

Podemos observar como hay diferentes archivos con diferentes extensiones. Los más reseñables son los siguientes:

cdb: Contenedor de metadatos.
fp: Base de datos de ficheros buenos conocidos (lista blanca).
hdb: Hashes MD5 de ficheros maliciosos conocidos.
ldb: Firmas lógicas.
mdb: Hashes MD5 de secciones PE de ficheros maliciosos conocidos.
ndb: Firmas en hexadecimal.
rmd: Firmas de metadatos.
zmd: Firmas de metadatos.

Estos archivos contienen las firmas en formato de texto, con lo que podemos fácilmente ver su contenido.


cat daily.hdb

Hay varios tipos de firmas en ClamAV. Las más sencillas son las que se almacenan en los archivos .hdb, cuyo formato es el siguiente:


MD5:tamaño:nombre_malware

Analicemos un ejemplo:


bb14987ca0f354b72ba8433a878d7ca3:9319:Java.Trojan.Agent-32

El primer campo es el hash calculado del fichero malicioso, que tiene 9319 bytes y cuyo nombre (para ClamAV) es Java.Trojan.Agent-32.

Este tipo de firma es el más sencillo, ya que tiene en cuenta todo el fichero. La contrapartida es que es menos flexible. El comando para crear una firma para un supuesto virus que se encuentra en el fichero virus.exe es la siguiente:


sigtool –md5 virus.exe > test.hdb

Seguidamente, podemos ver como es detectado el archivo como virus usando el comando clamscan.


/usr/bin/clamscan -d test.hdb virus.exe

En caso de que estemos seguros de que de que realmente tenemos un malware entre manos, podríamos contribuir a la comunidad de ClamAV con nuestra firma mediante la siguiente URL.

http://www.clamav.net/lang/en/sendvirus/submit-malware/

El siguiente formato de firma que vamos a analizar es el que se almacena en archivos .mdb, en el que la firma se corresponde con una sección de un archivo ejecutable tipo PE (Portable Executable) de Windows. En este caso, la forma de obtener la firma no es tan directa. Para complicar un poco más la cosa, los programas ejecutables, y sobre todo los virus, suelen venir empaquetados con alguna utilidad del tipo UPX o similar.
Para obtener las firmas vamos a utilizar un script en perl llamado PESectionExtractor.pl, y que se puede obtener en la siguiente URL.

http://hexacorn.com/d/PESectionExtractor.pl

Analicemos primero el formato:


tamaño:MD5:nombre_malware

Por ejemplo, la siguiente firma es para una sección PE de 13312 bytes y el nombre del malware es Win.Trojan.Sharik-4.


13312:e80fc496d01e3d36a3c8578c48b3c275:Win.Trojan.Sharik-4

Para obtener la sección PE que nos interesa recurrimos a PESectionExtractor.pl de la siguiente manera.


PESectionExtractor.pl notepad.exe

Este script ha extraído todas las secciones PE del ejecutable. Para generar el hash volvemos a usar sigtool con la opción –md5, pero esta vez sobre la sección que nos interese.

A partir de aquí sólo hay que crear la firma con el formato que acabamos de ver más arriba.

El siguiente tipo de firma que vamos a analizar son las firmas extendidas, almacenadas en los archivos .ndb, y que nos permiten mayor flexibilidad, ya que en ellas no se especifica un checksum, sino directamente una serie de opcodes del malware (si es un ejecutable). El formato de la firma es el siguiente.


nombre_malware:tipo:offset:firma_hexadecimal[:MinFL:[MaxFL]]

Un ejemplo de este tipo de firma puede ser el siguiente.


XML.Exploit.CVE_2013_3137:0:*:3c21646f6374797065{-30}5b203c21656e746974792025{-30}73797374656d20(22|27)687474703a2f2f{-30}2e786d6c(22|27)3e{-30}3b205d3e

El campo tipo puede contener cualquiera de los siguientes valores:

0: Cualquier tipo de fichero.
1: Portable Executable (PE).
2: Componente OLE2 (por ejemplo VBA script).
3: HTML.
4: Archivo de correo electrónico.
5: Archivo gráfico (png, jpg, etc.).
6: Ejecutable tipo ELF.
7: Archivo de texto ASCII.

El campo offset o desplazamiento indica a partir de qué posición del archivo debe darse la coincidencia de la firma. Tiene el siguiente formato.

*: En cualquier posición del archivo.
n: Un número entero que indica la posición absoluta.
EOF-n: Final del fichero menos n bytes.

Además, las firmas para los tipos PE y ELF soportan los siguientes formatos:
EP+n: Entry point mas n bytes (EP+0 para indicar el entry point del programa).
EP-n: Entry point menos n bytes.
Sx+n: Inicio de la sección x mas n bytes.
Sx-n: Inicio de la sección x menos n bytes.
SL+n: Inicio de la última sección más n bytes.
SL-n: Inicio de la última sección menos n bytes.

Finalmente, la firma va en hexadecimal y dependiendo del tipo de fichero, se corresponderá con una serie de opcodes si se trata de un ejecutable o los caracteres en hexadecimal si se trata de un archivo de texto.
Es posible añadir expresiones regulares (wildcards) que tiene el siguiente formato.

??: Coincidencia con cualquier byte.
a?: Coincidencia con el nibble más significativo.
?a: Coincidencia con el nibble menos significativo.
*: Coincidencia con cualquier número de bytes.
{n}: Coincidencia con exactamente n bytes.
{-n}: Coincidencia con n bytes o menos.
{n-}: Coincidencia con n bytes o más.
{n-m}: Coincidencia de entre n y m bytes (m > n).
(aa|bb|cc|..): Coincidencia con aa o bb o cc, etc.
!(aa|bb|cc|..): Coincidencia con cualquier byte excepto con aa y bb y cc, etc.
HEXSIG[x-y]aa o aa[x-y]HEXSIG: Coincidencia con aa adyacente a una firma hexadecimal.
(B): Coincidencia con fin de palabra.
(L): Coincidencia con CR, CRLF fin de fichero.

Los campos opcionales [:MinFL:[MaxFL]] sirven para especificar la máxima y mínima versión del motor de clamav que soporta esta firma.

La forma de obtener la firma es dependiente del tipo de archivo. Si se trata de un fichero de texto podemos usar sigtool para generar la cadena hexadecimal a partir de un texto.


sigtool –hex-dump cadena_caracteres

Para obtener los opcodes de un ejecutables, tendremos que localizar la porción de código característica del malware y usar un desensamblador para obtener los opcodes. En Linux puede usarse objdump.


objdump -d MiMalware

Supongamos que el siguiente código obtenido con objdump fuera descriptivo de un malware.


  41d4b3: e8 b8 df fe ff        call   0x40b470
  41d4b8: 8b 7d 08              mov    0x8(%ebp),%edi
  41d4bb: 59                    pop    %ecx
  41d4bc: e9 05 04 00 00        jmp    0x41d8c6
  41d4c1: 8b 45 14              mov    0x14(%ebp),%eax
  41d4c4: 3b c6                 cmp    %esi,%eax

En este caso, la firma hexadecimal podría ser la siguiente.


MiMalware:6:*:e8b8dffeff8b7d0859e9050400008b45143bc6

El último formato de firma que presentamos son los almacenados en los archivos .ldb, que son las llamadas firmas lógicas y cuyo formato general es el siguiente.


nombre_malware;BloqueDescriptorDeObjetivo;Expresión_Lógica;Firma0;Firma1;Firma2;…

La siguiente es un ejemplo de firma lógica.


Unix.Trojan.Hanthie-3;Engine:51-255,Target:0;(0&(1|2));6d792024706964203d20666f726b3b206578697420696620247069643b(0a|20)2430203d2022(70307374666978|756e69782d6461656d6f6e|756e697864)5c3022;5b48616e64206f662054686965665d;2462756666203d20225c7830355c7830305c783030222e247261775f686f73742e247261775f706f72743b

El primer campo corresponde al nombre. En el segundo campo podemos indicar información adicional además de las firmas. En este caso Engine especifica las capacidades que debe cumplir el motor de clamAV y Target está indicando el tipo de archivo (los mismos que los vistos para las firmas extendidas).
Como podemos observar, este formato soporta múltiples firmas separadas por punto y coma (;), y el campoExpresión_Lógica permite especificar como se relacionan estas firmas. Se usan las típicas expresiones lógicas al estilo de C o Java.
En el ejemplo de arriba se usa la siguiente expresión (0&(1|2)), que significa que se debe coincidir con la firma0 Y con la firma1 O la firma2 (una de las dos).

Ya no tienes excusa para que la próxima vez que encuentres un malware o cualquier tipo de exploit te animes a contribuir con la comunidad de este magnífico proyecto.

Category: ANTIVIRUS | Los comentarios están deshabilitados en Creando firmas de virus para ClamAV