PHP-Anwendungen mit HTTP-Authentifizierung unter Ubuntu 20.04 absichern
Die HTTP-Authentifizierung ist ein Verfahren zur Überprüfung von Benutzerzugängen, um sicherzustellen, dass nur berechtigte Personen bestimmte Webressourcen aufrufen können. Um sensible Dateien oder Endpunkte in einer PHP-Anwendung zu schützen, wird häufig die sogenannte Basic HTTP Authentication verwendet. Dabei muss jeder Client bei einer Anfrage einen Authorization-Header mitsenden, der den Benutzernamen und das Passwort Base64-kodiert enthält.
Wichtig zu wissen: Base64 dient lediglich zur Umwandlung spezieller Zeichen in ein HTTP-kompatibles Format – es handelt sich hierbei nicht um eine Verschlüsselung. In produktiven Systemen sollten Zugangsdaten daher stets über eine HTTPS-Verbindung übertragen werden, um die Sicherheit zu gewährleisten.
Diese Anleitung zeigt Schritt für Schritt, wie du eine passwortgeschützte PHP-Ressource auf einem Ubuntu 20.04 Server einrichtest. Bei erfolgreicher Anmeldung liefert die Schnittstelle Produktdaten im JSON-Format zurück. Bei fehlenden oder falschen Zugangsdaten erscheint eine Fehlermeldung.
Voraussetzungen
Stelle sicher, dass du folgende Voraussetzungen erfüllst:
- Ein Ubuntu 20.04 Server
- Ein Benutzerkonto mit sudo-Rechten
- Ein funktionsfähiger LAMP-Stack
Apache-Konfiguration anpassen
Stelle über SSH eine Verbindung zum Server her und passe die Apache-Konfigurationsdatei an, damit die .htaccess-Datei bestimmte Einstellungen überschreiben darf – das ist notwendig für die HTTP-Authentifizierung.
Öffne die Hauptkonfigurationsdatei mit folgendem Befehl:
$ sudo nano /etc/apache2/apache2.conf
Suche darin nach folgendem Abschnitt:
<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
Ändere nun die Direktive AllowOverride von None zu All wie folgt:
<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride All
Require all granted
</Directory>
Speichere die Änderungen und schließe den Editor.
Apache mod_rewrite aktivieren
Aktiviere nun das Apache-Modul mod_rewrite. Dieses Modul ermöglicht es dir, innerhalb von PHP-Skripten auf den HTTP_AUTHORIZATION-Header zuzugreifen.
$ sudo a2enmod rewrite
$ sudo systemctl restart apache2
Geschützte PHP-Ressource erstellen
Erstelle nun ein PHP-Skript, das eine Produktliste im JSON-Format nur dann anzeigt, wenn der Benutzer gültige Zugangsdaten vorweist. Lege dazu eine neue Datei im Web-Stammverzeichnis an:
$ sudo nano /var/www/html/sample.php
Füge anschließend den folgenden PHP-Code ein. Ersetze dabei EXAMPLE_PASSWORD durch ein sicheres Passwort:
<?php
header('Content-Type: application/json');
list($username, $password) = explode(':', base64_decode(substr($_SERVER['HTTP_AUTHORIZATION'], 6)));
if ($username != 'john' || $password != 'EXAMPLE_PASSWORD') {
header("HTTP/1.1 401 Unauthorized");
$error = [
'title' => 'Authentication failed',
'message' => 'Invalid username or password',
'error_code' => '401',
];
echo json_encode($error , JSON_PRETTY_PRINT);
} else {
$products = [];
$products[] = [
'product_id' => 1,
'product_name' => 'WIRELESS KEYBOARD',
'retail_price' => '44.80',
];
$products[] = [
'product_id' => 2,
'product_name' => 'LAPTOP BAG',
'retail_price' => '28.70',
];
$products[] = [
'product_id' => 3,
'product_name' => 'MOUSE PAD',
'retail_price' => '5.67',
];
echo json_encode($products, JSON_PRETTY_PRINT);
}
Speichere die Datei und beende den Editor.
Code-Erklärung
header(‘Content-Type: application/json’);
Dieser Befehl sendet einen Header an den Browser, der das Ausgabeformat auf JSON festlegt.
list($username, $password) = explode(‘:’, base64_decode(…));
Diese Zeile liest den Base64-kodierten Authorization-Header aus und trennt ihn in zwei Variablen für Benutzername und Passwort auf.
Authentifizierungsprüfung:
Die if/else-Anweisung überprüft, ob der Benutzername john lautet und ob das eingegebene Passwort mit EXAMPLE_PASSWORD übereinstimmt. Falls nicht, erfolgt eine HTTP-401-Fehlermeldung in JSON-Format.
Produktübersicht:
Bei erfolgreicher Authentifizierung wird ein Array mit Produktinformationen erstellt und als formatiertes JSON zurückgegeben.
Sicherheitsrelevante Hinweise und Funktionsweise
Die hier umgesetzte HTTP-Authentifizierung ist eine einfache, aber wirkungsvolle Methode, um sensible Inhalte in einer PHP-Anwendung abzusichern. Durch Benutzername und Passwort wird gewährleistet, dass nur berechtigte Nutzer Zugriff erhalten – so wird das Risiko einer ungewollten Datenfreigabe reduziert.
Wichtig ist dabei: Base64 dient nur der Umwandlung in ein HTTP-kompatibles Format und ist keine Verschlüsselungsmethode. In realen Systemen muss HTTPS verwendet werden, um zu verhindern, dass Zugangsdaten abgefangen werden.
Die serverseitige Logik stellt sicher, dass bei ungültigen Daten eine korrekte JSON-Fehlermeldung mit dem HTTP-Status 401 ausgegeben wird. Authentifizierte Benutzer erhalten strukturierte Produktinformationen, die sich bei Bedarf mit einer Datenbank oder Backend-Diensten erweitern lassen.
.htaccess-Datei für Authentifizierung konfigurieren
Damit die HTTP-Authentifizierung funktioniert, muss die .htaccess-Datei angepasst werden. Öffne sie mit folgendem Befehl:
$ sudo nano /var/www/html/.htaccess
Füge die folgende Anweisung in die Datei ein:
SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
Mit dieser Direktive weist du Apache an, den Inhalt der Variablen $_ENV['HTTP_AUTHORIZATION'] in $_SERVER['HTTP_AUTHORIZATION'] zu überführen. Dadurch kann dein PHP-Skript in /var/www/html/sample.php korrekt auf die Zugangsdaten zugreifen.
HTTP-Authentifizierung testen
Nachdem du Apache konfiguriert und die PHP-Ressource gesichert hast, solltest du prüfen, ob alles wie erwartet funktioniert.
Starte zunächst eine Anfrage ohne Zugangsdaten. Verwende dazu den curl-Befehl unter Linux mit der Option -i, um auch die HTTP-Header in der Ausgabe zu sehen:
$ curl -i -H 'Accept:application/json' localhost/sample.php
Wenn keine Authentifizierung erfolgt, solltest du eine Antwort wie diese erhalten:
HTTP/1.1 401 Unauthorized
Date: Tue, 26 Jan 2021 09:27:19 GMT
Server: Apache/2.4.41 (Ubuntu)
Content-Length: 121
Content-Type: application/json
{
"title": "Unauthorized",
"message": "You are not authorized to access this resource",
"error_code": "401"
}
Starte nun eine erneute Anfrage mit gültigen Zugangsdaten. Die Option -u kodiert Benutzername und Passwort automatisch im Base64-Format:
$ curl -u john:EXAMPLE_PASSWORD -i -H 'Accept:application/json' localhost/sample.php
Bei erfolgreicher Anmeldung gibt der Server eine JSON-Antwort mit Produktdaten zurück:
HTTP/1.1 200 OK
Date: Tue, 26 Jan 2021 09:30:50 GMT
Server: Apache/2.4.41 (Ubuntu)
Content-Length: 331
Content-Type: application/json
[
{
"product_id": 1,
"product_name": "WIRELESS KEYBOARD",
"retail_price": "44.80"
},
{
"product_id": 2,
"product_name": "LAPTOP BAG",
"retail_price": "28.70"
},
{
"product_id": 3,
"product_name": "MOUSE PAD",
"retail_price": "5.67"
}
]
Du kannst zusätzlich auch falsche Zugangsdaten testen, um sicherzustellen, dass der Zugriff abgelehnt wird:
$ curl -u john:WRONG_PASSWORD -i -H 'Accept:application/json' localhost/sample.php
$ curl -u wrong_username:EXAMPLE_PASSWORD -i -H 'Accept:application/json' localhost/sample.php
Auch hier sollte die Rückmeldung wie folgt aussehen:
HTTP/1.1 401 Unauthorized
Date: Tue, 26 Jan 2021 09:27:19 GMT
Server: Apache/2.4.41 (Ubuntu)
Content-Length: 121
Content-Type: application/json
{
"title": "Unauthorized",
"message": "You are not authorized to access this resource",
"error_code": "401"
}
Fazit
In dieser Anleitung hast du erfolgreich eine HTTP-Authentifizierung eingerichtet, um einen PHP-Endpunkt auf einem Ubuntu-20.04-Server abzusichern. Diese Methode stellt sicher, dass nur Benutzer mit korrekten Zugangsdaten auf geschützte Inhalte zugreifen können.
Für zusätzliche Sicherheit empfiehlt es sich, Apache mit einem TLS/SSL-Zertifikat auszustatten, sodass alle übertragenen Informationen verschlüsselt erfolgen.
