Du må være registrert og logget inn for å kunne legge ut innlegg på freak.no
X
LOGG INN
... eller du kan registrere deg nå
Dette nettstedet er avhengig av annonseinntekter for å holde driften og videre utvikling igang. Vi liker ikke reklame heller, men alternativene er ikke mange. Vær snill å vurder å slå av annonseblokkering, eller å abonnere på en reklamefri utgave av nettstedet.
  5 1967
Del I

Før du begynner å lese denne tråden, vil jeg anbefale følgende artikler:

1. RPC
2. i386 Systemkall
3. Hvordan få kode inn i kjørende applikasjoner

Skal i denne posten beskrive en metode for å få direkte aksess til kernelen til en annen maskin, og ikke måtte overføre forskjellige verktøy eller kalle lokale shell for å eie maskinen. Altså at man slipper alle former for payloads, ved å kun benytte et som gir et interface for alle de andre.

Metoden brukes i flere forskjellige sammenhenger, og er implementert i mange forskjellige verktøy. Deriblant Metasploit (Meterpreter).
Den ble første gang presentert under BlackHat i 2002, og brukes også i clustering av noen operativsystemer - for å raskt spre data over flere maskiner i et cluster.

Systemkall Proxy (syscall proxy) kan enkelt forklares med at du har alle applikasjoner på din egen maskin, men applikasjonenes systemkall blir utført mot en kernel på en annen maskin (enklest å benytte RPC til dette) - og ikke din egen.

Tenk f.eks. en applikasjon skal lese en fil lokalt. En operasjon du gjør flere ganger daglig, faktisk flere ganger i minuttet.
Applikasjonen sender da en stub_open() til sin systemkall klient, klienten sender en systemkall henvendelse til kernelens systemkall server som deretter sender en open() til kernelen som utfører en I/O operasjon mot driveren til disken, og dermed får dataene fra denne.

Men hva hindrer deg i å sende dette til kernelen på en annen maskin istedet, og kommunisere med den kernelens systemkall server?
Veldig lite...

Det å finne exploits er enkelt, bare surf litt på Milw0rm, så her er det altså snakk om hva du kan bytte ut payload i PoC eksempelet med...

Kan først si at Microsoft baserte OS, samt OS som IOS, benytter ikke-transparente systemkall. Man kan derfor ikke benytte systemkallproxymetoden under på samme måte der - men man kan fortsatte gjøre systemkall mot kernelen på disse operativsystemene. Men det blir seende mer ut som shellcode for win32 baserte OS.

Før dere blir blendet av alt det tekniske, kan jeg beskrive litt av potensialet for det over:

Hvis den lokale servicen du hacker gir systemkall proxyen din root tilgang, har du i praksis mer makt enn root. Du kan nemlig styre maskinen og dets prosesser med root tilgang, men lokal root vil aldri se dine prosesser fordi de kjører lokalt på din egen maskin, og systemkall proxyen kjører i minneområdet til den hackede applikasjonen.
Samtidig etterlater du omtrent ingen logger på maskinen, fordi logging gjerne er koblet til lokale applikasjoner og prosesser. Men siden du her ikke kaller '/bin/sh', så vil aldri events herfra bli logget. Du er altså über-root!

Men makten er enda større enn dette også! For hva om sårbarheten du utnytter ikke har tilgang til lokale applikasjoner eller shell? Med denne payloaden kan du fortsatt gjøre systemkall og dermed få tilgang til maskinen opp til et visst nivå (identiske rettigheter som applikasjonsbrukeren til applikasjonen du utnytter).

Så ved å bruke en systemkall proxy øker du tilgangene en sårbarhet eller ville gitt deg.

mwhahahahahaha!!


Så, over til materien.
I eksemplene nedover benytter jeg den samme pseudokoden som ble benyttet på BlackHat i 2002.
Denne beskriver dette konsepetet veldig bra, og samtidig er ikke dette rocketscience - så litt må dere kode selv også
(og er man lat, kan man laste ned systemkall proxyer og kompilere selv etter et par søk på google)

En systemkall server til Linux i pseudokode blir da omtrent:

channel = set_up_communication() [COLOR=Navy]#1.[/COLOR]
channel.send(ESP)
while channel.has_data() do
request = channel.read()
copy request in stack [COLOR=Navy]#2.[/COLOR]
pop registers
int 0x80
push eax
channel.send(stack) [COLOR=Navy]#3.[/COLOR]
Vis hele sitatet...
#1. Først må man sette opp kommunikasjonen. Ref. artikkel 1 øverst.
#2. Kopierer hele henvendelsen fra serverstacken
#3. Blokken med henvendelsen blir sent tilbake til klienten. Dette blir gjort for å returnere eventuelle OUT 3 arguments tilbake

Så kommunikasjon blir da seende omtrent ut som:

(dette er kun en loop med "les henvendelse - prosessering - skriv resultat")

push %ebx # fd

les_henvendelse:
mov %ebp,%esp
push %esp
xor %eax,%eax
movl $4,%edx # count

les_henvendelse2:
mov $3,%al # __NR_les
mov %esp,%ecx # buffer
int $0x80 # ingen error sjekk!
add %eax,%ecx # nytt buffer
sub %eax,%edx # byte som skal leses
jnz read_request2 # gjør if != 0
pop %edx # få antall bytes inn
sub %edx,%esp # hold av plass

les_henvendelse3:
movl $3,%eax # __NR_les
mov %esp,%ecx # buffer
int $0x80 # ingen error sjekk! [COLOR=Navy]#1.[/COLOR]
add %eax,%ecx # nytt buffer
sub %eax,%edx # byte som skal leses
jnz read_request3 # gjør if != 0

do: [COLOR=Navy]#2.[/COLOR]
pop %eax
pop %ebx
pop %ecx
pop %edx
pop %esi
pop %edi
int $0x80 [COLOR=Navy] #3.[/COLOR]
push %edi
push %esi
push %edx
push %ecx
push %ebx
push %eax

do_send_svar:
mov $4,%eax # __NR_les
mov (%ebp),%ebx # fd
mov %esp,%ecx # buffer
mov %ebp,%edx
sub %esp,%edx # count
int $0x80 # ingen error sjekk! [COLOR=Navy] #4.[/COLOR]

jmp les_henvendelse
pop %eax
pop %ebp
Vis hele sitatet...
#1. Les henvendelsen rett inn i ESP
#2. POP registers fra toppen av henvendelsen (henvendelsen er i stacken)
#3. Utfør systemkallet. EAX har allerede her systemkall verdien (det var en del av henvendelsen)
#4. Send tilbake svaret på henvendelsen.

Del II vil ta for seg en systemkall proxy for Windows.
Windows er en kombinasjon mellom et helt eget kapittel i denne saken, og ikke så veldig ulikt alikevel - når man først kommer ned i materien.
Utfordringen med Windows er den store mangelen på dokumentasjon fra Microsoft når det kommer til Native API i sine operativsystemer. Ikke bland dette med Win32 API, som er det interfacet de fleste applikasjoner til Windows benytter.

Grunnen til den manglende dokumentasjonen er selvsagt veldig åpenbar. Microsoft vil stå fritt til å kunne gjøre endringer i sin Native API, og vil ikke at noen andre enn dem selv skal benytte denne når de kommuniserer med kernelen. Dokumenterer de denne sier de samtidig at de vil supportere den, ha bakoverkompabilitet osv, slik status er for Win32 API.
Et godt eksempel som underbygger dette, er forskjellene i Native API mellom Windows NT4, Windows 2000, Windows XP og Windows 2003 iforhold til Win32 API på de samme versjonene.

(kommer ikke til å ta for meg Vista her, fordi Vista er for nytt for meg)

Gary Nebbett (en av verdens få gjenværende old school hackere) har derimot gjort mye av jobben for oss her, og har gjennom sine mange programmer og bøker vist veien. Han er heldigvis dyktig til å både dokumentere, dele kode og oppdatere verden når endringene kommer, så trenger man info om dypere funksjoner i Windows - så er det bare å lese hans kode og dokumentasjon.

Men for å summere fort, så kan man si at pga denne mangelen på dokumentasjon av funksjonalitet fra Microsoft, den helt absurde mengden funksjoner Microsoft har implementert (langt over 1000!!) og det faktum at store grupper av denne funksjonaliteten er deler av dynamiske biblioteker brukt i "user mode" - så refererer vi til "windows systemkall" for alle funksjoner i alle dynamiske biblioteker som er tilgjengelige for "user mode" prosesser.

Den største forskjellen i implementasjonen på Linux og Windows er at på Linux (og alle andre UNIX implementasjoner) benytter vi en INTEGER for å identifisere hvilke systemkall vi kan kalle, men på Windows finnes ikke dette (ihvertfall ikke som vi har tilgang til). Så proxyen under vil gi funksjonalitet nok til å kalle de funksjoner som er i prosessen man har utnyttet sitt minneområde.

Og allerede nå er det sikkert noen av dere, med litt mer erfaring med Windows enn normalt dødelige, som tenker "men vent nå litt".
For jo - initielt kan man kun kalle de funksjoner som er del av den DLL som allerede er lastet av prosessen...men, det er jo to spesielle funksjoner som ligger der; LoadLibrary og GetProcAddress!

The LoadLibrary function maps the specified executable module into the address space of the
calling process.

(...)

The GetProcAddress function retrieves the address of an exported function or variable from the
specified dynamic-link library (DLL).

—Windows Platform SDK: DLLs, Processes, and Threads
Vis hele sitatet...
Plutselig har man full tilgang gitt...og veldig rart ikke flere trojanere bruker denne metoden, for det fungerer. Det fungerer utrolig bra faktisk!

Dette blir da pseudokoden for en Windows Systemkallserver:

channel = set_up_communication()
channel.send(ESP)
channel.send(address of LoadLibrary)[COLOR=navy]#1.[/COLOR]
channel.send(address of GetProcAddress)[COLOR=navy]#2.[/COLOR]
while channel.has_data() do
request = channel.read()
copy request in stack
pop ebx
call [ebx] [COLOR=navy]#3.[/COLOR]
push eax
channel.send(stack)
Vis hele sitatet...


#1. #2. Adressene til LoadLibrary og GetProcAddress i serveren adresseområde blir sent tilbake til systemkall klienten du må lage, og klienten kan dermed bruke den generiske "kall alle mulige adresser" mekanismen implementert til å kalle disse funksjonene og laste hvilke som helst DLL'r fra din maskin inn i minnet til den hackede maskinen!
#3. Klienten sender den eksakte adressen til funksjonen den vil kalle i henvendelsen. Stacken er allerede forberedt på dette.

På denne måten kan altså en lignende server lages for Windows. Det å lage systemkall servere er altså ikke så veldig vanskelig, og makten du får er absurd - hvis du får inn disse som payload i et angrep. Men man har et par store utfordringer.
For det første må du ha mulighet til å kommunisere med målet, du må lage klienter som inneholder alle systemkall osv.

På Windows har man, som du kanskje begynner å forstå, den største utfordrigen. Basert på det ekstreme antallet systemkall man har må man lage en generisk klient som kan sende over alle mulige former for kall...være seg integers, pointers, structures, pointers til pointers til structures med pointers osv....

Så i starten vil jeg anbefale å benytte Metasploit sin Meterpreter.
Søk her for å finne info om denne:

Metasploit Payload List

Det finnes også en del grupper som jobber med utvikling rundt både klienter og servere i systemkall proxy settinger, og operativsystemer som QNX har det implementert som funksjonalitet i sine OS - så man har mange kilder og mye kode på nettet hvis man vil leke litt selv også.

Det er ihvertfall ingen tvil om at dette er en av de absolutt kraftigste payloadene man kan uploade gjennom et exploit, og klarer man å lage en stabil implementasjon har man så mye makt som er mulig å få over et operativsystem. Mer enn både root og administrator...

Lykke til!

Sitat av gunvar
Herlig, gleder meg til del II
det er en fin local Photoshop exploit på milw0rm jeg er keen på å teste ut på noen av kameratene. Hadde vært fint om jeg faktisk kunne gjort noe fancy på pc'ene deres etter å ha fått dem til å gå på exploiten.. fin artikkel
Vis hele sitatet...
Må innrømme at jeg ikke skrev artikkelen for at det skulle være lett å lage klipp og lim spøker med kompiser, fordi det å faktisk implementere denne formen for angrep - og da spesielt klientene, er ekstremt komplekst.
Skrev det derfor mest for å spre budskapet om at denne metoden er utrolig kraftig, at den er kanskje det ypperste innenfor angrepsmetodikk for de som behersker den - og for å forklare litt hva som faktisk er mulig.

Løsningen for deg er derfor å benytte Metasploit, hvis du ikke selv er en erfaren koder - og begynner å forstå metodene som ligger til grunn her. Da kan du selvsagt more deg

For disse metodene er absolutt i bruk...og en hacker som kan benytte denne metoden, kan bevege seg gjennom et system uten å etterlate spor andre steder enn et par logglinjer i brannmurer, ids systemer o.l. Sjelden så mye som en linje i en OS logg om hva vedkommende faktisk har gjort.
Sist endret av Carrier Return; 12. juni 2007 kl. 22:46.
Sitat av Carrier Return
(...)Må innrømme at jeg ikke skrev artikkelen for at det skulle være lett å lage klipp og lim spøker med kompiser, fordi det å faktisk implementere denne formen for angrep - og da spesielt klientene, er ekstremt komplekst.
Skrev det derfor mest for å spre budskapet om at denne metoden er utrolig kraftig, at den er kanskje det ypperste innenfor angrepsmetodikk for de som behersker den - og for å forklare litt hva som faktisk er mulig.

Løsningen for deg er derfor å benytte Metasploit, hvis du ikke selv er en erfaren koder - og begynner å forstå metodene som ligger til grunn her. Da kan du selvsagt more deg (...)
Vis hele sitatet...
Forstår at denne metoden kanskje er litt vel drøy for å bare kødde med kompisene mine, men det kunne jo ha vært gøy å prøve å skrive en form for implimentasjon av dette. Selv om jeg merker assembly-skillsa mine er litt for fraværende til å i det hele tatt forstå mesteparten av "les henvendelse - prosessering - skriv resultat"-eksempelet du viser i del 1.

Synes bare det virket så mye enklere enn det det faktisk viste seg å være etter å ha lest del 1. Skal lese litt mer og se om ikke dette faktisk kan være mulig for meg, selv om jeg tror nok nå at dette er noen hundre meter over min league. Bra artikler uansett *KP*
(Skal lese litt på artiklene du linker til jeg tror jeg, og se om jeg kanskje forstår no av RPC.)
Sist endret av gunvar; 13. juni 2007 kl. 23:26.
@Gunvar:
man trenger jo ikke legge med "all" funskjonalitet i første versjon.
F.eks. er det enklere å bare lage en filbrowser med kun mulighet til å kopiere ut eller legge inn filer i starten, enn å skulle ha alle systemkall som er støttet av windows. Og allerede da kan man ha mye moro.

Legg også merke til at jeg oversatte og stykket opp deler av koden i "les henvendelse - prosessering - skriv resultat" eksempelet for å utheve funksjonalitetene. Så legge merke til at jnz kaller "read_request2" og ikke "les_henvendelse2" f.eks.. Skrev det kun slik for at det skulle være mer oversiktlig å lese.

Skal lage oppskrifter på en del annet fremover. Er det mest windows folk er interessert i, eller skal jeg dekke litt linux/*nix også?
Vil også anbefale alle som har lyst til å leke mer på dette nivået om å sjekke ut Pluf sin artikkel på Milw0rm.

Kom i fjor, og er veldig omfattende:

Linux Per-Process Syscall Hooking

Som hacker, scriptkiddie, sikkerhetstester eller whatever, så er det en styrke å kunne leke på dette nivået - fordi det gir en utrolig mye bredere forståelse av hva som skjer når man gjør det man gjør.
Samtidig hjelper det hvis man vil skrive om exploits til å passe det man selv vil oppnå.
▼ ... mange måneder senere ... ▼
Ser at nivået de siste månedene har steget en god del her inne.
Kanskje noen flere har lyst til å bidra i denne tråden også...eller legge til andre ting rundt payload som kan være nyttig ved buffer overflows.