---

## 🖥️ Interfaz de administración de la UI

BlockGuard incluye una **aplicación de escritorio WPF** para gestionar archivos y carpetas protegidos a través de una interfaz visual — sin necesidad 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>

### Características

- **Panel de control** — Resumen del estado de protección (total de archivos, carpetas, estado de cifrado)
- **Archivos protegidos** — Agregar/eliminar archivos y carpetas para protegerlos del acceso de la IA mediante cuadros de diálogo de exploración de archivos
- **Registro de actividades** — Registro en tiempo real de todos los cambios de configuración
- **Configuración** — Ver la ruta del archivo de configuración e información del agente
- **Estado del agente** — Indicador en vivo que muestra si el servicio del agente BlockGuard se está ejecutando

### Cómo iniciar la UI```powershell
# From the project root
dotnet run --project src/BlockGuard.UI

---

## 🚀 Inicio Rápido

### 1. Clonar el Repositorio```powershell
git clone [email protected]:m2l33k/BlockGuard.git
cd BlockGuard

### 3. Construir la solución```powershell
dotnet build BlockGuard.sln --configuration Release

### 4. Configurar rutas protegidas y reglas

Edite `src/BlockGuard.Agent/appsettings.json` para definir **qué archivos proteger** y **qué procesos están 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
      }
    ]
  }
}

---

## ⚙️ Configuración

Toda la configuración reside en `src/BlockGuard.Agent/appsettings.json` bajo la sección `"BlockGuard"`.

### Rutas Protegidas

Un array de archivos o directorios a proteger. Los directorios protegen todos los archivos de forma recursiva.```json
"ProtectedPaths": [
  "C:\\Secrets\\ai-model-keys",
  "C:\\Secrets\\api-credentials.json",
  "D:\\Confidential\\reports"
]

**Ejemplo: Regla basada en firmas (para cualquier herramienta de gestión firmada)**```json
{
  "RuleName": "Signed-Management-Tool",
  "ExecutablePath": null,
  "ExpectedFileHash": null,
  "ExpectedSignerSubject": "CN=Contoso Security",
  "MinimumIntegrityLevel": "High",
  "RequireSignature": true
}

### Otras Opciones

| Opción | Predeterminado | Descripción |
|---|---|---|
| `IdentityCacheTtlSeconds` | `30` | Cuánto tiempo (segundos) se mantiene en caché una identidad de proceso validada |
| `HandleTimeoutSeconds` | `60` | Duración máxima (segundos) de una concesión ACL temporal |
| `AuditLogPath` | `C:\ProgramData\BlockGuard\Logs\audit.json` | Ruta del archivo de registro de auditoría JSON |
| `EnableDpapiEncryption` | `true` | Cifrar archivos protegidos en reposo con DPAPI |
| `DpapiScope` | `LocalMachine` | Ámbito DPAPI: `LocalMachine` o `CurrentUser` |

---

## 🏃 Ejecutando el Agente

### Opción A: Modo de Desarrollo (Consola)

Ideal para pruebas y depuración. Ejecute desde una **PowerShell elevada (Administrador)**:```powershell
dotnet run --project src/BlockGuard.Agent --configuration Release

Presiona `Ctrl+C` para detener.

### Opción B: Instalar como un servicio de Windows (Producción)```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

---

## ✅ Verificación de funcionamiento

Sigue estos pasos para confirmar que BlockGuard protege los archivos correctamente.

### Prueba 1: Build Verification```powershell
# From the project root directory
dotnet build BlockGuard.sln

# Expected: Build succeeded with 0 Error(s)

**✅ Resultado esperado:**
- Mensaje `BlockGuard Security Agent Starting`
- Sin errores `CRITICAL` o `FATAL`
- `ETW file trace session started successfully`
- `BlockGuard is now actively protecting X path(s)`

**❌ Si ves `ETW session — insufficient privileges`:**
- NO estás ejecutando como Administrador. Haz clic derecho en PowerShell → "Ejecutar como administrador"

### Prueba 3: Verificación de bloqueo de ACL

Después de que el agente se inicie, verifica que los archivos protegidos estén 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

### Prueba 5: Inspección del Registro de Auditoría

Después de que el agente se ejecute durante un tiempo, verifique el registro de auditoría:```powershell
# View the last 10 audit entries
Get-Content "C:\ProgramData\BlockGuard\Logs\audit.json" | Select-Object -Last 10

### Prueba 6: Verificar Captura de Eventos ETW

Abra una segunda terminal e intente acceder a un archivo protegido mientras el agente está en ejecución:```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"

### Test 7: Verificar que el Acceso No Autorizado esté Bloqueado (Modelo de IA)

Cuando un proceso (como un modelo de IA no autorizado) intenta leer una carpeta o archivo protegido, el agente deniega inmediatamente el acceso. La IA recibirá un error estricto de **Acceso Denegado**, y el intento se registra:

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12349/d2a2e20c0fc60e8b3a5f614b0a53c6c7275b634e93b1ce0b9fe4440c38215fac.png" alt="Acceso No Autorizado Denegado" width="600" />
</p>

### Test 8: Verificar el Cifrado 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 Directorio 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)

---

## 🔬 Cómo funciona

### Secuencia de inicio (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

### Validación de procesos (6 comprobaciones)

Cuando un proceso accede a un archivo protegido, BlockGuard lo valida mediante:

1. **Ruta del ejecutable** — Resuelve y canonicaliza la ruta completa (previene path traversal)
2. **Hash SHA-256** — Calcula el hash del binario en disco (detecta reemplazo de archivo)
3. **Firma Authenticode** — Valida la cadena de firma digital (detecta binarios sin firmar/alterados)
4. **SID del propietario del proceso** — Consulta el token para identificar la cuenta en ejecución
5. **Nivel de integridad** — Lee la etiqueta obligatoria (No confiable/Bajo/Medio/Alto/Sistema)
6. **ID del proceso padre** — Rastrea la cadena de creación del proceso (detecta inyección)

Todas las comprobaciones son **fail-closed**: si falla algún paso de validación, el acceso es **DENEGADO**.

---

## 🛠️ Solución de problemas

### "Sesión ETW — privilegios insuficientes"

**Causa:** El agente no se está ejecutando con privilegios de Administrador/SYSTEM.

**Solución:**```powershell
# Right-click PowerShell → "Run as Administrator"
dotnet run --project src/BlockGuard.Agent

### Errores de compilación después de clonar

**Solución:** Restaurar paquetes NuGet:```powershell
dotnet restore BlockGuard.sln
dotnet build BlockGuard.sln

---

## 🔒 Consideraciones de Seguridad

### Lo que Este Agente Puede Hacer
- ✅ Evitar que procesos no autorizados **lean** archivos protegidos mediante la aplicación de ACL
- ✅ Detectar y **auditar** todos los intentos de acceso a archivos en tiempo real mediante ETW
- ✅ Cifrar archivos **en reposo** usando DPAPI
- ✅ Detectar y **auto-remediar** la manipulación de ACL

### Lo que Este Agente No Puede Hacer
- ❌ **Bloquear lecturas de archivos en vuelo** — Este es un agente en modo usuario; el bloqueo real en vuelo requiere un controlador minifiltro del kernel
- ❌ **Detener ataques a nivel de kernel** — Un controlador malicioso del kernel puede eludir las ACL de NTFS
- ❌ **Evitar que los Administradores anulen** — Las cuentas de administrador pueden eliminar ACL (mitigado por la detección de manipulaciones)

### Recomendaciones para Producción

1. **Ejecutar como `NT AUTHORITY\SYSTEM`** — Usar un Servicio de Windows, no una aplicación de consola
2. **Firmar el binario del agente** con un certificado Authenticode para evitar la auto-manipulación
3. **Habilitar BitLocker** en el volumen para cifrado completo del disco (complementa DPAPI)
4. **Reenviar registros de auditoría a un SIEM** para monitoreo centralizado
5. **Habilitar Secure Boot + Driver Signature Enforcement** para evitar elusión a nivel de kernel

---

## 🤝 Contribuciones

1. Haz un fork del repositorio
2. Crea una rama de características: `git checkout -b feature/my-feature`
3. Confirma tus cambios: `git commit -m "Add my feature"`
4. Sube a la rama: `git push origin feature/my-feature`
5. Abre un Pull Request

### Estilo de Código
- Sigue las convenciones de nomenclatura de C# (PascalCase para miembros públicos)
- Agrega comentarios de documentación XML a todas las API públicas
- Cada validación debe **fallar cerrada** (negar en caso de error)
- Libera explícitamente todos los manejadores nativos en bloques `finally`
- Pon a cero los búferes de memoria sensible después de su uso

---

## 📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulta [LICENSE](https://github.com/m2l33k/blockguard/blob/main/LICENSE) para más detalles.

---

<p align="center">
  <b>Construido con principios de seguridad primero para la protección de archivos en Windows.</b>
  <br/>
  <sub>BlockGuard — porque tus datos merecen un guardia, no solo un candado.</sub>
</p>