Die Anfrage an die API wird mittels GET Parametern gemacht. Die Antwort kann in den Formaten XML, JSON und VDF ausgegeben werden.

Ein für Serveroperatoren sehr interessanter Teil ist leider nicht dokumentiert. Mittels der Valve Developer WIKI kann man zu SteamApps Versionsnummern mit der aktuellen abgleichen lassen. Im Fall von Counter-Strike: Source würde eine Abfrage mit XML folgendermaßen aussehen:

https://api.steampowered.com/ISteamApps/UpToDateCheck/v0001/?appid=240&version=1.0.0.69&format=xml

Die aktuelle Version ist 1.0.0.70. Deswegen ist die XML Antwort:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE response>
<response>
	<success>true</success>
	<up_to_date>false</up_to_date>
	<version_is_listable>false</version_is_listable>
	<required_version>10070</required_version>
	<message>Your server is out of date, please upgrade</message>
</response>

Fragt man mit einer aktuellen Version nach:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE response>
<response>
	<success>true</success>
	<up_to_date>true</up_to_date>
	<version_is_listable>true</version_is_listable>
</response>

Mittels der API kann man sich also relativ einfach ein Script schreiben, dass die lokale Serverversion mit der aktuellen abgleicht. Im Folgenden wird dann je nach Output reagiert. Wenn “up_to_date” “False” ist, kann z.B. ein Update gestartet werden.

Eine sehr einfach Möglichkeit hatte ich vergessen. Mit dem Programm dmidecode kann man die Hardwareinformationen seines Servers auslesen. Manchen Images enthalten es bereits. Bei anderen muss es noch installiert werden.

Die interessanteste Ausgabe ist die des Systemherstellers. Der Befehl dazu lautet:

dmidecode -s system-manufacturer

Auf einem mit VMWare virtualisiertem System ist die Ausgabe:

dmidecode -s system-manufacturer
VMware, Inc.

Bei Virtuozzo hingegen ist ein Zugriff auf diese Informationen gar nicht erst möglich:

dmidecode -s system-manufacturer
/dev/mem: Permission denied

Auf einem dedizierten Server von Fujitsu ist die Ausgabe:

dmidecode -s system-manufacturer
FUJITSU

Auch MSI Mainboads melden sich entsprechend:

dmidecode -s system-manufacturer
MSI

Steam-Service wird installiert

Zum korrekten Ausführen von Steam mit dieser Version von Windows muss die Steam-Service-Komponente innstaliert sein.
Für die Installation der Service-Komponente sind Administratoren-Zugriffsrechte erforderlich.

SERVICE INSTALLIEREN ABBRECHEN

Ich war erstmal reichlich verwundert, zumal Steam dies bisher nicht getan hatte. Bevor ich auf den Button “SERVICE INSTALLIEREN” klicke, wollte ich erst einmal wissen, ob dieses Fenster überhaupt zu Steam gehört, oder mir etwas untergeschoben worden ist. Mein Nutzerverhalten kann man zwar als vorsichtig bezeichnen, dennoch kann man nie wissen, was man sich trotzdem eingefangen haben könnte.

Eine Google Suche brachte nichts 100% konkretes zu Tage. Man konnte aber sehen, dass die Nachricht von Valve bzw. Steam kommt. Damit war meine erste Befürchtung, dass mein System kompromittiert ist, zum Glück falsch.

Tendentiell ist es wohl ein Problem mit der Rechteverwaltung des Windowsusers. Steam benötigt für die Installation eines Updates wohl Adminsitratorrechte. Bei der Autoerkennung dieser Rechte muss ein Problem bestehen, so dass der Updater nicht direkt gestartet werden kann.

Ich entschied mich dafür, den “SERVICE INSTALLIEREN” Button zu betätigen. Die Windows Administrator Warnung erschien. Sie bestätigte mir, dass die Anwendung von Valve kommt und als solche verifiziert ist.
Nachdem ich Windows erlaubt hatte, das Programm auszuführen, wurde der Updater gestartet. Im Anschluss startete Steam ohne weitere Probleme.

Mein Fazit:
Lieber einmal zu vorsichtig sein, als irgendwann das Nachsehen zu haben.

Zum einen arbeite ich gerade mit Hochdruck an einem CMS. Heutzutage selbstverständliche Funktionen, wie Rewrite Urls und Mehrsprachigkeit, werden selbstverständlich unterstützt. Setzt man Rewrite Urls ein, kann man Links wie domain.tld/de/Leihserver/, oder domain.tld/uk/Lendserver/Gameserver/ benutzen.
Keywords können je Artikel oder Seite gesetzt werden.
Seiten, wie die Verleih- und Protectionmodeseite, die bereits losgelöst vom CMS bestanden haben, sind ebenfalls mit von der Partie.

Die zweite Neuerung ist das Layout der Adminoberfläche. Die Menüführung wurde komplett überarbeitet und sollte die Arbeitsabläufe beschleunigen.

Beim Hover über das Menü wird das jeweilige Untermenü eingeblendet. Sobald man in einem Unterbereich arbeitet, wird die Subnavi zu diesem Bereich, die vorher nur über Hover erreichbar war, unterhalb der Überschrift des Bereiches aufgeklappt und permanent angezeigt. Sobald man den Bereich wieder verlässt, wird das zugehörige Untermenü wieder ausgeblendet.
Durch die neue Struktur kann ich wesentlich mehr Menüelemente einbauen, ohne dass es unübersichtlich wird.

Des Weiteren gibt es nun Rechts eine Übersicht, die bei Events, also Anzahl der Einträge größer als 0, farblich hervorgehoben wird. Es wird demnach beim Arbeiten sofort farblich ins Auge stechen, wenn man sich um etwas kümmern sollte.

Insgesamt habe ich versucht, durch Schattenwürfe, Trennlinien und Farbverläufe das Layout etwas aufzulockern.

Der derzeitige WIP Status sieht folgendermaßen aus:

Um den Spam einzudämmen, bietet sich eine Überprüfung an, wer so schreibt. Dabei macht man sich zu Nutze, dass Spammer wiederkehrende E-Mail Adressen und Usernamen verwenden.

Im ersten Schritt werden unerwünschte Top Level Domains und Domainendungen in 2 Arrays übergeben und überprüft, ob die verwendete E-Mail einen dieser Kriterien entspricht. Weil Spammer sehr flexibel sind, stellt diese Maßnahme lediglich einen Tropfen auf den heißen Stein dar.

Wesentlich effizienter ist der zweite Schritt. Hier wird die API von stopforumspam.com kontaktiert und gefragt, ob Name, oder E-Mail bereits als Spammer bekannt sind. Stopforumspam.com ist eine Seite, die bekannte Spammer sammelt und nicht kommerziellen Nutzern eine API zu der Datenbank anbietet.
Nur wenn die API antwortet, dass der Datensatz unbekannt ist, darf der User sich anmelden, bzw. einen Kommentar schreiben.

Die beschriebenen Ergänzungen werden in den Dateien register.php und comments.php vorgenommen.

Die Erweiterung der register.php:

// check e-mail
if(!validate_email($mail)) {
	$error[]=$_language->module['invalid_mail'];
} else {
	// Liste mit unzulaessigen Maildomains
	$badmaildomains=array('willich.nicht','auchnicht.de');
	// Liste mit unzulaessigen TLs array('cn','xxx')
	$badtld=array();
	// Useraccount von Domain trennen
	list($user,$domain)=explode('@',$mail);
	// Top Level herausfinden
	$domain_explode=explode('.',$domain);
	$last_array_entry=count($domain_explode)-1;
	// Überpruefen, ob die Domain geblacklisted ist
	if (in_array($domain,$badmaildomains) or in_array($domain_explode[$last_array_entry],$badtld)) {
		$error[]=$_language->module['invalid_mail'];
	} else {
		// Stopforumspam kontaktieren:
		$opts=stream_context_create(array('http'=>array('method'=>'GET','header'=>"Accept-language: en\r\nUser-Agent: ".$_SERVER['HTTP_HOST']."\r\n")));
		$contact_stopforumspam=@file_get_contents('http://www.stopforumspam.com/api?email[]='.urlencode($mail).'&username[]='.urlencode($username).'&username[]='.urlencode($nickname),false,$opts);
		if($contact_stopforumspam!=false) {
			$xmlreply = simplexml_load_string($contact_stopforumspam);
			foreach ($xmlreply as $xml_key => $xmlcheck) {
				// Wenn der Spammer in der Datenbank erfasst ist, feststellen, ob die Mail und oder der Username bekannt war und einen entsprechenden Fehler ausgeben
				if ($xmlcheck->appears==1) {
					if ($xml_key=='email') {
						$error[]=$_language->module['invalid_mail'];
					} else if ($xml_key=='username') {
						$error[]=$_language->module['nickname_inuse'];
					}
				}
			}
		}
	}
}

Und die Änderung in der comments.php:

function IsNoSpammer ($mail,$username,$useragent) {
	$nospammer=true;
	// Liste mit unzulaessigen Maildomains
	$badmaildomains=array('willich.nicht','auchnicht.de');
	// Liste mit unzulaessigen TLs array('cn','xxx')
	$badtld=array();
	// Useraccount von Domain trennen
	list($user,$domain)=explode('@',$mail);
	// Top Level herausfinden
	$domain_explode=explode('.',$domain);
	$last_array_entry=count($domain_explode)-1;
	// Überpruefen, ob die Domain geblacklisted ist
	if (in_array($domain,$badmaildomains) or in_array($domain_explode[$last_array_entry],$badtld)) {
		$nospammer=false;
	}
	$opts=stream_context_create(array('http'=>array('method'=>'GET','header'=>"Accept-language: en\r\nUser-Agent: ".$useragent."\r\n")));
	$contact_stopforumspam=@file_get_contents('http://www.stopforumspam.com/api?email[]='.urlencode($mail).'&username[]='.urlencode($username),false,$opts);
	if($contact_stopforumspam!=false) {
		$xmlreply = simplexml_load_string($contact_stopforumspam);
		foreach ($xmlreply as $xml_key => $xmlcheck) {
			// Wenn der Spammer in der Datenbank erfasst ist, $nospammer auf false setzen
			if ($xmlcheck->appears==1) {
				$nospammer=false;
			}
		}
	}
	return $nospammer;
}
if (IsNoSpammer($mail,$name,$_SERVER['HTTP_HOST'])==true) {
	// hier den DB Eintrag vornehmen.
} else {
	die();
}

Als die Diskussion aufflammte hat heise.de eine 2-Klick Lösung entwickelt, um Social Media Buttons mit dem Datenschutz unter einen Hut zu bringen. Bei dieser Methode wird erst nach ausdrücklicher Aufforderung durch den Benutzer der externe Code von Facebook und Co. angefordert und eingebunden.

Wegen der großen Nachfrage wurde der Code zu der 2-Klick Lösung unter der MIT Lizenz veröffentlicht.

Diese 2-Klick Lösung habe ich in meinem Blog eingebaut. Sie kann von nun an beim Aufruf der einzelnen Beiträge am Ende genutzt werden.

Nachtrag:
Ich habe die Einbindung erweitert. Nun kann man die Buttons auch in der Übersicht benutzen.

Ich hoffe, dass diese Änderung die Texte etwas lesbarer machen wird.

Mit Tabellen ist die gleichmäßige Höhen- und Breitengestaltung sehr einfach. Die Höhe und Breite aller Spalten richtet sich an den Maximalwerten der anderen Elemente aus. Eine einfache Tabelle sieht so aus:

<table>
    <tr>
        <td colspan="3">Header</td>
    </tr>
    <tr>
        <td>Linkes Menu</td>
        <td>Inhalt</td>
        <td>Rechtes Menu</td>
    </tr>
    <tr>
       <td colspan="3">Footer</td>
    </tr>
</table>

Der Einsatz von Tabellen zu diesem Zweck gilt aber als veraltet und damit nicht mehr zeitgemäß.

Zur Zeit verwendet man für die Layout Gestaltung überwiegend Divs. Dabei schreibt man die Positionsangaben zum DIV nicht in selbiges hinein, sondern weist diesem eine ID und oder Klasse zu. Die Eigenschaften der IDs und Klassen definiert man dann in einer extra *.css Datei.

Wenn man feste mit flexiblen Breiten- und Höhenangaben vermischt, wird man bei Divs auf Hürden und Hindernisse treffen.

Wenn man z.B. möchte, dass die Höhe des Layouts immer minimal 100% der Höhe des Browserfensters beträgt, umfasst man das eigentliche Layout mit einem Div. Dieses Div macht man dann zu einem Wrapper. In den Eigenschaften wird dann bestimmt, dass der Wrapper immer mindestens 100% der Seitenhöhe belegen soll. Die Divs, die das eigentliche Aussehen bestimmen sollen, werden in diesem Wrapper positioniert.

Bei einem Layout mit drei Spalten kann man diese mittels Float ausrichten. Bei dem Linken und Mittleren setzt man “float:left;”. Beim Rechten “float:right;”.
Ist die Höhe der Divs ein fester Wert, bekommt man keine Probleme. Soll aber zumindest eine Höhe flexibel sein, werden alle drei eine, an ihrem Inhalt bestimmte, unterschiedliche Höhe erhalten. Möchte man unterschiedliche Hintergründe verwenden, kann das Endergebnis sehr unsymmetrisch aussehen.

Eine Alternative ist es, die Position der 3 Spalten absolut (“position:absolute;”) zu bestimmen. Im Folgenden definiert man dann den Abstand der rechten und linken Spalte zum Rand mit 0. Die mittleren Spalte wird mit Margin nach Links und Rechts ausgerichtet. Als Werte für die Margin Angabe nimmt man die Spaltenbreite der äußeren beiden Spalten.
Im Ergebnis hat man 3 Spalten, bei denen für die beiden äußeren feste Pixelwerte verwendet werden können. Die Mittlere Spalte wird immer die restliche Breite für sich in Anspruch nehmen, egal wie Breit das Browserfenster des Users gerade ist.

Definiert man nun die minimale Höhe aller drei Spalten mit 100%, werden durch diese Höhenangabe alle Spalten gleichmäßig bis zum Ende des Wrappers getreckt.

Die farbliche Gestaltung der einzelnen Divs erfolgt ebenfalls mittels CSS. Im Beispiel habe ich die Farben Grün #0F0, Rot #0F0 und Blau #00F verwendet. Die Farben passen so sicher nicht zusammen und beißen sicher etwas in den Augen. Ich habe sie dennoch gewählt, um mittels des Kontrastes die gleichmäßige Höhe der Spalten besser darstellen zu können.

Eine Beispielseite, die den nachfolgenden Code verwendet, kann man hier ansehen: 3cols.html

Die CSS Angaben:

html,body {
	margin:0;
	height:100%;
	font-size:12px;
	font-family:"HelveticaNeue-Light","Helvetica Neue Light","Helvetica Neue",Helvetica,Arial,"Lucida Grande",sans-serif;
}
#header{
	position:relative;
	z-index:100;
	width:100%;
	height:30px;
	line-height:30px;
	text-align:center;
	font-size:14px;
	background-color:#3D3D3D;
	color:#CCCCCC;
}
#wrapper {
	position:relative;
	min-height:97%;
	height:auto !important;
	height:97%;
	overflow:hidden;
}
#menuleft {
	position:absolute;
	z-index:50;
	top:0px;
	left:0px;
	width:140px;
	height:100%;
	background-color:#0F0;
}
#datapage {
	position:absolute;
	z-index:1;
	height:100%;
	margin:0 140px 0 140px;
	background-color:#F00;
}
#menuright {
	position:absolute;
	z-index:50;
	top:0px;
	right:0px;
	width:140px;
	height:100%;
	background-color:#00F;
}
#footer{
	position:absolute;
	z-index:100;
	bottom:0px;
	width:100%;
	height:30px;
	line-height:30px;
	background-color:#3D3D3D;
	text-align:center;
	font-size:14px;
	color:#CCCCCC;
}

Der HTML Code, der diese CSS Angaben verwendet:

<body>
	<div id="header">
		Header
	</div>
	<div id="wrapper">
		<div id="menuleft">
			Linkes Menu
		</div>
		<div id="datapage">
			Inhalt
		</div>
		<div id="menuright">
			Rechtes Menu
		</div>
		<div id="footer">
			Footer
		</div>
	</div>
</body>

Dank strenger Chmods war der PHP User sehr eingeschränkt. Durch den Einsatz von disable_functions in der php.ini war es dem PHP User weder möglich, Systembefehle auszuführen, noch Sockets zu öffnen. Aus diesem Grund konnte nur Schaden bei der betroffenen Webseite selber angerichtet werden. Es war zum Beispiel möglich sämtliche Dateien auszulesen und zu manipuliert. Des Weiteren ist es sehr wahrscheinlich, dass der Inhalt der Datenbank sich in den Händen des Angreifers befindet.

Da es sich um einen angemieteten Webspace handelt, wäre es nun extrem aufwendig gewesen, alle Dateien per Hand nach Manipulationen zu durchsuchen. Ich wurde deswegen gebeten, ein PHP Skript zu schreiben, das diese Aufgabe für den Betroffenen erledigt.

Das Ergebnis sind diese beiden Functions:

<?php
// Function, die die einzelnen Dateien überprüft.
function checkfile($file) {
	// Der Inhalt dieser Dateitypen wird überprüft.
	$types=array('php', 'php4', 'php5', 'txt', 'html', 'htm');
	// Nach diesem Inhalt wird in den Dateien gesucht.
	$contents=array('Suchbegriff', 'Suchausdruck');
	$found=array();
	// Namen der ausführenden Datei und der zu durchsuchenden bestimmen.
	$thisfile=preg_split('/\//', $_SERVER['SCRIPT_FILENAME'], -1, PREG_SPLIT_NO_EMPTY);
	$filename=preg_split('/\//', $file, -1, PREG_SPLIT_NO_EMPTY);
	// Den Dateityp bestimmen.
	$filetype=preg_split('/\./', $file, -1, PREG_SPLIT_NO_EMPTY);
	// Wenn es sich nicht um die ausführende Datei handelt und der Typ in der Dateiliste ist, einen Filehandler für die Datei öffnen.
	if ($thisfile[count($thisfile)-1]!=$filename[count($filename)-1] and in_array($filetype[count($filetype)-1], $types)) {
		// Die Datei so lange auslesen, bis das Ende erreicht wurde.
		$fp= @fopen($file, 'r');
		// Wenn der Filehandler erfolgreich geöffnet werden konnte, die Datei durchsuchen.
		if ($fp) {
			while (!feof($fp)){
				// Alle Suchbegriffe durchgehen und wenn einer gefunden wurde, diesen Treffer dem Trefferarray hinzufügen.
				foreach ($contents as $content) {
					if(strpos(strtolower(fgets($fp)), strtolower($content)) !== false) $found[]=$content;
				}
			}
			// Dateihandler schließen
			fclose($fp);
		}
	}
	unset($fp);
	// Wenn Suchbegrife gefunden wurden, diese als String ausgeben. Anderenfalls mit false antworten.
	if (count($found) == 0) return false;
	else return implode(', ',$found);
}
// Das angegeben Verzeichnis und alle Unterverzeichnisse durchsuchen.
// Wenn kein Verzeichnis angegeben wird, dann im aktuellen beginnen.
function listcontent($dir='.') {
	// Wenn es sich um ein Verzeichnis handelt, den Inhalt listen.
	if (is_dir($dir)) {
		$dircontent=scandir($dir);
		// Den gesamten Inhalt des Verzeichnisses durchgehen.
		foreach ($dircontent as $c) {
			// Wenn es sich um ein Verzeichnis handelt, die Function listcontent() aufrufen;
			if ($c!='.' and $c!='..' and is_dir($dir.'/'.$c)) {
				listcontent($dir.'/'.$c);
			// Wenn es sich um eine Datei handelt und die checkfile() Function einen String zurückgibt, einen Suchtreffer ausgeben.
			} else if ($c!='.' and $c!='..' and checkfile($dir.'/'.$c)) {
				echo 'Found file: '.$dir.'/'.$c.' with content: '.checkfile($dir.'/'.$c).'<br />';
			}
		}
	// Wenn es sich um eine Datei handelt und die checkfile() Function einen String zurückgibt, einen Suchtreffer ausgeben.
	} else if (checkfile($dir.'/'.$c)) {
		echo 'Found potential bad file: '.$dir.'/'.$c.' with content: '.checkfile($dir.'/'.$c).'<br />';
	}
}
// Die Suche starten.
echo "Starting search<br />";
listcontent();
echo "Search finished<br />";
?>

Zum Validieren habe ich mir nun folgendes Konzept überlegt:
Im ersten Schritt werden die Superglobals in ein Object übergeben und dabei escaped. Nach der Übergabe werden die Superglobals gelöscht, da ihr Inhalt nicht mehr benötigt wird.

Im folgenden kann der vorherige Inhalt der Superglobals zusammen mit einer Funktion aufgerufen werden, die den Inhalt überprüft. Nur wenn die Überprüfung erfolgreich war, wird der Wert zurückgegeben.

Bei dem Aufruf der Funktion gibt man an, welchen Key aus welcher Superglobal erwünscht ist. Wenn die Funktion auch auf Länge überprüfen kann, dann muss man auch noch die Länge angegeben werden.
Mit dem ersten Wert sagt man, welcher Key gewünscht ist, mit dem zweiten Wert sagt man, von welcher der vorherigen Superglobals der Wert genommen werden soll.

Für den produktiven Einsatz braucht man sicher noch mehr Funktionen. Als Ausgangscode ist die Klasse sicher gut zu gebrauchen:

< ?php
class ValidateUserinput {
	private $get=array();
	private $post=array();
	private $server=array();
	private $cookie=array();
	private $request=array();
	private $env=array();
	// Wenn die Magic Quotes nicht zum escapen eingesetzt werden, dann mit addcslashes escapen
	private function magic_quotes ($value) {
		if (!function_exists('get_magic_quotes_gpc') or get_magic_quotes_gpc()==0) {
			$value=addcslashes($value);
		}
		return $value;
	}
	private function inputsecurity ($value,$what) {
		foreach ($value as $key => $val) {
			if (is_string($val)) {
				$this->$what[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->$what[$key] = $this->inputsecurity($val,$what);
			}
		}
	}
	// Constructor
	function __construct($get,$post,$server,$cookie,$request,$env) {
		foreach ($get as $key => $val) {
			if (is_string($val)) {
				$this->get[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->get[$key] = $this->inputsecurity($val,'get');
			}
		}
		foreach ($post as $key => $val) {
			if (is_string($val)) {
				$this->post[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->post[$key] = $this->inputsecurity($val,'post');
			}
		}
		foreach ($server as $key => $val) {
			if (is_string($val)) {
				$this->server[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->server[$key] = $this->inputsecurity($val,'server');
			}
		}
		foreach ($cookie as $key => $val) {
			if (is_string($val)) {
				$this->cookie[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->cookie[$key] = $this->inputsecurity($val,'cookie');
			}
		}
		foreach ($request as $key => $val) {
			if (is_string($val)) {
				$this->request[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->request[$key] = $this->inputsecurity($val,'request');
			}
		}
		foreach ($env as $key => $val) {
			if (is_string($val)) {
				$this->env[$key] = $this->magic_quotes($val);
			} else if (is_array($val)) {
				$this->env[$key] = $this->inputsecurity($val,'env');
			}
		}
	}
	// Destructor
	function __destruct() {
		unset($this->get);
		unset($this->post);
		unset($this->server);
		unset($this->cookie);
		unset($this->reques);
		unset($this->env);
	}
	// Url Filter
	function url ($value,$type) {
		$check=$this->$type;
		if(filter_var($check[$value],FILTER_VALIDATE_URL)) {
			return $check[$value];
		}
	}
	// Mail Filter
	function ismail($value,$type) {
		$check=$this->$type;
		if(filter_var($check[$value],FILTER_VALIDATE_EMAIL)) {
			return $check[$value];
		}
	}
	// IP4 Adressen
	function ip4 ($value,$type) {
		$check=$this->$type;
		if(filter_var($check[$value], FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)){
			return $check[$value];
		}
	}
	// IP 6 Adressen
	function ip6 ($value,$type) {
		$check=$this->$type;
		if(filter_var($check[$value], FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)){
		return $check[$value];
		}
	}
	// IP4 und IP6 Adressen
	function ip ($value,$type) {
		$check=$this->$type;
		if(filter_var($check[$value], FILTER_VALIDATE_IP)){
			return $value;
		}
	}
	// Serverport
	function port($value,$type) {
		$check=$this->$type;
		if (preg_match("/^(0|([1-9]\d{0,3}|[1-5]\d{4}|[6][0-5][0-5]([0-2]\d|[3][0-5])))$/",$check[$value])) {
			return $check[$value];
		}
	}
	// A-Z, a-z und 0-9 sind in beliebiger Anordnung mit einer maximalen Stringlänge erlaubt.
	function pregw($value,$length,$type) {
		$check=$this->$type;
		if (preg_match("/^[\w]{1,$length}$/",$check[$value])) {
			return $check[$value];
		}
	}
	// Gibt den Wert ohne Inputüberprüfung zurück.
	function escaped ($value,$type) {
		$check=$this->$type;
		return $check[$value];
	}
}
// Die Superglobals leeren, nachdem sie in das Object übergeben worden sind.
$ui=new ValidateUserinput($_GET,$_POST,$_SERVER,$_COOKIE,$_REQUEST,$_ENV);
unset($_GET);
unset($_POST);
unset($_SERVER);
unset($_COOKIE);
unset($_REQUEST);
unset($_ENV);
// Ab hier würde dann der restliche PHP Code beginnen.
// Die einzelnen Werte werden dadurch aufgerufen, dass man mit der Funktion bestimmt, auf was der Wert überprüft werden soll.
// Mit dem ersten Wert sagt man, welcher Key gewünscht ist, mit dem zweiten Wert sagt man, von welcher der vorherigen Superglobals der Wert genommen werden soll.
// Bei dem Beispielaufruf datei.php?w=test würde test ausgegeben werden
if ($ui->escaped('w','get')) echo $ui->escaped('w','get');
else echo 'Nicht validiert';
?>

Was hingegen teilweise auf die Kappe der ESL geht, ist der Umstand, dass sich über mögliche Angriffswege ausgeschwiegen wurde. Nicht jeder Coder kennt sich in den Eigenarten einzelner Gameserver aus, oder verfolgt die Diskussionen zu diesen. Wenn er sich nur auf die ESL verlässt und auf den Rat von Dritten verzichtet, wird er wichtige Dinge übersehen. Wenn er jedoch Hinweise Dritter bewusst übergeht, ist eine fehlerhafte Umsetzung alleinig ihm anzulasten.

Da es bis heute keine zusammenfassende Auflistung über mögliche Angriffswege und Abwehrmaßnahmen gibt, habe ich nun im Rahmen meiner ehrenamtlichen Tätigkeit bei der ESL einen Vorschlag für eine Richtlinie erarbeitet und diese an die ESL weitergeleitet. Ob und in welcher Form mein Vorschlag übernommen wird, ist Sache der ESL.

Auch unabhängig vom Protection Mode ist es sicherlich interessant, über welche Wege Kunden ihre Server anderes betreiben können, als vom Anbieter vorgesehen.

Viele der Punkte gibt es schon seitdem es Gameserver gibt und sind versierten Anwendern ebenso lange bekannt. Dennoch werden sie leider immer wieder übersehen.

Im folgenden nun mein Vorschlag einer Richtlinie für den Protection Mode

Ziel:
Der Server, der unter der angegeben Adresse (IP:Port) erreicht wird, darf außer den Servertools eslplugin und zblock keine weiteren Servertools geladen haben.

Angriffswege , die nicht funktionieren dürfen:
1. Upload in das geschütze Verzeichnis:
Der User darf nicht in der Lage sein, Servertools in die Verzeichnisse des geschützen Server zu laden und von dort auszuführen.

2. plugin_load:
Das Ausführen des Servercommands “plugin_load” muss verhindert werden. Dabei ist auch zu beachten, das die *.so Dateien des Servers manipuliert werden können, so dass der Befehl unter dem Beispielnamen “plg1n_load” läuft. Über das deaktivieren des Befehls hinaus, muss deswegen sicher gestellt sein, dass der Benutzer die *.so des Servers nicht verändern kann.

3. Änderung der ausführbaren Dateien:
Mittels eines FTP Client und Editor können Änderungen an den Startskripten , ausgeführten Binaries und den *.so in den bin/ Ordern der Server gemacht werden. Des Weiteren kann man diese Änderungen auch mit Servertools wie Sourcemod und Eventscript herbeiführen.
Diese Veränderungen müssen sowohl beim geschützten, als auch ungeschützen Server entweder rückgängig, oder von vornherein verhindert werden.

4. (Reverse) Shells:
Manche Servertools können Shells bereitstellen, mit denen man Prozesse vom Gameserverprozess losgelöst starten kann. Diese Prozesse müssen beim Start des Protected Modes beim normalen User beendet werden.

5. Folgen von Punkt 3 und 4:
Ein nach den Punkt 3 oder 4 kompromitierter ungeschützter Server kann auch durch eine Firewall hindurch eine Reverse Shell aufbauen. Wenn diese beim Start des Protected Modes nicht erkannt wird, kann man die Adresse des geschützten Servers mit einem ungeschützten belegen.
Eine Belegung der Adresse kann ebenso mit Endlosschleifen und Cronjobs erreicht werden.
Es müssen deswegen alle ungewollten Cronjobs und Prozesse beim Benutzer des ungeschützten Servers beendet werden, bevor der protected Server gestartet wird. Es darf nicht möglich sein, dass die Adresse voin einem anderen Prozess, als dem geschützten benutzt wird.

Mögliche Maßnahmen:
Folgende Maßnahmen müssen nicht alle umgesetzt werden. Sie sind lediglich eine Liste von Dingen, mit denen man das Ziel erreichen kann.

1. Strenge Chmods
2. Zugriffseinschränkungen und Dateifilter am FTP Server
3. Prozess und Port Kontrolle
4. Verbieten des Befehls plugin_load
5. Überprüfung kritischer Serverdateien vor jedem Serverstart sowohl im Protected Mode als auch im Unprotected Mode
6. Ohne Differenzierung alle Prozesse des ungeschützten Users beim Start des Protection Modes killen
7. Die Server mit unterschiedlichen Usern starten. Dabei sollte unter keinen Umständen ein User mit Root, oder Sudo Rechten den Prozesse ausführen.
8. Für jeden Gameserverprozess ein eigenes Chroot

Zusätzlicher Hinweis:
Es gibt keine wirksamen Maßnahmen gegen Shellplugins. Im Extremfall könnte dies ausgenutzt werden, um über veralterte Pakete oder Kernel Rootrechte erlangt werden. Es ist deswegen darauf zu achten, dass der Server nicht über bekannte Exploits von innen angreifbar ist.

Mit folgendem Code kann man sich den gesamten Inhalt samt Keys auflisten lassen:

< ?php
foreach ($_SERVER as $key => $info) {
	echo $key.': '.$info.'';
}
?>

Die Ausgabe kann dann wie folgt aussehen:

TMPDIR: /var/www/html/project.tld/temp/
PATH: /usr/local/bin:/usr/bin:/bin
PHPRC: /var/www/html/project.tld/conf/
PWD: /var/www/html/project.tld/php-fcgi
FCGI_ROLE: RESPONDER
UNIQUE_ID: Twgt2T5asdUAAHbGuiIAAACS
HTTP_HOST: project.tld
HTTP_USER_AGENT: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:9.0.1) Gecko/20100101 Firefox/9.0.1
HTTP_ACCEPT: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
HTTP_ACCEPT_LANGUAGE: de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
HTTP_ACCEPT_ENCODING: gzip, deflate
HTTP_ACCEPT_CHARSET: ISO-8859-1,utf-8;q=0.7,*;q=0.7
HTTP_COOKIE: PHPSESSID=2a03a4eec3as2b9a4afd692474c64c1e
HTTP_DNT: 1
HTTP_CONNECTION: close
SERVER_SIGNATURE:
SERVER_SOFTWARE: Apache/2.2.17
SERVER_NAME: project.tld
SERVER_ADDR: 1.1.1.1
SERVER_PORT: 80
REMOTE_ADDR: 2.2.2.2
DOCUMENT_ROOT: /var/www/html/project.tld/httpd
SERVER_ADMIN: admin@project.tld
SCRIPT_FILENAME: /var/www/html/project.tld/httpd/test.php
REMOTE_PORT: 50156
GATEWAY_INTERFACE: CGI/1.1
SERVER_PROTOCOL: HTTP/1.1
REQUEST_METHOD: GET
QUERY_STRING: test=test
REQUEST_URI: /test.php?test=test
SCRIPT_NAME: /test.php
PHP_SELF: /test.php
REQUEST_TIME: 1325936089

$_SERVER enthält keinen Key für den Namen der aufgerufenen Datei selber. Wenn man darauf reagieren möchte, welche Datei einen bestimmten Code includiert hat, wird man mit dem Aufruf eines Keys von $_SERVER alleine erfolglos sein. Man kann die notwendige Information aber aus dem Key ‘SCRIPT_NAME’ gewinnen:

< ?php
// den Key 'SCRIPT_NAME' an den "/" trennen.
$split=preg_split("/\//",$_SERVER['SCRIPT_NAME'],-1,PREG_SPLIT_NO_EMPTY);
// Die Einträge des Arrays bestimmen und 1 abziehen, da bei den Array Keys bei 0 zu zählen begonnen wird
$count=count($split)-1;
// Der Letzte Eintrag ist unsere Datei
$file=$split[$count];
// Wenn es die Datei x ist, 'Hello World' ausgeben, ansonsten den Dateinamen
if ($file=='x.php') {
	echo 'Hello World';
} else {
	echo $file;
}
?>

Ohne Kommentare und zusammegefasst sieht der Code dann so aus:

< ?php
$split=preg_split("/\//",$_SERVER['SCRIPT_NAME'],-1,PREG_SPLIT_NO_EMPTY);
$file=$split[count($split)-1];
if ($file=='x.php') {
	echo 'Hello World';
} else {
	echo $file;
}
?>

Man könnte nun mit exec(); arbeiten. Diese Funktion wird aber von vielen Hostern als Sicherheitsrisiko eingestuft. Deswegen ist sie zu Recht deaktiviert. Wenn die Funktion zugelassen ist, kann man mit PHP rm -r aufrufen:

exec("rm -r /Absoluter/Pfad/Zum/löschenden/Ordner/");

Wenn die exec(); Funktion nicht zur Verfügung steht, kommt man nicht darum herum eine Funktion zu schreiben, die die Funktionsweise von rm -r nachbildet.
Die eigene Funktion muss den Ordnerinhalt auflisten und für jedes Element der Liste überprüfen können, ob es sich um eine Datei, oder einen Ordner handelt. Wenn es sich um eine Datei handelt, soll die Datei mit der PHP Funktion unlink(); gelöscht werden. Wenn es sich um einen Ordner handelt, sollte die Funktion sich selber so lange selber aufrufen, bis sie in keinen weiteren Unterordner herabsteigen und dabei die Dateien aus den Unterordnern löschen kann.

function rmr($dir) {
	// Wenn der Input ein Ordner ist, dann Überprüfung des Inhaltes beginnen
	if (is_dir($dir)) {
		// Ordnerinhalt auflisten und jedes Element nacheinander überprüfen
		$dircontent=scandir($dir);
		foreach ($dircontent as $c) {
			// Wenn es sich um einen Ordner handelt, die Funktion rmr(); aufrufen
			if ($c!='.' and $c!='..' and is_dir($dir.'/'.$c)) {
				rmr($dir.'/'.$c);
			// Wenn es eine Datei ist, diese löschen
			} else if ($c!='.' and $c!='..') {
				unlink($dir.'/'.$c);
			}
		}
		// Den nun leeren Ordner löschen
		rmdir($dir);
	// Wenn es sich um eine Datei handelt, diese löschen
	} else {
		unlink($dir);
	}
}
// Aufrufen der Funktion
rmdir('Zu/Löschender/Ordner');

Zum neuen Jahr möchte ich euch ein kleines PHP Skript zur Verfügung stellen, mit dem man ein Zip Archiv rekursiv auf dem Webspace entpacken kann.

$zielordner='entpacken/';
$archivname='archiv.zip';
$zo=@zip_open($archivname);
// Wenn das Archiv geöffnet werden konnte, weitermachen
if (is_resource($zo)) {
	// Den Inhalt in einer While Schleife durchgehen
	while ($ze=zip_read($zo)) {
		// Den Namen von der Datei, oder Ordner bestimmen.
		$name=zip_entry_name($ze);
		// Den Eintrag öffnen und mittels Regex überprüfen, ob es sich um eine Datei handelt.
		$zeo=zip_entry_open($zo,$ze,'r');
		if (preg_match('/^(.*)\.[\w]{1,}$/',$name)) {
			// Den Ordner, bzw. die Unterordner bestimmen, in dem sich die Datei befindet
			$folders=preg_split('/\//',$name,-1,PREG_SPLIT_NO_EMPTY);
			$count=count($folders)-1;
			$i=0;
			unset($checkfolder);
			while ($i< $count) {
				if (isset($checkfolder)) {
					$checkfolder .='/'.$folders[$i];
				} else {
					$checkfolder=$folders[$i];
				}
				$i++;
			}
			// Wenn es sich um einen Unterordner handelt und er nicht existiert, diesen erstellen.
			if (isset($checkfolder) and $checkfolder!='' and !is_dir($zielordner.$checkfolder) and !is_file($zielordner.$checkfolder)) {
				@mkdir($zielordner.$name);
			}
		// Falls der Regex ergibt, dass es sich um einen Ordner handeln muss, überprüfen, ob er existiert und gegebenen Falls erstellen
		} else if (!is_dir($zielordner.$name)) {
			@mkdir($zielordner.$name);
		}
		// Wenn es sich um eine Datei handelt, einen File Handler für die zu entpackende Datei öffnen und den Inhalt der gepackten Datei in diesen Handler Schreiben
		if (preg_match('/^(.*)\.[\w]{1,}$/',$name) and $zeo) {
			// File Handler öffnen
			$nf=fopen($zielordner.$name,'w');
			// Dateigröße bestimmen
			$fz=zip_entry_filesize($ze);
			// Den Inhalt der gepackten Datei in den Handler schreiben
			fwrite($nf,zip_entry_read($ze,$fz),$fz);
			// Handler schließen
			zip_entry_close($ze);
			fclose($nf);
		}
	}
	// Archiv schließen
	zip_close($zo);
}

Der folgende Code ist sicherlich nicht der performanteste, erfüllt jedoch seinen Zweck. Für einzelne Gameserver mag es hilfreich sein. Ein komplettes System würde ich darauf aber nicht aufzubauen wollen.

Wenn man die Demos auch auf dem Gameserver archivieren möchte, muss man den zusätzlichen Parameter -k bei bzip2 verwenden. Er steht für keep und weist bzip2 an, die Ausgangsdatei nicht zu entfernen.

Hier nun das kleine Bashscript:

#!/bin/bash

DIR='/home/username/servername/css'
DEMODIR='cstrike'

cd $DIR/$DEMODIR
tail -f $DIR/screenlog.0 | while read line; do
 if [[ `echo $line | grep 'Completed SourceTV demo'` ]]; then
  DEMONAME=`echo -n "$line" | awk '{print $4}' | tr -d '"' | tr -d ','`
  if [[ ! `lsof $DEMONAME` ]]; then
   nice -n +19 bzip2 -s -q -9 $DEMONAME
   wput --remove-source-files $DEMONAME.bz2 ftp://user:password@1.1.1.1/demos/
  fi
 fi
done

$ip='1.1.1.1';
$port=7777;
$socket= @fsockopen("udp://".$ip,$port,$errnum,$errstr,5);
if ($socket==true) {
 $ex=explode('.',$ip);
 $packet='SAMP'.chr($ex[0]).chr($ex[1]).chr($ex[2]).chr($ex[3]).chr($port & 0xFF).chr($port >> 8 & 0xFF).'i';
 fwrite($socket,$packet);
 fread($socket,11);
 $return['password']=ord(fread($socket,1));
 $return['player']=ord(fread($socket,2));
 $return['slots']=ord(fread($socket,2));
 $return['hostname']=htmlentities(fread($socket,ord(fread($socket,4))));
 $return['mode']=htmlentities(fread($socket,ord(fread($socket,4))));
 $return['map']=htmlentities(fread($socket,ord(fread($socket,4))));
} else {
 $return=$errnum.': '.$errstr;
}
if (is_resource($socket)) {
 fclose($socket);
}

Außer TSDNS soll nichts domainbezogenes auf diesem Server laufen. Der Hostname und ein Reserve DNS Eintrag wurde deswegen nicht auf ts.domain.tld eingestellt. Weil diese Subdomain nicht in Gebrauch ist, wurde kein A Record zu ts.domain.tld erstellt.

Nach dem Konfigurieren der tsdns_settings.ini wurde dann noch der TSDNS Server geupdatet.

In der Theorie sollte nun alles gehen. Nicht so in der Praxis. Ein Ping bzw. Tracert auf eine Subdomain zur Subdomain landet bei der richtigen IP. Beim Verbinden mit dem Teamspeak 3 Client gibt es aber Probleme. Egal welche Subdomain man benutzt, man landet immer auf dem virtuellen Teamspeak 3 Server dieser IP, der auf dem Standardport betrieben wird.

Sobald man einen A Record für die nicht verwendete Subdomain ts.domain.tld erstellt und die Änderung übernommen wurde, stoppt dieses Verhalten. Ab diesem Zeitpunkt ist es dann möglich, auf den virtuellen Teamspeak 3 Server zu verbinden, der in der tsdns_settings.ini angegeben wurde.

Fake Clients werden dem Gameserver Bots hinzugefügt und täuschen vor, dass diese Menschliche Spieler seien.

Eine andere Methode um die Beliebtheit seines Servers zu steigern ist es, den Server mehrfach unter unterschiedlichen Adressen in den Serverbrowser zu bringen. Egal auf welche der Adressen man verbindet, man landet immer auf dem gleichen Gameserver.

Des Weiteren unterdrücken manche Serverbetreiber Informationen, die zeigen, das der Server modifiziert wurde. Sie werden unterdrückt, weil sie ein niedrigeres Serverranking zur Folge haben. Die Folge davon sind weniger Spieler.

Diese Art von Modifikationen werden von Valve als sehr schädlich für die Community angesehen. Deswegen wird Valve im ersten Schritt Kontakt mit Serverbetreibern suchen, um ihnen eine Chance zu geben, das Verhalten einzustellen.
Zu einem späteren, bisher nicht bekannten Zeitpunkt, wird dieses Vorgehen dann verschärft werden. Die genauen Konsequenzen werden zwar nicht genannt. Ich gehe davon aus, dass Valve irgendwann damit beginnen wird, die Server von Unbelehrbaren aus dem Serverbrowser zu nehmen.

Die Nutzer dieser Methoden sollten sich also vorsehen und ihre Strategie ändern. Wer möchte schon, dass sein Server über Kurz, oder Lang aus der Serverliste entfernt wird.

Heise berichtet so eben, dass Windows 8 die Zugangsdaten in der Cloud speichern wird.

Wer braucht denn noch Staatstrojaner, wenn er direkt auf Daten zugreifen kann…

In diesem Beitrag möchte ich etwas Eigenwerbung für das Teamspeak 3 Modul von meinem Interface Easy-Wi machen.

Der Sinn von TSDNS ist es, dem Benutzer das Verbinden auf Teamspeak 3 Server so einfach, wie möglich zu machen. Das Verbinden auf eine Domain ist einfacher, weil sie einfacher zu merken ist und weil sie weniger verwirren kann, als eine Kombination von IP und Port.
Des Weiteren verlangen zahlreiche Benutzer den Standardport zu einem Serverdienst. Technisch gesehen ist dies sinnlos. Darüber hinaus werden unnötigerweise kostbare IP4 Adressen verschwendet, wenn man diesem Wunsch nachkommt. Verbindet man nun auf eine Domain, benötigt man keinen Port mehr, so dass der Wunsch nach einem Standardport entfällt und damit kostbare IP4 Adressen gespart werden können.

Egal, ob man Teamspeak 3 Server nun gewerblich vermietet, oder mittels einer NPO Lizenz kostenlos an Freunde und Bekannte verteilt. Es bleibt ein kleiner Schwachpunkt. Man muss jedes mal arbeiten, wenn jemand eine Änderung wünscht.

Aus diesem Grund ist die Nutzung von TSDNS bei Easy-Wi vollständig automatisiert. Die Verwaltung der tsdns_settings.ini, so wie das Starten und Updaten des TSDNS Servers, werden von Easy-Wi übernommen.

Beim Anlegen einer Teamspeak 3 Grundinstallation wird einmalig eine Standarddns, wie ts3.myclan.tld angegeben. Wird nun ein Voiceserver angelegt, wird eine Subdomain nach dem Schema Username-VirtualserverID.ts3.myclan.tld vorgegeben. Möchte man diese Kombination nicht nutzen, steht es einem natürlich frei, diese Vorgabe durch die gewünschte (Sub) Domain zu überschreiben. Selbstverständlich kann die (Sub)Domain jederzeit sowohl vom Benutzer, als auch vom Admin nachträglich bearbeitet werden. Dafür reicht es, die Domain im zuständigen Formularfeld zu ändern und die Änderung zu speichern. Der Admin muss somit nur eingreifen, wenn der Benutzer mit dem Eingeben einer Domain überfordert ist.

Sollte man bereits manuell, oder mit einem anderen Interface, Teamspeak 3 Server angelegt haben, so bietet Easy-Wi die Möglichkeit, die bestehenden Server zu übernehmen. In diesem Fall wird überprüft, ob bereits ein TSDNS Server konfiguriert wurde. Ist dies der Fall, werden die Einstellungen ebenfalls übernommen. Falls für einen Server keine TSDNS Einstellungen gemacht worden sind, so wird eine Subdomain nach dem oben beschriebenen Schema generiert.

Damit der Arbeitsaufwand auch in allen anderen Fällen reduziert wird, gibt es eine Überwachung vom Status der Teamspeak 3 Server.
Es wird z.B. überwacht, ob der Benutzer bestimmte Parameter, wie Passwort, Hostbanner, Hostbutton, usw. einhält. Sollte ein Wert nicht eingehalten worden sein, werden die Admins und der Benutzer mit einer E-Mail informiert.

Neben Benutzern, die sich nicht an Vorgaben halten, kann es auch zu kleineren technischen Problemen kommen. So kommt es manchmal vor, dass beim Starten der Teamspeak 3 Hauptinstanz, nicht alle virtuellen Server gestartet werden. Dies kann passieren, obwohl der Parameter autostart gesetzt wurde. Manuelles Starten kann hier sehr viel Zeit kosten. Aus diesem Grund wird ein Server, der offline ist, obwohl er online sein sollte, automatisch gestartet und der Benutzer darüber informiert.

Sollte die Hauptinstanz also solche nicht erreichbar sein, werden die Admins natürlich auch informiert.

Die angelegten Teamspeak 3 Server können auch automatisiert mit dem Verleihmodul verliehen werden. Bei diesem gibt man vor, wie lange die Server minimal und maximal ausleihbar sein sollen und wie viele Slots minimal und maximal je Server vergeben werden dürfen. Zusätzlich definiert man die Schritte zwischen dem Minimal- und Maximalwert. Bei jedem Verleihvorgang wird der Server dann resettet und ein neuer initialer Admintoken ausgegeben. Das Verleihen kann dabei entweder über das mitgelieferte Formular geschehen, oder die XML Schnittstelle geregelt werden.

Wenn man Teamspeak 3 mit einer NPO Lizenz verleiht sollte man dringenst beachten, dass man keinerlei Gewinn daraus ziehen darf. Bereits Google Werbung auf der Webseite kann als gewinnbringend im Sinne der NPO Lizenz gesehen werden. Im schlimmsten Fall wird dann die NPO Lizenz entzogen und die IP des eingesetzten Servers geblacklistet.