Abschnitt 11 · Lektion 5
Dateien hochladen
Ein Upload sieht aus wie ein weiteres Formularfeld. Dabei legt ein Fremder eine Datei auf deinem Server ab. Was danach mit ihr passiert, entscheidest du, und bis sie abgelegt ist, muss sie eine ganze Reihe von Prüfungen bestehen.
Das Formular braucht eine zusätzliche Angabe
<?php
declare(strict_types=1);
// Zwei Formulare, ein Unterschied: Das obere hat enctype, das
// untere nicht. Dieselbe Datei kommt oben als Datei an und unten
// nur als ihr Name.
function e(?string $wert): string
{
return htmlspecialchars($wert ?? "", ENT_QUOTES, "UTF-8");
}
$fehlerNamen = [
UPLOAD_ERR_OK => "UPLOAD_ERR_OK (alles in Ordnung)",
UPLOAD_ERR_INI_SIZE => "UPLOAD_ERR_INI_SIZE (größer als upload_max_filesize)",
UPLOAD_ERR_FORM_SIZE => "UPLOAD_ERR_FORM_SIZE",
UPLOAD_ERR_PARTIAL => "UPLOAD_ERR_PARTIAL (nur halb angekommen)",
UPLOAD_ERR_NO_FILE => "UPLOAD_ERR_NO_FILE (gar keine Datei)",
UPLOAD_ERR_NO_TMP_DIR => "UPLOAD_ERR_NO_TMP_DIR",
UPLOAD_ERR_CANT_WRITE => "UPLOAD_ERR_CANT_WRITE",
UPLOAD_ERR_EXTENSION => "UPLOAD_ERR_EXTENSION",
];
$anhang = $_FILES["anhang"] ?? null;
?>
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Was ankommt</title>
<style>
td { border: 1px solid #ccc; padding: 0.2rem 0.5rem; }
</style>
</head>
<body>
<h1>Was bei einem Upload ankommt</h1>
<form method="post" action="/" enctype="multipart/form-data">
<p><strong>Mit enctype:</strong> <input type="file" name="anhang"></p>
<button type="submit">Hochladen</button>
</form>
<form method="post" action="/">
<p><strong>Ohne enctype:</strong> <input type="file" name="anhang"></p>
<button type="submit">Hochladen</button>
</form>
<h2>In $_FILES steht</h2>
<?php if ($anhang === null) { ?>
<p>nichts.</p>
<?php } else { ?>
<table>
<tr><td>name</td><td><?= e($anhang["name"]) ?></td></tr>
<tr><td>type</td><td><?= e($anhang["type"]) ?></td></tr>
<tr><td>size</td><td><?= (int) $anhang["size"] ?> Bytes</td></tr>
<tr><td>tmp_name</td><td><?= e($anhang["tmp_name"]) ?></td></tr>
<tr><td>error</td><td><?= e($fehlerNamen[$anhang["error"]] ?? "unbekannt") ?></td></tr>
</table>
<?php } ?>
<h2>In $_POST steht</h2>
<ul>
<?php foreach ($_POST as $schluessel => $wert) { ?>
<li><?= e($schluessel) ?> = <?= e(is_string($wert) ? $wert : "kein Text") ?></li>
<?php } ?>
</ul>
</body>
</html> <input type="file"> allein reicht nicht. Am <form> muss zusätzlich
enctype="multipart/form-data" stehen. Sonst schickt der Browser nur den Dateinamen als ganz
gewöhnliches Textfeld mit, und der Inhalt bleibt zu Hause.
Der Fehler ist unangenehm, weil nichts kaputtgeht. Es kommt etwas an, es sieht sogar richtig aus, es
ist nur die falsche Sache. Im Browser stehen beide Formulare untereinander. Schickst du dieselbe
Datei einmal oben und einmal unten ab, siehst du den Unterschied. Mit enctype füllt sie die
Tabelle unter $_FILES. Ohne steht dort nichts, und ihr Name taucht stattdessen unter $_POST auf.
Was in $_FILES steht
Für Uploads gibt es ein eigenes Array, denn zu einer Datei gehört mehr als ein Wert. Unter dem
name aus dem Formular stehen dort fünf Angaben.
name ist der Dateiname, den der Browser mitgeschickt hat. type ist der Typ, den der Browser
behauptet. size ist die Größe in Bytes. tmp_name ist der Pfad zu einer Zwischendatei, die PHP
angelegt hat und die am Ende der Anfrage wieder verschwindet. Und error ist ein Zahlencode, an dem
du siehst, ob überhaupt alles angekommen ist.
Von diesen fünf Angaben kommen name und type vom Absender. Das sind Behauptungen, sonst nichts.
size, tmp_name und error stellt PHP fest.
Seit PHP 8.1 kommt ein sechster Eintrag dazu, full_path. Bei einer einzelnen Datei steht darin
noch einmal der Dateiname, bei einem hochgeladenen Ordner der Pfad, etwa urlaub/strand.jpg. Auch
er kommt vom Absender.
Lässt der Besucher das Feld leer, ist der Eintrag trotzdem da, mit UPLOAD_ERR_NO_FILE unter
error und sonst leer. Der Besucher wollte einfach nichts schicken, und das darf dein Programm
ruhig freundlicher behandeln als einen abgebrochenen Upload.
Die vier Prüfungen, in dieser Reihenfolge
Zuerst kommt der Fehlercode. $datei["error"] muss UPLOAD_ERR_OK sein. Alles andere heißt, dass
nichts oder nur die Hälfte angekommen ist, und dann ist jede weitere Prüfung sinnlos.
UPLOAD_ERR_NO_FILE heißt dabei meistens nur, dass das Feld leer geblieben ist.
Danach die Größe. $datei["size"] wird gegen eine eigene Obergrenze verglichen, denn es geht um
Platz auf der Festplatte. PHP hat zwar selbst eine Grenze namens upload_max_filesize, aber die
steht in der Konfiguration des Servers und ist nicht unbedingt die, die du für deine Anwendung im
Kopf hast.
Dann der Typ. Der wird aus dem Inhalt der Datei festgestellt und mit den Typen verglichen, die die Anwendung annimmt.
Erst ganz zum Schluss wird abgelegt. move_uploaded_file() schiebt die Zwischendatei an ihren
Platz, und zwar diese Funktion und nicht rename() oder copy(). Nur sie prüft nebenbei, dass die
Quelle wirklich eine frisch hochgeladene Zwischendatei ist und nicht irgendein Pfad, den jemand
untergeschoben hat.
Wird nichts abgelegt, ist die Zwischendatei am Ende der Anfrage von selbst weg. Aufräumen musst du nur, was du selbst verschoben hast.
Der Typ kommt aus der Datei, nicht aus dem Namen
<?php
declare(strict_types=1);
// Zwei Dateien, gerade angelegt. Die eine heisst wie ein Bild und
// ist Text, die andere heisst wie Text und ist ein Bild.
$ordner = __DIR__ . "/proben";
if (!is_dir($ordner)) {
mkdir($ordner);
}
file_put_contents("$ordner/foto.png", "Das hier ist ganz normaler Text.\n");
// Ein winziges echtes PNG. Mehr als die ersten Bytes braucht
// finfo gar nicht.
$png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGA"
. "hKmMIQAAAABJRU5ErkJggg==";
file_put_contents("$ordner/bild.txt", base64_decode($png));
$kenner = finfo_open(FILEINFO_MIME_TYPE);
foreach (["foto.png", "bild.txt"] as $name) {
echo $name, "\n";
echo " Die Endung sagt: ", pathinfo($name, PATHINFO_EXTENSION), "\n";
echo " Der Inhalt sagt: ", finfo_file($kenner, "$ordner/$name"), "\n\n";
}
// Aelterer Code ruft hier finfo_close() auf. Noetig war das nie,
// und seit PHP 8.5 meldet es ein Deprecated: Der Kenner raeumt sich selbst
// weg, sobald ihn niemand mehr braucht. $datei["type"] steht verlockend nah, und es ist der Wert, den man nie benutzt. Der Browser hat ihn
hingeschrieben, und wer die Anfrage selbst zusammenbaut, schreibt hin, was ihm passt. Im Terminal
lädt beim ersten Beispiel
curl -s -F 'anhang=@index.php;type=image/png' localhost:3000/ | grep '<td>type' die index.php
des Beispiels hoch und behauptet dabei, sie sei ein PNG. In der Antwort steht danach image/png,
und die Datei ist immer noch PHP.
Die Endung im Dateinamen ist genauso wenig wert. Eine Datei heißt urlaub.jpg, weil jemand sie so
genannt hat, und mehr sagt das nicht aus.
Was wirklich drinsteht, sagt dir finfo. finfo_open(FILEINFO_MIME_TYPE) legt die Erkennung an,
und finfo_file() sieht sich damit eine Datei an und gibt einen Typ zurück, etwa image/png oder
text/plain. Dafür werden die ersten Bytes gelesen, denn die meisten Dateiformate fangen mit einer
erkennbaren Folge an. Im Beispiel sagt der Inhalt von foto.png deshalb text/plain und der von
bild.txt image/png.
In älterem Code steht dahinter oft noch ein finfo_close(). Nötig war das nie, weil PHP die
Erkennung von selbst wegräumt. Seit PHP 8.5 schreibt der Aufruf sogar eine Deprecated-Meldung auf
den Fehlerkanal.
Geprüft wird dann, ob der Typ erlaubt ist, nicht ob er verboten ist. Eine Liste mit den drei Typen, die deine Anwendung annimmt, kannst du überblicken. Eine Liste der verbotenen Typen ist immer unvollständig.
Den Namen vergibst du selbst
<?php
declare(strict_types=1);
// Der Name, den der Browser mitschickt, ist eine Angabe des
// Absenders wie jede andere. Drei Beispiele, was darin stehen
// kann, und was daraus wird.
$erlaubt = [
"image/jpeg" => "jpg",
"image/png" => "png",
"application/pdf" => "pdf",
];
$mitgeliefert = [
"urlaub.jpg",
"../../index.php",
"rechnung.php",
];
foreach ($mitgeliefert as $name) {
echo "Mitgeliefert: ", $name, "\n";
echo " nach basename(): ", basename($name), "\n";
echo " selbst vergeben: ", bin2hex(random_bytes(8)), ".", $erlaubt["image/png"], "\n\n";
}
echo "Die Endung kommt aus dieser Liste und nirgendwo sonst:\n";
foreach ($erlaubt as $typ => $endung) {
echo " ", $typ, " wird zu .", $endung, "\n";
} Den mitgelieferten Dateinamen zu übernehmen, geht ebenso schief. Den Pfad in name schneidet PHP
zwar selbst ab, aus ../../index.php wird index.php. In full_path steht er aber noch. Im Namen
können außerdem Zeichen stehen, die dein Dateisystem nicht mag, oder eine Endung wie .php. Und
zwei Besucher mit demselben Handy laden beide IMG_0001.jpg hoch, und der zweite überschreibt den
ersten.
Den Zielnamen erzeugt deshalb dein Programm. bin2hex(random_bytes(8)) gibt sechzehn zufällige
Zeichen, und die Endung kommt aus der Liste der erlaubten Typen, nicht aus dem, was angekommen ist.
Im Beispiel bekommt jeder Name .png, auch urlaub.jpg, weil der Typ dort ohne Prüfung als
image/png angenommen ist. Willst du den ursprünglichen Namen anzeigen, merkst du ihn dir daneben.
Ausgegeben wird er dann aber wie jede andere Eingabe durch e().
basename() schneidet einen Pfad ab, etwa den aus full_path, und ist besser als nichts. Es bleibt
trotzdem nur die zweitbeste Antwort, denn es löst weder das Überschreiben noch die Frage, was in dem
Namen sonst noch alles steckt.
Wo die Dateien landen
Im Zielordner darf kein PHP ausgeführt werden. Sonst reicht eine einzige Datei, die durch alle Prüfungen gerutscht ist, und jemand ruft sie einfach auf.
Am sichersten liegt der Zielordner außerhalb der Dokumentwurzel, und ein kleines Skript liefert die
Dateien aus. Auf einem klassischen Hosting-Paket geht es auch mit einer .htaccess im Zielordner,
die die Ausführung dort abschaltet. In Abschnitt 15 bekommt die Notizanwendung einen öffentlichen
Ordner und einen privaten daneben.
In der Aufgabe sind vier Stellen einer Prüfkette für hochgeladene Belege noch leer.
Zum Mitnehmen
Ein Upload braucht enctype am Formular und geht durch vier Schritte in fester Reihenfolge, Fehlercode, Größe, Typ aus dem Inhalt und erst dann move_uploaded_file. Den Namen vergibt dein Programm selbst, und im Zielordner läuft kein PHP.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.