cliffe/secgenCrear VMs inseguras aleatoriamente
SecGen crea máquinas virtuales vulnerables, entornos de laboratorio y desafíos de hacking, para que los estudiantes puedan aprender técnicas de pruebas de penetración en seguridad.
Las máquinas como Metasploitable2 son siempre las mismas. Este proyecto utiliza Vagrant, Puppet y Ruby para crear máquinas virtuales vulnerables aleatorias que pueden usarse para aprender o para organizar eventos CTF.
La última versión está disponible en: http://github.com/cliffe/SecGen/
Por favor, completa una breve encuesta para contarnos cómo estás usando SecGen.
Para una solución alojada visita: https://hacktivity.co.uk/
Los estudiantes de seguridad informática se benefician al participar en desafíos de hacking. El trabajo práctico de laboratorio y los desafíos de hacking preconfigurados son una práctica común tanto en la educación en seguridad como también como pasatiempo para personas con mentalidad de seguridad. Los desafíos de hacking competitivos, como las competiciones de captura la bandera (CTF), se han convertido en un pilar en las conferencias de la industria y son el foco de grandes comunidades en línea. Las máquinas virtuales (VMs) proporcionan una forma efectiva de compartir objetivos para hacking, y pueden diseñarse para poner a prueba las habilidades del atacante. Sitios web como Vulnhub alojan VMs de desafíos de hacking preconfiguradas y son un recurso valioso para quienes aprenden y mejoran sus habilidades en seguridad informática. Sin embargo, desarrollar estos desafíos de hacking consume mucho tiempo y, una vez creados, son esencialmente estáticos. Es decir, una vez que el desafío ha sido "resuelto", no queda ningún desafío para el estudiante, y si el desafío se crea para una competición o evaluación, no se puede reutilizar sin riesgo de plagio y colusión.
Security Scenario Generator (SecGen) genera sistemas vulnerables aleatorios. Las VMs se crean basándose en una especificación de escenario, que describe las restricciones y propiedades de las VMs a crear. Por ejemplo, un escenario podría especificar la creación de un sistema con una vulnerabilidad explotable de forma remota que resultaría en un compromiso a nivel de usuario, y una falla explotable localmente que resultaría en un compromiso a nivel de root. Esto requeriría que el atacante descubra y explote ambas vulnerabilidades seleccionadas aleatoriamente para obtener acceso root al sistema. Alternativamente, el escenario definido puede ser más específico, especificando ciertos tipos de servicios (como FTP o SMB) o incluso vulnerabilidades exactas (por CVE).
SecGen es una aplicación Ruby, con un lenguaje de configuración XML. SecGen lee su configuración, incluyendo las vulnerabilidades, servicios, redes, usuarios y contenido disponibles, lee la definición del escenario solicitado, aplica lógica para aleatorizar el escenario, y aprovecha Puppet y Vagrant para aprovisionar las VMs requeridas.
SecGen es software libre: puedes redistribuirlo y/o modificarlo bajo los términos de la Licencia Pública General de GNU tal como la publica la Free Software Foundation, ya sea la versión 3 de la Licencia, o (a tu elección) cualquier versión posterior.
SecGen contiene módulos, que instalan varios paquetes de software. Cada módulo de SecGen puede contener software o obtenerlo de forma remota, y cada módulo define su propia licencia en el archivo secgen_metadata.xml adjunto.
SecGen está desarrollado y probado en Ubuntu Linux. En teoría, SecGen debería funcionar en Mac o Windows, si tienes todo el software requerido instalado.
Necesitarás instalar lo siguiente:
Este proyecto se ha adaptado para funcionar con la versión de Ubuntu (20.04) debido a que (16.04) llegó al final de su vida útil en abril de 2021, aunque aún funcionará en esa versión, no se garantiza que soporte las actualizaciones de seguridad necesarias para tu entorno de desarrollo.
Asegúrate de que Ubuntu esté actualizado usando los siguientes comandos:```bash sudo apt update sudo apt upgrade
Instale una versión reciente de vagrant:```bash
wget https://releases.hashicorp.com/vagrant/2.2.9/vagrant_2.2.9_x86_64.deb
sudo apt install ./vagrant_2.2.9_x86_64.deb
Instale otros paquetes requeridos:```bash sudo apt-get install ruby-dev zlib1g-dev liblzma-dev build-essential patch virtualbox ruby-bundler imagemagick libmagickwand-dev exiftool libpq-dev libcurl4-openssl-dev libxml2-dev graphviz graphviz-dev libpcap0.8-dev git
Clona el repositorio SecGen usando el siguiente comando.Por defecto será /home/username/SecGen, cambia según sea necesario:```bash
git clone https://github.com/cliffe/SecGen.git
Instala gems usando los siguientes comandos:```bash #Step In to the file directory
cd /home/username/SecGen
bundle update --bundler
Actualizar gemas:```bash
bundle update
Instala todos los paquetes necesarios:```bash
wget https://releases.hashicorp.com/vagrant/1.9.8/vagrant_1.9.8_x86_64.deb sudo apt install ./vagrant_1.9.8_x86_64.deb
sudo apt-get install ruby-dev zlib1g-dev liblzma-dev build-essential patch virtualbox ruby-bundler imagemagick libmagickwand-dev exiftool libpq-dev libcurl4-openssl-dev libxml2-dev graphviz graphviz-dev libpcap0.8-dev git
Copia SecGen a un directorio de tu elección, como */home/user/bin/SecGen*
Luego instala las gems:```bash
cd /home/user/bin/SecGen
bundle install
Para usar las basesboxes de Windows necesitarás instalar Packer. Usa el siguiente comando:```bash curl -SL https://releases.hashicorp.com/packer/1.3.2/packer_1.3.2_linux_amd64.zip -o packer_1.3.2_linux_amd64.zip unzip packer_1.3.2_linux_amd64.zip sudo mv packer /usr/local/ sudo bash -c 'echo "export PATH="$PATH:/usr/local/"" >> /etc/environment' sudo vagrant plugin install winrm sudo vagrant plugin install winrm-fs
## Uso
Uso básico:```bash
ruby secgen.rb run
Esto utilizará el escenario predeterminado para generar VM(s) de forma aleatoria.
SecGen acepta argumentos para cambiar la forma en que se comporta, los argumentos actualmente implementados son:```bash ruby secgen.rb [--options] OPTIONS: --scenario [xml file], -s [xml file]: Set the scenario to use (defaults to /home/secgen/SecGen/scenarios/default_scenario.xml) --project [output dir], -p [output dir]: Directory for the generated project (output will default to /home/secgen/SecGen/projects/SecGen20200313_094915) --shutdown: Shutdown VMs after provisioning (vagrant halt) --network-ranges: Override network ranges within the scenario, use a comma-separated list --forensic-image-type [image type]: Forensic image format of generated image (raw, ewf) --read-options [conf path]: Reads options stored in file as arguments (see example.conf) --memory-per-vm: Allocate generated VMs memory in MB (e.g. --memory-per-vm 1024) --total-memory: Allocate total VM memory for the scenario, split evenly across all VMs. --cpu-cores: Number of virtual CPUs for generated VMs --help, -h: Shows this usage information --system, -y [system_name]: Only build this system_name from the scenario --snapshot: Creates a snapshot of VMs once built --no-tests: Prevent post-provisioning tests from running.
VIRTUALBOX OPTIONS:
--gui-output, -g: Show the running VM (not headless)
--nopae: Disable PAE support
--hwvirtex: Enable HW virtex support
--vtxvpid: Enable VTX support
--max-cpu-usage [1-100]: Controls how much cpu time a virtual CPU can use
(e.g. 50 implies a single virtual CPU can use up to 50% of a single host CPU)
OVIRT OPTIONS:
--ovirtuser [ovirt_username]
--ovirtpass [ovirt_password]
--ovirt-url [ovirt_api_url]
--ovirtauthz [ovirt authz]
--ovirt-cluster [ovirt_cluster]
--ovirt-network [ovirt_network_name]
--ovirt-affinity-group [ovirt_affinity_group_name]
ESXI OPTIONS:
--esxiuser [esxi_username]
--esxipass [esxi_password]
--esxi-hostname [esxi_api_url]
(ESXi hostname/IP)
--esxi-datastore [esxi_datastore]
--esxi-disktype [esxi_disktype]: 'thin', 'thick', or 'eagerzeroedthick'
(If unspecified, it will be set to 'thin')
--esxi-network [esxi_network_name]
(If its not specified, the default is to use the first found)
--esxi-guest-nictype [esxi_nictype]: 'e1000', 'e1000e', 'vmxnet', 'vmxnet2', 'vmxnet3', 'Vlance', or 'Flexible'
(RISKY - Can cause VM to not respond)
--esxi-no-hostname
(Setting the hostname on some boxes can cause vagrant up to fail if the network configuration was not previously cleaned up.)
PROXMOX OPTIONS:
--proxmoxuser [username]
--proxmoxpass [password]
--proxmox-url [api_url]
--proxmox-node [node]
--proxmox-network [proxmox network name]
--proxmox-vlan [vlan number]
COMMANDS:
run, r: Builds project and then builds the VMs
build-project, p: Builds project (vagrant and puppet config), but does not build VMs
build-vms, v: Builds VMs from a previously generated project
(use in combination with --project [dir])
ovirt-post-build: only performs the ovirt actions that normally follow a successful vm build
(snapshots and networking)
create-forensic-image: Builds forensic images from a previously generated project
(can be used in combination with --project [dir])
list-scenarios: Lists all scenarios that can be used with the --scenario option
list-projects: Lists all projects that can be used with the --project option
delete-all-projects: Deletes all current projects in the projects directory
## Solución de problemas: actualización de cajas base
Si SecGen encuentra errores al instalar paquetes, las VMs de plantilla (cajas base) que publicamos en Vagrant cloud pueden necesitar una actualización (especialmente Kali, que es de lanzamiento continuo). Después de haber construido algunas VMs, navegue en su directorio personal `.vagrant.d/boxes/`, desde aquí puede lanzar manualmente las VMs que se usan como plantillas y aplicar actualizaciones de software `sudo apt-get update; sudo apt-get upgrade`. Luego apague la VM y vuelva a intentar SecGen.
Para Proxmox, use este plugin de Vagrant: https://github.com/cliffe/vagrant-proxmox/, y aplique esta corrección a Vagrant: https://github.com/hashicorp/vagrant/pull/12463/files.
Normalmente necesitará crear una VM base Debian Buster, siguiendo aproximadamente estas instrucciones:
https://github.com/cliffe/SecGen/blob/master/README-Creating-Bases.md
## Escenarios
SecGen genera VMs basándose en una especificación de escenario, que describe las restricciones y propiedades de las VMs a crear.
### Uso de escenarios existentes
Los escenarios existentes hacen que la barrera de entrada de SecGen sea baja: al invocar SecGen, se puede especificar un escenario como argumento de comando, y SecGen leerá la definición del escenario apropiada y procederá con la aleatorización y generación de VMs. Esto elimina la necesidad de que los usuarios finales del framework comprendan la especificación de configuración de SecGen.
Los escenarios se pueden encontrar en el directorio scenarios/. Por ejemplo, para iniciar una VM que tenga una vulnerabilidad explotable remotamente aleatoria que resulte en un compromiso a nivel de usuario:```bash
ruby secgen.rb --scenario scenarios/examples/remotely_exploitable_user_vulnerability.xml run
Para generar un conjunto de máquinas virtuales para una organización ficticia generada aleatoriamente, con un sistema de escritorio, un servidor web y un servidor de intranet:```bash ruby secgen.rb --scenario scenarios/security_audit/team_project.xml run
Tenga en cuenta que el servidor de la intranet tiene un mandato de seguridad, con instrucciones para realizar una auditoría de seguridad de estos sistemas. El sistema de escritorio puede acceder a la intranet para acceder al mandato, pero la máquina virtual del atacante (por ejemplo, Kali) puede conectarse únicamente a la NIC compartida por el servidor web para simular la necesidad de pivotar ataques a través del servidor web, ya que no pueden conectarse directamente al sistema de la intranet. La "guía de calificación" está en forma del archivo output scenario.xml en el directorio del proyecto, que proporciona los detalles de los sistemas generados.
#### Máquinas virtuales para un evento CTF```bash
ruby secgen.rb --scenario scenarios/ctf/flawed_fortress_1.xml run
Tenga en cuenta que también se genera un archivo 'CTFd_importable.zip', que contiene todas las banderas y pistas, que puede importar en el frontend del marcador CTFd. Esto es compatible con CTFd v2.0.2 y posteriores.
Cuenta de administrador predeterminada: Nombre de usuario: adminusername Contraseña: adminpassword
Escribir sus propios escenarios le permite definir una VM o un conjunto de VMs con una configuración tan específica o general como desee.
La especificación de escenarios de SecGen es una interfaz potente para especificar las restricciones de los sistemas vulnerables a generar. Los escenarios se definen en archivos de configuración XML que especifican sistemas en términos de una base, servicios/utilidades, vulnerabilidades y redes.
Para más detalles, consulte la Guía para crear escenarios.
SecGen está diseñado para ser fácilmente ampliable con módulos que definen vulnerabilidades y otros tipos de cambios de software, configuración y contenido.
Los tipos de módulos compatibles en SecGen son:
Cada módulo de vulnerabilidad se encuentra dentro del árbol de directorios modules/vulnerabilities, que está organizado para coincidir con la estructura de directorios de módulos de Metasploit Framework (MSF). Por ejemplo, el módulo de vulnerabilidad distcc_exec se encuentra en: modules/vulnerabilities/unix/misc/distcc_exec/.
La raíz del directorio del módulo siempre contiene un archivo secgen_metadata.xml y también contiene archivos puppet, que se utilizan para hacer que un sistema sea vulnerable.
Para más detalles, consulte la Guía de metadatos de módulos.
Los codificadores y generadores tienen código que se evalúa en el momento de la construcción del proyecto, como codificar texto y generar banderas y otro contenido potencialmente aleatorio. En cada caso, se trata de un script ruby ubicado dentro del directorio del módulo en local/secgen_local.rb. Aunque normalmente son llamados por SecGen, los scripts secgen_local.rb se pueden ejecutar directamente y aceptan todas las entradas de parámetros como argumentos de línea de comandos, y devuelven la salida en formato JSON a stdout. Otra salida legible por humanos se escribe en stderr.```bash #ruby modules/encoders/string/base64/secgen_local/local.rb --strings_to_encode "encode this" --strings_to_encode "and this" BASE64 Encoder Encoding '["encode this", "and this"]' Encoded: ["ZW5jb2RlIHRoaXM=", "YW5kIHRoaXM="] ["ZW5jb2RlIHRoaXM=","YW5kIHRoaXM="]
## Puppet se usa para aprovisionar las máquinas virtuales
Cada módulo de vulnerabilidad, servicio y utilidad contiene archivos Puppet que se utilizan para aprovisionar el software y los cambios de configuración en las máquinas virtuales. Cuando se ejecuta Puppet para aprovisionar las máquinas virtuales, toda la aleatorización ya ha tenido lugar en el momento de la compilación.
Para más detalles, consulte la **[guía de módulos Puppet](https://github.com/cliffe/secgen/blob/master/README-Modules-Puppet.md)**.
## Salida del proyecto SecGen
Por defecto, la salida se dirige a 'projects/SecGen_*[CurrentTime]*/'
La salida del proyecto incluye:
- Una configuración de Vagrant para poner en marcha las máquinas.
- Un directorio que contiene todos los módulos Puppet necesarios para lo anterior. Se crea un archivo Librarian-Puppet para gestionar los módulos, y algunos módulos requeridos pueden obtenerse a través de PuppetForge, por lo que se requiere una conexión a Internet al construir el proyecto.
- Un archivo XML de escenario des-aleatorizado. Usando SecGen, puede usar este archivo 'scenario.xml' para recrear la configuración de Vagrant y los archivos Puppet mencionados. Cualquier aleatorización que se haya aplicado debería estar des-aleatorizada en esta salida (en comparación con el archivo de escenario original). Este archivo contiene todos los detalles de los sistemas creados, y también se puede usar más adelante para calificar, puntuar o dar pistas.
- Un archivo 'flag_hints.xml' que contiene todas las banderas junto con múltiples pistas por bandera.
- Un archivo 'CTFd_importable.zip' útil para eventos CTF, para importar en el [frontend de tabla de clasificación de CTFd](https://github.com/CTFd/CTFd).
Si inicia SecGen con el comando "build-project" (o "p") crea los archivos anteriores y luego se detiene. El comando "run" (o "r") crea los archivos del proyecto y luego usa Vagrant para construir la(s) máquina(s) virtual(es).
Es posible copiar el directorio del proyecto a cualquier sistema compatible con Vagrant, y simplemente ejecutar "vagrant up" para crear las máquinas virtuales.
La contraseña de root predeterminada para las cajas base es 'puppet', pero esto puede ser modificado por SecGen dependiendo del escenario utilizado.
## Procesamiento por lotes con SecGen
Ahora es posible generar múltiples máquinas virtuales en un lote mediante el uso de batch_secgen, que gestiona una cola de trabajos para crear en masa máquinas virtuales con SecGen. Hay comandos auxiliares disponibles para agregar trabajos, listar trabajos en la tabla, eliminar trabajos y restablecer el estado de los trabajos de 'running' o 'error' a 'todo'.
Para más detalles, consulte la **[guía de creación de máquinas virtuales por lotes](https://github.com/cliffe/secgen/blob/master/README-Batch-VMs.md)**.
## Clave de áreas de conocimiento de CyBOK
El Cuerpo de Conocimiento de Ciberseguridad (CyBOK) es un cuerpo de conocimiento que tiene como objetivo encapsular las diversas áreas de conocimiento presentes en la ciberseguridad. Los escenarios dentro de SecGen ahora contienen elementos XML que los vinculan a áreas de conocimiento de CyBOK y a temas específicos dentro de esas áreas. Además, el contenido de video para los escenarios está etiquetado con asociaciones de CyBOK.
Para un índice de escenarios de laboratorio en SecGen organizados por áreas de conocimiento de CyBOK, consulte **[Escenarios de laboratorio y CyBOK](https://github.com/cliffe/secgen/blob/master/README-CyBOK-Scenarios-Indexed.md)**. Asimismo, para **[escenarios CTF](https://github.com/cliffe/secgen/blob/master/README-CyBOK-CTF-Scenarios-Indexed.md)**.
Para una lista de videos de conferencias y demostraciones con metadatos de CyBOK, consulte **[Videos de conferencias y CyBOK](https://github.com/cliffe/secgen/blob/master/README-CyBOK-Lecture-Videos.md)**.
La siguiente tabla es una clave para las abreviaturas que encontrará dentro de los elementos XML de CyBOK en los escenarios:
| Abreviatura | Área de Conocimiento (KA) | Capítulo | Árbol de Conocimiento|
| ----------- | -------------------- | ------- | --------------|
| IC | Introducción a CyBOK | [link](https://www.cybok.org/media/downloads/Introduction_to_CyBOK.pdf)| [link](https://www.cybok.org/media/downloads/CyBOK_introduction.pdf) |
| FM | Métodos Formales | n/a | [link](https://www.cybok.org/media/downloads/Formal_Methods_for_Security_VK6XZwO.pdf)|
| RMG | Gestión de Riesgos y Gobernanza | [link](https://www.cybok.org/media/downloads/Risk-Management--Governance-issue-1.0.pdf)| [link](https://www.cybok.org/media/downloads/Risk_Management__Governancev2.pdf)|
| LR | Ley y Regulación | [link](https://www.cybok.org/media/downloads/Law__Regulation_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Law__Regulation.pdf)|
| HF | Factores Humanos | [link](https://www.cybok.org/media/downloads/Human_Factors_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Human_Factors.pdf)|
| POR | Privacidad y Derechos en Línea | [link](https://www.cybok.org/media/downloads/Privacy__Online_Rights_issue_1.0_FNULPeI.pdf)| [link](https://www.cybok.org/media/downloads/Privacy__Online_Rights.pdf)|
| MAT | Malware y Tecnologías de Ataque | [link](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Malware__Attack_Technologies.pdf)|
| AB | Comportamientos Adversarios | [link](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Adversarial_Behaviours.pdf)|
| SOIM | Operaciones de Seguridad y Gestión de Incidentes | [link](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management.pdf)|
| F | Forense | [link](https://www.cybok.org/media/downloads/Forensics_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Forensics.pdf)|
| C | Criptografía | [link](https://www.cybok.org/media/downloads/Cryptography-issue-1.0.pdf)| [link](https://www.cybok.org/media/downloads/Cryptography.pdf)|
| AC | Criptografía Aplicada | [link](https://www.cybok.org/media/downloads/Applied_Cryptography_v1.0.0.pdf)| [link](https://www.cybok.org/media/downloads/Applied_Cryptography_tree-1.0.0.pdf)|
| OSV | Seguridad de Sistemas Operativos y Virtualización | [link](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security_issue_1.0_xhesi5S.pdf)| [link](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security.pdf)|
| DSS | Seguridad de Sistemas Distribuidos | [link](https://www.cybok.org/media/downloads/Distributed_Systems_Security_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Distributed_Systems_Security.pdf)|
| AAA | Autenticación, Autorización y Responsabilidad | [link](https://www.cybok.org/media/downloads/AAA_issue_1.0_q3qspzo.pdf)| [link](https://www.cybok.org/media/downloads/AAA.pdf) |
| SS | Seguridad de Software | [link](https://www.cybok.org/media/downloads/Software_Security_issue_1.0_1M7Kfk2.pdf)| [link](https://www.cybok.org/media/downloads/Software_Security.pdf)|
| WAM | Seguridad Web y Móvil | [link](https://www.cybok.org/media/downloads/Web__Mobile_Security_issue_1.0_XFpbYNz.pdf)| [link](https://www.cybok.org/media/downloads/Web__Mobile_Security.pdf)|
| SSL | Ciclo de Vida del Software Seguro | [link](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle.pdf)|
| NS | Seguridad de Redes | [link](https://www.cybok.org/media/downloads/Network_Security_issue_1.0_qsCh0SR.pdf)| [link](https://www.cybok.org/media/downloads/Network_Security.pdf)|
| HS | Seguridad de Hardware | [link](https://www.cybok.org/media/downloads/Hardware_Security_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Hardware_Security.pdf)|
| CPS | Sistemas Ciberfísicos | [link](https://www.cybok.org/media/downloads/Cyber-Physical_Systems_Security_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Cyber_Physical_Systems_Security.pdf)|
| PLT | Seguridad de la Capa Física y Telecomunicaciones | [link](https://www.cybok.org/media/downloads/Physical_Layer__Telecommunications_Security_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Physical_Layer__Telecomms_Security.pdf)|
## Hacktivity Cyber Security Labs
[Para una solución alojada, visite: https://hacktivity.leedsbeckett.ac.uk/](https://hacktivity.leedsbeckett.ac.uk/)
Hacktivity funciona con SecGen y proporciona un entorno de laboratorio completamente alojado para la educación en ciberseguridad. Realice un seguimiento de su progreso con información de CyBOK.
## Agradecimientos
*Equipo de desarrollo:*
- Dr Z. Cliffe Schreuders http://z.cliffe.schreuders.org
- Tom Shaw
- Alix Hiscock
- Rosie Fletcher
- James Davis
- Sofia Markusfeld
- Harry Hall
- Jack Biggs
- Tom Harrison
- Jason Keighley
- Lewis Ardern -- autor de la primera versión de prueba de concepto de SecGen
- Connor Wilson
Muchas gracias a todos los que han contribuido al proyecto. La lista anterior no es completa ni exhaustiva; consulte el [historial de GitHub](https://github.com/cliffe/SecGen/graphs/contributors).
*Apoyo de subvenciones:*
- Este proyecto cuenta con el apoyo de una subvención de aprendizaje y enseñanza en ciberseguridad de la Higher Education Academy (HEA) (2015-2017).
- Este proyecto cuenta con el apoyo de una subvención del Fondo de Excelencia Docente de la Universidad Leeds Beckett (2018-2019).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a CyBOK 1.0 (2021).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a CyBOK 1.1 (2021-2022).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a CyBOK 1.1 (2022-2023).
- Este proyecto cuenta con el apoyo de una subvención de CyberASAP (Programa Acelerador de Startups Académicas en Ciberseguridad) de Innovate UK (2022-2023).
- Este proyecto cuenta con el apoyo de una subvención del Fondo de Excelencia Docente de la Universidad Leeds Beckett (2023).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a CyBOK 1.1 (2023-2024).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a CyBOK 1.1 (2024-2025).
- Este proyecto cuenta con el apoyo de una subvención de recursos del Cuerpo de Conocimiento de Ciberseguridad (CyBOK) en torno a Seguridad Informada por la Seguridad (2025-2026).
## Contribuciones
Animamos a las contribuciones al proyecto.
Brevemente, haga un fork desde http://github.com/cliffe/SecGen/, cree una rama, realice y confirme sus cambios, luego cree una solicitud de extracción.
## Recursos
Artículo: [Z.C. Schreuders, T. Shaw, "Hacktivity Cyber Security Labs: Randomised Challenges and Virtualisation Infrastructure Management, with CyBOK Integration," Advances in Cyber Security Education, Bristol, UK. CSE-Connect, 2024.](https://link.springer.com/chapter/10.1007/978-3-031-77524-6_4#citeas)
Artículo: [Z.C. Schreuders, T. Shaw, A. Mac Muireadhaigh, and P. Staniforth, “Hackerbot: Attacker Chatbots for Randomised and Interactive Security Labs, Using SecGen and oVirt,” USENIX Workshop on Advances in Security Education (ASE'18), Baltimore, MD, USA. USENIX Association, 2018.](https://www.usenix.org/conference/ase18/presentation/schreuders) (Este artículo describe Hackerbot y cómo usamos SecGen con oVirt.)
Artículo: [Z.C. Schreuders, T. Shaw, M. Shan-A-Khuda, G. Ravichandran, J. Keighley, and M. Ordean, “Security Scenario Generator (SecGen): A Framework for Generating Randomly Vulnerable Rich-scenario VMs for Learning Computer Security and Hosting CTF Events,” USENIX Workshop on Advances in Security Education (ASE'17), Vancouver, BC, Canada. USENIX Association, 2017.](https://www.usenix.org/conference/ase17/workshop-program/presentation/schreuders) (Este artículo proporciona una buena visión general de SecGen.)
Artículo: [Z.C. Schreuders, and L. Ardern, "Generating randomised virtualised scenarios for ethical hacking and computer security education: SecGen implementation and deployment," in The first UK Workshop on Cybersecurity Training & Education (Vibrant Workshop 2015) Liverpool, UK, 2015.](http://z.cliffe.schreuders.org/publications/VibrantWorkshop2015%20-%20Generating%20randomised%20virtualised%20scenarios%20for%20ethical%20hacking%20and%20computer%20security%20education%20%28SecGen%29.pdf) (Este artículo describe el primer prototipo.)
Entrevista de podcast: [Purple Squad Security Episode 011 – Security Scenario Generator with Dr. Z. Cliffe Schreuders](https://purplesquadsec.com/podcast/episode-011-security-scenario-generator-dr-z-cliffe-schreuders/)