Site perso d'un administrateur d'infrastructures sécurisées

Catégorie : Automatiser des tâches à l’aide de scripts

Créer un utilisateur dans Active Directory depuis un fichier CSV avec PowerShell

Voici un script Powershell qui permet d’ajouter dynamiquement des utilisateurs dans une OU « Utilisateurs » d’un annuaire active Directory.

Le fichier contenant les utilisateurs se trouve dans « Documents », et ressemble à ceci :

FirstName;LastName;Username;UserPrincipalName;OUPath
Alexandre;TEST;atest;atest@deploys.local;OU=Utilisateurs,DC=DEPLOYS,DC=LOCAL
Jean;DUPOND;jdupond;jdupond@deploys.local;OU=Utilisateurs,DC=DEPLOYS,DC=LOCAL

Et le script (appelé « CreateUser.ps1 ») :

# Import du module Active Directory pour pouvoir utiliser les cmdlets spécialisées
Import-Module ActiveDirectory

# Définition d'un mot de passe sécurisé qui sera utilisé pour tous les nouveaux utilisateurs
$password = ConvertTo-SecureString "Motdepassetemporaire123" -AsPlainText -Force

# Spécification du chemin vers le fichier CSV contenant les informations des utilisateurs
$CSVFile = "C:\Users\Administrateur\Documents\users.csv"
# Importation des données du fichier CSV en utilisant un point-virgule comme délimiteur
$CSVData = Import-Csv -Path $CSVFile -Delimiter ";" -Encoding UTF8

# Affichage des données importées pour vérification par l'utilisateur du script
Write-Output "Vérification du fichier CSV :"
$CSVData

# Boucle pour traiter chaque ligne (chaque utilisateur) du fichier CSV
Foreach ($User in $CSVData) {
    # Attribution des données CSV aux variables pour un usage facile dans le script
    $prenom = $User.FirstName
    $nom = $User.LastName
    $login = $User.Username
    $compte = $User.UserPrincipalName
    $OUPath = $User.OUPath

    # Vérification de l'existence de l'utilisateur dans Active Directory en utilisant son SamAccountName
    if (Get-ADUser -Filter "SamAccountName -eq '$login'") {
        # Si l'utilisateur existe déjà, un avertissement est généré
        Write-Warning "L'utilisateur $login est déjà présent dans l'annuaire"
    }
    else {
        # Si l'utilisateur n'existe pas, il est créé avec les informations fournies
        New-ADUser  -Name "$nom $prenom" `
                    -GivenName $prenom `
                    -Surname $nom `
                    -SamAccountName $login `
                    -UserPrincipalName $compte `
                    -Path $OUPath `
                    -AccountPassword $password `
                    -ChangePasswordAtLogon $true `
                    -Enabled $true
        # Un message de confirmation est affiché après la création de chaque utilisateur
        Write-Output "Utilisateur ajouté à l'AD : $login"
    }
}

Quelques points à noter :

  • Le mot de passe par défaut est défini en clair dans le script et converti en une chaîne sécurisée, ce qui n’est pas une pratique recommandée en termes de sécurité. Il serait préférable de demander à l’utilisateur d’entrer le mot de passe lors de l’exécution du script ou d’utiliser une méthode plus sécurisée pour gérer les mots de passe.
  • La cmdlet Import-Csv est utilisée pour lire les données d’un fichier CSV où les champs sont séparés par des points-virgules (;), ce qui est courant dans les systèmes où la virgule n’est pas utilisée comme séparateur de liste standard (par exemple, dans certains paramétrages régionaux européens).
  • La boucle foreach parcourt chaque ligne du fichier CSV et tente de créer un nouvel utilisateur avec les données fournies.
  • La cmdlet Get-ADUser avec le filtre -Filter est utilisée pour vérifier si un utilisateur avec le SamAccountName spécifié existe déjà dans AD.
  • Si l’utilisateur n’existe pas, la cmdlet New-ADUser est utilisée pour créer l’utilisateur avec les paramètres spécifiés.
  • L’option -ChangePasswordAtLogon est définie sur $true, ce qui oblige l’utilisateur à changer son mot de passe lors de sa première connexion.
  • L’attribut -Enabled est défini sur $true, ce qui signifie que le compte sera activé immédiatement après sa création.
  • Dans PowerShell, le caractère backtick ` est utilisé comme caractère d’échappement, y compris pour indiquer que la ligne de commande continue sur la ligne suivante. Cela est souvent utilisé pour améliorer la lisibilité des scripts en permettant de séparer des commandes longues sur plusieurs lignes.

Ressources utiles :

https://www.it-connect.fr/chapitres/creer-des-utilisateurs-dans-lad-a-partir-dun-csv/

https://www.alitajran.com/import-ad-users-from-csv-powershell

Un coquillage

Bonnes pratiques à appliquer pour écrire des scripts Shell

Modularisation avec des Fonctions :

Pour des scripts plus lisibles et maintenables, utilisez des fonctions pour segmenter votre code.

Exemple :

greeting() { echo "Bonjour, $1" } greeting "Alice"

Documenter Votre Code :

  • Documentez vos fonctions en expliquant leur but et les arguments nécessaires.
  • Exemple :
# Cette fonction affiche un message de bienvenue # $1 - Le nom de la personne greeting() { echo "Bonjour, $1" }

Utilisation de Shift :

  • Utilisez shift pour gérer les arguments de manière plus flexible.
  • Exemple :
process_file() { 
local input_file="$1"; shift 
local output_file="$1"; shift 
}

Déclaration des Variables :

Déclarez les variables en précisant leur type si nécessaire.

Exemple : declare -i count=0 pour un entier.

Cotation des Variables :

Citez vos variables pour éviter des problèmes avec des espaces ou des caractères spéciaux.

Exemple :

echo "$variable"

Usage des Tableaux :

  • Utilisez des tableaux pour stocker des collections d’éléments.
  • Exemple : arr=(item1 item2 item3)

Utilisation de $@ :

  • Préférez $@ à $* pour obtenir les arguments comme une liste séparée.
  • Exemple :
for arg in "$@"; do echo "$arg" done

Nom des Variables :

  • Utilisez des majuscules uniquement pour les variables d’environnement, et des minuscules pour les autres.

Préférence pour les Opérations Intégrées :

  • Utilisez les fonctionnalités intégrées du shell au lieu d’invoquer des programmes externes.
  • Exemple : Utilisez ${string//substring/replacement} au lieu de sed.

Optimisation des Pipes :

  • Réduisez l’usage des pipes en évitant des commandes inutiles.
  • Exemple : Utilisez awk '/pattern/{print $1}' file au lieu de grep pattern file | awk '{print $1}'.

Globbing et Valeurs Nulles :

  • Utilisez le globbing pour générer des listes de fichiers, et utilisez -print0 avec find pour gérer des noms de fichiers complexes.
  • Exemple :
find . -type f -print0 | xargs -0 rm -f

Substitution de Commandes :

  • Préférez $(command) à `command` pour une meilleure lisibilité.
  • Exemple : echo "Nous sommes le $(date)"

Substitution de Processus et Fichiers Temporaires :

  • Utilisez la substitution de processus < (command) pour éviter les fichiers temporaires.
  • Exemple :
diff <(command1) <(command2)

Usage de [[ et (( pour les Conditions :

  • Utilisez [[ ... ]] pour les tests et (( ... )) pour les comparaisons arithmétiques.
  • Exemple :
if (( number > 10 )); then echo "Le nombre est supérieur à 10." fi

Vérification des Commandes :

  • Utilisez la commande directement dans la condition de l’instruction if.
  • Exemple :bash
if grep -q "pattern" file; then echo "Pattern trouvé." fi

Utilisation de set -e :

  • Placez set -e en haut de votre script pour quitter dès qu’une instruction échoue.
  • Exemple :
set -e command1 command2 # Le script s'arrête ici si command1 échoue

Vérification des Dépendances : Assurez-vous que toutes les commandes externes nécessaires sont disponibles avant de procéder.

command -v awk >/dev/null 2>&1 || { echo "awk est requis mais n'est pas installé. Abandon."; exit 1; }

Utilisation de trap pour le Nettoyage : Utilisez la commande trap pour nettoyer les ressources avant de quitter.

trap 'rm -f "$tempfile"' EXIT tempfile=$(mktemp)

Utilisation de getopts pour Gérer les Options : Utilisez getopts pour gérer les options et les arguments de votre script de manière standard.

while getopts "hvf:" opt; do case $opt in h) echo "Usage: $0 [-h] [-v] [-f file]"; exit ;; v) verbose=true ;; f) file=$OPTARG ;; *) echo "Option invalide: -$OPTARG" >&2; exit 1 ;; esac done

Utilisation de readonly et declare -r pour les Constantes : Déclarez les constantes avec readonly ou declare -r.

readonly PI=3.14159

Vérification des Codes de Retour : Vérifiez les codes de retour des commandes importantes.

command || { echo "command a échoué"; exit 1; }

Indentation et Style Consistant : Adoptez un style d’indentation consistant pour améliorer la lisibilité.

Utilisation de Fonctions pour les Blocs Logiques : Encapsulez des blocs logiques dans des fonctions pour améliorer la modularité et la lisibilité.

Évitez l’Usage de eval : La commande eval peut être dangereuse. Évitez son utilisation ou assurez-vous de bien comprendre ses implications.

Utilisation de set -u : Utilisez set -u pour quitter le script si des variables non définies sont utilisées.

set -u echo "$undefined_variable" # Ceci déclenchera une erreur

Utilisation de Commentaires Informatifs : Commentez votre code de manière informative sans être redondant.

Nommage des Variables et des Fonctions : Utilisez des noms descriptifs pour vos variables et fonctions pour améliorer la compréhension du code.

Utilisation de set -o pipefail : Utilisez set -o pipefail pour attraper les erreurs dans les pipelines.

set -o pipefail command1 | command2 | command3

Vérification des Performances : Si le script est destiné à traiter de grands ensembles de données, prenez en compte les performances. Utilisez des outils comme time pour mesurer le temps d’exécution.

Ces bonnes pratiques rendront vos scripts shell plus robustes, lisibles, et faciles à maintenir !

Web Shell et sécurité

Les menaces Web Shell sont en ascension, utilisées par des cybercriminels pour infiltrer des serveurs en exploitant des failles dans les applications web ou les configurations réseau.

Un Web Shell est un script malveillant déposé sur un serveur web permettant un contrôle à distance. Il peut être écrit dans divers langages comme PHP, ASP, Python, ou Unix.

Un accès réussi offre à l’attaquant la possibilité de télécharger, supprimer, charger ou exécuter des fichiers sur le serveur, d’où l’importance de la gestion sécurisée des fichiers et répertoires sous Bash.

Quelques mesures de sécurité à prendre en considération :

  1. Mises à Jour Constantes :
    • Assurer la mise à jour régulière ou automatique du système et des applications pour éliminer les vulnérabilités connues.
    • Exemple : Utiliser des systèmes de gestion de paquets comme apt pour Ubuntu ou yum pour CentOS pour automatiser les mises à jour.
  2. Principe de Moindre Privilège :
    • Appliquer des droits d’accès restrictifs sur le serveur web, surtout dans le répertoire racine, réduisant ainsi les chances d’une escalade de privilèges par un attaquant.
    • Exemple : N’autoriser que l’utilisateur root ou l’administrateur à créer ou modifier des fichiers dans des répertoires sensibles.
  3. Zone Démilitarisée (DMZ) :
    • Configurer une DMZ entre le serveur web et le réseau interne pour limiter les interactions et avoir un suivi du trafic pouvant révéler des activités suspectes.
    • Exemple : Utilisation de pare-feux et de routeurs pour isoler le serveur web du reste du réseau.
  4. Configuration Sécurisée du Serveur Web :
    • Désactiver les services inutiles, bloquer les ports non utilisés, empêcher l’accès au panneau de gestion depuis l’extérieur, et utiliser des identifiants robustes.
    • Exemple : Utilisation de scanners de vulnérabilité comme Nessus pour identifier et rectifier les configurations faibles.
  5. Validation Stricte des Entrées :
    • Valider toutes les entrées utilisateur pour éviter les injections de code malveillant.
    • Exemple : Utilisation de fonctions de validation ou d’outils comme OWASP ZAP pour tester les entrées.
  6. Analyses de Vulnérabilité :
    • Effectuer des scans réguliers pour détecter des failles potentielles.
    • Exemple : Utilisation de scanners comme OpenVAS pour identifier des vulnérabilités dans le système et les applications.
  7. Utilisation de Pare-feu d’Application Web ou Proxy Inverse :
    • Déployer des solutions de sécurité additionnelles pour améliorer la protection contre les attaques.
    • Exemple : Utilisation de mod_security comme pare-feu d’application web.

Exemples de Risques et Solutions :

  1. Injection de Code :
    • Risque : Un utilisateur mal intentionné peut injecter des commandes dangereuses si les entrées ne sont pas correctement validées.
    • Solution : Utiliser des fonctions d’échappement de caractères et de validation des entrées.
  2. Scripts Shell en CGI :
    • Risque : Les scripts Shell utilisés pour les CGI peuvent être exploités si l’entrée utilisateur n’est pas correctement gérée.
    • Solution : Préférer l’utilisation de langages plus sécurisés comme PHP ou Python, ou des moteurs de recherche tiers sécurisés comme le moteur de recherche personnalisé Google.
  3. Stockage de Mots de Passe dans les Scripts :
    • Risque : Un mot de passe codé en dur dans un script peut être découvert par un attaquant.
    • Solution : Utiliser des mécanismes sécurisés de stockage des mots de passe, comme les coffres-forts de mots de passe.

Conseil Final : La sécurité doit être une priorité dès le début du développement, en adoptant des pratiques codage sécurisé et en étant conscient des risques associés à certaines actions, comme le stockage de mots de passe en clair ou l’exécution de code basée sur des entrées utilisateur non validées.

Création d’un script de sauvegarde avec Bash

Imaginez que nous voulions sauvegarder le contenu d’un répertoire documents dans un autre répertoire backup.

Voici le contenu de sauvegarde.sh

#!/bin/bash

# Ce script est conçu pour sauvegarder le contenu du répertoire 'documents' dans le répertoire 'backup'

SOURCE_DIRECTORY="/chemin/absolu/vers/documents"
BACKUP_DIRECTORY="/chemin/absolu/vers/backup"

# Vérifier que le répertoire source existe
if [ ! -d "$SOURCE_DIRECTORY" ]; then
    echo "Erreur : Le répertoire source $SOURCE_DIRECTORY n'existe pas."
    exit 1
fi

# Si le répertoire de sauvegarde n'existe pas, le créer
if [ ! -d "$BACKUP_DIRECTORY" ]; then
    mkdir "$BACKUP_DIRECTORY"
fi

# Copier les fichiers
cp -R "$SOURCE_DIRECTORY"/* "$BACKUP_DIRECTORY"

# Vérifier si la copie a réussi
if [ $? -eq 0 ]; then
    echo "Sauvegarde effectuée avec succès."
else
    echo "Erreur lors de la sauvegarde."
    exit 1
fi

Utilisation :

  1. Assurez-vous que les chemins pour SOURCE_DIRECTORY et BACKUP_DIRECTORY sont correctement définis.
  2. Rendez le script exécutable avec la commande chmod +x sauvegarde.sh.
  3. Exécutez le script avec ./sauvegarde.sh.

Automatisation avec Cron :

Si vous voulez exécuter ce script automatiquement tous les jours à 23h00 :

  1. Ouvrez votre crontab avec crontab -e.
  2. Ajoutez la ligne suivante :

00 23 * * * /chemin/absolu/vers/sauvegarde.sh

Avec cela, votre script de sauvegarde s’exécutera automatiquement chaque jour à 23h00. Assurez-vous de remplacer /chemin/absolu/vers/sauvegarde.sh par le chemin réel vers votre script.

Commandes usuelles du Shell Bash

Structure et Composants d’une Commande Bash

1. Le nom de la commande : L’essence de toute instruction à l’ordinateur réside dans le nom de la commande. Dans le monde de Bash, chaque nom de commande est associé à une action précise. Lorsque Bash reconnaît une commande, il s’efforce de l’exécuter. Si la commande est inconnue ou incorrecte, Bash répondra par un message d’erreur. Au-delà des commandes simples, Bash permet également de définir des fonctions. Ces fonctions peuvent regrouper plusieurs commandes, facilitant ainsi leur exécution en une seule invocation de la fonction.

2. Les arguments de la commande : Les arguments donnent du contexte à nos commandes. En ajoutant des arguments, on peut par exemple préciser un nom de fichier ou un emplacement. Prenons l’exemple d’une commande destinée à copier un fichier : elle nécessitera au moins deux arguments – le nom du fichier source et la destination du fichier. Les arguments fournissent les détails nécessaires pour permettre à la commande de fonctionner comme prévu. Lorsqu’il y a plusieurs arguments, ils sont généralement séparés par des espaces.

3. Les options de la commande : Ajoutées à une commande pour modifier ou préciser son comportement, les options sont généralement introduites par un tiret simple -, suivi du nom complet de l’option ou de son abréviation. Selon la commande, diverses options peuvent être disponibles, offrant une flexibilité accrue à l’utilisateur.

Liste des commandes usuelles

su : Pour se connecter en tant qu’utilisateur root.

Exemple :

su

Note : Sur certains systèmes, sudo -i est utilisé pour obtenir un shell root.

cd : Change de répertoire.

  • Exemple :
cd /usr/bin/

Option courante : cd - pour retourner au précédent répertoire.

ls : Affiche le contenu du répertoire.

  • Exemple :
ls /home/

Options courantes :

ls -l pour un affichage détaillé.

ls -a pour afficher tous les fichiers, y compris les cachés.

touch : Crée un fichier.

  • Exemple :
touch nouveau_fichier.txt

rm : Supprime des fichiers ou des répertoires.

  • Exemple :
rm fichier_a_supprimer.txt

Options courantes :

rm -r pour supprimer un répertoire et son contenu.

rm -f pour forcer la suppression sans demande de confirmation.

mkdir : Crée un répertoire.

  • Exemple :
mkdir nouveau_repertoire

Option courante :

mkdir -p pour créer des répertoires parents si nécessaires.

more : Affiche le contenu d’un fichier.

  • Exemple :
more fichier.txt

grep : Recherche une chaîne dans un fichier.

  • Exemple :
grep "erreur" journal.log

Options courantes :

grep -i pour une recherche insensible à la casse.

grep -r pour une recherche récursive dans les répertoires.

ps : Affiche les processus en cours.

  • Exemple :
ps aux

Options courantes :

ps -e pour afficher tous les processus du système.

ps -u utilisateur pour afficher les processus d’un utilisateur spécifique.

kill : Envoie un signal à un processus, généralement pour l’arrêter.

  • Exemple :
kill 12345 (où 12345 est l'ID du processus)

Options courantes :

  • kill -9 pour forcer l’arrêt d’un processus.
  • killall nom_du_processus pour tuer tous les processus portant ce nom

Quelques fonctions de base de Bash

Guide pour vérifier et utiliser Bash

Vérification de la présence de Bash : Pour déterminer si Bash est installé sur votre machine Ubuntu, ouvrez le terminal et entrez la commande :


ps

Si ‘Bash’ figure dans la liste, cela signifie qu’il est installé et prêt à être utilisé.

Exécution d’un script avec Bash : Si vous avez un script préparé, nommé « script.sh », voici comment l’exécuter :

  1. Naviguez jusqu’au répertoire contenant votre script avec la commande cd.
  2. Exécutez le script en entrant :

bash script.sh

ou :


./script.sh

Si le script ne s’exécute pas, il est probable qu’il ne soit pas défini comme exécutable. Pour le rendre exécutable, utilisez :


chmod +x script.sh

Fonctions courantes dans Bash :

  1. Comparaison de chaînes ou de noms de fichiers :
    • Utilisation : if [ "$string1" = "$string2" ]; then ...
    • Exemple : Pour vérifier si deux chaînes sont identiques :
string1="Hello" string2="World" 
if [ "$string1" != "$string2" ]; then echo "Les deux chaînes sont différentes."fi

Recherche d’une séquence spécifique dans un fichier :

  • grep
    • Utilisation : grep "motif" fichier
    • Exemple : Pour trouver toutes les occurrences du mot « erreur » dans le fichier « journal.log » :bash

grep "erreur" journal.log

Remplacement de chaînes :

  • sed
    • Utilisation : sed 's/motif/remplacement/' fichier
    • Exemple : Pour remplacer toutes les occurrences de « ancien » par « nouveau » dans le fichier « texte.txt » :bash

sed 's/ancien/nouveau/g' texte.txt

Affichage de données à l’écran :

  • echo
    • Utilisation : echo "Votre texte ici"
    • Exemple : Pour afficher le message « Bonjour le monde ! » à l’écran :bash

echo "Bonjour le monde !"

Création de variables :

  • Utilisation : variable=valeur
  • Exemple : Pour assigner la valeur 3 à une variable nommée « compteur » :bash

compteur=3 echo $compteur

Qu’est-ce que Bash concrètement ?

Découverte de Bash : Une immersion dans le monde de la ligne de commande

Si le monde digital était une symphonie, Bash serait un de ses instruments les plus mélodieux. Permettez-moi de vous l’expliquer :

Bash, c’est quoi exactement ?

Au cœur de Bash, vous trouverez deux entités inséparables. La première, c’est ce qu’on appelle un shell de ligne de commande. C’est comme un pont entre vous et votre ordinateur, où au lieu d’utiliser une souris pour cliquer sur des icônes, vous tapez des commandes. Mais Bash ne s’arrête pas là. C’est également un langage de script. Imaginez avoir une série de commandes que vous exécutez souvent. Plutôt que de les taper à chaque fois, avec Bash, vous pouvez les regrouper dans un « script » et le lancer quand bon vous semble.

Éclaircissement sur le concept de Shell

Un shell, c’est comme un interprète. Imaginez-vous dans un pays étranger sans connaître la langue. Vous avez besoin d’un traducteur pour comprendre et vous faire comprendre. De la même manière, un shell traduit vos commandes tapées au clavier pour les faire comprendre à votre ordinateur. Alors oui, vous pourriez utiliser une interface graphique (avec ses jolies icônes), mais le shell a ses propres atouts :

  • Rapidité: Il est souvent plus vif qu’une interface graphique.
  • Automatisation: Répétez les tâches sans effort.
  • Flexibilité: Interagissez avec diverses ressources, y compris le cloud.
  • Traçabilité: Conservez une trace écrite de toutes vos commandes, idéal pour un audit.

Pourquoi se tourner vers Bash ?

Bash n’est pas simplement un outil, c’est une boîte à outils. Que voulez-vous faire ?

  • Identifier et supprimer des doublons sur un disque ?
  • Renommer des fichiers en masse ?
  • Automatiser le déplacement de fichiers ?
  • Programmer l’allumage ou l’extinction de votre système ?
  • Créer une base de données à partir de simples fichiers texte ?

Tout cela (et bien plus) est possible avec Bash.

Les joyaux de Bash :

  • Diversité : Une panoplie de commandes pour presque toute action imaginable.
  • Universalité : Présent sur presque toutes les plateformes.
  • Polyvalence : Parfait pour une utilisation interactive ou pour automatiser des tâches.
  • Richesse : Accès à une pléthore de librairies.
  • Mobilité : Utilisez-le à distance avec SSH.
  • Multitâche : Exécutez deux tâches en simultané grâce au mécanisme de pipe « | ». C’est ce qu’on appelle élégamment un « co-processus ».

Petits apartés terminologiques :

  • Librairie : Pensez-y comme à une étagère remplie de livres prêts à être utilisés, sauf que ces « livres » sont en réalité des routines informatiques prêtes à l’emploi.
  • SSH (Secure Shell) : C’est comme un tunnel sécurisé. Si Bash était une voiture, SSH serait la voie rapide et protégée qui vous permet de la conduire en toute sécurité sur le réseau.

Fièrement propulsé par WordPress & Thème par Anders Norén