Mémo de lignes de commandes

Nicolas Mesnier

Mis à jour le 21/11/2023.

Dans le monde GNU/Linux et plus généralement de la famille UNIX, les plus grandes difficultés éprouvées par les débutants sont de trouver les commandes adaptées à leurs besoins. Or, si toutes les fonctions standards sont bien documentées avec les pages man, il est difficile pour l’apprenti geeck de savoir quelles commandes existent et sont adaptées à son besoin du moment.

Ce mémo regroupe ${quelques} commandes élémentaires et astuces pour augmenter votre productivité en utilisant une console ; ${quelques} pouvant évidemment être calculé et affiché dans un terminal avec :

quelques = $(cat tips.md | grep '^[ ]*@\.' | wc -l)
echo ${quelques}

Toutes les commandes apparaissant dans ce document ont été empruntées à d’autres mais, par maladresse, je n’ai pas fait l’effort d’en retenir les auteur⋅e⋅s.

Guide de survie

Interpréteur de commandes (shell), terminal

L’interpréteur de commandes (ou shell) est le logiciel le plus important car il réalise l’interface entre l’utilisateur, le système d’exploitation et les logiciels. Ce programme tourne dans une fenêtre (émulateur de terminal) ou sur une console en mode texte (terminal). Son rôle est de lire une entrée (clavier, fichier, etc), de l’interpréter et, si besoin, de lancer une commande. La syntaxe du shell forme un langage de programmation de haut niveau (un langage de script directement interprété). Si cette syntaxe n’est pas respectée, le shell renvoie une erreur.

Il existe plusieurs interpréteurs de commandes UNIX. Les principaux sont :

Le shell est utilisé le plus souvent de manière interactive, pour passer des commandes au système. Il est associé au terminal sur lequel vous êtes connecté (ou à une fenêtre sur ce terminal). Pour signifier que le shell est prêt à recevoir ces commandes, il affiche un prompt. Ce prompt peut contenir un nombre variable d’informations selon la configuration, par exemple :

moi@monPC:~/répertoire/de/travail$

Ce processus prend comme données ce que vous tapez au clavier et génère comme sorties des affichages sur l’écran du terminal ou des actions sur des fichiers. De façon générique sous UNIX, le clavier est appelé entrée standard (stdin) et l’écran la sortie standard (stdout). En cas d’erreur, un message s’affiche sur l’écran, alors devenu erreur standard (stderr).

Dans la suite, on note :

Exécuter une commande

Une commande est une liste de chaînes de caractères séparées par des espaces de la forme :

command [<chaine1>...<chaineP>]

Certaines commandes n’ont pas de paramètre, d’autres ne s’utilisent qu’avec un nombre précis de paramètres. On différencie deux types de paramètres :

Pour exécuter une commande, il suffit de taper

command ... <CR>

<CR> désigne l’appui sur la touche carriage return (entrée). L’interpréteur de commandes exécute alors la commande ou crée le ou les processus correspondant à la commande. Le code de sortie de la commande est stocké dans la variable ?

$ echo $?

s’il est égal à 0 la commande a réussie, 1+ sinon.

Raccourcis Bash

  1. Voir le nom du shell utilisé

    $ echo $SHELL
  2. Effacer l’écran du terminal

    $ clear
  3. Rafraîchir l’affichage

    <C-l>
  4. Relancer/ré-initialiser le terminal

    $ reset
  5. Bloquer l’affichage du terminal

    <C-s>

    le débloquer avec

    <C-q>
  6. Interrompre la commande en cours

    <C-c>
  7. Ouvrir un éditeur de texte

    $ <C+x><C-e>
  8. Afficher les utilisateurs

    $ ~<TAB><TAB>
  9. Afficher les (nombreuses) variables systèmes

    $ $<TAB><TAB>

On donne ci-après les principaux raccourcis en Bash.

<tab> compéter le mot courant (complétion)
<tab><tab> afficher les propositions de complétion du mot courant
<C-p> afficher les commandes précédentes
<C-n> afficher les commandes suivantes
Déplacements
<C-a> aller au début de la ligne
<C-e> aller à la fin de la ligne
<M-b> aller au début du mot
<M-f> aller à la fin au mot suivant
Coupes (yank)
<C-k> couper la ligne après le curseur
<C-u> couper la ligne avant le curseur
<M-d> couper la fin du mot depuis le curseur
<C-w> couper le début du mot jusqu’au curseur
<C-d> couper le caractère sous le curseur
<C-h> couper le caractère avant le curseur
Collages
<C-y> coller
<C-y><M-y> coller en remontant l’historique du kill ring
Édition
<M-u> mettre en majuscule le mot depuis le curseur
<M-L> mettre en minuscule le mot depuis le curseur
Historique
SHIFT+P.UP parcourir les pages précédentes
SHIFT+P.DOWN parcourir les pages suivantes

Rechercher une commande, documentation

Les commandes usuelles qui permettent de survivre sur une console GNU/Linux sont répertoriées sur les pages Coreutils et commandes shell (debian). On donne un abrégé dans la section GNU coreutils.

  1. Rechercher une commande ayant un rapport avec keyword

    $ apropos keyword
    $ man -k keyword
  2. Afficher l’aide d’une commande

    $ man command

    taper q pour quitter.
    Afficher l’aide de la commande man

    $ man man
  3. Afficher une ligne d’explication d’une commande

    $ whatis command
  4. Afficher un descriptif long d’une commande

    $ info command
  5. Afficher l’emplacement d’un fichier de commande

    $ whereis command

    ou

    $ which command

    ou

    $ type -p command

Historique des commandes

L’historique des commandes passées est stocké dans le fichier défini dans $HISTFILE, pointant souvent vers ~/.bash_history. Sa longueur est définie dans la variable $HISTSIZE, généralement entre 500 et 1000 lignes.

  1. Voir l’historique des commandes

    $ history

    En entrant !num , on relance la commande affichée ligne num.

  2. Exécuter de nouveau la commande précédente

    $ !!

    à prononcer bang bang !

  3. Exécuter une commande avec les arguments de la précédente

    $ command !*
  4. Ne pas ajouter une commande à l’historique

    $  command

    en la préfixant avec une espace.

Exécutions séquentielles ou conditionnelles

  1. Exécuter de façon séquentielle deux commandes

    $ command1 ; command2
  2. Exécuter de façon parallèle deux commandes

    $ command1 & command2
  3. Exécuter la command2 que si la command1 a réussie

    $ command1 && command2

    Le résultat est un succès si les deux commandes ont réussies (&& est le ET logique).

  4. Exécuter la command2 que si la command1 a échoué

    $ command1 || command2

    Le résultat est un succès si une des deux commandes a réussie (|| est le OU logique).

Redirections

Fichiers spéciaux

/dev/stdin

désigne l’entrée standard

/dev/stdout

désigne la sortie standard

/dev/stderr

désigne la sortie d’erreur standard

L’entrée (stdin), la sortie (stdout) et l’erreur standard (stderr) ont respectivement les descripteurs de fichiers 0, 1 et 2.

/dev/tty

désigne le terminal auquel vous êtes connecté

/dev/null

Ce fichier se comporte comme un « trou noir » en absorbant toute redirection sans être modifié.

/dev/zero

Ce fichier renvoie des octets nuls à l’infini.

/dev/urandom

Ce fichier renvoie des octets aléatoires à l’infini.

Plus de détails sur stackexchange.

  1. Afficher le nom de son terminal

    $ tty
  2. Rediriger la sortie standard de command vers le le fichier outfile

    $ command > outfile

    ou

    $ command 1> outfile

    Si le fichier outfile existe déjà, son contenu est écrasé.

  3. Rediriger la sortie standard de command vers le fichier outfile s’il n’existe pas

    $ set -o noclobber
    $ command > outfile
    $ set +o noclobber
  4. Rediriger la sortie standard de la command vers le fichier outfile

    $ command >> outfile

    Si outfile existe déjà, le contenu est ajouté à la fin du fichier.

  5. Rediriger l’entrée standard de la command vers le fichier infile

    $ command < infile

    La commande lit le contenu du fichier infile.

  6. Rediriger l’entrée standard de command2 vers la sortie standard de la command1

    $ command2 < (command1)
  7. Rediriger la sortie d’erreur standard de command vers le fichier outfile (l’écraser)

    $ command 2> outfile

    Si on ne veut pas lire outfile, autant le remplacer par /dev/null.

  8. Rediriger l’erreur standard de command au même endroit que la sortie standard

    $ command 2>&1
  9. Rediriger la sortie standard de command au même endroit que la l’erreur standard

    $ command 1>&2

Tubes (pipeline)

Les shell des systèmes d’exploitation de type Unix disposent d’un mécanisme appelé tube (pipeline ou pipe). Ce mécanisme permet de chaîner des processus de sorte que la sortie d’un processus (stdout) alimente directement l’entrée (stdin) du suivant.

  1. Exécuter la command2 avec le résultat de la command1

    $ command1 | command2

    L’exécution peut être simultanée. Cette commande est équivalente à

    $ command2 < (command1)
  2. Scinder les éléments provenant du tube en différentes lignes

    ... | xargs -n 1 echo
  3. Concaténer les lignes provenant du tube en une ligne

    ... | xarg echo
  4. Concaténer 3 lignes provenant du tube en une ligne en séparant les deux premières avec un tiret et les deux dernières avec un slash

    ... | paste -sd"-/" -
  5. Extraire du tube les lignes contenant expression

    ... | grep expresion

    ou celles ne la contenant pas

    ... | grep -v expresion
  6. Lancer une commande de manière répétitive avec chaque élément provenant du pipe comme paramètre

    ... | xargs -n 1 command
  7. Donner un fichier en argument d’une commande

    $ command <<EOF
      ...
      EOF

    avec le here document <<, EOF étant une chaîne permettant d’identifier la fin du fichier, <C-d> sinon.

  8. Donner une chaîne de caractères en argument d’une commande

    $ command <<< string

    avec le here sting <<<. Il faut toujours préférer cette solution à

    $ echo string | command

    car elle utilise un processus de moins.

  9. Écrire dans un fichier et en sortie standard stdout, par exemple pour continuer un long pipe

    $ command | tee outfile | ...
  10. Éditer le résultat d’une commande avec Vim

    $ command | vim -

Expressions rationnelles

Une expression rationnelle est une manière compacte de représenter une chaîne de caractères.

Expression Signification
. Tout caractère (sauf newline)
\ Caractère d’échappement (interprétation littérale du caractère suivant)
^ Début de ligne
$ Fin de ligne
\< Début de mot
\> Fin de mot
\n Fin de ligne
\r Retour chariot
\t Tabulation
Classes de caractères
\c Control
\s, \S Espace, ou pas
\d, \D Nombre, ou pas
\w, \W Mot, ou pas
\x, \O Nombre hexadécimal, octal
POSIX
[:upper:] Une lettre en majuscule
[:lower:] Une lettre en minuscule
[:alpha:] Une lettre
[:alnum:] Une lettre ou un chiffre
[:digit:] Un chiffre
[:xdigit:] Un chiffre hexadécimal
[:punct:] Un caractère de ponctuation
[:blank:] Un espace ou tabulation
[:cntrl:] Un caractère de contrôle
[:word:] Une lettre, un chiffre ou underscore
Groupes, ensembles
(...) Groupe
\n n-ième groupe
[abc] Un des caractères spécifiés
[a-dh] Une lettre de a à d ou h
[0-57] 0, 1, 2, 3, 4, 5 ou 7
[a-d5-8-] a, b, c, d, 5, 6, 7, 8 ou -
[012^] 0, 1, 2 ou ^
[^abc] Un caractère ne figurant pas dans la liste
[^0-9] Tout sauf un chiffre
[^a-zA-Z] Tout sauf une lettre
Quantificateurs
r* Aucune ou plusieurs instances de l’expression r
r+ Au moins une instance de l’expression r
r? Aucune ou une instance de l’expression r
{n} Exactement n fois l’élément précédent
{n,m} Entre n et m fois l’élément précédent
{n,} n fois ou plus l’élément précédent
{,m} m fois au plus l’élément précédent
r1|r2 Instance de l’expression r1 ou r2
Références
&, \0 tout le motif
\n le n-ième groupe (n>=1)
\r couper la ligne en 2 à ce point
\u le caractère suivant en majuscule
\l le caractère suivant en minuscule
  1. Afficher la table des caractères ASCII

    $ man ascii

Navigation

Tout est fichier dans un système GNU/Linux ou UNIX. Un répertoire est un certain type de fichier. Chaque terminal (par exemple /dev/pts/4), chaque disque dur ou partition (par exemple /dev/sdb1) et tous les processus sont tous représentés comme des fichiers.

Répertoires

  1. Afficher le nom du répertoire courant (print working directory)

    $ pwd

    ou

    $ echo $PWD

    ou

    $ echo ~+
  2. Voir les fichiers du répertoire

    $ ls -1

    y compris les fichiers cachés

    $ ls -al

    et ajouter l’option -h pour « humain ».

  3. Voir tous les fichiers .tex du répertoire

    $ ls -1 *.tex

    * remplace toute chaîne de caractères et ? n’en remplace qu’un.

  4. Changer de répertoire

    $ cd directory/

    pour aller dans le répertoire père

    $ cd ..
  5. Changer de répertoire pour le home directory

    $ cd

    ou

    $ cd $HOME
  6. Changer le répertoire courant pour le répertoire précédent

    $ cd -

    ou

    $ cd $OLDPWD
  7. Afficher le nom du répertoire précédent

    $ echo $OLDPWD

    ou

    $ echo ~-
  8. Créer un répertoire et y aller

    $ mkdir directory && cd $_
  9. Se balader dans l’arborescence des répertoires avec une pile, visible avec

    $ dirs

    ajouter un répertoire à la pile et y aller

    $ pushd directory

    supprimer le dernier répertoire de la pile et revenir au précédent

    $ popd
  10. Créer un répertoire et son arborescence

    $ mkdir -p dir/subdir/directory
  11. Copier un répertoire (et son contenu) vers un autre

    $ cp -r directory destination/.

    utiliser l’option -i pour éviter d’écraser involontairement un fichier de même nom s’il existe.

  12. Supprimer un répertoire vide

    $ rmdir directory
  13. Supprimer un répertoire et tout ce qu’il contient

    $ rm -rf directory
  14. Afficher le contenu de l’arborescence des fichiers dans un répertoire

    $ tree directory
  15. Afficher la taille d’un répertoire

    $ du -sh directory

    si directory n’est pas spécifié, du répertoire courant.

  16. Afficher la taille d’un répertoire et de ses sous-répertoires

    $ du -h directory

    ou en se limittant aux répertoires et trier la sortie par taille décroissante

    $ du -hd 1 directory | sort -hr
  17. Supprimer tous les sous-répertoires vide de dir

    $ find dir -type d -empty -delete

Fichiers

  1. Afficher le type d’un fichier

    $ file infile
  2. Obtenir les informations d’un fichier

    $ stat infile
  3. Actualiser la date de dernière modification d’un fichier

    $ touch infile

    Si infile n’existe pas, il est créé.

  4. Copier un fichier

    $ cp infile outfile
  5. Renommer ou déplacer un fichier

    $ mv infile outfile
  6. Renommer des fichiers (Debian)

    $ rename 's/exp1/exp2/' xxxexp1xx

    Attention : cette commande n’existe pas sur toutes les plateformes et n’a pas toujours la même syntaxe (ici Debian). Ce qui fonctionne toujours est :

    $ find . -maxdepth 1 -name "*exp1*" \
      -exec bash -c 'mv $0 ${0/exp1/exp2}' {}  \;
  7. Renommer en fichier en *.old

    $ mv filename{,.old}
  8. Supprimer un fichier

    $ rm infile
  9. Supprimer un fichier au nom incluant des caractères spéciaux ou bizarres, à partir de son inode

    $ ls -i

    qui renvoie 2 colonnes, avec l’inode sur la première et le nom de fichier sur la seconde. Admettons que vous vouliez supprimer celui d’inode 12345

    $ find . -inum 12345 -delete

    ou

    $ find . -inum -exec rm -i {} \;
  10. Créer un lien symbolique

    $ ln -s target_file linked_file
  11. Supprimer un lien symbolique

    $ unlink linked_file

    ou

    $ rm linked_file
  12. Voir le contenu (la cible) d’un lien symbolique

    $ readlink linked_file
  13. Effacer un grand nombre de fichier

    $ mkdir empty && rsync -r –delete empty/ some-dir && rmdir some-dir

Recherches

  1. Rechercher un fichier d’après son nom dans le répertoire dir

    $ find dir -type f -name filename

    Si votre système dispose d’une base de données /var/lib/mlocate/mlocate.db, il est plus rapide de faire la recherche avec

    $ locate filename

    Selon le système, il peut être nécessaire de créer et mettre à jour cette BDD avec

    # updatedb
  2. Rechercher des fichiers que l’on a le droit de lire et ainsi éviter les « Permission non accordée » en rafale en redirigeant la sortie standard d’erreur dans le « trou noir »

    $ find dir -type f -name filename 2> /dev/null
  3. Rechercher les fichiers modifiés il y a 30 jours

    $ find dir -mtime +30 -type f
  4. Rechercher un répertoire d’après son nom

    $ find dir -type d dirname
  5. Rechercher les répertoires dont les fichiers *.tex contiennent l’expression exp

    $ grep -nre exp --include=*.tex | cut -d: -f 1 \
       | uniq | tr "\n" "\0" | xargs -0 dirname | uniq

    la séquence tr "\n" "\0" | xargs -0 permet de tenir compte de noms de répertoire avec des espaces : en effet la commande tr "\n" "\0" remplace le caractère de fin de ligne par null et l’option -0 de xargs indique d’utiliser ce même caractère comme séparateur plutôt qu’une espace.

  6. Rechercher et supprimer un répertoire

    $ find . -type d -name 'dirname' -print0 | xargs -r0 -- rm -r
  7. Rechercher les répertoires vers lesquels pointent les liens de $HOME/bin

    $ find $HOME/bin -type l \
       | xargs readlink | xargs dirname | sort -u

    ou

    $ find $HOME/bin -type l | xargs file | cut -d: -f2 \
       | sed 's/^[ ]*symbolic link to //g' | tr '\n' '\0' \
       | xargs -0 dirname | sort | uniq

Manipulation de fichiers texte

Édition de fichiers textes (avec vim)

vi est un éditeur de texte présent d’office sur la majorité des UNIX. vim (Vi IMproved) est son clone moderne libre GNU/Linux, avec une compatibilité descendante complète. Voir le mémo vim pour en savoir plus.

  1. Ouvrir 2 fichiers cote à cote

    $ vim -O file1 file2

    ou dessus-dessous

    $ vim -o file1 file2
  2. Utiliser vim comme explorateur de fichier

    $ vim .

Avec ces commandes, vous vous retrouvez évidemment dans vim. Si vous avez lancé ces commandes par erreur, tapez !qa pour quitter sans rien modifier.

Visualiser le contenu d’un fichier

  1. Voir le fichier dans le terminal

    $ cat infile

    ou avec un pager ; au choix :

    $ more infile

    ou

    $ less infile
  2. Voir les lignes a à b d’un fichier

    $ sed -n a,bp infile
  3. Voir les a premières lignes d’un fichier

    $ head -n a infile
  4. Voir les b dernières lignes d’un fichier

    $ tail -n b infile
  5. Afficher le contenu d’un fichier en ASCII

    $ od -c infile

    ou en héxadécimal

    $ od -t x1 infile

Encodage

  1. Obtenir les informations d’encodage d’un fichier

    $ file -bi infile
  2. Vérifier si un fichier texte est bien encodé en UTF-8

    $ iconv -f utf8 -t utf8 input.txt >/dev/null || echo "Non UTF-8"
  3. Convertir l’encodage d’un fichier (ASCII vers UTF-8)

    $ iconv -f ascii -t utf8 infile > newfile
  4. Trouver la syntaxe hexadécimale d’un caractère char

    $ printf char | hexdump -v -e '"x" 1/1 "%02X" " "';echo

    puis le remplacer avec sed

    $ sed -i 's/\x??\x??/new_char/g' infile
  5. Afficher un caractère Unicode U+xxxx dans son shell

    $ echo -ne '\uxxxx'       # u (petit) + 4 chiffres hexadécimaux

    ou

    $ echo -ne '\Uxxxxxxxx'   # U (grand) + 8 chiffres hexadécimaux

    ou

    $ python3 -c 'print(u"\uxxx")

    évidemment, il faut que la variable LANG soit correctement paramétrée, du genre LANG=fr_FR.utf8 telle que

    $ echo ${LANG##*.}

    retourne utf8 ou UTF-8.

  6. Changer les fins de lignes MS Windows (^M = <C-v><C-m>) en line feed Unix \n

    $ sed -i 's/^M//g' infile

    ou les fins de ligne Mac OS X \r

    $ sed -i 's/\r/\n/g' infile
  7. Enlever les BOM d’un fichier UTF-8, vu avec file, genre UTF-8 Unicode (with BOM) text:

    $ tail --bytes=+4 infile > outfile

Pour tout débogger les problèmes d’encodage courant, voir le tableau .

Comparaison

  1. Voir les différences entre 2 fichiers textes

    $ diff infile1 infile2

    mais en couleur c’est toujours mieux

    $ diff --color infile1 infile2

    Sans tenir compte des espaces (option -w)

    $ diff --color -w infile1 infile2

    Pour s’affranchir des carriage return de MS windows

    $ diff --color -w --strip-trailing-cr infile1 infile2
  2. Comparer le contenu de 2 fichiers textes cote-à-cote

    $ sdiff infile1 infile2
  3. Éditer le contenu de 2 fichiers textes cote-à-cote avec coloration des différences

    $ vimdiff infile1 infile2

    ou, avec SSH

    $ vimdiff infile scp://user@host/folder/infile2
  4. Voir les différences entre 2 fichiers textes après tri

    $ diff <(sort infile1) <(sort infile2)
  5. Corriger un fichier avec un patch

    $ patch infile1 < infile.patch

    le patch étant généré avec

    $ diff infile1 infile2 > infile.patch
  6. Comparaison de 2 fichiers texte triés

    $ comm infile1 infile2

    renvoie 3 colonnes contenant respectivement les lignes n’appartenant qu’au fichier infile1, celles n’appartenant qu’au fichier infile2 et celles en commun. L’option -13 supprime les colonnes 1 et 3 de l’affichage.

Rechercher et remplacer

  1. Trouver une expression dans un fichier

    $ grep -n 'expression' infile

    affiche la ligne de l’occurrence, avec l’option -i devient insensible à la casse.

  2. Remplacer une expression par une autre dans un fichier

    $ sed -i 's/expression1/expression2/g' infile
  3. Supprimer les lignes vides

    $ sed -i '/^$/d' infile

Découper, assembler

  1. Afficher la 3ème colonne d’un fichier, celles-ci étant délimitées par ;

    $ cut -d; -f3 infile
  2. Découper un fichier texte par blocs de 100 lignes

    $ split -l 100 -d infile

    ici de noms x00, x01, etc.

  3. Découper un fichier texte sur un motif

    $ csplit infile '/\section/' '{*}' -f 'prefix_'
  4. Assembler une collection de fichiers texte de noms x00, x01, etc

    $ cat x* > outfile
  5. Concaténer des fichiers (verticalement)

    $ cat infile1 infile2 ...
  6. Concaténer les colonnes de fichiers (horizontalement)

    $ paste infile1 infile2

Remettre en forme

  1. Limiter la longueur des lignes à 72 caractères

    $ fold -sw 72 infile > outfile

    ou

    $ fmt -s infile > outfile
  2. Remettre en forme un fichier texte en joignant les lignes successives

    $ fmt infile > outfile

Corrections orthographique et grammaticale

  1. Vérifier l’orthographe d’un fichier écrit en français

    $ aspell check --lang=fr infile

    ou

    $ aspell check -l fr infile
  2. Vérifier la grammaire d’un fichier écrit en français avec Grammalecte

    $ python3 chemin-vers/Grammalecte-fr/cli.py -f infile

    ou alors créer un alias dans votre .bashrc

    alias grammalecte="python3 chemin-vers/Grammalecte-fr/cli.py -off apos -f"

    puis taper dans le shell

    $ grammalecte infile

    Heureusement, il existe un plugin pour une bonne intégration dans vim.

Traduction

Avec translate-shell

  1. Traduire un mot, une phrase, une expression

    $ trans fr:en "mot/phrase/expression"

    ou de façon concise

    $ trans -b fr:en "mot/phrase/expression"
  2. Traduire une page web en français

    $ trans :fr <URL>

Exporter le contenu, changer de format

  1. Convertir un fichier texte en PDF

    $ paps input.txt | ps2pdf - output.pdf

    ou

    $ paps input.txt --font="Monospace Regular 10" \
       | ps2pdf -sPAPERSIZE=a4 -dOptimize=true -dEmbedAllFonts=true\
                - output.pdf
  2. Exporter un fichier texte en PDF (HTML, DOCX…)

    $ pandoc infile -o outfile.pdf
  3. Voir un fichier Markdown en rich text dans le terminal

    $ pandoc file.md | w3m -T text/html

Manipulation de PDF

  1. Afficher les informations d’un PDF

    $ pdfinfo file.pdf
  2. Convertir un PDF en fichier texte

    $ pdftotext infile.pdf outfile.txt

Comparaison

  1. Voir les différences entre 2 fichiers PDF

    $ diffpdf infile1.pdf infile2.pdf

    Voir la page de diffPDF ou télécharger ses sources sur GitHub bien qu’il soit dans les dépots.

Recherches

  1. Rechercher le numéro des lignes contenant une expression dans un fichier PDF

    $ pdfgrep -n pattern file.pdf
  2. Rechercher de façon récursive dans le répertoire courant les fichiers PDF dont le nom commence par foo et qui contiennent l’expression pattern

    $ pdfgrep -r --include "foo*.pdf" pattern
  3. Rechercher tous les fichiers PDF contenant l’expression pattern

    $ find . -name "*.pdf" -print0 | xargs -0 pdfgrep pattern

Annotations

Je ne connais pas d’outil en ligne de commandes pour annoter un fichier PDF. J’utilise Okular avec clavier/souris ou Xournal avec une tablette graphique.

Composition

  1. Composer un PDF à partir de plusieurs

    $ pdftk A=file1.pdf B=file2.pdf cat A1-3 B2 A4 output outfile.pdf

    ici les pages 1 à 3 du fichier file1.pdf (alias A), puis la page 2 du fichier file2.pdf (alias B), etc.

  2. Supprimer des pages d’un PDF

    $ pdftk infile.pdf  cat '~7~9~14'  output outfile.pdf

    supprime les pages 7, 9 et 14

  3. Inverser les pages d’un PDF

    $ pdftk infile.pdf cat end-1 output outfile.pdf
  4. Retourner les pages d’un PDF

    $ pdftk infile.pdf  cat 1-endsouth output outfile.pdf

    avec south pour 180°, west pour 270° et east pour 90°

  5. Composer un PDF en deux pages sur une (en 2x1 comme avec lpr -o number-up=2)

    $ pdfjam --nup 2x1 --paper a4paper --landscape --scale 1 \
        --outfile outfile.pdf infile.pdf

    ou

    $ pdfnup infile.pdf
  6. Composer un PDF livret en 2 pages par feuilles

    $ pdfbook --short-edge --paper a4paper \
        --outfile outfile.pdf infile.pdf
  7. Composer un PDF avec 4 pages par feuilles

    $ pdfnup  --nup 2x2 --paper a4paper --landscape \
        --outfile outfile.pdf infile.pdf

Remettre en forme

  1. Convertir un fichier PDF en version « vraiment portable »

    $ gs -dSAFER -dBATCH -dNOPAUSE -sDEVICE=pdfwrite \
         -dCompatibilityLevel=1.4 \
         -dPDFSETTINGS=/printer \
         -sOutputFile=outile.pdf infile.pdf
  2. Supprimer la transparence des images d’un PDF (l’aplatir en bitmap, option de gs)

    $ gs ...
         -dCompatibilityLevel=1.3 \
      ...
  3. Convertir les images d’un PDF en niveaux de gris (options de gs)

    $ gs ...
      -sColorConversionStrategy=Gray -dProcessColorModel=/DeviceGray \
      ...
  4. Re-dimensionner un PDF en A4 (options de gs)

    $ gs ...
      -sPAPERSIZE=a4 -dFIXEDMEDIA -dPDFFitPage \
      ...
  5. Comprimer les images d’un PDF (options de gs)

    $ gs ...
      -dPDFSETTINGS=/printer \
      -dDownsampleColorImages=true -dColorImageResolution=200 \
      ...

    ou, au choix

    -dPDFSETTINGS=/screen (72 dpi)
    -dPDFSETTINGS=/prepress
  6. Sélectionner les pages a à b d’un PDF (options de gs)

    $ gs ...
      -dFirstPage=a -dLastPage=b \
      ...
  7. Incorporer les polices (options de gs)

    $ gs ...
      -dNOPLATFONTS -dSubsetFonts=true -dEmbedAllFonts=true \
      ...
  8. Édition des tags

    $ gs ...
      -dDOPDFMARKS -sOutputFile=outile.pdf infile.pdf tagfile

    ou tagfile est un fichier ASCII de la forme

    [ /Author (you)
      /Title (title) 
      /Subject (subject)
      /Keywords (keword1, keword2)
      /CreationDate (D:20190209145643+01'00')
      /ModDate (D:20190209145643+01'00')
      /Producer (pdfTeX 1.40.17 + GPL Ghostscript 9.20)
      /Creator (LaTeX with teXstyles 0.0.1)
      /DOCINFO pdfmark

    dont les champs doivent être encodés en UTF-16 BE s’ils comportent des accents. Il faudra par exemple remplacer le champ

    (Ingénieur)

    par

    <FEFF0049006E006700E9006E0069006500750072>

    chaîne qui peut être obtenue avec le one-liner

    $ echo "Ingénieur" \
       | iconv -f utf-8 -t utf-16be \
       | echo "<FEFF"$(hexdump -v -e '1/1 "%02X" ') \
       | sed 's/.\{4\}$/>/'

    ou avec la fonction python

    import binascii
    def pdfTag(c):
      # if not ascii, change encoding
      if False in [ord(k)<128 for k in c]:
        return(''.join(['<FEFF',
          str(binascii.hexlify(c.encode('UTF-16BE')))[2:-1].upper(),
          ">"]))
      else: # ascii
        return("("+c+")")

Protéger par mot de passe

  1. Protéger un PDF avec un mot de passe

    $ pdftk infile.pdf output outfile.pdf user_pw PROMPT

    à saisir dans l’invite (PROMPT). Par défaut l’impression du fichier généré n’est pas autorisée. Pour que ce soit le cas :

    $ pdftk infile.pdf output outfile.pdf user_pw PROMPT \
        allow printing

Manipulation d’images

Changer de format

  1. Changer de format une image

    $ convert image.jpg image.png
  2. Supprimer la transparence et la remplacer par du blanc

    $ convert image1.png -background white -alpha remove image2.png
  3. Convertir une image bitmap (PNG, JPEG) en format vectoriel (SVG)

    $ convert infile.png bmp:- | potrace -s - -o outfile.svg
  4. Convertir une image bitmap (PNG, JPEG) en PDF

    $ convert -background white -page a4 -compress Zip -quality 0 \
            infile.png outfile.pdf
  5. Convertir un ensemble d’images en PDF

    $ img2pdf -o oufile.pdf --pagesize a4 images/*.jpg

Redimensionner

  1. Redimensionner une image

    $ convert $image -resize "$largeur"x"$hauteur" $newimagename
  2. Retourner une image

    $ convert $image -rotate 90 $newimagename

GIF & Co.

  1. Faire un GIF avec une collection d’images

    $ convert -delay 20 -loop 0 img_*.gif output.gif
  2. Extraire les images d’un GIF

    $ convert -coalesce infile.gif img_%d.png
  3. Faire un GIF avec les pages d’un PDF

    $ convert -verbose -delay 50 -alpha off -background #FFFFFF \
       -loop 0 -density 300 infile.pdf outfile.gif

Vignettes

  1. Convertir une page de PDF en PNG

    $ convert -trim infile.pdf[0] -quality 100 \
              -flatten -resize x300 outfile.png

Visualisation des fonctions et données

  1. Tracer avec gnuplot

Autres médias

Audio

  1. Convertir un mp3 en wav

    $ mpg123 -w outfile.wav infile.mp3
  2. Écouter la radio, par exemple france culture

    $ cvlc http://direct.franceculture.fr/live/franceculture-midfi.mp3

    (voir ici pour quelques adresses de flux).

Vidéos

  1. Convertir un avi en mov

    $ ffmpeg -i input.avi -acodec libmp3lame -ab 192 output.mov
  2. Découper une vidéo à 24’53 :

    $ ffmpeg -i video.mp4 -acodec copy -vcodec copy \
        -ss 0 -t 00:24:53 video1.mp4
    $ ffmpeg -i video.mp4 -acodec copy -vcodec copy \
        -ss 00:24:53 video2.mp4

Gestion de fichiers

Archiver, compresser

  1. Archiver et compresser un répertoire

    $ tar cz mydir -f mydir.tar.gz
    $ tar cf - mydir | gzip -c mydir.tar.gz

    avec bzip2

    $ tar cj mydir -f mydir.tar.bz2
    $ tar cf - mydir | bzip2 -c > mydir.tar.bz2

    avec zip

    $ tar cf - mydir | zip outfile.zip -
  2. Décompresser et extraire un répertoire

    $ tar xzf mydir.tar.gz
    $ gzip -d -c mydir.tar.gz | tar xf -
    $ gunzip -c mydir.tar.gz | tar xf -

    avec bzip2

    $ tar xjf mydir.tar.bz2
    $ bzip2 -d -c mydir.tar.bz2 | tar xf -
    $ bunzip2 -c mydir.tar.bz2 | tar xf -

    avec zip

    $ tar cf - mydir | gzip outfile.zip -

Archives zip

Attention à l’encodage !

  1. Compresser un répertoire dans une archive zip

    $ zip -r foo.zip foo
    $ zip -r foo foo
  2. Décompresser une archive zip

    $ unzip foo.zip
  3. Voir les fichiers contenus dans une archive zip

    $ zip foo.zip -sf
  4. Ajouter le fichier bar à une archive zip

    $ zip foo.zip bar
    $ zip foo.zip add bar
    $ zip foo.zip -u bar
  5. Mettre à jour le fichier bar d’une archive zip

    $ zip foo.zip -u bar
  6. Supprimer le fichier bar d’une archive zip

    $ zip foo.zip -d bar

Gestion de versions

Voir la section « Comparaison » pour le contenu des fichiers textes.

Avec git & Co.

Synchronisation de répertoires

  1. Synchroniser 2 répertoires (unidirectionnel)

    $ rsync -a --stats --progress --delete $SRC $DST/

    L’option -a précise le mode archive (récursif, liens, permissions) et --delete permet de supprimer les fichiers de la cible qui ne sont pas dans la source.

  2. Synchroniser 2 répertoires par SSH

    $ rsync -azv --delete -e ssh $SRC user@host:$DST/

    L’option -z permet de compresser les fichiers pendant le transfert et -v active le mode verbeux.

  3. Sauvegarde incrémentale

    $ rsync -abz --stats --progress --delete --suffix="_old" \
        --backup-dir=$(basename $SRC)"_$(date +%Y-%m-%d)" $SRC $DST/

    L’option -b ou --backup permet de garder une trace des fichiers de la cible modifiés, ici avec le suffixe _old dans le répertoire précisé par --backup-dir.

Voir ici pour d’autres options de rsync.

  1. Synchronisation biderectionnelle en deux temps

    $ rsync -Pcauv dir1/ dir2/
    $ rsync -Pcauv dir2/ dir1/

    -P affiche la progression partielles, -c compare les sommes de contrôle (checksum) et non les dates ou la taille, -a actove le mode archive (récursif, liens, permissions), -u passe les fichiers plus récents de la cible et -v active le mode verbeux (vu ).

  2. Synchroniser 2 répertoires

    $ unison dir1/ dir2/

    Nécessite l’installation de la même version d’unison sur les deux systèmes.

  3. Vérifier que tous les fichiers d’une carte SD ${SDdir} sont dans sous-répertoire d’un répertoire ${homedir}

    for file in $(ls ${SDdir}); do 
        filename=$(basename ${file})         
        if [ $(find ${homedir} -name "${filename}" | wc -l) -lt 1 ]
        then
            echo "${file} à sauver"
        fi
    done

Sauvegardes

Pour gérer mes sauvegardes, j’utilise l’excellent BorgBackup (aide en ligne)

  1. Initialiser un dépôt vide

    $ mkdir -p /media/$whoami/... \
       && borg init --encryption=repokey $_

    Le système vous demande une phrase de passe (deux fois).

  2. Créer un backup

    $ borg create --info --stats /path/to/repo::backup_name dir_to_backup/

    Pour le nom du backup, pas besoin de faire original. Si la sauvegarde est quotidienne, un $(date +%F) suffit.

  3. Voir les backup existants

    $ borg list /path/to/repo
  4. Supprimer un backup

    $ borg delete /path/to/repo::backup_name
  5. Voir les différences entre 2 backups

    $ borg diff /path/to/repo::backup_name1 backup_name2
  6. Restauration de sauvegarde

    $ borg mount /path/to/repo::backup_name /mount/point

    /mount/point est un point de montage que vous avez créé avec les permissions adéquates (chown you:you /mount/point et chmod 700 /mount/point).
    Explorez puis démonter

    $ umount /mount/point
  7. Suppression automatique des archives anciennes

    $ borg prune -v /path/to/repo \
        --keep-daily=7 \
        --keep-weekly=4 \
        --keep-monthly=6

    permet de garder :

    • une archive par jour les 7 derniers jours,
    • une archive par semaine pour les 4 dernières semaines,
    • une archive par mois pour les 6 derniers mois (-1 pour tous les mois).

Pour « rester propre »

  1. Comparer 2 fichiers bit à bit

    $ cmp file1 file2
  2. Trouver des fichiers en double dans un répertoire

    $ fdupes -r directory > outfile
  3. Trouver les fichiers en double dans un répertoire et les trier par taille décroissante

    $ fdupes -rS directory | sed -e 's/^$/@@MAKE@@INLINE@@/g' | tr '\n' '\0' \
    | sed -e 's/@@MAKE@@INLINE@@\x00/\n/g' | sort -rn | tr '\0' '\n' \
    > outfile
  4. Supprimer les fichiers en double dans un répertoire

    $ fdupes -rd directory

    ou de façon automatique (option N) en ne gardant que le premier (option f)

    $ fdupes -rdfN directory
  5. Supprimer les fichiers en double dans un répertoire ayant le motif pattern

    $ fdupes -r directory -f | grep pattern \
        | tr "\n" "\0" | xargs -0 -n 1 rm -v
  6. Éditer une liste de noms de fichiers puis les supprimer

    $ fdupes -r directory > outfile.list

    enfin supprimer les fichiers en omettant les lignes vides mais en tenant compte des espaces dans les noms de fichier)

    $ cat outfile.list | sed -e '/^$/d' | tr '\n' '\0' | xargs -0 rm -v
  7. Supprimer tous les fichiers en double contenus dans un sous-répertoire dir/sub/ de dir :

    $ fdupes -r dir > outfile
    $ for f in $(ls dir/sub/*.jpg);do \
      test $(grep -c $f outfile) -ge 1 && rm -v $f;\
      done
  8. Trouver les répertoires en double

    $ diff dir1 dir2 | grep "Commmon" | cut -d " " -f3 \
        | uniq | tr "\n" "\0" | xargs -0 basename -a

Communication, Internet

Liens

  1. URL to link

    import re
    text = re.sub('(https?:\/\/[^\s<"]+)', r'<a href="\1">\1</a>', text)
  2. Générer un code QR en PDF

    $ qrencode "URL" -t eps -o - | epstopdf -f -o outfile.pdf

Téléchargement

  1. Télécharger un fichier

    $ wget http://path.to.the/file

    ou

    $ curl http://path.to.the/file
  2. Télécharger un fichier et le renommer

    $ wget http://path.to.the/file -O newname
  3. Reprendre un téléchargement avorté

    $ wget -c http://path.to.the/file
  4. Télécharger un fichier après authentification HTTP

    $ curl -u username:password URL
  5. Télécharger tous les PDF d’un site

    $ wget -e robots=off -r -l1 --no-parent -A.pdf URL
  6. Lister les formats disponibles sur un site de streaming

    $ youtube-dl -F URL
  7. Télécharger une vidéo sur un site de streaming en limitant la bande passante à 150 ko

    $ youtube-dl -r 150K -f <format code> URL

Partage de fichiers (local et temporaire)

  1. Un serveur web qui sert le dossier courant sur le port 8000

    $ python3 -m http.server 8000

FTP

  1. Lister le contenu d’un répertoire FTP

    $ curl ftp://username:password@example.com
  2. Envoyer un fichier par FTP

    $ lftp -u $FTPuser,$FTPpwd ftp://@$FTPserver \
        -e "put outfile ; quit"
  3. Créer un dossier miroir par FTP

    $ lftp -u FTPuser,FTPpwd ftp://@FTPserver \
        -e "mirror -e -R localdir FTPdir ; quit"

Mails

  1. Envoyer un email avec mutt

    $ mutt -s "Subject" address@to.fr -a attached.pdf < body_text_file
  1. Afficher la météo à Paris dans son terminal

    $ curl wttr.in/paris,france

    ou à Lyon en français

    $ curl fr.wttr.in/lyon,france
  2. Faire une recherche sur le web en tapant directement dans le terminal

    $ duckduckgo "ma recherche"

    ou

    $ google "ma recherche"

    après avoir inséré dans votre ~/.bashrc les lignes :

    google() { w3m https://www.google.com/search\?q\="$1" ;}
    duckduckgo() { w3m https://duckduckgo.com/\?q\="$1" ;}

SSH

  1. Se connecter en SSH

    $ ssh user@host
  2. Envoyer un fichier par SSH

    $ scp -O infile user@host:directory/.

    ou en sens inverse

    $ scp -O user@host:directory/infile .

    où l’option -O est nécessaire depuis OpenSSH 8.8 (qui utilise le protocole SFTP par défaut).

  3. Envoyer un dossier par SSH

    $ scp -O -r dir user@host:directory/.
  4. Monter un répertoire à travers une connexion SSH

    $ sshfs user@shost:/path/to/folder /path/to/mount/point

    avec le point de montage

    $ sudo mkdir -p /path/to/mount/point
    $ sudo chown you:you /path/to/mount/point
    $ chmod 700 /path/to/mount/point

    et, une fois fini

    $ fusermount -u mountpoint

    Assurez-vous d’avoir eu accès par SSH avant que l’hôte soit connue.

Workflow

  1. Chronométrer une commande

    $ time command
  2. Faire une pause de 8 seconde

    $ sleep 8

Calculatrice

  1. Calculer (avec bc)

    $ bc -l <<< "1+sqrt(5)"

    où l’option -l charge la bibliothèque maths. Les fonctions élémentaires sont :

    s(x)    sinus
    c(x)    cosinus
    a(x)    arctangente
    l(x)    logarithme naturel
    e(x)    exponentielle
    sqrt(x) racine carrée
    x^y     puissance
    x%y     reste de la division euclidienne

    Pour calculer π\pi:

    $ pi=$(bc -l <<< "scale=10; 4*a(1)")
  2. Calculer (avec octave)

    $ octave -q <<< "[1:3:12]*pi"

    avec une syntaxe à la matlab.

Vie de tous les jours

  1. Afficher la date

    $ date

    ou juste année-mois-jour

    $ date +%F
    $ date +"%Y-%m-%d"
  2. Afficher le calendrier du mois mm de l’année aaaa

    $ cal mm aaaa

    si pas d’argument, celui du mois en cours.

  3. Lancer un chronomètre avec

    $ time cat

    puis taper

    <C-d>

    pour l’arrêter.

Impression

  1. Lister les imprimantes

    $ lpstat -p

    ou en se limitant aux noms

    $ lpstat -a | cut -f1 -d ' '
  2. Soumettre un travail d’impression à l’imprimante printer

    $ lpr -P printer filename
  3. Limiter l’impression à certaines pages

    $ lpr -o page-ranges=1-4,7,9-12 filename
  4. Imprimer un document en format paysage ajusté à un A4

    $ lpr -o landscape -o fit-to-page -o media=A4 filename
  5. Imprimer 4 pages par feuille (2 pages/page et recto-verso)

    $ lpr -o number-up=2 -o sides=two-sided-long-edge filename
  6. Préciser le nombre de copies n à imprimer

    $ lpr -#n filename
  7. Voir la pile d’impression de l’imprimante printer

    $ lpq -P printer
  8. Supprimer le travail d’impression job-id

    $ lprm job-id
  9. Changer l’imprimante destinataire d’un travail job-id

    $ /usr/sbin/lpmove job-id new-printer

Processus programmé

  1. Exécuter une commande à une heure donnée

    $ at HHMM <<< "cmd args"
  2. Lister les PID des commandes programmées

    $ atq
    $ at -l
  3. Voir le contenu d’une commande programmée

    $ at -c PID

Multiplexeur de terminaux

Les multiplexeurs de terminaux permettent d’ouvrir plusieurs terminaux dans une même console, de passer de l’un à l’autre et de les mémoriser pour les récupérer plus tard. Dans le monde GNU/Linux, les deux principaux sont le « vieux » screen et tmux.

screen

  1. Créer une session

    $ screen -S name
  2. Voir les sessions existantes

    $ screen -ls
  3. Se connecter à une session

    $ screen -r name

    ou, si elle n’est pas détachée

    $ screen -x name
  4. Détacher une session

    <C-a> <C-d>
  5. Fermer (tuer) une session (et toutes ses fenêtres)

    <C-a> <C-\>
  6. Créer une nouvelle fenêtre

    <C-a> <C-c>

    puis naviguer vers la précédente

    <C-a> <C-p>

    ou la suivante

    <C-a> <C-n>
  7. Lister les fenêtres disponibles

    <C-a> "
  8. Passer à la fenêtre n

    <C-a> n
  9. Renommer la fenêtre

    <C-a> A

    en changeant le nom pré-affecté en bas à gauche.

  10. Supprimer la fenêtre courante

    <C-a> K
  11. Découper la fenêtre courante horizontalement

    <C-a> S

    ou verticalement

    <C-a> |

    en deux régions, puis y aller

    <C-a> <tab>

    et lancer un shell (fenêtre vide par défaut)

    <C-a> c
  12. Supprimer toutes les régions souf la courante

    <C-a> Q

tmux

Tmux est assez performant sur la gestion de l’affichage avec notamment le découpage de fenêtres en panes.

  1. Ouvrir une nouvelle session tmux

    $ tmux new -s SessionName
  2. Renommer la session

    <C-b> $
  3. Lister les sessions

    $ tmux ls

    ou directement dans une session

    <C-b> s

    puis sélectionner celle voulue.

  4. Naviguer entre les sessions

    <C-b> )     " session suivante
    <C-b> (     " session précédente
  5. Détacher une session

    <C-b> d
  6. Attacher une session

    $ tmux a -t SessionName
    $ tmux at -t SessionName
    $ tmux attach -t SessionName
  7. Tuer une session

    $ tmux kill-session -t SessionName

    ou toutes sauf la session courante

    $ tmux kill-session -a

    ou, depuis la session

    <C-d>
  8. Créer une nouvelle fenêtre

    <C-b> c
  9. Renommer la fenêtre

    <C-b> ,
  10. Afficher la liste des fenêtres disponibles

    <C-b> w
  11. Passer d’une fenêtre à une autre

    <C-b> n        " fenêtre suivante
    <C-b> p        " fenêtre précédente
    <C-b> x        " fenêtre numéro x (numéros affichés en bas)
  12. Fermer la fenêtre courante

    <C-b> &
  13. Scinder le pane verticalement

    <C-b> %

    ou horizontalement

    <C-b> "
  14. Changer l’affichage courant

    <C-b> <space>
  15. Se déplacer de pane en pane

    <C-b> <up>
    <C-b> <down>
    <C-b> <left>
    <C-b> <right>
  16. Basculer d’un pane à l’autre

    <C-b> o

    ou au dernier pane utilisé

    <C-b> ;
  17. Afficher le numéro des panes

    <C-b> q
  18. Se rendre sur le pane x

    <C-b> q x
  19. Zoomer sur le pane courant

    <C-b> z
  20. Redimensionner le pane courant

    <C-b-up>
    <C-b-down>
    <C-b-left>
    <C-b-right>
  21. Déplacer le pane courant à gauche

    <C-b> {

    ou à droite

    <C-b> }
  22. Écrire simultanément dans tous les panes

    <C-b>:setw synchronize-panes on

    puis pour le désactiver

    <C-b>:setw synchronize-panes off
  23. Convertir le pane courant en fenêtre

    <C-b> !
  24. Afficher l’heure dans le pane courant

    <C-b> t
  25. Supprimer le pane courant

    <C-b> x
  26. Activer le mode copie

    <C-b> [

    démarrer une selection

    <space>

    copier la sélection

    <enter>

    quitter le mode copie

    q

    Sélctionner le pane et coller

    <C-b> ]

Outils de sécurité

Générer des mots de passes

  1. Générer un mot de passe de 12 caractères

    $ apg -a 1 -m 12 -n 1

    ou 10 mots de passe de 20 caractères

    $ apg -a 1 -m 20 -n 10
  2. Générer un mot de passe avec une saisie clavier pour maximiser l’entropie

    $ apg -a 1 -m 12 -n 1 -s

Chiffrer/déchiffrer un fichier

  1. Chiffrer un fichier

    $ gpg -c infile
    $ gpg -c --cipher-algo AES256 infile

    Algo de chiffrement symmétriques : AES256, TWOFISH et BLOWFISH

  2. Déchiffrer un fichier

    $ gpg infile.gpg
  3. Éviter le prompt graphique de pinenty

    $ echo "passwd" | gpg --pinentry-mode loopback \
        --passphrase-fd 0 -d infile.gpg

Archiver, compresser et chiffrer un répertoire

  1. Archiver, compresser et chiffrer un répertoire

    $ tar cz mydir | gpg -c > mydir.tar.gz.gpg
  2. Déchiffrer, décompresser et extraire

    $ gpg -d mydir.tar.gz.gpg | tar -xz

Chiffrer/déchiffrer avec une clé

  1. Chiffrer un fichier

    $ gpg -e -r user_id my_file

    ou

    $ gpg -er user_email my_file
  2. Déchiffrer un fichier

    $ gpg my_file.gpg

    ou de façon discrète

    $ gpg -d my_file.gpg

    de façon à pouvoir continuer dans un pipe.

Gestion des clés avec GnuPG

  1. Lister les clés publiques

    $ gpg --list-keys
    $ gpg -k

    et les clés privées

    $ gpg --list-secret-keys
    $ gpg -K
  2. Exporter sa clé publique

    $ gpg --armor --export KeyID > pubK.asc
  3. Publier sa clé publique

    $ gpg --send-keys --keyserver pgp.mit.edu keyID
  4. Exporter sa clé privée

    $ gpg --armor --export-secret-keys KeyID > privK.asc
  5. Importer une clé

    $ gpg --import keyfile.asc
  6. Supprimer une clé publique

    $ gpg --delete-keys pub_keyID

    ou privée

    $ gpg --delete-secret-keys priv_key_ID

    ou les deux

    $ gpg --delete-secret-and-public-key keyID
  7. Changer la passphrase d’une clé

    $ gpg --edit-key keyID

    puis dans le shell de gpg

    gpg> passwd
    gpg> save
  8. Révoquer une clé

    $ gpg --gen-revoke keyID
  9. Changer la date d’expiration d’une clé

    $ gpg --edit-key keyID

    puis dans le shell de gpg

    gpg> list
    gpg> key 0
    gpg> expire
    gpg> key 1
    gpg> expire
    gpg> save

    enfin la publier

    $ gpg --keyserver pgp.mit.edu --send-keys keyID
  10. Relancer l’agent GnuPG

    $ gpg-connect-agent reloadagent /bye

Signer, chiffrer ses emails

  1. Chiffrer une pièce jointe envoyée à recipient@email.com

    $ gpg --armor --encrypt --sign -r recipient@email.com filename
  1. Signer un email

    $ gpg --sign-key email@example.com

Éditer un fichier texte chiffré avec vim

L’idée est d’utiliser le mécanisme de clés publique et privée GnuPG avec vim. L’ouverture du fichier nécessite la clé privée, incluant sa passphrase puis l’enregistrement la clé publique. Par sécurité, aucun cache n’est généré. Voir la configuration du .vimrc. On tape ensuite simplement dans le terminal :

$ vim file.gpg

puis on entre sa passphrase dans le GPG pinentry.

Gestion des mots de passe

pass
gestionnaire de mots de passe à la UNIX basé sur GPG. https://www.passwordstore.org/

Outils de programmation

Scripts idempotents

On dira d’un script qu’il est idempotent si l’état du système reste le même après un ou plusieurs appels de celui-ci. En pratique, on veillera d’abord à ce qu’il ne lève pas d’erreur en cas d’exécutions multiples.

  1. Créer un répertoire

    $ mkdir -p directory

    l’option -p permet de ne pas renvoyer d’erreur si directory existe ;

  2. Supprimer un fichier

    $ rm infile

    l’option -f permet d’ignorer les fichiers inexistants ;

  3. Créer un lien symbolique

    $ ln -sf target_file linked_file

    l’option -f permet de supprimer target_file avant de le recréer ;

  4. Monter un disque

     $ mountpoint -q DataDir || mount Volume DataDir

    en s’assurant qu’il ne soit monté avant ;

  5. Créer et utiliser un répertoire temporaire qui sera supprimé quand le script termine

    TMPDIR=$(mktemp -d) || exit 1
    trap "cd / ; rm -rf '${TMPDIR}'" EXIT

Python

  1. Retrouver une fonction dans un shell python

    import inspect
    print(inspect.getsource(fonction))
  2. Parcourir deux listes simultanément avec un compteur

    for i, x, y in izip(count(), a, b):

    plus rapide que

    for i, (x, y) in enumerate(zip(a, b)):
  3. Définir des array avec les colonnes d’un fichier texte

    col_k = np.readtxt("file")[:,k]
  4. Modifier la taille de pile de récursivité

    import sys
    sys.setrecursionlimit(n)

    avec n=O(1000)n=O(1000) par défaut.

  5. Encoder et décoder du JSON

    def JsonRead(infile):
        with open(infile,'r') as f:
            data = json.load(f)
        return(data)

    data est un dictionnaire.

    def JsonWrite(data, oufile):
        with open(oufile,'w') as f:
            f.writelines(json.dumps(data, sort_keys=True, indent=4))

Administration système

  1. Lancer une commande en administrateur

    $ sudo command

    ou

    $ su -c command
  2. Ajouter un utilisateur au groupe sudo

    # adduser <user> sudo
  3. Autoriser un utilisateur à utiliser le système de fenètres X

    $ sudo xhost local:user
  4. Arrêter le système (en root)

    # shutdown -h now

    ou

    su -c poweroff

    par sécurité sur debian poweroff pointe vers /sbin/poweroff.

  5. Afficher depuis combien de temps vous êtes connecté et la charge de la machine

    $ uptime
  6. Afficher l’historique des redémarrages du système

    $ last reboot

Plate-forme, distribution, etc.

  1. Nom de machine

    $ hostname
  2. Changer le nom de la machine

    # hostnamectl set-hostname <host-name>

    puis éditer les fichiers /etc/hostname et /etc/hosts.

    Vérifier avec

    $ hostnamectl
  3. Distribution

    $ lsb_release -idrc
  4. Afficher les informations de la distribution

    $ lsb_release -a
  5. Informations du système

    $ uname -a
  6. Noyau

    $ uname -r
  7. Afficher l’environnement de bureau utilisé

    $ echo "$XDG_CURRENT_DESKTOP"
  8. Afficher le gestionnaire X11

    $ cat /etc/X11/default-display-manager

État du système

  1. Version du noyau Linux utilisé, son nom, la version du compilateur utilisé :

    $ cat /proc/version
  2. Informations CPU

    $ cat /proc/cpuinfo
  3. Informations mémoire

    $ cat /proc/meminfo
  4. Utilisation de la mémoire

    $ free -h
  5. Partitions montées

    $ cat /proc/partitions

Debian GNU/Linux

  1. Date d’installation d’un paquet

    # zgrep -h " installed " /var/log/dpkg.log* | sort | grep package
  2. Trouver le paquet qui a installé une commande, avec une commande :

    whatinstalled() { which "$@" | xargs -r readlink -f | xargs -r dpkg -S ;}

    puis

    $ whatinstalled <package>
  3. Vider le cache

    # sync && echo 3 | tee /proc/sys/vm/drop_caches
  4. Analyser le démarrage

    # systemd-analyze time
    # systemd-analyze critical-chain
    # systemd-analyze blame
  5. Gérer les messages d’erreur

    # dmesg

    ou

    # journalctl -p err

Utilisateurs, groupes, permissions

  1. Nom d’utilisateur

    $ whoami
  2. Identifiants des groupes auxquels appartient un utilisateur

    $ id user

    si user n’est pas spécifié, de l’utilisateur courant (vous).

  3. Identifier qui est connecté à la machine, comment (shells ouverts) et depuis combien de temps :

    $ who
  4. Afficher la liste de tous les utilisateurs connectés à la machine :

    $ users
  5. Identifier ce que chacun fait sur la machine

    $ w
  6. Afficher les utilisateurs qui se sont connectés au système

    $ last
  7. Se connecter au compte user

    $ su - user

    pour se déconnecter, taper

    $ exit

    ou

    $ logout
  8. Afficher les informations de l’utilisateur login

    $ finger login
  9. Modifier son mot de passe

    $ passwd

    Commande à réaliser avec le compte root ou en super user avec sudo en préfixe.

  10. Créer un nouvel utilisateur

    # adduser newuser

    ou

    # useradd -m -d /home/newuser -c "Full name" newuser

    Pour supprimer son compte, taper

    # deluser --remove-home newuser

    ou

    # userdel -r newuser
  11. Modifier les informations d’un utilisateur

    $ usermod -c "son nom" \
        -s /bin/bash user
  12. Créer un nouveau groupe

    $ addgroup newgroup
  13. Ajouter un utilisateur à un groupe

    $ adduser username groupname
  14. Changer un utilisateur de groupe

    $ chgrp vboxusers /dev/vboxdrv
  15. Lister les connexions bloquées

    # lastb

    et pour lister toutes les connexions

    $ last

Permissions des fichiers

On distingue trois types d’utilisateurs :

Pour chaque type, les permissions sont notées :

0     ---      aucune permission
1     --x      exécution
2     -w-      écriture
3     -wx      écriture et exécution
4     r--      lecture
5     r-x      lecture et exécution
6     rw-      lecture et écriture
7     rwx      lecture, écriture et exécution
  1. Créer un répertoire pour le seul utilisateur user1

    $ mkdir newdir
    $ chown user1:user1 newdir
    $ chmod 700 newdir
  2. Changer de propriétaire et de groupe un fichier

    $ chown user:group filename

    Pour changer seulement le propriétaire

    $ chown user filename

    ou seulement de groupe

    $ chown :group filename

    ou

    $ chgrp group filename
  3. Changer les permissions d’un fichier

     U   G   W
    rw- --- ---     chmod 600 filename  (à préférer par défaut)
    rw- r-- r--     chmod 644 filename
    rw- rw- r--     chmod 664 filename
    rwx r-x r-x     chmod 755 filename
    rwx rwx r-x     chmod 775 filename
    rwx rwx rwx     chmod 777 filename  (à proscrire)
  4. Voir le masque de permissions appliqué par défaut

    $ umask

    en base octale, ou, pour la version symbolique, du genre u=rwx,g=rx,o=rx

    $ umask -S

Les restrictions appliquées par un masque sont :

masque           droits laissés
7       ---      aucun
6       --x      exécution
5       -w-      écriture
4       -wx      écriture et exécution
3       r--      lecture
2       r-x      lecture et exécution
1       rw-      lecture et écriture
0       rwx      lecture, écriture et exécution
  1. Changer le masque des permissions par défaut

     U   G   W
    rw- --- ---     umask 177 (à préférer par défaut)
    rw- r-- r--     umask 133
    rw- rw- r--     umask 113
    rwx r-x r-x     umask 022
    rwx rwx r-x     umask 002
    rwx rwx rwx     umask 000 (à proscrire)
  2. Ajouter un droit d’exécution

    $ chmod +x filename
  3. Lister les attributs d’un fichier

    # lsattr <file>
  4. Bloquer un fichier (le rendre immuable)

    # chattr +i <file>

    le débloquer avec

    # chattr -i <file>
  5. Bloquer un répertoire

    # chattr -R +i path

Locales

  1. Afficher les paramètres régionaux du système

    $ localectl status
  2. Afficher les localisations disponibles

    $ localectl list-locales
  3. Passer en anglais

    $ sudo localectl set-locale LANG=en_US.utf8

    ou en français

    $ sudo localectl set-locale LANG=fr_FR.utf8
  4. Redéfinir la variable LANG pour se connecter en SSH

    $ LANG=en_US.utf8 && ssh ...

Systèmes de fichiers, disques

  1. Description de la hiérarchie du système de fichiers

    $ man hier
  2. Informations sur les périphériques bloc

    $ lsblk

    Avec les identifiants de partitions et les labels :

    $ lsblk --output NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,PARTLABEL,UUID
  3. Systèmes de fichiers montés

    mount
  4. Lister les disques

    $ df -h
  5. Monter un disque

    $ mount volume DataDir

    Monte le volume désigné par volume (comme /dev/sdb1) dans le point de montage DataDir (répertoire). L’option -t permet de définir le type de volume monté (vfat pour windows, iso9660 pour un CD-ROM par exemples). Pour le démonter :

    $ umount
  6. Formater un disque (clé USB) en FAT 32

    # umount /dev/sdb1
    # mkfs.vfat -F 32 /dev/sdb1
  7. Copier une image ISO sur un disque (pas sur une partition) ; par exemple /dev/sdb et non pas /dev/sdb1:

    # dd if=image.iso of=/dev/sdb bs=4M && sync

    Attention la commande dd est très performante mais en cas d’erreur de syntaxe, il est possible d’effacer un disque dur.

  8. Créer une image ISO à partir d’un répertoire

    $ genisoimage -o image.iso directory

Processus

  1. Afficher la liste des processus en cours d’exécution :

    $ ps -ef

    ou

    $ ps aux
  2. AFficher les processus sous forme d’arbre

    $ pstree -p
  3. Afficher la liste des processus en cours d’exécution ainsi que la consommation en ressources de chacun d’eux :

    $ top
  4. Mesurer la durée d’exécution d’une commande

    $ time command
  5. Afficher la liste des processus actifs de l’utilisateur

    $ ps
  6. Afficher les processus dans une arborescence

    $ pstree
  7. Tuer un processus en utilisant son pid

    $ kill [signal] pid
  8. Tuer un processus en utilisant le nom du programme

    $ pkill [signal] progname

Les signaux utilisés par kill/pkill sont :

signal mode action
-1 (HUP) recharger le fichier de configuration du processus
-2 (INT) interrompre le processus
-3 (QUIT) quitter le processus
-9 (KILL) tuer le processus (à éviter, tenter -15 avant)
-15 (TERM) terminer le processus proprement
-18 (STOP) geler le processus
-20 (CONT) reprendre l’exécution d’un processus gelé
  1. Supprimer tous les processus associés à une commande

    $ killall command
  2. Lancer une commande avec une priorité faible

    $ nice command
  3. Trouver la liste des processus qui utilise un répertoire (en root)

    $ lsof -x +D /repertoire
  4. Trouver la liste des fichiers ouverts par un processus (en root)

    $ lsof -p PID

Monitoring

  1. Place au premier plan le processus pid

    $ fg pid
  2. Place en arrière plan le processus pid

    $ bg pid
  3. Redéfinir le niveau de priorité du processus pid

    $ renice +1 pid
  4. Afficher la liste des processus en arrière plan

    $ jobs
  5. Tuer le job [n]

    $ kill %n

Terminal série

  1. Créer un terminal série avec screen

    $ screen -S name /dev/{tty,ACM}...

Réseau

  1. Lister les interfaces avec leurs modes de connexion

    $ nmcli
    $ nmcli d
  2. Lister les connexions actives

    $ nmcli connection show --active
    $ nmcli con show --active
  3. Démarrer ou éteindre une connexion

    $ nmcli connection down connection_name
    $ nmcli connection up connection_name
  4. Activer la Wi-Fi

    $ nmcli radio wifi on

    ou la désactiver

    $ nmcli radio wifi off
  5. Vérifier l’accès à Internet

    $ nmcli network connexion
    $ nmcli net con

    doit renvoyer full pour un accès complet.

  6. Afficher la liste de toutes les connexions réseaux

    # lsof -i
  7. Trouver le processus qui écoute sur le port 80

    # lsof -nP -i tcp:80 | grep LISTEN
  8. Configurer un proxy

    $ export http_proxy="http://user:password@host:port"
    $ export https_proxy="http://user:password@host:port"
    $ export ftp_proxy="http://user:password@host:port"

    visible avec

    $ echo $http_proxy

    Exemple, sans authentification

    $ export http_proxy="http://172.20.1.4:3128/"

IP

  1. Obtenir son IP locale

    $ /sbin/ifconfig
    $ ip addr show eth0
    $ ip addr show eth0 | grep inet\  | cut -d' ' -f6 | cut -d/ -f1
    $ ip addr show scope global | grep inet\  | cut -d' ' -f6 | cut -d/ -f1
    $ hostname -I
  2. Obtenir son IP publique

    $ curl -s ipecho.net/plain;echo
    $ curl -s https://ifconfig.me/ip;echo
    $ curl -s http://whatismijnip.nl | cut -d " " -f 5

DNS

  1. to get IP (DNS)

    $ dig URL +short
  2. to get URL (DNS Reverse)

    $ dig -x IP +short
  3. to use a Specific DNS server “dnsserver”

    $ dig @dnsserver ...

Périphériques

  1. Afficher la liste des périphériques USB connectés

    $ lsusb
  2. Afficher la liste des périphériques PCI connectés

    $ lspci
  3. Afficher les pilotes et les modules du noyau des périphériques matériels

    $ lspci -nnk

Carte Wi-Fi

  1. Régler la région « France » pour accéder canaux 11/12/13

    # sed -i "s/^REGDOMAIN=.*$/REGDOMAIN=FR/" /etc/default/crda

Résidus

Interaction avec un Mac

  1. Afficher un message à l’utilisateur (du clavier) depuis un terminal (ssh)

    $ osascript -e 'display dialog "Hello!"'

Ressources

Lectures recommandées

Sur les commandes UNIX et GNU/Linux

en anglais :

Idées & astuces

Guides des « bonnes pratiques » de l’ANSII

GNU coreutils

GNU file utilities

chgrp Changes file group ownership.
chown Changes file ownership.
chmod Changes file permissions.
cp Copies files.
dd Copies and converts a file.
df Shows disk free space on filesystems.
dir Gives a brief directory listing.
dircolors Setup program for the color output of GNU ls.
du Shows disk usage on filesystems.
install Copies file and sets its permissions.
link Creates a single file hardlink
ln Creates file links.
ls Lists directory contents.
mkdir Creates directories.
mkfifo Creates FIFOs (named pipes).
mknod Creates special files.
mv Moves files.
rm Removes (deletes) files.
rmdir Removes empty directories.
shred Destroy data in files.
sync Synchronizes filesystem buffers and disk.
touch Changes file timestamps.
unlink Removes a single file or a hardlink
vdir Long directory listing.

Shell utilities

basename Removes the path prefix from a given pathname.
chroot Changes the root directory.
date Prints/sets the system date and time.
dirname Removes the last level or filename from a given pathname.
echo Prints a line of text.
env Displays/modifies the environment.
expr Evaluates expressions.
factor Prints prime factors.
false Returns an unsuccessful exit status.
groups Print the groups that the user is a member of.
hostid Print the numeric identifier for the current host
hostname Print or set the machine name.
id Print real/effective ?uid/?gid.
logname Print current login name.
nice Modify scheduling priority.
nohup Allows a command to continue running after logging out.
pathchk Check file name portability.
pinky Lightweight finger
printenv Prints environment variables.
printf Formats and prints data.
pwd Print the current working directory.
seq Print numeric sequences.
sleep Suspends execution for a specified time.
stty Print/change terminal settings.
su Allows you to adopt the id of another user or superuser.
tee Sends output to multiple files.
test Evaluates an expression.
true Returns a successful exit status.
tty Print terminal name.
uname Print system information.
users Print current user names.
who Print a list of all users currently logged in.
whoami Print effective user id.
yes Print a string repeatedly.

Text utilities

cat concatenate files and print to the standard output
cksum checksum and count the bytes in a file
comm compare two sorted files line by line
csplit split a file into sections determined by context lines
cut remove sections from each line of files
expand convert tabs to spaces
fmt simple optimal text formatter
fold wrap each input line to fit in specified width
head output the first part of files
join join lines of two files on a common field
md5sum compute and check MD5 message digest
nl number lines of files
od dump files in octal and other formats
paste merge lines of files
pr convert text files for printing
ptx produce a permuted index of file contents
sort sort lines of text files
split split a file into pieces
sum checksum and count the blocks in a file
tac concatenate and print files in reverse
tail output the last part of files
tr translate or delete characters
tsort perform topological sort
unexpand convert spaces to tabs
uniq remove duplicate lines from a sorted file
wc print the number of bytes, words, and lines in files

About

  1. Pour éditer ce document :

    $ pandoc -o tips.pdf tips.md -s --highlight-style haddock
  2. Pour éditer ce document en manpage :

    $ pandoc tips.md -s -t man >tips.man

    et le voir :

    $ man ./tips.man