microsoft/cyberbattlesimUna plataforma de experimentación e investigación para investigar la interacción de agentes automatizados en entornos de red simulados abstractos.
8 de abril de 2021: Consulte el anuncio en el blog de seguridad de Microsoft.
CyberBattleSim es una plataforma de investigación experimental para investigar la interacción de agentes automatizados que operan en un entorno de red empresarial abstracto simulado. La simulación proporciona una abstracción de alto nivel de las redes informáticas y los conceptos de ciberseguridad. Su interfaz Python basada en OpenAI Gym permite el entrenamiento de agentes automatizados utilizando algoritmos de aprendizaje por refuerzo.
El entorno de simulación está parametrizado por una topología de red fija y un conjunto de vulnerabilidades que los agentes pueden utilizar para moverse lateralmente en la red. El objetivo del atacante es tomar el control de una parte de la red explotando vulnerabilidades que están plantadas en los nodos informáticos. Mientras el atacante intenta propagarse por la red, un agente defensor observa la actividad de la red e intenta detectar cualquier ataque en curso y mitigar el impacto en el sistema expulsando al atacante. Proporcionamos un defensor estocástico básico que detecta y mitiga los ataques en curso basándose en probabilidades predefinidas de éxito. Implementamos la mitigación mediante la reimagen de los nodos infectados, un proceso modelado abstractamente como una operación que abarca múltiples pasos de simulación.
Para comparar el rendimiento de los agentes, observamos dos métricas: la cantidad de pasos de simulación necesarios para alcanzar su objetivo y las recompensas acumuladas a lo largo de los pasos de simulación en las épocas de entrenamiento.
Consideramos este proyecto como una plataforma de experimentación para realizar investigaciones sobre la interacción de agentes automatizados en entornos de red abstractos simulados. Al abrirlo como código abierto, esperamos alentar a la comunidad de investigación a investigar cómo los ciberagentes interactúan y evolucionan en dichos entornos de red.
La simulación que proporcionamos es, sin duda, simplista, pero esto tiene ventajas. Su naturaleza altamente abstracta prohíbe la aplicación directa a sistemas del mundo real, lo que proporciona una salvaguardia contra el posible uso malintencionado de agentes automatizados entrenados con ella. Al mismo tiempo, su simplicidad nos permite centrarnos en aspectos de seguridad específicos que pretendemos estudiar y experimentar rápidamente con algoritmos recientes de aprendizaje automático e IA.
Por ejemplo, la implementación actual se centra en las técnicas de ciberataques de movimiento lateral, con la esperanza de comprender cómo la topología y la configuración de la red los afectan. Con este objetivo en mente, consideramos que no era necesario modelar el tráfico de red real. Este es solo un ejemplo de una limitación significativa en nuestro sistema que las contribuciones futuras podrían querer abordar.
En el aspecto algorítmico, proporcionamos algunos agentes básicos como puntos de partida, pero nos gustaría saber cómo se comparan con ellos los algoritmos de aprendizaje por refuerzo de última generación. Descubrimos que el gran espacio de acción intrínseco a cualquier sistema informático es un desafío particular para el aprendizaje por refuerzo, en contraste con otras aplicaciones como los videojuegos o el control de robots. Entrenar agentes que puedan almacenar y recuperar credenciales es otro desafío que se enfrenta al aplicar técnicas de RL donde los agentes típicamente no tienen memoria interna. Estas son otras áreas de investigación donde la simulación podría usarse con fines de evaluación comparativa.
Otras áreas de interés incluyen el uso responsable y ético de los sistemas autónomos de ciberseguridad: ¿Cómo diseñar una red empresarial que brinde una ventaja intrínseca a los agentes defensores? ¿Cómo realizar una investigación segura destinada a defender las empresas contra ciberataques autónomos y al mismo tiempo prevenir el uso malintencionado de dicha tecnología?
Lea la Introducción rápida al proyecto.
| Tipo | Rama | Estado |
|---|---|---|
| CI | master |  |
| Imagen Docker | master |  |
Consulte la Documentación de evaluación comparativa. Los cuadernos Jupyter con las últimas ejecuciones están verificados en una etiqueta dedicada en /notebooks/benchmarks (latest_benchmark).
Se recomienda encarecidamente trabajar en un entorno Linux, ya sea directamente o mediante WSL en Windows. Ejecutar Python directamente en Windows debería funcionar, pero ya no es compatible.
Comience clonando el repositorio:
git clone https://github.com/microsoft/CyberBattleSim.git
Si obtiene el siguiente error al ejecutar papermill en los cuadernos (o alternativamente al ejecutar 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
u otras bibliotecas compartidas como libgdk_pixbuf-2.0.so.0,
entonces ejecute el siguiente comando:
sudo apt install libnss3-dev libgtk-3-0 libxss1 libasound2-dev libgtk2.0-0 libgconf-2-4
Las instrucciones se probaron en una distribución de Linux Ubuntu (tanto nativa como a través de WSL).
Si conda no está instalado, debe instalarlo ejecutando el script install_conda.sh.
bash install-conda.sh
Una vez hecho esto, abra una nueva terminal y ejecute el script de inicialización:
bash init.sh
Esto creará un entorno conda llamado cybersim con todas las dependencias de SO y python requeridas.
Para activar el entorno ejecute:
conda activate cybersim
El entorno de desarrollo compatible en Windows es a través de WSL. Primero debe instalar una distribución de Ubuntu WSL en su máquina Windows, y luego continúe con las instrucciones de Linux (sección siguiente).
Para autenticarse con Git, puede usar la autenticación basada en SSH o alternativamente use el truco de credential-helper para generar automáticamente un token PAT. Esto último se puede hacer ejecutando el siguiente comando en WSL (más información aquí):
git config --global credential.helper "/mnt/c/Program\ Files/Git/mingw64/libexec/git-core/git-credential-manager.exe"
Para ejecutar su entorno dentro de un contenedor Docker, recomendamos ejecutar docker a través del Subsistema de Windows para Linux (WSL) usando las siguientes instrucciones:
Instalación de Docker en Windows bajo WSL).
Este método ya no se mantiene; en su lugar, prefiera ejecutarlo en
un entorno Linux de subsistema WSL.
Pero si insiste, comience instalando Python 3.10 y luego, en un símbolo del sistema de Powershell, ejecute el script ./init.ps1.
El método más rápido para ponerse en marcha es a través del contenedor Docker.
NOTA: por razones de licencia, no redistribuimos públicamente ningún artefacto de compilación. En particular, el registro de Docker
spinshot.azurecr.ioal que se hace referencia en los comandos siguientes se mantiene privado solo para los mantenedores del proyecto.Como solución alternativa, puede recrear la imagen de Docker usted mismo usando el
Dockerfileproporcionado, publicar la imagen resultante en su propio registro de Docker y reemplazar el nombre del registro en los comandos siguientes.
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
Ejecute los siguientes comandos para ejecutar una simulación con un agente RL de referencia:
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
Si todo está configurado correctamente, debería obtener una salida similar 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 familiarizarse rápidamente con el proyecto, puede abrir uno de los cuadernos Jupyter proporcionados para jugar de forma interactiva con los entornos de gymnasium.
Notas sobre los cuadernos
.py:
- Nuestros cuadernos están verificados en Git como archivos
.py. Se pueden abrir y ejecutar directamente en VSCode o en Jupyter usando la extensión Jupytext.- Los archivos
.ipynbde salida también se pueden regenerar automáticamente usando papermill ejecutando el script bash run_benchmark.sh.- También publicamos una instantánea de los cuadernos
.ipynbcorrespondientes con toda la salida y los gráficos en una etiqueta de git separada. La última instantánea de la salida de los cuadernos Jupyter, incluidos los puntos de referencia, es accesible desde la siguiente etiqueta de git: /notebooks/benchmarks (latest_benchmark).
Algunos cuadernos para empezar:
Cuadernos de entorno 'Capture The Flag':
Cuadernos de entorno en cadena:
Otros entornos:
Evaluaciones comparativas: Los siguientes cuadernos muestran la evaluación comparativa de los agentes de referencia en varios entornos.
La última instantánea de la salida de los cuadernos Jupyter, incluidos los puntos de referencia, es accesible desde la siguiente etiqueta de git: /notebooks/benchmarks (latest_benchmark).
El siguiente código muestra cómo crear una instancia del entorno de OpenAI Gym CyberBattleChain-v0, un entorno basado en una estructura de red en cadena, con 10 nodos (size=10) donde el objetivo del agente es obtener la propiedad total de la red (own_atleast_percent=1.0) o romper el SLA de disponibilidad de la red del 80% (maintain_sla=0.80), mientras la red está siendo monitoreada y protegida por el defensor básico modelado probabilísticamente (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 probar otras topologías de red, tome como ejemplo chainpattern.py para definir su propio conjunto de máquinas y vulnerabilidades, luego agregue una entrada en el inicializador del módulo para declarar y registrar el entorno Gym.
Este proyecto agradece las contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Acuerdo de Licencia de Colaborador (CLA) que declara que tiene el derecho y, de hecho, nos otorga los derechos para usar su contribución. Para obtener más detalles, visite https://cla.opensource.microsoft.com.
Cuando envíe una solicitud de extracción, un bot de CLA determinará automáticamente si necesita proporcionar un CLA y decorará el PR de manera adecuada (por ejemplo, verificación de estado, comentario). Simplemente siga las instrucciones proporcionadas por el bot. Solo necesitará hacer esto una vez en todos los repositorios que usen nuestro CLA.
Este proyecto ha adoptado el Código de Conducta de Código Abierto de Microsoft. Para obtener más información, consulte las Preguntas frecuentes sobre el Código de Conducta o comuníquese con [email protected] si tiene preguntas o comentarios adicionales.
Aquí hay algunas ideas sobre cómo contribuir: mejorar la simulación (basada en eventos, refinamiento de la simulación, etc.), entrenar un algoritmo de RL en la simulación existente, implementar un punto de referencia para evaluar y comparar la novedad de los agentes, agregar más modos generativos de red para entrenar al agente RL, contribuir a la documentación, corregir errores.
Consulte también la wiki para más ideas.
@misc{msft:cyberbattlesim,
Author = {Microsoft Defender Research Team.}
Note = {Created by 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 proyecto no incluye ningún dato de cliente. Los modelos y topologías de red proporcionados son puramente ficticios. Los usuarios del código proporcionado proporcionan toda la entrada a la simulación y deben tener los permisos necesarios para usar cualquier dato proporcionado.
Este proyecto puede contener marcas comerciales o logotipos para proyectos, productos o servicios. El uso autorizado de las marcas comerciales o logotipos de Microsoft está sujeto y debe seguir las Directrices de marcas comerciales y marcas de Microsoft. El uso de marcas comerciales o logotipos de Microsoft en versiones modificadas de este proyecto no debe causar confusión ni implicar el patrocinio de Microsoft. Cualquier uso de marcas comerciales o logotipos de terceros está sujeto a las políticas de dichos terceros.