M.2. Écriture de scripts

Écrivez un script pour réaliser chacune des tâches suivantes.

Facile

Liste des répertoires à partir du répertoire personnel de l'utilisateur

Listez les répertoires et les sous rèpertoires à partir du répertoire personnel de l'utilisateur et sauvegardez le résultat dans un fichier. Compressez le fichier, demandez à l'utilisateur d'insérer une disquette et d'appuyer sur ENTER. Enfin, sauvegardez le fichier sur la disquette.

Script auto-reproductible

Écrivez un script qui se sauvegarde lui-même, c'est-à-dire qu'il se copie dans un fichier nommé backup.sh.

Astuce : utilisez la commande cat et les paramètres de position appropriés.

Conversion de boucles for en boucle while et en boucles until

Convertissez les boucles for de l'Exemple 10.1, « Des boucles for simples » en boucles while. Indice : stockez les données dans un tableau et parcourez les éléments du tableau.

Après avoir effectué ce « gros lifting », convertissez maintenant les boucles de l'exemple en boucles until.

Modification de l'espacement des lignes d'un fichier texte

Écrivez un script qui lit chaque ligne d'un fichier cible puis écrit la ligne sur stdout suivie d'une ligne vide. Ceci a pour effet de doubler l'espacement des lignes du fichier.

Incluez tout le code nécessaire pour vérifier que le script obtient l'argument nécessaire en ligne de commande (un nom de fichier), et que le fichier spécifié existe.

Quand le script s'exécute correctement, modifiez-le pour tripler l'espacement des lignes du fichier cible.

Enfin, écrivez un script pour supprimer toutes les lignes vides du fichier cible.

Liste inverse

Écrivez un script qui s'affiche lui-même sur stdout mais à l'envers.

Décompression automatique de fichiers

À partir d'une liste de noms de fichiers donnée en entrée, cherchez sur chaque fichier cible le type de compression utilisé en analysant la sortie de la commande file. Puis, appellez automatiquement la commande de décompression appropriée (gunzip, bunzip2, unzip, uncompress ou autre). Si un fichier cible n'est pas compressé, affichez un message d'erreur mais ne faites aucune autre action sur ce fichier particulier.

Identifiant unique

Générez un identifiant hexadécimal à six chiffres « unique » pour votre ordinateur. N'utilisez pas la commande défectueuse hostid. Indice : md5sum /etc/passwd, puis sélectionnez les six premiers chiffres de la sortie.

Sauvegarde

Archivez dans une « archive tar » (fichier *.tar.gz) tous les fichiers de votre répertoire personnel (/home/votre-nom) qui ont été modifiés dans les dernières 24 heures. Indice : utilisez find.

Vérifier si un processus est toujours en cours d'exécution

Avec un identifiant de processus (PID) comme argument, ce script vérifiera, à un interval spécifié par l'utilisateur, si le processus donné est toujours en cours d'exécution. Vous pouvez utiliser les commandes ps et sleep.

Premiers

Afficher (sur stdout) tous les nombres premiers entre 60000 et 63000. La sortie doit être joliment formatée en colonnes (indice : utilisez printf).

Numéros de loterie

Un type de loterie implique de choisir cinq numéros différents entre 1 et 50. Écrivez un script générant cinq numéros pseudo-aléatoires dans cet intervalle sans doublons. Le script donnera la possibilité d'afficher les nombres sur stdout ou de les sauvegarder dans un fichier avec la date et l'heure où cet ensemble de nombres a été généré.

Intermédiaire

Entier ou chaîne

Écrivez une fonction de script déterminant si un argument passé est un entier ou une chaîne. La fonction renverra TRUE (0) s'il s'agit d'un entier et FALSE (1) s'il s'agit d'une chaîne.

Astuce : que renvoie l'expression suivante quand $1 n'est pas un entier ?

expr $1 + 0

Gestion de l'espace disque

Listez, un par un, tous les fichiers faisant plus de 100 Ko dans l'arborescence du répertoire /home/utilisateur. Donnez à l'utilisateur la possibilité de supprimer ou de compresser le fichier, puis continuez en affichant le suivant. Écrivez un journal avec le nom de tous les fichiers supprimés et l'heure de leur suppression.

Supprimer les comptes inactifs

Les comptes inactifs sur un réseau font perdre de l'espace disque et pourraient devenir un risque de sécurité. Écrivez un script d'administration (appelé par root ou le démon cron) vérifiant et supprimant les comptes utilisateurs qui n'ont pas été utilisés pendant les 90 derniers jours.

Forcer les quotas disque

Écrivez un script pour un système multi-utilisateurs vérifiant l'utilisation du disque par les utilisateurs. Si un utilisateur dépasse la limite fixée (100 Mo par exemple) dans leur répertoire personnel (/home/utilisateur), alors le script lui enverra automatiquement un message d'avertissement par mail.

Le script utilisera les commandes du et mail. Comme option, il permettra de configurer et de forcer les quotas en utilisant les commandes quota et setquota.

Informations sur les utilisateurs connectés

Pour tous les utilisateurs connectés, affichez leur noms réels et l'heure et la date de leur dernière connexion.

Astuce : utilisez who, lastlog et analysez /etc/passwd.

Suppression sécurisée

Écrivez, en tant que script, une commande de suppression « sécurisée », srm.sh. Les fichiers dont les noms sont passés en argument sur la ligne de commande de ce script ne sont pas supprimés mais compressés s'ils ne le sont pas déjà (utilisez file pour le vérifier), puis déplacés dans un répertoire /home/utilisateur/poubelle. Lors de son appel, le script vérifie s'il existe des fichiers ayant plus de 48 heures dans ce répertoire « poubelle » et les supprime.

Faire la monnaie

Quel est le moyen le plus efficace de faire la monnaie sur 1,68 euros en utilisant seulement les pièces en circulation courante (jusqu'à 50 centimes) ? Ce sont trois pièces de 50 centimes, une de 10, une de 5 et trois de un.

À partir d'une entrée arbitraire en ligne de commande en euros et centimes ($*.??), calculez la monnaie en utilisant le plus petit nombre de pièces. Si la monnaie de votre pays n'est pas l'euro, vous pouvez utiliser votre monnaie locale à la place. Le script devra analyser l'entrée en ligne de commande, puis la modifier en multiple de la plus petite unité monétaire (centime ou autre). Indice : jetez un oeil sur l'Exemple 23.8, « Convertir des nombres en chiffres romains ».

Equations quadratiques

Résolvez une équation « quadratique » de la forme Ax^2 + Bx + C = 0. Créez un script qui prend comme arguments les coefficients A, B et C, et renvoie les solutions avec jusqu'à quatre chiffres après la virgule.

Indice : envoyez les coefficients via un tube à bc en utilisant la formule bien connue x = ( -B +/- sqrt( B^2 - 4AC ) ) / 2A.

Somme des nombres correspondants

Trouvez la somme de tous les nombres de cinq chiffres (dans l'intervalle 10000-99999) contenant exactement deux des chiffres de l'ensemble suivant : { 4, 5, 6 }. Ils peuvent se répéter à l'intérieur du même nombre et, si c'est le cas, ils sont comptés une fois à chaque occurence.

Quelques exemples de nombres correspondants : 42057, 74638 et 89515.

Nombres porte-bonheur

Un "nombre porte-bonheur" est un de ces nombres dont les chiffres, pris individuellement, additionnés valent 7. Par exemple, 62431 est un "nombre porte-bonheur" (6 + 2 + 4 + 3 + 1 = 16, 1 + 6 = 7). Trouvez tous les "nombres porte-bonheur" entre 1000 et 10000.

Classer par ordre alphabétique une chaîne de caractères

Classez par ordre alphabétique (suivant l'ordre ASCII) une chaîne de caractères arbitraire lue sur la ligne de commande.

Analyse

Analysez /etc/passwd et affichez son contenu sous la forme d'un joli tableau, facile à lire.

Tracer les connexions

Analyser /var/log/messages pour produire un fichier joliment formaté des connexions des utilisateurs avec l'heure de connexion. Le script peut devoir se lancer en tant que root (conseil : cherchez la chaîne « LOGIN »).

Mise en forme de l'affichage d'un fichier de données

Certaines bases de données et tableurs utilisent des fichiers de sauvegarde avec des valeurs séparées par des virgules (CSV). D'autres applications ont souvent besoin d'analyser ces fichiers.

À partir d'un fichier de données au format CSV, de la forme:

Jones,Bill,235 S. Williams St.,Denver,CO,80221,(303) 244-7989
Smith,Tom,404 Polk Ave.,Los Angeles,CA,90003,(213) 879-5612
...

Reformatez les données et affichez-les sur stdout avec des colonnes disposant d'un titre et de même largeur.

Justification

À partir d'une entrée texte au format ASCII provenant soit de stdin soit d'un fichier, justifiez à droite chaque ligne suivant une longueur de ligne spécifiée par l'utilisateur en ajustant l'espacement entre les mots et envoyez la sortie sur stdout.

Liste de diffusion

En utilisant la commande mail, écrivez un script gérant une liste de diffusion simple. Le script envoie automatiquement par courrier électronique la lettre d'informations mensuelle de la compagnie, lue à partir d'un fichier texte spécifié aux adresses de la liste de diffusion que le script lit à partir d'un autre fichier spécifié.

Générer des mots de passe

Générez des mots de passe de huit caractères pseudo-aléatoires en utilisant les caractères contenus dans les intervalles [0-9], [A-Z], [a-z]. Chaque mot de passe doit contenir au moins deux chiffres.

Surveiller un utilisateur

Vous suspectez un utilisateur particulier sur le réseau d'abuser de ces droits et certainement de tenter de corrompre le système. Écrivez un script qui surveille et trace automatiquement son activité de la semaine et supprime les entrées qui ont plus de sept jours.

Vous pouvez utiliser last, lastlog et lastcomm pour vous aider dans la surveillance du suspect.

Vérifier les liens cassés

En utilisant lynx avec l'option -traversal, écrivez un script qui vérifie les liens cassés d'un site web.

Difficile

Tester des mots de passe

Écrire un script pour vérifier et valider les mots de passe. Le but est de marquer les candidats « faibles » ou facilement devinables.

Un mot de passe en test sera en entrée du script via un paramètre de la ligne de commande. Pour être considéré comme acceptable, un mot de passe doit satisfaire les qualifications minimums suivantes :

  • Longueur minimum de huit caractères

  • Contenir au moins un caractère numérique

  • Contenir au moins un caractère non alphabétique, numérique et figurant : @, #, $, %, &, *, +, -, =

Optionnel :

  • Faire une vérification de type dictionnaire sur chaque séquence d'au moins quatre caractères consécutifs du mot de passe en test. Ceci éliminera les mots de passe contenant des « mots » disponibles dans un dictionnaire standard.

  • Autoriser le script à vérifier tous les mots de passe du système. Ils pourraient ou non résider dans /etc/passwd.

Cet exercice a pour but de tester la maîtrise des expressions rationnelles.

Référence croisée

Écrire un script qui génère une référence croisée (concordance) sur un fichier cible. La sortie sera un listing de toutes les occurences de mots dans le fichier cible avec les numéros de ligne où ils apparaissent. Habituellement, les constructions de liste liée seraient utilisées dans un tel cas. Du coup, vous avez intérêt à utiliser des tableaux pour cet exercice. Exemple 15.11, « Analyse de fréquence d'apparition des mots » n'est probablement pas un bon début.

Racine carrée

Écrire un script qui calcule les racines carrées de nombres en utilisant la méthode de Newton.

L'algorithme pour cela, exprimé en pseudo-code Bash, est le suivant :

#  Méthode d'Isaac Newton pour une extraction rapide
#+ des racines carrées.

tentative = $argument
#  $argument est le nombre dont on veut trouver la racine carrée.
#  $tentative est la tentative calculée -- ou une solution triviale --
#+ de la racine carrée.
#  Notre première tentative de racine carrée est l'argument lui-même.

ancienne_tentative = 0
# $ancienne_tentative est l'ancien $tentative.

tolerance = .000001
# La tolérance acceptée pour notre calcul.

nb_boucles = 0
# Gardons trace du nombre de fois passé dans la boucle.
# Certains arguments demanderont plus d'itérations que d'autres.


while [ ABS( $tentative $ancienne_tentative ) -gt $tolerance ]
#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Corrigez la syntaxe.

#      "ABS" est une fonction à virgule flottante pour trouver la valeur absolue
#+      de la différence entre les deux termes.
#             Donc, tant que la différence entre la solution actuelle et ancienne
#+            ne dépasse pas la tolérance, on continue.

do
   ancienne_tentative = $tentative  # Met $ancienne_tentative avec la valeur de $tentative.

#  =======================================================
   tentative = ( $ancienne_tentative + ( $argument / $ancienne_tentative ) ) / 2.0
#        = 1/2 ( ($ancienne_tentative **2 + $argument) / $ancienne_tentative )
#  équivalent à :
#        = 1/2 ( $ancienne_tentative + $argument / $ancienne_tentative )
#  c'est-à-dire une moyenne de la solution tentée et la proportion d'une déviation
#+ de l'argument
#+ (donc division par deux de l'erreur).
#  Ceci converge sur une solution précise
#+ avec étonnament peu d'itérations de boucle...
#+ pour arguments > $tolerance, bien sûr.
#  =======================================================

   (( nb_boucles++ ))     # Mise à jour du compteur de boucle.
done

C'est une recette assez simple et dont la conversion en Bash semble au premier regard être assez facile. Cela étant dit, le problème est que Bash n'a pas de support natif pour les nombres à virgules flottantes. Donc, le rédacteur du script aura besoin d'utiliser bc ou peut-être awk pour convertir les nombres et faire les calculs. Cela peut devenir un gros bazar...

Journal des accès aux fichiers

Tracez tous les accès aux fichiers dans /etc sur une journée. Ce journal devra inclure le nom du fichier, le nom de l'utilisateur et l'heure d'accès. Il doit aussi être indiqué si le fichier est modifié. Écrivez cette information en enregistrements bien mis en forme dans un fichier journal.

Traces sur les processus

Écrivez un script pour tracer de façon continue tous les processus en cours d'exécution et pour garder trace de tous les processus fils que chaque parent lance. Si un processus lance plus de cinq fils, alors le script envoie un mail à l'administrateur système (ou root) avec toutes les informations intéressantes, ceci incluant l'heure, le PID du père, les PID des enfants, etc. Le script ajoute un rapport dans un journal toutes les dix minutes.

Suppression des commentaires

Supprimez tous les commentaires d'un script shell dont le nom est spécifié en ligne de commande. Notez que la « ligne #! » ne doit pas subir le même traitement.

Suppression des balises HTML

Supprimez toutes les balises HTML d'un fichier, puis reformatez-le en lignes de 60 à 75 caractères de longueur. Réajustez les espacements de paragraphes et de blocs de façon appropriée, et convertissez les tables HTML en leur équivalent texte approximatif.

Conversion XML

Convertissez un fichier XML à la fois en HTML et en texte.

Chasse aux spammeurs

Écrivez un script qui analyse un courrier électronique spam en faisant des recherches DNS à partir de l'adresse IP spécifiée dans les en-têtes pour identifier les hôtes relais ainsi que le fournisseur d'accès internet (FAI) d'origine. Le script renverra le message de spam non modifié aux FAI responsables. Bien sûr, il sera nécessaire de filtrer les adresses IP de votre propre FAI si vous ne voulez pas vous plaindre de vous-même.

Si nécessaire, utilisez les commandes d'analyse réseau appropriées.

Pour quelques idées, voir l'Exemple 15.39, « Analyser le domaine d'un courrier indésirable » et l'Exemple A.30, « Identification d'un spammer ».

En option : écrire un script qui recherche dans une liste de mails et supprime le pourriel suivant des filtres spécifiés.

Créer des pages man

Écrire un script automatisant le processus d'écriture de pages man.

Avec un fichier texte contenant l'information à formater en une page man, le script lira le fichier puis les commandes groff appropriées pour sortir les pages man sur stdout. Le fichier texte contient des blocs d'information sous des en-têtes standards pour en-têtes de pages man, c'est-à-dire « NAME », « SYNOPSIS », « DESCRIPTION, », etc.

See Exemple 15.27, « manview : Visualisation de pages man formatées  ».

Code Morse

Convertissez un fichier texte en code Morse. Chaque caractère du fichier texte sera représenté par le code Morse correspondant, un ensemble de points et de tirets bas, séparé par une espace blanche du suivant. Par exemple :

Appelle le script "morse.sh" avec "script" en argument.


$ sh morse.sh script

... _._. ._. .. .__. _
s   c    r   i   p   t
Dump Hexa

Faites une sortie hexadécimale d'un fichier binaire donné en argument. La sortie devra être en colonnes, le premier champ indiquant l'adresse, chacun des huit champs suivants un nombre hexa de quatre octets, et le dernier champ l'équivalent ASCII des huit champs précédents.

La suite évidente à tout ceci est d'étendre la sortie hexadécimal à un désassembleur. En utilisant une table de recherche ou une autre stuce, convertir les valeurs hexadécimales des codes op du 80x86.

Emulation d'un registre à décalage

En s'inspirant de l'Exemple 26.14, « Émuler une pile », écrivez un script qui émule un registre à décalage de 64 bits par un tableau. Implémentez des fonctions pour charger le registre, décaler à gauche, décaler à droite et faire une rotation. Enfin, écrivez une fonction qui interprète le contenu du registre comme huit caractères ASCII sur 8 bits.

Déterminant

Résolvez un déterminant 4 x 4.

Mots cachés

Écrivez un générateur de puzzle de « recherche de mots », un script qui cache dix mots d'entrée dans une matrice de 10 x 10 lettres choisies au hasard. Les mots peuvent être cachés en horizontal, en vertical et en diagonale.

Optionnel : écrivez un script qui résout des puzzles de mots. Pour ne pas rendre ceci trop complexe, le script trouvera seulement les mots horizontaux et verticaux (astuce : traitez chaque ligne et colonne comme une chaîne et recherchez les sous-chaînes).

Anagramme

Faites un anagramme des quatre lettres d'entrée. Par exemple, les anagrammes de word sont : do or rod row word. Vous pouvez utiliser /usr/share/dict/linux.words comme liste de référence.

Suite de mots

Une « suite de mots » est une séquence de mots, chacun différant du précédent d'une seule lettre.

Par exemple, pour faire « suivre » vase à mark :

mark --> park --> part --> past --> vast --> vase
         ^           ^       ^      ^           ^

Écrivez un script résolvant des puzzles de type « suite de mots ». Étant donné un mot de départ et un mot de fin, le script donnera toutes les étapes intermédiaires de la « suite ». Notez que tous les mots de la séquence doivent être des mots existants dans le dictionnaire.

Index 'brouillard'

L'« index brouillard » d'un passage de texte permet d'estimer sa difficulté de lecture, par un nombre correspondant grossièrement à un niveau d'école. Par exemple, un passage d'index 12 devrait être compréhensible par toute personne ayant plus de 12 ans d'école.

La version 'Gunning' de cet index utilise l'algorithme suivant.

  1. Choisissez une section de texte d'au moins 100 mots de longueur.

  2. Comptez le nombre de phrases (une portion d'une phrase tronquée par les limites de la section de texte compte pour un).

  3. Trouvez le nombre moyen de mots par phrase.

    MOY_MOT_PHRASE = TOTAL_MOTS / PHRASES

  4. Comptez le nombre de mots « difficiles » dans le segment -- ceux contenant au moins trois syllabes. Divisez cette quantité par le nombre total de mots pour obtenir la proportion de mots difficiles.

    PRO_MOTS_DIFFIC = MOTS_LONGS / TOTAL_MOTS

  5. L'index 'Gunning' est la somme des deux quantités ci-dessus, multiplié par 0,4, arrondie à l'entier le plus proche.

    G_FOG_INDEX = int ( 0.4 * ( MOY_MOT_PHRASE + PRO_MOTS_DIFFIC ) )

L'étape 4 est de loin la partie la plus difficile de cet exercice. Il existe différents algorithmes pour estimer le nombre de syllabes dans un mot. Un moyen empirique consiste à considérer le nombre de lettres dans un mot et le mélange voyelles - consonnes.

Une stricte interprétation de l'index 'Gunning' ne compte pas les mots composés et les noms propres comme des mots « difficiles », mais cela compliquerait considérablement le script.

Calculer PI en utilisant l'aiguille de Buffon

Le mathématicien français du 18è siècle Buffon a conçu une expérimentation nouvelle. Lâchez de manière répétée une aiguille de longueur « n » sur un sol en bois composé de planches longues et étroites. Les trous séparant les planches de largeur égale sont à une distance fixe « d » les uns des autres. Gardez une trace du nombre de lâchés et du nombre de fois où l'aiguille fait une intersection avec un trou sur le sol. Le ratio de ces deux nombres se trouve être un multiple fractionnel de PI.

Dans l'esprit de l'Exemple 15.47, « Calculer PI », écrivez un script qui lance une simulation de Monte Carlo de l'aiguille de Buffon. Pour simplifier le problème, initialisez la longueur de l'aiguille à la distance entre les trous, n = d.

Indice : il existe en fait deux variables critiques, la distance du centre de l'aiguille au trou le plus proche et l'angle formé par l'aiguille et le trou. Vous pouvez utiliser bc pour réaliser les calculs.

Cryptage Playfair

Implémentez le cryptage Playfair (Wheatstone) dans un script.

Le cryptage Playfair crypte le texte par substitution de chaque « diagramme » de deux lettres (groupe). Traditionnellement, on utiliserait un carré de cinq lettres sur cinq composant un alphabet pour le cryptage et le décriptage.

   C O D E S
   A B F G H
   I K L M N
   P Q R T U
   V W X Y Z

Chaque lettre de l'alphabet apparaît une fois. Le I représente aussi le J.
Le mot clé choisi arbitrairement, "CODES" vient en premier, ensuite le
reste de l'alphabet, de gauche à droite, en évitant les lettres déjà utilisées.

Pour crypter, séparez le message texte en groupes de deux lettres. Si un groupe
a deux lettres identiques, supprimez la seconde et formez un nouveau groupe.
Si il reste une seule lettre à la fin, insérez le caractère "null", typiquement
un "X".

THIS IS A TOP SECRET MESSAGE

TH IS IS AT OP SE CR ET ME SA GE

Pour chaque groupe, il existe trois possibilités.
-------------------------------------------------
1) Les deux lettres sont sur la même ligne du carré
   Pour chaque lettre, substituez celle immédiatement à droite sur la ligne. Si
   nécessaire, retournez au début de la ligne.
ou

2) Les deux lettres sont dans la même colonne du carré
   Pour chaque lettre, substituez celle immédiatement en dessous sur cette colonne.
   Si nécessaire, retournez en haut de la colonne.

ou

3) Les deux lettres sont aux coins d'un rectangle à l'intérieur du carré.
   Pour chaque lettre, substituez celle à l'autre coin du rectangle se trouvant
   sur la même ligne.


Le groupe "TH" fait partie du cas #3.
G H
M N
T U           (Rectangle avec "T" et "H" aux coins)

T --> U
H --> G


Le groupe "SE" fait partie du cas #1.
C O D E S     (Ligne contenant "S" et "E")

S --> C  (on retourne au début de la ligne)
E --> S

=========================================================================

Pour décrypter un texte, inversez la procédure ci-dessus pour #1 et #2
(déplacez-vous dans la direction opposée pour la substitution). Pour le cas #3,
prenez juste les deux coins restants du rectangle.


Le travail classique d'Helen Fouche Gaines, ELEMENTARY CRYPTANALYSIS (1939),
donne les étapes détaillées sur le cryptage Playfair et ses méthodes de
résolution.

Ce script aura trois sections principales

  1. Génération du « carré de clé » basé sur un mot-clé saisi par l'utilisateur.

  2. Cryptage d'un message « texte ».

  3. Décryptage du texte crypté.

Ce script utilisera de façon poussée les tableaux et les fonctions.

--

Merci de ne pas envoyer à l'auteur vos solutions pour ces exercices. Il existe de bien meilleures façons de l'impressionner avec votre intelligence comme, par exemple, l'envoi de corrections de bogues et des suggestions pour améliorer ce livre.