==============================================================================
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
--------------------[ previous ]---[ index ]---[ next ]---------------------


浜様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様
藩HACKiNG様様様様幼陳陳陳陳 iNTR0DUZi0NE Ai DATAPiPE 陳陳陳陳陳様様様様様様様夕

Per capire il funzionamento di un datapipe bisogna aver prima chiaro il
concetto di pipe: nelle shell un pipe serve per una gestione completa e
corretta dell'input e dell'output, e in particolare permette di passare dati
da un comando all'altro, consentendo quindi di utilizzare l'output di un
programma come input di un altro: un pipe insomma non svolge altro che una
funzione di condotto tra due flussi di dati. 
In Unix e sistemi Unix like il pipe nelle shell e' espresso con il carattere
'|'. Facciamo un esempio per chiarire meglio il concetto:
supponiamo di volere mandare il nostro file delle password a un nostro amico,
utilizzando il mail transfer agent di Linuz, mail, anziche' utilizzare un mailer
e fare un file attach; ci bastera' scrivere:

$ more /etc/passwd | mail amico@pirla.com
    |       |         |        |
    |_ comando per vedere a schermo il contenuto di un file (simile a type
	    |	      |	       |	                     del DOS)
 	    |_ file che vogliamo vedere con il comando more
                      |        |
                      |_ mail transfer agent
                               |
                               |_ indirizzo di posta del nostro amico :)

In questo caso ridirigiamo attraverso il pipe l'output di 'more
/etc/passwd', ovvero il contenuto del passwd, verso il comando mail che lo
utilizzera' come input, in questo caso come corpo del messaggio indirizzato
a amico@pirla.com.
Chiarito il concetto di pipe, passiamo ora al funzionamento di un datapipe.
Innanzitutto bisogna definirlo: un datapipe e' un programma che consente di
ridirigere una connessione verso un determinato server. Possiamo
schematizzare il tutto come segue:

A nostro computer
B server che ospita il datapipe
C server "vittima", ovvero server su cui la connessione viene dirottata

Quindi: 
	1- A chiama B (a una determinata porta che avrete scelto)
	2- B mette in contatto A con C

Sul server C siete quindi loggati con l'IP di B. Il datapipe funzia, come
visto per i pipe, da condotto, da tramite... vediamo ora come sfruttare questa
situazione! :)
Per cominciare, di cosa avete bisogno... allora:

* una shell (che sia in grado di compilare il codice del datapipe :)
* un datapipe (vedete poi! :)

...a questo punto vi chiederete cosa fare... :) beh ora ve lo spiego! :)
Per prima cosa uppate il codice del datapipe sul server B via FTP o forse
meglio con un copia/incolla + cat via telnet! :) ...un altro metodo sicuro
e' farlo via mail...spedite una mail con attach il codice del datapipe alla
vostra shell! :) N.B. se uppate via FTP occhio all'xferlog o wu_ftp.log ! :)
Ora non dovete fare altro che compilare il codice del datapipe e
eseguirlo...:) Solitamente i datapipe richiedo 3 parametri: 

	1) local port: e' la porta locale, ovvero la porta che utilizzerete
		       per ridirigere la connessione (sul server B)
	2) remote host: e' il server su cui volete ridirigire la connessione
			(server C)
	3) remote port: e' la porta (del server C) a cui vi collegherete

Vi sono poi datapipe che vi consentono di loggare le connessioni e altre
cosette ...ma a noi non importa, anzi non vogliamo che questo accada! :)
...il codice che allego scarica la connessione sul server C e niente altro...
...insomma, no logging!
Ora che sapete usare un datapipe, vi chiederete: cosa ce ne facciamo?
Semplice, potete utilizzarlo per spoofarvi! Su IRC o su un qualsiasi server
che avrete impostato come server C! :) (il remote host!)...e il vostro IP
"reale", quello che l'ISP vi assegna, se saprete sfruttare adeguatamente il
server B, non verra' loggato da nessuna parte! :) ...sfruttare adeguatamente
il server B, vuol dire non lasciare nessuna traccia nell'history file,
nell'utmp e wtmp eccetera eccetera... :)

Ecco il codice del datapipe da compilare :


}---------------------------------> INIZIO <----------------------------------{

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <netdb.h>
 
#include <linux/time.h>
 
#undef STRERROR
#ifdef STRERROR
extern char *sys_errlist[];
extern int sys_nerr;
char *undef = "Undefined error";

char *strerror(error)  
  int error;
{
  if (error > sys_nerr)
    return undef;
  return sys_errlist[error];
}
#endif

main(argc, argv)
  int argc;
  char **argv;
{
  int lsock, csock, osock;
  FILE *cfile;
  char buf[4096];
  struct sockaddr_in laddr, caddr, oaddr;
  int caddrlen = sizeof(caddr);
  fd_set fdsr, fdse;
  struct hostent *h;
  struct servent *s;
  int nbyt;
  unsigned long a;
  unsigned short oport;

  if (argc != 4) {
    fprintf(stderr,"Usage: %s localport remoteport remotehost\n",argv[0]);
    return 30;
  }
  a = inet_addr(argv[3]);
  if (!(h = gethostbyname(argv[3])) &&
      !(h = gethostbyaddr(&a, 4, AF_INET))) {
    perror(argv[3]);
    return 25;
  }
  oport = atol(argv[2]);
  laddr.sin_port = htons((unsigned short)(atol(argv[1])));
  if ((lsock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
    perror("socket");
    return 20;
  }
  laddr.sin_family = htons(AF_INET);
  laddr.sin_addr.s_addr = htonl(0);
  if (bind(lsock, &laddr, sizeof(laddr))) {
    perror("bind");
    return 20;
  }
  if (listen(lsock, 1)) {
    perror("listen");
    return 20;
  }
  if ((nbyt = fork()) == -1) {
    perror("fork");
    return 20;
  }
  if (nbyt > 0)
    return 0;
  setsid();
  while ((csock = accept(lsock, &caddr, &caddrlen)) != -1) {
    cfile = fdopen(csock,"r+");
    if ((nbyt = fork()) == -1) {
      fprintf(cfile, "500 fork: %s\n", strerror(errno));
      shutdown(csock,2);
      fclose(cfile);
      continue;
    }
    if (nbyt == 0)
      goto gotsock;
    fclose(cfile);
    while (waitpid(-1, NULL, WNOHANG) > 0);
  }
  return 20;

 gotsock:
  if ((osock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
    fprintf(cfile, "500 socket: %s\n", strerror(errno));
    goto quit1;
  }
  oaddr.sin_family = h->h_addrtype;
  oaddr.sin_port = htons(oport);
  memcpy(&oaddr.sin_addr, h->h_addr, h->h_length);
  if (connect(osock, &oaddr, sizeof(oaddr))) {
    fprintf(cfile, "500 connect: %s\n", strerror(errno));
    goto quit1;
  }
  while (1) {
    FD_ZERO(&fdsr);
    FD_ZERO(&fdse);
    FD_SET(csock,&fdsr);
    FD_SET(csock,&fdse);
    FD_SET(osock,&fdsr);
    FD_SET(osock,&fdse);
    if (select(20, &fdsr, NULL, &fdse, NULL) == -1) {
      fprintf(cfile, "500 select: %s\n", strerror(errno));
      goto quit2;
    }
    if (FD_ISSET(csock,&fdsr) || FD_ISSET(csock,&fdse)) {
      if ((nbyt = read(csock,buf,4096)) <= 0)
	goto quit2;
      if ((write(osock,buf,nbyt)) <= 0)
	goto quit2;
    } else if (FD_ISSET(osock,&fdsr) || FD_ISSET(osock,&fdse)) {
      if ((nbyt = read(osock,buf,4096)) <= 0)
	goto quit2;
      if ((write(csock,buf,nbyt)) <= 0)
	goto quit2;
    }
  }

 quit2:
  shutdown(osock,2);
  close(osock);
 quit1:
  fflush(cfile);
  shutdown(csock,2);
 quit0:
  fclose(cfile);
  return 0;
}

}*---------------------------------> FINE <----------------------------------{

Per concludere, un paio di note: 
1) ricordatevi che il processo del datapipe puo' esser visto dal system
administrator con un semplice ps -ax; per ovviare a questo problema potete o
utilizzare le tecniche esposte nell'articolo di PiGPeN73 "Come nascondersi
nei sistemi unix" o forse meglio ancora in aggiunta a queste tecniche,
scrivere uno script o un programmino che se chiamato con dei parametri, che
solo voi saprete, sara' in grado lanciare il datapipe! :) ...e al ps -ax il
sysadm vedra' solo il vostro prg anziche' il datapipe! :) 
se poi rinominate il vostro prg con qualche nome del tipo xtern probabilemente
il sysadm non se ne accorgera' nemmeno! :)
2) mettete il datapipe in una directory sperduta, meglio se di un altro
utente (fate voi! :)
3) se utilizzate il datapipe verso piu' server ricordatevi di killare i
processi che non vi servono piu' (solitamente con kill -HUP )...
...avrete piu' possibilita' di non essere sgamati! :)

In alternativa a tutte queste pallose note potete utilizzare il rootkit (non 
per tutti gli os esiste) per nascondere il processo ! :) 

Alla prossima... :) 

_EOF_
                               bELFaghor Nocturnus Daem0n

--------------------[ previous ]---[ index ]---[ next ]---------------------
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
==============================================================================