cliffe/secgenCriar VMs inseguras aleatoriamente
O SecGen cria máquinas virtuais vulneráveis, ambientes de laboratório e desafios de hacking, para que os alunos possam aprender técnicas de testes de penetração em segurança.
Caixas como o Metasploitable2 são sempre as mesmas, este projeto usa Vagrant, Puppet e Ruby para criar máquinas virtuais aleatoriamente vulneráveis que podem ser usadas para aprendizagem ou para hospedar eventos CTF.
A versão mais recente está disponível em: http://github.com/cliffe/SecGen/
Por favor, complete uma breve pesquisa para nos informar como está a usar o SecGen.
Para uma solução alojada, visite: https://hacktivity.co.uk/
Os alunos de segurança informática beneficiam da realização de desafios de hacking. O trabalho prático de laboratório e os desafios de hacking pré-configurados são uma prática comum tanto na educação em segurança como também como passatempo para pessoas com mentalidade de segurança. Desafios de hacking competitivos, como as competições de captura da bandeira (CTF), tornaram-se um pilar em conferências da indústria e são o foco de grandes comunidades online. As máquinas virtuais (VMs) fornecem uma forma eficaz de partilhar alvos para hacking, e podem ser concebidas para testar as competências do atacante. Sites como o Vulnhub hospedam VMs de desafios de hacking pré-configuradas e são um recurso valioso para aqueles que aprendem e avançam as suas competências em segurança informática. No entanto, desenvolver estes desafios de hacking consome tempo e, uma vez criados, são essencialmente estáticos. Isto é, uma vez que o desafio foi "resolvido", não há desafio restante para o aluno, e se o desafio for criado para uma competição ou avaliação, o desafio não pode ser reutilizado sem risco de plágio e conluio.
O Security Scenario Generator (SecGen) gera sistemas vulneráveis aleatorizados. As VMs são criadas com base numa especificação de cenário, que descreve as restrições e propriedades das VMs a serem criadas. Por exemplo, um cenário poderia especificar a criação de um sistema com uma vulnerabilidade explorável remotamente que resultaria num compromisso ao nível do utilizador, e uma falha explorável localmente que resultaria num compromisso ao nível de root. Isto exigiria que o atacante descobrisse e explorasse ambas as vulnerabilidades selecionadas aleatoriamente para obter acesso root ao sistema. Alternativamente, o cenário definido pode ser mais específico, especificando certos tipos de serviços (como FTP ou SMB) ou mesmo vulnerabilidades exatas (por CVE).
O SecGen é uma aplicação Ruby, com uma linguagem de configuração XML. O SecGen lê a sua configuração, incluindo as vulnerabilidades, serviços, redes, utilizadores e conteúdo disponíveis, lê a definição do cenário solicitado, aplica lógica para aleatorizar o cenário e utiliza Puppet e Vagrant para provisionar as VMs necessárias.
O SecGen é software livre: pode redistribuí-lo e/ou modificá-lo sob os termos da Licença Pública Geral GNU, conforme publicada pela Free Software Foundation, seja a versão 3 da Licença ou (à sua escolha) qualquer versão posterior.
O SecGen contém módulos, que instalam vários pacotes de software. Cada módulo do SecGen pode conter ou obter software remotamente, e cada módulo define a sua própria licença no ficheiro secgen_metadata.xml que o acompanha.
O SecGen é desenvolvido e testado no Ubuntu Linux. Em teoria, o SecGen deve funcionar no Mac ou Windows, se tiver todo o software necessário instalado.
Precisará de instalar o seguinte:
Este projeto foi adaptado para funcionar com a versão Ubuntu (20.04) devido ao fim de vida do (16.04) em abril de 2021, embora ainda funcione nessa versão, não é garantido o suporte para as atualizações de segurança necessárias para o seu ambiente de desenvolvimento.
Certifique-se de que o Ubuntu está atualizado usando os seguintes comandos:```bash sudo apt update sudo apt upgrade
Instale uma versão recente do 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 outros pacotes necessários:```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
Clone o repositório SecGen usando o seguinte comando.Por padrão, este será /home/username/SecGen, altere conforme necessário:```bash
git clone https://github.com/cliffe/SecGen.git
Instale gems usando os seguintes comandos:```bash #Step In to the file directory
cd /home/username/SecGen
bundle update --bundler
Atualizar gems:```bash
bundle update
Instale todos os pacotes necessários:```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
Copie o SecGen para um diretório de sua escolha, como */home/user/bin/SecGen*
Em seguida, instale as gems:```bash
cd /home/user/bin/SecGen
bundle install
Para usar as basesboxes do Windows, você precisará instalar o Packer. Use o seguinte 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
Isto usará o cenário padrão para gerar aleatoriamente VM(s).
SecGen aceita argumentos para alterar o seu comportamento, os argumentos atualmente implementados são:```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
## Solução de problemas: atualizando as boxes base
Se o SecGen encontrar erros ao instalar pacotes, as VMs modelo (boxes base) que publicamos na Vagrant cloud podem precisar de atualização (especialmente o Kali, que é uma rolling-release). Depois de construir algumas VMs, navegue no seu diretório inicial `.vagrant.d/boxes/`, a partir daqui você pode iniciar manualmente as VMs que são usadas como modelos e aplicar atualizações de software `sudo apt-get update; sudo apt-get upgrade`. Em seguida, desligue a VM e tente o SecGen novamente.
Para Proxmox, use este plugin do Vagrant: https://github.com/cliffe/vagrant-proxmox/, e faça esta correção no Vagrant: https://github.com/hashicorp/vagrant/pull/12463/files.
Você geralmente precisará criar uma VM base Debian Buster, seguindo amplamente estas instruções:
https://github.com/cliffe/SecGen/blob/master/README-Creating-Bases.md
## Cenários
O SecGen gera VMs com base em uma especificação de cenário, que descreve as restrições e propriedades das VMs a serem criadas.
### Usando cenários existentes
Cenários existentes tornam a barreira de entrada do SecGen baixa: ao invocar o SecGen, um cenário pode ser especificado como um argumento de comando, e o SecGen lerá então a definição de cenário apropriada e prosseguirá com a randomização e geração de VM. Isso elimina a necessidade de os usuários finais do framework entenderem a especificação de configuração do SecGen.
Os cenários podem ser encontrados no diretório scenarios/. Por exemplo, para criar uma VM que tenha uma vulnerabilidade aleatória explorável remotamente que resulte em comprometimento ao nível de usuário:```bash
ruby secgen.rb --scenario scenarios/examples/remotely_exploitable_user_vulnerability.xml run
Para gerar um conjunto de VMs para uma organização fictícia gerada aleatoriamente, com um sistema de desktop, servidor web e servidor de intranet:```bash ruby secgen.rb --scenario scenarios/security_audit/team_project.xml run
Note que o servidor da intranet tem uma atribuição de segurança, com instruções para realizar uma auditoria de segurança desses sistemas. O sistema desktop pode acessar a intranet para acessar a atribuição, mas a VM do atacante (por exemplo, Kali) pode estar conectada apenas à NIC compartilhada pelo servidor Web para simular a necessidade de pivotar ataques através do servidor Web, já que não podem se conectar diretamente ao sistema da intranet. O "guia de correção" está na forma do arquivo de saída scenario.xml no diretório do projeto, que fornece os detalhes dos sistemas gerados.
#### VMs para um evento CTF
Para gerar um conjunto de VMs para uma competição CTF:```bash
ruby secgen.rb --scenario scenarios/ctf/flawed_fortress_1.xml run
Note que um ficheiro 'CTFd_importable.zip' também é gerado, contendo todas as flags e dicas, que você pode importar para o frontend do placar CTFd. Isto é compatível com CTFd v2.0.2 e mais recente.
Conta de administrador padrão: Nome de usuário: adminusername Senha: adminpassword
Escrever seus próprios cenários permite definir uma VM ou conjunto de VMs com uma configuração tão específica ou geral quanto desejado.
A especificação de cenários do SecGen é uma interface poderosa para especificar as restrições dos sistemas vulneráveis a serem gerados. Os cenários são definidos em arquivos de configuração XML que especificam sistemas em termos de uma base, serviços/utilitários, vulnerabilidades e redes.
Para detalhes, consulte o Guia de Criação de Cenários.
O SecGen foi projetado para ser facilmente extensível com módulos que definem vulnerabilidades e outros tipos de software, configuração e alterações de conteúdo.
Os tipos de módulos suportados no SecGen são:
Cada módulo de vulnerabilidade está contido na árvore de diretórios modules/vulnerabilies, que é organizada para corresponder à estrutura de diretórios de módulos do Metasploit Framework (MSF). Por exemplo, o módulo de vulnerabilidade distcc_exec está contido em: modules/vulnerabilities/unix/misc/distcc_exec/.
A raiz do diretório do módulo sempre contém um arquivo secgen_metadata.xml e também contém arquivos puppet, que são usados para tornar um sistema vulnerável.
Para detalhes, consulte o Guia de Metadados de Módulos.
Codificadores e geradores possuem código que é avaliado no momento da construção do projeto, como codificar texto e gerar flags e outros conteúdos potencialmente aleatórios. Em cada caso, este é um script ruby localizado dentro do diretório do módulo em local/secgen_local.rb. Embora normalmente chamados pelo SecGen, os scripts secgen_local.rb podem ser executados diretamente e aceitam todas as entradas de parâmetros como argumentos de linha de comando, e retornam a saída no formato JSON para stdout. Outra saída legível por humanos é escrita em 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 é usado para provisionar as VMs
Cada módulo de vulnerabilidade, serviço e utilitário contém arquivos Puppet que são usados para provisionar o software e as alterações de configuração nas VMs. No momento em que o Puppet é executado para provisionar as VMs, toda a randomização já ocorreu no momento da construção.
Para mais detalhes, consulte o **[Guia de Módulos Puppet](https://github.com/cliffe/secgen/blob/HEAD/README-Modules-Puppet.md)**.
## Saída do projeto SecGen
Por padrão, a saída está em 'projects/SecGen_*[CurrentTime]*/'
A saída do projeto inclui:
- Uma configuração Vagrant para inicializar as boxes.
- Um diretório contendo todos os módulos Puppet necessários para o acima. Um arquivo Librarian-Puppet é criado para gerenciar módulos, e alguns módulos necessários podem ser obtidos via PuppetForge, portanto, é necessária uma conexão com a Internet ao construir o projeto.
- Um arquivo de cenário XML não randomizado. Usando o SecGen, você pode usar este arquivo 'scenario.xml' para recriar a configuração Vagrant e os arquivos Puppet acima. Qualquer randomização que tenha sido aplicada deve ser des-randomizada nesta saída (em comparação com o arquivo de cenário original). Este arquivo contém todos os detalhes dos sistemas criados e também pode ser usado posteriormente para classificação, pontuação ou fornecimento de dicas.
- Um arquivo 'flag_hints.xml', contendo todas as flags juntamente com múltiplas dicas por flag.
- Um arquivo 'CTFd_importable.zip' útil para eventos CTF, para importação no [frontend de scoreboard CTFd](https://github.com/CTFd/CTFd).
Se você iniciar o SecGen com o comando "build-project" (ou "p"), ele cria os arquivos acima e depois para. O comando "run" (ou "r") cria os arquivos do projeto e então usa o Vagrant para construir a(s) VM(s).
É possível copiar o diretório do projeto para qualquer sistema compatível com Vagrant e simplesmente executar "vagrant up" para criar as VMs.
A senha root padrão para as base-boxes é 'puppet', mas isso pode ser modificado pelo SecGen dependendo do cenário utilizado.
## Processamento em Lote com SecGen
A geração de múltiplas VMs em lote agora é possível através do uso do batch_secgen, que gerencia uma fila de trabalhos para criar VMs em massa com o SecGen. Existem comandos auxiliares disponíveis para adicionar trabalhos, listar trabalhos na tabela, remover trabalhos e redefinir o status de trabalhos de 'running' ou 'error' para 'todo'.
Para mais detalhes, consulte o **[Guia de Criação em Lote de VMs](https://github.com/cliffe/secgen/blob/HEAD/README-Batch-VMs.md)**.
## Chave de Área de Conhecimento CyBOK
O Cyber Security Body of Knowledge (CyBOK) é um corpo de conhecimento que visa encapsular as várias áreas de conhecimento presentes na segurança cibernética.
Cenários dentro do SecGen agora contêm elementos XML que os vinculam a áreas de conhecimento CyBOK e tópicos específicos dentro dessas áreas de conhecimento.
Além disso, o conteúdo de vídeo para cenários é marcado com associações CyBOK.
Para um índice de cenários de laboratório no SecGen organizados por Áreas de Conhecimento CyBOK, consulte o **[Cenários de Laboratório e CyBOK](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-Scenarios-Indexed.md)**. Da mesma forma, para **[cenários CTF](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-CTF-Scenarios-Indexed.md)**.
Para uma lista de vídeos de palestras e demonstrações com metadados CyBOK, consulte o **[Vídeos de Palestras e CyBOK](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-Lecture-Videos.md)**.
A tabela abaixo é uma chave para as abreviações que você encontrará dentro dos elementos XML CyBOK nos cenários:
| Abreviação | Área de Conhecimento (KA) | Capítulo | Árvore de Conhecimento|
| ----------- | -------------------- | ------- | --------------|
| IC | Introdução ao 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 Formais | n/a | [link](https://www.cybok.org/media/downloads/Formal_Methods_for_Security_VK6XZwO.pdf)|
| RMG | Gestão de Risco e Governança | [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 | Lei e Regulação | [link](https://www.cybok.org/media/downloads/Law__Regulation_issue_1.0.pdf)| [link](https://www.cybok.org/media/downloads/Law__Regulation.pdf)|
| HF | Fatores 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 | Privacidade e Direitos Online | [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 e Tecnologias 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 | Comportamentos Adversários | [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 | Operações de Segurança e Gestão 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 | Criptografia | [link](https://www.cybok.org/media/downloads/Cryptography-issue-1.0.pdf)| [link](https://www.cybok.org/media/downloads/Cryptography.pdf)|
| AC | Criptografia 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 | Segurança de Sistemas Operacionais e Virtualização | [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 | Segurança de Sistemas Distribuídos | [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 | Autenticação, Autorização e Responsabilidade | [link](https://www.cybok.org/media/downloads/AAA_issue_1.0_q3qspzo.pdf)| [link](https://www.cybok.org/media/downloads/AAA.pdf) |
| SS | Segurança 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 | Segurança Web e Móvel | [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 de 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 | Segurança de Rede | [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 | Segurança 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 | Segurança da Camada Física e Telecomunicações | [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 uma solução hospedada, visite: https://hacktivity.leedsbeckett.ac.uk/](https://hacktivity.leedsbeckett.ac.uk/)
O Hacktivity é alimentado pelo SecGen e fornece um ambiente de laboratório totalmente hospedado para educação em segurança cibernética. Acompanhe seu progresso com insights CyBOK.
## Agradecimentos
*Equipe de desenvolvimento:*
- 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 da primeira prova de conceito do SecGen
- Connor Wilson
Muitos agradecimentos a todos que contribuíram para o projeto. A lista acima não é completa ou exaustiva, consulte o [histórico do GitHub](https://github.com/cliffe/SecGen/graphs/contributors).
*Suporte a subsídios:*
- Este projeto é apoiado por uma bolsa de ensino e aprendizagem em segurança cibernética da Higher Education Academy (HEA) (2015-2017).
- Este projeto é apoiado por uma bolsa do Teaching Excellence Fund da Leeds Beckett University (2018-2019).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do CyBOK 1.0 (2021).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do CyBOK 1.1 (2021-2022).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do CyBOK 1.1 (2022-2023).
- Este projeto é apoiado por uma bolsa do CyberASAP (Cyber Security Academic Startup Accelerator Programme) Innovate UK (2022-2023).
- Este projeto é apoiado por uma bolsa do Teaching Excellence Fund da Leeds Beckett University (2023).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do CyBOK 1.1 (2023-2024).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do CyBOK 1.1 (2024-2025).
- Este projeto é apoiado por uma bolsa de recursos do Cyber Security Body of Knowledge (CyBOK) em torno do Security-Informed Safety (2025-2026).
## Contribuição
Incentivamos contribuições para o projeto.
Resumidamente, faça um fork de http://github.com/cliffe/SecGen/, crie um branch, faça e commit suas alterações e, em seguida, crie um pull request.
## Recursos
Artigo: [Z.C. Schreuders, T. Shaw, "Laboratórios de Segurança Cibernética Hacktivity: Desafios Randomizados e Gerenciamento de Infraestrutura de Virtualização, com Integração CyBOK," Avanços na Educação em Segurança Cibernética, Bristol, Reino Unido. CSE-Connect, 2024.](https://link.springer.com/chapter/10.1007/978-3-031-77524-6_4#citeas)
Artigo: [Z.C. Schreuders, T. Shaw, A. Mac Muireadhaigh e P. Staniforth, "Hackerbot: Chatbots Ataques para Laboratórios de Segurança Randomizados e Interativos, Usando SecGen e oVirt," USENIX Workshop on Advances in Security Education (ASE'18), Baltimore, MD, EUA. USENIX Association, 2018.](https://www.usenix.org/conference/ase18/presentation/schreuders) (Este artigo descreve o Hackerbot e como usamos o SecGen com oVirt.)
Artigo: [Z.C. Schreuders, T. Shaw, M. Shan-A-Khuda, G. Ravichandran, J. Keighley e M. Ordean, "Security Scenario Generator (SecGen): Uma Estrutura para Gerar VMs de Cenário Rico Aleatoriamente Vulneráveis para Aprendizagem de Segurança de Computadores e Realização de Eventos CTF," USENIX Workshop on Advances in Security Education (ASE'17), Vancouver, BC, Canadá. USENIX Association, 2017.](https://www.usenix.org/conference/ase17/workshop-program/presentation/schreuders) (Este artigo fornece uma boa visão geral do SecGen.)
Artigo: [Z.C. Schreuders e L. Ardern, "Gerando cenários virtualizados aleatórios para hacking ético e educação em segurança de computadores: Implementação e implantação do SecGen," no The first UK Workshop on Cybersecurity Training & Education (Vibrant Workshop 2015) Liverpool, Reino Unido, 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 artigo descreve o primeiro protótipo.)
Entrevista em podcast: [Purple Squad Security Episode 011 – Security Scenario Generator com Dr. Z. Cliffe Schreuders](https://purplesquadsec.com/podcast/episode-011-security-scenario-generator-dr-z-cliffe-schreuders/)