r2 <binario> - abrir le binario con radare2
aaaa --------- analizar al mismo
s sym.main --- ir a main
VV ----------- entrar en modo gráfico

iI -- info sobre el binario, arquitectura, stripped, nx etc
ir -- funciones que se cargan en runtime
is -- símbolos del binario (debugeando)
iz -- strings en la sección data
izz - strings en todo el binario
il -- librerías cargadas dinamicamente

axt @@ str.* ------- referencia a los strings
axt @@c:iz --------- idem anterior
axt [addr] --------- encontrar referencias a esta dirección (de datos o código)
axt sym.imp.printf - muestra las llamadas a printf
afi ---------------- info sobre la función actual

afl ------------- listar las funciones
s <dirección> --- ir a dirección
sr <registro> --- ir a dirección en el registro
s sym.<función> - ir a función

V ----------- pasar a modo visual
pp ---------- pasar distintos formatos
j ----------- abajo
k ----------- arriba
[enter] ----- seguir jump o el call
: ----------- entrar un comando

VV --------- pasar a modo gráfico
pp --------- pasar distintos formatos
h ---------- izquierda
l ---------- derecha
j ---------- abajo
k ---------- arriba
g[a,b,c..] - seguir el jump o el call

V!

c -------- seleccionar una linea
; coment - agregar un comentario
;- ------- quitar un comentario

c --------------- seleccionar una linea
f flag_name ----- agregar una flag
f-flag_name ----- quitar una flag
fs -------------- listar tipos de flags
fs flag-type; f - listar flags del tipo flag-type

r-num - quitar num bytes
r+num - agregar num bytes

afvn <old> <new> (variables)
afn <new>        (funciones)

px <len> @ <registro | addr> - Print heXadecimal
ps <len> @ <direccion> ------- muestra string

w <string> [@addr] -- escribe un string en addr o en posición actual
wz <string> [@addr] - escribe un string agregando un null-byte al final
wa <assembler> ------ separar instucciones con ';' y usar '"' alrededor del comando
w0 <len> [@addr] ---- escribe 'len' null bytes
dr <registro> = <hex>

oo+ ----------- reabrir binario en modo lectura-escritura
[ir a address]
[usar wx o wa]
oo ------------ reabrir binario en modo lectura

Ps [file] ---- guarda proyecto actual
Pl ----------- lista los proyectos
Po <proyect> - abre proyecto

(nombre, accion1, accion2,..) - crear una macro
(-nombre) --------------------- borrar macro
.(nombre) --------------------- ejecutar una macro
(* ---------------------------- listar macros
"(foo x y,pd $0; s +$1)" ------ crear una macro con parámetros (los '"' son por el ';')
.(foo 5 6) -------------------- ejecutar una macro con parámetros

? 0x88
? 123

! <comando>

r2 -d <bin> arg1 arg2 - debugear bin con params
r2 -d <pid> ----------- debug proceso existente
aaaa ------------------ analizar
dcu main -------------- avanzar hasta main

e??dbg ------------------ listar las configuraciones existentes
e dbg.<conf> ------------ ver valor asignado a la configuración
e dbg.<conf>=true|false - asignar el valor de true o false

db ------------- listar break points
db <addr> (F2) - agregar break point 
db - <addr> ---- quitar break point
s  (F7) -------- single-step
S  (F8) -------- step-over
dc (F9) -------- continuar
dcu <fun|addr> - continuar hasta <fun|addr>

drx? --------------------------- Hardware breakpoints commands
drx ---------------------------- listar debugging registers
drx <num> <addr> <len> <r|w|x> - break point al leer|escribir|ejecutar entre addr y addr+len
dc (F9) ------------------------ continuar

dbt - mostrar backtrace
dm -- mostrar mapeo de memoria
dr -- muestra los registros
drr - muestra los registros con más info

dr rip = 0x123

r2 -d ./binary -e dbg.profile=foo.rr2

#!/usr/bin/rarun2
program=./bin
arg1=algo
arg2=algo2
stdin=./somefile1.txt
stdout=./somefile2.txt
preload=libc.so
listen=<port> -> socat TCP-LISTEN:<port>,reuseaddr,fork EXEC:"./bin"

f foo = 1024 - le pones un alias
s rsp -------- te vas al stack
ds ----------- step
dso ---------- step over
dm ----------- memory maps
dd ----------- file descriptors
sr rip ------- actualiza la current address de radare
pd n --------- imprime el dessamsemble the n instrucciones
dr zf=1 ------ hace que el flag zero sea 1

rasm2 -L                         -> muestra las arquitecturas soportadas  
rasm2 -a x86 -b 32 'assembler'   -> arquitectura de ejemplo
rasm2 'assembler'

rasm2 -d <opcodes>

rafind2 [-zZXnrhv] [-b size] [-f from] [-t to] [-[m|s|e] str] [-x hex] file

rafind2  -s <string>  file

rafind2  -e <regex>  file

rafind2  -x <hex>  file

rax2 <0x...>

rax2 <decimal>

rax2 -b <binario>

rax2 ...b

rax2 -S <string>

ragg2 -P <num> -r > pattern.txt

#!/usr/bin/rarun2
stdin=./pattern.txt

r2 -R profile.rr2 -d <binario>
dc
wopO rip

$ rabin2 -I ./program - Binary info (same as i from radare2 shell)
ii [q] ---------------- Imports
?v sym.imp.func_name -- Get address of func_name@PLT
?v reloc.func_name ---- Get address of func_name@GOT
ie [q] ---------------- Get address of Entrypoint
iS -------------------- Show sections with permissions (r/x/w)
i~canary -------------- Check canaries
i~pic ----------------- Check if Position Independent Code
i~nx ------------------ Check if compiled with NX

dm --------------------------- Show memory maps
dmm -------------------------- List modules (libraries, binaries loaded in memory)
dmi [addr|libname] [symname] - List symbols of target lib

e search.* - Edit searching configuration
/? --------- List search subcommands
/ string --- Search string in memory/binary
/x hex ----- Search hex pairs in memory/binary
/R [?] ----- Search for ROP gadgets
/R/ -------- Search for ROP gadgets with a regular expressions

dc --------- Continue execution
dcu addr --- Continue execution until address
dcr -------- Continue until ret (uses step over)
dbt [?] ---- Display backtrace based on dbg.btdepth and dbg.btalgo
doo [args] - Reopen in debugger mode with args
ds --------- Step one instruction
dso -------- Step over

pdf @ addr - Print the assembly of a function in the given offset
V ---------- Visual mode, use p/P to toggle between different modes
VV --------- Visual Graph mode, navigating through ASCII graphs
V! --------- Visual panels mode. Very useful for exploitation