microsoft/cyberbattlesimUma plataforma de experimentação e pesquisa para investigar a interação de agentes automatizados em ambientes de rede simulados abstratos.
8 de abril de 2021: Veja o anúncio no Blog de Segurança da Microsoft.
O CyberBattleSim é uma plataforma de pesquisa experimental para investigar a interação de agentes automatizados operando em um ambiente de rede empresarial abstrato simulado. A simulação fornece uma abstração de alto nível de redes de computadores e conceitos de segurança cibernética. Sua interface Open AI Gym baseada em Python permite o treinamento de agentes automatizados usando algoritmos de aprendizado por reforço.
O ambiente de simulação é parametrizado por uma topologia de rede fixa e um conjunto de vulnerabilidades que os agentes podem utilizar para se mover lateralmente na rede. O objetivo do atacante é tomar posse de uma parte da rede explorando vulnerabilidades que estão plantadas nos nós de computador. Enquanto o atacante tenta se espalhar pela rede, um agente defensor monitora a atividade da rede e tenta detectar qualquer ataque em andamento e mitigar o impacto no sistema expulsando o atacante. Fornecemos um defensor estocástico básico que detecta e mitiga ataques em andamento com base em probabilidades predefinidas de sucesso. Implementamos a mitigação refazendo a imagem dos nós infectados, um processo modelado abstratamente como uma operação que abrange várias etapas de simulação.
Para comparar o desempenho dos agentes, analisamos duas métricas: o número de etapas de simulação necessárias para atingir seu objetivo e as recompensas acumuladas ao longo das etapas de simulação durante as épocas de treinamento.
Vemos este projeto como uma plataforma de experimentação para conduzir pesquisa sobre a interação de agentes automatizados em ambientes de rede simulados abstratos. Ao abrir seu código-fonte, esperamos encorajar a comunidade de pesquisa a investigar como os ciberagentes interagem e evoluem em tais ambientes de rede.
A simulação que fornecemos é reconhecidamente simplista, mas isso tem vantagens. Sua natureza altamente abstrata proíbe a aplicação direta a sistemas do mundo real, fornecendo assim uma salvaguarda contra o uso nefasto potencial de agentes automatizados treinados com ela. Ao mesmo tempo, sua simplicidade nos permite focar em aspectos específicos de segurança que pretendemos estudar e experimentar rapidamente com algoritmos recentes de aprendizado de máquina e IA.
Por exemplo, a implementação atual se concentra em técnicas de ataque de movimento lateral, na esperança de entender como a topologia e a configuração da rede as afetam. Com esse objetivo em mente, sentimos que modelar o tráfego real de rede não era necessário. Este é apenas um exemplo de uma limitação significativa em nosso sistema que contribuições futuras podem querer abordar.
No lado algorítmico, fornecemos alguns agentes básicos como pontos de partida, mas estaríamos curiosos para descobrir como algoritmos de aprendizado por reforço de ponta se comparam a eles. Descobrimos que o grande espaço de ação intrínseco a qualquer sistema de computador é um desafio particular para o Aprendizado por Reforço, em contraste com outras aplicações, como videogames ou controle de robôs. Treinar agentes que possam armazenar e recuperar credenciais é outro desafio enfrentado ao aplicar técnicas de RL onde os agentes normalmente não possuem memória interna. Essas são outras áreas de pesquisa onde a simulação pode ser usada para fins de benchmarking.
Outras áreas de interesse incluem o uso responsável e ético de sistemas autônomos de segurança cibernética: Como projetar uma rede empresarial que dê uma vantagem intrínseca aos agentes defensores? Como conduzir pesquisa segura com o objetivo de defender empresas contra ataques cibernéticos autônomos, evitando ao mesmo tempo o uso nefasto de tal tecnologia?
Leia a Introdução rápida ao projeto.
| Tipo | Ramo | Status |
|---|---|---|
| CI | master |  |
| Imagem Docker | master |  |
Veja a documentação de Benchmark. Os notebooks Jupyter com as execuções mais recentes estão registrados sob uma tag dedicada em /notebooks/benchmarks (latest_benchmark).
É fortemente recomendado trabalhar em um ambiente Linux, diretamente ou via WSL no Windows. Executar Python diretamente no Windows deve funcionar, mas não é mais suportado.
Comece verificando o repositório:
git clone https://github.com/microsoft/CyberBattleSim.git
Se você obtiver o seguinte erro ao executar o papermill nos notebooks
(ou alternativamente ao executar orca --help)
/home/wiblum/miniconda3/envs/cybersim/lib/orca_app/orca: error while loading shared libraries: libXss.so.1: cannot open shared object file: No such file or directory
ou outras bibliotecas compartilhadas como libgdk_pixbuf-2.0.so.0,
Então execute o seguinte comando:
sudo apt install libnss3-dev libgtk-3-0 libxss1 libasound2-dev libgtk2.0-0 libgconf-2-4
As instruções foram testadas em uma distribuição Ubuntu Linux (tanto nativa quanto via WSL).
Se o conda não estiver instalado, você precisa instalá-lo executando o script install_conda.sh.
bash install-conda.sh
Feito isso, abra um novo terminal e execute o script de inicialização:
bash init.sh
Isso criará um ambiente conda chamado cybersim com todas as dependências necessárias do sistema operacional e Python.
Para ativar o ambiente, execute:
conda activate cybersim
O ambiente de desenvolvimento suportado no Windows é via WSL. Você primeiro precisa instalar uma distribuição Ubuntu WSL em sua máquina Windows, e então prosseguir com as instruções para Linux (próxima seção).
Para autenticar com Git, você pode usar autenticação baseada em SSH ou alternativamente usar o truque de auxiliar de credencial para gerar automaticamente um token PAT. Isso pode ser feito executando o seguinte comando no WSL (mais informações aqui):
git config --global credential.helper "/mnt/c/Program\ Files/Git/mingw64/libexec/git-core/git-credential-manager.exe"
Para executar seu ambiente dentro de um contêiner Docker, recomendamos executar docker via Subsistema Windows para Linux (WSL) usando as seguintes instruções:
Instalando Docker no Windows sob WSL).
Este método não é mais mantido; prefira executar em
um ambiente Linux via WSL.
Mas se você insistir, comece instalando Python 3.10 e então, em um prompt do Powershell, execute o script ./init.ps1.
O método mais rápido para começar é através do contêiner Docker.
NOTA: Por razões de licenciamento, não redistribuímos publicamente nenhum artefato de build. Em particular, o registro Docker
spinshot.azurecr.iomencionado nos comandos abaixo é mantido privado apenas para os mantenedores do projeto.Como alternativa, você pode recriar a imagem Docker usando o
Dockerfilefornecido, publicar a imagem resultante em seu próprio registro Docker e substituir o nome do registro nos comandos abaixo.
commit=7c1f8c80bc53353937e3c69b0f5f799ebb2b03ee
docker login spinshot.azurecr.io
docker pull spinshot.azurecr.io/cyberbattle:$commit
docker run -it spinshot.azurecr.io/cyberbattle:$commit python -m cyberbattle.agents.baseline.run
docker build -t cyberbattle:1.1 .
docker run -it -v "$(pwd)":/source --rm cyberbattle:1.1 python -m cyberbattle.agents.baseline.run
Execute os seguintes comandos para executar uma simulação com um agente RL de base:
python -m cyberbattle.agents.baseline.run --training_episode_count 5 --eval_episode_count 3 --iteration_count 100 --rewardplot_width 80 --chain_size=4 --ownership_goal 0.2
python -m cyberbattle.agents.baseline.run --training_episode_count 5 --eval_episode_count 3 --iteration_count 100 --rewardplot_width 80 --chain_size=4 --reward_goal 50 --ownership_goal 0
Se tudo estiver configurado corretamente, você deve obter uma saída semelhante a esta:
torch cuda available=True
###### DQL
Learning with: episode_count=1,iteration_count=10,ϵ=0.9,ϵ_min=0.1, ϵ_expdecay=5000,γ=0.015, lr=0.01, replaymemory=10000,
batch=512, target_update=10
## Episode: 1/1 'DQL' ϵ=0.9000, γ=0.015, lr=0.01, replaymemory=10000,
batch=512, target_update=10
Episode 1|Iteration 10|reward: 139.0|Elapsed Time: 0:00:00|###################################################################|
###### Random search
Learning with: episode_count=1,iteration_count=10,ϵ=1.0,ϵ_min=0.0,
## Episode: 1/1 'Random search' ϵ=1.0000,
Episode 1|Iteration 10|reward: 194.0|Elapsed Time: 0:00:00|###################################################################|
simulation ended
Episode duration -- DQN=Red, Random=Green
10.00 ┼
Cumulative rewards -- DQN=Red, Random=Green
194.00 ┼ ╭──╴
174.60 ┤ │
155.20 ┤╭─────╯
135.80 ┤│ ╭──╴
116.40 ┤│ │
97.00 ┤│ ╭╯
77.60 ┤│ │
58.20 ┤╯ ╭──╯
38.80 ┤ │
19.40 ┤ │
0.00 ┼──╯
Para se familiarizar rapidamente com o projeto, você pode abrir um dos notebooks Jupyter fornecidos para interagir interativamente com os ambientes gymnasium.
Notas sobre os notebooks
.py:
- Nossos notebooks são registrados no Git como arquivos
.py. Eles podem ser abertos e executados diretamente no VSCode ou no Jupyter usando a extensão Jupytext.- Os arquivos
.ipynbde saída também podem ser regenerados automaticamente usando papermill executando o script bash run_benchmark.sh.- Também publicamos um snapshot dos notebooks
.ipynbcorrespondentes com toda a saída e plotagens em uma tag git separada. O snapshot mais recente da saída dos notebooks Jupyter, incluindo os benchmarks, está acessível a partir da seguinte tag git: /notebooks/benchmarks (latest_benchmark).
Alguns notebooks para começar:
Ambientes de brinquedo 'Capture The Flag':
Ambientes de cadeia:
Outros ambientes:
Benchmarks: Os seguintes notebooks mostram a avaliação de benchmark dos agentes de base em vários ambientes.
O snapshot mais recente da saída dos notebooks Jupyter, incluindo os benchmarks, está acessível a partir da seguinte tag git: /notebooks/benchmarks (latest_benchmark).
O código a seguir mostra como criar uma instância do ambiente OpenAI Gym CyberBattleChain-v0, um ambiente baseado em uma estrutura de rede em cadeia, com 10 nós (size=10) onde o objetivo do agente é obter a propriedade total da rede (own_atleast_percent=1.0) ou
quebrar o SLA de 80% de disponibilidade da rede (maintain_sla=0.80), enquanto a rede é monitorada e protegida pelo defensor básico modelado probabilisticamente (defender_agent=ScanAndReimageCompromisedMachines):
import cyberbattle._env.cyberbattle_env
cyberbattlechain_defender =
gym.make('CyberBattleChain-v0',
size=10,
attacker_goal=AttackerGoal(
own_atleast=0,
own_atleast_percent=1.0
),
defender_constraint=DefenderConstraint(
maintain_sla=0.80
),
defender_agent=ScanAndReimageCompromisedMachines(
probability=0.6,
scan_capacity=2,
scan_frequency=5))
Para experimentar outras topologias de rede, tome como exemplo chainpattern.py para definir seu próprio conjunto de máquinas e vulnerabilidades, depois adicione uma entrada em o inicializador do módulo para declarar e registrar o ambiente Gym.
Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que você concorde com um Contrato de Licença de Contribuidor (CLA) declarando que você tem o direito de nos conceder, e de fato concede, os direitos de uso de sua contribuição. Para detalhes, visite https://cla.opensource.microsoft.com.
Ao enviar um pull request, um bot do CLA determinará automaticamente se você precisa fornecer um CLA e decorará o PR apropriadamente (por exemplo, verificação de status, comentário). Simplesmente siga as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios que usam nosso CLA.
Este projeto adotou o Código de Conduta de Código Aberto da Microsoft. Para mais informações, consulte as Perguntas Frequentes sobre o Código de Conduta ou entre em contato com [email protected] para quaisquer perguntas ou comentários adicionais.
Aqui estão algumas ideias de como contribuir: aprimorar a simulação (baseada em eventos, refinamento da simulação, …), treinar um algoritmo de RL na simulação existente, implementar benchmark para avaliar e comparar novidade dos agentes, adicionar mais modos gerativos de rede para treinar o agente de RL, contribuir com a documentação, corrigir bugs.
Veja também o wiki para mais ideias.
@misc{msft:cyberbattlesim,
Author = {Microsoft Defender Research Team.}
Note = {Criado por Christian Seifert, Michael Betser, William Blum, James Bono, Kate Farris, Emily Goren, Justin Grana, Kristian Holsheimer, Brandon Marken, Joshua Neil, Nicole Nichols, Jugal Parikh, Haoran Wei.},
Publisher = {GitHub},
Howpublished = {\url{https://github.com/microsoft/cyberbattlesim}},
Title = {CyberBattleSim},
Year = {2021}
}
Este projeto não inclui nenhum dado de cliente. Os modelos e topologias de rede fornecidos são puramente fictícios. Os usuários do código fornecido fornecem toda a entrada para a simulação e devem ter as permissões necessárias para usar quaisquer dados fornecidos.
Este projeto pode conter marcas registradas ou logotipos para projetos, produtos ou serviços. O uso autorizado de marcas registradas ou logotipos da Microsoft está sujeito e deve seguir as Diretrizes de Marca Registrada e Marca da Microsoft. O uso de marcas registradas ou logotipos da Microsoft em versões modificadas deste projeto não deve causar confusão ou implicar patrocínio da Microsoft. Qualquer uso de marcas registradas ou logotipos de terceiros está sujeito às políticas desses terceiros.