Installation¶

phpMyAdmin n’applique pas de méthodes de sécurité particulières au serveur de données MySQL. Il appartient toujours à l’administrateur système d’accorder les autorisations adéquates sur les bases de données MySQL. La page Utilisateurs de phpMyAdmin peut être utilisée pour cela.

Distributions Linux¶

phpMyAdmin est fourni dans la plupart des distributions Linux. Il est recommandé d’utiliser les paquets de la distribution quand c’est possible - phpMyAdmin est généralement intégré dans votre distribution et les mises à jour de sécurité seront alors disponibles automatiquement.

Debian et Ubuntu¶

La plupart des versions de Debian et Ubuntu incluent un paquet phpMyAdmin, mais le fichier de configuration maintenu dans /etc/phpmyadmin peut être différent de celui de la documentation officielle de phpMyAdmin. Plus spécifiquement, il permet :

Configuration d’un serveur Web (fonctionne avec Apache et lighttpd).
Création de Stockage de la configuration de phpMyAdmin en utilisant dbconfig-common.
Sécurisation du script de paramétrage, voir Script de paramétrage sous Debian, Ubuntu et dérivés.

Des détails plus spécifiques sur l’installation des paquets Debian ou Ubuntu sont disponibles dans notre wiki.

Voir aussi

Plus d’informations disponibles dans README.Debian (il est installé sous /usr/share/doc/phpmyadmin/README.Debian avec le paquet).

OpenSUSE¶

OpenSUSE contient déjà le paquet phpMyAdmin. Installez-le à partir du Service openSUSE Build.

Gentoo¶

Gentoo fourni le paquet phpMyAdmin, aussi bien dans une configuration proche du stock que dans une configuration webapp-config. Utilisez emerge dev-db/phpmyadmin pour installer.

Mandriva¶

Mandriva fournit le paquet phpMyAdmin dans la branche contrib et peut être installé dans le Centre de contrôle.

Fedora¶

Fedora fournit le paquet phpMyAdmin, mais le fichier de configuration maintenu dans /etc/phpMyAdmin/ peut être différent de celui de la documentation officielle de phpMyAdmin.

Red Hat Enterprise Linux¶

Red Hat Enterprise Linux itself and thus derivatives like CentOS don’t ship phpMyAdmin, but the Fedora-driven repository Extra Packages for Enterprise Linux (EPEL) is doing so, if it’s enabled. But be aware that the configuration file is maintained in /etc/phpMyAdmin/ and may differ in some ways from the official phpMyAdmin documentation.

Installation sur Windows¶

La manière la plus simple d’installer phpMyAdmin sous Windows est d’utiliser des produits tiers qui contiennent phpMyAdmin ainsi que le serveur de base de données et le serveur Web, comme XAMPP.

D’autres options similaires sont disponibles sur la page Wikipedia.

Installation à partir de Git¶

Quelques applications supplémentaires sont nécessaires pour installer depuis Git :

Git pour télécharger la source, ou la source la plus récente directement depuis Github
Composeur
Node.js (version 14 ou plus)
Yarn

Les sources actuelles de phpMyAdmin peuvent être clonées à partir de https://github.com/phpmyadmin/phpmyadmin.git :

git clone https://github.com/phpmyadmin/phpmyadmin.git

Il faut de plus installer les dépendances en utilisant l’outil Composer :

composer update

Si vous ne comptez pas faire de développement, l’installation des outils développeurs peut être ignorée en invoquant :

composer update --no-dev

Enfin, il faudra utiliser Yarn pour installer quelques dépendances JavaScript :

yarn install --production

Installation au moyen de Composer¶

phpMyAdmin peut être installé au moyen de l’outil Composer. Depuis la version 4.7.0, les versions sont automatiquement répliquées vers le dépôt par défaut Packagist.

Note

Le contenu du dépôt Composer est généré automatiquement et séparément, donc le contenu n’est pas absolument identique à celui de l’archive téléchargée. Cependant, il ne devrait pas y avoir de différences fonctionnelles.

Pour installer phpMyAdmin, exécuter simplement :

composer create-project phpmyadmin/phpmyadmin

Il est aussi possible d’utiliser notre dépôt Composer qui contient l’archive et qui est disponible sur <https://www.phpmyadmin.net/packages.json> :

composer create-project phpmyadmin/phpmyadmin --repository-url=https://www.phpmyadmin.net/packages.json --no-dev

Installation au moyen de Docker¶

phpMyAdmin fournit une image Docker officielle facilement déployable. Elle est téléchargeable en utilisant :

docker pull phpmyadmin

Le serveur phpMyAdmin écoutera sur le port 80. Il prend en charge plusieurs méthodes pour configurer le lien vers le serveur de base de données, soit par la fonctionnalité de lien de Docker, en liant le conteneur de base de données à db pour phpMyAdmin (en indiquant --link votre_serveur_de_base_de_données:db) soit par les variables d’environnement (dans ce cas, il appartient à l’utilisateur de paramétrer la partie réseau dans Docker pour permettre au conteneur de phpMyAdmin d’accéder au conteneur de base de données par le réseau).

Variables d’environnement Docker¶

Plusieurs fonctionnalités de phpMyAdmin peuvent être configurées en utilisant les variables d’environnement :

PMA_ARBITRARY¶: Permet de saisir le nom du serveur de base de données sur le formulaire de connexion.

Voir aussi

$cfg['AllowArbitraryServer']

PMA_HOST¶: Le nom d’hôte ou l’adresse IP du serveur de base de données à utiliser.

Voir aussi

$cfg['Servers'][$i]['host']

PMA_HOSTS¶: Une liste de noms d’hôtes ou d’adresses IP de serveurs de base de données à utiliser.

Note

Utilisé seulement si PMA_HOST est vide.

PMA_VERBOSE¶: Nom complet du serveur de base de données.

Voir aussi

$cfg['Servers'][$i]['verbose']

PMA_VERBOSES¶: Une liste de noms d’hôtes complets, séparés par des virgules, de serveurs de base de données.

Note

Utilisé seulement si PMA_VERBOSE est vide.

PMA_USER¶: Le nom d’utilisateur à utiliser pour Mode d’authentification par configuration.

PMA_PASSWORD¶: Mot de passe à utiliser pour Mode d’authentification par configuration.

PMA_PORT¶: Port du serveur de base de données à utiliser.

PMA_PORTS¶: Une liste de ports du serveur de base de données à utiliser.

Note

Utilisé seulement si PMA_PORT est vide.

PMA_SOCKET¶: Socket file for the database connection.

PMA_SOCKETS¶: Comma-separated list of socket files for the database connections.

Note

Used only if PMA_SOCKET is empty.

PMA_ABSOLUTE_URI¶: Le chemin complet (https://pma.exemple.net/) où le reverse proxy rend phpMyAdmin disponible.

Voir aussi

$cfg['PmaAbsoluteUri']

PMA_QUERYHISTORYDB¶: Si définit à true, active le stockage de l’historique de SQL dans $cfg['Servers'][$i]['pmadb']. Si false, l’historique sera stocké dans le navigateur et effacé à la déconnexion.

Voir aussi

$cfg['Servers'][$i]['history']

Voir aussi

$cfg['QueryHistoryDB']

PMA_QUERYHISTORYMAX¶: Quand définit comme nombre entier, contrôle le nombre d’élément dans l’historique.

Voir aussi

$cfg['QueryHistoryMax']

PMA_CONTROLHOST¶: Si définit, cela pointe vers un hôte de base de données alternatif utilisé pour stocker la base « Stockage de la configuration de phpMyAdmin ».

Voir aussi

$cfg['Servers'][$i]['controlhost']

PMA_CONTROLUSER¶: Définit le nom d’utilisateur de phpMyAdmin pour utiliser la base de données « Stockage de la configuration de phpMyAdmin ».

Voir aussi

$cfg['Servers'][$i]['controluser']

PMA_CONTROLPASS¶: Définit le mot de passe de phpMyAdmin pour utiliser la base de données « Stockage de la configuration de phpMyAdmin ».

Voir aussi

$cfg['Servers'][$i]['controlpass']

PMA_CONTROLPORT¶: Quand définit, cela surchargera le port par défaut (3306) pour se connecter à l’hôte de contrôle.

Voir aussi

$cfg['Servers'][$i]['controlport']

PMA_PMADB¶: Quand définit, spécifie le nom de la base de données à utiliser pour la base « Stockage de la configuration de phpMyAdmin ». Quand non définit, les fonctionnalités avancées ne seront pas activées par défaut : elles pourront toujours être activées pour un utilisateur quand il se connecte avec la fonctionnalité Zéro configuration.

Note

Valeurs suggérées : phpmyadmin or pmadb

Voir aussi

$cfg['Servers'][$i]['pmadb']

HIDE_PHP_VERSION¶: Si elle est définie, cette option cachera la version de PHP (expose_php = Off). Définissez n’importe quelle valeur (comme HIDE_PHP_VERSION=true).

UPLOAD_LIMIT¶: Si elle est définie, cette option remplacera la valeur par défaut pour apache et php-fpm (cela modifiera les valeurs de upload_max_filesize et post_max_size).

Note

Format : [0-9+](K,M,G) la valeur par défaut est 2048K

MEMORY_LIMIT¶: Si définit, cette option surchargera la limite mémoire $cfg['MemoryLimit'] de phpMyAdmin et memory_limit de PHP.

Note

Format : [0-9+](K,M,G) où K est pour kilo-octets, M pour méga-octet, G pour giga-octets et 1K = 1024 octets. La valeur par défaut est 512M.

MAX_EXECUTION_TIME¶: Si définit, cette option surchargera le temps maximum d’exécution en secondes pour $cfg['ExecTimeLimit'] de phpMyAdmin et max_execution_time de PHP.

Note

Format : [0-9+]. La valeur par défaut est 600.

PMA_CONFIG_BASE64¶: Si elle est activée, cette option remplacera le fichier par défaut config.inc.php avec le contenu décodé en base64 de la variable.

PMA_USER_CONFIG_BASE64¶: Si elle est définie, cette option remplacera le paramètre par défaut config.user.inc.php par le contenu décodé en base64 de la variable.

PMA_UPLOADDIR¶: Si elle est définie, cette option définira le chemin où les fichiers peuvent être enregistrés pour être disponibles à l’importation ($cfg['UploadDir'])

PMA_SAVEDIR¶: Si elle est définie, cette option définira le chemin où les fichiers exportés peuvent être sauvegardés ($cfg['SaveDir'])

APACHE_PORT¶: Si elle est définie, cette option changera le port par défaut d’Apache de 80 au cas où vous voudriez qu’il fonctionne sur un port différent comme un port non privilégié. Définissez-la à n’importe quelle valeur de port (comme APACHE_PORT=8090).

Par défaut, Mode d’authentification par « cookie » est utilisé, mais si PMA_USER et PMA_PASSWORD sont définis, Mode d’authentification par configuration est utilisé.

Note

Les identifiants nécessaires pour se connecter sont stockés dans le serveur MySQL, dans le cas d’utilisation d’une image Docker. Il existe divers moyens pour les définir (par exemple, MYSQL_ROOT_PASSWORD en démarrant le conteneur MySQL). Veuillez consulter la documentation pour conteneur MariaDB ou conteneur MySQL.

Personnalisation de la configuration¶

Une configuration additionnelle peut être effectuée dans /etc/phpmyadmin/config.user.inc.php. Si ce fichier existe, il sera chargé après la configuration générée à partir des variables d’environnement ci-dessus, vous pouvez donc écraser toute variable de configuration. Cette configuration peut être ajoutée en tant que volume en invoquant Docker en utilisant les paramètres -v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php.

Noter que le fichier de configuration fourni est appliqué après Variables d’environnement Docker, mais que n’importe quelle valeur peut être écrasée.

Par ex. pour modifier le comportement par défaut de l’exportation en CSV, il est possible d’utiliser le fichier de configuration suivant :

<?php
$cfg['Export']['csv_columns'] = true;

Il est aussi possible de l’utiliser pour définir la configuration du serveur au lieu d’utiliser les variables d’environnement listées dans Variables d’environnement Docker :

<?php
/* Override Servers array */
$cfg['Servers'] = [
    1 => [
        'auth_type' => 'cookie',
        'host' => 'mydb1',
        'port' => 3306,
        'verbose' => 'Verbose name 1',
    ],
    2 => [
        'auth_type' => 'cookie',
        'host' => 'mydb2',
        'port' => 3306,
        'verbose' => 'Verbose name 2',
    ],
];

Voir aussi

Voir Configuration pour une description détaillée des options de configuration.

Volumes Docker¶

Vous pouvez utiliser les volumes suivants pour personnaliser le comportement de l’image :

/etc/phpmyadmin/config.user.inc.php

Peut être utilisé pour des réglages supplémentaires, voir le chapitre précédent pour plus de détails.

/sessions/

Répertoire où sont stockées les sessions PHP. Vous pouvez partager cela, par exemple, lorsque vous utilisez Mode d’authentification “signon”.

/www/themes/

Le répertoire où phpMyAdmin recherche les thèmes. Par défaut, seuls sont fournis par phpMyAdmin sont livrés, mais vous pouvez en ajouter d’autres (voir Thèmes personnalisés) en utilisant les volumes Docker.

Exemples Docker¶

Pour connecter phpMyAdmin sur un serveur donné, utiliser :

docker run --name phpmyadmin -d -e PMA_HOST=dbhost -p 8080:80 phpmyadmin:latest

Pour connecter phpMyAdmin à plusieurs serveurs, utiliser :

docker run --name phpmyadmin -d -e PMA_HOSTS=dbhost1,dbhost2,dbhost3 -p 8080:80 phpmyadmin:latest

Pour utiliser l’option de serveur arbitraire :

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -e PMA_ARBITRARY=1 phpmyadmin:latest

Vous pouvez aussi lier le conteneur de base de données utilisant Docker :

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 phpmyadmin:latest

Exécution avec une configuration additionnelle :

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php phpmyadmin:latest

Utilisation de thèmes additionnels :

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -v /some/local/directory/custom/phpmyadmin/themeName/:/var/www/html/themes/themeName/ phpmyadmin:latest

Utiliser docker-compose¶

Alternativement, vous pouvez aussi utiliser docker-compose avec docker-compose.yml à partir de <https://github.com/phpmyadmin/docker>. Ceci exécutera phpMyAdmin avec un serveur arbitraire - permettant de spécifier le serveur MySQL/MariaDB server sur la page de connexion.

docker compose up -d

Personnalisation du fichier de configuration à l’aide de docker-compose¶

Il est possible d’utiliser un fichier externe pour personnaliser la configuration de phpMyAdmin et le passer à l’aide d’une directive volumes :

phpmyadmin:
    image: phpmyadmin:latest
    container_name: phpmyadmin
    environment:
     - PMA_ARBITRARY=1
    restart: always
    ports:
     - 8080:80
    volumes:
     - /sessions
     - ~/docker/phpmyadmin/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php
     - /custom/phpmyadmin/theme/:/www/themes/theme/

Voir aussi

Personnalisation de la configuration

En exécution derrière haproxy dans un sous-répertoire¶

Pour exposer phpMyAdmin exécuté dans un conteneur Docker depuis un sous-répertoire, il faut réécrire le chemin de requête du serveur mandatant les requêtes.

Par exemple, en utilisant haproxy, ça peut être réalisé en :

frontend http
    bind *:80
    option forwardfor
    option http-server-close

    ### NETWORK restriction
    acl LOCALNET  src 10.0.0.0/8 192.168.0.0/16 172.16.0.0/12

    # /phpmyadmin
    acl phpmyadmin  path_dir /phpmyadmin
    use_backend phpmyadmin if phpmyadmin LOCALNET

backend phpmyadmin
    mode http

    reqirep  ^(GET|POST|HEAD)\ /phpmyadmin/(.*)     \1\ /\2

    # phpMyAdmin container IP
    server localhost     172.30.21.21:80

Quand vous utilisez traefik, quelque chose comme ce qui suit devrait fonctionner :

defaultEntryPoints = ["http"]
[entryPoints]
  [entryPoints.http]
  address = ":80"
    [entryPoints.http.redirect]
      regex = "(http:\\/\\/[^\\/]+\\/([^\\?\\.]+)[^\\/])$"
      replacement = "$1/"

[backends]
  [backends.myadmin]
    [backends.myadmin.servers.myadmin]
    url="http://internal.address.to.pma"

[frontends]
   [frontends.myadmin]
   backend = "myadmin"
   passHostHeader = true
     [frontends.myadmin.routes.default]
     rule="PathPrefixStrip:/phpmyadmin/;AddPrefix:/"

Puis il faudrait spécifier PMA_ABSOLUTE_URI dans la configuration docker-compose :

version: '2'

services:
  phpmyadmin:
    restart: always
    image: phpmyadmin:latest
    container_name: phpmyadmin
    hostname: phpmyadmin
    domainname: example.com
    ports:
      - 8000:80
    environment:
      - PMA_HOSTS=172.26.36.7,172.26.36.8,172.26.36.9,172.26.36.10
      - PMA_VERBOSES=production-db1,production-db2,dev-db1,dev-db2
      - PMA_USER=root
      - PMA_PASSWORD=
      - PMA_ABSOLUTE_URI=http://example.com/phpmyadmin/

IBM Cloud¶

Un de nos utilisateurs a créé un guide pratique pour l’installation de phpMyAdmin sur la plate-forme IBM Cloud.

Installation rapide¶

Choose an appropriate distribution kit from the phpmyadmin.net Downloads page. Some kits contain only the English messages, others contain all languages. We’ll assume you chose a kit whose name looks like phpMyAdmin-x.x.x-all-languages.tar.gz.
Assurez-vous d’avoir téléchargé une archive authentique, voir Vérification d’intégrité de phpMyAdmin.
« Détarrez » (.tar) ou « dézippez » (.zip) la distribution (assurez-vous de conserver l’arborescence des sous-répertoires) : tar -xzvf phpMyAdmin_x.x.x-all-languages.tar.gz à la racine de votre serveur web. Si vous n’avez pas d’accès directement à la racine du serveur, mettez les fichiers dans un répertoire de votre ordinateur local, et, après l’étape 4, transférez le répertoire sur votre serveur web en utilisant, par exemple, le protocole FTP.
Assurez-vous que tous les scripts aient le propriétaire adéquat (si PHP fonctionne en mode sécurisé, avoir des scripts avec un propriétaire différent de celui des autres posera un problème). Voir la section 4.2 Quel est le meilleur moyen de sécuriser phpMyAdmin contre les attaques malicieuses ? et 1.26 Je viens d’installer phpMyAdmin dans le document racine de IIS mais j’obtiens l’erreur « Le fichier spécifié est introuvable » quand j’essaie d’exécuter phpMyAdmin. pour des suggestions.
Vous devez maintenant configurer votre installation. Deux méthodes peuvent être utilisées. Traditionnellement, les utilisateurs ont une copie modifiée manuellement du fichier config.inc.php, mais un script d’installation de type assistant d’installation est maintenant fourni pour ceux qui préfèrent une installation graphique. Créer un fichier config.inc.php demeure néanmoins un moyen rapide pour démarrer et nécessaire pour certaines fonctionnalités avancées.

Création manuelle du fichier¶

Pour créer manuellement le fichier, utiliser un éditeur de texte pour créer le fichier config.inc.php (il est possible de copier le fichier config.sample.inc.php pour obtenir un fichier de configuration minimal) dans le répertoire principal de phpMyAdmin (celui qui contient le fichier index.php). phpMyAdmin charge tout d’abord les valeurs de configuration par défaut puis écrase ces valeurs avec celles trouvées dans le fichier config.inc.php. Si la valeur par défaut convient pour un paramètre particulier, il n’est pas nécessaire de l’inclure dans le fichier config.inc.php. Il faudra alors probablement besoin de quelques directives pour continuer. Une configuration simple peut ressembler à ceci :

<?php
// The string is a hexadecimal representation of a 32-bytes long string of random bytes.
$cfg['blowfish_secret'] = sodium_hex2bin('f16ce59f45714194371b48fe362072dc3b019da7861558cd4ad29e4d6fb13851');

$i=0;
$i++;
$cfg['Servers'][$i]['auth_type']     = 'cookie';
// if you insist on "root" having no password:
// $cfg['Servers'][$i]['AllowNoPassword'] = true;

Ou, si vous préférez ne pas avoir d’invite de connexion à chaque fois :

<?php

$i=0;
$i++;
$cfg['Servers'][$i]['user']          = 'root';
$cfg['Servers'][$i]['password']      = 'changeme'; // use here your password
$cfg['Servers'][$i]['auth_type']     = 'config';

Avertissement

Le stockage des mots de passe dans la configuration n’est pas sûr car n’importe qui peut alors manipuler votre base de données.

Pour une explication complète de toutes les valeurs de configuration possibles, veuillez consulter la section Configuration de ce document.

Utilisation du script d’installation¶

Au lieu de modifier manuellement le fichier config.inc.php, il est possible d’utiliser le script d’installation de phpMyAdmin. Le fichier peut être généré depuis le script d’installation, puis téléchargé pour être transféré vers le serveur.

Ensuite ouvrir le navigateur et aller à l’emplacement où phpMyAdmin est installé, avec le suffixe /setup. Les modifications ne sont pas enregistrées sur le serveur, il faut utiliser le bouton Télécharger pour les enregistrer localement pour les transférer ensuite vers le serveur.

Maintenant, le fichier est prêt à être utilisé. Vous pouvez choisir de vérifier ou modifier le fichier de configuration avec votre éditeur favori, si vous préférez définir des options avancées que le script d’installation de permet pas de faire.

Si vous utilisez la méthode d’authentification « config », il est recommandé de protéger le répertoire d’installation de phpMyAdmin parce-qu’avec ce type d’authentification, un utilisateur n’a pas besoin de saisir de mot de passe pour y accéder. Nous recommandons d’utiliser une méthode d’authentification alternative, telle que HTTP-AUTH dans un fichier .htaccess ou de passer sur une authentification de type cookie ou HTTP. Voir la FAI et installation multi-utilisateurs, plus particulièrement 4.4 phpMyAdmin donne toujours « Accès refusé » en utilisant l’authentification HTTP. pour plus d’informations.
Ouvrez le répertoire principal de phpMyAdmin dans votre navigateur. phpMyAdmin devrait maintenant afficher un écran de bienvenue et vos bases de données, ou une boîte de dialogue de connexion si vous utilisez le mode HTTP ou le mode d’authentification par cookie.

Script de paramétrage sous Debian, Ubuntu et dérivés¶

Debian et Ubuntu ont modifié la façon dont le script de paramétrage est activé ou désactivé, de sorte qu’une seule ligne de commande doit être exécutée pour chacun d’eux.

Pour permettre la modification de la configuration, exécuter :

/usr/sbin/pma-configure

Pour bloquer la modification de la configuration, exécuter :

/usr/sbin/pma-secure

Script d’installation pour openSUSE¶

Certaines versions d’openSUSE ne contiennent pas le script de configuration dans le paquet. Si vous voulez générer la configuration, vous pouvez télécharger le paquet d’origine sur <https://www.phpmyadmin.net/> ou utiliser le script de notre serveur de démonstration : <https://demo.phpmyadmin.net/master/setup/>.

Vérification d’intégrité de phpMyAdmin¶

Depuis juillet 2015, toutes les versions de phpMyAdmin sont signées avec une clé par le développeur qui effectue la publication, qui jusqu’à janvier 2016 était Marc Delisle. Son identifiant de clef est 0xFEFC65D181AF644A, son empreinte de clé PGP est la suivante :

436F F188 4B1A 0C3F DCBF 0D79 FEFC 65D1 81AF 644A

et vous pouvez obtenir plus d’informations sur l’identification sur <https://keybase.io/lem9>.

À compter de janvier 2016, le gestionnaire de publication est Isaac Bennetch. Son ID de clé est 0xCE752F178259BD92,et son empreinte PGP est :

3D06 A59E CE73 0EB7 1B51 1C17 CE75 2F17 8259 BD92

et vous pouvez obtenir plus d’informations sur l’identification sur <https://keybase.io/ibennetch>.

D’autres téléchargements supplémentaires (comme les thèmes) doivent être signés par Michal Čihař. Sa clé d’identification est 0x9C27B31342B7511D, et son empreinte PGP est :

63CB 1DF1 EF12 CF2A C0EE 5A32 9C27 B313 42B7 511D

et vous pouvez obtenir plus d’informations sur l’identification sur <https://keybase.io/nijel>.

Vous devriez vérifier que la signature correspond à l’archive que vous avez téléchargée. De cette façon vous pouvez être sûr que vous utilisez le même code qui a été publié. Vous devriez aussi vérifier la date de la signature pour être sûr que vous avez téléchargé la dernière version.

Chaque archive est accompagnée par des fichiers .asc qui contiennent la signature PGP pour celle-ci. Une fois que vous avez ces deux fichiers dans le même dossier, vous pouvez vérifier la signature :

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Can't check signature: public key not found

Comme vous pouvez le voir gpg se plaint qu’il ne connaît pas la clé publique. À ce stade, vous devriez faire une des étapes suivantes :

Télécharger le trousseau de clés de notre serveur de téléchargement, puis l’importer avec :

$ gpg --import phpmyadmin.keyring

Télécharger et importer la clé de l’un des serveurs principaux :

$ gpg --keyserver hkp://pgp.mit.edu --recv-keys 3D06A59ECE730EB71B511C17CE752F178259BD92
gpg: requesting key 8259BD92 from hkp server pgp.mit.edu
gpg: key 8259BD92: public key "Isaac Bennetch <bennetch@gmail.com>" imported
gpg: no ultimately trusted keys found
gpg: Total number processed: 1
gpg:               imported: 1  (RSA: 1)

Ceci améliorera la situation un peu - à ce stade, vous pouvez vérifier que la signature de la clé donnée est correcte, mais vous ne pouvez toujours pas faire confiance au nom utilisé dans la clé :

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>"
gpg:                 aka "Isaac Bennetch <isaac@bennetch.org>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 3D06 A59E CE73 0EB7 1B51  1C17 CE75 2F17 8259 BD92

Le problème ici est que tout le monde pouvait délivrer la clé portant ce nom. Vous devez vous assurer que la clé est actuellement détenue par la personne mentionnée. Le GNU Privacy Handbook couvre ce sujet dans le chapitre Validating other keys on your public keyring. La méthode la plus fiable est de rencontrer le développeur en personne et de procéder à l’échange des empreintes digitales de clé, cependant vous pouvez également compter sur la toile de confiance. De cette façon vous pouvez faire confiance à la clé de manière transitive au moyen des signatures des autres personnes, qui ont rencontré le développeur en personne.

Une fois que la clé est approuvée, l’avertissement ne s’affichera plus :

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>" [full]

Si la signature était invalidée (l’archive a été changée), vous obtiendriez une erreur manifeste indépendamment du fait que la clé est approuvée ou non :

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: BAD signature from "Isaac Bennetch <bennetch@gmail.com>" [unknown]

Stockage de la configuration de phpMyAdmin¶

Modifié dans la version 3.4.0: Avant phpMyAdmin 3.4.0, ceci était appelé Infrastructure de tables liées, mais le nom a été changé en raison de la couverture étendue du stockage.

Si vous voulez bénéficier d’une série de nouveautés (Signets, commentaires, historique SQL, mécanisme de suivi, génération de PDF, Transformations, Relations , etc.), vous devrez créer un ensemble de tables spéciales. Ces tables peuvent se trouver dans votre propre base de données, ou dans une base de données centrale pour une installation multi-utilisateurs (cette base de données serait alors accédée par le controluser, aussi, aucun autre utilisateur ne devrait avoir de droits sur celle-ci).

Zéro configuration¶

In many cases, this database structure can be automatically created and configured. This is called “Zero Configuration” mode and can be particularly useful in shared hosting situations. “ZeroConf” mode is on by default, to disable set $cfg['ZeroConf'] to false.

Les trois scénarios suivants traitent du mode Zéro configuration :

Lors de l’ouverture d’une base de données dans laquelle les tables de stockage ne sont pas présentes, phpMyAdmin propose de les créer à partir de l’onglet Opérations.
Lors de l’ouverture d’une base de données dans laquelle les tables existent déjà, le logiciel le détecte automatiquement et commence à les utiliser. C’est la situation la plus courante ; après la création initiale automatique des tables, elles sont utilisées continuellement sans déranger l’utilisateur. Ceci est très utilise sur un hébergement partagé où l’utilisateur ne peut pas éditer le fichier config.inc.php et d’habitude, l’utilisateur n’a accès qu’à une seule base de données.
Lorsqu’il y a plusieurs bases de données, si l’utilisateur ouvre d’abord la base contenant les tables de stockage puis change de base de données, phpMyAdmin continue à utiliser les tables de la première base. L’utilisateur n’est pas invité à créer d’autres tables dans la nouvelle base.

Configuration manuelle¶

Veuillez regarder dans votre répertoire ./sql/, où vous devriez trouver un fichier du nom de create_tables.sql. (Si vous utilisez un serveur Windows, portez une attention particulière à la partie 1.23 J’exécute MySQL sur une machine Win32. Chaque fois que je crée une nouvelle table, les noms de la table et des colonnes sont convertis en lettres minuscules !).

Si vous aviez déjà cette infrastructure et :

mis à jour vers MySQL 4.1.2 ou supérieur, veuillez utiliser le fichier sql/upgrade_tables_mysql_4_1_2+.sql.
mis à jour phpMyAdmin en version 4.3.0 ou supérieur depuis 2.5.0 ou supérieur (<= 4.2.x), veuillez utiliser sql/upgrade_column_info_4_3_0+.sql.
mis à jour vers phpMyAdmin 4.7.0 ou plus récent à partir de 4.3.0 ou plus récent, veuillez utiliser sql/upgrade_tables_4_7_0+.sql.

puis créer de nouvelles tables en important sql/create_tables.sql.

Vous pouvez d’ores et déjà utiliser phpMyAdmin qui créera les tables pour vous. Soyez conscient que vous pouvez avoir besoin de privilèges spéciaux (administrateur) pour créer la base de données et les tables, et que le script peut avoir besoin de quelques ajustements en fonction du nom de la base de données.

Après avoir importé le fichier ./sql/create_tables.sql, il faudra spécifier le nom des tables dans le fichier ./config.inc.php. Les directives à utiliser pour cela sont dans la section Configuration.

Il vous faudra également un utilisateur de contrôle ($cfg['Servers'][$i]['controluser'] et/ou $cfg['Servers'][$i]['controlpass'] possédant les droits appropriés sur ces tables. Vous pouvez le créer au moyen de l’énoncé suivant :

Et pour toute version de MariaDB :

CREATE USER 'pma'@'localhost' IDENTIFIED VIA mysql_native_password USING 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON `<pma_db>`.* TO 'pma'@'localhost';

Pour MySQL 8.0 et plus récent :

CREATE USER 'pma'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON <pma_db>.* TO 'pma'@'localhost';

Pour MySQL plus vieux que 8.0 :

CREATE USER 'pma'@'localhost' IDENTIFIED WITH mysql_native_password AS 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON <pma_db>.* TO 'pma'@'localhost';

Notez que les installations de MySQL avec PHP plus ancien que 7.4 et MySQL plus récent que 8.0 peuvent nécessiter l’utilisation de l’authentification mysql_native_password comme solution de contournement, voir 1.45 Je reçois un message d’erreur à propos d’une méthode d’authentification inconnue caching_sha2_password lors de la tentative d’identification pour plus de détails.

Mise à jour à partir d’une précédente version¶

Avertissement

Ne jamais extraire une nouvelle version de phpMyAdmin par-dessus une version déjà existante. Toujours supprimer d’abord les anciens fichiers en ne conservant que la configuration.

De cette manière, vous ne laisserez pas de fichiers vieux ou périmés dans le répertoire, ce qui peut avoir de sérieuses implications de sécurité et provoquer divers dysfonctionnements.

Copiez simplement le fichier config.inc.php de votre installation précédente dans la nouvelle installation. Les fichiers de configuration de très anciennes versions (2.3.0 ou précédentes) peuvent nécessiter des ajustements car certaines options ont été modifiées ou supprimés. Pour une compatibilité avec PHP 5.3 et plus, supprimez une déclaration set_magic_quotes_runtime(0); que vous pourriez trouver à la fin de votre fichier de configuration.

La mise à jour complète peut être effectuée en quelques étapes simples :

Télécharger la dernière version de phpMyAdmin sur <https://www.phpmyadmin.net/downloads/>.
Renommer le répertoire existant de phpMyAdmin (par exemple en phpmyadmin-old).
Décompresser le phpMyAdmin fraîchement téléchargé dans l’emplacement désiré (par exemple phpmyadmin).
Copier le fichier config.inc.php` de l’ancien répertoire (phpmyadmin-old) vers le nouveau (phpmyadmin).
Tester que tout fonctionne correctement.
Supprimer la sauvegarde d’une version précédente (phpmyadmin-old).

Si vous avez mis à jour votre serveur MySQL d’une version plus ancienne que la 4.1.2 vers une version 5.x ou supérieure et que vous utilisez la configuration de stockage de phpMyAdmin, vous devez exécuter le script SQL suivant : sql/upgrade_tables_mysql_4_1_2+.sql.

Si vous avez mis à jour phpMyAdmin en version 4.3.0 ou supérieur à depuis 2.5.0 ou supérieur (<= 4.2.x) et si vous utilisez la configuration de stockage de phpMyAdmin, vous devez exécuter le script SQL qui se trouve dans sql/upgrade_column_info_4_3_0+.sql.

Ne pas oublier de vider le cache du navigateur et l’ancienne session en se déconnectant puis en se reconnectant.

Utiliser les modes d’authentification¶

Les authentifications HTTP et par cookies sont recommandées dans un environnement multi-utilisateurs où vous souhaitez que chaque utilisateur n’ait accès qu’à sa propre base de données et n’aille pas trifouiller dans les bases de données des voisins. Néanmoins, sachez que MS Internet Explorer semble avoir une gestion peu fiable des cookies, tout du moins jusqu’à sa version 6. Dans un environnement mono-utilisateur, vous pouvez également souhaiter utiliser une authentification HTTP ou par cookies afin d’éviter de stocker votre nom d’utilisateur / mot de passe en clair dans le fichier de configuration.

Les modes d’authentification HTTP et par cookie sont plus sécurisés : les informations de connexion de MySQL n’ont pas besoin d’être définies dans le fichier de configuration de phpMyAdmin (excepté pour $cfg['Servers'][$i]['controluser']). Cependant, gardez à l’esprit que le mot de passe transite en clair, à moins d’utiliser le protocole HTTPS. Dans le mode cookie, le mot de passe est stocké, chiffré avec l’algorithme AES, dans un cookie temporaire.

Ensuite, un ensemble de privilèges doit être accordé à chaque utilisateur réel sur un ensemble de bases définies. Normalement, vous ne devriez pas donner de privilèges globaux à un utilisateur ordinaire, à moins que vous ne sachiez ce que vous faites (par exemple, si vous créez un super-utilisateur). Par exemple, déléguer à un utilisateur réel tous les privilèges sur la base de données user_base :

GRANT ALL PRIVILEGES ON user_base.* TO 'real_user'@localhost IDENTIFIED BY 'real_password';

Tout ce que les utilisateurs pourraient faire est entièrement contrôlé par le système de gestion des utilisateurs de MySQL. Avec les modes d’authentification HTTP ou par cookie, vous n’avez pas besoin de renseigner les champs utilisateur/mot de passe dans $cfg['Servers'].

Voir aussi

1.35 Puis-je utiliser l’authentification HTTP avec Apache CGI ?, 1.35 Puis-je utiliser l’authentification HTTP avec Apache CGI ?, 4.1 Je suis un FAI. Puis-je configurer une seule copie centralisée de phpMyAdmin ou dois-je faire l’installation pour chaque client ?, 4.2 Quel est le meilleur moyen de sécuriser phpMyAdmin contre les attaques malicieuses ?, 4.3 J’obtiens des erreurs sur l’impossibilité d’inclure un fichier dans /lang ou dans /libraries.

Mode d’authentification HTTP¶

Il utilise la méthode d’authentification HTTP basique et vous autorise à vous connecter en tant que n’importe quel utilisateur MySQL valide.
Il est géré par la plupart des configurations PHP. Pour la gestion IIS (ISAPI) utilisant PHP CGI, voir 1.35 Puis-je utiliser l’authentification HTTP avec Apache CGI ? ; pour utiliser Apache CGI voir 1.35 Puis-je utiliser l’authentification HTTP avec Apache CGI ?.
Quand PHP est exécuté avec Apache mod_proxy_fcgi (par exemple avec PHP-FPM), les en-têtes Authorization ne sont pas passés à l’application sous-jacente FCGI, et les identifiants n’atteindront pas l’application. Dans ce cas, vous pouvez ajouter l directive de configuration :
```
SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
```
Voir également la section 4.4 phpMyAdmin donne toujours « Accès refusé » en utilisant l’authentification HTTP. sur le fait de ne pas utiliser le mécanisme d’authentification .htaccess en même temps que le mode d’authentification “HTTP”.

Note

Il n’existe pas de manière de se déconnecter proprement en utilisant l’authentification HTTP : la plupart des navigateurs retiennent les identifiants jusqu’à ce qu’une nouvelle authentification réussisse avec d’autres identifiants. À cause de cela, cette méthode possède une limitation qui ne vous permet pas de vous connecter avec le même utilisateur après la déconnexion.

Mode d’authentification “signon”¶

Ce mode est un moyen pratique pour utiliser les informations d’identification provenant d’une autre application pour s’authentifier dans phpMyAdmin en utilisant une authentification unique.
L’autre application a besoin de stocker les informations de connexion dans les données de session (consulter $cfg['Servers'][$i]['SignonSession'] et $cfg['Servers'][$i]['SignonCookieParams']) ou vous devez mettre en œuvre un script pour renvoyer les crédentiels (consulter $cfg['Servers'][$i]['SignonScript']).
Quand aucun identifiant de connexion n’est disponible, l’utilisateur est redirigé vers $cfg['Servers'][$i]['SignonURL'], où vous pouvez traiter le processus de connexion.

Un exemple très basique pour stocker les identifiants de connexion est disponible : examples/signon.php :

<?php
/**
 * Single signon for phpMyAdmin
 *
 * This is just example how to use session based single signon with
 * phpMyAdmin, it is not intended to be perfect code and look, only
 * shows how you can integrate this functionality in your application.
 */

declare(strict_types=1);

/* Use cookies for session */
ini_set('session.use_cookies', 'true');
/* Change this to true if using phpMyAdmin over https */
$secureCookie = false;
/* Need to have cookie visible from parent directory */
session_set_cookie_params(0, '/', '', $secureCookie, true);
/* Create signon session */
$sessionName = 'SignonSession';
session_name($sessionName);
// Uncomment and change the following line to match your $cfg['SessionSavePath']
//session_save_path('/foobar');
@session_start();

/* Was data posted? */
if (isset($_POST['user'])) {
    /* Store there credentials */
    $_SESSION['PMA_single_signon_user'] = $_POST['user'];
    $_SESSION['PMA_single_signon_password'] = $_POST['password'];
    $_SESSION['PMA_single_signon_host'] = $_POST['host'];
    $_SESSION['PMA_single_signon_port'] = $_POST['port'];
    /* Update another field of server configuration */
    $_SESSION['PMA_single_signon_cfgupdate'] = ['verbose' => 'Signon test'];
    $_SESSION['PMA_single_signon_HMAC_secret'] = hash('sha1', uniqid(strval(random_int(0, mt_getrandmax())), true));
    $id = session_id();
    /* Close that session */
    @session_write_close();
    /* Redirect to phpMyAdmin (should use absolute URL here!) */
    header('Location: ../index.php');
} else {
    /* Show simple form */
    header('Content-Type: text/html; charset=utf-8');

    echo '<?xml version="1.0" encoding="utf-8"?>' . "\n";
    echo '<!DOCTYPE HTML>
<html lang="en" dir="ltr">
<head>
<link rel="icon" href="../favicon.ico" type="image/x-icon">
<link rel="shortcut icon" href="../favicon.ico" type="image/x-icon">
<meta charset="utf-8">
<title>phpMyAdmin single signon example</title>
</head>
<body>';

    if (isset($_SESSION['PMA_single_signon_error_message'])) {
        echo '<p class="error">';
        echo $_SESSION['PMA_single_signon_error_message'];
        echo '</p>';
    }

    echo '<form action="signon.php" method="post">
Username: <input type="text" name="user" autocomplete="username" spellcheck="false"><br>
Password: <input type="password" name="password" autocomplete="current-password" spellcheck="false"><br>
Host: (will use the one from config.inc.php by default)
<input type="text" name="host"><br>
Port: (will use the one from config.inc.php by default)
<input type="text" name="port"><br>
<input type="submit">
</form>
</body>
</html>';
}

Sinon, vous pouvez aussi utiliser cette solution en utilisant OpenID : examples/openid.php :

<?php
/**
 * Single signon for phpMyAdmin using OpenID
 *
 * This is just example how to use single signon with phpMyAdmin, it is
 * not intended to be perfect code and look, only shows how you can
 * integrate this functionality in your application.
 *
 * It uses OpenID pear package, see https://pear.php.net/package/OpenID
 *
 * User first authenticates using OpenID and based on content of $AUTH_MAP
 * the login information is passed to phpMyAdmin in session data.
 */

declare(strict_types=1);

if (false === @include_once 'OpenID/RelyingParty.php') {
    exit;
}

/* Change this to true if using phpMyAdmin over https */
$secureCookie = false;

/**
 * Map of authenticated users to MySQL user/password pairs.
 */
$authMap = ['https://launchpad.net/~username' => ['user' => 'root', 'password' => '']];

// phpcs:disable PSR1.Files.SideEffects,Squiz.Functions.GlobalFunction

/**
 * Simple function to show HTML page with given content.
 *
 * @param string $contents Content to include in page
 */
function Show_page(string $contents): void
{
    header('Content-Type: text/html; charset=utf-8');

    echo '<?xml version="1.0" encoding="utf-8"?>' . "\n";
    echo '<!DOCTYPE HTML>
<html lang="en" dir="ltr">
<head>
<link rel="icon" href="../favicon.ico" type="image/x-icon">
<link rel="shortcut icon" href="../favicon.ico" type="image/x-icon">
<meta charset="utf-8">
<title>phpMyAdmin OpenID signon example</title>
</head>
<body>';

    if (isset($_SESSION['PMA_single_signon_error_message'])) {
        echo '<p class="error">' . $_SESSION['PMA_single_signon_message'] . '</p>';
        unset($_SESSION['PMA_single_signon_message']);
    }

    echo $contents;
    echo '</body></html>';
}

/**
 * Display error and exit
 *
 * @param Exception $e Exception object
 */
function Die_error(Throwable $e): void
{
    $contents = "<div class='relyingparty_results'>\n";
    $contents .= '<pre>' . htmlspecialchars($e->getMessage()) . "</pre>\n";
    $contents .= "</div class='relyingparty_results'>";
    Show_page($contents);
    exit;
}

// phpcs:enable

/* Need to have cookie visible from parent directory */
session_set_cookie_params(0, '/', '', $secureCookie, true);
/* Create signon session */
$sessionName = 'SignonSession';
session_name($sessionName);
@session_start();

// Determine realm and return_to
$base = 'http';
if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on') {
    $base .= 's';
}

$base .= '://' . $_SERVER['SERVER_NAME'] . ':' . $_SERVER['SERVER_PORT'];

$realm = $base . '/';
$returnTo = $base . dirname($_SERVER['PHP_SELF']);
if ($returnTo[strlen($returnTo) - 1] !== '/') {
    $returnTo .= '/';
}

$returnTo .= 'openid.php';

/* Display form */
if ((! count($_GET) && ! count($_POST)) || isset($_GET['phpMyAdmin'])) {
    /* Show simple form */
    $content = '<form action="openid.php" method="post">
OpenID: <input type="text" name="identifier"><br>
<input type="submit" name="start">
</form>';
    Show_page($content);
    exit;
}

/* Grab identifier */
$identifier = null;
if (isset($_POST['identifier']) && is_string($_POST['identifier'])) {
    $identifier = $_POST['identifier'];
} elseif (isset($_SESSION['identifier']) && is_string($_SESSION['identifier'])) {
    $identifier = $_SESSION['identifier'];
}

/* Create OpenID object */
try {
    $o = new OpenID_RelyingParty($returnTo, $realm, $identifier);
} catch (Throwable $e) {
    Die_error($e);
}

/* Redirect to OpenID provider */
if (isset($_POST['start'])) {
    try {
        $authRequest = $o->prepare();
    } catch (Throwable $e) {
        Die_error($e);
    }

    $url = $authRequest->getAuthorizeURL();

    header('Location: ' . $url);
    exit;
}

/* Grab query string */
if (! count($_POST)) {
    [, $queryString] = explode('?', $_SERVER['REQUEST_URI']);
} else {
    // Fetch the raw query body
    $queryString = file_get_contents('php://input');
}

/* Check reply */
try {
    $message = new OpenID_Message($queryString, OpenID_Message::FORMAT_HTTP);
} catch (Throwable $e) {
    Die_error($e);
}

$id = $message->get('openid.claimed_id');

if (empty($id) || ! isset($authMap[$id])) {
    Show_page('<p>User not allowed!</p>');
    exit;
}

$_SESSION['PMA_single_signon_user'] = $authMap[$id]['user'];
$_SESSION['PMA_single_signon_password'] = $authMap[$id]['password'];
$_SESSION['PMA_single_signon_HMAC_secret'] = hash('sha1', uniqid(strval(random_int(0, mt_getrandmax())), true));
session_write_close();
/* Redirect to phpMyAdmin (should use absolute URL here!) */
header('Location: ../index.php');

Si vous voulez transmettre les identifiants de connexion en utilisant d’autres moyens, vous devrez mettre en œuvre une classe enveloppante (wrapper) en PHP pour obtenir les données et les définir dans $cfg['Servers'][$i]['SignonScript']. Voici un script minimaliste pour cela : examples/signon-script.php :

<?php
/**
 * Single signon for phpMyAdmin
 *
 * This is just example how to use script based single signon with
 * phpMyAdmin, it is not intended to be perfect code and look, only
 * shows how you can integrate this functionality in your application.
 */

declare(strict_types=1);

// phpcs:disable Squiz.Functions.GlobalFunction

/**
 * This function returns username and password.
 *
 * It can optionally use configured username as parameter.
 *
 * @param string $user User name
 *
 * @return array<int,string>
 */
function get_login_credentials(string $user): array
{
    /* Optionally we can use passed username */
    if (! empty($user)) {
        return [$user, 'password'];
    }

    /* Here we would retrieve the credentials */
    return ['root', ''];
}

Voir aussi

$cfg['Servers'][$i]['auth_type'], $cfg['Servers'][$i]['SignonSession'], $cfg['Servers'][$i]['SignonCookieParams'], $cfg['Servers'][$i]['SignonScript'], $cfg['Servers'][$i]['SignonURL'], Exemple pour l’authentification “signon”

Mode d’authentification par configuration¶

Ce mode est parfois le moins sécurisé car il requiert de remplir les champs $cfg['Servers'][$i]['user'] et $cfg['Servers'][$i]['password'] (par conséquent, quiconque peut lire votre fichier config.inc.php peut découvrir votre nom d’utilisateur et votre mot de passe).
Dans la section FAI et installation multi-utilisateurs il y a un point expliquant comment protéger votre fichier de configuration.
Pour une sécurité supplémentaire dans ce mode, vous devriez considérer les directives de configuration de l’authentification hôte $cfg['Servers'][$i]['AllowDeny']['order'] et $cfg['Servers'][$i]['AllowDeny']['rules'].
Contrairement aux modes par cookie et HTTP, l’utilisateur n’a pas besoin de s’authentifier lors du premier chargement du site phpMyAdmin. C’est prévu ainsi, mais cela pourrait permettre à tout utilisateur d’accéder à votre installation. L’utilisation d’une méthode de restriction est recommandée, que ce soit en utilisant un fichier .htaccess avec la directive HTTP-AUTH ou en interdisant les requêtes HTTP entrantes sur le routeur ou le pare-feu (ces deux suggestions n’entrent pas dans les sujets abordés dans ce manuel mais vous pouvez facilement trouver des informations sur ces sujets avec Google).

Sécuriser votre installation de phpMyAdmin¶

L’équipe de phpMyAdmin essaye tant bien que mal de rendre l’application sûre, cependant, il est toujours possible de la rendre encore plus sûre :

Suivez nos annonces de sécurité et mettez à jour phpMyAdmin chaque fois qu’une vulnérabilité est révélée.
Utiliser phpMyAdmin en HTTPS seulement. De préférence, utiliser HSTS, pour être protégé des attaques de type « protocol downgrade ».
Assure-vous que votre configuration PHP suive les recommandations pour les sites de production, par exemple display_errors doit être désactivé.
Supprimez le dossier test de phpMyAdmin, à moins que vous ne développiez et ayez besoin d’une suite de test.
Supprimez le dossier setup de phpMyAdmin, vous ne l’utiliserez probablement plus après l’installation initiale.
Choisit la méthode d’authentification appropriée - Mode d’authentification par « cookie » est probablement le meilleur choix dans le cas d’un hébergement mutualisé.
Refuse l’accès aux fichiers auxiliaires des sous-dossiers ./libraries et ./templates/ de la configuration du serveur Web. Une telle configuration empêche de possibles vulnérabilités à l’exposition de chemins et de scripts inter-sites qui pourraient être découvertes dans le code. Pour le serveur Web Apache, la façon habituelle de procéder est d’utiliser un fichier .htaccess dans ces dossiers.
Refuse l’accès aux fichiers temporaires, voir $cfg['TempDir'] (si cela est placé à l’intérieur de votre racine web, voir aussi Les répertoires de transfert/sauvegarde/import du serveur web) .
Il est généralement conseillé de protéger l’installation phpMyAdmin publique contre les accès des robots car ils ne peuvent rien faire de bon en général ici. Vous pouvez faire ceci en utilisant le fichier robots.txt à la racine de votre serveur Web ou en limitant l’accès par la configuration de votre serveur Web, voir 1.42 Comment empêcher les robots d’accéder à phpMyAdmin ?.
Si vous ne voulez pas que tous les utilisateurs MySQL puissent accéder à phpMyAdmin, vous pouvez utiliser $cfg['Servers'][$i]['AllowDeny']['rules'] pour les limiter ou $cfg['Servers'][$i]['AllowRoot'] pour refuser l’accès utilisateur root.
Active Authentification à deux facteurs pour votre compte.
Envisagez de masquer phpMyAdmin derrière une authentification de serveur mandataire, de sorte que les utilisateurs aient à s’identifier avant de fournir les identifiants MySQL. Pour cela, vous pouvez configurer votre serveur Web pour qu’il nécessite une authentification HTTP. Par exemple, pour Apache, cela peut être réalisé avec :
```
AuthType Basic
AuthName "Restricted Access"
AuthUserFile /usr/share/phpmyadmin/passwd
Require valid-user
```
Après avoir changé la configuration, il faut créer une liste des utilisateurs qui peuvent s’authentifier. Cela peut être fait en utilisant l’utilitaire htpasswd :
```
htpasswd -c /usr/share/phpmyadmin/passwd username
```
Si vous craignez les attaques automatisées, l’activation de Captcha au moyen de $cfg['CaptchaLoginPublicKey'] et $cfg['CaptchaLoginPrivateKey'] pourrait être envisageable.
Les tentatives de connexion qui ont échouées sont inscrites au journal syslog (si disponible, voir $cfg['AuthLog']). Cela peut servir à un outil comme fail2ban pour bloquer les attaques par force brute. Noter que le fichier de journalisation utilisé par syslog n’est pas le même que celui des erreurs Apache ou celui journalisant les accès.
Au cas où phpMyAdmin est exécuté en même temps que d’autres applications PHP, il est généralement conseillé d’utiliser un emplacement de session séparé pour phpMyAdmin afin d’éviter des attaques possibles basées sur la session. Pour cela il est possible d’utiliser $cfg['SessionSavePath'].

Utilisation de SSL pour la connexion au serveur de base de données¶

Il est recommandé d’utiliser SSL lors de la connexion au serveur de bases de données distant. Il existe plusieurs options de configuration SSL :

$cfg['Servers'][$i]['ssl']: Définit si SSL est utilisé ou pas. En cas d’activation seule, la connexion sera chiffrée mais pas authentifiée ; il sera impossible de vérifier que la communication se fait avec le bon serveur.
$cfg['Servers'][$i]['ssl_key'] et $cfg['Servers'][$i]['ssl_cert']: Ceci est utilisé pour l’authentification du client au serveur.
$cfg['Servers'][$i]['ssl_ca'] et $cfg['Servers'][$i]['ssl_ca_path']: Les autorités de certification de confiance pour les certificats de serveur. Cela est utilisé pour s’assurer que la communication est faite un serveur de confiance.
$cfg['Servers'][$i]['ssl_verify']: Cette configuration désactive la vérification du certificat de serveur. À utiliser avec prudence.

Lorsque le serveur de base de données utilise une connexion locale ou un réseau privé et que SSL ne peut pas être configuré, vous pouvez utiliser $cfg['MysqlSslWarningSafeHosts'] pour lister explicitement les noms d’hôtes qui sont considérés comme sûrs.

Voir aussi

Google Cloud SQL avec SSL, Amazon RDS Aurora avec SSL, $cfg['Servers'][$i]['ssl'], $cfg['Servers'][$i]['ssl_key'], $cfg['Servers'][$i]['ssl_cert'], $cfg['Servers'][$i]['ssl_ca'], $cfg['Servers'][$i]['ssl_ca_path'], $cfg['Servers'][$i]['ssl_ciphers'], $cfg['Servers'][$i]['ssl_verify']

Problèmes connus¶

Les utilisateurs avec des privilèges spécifiques à des colonnes ne peuvent pas utiliser « Parcourir »¶

Si un utilisateur a des privilèges spécifiques à des colonnes sur certaines (mais pas toutes) colonnes dans une table, « Parcourir » échouera avec un message d’erreur.

Comme moyen de contournement, une requête enregistrée du même nom que la table peut être créée. Elle sera utilisée à la place du lien « Parcourir ». Problème 11922.

Problème de reconnexion après s’être déconnecté en utilisant l’authentification “http”¶

En utilisant auth_type “http”, il peut être impossible de se reconnecter (lorsque la déconnexion est faite manuellement ou après une période d’inactivité). Problème 11898.

Installation¶

Distributions Linux¶

Debian et Ubuntu¶

OpenSUSE¶

Gentoo¶

Mandriva¶

Fedora¶

Red Hat Enterprise Linux¶

Installation sur Windows¶

Installation à partir de Git¶

Installation au moyen de Composer¶

Installation au moyen de Docker¶

Variables d’environnement Docker¶

Personnalisation de la configuration¶

Volumes Docker¶

Exemples Docker¶

Utiliser docker-compose¶

Personnalisation du fichier de configuration à l’aide de docker-compose¶

En exécution derrière haproxy dans un sous-répertoire¶

IBM Cloud¶

Installation rapide¶

Création manuelle du fichier¶

Utilisation du script d’installation¶

Script de paramétrage sous Debian, Ubuntu et dérivés¶

Script d’installation pour openSUSE¶

Vérification d’intégrité de phpMyAdmin¶

Stockage de la configuration de phpMyAdmin¶

Zéro configuration¶

Configuration manuelle¶

Mise à jour à partir d’une précédente version¶

Utiliser les modes d’authentification¶

Mode d’authentification HTTP¶

Mode d’authentification par « cookie »¶

Mode d’authentification “signon”¶

Mode d’authentification par configuration¶

Sécuriser votre installation de phpMyAdmin¶

Utilisation de SSL pour la connexion au serveur de base de données¶

Problèmes connus¶

Les utilisateurs avec des privilèges spécifiques à des colonnes ne peuvent pas utiliser « Parcourir »¶

Problème de reconnexion après s’être déconnecté en utilisant l’authentification “http”¶