Da das Intervall zwischen den einzelnen Zugriffen recht kurz ist, sind die Einträge im Log sehr zahlreich.

Die Datei ist meines Wissens für Dinge wie das versenden von E-Mails bei neuen Kommentaren zuständig.

Bei einem Blog der nur ein paar hundert Aufrufe in der Stunde hat und bei dem nur ab und zu Kommentare gepostet werden ist diese Funktion demnach eine Recourcenverschwendung.

Eine Alternative musste demnach her.

Als erstes habe ich die Funktion ganz deaktiviert, indem ich folgendes in die wp-config.php eingetragen habe:

define('DISABLE_WP_CRON', true);

Im nächsten Schritt habe ich einen Cronjob angelegt, der die Datei auf der Console ausführt:

0 */1 * * * cd /homepages/domain.tld/httpd && timeout=120 php ./wp-cron.php

Der Cronjob ruft die Datei stündlich auf und ich kann weiterhin alle Funktionen wahrnehmen. Der wesentliche Unterschied liegt da drin, das der Webserver nicht alle X Aufrufe die Datei aufruft.

Jeder sollte so schnell wie möglich seine Installationen aktualisieren. Diese Eile ist notwendig, weil es sich um Sicherheitsupdate handelt. Es behebt ein Problem, bei dem ein Angreifer den Server zum Absturz bringen kann.

Zusätzlich wurde folgendes geändert:

• Änderungen aus 1.4.0 behoben, die zu einem erhöhten Leistungsverbrauch bei “The Ship” führen.
• Gamedata Unterstützung für Spiele aktualisiert.
• Diverse Fehler behoben

Sourcemod kann von der Downloadseite heruntergeladen werden. Einige Support Links:

• Hifle beim Updaten
• Komplette beschreibung des Updates

Der originale englische Text:

SourceMod 1.4.2 Released Apr 13, 2012 22:03
I’m pleased to announce that SourceMod 1.4.2 has been released.

It is strongly recommended that users of older versions update as soon as possible. We resolved an important security issue wherein an attacker could intentionally cause the game server to crash.

Other than that, this is a minor update, whose highlights include:

• Fixed regression in SM 1.4.0 causing load issue on The Ship
• Updated gamedata for supported games
• Bug fixes

You can get SourceMod from the downloads page. Some support links:

• Need help upgrading?
• Release notes.

Thanks to BAILOPAN and Asherkin for fixes and helping to ready the release, as well as other members of the SM community for various other fixes, including FlaminSarge, Dr!fter, VoiDeD, and ProdigySim.

Hier sind ein paar aktuelle Bilder aus dem Backend des Interfaces

In dem Code waren noch einige Dinge unausgereift und führten zu Problemen. Diese lagen insbesondere im Zusammenhang mit Userinput der in Form eines Arrays gesendet wurde.

Die Schwachstellen sind nun ausgebessert und mehr Methoden zum Validieren zusammengekommen. Demnach sollte die Klasse für den produktiven Einsatz geeignet sein.

Die Downloadseite befindet sich hier.

Zusätzliche Methoden und reguläre Ausdrücke kann man immer gebrauchen. Wer also Ergänzungen hat, kann sie mir gerne per Mail und oder Kommentar schreiben. Ich werde sie dann nachtragen.

Je nach deren Qualität dauert es dann einige Arbeitsschritte, bis man das gewünschte Ergebnis hat.

Ich wurde vor kurzem auf das kostenlose Programm Greenshot hingewiesen, dass das Erstellen von Screenshots stark vereinfacht.

Drückt man die Drucken Taste kann man nun den Bereich auswählen, von den man einen Screenshot erstellen möchte.

Die Tastenkombination ALT + Drucken kopiert das gerade geöffnete Fenster.

Mit dem Tastenkürzel STRG + Drucken wird, wie gewohnt, der ganze Bildschirm erfasst.

Nachdem man einen Bereich, oder gleich den ganzen Bildschirminhalt aufgenommen hat, startet sich Greenshot von selber und man hat eine Palette von Werkzeugen, mit denen man die Aufnahme bearbeiten kann.

Die Benutzeroberfläche sieht folgendermaßen aus:

Vielen unbekannt gibt es auf der Bash zahlreiche kleine Shortcuts, die einem das Leben einfacher machen.

• Bei Pfaden hat die Tabulator Taste eine Verfollständigungsfunktion. Hat man bereits z.B. /etc/pass eingetippt und drückt die Tabulator Taste, hat man automatisch /etc/passwd.
• Drückt man nacheinander “Escape” und “.” wird das letzte zusammenhängende Element eingefügt. Hat man z.B. vorher “touch /neuer/pfad/und/datei.txt” eingegeben kann man nun “/neuer/pfad/und/datei.txt” mit der Kombi aufrufen.
• Mit den Pfeiltasten “oben” und “unten” kann man die bisher eingegebenen Befehle anzeigen lassen
• An Stelle von “cd /home/MenUser” kann man nur “cd”, oder “cd ~” verwenden.

Es gibt sicher noch viel mehr. Die oben genannten vereinfachen das alltägliche Arbeiten auf jeden Fall enorm.

Ich habe es zum Anlass genommen, auf die Google Dienste Adsense und Analytics für diesen Blog zu verzichten.

Zu diesem Schritt hatte ich mich schon früher entschlossen. Nur hatte ich bisher leider keine Zeit den Entschluss auch in die Tat umzusetzen.

Unter Low Ratern versteht man Spieler, die Netsettings verwenden, welche wenig Daten zum Server senden und empfangen. Bei HL1 und HL2 Spielen wie Counter-Strike 1.6 und Counter-Strike: Source werden die “Rates” mit folgenden Configeinträgen bestimmt:

// Maximal benutzbare Bandbreite. Je Mehr Spieler auf dem Server und desto größer die cl_cmd- und cl_udpaterate Werte sind, desto mehr wird gebraucht.
rate “25000″

// Anzahl in der Sekunde, in der Daten von dir zum Server gesendet werden. Kann nicht größer als die erreichten FPS sein.
cl_cmdrate “66″

// Anzahl in der Sekunde, in der Daten vom Server zu dir gesendet werden. Man sollte aufpassen, dass hier keine zu große Abweichung zu cl_cmdrate entsteht.
cl_updaterate “66″

// So viele (0.01=10ms) werden die Hitboxes nach hinten versetzt, um den Ping auszugleichen. Bei einem hohen Ping sollte man einen höheren Wert nehmen.
// Als Startwert kann man den durchschnittlichen Scoreboard Ping nehmen. Danach so weit herabsetzen, bis man merkt, das dieHitboxen nicht mehr passen.
cl_interp “0.01″

Die Standardwerte von Valve sind deutlich geringer, als die im Beispiel verwendeten.

Es hält sich nun hartnäckig das Gerücht, dass man Spieler mit diesen Einstellungen schlechter treffen kann. Für HL1 Spiele, wie Counter-Strike 1.6 trifft dies bedingt zu. Bei HL2 Spielen wie Counter-Strike: Source ist der Netzwerkcode deutlich robuster, so dass bei mir der Eindruck entstanden ist, dass die Netsettings anderer eine unbedeutenderer Rolle spielen.

Man kann sich nun entweder über Spieler mit wenig technischen Kenntnissen aufregen, oder als Admin aktiv werden.
Sowohl HL1, als auch HL2 basierenden Servern bieten die Möglichkeit, die zulässigen Grenzwerte für die Netsettings einzuschränken. Verbindet ein Spieler mit Netsettings außerhalb dieser Grenzen auf den Server, wird sein Spiel den zulässigen Grenzwert verwenden.

Die Grenzen werden folgendermaßen in der server.cfg bestimmt:

// Minimale Bandbreite 0=unlimited
sv_minrate “15000″

// Maximale Bandbreite 0=unlimited
sv_maxrate “100000″

// Minimum Updates pro Sekunde zum Client
sv_minupdaterate “40″

// Maximum Updates pro Sekunde zum Client
sv_maxupdaterate “66″

// Minimum Updates vom Client pro Sekunde
sv_mincmdrate “40″

// Maximum Updates vom Client pro Sekunde
sv_maxcmdrate “66″

Beim Erzwingen werden die Grenzen nur angewendet. Die Config des Spielers wird nicht überschrieben. Aus diesem Grund sind Plugins, die die Netsettings der Spieler überprüfen überflüssig und schaden eventuell sogar der Community auf dem Server. Schaden können sie , weil schlechte Verlierer nun die Configwerte der Spieler anschauen können. Die Schuld für das Verlieren wird auf die angeblichen “Low Rates” geschoben und entsprechend geschimpft. Dies natürlich auch dann, wenn der beschimpfte Spieler vom Server gezwungen wird, andere Werte zu verwenden, die alles andere als “Low” sind.

Manch ein Admin wird nun auf die Idee kommen, den maximal zulässigen Wert auch als minimalen Wert zu verwenden, damit jeder mit den Werten 100/100, oder 66/66 spielt.
Dies ist keine gute Idee. Es gibt viele Spieler, die mit alter Hardware und oder Laptops spielen. Diese erreichen nur niedrige Frameraten (FPS). Ein Spieler kann nur so viele Updates in der Sekunde senden, wie er FPS hat. Weicht die effektiv gesendete cmdrate nun zu stark von der eingestellten updaterate ab, trifft man den Spieler in der Regel sogar schlechter, als einen, der etwas niedrigere Rates verwendet.
Der bessere und benutzerfreundlichere Weg ist somit ein minimaler Wert von 40-50.

Zwingt man die Spieler Netsettings innerhalb dieser Grenzen zu benutzen, ist schlechtes Treffen nicht mehr den Configeinstellungen geschuldet. Die Aussage, man treffe einen anderen wegen seinen “Low Rates” nicht ist demnach nur noch eine Ausrede für eigenes Unvermögen.

Mit wenigen Handgriffen sind “Low Rater” kein Problem für den Spielablauf.

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;
}
?>