cliffe/secgenCréer des VM aléatoirement non sécurisées
SecGen crée des machines virtuelles vulnérables, des environnements de laboratoire et des défis de piratage, afin que les étudiants puissent apprendre les techniques de tests de pénétration en sécurité.
Des boîtes comme Metasploitable2 sont toujours identiques ; ce projet utilise Vagrant, Puppet et Ruby pour créer des machines virtuelles aléatoirement vulnérables qui peuvent être utilisées pour l'apprentissage ou pour héberger des événements CTF.
La dernière version est disponible à : http://github.com/cliffe/SecGen/
Merci de répondre à un court sondage pour nous dire comment vous utilisez SecGen.
Pour une solution hébergée, visitez : https://hacktivity.co.uk/
Les étudiants en sécurité informatique bénéficient de la participation à des défis de piratage. Les travaux pratiques en laboratoire et les défis de piratage préconfigurés sont une pratique courante dans l'enseignement de la sécurité, ainsi qu'un passe-temps pour les personnes intéressées par la sécurité. Les défis de piratage compétitifs, tels que les compétitions capture the flag (CTF), sont devenus un pilier des conférences industrielles et sont au centre de grandes communautés en ligne. Les machines virtuelles (VM) offrent un moyen efficace de partager des cibles de piratage et peuvent être conçues pour tester les compétences de l'attaquant. Des sites Web tels que Vulnhub hébergent des VM de défis de piratage préconfigurées et constituent une ressource précieuse pour ceux qui apprennent et améliorent leurs compétences en sécurité informatique. Cependant, développer ces défis de piratage prend du temps, et une fois créés, ils sont essentiellement statiques. Autrement dit, une fois le défi « résolu », il ne reste plus de défi pour l'étudiant, et si le défi est créé pour une compétition ou une évaluation, il ne peut pas être réutilisé sans risquer le plagiat et la collusion.
Le Générateur de scénarios de sécurité (SecGen) génère des systèmes vulnérables randomisés. Les VM sont créées en fonction d'une spécification de scénario, qui décrit les contraintes et les propriétés des VM à créer. Par exemple, un scénario pourrait spécifier la création d'un système avec une vulnérabilité exploitable à distance qui entraînerait un compromis au niveau utilisateur, et une faille exploitable localement qui entraînerait un compromis au niveau root. Cela obligerait l'attaquant à découvrir et à exploiter les deux vulnérabilités sélectionnées aléatoirement afin d'obtenir un accès root au système. Alternativement, le scénario défini peut être plus spécifique, en spécifiant certains types de services (tels que FTP ou SMB) ou même des vulnérabilités exactes (par CVE).
SecGen est une application Ruby, avec un langage de configuration XML. SecGen lit sa configuration, y compris les vulnérabilités, services, réseaux, utilisateurs et contenus disponibles, lit la définition du scénario demandé, applique une logique de randomisation du scénario, et exploite Puppet et Vagrant pour provisionner les VM requises.
SecGen est un logiciel libre : vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU telle que publiée par la Free Software Foundation, soit la version 3 de la Licence, soit (à votre choix) toute version ultérieure.
SecGen contient des modules, qui installent divers packages logiciels. Chaque module SecGen peut contenir ou sourcer à distance des logiciels, et chaque module définit sa propre licence dans le fichier secgen_metadata.xml qui l'accompagne.
SecGen est développé et testé sur Ubuntu Linux. En théorie, SecGen devrait fonctionner sur Mac ou Windows, si tous les logiciels requis sont installés.
Vous devrez installer les éléments suivants :
Ce projet a été adapté pour fonctionner avec la version Ubuntu (20.04) en raison de la fin de vie de (16.04) à partir d'avril 2021, bien qu'il fonctionne encore sur cette version, il n'est pas garanti de prendre en charge les mises à jour de sécurité nécessaires pour votre environnement de développement.
Assurez-vous qu'Ubuntu est mis à jour en utilisant les commandes suivantes :```bash sudo apt update sudo apt upgrade
Installer une version récente 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
Installer les autres paquets requis :```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
Clonez le dépôt SecGen en utilisant la commande suivante.Par défaut, ce sera /home/username/SecGen, modifiez si nécessaire:```bash
git clone https://github.com/cliffe/SecGen.git
Installez les gems en utilisant les commandes suivantes :```bash #Step In to the file directory
cd /home/username/SecGen
bundle update --bundler
Mettre à jour gems:```bash
bundle update
Installez tous les paquets requis :```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
Copiez SecGen dans un répertoire de votre choix, tel que */home/user/bin/SecGen*
Ensuite, installez les gems :```bash
cd /home/user/bin/SecGen
bundle install
Pour utiliser les boîtes de base Windows, vous devrez installer Packer. Utilisez la commande suivante :```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
## Usage
Utilisation de base :```bash
ruby secgen.rb run
Ceci utilisera le scénario par défaut pour générer aléatoirement des VM(s).
SecGen accepte des arguments pour changer son comportement, les arguments actuellement implémentés sont :```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
## Dépannage : mise à jour des boîtes de base
Si SecGen rencontre des erreurs lors de l'installation de paquets, il se peut que les machines virtuelles modèles (boîtes de base) que nous publions sur Vagrant cloud aient besoin d'être mises à jour (notamment Kali, qui est une version à publication continue). Après avoir construit quelques machines virtuelles, naviguez dans votre répertoire personnel `.vagrant.d/boxes/`, à partir duquel vous pouvez lancer manuellement les machines virtuelles utilisées comme modèles et appliquer les mises à jour logicielles `sudo apt-get update; sudo apt-get upgrade`. Ensuite, éteignez la machine virtuelle et réessayez SecGen.
Pour Proxmox, utilisez ce plugin Vagrant : https://github.com/cliffe/vagrant-proxmox/, et appliquez ce correctif à Vagrant : https://github.com/hashicorp/vagrant/pull/12463/files.
Vous devrez généralement créer une machine virtuelle de base Debian Buster, en suivant ces instructions :
https://github.com/cliffe/SecGen/blob/master/README-Creating-Bases.md
## Scénarios
SecGen génère des machines virtuelles basées sur une spécification de scénario, qui décrit les contraintes et les propriétés des machines virtuelles à créer.
### Utilisation de scénarios existants
Les scénarios existants rendent l'entrée dans SecGen simple : lors de l'invocation de SecGen, un scénario peut être spécifié comme argument de commande, et SecGen lira alors la définition de scénario appropriée et procédera à la randomisation et à la génération de la machine virtuelle. Cela supprime la nécessité pour les utilisateurs finaux du framework de comprendre la spécification de configuration de SecGen.
Les scénarios se trouvent dans le répertoire scenarios/. Par exemple, pour lancer une machine virtuelle qui présente une vulnérabilité exploitable à distance aléatoire entraînant une compromission au niveau utilisateur :```bash
ruby secgen.rb --scenario scenarios/examples/remotely_exploitable_user_vulnerability.xml run
Pour générer un ensemble de machines virtuelles pour une organisation fictive générée aléatoirement, comprenant un poste de travail, un serveur web et un serveur intranet :```bash ruby secgen.rb --scenario scenarios/security_audit/team_project.xml run
Notez que le serveur intranet a un mandat de sécurité, avec des instructions pour effectuer un audit de sécurité de ces systèmes. Le système de bureau peut accéder à l'intranet pour consulter le mandat, mais la machine de l'attaquant (par exemple, Kali) peut être connectée uniquement à la carte réseau partagée par le serveur Web pour simuler la nécessité de pivoter les attaques via le serveur Web, car elle ne peut pas se connecter directement au système intranet. Le « guide de notation » se présente sous la forme du fichier de sortie scenario.xml dans le répertoire du projet, qui fournit les détails des systèmes générés.
#### Machines virtuelles pour un événement CTF
Pour générer un ensemble de machines virtuelles pour une compétition CTF :```bash
ruby secgen.rb --scenario scenarios/ctf/flawed_fortress_1.xml run
Notez qu'un fichier CTFd_importable.zip est également généré, contenant tous les flags et indices, que vous pouvez importer dans le frontend du classement CTFd.
Ceci est compatible avec CTFd v2.0.2 et plus récent.
Compte administrateur par défaut : Nom d'utilisateur : adminusername Mot de passe : adminpassword
Écrire vos propres scénarios vous permet de définir une machine virtuelle ou un ensemble de machines virtuelles avec une configuration aussi spécifique ou générale que souhaité.
La spécification de scénario de SecGen est une interface puissante pour définir les contraintes des systèmes vulnérables à générer. Les scénarios sont définis dans des fichiers de configuration XML qui spécifient les systèmes en termes de base, de services/utilitaires, de vulnérabilités et de réseaux.
Pour plus de détails, veuillez consulter le guide de création de scénarios.
SecGen est conçu pour être facilement extensible avec des modules qui définissent des vulnérabilités et d'autres types de logiciels, de configurations et de modifications de contenu.
Les types de modules supportés par SecGen sont :
Chaque module de vulnérabilité est contenu dans l'arborescence des répertoires modules/vulnerabilities, qui est organisée pour correspondre à la structure des répertoires du module Metasploit Framework (MSF). Par exemple, le module de vulnérabilité distcc_exec est contenu dans : modules/vulnerabilities/unix/misc/distcc_exec/.
La racine du répertoire du module contient toujours un fichier secgen_metadata.xml et contient également des fichiers Puppet, qui sont utilisés pour rendre un système vulnérable.
Pour plus de détails, veuillez consulter le guide des métadonnées des modules.
Les encodeurs et les générateurs ont un code qui est évalué au moment de la construction du projet, comme l'encodage de texte, la génération de flags et d'autres contenus potentiellement aléatoires. Dans chaque cas, il s'agit d'un script Ruby situé dans le répertoire du module dans local/secgen_local.rb. Bien qu'il soit normalement appelé par SecGen, les scripts secgen_local.rb peuvent être exécutés directement, et acceptent toutes les entrées de paramètres comme arguments de ligne de commande, et renvoient la sortie au format JSON sur stdout. D'autres sorties lisibles par l'homme sont écrites sur 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 est utilisé pour provisionner les VM
Chaque module de vulnérabilité, de service et d'utilitaire contient des fichiers Puppet qui sont utilisés pour provisionner les logiciels et les changements de configuration sur les VMs. Au moment où Puppet est exécuté pour provisionner les VMs, toute la randomisation a déjà eu lieu lors de la construction.
Pour plus de détails, veuillez consulter le **[guide des modules Puppet](https://github.com/cliffe/secgen/blob/master/README-Modules-Puppet.md)**.
## Sortie du projet SecGen
Par défaut, la sortie se fait dans 'projects/SecGen_*[CurrentTime]*/'
La sortie du projet comprend :
- Une configuration Vagrant pour lancer les machines.
- Un répertoire contenant tous les modules Puppet requis pour ce qui précède. Un fichier Librarian-Puppet est créé pour gérer les modules, et certains modules requis peuvent être obtenus via PuppetForge, donc une connexion Internet est nécessaire lors de la construction du projet.
- Un fichier XML de scénario dé-randomisé. En utilisant SecGen, vous pouvez utiliser ce fichier 'scenario.xml' pour recréer la configuration Vagrant et les fichiers Puppet ci-dessus. Toute randomisation qui a été appliquée devrait être dé-randomisée dans cette sortie (par rapport au fichier de scénario original). Ce fichier contient tous les détails des systèmes créés, et peut également être utilisé plus tard pour la notation, le scoring ou pour donner des indices.
- Un fichier 'flag_hints.xml', contenant tous les flags avec plusieurs indices par flag.
- Un fichier 'CTFd_importable.zip' utile pour les événements CTF, pour import dans le [frontend du tableau de bord CTFd](https://github.com/CTFd/CTFd).
Si vous démarrez SecGen avec la commande "build-project" (ou "p"), il crée les fichiers ci-dessus puis s'arrête. La commande "run" (ou "r") crée les fichiers du projet puis utilise Vagrant pour construire la ou les VMs.
Il est possible de copier le répertoire du projet sur tout système compatible avec Vagrant, et simplement exécuter "vagrant up" pour créer les VMs.
Le mot de passe root par défaut pour les boîtes de base est 'puppet', mais cela peut être modifié par SecGen en fonction du scénario utilisé.
## Traitement par lots avec SecGen
La génération de plusieurs VMs par lots est désormais possible grâce à l'utilisation de batch_secgen, qui gère une file d'attente de jobs pour créer en masse des VMs avec SecGen. Des commandes d'aide sont disponibles pour ajouter des jobs, lister les jobs dans le tableau, supprimer des jobs, et réinitialiser le statut des jobs de 'running' ou 'error' à 'todo'.
Pour plus de détails, veuillez consulter le **[guide de création par lots de VMs](https://github.com/cliffe/secgen/blob/master/README-Batch-VMs.md)**.
## Clé des domaines de connaissance CyBOK
Le Cyber Security Body of Knowledge (CyBOK) est un corpus de connaissances qui vise à encapsuler les différents domaines de connaissance présents dans la cybersécurité.
Les scénarios dans SecGen contiennent désormais des éléments XML les reliant aux domaines de connaissance CyBOK et à des sujets spécifiques au sein de ces domaines.
De plus, le contenu vidéo des scénarios est étiqueté avec des associations CyBOK.
Pour un index des scénarios de laboratoire dans SecGen organisé par domaines de connaissance CyBOK, veuillez consulter **[Lab Scenarios and CyBOK](https://github.com/cliffe/secgen/blob/master/README-CyBOK-Scenarios-Indexed.md)**. De même, pour les **[scénarios CTF](https://github.com/cliffe/secgen/blob/master/README-CyBOK-CTF-Scenarios-Indexed.md)**.
Pour une liste de vidéos de cours et de démonstration avec métadonnées CyBOK, veuillez consulter **[Lecture Videos and CyBOK](https://github.com/cliffe/secgen/blob/master/README-CyBOK-Lecture-Videos.md)**.
Le tableau ci-dessous est une clé pour les abréviations que vous trouverez dans les éléments XML CyBOK au sein des scénarios :
| Abréviation | Domaine de connaissance (KA) | Chapitre | Arbre de connaissances |
| ----------- | -------------------- | ------- | --------------|
| IC | Introduction à CyBOK | [lien](https://www.cybok.org/media/downloads/Introduction_to_CyBOK.pdf)| [lien](https://www.cybok.org/media/downloads/CyBOK_introduction.pdf) |
| FM | Méthodes formelles | n/a | [lien](https://www.cybok.org/media/downloads/Formal_Methods_for_Security_VK6XZwO.pdf)|
| RMG | Gestion des risques & gouvernance | [lien](https://www.cybok.org/media/downloads/Risk-Management--Governance-issue-1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Risk_Management__Governancev2.pdf)|
| LR | Droit & réglementation | [lien](https://www.cybok.org/media/downloads/Law__Regulation_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Law__Regulation.pdf)|
| HF | Facteurs humains | [lien](https://www.cybok.org/media/downloads/Human_Factors_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Human_Factors.pdf)|
| POR | Vie privée & droits en ligne | [lien](https://www.cybok.org/media/downloads/Privacy__Online_Rights_issue_1.0_FNULPeI.pdf)| [lien](https://www.cybok.org/media/downloads/Privacy__Online_Rights.pdf)|
| MAT | Malwares & Technologies d'attaque | [lien](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Malware__Attack_Technologies.pdf)|
| AB | Comportements adverses | [lien](https://www.cybok.org/media/downloads/Malware__Attack_Technology_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Adversarial_Behaviours.pdf)|
| SOIM | Opérations de sécurité & Gestion des incidents | [lien](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Security_Operations__Incident_Management.pdf)|
| F | Forensique | [lien](https://www.cybok.org/media/downloads/Forensics_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Forensics.pdf)|
| C | Cryptographie | [lien](https://www.cybok.org/media/downloads/Cryptography-issue-1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Cryptography.pdf)|
| AC | Cryptographie appliquée | [lien](https://www.cybok.org/media/downloads/Applied_Cryptography_v1.0.0.pdf)| [lien](https://www.cybok.org/media/downloads/Applied_Cryptography_tree-1.0.0.pdf)|
| OSV | Sécurité des systèmes d'exploitation & virtualisation | [lien](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security_issue_1.0_xhesi5S.pdf)| [lien](https://www.cybok.org/media/downloads/Operating_Systems__Virtualisation_Security.pdf)|
| DSS | Sécurité des systèmes distribués | [lien](https://www.cybok.org/media/downloads/Distributed_Systems_Security_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Distributed_Systems_Security.pdf)|
| AAA | Authentification, Autorisation et Responsabilité | [lien](https://www.cybok.org/media/downloads/AAA_issue_1.0_q3qspzo.pdf)| [lien](https://www.cybok.org/media/downloads/AAA.pdf) |
| SS | Sécurité logicielle | [lien](https://www.cybok.org/media/downloads/Software_Security_issue_1.0_1M7Kfk2.pdf)| [lien](https://www.cybok.org/media/downloads/Software_Security.pdf)|
| WAM | Sécurité Web et mobile | [lien](https://www.cybok.org/media/downloads/Web__Mobile_Security_issue_1.0_XFpbYNz.pdf)| [lien](https://www.cybok.org/media/downloads/Web__Mobile_Security.pdf)|
| SSL | Cycle de vie sécurisé du logiciel | [lien](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Secure_Software_Lifecycle.pdf)|
| NS | Sécurité réseau | [lien](https://www.cybok.org/media/downloads/Network_Security_issue_1.0_qsCh0SR.pdf)| [lien](https://www.cybok.org/media/downloads/Network_Security.pdf)|
| HS | Sécurité matérielle | [lien](https://www.cybok.org/media/downloads/Hardware_Security_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Hardware_Security.pdf)|
| CPS | Systèmes cyberphysiques | [lien](https://www.cybok.org/media/downloads/Cyber-Physical_Systems_Security_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Cyber_Physical_Systems_Security.pdf)|
| PLT | Sécurité de la couche physique et des télécommunications | [lien](https://www.cybok.org/media/downloads/Physical_Layer__Telecommunications_Security_issue_1.0.pdf)| [lien](https://www.cybok.org/media/downloads/Physical_Layer__Telecomms_Security.pdf)|
## Hacktivity Cyber Security Labs
[Pour une solution hébergée, visitez : https://hacktivity.leedsbeckett.ac.uk/](https://hacktivity.leedsbeckett.ac.uk/)
Hacktivity est propulsé par SecGen, et fournit un environnement de laboratoire entièrement hébergé pour l'éducation à la cybersécurité. Suivez votre progression avec les informations CyBOK.
## Remerciements
*Équipe de développement :*
- 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 -- auteur de la première version de proof-of-concept de SecGen
- Connor Wilson
Un grand merci à tous ceux qui ont contribué au projet. La liste ci-dessus n'est pas complète ni exhaustive, veuillez consulter l'[historique GitHub](https://github.com/cliffe/SecGen/graphs/contributors).
*Soutien par subventions :*
- Ce projet est soutenu par une subvention d'apprentissage et d'enseignement en cybersécurité de la Higher Education Academy (HEA) (2015-2017).
- Ce projet est soutenu par une subvention du Fonds d'excellence pédagogique de l'Université Leeds Beckett (2018-2019).
- Ce projet est soutenu par une subvention de ressources autour de CyBOK 1.0 du Cyber Security Body of Knowledge (CyBOK) (2021).
- Ce projet est soutenu par une subvention de ressources autour de CyBOK 1.1 du Cyber Security Body of Knowledge (CyBOK) (2021-2022).
- Ce projet est soutenu par une subvention de ressources autour de CyBOK 1.1 du Cyber Security Body of Knowledge (CyBOK) (2022-2023).
- Ce projet est soutenu par une subvention Innovate UK du CyberASAP (Cyber Security Academic Startup Accelerator Programme) (2022-2023).
- Ce projet est soutenu par une subvention du Fonds d'excellence pédagogique de l'Université Leeds Beckett (2023).
- Ce projet est soutenu par une subvention de ressources autour de CyBOK 1.1 du Cyber Security Body of Knowledge (CyBOK) (2023-2024).
- Ce projet est soutenu par une subvention de ressources autour de CyBOK 1.1 du Cyber Security Body of Knowledge (CyBOK) (2024-2025).
- Ce projet est soutenu par une subvention de ressources autour de la sécurité informée par la sécurité (Security-Informed Safety) du Cyber Security Body of Knowledge (CyBOK) (2025-2026).
## Contribuer
Nous encourageons les contributions au projet.
En bref, veuillez forker depuis http://github.com/cliffe/SecGen/, créer une branche, effectuer et committer vos modifications, puis créer une pull request.
## Ressources
Article : [Z.C. Schreuders, T. Shaw, "Hacktivity Cyber Security Labs: Défis aléatoires et gestion de l'infrastructure de virtualisation, avec intégration CyBOK," Advances in Cyber Security Education, Bristol, Royaume-Uni. CSE-Connect, 2024.](https://link.springer.com/chapter/10.1007/978-3-031-77524-6_4#citeas)
Article : [Z.C. Schreuders, T. Shaw, A. Mac Muireadhaigh, and P. Staniforth, "Hackerbot: Chatbots attaquants pour des laboratoires de sécurité randomisés et interactifs, utilisant SecGen et oVirt," USENIX Workshop on Advances in Security Education (ASE'18), Baltimore, MD, USA. USENIX Association, 2018.](https://www.usenix.org/conference/ase18/presentation/schreuders) (Cet article décrit Hackerbot et comment nous utilisons SecGen avec oVirt.)
Article : [Z.C. Schreuders, T. Shaw, M. Shan-A-Khuda, G. Ravichandran, J. Keighley, and M. Ordean, "Security Scenario Generator (SecGen) : Un cadre pour générer des VM aléatoirement vulnérables et riches en scénarios pour l'apprentissage de la sécurité informatique et l'organisation d'événements CTF," 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) (Cet article fournit une bonne vue d'ensemble de SecGen.)
Article : [Z.C. Schreuders, and L. Ardern, "Génération de scénarios virtualisés randomisés pour le hacking éthique et l'éducation à la sécurité informatique : implémentation et déploiement de SecGen," in The first UK Workshop on Cybersecurity Training & Education (Vibrant Workshop 2015) Liverpool, Royaume-Uni, 2015.](http://z.cliffe.schreuders.org/publications/VibrantWorkshop2015%20-%20Generating%20randomised%20virtualised%20scenarios%20for%20ethical%20hacking%20and%20computer%20security%20education%20%28SecGen%29.pdf) (Cet article décrit le premier prototype.)
Interview podcast : [Purple Squad Security Episode 011 – Security Scenario Generator avec Dr. Z. Cliffe Schreuders](https://purplesquadsec.com/podcast/episode-011-security-scenario-generator-dr-z-cliffe-schreuders/)