Écrivez un script pour réaliser chacune des tâches suivantes.
Facile
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.
É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.
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.
É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.
Écrivez un script qui s'affiche lui-même sur stdout mais à l'envers.
À 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.
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.
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.
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.
Afficher (sur stdout) tous les nombres premiers entre 60000 et 63000. La sortie doit être joliment formatée en colonnes (indice : utilisez printf).
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
É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
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.
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.
É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.
Pour tous les utilisateurs connectés, affichez leur noms réels et l'heure et la date de leur dernière connexion.
É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.
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 ».
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.
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.
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.
Classez par ordre alphabétique (suivant l'ordre ASCII) une chaîne de caractères arbitraire lue sur la ligne de commande.
Analysez /etc/passwd et affichez son contenu sous la forme d'un joli tableau, facile à lire.
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 »).
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.
À 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.
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é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.
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.
En utilisant lynx avec l'option -traversal, écrivez un script qui vérifie les liens cassés d'un site web.
Difficile
É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.
É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.
É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 devrait ê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...
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.
É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 écrit un rapport dans un journal toutes les dix minutes.
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.
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.
Convertissez un fichier XML à la fois en HTML et en texte.
É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.38, « Analyser le domaine d'un courrier indésirable » et l'Exemple A.29, « 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.
É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 ».
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
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.
En s'inspirant de l'Exemple 26.13, « É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.
Résolvez un déterminant 4 x 4.
É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).
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.
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.
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.
Choisissez une section de texte d'au moins 100 mots de longueur.
Comptez le nombre de phrases (une portion d'une phrase tronquée par les limites de la section de texte compte pour un).
Trouvez le nombre moyen de mots par phrase.
MOY_MOT_PHRASE = TOTAL_MOTS / PHRASES
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
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.
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.46, « 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.
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
Génération du « carré de clé » basé sur un mot-clé saisi par l'utilisateur.
Cryptage d'un message « texte ».
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.