# AppLocker

> Guia completo sobre o AppLocker da Microsoft, abordando conceitos, arquitetura, configuração, gerenciamento via GPO, regras, melhores práticas e integração com Active Directory.

***

## 🔍 Introdução ao AppLocker

O **AppLocker** é uma tecnologia de controle de aplicações da Microsoft, introduzida no Windows 7 e Windows Server 2008 R2, que permite aos administradores especificar quais usuários ou grupos podem executar determinados aplicativos no sistema. Diferente das antigas **Software Restriction Policies (SRP)**, o AppLocker oferece maior granularidade, flexibilidade e facilidade de gerenciamento.

### Benefícios Principais

| **Benefício**                  | **Descrição**                                                                     |
| ------------------------------ | --------------------------------------------------------------------------------- |
| **Controle Granular**          | Permite criar regras baseadas em editor, nome do produto, versão, caminho e hash. |
| **Modo de Auditoria**          | Teste de políticas antes da aplicação efetiva, sem bloquear usuários.             |
| **Gerenciamento Centralizado** | Integração com Active Directory e Políticas de Grupo (GPO).                       |
| **Regras por Usuário/Grupo**   | Diferentes permissões para diferentes conjuntos de usuários.                      |
| **Suporte a Modern Apps**      | Controle sobre aplicativos UWP e Microsoft Store.                                 |

***

## 🧠 Conceitos Fundamentais

### 2.1 O que é AppLocker?

AppLocker é um recurso de **controle de aplicações** que permite:

* **Permitir ou negar** a execução de aplicativos.
* **Restringir por usuário ou grupo** (ex.: apenas o grupo TI pode executar PowerShell).
* **Aplicar a diferentes tipos de arquivos**: executáveis (.exe, .com), scripts (.ps1, .vbs, .js), instaladores (.msi, .msp) e aplicativos empacotados (UWP).

### 2.2 Diferenças entre AppLocker e SRP

| **Característica**     | **Software Restriction Policies (SRP)** | **AppLocker**                                             |
| ---------------------- | --------------------------------------- | --------------------------------------------------------- |
| **Introdução**         | Windows XP / Server 2003                | Windows 7 / Server 2008 R2                                |
| **Granularidade**      | Regras por caminho, hash, zona          | Regras por editor, nome do produto, versão, caminho, hash |
| **Regras por usuário** | Não                                     | Sim                                                       |
| **Modo de auditoria**  | Não                                     | Sim                                                       |
| **Suporte a UWP**      | Não                                     | Sim                                                       |
| **Suporte a scripts**  | Limitado                                | Completo (PowerShell, VBScript, JScript, etc.)            |
| **DLL Control**        | Não                                     | Sim (opcional)                                            |

### 2.3 Componentes e Arquitetura

```mermaid
graph TB
    subgraph Gerenciamento
        GPO[Políticas de Grupo - GPO]
        AD[Active Directory]
        GP_Console[Console de Gerenciamento de Políticas de Grupo]
    end
    
    subgraph Servidor
        SYSVOL[SYSVOL - Armazenamento de Políticas]
    end
    
    subgraph Cliente Windows
        AppLocker_Service[Serviço AppLocker - AppIDSvc]
        Registry[Registro do Windows - Políticas Locais]
        EventLog[Log de Eventos - AppLocker]
        Kernel[Kernel - Interceptação de Execução]
    end
    
    GPO --> SYSVOL
    AD --> GPO
    GP_Console --> GPO
    SYSVOL --> Registry
    Registry --> AppLocker_Service
    AppLocker_Service --> Kernel
    AppLocker_Service --> EventLog
```

**Componentes principais:**

| **Componente**                              | **Função**                                                                                                       |
| ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **Serviço Application Identity (AppIDSvc)** | Serviço responsável por avaliar regras do AppLocker. Deve estar em execução para que as regras sejam aplicadas.  |
| **Regras Armazenadas**                      | Localizadas em `%Windir%\System32\AppLocker` e no registro `HKLM\Software\Policies\Microsoft\Windows\SrpV2`.     |
| **Políticas de Grupo**                      | Distribuem e gerenciam as regras centralizadamente.                                                              |
| **Log de Eventos**                          | Eventos de bloqueio e auditoria são registrados em `Applications and Services Logs\Microsoft\Windows\AppLocker`. |

***

## 📜 Regras do AppLocker

### 3.1 Tipos de Regras

| **Tipo**             | **Descrição**                      | **Exemplo**                                                       |
| -------------------- | ---------------------------------- | ----------------------------------------------------------------- |
| **Permitir (Allow)** | Permite a execução do aplicativo.  | Permitir que todos os usuários executem `notepad.exe`.            |
| **Negar (Deny)**     | Bloqueia a execução do aplicativo. | Negar execução de `powershell.exe` para usuários não autorizados. |

### 3.2 Condições de Regras

O AppLocker suporta quatro tipos de condições, que podem ser combinadas:

| **Condição**                    | **Descrição**                                              | **Vantagens**                                               | **Desvantagens**                                                    |
| ------------------------------- | ---------------------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------- |
| **Editor (Publisher)**          | Baseada na assinatura digital do arquivo (certificado).    | Ideal para software comercial; não quebra com atualizações. | Não funciona para aplicativos sem assinatura.                       |
| **Caminho (Path)**              | Baseada na localização do arquivo.                         | Simples e direta.                                           | Pode ser contornada se o usuário copiar o arquivo para outro local. |
| **Hash de Arquivo**             | Baseada no hash criptográfico do arquivo.                  | Extremamente específica.                                    | Quebra a cada atualização do aplicativo.                            |
| **Nome do Produto (File Name)** | Baseada no nome do arquivo (usada com condição de editor). | Permite regras genéricas para versões específicas.          | Requer assinatura digital.                                          |

#### Exemplos de Regras por Condição

```xml
<!-- Regra por Editor (Publisher) -->
<FilePublisherRule>
  <Name>Allow Microsoft Office</Name>
  <Description>Permite executar aplicativos assinados pela Microsoft Office</Description>
  <Conditions>
    <FilePublisherCondition>
      <PublisherName>O=MICROSOFT CORPORATION, L=REDMOND, S=WASHINGTON, C=US</PublisherName>
      <ProductName>Microsoft Office</ProductName>
      <BinaryName>*</BinaryName>
      <BinaryVersionRange>
        <LowSection>16.0.0.0</LowSection>
        <HighSection>17.0.0.0</HighSection>
      </BinaryVersionRange>
    </FilePublisherCondition>
  </Conditions>
</FilePublisherRule>

<!-- Regra por Caminho -->
<FilePathRule>
  <Name>Allow Windows System32</Name>
  <Description>Permite executar arquivos do diretório System32</Description>
  <Conditions>
    <FilePathCondition>
      <Path>%WINDIR%\System32\*</Path>
    </FilePathCondition>
  </Conditions>
</FilePathRule>
```

### 3.3 Ações de Regras

* **Allow (Permitir):** Usuários autorizados podem executar o aplicativo.
* **Deny (Negar):** Usuários não podem executar o aplicativo.
* **Audit Only (Somente Auditoria):** Permite execução mas registra evento para análise (usado no modo de auditoria).

***

## 🎚️ Modos de Operação

### 4.1 Audit Mode (Modo de Auditoria)

No modo de auditoria, as regras **não bloqueiam** a execução, mas **registram eventos** indicando o que teria sido bloqueado.

**Quando usar:**

* Antes da implementação em produção.
* Para identificar aplicativos legítimos que seriam afetados.
* Para refinar regras sem impacto nos usuários.

```powershell
# Verificar modo atual
Get-AppLockerPolicy -Effective | Select-Object -ExpandProperty RuleCollections | 
    ForEach-Object { $_.EnforcementMode }

# Configurar modo de auditoria via GPO
# Computer Configuration > Policies > Windows Settings > Security Settings > Application Control Policies > AppLocker
# Configure "Configure rule enforcement" para "Audit only"
```

### 4.2 Enforcement Mode (Modo de Aplicação)

No modo de aplicação, as regras são **efetivamente aplicadas**, bloqueando execuções não autorizadas.

**Modos de aplicação:**

| **Modo**                        | **Descrição**                                                                          |
| ------------------------------- | -------------------------------------------------------------------------------------- |
| **Enforce rules**               | Regras são aplicadas completamente.                                                    |
| **Enforce rules and DLL rules** | Aplica regras para executáveis e também para DLLs (maior segurança, maior sobrecarga). |
| **Audit only**                  | Modo de auditoria.                                                                     |

***

## 🏛️ Gerenciamento via GPO e AD

### 5.1 Configuração de Políticas de Grupo

O AppLocker é configurado através de **Políticas de Grupo (GPO)**, permitindo gerenciamento centralizado via Active Directory.

#### Caminho da GPO:

```
Computer Configuration
└── Policies
    └── Windows Settings
        └── Security Settings
            └── Application Control Policies
                └── AppLocker
```

#### Passos para Configuração:

1. **Criar uma nova GPO** ou editar uma existente.
2. **Navegar até** `Computer Configuration > Policies > Windows Settings > Security Settings > Application Control Policies > AppLocker`.
3. **Configurar regras** para cada coleção (Executáveis, Scripts, Instaladores, etc.).
4. **Definir modo de aplicação** em `Configure rule enforcement`.
5. **Aplicar a GPO** à OU desejada.

### 5.2 Distribuição de Regras

As regras do AppLocker são armazenadas no **SYSVOL** como arquivos XML e distribuídas via GPO:

```
SYSVOL\domain\Policies\{GPO-GUID}\Machine\Registry.pol
```

**Arquivos de regras:**

* `AppLocker.xml` – Regras principais.
* `AppLocker_Executable.xml` – Regras para executáveis.
* `AppLocker_Installer.xml` – Regras para instaladores.
* `AppLocker_Script.xml` – Regras para scripts.
* `AppLocker_Dll.xml` – Regras para DLLs (opcional).
* `AppLocker_MSI.xml` – Regras para MSI.

### 5.3 Modelagem de Políticas

Antes de aplicar uma GPO, utilize o **Group Policy Modeling Wizard** para simular o impacto:

```powershell
# Gerar relatório de modelagem via PowerShell
Invoke-GPModeling -Domain "dominio.local" -User "DOMINIO\usuario" -Computer "SRV-WKS01" -OutputPath "C:\ModelingReport.html"
```

***

## 📚 Coleções de Regras

O AppLocker organiza as regras em **coleções** por tipo de arquivo.

### 6.1 Executable Rules

Controla arquivos executáveis:

* `.exe`, `.com`, `.bat`, `.cmd`, `.scr`

**Exemplo:**

```xml
<FilePublisherRule>
  <Name>Allow Microsoft Office</Name>
  <Conditions>
    <FilePublisherCondition>
      <PublisherName>O=MICROSOFT CORPORATION, L=REDMOND, S=WASHINGTON, C=US</PublisherName>
      <ProductName>Microsoft Office</ProductName>
    </FilePublisherCondition>
  </Conditions>
  <Action>Allow</Action>
</FilePublisherRule>
```

### 6.2 Windows Installer Rules

Controla arquivos de instalação:

* `.msi`, `.msp`

**Exemplo:**

```xml
<FilePathRule>
  <Name>Allow All MSI from Trusted Source</Name>
  <Conditions>
    <FilePathCondition>
      <Path>C:\TrustedInstaller\*</Path>
    </FilePathCondition>
  </Conditions>
  <Action>Allow</Action>
</FilePathRule>
```

### 6.3 Script Rules

Controla arquivos de script:

* `.ps1`, `.vbs`, `.vbe`, `.js`, `.jse`, `.cmd`, `.bat`, `.wsf`, `.wsh`

**Exemplo:**

```xml
<FileHashRule>
  <Name>Allow Signed PowerShell Scripts</Name>
  <Conditions>
    <FileHashCondition>
      <FileHash>
        <FilePath>C:\Scripts\signed-script.ps1</FilePath>
        <Hash>1234567890ABCDEF...</Hash>
      </FileHash>
    </FileHashCondition>
  </Conditions>
  <Action>Allow</Action>
</FileHashRule>
```

### 6.4 Packaged App Rules

Controla aplicativos empacotados (UWP/Store Apps):

* Aplicativos da Microsoft Store
* Aplicativos empacotados personalizados (.appx, .msix)

**Exemplo:**

```xml
<FilePublisherRule>
  <Name>Allow Microsoft Store Apps</Name>
  <Conditions>
    <FilePublisherCondition>
      <PublisherName>CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US</PublisherName>
      <ProductName>*</ProductName>
    </FilePublisherCondition>
  </Conditions>
  <Action>Allow</Action>
</FilePublisherRule>
```

### 6.5 DLL Rules

Controla bibliotecas de vínculo dinâmico (opcional):

* `.dll`, `.ocx`

> ⚠️ **Importante:** Habilitar regras para DLLs aumenta significativamente a sobrecarga de processamento e pode impactar o desempenho. Use apenas quando necessário.

***

## 🛠️ Criação e Gerenciamento de Regras

### 7.1 Interface Gráfica

**Passos para criar regras via GUI:**

1. Abra **gpedit.msc** ou **Group Policy Management Console**.
2. Navegue até `Computer Configuration > Windows Settings > Security Settings > Application Control Policies > AppLocker`.
3. Clique com botão direito na coleção desejada (ex.: **Executable Rules**).
4. Selecione **Create New Rule**.
5. Siga o assistente:
   * **Permitir ou Negar**
   * **Condição**: Editor, Caminho, Hash
   * **Usuários/Grupos** (se aplicável)
   * **Ações** e **Exceções** (se necessário)

### 7.2 PowerShell para AppLocker

O módulo **AppLocker** do PowerShell permite gerenciamento programático.

```powershell
# Importar módulo (disponível no Windows 8/Server 2012+)
Import-Module AppLocker

# Listar regras atuais
Get-AppLockerPolicy -Effective | Select-Object -ExpandProperty RuleCollections

# Criar nova regra por caminho
$rule = New-AppLockerPolicy -RuleType Path -User Everyone -Path "%WINDIR%\System32\notepad.exe" -Action Allow
$rule.RuleCollections

# Exportar política atual
Get-AppLockerPolicy -Effective | Export-AppLockerPolicy -Path "C:\AppLockerPolicy.xml"

# Importar nova política
Set-AppLockerPolicy -XmlPolicy "C:\NewAppLockerPolicy.xml" -Merge

# Verificar eventos de bloqueio
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-AppLocker/EXE and DLL'; ID=8004} | 
    Select-Object TimeCreated, Message
```

### 7.3 Importação/Exportação de Regras

#### Exportar Regras:

```powershell
# Exportar todas as regras
Get-AppLockerPolicy -Effective | Export-AppLockerPolicy -Path "C:\Backup\AppLocker_$(Get-Date -Format 'yyyyMMdd').xml"

# Exportar apenas uma coleção
$policy = Get-AppLockerPolicy -Effective
$policy.RuleCollections | Where-Object {$_.RuleCollectionType -eq "Exe"} | 
    Export-Clixml -Path "C:\Backup\ExeRules.xml"
```

#### Importar Regras:

```powershell
# Importar política (substitui existente)
Set-AppLockerPolicy -XmlPolicy "C:\NewPolicy.xml"

# Mesclar com política existente
Set-AppLockerPolicy -XmlPolicy "C:\AdditionalRules.xml" -Merge

# Importar via GPO (usando LGPO.exe)
lgpo.exe /s "C:\PolicyExport" /n "AppLocker Policy"
```

***

## 📊 Monitoramento e Auditoria

### 8.1 Eventos do AppLocker

O AppLocker registra eventos nos seguintes logs:

| **Log**                                                 | **Eventos** | **Descrição**           |
| ------------------------------------------------------- | ----------- | ----------------------- |
| **Microsoft-Windows-AppLocker/EXE and DLL**             | 8003-8006   | Executáveis e DLLs      |
| **Microsoft-Windows-AppLocker/MSI and Script**          | 8021-8024   | Instaladores e scripts  |
| **Microsoft-Windows-AppLocker/Packaged app-Deployment** | 8025-8028   | Aplicativos empacotados |

#### Eventos Principais:

| **Evento ID** | **Descrição**                   |
| ------------- | ------------------------------- |
| **8003**      | Execução bloqueada (executável) |
| **8004**      | Execução permitida (executável) |
| **8005**      | Execução bloqueada (script)     |
| **8006**      | Execução permitida (script)     |
| **8021**      | Instalação bloqueada (MSI)      |
| **8024**      | Aplicativo empacotado bloqueado |

### 8.2 Relatórios e Logs

#### Gerar relatório de execuções bloqueadas:

```powershell
# Gerar relatório HTML de bloqueios nas últimas 24h
$events = Get-WinEvent -FilterHashtable @{
    LogName='Microsoft-Windows-AppLocker/EXE and DLL'
    ID=8003
    StartTime=(Get-Date).AddDays(-1)
} -ErrorAction SilentlyContinue

$html = $events | ForEach-Object {
    $message = $_.Message
    [PSCustomObject]@{
        Time = $_.TimeCreated
        User = if ($message -match "User:\s*(.+?)\s*Path") { $matches[1] } else { "N/A" }
        Path = if ($message -match "Path:\s*(.+?)\s*Rule") { $matches[1] } else { "N/A" }
    }
} | ConvertTo-Html -Title "AppLocker Blocked Executions Report"

$html | Out-File "C:\Reports\AppLocker_Blocked.html"
```

### 8.3 Análise de Conformidade

```powershell
# Gerar relatório de conformidade com regras
function Get-AppLockerCompliance {
    $blocked = Get-WinEvent -FilterHashtable @{
        LogName='Microsoft-Windows-AppLocker/EXE and DLL'
        ID=8003
        StartTime=(Get-Date).AddDays(-30)
    } -ErrorAction SilentlyContinue
    
    $blocked | Group-Object { 
        if ($_.Message -match "Path:\s*(.+?)\s*Rule") { $matches[1] } 
    } | Select-Object Name, Count | Sort-Object Count -Descending | 
        Format-Table -AutoSize
}

Get-AppLockerCompliance
```

***

## 🔧 Resolução de Problemas

### 9.1 Problemas Comuns

| **Problema**                                     | **Causa Possível**                    | **Solução**                                                   |
| ------------------------------------------------ | ------------------------------------- | ------------------------------------------------------------- |
| **Aplicativo não abre, sem mensagem**            | AppLocker bloqueando silenciosamente  | Verificar eventos 8003 no log; configurar regra de permissão. |
| **Regras não são aplicadas**                     | Serviço AppIDSvc não está em execução | Iniciar serviço: `Start-Service AppIDSvc`                     |
| **Usuário executando aplicativo não autorizado** | Regra por caminho contornada          | Usar regras por editor (assinatura) ou hash.                  |
| **Aplicativos da Microsoft Store bloqueados**    | Regras de Packaged App ausentes       | Criar regra permitindo assinatura da Microsoft.               |
| **DLLs bloqueadas**                              | DLL Rules habilitadas sem regras      | Desabilitar DLL Rules ou criar regras apropriadas.            |

### 9.2 Debugging e Troubleshooting

#### Verificar status do serviço:

```powershell
Get-Service AppIDSvc | Select-Object Name, Status, StartType

# Se não estiver em execução
Start-Service AppIDSvc
Set-Service AppIDSvc -StartupType Automatic
```

#### Verificar política aplicada:

```powershell
# Obter política efetiva
$policy = Get-AppLockerPolicy -Effective
$policy.RuleCollections | ForEach-Object {
    Write-Host "Coleção: $($_.RuleCollectionType)" -ForegroundColor Cyan
    $_.Rules | Select-Object Name, Action, User
}
```

#### Testar regras para um arquivo específico:

```powershell
# Testar se um arquivo seria permitido
Test-AppLockerPolicy -Path "C:\Program Files\MyApp\app.exe" -User "DOMINIO\usuario" -Policy $policy
```

#### Habilitar logging detalhado:

```powershell
# Habilitar logs de depuração (via registro)
reg add "HKLM\Software\Policies\Microsoft\Windows\AppLocker" /v DebugLog /t REG_DWORD /d 1 /f

# Coletar trace via Performance Monitor
logman start AppLockerTrace -p "Microsoft-Windows-AppLocker" -o "C:\Logs\AppLockerTrace.etl" -ets
logman stop AppLockerTrace -ets
```

***

## 🔒 Segurança e Melhores Práticas

### 10.1 Hardening com AppLocker

**Configurações recomendadas para máxima segurança:**

```powershell
# Regra base: negar tudo por padrão
# 1. Criar regra de negação para %OSDRIVE%\Users\*\*
# 2. Criar regras de permissão apenas para locais confiáveis
# 3. Habilitar regras para todos os tipos de arquivo

# Exemplo de política de bloqueio padrão
$defaultDeny = @"
<FilePathRule>
  <Name>Deny All from User Folders</Name>
  <Conditions>
    <FilePathCondition>
      <Path>%USERPROFILE%\*</Path>
    </FilePathCondition>
  </Conditions>
  <Action>Deny</Action>
</FilePathRule>
"@
```

**Princípios de segurança:**

| **Princípio**              | **Implementação**                                                   |
| -------------------------- | ------------------------------------------------------------------- |
| **Menor privilégio**       | Conceder permissões apenas para aplicativos necessários.            |
| **Defesa em profundidade** | Combinar AppLocker com WDAC (Windows Defender Application Control). |
| **Regras por editor**      | Preferir regras por assinatura digital em vez de caminho.           |
| **Exceções mínimas**       | Manter o número de exceções o mais baixo possível.                  |

### 10.2 Estratégias de Implementação

#### Estratégia Faseada:

```mermaid
graph LR
    A[Fase 1: Auditoria] --> B[Fase 2: Análise]
    B --> C[Fase 3: Refinamento]
    C --> D[Fase 4: Aplicação Piloto]
    D --> E[Fase 5: Implementação Completa]
    E --> F[Fase 6: Manutenção Contínua]
```

| **Fase**             | **Atividades**                                          | **Duração** |
| -------------------- | ------------------------------------------------------- | ----------- |
| **Auditoria**        | Ativar modo de auditoria; coletar dados por 2-4 semanas | 2-4 semanas |
| **Análise**          | Identificar aplicativos críticos; categorizar por risco | 1-2 semanas |
| **Refinamento**      | Criar regras baseadas nos dados coletados               | 1 semana    |
| **Aplicação Piloto** | Aplicar em grupo piloto; monitorar incidentes           | 2-4 semanas |
| **Implementação**    | Expandir para toda a organização                        | 4-8 semanas |
| **Manutenção**       | Revisar logs; atualizar regras                          | Contínuo    |

### 10.3 Checklist de Configuração

#### Pré-Implementação:

* [ ] **Serviço AppIDSvc** configurado para iniciar automaticamente.
* [ ] **Modo de auditoria** ativado para todas as coleções.
* [ ] **Logs de eventos** configurados com tamanho adequado.
* [ ] **Ambiente de teste** com perfis de usuário representativos.

#### Implementação:

* [ ] **Regra base** para diretórios do sistema (permitir).
* [ ] **Regra base** para diretórios de usuários (negar/auditar).
* [ ] **Regras por editor** para software corporativo (Office, Adobe, etc.).
* [ ] **Regras por caminho** para diretórios de aplicativos customizados.
* [ ] **Exceções documentadas** com justificativa.

#### Pós-Implementação:

* [ ] **Monitoramento diário** de eventos de bloqueio.
* [ ] **Revisão semanal** de logs de auditoria.
* [ ] **Processo de solicitação** para novas regras.
* [ ] **Backup regular** das políticas XML.

***

## ⚖️ AppLocker vs. WDAC

O **Windows Defender Application Control (WDAC)** é a evolução do AppLocker, introduzido no Windows 10 e Windows Server 2016.

| **Característica**              | **AppLocker**          | **WDAC**                                 |
| ------------------------------- | ---------------------- | ---------------------------------------- |
| **Controle de Kernel**          | Usuário                | Kernel (mais seguro)                     |
| **Proteção de Boot**            | Não                    | Sim (protege drivers e kernel)           |
| **Controle de Drivers**         | Não                    | Sim                                      |
| **Facilidade de Gerenciamento** | Mais fácil (GUI + GPO) | Mais complexo (apenas PowerShell/XML)    |
| **Suporte a Assinatura**        | Sim                    | Sim (mais granular)                      |
| **Windows 10/11**               | Sim                    | Sim (recomendado para novos deployments) |
| **Windows Server**              | Sim                    | Sim (2016+)                              |

**Recomendação:**

* **AppLocker:** Ambientes legados, facilidade de gerenciamento, equipes menores.
* **WDAC:** Ambientes de alta segurança, proteção de kernel, organizações com maturidade em segurança.

***

## 📚 Conclusão

O AppLocker é uma ferramenta poderosa para controle de aplicações em ambientes Windows, oferecendo:

* ✅ **Flexibilidade** através de múltiplos tipos de regras.
* ✅ **Segurança** com granularidade por usuário/grupo.
* ✅ **Gerenciabilidade** via Active Directory e Políticas de Grupo.
* ✅ **Testabilidade** com modo de auditoria.

A implementação bem-sucedida requer planejamento, testes e monitoramento contínuo. Combine o AppLocker com outras medidas de segurança (como WDAC, LAPS, e políticas de restrição de PowerShell) para uma defesa em profundidade eficaz.

***

## 🔗 Referências

* [Microsoft Docs: AppLocker Overview](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/applocker/applocker-overview)
* [Microsoft Docs: AppLocker Design Guide](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/applocker/applocker-design-guide)
* [Microsoft Docs: AppLocker PowerShell Commands](https://learn.microsoft.com/en-us/powershell/module/applocker/)
* [Microsoft Docs: AppLocker Events](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/applocker/using-event-viewer-with-applocker)
* [Microsoft Docs: Windows Defender Application Control (WDAC)](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/windows-defender-application-control/windows-defender-application-control)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/ambientes/windows/applocker.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.