diff --git a/SUMMARY.md b/SUMMARY.md
index 1cc896174..469469af5 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -725,6 +725,7 @@
* [Ret2plt](binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md)
* [Ret2ret & Reo2pop](binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2ret.md)
* [CET & Shadow Stack](binary-exploitation/common-binary-protections-and-bypasses/cet-and-shadow-stack.md)
+ * [Libc Protections](binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md)
* [Memory Tagging Extension (MTE)](binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md)
* [No-exec / NX](binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md)
* [PIE](binary-exploitation/common-binary-protections-and-bypasses/pie/README.md)
diff --git a/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md b/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
new file mode 100644
index 000000000..e0ec1c380
--- /dev/null
+++ b/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md
@@ -0,0 +1,108 @@
+# Protections Libc
+
+
+
+Apprenez le piratage AWS de zéro à héros avechtARTE (Expert en équipe rouge AWS de HackTricks)!
+
+Autres façons de soutenir HackTricks :
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+
+
+## Application de l'alignement des tranches
+
+**Malloc** alloue de la mémoire par groupes de **8 octets (32 bits) ou 16 octets (64 bits)**. Cela signifie que la fin des tranches dans les systèmes 32 bits doit être alignée sur **0x8**, et dans les systèmes 64 bits sur **0x0**. La fonctionnalité de sécurité vérifie que chaque tranche s'aligne correctement à ces emplacements spécifiques avant d'utiliser un pointeur d'un bac.
+
+### Avantages en termes de sécurité
+
+L'application de l'alignement des tranches dans les systèmes 64 bits améliore considérablement la sécurité de Malloc en **limitant le placement des tranches falsifiées à seulement 1 adresse sur 16**. Cela complique les efforts d'exploitation, en particulier dans les scénarios où l'utilisateur a un contrôle limité sur les valeurs d'entrée, rendant les attaques plus complexes et plus difficiles à exécuter avec succès.
+
+* **Attaque Fastbin sur \_\_malloc\_hook**
+
+Les nouvelles règles d'alignement dans Malloc contrecarrent également une attaque classique impliquant le `__malloc_hook`. Auparavant, les attaquants pouvaient manipuler les tailles de tranche pour **écraser ce pointeur de fonction** et obtenir une **exécution de code**. Désormais, l'exigence stricte d'alignement garantit que de telles manipulations ne sont plus viables, fermant ainsi une voie d'exploitation courante et améliorant la sécurité globale.
+
+## Mélange de pointeurs sur les fastbins et tcache
+
+Le **mélange de pointeurs** est une amélioration de sécurité utilisée pour protéger les **pointeurs Fd fastbin et tcache** dans les opérations de gestion de mémoire. Cette technique aide à prévenir certains types de tactiques d'exploitation de mémoire, en particulier celles qui ne nécessitent pas d'informations de mémoire divulguées ou qui manipulent directement les emplacements mémoire par rapport à des positions connues (écrasements **relatifs**).
+
+Le cœur de cette technique est une formule d'obscurcissement :
+
+**`Nouveau_Ptr = (L >> 12) XOR P`**
+
+* **L** est l'**emplacement de stockage** du pointeur.
+* **P** est le **pointeur Fd fastbin/tcache** réel.
+
+La raison du décalage des bits de l'emplacement de stockage (L) de 12 bits vers la droite avant l'opération XOR est critique. Cette manipulation adresse une vulnérabilité inhérente à la nature déterministe des 12 bits les moins significatifs des adresses mémoire, qui sont généralement prévisibles en raison des contraintes de l'architecture du système. En décalant les bits, la partie prévisible est éliminée de l'équation, améliorant le caractère aléatoire du nouveau pointeur mélangé et protégeant ainsi contre les attaques qui reposent sur la prévisibilité de ces bits.
+
+Ce pointeur mélangé exploite le caractère aléatoire existant fourni par la **Randomisation de l'Agencement de l'Espace d'Adresses (ASLR)**, qui randomise les adresses utilisées par les programmes pour rendre difficile aux attaquants de prédire la disposition mémoire d'un processus.
+
+**Démêler** le pointeur pour récupérer l'adresse d'origine implique d'utiliser la même opération XOR. Ici, le pointeur mélangé est traité comme P dans la formule, et lorsqu'il est XORé avec l'emplacement de stockage inchangé (L), cela révèle le pointeur d'origine. Cette symétrie dans le mélange et le démélange garantit que le système peut encoder et décoder efficacement les pointeurs sans surcharge significative, tout en augmentant considérablement la sécurité contre les attaques qui manipulent les pointeurs mémoire.
+
+### Avantages en termes de sécurité
+
+Le mélange de pointeurs vise à **empêcher les écrasements partiels et complets de pointeurs dans la gestion du tas**, une amélioration significative en termes de sécurité. Cette fonctionnalité impacte les techniques d'exploitation de plusieurs manières :
+
+1. **Prévention des écrasements relatifs de Bye Byte** : Auparavant, les attaquants pouvaient modifier une partie d'un pointeur pour **rediriger les tranches du tas vers des emplacements différents sans connaître les adresses exactes**, une technique évidente dans l'exploit **House of Roman** sans fuite. Avec le mélange de pointeurs, de tels écrasements relatifs **sans fuite de tas nécessitent désormais une force brute**, réduisant considérablement leur probabilité de succès.
+2. **Difficulté accrue des attaques Fastbin/Tcache Bin** : Les attaques courantes qui écrasent les pointeurs de fonction (comme `__malloc_hook`) en manipulant les entrées fastbin ou tcache sont entravées. Par exemple, une attaque pourrait impliquer la divulgation d'une adresse LibC, la libération d'une tranche dans le tcache bin, puis l'écrasement du pointeur Fd pour le rediriger vers `__malloc_hook` pour une exécution de code arbitraire. Avec le mélange de pointeurs, ces pointeurs doivent être correctement mélangés, **nécessitant une fuite de tas pour une manipulation précise**, élevant ainsi la barrière d'exploitation.
+3. **Nécessité de fuites de tas dans des emplacements non-tas** : Créer une fausse tranche dans des zones non-tas (comme la pile, la section .bss ou PLT/GOT) nécessite désormais également une fuite de tas en raison du besoin de mélange de pointeurs. Cela étend la complexité de l'exploitation de ces zones, similaire à l'exigence de manipulation des adresses LibC.
+4. **La fuite d'adresses de tas devient plus difficile** : Le mélange de pointeurs restreint l'utilité des pointeurs Fd dans les bacs fastbin et tcache en tant que sources de fuites d'adresses de tas. Cependant, les pointeurs dans les bacs non triés, petits et grands restent non mélangés, donc toujours utilisables pour la fuite d'adresses. Ce changement pousse les attaquants à explorer ces bacs pour des informations exploitables, bien que certaines techniques permettent toujours de démêler les pointeurs avant une fuite, bien que sous contraintes.
+
+### **Démêler les pointeurs avec une fuite de tas**
+
+{% hint style="danger" %}
+Pour une meilleure explication du processus, [**consultez le message original ici**](https://maxwelldulin.com/BlogPost?post=5445977088).
+{% endhint %}
+
+### Aperçu de l'algorithme
+
+La formule utilisée pour mélanger et démêler les pointeurs est :
+
+**`Nouveau_Ptr = (L >> 12) XOR P`**
+
+Où **L** est l'emplacement de stockage et **P** est le pointeur Fd. Lorsque **L** est décalé vers la droite de 12 bits, il expose les bits les plus significatifs de **P**, en raison de la nature de **XOR**, qui produit 0 lorsque les bits sont XORés avec eux-mêmes.
+
+**Étapes clés de l'algorithme :**
+
+1. **Fuite initiale des bits les plus significatifs** : En XORant le décalage de **L** avec **P**, vous obtenez efficacement les 12 bits supérieurs de **P** car la partie décalée de **L** sera zéro, laissant les bits correspondants de **P** inchangés.
+2. **Récupération des bits du pointeur** : Comme XOR est réversible, connaître le résultat et l'un des opérandes vous permet de calculer l'autre opérande. Cette propriété est utilisée pour déduire l'ensemble complet de bits pour **P** en XORant successivement des ensembles de bits connus avec des parties du pointeur mélangé.
+3. **Démêlage itératif** : Le processus est répété, chaque fois en utilisant les bits de **P** nouvellement découverts de l'étape précédente pour décoder le segment suivant du pointeur mélangé, jusqu'à ce que tous les bits soient récupérés.
+4. **Gestion des bits déterministes** : Les 12 derniers bits de **L** sont perdus en raison du décalage, mais ils sont déterministes et peuvent être reconstruits après le processus.
+
+Vous pouvez trouver une implémentation de cet algorithme ici : [https://github.com/mdulin2/mangle](https://github.com/mdulin2/mangle)
+## Garde de pointeur
+
+La garde de pointeur est une technique de mitigation des exploits utilisée dans glibc pour protéger les pointeurs de fonction stockés, en particulier ceux enregistrés par des appels de bibliothèque tels que `atexit()`. Cette protection implique de brouiller les pointeurs en les XORant avec un secret stocké dans les données du thread (`fs:0x30`) et en appliquant une rotation bit à bit. Ce mécanisme vise à empêcher les attaquants de détourner le flux de contrôle en écrivant sur les pointeurs de fonction.
+
+### **Contourner la Garde de Pointeur avec une fuite**
+
+1. **Compréhension des Opérations de Garde de Pointeur :** Le brouillage des pointeurs est effectué en utilisant la macro `PTR_MANGLE` qui XOR le pointeur avec un secret de 64 bits puis effectue une rotation gauche de 0x11 bits. L'opération inverse pour récupérer le pointeur d'origine est gérée par `PTR_DEMANGLE`.
+2. **Stratégie d'Attaque :** L'attaque est basée sur une approche de texte clair connu, où l'attaquant doit connaître à la fois la version originale et la version brouillée d'un pointeur pour déduire le secret utilisé pour le brouillage.
+3. **Exploitation des Textes Clairs Connus :**
+* **Identification des Pointeurs de Fonction Fixes :** En examinant le code source de glibc ou les tables de pointeurs de fonction initialisées (comme `__libc_pthread_functions`), un attaquant peut trouver des pointeurs de fonction prévisibles.
+* **Calcul du Secret :** En utilisant un pointeur de fonction connu tel que `__pthread_attr_destroy` et sa version brouillée de la table de pointeurs de fonction, le secret peut être calculé en effectuant une rotation inverse (rotation droite) du pointeur brouillé puis en le XORant avec l'adresse de la fonction.
+4. **Textes Clairs Alternatifs :** L'attaquant peut également expérimenter en brouillant des pointeurs avec des valeurs connues comme 0 ou -1 pour voir si cela produit des motifs identifiables en mémoire, révélant potentiellement le secret lorsque ces motifs sont trouvés dans les vidages mémoire.
+5. **Application Pratique :** Après avoir calculé le secret, un attaquant peut manipuler les pointeurs de manière contrôlée, contournant essentiellement la protection de la Garde de Pointeur dans une application multi-thread avec la connaissance de l'adresse de base de la libc et la capacité de lire des emplacements mémoire arbitraires.
+
+## Références
+
+* [https://maxwelldulin.com/BlogPost?post=5445977088](https://maxwelldulin.com/BlogPost?post=5445977088)
+* [https://blog.infosectcbr.com.au/2020/04/bypassing-pointer-guard-in-linuxs-glibc.html?m=1](https://blog.infosectcbr.com.au/2020/04/bypassing-pointer-guard-in-linuxs-glibc.html?m=1)
+
+
+
+Apprenez le piratage AWS de zéro à héros avechtARTE (HackTricks AWS Red Team Expert)!
+
+D'autres façons de soutenir HackTricks :
+
+* Si vous voulez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+
diff --git a/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/macos-installers-abuse.md b/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/macos-installers-abuse.md
index 3267cad35..8e0d288d8 100644
--- a/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/macos-installers-abuse.md
+++ b/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/macos-installers-abuse.md
@@ -18,14 +18,14 @@ Autres façons de soutenir HackTricks :
Un **package d'installation macOS** (également connu sous le nom de fichier `.pkg`) est un format de fichier utilisé par macOS pour **distribuer des logiciels**. Ces fichiers sont comme une **boîte qui contient tout ce dont un logiciel** a besoin pour s'installer et fonctionner correctement.
-Le fichier du package est en fait une archive qui contient une **hiérarchie de fichiers et de répertoires qui seront installés sur la cible**. Il peut également inclure des **scripts** pour effectuer des tâches avant et après l'installation, comme la configuration des fichiers ou le nettoyage des anciennes versions du logiciel.
+Le fichier du package est en fait une archive qui contient une **hiérarchie de fichiers et de répertoires qui seront installés sur la cible**. Il peut également inclure des **scripts** pour effectuer des tâches avant et après l'installation, comme la configuration des fichiers de configuration ou le nettoyage des anciennes versions du logiciel.
### Hiérarchie
-- **Distribution (xml)** : Personnalisations (titre, texte de bienvenue...) et scripts/vérifications d'installation
-- **PackageInfo (xml)** : Informations, exigences d'installation, emplacement d'installation, chemins vers les scripts à exécuter
+- **Distribution (xml)** : Personnalisations (titre, texte de bienvenue...) et vérifications de script/installation
+- **PackageInfo (xml)** : Infos, exigences d'installation, emplacement d'installation, chemins vers les scripts à exécuter
- **Liste des matériaux (bom)** : Liste des fichiers à installer, mettre à jour ou supprimer avec les autorisations de fichier
- **Charge utile (archive CPIO compressée gzip)** : Fichiers à installer dans l'emplacement d'installation à partir de PackageInfo
- **Scripts (archive CPIO compressée gzip)** : Scripts d'installation pré et post et autres ressources extraites vers un répertoire temporaire pour l'exécution.
@@ -50,27 +50,31 @@ Pour visualiser le contenu de l'installateur sans le décompresser manuellement,
Les fichiers DMG, ou images disque Apple, sont un format de fichier utilisé par macOS d'Apple pour les images disque. Un fichier DMG est essentiellement une **image disque montable** (il contient son propre système de fichiers) qui contient des données de bloc brut généralement compressées et parfois chiffrées. Lorsque vous ouvrez un fichier DMG, macOS le **monte comme s'il s'agissait d'un disque physique**, vous permettant d'accéder à son contenu.
+{% hint style="danger" %}
+Notez que les installateurs **`.dmg`** prennent en charge **tant de formats** que par le passé, certains d'entre eux contenant des vulnérabilités ont été abusés pour obtenir une **exécution de code kernel**.
+{% endhint %}
+
### Hiérarchie
-La hiérarchie d'un fichier DMG peut être différente en fonction du contenu. Cependant, pour les DMG d'applications, elle suit généralement cette structure :
+La hiérarchie d'un fichier DMG peut être différente en fonction du contenu. Cependant, pour les DMG d'application, elle suit généralement cette structure :
-* Niveau supérieur : C'est la racine de l'image disque. Il contient souvent l'application et éventuellement un lien vers le dossier Applications.
-* Application (.app) : Il s'agit de l'application réelle. Dans macOS, une application est généralement un package qui contient de nombreux fichiers et dossiers individuels qui composent l'application.
-* Lien vers Applications : Il s'agit d'un raccourci vers le dossier Applications dans macOS. Le but de ceci est de faciliter l'installation de l'application. Vous pouvez faire glisser le fichier .app vers ce raccourci pour installer l'application.
+- Niveau supérieur : C'est la racine de l'image disque. Il contient souvent l'application et éventuellement un lien vers le dossier Applications.
+- Application (.app) : Il s'agit de l'application réelle. Dans macOS, une application est généralement un package qui contient de nombreux fichiers et dossiers individuels qui composent l'application.
+- Lien vers Applications : Il s'agit d'un raccourci vers le dossier Applications dans macOS. Le but de ceci est de faciliter l'installation de l'application. Vous pouvez faire glisser le fichier .app vers ce raccourci pour installer l'application.
## Privilège élevé via abus de pkg
### Exécution à partir de répertoires publics
-Si un script d'installation préalable ou postérieur exécute par exemple à partir de **`/var/tmp/Installerutil`**, et qu'un attaquant peut contrôler ce script, il peut alors escalader les privilèges chaque fois qu'il est exécuté. Ou un autre exemple similaire :
+Si un script d'installation pré ou post exécute par exemple à partir de **`/var/tmp/Installerutil`**, et qu'un attaquant pouvait contrôler ce script, il pourrait escalader les privilèges chaque fois qu'il est exécuté. Ou un autre exemple similaire :
-
+
### AuthorizationExecuteWithPrivileges
-Il s'agit d'une [fonction publique](https://developer.apple.com/documentation/security/1540038-authorizationexecutewithprivileg) que plusieurs installateurs et mises à jour appelleront pour **exécuter quelque chose en tant que root**. Cette fonction accepte le **chemin** du **fichier** à **exécuter** en tant que paramètre, cependant, si un attaquant peut **modifier** ce fichier, il pourra **abuser** de son exécution avec les privilèges root pour **escalader les privilèges**.
+Il s'agit d'une [fonction publique](https://developer.apple.com/documentation/security/1540038-authorizationexecutewithprivileg) que plusieurs installateurs et mises à jour appelleront pour **exécuter quelque chose en tant que root**. Cette fonction accepte le **chemin** du **fichier** à **exécuter** en tant que paramètre, cependant, si un attaquant pouvait **modifier** ce fichier, il serait capable d'**abuser** de son exécution avec les privilèges root pour **escalader les privilèges**.
```bash
# Breakpoint in the function to check wich file is loaded
(lldb) b AuthorizationExecuteWithPrivileges
@@ -82,7 +86,7 @@ Pour plus d'informations, consultez cette présentation : [https://www.youtube.c
Si un installateur écrit dans `/tmp/fixedname/bla/bla`, il est possible de **créer un montage** sur `/tmp/fixedname` sans propriétaires afin de **modifier n'importe quel fichier pendant l'installation** pour abuser du processus d'installation.
-Un exemple de ceci est **CVE-2021-26089** qui a réussi à **écraser un script périodique** pour obtenir une exécution en tant que root. Pour plus d'informations, consultez la présentation : [**OBTS v4.0: "Mont(agne) de Bugs" - Csaba Fitzl**](https://www.youtube.com/watch?v=jSYPazD4VcE)
+Un exemple de cela est **CVE-2021-26089** qui a réussi à **écraser un script périodique** pour obtenir une exécution en tant que root. Pour plus d'informations, consultez la présentation : [**OBTS v4.0: "Mont(agne) de Bugs" - Csaba Fitzl**](https://www.youtube.com/watch?v=jSYPazD4VcE)
## pkg en tant que logiciel malveillant
@@ -90,16 +94,17 @@ Un exemple de ceci est **CVE-2021-26089** qui a réussi à **écraser un script
Il est possible de simplement générer un fichier **`.pkg`** avec des **scripts de pré et post-installation** sans aucune charge utile.
-### JS dans le fichier xml de distribution
+### JS dans le xml de distribution
-Il est possible d'ajouter des balises **`
.png)
