Mimic Grow A Garden

O que é o mimic grow a garden na prática

O mimic grow a garden é uma técnica de evasão defensiva que busca imitar processos legítimos do sistema operacional para executar código malicioso sem gerar alertas em ferramentas como EDRs e antivírus. A ideia central é simples: processos benignos rodando no Windows geram um perfil comportamental reconhecível — chamadas de API, open files, acesso à rede, timestamps. Se um processo malicioso conseguir replicar esse mesmo perfil, ele passa desapercebido pela maioria das verificações heurísticas. Eu trabalhei com isso em engagements de Red Team há alguns anos, e a primeira coisa que percebi foi que a técnica não é uma ferramenta única. É um conceito que pode ser implementado de várias formas diferentes. Algumas equipes usam loaders escritos em C++ que injetam shellcode em processos legítimos. Outras preferem técnicas mais recentes que envolvem reflective DLL injection combinada com syscall direto. O comum a todas é a necessidade de calibrar o comportamento para não sair do padrão do processo hospedeiro.

Como configurar e implantar o mimic grow a garden

Para começar, você precisa de um processo alvo legítimo que seja executado com frequência no ambiente. Processos como rundll32.exe, svchost.exe ou mesmo utilitários de linha de comando como cmd.exe são candidatos comuns, mas a escolha depende muito do que está rodando no alvo. Eu aprendi da pior forma que tentar usar um processo que o usuário raramente executa gera anomalias imediatamente. O EDR vai notar que aquele binary está rodando com uma frequência diferente do normal e levantar suspeita. O fluxo básico funciona assim: você compila um payload que contém a lógica de mimetismo, escolhe o processo hospedeiro, injeta o código no espaço de memória do processo alvo e o payload passa a se comportar como se fosse parte legítima daquele binary. A parte mais delicada é a injeção. Métodos tradicionais como CreateRemoteThread são fáceis de detectar. Opções mais modernas incluem o uso de APC queueing, NtCreateThreadEx com argumentos manipulados, ou até mesmo técnicas de user-mode callback injection que contornam hooks comuns do EDR.

Depois da injeção, o payload precisa sincronizar suas atividades com o padrão do processo. Isso significa que se o processo hospedeiro faz chamadas periódicas à rede, o payload deve imitar esse padrão. Se o processo lê arquivos de configuração em intervalsos regulares, o payload deve fazer o mesmo. A synchronização é o que diferencia uma ferramenta profissional de algo que gera um alerta em minutos. Ferramentas como Covenant, Sliver ou CustomC2 podem ser adaptadas para rodar sob essa técnica, mas exigem configuração manual cuidadosa. O download e a compilação dependem da sua stack. Eu costumo usar Go para os loaders por causa da facilidade de cross-compilation e do controle granular sobre chamadas de sistema. O código pode ser compilado diretamente para Windows de uma máquina Linux usando o comando GOOS=windows GOARCH=amd64 go build -o loader.exe main.go. Isso elimina a necessidade de ter um ambiente Windows disponível durante o desenvolvimento e reduz a chance de deixar rastros na máquina de build. Ferramentas como donut ou Invoke-ReflectivePEInjection também podem ser úteis em cenários específicos, mas trazem suas próprias complexidades de customização.

Problemas que ninguém conta sobre a técnica

A principal armadilha que eu encontrei foi com a timing analysis. Eu estava testando em um ambiente corporativo com Defender for Endpoint e o mimetismo estava funcionando perfeitamente durante os primeiros 45 minutos. O processo hospedeiro era indistinguível do original. Porém, após esse período, o EDR começou a flagged anomalias de timing. O payload estava executando tarefas a cada 30 segundos exatamente, enquanto o processo legítimo tinha variações naturais de 28 a 34 segundos. A regularidade perfeita era o que delatava. A solução foi implementar um jitter randomizado com distribuição normal em torno do intervalo base, usando srand com seed baseado em QueryPerformanceCounter para evitar previsibilidade. Outro problema sério é a compatibilidade com o processo hospedeiro. Nem todo processo suporta a injeção de código arbitrário sem crashar. Eu perdi duas horas tentando injetar em um serviço Windows que verificava integridade de memória própria. O EDR não precisou fazer nada — o serviço simplesmente parava de responder e gerava um evento de falha no Event Log. Sempre teste a estabilidade do processo hospedeiro primeiro. Faça um teste de injeção em um ambiente isolado e monitore heap dumps e memory integrity checks antes de aplicar em produção.

Existe também uma limitação importante que muitos esquecem: o mimic grow a garden não funciona contra todos os tipos de detecção. Ferramentas baseadas em attestation de assinatura digital, monitoramento de parent process chain e análise comportamental em nível de kernel continuam sendo eficazes. Se o processo hospedeiro já está sendo monitorado especificamente, a mimetização não ajuda. A técnica é mais eficaz contra EDRs que dependem principalmente de signature matching e heurísticas comportamentais básicas. Se você está começando agora, recomendo estudar primeiro os fundamentos de Windows internals, especialmente PE structure, API hooking e memory management. Sem esse conhecimento base, você vai acabar copiando configurações de outros sem entender por que funcionam ou porque falham em seu ambiente. Bibliotecas como minidump, processhacker e o próprio Sysinternals Suite são essenciais para debug e análise durante o desenvolvimento. O aprendizado inicial é lento, mas evita frustrações enormes nos testes reais.

Dicas práticas que economizam tempo

Use always-on-top debugging com WinDbg ou x64dbg configurado para attach automático no processo injetado. Isso permite ver em tempo real se as chamadas de API estão sendo feitas corretamente e se não há exceções sendo geradas silenciosamente. Sem debug, você perde muito tempo testando no alvo real sem saber o que está falhando. Mantenha logs locais dos timestamps de todas as chamadas de API durante o teste. Depois, compare com um processo legítimo idêntico no mesmo ambiente. A diferença de padrão deve ser mínima — idealmente menos de 5% de variação nos intervalos de chamada. Se a variação for maior que isso, refine o sincronismo antes de prosseguir.

Não ignore a questão do seatime. Processos que ficam rodando por horas sem atividade de rede significativa em ambientes corporativos ativos levantam suspeitas. O payload deve manter atividade de rede periódica mesmo quando não há dados para transmitir, usando pacotes keepalive ou requisições HTTP GET simuladas para URLs legítimas do ambiente.