Les développeurs PHP doivent sécuriser les formulaires de téléchargement de fichiers pour éviter les menaces comme les fichiers malveillants.
Une mauvaise gestion des uploads peut exposer le site à des attaques, compromettant la sécurité des données et la confiance des utilisateurs.
Découvrez dans cet article comment créer un formulaire d’uploade sécurisé en PHP 8, en maîtrisant la superglobale $_FILES, les contrôles d’erreur, et les vérifications d’extensions pour protéger votre application contre les risques potentiels.
Introduction
Imaginez qu’une personne essaie de vous contacter car elle est victime d’un bug d’utilisation sur votre site : elle souhaiterait peut-être vous partager une capture d’écran, ce qui faciliterait beaucoup votre travail de débogage.
Pour cela, vous allez devoir proposer la soumission de fichiers dans votre formulaire de contact !
Vous aviez découvert les superglobales $_GET et $_POST dans les chapitres précédents, c’est maintenant au tour de la super variable $_FILES de faire son entrée dans votre projet !
Dans cet article, nous allons apprendre comment uploader des fichiers sur un serveur distant en utilisant un formulaire HTML simple et du PHP. Vous pouvez télécharger n’importe quel type de fichier comme des images, des vidéos, des fichiers ZIP, des documents Microsoft Office, des fichiers PDF, ainsi que des fichiers exécutables et un large éventail d’autres types de fichiers.
Écrire le Formulaire HTML pour l'Upload de Fichiers
Dans cette section, vous découvrirez comment ce formulaire HTML vous permet de télécharger un fichier. Il utilise la méthode POST pour envoyer vos données au serveur et spécifie l’encodage « multipart/form-data », qui est essentiel pour le transfert de fichiers. Le formulaire comprend un label vous invitant à « Uploader un fichier » ainsi qu’un champ de type « file » pour choisir le fichier à télécharger. Une fois que vous avez sélectionné votre fichier, vous pouvez soumettre le formulaire en cliquant sur le bouton « Envoyer ».
Voila le code du formulaire
<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>uploader un fichier</title>
<style id="wpr-lazyload-bg-container"></style><style id="wpr-lazyload-bg-exclusion"></style>
<noscript>
<style id="wpr-lazyload-bg-nostyle">.jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https://blog.alphorm.com/wp-content/plugins/jet-tabs/assets/images/spinner-32.svg');}.rll-youtube-player .play{--wpr-bg-1bc92f20-cf2e-4526-a736-a7f0bbac4605: url('https://blog.alphorm.com/wp-content/plugins/wp-rocket/assets/img/youtube.png');}</style>
</noscript>
<script type="application/javascript">const rocket_pairs = [{"selector":".jet-image-accordion__item-loader span","style":".jet-image-accordion__item-loader span{--wpr-bg-b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg');}","hash":"b5f84ee5-f0b7-432a-b1bd-0f52e4b9e5ba","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/jet-tabs\/assets\/images\/spinner-32.svg"},{"selector":".rll-youtube-player .play","style":".rll-youtube-player .play{--wpr-bg-1bc92f20-cf2e-4526-a736-a7f0bbac4605: url('https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png');}","hash":"1bc92f20-cf2e-4526-a736-a7f0bbac4605","url":"https:\/\/blog.alphorm.com\/wp-content\/plugins\/wp-rocket\/assets\/img\/youtube.png"}]; const rocket_excluded_pairs = [];</script></head>
<body>
<form action="" method="post" enctype="multipart/form-data">
<label for="upload">Uploader un fichier</label>
<input type="file" name="myFile" id="upload">
<input type="submit" name="envoyer" value="Envoyer">
</form>
<script>var rocket_beacon_data = {"ajax_url":"https:\/\/blog.alphorm.com\/wp-admin\/admin-ajax.php","nonce":"d6f9e36d97","url":"https:\/\/blog.alphorm.com\/gerer-les-fichiers-en-php-8","is_mobile":false,"width_threshold":1600,"height_threshold":700,"delay":500,"debug":null,"status":{"atf":true,"lrc":true},"elements":"img, video, picture, p, main, div, li, svg, section, header, span","lrc_threshold":1800}</script><script data-name="wpr-wpr-beacon" src='https://blog.alphorm.com/wp-content/plugins/wp-rocket/assets/js/wpr-beacon.min.js' async></script><script>class RocketElementorAnimation{constructor(){this.deviceMode=document.createElement("span"),this.deviceMode.id="elementor-device-mode-wpr",this.deviceMode.setAttribute("class","elementor-screen-only"),document.body.appendChild(this.deviceMode)}_detectAnimations(){let t=getComputedStyle(this.deviceMode,":after").content.replace(/"/g,"");this.animationSettingKeys=this._listAnimationSettingsKeys(t),document.querySelectorAll(".elementor-invisible[data-settings]").forEach(t=>{const e=t.getBoundingClientRect();if(e.bottom>=0&&e.top<=window.innerHeight)try{this._animateElement(t)}catch(t){}})}_animateElement(t){const e=JSON.parse(t.dataset.settings),i=e._animation_delay||e.animation_delay||0,n=e[this.animationSettingKeys.find(t=>e[t])];if("none"===n)return void t.classList.remove("elementor-invisible");t.classList.remove(n),this.currentAnimation&&t.classList.remove(this.currentAnimation),this.currentAnimation=n;let s=setTimeout(()=>{t.classList.remove("elementor-invisible"),t.classList.add("animated",n),this._removeAnimationSettings(t,e)},i);window.addEventListener("rocket-startLoading",function(){clearTimeout(s)})}_listAnimationSettingsKeys(t="mobile"){const e=[""];switch(t){case"mobile":e.unshift("_mobile");case"tablet":e.unshift("_tablet");case"desktop":e.unshift("_desktop")}const i=[];return["animation","_animation"].forEach(t=>{e.forEach(e=>{i.push(t+e)})}),i}_removeAnimationSettings(t,e){this._listAnimationSettingsKeys().forEach(t=>delete e[t]),t.dataset.settings=JSON.stringify(e)}static run(){const t=new RocketElementorAnimation;requestAnimationFrame(t._detectAnimations.bind(t))}}document.addEventListener("DOMContentLoaded",RocketElementorAnimation.run);</script></body>
</html>
Voilà résultat
Utiliser la Superglobale $_FILES en PHP 8
Dans cette section, vous allez voir comment le formulaire dont nous avons parlé fonctionne en détail. Nous allons maintenant ajouter le code suivant à notre formulaire :
if(isset($_POST['envoyer'])){
echo"envoyer" ;
}
?>
Ce code PHP vérifie si le formulaire a été soumis en utilisant la méthode POST. Voici une explication détaillée :
- if(isset($_POST[‘envoyer’])): Cette ligne vérifie si le bouton de soumission du formulaire nommé « envoyer » a été cliqué. La fonction isset() est utilisée pour déterminer si une variable est définie et n’est pas nulle. Dans ce cas, elle vérifie si l’élément du tableau associatif $_POST avec la clé ‘envoyer’ existe, ce qui signifie que le formulaire a été soumis.
- echo « envoyer »: Si le formulaire a été soumis, cette ligne de code sera exécutée, et le texte « envoyer » sera affiché à l’écran.
Voila resulat d’affchage
Nous allons maintenant enrichir le code précédent en ajoutant la fonctionne var_dump.
La fonction var_dump() récupère des informations sur une ou plusieurs variables. Les informations contiennent le type et la valeur de la ou des variables PHP 8.
- Explication le rôle du var_dump
Syntaxe
var_dump(var1, var2, ...);
Valeurs des paramètres
Paramètre | Description |
|---|---|
var1, var2, … | Requis. Spécifie la ou les variables à partir desquelles vider les informations
|
Voilà le code modifier
if(isset($_POST['envoyer'])){
echo"<pre>" ;
var_dump($_FILES);
echo"</pre>" ;
}
Bravo, vous avez réussi ! Le code fonctionne bien.
Gérer les Erreurs de Téléchargement avec la Clé "Error"
Nous allons maintenant explorer les erreurs possibles et voir comment les retours peuvent se présenter. Allons-y ensemble !
Constante | Valeur | Description | |
|---|---|---|---|
UPLOAD_ERR_OK
| 0 | Le fichier a été téléchargé avec succès.
| |
UPLOAD_ERR_INI_SIZE | 1
| Le fichier téléchargé dépasse la directive upload_max_filesize dans php.ini
| |
UPLOAD_ERR_FORM_SIZE
| 2 | Le fichier téléchargé dépasse la directive MAX_FILE_SIZE spécifiée dans le formulaire HTML.
| |
UPLOAD_ERR_PARTIAL
| 3 | Le fichier n’a été que partiellement téléchargé.
| |
UPLOAD_ERR_NO_FILE
| 4 | Aucun fichier n’a été téléchargé.
| |
UPLOAD_ERR_NO_TMP_DIR | 6 | Il manque un dossier temporaire.
| |
UPLOAD_ERR_CANT_WRITE | 7 | Échec de l’écriture du fichier sur le disque. | |
UPLOAD_ERR_EXTENSION
| 8 | Une extension PHP a arrêté le téléchargement du fichier.
|
Exemple :
Dans le code précédemment en va ajouter cette ligne dans script php
echo $_FILES['myFile']['error'];
Résultat d’affichage
Le résultat que vous voyez est un affichage du tableau associatif $_FILES en PHP, qui contient des informations sur le fichier téléchargé. Voici une explication détaillée des différents paramètres :
- « myFile » : C’est le nom de l’input de type « file » dans le formulaire HTML. Toutes les informations suivantes sont associées à ce champ de fichier.
- « name » : Contient le nom original du fichier téléchargé, ici « DSC_0328 (2).jpg ».
- « full_path » : Contient le chemin complet du fichier téléchargé, ici « DSC_0328 (2).jpg ». Cette clé n’est disponible qu’à partir de PHP 8.1.0.
- « type » : Indique le type MIME du fichier, ici « image/jpeg », ce qui signifie qu’il s’agit d’une image au format JPEG.
- « tmp_name » : Le chemin vers le fichier temporaire sur le serveur où le fichier a été stocké, ici « C:\xampp\tmp\php6D62.tmp ». Ce fichier est stocké temporairement sur le serveur avant d’être déplacé ou traité.
- « error » : Le code d’erreur associé au téléchargement du fichier, ici int(0). Une valeur de 0 (UPLOAD_ERR_OK) indique que le fichier a été téléchargé avec succès sans aucune erreur.
- « size » : La taille du fichier en octets, ici int(183431), ce qui signifie que le fichier a une taille de 183,431 octets (ou environ 183 Ko).
Déplacer le Fichier Temporaire vers le Dossier Final
Maintenant, nous allons chercher le fichier que vous avez déposé temporairement sur le serveur.
Voilà le code :
<?php
if(isset($_POST['envoyer'])){
$dossierTemp=$_FILES['myFile']['tmp_name'];
$dossierSite="upload/".$_FILES['myFile']['name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
if($deplacer){
echo"Fichier uploadé avec succées";
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}
?>
Explication de code :
- Vérification de la soumission du formulaire :
if(isset($_POST['envoyer']))
Cette ligne vérifie si le formulaire a été soumis en utilisant la méthode POST et si le bouton de soumission nommé « envoyer » a été cliqué. Si c’est le cas, le code à l’intérieur des accolades sera exécuté.
- Récupération du chemin du fichier temporaire :
$dossierTemp = $_FILES['myFile']['tmp_name'];
Cette ligne récupère le chemin du fichier temporaire sur le serveur, où le fichier téléchargé est stocké temporairement. La variable $dossierTemp contient ce chemin.
- Définition du chemin de destination :
$dossierSite = "upload/" . $_FILES['myFile']['name'];
Cette ligne définit le chemin de destination où le fichier sera déplacé. Le fichier sera stocké dans un répertoire appelé « upload » (assurez-vous que ce répertoire existe et qu’il est accessible en écriture) et conservera son nom original.
- Déplacement du fichier :
$deplacer = move_uploaded_file($dossierTemp, $dossierSite);
Cette ligne utilise la fonction move_uploaded_file() pour déplacer le fichier du répertoire temporaire vers le répertoire de destination spécifié. La variable $deplacer sera true si le fichier a été déplacé avec succès, et false sinon.
- Vérification du succès du déplacement
if($deplacer){
echo "Fichier uploadé avec succès";
}else{
echo "Le fichier n'a pas pu être uploadé";
}
Si le fichier a été déplacé avec succès ($deplacer est true), un message de succès sera affiché : « Fichier uploadé avec succès ». Sinon, un message d’erreur sera affiché : « Le fichier n’a pas pu être uploadé ».
Résultat d’affichage
Configurer les Droits d'Écriture pour les Fichiers
Dans cette section, vous allez découvrir comment vérifier les droits des fichiers et des dossiers sur un serveur distant en utilisant FileZilla.
Définition
FileZilla est un logiciel client FTP (File Transfer Protocol) open-source, populaire et gratuit, utilisé pour transférer des fichiers entre un ordinateur local et un serveur distant sur Internet. Il est compatible avec plusieurs protocoles de transfert de fichiers, y compris FTP, SFTP (SSH File Transfer Protocol), et FTPS (FTP Secure). FileZilla est apprécié pour son interface utilisateur intuitive, ses fonctionnalités robustes et sa grande flexibilité
Définir les Permissions à 755 avec FileZilla
- Ouvrir FileZilla puis naviguer jusqu’au dossier ‘upload’
Dans la fenêtre de FileZilla, trouvez et sélectionnez le dossier ‘upload’ que vous avez créé.
- Définir les droits d’accès
Ensuite, faites un clic droit pour définir les droits d’accès, puis sélectionnez ‘Droits d’accès au fichier’
- Configurer les permissions
Par la suite une fenêtre apparaîtra vous permettant de définir les droits d’accès pour le dossier.
Entrez la valeur 755 dans le champ dédié ou cochez les cases correspondantes :
Explication des permissions 755 :
- Propriétaire (7) : Le propriétaire du fichier a tous les droits (lecture, écriture, exécution).
- Groupe (5) : Les membres du groupe ont les droits de lecture et d’exécution.
- Autres (5) : Tous les autres utilisateurs ont également les droits de lecture et d’exécution.
Contrôler l'Extension des Fichiers en PHP 8
Pour contrôler l’extension des fichiers avant de les télécharger, vous pouvez ajouter une vérification dans le script PHP. Voici comment vous pouvez le faire :
Premièrement, nous allons vérifier le nom du fichier en modifiant le script PHP en utilisant $_FILES[‘myFile’][‘name’], qui permet d’accéder au nom du fichier.
Voila le code
<?php
if(isset($_POST['envoyer'])){
$fichierNom=$_FILES['myFile']['name'];
$dossierTemp=$_FILES['myFile']['tmp_name'];
$dossierSite="upload/".$_FILES['myFile']['name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
if($deplacer){
echo"Fichier uploadé avec succées ".$fichierNom;
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}
?>
Résultat d’affichage
Pour afficher l’extension, nous allons modifier le code précédent en ajoutant cette ligne : $extension = strrchr($fichierNom, ‘.’);.
Voilà le code complet :
<?php
if(isset($_POST['envoyer'])){
$fichierNom=$_FILES['myFile']['name'];
$dossierTemp=$_FILES['myFile']['tmp_name'];
$dossierSite="upload/".$_FILES['myFile']['name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
$extension=strrchr($fichierNom,'.') ;
if($deplacer){
echo"Fichier uploadé avec succées ".$extension;
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}
?>
Résultat d’affichage
Maintenant en ajoutant dans ce script PHP, nous commençons par définir un tableau $autorises qui contient les extensions de fichier autorisées, à savoir « .jpg » et « .JPG », ce qui permet de gérer les cas où l’extension du fichier peut être en majuscules ou en minuscules. Ensuite, nous utilisons la fonction in_array () pour vérifier si l’extension du fichier téléchargé, stockée dans la variable $extension, fait partie des extensions autorisées. Si c’est le cas, nous tentons de déplacer le fichier vers son emplacement final à l’aide de la fonction move_uploaded_file (), et si le déplacement réussit, nous affichons un message indiquant que le fichier a été uploadé avec succès, suivi de son extension. Si le déplacement échoue, un message d’erreur est affiché. En revanche, si l’extension du fichier n’est pas autorisée, un message indiquant que l’extension n’est pas autorisée est affiché. Ce mécanisme assure que seuls les fichiers avec des extensions spécifiquement autorisées peuvent être téléchargés sur le serveur, ajoutant ainsi une couche de sécurité.
Voici le code correspondant pour plus de clarté :
<?php
if(isset($_POST['envoyer'])){
$fichierNom=$_FILES['myFile']['name'];
$dossierTemp=$_FILES['myFile']['tmp_name'];
$dossierSite="upload/".$_FILES['myFile']['name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
$extension=strrchr($fichierNom,'.') ;
$autorises=[".jpg",'.JPG'];
if(in_array( $extension, $autorises)){
if($deplacer){
echo"Fichier uploadé avec succées ".$extension;
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}else{
echo"Extension non autorisée";
}
}
?>
Voila résultat d’affichage le cas de succès
Le cas contraire si non autoriser
Maîtrise Complète de PHP 8 : De l'Initiation à l'Expertise en Architecture MVC
Vérifier la Taille des Fichiers Téléchargés
Pour contrôler la taille des fichiers téléchargés, vous pouvez ajouter une vérification avant de les accepter. Utilisez $_FILES[‘myFile’][‘size’] pour obtenir la taille du fichier en octets, puis comparez cette taille à une limite que vous aurez définie. Voici comment intégrer cette vérification dans votre script PHP :
<?php
if(isset($_POST['envoyer'])){
$fichierNom=$_FILES['myFile']['name'];
$dossierTemp=$_FILES['myFile']['tmp_name'];
$dossierSite="upload/".$_FILES['myFile']['name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
$extension=strrchr($fichierNom,'.') ;
$tailMax= $_POST['tailleMaxi'];
$tailleFichier=$_FILES['myFile']['size'];
$autorises=[".jpg",'.JPG','.png','.PNG'];
if(! in_array( $extension, $autorises)){
echo"Extension non autorisée";
}elseif($tailleFichier>$tailMax){
echo"Fichier Trop volumineux";
}else{
if($deplacer){
echo"Fichier uploadé avec succées ".$extension;
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}
}
?>
</form>
Maintenant en va tester le code
Renommer et Contrôler le Nom des Fichiers
En fin pour terminer cet article on va voir comment contrôle le non de fichier
Voici comment vous pouvez contrôler le nom
<?php
if(isset($_POST['envoyer'])){
$fichierNom=$_FILES['myFile']['name'];
$dossierTemp=$_FILES['myFile']['tmp_name'];
$deplacer=move_uploaded_file($dossierTemp,$dossierSite);
$extension=strrchr($fichierNom,'.') ;
$tailMax= $_POST['tailleMaxi'];
$tailleFichier=$_FILES['myFile']['size'];
$autorises=[".jpg",'.JPG','.png','.PNG'];
$nouveauNom=time();
$nouveauNom=$nouveauNom.$extension;
$dossierSite="upload/".$nouveauNom;
if(! in_array( $extension, $autorises)){
echo"Extension non autorisée";
}elseif($tailleFichier>$tailMax){
echo"Fichier Trop volumineux";
}else{
if($deplacer){
echo"Fichier uploadé avec succées ".$extension;
}else{
echo'le fichier n\' a pas pu etre uploadé';
}
}
}
?>
Ce script PHP gère le téléchargement de fichiers en vérifiant d’abord l’extension et la taille du fichier avant de le déplacer vers un répertoire spécifié. La taille maximale autorisée pour le fichier est récupérée à partir du formulaire soumis par l’utilisateur via $_POST[‘tailleMaxi’]. Ensuite, la taille réelle du fichier téléchargé est obtenue à l’aide de $_FILES[‘myFile’][‘size’]
Les extensions autorisées pour les fichiers sont définies dans un tableau $autorises, incluant .jpg, .JPG, .png, et .PNG. Un nouveau nom de fichier est généré en utilisant un horodatage obtenu par la fonction time (), auquel est concaténée l’extension du fichier. Le chemin de destination pour le fichier uploadé est construit en utilisant ce nouveau nom.
Le script commence par vérifier si l’extension du fichier est dans la liste des extensions autorisées à l’aide de in_array (). Si ce n’est pas le cas, il affiche un message « Extension non autorisée ». Ensuite, il compare la taille du fichier téléchargé avec la taille maximale autorisée. Si le fichier dépasse cette taille, un message « Fichier Trop volumineux » est affiché.
Si les vérifications d’extension et de taille sont satisfaites, le script tente de déplacer le fichier depuis son emplacement temporaire vers le répertoire spécifié. Si le déplacement réussit, il affiche « Fichier uploadé avec succès » suivi de l’extension du fichier. Si le déplacement échoue, un message d’erreur indiquant que le fichier n’a pas pu être uploadé est affiché.
Résultat d’affichage de code
Si nous vérifions dans le dossier upload, nous trouverons que le fichier a bien été enregistré.
- Les formulaires permettent d’envoyer des fichiers. On retrouve les informations sur les fichiers envoyés dans un array $_FILES. Leur traitement est cependant plus complexe.
- Il faudra toujours contrôler les fichiers reçus : leur existence et leur taille qui est soumise à limitation par la configuration de PHP.
- Il faudra vérifier leur extension (à l’aide de la fonction pathinfo) et surtout refuser tout fichier PHPqui pourrait par la suite s’exécuter sur votre serveur.
- À l’aide de la fonction move_uploaded_file, vous pouvez conserver le fichier téléversé sur votre serveur, mais vérifiez bien que vous avez les droits d’écrire des fichiers d’abord.
Conclusion
Maîtriser la gestion des fichiers en PHP 8 vous permet de créer des applications web robustes et sécurisées. Grâce aux concepts abordés dans cet article, vous savez maintenant comment créer des formulaires pour le transfert de fichiers, gérer les erreurs liées au téléchargement, et configurer les paramètres critiques comme les permissions de fichiers et le contrôle des extensions. En appliquant ces pratiques, vous pouvez améliorer la sécurité et l’efficacité de vos applications web, tout en offrant une meilleure expérience utilisateur. PHP 8 continue d’évoluer, et la gestion des fichiers reste un aspect clé pour tirer parti de ses capacités. Et par la suite nous allons traiter les filtres des données avec PHP 8.
