mitmario.dev

Dateien hochladen

PHP Sandbox 5 Min Lesezeit 3 BeispieleLektion 5 von 7

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

Eine Datei kommt wirklich an
<?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

Die Endung ist eine Behauptung
<?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

Der Zielname kommt von dir
<?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, kostenlos

Zu 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.