lockdown.sh

#!/usr/bin/bash

# Vérifier si on est root
if [ "$(id -u)" -ne 0 ]; then
   echo "Ce script doit être exécuté en tant que root (sudo)."
   exit 1
fi

# Vérifier les arguments
if [ "$#" -ne 2 ]; then
    echo "Usage: $0 <heures_avant_blocage> <durée_bocage_en_heures>"
    echo "Exemple: $0 0.5 8 (pour un blocage dans 30 min qui dure 8h)"
    exit 1
fi

# Remplacer les virgules par des points
DELAY_HOURS=$(echo $1 | tr ',' '.')
LOCK_HOURS=$(echo $2 | tr ',' '.')

# Installer bc si nécessaire (utilise pacman pour Arch)
if ! command -v bc &> /dev/null; then
    echo "Installation de bc nécessaire pour les calculs..."
    pacman -S --noconfirm bc
fi

# Convertir en secondes
DELAY_SECONDS=$(echo "$DELAY_HOURS * 3600" | bc | cut -d'.' -f1)
LOCK_DURATION_SECONDS=$(echo "$LOCK_HOURS * 3600" | bc | cut -d'.' -f1)

# Calculer timestamps
CURRENT_TIME=$(date +%s)
START_TIME=$((CURRENT_TIME + DELAY_SECONDS))
END_TIME=$((START_TIME + LOCK_DURATION_SECONDS))

echo "Configuration du verrouillage avancé pour Arch Linux avec systemd-boot..."

# Détecter la partition EFI
EFI_PARTITION=$(bootctl --print-esp-path 2>/dev/null || echo "/efi")
if [ ! -d "$EFI_PARTITION" ]; then
    EFI_PARTITION="/boot/efi"
fi

echo "Partition EFI détectée: $EFI_PARTITION"

# Créer le répertoire de configuration si nécessaire
mkdir -p /etc/lockdown

# Stocker la configuration
echo "$START_TIME $END_TIME" > /etc/lockdown/schedule
chmod 600 /etc/lockdown/schedule

# Créer le script de vérification précoce
cat > /usr/local/bin/early-lockdown-check.sh << 'EOF'
#!/bin/bash

# Fonction pour éteindre le système en cas de verrouillage actif
check_lockdown() {
    if [ -f "/etc/lockdown/schedule" ]; then
        read START_TIME END_TIME < /etc/lockdown/schedule
        CURRENT_TIME=$(date +%s)
        
        if [ "$CURRENT_TIME" -ge "$START_TIME" ] && [ "$CURRENT_TIME" -lt "$END_TIME" ]; then
            echo "SYSTÈME VERROUILLÉ JUSQU'À $(date -d "@$END_TIME" '+%H:%M:%S le %d/%m/%Y')"
            echo "ARRÊT AUTOMATIQUE DANS 10 SECONDES..."
            sleep 10
            /sbin/poweroff -f
            # Bloquer complètement le démarrage
            exit 1
        elif [ "$CURRENT_TIME" -ge "$END_TIME" ]; then
            # Période terminée, supprimer le fichier
            rm -f /etc/lockdown/schedule
        fi
    fi
    return 0
}

# Exécuter la vérification
check_lockdown
EOF

chmod +x /usr/local/bin/early-lockdown-check.sh

# Créer un hook mkinitcpio personnalisé pour Arch Linux
mkdir -p /etc/initcpio/hooks/
mkdir -p /etc/initcpio/install/

# Hook d'installation pour mkinitcpio
cat > /etc/initcpio/install/lockdown << 'EOF'
#!/bin/bash

build() {
    add_file /etc/lockdown/schedule /etc/lockdown/schedule
    add_binary date
    add_binary cut
    add_runscript
}

help() {
    cat <<HELPEOF
This hook adds lockdown verification to the initramfs.
HELPEOF
}
EOF

# Script qui s'exécute dans l'initramfs
cat > /etc/initcpio/hooks/lockdown << 'EOF'
#!/usr/bin/ash

run_hook() {
    # Si le fichier de verrouillage existe
    if [ -f "/etc/lockdown/schedule" ]; then
        # Lire les timestamps
        read START_TIME END_TIME < /etc/lockdown/schedule
        CURRENT_TIME=$(date +%s)
        
        # Si on est dans la période de verrouillage
        if [ $CURRENT_TIME -ge $START_TIME ] && [ $CURRENT_TIME -lt $END_TIME ]; then
            # Afficher message et bloquer le démarrage
            echo "SYSTÈME VERROUILLÉ JUSQU'À $(date -d "@$END_TIME" '+%H:%M:%S le %d/%m/%Y')"
            echo "ARRÊT DANS 10 SECONDES..."
            sleep 10
            /sbin/poweroff -f
            # Bloquer complètement le démarrage
            while true; do
                echo "SYSTÈME VERROUILLÉ"
                sleep 5
                /sbin/poweroff -f
            done
        fi
    fi
}
EOF

# Modifier /etc/mkinitcpio.conf pour inclure le hook
if ! grep -q "lockdown" /etc/mkinitcpio.conf; then
    # Ajouter le hook lockdown avant fsck dans la ligne HOOKS
    sed -i 's/HOOKS=(/&lockdown /' /etc/mkinitcpio.conf
fi

# Reconstruire l'initramfs avec mkinitcpio (Arch Linux)
echo "Reconstruction de l'initramfs avec le module de verrouillage..."
mkinitcpio -P

# Créer le script de vérification principal
cat > /usr/local/bin/lockdown-check.sh << 'EOF'
#!/bin/bash

# Vérifier si le fichier existe
if [ ! -f "/etc/lockdown/schedule" ]; then
    exit 0
fi

# Lire les timestamps
read START_TIME END_TIME < /etc/lockdown/schedule
CURRENT_TIME=$(date +%s)

# Vérifier la période
if [ "$CURRENT_TIME" -ge "$START_TIME" ] && [ "$CURRENT_TIME" -lt "$END_TIME" ]; then
    # En période de verrouillage
    echo "Système verrouillé jusqu'à $(date -d "@$END_TIME")"
    sleep 3
    /sbin/poweroff -f
elif [ "$CURRENT_TIME" -ge "$END_TIME" ]; then
    # Période terminée
    rm -f /etc/lockdown/schedule
fi
EOF

chmod +x /usr/local/bin/lockdown-check.sh

# Créer plusieurs services systemd pour redondance
# 1. Service très tôt dans le démarrage
cat > /etc/systemd/system/lockdown-check-early.service << 'EOF'
[Unit]
Description=Vérification précoce du verrouillage
DefaultDependencies=no
Before=sysinit.target
After=local-fs.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/lockdown-check.sh
TimeoutSec=0

[Install]
WantedBy=sysinit.target
EOF

# 2. Service avant login
cat > /etc/systemd/system/lockdown-check.service << 'EOF'
[Unit]
Description=Vérification du verrouillage
DefaultDependencies=no
Before=display-manager.service getty@.service

[Service]
Type=oneshot
ExecStart=/usr/local/bin/lockdown-check.sh
TimeoutSec=0

[Install]
WantedBy=multi-user.target
EOF

# 3. Créer une entrée systemd-boot de verrouillage
# Trouver le répertoire des entrées systemd-boot
BOOT_ENTRIES_DIR=""
for possible_dir in "$EFI_PARTITION/loader/entries" "$EFI_PARTITION/boot/loader/entries" "/boot/loader/entries"; do
    if [ -d "$possible_dir" ]; then
        BOOT_ENTRIES_DIR="$possible_dir"
        break
    fi
done

if [ -n "$BOOT_ENTRIES_DIR" ]; then
    echo "Répertoire des entrées systemd-boot trouvé: $BOOT_ENTRIES_DIR"
    
    # Créer une entrée de boot de verrouillage
    cat > "$BOOT_ENTRIES_DIR/00-lockdown.conf" << EOF
title   Système Verrouillé
linux   /vmlinuz-linux
initrd  /intel-ucode.img
initrd  /initramfs-linux.img
options root=LABEL=root ro lockdown_active
EOF
    
    # Créer un fichier de verrouillage pour systemd-boot
    echo "$END_TIME" > "$EFI_PARTITION/lockdown_active"
    
    # Modifier temporairement la configuration du loader pour pointer vers l'entrée de verrouillage
    LOADER_CONF="$EFI_PARTITION/loader/loader.conf"
    if [ ! -f "$LOADER_CONF" ]; then
        LOADER_CONF="$EFI_PARTITION/boot/loader/loader.conf"
    fi
    
    if [ -f "$LOADER_CONF" ]; then
        cp "$LOADER_CONF" "$LOADER_CONF.backup"
        # Modifier le fichier pour forcer le boot sur l'entrée de verrouillage
        sed -i 's/^default.*/default 00-lockdown/' "$LOADER_CONF"
        sed -i 's/^timeout.*/timeout 1/' "$LOADER_CONF"
    fi
else
    echo "Attention: Répertoire des entrées systemd-boot non trouvé"
fi

# Créer le déclencheur de démarrage du verrouillage
cat > /usr/local/bin/lockdown-trigger.sh << EOF
#!/bin/bash

# Attendre le délai spécifié
sleep $DELAY_SECONDS

# Activer le verrouillage systemd-boot si disponible
if [ -n "$BOOT_ENTRIES_DIR" ] && [ -f "$LOADER_CONF" ]; then
    cp "$LOADER_CONF.backup" "$LOADER_CONF"
    sed -i 's/^default.*/default 00-lockdown/' "$LOADER_CONF"
    sed -i 's/^timeout.*/timeout 1/' "$LOADER_CONF"
fi

# Exécuter la vérification
/usr/local/bin/lockdown-check.sh
EOF
chmod +x /usr/local/bin/lockdown-trigger.sh

# Activer tous les services
systemctl daemon-reload
systemctl enable lockdown-check-early.service
systemctl enable lockdown-check.service

# Démarrer le déclencheur en arrière-plan
nohup /usr/local/bin/lockdown-trigger.sh >/dev/null 2>&1 &

# Créer une tâche cron pour l'arrêt programmé comme backup
if [ "$DELAY_SECONDS" -gt 60 ]; then
    SHUTDOWN_TIME=$(date -d "@$START_TIME" '+%H:%M')
    SHUTDOWN_DATE=$(date -d "@$START_TIME" '+%d/%m/%Y')
    echo "Programmation de l'arrêt à $SHUTDOWN_TIME le $SHUTDOWN_DATE"
    (crontab -l 2>/dev/null; echo "$(date -d "@$START_TIME" '+%M %H %d %m *') /sbin/poweroff -f # LOCKDOWN") | crontab -
fi

# VERROUILLAGE SUPPLÉMENTAIRE: Ajouter une règle udev pour éteindre le système
cat > /etc/udev/rules.d/99-lockdown.rules << EOF
ACTION=="add", SUBSYSTEM=="module", RUN+="/usr/local/bin/lockdown-check.sh"
EOF

# Modifier le fichier /etc/fstab pour monter le système de fichiers en lecture seule
cp /etc/fstab /etc/fstab.backup
sed -i '/[[:space:]]\/[[:space:]]/s/rw/ro/' /etc/fstab

# Programmer la restauration du système après la période
cat > /usr/local/bin/restore-system.sh << EOF
#!/bin/bash
# Ce script se déclenchera après la période de verrouillage
sleep $((LOCK_DURATION_SECONDS + DELAY_SECONDS + 300))  # Ajouter 5 minutes pour être sûr

# Restaurer fstab
cp /etc/fstab.backup /etc/fstab

# Nettoyer les fichiers de verrouillage
rm -f "$EFI_PARTITION/lockdown_active"
rm -f /etc/udev/rules.d/99-lockdown.rules
rm -f /etc/lockdown/schedule

# Restaurer systemd-boot si configuré
if [ -f "$LOADER_CONF.backup" ]; then
    cp "$LOADER_CONF.backup" "$LOADER_CONF"
    rm -f "$LOADER_CONF.backup"
fi

# Supprimer l'entrée de verrouillage
if [ -f "$BOOT_ENTRIES_DIR/00-lockdown.conf" ]; then
    rm -f "$BOOT_ENTRIES_DIR/00-lockdown.conf"
fi

# Nettoyer le crontab
crontab -l | grep -v "LOCKDOWN" | crontab -

# Reconstruire l'initramfs pour retirer le hook
sed -i 's/lockdown //g' /etc/mkinitcpio.conf
mkinitcpio -P

echo "Système restauré après la période de verrouillage"
EOF
chmod +x /usr/local/bin/restore-system.sh
nohup /usr/local/bin/restore-system.sh >/dev/null 2>&1 &

# Mettre à jour systemd-boot
echo "Mise à jour de systemd-boot..."
bootctl update

# Afficher un récapitulatif
echo "Verrouillage renforcé programmé avec succès pour Arch Linux (systemd-boot) :"
echo "- Début : $(date -d "@$START_TIME" '+%H:%M:%S le %d/%m/%Y') (dans environ $(echo "scale=2; $DELAY_HOURS" | bc) heures)"
echo "- Fin   : $(date -d "@$END_TIME" '+%H:%M:%S le %d/%m/%Y') (durée de $(echo "scale=2; $LOCK_HOURS" | bc) heures)"
echo "L'ordinateur s'éteindra automatiquement au début de la période."
echo "IMPORTANT: Plusieurs mécanismes de protection ont été mis en place pour empêcher complètement le démarrage."
echo "Partition EFI utilisée: $EFI_PARTITION"