# Início

### Introdução

Executar um programa no boot significa rodá-lo em um ambiente minimalista (bare-metal ou com bootloader), independente do SO. Isso é útil para diagnósticos, recuperação ou tarefas personalizadas. Requisitos:

* Conhecimento básico de programação (C/Assembly).
* Ferramentas como NASM, GCC, GRUB ou Windows ADK.
* Teste em ambiente virtual (ex.: QEMU).
* Acesso administrativo (sudo no Linux, administrador no Windows).

**Aviso:** Desative Secure Boot no UEFI se necessário (entre no setup do BIOS/UEFI pressionando Del, F2 ou F10 durante o boot, e desative na seção de boot). Teste com cuidado para evitar problemas. Faça backup do sistema antes de prosseguir.

### Executando no Linux (Usando GRUB ou Outras Abordagens)

O GRUB é o bootloader padrão no Linux e permite configurações flexíveis. Outras opções incluem partições personalizadas, firmware ou sistemas minimalistas. Abaixo, os passos são detalhados com comandos específicos e verificações.

#### 1. Usar o Bootloader GRUB

1. **Prepare o ambiente:** Abra um terminal e obtenha permissões de root com `sudo -i`. Instale ferramentas necessárias: `apt install grub-customizer nasm` (Ubuntu/Debian) ou equivalente (ex.: `dnf install grub2-tools nasm` no Fedora).
2. **Crie o programa:** Escreva um programa bare-metal em Assembly (ex.: boot.asm). Exemplo:

   ```
   bits 16
   org 0x7C00
   mov ah, 0x0E
   mov al, 'H'
   int 0x10
   mov al, 'i'
   int 0x10
   cli
   hlt
   times 510-($-$$) db 0
   dw 0xAA55
   ```

   Compile com `nasm -f bin boot.asm -o /boot/programa.bin`.
3. **Edite o GRUB:** Abra `nano /etc/grub.d/40_custom`. Adicione:

   ```
   menuentry "Meu Programa Personalizado" {
       insmod part_gpt
       insmod ext2
       set root='hd0,gpt1'  # Ajuste para sua partição de boot
       chainloader /programa.bin
   }
   ```

   Salve (Ctrl+O, Enter, Ctrl+X).
4. **Atualize o GRUB:** Execute `update-grub`. Verifique o output para erros. O arquivo grub.cfg será atualizado em /boot/grub/.
5. **Teste:** Reinicie com `reboot`. Pressione Shift no boot para abrir o menu GRUB. Selecione "Meu Programa Personalizado". Se falhar, use um live USB com `boot-repair`.
6. **Reversão:** Remova a entrada de /etc/grub.d/40\_custom e execute `update-grub`.

**Limitações:** O programa deve ser minimalista, sem dependências de bibliotecas.

#### 2. Criar uma Partição de Boot Personalizada

1. **Verifique o disco:** Use `fdisk -l` para listar partições. Identifique o disco (ex.: /dev/sda).
2. **Crie partição:** Execute `fdisk /dev/sda`, pressione 'n' (nova), 'p' (primária), escolha tamanho (ex.: +100M), defina tipo como EFI (ef) se UEFI, grave com 'w'.
3. **Formate:** `mkfs.fat -F32 /dev/sdaX` (para EFI) ou `mkfs.ext2 /dev/sdaX`. Monte: `mkdir /mnt/boot; mount /dev/sdaX /mnt/boot`.
4. **Compile o programa:** Compile boot.asm para /mnt/boot/programa.bin com `nasm -f bin boot.asm -o /mnt/boot/programa.bin`.
5. **Instale GRUB:** `grub-install --target=i386-pc --boot-directory=/mnt/boot /dev/sdaX`. Crie /mnt/boot/grub/grub.cfg com a entrada do programa.
6. **Configure UEFI:** Reinicie, entre no setup UEFI, priorize a nova partição.
7. **Teste:** Use `qemu-system-x86_64 -drive file=/dev/sdaX,format=raw` para simular.

#### 3. Modificar o Firmware (BIOS/UEFI)

1. **Instale EDK II:** `git clone https://github.com/tianocore/edk2.git`. Configure: `make -C BaseTools`.
2. **Crie app EFI:** Escreva código C/Assembly (ex.: exibir mensagem via UEFI protocols). Coloque em edk2/SeuModulo/.
3. **Compile:** `build -p Plataforma/Plataforma.dsc -m SeuModulo/SeuModulo.inf`.
4. **Integre:** Baixe o firmware do fabricante (ex.: ASUS). Use UEFITool para inserir o .efi.
5. **Atualize:** Copie para USB FAT32, flash via UEFI setup.
6. **Teste:** `qemu-system-x86_64 -bios seu_firmware.rom`.

**Riscos:** Pode "brickar" o hardware. Mantenha backup do firmware.

#### 4. Usar um Sistema Operacional Minimalista

1. **Instale Buildroot:** `wget https://buildroot.org/downloads/buildroot-latest.tar.gz`, extraia, configure com `make menuconfig`.
2. **Adicione programa:** Inclua seu binário como pacote, configure init em rootfs\_overlay/etc/init.d/S01seuprograma.
3. **Compile:** `make` gera rootfs.tar ou ISO.
4. **Grave:** `dd if=output/images/rootfs.iso of=/dev/sdX bs=4M`.
5. **Teste:** Configure UEFI para boot do dispositivo.

#### Exemplo Prático: Hello World no Boot

```
bits 16
org 0x7C00
mov ah, 0x0E
mov al, 'H'
int 0x10
mov al, 'i'
int 0x10
cli
hlt
times 510-($-$$) db 0
dw 0xAA55
```

Compile com `nasm -f bin boot.asm -o boot.bin` e integre ao GRUB.

### Executando no Windows (Usando BOOTMGR ou Outras Abordagens)

O Windows usa o Boot Manager (BOOTMGR), menos flexível que o GRUB. Use entradas personalizadas, WinPE, bootloader alternativo ou USB. Abaixo, passos detalhados.

#### 1. Usar o Windows Boot Manager

1. **Prepare o ambiente:** Abra o Prompt de Comando como administrador (Win+R, digite "cmd", Ctrl+Shift+Enter). Instale NASM (baixe de nasm.us, adicione ao PATH).
2. **Crie o programa:** Escreva boot.asm (exemplo abaixo). Compile: `nasm -f bin boot.asm -o C:\boot.bin`.
3. **Gere uma GUID:** Execute `bcdedit /create /d "Meu Programa" /application BOOTSECTOR`. Anote a GUID exibida (ex.: {12345678-...}).
4. **Configure o BCD:** Execute:

   ```
   bcdedit /set {sua-guid} device partition=C:
   bcdedit /set {sua-guid} path \boot.bin
   ```

   Verifique com `bcdedit /enum all`.
5. **Grave o binário:** Copie boot.bin para C:\ (ex.: `copy boot.bin C:\`).
6. **Teste:** Reinicie (pressione F8 ou Shift+Restart para menu de boot). Selecione "Meu Programa". Use USB de recuperação se falhar.
7. **Reversão:** `bcdedit /delete {sua-guid}`.

#### 2. Criar um Ambiente WinPE

1. **Baixe o ADK:** No site da Microsoft, baixe o Windows ADK para sua versão (ex.: Windows 11).
2. **Instale:** Escolha "Deployment Tools" e "Windows Preinstallation Environment".
3. **Crie base WinPE:** `copype amd64 C:\WinPE` (ou x86 para 32-bit).
4. **Adicione programa:** Copie seu executável (ex.: programa.exe) para C:\WinPE\media. Edite C:\WinPE\media\sources\startnet.cmd com notepad, adicione:

   ```
   wpeinit
   C:\programa.exe
   ```
5. **Crie mídia:** `MakeWinPEMedia /UFD C:\WinPE F:` (USB em F:) ou `MakeWinPEMedia /ISO C:\WinPE C:\WinPE.iso`.
6. **Configure UEFI:** Insira USB, reinicie, priorize USB no setup UEFI.
7. **Teste:** Verifique se o WinPE executa o programa.

#### 3. Modificar o Firmware (UEFI)

1. **Instale EDK II:** Baixe do GitHub, configure com Visual Studio ou GCC.
2. **Crie app EFI:** Escreva código C usando UEFI protocols.
3. **Compile:** Use build tool do EDK II.
4. **Integre:** Use UEFITool para inserir .efi no firmware do fabricante.
5. **Atualize:** Flash via USB no UEFI setup.
6. **Teste:** `qemu-system-x86_64 -bios seu_firmware.rom`.

#### 4. Usar um Bootloader Alternativo (GRUB)

1. **Instale Grub2Win:** Baixe do site oficial, instale como admin.
2. **Configure:** Abra Grub2Win, edite grub.cfg para incluir:

   ```
   menuentry "Meu Programa" {
       chainloader /boot.bin
   }
   ```
3. **Copie binário:** Coloque boot.bin na raiz do disco (ex.: C:\\).
4. **Teste:** Reinicie, selecione no menu GRUB.

#### 5. Usar Dispositivo Externo (USB/CD)

1. **Compile programa:** Crie boot.bin com NASM.
2. **Crie mídia:** Baixe Rufus, use DD mode para gravar boot.bin em USB.
3. **Configure UEFI:** Priorize USB no boot order.
4. **Teste:** Reinicie, verifique execução.

#### Exemplo Prático: Hello no Boot

```
bits 16
org 0x7C00
mov ah, 0x0E
mov al, 'H'
int 0x10
mov al, 'e'
int 0x10
mov al, 'l'
int 0x10
mov al, 'l'
int 0x10
mov al, 'o'
int 0x10
cli
hlt
times 510-($-$$) db 0
dw 0xAA55
```

Compile com `nasm -f bin boot.asm -o boot.bin` e use com BCD ou USB.

### Considerações Gerais

* **Ambiente:** Bare-metal; gerencie hardware diretamente.
* **Segurança:** Teste em QEMU; evite vulnerabilidades.
* **Hardware:** Compatível com x86/x64.
* **Casos de Uso:** Diagnóstico, recuperação.