---

## 🖥️ Interface de Gerenciamento da IU

O BlockGuard inclui um **aplicativo desktop WPF** para gerenciar arquivos e pastas protegidos através de uma interface visual — sem necessidade de editar `appsettings.json` manualmente.

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12349/51a9b7894117382666d869cee59860a33698f666133bd23c6b6cd48b225d942c.png" alt="BlockGuard UI" width="640" />
</p>

### Recursos

- **Painel** — Visão geral do status de proteção (total de arquivos, pastas, estado de criptografia)
- **Arquivos Protegidos** — Adicionar/remover arquivos e pastas para proteger do acesso de IA através de diálogos do navegador de arquivos
- **Registro de Atividades** — Registro em tempo real de todas as alterações de configuração
- **Configurações** — Visualizar caminho do arquivo de configuração e informações do agente
- **Status do Agente** — Indicador ao vivo mostrando se o serviço do agente BlockGuard está em execução

### Como Iniciar a IU```powershell
# From the project root
dotnet run --project src/BlockGuard.UI

---

## 🚀 Início Rápido

### 1. Clone o Repositório```powershell
git clone [email protected]:m2l33k/BlockGuard.git
cd BlockGuard

### 3. Construir a Solução```powershell
dotnet build BlockGuard.sln --configuration Release

### 4. Configurar Caminhos Protegidos e Regras

Edite `src/BlockGuard.Agent/appsettings.json` para definir **quais arquivos proteger** e **quais processos são autorizados**:```json
{
  "BlockGuard": {
    "ProtectedPaths": [
      "C:\\Secrets\\ai-model-keys",
      "C:\\Secrets\\api-credentials.json"
    ],
    "AuthorizedProcesses": [
      {
        "RuleName": "AI-Model-Inference-Engine",
        "ExecutablePath": "C:\\Program Files\\MyAI\\inference.exe",
        "MinimumIntegrityLevel": "Medium",
        "RequireSignature": false
      }
    ]
  }
}

---

## ⚙️ Configuração

Toda a configuração está em `src/BlockGuard.Agent/appsettings.json` na seção `"BlockGuard"`.

### Caminhos Protegidos

Um array de arquivos ou diretórios para proteger. Diretórios protegem todos os arquivos recursivamente.```json
"ProtectedPaths": [
  "C:\\Secrets\\ai-model-keys",
  "C:\\Secrets\\api-credentials.json",
  "D:\\Confidential\\reports"
]

**Exemplo: Regra baseada em assinatura (para qualquer ferramenta de gerenciamento assinada)**```json
{
  "RuleName": "Signed-Management-Tool",
  "ExecutablePath": null,
  "ExpectedFileHash": null,
  "ExpectedSignerSubject": "CN=Contoso Security",
  "MinimumIntegrityLevel": "High",
  "RequireSignature": true
}

### Outras Opções

| Opção | Padrão | Descrição |
|---|---|---|
| `IdentityCacheTtlSeconds` | `30` | Quanto tempo (segundos) uma identidade de processo validada permanece em cache |
| `HandleTimeoutSeconds` | `60` | Duração máxima (segundos) de uma concessão temporária de ACL |
| `AuditLogPath` | `C:\ProgramData\BlockGuard\Logs\audit.json` | Caminho para o arquivo de log de auditoria JSON |
| `EnableDpapiEncryption` | `true` | Criptografar arquivos protegidos em repouso com DPAPI |
| `DpapiScope` | `LocalMachine` | Escopo DPAPI: `LocalMachine` ou `CurrentUser` |

---

## 🏃 Executando o Agente

### Opção A: Modo de Desenvolvimento (Console)

Melhor para testes e depuração. Execute a partir de um **PowerShell elevado (Administrador)**:```powershell
dotnet run --project src/BlockGuard.Agent --configuration Release

Pressione `Ctrl+C` para parar.

### Opção B: Instalar como um Serviço do Windows (Produção)```powershell
# 1. Publish a self-contained build
dotnet publish src/BlockGuard.Agent -c Release -r win-x64 --self-contained -o C:\BlockGuard

# 2. Create the Windows Service
sc.exe create BlockGuard binPath= "C:\BlockGuard\BlockGuard.Agent.exe" start= auto obj= "NT AUTHORITY\SYSTEM" DisplayName= "BlockGuard Security Agent"

# 3. Set the service description
sc.exe description BlockGuard "Process-based file access security agent (DLP)"

# 4. Start the service
sc.exe start BlockGuard

## ✅ Verificando se Funciona

Siga estas etapas para confirmar que o BlockGuard está protegendo os arquivos corretamente.

### Teste 1: Verificação de Build```powershell
# From the project root directory
dotnet build BlockGuard.sln

# Expected: Build succeeded with 0 Error(s)

**✅ Saída esperada:**
- Mensagem `BlockGuard Security Agent Starting`
- Nenhum erro `CRITICAL` ou `FATAL`
- `ETW file trace session started successfully`
- `BlockGuard is now actively protecting X path(s)`

**❌ Se você vir `ETW session — insufficient privileges`:**
- Você NÃO está executando como Administrador. Clique com o botão direito no PowerShell → "Executar como Administrador"

### Teste 3: Verificação de Bloqueio de ACL

Após a inicialização do agente, verifique se os arquivos protegidos estão bloqueados:```powershell
# Create a test protected file
New-Item -Path "C:\Secrets" -ItemType Directory -Force
Set-Content -Path "C:\Secrets\api-credentials.json" -Value '{"api_key": "secret123"}'

# Start the agent (it will lock down the file)
dotnet run --project src/BlockGuard.Agent

# In ANOTHER non-admin terminal, try to read the file:
Get-Content "C:\Secrets\api-credentials.json"
# Expected: Access Denied error

### Teste 5: Inspeção do Log de Auditoria

Depois que o agente executar por um tempo, verifique o log de auditoria:```powershell
# View the last 10 audit entries
Get-Content "C:\ProgramData\BlockGuard\Logs\audit.json" | Select-Object -Last 10

### Teste 6: Verificar Captura de Eventos ETW

Abra um segundo terminal e tente acessar um arquivo protegido enquanto o agente está em execução:```powershell
# Terminal 1: Agent is running with console output
dotnet run --project src/BlockGuard.Agent

# Terminal 2: Try reading a protected file with notepad
notepad.exe "C:\Secrets\api-credentials.json"

### Teste 7: Verificar Acesso Não Autorizado Bloqueado (Modelo de IA)

Quando um processo (como um modelo de IA não autorizado) tenta ler uma pasta ou arquivo protegido, o agente nega imediatamente o acesso. A IA receberá um erro estrito de **Acesso Negado** e a tentativa será registrada:

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12349/d2a2e20c0fc60e8b3a5f614b0a53c6c7275b634e93b1ce0b9fe4440c38215fac.png" alt="Acesso Não Autorizado Negado" width="600" />
</p>

### Teste 8: Verificar Criptografia DPAPI```powershell
# Check that the .enc file was created
Test-Path "C:\Secrets\api-credentials.json.enc"
# Expected: True

# Check that the original plaintext file was securely deleted
Test-Path "C:\Secrets\api-credentials.json"
# Expected: False (if EnableDpapiEncryption is true)

### Test 10: Verificar diretório de logs```powershell
# Check both log locations
Get-ChildItem "C:\ProgramData\BlockGuard\Logs\"

# Expected files:
# audit.json              (structured JSON audit log)
# blockguard-20260305.log (daily rolling application log)

---

## 🔬 Como Funciona

### Sequência de Inicialização (5 Fases)```
Phase 1: ACL Lockdown
  └─ Strip all permissions from protected files
  └─ Grant access only to SYSTEM + Administrators
  └─ Disable ACL inheritance

Phase 2: DPAPI Encryption (optional)
  └─ Encrypt each protected file at rest
  └─ Securely delete plaintext (overwrite with random data)
  └─ Store ciphertext as .enc files

Phase 3: Event Subscription
  └─ Register handler for file access events

Phase 4: ETW Monitoring
  └─ Start kernel-level file trace session
  └─ Filter events by protected paths
  └─ Emit FileAccessEvent for each match

Phase 5: Integrity Check Loop
  └─ Every 60 seconds, verify ACLs are intact
  └─ Auto-remediate if tampering detected

### Validação de Processo (6 Verificações)

Quando um processo acessa um arquivo protegido, o BlockGuard o valida através de:

1. **Executable Path** — Resolve e canoniza o caminho completo (impede traversal de caminho)
2. **SHA-256 Hash** — Calcula o hash do binário em disco (detecta substituição de arquivo)
3. **Authenticode Signature** — Valida a cadeia de assinatura digital (detecta binários não assinados/adulterados)
4. **Process Owner SID** — Consulta o token para identificar a conta em execução
5. **Integrity Level** — Lê o rótulo obrigatório (Untrusted/Low/Medium/High/System)
6. **Parent Process ID** — Rastreia a cadeia de criação do processo (detecta injeção)

Todas as verificações **fail-closed**: se qualquer etapa de validação falhar, o acesso é **NEGADO**.

---

## 🛠️ Solução de Problemas

### "ETW session — privilégios insuficientes"

**Causa:** O agente não está em execução com privilégios de Administrador/SISTEMA.

**Solução:**```powershell
# Right-click PowerShell → "Run as Administrator"
dotnet run --project src/BlockGuard.Agent

### Erros de compilação após clonagem

**Correção:** Restaure os pacotes NuGet:```powershell
dotnet restore BlockGuard.sln
dotnet build BlockGuard.sln

---

## 🔒 Considerações de Segurança

### O Que Este Agente Pode Fazer
- ✅ Impedir que processos não autorizados **leiam** arquivos protegidos via imposição de ACL
- ✅ Detectar e **auditar** todas as tentativas de acesso a arquivos em tempo real via ETW
- ✅ Criptografar arquivos **em repouso** usando DPAPI
- ✅ Detectar e **corrigir automaticamente** adulteração de ACL

### O Que Este Agente Não Pode Fazer
- ❌ **Bloquear leituras de arquivos em tempo real** — Este é um agente em modo de usuário; o bloqueio verdadeiro em tempo real requer um driver de filtro no kernel
- ❌ **Impedir ataques em nível de kernel** — Um driver malicioso do kernel pode ignorar ACLs do NTFS
- ❌ **Impedir que Administradores substituam** — Contas de administrador podem remover ACLs (mitigado pela detecção de adulteração)

### Recomendações para Produção

1. **Executar como `NT AUTHORITY\SYSTEM`** — Use um Serviço Windows, não um aplicativo de console
2. **Assinar o binário do agente** com um certificado Authenticode para evitar adulteração
3. **Habilitar o BitLocker** no volume para criptografia de disco completo (complementa DPAPI)
4. **Encaminhar logs de auditoria para um SIEM** para monitoramento centralizado
5. **Habilitar Secure Boot + Driver Signature Enforcement** para evitar bypass em nível de kernel

---

## 🤝 Contribuindo

1. Faça um fork do repositório
2. Crie um branch de funcionalidade: `git checkout -b feature/my-feature`
3. Faça commit das suas alterações: `git commit -m "Add my feature"`
4. Envie para o branch: `git push origin feature/my-feature`
5. Abra um Pull Request

### Estilo de Código
- Siga as convenções de nomenclatura C# (PascalCase para membros públicos)
- Adicione comentários de documentação XML para todas as APIs públicas
- Toda validação deve **falhar-fechado** (negar em erro)
- Descartar explicitamente todos os handles nativos em blocos `finally`
- Zerar buffers de memória sensíveis após o uso

---

## 📄 Licença

Este projeto é licenciado sob a Licença MIT. Veja [LICENSE](https://github.com/m2l33k/blockguard/blob/HEAD/LICENSE) para detalhes.

---

<p align="center">
  <b>Construído com princípios de segurança em primeiro lugar para proteção de arquivos Windows.</b>
  <br/>
  <sub>BlockGuard — porque seus dados merecem um guarda, não apenas uma fechadura.</sub>
</p>