cliffe/secgenCrea VM insicure in modo casuale
SecGen crea macchine virtuali vulnerabili, ambienti di laboratorio e sfide di hacking, in modo che gli studenti possano apprendere le tecniche di penetration testing.
Box come Metasploitable2 sono sempre uguali, questo progetto utilizza Vagrant, Puppet e Ruby per creare macchine virtuali casualmente vulnerabili che possono essere utilizzate per l'apprendimento o per ospitare eventi CTF.
L'ultima versione è disponibile su: http://github.com/cliffe/SecGen/
Completa un breve sondaggio per dirci come utilizzi SecGen.
Per una soluzione ospitata visita: https://hacktivity.co.uk/
Gli studenti di sicurezza informatica traggono vantaggio dall'impegnarsi in sfide di hacking. Il lavoro pratico in laboratorio e le sfide di hacking preconfigurate sono una pratica comune sia nell'educazione alla sicurezza che come passatempo per individui interessati alla sicurezza. Le sfide di hacking competitive, come le competizioni capture the flag (CTF), sono diventate un punto fermo nelle conferenze di settore e sono il fulcro di grandi comunità online. Le macchine virtuali (VM) forniscono un modo efficace per condividere bersagli per l'hacking e possono essere progettate per testare le abilità dell'attaccante. Siti web come Vulnhub ospitano VM di sfide di hacking preconfigurate e sono una risorsa preziosa per coloro che apprendono e migliorano le loro competenze in sicurezza informatica. Tuttavia, sviluppare queste sfide di hacking richiede tempo e, una volta create, sono essenzialmente statiche. Cioè, una volta che la sfida è stata "risolta", non rimane alcuna sfida per lo studente, e se la sfida è creata per una competizione o una valutazione, non può essere riutilizzata senza rischiare plagio e collusione.
Security Scenario Generator (SecGen) genera sistemi vulnerabili randomizzati. Le VM vengono create in base a una specifica di scenario, che descrive i vincoli e le proprietà delle VM da creare. Ad esempio, uno scenario potrebbe specificare la creazione di un sistema con una vulnerabilità sfruttabile da remoto che comporterebbe un compromesso a livello utente, e un difetto sfruttabile localmente che comporterebbe un compromesso a livello root. Ciò richiederebbe all'attaccante di scoprire e sfruttare entrambe le vulnerabilità selezionate casualmente per ottenere accesso root al sistema. In alternativa, lo scenario definito può essere più specifico, specificando certi tipi di servizi (come FTP o SMB) o anche vulnerabilità esatte (per CVE).
SecGen è un'applicazione Ruby, con un linguaggio di configurazione XML. SecGen legge la sua configurazione, incluse le vulnerabilità, i servizi, le reti, gli utenti e i contenuti disponibili, legge la definizione dello scenario richiesto, applica la logica per randomizzare lo scenario e sfrutta Puppet e Vagrant per il provisioning delle VM richieste.
SecGen è software libero: puoi ridistribuirlo e/o modificarlo secondo i termini della GNU General Public License come pubblicata dalla Free Software Foundation, sia la versione 3 della Licenza, o (a tua scelta) qualsiasi versione successiva.
SecGen contiene moduli, che installano vari pacchetti software. Ogni modulo SecGen può contenere o ottenere software da remoto, e ogni modulo definisce la propria licenza nel file secgen_metadata.xml allegato.
SecGen è sviluppato e testato su Ubuntu Linux. In teoria, SecGen dovrebbe funzionare su Mac o Windows, se hai tutto il software richiesto installato.
Dovrai installare quanto segue:
Questo progetto è stato adattato per funzionare con la release Ubuntu (20.04) a causa della fine del ciclo di vita di (16.04) ad aprile 2021, sebbene funzioni ancora su quella versione, non è garantito che supporti gli aggiornamenti di sicurezza necessari per il tuo ambiente di sviluppo.
Assicurati che Ubuntu sia aggiornato usando i seguenti comandi:```bash sudo apt update sudo apt upgrade
Installa una versione recente di 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
Installa gli altri pacchetti richiesti:```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 il repository SecGen usando il seguente comando.Di default sarà /home/username/SecGen, modifica come necessario:```bash
git clone https://github.com/cliffe/SecGen.git
Installa le gemme usando i seguenti comandi:```bash #Step In to the file directory
cd /home/username/SecGen
bundle update --bundler
Aggiorna le gemme:```bash
bundle update
Installa tutti i pacchetti necessari:```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 in una directory a tua scelta, ad esempio */home/user/bin/SecGen*
Poi installa i gems:```bash
cd /home/user/bin/SecGen
bundle install
Per utilizzare i basesboxes Windows sarà necessario installare Packer. Utilizza il seguente 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
## Utilizzo
Utilizzo base:```bash
ruby secgen.rb run
Utilizzerà lo scenario predefinito per generare casualmente VM.
SecGen accetta argomenti per cambiare il suo comportamento. Gli argomenti attualmente implementati sono:```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
## Risoluzione dei problemi: aggiornamento delle base box
Se SecGen riscontra errori durante l'installazione dei pacchetti, le VM template (base box) che pubblichiamo su Vagrant cloud potrebbero aver bisogno di aggiornamenti (soprattutto Kali, che è una rolling-release). Dopo aver creato alcune VM, naviga nella home directory `.vagrant.d/boxes/`, da qui puoi avviare manualmente le VM utilizzate come template e applicare gli aggiornamenti software `sudo apt-get update; sudo apt-get upgrade`. Quindi spegni la VM e riprova con SecGen.
Per Proxmox, usa questo plugin Vagrant: https://github.com/cliffe/vagrant-proxmox/, e applica questa correzione a Vagrant: https://github.com/hashicorp/vagrant/pull/12463/files.
Di solito sarà necessario creare una VM base Debian Buster, seguendo in linea di massima queste istruzioni:
https://github.com/cliffe/SecGen/blob/master/README-Creating-Bases.md
## Scenari
SecGen genera VM basate su una specifica di scenario, che descrive i vincoli e le proprietà delle VM da creare.
### Utilizzo di scenari esistenti
Gli scenari esistenti rendono bassa la barriera di ingresso per SecGen: quando si invoca SecGen, è possibile specificare uno scenario come argomento del comando, e SecGen leggerà la definizione dello scenario appropriato e procederà alla randomizzazione e generazione delle VM. Ciò elimina la necessità per gli utenti finali del framework di comprendere la specifica di configurazione di SecGen.
Gli scenari si trovano nella directory scenarios/. Ad esempio, per avviare una VM che ha una vulnerabilità remota sfruttabile casuale che porta a una compromissione a livello utente:```bash
ruby secgen.rb --scenario scenarios/examples/remotely_exploitable_user_vulnerability.xml run
Per generare un set di VM per un'organizzazione fittizia generata casualmente, con un sistema desktop, un server web e un server intranet:```bash ruby secgen.rb --scenario scenarios/security_audit/team_project.xml run
Si noti che il server intranet ha un ambito di sicurezza, con istruzioni su come eseguire un audit di sicurezza di questi sistemi. Il sistema desktop può accedere all'intranet per consultare l'ambito, ma la VM dell'attaccante (ad esempio, Kali) può essere collegata solo alla NIC condivisa dal server Web per simulare la necessità di effettuare attacchi pivot attraverso il server Web, poiché non può connettersi direttamente al sistema intranet. La "guida di valutazione" è in forma del file scenario.xml nella directory del progetto, che fornisce i dettagli dei sistemi generati.
#### VM per un evento CTF
Per generare un set di VM per una competizione CTF:```bash
ruby secgen.rb --scenario scenarios/ctf/flawed_fortress_1.xml run
Nota che viene generato anche un file 'CTFd_importable.zip', contenente tutte le flag e i suggerimenti, che puoi importare nel frontend del tabellone CTFd. Questo è compatibile con CTFd v2.0.2 e versioni successive.
Account amministratore predefinito: Nome utente: adminusername Password: adminpassword
Scrivere i propri scenari consente di definire una VM o un insieme di VM con una configurazione tanto specifica quanto generale a piacere.
La specifica degli scenari di SecGen è un'interfaccia potente per specificare i vincoli dei sistemi vulnerabili da generare. Gli scenari sono definiti in file di configurazione XML che specificano i sistemi in termini di base, servizi/utility, vulnerabilità e reti.
Per dettagli, consulta la guida alla Creazione degli Scenari.
SecGen è progettato per essere facilmente estendibile con moduli che definiscono vulnerabilità e altri tipi di modifiche software, di configurazione e di contenuto.
I tipi di moduli supportati in SecGen sono:
Ogni modulo di vulnerabilità è contenuto all'interno dell'albero delle directory modules/vulnerabilies, organizzato per corrispondere alla struttura delle directory dei moduli di Metasploit Framework (MSF). Ad esempio, il modulo di vulnerabilità distcc_exec è contenuto in: modules/vulnerabilities/unix/misc/distcc_exec/.
La radice della directory del modulo contiene sempre un file secgen_metadata.xml e contiene anche file puppet, utilizzati per rendere un sistema vulnerabile.
Per dettagli, consulta la guida ai Metadati dei Moduli.
I codificatori e i generatori hanno codice che viene valutato al momento della build del progetto, come la codifica del testo e la generazione di flag e altri contenuti potenzialmente randomizzati. In ogni caso, si tratta di uno script ruby situato all'interno della directory del modulo in local/secgen_local.rb. Sebbene normalmente chiamati da SecGen, gli script secgen_local.rb possono essere eseguiti direttamente e accettano tutti i parametri di input come argomenti della riga di comando, e restituiscono l'output in formato JSON su stdout. Altri output leggibili dall'uomo vengono scritti su 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 è utilizzato per il provisioning delle VM
Ogni modulo di vulnerabilità, servizio e utilità contiene file Puppet che vengono utilizzati per eseguire il provisioning del software e delle modifiche di configurazione sulle VM. Quando Puppet viene eseguito per il provisioning delle VM, tutta la randomizzazione è già avvenuta in fase di build.
Per i dettagli, consultare la **[Guida ai moduli Puppet](https://github.com/cliffe/secgen/blob/HEAD/README-Modules-Puppet.md)**.
## Output del progetto SecGen
Per impostazione predefinita, l'output è in 'projects/SecGen_*[CurrentTime]*/'
L'output del progetto include:
- Una configurazione Vagrant per avviare le macchine virtuali.
- Una directory contenente tutti i moduli puppet richiesti per quanto sopra. Viene creato un file Librarian-Puppet per gestire i moduli, e alcuni moduli richiesti possono essere ottenuti tramite PuppetForge, pertanto è necessaria una connessione Internet durante la costruzione del progetto.
- Un file XML di scenario de-randomizzato. Usando SecGen puoi utilizzare questo file 'scenario.xml' per ricreare la configurazione Vagrant e i file puppet sopra menzionati. Ogni randomizzazione applicata dovrebbe essere de-randomizzata in questo output (rispetto al file scenario originale). Questo file contiene tutti i dettagli dei sistemi creati, e può essere utilizzato in seguito per valutazioni, punteggi o suggerimenti.
- Un file 'flag_hints.xml', contenente tutte le flag insieme a molti suggerimenti per flag.
- Un file 'CTFd_importable.zip' utile per eventi CTF, per l'importazione nel [frontend della classifica CTFd](https://github.com/CTFd/CTFd).
Se avvii SecGen con il comando "build-project" (o "p") crea i file sopra e poi si ferma. Il comando "run" (o "r") crea i file del progetto e poi usa Vagrant per costruire le VM.
È possibile copiare la directory del progetto su qualsiasi sistema compatibile con Vagrant, e semplicemente eseguire "vagrant up" per creare le VM.
La password di root predefinita per le base-box è 'puppet', ma può essere modificata da SecGen a seconda dello scenario utilizzato.
## Elaborazione batch con SecGen
Generare più VM in un batch è ora possibile attraverso l'uso di batch_secgen, che gestisce una coda di job per creare in massa VM con SecGen. Sono disponibili comandi di supporto per aggiungere job, elencare job nella tabella, rimuovere job e reimpostare lo stato dei job da 'running' o 'error' a 'todo'.
Per i dettagli, consultare la **[Guida alla creazione batch di VM](https://github.com/cliffe/secgen/blob/HEAD/README-Batch-VMs.md)**.
## Chiave delle aree di conoscenza CyBOK
Il Cyber Security Body of Knowledge (CyBOK) è un corpo di conoscenze che mira a incapsulare le varie aree di conoscenza presenti nella sicurezza informatica. Gli scenari all'interno di SecGen ora contengono elementi XML che li collegano alle aree di conoscenza CyBOK e a topic specifici all'interno di tali aree. Inoltre, i contenuti video per gli scenari sono taggati con associazioni CyBOK.
Per un indice degli scenari di laboratorio in SecGen organizzati per aree di conoscenza CyBOK, consulta **[Scenari di laboratorio e CyBOK](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-Scenarios-Indexed.md)**. Allo stesso modo, per **[scenari CTF](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-CTF-Scenarios-Indexed.md)**.
Per un elenco di video di lezioni e demo con metadati CyBOK, consulta **[Video di lezioni e CyBOK](https://github.com/cliffe/secgen/blob/HEAD/README-CyBOK-Lecture-Videos.md)**.
La tabella seguente è una chiave per le abbreviazioni che troverete negli elementi XML CyBOK all'interno degli scenari:
| Abbreviazione | Area di conoscenza (KA) | Capitolo | Albero della conoscenza|
| ----------- | -------------------- | ------- | --------------|
| IC | Introduzione a CyBOK | [collegamento](https://www.cybok.org/media/downloads/Introduction_to_CyBOK.pdf)| [collegamento](https://www.cybok.org/media/downloads/CyBOK_introduction.pdf) |
| FM | Metodi formali | n/a | [collegamento](https://www.cybok.org/media/downloads/Formal_Methods_for_Security_VK6XZwO.pdf)|
| RMG | Gestione del rischio e governance | [collegamento](https://www.cybok.org/media/downloads/Risk-Management--Governance-issue-1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Risk_Management__Governancev2.pdf)|
| LR | Legge e regolamentazione | [collegamento](https://www.cybok.org/media/downloads/Law__Regulation_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Law__Regulation.pdf)|
| HF | Fattori umani | [collegamento](https://www.cybok.org/media/downloads/Human_Factors_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Human_Factors.pdf)|
| POR | Privacy e diritti online | [collegamento](https://www.cybok.org/media/downloads/Privacy__Online_Rights_issue_1.0_FNULPeI.pdf)| [collegamento](https://www.cybok.org/media/downloads/Privacy__Online_Rights.pdf)|
| MAT | Malware e tecnologie di attacco | [collegamento](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Malware__Attack_Technologies.pdf)|
| AB | Comportamenti avversari | [collegamento](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Adversarial_Behaviours.pdf)|
| SOIM | Operazioni di sicurezza e gestione degli incidenti | [collegamento](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management.pdf)|
| F | Forensica | [collegamento](https://www.cybok.org/media/downloads/Forensics_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Forensics.pdf)|
| C | Crittografia | [collegamento](https://www.cybok.org/media/downloads/Cryptography-issue-1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Cryptography.pdf)|
| AC | Crittografia applicata | [collegamento](https://www.cybok.org/media/downloads/Applied_Cryptography_v1.0.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Applied_Cryptography_tree-1.0.0.pdf)|
| OSV | Sicurezza dei sistemi operativi e della virtualizzazione | [collegamento](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security_issue_1.0_xhesi5S.pdf)| [collegamento](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security.pdf)|
| DSS | Sicurezza dei sistemi distribuiti | [collegamento](https://www.cybok.org/media/downloads/Distributed_Systems_Security_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Distributed_Systems_Security.pdf)|
| AAA | Autenticazione, autorizzazione e responsabilità | [collegamento](https://www.cybok.org/media/downloads/AAA_issue_1.0_q3qspzo.pdf)| [collegamento](https://www.cybok.org/media/downloads/AAA.pdf) |
| SS | Sicurezza del software | [collegamento](https://www.cybok.org/media/downloads/Software_Security_issue_1.0_1M7Kfk2.pdf)| [collegamento](https://www.cybok.org/media/downloads/Software_Security.pdf)|
| WAM | Sicurezza web e mobile | [collegamento](https://www.cybok.org/media/downloads/Web__Mobile_Security_issue_1.0_XFpbYNz.pdf)| [collegamento](https://www.cybok.org/media/downloads/Web__Mobile_Security.pdf)|
| SSL | Ciclo di vita del software sicuro | [collegamento](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle.pdf)|
| NS | Sicurezza di rete | [collegamento](https://www.cybok.org/media/downloads/Network_Security_issue_1.0_qsCh0SR.pdf)| [collegamento](https://www.cybok.org/media/downloads/Network_Security.pdf)|
| HS | Sicurezza hardware | [collegamento](https://www.cybok.org/media/downloads/Hardware_Security_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Hardware_Security.pdf)|
| CPS | Sistemi cyber-fisici | [collegamento](https://www.cybok.org/media/downloads/Cyber-Physical_Systems_Security_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Cyber_Physical_Systems_Security.pdf)|
| PLT | Sicurezza del livello fisico e delle telecomunicazioni | [collegamento](https://www.cybok.org/media/downloads/Physical_Layer__Telecommunications_Security_issue_1.0.pdf)| [collegamento](https://www.cybok.org/media/downloads/Physical_Layer__Telecomms_Security.pdf)|
## Hacktivity Cyber Security Labs
[Per una soluzione ospitata visita: https://hacktivity.leedsbeckett.ac.uk/](https://hacktivity.leedsbeckett.ac.uk/)
Hacktivity è alimentato da SecGen e fornisce un ambiente di laboratorio completamente ospitato per l'educazione alla sicurezza informatica. Traccia i tuoi progressi con gli insight CyBOK.
## Ringraziamenti
*Team di sviluppo:*
- 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 -- autore del primo proof-of-concept di SecGen
- Connor Wilson
Molte grazie a tutti coloro che hanno contribuito al progetto. L'elenco sopra non è completo o esaustivo, si prega di fare riferimento alla [cronologia di GitHub](https://github.com/cliffe/SecGen/graphs/contributors).
*Supporto sovvenzioni:*
- Questo progetto è supportato da una sovvenzione della Higher Education Academy (HEA) per l'apprendimento e l'insegnamento della sicurezza informatica (2015-2017).
- Questo progetto è supportato da una sovvenzione del Leeds Beckett University Teaching Excellence Fund (2018-2019).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su CyBOK 1.0 (2021).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su CyBOK 1.1 (2021-2022).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su CyBOK 1.1 (2022-2023).
- Questo progetto è supportato da una sovvenzione CyberASAP (Cyber Security Academic Startup Accelerator Programme) di Innovate UK (2022-2023).
- Questo progetto è supportato da una sovvenzione del Leeds Beckett University Teaching Excellence Fund (2023).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su CyBOK 1.1 (2023-2024).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su CyBOK 1.1 (2024-2025).
- Questo progetto è supportato da una sovvenzione del Cyber Security Body of Knowledge (CyBOK) per risorse su Security-Informed Safety (2025-2026).
## Come contribuire
Incoraggiamo i contributi al progetto.
Brevemente, effettua il fork da http://github.com/cliffe/SecGen/, crea un branch, apporta e committa le tue modifiche, quindi crea una pull request.
## Risorse
Articolo: [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)
Articolo: [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) (Questo articolo descrive Hackerbot e come utilizziamo SecGen con oVirt.)
Articolo: [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) (Questo articolo fornisce una buona panoramica di SecGen.)
Articolo: [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) (Questo articolo descrive il primo prototipo.)
Intervista 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/)