Funciones PHP explotables

Estoy tratando de crear una lista de funciones que se puedan usar para la ejecución de código arbitrario. El propósito no es enumerar las funciones que deberían incluirse en la lista negra o no permitirse. Más bien, me gustaría tener a grepmano una lista de palabras clave de bandera roja cuando busque puertas traseras en un servidor comprometido.

La idea es que si desea crear un script PHP malicioso multipropósito, como un script de "shell web" como c99 o r57, tendrá que usar una o más funciones relativamente pequeñas. en algún lugar del archivo para permitir al usuario ejecutar código arbitrario. La búsqueda de esas funciones lo ayuda a reducir más rápidamente un montón de decenas de miles de archivos PHP a un conjunto relativamente pequeño de scripts que requieren un examen más detallado.

Claramente, por ejemplo, cualquiera de los siguientes se consideraría malicioso (o codificación terrible):

<? eval($_GET['cmd']); ?>

<? system($_GET['cmd']); ?>

<? preg_replace('/.*/e',$_POST['code']); ?>

Etcétera.

Al buscar en un sitio web comprometido el otro día, no noté un fragmento de código malicioso porque no me di cuenta preg_replacede que el uso de la /ebandera podía hacer que fuera peligroso (lo cual, ¿en serio? ¿Por qué está ahí ?). ¿Hay otros que me perdí?

Aquí está mi lista hasta ahora:

Ejecutar Shell

• system
• exec
• popen
• backtick operator
• pcntl_exec

Ejecutar PHP

• eval
• preg_replace(con /emodificador)
• create_function
• include[ _once] / require[ _once] ( ver la respuesta de Mario para detalles de exploit)

También podría ser útil tener una lista de funciones que sean capaces de modificar archivos, pero imagino que el 99% del tiempo el código de explotación contendrá al menos una de las funciones anteriores. Pero si tiene una lista de todas las funciones capaces de editar o generar archivos, publíquela y la incluiré aquí. (Y no estoy contando mysql_execute, ya que es parte de otra clase de exploit).

Para construir esta lista utilicé 2 fuentes. Un estudio en escarlata y ratas . También he agregado algunos de los míos a la mezcla y las personas en este hilo han ayudado.

Editar: Después de publicar esta lista, me puse en contacto con el fundador de RIPS y, a partir de ahora, esta herramienta busca en el código PHP el uso de todas las funciones de esta lista.

La mayoría de estas llamadas a funciones se clasifican como sumideros. Cuando una variable contaminada (como $ _REQUEST) se pasa a una función sumidero, entonces tiene una vulnerabilidad. Programas como RATS y RIPS utilizan la funcionalidad grep like para identificar todos los sumideros en una aplicación. Esto significa que los programadores deben tener especial cuidado al usar estas funciones, pero si todos estuvieran prohibidos, entonces no podría hacer mucho.

" Con un gran poder viene una gran responsabilidad " .

--Stan Lee

Ejecución de comando

exec           - Returns last line of commands output
passthru       - Passes commands output directly to the browser
system         - Passes commands output directly to the browser and returns last line
shell_exec     - Returns commands output
`` (backticks) - Same as shell_exec()
popen          - Opens read or write pipe to process of a command
proc_open      - Similar to popen() but greater degree of control
pcntl_exec     - Executes a program

Ejecución de código PHP

Además de que evalhay otras formas de ejecutar código PHP: include/ requirese puede usar para la ejecución remota de código en forma de vulnerabilidades de inclusión de archivo local e inclusión de archivo remoto .

eval()
assert()  - identical to eval()
preg_replace('/.*/e',...) - /e does an eval() on the match
create_function()
include()
include_once()
require()
require_once()
$_GET['func_name']($_GET['argument']);
$func = new ReflectionFunction($_GET['func_name']); $func->invoke(); or $func->invokeArgs(array());

Lista de funciones que aceptan devoluciones de llamada

Estas funciones aceptan un parámetro de cadena que podría usarse para llamar a una función de elección del atacante. Dependiendo de la función, el atacante puede o no tener la capacidad de pasar un parámetro. En ese caso Information Disclosure, se phpinfo()podría usar una función como .

Function                     => Position of callback arguments
'ob_start'                   =>  0,
'array_diff_uassoc'          => -1,
'array_diff_ukey'            => -1,
'array_filter'               =>  1,
'array_intersect_uassoc'     => -1,
'array_intersect_ukey'       => -1,
'array_map'                  =>  0,
'array_reduce'               =>  1,
'array_udiff_assoc'          => -1,
'array_udiff_uassoc'         => array(-1, -2),
'array_udiff'                => -1,
'array_uintersect_assoc'     => -1,
'array_uintersect_uassoc'    => array(-1, -2),
'array_uintersect'           => -1,
'array_walk_recursive'       =>  1,
'array_walk'                 =>  1,
'assert_options'             =>  1,
'uasort'                     =>  1,
'uksort'                     =>  1,
'usort'                      =>  1,
'preg_replace_callback'      =>  1,
'spl_autoload_register'      =>  0,
'iterator_apply'             =>  1,
'call_user_func'             =>  0,
'call_user_func_array'       =>  0,
'register_shutdown_function' =>  0,
'register_tick_function'     =>  0,
'set_error_handler'          =>  0,
'set_exception_handler'      =>  0,
'session_set_save_handler'   => array(0, 1, 2, 3, 4, 5),
'sqlite_create_aggregate'    => array(2, 3),
'sqlite_create_function'     =>  2,

Divulgación de información

La mayoría de estas llamadas a funciones no son sumideros. Pero más bien puede ser una vulnerabilidad si alguno de los datos devueltos es visible para un atacante. Si un atacante puede ver phpinfo(), definitivamente es una vulnerabilidad.

phpinfo
posix_mkfifo
posix_getlogin
posix_ttyname
getenv
get_current_user
proc_get_status
get_cfg_var
disk_free_space
disk_total_space
diskfreespace
getcwd
getlastmo
getmygid
getmyinode
getmypid
getmyuid

Otro

extract - Opens the door for register_globals attacks (see study in scarlet).
parse_str -  works like extract if only one argument is given.  
putenv
ini_set
mail - has CRLF injection in the 3rd parameter, opens the door for spam. 
header - on old systems CRLF injection could be used for xss or other purposes, now it is still a problem if they do a header("location: ..."); and they do not die();. The script keeps executing after a call to header(), and will still print output normally. This is nasty if you are trying to protect an administrative area. 
proc_nice
proc_terminate
proc_close
pfsockopen
fsockopen
apache_child_terminate
posix_kill
posix_mkfifo
posix_setpgid
posix_setsid
posix_setuid

Funciones del sistema de archivos

Según RATS, todas las funciones del sistema de archivos en php son desagradables. Algunos de estos no parecen muy útiles para el atacante. Otros son más útiles de lo que piensas. Por ejemplo, si allow_url_fopen=Onse puede usar una url como ruta de archivo, entonces copy($_GET['s'], $_GET['d']);se puede usar una llamada para cargar un script PHP en cualquier parte del sistema. Además, si un sitio es vulnerable a una solicitud enviada a través de GET, se puede abusar de todas esas funciones del sistema de archivos para canalizar y atacar a otro host a través de su servidor.

// open filesystem handler
fopen
tmpfile
bzopen
gzopen
SplFileObject->__construct
// write to filesystem (partially in combination with reading)
chgrp
chmod
chown
copy
file_put_contents
lchgrp
lchown
link
mkdir
move_uploaded_file
rename
rmdir
symlink
tempnam
touch
unlink
imagepng   - 2nd parameter is a path.
imagewbmp  - 2nd parameter is a path. 
image2wbmp - 2nd parameter is a path. 
imagejpeg  - 2nd parameter is a path.
imagexbm   - 2nd parameter is a path.
imagegif   - 2nd parameter is a path.
imagegd    - 2nd parameter is a path.
imagegd2   - 2nd parameter is a path.
iptcembed
ftp_get
ftp_nb_get
// read from filesystem
file_exists
file_get_contents
file
fileatime
filectime
filegroup
fileinode
filemtime
fileowner
fileperms
filesize
filetype
glob
is_dir
is_executable
is_file
is_link
is_readable
is_uploaded_file
is_writable
is_writeable
linkinfo
lstat
parse_ini_file
pathinfo
readfile
readlink
realpath
stat
gzfile
readgzfile
getimagesize
imagecreatefromgif
imagecreatefromjpeg
imagecreatefrompng
imagecreatefromwbmp
imagecreatefromxbm
imagecreatefromxpm
ftp_put
ftp_nb_put
exif_read_data
read_exif_data
exif_thumbnail
exif_imagetype
hash_file
hash_hmac_file
hash_update_file
md5_file
sha1_file
highlight_file
show_source
php_strip_whitespace
get_meta_tags

Tendría que escanear para incluir ($ tmp) y requerir (HTTP_REFERER) y * _once también. Si un script de exploit puede escribir en un archivo temporal, podría incluirlo más tarde. Básicamente una evaluación de dos pasos.

E incluso es posible ocultar el código remoto con soluciones como:

 include("data:text/plain;base64,$_GET[code]");

Además, si su servidor web ya se ha visto comprometido, no siempre verá el mal sin codificar. A menudo, el shell de exploit está codificado con gzip. Piense en include("zlib:script2.png.gz");No eval aquí, sigue siendo el mismo efecto.

Esta no es una respuesta per se, pero aquí hay algo interesante:

$y = str_replace('z', 'e', 'zxzc');
$y("malicious code");

En el mismo espíritu, call_user_func_array()se puede utilizar para ejecutar funciones ofuscadas.

Me sorprende que nadie haya mencionado echoy printcomo puntos de explotación de seguridad.

Cross-Site Scripting (XSS) es una grave vulnerabilidad de seguridad, porque es aún más común que las vulnerabilidades de ejecución de código del lado del servidor.

En particular, me gustaría agregar unserialize () a esta lista. Ha tenido una larga historia de varias vulnerabilidades, incluida la ejecución de código arbitrario, la denegación de servicio y la fuga de información de memoria. Nunca debe llamarse en datos proporcionados por el usuario. Muchos de estos vuls han sido reparados en lanzamientos en los últimos años de rocío, pero aún conserva un par de vuls desagradables en el momento actual de la escritura.

Para obtener más información acerca de las funciones / uso de php poco fiables, consulte el Proyecto PHP Endurecido y sus avisos. También la reciente Mes de Seguridad en PHP y de 2007 Mes de errores de PHP proyectos

También tenga en cuenta que, por diseño, la deserialización de un objeto hará que se ejecuten las funciones de constructor y destructor; otra razón para no llamarlo en datos proporcionados por el usuario.

Mi VPS está configurado para deshabilitar las siguientes funciones:

root@vps [~]# grep disable_functions /usr/local/lib/php.ini
disable_functions = dl, exec, shell_exec, system, passthru, popen, pclose, proc_open, proc_nice, proc_terminate, proc_get_status, proc_close, pfsockopen, leak, apache_child_terminate, posix_kill, posix_mkfifo, posix_setpgid, posix_setsid, posix_setuid

PHP tiene suficientes funciones potencialmente destructibles que su lista podría ser demasiado grande para obtener. Por ejemplo, PHP tiene chmod y chown, que podrían usarse simplemente para desactivar un sitio web.

EDITAR: Quizás desee crear un script bash que busque un archivo para una matriz de funciones agrupadas por peligro (funciones que son malas, funciones que son peores, funciones que nunca deberían usarse), y luego calcular la relatividad del peligro que el archivo impone en un porcentaje. Luego envíe esto a un árbol del directorio con los porcentajes etiquetados junto a cada archivo, si es mayor que un umbral de, digamos, 30% de peligro.

¡También tenga en cuenta la clase de "vulnerabilidades de interrupción" que permiten leer y escribir ubicaciones arbitrarias de memoria!

Estos afectan funciones como trim (), rtrim (), ltrim (), explotar (), strchr (), strstr (), substr (), chunk_split (), strtok (), addcslashes (), str_repeat () y más . Esto se debe en gran parte, pero no exclusivamente, a la función de paso por referencia de tiempo de llamada del lenguaje que ha quedado en desuso durante 10 años pero no está deshabilitado.

Para obtener más información, vea la charla de Stefan Esser sobre las vulnerabilidades de interrupción y otros problemas de PHP de nivel inferior en BlackHat USA 2009 Slides Paper

Este documento / presentación también muestra cómo se puede usar dl () para ejecutar código de sistema arbitrario.

Vectores ejecutivos específicos de plataforma, pero también teóricos:

• dotnet_load ()
• nuevo COM ("WScript.Shell")
• nuevo Java ("java.lang.Runtime")
• event_new () - muy eventualmente

Y hay muchos más métodos de disfraz:

• proc_open es un alias para popen
• call_user_func_array ("exE" .chr (99), array ("/ usr / bin / damage", "--todos"));
• file_put_contents ("/ cgi-bin / nextinvocation.cgi") && chmod (...)
• PharData :: setDefaultStub - un poco más de trabajo para examinar el código en archivos .phar
• runkit_function_rename ("exec", "innocent_name") o APD rename_function

Además de la evalconstrucción del lenguaje, hay otra función que permite la ejecución de código arbitrario:assert

assert('ex' . 'ec("kill --bill")');

No se ha mencionado una fuente de exploits interesantes. PHP permite que las cadenas tengan 0x00bytes en ellas. Las funciones subyacentes (libc) tratan esto como el final de una cadena.

Esto permite situaciones en las que se puede engañar la comprobación de cordura (mal implementada) en PHP, por ejemplo, en una situación como:

/// note: proof of principle code, don't use
$include = $_GET['file'];
if ( preg_match("/\\.php$/",$include) ) include($include);

Esto puede incluir cualquier archivo, no solo los que terminan en .php, llamandoscript.php?file=somefile%00.php

Por lo tanto, cualquier función que no obedezca la longitud de la cadena de PHP puede generar cierta vulnerabilidad.

¿Qué pasa con los elementos sintácticos peligrosos?

La " variable variable " ( $$var) encontrará una variable en el alcance actual con el nombre de $ var. Si se usa incorrectamente, el usuario remoto puede modificar o leer cualquier variable en el alcance actual. Básicamente un más débil eval.

Por ejemplo: escribe un código $$uservar = 1;, luego el usuario remoto establece $uservar"admin", lo $adminque hace que se establezca 1en el ámbito actual.

Supongo que no podrás encontrar todas las posibles vulnerabilidades al analizar tus archivos fuente.

• Además, si hay listas realmente excelentes aquí, puede perderse una función que puede ser explotada

• todavía podría haber un código malvado "oculto" como este

$ myEvilRegex = base64_decode ('Ly4qL2U =');

preg_replace ($ myEvilRegex, $ _POST ['código']);

• ahora podría decir, simplemente extiendo mi script para que también coincida con esto

• pero entonces tendrás ese mayn "código posiblemente malvado" que además está fuera de su contexto

• para ser (pseudo-) seguro, realmente debería escribir un buen código y leer todo el código existente usted mismo

Backtick Operator Backtick en el manual de php

Sé que move_uploaded_filese ha mencionado, pero la carga de archivos en general es muy peligrosa. Solo la presencia de $_FILESdebería generar cierta preocupación.

Es bastante posible incrustar código PHP en cualquier tipo de archivo. Las imágenes pueden ser especialmente vulnerables con comentarios de texto. El problema es particularmente problemático si el código acepta la extensión que se encuentra dentro de los $_FILESdatos tal cual.

Por ejemplo, un usuario podría cargar un archivo PNG válido con código PHP incrustado como "foo.php". Si el script es particularmente ingenuo, puede copiar el archivo como "/uploads/foo.php". Si el servidor está configurado para permitir la ejecución de scripts en los directorios de carga de usuarios (a menudo el caso, y un descuido terrible), puede ejecutar instantáneamente cualquier código PHP arbitrario. (Incluso si la imagen se guarda como .png, es posible que el código se ejecute a través de otras fallas de seguridad).

Una lista (no exhaustiva) de cosas para verificar en las cargas:

• Asegúrese de analizar el contenido para asegurarse de que la carga sea del tipo que dice ser
• Guarde el archivo con una extensión de archivo segura y conocida que nunca se ejecutará
• Asegúrese de que PHP (y cualquier otra ejecución de código) esté deshabilitado en los directorios de carga de usuarios

Agreguemos pcntl_signaly pcntl_alarma la lista.

Con la ayuda de esas funciones, puede evitar cualquier restricción set_time_limit creada en php.ini o en el script.

Este script, por ejemplo, se ejecutará durante 10 segundos a pesar de set_time_limit(1);

(El crédito es para el tweet y esencia de Sebastian Bergmanns :

<?php
declare(ticks = 1);

set_time_limit(1);

function foo() {
    for (;;) {}
}

class Invoker_TimeoutException extends RuntimeException {}

class Invoker
{
    public function invoke($callable, $timeout)
    {
        pcntl_signal(SIGALRM, function() { throw new Invoker_TimeoutException; }, TRUE);
        pcntl_alarm($timeout);
        call_user_func($callable);
    }
}

try {
    $invoker = new Invoker;
    $invoker->invoke('foo', 1);
} catch (Exception $e) {
    sleep(10);
    echo "Still running despite of the timelimit";
}

Hay muchas vulnerabilidades de PHP que pueden deshabilitarse mediante la configuración en el archivo PHP.ini. El ejemplo obvio es register_globals, pero dependiendo de la configuración, también puede ser posible incluir o abrir archivos desde máquinas remotas a través de HTTP, que pueden explotarse si un programa usa nombres de archivo variables para cualquiera de sus funciones include () o manejo de archivos.

PHP también permite la llamada a funciones variables agregando () al final del nombre de una variable; por ejemplo $myvariable();, llamará al nombre de función especificado por la variable. Esto es explotable; por ejemplo, si un atacante puede hacer que la variable contenga la palabra 'eval' y pueda controlar el parámetro, puede hacer lo que quiera, aunque el programa no contenga la función eval ().

Estas funciones también pueden tener algunos efectos desagradables.

• str_repeat()
• unserialize()
• register_tick_function()
• register_shutdown_function()

Los dos primeros pueden agotar toda la memoria disponible y el último mantiene el agotamiento ...

Recientemente hubo una discusión sobre esto en security.stackexchange.com

funciones que pueden usarse para la ejecución de código arbitrario

Bueno, eso reduce un poco el alcance, pero dado que 'imprimir' se puede usar para inyectar javascript (y, por lo tanto, robar sesiones, etc.) todavía es algo arbitrario.

no es para enumerar funciones que deberían estar en la lista negra o no permitidas. Más bien, me gustaría tener una lista grepable

Ese es un enfoque sensato.

Sin embargo, considere escribir su propio analizador: muy pronto encontrará que un enfoque basado en grep se sale de control (awk sería un poco mejor). ¡Muy pronto también comenzarás a desear haber implementado una lista blanca también!

Además de los obvios, recomendaría marcar cualquier cosa que incluya un argumento con cualquier cosa que no sea un literal de cadena. Cuidado con __autoload () también.

Me temo que mi respuesta podría ser demasiado negativa, pero ...

En mi humilde opinión, todas las funciones y métodos disponibles pueden usarse con fines nefastos. Piense en ello como un efecto de goteo de nefasto: una variable se asigna a un usuario o entrada remota, la variable se usa en una función, el valor de retorno de la función se usa en una propiedad de clase, la propiedad de clase se usa en una función de archivo, Etcétera. Recuerde: una dirección IP falsificada o un ataque man-in-the-middle pueden explotar todo su sitio web.

Su mejor apuesta es a rastro de principio a fin cualquier usuario posible o de entrada remota, a partir de $_SERVER, $_GET, $_POST, $_FILE, $_COOKIE, include(some remote file)( si interruptores igual al número de funciones y métodos en PHP (incluyendo definido por el usuario).allow_url_fopen está encendido), todas las demás funciones / clases se ocupan de archivos remotos, etc. programáticamente construir un perfil de pila-trace de cada valor suministrado por usuario o remoto. Esto se puede hacer programáticamente obteniendo todas las instancias repetidas de la variable asignada y las funciones o métodos en los que se usa, luego compilando recursivamente una lista de todas las ocurrencias de esas funciones / métodos, y así sucesivamente. Examínelo para asegurarse de que primero pasa por las funciones de filtrado y validación adecuadas en relación con todas las demás funciones que toca. Esto es, por supuesto, un examen manual, de lo contrario, tendrá un número total decase

Alternativamente, para manejar solo la entrada del usuario, haga que se inicialice una clase de controlador estático al comienzo de todos los scripts que 1) valida y almacena todos los valores de entrada proporcionados por el usuario en una lista blanca de propósitos permitidos; 2) borra esa fuente de entrada (es decir $_SERVER = null). Puedes ver donde esto se pone un poco naziesco.

Aquí hay una lista de funciones que mi proveedor deshabilita por motivos de seguridad:

• ejecutivo
• dl
• show_source
• apache_note
• apache_setenv
• closelog
• debugger_off
• debugger_on
• define_syslog_variables
• Escapeshellarg
• escapeshellcmd
• ini_restore
• Openlog
• pasar a través de
• pclose
• pcntl_exec
• popen
• proc_close
• proc_get_status
• proc_nice
• proc_open
• proc_terminate
• shell_exec
• syslog
• sistema
• url_exec

La mayoría de los ataques en el código utilizan múltiples fuentes de acceso, o múltiples pasos para ejecutarse. Buscaría no solo un código o método que tenga código malicioso, sino todos los métodos, funciones que lo ejecuten o lo llamen. La mejor seguridad también incluiría la codificación y validación de los datos del formulario a medida que entran y salen.

Tenga cuidado también con la definición de variables del sistema, que luego se pueden llamar desde cualquier función o método en el código.

Se descubrieron varios desbordamientos de búfer utilizando funciones de caracteres de 4 bits que interpretan el texto. htmlentities () htmlspecialchars ()

estaban en la parte superior, una buena defensa es usar mb_convert_encoding () para convertir a codificación única antes de la interpretación.

Puede encontrar una lista actualizada continuamente de sumideros confidenciales (funciones php explotables) y sus parámetros en RIPS /config/sinks.php, un analizador de código fuente estático para vulnerabilidades en aplicaciones PHP que también detecta puertas traseras PHP.