# GDB

Entre no GDB antes de continuar. Para acessar, basta executar o comando `gdb`. Caso queira instale também o `peda`, para deixar o GDB com um visual mais amigável.

Outro recurso que podemos utilizar para deixar o GDB mais amigável é executando os comandos abaixo:

```bash
gdb -q <file> -tui

# Código Assembly
layout asm

# x Registradores
layout regs
```

{% hint style="success" %}
**NOTA**: Caso queira utilizar uma ferramenta GUI, utilize o **`edb`**, com o seguinte comando: **`edb --run <file>`**
{% endhint %}

### Configurando o gdb

Para deixarmos o gdb configurado para abrir sempre em formato Intel, execute os comandos:

```bash
gdb -q
set disassembly-flavor intel
quit

echo "set disassembly-flavor intel" >> ~/.gdbinit
```

### Comandos Básicos

Exibindo o código fonte

```
list
```

{% hint style="warning" %}
**IMPORTANTE:** Essa opção provavelmente não estará disponível, pois ninguém quer deixar um programa compilado que deixe exibir o códgo fonte. Para deixar essa leitura disponível, utilize o seguinte comando para compilar: **gcc -g \<file.c> -o \<file>**
{% endhint %}

Exibindo as variáveis

```bash
info variables
```

Vendo as functions do binário

```bash
info functions
# ou
i f
```

Abaixo, algumas maneiras de executar o programa de forma normal, com parâmetros ou sem:

```bash
run
run <arg1> <arg2> ... <argX>
run $(<subcommand_os>)
run < <(<command>)
run < <file.txt>
```

Executando o programa em modo debug

```bash
start
# ou
start <arg1> <arg2> ... <argX>
```

Vendo o Disasseble completo de um trecho (no exemplo abaixo, usamos o `main`)

```bash
disassemble main
# ou
disas main
```

Visualiza os endereços de memória que o programa está ocupando

```bash
info proc mappings
```

Definindo novos valores paras os registadores

```bash
set $eip = 0x00112233
```

### Argumentos

```bash
# Defininado argumentos antes de executar
set args <arg1> <arg2> ... <argX>

# Resetando os argumentos
set args
```

### Registradores

```bash
# Também pode-se utilizar: i r
info registers

# Também pode-se utilizar: i r <register>
info register <register>
```

### Examine

O comando Examine (usamos o atalho `x` para executá-lo), serve para examinar determinado endereço de memória de várias maneiras. Este comando espera 2 argumentos, sendo eles o local da memória a ser examinado e o segundo é como exibir essa memória. Assim como o `Examine` utiliza uma abreviação (x), o formato de exibição também trabalha com abreviações, sendo elas:

```bash
# Octal
o

# Hexadecimal
x

# Unsigned, por padrão decimal (base-10)
u

# Binário (texto em base-10 binário)
t
```

Por exemplo, para exibirmos determinado endereço de memória em Hexadecimal, execute

```bash
x/x <address_memory>
```

### Breakpoints

Inserindo Breakpoints

```bash
break _main # Geralmente as pessoas usam o nome _main para o Entry Point
break *<main+16>
b* 0x00112233
```

Deletando todos os breakpoints

```bash
del
# ou
d
```

Indo para a próxima instrução com `NI` (Next Instruction) e `SI` (Step Instruction)

```bash
# Continua o código sem entrar no método que a linha atual está chamando
ni

# Entra no método que a linha atual está chamando
si
```

Indo para o próximo breakpoint

```
c
```

### Executando Determinada Função

Mesmo sem o programa chegar a determinada função, podemos forçar a sua execução. Com o padrão `call((<type_return>(*)()) <method_name>)(<params>)`, podemos fazer isso, como no exemplo abaixo:

```bash
call((void(*)()) calcula)(30)
```

### Sites

```bash
# Tutorial do gdb (PT-BR)
http:s//www.lrc.ic.unicamp.br/~luciano/courses/mc202-2s2009/tutorial_gdb.txt

# PEDA
https://github.com/longld/peda
```