radare2

root@kali:~# r2 -h
Usage: r2 [-ACdfjLMnNqStuvwzX] [-P patch] [-p prj] [-a arch] [-b bits] [-c cmd]
          [-s addr] [-B baddr] [-m maddr] [-i script] [-e k=v] file|pid|-|--|=
 --           run radare2 without opening any file
 -            same as 'r2 malloc://512'
 =            read file from stdin (use -i and -c to run cmds)
 -=           perform !=! command to run all commands remotely
 -0           print \x00 after init and every command
 -1           redirect stderr to stdout
 -2           close stderr file descriptor (silent warning messages)
 -a [arch]    set asm.arch
 -A           run 'aaa' command to analyze all referenced code
 -b [bits]    set asm.bits
 -B [baddr]   set base address for PIE binaries
 -c 'cmd..'   execute radare command
 -C           file is host:port (alias for -c+=http://%s/cmd/)
 -d           debug the executable 'file' or running process 'pid'
 -D [backend] enable debug mode (e cfg.debug=true)
 -e k=v       evaluate config var
 -f           block size = file size
 -F [binplug] force to use that rbin plugin
 -h, -hh      show help message, -hh for long
 -H ([var])   display variable
 -i [file]    run rlang program, r2script file or load plugin
 -I [file]    run script file before the file is opened
 -j           use json for -v, -L and maybe others
 -k [OS/kern] set asm.os (linux, macos, w32, netbsd, ...)
 -L, -LL      list supported IO plugins (-LL list core plugins)
 -m [addr]    map file at given address (loadaddr)
 -M           do not demangle symbol names
 -n, -nn      do not load RBin info (-nn only load bin structures)
 -N           do not load user settings and scripts
 -NN          do not load any script or plugin
 -q           quiet mode (no prompt) and quit after -i
 -qq          quit after running all -c and -i
 -Q           quiet mode (no prompt) and quit faster (quickLeak=true)
 -p [prj]     use project, list if no arg, load if no file
 -P [file]    apply rapatch file and quit
 -r [rarun2]  specify rarun2 profile to load (same as -e dbg.profile=X)
 -R [rr2rule] specify custom rarun2 directive (uses base64 dbg.profile)
 -s [addr]    initial seek
 -S           start r2 in sandbox mode
 -t           load rabin2 info in thread
 -u           set bin.filter=false to get raw sym/sec/cls names
 -v, -V       show radare2 version (-V show lib versions)
 -w           open file in write mode
 -x           open without exec-flag (asm.emu will not work), See io.exec
 -X           same as -e bin.usextr=false (useful for dyldcache)
 -z, -zz      do not load strings or load them even in raw

root@kali:~# r2agent -h
Usage: r2agent [-adhsLjv] [-p port]
  -a        listen for everyone (localhost by default)
  -d        run in daemon mode (background)
  -h        show this help message
  -s        run in sandbox mode
  -u        enable http authorization access
  -t        user:password authentication file
  -p [port] specify listening port (defaults to 8080)
  -L        list currently loaded r2 sessions and exit
  -v        show r2 version information and exit
  -j        output JSON when used with -v or -L

root@kali:~# r2pm -h
Usage: r2pm [-flags] [pkgs...]
Commands:
 -a [repository]   add or -delete external repository
 -c ([git/dir])    clear source cache (R2PM_GITDIR)
 -ci <pkgname>     clean + install
 -cp               clean the user's home plugin directory
 -d,doc [pkgname]  show documentation and source for given package
 -e [pkgname]      edit using $EDITOR the given package script
 -f                force operation (Use in combination of -U, -i, -u, ..)
 -gi <pkg>         global install (system-wide)
 -h                display this help message
 -H ([variable])   list all or selected r2pm environment variables
 -i <pkgname>      install/update package and its dependencies (see -c, -g)
 -I                information about the repository and installed packages
 -j                json output
 -l                list installed packages
 -q                be quiet
 -r [cmd ...args]  run shell command with R2PM_BINDIR in PATH
 -R <pkgname>      reload plugin (See R2PM_RELOAD code block package)
 -s [<keyword>]    search available packages in database matching a string
 -t [YYYY-MM-DD]   set a moment in time to pull the code from the git packages
 -u <pkgname>      uninstall package (see -f to force uninstall)
 -uci <pkgname>    uninstall + clean + install
 -ui <pkgname>     uninstall + install
 -U                download/initialize or update database (-f for a clean clone)
 -UU               same as -U but upgrade all the installed r2 plugins
 -v                show version

root@kali:~# r2r -h
Usage: r2r [-qvVnLi] [-C dir] [-F dir] [-f file] [-o file] [-s test] [-t seconds] [-j threads] [test file/dir | @test-type]
 -C [dir]     chdir before running r2r (default follows executable symlink + test/new
 -F [dir]     run fuzz tests (open and default analysis) on all files in the given dir
 -L           log mode (better printing for CI, logfiles, etc.)
 -V           verbose
 -f [file]    file to use for json tests (default is bins/elf/crackme0x00b)
 -g           run the tests specified via '// R2R' comments in modified source files
 -h           print this help
 -H           display environment variables
 -i           interactive mode
 -j [threads] how many threads to use for running tests concurrently (default is 8)
 -n           do nothing (don't run any test, just load/parse them)
 -o [file]    output test run information in JSON format to file
 -q           quiet
 -s [test]    set R2R_SKIP_(TEST)=1 to skip running that test type
 -S [0-100]   set R2R_SHALLOW=N to skip a random percentage of tests
 -t [seconds] timeout per test (default is (60*60))
 -u           do not git pull/clone test/bins (See R2R_OFFLINE)
 -v           show version

R2R_SKIP_ARCHOS=0  # do not run the arch-os-specific tests
R2R_SKIP_JSON=0    # do not run the JSON tests
R2R_SKIP_FUZZ=0    # do not run the fuzz tests
R2R_SKIP_UNIT=0    # do not run the unit tests
R2R_SKIP_CMD=0     # do not run the cmds tests
R2R_SKIP_ASM=0     # do not run the rasm2 tests
R2R_JOBS=8         # maximum parallel jobs
R2R_TIMEOUT=3600   # timeout after 1 minute (60 * 60)
R2R_OFFLINE=0      # same as passing -u
R2R_SHALLOW=0      # skip 0-100% random tests
R2R_RADARE2=radare2 # radare2 binary to launch

Supported test types: @asm @json @unit @fuzz @arch @cmd
OS/Arch for archos tests: linux-x86_64

root@kali:~# r2sdb -h
usage: sdb [-0cCdDehjJrtv|-D A B] [-|db] [.file]|[-=]|==||[-+][(idx)key[:json|=value] ..]
  -0      terminate results with \x00
  -c      count the number of keys database
  -C      create foo.{c,h} for embedding (uses gperf)
  -d      decode base64 from stdin
  -D      diff two databases
  -e      encode stdin as base64
  -g [..] grep expression
  -G      print database in gperf format
  -h      show this help
  -j      output in json
  -o [f]  output file name for -C -t
  -J      enable journaling
  -r      process .sdb.txt files in the given path
  -t      use textmode (for -C)
  -v      show version information
usage: sdb [-0cCdDehjJrtv|-D A B] [-|db] [.file]|[-=]|==||[-+][(idx)key[:json|=value] ..]

root@kali:~# rabin2 -h
Usage: rabin2 [-AcdeEghHiIjJlLMqrRsSUvVxzZ] [-@ at] [-a arch] [-b bits] [-B addr]
              [-C F:C:D] [-f str] [-m addr] [-n str] [-N m:M] [-P[-P] pdb]
              [-o str] [-O help] [-k query] [-D lang mangledsymbol] file
 -@ [addr]       show section, symbol or import at addr
 -A              list sub-binaries and their arch-bits pairs
 -a [arch]       set arch (x86, arm, .. or <arch>_<bits>)
 -b [bits]       set bits (32, 64 ...)
 -B [addr]       override base address (pie bins)
 -c              list classes
 -cc             list classes in header format
 -C [fmt:C:D]    create [elf,mach0,pe] with Code and Data hexpairs (see -a)
 -d              show debug/dwarf information
 -D lang name    demangle symbol name (-D all for bin.demangle=true)
 -e              program entrypoint
 -ee             constructor/destructor entrypoints
 -E              globally exportable symbols
 -f [str]        select sub-bin named str
 -F [binfmt]     force to use that bin plugin (ignore header check)
 -g              same as -SMZIHVResizcld -SS -SSS -ee (show all info)
 -G [addr]       load address . address to header
 -h              this help message
 -H              header fields
 -i              imports (symbols imported from libraries)
 -I              binary info
 -j              output in json
 -J ([var])      display variable
 -k [sdb-query]  run sdb query. for example: '*'
 -K [algo]       calculate checksums (md5, sha1, ..)
 -l              linked libraries
 -L [plugin]     list supported bin plugins or plugin details
 -m [addr]       show source line at addr
 -M              main (show address of main symbol)
 -n [str]        show section, symbol or import named str
 -N [min:max]    force min:max number of chars per string (see -z and -zz)
 -o [str]        output file/folder for write operations (out by default)
 -O [str]        write/extract operations (-O help)
 -p              show always physical addresses
 -P              show debug/pdb information
 -PP             download pdb file for binary
 -q              be quiet, just show fewer data
 -qq             show less info (no addr/size for -z for ex.)
 -Q              show load address used by dlopen (non-aslr libs)
 -r              radare output
 -R              relocations
 -s              symbols
 -S              sections
 -SS             segments
 -SSS            sections mapping to segments
 -t              display file hashes
 -T              display file signature
 -u              unfiltered (no rename duplicated symbols/sections)
 -U              resoUrces
 -v              display version and quit
 -V              show binary version information
 -w              display try/catch blocks
 -x              extract bins contained in file
 -X [fmt] [f] .. package in fat or zip the given files and bins contained in file
 -z              strings (from data section)
 -zz             strings (from raw bins [e bin.str.raw=1])
 -zzz            dump raw strings to stdout (for huge files)
 -Z              guess size of binary program
Environment:
R2_NOPLUGINS	                      # same as r2 -N. Dont load shared plugins
RABIN2_ARGS	                      # ignore cli and use these program arguments
RABIN2_CHARSET	e cfg.charset         # set default value charset for -z strings
RABIN2_CODESIGN_VERBOSE	                      # show codesign details at parse time
RABIN2_DEBASE64	e bin.str.debase64    # try to debase64 all strings
RABIN2_DEMANGLE	e bin.demangle        # dont demangle symbols if value is 0
RABIN2_DEMANGLE_CMD	e bin.demangle.cmd    # try to purge false positives
RABIN2_DEMANGLE_TRYLIB	e bin.demangle.trylib # load Swift libs to demangle (default: false)
RABIN2_LANG	e bin.lang            # assume lang for demangling
RABIN2_MACHO_NOFUNCSTARTS	                      # if set it will ignore the FUNCSTART information
RABIN2_MACHO_NOSWIFT	                      # avoid parsing the swift metadata
RABIN2_MACHO_SKIPFIXUPS	                      # do not parse the mach-o chained fixups
RABIN2_MAXSTRBUF	e bin.str.maxbuf      # specify maximum buffer size
RABIN2_PDBSERVER	e pdb.server          # use alternative PDB server
RABIN2_PREFIX	e bin.prefix          # prefix symbols/sections/relocs with a specific string
RABIN2_STRFILTER	e bin.str.filter      # r2 -qc 'e bin.str.filter=??' -
RABIN2_STRPURGE	e bin.str.purge       # try to purge false positives
RABIN2_SYMSTORE	e pdb.symstore        # path to downstream symbol store
RABIN2_VERBOSE	e bin.verbose         # show debugging messages from the parser

root@kali:~# radare2 -h
Usage: r2 [-ACdfjLMnNqStuvwzX] [-P patch] [-p prj] [-a arch] [-b bits] [-c cmd]
          [-s addr] [-B baddr] [-m maddr] [-i script] [-e k=v] file|pid|-|--|=
 --           run radare2 without opening any file
 -            same as 'r2 malloc://512'
 =            read file from stdin (use -i and -c to run cmds)
 -=           perform !=! command to run all commands remotely
 -0           print \x00 after init and every command
 -1           redirect stderr to stdout
 -2           close stderr file descriptor (silent warning messages)
 -a [arch]    set asm.arch
 -A           run 'aaa' command to analyze all referenced code
 -b [bits]    set asm.bits
 -B [baddr]   set base address for PIE binaries
 -c 'cmd..'   execute radare command
 -C           file is host:port (alias for -c+=http://%s/cmd/)
 -d           debug the executable 'file' or running process 'pid'
 -D [backend] enable debug mode (e cfg.debug=true)
 -e k=v       evaluate config var
 -f           block size = file size
 -F [binplug] force to use that rbin plugin
 -h, -hh      show help message, -hh for long
 -H ([var])   display variable
 -i [file]    run rlang program, r2script file or load plugin
 -I [file]    run script file before the file is opened
 -j           use json for -v, -L and maybe others
 -k [OS/kern] set asm.os (linux, macos, w32, netbsd, ...)
 -L, -LL      list supported IO plugins (-LL list core plugins)
 -m [addr]    map file at given address (loadaddr)
 -M           do not demangle symbol names
 -n, -nn      do not load RBin info (-nn only load bin structures)
 -N           do not load user settings and scripts
 -NN          do not load any script or plugin
 -q           quiet mode (no prompt) and quit after -i
 -qq          quit after running all -c and -i
 -Q           quiet mode (no prompt) and quit faster (quickLeak=true)
 -p [prj]     use project, list if no arg, load if no file
 -P [file]    apply rapatch file and quit
 -r [rarun2]  specify rarun2 profile to load (same as -e dbg.profile=X)
 -R [rr2rule] specify custom rarun2 directive (uses base64 dbg.profile)
 -s [addr]    initial seek
 -S           start r2 in sandbox mode
 -t           load rabin2 info in thread
 -u           set bin.filter=false to get raw sym/sec/cls names
 -v, -V       show radare2 version (-V show lib versions)
 -w           open file in write mode
 -x           open without exec-flag (asm.emu will not work), See io.exec
 -X           same as -e bin.usextr=false (useful for dyldcache)
 -z, -zz      do not load strings or load them even in raw

root@kali:~# radiff2 -h
Usage: radiff2 [-options] [-A[A]] [-B #] [-g sym] [-m graph_mode][-t %] [file] [file]
  -a [arch]  specify architecture plugin to use (x86, arm, ..)
  -A [-A]    run aaa or aaaa after loading each binary (see -C)
  -b [bits]  specify register size for arch (16 (thumb), 32, 64, ..)
  -B [baddr] define the base address to add the offsets when listing
  -c [cmd]   run given command on every RCore instance
  -C         graphdiff code (columns: off-A, match-ratio, off-B) (see -A)
  -d         use delta diffing
  -D         show disasm instead of hexpairs
  -e [k=v]   set eval config var value for all RCore instances
  -f [help]  select output format (see '-f help' for details)
  -g [arg]   graph diff of [sym] or functions in [off1,off2]
  -i [help]  compare bin information (symbols, strings, classes, ..)
  -j         output in json format (see -f json)
  -l [addr]  specify final offset (length) for diffing, same format as -o
  -m [mode]  choose the graph output mode (aditsjJ)
  -n         count of changes
  -o [addr]  specify initial offset for diffing, can use A:B format
  -O         code diffing with opcode bytes only
  -p         use physical addressing (io.va=false) (only for radiff2 -AC)
  -q         quiet mode (disable colors, reduce output)
  -r         output in radare commands
  -s         compute edit distance (no substitution, Eugene W. Myers O(ND) diff algorithm)
  -ss        compute Levenshtein edit distance (substitution is allowed, O(N^2))
  -S [name]  sort code diff (name, namelen, addr, size, type, dist) (only for -C or -g)
  -t [0-100] set threshold for code diff (default is 70%)
  -T         analyze files in threads (EXPERIMENTAL, 30% faster and crashy)
  -x         show two column hexdump diffing
  -X         use xpatch format for the diffing output
  -u         unified output (---+++)
  -U         unified output using system 'diff'
  -v         show version information
  -V         be verbose (current only for -s)

root@kali:~# rafind2 -h
Usage: rafind2 [-mBXnzZhqv] [-a align] [-b sz] [-f/t from/to] [-[e|s|S] str] [-x hex] -|file|dir ..
 -a [align] only accept aligned hits
 -b [size]  set block size
 -B         use big endian instead of the little one (See -V)
 -c         disable colourful output (mainly for for -X)
 -e [regex] search for regex matches (can be used multiple times)
 -E         perform a search using an esil expression
 -f [from]  start searching from address 'from'
 -F [file]  read the contents of the file and use it as keyword
 -h         show this help
 -i         identify filetype (r2 -nqcpm file)
 -j         output in JSON
 -L         list all io plugins (same as r2 for now)
 -m         magic search, file-type carver
 -M [str]   set a binary mask to be applied on keywords
 -n         do not stop on read errors
 -r         print using radare commands
 -s [str]   search for a string (more than one string can be passed)
 -S [str]   search for a wide string (more than one string can be passed).
 -t [to]    stop search at address 'to'
 -q         quiet: fewer output do not show headings or filenames.
 -v         print version and exit
 -V [s:num | s:num1,num2] search for a value or range in the specified endian (-V 4:123 or -V 4:100,200)
 -x [hex]   search for hexpair string (909090) (can be used multiple times)
 -X         show hexdump of search results
 -z         search for zero-terminated strings
 -Z         show string found on each search hit

root@kali:~# ragg2 -h
Usage: ragg2 [-FOLsrxhvz] [-a arch] [-b bits] [-k os] [-o file] [-I path]
             [-i sc] [-E enc] [-B hex] [-c k=v] [-C file] [-p pad] [-q off]
             [-S string] [-f fmt] [-nN dword] [-dDw off:hex] [-e expr] file|f.asm|-
 -a [arch]       select architecture (x86, mips, arm)
 -b [bits]       register size (32, 64, ..)
 -B [hexpairs]   append some hexpair bytes
 -c [k=v]        set configuration options
 -C [file]       append contents of file
 -d [off:dword]  patch dword (4 bytes) at given offset
 -D [off:qword]  patch qword (8 bytes) at given offset
 -e [egg-expr]   take egg program from string instead of file
 -E [encoder]    use specific encoder. see -L
 -f [format]     output format (raw, c, pe, elf, mach0, python, javascript)
 -F              output native format (osx=mach0, linux=elf, ..)
 -h              show this help
 -H ([var])      display variable
 -i [shellcode]  include shellcode plugin, uses options. see -L
 -I [path]       add include path
 -k [os]         operating system's kernel (linux,bsd,osx,w32)
 -L              list all plugins (shellcodes and encoders)
 -n [dword]      append 32bit number (4 bytes)
 -N [dword]      append 64bit number (8 bytes)
 -o [file]       output file
 -O              use default output file (filename without extension or a.out)
 -p [padding]    add padding after compilation (padding=n10s32)
                 ntas : begin nop, trap, 'a', sequence
                 NTAS : same as above, but at the end
 -P [size]       prepend debruijn pattern
 -q [fragment]   debruijn pattern offset
 -r              show raw bytes instead of hexpairs
 -s              show assembler
 -S [string]     append a string
 -v              show version
 -w [off:hex]    patch hexpairs at given offset
 -x              execute
 -X [hexpairs]   execute rop chain, using the stack provided
 -z              output in C string syntax
R2_NOPLUGINS	do not load any plugin

root@kali:~# rahash2 -h
Usage: rahash2 [-BehjkLqrvX] [-b S] [-a A] [-c H] [-E A] [-s S] [-f O] [-t O] [file] ...
 -a algo     comma separated list of algorithms (default is 'sha256')
 -b bsize    specify the size of the block (instead of full file)
 -B          show per-block hash
 -c hash     compare with this hash
 -e          swap endian (use little endian)
 -E algo     encrypt. Use -S to set key and -I to set IV
 -D algo     decrypt. Use -S to set key and -I to set IV
 -f from     start hashing at given address
 -i num      repeat hash N iterations (f.ex: 3DES)
 -I iv       use give initialization vector (IV) (hexa or s:string)
 -j          output in json
 -J          new simplified json output (same as -jj)
 -S seed     use given seed (hexa or s:string) use ^ to prefix (key for -E)
             (- will slurp the key from stdin, the @ prefix points to a file
 -k          show hash using the openssh's randomkey algorithm
 -q          run in quiet mode (-qq to show only the hash)
 -L          list muta plugins (combines with -q, used by -a, -E and -D)
 -r          output radare commands
 -s string   hash this string instead of files
 -t to       stop hashing at given address
 -x hexstr   hash this hexpair string instead of files
 -X          output in hexpairs instead of binary/plain
 -v          show version information

root@kali:~# rapatch2 -h
Usage: rapatch2 [-p N] [-sv] [-R] [patchfile] ([targetfile])
  -p N       patch level, skip N directories
  -R         reverse patch
  -s         sandbox mode, disable scripts and r2 command execution
  -q         be quiet
  -v         show version

root@kali:~# rarun2 -h
Usage: rarun2 -v|-t|script.rr2 [directive ..]
program=/bin/ls
arg1=/bin
# arg2=hello
# arg3="hello\nworld"
# arg4=:048490184058104849
# arg5=:!ragg2 -p n50 -d 10:0x8048123
# arg6=@arg.txt
# arg7=@300@ABCD # 300 chars filled with ABCD pattern
# system=r2 -
# daemon=false
# aslr=no
setenv=FOO=BAR
# unsetenv=FOO
# clearenv=true
# envfile=environ.txt
timeout=3
# timeoutsig=SIGTERM # or 15
# connect=localhost:8080
# listen=8080
# pty=false
# fork=true
# bits=32
# pid=0
# pidfile=/tmp/foo.pid
# #sleep=0
# #maxfd=0
# #execve=false
# #maxproc=0
# #maxstack=0
# #core=false
# #stdio=blah.txt
# #stderr=foo.txt
# #stderrout=false
# stdout=foo.txt
# stdin=input.txt # or !program to redirect input from another program
# input=input.txt
# chdir=/
# chroot=/mnt/chroot
# libpath=$PWD:/tmp/lib
# r2preload=yes
# preload=/lib/libfoo.so # you can load more than one lib by using this directive many times
# setuid=2000
# seteuid=2000
# setgid=2001
# setegid=2001
# nice=5

root@kali:~# rasign2 -h
Usage: rasign2 [options] [file]
 -a               make signatures from all .o files in the provided .a file
 -A[AAA]          same as r2 -A, the more 'A's the more analysis is performed
 -f               interpret the file as a FLIRT .sig file and dump signatures
 -h               help menu
 -j               show signatures in json
 -i script.r2     execute this script in the 
 -o sigs.sdb      add signatures to file, create if it does not exist
 -q               quiet mode
 -r               show output in radare commands
 -S               perform operation on sdb signature file ('-o -' to save to same file)
 -s signspace     save all signatures under this signspace
 -c               add collision signatures before writing file
 -v               show version information
 -m               merge/overwrite signatures with same name
Examples:
  rasign2 -o libc.sdb libc.so.6

root@kali:~# rasm2 -h
Usage: rasm2 [-ACdDehHLBvw] [-a arch] [-b bits] [-s addr] [-S syntax]
   [-f file] [-o file] [-F fil:ter] [-i skip] [-l len] 'code'|hex|0101b|-
 -a [arch]    set architecture to assemble/disassemble (see -L)
 -A           show Analysis information from given hexpairs
 -b [bits]    set cpu register size (8, 16, 32, 64) (RASM2_BITS)
 -B           binary input/output (-l is mandatory for binary input)
 -c [cpu]     select specific CPU (depends on arch)
 -C           output in C format
 -d, -D       disassemble from hexpair bytes (-D show hexpairs)
 -e           use big endian instead of little endian
 -E           display ESIL expression (same input as in -d)
 -f [file]    read data from file
 -F [parser]  specify which parse filter use (see -LL)
 -h, -hh      show this help, -hh for long
 -H ([var])   display variable
 -i [len]     ignore/skip N bytes of the input buffer
 -j           output in json format
 -k [kernel]  select operating system (linux, windows, darwin, android, ios, ..)
 -l [len]     input/Output length
 -L ([name])  list RArch plugins: (a=asm, d=disasm, e=esil)
 -LL ([name]) list RAsm parse plugins
 -N           same as r2 -N (or R2_NOPLUGINS) (not load any plugin)
 -o [file]    output file name (rasm2 -Bf a.asm -o a)
 -p           run SPP over input for assembly
 -q           quiet mode
 -r           output in radare commands
 -s,-@ [addr] define initial start/seek address (default 0)
 -S [syntax]  select syntax (intel, att)
 -v           show version information
 -x           use hex dwords instead of hex pairs when assembling.
 -w           what's this instruction for? describe opcode
 If '-l' value is greater than output length, output is padded with nops
 If the last argument is '-' reads from stdin
Environment:
R2_NOPLUGINS	do not load shared plugins (speedup loading)
R2_LOG_LEVEL	change the log level
R2_DEBUG	if defined, show error messages and crash signal
R2_DEBUG_ASSERT	lldb -- r2 to get proper backtrace of the runtime assert
RASM2_ARCH	same as rasm2 -a
RASM2_BITS	same as rasm2 -b

root@kali:~# ravc2 -h
Usage: ravc2 [-qvh] [action] [args ...]
Flags:
 -q         quiet mode
 -v         show version
 -h         display this help message
 -H ([var]) display variable
 -j         json output
Actions:
 init       [git | rvc]          initialize a repository with the given vc
 branch     [name]               if a name is provided, create a branch with that name otherwise list branches
 commit     [message] [files...] commit the files with the message
 checkout   [branch]             set the current branch to the given branch
 status                        print a status message
 reset                         remove all uncommited changes
 log                           print all commits
RAVC2_USER	override cfg.user value to author commit

root@kali:~# rax2 -h
Usage: rax2 [-h|...] [- | expr ...] # convert between numeric bases
  int        ->  hex              ;  rax2 10
  hex        ->  int              ;  rax2 0xa
  -int       ->  hex              ;  rax2 -77
  -hex       ->  int              ;  rax2 0xffffffb3
  int        ->  bin              ;  rax2 b30
  int        ->  ternary          ;  rax2 t42
  bin        ->  int              ;  rax2 1010d
  ternary    ->  int              ;  rax2 1010dt
  float      ->  hex              ;  rax2 3.33f
  hex        ->  float            ;  rax2 Fx40551ed8
  oct        ->  hex              ;  rax2 35o
  hex        ->  oct              ;  rax2 Ox12 (O is a letter)
  bin        ->  hex              ;  rax2 1100011b
  hex        ->  bin              ;  rax2 Bx63
  ternary    ->  hex              ;  rax2 212t
  hex        ->  ternary          ;  rax2 Tx23
  raw        ->  hex              ;  rax2 -S < /binfile
  hex        ->  raw              ;  rax2 -s 414141
  -a         show ascii table     ;  rax2 -a
  -b <base>  output in <base>     ;  rax2 -b 10 0x46
  -c         output in C string   ;  rax2 -c 0x1234 # \x34\x12\x00\x00
  -C         dump as C byte array ;  rax2 -C < bytes
  -d         force integer        ;  rax2 -d 3 -> 3 instead of 0x3
  -e         swap endianness      ;  rax2 -e 0x33
  -D         base64 decode        ;  rax2 -D "aGVsbG8="
  -E         base64 encode        ;  rax2 -E "hello"
  -f         floating point       ;  rax2 -f 6.3+2.1
  -F         stdin slurp code hex ;  rax2 -F < shellcode.[c/py/js]
  -h         help                 ;  rax2 -h
  -H         hash string          ;  rax2 -H linux osx
  -i         IP address <-> LONG  ;  rax2 -i 3530468537
  -j         json format output   ;  rax2 -j 0x1234 # same as r2 -c '?j 0x1234'
  -k         keep base            ;  rax2 -k 33+3 -> 36
  -K         randomart            ;  rax2 -K 0x34 1020304050
  -n         newline              ;  append newline to output (for -E/-D/-r/..)
  -o         octalstr -> raw      ;  rax2 -o \162 \62 # r2
  -q         quiet mode           ;  rax2 -qC < /etc/hosts # be quiet
  -r         r2 style output      ;  rax2 -r 0x1234 # same as r2 -c '? 0x1234'
  -s         hexstr -> raw        ;  rax2 -s 43 4a 50
  -S         raw -> hexstr        ;  rax2 -S < /bin/ls > ls.hex
  -rS        raw -> hex.r2        ;  rax2 -rS < /bin/ls > ls.r2
  -t         tstamp -> str        ;  rax2 -t 1234567890
  -u         units                ;  rax2 -u 389289238 # 317.0M
  -v         version              ;  rax2 -v
  -w         signed word          ;  rax2 -w 0xffff 0xffff_ffff '0xff&0xfffff'
  -x         output in hexpairs   ;  rax2 -x 0x1234 # 34120000
  -X         bin -> hex(bignum)   ;  rax2 -X 111111111 # 0x1ff
  -z         str -> bin           ;  rax2 -z hello
  -Z         bin -> str           ;  rax2 -Z 01000101 01110110