Se connecter à la firebase database MySQL avec C # en tant qu’utilisateur non root?

Certains concepts importants sont également les lignes dans le tableau montré ici:

select user,host,password from mysql.user where user='pfinferno'; 

Points importants à retenir, les utilisateurs peuvent avoir plusieurs noms d’hôte ou caractères génériques. Chacun a ses propres droits et mots de passe. Bien que le mot de passe ci-dessus soit haché, vous pouvez au moins le voir rapidement pour voir si tous les mots de passe correspondent (par exemple, root avec 3 comptes).

La colonne hôte est remplie par les valeurs suivantes, principalement:

Spécimen A:

• localhost
• 127.0.0.1
• %
• noms communs tels que md21.newyork.comcastbusiness.net et similaires

La valeur % est le caractère générique. C’est pour la flexibilité, mais il peut être très dangereux lorsqu’il est utilisé avec des utilisateurs comme ‘root’ @ ‘%’. Garder la racine comme le premier deux seulement dans le spécimen A est fortement conseillé. En outre, les deux premiers sont assez différents dans différents outils. Ce que je recommande, c’est d’avoir une ligne d’utilisateur root pour les deux premiers et de garder les mots de passe identiques. Il y a des avantages et des inconvénients à cette approche. Mais souvenez-vous que lorsque vous ne pouvez pas vous connecter à autre chose, vous pouvez vous fier à la connexion, qu’il s’agisse d’un agent, de phpmyadmin, d’un outil, des parameters de my.conf, etc.

Dans l’exemple donné par Mureinik, il accorde des privilèges à l’utilisateur avec l’hôte générique = % . Cela signifie qu’il s’appuie sur un utilisateur créé en tant que tel. Notez que les comptes utilisateur sont configurés de cette façon. Bien que rien ne vous empêche de le verrouiller plus fermement.

Lorsqu’un utilisateur tente de se connecter au serveur, l’utilisateur auquel il est finalement connecté peut être résolu en une combinaison utilisateur / hôte différente, comme on peut le voir dans le cas où il n’y a pas d’utilisateur localhost (hôte) ou de nom commun, mais plutôt une avec une valeur d’hôte de % générique. Cela peut être vu avec cette requête:

Spécimen B:

 select current_user(),user(); 

Ce dernier est l’utilisateur présenté par la tentative de connexion, le premier est celui qui a été résolu et actuel . Les implications peuvent entraîner des jours de débogage, comme on peut le voir sur ces forums. Certaines personnes ne peuvent pas se connecter pendant des jours, je suis sérieux.

Spécimen C:

 create user 'pfinferno'@'localhost' identified by 'thePassword'; create user 'pfinferno'@'127.0.0.1' identified by 'thePassword'; create user 'pfinferno' identified by 'thePassword'; create user 'pfinferno'@'md21.newyork.comcastbusiness.net' identified by 'thePassword'; 

– la note n ° 3 ci-dessus est identique à celle de ‘pfinferno’ @ ‘%’

Maintenant, le nom d’hôte peut être générique pour les utilisateurs normaux et le nom d’hôte peut être localhost et 127.0.0.1 pour root uniquement. Mais dans la tentative de verrouiller la sécurité, les administrateurs créent souvent des comptes d’utilisateurs basés sur le nom d’hôte entrant (tel que le spécimen C, ligne 4) et modifient la sécurité avec des subventions basées sur cela. La gestion peut être un peu écrasante. Donc, ils se contentent souvent de dire de la visser, je vais créer l’utilisateur générique. Cela peut convenir à un nouvel utilisateur, dit Susie, mais pour Secimen C, ligne 4, si vous venez ici, vous pouvez obtenir des subventions pour un utilisateur de la ligne 3 que vous ne récupérerez pas. Ainsi, la résolution de quel utilisateur vous êtes actuallity (voir spécimen B), va du nom d’hôte le plus spécifique à la version de remplacement, jusqu’à ce qu’il en trouve un tel que le joker.

Malheureusement, les utilisateurs ne se connectent pas avec le nom d’hôte spécifié en soi, ils ne sont que ce qu’ils sont. Ils essaient de se connecter. Donc, vous ne dites pas bon je veux être ce truc @hostname, vous êtes juste ce que vous êtes. Vous êtes 'pfinferno'@'md21.newyork.comcastbusiness.net' , mais vous pouvez 'pfinferno'@'md21.newyork.comcastbusiness.net' caractères génériques.

Si les utilisateurs sont supprimés dans le spécimen C, sauf les % caractères génériques, il est préférable d’avoir les subventions qui les accompagnent, car vous êtes maintenant un nouvel utilisateur.

Essayez de limiter l’utilisation de caractères génériques dans l’instruction grant à ne pas faire *.* Comme dans l’approche paresseuse, qui n’accorderait que des droits sur toutes les bases de données et tables. Dans l’exemple de Mureinik, c’était pour toutes les tables d’une firebase database. Pas trop mal. Essayez d’affiner les droits, par exemple en accordant des privilèges SELECT sur des tables ou pas du tout, aux utilisateurs qui n’en ont pas besoin. Faites attention à l’ WITH GRANT OPTION telle qu’elle apparaît sur le filet, en coupant et collant. Si vous l’utilisez, vous venez d’accorder les droits d’utilisateur pour accorder d’autres droits d’utilisateur.

Tunnels SSH

Une des raisons pour lesquelles vous ne souhaitez peut-être pas utiliser Secimen Un hôte = % caractères génériques (autres que l’évidence que nous sums opposés au risque) est que

 create user 'pfinferno'@'localhost' identified by 'thePassword'; 

est parfait pour les tunnels SSH. Vous vous connecteriez via un canal cryptographiquement sécurisé avec PKI, et vous vous présenteriez comme si vous étiez @ localhost. Cela réduit considérablement l’exposition à la sécurité.

Pourquoi je ne peux pas me connecter?

J’espère que le visuel ci-dessous avec peu de commentaires peut montrer pourquoi j’ai nommé cette section comme je l’ai fait.

 drop user 'pfinferno'@'localhost'; drop user 'pfinferno'@'127.0.0.1'; drop user 'pfinferno'@'%'; drop user 'pfinferno'@'md21.newyork.comcastbusiness.net'; flush privileges; -- some say this is not necessary, I have found otherwise create user 'pfinferno'@'localhost' identified by 'thePassword'; create user 'pfinferno'@'127.0.0.1' identified by 'thePassword'; create user 'pfinferno' identified by 'thePassword'; create user 'pfinferno'@'md21.newyork.comcastbusiness.net' identified by 'thePassword'; 

…

 select user,host,password from mysql.user where user='pfinferno'; grant all on so_gibberish.* to 'pfinferno'@'%'; -- grant all rights on so_gibberish db flush privileges; -- some say this is not necessary, I have found otherwise 

Regardez des subventions.

 show grants for 'pfinferno'@'localhost'; -- sandboxed. Can just log in and sit there +-----------------------------------------------------------------------------------------+ | Grants for pfinferno@localhost | +-----------------------------------------------------------------------------------------+ | GRANT USAGE ON *.* TO 'pfinferno'@'localhost' IDENTIFIED BY PASSWORD '*74692AE70C53...' | +-----------------------------------------------------------------------------------------+ show grants for 'pfinferno'@'127.0.0.1'; -- sandboxed. Can just log in and sit there same as above show grants for 'pfinferno'; -- wildcard % user, has all rights on so_gibberish; +-----------------------------------------------------------------------------------------+ | Grants for pfinferno@% | +-----------------------------------------------------------------------------------------+ | GRANT USAGE ON *.* TO 'pfinferno'@'%' IDENTIFIED BY PASSWORD '*74692AE70C53...' | | GRANT ALL PRIVILEGES ON `so_gibberish`.* TO 'pfinferno'@'%' | +-----------------------------------------------------------------------------------------+ 

Notez ci-dessus que GRANT USAGE signifie qu’au moins vous avez le droit de vous connecter et de vous asseoir (en sandbox). Mais l’utilisateur % générique possède également tous les droits sur la firebase database so_gibberish.

Maintenant, je vais à l’invite mysql -u pfinferno -pthePassword via mysql -u pfinferno -pthePassword

 mysql> show databases; +--------------------+ | Database | +--------------------+ | information_schema | +--------------------+ mysql> select current_user(),user(); +---------------------+---------------------+ | current_user() | user() | +---------------------+---------------------+ | pfinferno@localhost | pfinferno@localhost | +---------------------+---------------------+ 

L’utilisateur tenté ( user() ) a été résolu à la même chose ( current_user() ). J’étais bac à sable, capable de faire essentiellement rien, sauf select now() jusqu’à ennuyer à mort.

 mysql> use so_gibberish; ERROR 1044 (42000): Access denied for user 'pfinferno'@'localhost' to database 'so_gibberish' 

quitter mysql CLI en tant que cet utilisateur.

À présent

 drop user 'pfinferno'@'localhost'; drop user 'pfinferno'@'127.0.0.1'; drop user 'pfinferno'@'md21.newyork.comcastbusiness.net'; 

Je viens de laisser tomber trois des quatre utilisateurs de pfinferno

Aller à l’invite mysql via mysql -u pfinferno -pthePassword

 mysql> show databases; +--------------------+ | Database | +--------------------+ | information_schema | | so_gibberish | +--------------------+ mysql> select current_user(),user(); +----------------+---------------------+ | current_user() | user() | +----------------+---------------------+ | pfinferno@% | pfinferno@localhost | +----------------+---------------------+ mysql> use so_gibberish; Database changed 

Cela montre que @ la CLI (ou n’importe quel programme) de n’importe quel hôte, que la tentative de connexion est d’abord présentée par l’utilisateur et ensuite résolue à réelle (voir la sortie de user() et current_user() , respectivement).

Donc, peut-être curieusement, lorsque j’ai abandonné les utilisateurs, les EFFECTIVE RIGHTS augmenté au fur et à mesure que l’utilisateur était résolu à un autre. Cela peut faire l’object d’heures / jours / semaines de débogage. Les utilisateurs ne peuvent avoir aucune idée de qui ils sont vraiment connectés (ou résolus), ou pourquoi ils ne peuvent pas, chacun d’ailleurs, avoir un mot de passe différent! Cela est particulièrement vrai avec l’utilisateur root avec plusieurs lignes dans mysql.user … et considérant que probablement 50% de tous les utilisateurs de mysql se connectent avec lui, initialement, en tant que développeurs. Juste un invité.

Vous pouvez utiliser la syntaxe d’ grant , en tant que root pour accorder des permissions à d’autres utilisateurs. Par exemple:

 GRANT ALL PRIVILEGES ON mydatabase.* TO pfinferno 

Eh bien, tout d’abord, vous devez réaliser que cette “racine” (de MySQL) est différente de l’utilisateur “root” (de votre ordinateur).

Lorsque vous vous connectez à la firebase database MySQL (en tant que root en premier), vous pouvez créer un autre utilisateur avec le moins de privilèges. (Création de l’utilisateur: https://dev.mysql.com/doc/refman/5.1/en/create-user.html )

Après cela, vous pouvez accorder (accorder) des privilèges à cet utilisateur spécifique. (Octroi de privilèges: https://dev.mysql.com/doc/refman/5.1/fr/grant.html ) Vous pouvez, par exemple, autoriser certains utilisateurs à sélectionner uniquement des données dans les tables. Un autre utilisateur peut insérer / mettre à jour. Etc.

Ainsi, dans votre application, vous pouvez spécifier un autre utilisateur au lieu de root, comme vous pouvez le voir normalement.