One place for hosting & domains

      phpMyAdmin

      Cara Menginstal dan Mengamankan phpMyAdmin pada Ubuntu 20.04


      Versi tutorial sebelumnya ditulis oleh Brennan Bearnes.

      Pengantar

      Walaupun banyak pengguna membutuhkan fungsionalitas dari sistem manajemen basis data seperti MySQL, mereka mungkin tidak merasa nyaman berinteraksi dengan sistem hanya dari prompt MySQL.

      phpMyAdmin diciptakan sehingga pengguna dapat berinteraksi dengan MySQL melalui antarmuka web. Dalam panduan ini, kita akan membahas cara menginstal dan mengamankan phpMyAdmin sehingga Anda dapat menggunakannya secara aman untuk mengelola basis data Anda pada sistem Ubuntu 20.04.

      Prasyarat

      Agar bisa menyelesaikan panduan ini, Anda membutuhkan:

      Selain itu, ada pertimbangan keamanan penting saat menggunakan perangkat lunak seperti phpMyAdmin, karena perangkat lunak tersebut:

      • Berkomunikasi secara langsung dengan instalasi MySQL Anda
      • Menangani autentikasi dengan menggunakan kredensial MySQL
      • Menjalankan dan memberikan hasil untuk kueri SQL arbitrer

      Karena alasan-alasan ini, dan karena aplikasi PHP yang digunakan secara luas sering menjadi target penyerangan, Anda jangan pernah menjalankan phpMyAdmin pada sistem jarak jauh melalui koneksi HTTP biasa.

      Jika Anda tidak memiliki domain yang sudah dikonfigurasi dengan sertifikat SSL/TLS, Anda dapat mengikuti panduan mengamankan Apache dengan Let’s Encrypt pada Ubuntu 20.04 ini. Ini akan mengharuskan Anda untuk mendaftarkan nama domain, menciptakan catatan DNS untuk server Anda, dan menyiapkan Hos Virtual Apache.

      Langkah 1 — Menginstal phpMyAdmin

      Anda dapat menggunakan APT untuk menginstal phpMyAdmin dari repositori Ubuntu asali.

      Sebagai pengguna sudo non-root Anda, perbarui indeks paket server Anda:

      Setelah itu, Anda dapat menginstal paket phpmyadmin. Bersama dengan paket ini, dokumentasi resmi juga menganjurkan Anda menginstal beberapa ekstensi PHP ke server Anda untuk mengaktifkan fungsionalitas tertentu dan meningkatkan kinerja.

      Jika Anda mengikuti prasyarat tutorial tumpukan LAMP, beberapa dari modul-modul ini akan telah terinstal bersama dengan paket php. Namun, Anda disarankan untuk menginstal paket-paket ini juga:

      • php-mbstring: Modul untuk mengelola string non-ASCII dan mengubah string menjadi pengodean yang berbeda-beda
      • php-zip: Ekstensi ini mendukung pengunggahan berkas .zip ke phpMyAdmin
      • php-gd: Mengaktifkan dukungan untuk Pustaka Grafis GD
      • php-json: Menyediakan PHP dengan dukungan untuk serialisasi JSON
      • php-curl: Mengizinkan PHP untuk berinteraksi dengan berbagai jenis server menggunakan protokol yang berbeda-beda

      Jalankan perintah berikut untuk menginstal paket-paket ini ke sistem Anda. Namun, harap dicatat, bahwa proses instalasi mengharuskan Anda untuk membuat beberapa pilihan untuk mengonfigurasi phpMyAdmin dengan benar. Kita akan membahas opsi-opsi ini segera:

      • sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl

      Berikut ini adalah opsi yang Anda harus pilih saat diminta untuk mengonfigurasi instalasi Anda dengan benar:

      • Untuk pilihan server, pilih apache2

        Peringatan: Ketika prompt muncul, “apache2” disorot, tetapi tidak dipilih. Jika Anda tidak menekan bilah SPACE untuk memilih Apache, penginstal tidak akan memindahkan berkas yang diperlukan selama instalasi. Tekan SPACE, TAB, lalu ENTER untuk memilih Apache.
      • Pilih Yes saat Anda ditanya apakah ingin menggunakan dbconfig-common untuk menyiapkan basis data
      • Lalu, Anda akan diminta untuk memilih dan mengonfirmasi kata sandi aplikasi MySQL untuk phpMyAdmin

      Catatan: Dengan asumsi Anda telah menginstal MySQL dengan mengikuti Langkah 2 dari tutorial prasyarat tumpukan LAMP, Anda mungkin telah memutuskan untuk mengaktifkan plugin Validate Password. Saat penulisan dokumen ini, mengaktifkan komponen ini akan memicu kesalahan saat Anda mencoba mengatur kata sandi untuk pengguna phpmyadmin:

      Kesalahan validasi kata sandi phpMyAdmin

      Untuk menyelesaikan ini, pilih opsi abort untuk menghentikan proses instalasi. Lalu, buka prompt MySQL Anda:

      Atau, jika Anda mengaktifkan autentikasi kata sandi untuk pengguna MSQL root, jalankan perintah ini lalu masukkan kata sandi Anda saat diminta:

      Dari prompt, jalankan perintah berikut untuk menonaktifkan komponen Validate Password. Perhatikan bahwa ini tidak benar-benar akan menghapus instalasinya, tetapi hanya menghentikan komponen dimuat pada server MySQL Anda:

      • UNINSTALL COMPONENT "file://component_validate_password";

      Setelah itu, Anda dapat menutup klien MySQL:

      Lalu, coba instal paket phpmyadmin lagi dan proses akan bekerja seperti yang diharapkan:

      • sudo apt install phpmyadmin

      Setelah phpMyAdmin terinstal, Anda dapat membuka prompt MySQL sekali lagi dengan sudo mysql atau mysql -u root -u -p lalu jalankan perintah berikut untuk mengaktifkan kembali komponen Validate Password:

      • INSTALL COMPONENT "file://component_validate_password";

      Proses instalasi ini menambahkan berkas konfigurasi phpMyAdmin Apache ke dalam direktori /etc/apache2/conf-enabled/, di mana berkas konfigurasi tersebut terbaca secara otomatis. Untuk menyelesaikan konfigurasi Apache dan PHP untuk bekerja dengan phpMyAdmin, tugas yang tersisa dalam bagian tutorial ini adalah untuk secara eksplisit mengaktifkan ekstensi PHP mbstring, yang dapat Anda lakukan dengan mengetik:

      Setelah itu, mulai ulang Apache supaya perubahan Anda dapat dikenali:

      • sudo systemctl restart apache2

      phpMyAdmin sekarang sudah terinstal dan dikonfigurasi untuk bekerja dengan Apache. Namun, sebelum Anda dapat log masuk dan mulai berinteraksi dengan basis data MySQL Anda, Anda perlu memastikan bahwa pengguna MySQL Anda memiliki privilese yang dibutuhkan untuk berinteraksi dengan program ini.

      Langkah 2 — Menyesuaikan Autentikasi dan Privilese Pengguna

      Saat Anda menginstal phpMyAdmin ke server Anda, proses ini secara otomatis menciptakan pengguna basis data yang disebut phpmyadmin, yang menjalankan proses mendasar tertentu untuk program. Alih-alih log masuk sebagai pengguna dengan kata sandi administratif yang Anda atur selama instalasi, Anda disarankan untuk log masuk sebagai pengguna MYSQL root atau sebagai pengguna yang dikhususkan untuk mengelola basis data melalui antarmuka phpMyAdmin.

      Mengonfigurasi Akses Kata Sandi untuk Akun Root MySQL

      Dalam sistem Ubuntu yang menjalankan MySQL 5.7 (dan versi lebih baru), pengguna MySQL root ditetapkan untuk melakukan autentikasi dengan menggunakan plugin auth_socket secara asali alih-alih dengan kata sandi. Ini mengizinkan keamanan dan kebergunaan yang lebih besar dalam banyak kasus, tetapi juga dapat memperumit keadaan saat Anda perlu untuk mengizinkan program eksternal — seperti phpMyAdmin — untuk mengakses pengguna.

      Untuk log masuk ke phpMyAdmin sebagai pengguna MySQL root, Anda perlu mengganti metode autentikasi dari auth_socket menjadi salah satu metode yang memanfaatkan kata sandi, jika Anda belum melakukan itu. Untuk melakukan ini, buka prompt MySQL dari terminal Anda:

      Selanjutnya, periksa metode autentikasi mana yang masing-masing akun pengguna MySQL Anda gunakan dengan perintah berikut:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | | auth_socket | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Pada contoh ini, Anda dapat melihat bahwa pengguna root memang mengautentikasi dengan menggunakan plugin auth_socket. Untuk mengonfigurasi akun root agar mengautentikasi dengan kata sandi, jalankan perintah ALTER USER berikut. Pastikan untuk mengubah password menjadi kata sandi yang kuat pilihan Anda:

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Catatan: Pernyataan ALTER USER sebelumnya telah menetapkan pengguna MYSQL root untuk mengautentikasi dengan plugin caching_sha2_password. Sesuai dokumentasi MySQL resmi, caching_sha2_password adalah plugin autentikasi MySQL yang lebih disukai, karena plugin ini menyediakan enkripsi kata sandi yang lebih aman daripada mysql_native_password yang lebih tua tetapi masih digunakan secara luas.

      Namun, beberapa versi PHP tidak berfungsi secara andal dengan caching_sha2_password. PHP telah melaporkan bahwa isu ini sudah diperbaiki pada PHP 7.4, tetapi jika Anda menjumpai kesalahan saat mencoba log masuk ke phpMyAdmin nantinya, Anda mungkin ingin mengatur root untuk mengautentikasi dengan mysql_native_password sebagai gantinya:

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Lalu, periksa lagi metode autentikasi yang digunakan oleh setiap pengguna Anda untuk mengonfirmasi bahwa root tidak lagi mengautentikasi dengan menggunakan plugin auth_socket:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | *DE06E242B88EFB1FE4B5083587C260BACB2A6158 | caching_sha2_password | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Anda dapat melihat dari keluaran ini bahwa pengguna root akan mengautentikasi dengan menggunakan kata sandi. Anda kini dapat log masuk ke antarmuka phpMyAdmin sebagai pengguna root Anda dengan kata sandi yang Anda sudah atur untuk itu di sini.

      Mengonfigurasi Akses Kata Sandi untuk Pengguna MySQL Khusus

      Selain itu, sebagian orang mungkin menganggap bahwa terhubung ke phpMyAdmin dengan pengguna khusus terasa lebih cocok dengan alur kerja mereka. Untuk melakukan ini, buka shell MySQL sekali lagi:

      Jika Anda memiliki autentikasi kata sandi yang diaktifkan untuk pengguna root Anda, seperti yang dijelaskan di bagian sebelumnya, Anda perlu menjalankan perintah berikut dan memasukkan kata sandi Anda saat diminta agar terhubung:

      Dari sana, ciptakan pengguna baru dan beri kata sandi yang kuat:

      • CREATE USER 'sammy'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Catatan: Sekali lagi, tergantung versi PHP yang telah Anda instal, Anda mungkin ingin mengatur pengguna baru Anda untuk mengautentikasi dengan mysql_native_password alih-alih caching_sha2_password:

      • ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Lalu, beri privilese yang sesuai kepada pengguna baru Anda. Sebagai contoh, Anda dapat memberikan privilese kepada pengguna untuk semua tabel di dalam basis data, serta kekuasaan untuk menambah, mengubah, dan menghapus privilese pengguna, dengan perintah ini:

      • GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;

      Setelah itu, keluarlah dari shell MySQL:

      Anda kini dapat mengakses antarmuka web dengan mengunjungi nama domain atau alamat IP publik server Anda yang diikuti dengan /phpmyadmin:

      https://your_domain_or_IP/phpmyadmin
      

      Layar log masuk phpMyAdmin

      Lakukan log masuk ke antarmuka, baik sebagai root atau dengan nama pengguna dan kata sandi baru yang baru saja Anda konfigurasikan.

      Saat Anda log masuk, Anda akan melihat antarmuka pengguna, yang akan terlihat seperti ini:

      Antarmuka pengguna phpMyAdmin

      Karena Anda sekarang dapat terhubung dan berinteraksi dengan phpMyAdmin, yang tersisa hanyalah memperkuat keamanan sistem Anda untuk melindunginya dari penyerang.

      Langkah 3 — Mengamankan Instans phpMyAdmin Anda

      Karena sangat umum digunakan di mana-mana, phpMyAdmin adalah target populer bagi penyerang, dan Anda harus lebih berhati-hati untuk mencegah akses yang tidak sah. Salah satu cara melakukan ini adalah dengan menempatkan gateway di depan seluruh aplikasi dengan menggunakan fungsionalitas autentikasi dan otorisasi .htaccess bawaan dari Apache.

      Untuk melakukan ini, Anda harus terlebih dahulu mengaktifkan penggunaan dari penimpaan berkas .htaccess dengan mengedit berkas konfigurasi Apache dari instalasi phpMyAdmin Anda.

      Gunakan editor teks khusus yang Anda sukai untuk mengedit berkas phpmyadmin.conf yang telah ditempatkan di dalam direktori konfigurasi Apache Anda. Di sini, kita akan menggunakan nano:

      • sudo nano /etc/apache2/conf-available/phpmyadmin.conf

      Tambahkan arahan AllowOverride All di dalam bagian <Directory /usr/share/phpmyadmin> dari berkas konfigurasi, seperti ini:

      /etc/apache2/conf-available/phpmyadmin.conf

      <Directory /usr/share/phpmyadmin>
          Options FollowSymLinks
          DirectoryIndex index.php
          AllowOverride All
          . . .
      

      Saat Anda telah menambahkan baris ini, simpan dan tutup berkas. Jika Anda menggunakan nano untuk mengedit berkas, lakukan itu dengan menekan CTRL + X, Y, lalu ENTER.

      Untuk menerapkan perubahan yang Anda buat, mulai ulang Apache:

      • sudo systemctl restart apache2

      Karena sekarang Anda telah mengaktifkan penggunaan berkas .htaccess untuk aplikasi Anda, Anda perlu menciptakan satu berkas untuk benar-benar menerapkan keamanan.

      Agar ini berhasil, berkas tersebut harus diciptakan di dalam direktori aplikasi. Anda dapat menciptakan berkas yang diperlukan dan membukanya di dalam editor teks Anda dengan privilese root dengan mengetik:

      • sudo nano /usr/share/phpmyadmin/.htaccess

      Dalam berkas ini, masukkan informasi berikut ini:

      /usr/share/phpmyadmin/.htaccess

      AuthType Basic
      AuthName "Restricted Files"
      AuthUserFile /etc/phpmyadmin/.htpasswd
      Require valid-user
      

      Berikut ini adalah makna dari masing-masing baris ini:

      • AuthType Basic: Baris ini menentukan tipe autentikasi yang Anda sedang terapkan. Jenis ini akan menerapkan autentikasi kata sandi dengan menggunakan berkas kata sandi.
      • AuthName: Ini menetapkan pesan untuk kotak dialog autentikasi. Anda harus menjaga ini tetap generik sehingga pengguna yang tidak sah tidak akan mendapatkan informasi tentang apa yang dilindungi.
      • AuthUserFile: Ini menetapkan lokasi berkas kata sandi yang akan digunakan untuk autentikasi. Ini harus berada di luar direktori yang sedang dilayani. Kita akan segera membuat berkas ini.
      • Require valid-user: Ini menentukan bahwa hanya pengguna terautentikasi yang diberi akses ke sumber daya ini. Inilah yang sebenarnya menghentikan masuknya pengguna yang tidak sah.

      Setelah Anda selesai, simpan dan tutup berkas.

      Lokasi yang Anda sudah pilih untuk berkas kata sandi Anda adalah /etc/phpmyadmin/.htpasswd. Anda kini dapat menciptakan berkas ini dan memberikannya kepada pengguna awal dengan utilitas htpasswd:

      • sudo htpasswd -c /etc/phpmyadmin/.htpasswd username

      Anda akan diminta untuk memilih dan mengonfirmasi kata sandi untuk pengguna yang Anda buat. Setelah itu, berkas dibuat dengan kata sandi yang telah melalui proses hash yang Anda masukkan.

      Jika Anda ingin memasukkan pengguna tambahan, Anda perlu melakukannya tanpa bendera -c, seperti ini:

      • sudo htpasswd /etc/phpmyadmin/.htpasswd additionaluser

      Sekarang, saat Anda mengakses subdirektori phpMyAdmin Anda, Anda akan diminta nama akun dan kata sandi tambahan yang Anda baru saja konfigurasikan:

      https://domain_name_or_IP/phpmyadmin
      

      Kata sandi apache phpMyAdmin

      Setelah memasukkan autentikasi Apache, Anda akan dibawa ke laman autentikasi phpMyAdmin reguler untuk memasukkan kredensial MySQL Anda. Dengan menambahkan set kredensial non-MySQL ekstra, Anda memberikan basis data Anda suatu lapisan keamanan tambahan. Ini adalah sesuatu yang baik karena sejak dulu phpMyAdmin rentan terhadap ancaman keamanan.

      Kesimpulan

      Anda seharusnya kini telah memiliki phpMyAdmin yang terkonfigurasi dan siap digunakan pada server Ubuntu 20.04 Anda. Menggunakan antarmuka ini, Anda dapat menciptakan basis data, pengguna, dan tabel, serta melakukan operasi biasa seperti menghapus serta memodifikasi struktur dan data.



      Source link

      Comment installer et sécuriser Secure phpMyAdmin sur Ubuntu 20.04


      Une version antérieure de ce tutoriel a été écrite par Brennan Bearnes.

      Introduction

      Si de nombreux utilisateurs ont besoin des fonctionnalités d’un système de gestion de base de données comme MySQL, ils peuvent ne pas se sentir à l’aise pour interagir avec le système uniquement à partir de l’invite MySQL.

      phpMyAdmin a été créé pour que les utilisateurs puissent interagir avec MySQL via une interface web. Dans ce guide, nous allons voir comment installer et sécuriser phpMyAdmin afin que vous puissiez l’utiliser en toute sécurité pour gérer vos bases de données sur un système Ubuntu 20.04.

      Conditions préalables

      Afin de compléter ce guide, il vous faudra :

      De plus, il y a des considérations de sécurité importantes lors de l’utilisation de logiciels comme phpMyAdmin, puisque celui-ci :

      • communique directement avec votre installation MySQL
      • gère l’authentification à l’aide des identifiants MySQL
      • exécute et renvoie des résultats pour des requêtes SQL arbitraires

      Pour ces raisons, et parce qu’il s’agit d’une application PHP largement déployée qui est fréquemment la cible d’attaques, vous ne devriez jamais exécuter phpMyAdmin sur des systèmes distants via une simple connexion HTTP.

      Si vous n’avez pas de domaine existant configuré avec un certificat SSL/TLS, vous pouvez suivre ce guide sur la sécurisation d’Apache avec Let’s Encrypt sur Ubuntu 20.04. Pour cela, vous devrez enregistrer un nom de domaine, créer des enregistrements DNS pour votre serveur et mettre en place un hôte virtuel Apache. 

      Étape 1 — Installer Django

      Vous pouvez utiliser APT pour installer phpMyAdmin à partir des dépôts Ubuntu par défaut.

      En tant qu’utilisateur non root sudo, mettez à jour l’index des paquets de votre serveur :

      Ensuite, vous pouvez installer le paquet phpmyadmin. Parallèlement à ce paquet, la documentation officielle recommande également d’installer quelques extensions PHP sur votre serveur afin d’activer certaines fonctionnalités et d’améliorer les performances.

      Si vous avez suivi le tutoriel préalable sur la pile LAMP, plusieurs de ces modules auront été installés en même temps que le paquet php.   Toutefois, il est recommandé d’installer également ces paquets :

      • php-mbstring : Un module pour gérer les chaînes non ASCII et convertir les chaînes en différents encodages
      • php-zip : Cette extension permet de télécharger des fichiers .zip vers phpMyAdmin
      • php-gd : Permet de prendre en charge la bibliothèque graphique GD
      • php-json : Fournit à PHP un support pour la sérialisation JSON
      • php-curl : Permet à PHP d’interagir avec différents types de serveurs utilisant différents protocoles

      Exécutez la commande suivante pour installer ces paquets sur votre système. Veuillez noter, cependant, que le processus d’installation nécessite que vous fassiez certains choix pour configurer correctement phpMyAdmin. Nous allons bientôt passer en revue ces options :

      • sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl

      Voici les options que vous devez choisir lorsque vous y êtes invité afin de configurer correctement votre installation :

      • Pour la sélection du serveur, choisissez apache2

        Warning: Lorsque l’invite apparaît, « apache2 » est mis en évidence, mais n’est pas sélectionné. Si vous ne tapez pas sur SPACE pour sélectionner Apache, l’installateur ne déplacera* pas *les fichiers nécessaires pendant l’installation. Appuyez sur SPACE, TAB, puis ENTER pour sélectionner Apache.
      • Sélectionnez Yes quand il est demandé s’il faut utiliser dbconfig-common pour créer la base de données
      • Il vous sera ensuite demandé de choisir et de confirmer un mot de passe d’application MySQL pour phpMyAdmin

      Note : En supposant que vous ayez installé MySQL en suivant l’étape 2 du tutoriel préalable sur la pile LAMP, vous avez peut-être décidé d’activer le plugin Validate Password plugin. A partir de ce moment, l’activation de ce composant déclenchera une erreur lorsque vous tenterez de définir un mot de passe pour l’utilisateur phpmyadmin :

      Erreur de validation du mot de passe phpMyAdmin

      Pour résoudre ce problème, sélectionnez l’option d’annulation pour arrêter le processus d’installation. Ensuite, ouvrez votre prompt MySQL :

      Ou, si vous avez activé l’authentification par mot de passe pour l’utilisateur MySQL root, exécutez cette commande et entrez ensuite votre mot de passe lorsque vous y êtes invité :

      À l’invite, exécutez la commande suivante pour désactiver le composant Validate Password. Notez que cela ne le désinstallera pas réellement, mais empêchera simplement le composant d’être lancé sur votre serveur MySQL :

      • UNINSTALL COMPONENT "file://component_validate_password";

      Ensuite, vous pouvez fermer le client MySQL :

      Essayez ensuite d’installer le paquet phpmyadmin et il fonctionnera comme prévu :

      • sudo apt install phpmyadmin

      Une fois que phpMyAdmin est installé, vous pouvez ouvrir l’invite MySQL une nouvelle fois avec sudo mysql ou mysql -u root -p et ensuite exécuter la commande suivante pour réactiver le composant Validate Password : 

      • INSTALL COMPONENT "file://component_validate_password";

      Le processus d’installation ajoute le fichier de configuration Apache de phpMyAdmin dans le répertoire /etc/apache2/conf-enabled/, où il est lu automatiquement. Pour finir de configurer Apache et PHP afin qu’ils fonctionnent avec phpMyAdmin, la seule tâche qui reste à accomplir dans cette section du tutoriel est d’activer explicitement l’extension PHP mbstring, ce que vous pouvez faire en tapant :

      Ensuite, redémarrez Apache pour que vos modifications soient reconnues :

      • sudo systemctl restart apache2

      phpMyAdmin est maintenant installé et configuré pour fonctionner avec Apache. Toutefois, avant de pouvoir vous connecter et de commencer à interagir avec vos bases de données MySQL, vous devrez vous assurer que vos utilisateurs MySQL disposent des privilèges requis pour interagir avec le programme.

      Étape 2 – Ajustement de l’authentification et des privilèges des utilisateurs

      Lorsque vous avez installé phpMyAdmin sur votre serveur, il a automatiquement créé un utilisateur de base de données appelé phpmyadmin qui effectue certains processus sous-jacents pour le programme. Plutôt que de vous connecter en tant qu’utilisateur avec le mot de passe administratif que vous avez défini lors de l’installation, il est recommandé de vous connecter soit en tant que root user MySQL, soit en tant qu’dedicated user à la gestion des bases de données via l’interface phpMyAdmin.

      Configuration du mot de passe d’accès au compte root MySQL

      Dans les systèmes Ubuntu fonctionnant sous MySQL 5.7 (et versions ultérieures), l’utilisateur MySQL root est configuré pour s’authentifier en utilisant le plugin auth_socket par défaut plutôt qu’avec un mot de passe. Cela permet une plus grande sécurité et facilité d’utilisation dans de nombreux cas, mais cela peut également compliquer les choses lorsque vous devez autoriser un programme externe – comme phpMyAdmin – pour accéder à l’utilisateur.

      Afin de vous connecter à phpMyAdmin en tant qu’utilisateur MySQL root, vous devrez changer sa méthode d’authentification de auth_socket à une méthode qui utilise un mot de passe, si vous ne l’avez pas déjà fait. Pour ce faire, ouvrez l’invite MySQL depuis votre terminal :

      Ensuite, vérifiez la méthode d’authentification utilisée par chacun de vos comptes utilisateurs MySQL à l’aide de la commande suivante :

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | | auth_socket | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Dans cet exemple, vous pouvez voir que l’utilisateur root s’authentifie effectivement en utilisant le plugin auth_socket. Pour configurer le compte root afin qu’il s’authentifie avec un mot de passe, exécutez la commande ALTER USER suivante.   Assurez-vous de changer password par un mot de passe fort de votre choix :

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Remarque : L’instruction ALTER USER précédente définit l’utilisateur MySQL root pour s’authentifier avec le plugin caching_sha2_password. Selon la documentation officielle de MySQL, caching_sha2_password est le plugin d’authentification préféré de MySQL, car il fournit un cryptage de mot de passe plus sûr que l’ancien, mais encore largement utilisé, mysql_native_password.

      Cependant, certaines versions de PHP ne fonctionnent pas de manière fiable avec caching_sha2_password. PHP a signalé que ce problème a été corrigé à partir de PHP 7.4, mais si vous rencontrez une erreur en essayant de vous connecter à phpMyAdmin plus tard, vous pourriez vouloir définir root pour vous authentifier avec mysql_native_password à la place :

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Ensuite, vérifiez à nouveau les méthodes d’authentification employées par chacun de vos utilisateurs pour confirmer que le root ne s’authentifie plus à l’aide du plugin auth_socket :

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | *DE06E242B88EFB1FE4B5083587C260BACB2A6158 | caching_sha2_password | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Vous pouvez voir à partir de cette sortie que le root user s’authentifiera à l’aide d’un mot de passe. Vous pouvez maintenant vous connecter à l’interface phpMyAdmin en tant que root user avec le mot de passe que vous lui avez attribué ici.

      Configuration de l’accès par mot de passe pour un utilisateur MySQL dédié

      Alternativement, certains peuvent trouver qu’il est plus adapté à leur travail de se connecter à phpMyAdmin avec un dedicated user. Pour ce faire, ouvrez à nouveau le shell MySQL :

      Si vous avez activé l’authentification par mot de passe pour votre root user, comme décrit dans la section précédente, vous devrez exécuter la commande suivante et saisir votre mot de passe lorsque vous y serez invité afin de vous connecter :

      De là, créez un nouvel utilisateur et attribuez-lui un mot de passe fort :

      • CREATE USER 'sammy'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Note : Encore une fois, selon la version de PHP que vous avez installée, vous voudrez peut-être configurer votre nouvel utilisateur pour qu’il s’authentifie avec le mot de passe mysql_native_password au lieu du mot de passe caching_sha2_password :

      • ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Ensuite, accordez à votre nouvel utilisateur les privilèges appropriés. Par exemple, vous pourriez accorder les privilèges d’utilisateur à toutes les tables de la base de données, ainsi que le pouvoir d’ajouter, de modifier et de supprimer des privilèges d’utilisateur, avec cette commande :

      • GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;

      Ensuite, quittez le shell MySQL :

      Vous pouvez maintenant accéder à l’interface web en visitant le nom de domaine ou l’adresse IP publique de votre serveur suivi de /phpmyadmin :

      https://your_domain_or_IP/phpmyadmin
      

      Écran de connexion à phpMyAdmin

      Connectez-vous à l’interface, soit commeroot ou avec le nouveau nom d’utilisateur et le nouveau mot de passe que vous venez de configurer. 

      Lorsque vous vous connecterez, vous verrez l’interface utilisateur, qui ressemblera à ceci :

      Interface utilisateur de phpMyAdmin

      Maintenant que vous êtes capable de vous connecter et d’interagir avec phpMyAdmin, il ne vous reste plus qu’à renforcer la sécurité de votre système pour le protéger des attaques.

      Étape 3 – Sécuriser votre instance phpMyAdmin

      En raison de son ubiquité, phpMyAdmin est une cible populaire pour les attaquants, et vous devriez faire très attention à empêcher tout accès non autorisé. Une façon de procéder consiste à placer une passerelle devant l’ensemble de l’application en utilisant les fonctionnalités d’authentification et d’autorisation .htaccess intégrées à Apache.

      Pour ce faire, vous devez d’abord activer l’utilisation des fichiers .htaccess en modifiant le fichier de configuration Apache de votre installation de phpMyAdmin.

      Utilisez votre éditeur de texte favori pour modifier le fichier phpmyadmin.conf qui a été placé dans votre répertoire de configuration Apache. Ici, nous utiliserons nano :

      • sudo nano /etc/apache2/conf-available/phpmyadmin.conf

      Ajoutez une directive AllowOverride All dans la section <Directory /usr/share/phpmyadmin> du fichier de configuration, comme ceci :

      /etc/apache2/conf-available/phpmyadmin.conf

      <Directory /usr/share/phpmyadmin>
          Options FollowSymLinks
          DirectoryIndex index.php
          AllowOverride All
          . . .
      

      Lorsque vous avez ajouté cette ligne, enregistrez et fermez le fichier. Si vous avez utilisé nano pour éditer le fichier, faites-le en appuyant sur CTRL + X, Y, puis ENTER

      Pour mettre en œuvre les modifications que vous avez apportées, redémarrez Apache :

      • sudo systemctl restart apache2

      Maintenant que vous avez autorisé l’utilisation de fichiers .htaccess pour votre application, vous devez en créer un pour mettre en place une certaine sécurité. 

      Pour que cela soit possible, le fichier doit être créé dans le répertoire de l’application. Vous pouvez créer le fichier nécessaire et l’ouvrir dans votre éditeur de texte avec les privilèges root en tapant :

      • sudo nano /usr/share/phpmyadmin/.htaccess

      Dans ce fichier, entrez les informations suivantes :

      /usr/share/phpmyadmin/.htaccess

      AuthType Basic
      AuthName "Restricted Files"
      AuthUserFile /etc/phpmyadmin/.htpasswd
      Require valid-user
      

      Voici ce que signifie chacune de ces lignes :

      • AuthType Basic : Cette ligne précise le type d’authentification que vous mettez en œuvre. Ce type mettra en œuvre l’authentification par mot de passe à l’aide d’un fichier de mots de passe.
      • AuthName : Définit le message pour la boîte de dialogue d’authentification. Vous devez conserver ce générique afin que les utilisateurs non autorisés n’obtiennent aucune information sur ce qui est protégé.
      • AuthUserFile : permet de définir l’emplacement du fichier de mots de passe qui sera utilisé pour l’authentification. Cela doit se faire en dehors des répertoires qui sont desservis. Nous allons créer ce dossier prochainement.
      • Require valid-user : Ceci spécifie que seuls les utilisateurs authentifiés doivent avoir accès à cette ressource. C’est ce qui empêche en fait les utilisateurs non autorisés d’entrer.

      Lorsque vous avez terminé, enregistrez et fermez le fichier.

      L’emplacement que vous avez choisi pour votre fichier de mots de passe était /etc/phpmyadmin/.htpasswd. Vous pouvez maintenant créer ce fichier et le transmettre à un utilisateur initial avec l’utilitaire htpasswd :

      • sudo htpasswd -c /etc/phpmyadmin/.htpasswd username

      Vous serez invité à sélectionner et à confirmer un mot de passe pour l’utilisateur que vous créez. Ensuite, le fichier est créé avec le mot de passe haché que vous avez entré.

      Si vous voulez entrer un utilisateur supplémentaire, vous devez le faire sans le drapeau -c, comme ceci :

      • sudo htpasswd /etc/phpmyadmin/.htpasswd additionaluser

      Maintenant, lorsque vous accédez à votre sous-répertoire phpMyAdmin, il vous sera demandé le nom de compte et le mot de passe supplémentaires que vous venez de configurer :

      https://domain_name_or_IP/phpmyadmin
      

      Mot de passe apache de phpMyAdmin

      Après avoir entré l’authentification Apache, vous serez dirigé vers la page d’authentification phpMyAdmin habituelle pour entrer vos identifiants MySQL. En ajoutant un ensemble supplémentaire d’identifiants non-MySQL, vous apportez à votre base de données une couche de sécurité supplémentaire. Ceci est souhaitable, puisque phpMyAdmin a été vulnérable aux menaces de sécurité par le passé.

      Conclusion

      Vous devriez maintenant avoir configuré phpMyAdmin et être prêt à l’utiliser sur votre serveur Ubuntu 20.04. Cette interface vous permet de créer des bases de données, des utilisateurs et des tableaux, ainsi que d’effectuer les opérations habituelles comme la suppression et la modification de structures et de données.



      Source link

      Cómo instalar y proteger phpMyAdmin en Ubuntu 20.04


      Brennan Bearnes escribió una versión anterior de este tutorial.

      Introducción

      Aunque muchos usuarios necesitan la funcionalidad de un sistema de gestión de bases de datos como MySQL, es posible que no se sientan cómodos interactuando con el sistema únicamente desde la consola de MySQL.

      phpMyAdmin se creó con el propósito de que los usuarios puedan interactuar con MySQL a través de una interfaz web. En esta guía, abordaremos la forma de instalar y proteger phpMyAdmin de modo que pueda utilizarlo de forma segura para gestionar sus bases de datos en un sistema Ubuntu 20.04.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      Adicionalmente, existen importantes consideraciones de seguridad al utilizar software como phpMyAdmin, ya que:

      • Se comunica directamente con su instalación de MySQL.
      • Maneja la autenticación utilizando credenciales de MySQL.
      • Se ejecuta y muestra resultados para consultas SQL arbitrarias.

      Por estas razones, y porque se trata de una aplicación PHP ampliamente implementada que con frecuencia recibe ataques, nunca debe ejecutar phpMyAdmin en sistemas remotos a través de una conexión HTTP simple.

      Si no tiene un dominio existente configurado con un certificado SSL/TLS, puede seguir esta guía para proteger Apache con Let’s Encrypt en Ubuntu 20.04. Deberá registrar un nombre de dominio, crear registros DNS para su servidor y configurar un host virtual en Apache.

      Paso 1: Instalación de phpMyAdmin

      Puede utilizar APT para instalar phpMyAdmin desde los repositorios predeterminados de Ubuntu.

      Como non-root user, actualice el índice de paquetes de su servidor:

      Después de esto, puede instalar el paquete phpmyadmin. Junto con este paquete, en la documentación oficial también se le recomienda instalar algunas extensiones PHP en su servidor para habilitar ciertas funcionalidades y mejorar el rendimiento.

      Si siguió el tutorial de pila LAMP de los requisitos previos, varios de estos módulos se habrán instalado junto con el paquete php. Sin embargo, se recomienda también instalar estos paquetes:

      • php-mbstring: módulo para administrar cadenas no-ASCII y convertir cadenas a diferentes codificaciones.
      • php-zip: esta extensión admite la carga de archivos .zip a phpMyAdmin.
      • php-gd: habilita la obtención de ayuda de la biblioteca GD Graphics.
      • php-json: proporciona PHP con compatibilidad para serialización JSON.
      • php-curl: permite que PHP interactúe con diferentes tipos de servidores utilizando diferentes protocolos.

      Ejecute el siguiente comando para instalar estos paquetes en su sistema. Tenga en cuenta que el proceso de instalación requiere que tome algunas decisiones para configurar phpMyAdmin correctamente. En breve, veremos estas opciones:

      • sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl

      Estas son las opciones que debe elegir cuando se le solicite para configurar correctamente su instalación:

      • Para la selección del servidor, elija apache2

        Advertencia: Cuando la línea de comandos aparece, “apache2” está resaltado, pero no está seleccionado. Si no pulsa SPACE para seleccionar Apache, el instalador no moverá los archivos necesarios durante la instalación. Pulse ESPACIO, TAB y luego ENTER para seleccionar Apache.
      • Cuando se le pregunte si utiliza dbconfig-common para configurar la base de datos, seleccione Yes.
      • Luego, se le solicitará elegir y confirmar una contraseña para la aplicación de MySQL para phpMyAdmin.

      Nota: Suponiendo que instaló MySQL conforme al paso 2 del tutorial de la pila LAMP de los requisitos previos, es posible que haya decidido habilitar el complemento Validate Password. En el momento en que se redactó este documento, habilitar este componente generará un error cuando intente establecer una contraseña para el usuario phpmyadmin:

      Error de validación de contraseña phpMyAdmin

      Para resolver esto, seleccione la opción abort a fin de detener el proceso de instalación. Luego, abra su línea de comandos de MySQL:

      O bien, si habilitó la autenticación de contraseña para el root user de MySQL, ejecute este comando y luego ingrese su contraseña cuando se le solicite:

      Desde la línea de comandos, ejecute el siguiente comando para deshabilitar el componente Validate Password. Tenga en cuenta que con esto en realidad no se desinstalará, sino solo se evitará que el componente sea cargado en su servidor MySQL:

      • UNINSTALL COMPONENT "file://component_validate_password";

      Después de esto, puede cerrar el cliente MySQL:

      Luego, vuelva a instalar el paquete phpmyadmin, que funcionará según lo previsto:

      • sudo apt install phpmyadmin

      Una vez que phpMyAdmin esté instalado, puede abrir la línea de comandos de MySQL una vez más con sudo mysql o mysql -u root -p y luego ejecutar el siguiente comando para volver a habilitar el componente “Validate Password”:

      • INSTALL COMPONENT "file://component_validate_password";

      El proceso de instalación añade el archivo de configuración de phpMyAdmin de Apache al directorio /etc/apache2/conhable/, donde se lee de forma automática. Para terminar de configurar Apache y PHP a fin de que funcionen con phpMyAdmin, la única tarea que queda a continuación en esta sección del tutorial es habilitar explícitamente la extensión PHP mbstring. Esto se puede hacer escribiendo lo siguiente:

      A continuación, reinicie Apache para que sus cambios surtan efecto:

      • sudo systemctl restart apache2

      phpMyAdmin ahora está instalado y configurado para funcionar con Apache. Sin embargo, pra poder iniciar sesión y comenzar a interactuar con sus bases de datos de MySQL, deberá asegurarse de que sus usuarios de MySQL tengan los privilegios necesarios para interactuar con el programa.

      Paso 2: Ajuste de la autenticación y los privilegios de usuario

      Cuando instaló phpMyAdmin en su servidor, automáticamente creó un usuario de base de datos llamado phpmyadmin que realiza ciertos procesos subyacentes para el programa. En vez de registrarse como este usuario con la contraseña administrativa que estableció durante la instalación, se le recomienda iniciar sesión como root user de MySQL o como usuario dedicado a administrar las bases de datos a través de la interfaz de phpMyAdmin.

      Configuración del acceso con contraseña para la cuenta root de MySQL

      En los sistemas Ubuntu con MySQL 5.7 (y versiones posteriores), el usuario root de MySQL se configura para la autenticación usando el complemento auth_socket de manera predeterminada en lugar de una contraseña. En muchos casos, esto proporciona mayor seguridad y utilidad, pero también puede generar complicaciones cuando sea necesario permitir que un programa externo (como phpMyAdmin) acceda al usuario.

      Si aún no lo ha hecho, deberá cambiar el método de autenticación de auth_socket a uno que haga uso de una contraseña, para poder acceder a phpMyAdmin como su root user de MySQL. Para hacer esto, abra la consola de MySQL desde su terminal:

      A continuación, compruebe con el siguiente comando el método de autenticación utilizado por una de sus cuentas de usuario de MySQL:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | | auth_socket | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      En este ejemplo, puede ver que, en efecto, el usuario root se autentica utilizando el complemento de auth_socket. Para configurar la cuenta de root de modo que la autenticación se realice con una contraseña, ejecute el siguiente comando ALTER USER. Asegúrese de cambiar password por una contraseña segura que elija:

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Nota: La instrucción ALTER USER previa establece el root user de MySQL para la autenticación con el complemento caching_sha2_password. Según la documentación oficial de MySQL, caching_sha2_password es el complemento de autenticación preferido por MySQL, ya que proporciona un cifrado de contraseña más seguro que el anterior, aunque aún usado ampliamente, mysql_native_password.

      Sin embargo, algunas versiones de PHP no funcionan de forma confiable con caching_sha2_password. PHP notificó que este problema se corregió a partir de PHP 7.4, pero si encuentra un error cuando intente iniciar sesión en phpMyAdmin más adelante, es conveniente que en vez de esto establezca root para autenticar con mysql_native_password.

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Luego, compruebe nuevamente los métodos de autenticación empleados por cada uno de sus usuarios para confirmar que root ya no se autentique usando el complemento auth_socket:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | *DE06E242B88EFB1FE4B5083587C260BACB2A6158 | caching_sha2_password | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      En este resultado, podrá ver que el root user se auntenticará usando una contraseña. Ahora podrá iniciar sesión en la interfaz phpMyAdmin como usuario root con la contraseña que estableció aquí.

      Configuración del acceso con contraseña para un usuario dedicado de MySQL

      Por otra parte, para el flujo de trabajo de algunos puede resultar más conveniente la conexión a phpMyAdmin con un usuario dedicado. Para hacer esto, abra una vez más el shell de MySQL:

      Si tiene habilitada la autenticación de contraseña para su root user, como se describe en la sección anterior, deberá ejecutar el siguiente comando e ingresar su contraseña cuando se le solicite para establecer conexión:

      A partir de ahí, cree un usuario nuevo y asigne una contraseña segura:

      • CREATE USER 'sammy'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Nota: De nuevo, dependiendo de la versión de PHP que instaló, es conveniente establecer su nuevo usuario para la autenticación con mysql_native_password en lugar de caching_sha2_password:

      • ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Luego, conceda a su nuevo usuario los privilegios apropiados. Por ejemplo, con el siguiente comando podría conceder privilegios de usuario a todas las tablas dentro de la base de datos, así como la facultad de añadir, cambiar y eliminar privilegios de usuario:

      • GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;

      A continuación, cierre el shell de MySQL:

      Ahora puede acceder a la interfaz web visitando el nombre de dominio o la dirección IP pública de su servidor, con “/phpmyadmin” agregado:

      https://your_domain_or_IP/phpmyadmin
      

      Pantalla de inicio de sesión de phpMyAdmin

      Inicie sesión en la interfaz como root o con el nombre de usuario y la contraseña que configuró.

      Cuando inicie sesión, verá la interfaz de usuario. Tendrá el siguiente aspecto:

      Interfaz de usuario de phpMyAdmin

      Ahora que puede establecer conexión e interactuar con phpMyAdmin, solo falta fortalecer la seguridad de sus sistemas para protegerlos de atacantes.

      Paso 3: Protección de la instancia de phpMyAdmin

      Debido a su presencia universal, phpMyAdmin es un objetivo popular para atacantes. Debe tomar medidas adicionales para evitar el acceso no autorizado. Una opción para hacer esto es disponer una puerta de enlace delante de toda la aplicación utilizando las funciones de autenticación y autorización de .htaccess integradas de Apache.

      Para hacerlo, primero debe habilitar el uso de anulaciones del archivo .htaccess editando su archivo de configuración de Apache.

      Utilice su editor de texto preferido para editar el archivo phpmyadmin.conf que se dispuso en su directorio de configuración de Apache. En este caso, utilizaremos nano:

      • sudo nano /etc/apache2/conf-available/phpmyadmin.conf

      Agregue una directiva AllowOverride All dentro de la sección <Directory /usr/share/phpmyadmin>​​​ del archivo de configuración, como se muestra:

      /etc/apache2/conf-available/phpmyadmin.conf

      <Directory /usr/share/phpmyadmin>
          Options FollowSymLinks
          DirectoryIndex index.php
          AllowOverride All
          . . .
      

      Una vez que agregue esta línea, guarde y cierre el archivo. Si utilizó nano para editar el archivo, hágalo presionando CTRL + X, Y y luego ENTER.

      Para implementar los cambios que realizó, reinicie Apache:

      • sudo systemctl restart apache2

      Ahora que habilitó el uso de .htaccess para su aplicación, deberá crear uno para implementar seguridad.

      Para que pueda hacerlo de forma correcta, el archivo debe crearse dentro del directorio de la aplicación. Puede crear el archivo necesario y abrirlo en su editor de texto con privilegios root escribiendo lo siguiente:

      • sudo nano /usr/share/phpmyadmin/.htaccess

      Dentro de este archivo, ingrese la siguiente información:

      /usr/share/phpmyadmin/.htaccess

      AuthType Basic
      AuthName "Restricted Files"
      AuthUserFile /etc/phpmyadmin/.htpasswd
      Require valid-user
      

      A continuación, se muestra lo que significa cada una de estas líneas:

      • AuthType Basic: en esta línea se especifica el tipo de autenticación que implementará. Con este tipo se implementará la autenticación de contraseña utilizando un archivo de contraseña.
      • AuthName: establece el mensaje para el cuadro de diálogo de autenticación. Debe procurar que esto sea genérico para que los usuarios no autorizados no obtengan información sobre lo que se protege.
      • AuthUserFile: establece la ubicación del archivo de contraseña que se utilizará para la autenticación. Esto debe quedar fuera de los directorios que se presentan. Crearemos este archivo pronto.
      • Require valid-user: especifica que solo los usuarios autenticados deberán tener acceso al recurso. Esto es lo que realmente impide el ingreso de los usuarios no autorizados.

      Cuando termine, guarde y cierre el archivo.

      La ubicación que seleccionó para su archivo de contraseña fue /etc/phpmyadmin/.htpasswd. Ahora puede crear este archivo y pasarle un usuario inicial con la utilidad htpasswd:

      • sudo htpasswd -c /etc/phpmyadmin/.htpasswd username

      Para el usuario que creará, se le solicitará seleccionar y confirmar una contraseña. Después, el archivo se creará con la contraseña con hash que ingresó.

      Si desea ingresar un usuario adicional, debe hacerlo sin el indicador -c, como se muestra:

      • sudo htpasswd /etc/phpmyadmin/.htpasswd additionaluser

      Ahora, cuando acceda a su subdirectorio phpMyAdmin, se le solicitarán el nombre de cuenta y la contraseña adicionales que acaba de configurar:

      https://domain_name_or_IP/phpmyadmin
      

      Contraseña phpMyAdmin de Apache

      Después de ingresar la autenticación de Apache, accederá a la página de autenticación normal de phpMyAdmin para ingresar sus credenciales de MySQL. Al añadir un conjunto adicional de credenciales que no son las de MySQL, proporciona a su base de datos una capa de seguridad adicional. Esto es conveniente, ya que phpMyAdmin ha sido vulnerable a amenazas de seguridad en el pasado.

      Conclusión

      De esta manera, phpMyAdmin debería estar ya configurado y listo para usar en su servidor Ubuntu 20.04. Utilizando esta interfaz, puede crear fácilmente bases de datos, usuarios y tablas, y realizar operaciones habituales, como las de eliminar y modificar estructuras y datos.



      Source link