Ein alter Bekannter (Xaitax und DocFX) haben mal für alle Programmierer, die sihc schwer tun, eine Frau anzumachen, mal ein kleines Manual geschrieben.
|=---------------------=[ The ultimate w0men r00ting pap3r]=------------------=|
|=----------------------------------------------------------------------------=|
|=-----------------------=[ xaitax | sticky bit | DocFX ]=--------------------=|
|=----------------------------------------------------------------------------=|
1.) Vorwort
2.) Der Scan der zu r00tenden host-Ess
3.) Der Source fuer den Scan
4.) Der Host-ess r00t
5.) Das r00t Exploit incl. Description
----------------
|- 1.) Vorwort |
----------------
Hey Leute, hier endlich das langersehnte w0mens r00ting pap3r. Da eine
unglaublich grosse Nachfrage besteht, wollen wir euch nun endlich mal einen
grossen Einblick in die Welt des Frauen r00ten zeigen und geben. Leider koennen
wir euch keine praktischen Beispiele geben, aber das schafft ihr auch mit
unserer step-by-step Anleitung. 😉 Es ist aus lauter Mitleid und Einsicht in
euch von xaitax, DocFX und sticky bit in einer laengeren Phase, dank
Urlaubsverzoegerungen(ok, ja es war Faulheit 😛), in voller Hingabe geschrieben
wurden. Aber kommt als Mann niemals auf die Idee nach dieser Anleitung bei
jemandem Gleichgeschlechtlichen einzur00ten. 😉 Das koennte braune Konsequenzen
nach sich ziehen. Und das wollen wir dann doch nicht riskieren. Der sogenannte
_Black Hole Bug_. Ein bekannter und immer weiter verbreiteter Vulnerability.
--------------------------------------
|- 2.) Der Scan der zu r00tenden Box |
--------------------------------------
Nun als erstes muessen wir uns ueberlegen bei welcher Box wir einr00ten wollen.
Dazu muessen wir mehrere Vorgaenge vornehmen. Als erstes sollten wir in ein
Board gehen, auch wenn wir da evtl. 10 Byte Eintritt bezahlen muessen. Aber da
dort eine Menge Traffic herrscht, haben wir sicherlich mehr Erfolg als sonst wo.
Als erstes muessen wir das Layout checken, denn erst dann koennen wir anfangen
die Host-ess'en zu scannen. Wenn man sich mehrere Layer anschaut trifft man auf
die diversesten Host-ess'en. Wir sollten uns genau umschauen in welchen
Kategorien wir auf die meissten Host-ess'en treffen koennten. Moeglicherweise
wirst du auch auf diverse *.mid Sounds aus allen Ecken treffen. Um auf das Board
zu kommen werden wir das entsprechende POP6 Protokoll nutzen.
---------------------------------
|- 3.) Der Source fuer den Scan |
---------------------------------
/******************************************************************************/
#include <communication.h>
#include <clothes.h>
#include <smilefaces.h>
#include <money.h>
#include <alkohol.h>
#ifdef _HASCAR_
#include <drivingskills.h>
#else
#include <bike.h>
#include <oepnv.h>
#endif
/******************************************************************************/
class Person {
private:
char[64] name;
short unsigned int age;
bool male;
float PromilAlk;
int Money;
void WalkToLocation(CLocation aLocation);
public:
CLocation Location;
CClothes clothes;
int GetAge();
int GetMoney(int count);
void PrepareNight();
bool ConnectBoard(CBorad board);
}
/******************************************************************************/
void Person::WalkToLocation(CLocation aLocation)
{
int i;
SetWalkDirectory(aLocation,Location);
while (aLocation!=Location) {
MakeStep();
if (PromilAlk>1) {
SetWalkDirection(WalkDirection+Random(PromilAlk));
}
}
}
/******************************************************************************/
int Person::GetAge()
{
if (male) {
return age;
} else {
switch (age) {
case 15..18: return age+2;
case 24..40: return age-3;
else return age;
}
}
}
/******************************************************************************/
int Person::GetMoney(int count)
{
Money-=count;
return count;
}
/******************************************************************************/
void Person:😛repareNight()
{
CClothes cl;
TakeShower(this);
DryHair(this);
StyleHair(this);
ShaveFace(this);
me.clothes=SelectClothes(this,QUALITY_REALLY_GOOD);
}
/******************************************************************************/
bool Person::ConnectBoard(CBorad board)
{
if (age<18) {
if (!(SendMessage(MOMS_HANDLE,
this,
board.Handle,
PLEASE_LET_ME_GO_TONIGHT) == IS_OK)) {
return false; // shit happens.
// hope it'll work tomorrow
}
}
#ifdef _HASCAR_
DriveToLocation(board);
#else
CBike b;
if (b.CheckForPunktire) {
GoByBike(Board);
}else{
if (Money>50) {
GoByBus(Board);
}else {
WalkToLocation(Board);
}
}
#endif
while (Friends.Location!=Board) { Delay(10); }
if (age<18) {
try {
Duck();
Hide(BEHIND_FRIENDS);
WalkToLocation(Board.Entrance);
} except {
return false; // fuckin keeper...
}
} else {
WalkToLocation(Board.Keeper);
Say("hi, isn't it a nice day today?");
Smile();
if (WaitForAnswer()!=ERR_TIMEOUT){
Chat(Board.Keeper);
// this is better for a good connection...
}
WalkToLocation(Board.Entrance);
}
if (!Pay(Board.Entrance)) return false; //not enugh money
return true; // yeah! connected....
}
/******************************************************************************/
int Main()
{
CBoard b;
CPerson me; // ha! this is me!
// ------------- you have to customize this part! -----------
// if you dont have your own values the program properly crashes!
me.name="Peter";
me.age=18;
me.male=true;
me.PromilAlk=0;
me.Location=Home;
me.Money=100;
b.Name="Metropol";
// -----------------------------------------------------------
me.PrepareNight();
if (!b.Exists()) {
return 1; // Err, board not found
}
if (!me.ConnectBoard(b)) {
return 2; // Err, unable to connect
}
b.KeepClothes(me.UnncessarryClothes, me.GetMoney(1));
me.Chat(Friends);
me.WalkToLocation(Board.NextChair);
me.LookAt(OBJECT_ALL);
if (Similar(Answer,"What are u stearing at?")) {
Say("oh, nothing. just wondering if the dj will ever play good musik");
me.TurnAround();
}
if (!me.male) {
return 3; // Err, femal objects are currently not supported
}
Board.AddBoy(me); // now i'm available
int i;
CPerson* Girl,MyGirl,tmp;
MyGirl = NULL;
for (i=0; i<Board.GirlCount; i++) {
Girl=&Board.Girl;
me.LookAt(*Girl);
if (!(me.IsNiceView() && Girl->isBeautifoul)) {
continue;
}
tmp=Board.GetNearestObject(Girl->Location);
if (tmp->male) { // fuck, properly she is alredy busy :-(
if (me.Braveness<EXTREME_LARGE) {
continue;
}
}
switch(Girl->Location){
case(Board.Bar):
CDrinks[2] c;
me.WalkToLocation(Board.Bar);
c = me.Buy(Bar.Drink,me.GetMoney(4),2);
me.Give(*Girl,c[0]);
me.Drink(c[1]);
me.Chat(*Girl);
me.Ask("Wanna dance?");
if (!(Similar(Girl->Answer,"Sure!"))) {
me.Say("My friend saied, u can dance so beautifoul i cant imagine...");
me.Say("so, i want u to prove it...");
if (Similar(Girl->Answer,"Fuck Up!")) {
continue;
}
}
break;
case(Board.DancFloor): // just right
break;
case(Board.Toilet):
// not yet implemented
break;
else // not yet implemented
break;
}
// Girl->WalkToLocation(Board.DanceFloor); // :-( Err, NoAccess
me.WalkToLocation(Board.DanceFloor);
me.WaitForObject(*Girl);
if (Girl->Location != me.Location) {
continue;
}
me.Put(me.HandyNumer,Girl->HandPocket);
me.Dance();
me.LookAt(*Girl);
me.Dance();
if (Girl->LooksAtObject(me)) {
me.Dance(*Girl);
me.Whisper("u r so beautifoul");
me.keepDancin();
} else {
continue;
}
me.Take(Girl->Hand);
me.WalkToLocation(Board.Sofa);
do {
CDrinks[2] c;
c = me.Buy(Bar.Drink,me.GetMoney(4),2);
me.Give(*Girl,c[0]);
me.Drink(c[1]);
me.Chat(*Girl);
} until ((me.PromilAlk>1) && (Girl->PromilAlk>1.5));
me.Kiss(*Girl);
MyGirl=Girl;
}
if (MyGirl!=NULL) {
// and here u can do what ever u wanna do... cause u r the winner....
} else {
// loooser
me.WalkToLocation(Home);
}
}
-------------------------
|- 4.) Der Hostess-r00t |
-------------------------
Um eine Host-ess zu rooten nuetzen wir das auf allen Host-essen implementierte
POP6 Protokoll, normaler Weise ist dieses jedoch nicht unter Verwendung, bzw.
fuer oeffentlichen Gebrauch freigegeben.
Also was tun?
Nun der Trick an der Sache ist folgender, ueber ein anderes Protokoll, welches
auf der Host-ess fuer oeffentliche Kommunikation freigegeben ist, speisen wir
Sequenzen ein, die den im Hauptprozessor verankerten Wunsch zur Erstellung von
geforkten Prozessen (auch wenn wir die normalerweise nicht wollen!) und damit
der effizientern Aufteilung der Rechenlast so wie dem Aufrecht erhalten der
Berechnungen. Der Aufruf solcher Forking-Prozess-Einleitenden-Operationen ist
ein im BIOS fast jeder Host-ess gespeichertes Feature, das standardmaessig
ausgeliefert wird. Selbst wenn der Administrator einer Host-ess von der Gefahr
dieses Features weiss, kann er es fast nie abstellen und oft nur schlecht
eindaemmen.
Und wie machen wir das jetzt genau?
Anzunehmen ist, dass bei den meissten Hostessen das HTP (Human Talk Protocol)
implementiert und oeffentliche Daemons frei gegeben sind. In der Praxis ist das
zu 99% Prozent der Fall.
Jetzt kommt die Arbeit. Wir muessen also nun unser "Opfer" genau ueberpfuefen.
Das ist leider von Host-ess zu Host-ess sehr sehr unterschiedlich, einigen
wenigen soll sogar der blosse Wunsch zum Protokollwechsel auf POP6 auf der HTP
Ebene genuegen um den POP6 Demon zu starten und gut "geoelt" frei zu geben, auch
wenn dies in der Praxis eher selten der Fall sein duerfte. Dies ist auch eine
nicht unbedingt zu empfehlende Vorgehensweise, denn oft fangen
Host-ess'en-interne Firewalls diese Anfrage ab und loggen euch als potenziellen
r00t'er. Das dann jede Kommunikation mit der Host-ess geblockt wird sollte klar
sein.
Wichtig ist, dass ihr euch nun eine gute Strategie ueberlegt. Sendet dazu
einfach ein paar unverbindliche Anfragen auf Files unterschiedlicher Typen,
moeglichst breit gefaechert (tut so als seit ihr ein Mann von Welt-Weit-Web),
und findet heraus auf welche Typen die Host-ess besonders arbeitsintensiv
reagiert, leider ist es in der Praxis oft schwer zu erkennen, denn einige Typen
reagieren auf gewuenschte Anfragen mit schnellerer Berechnung, andere leider mit
langsamerer Berechnung, da sie noch einige Pruefroutinen dran haengen. Aber der
Einsatz eines Host-ess'en Scanners (Listing 0.0) sollte hier Klarheit bringen.
Habt ihr einen Filetyp erkannt auf den eure Wunsch Host-ess spezialisiert ist,
solltet ihr Interesse an diesem Typ zeigen und evtl. auch Files diesen Typs
anbieten. Werdet dabei aber nicht einseitig, auch ein paar andere Filetypen, oft
verwendet wird z.B. *.joke, sollte immer dabei sein, um ein einfrieren der
sowohl fuer eure Maschiene als auch die des Objektes arbeitsintensiven Prozesse
zu verhindern. Auch hier sollte der Scanner Klarheit geben koennen wie
die Auslastung auf dem Host gerade ist, und ob ihr noch Einen drauf legen
koennt/muesst.
Auch ist u. U. der Einsatz anderer Protokolle ausser dem HTP notwendig, aber das
solltet ihr inzwischen von eurer Host-ess wissen.
Bei manchen Host-ess'en kann der Anteil der zu sendenden Files allerdings derbe
in die Resourcen gehen, besonders wenn es eine hartnaeckige Host-ess ist oder
der Admin hinterlistig ist. Vom verschicken von Hardware raten wir ab, das
fuehrt oft zu nichts und ist nur dazu da eure Maschiene auszuschlachten, ihr mue
sst hier halt abwaegen was was wert ist. Stellt die Host-ess nun selbststaendig
Anfragen an eure Daemons ist es eigentlich schon fast geschafft. Wir haben jetzt
eine Layer3 bis Layer4 Kommunikation mit der Host-ess machen koennen. Dieses ist
allerdings noch nicht das was wir wollen, denn wir wollen ja Layer2 oder gar 0.
😉
Jetzt kommt der in Listing 0.0 gezeigte Exploit zum Einsatz, vorher ist es
allerdings noch ratsam abzuwarten bis alle anderen Verbindungen der Host-ess
geschlossen (evtl. sind da auch grad andere am r00ten, das koennte boese enden.
Vorher checken!) sind und ihr euch in einer gesicherten Umgebung befindet, denn
das erhoeht die Erfolgschancen, aber wer'n Abenteuer sucht, bitte!
Dieser Exploit, wohl gemerkt nur eine Basis Version schickt nun unter HTP
Sequenzen an die Host-ess, welche normalerweise ungefiltert in die CPU gehen und
im Hintergund von oben erwaehnten BIOS-Feature ueberwacht werden.
Ob das BIOS nun auf einen solchen Arbitary-Code reagiert haengt von den
Sequenzen ab und auf welchem Layer der Kommunikation ihr euch befindet. Um hier
gute Strategien zu entwickeln bedarf es viel Erfahrung, welche Sequenzen was
bewirken koennen. Springt das BIOS auf den Code an, so wird es im Hauptprozessor
den POP6 einspeisen und euch auf den Pprotokollwechsel aufmerksam machen. Der
Exploit verbindet euch nun mittels POP6 auf den Port 1 (bei f Typen!) und voila,
ihr seid drinnen! Nach ein wenig hin und her koennt ihr dann euer Zeug da
lassen, mehr oder weniger, denn um die leider weit verbreiteten geforkten
Child-Prozesse zu vermeiden benutzt der Exploit einen Schutz-Mechanismus, der
diese und noch andere Nebeneffekte verhindert, allerdings ist der ultimative
Zugriff damit nicht moeglich. Naeheres dazu aber in der Anleitung des Exploits.
Ob ihr nun eine Layer0 oder nur eine Layer1 oder 2 Verbindung hattet ist schwer
zu sagen, auch hier kommt es wieder auf die Erfahrung an, manche BIOS'e in den
Host-ess'en sind so eingestellt, dass sie einen solchen Zugriff nur auf Level0
zulassen, manche auch auf 1 oder 2 ...
Solltet ihr eine Layer1 und Layer0 Verbindung erreicht haben, d.h. ihr werdet
danach getrustet und je nach Host-ess evtl. der einzige Kommunikationspartner
fuer POP6, haben wollen koennt ihr versuchen die I-Love-You Backdoor einzubauen,
naeheres dazu in Listing 0.0. Bedenkt aber dabei, dass ihr dann evtl. nur noch
fuer POP6 Kommunikation mit dieser einen Host-ess zu gebrauchen seid, denn
manche Host-ess'en reagieren mit zuruecksetzen der Verbindung auf Layer3 oder
gar hoeher, wenn sie eine POP6 Kommunikation von euch zu anderen Host-essen
heraus finden. Auch ist diese Backdoor nur auf der HDD gespeichert und wie das
mit Magnetspeichern so ist, da ist leider nichts auf Dauer.
-------------------------------------------
|- 5.) Das r00t exploit incl. Description |
-------------------------------------------
#!/usr/bin/perle
use Con::Con;
use Socket;
$your_bunny = 'na wer wohl?';
$geschwaetz = 'was sie halt hoeren will...';
socket (F, PF_INET, WRD_STREAM, getprotobyname('htp'));
connect (F, sockaddr_in(4, inet_aton($your _bunny)));
while ($f !~ /switching protocol: pop6/){
send (F, "$geschwaetz\r\n\") || die;
$f = <F>;
}
close F;
socket (F, PF_INET, LIQ_STREAM, getprotobyname('pop6'));
connect (F, sockaddr_in(1, inet_aton($your_bunny)));
&Con::Con:😀OM(1);
send (F, "~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)~<)") || die;
close F;
print "\a";
exit;
# Zur Benutzung:
# Passt als erstes die Variablen in Zeile 6 und 7 auf eure Host-ess an.
# $your_bunny bekommt den Host-ess'ennamen des zu rootenden Objektes,
# $geschwaetz solltet ihr dem zu rootenden Objekt anpassen. Bei vielen
# Maschienen tut es die Zeichenfolge 'r0man+!5ch3523ux' aber das kann
# stark varieren. Fuer manche Objekte, z. B. SM-Host-essen, kann es sogar
# noetig sein, statt der ueblichen ASCII Zeichenfolgen handfeste Bitwerte
# mit BEAT-Sequenzen zu senden und ggf. ein anderes Protocol fuer den
# ersten Sendevorgang zu verwenden. Bei gut gesicherten Maschienen kann es
# vorkommen, das eine einzige Zeichenfolge nicht ausreicht, sondern diese
# immer wieder, evtl. sogar nach Challenge-Response Verfahren neu generiert
# werden muss. Ihr solltet also ueber eure Host-ess Bescheid wissen und
# immer bedenken, dies ist nur ein Basic-X-Ploit!!!
#
# Wichtig ist noch der Import des Con::Con:😀OM-Moduls in Zeile 3 und
# der Aufruf seiner Subroutine DOM in Zeile 21.
# Dieses Modul ermoeglich eine sichere Verbindung. Dies dient vor allem
# dazu das evtl. unerwuenschte Loggen zu verhindern, bei dem u. A.
# Forking-Prozesse entstehen koennen, die euch Anhand eindeutiger
# DNS-Lookups als r00ter enttarnen koennen, und dann koennt ihr euch
# ewig und drei Tage um so 'nen scheiss Child-Prozess kuemmern.
# Ausserdem schuetzt euch diese Routine vor evtl. installierter Malware,
# die sich versuchen wird auf eurer Maschiene zu installieren.
# Nachteil ist allerdings, dass der Sandkasteneffekt der durch die Routine
# entseht. D. h. ihr bekommt nur einen virtuellen Schreibzugriff.
# Bei Maschienen mit denen ihr oeffters kommunizieren wollt solltet ihr
# daher unbedingt einen PILL-Driver installieren, und den Aufruf
# dieser Routine entfernen. Aber Vorsicht, leider sind nicht alle Host-ess'en
# mit diesem Treiber kompatibel und bevor ihr die ganze Maschiene kaputt
# macht...
#
# Naja was gibts noch, ach ja, dies ist ein X-Ploit fuer Typ f Host-essen,
# Wer es fuer Typ m Host-essen (es gibt keinen Port 1, also leicht zu
# erkennen) verwenden will sollte sich vorher nochmal in dieses Thema genau
# einlesen und den X-Ploit ggf. anpassen.
#
# OK, also nochmal dran denken, das ist nur ein Basic-X-Ploit und kackt
# uns nicht an wenn es nicht den gewuenschten Effekt hat.
#
# Also dann wenn ihr das alles begriffen habt und ihr euch sicher seid,
# dann ruft dieses Skript, wie es auf eurem OS ueblich ist, auf und feucht
# froehliches r00ten!
# X-Ploit ggf. anpassen.
-------------
|- Authors: |
-------------
-| xaitax - [email protected]
-| sticky bit
-| DocFX - [email protected]
