SOC: resposta a incidentes, automação e playbooks

Fundamentos de resposta a incidentes - Apresentação

Apresentando o curso e o instrutor

Olá! Seja muito bem-vinde ao nosso curso de SOC com foco em resposta a incidentes. Eu sou Fernando Luis de Oliveira Costa e serei o seu instrutor nesta jornada.

Audiodescrição: Eu sou um homem branco, de cabelo castanho curto, barba curta e uso óculos.

Como profissionais de SOC, sabemos muito bem o que será enfrentado: o frio na barriga do primeiro incidente, a pressão de tomar decisões que podem salvar ou comprometer a empresa, e a satisfação de conduzir uma resposta bem executada, conter um ataque em minutos e ver os sistemas voltando ao ar. O objetivo deste curso é preparar para esses momentos. Não apenas com teoria: vamos praticar com laboratórios que simulam incidentes reais, playbooks (roteiros) que poderão ser utilizados nas empresas e checklists (listas de verificação) que guiarão o trabalho no dia a dia. Se você já atua ou deseja atuar com SOC, este curso é para você.

No âmbito profissional, eu tenho mais de 18 anos de experiência em Cibersegurança, Segurança da Informação e Tecnologia da Informação, com passagens pelas Forças Armadas, pela Envilha (empresa do grupo Compass UOL) e também pelo Banco Votorantim. Em termos de formação, sou bacharel em Ciência da Computação pela Unicamp, sou pós-graduado em Defesa Cibernética, tenho um curso avançado de Guerra Cibernética e certificações como OSCP, CCNA, Microsoft, AWS, entre outras. Quem quiser meu contato, meu LinkedIn é fernando-oliveira-costa.

Contextualizando o mercado e a demanda

Antes de mergulharmos no conteúdo, vamos contextualizar por que este curso é importante para a carreira. O mercado de Segurança Cibernética está em plena expansão. As empresas buscam pessoas que saibam responder a incidentes, que, quando o alarme tocar, não congelem, saibam o que fazer nos primeiros cinco minutos, tenham método, calma e competência técnica. As estatísticas comprovam: ataques de ransomware (sequestro de dados) cresceram mais de 60% nos últimos anos; o custo médio de uma violação de dados já ultrapassa 4 milhões de dólares; e o tempo médio para detectar e conter um incidente ainda é de quase 300 dias em muitas organizações.

Como percebemos, o cenário de segurança da informação é crítico, e os números vêm aumentando. Isso significa demanda crescente por profissionais — principalmente pessoas analistas de SOC — que dominem os fundamentos de resposta a incidentes, reduzam o tempo de detecção e de contenção e minimizem os impactos inevitáveis para as empresas. Este curso foi desenhado exatamente para isso: formar profissionais capazes de responder a incidentes.

Apresentando a estrutura do curso

O curso está organizado em seis aulas, cada uma cobrindo uma parte essencial do ciclo de resposta a incidentes.

Na Aula 1, vamos abordar os fundamentos da resposta a incidentes. Vamos aprender os conceitos essenciais e a diferença entre evento, incidente e problema. Vamos conhecer os dois principais modelos de ciclo de resposta, o NIST e o PICERL. Vamos entender os papéis e responsabilidades durante um incidente — quem decide, quem executa, quem comunica. E vamos compreender o que significa alcançar uma preparação efetiva: as políticas, o plano de resposta, os playbooks (roteiros) e as simulações.

Aula 2 — detecção e análise: vamos aprender a realizar a triagem de alertas, priorizar com critérios objetivos, escalar corretamente e conduzir a análise de causa raiz, utilizando o Modelo Diamante de Análise de Intrusão e o método dos 5 porquês. Vamos priorizar alertas do SOC com um script (roteiro de automação) em Python e analisar um ataque simulado.

Aula 3 — contenção: esta é uma fase mais intensa. Vamos aprender a conter um incidente sem destruir evidências, isolar endpoints (dispositivos finais) comprometidos em Windows e Linux, bloquear credenciais e revogar acessos, conter a movimentação de atacantes (movimento lateral) e tomar decisões difíceis. Quando o isolamento impacta o negócio, o que nós fazemos?

Aula 4 — erradicação e recuperação: com o atacante contido, vamos remover completamente a ameaça, identificando e eliminando artefatos maliciosos, persistências e backdoors (acessos clandestinos). Vamos validar que a erradicação foi completa, recuperar os sistemas com segurança, restaurar os backups, validar a integridade e implementar monitoramento pós-recuperação.

Aula 5 — runbooks e playbooks: vamos construir playbooks (roteiros de resposta) completos para os cenários mais comuns do dia a dia — phishing (fraude de isca), brute force (força bruta), conta comprometida, ransomware (sequestro de dados), exfiltração de dados, entre outros. Vamos adaptar esses playbooks ao ambiente específico da sua organização e executar um playbook de ponta a ponta. Também veremos como estruturar e manter os runbooks (guias operacionais) necessários.

Aula 6 — comunicação, documentação e lições aprendidas: embora muitas vezes subestimada, esta parte separa um excelente analista de um bom analista. Vamos aprender que a comunicação, especialmente durante uma crise, exige método e faz muita diferença. Vamos entender as obrigações de notificar a ANPD, em conformidade com a LGPD e a GDPR. Também vamos estruturar um relatório completo e conduzir as lições aprendidas, que frequentemente são reuniões subestimadas ou mal conduzidas nas empresas, abordando como torná-las relevantes para a organização.

Organizando a prática e os requisitos

Este não é um curso para assistir passivamente. É um curso para praticar. Cada aula inclui laboratórios práticos para executarmos em nossa própria máquina. Vamos perceber que a teoria é importante, mas a prática é determinante para o sucesso.

Do que vamos precisar? De um computador com pelo menos 8 GB de RAM; o ideal é 16 GB para que os laboratórios rodem sem problemas.

O curso está estruturado em 24 vídeos de conteúdo, para estudarmos no nosso ritmo, pausando quando necessário e repetindo quantas vezes desejarmos. Em cada vídeo, encontraremos exercícios práticos: vamos solicitar que você pause, execute uma tarefa e depois retorne para conferir o gabarito. Realize os exercícios em um pool (conjunto); é neles que vamos aprender e consolidar o aprendizado.

No próximo vídeo, dedicado à preparação do laboratório, vamos orientar a instalação e a configuração de todo o ambiente. Não se preocupe: haverá dois vídeos que guiarão essa preparação. Não pule essas aulas; é importante que o ambiente esteja bem configurado para a prática dos exercícios de laboratório.

Eu estou muito feliz de ter vocês aqui. Para nós, a resposta a incidentes é uma das áreas mais desafiadoras e gratificantes da segurança e, ao final do curso, teremos o preparo para encarar esses desafios. Vamos começar? Te vejo no próximo vídeo.

Fundamentos de resposta a incidentes - Configurando laboratório com VirtualBox e Vagrant

Preparando o ambiente com virtualbox

Olá! Seja bem-vinde ao vídeo de preparação do laboratório.

Neste vídeo, nós faremos a instalação do VirtualBox e de duas máquinas virtuais: uma com Windows e outra com Linux. Inicialmente, faremos a baixa do VirtualBox. Para isso, vamos acessar a página de Downloads (downloads) do VirtualBox. Basta pesquisar no Google por VirtualBox Downloads para chegar a essa página.

Nesta página, nós encontramos duas opções. Faremos a baixa do instalador em VirtualBox Platform Packages (Pacotes da Plataforma do VirtualBox), ou seja, o instalador da versão mais recente, escolhendo o sistema operacional que estamos utilizando. No lado direito, também faremos a baixa do VirtualBox Extension Pack (Pacote de Extensão do VirtualBox). Basta selecionar Accept Download (Aceitar download), e esses dois arquivos serão baixados. Não faremos a instalação aqui porque já temos o VirtualBox instalado em nosso ambiente. A instalação consiste em executar os arquivos com dois cliques e seguir a instalação padrão, aceitando todas as opções.

Requisitos para o computador:

• 8 GB de RAM (preferencialmente 16 GB, para que as máquinas sejam executadas com mais rapidez).
• 50 GB de espaço em disco.
• Processador com suporte à virtualização.

Instalando o vagrant e verificando a versão

Em seguida, faremos a instalação do Vagrant. O Vagrant é uma ferramenta de IaC, Infrastructure as Code (infraestrutura como código). Ele facilita, pois permite que nós automatizemos a criação e a configuração das máquinas virtuais, sem precisar baixar a ISO e instalar manualmente.

Da mesma forma, pesquisamos no Google por Vagrant Downloads e encontramos a página. Nela, nós escolhemos o arquivo que corresponde ao sistema operacional que estamos utilizando, seja macOS, Windows ou Linux. Em seguida, seguimos com a instalação padrão.

Para verificar, depois da instalação, se está funcionando, no Windows abrimos o PowerShell e, no Linux e no macOS, abrimos o terminal e executamos, em qualquer diretório, o comando vagrant --version. O Vagrant apresentará a versão instalada. Se a versão aparecer, deu tudo certo. Se for solicitado o reboot (reinicialização) da máquina, realizamos a reinicialização e retomamos o vídeo.

Para realizar essa verificação, execute:

vagrant --version

Criando o diretório do projeto e inicializando o vagrant

Depois disso, criaremos uma pasta (diretório) para hospedar os arquivos de configuração das máquinas virtuais. No terminal, executamos o comando mkdir labsoc para criar a pasta "labsoc" (você pode escolher outro nome, se preferir). Em seguida, acessamos esse diretório.

Como exemplo prático de criação e acesso ao diretório (em um ambiente Windows), os comandos podem ser:

mkdir LabSoC
cd LabSoC\

O próximo comando que vamos executar é vagrant init. Esse comando prepara esse diretório para a criação das máquinas virtuais.

No terminal, rode:

vagrant init

Após a execução, notamos que foi criado um arquivo chamado Vagrantfile. Isso quer dizer que deu tudo certo. Esse arquivo, que é o arquivo de configuração do Vagrant, é onde vamos definir as máquinas que queremos criar; portanto, precisaremos editá-lo.

Editando o vagrantfile com a configuração do laboratório

Para editar esse arquivo, acessaremos as configurações que já estão no nosso repositório do GitHub, no link que estamos disponibilizando aqui. Pause o vídeo e digite esse link no navegador. Ao acessar o repositório, encontramos as configurações do Vagrant que utilizaremos no laboratório. Copiamos o conteúdo desse arquivo. Depois de copiar, voltamos ao terminal e acessamos esse arquivo.

No caso do Windows (Windows), nós vamos realizar pela interface gráfica. No caso de Linux (Linux) e macOS (macOS), basta abrir com o editor nano ou qualquer outro editor de arquivos e editar esse arquivo. Nós vamos usar a interface gráfica do Windows (Windows), que é mais simples e comum.

Será aberto o diretório que nós criamos, exibido como pasta. Com o botão direito, nós vamos editar esse arquivo com o Bloco de Notas. Se houver outro editor, não há problema.

Haverá um conjunto de configurações, cujas recomendações estão todas comentadas. Vamos selecionar tudo, excluir e copiar as configurações que estão no nosso repositório.

Esse é um exemplo completo de Vagrantfile com as duas VMs do laboratório:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  # VM Windows 10
  config.vm.define "windows" do |win|
    win.vm.box = "gusztavvargadr/windows-10"
    win.vm.hostname = "srv-db01"
    win.vm.network "private_network", ip: "192.168.56.10"
    
    win.winrm.transport = :negotiate
    win.winrm.basic_auth_only = true
    win.winrm.retry_delay = 10
    
    win.vm.provider "virtualbox" do |vb|
      vb.memory = "4096"
      vb.cpus = 2
      vb.customize ["modifyvm", :id, "--graphicscontroller", "vboxsvga"]
      vb.customize ["modifyvm", :id, "--vram", "128"]
      vb.customize ["modifyvm", :id, "--accelerate3d", "on"]
      vb.customize ["modifyvm", :id, "--clipboard", "bidirectional"]
      vb.customize ["modifyvm", :id, "--draganddrop", "hosttoguest"]
      vb.customize ["modifyvm", :id, "--usb", "on"]
      vb.customize ["modifyvm", :id, "--usbehci", "on"]
    end
  end

  # VM Ubuntu Linux
  config.vm.define "linux" do |lin|
    lin.vm.box = "ubuntu/jammy64"
    lin.vm.hostname = "analyst"
    lin.vm.network "private_network", ip: "192.168.56.20"

    lin.vm.provider "virtualbox" do |vb|
      vb.memory = "4096"
      vb.cpus = 2
      vb.customize ["modifyvm", :id, "--graphicscontroller", "vmsvga"]
      vb.customize ["modifyvm", :id, "--vram", "128"]
      vb.customize ["modifyvm", :id, "--accelerate3d", "on"]
      vb.customize ["modifyvm", :id, "--clipboard", "bidirectional"]
      vb.customize ["modifyvm", :id, "--draganddrop", "hosttoguest"]
      vb.customize ["modifyvm", :id, "--usb", "on"]
      vb.customize ["modifyvm", :id, "--usbehci", "on"]
      vb.customize ["modifyvm", :id, "--keyboard", "usb"]
      vb.customize ["modifyvm", :id, "--mouse", "usbtablet"]
    end
  end
end

Após isso, salvamos e fechamos o arquivo. Em seguida, voltamos para a nossa apresentação.

Uma explicação curta: nesse arquivo, há duas configurações, correspondentes a cada uma das máquinas que vamos utilizar durante o laboratório.

Criando máquinas virtuais com vagrant

Para criar cada uma das VMs (máquinas virtuais), basta executar o comando vagrant up seguido do nome da máquina que vamos criar, seja a de Windows (Windows) ou a de Linux (Linux). Nós não vamos realizar isso agora, pois pode demorar bastante, já que o Vagrant vai ler esse Vagrantfile, verificar as boxes (imagens base) do Vagrant — os artefatos utilizados para provisionar as VMs — e fazer o download (transferência). Depois, ele cria as máquinas, aplica toda a configuração definida no Vagrantfile e inicia as VMs.

Exemplos de criação das duas VMs:

vagrant up windows
vagrant up linux

Neste momento, executamos esse comando e fazemos uma pausa no vídeo até que tudo seja concluído com êxito. Após a conclusão, a VM de Windows (Windows) será exibida com a interface gráfica. Já a de Linux (Linux) não vem com interface gráfica por padrão.

Instalando interface gráfica no ubuntu

Para instalar uma interface gráfica no Ubuntu, acessamos o diretório que nós já criamos e utilizamos vagrant ssh linux. O usuário e a senha são vagrant/vagrant em ambas as VMs (tanto na de Windows quanto na de Linux); essa é a credencial padrão. Se desejarmos, podemos alterá-la posteriormente.

A sequência de comandos no terminal para atualizar pacotes, instalar os headers do Linux e o Ubuntu Desktop, e reiniciar, pode ser:

vagrant ssh linux
sudo apt update
sudo apt install -y build-essential dkms linux-headers-$(uname -r)
sudo apt install -y ubuntu-desktop
sudo reboot

Em seguida, executamos os comandos sudo apt update e sudo apt install para instalar a última versão dos headers (cabeçalhos) do Linux. Depois, executamos o comando que instalará o Ubuntu Desktop (Área de Trabalho); ao final, a máquina virtual solicitará reinicialização. Após a reinicialização, a instalação da interface gráfica do Ubuntu será concluída.

Observação: caso a VM fique lenta após essa instalação, alteramos, no Vagrantfile ou diretamente na configuração da máquina virtual no VirtualBox, a memória de 2 GB para 4 GB. A configuração padrão da VM de Linux (Linux), por não ter interface gráfica, é 2 GB. Podemos aumentar conforme a disponibilidade de memória do computador em que estamos executando.

Outra observação: caso não haja muita memória disponível, não recomendamos instalar a interface gráfica, pois não será necessária durante a prática das aulas e economiza recursos.

Encerrando e apresentando próximos passos

Por fim, essas são as configurações; a rede já estará funcionando. Ao final desta aula, teremos uma VM de Windows (Windows) com 4 GB e interface gráfica e uma VM de Linux (Linux) com Ubuntu sem interface gráfica, caso não optemos por instalá-la. Para demonstrar, teremos uma VM de Linux (Linux) e uma de Windows (Windows) dentro do VirtualBox; esse é o resultado esperado ao final desta aula.

Combinado?

Encerramos este vídeo por aqui. Na próxima aula, daremos continuidade à preparação deste laboratório, instalando algumas ferramentas nessas VMs e executando alguns scripts para validar se está tudo correto. Te vejo no próximo vídeo.

Fundamentos de resposta a incidentes - Clonando repositório e executando scripts

Iniciando a preparação do laboratório e acessando as máquinas virtuais

Olá! Dando continuidade à preparação do nosso laboratório, no vídeo de hoje nós faremos a instalação de algumas ferramentas que utilizaremos no curso.

Primeiramente, para acessar as nossas VMs, o processo é simples. No caso da VM Windows, abrimos o VirtualBox e damos um duplo clique em LabsocWindows. No caso da VM Linux, temos duas opções: abrir o VirtualBox e dar um duplo clique em LabsocLinux, ou acessar pelo diretório em que configuramos o comando vagrant init e utilizar o comando vagrant ssh linux. Em ambos os casos, para efetuar login, o usuário e a senha são: usuário vagrant e senha vagrant.

Configurando a vm linux e instalando o git

Para começarmos, vamos para a VM Linux. Nela, nós vamos atualizar os pacotes, em seguida instalar o Git, que é a ferramenta utilizada para clonar o repositório contendo todos os scripts e arquivos que usaremos no laboratório. Depois disso, acessaremos o subdiretório "scripts", executaremos o comando de permissão para tornar o script executável e, por fim, executaremos o script.

Na VM Linux, no nosso caso, estamos com a interface gráfica. Caso não esteja com a interface gráfica, não há problema, pois o terminal já estará disponível e todo o procedimento será feito nele. Quem estiver com a interface gráfica deve abrir um terminal.

Para começar, executamos o comando de atualização das listas de pacotes do sistema, de forma que possamos posteriormente instalar o pacote Git. Esse processo normalmente leva poucos segundos; aguardamos a conclusão.

sudo apt update

Em seguida, executamos o comando de instalação do Git com confirmação automática. Em nosso ambiente, o Git já estava instalado; em outros ambientes, a instalação será realizada nesse momento.

sudo apt install git -y

Clonando o repositório e executando os scripts no linux

Agora, seguimos para a clonagem do repositório. Para clonar, utilizamos o comando de clonagem do Git seguido da URL do repositório. Onde obtemos essa URL? No mesmo local onde acessamos os scripts anteriormente. Na página do repositório, na raiz, há o botão “Code” em inglês — isto é, o botão em inglês Code (Código). Ao clicar nele, é exibida a URL; basta clicar no botão de cópia para a área de transferência — em inglês, o botão Copy to clipboard (Copiar para a área de transferência) — para copiar o endereço. Voltamos para a VM Linux e, no terminal, usamos o botão direito e a opção em inglês Paste (Colar) para colar a URL, e então confirmamos a execução. A clonagem do repositório será realizada.

git clone https://github.com/alura-cursos/6258-soc-resposta-incidentes.git

Listando o diretório com o comando apropriado, verificamos que o repositório já está presente. Acessamos o repositório e, dentro dele, o subdiretório "scripts". Ao listar novamente, visualizamos os scripts que utilizaremos na preparação do laboratório.

cd 6258-soc-resposta-incidentes/scripts

Agora, concedemos permissão de execução ao script. Para isso, executamos o comando de alteração de permissões (modo execução para todos) no arquivo install_tools_linux.sh. Em seguida, executamos o arquivo com o prefixo adequado para execução direta. O script inicia sua execução e realiza uma série de ações.

chmod +x install_tools_linux.sh

./install_tools_linux.sh

Esse script pode demorar, pois realiza uma atualização completa do sistema, atualizando todos os pacotes da máquina. Faremos uma pausa e retomaremos quando tudo estiver concluído.

Voltamos. O script foi concluído com sucesso, instalando Python, Netcat, tcpdump e Nmap. O Git já estava instalado e também foram criados alguns diretórios.

Instalando o git no windows e preparando o powershell

Retornamos à nossa apresentação. Agora, vamos acessar a VM Windows. Nessa VM, seguiremos o mesmo passo a passo: primeiramente, faremos o download (transferência) do Git, realizaremos a instalação com as opções padrão e, em seguida, faremos a clonagem do repositório, acessaremos o subdiretório "scripts" e executaremos o script no PowerShell.

Vamos à VM Windows. Primeiramente, abrimos o navegador e fazemos uma busca por Git download (transferência). Será exibida a página de download (transferência) do Git. No nosso caso, como estamos no Windows, a página já oferecerá o instalador correspondente; caso esteja no macOS ou no Linux, haverá as versões específicas para esses sistemas. Realizamos o download (transferência) e executamos o instalador.

Em seguida, seguimos as opções padrão do instalador do Git e concluímos a instalação. A instalação é rápida.

Após concluir a instalação, abrimos o PowerShell para repetir o mesmo passo a passo: a clonagem do repositório do curso. No caso do Windows, devemos nos atentar para realizar a instalação no diretório C:. Ao abrir o PowerShell, ele normalmente inicia no diretório do usuário, ou seja, no home (pasta pessoal do usuário). Em seguida, acessamos o diretório C:\ para que possamos seguir a partir dele com a instalação. A finalização da instalação leva alguns minutos.

cd C:\

Com a instalação concluída, fechamos a janela e abrimos o PowerShell. Na barra de pesquisa do sistema, digitamos “PowerShell” e abrimos o terminal PowerShell para prosseguir com a instalação. Como comentado, o terminal inicia no home (pasta pessoal do usuário); queremos o diretório C:. Ajustamos o terminal para o diretório C:. Aumentamos o tamanho da fonte para facilitar a visualização.

Clonando o repositório e executando os scripts no windows

Com o Git já instalado, executamos git clone, copiando a mesma URL utilizada na máquina Linux. A clonagem do repositório ocorre da mesma forma.

git clone https://github.com/alura-cursos/6258-soc-resposta-incidentes.git

Em seguida, acessamos o subdiretório "scripts".

cd .\6258-soc-resposta-incidentes\scripts\

Para visualizar os arquivos, executamos o comando dir.

dir

Identificamos o script install_tools_windows.ps1. Para executá-lo, utilizamos .\install_tools_windows.ps1. O processo continua seguindo o fluxo definido no script.

.\install_tools_windows.ps1

No Windows, há um detalhe: o script solicita o download manual do pacote Sysinternals Suite. Copiamos a URL indicada, retornamos ao navegador e fazemos o download (transferência). Ao concluir o download (transferência), abrimos a pasta onde o arquivo .zip (arquivo compactado) foi salvo. Clicamos com o botão direito, selecionamos a opção Extract All (Extrair Tudo) e, em seguida, escolhemos Browse (Procurar) para alterar o local de extração. Definimos a pasta de destino, clicamos em Extract (Extrair) e aguardamos a extração ser concluída. Com todos os arquivos extraídos, retornamos ao PowerShell.

No PowerShell, digitamos S (de “SIM”), confirmando que já baixamos e extraímos o pacote. Ao pressionar “Enter”, o processo continua, informando que o Python será instalado. A instalação do Python é automática e pode demorar um pouco.

S

Enquanto o Python é baixado e instalado, explicamos os próximos passos: faremos testes com dois scripts, um na VM Linux e outro na VM Windows, para verificar se a instalação foi concluída corretamente. Aguardamos a instalação do Python e a finalização do script.

Concluída a execução do script no Windows, tudo ocorreu com sucesso: o pacote Sysinternals Suite foi baixado e extraído, e o Python 3 foi instalado. Em seguida, realizamos os testes para confirmar a instalação de todas as ferramentas.

Testando instalações nas máquinas virtuais

Na VM Linux, executamos o script de verificação: python3 prep1_test.py. Após pressionar “Enter”, observamos que todas as instalações foram verificadas com êxito, conforme o esperado.

python3 prep1_test.py

Na VM Windows, executamos o script .\prep1_test.ps1. Da mesma forma, todos os itens são indicados em verde, confirmando que tudo ocorreu corretamente.

.\prep1_test.ps1

Encerrando e administrando máquinas virtuais com vagrant

Esse era o resultado esperado para este vídeo: todas as ferramentas instaladas com sucesso e devidamente verificadas. Também deixamos dicas de alguns comandos do Vagrant para administrar as VMs: subir as VMs, subir uma VM específica, desligar todas, suspender, acessar, verificar o status e, caso seja necessário remover tudo, utilizar vagrant destroy com cautela.

No próximo vídeo, vamos finalizar a preparação do laboratório, criando os usuários e todos os arquivos necessários para os exercícios simulados ao longo do curso. Nos vemos no próximo vídeo.

Sobre o curso SOC: resposta a incidentes, automação e playbooks

O curso SOC: resposta a incidentes, automação e playbooks possui 477 minutos de vídeos, em um total de 52 atividades. Gostou? Conheça nossos outros cursos de Blue Team & SOC em Cibersegurança, ou leia nossos artigos de Cibersegurança.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• O ciclo de resposta a incidentes