Ajouter un utilisateur au système

$ sudo   adduser   nom_du_user

(répondre aux différentes questions posées)

Ajouter un utilisateur Samba

(après avoir créé le user au niveau du système avec la commande précédente)

$ sudo    smbpasswd   -a   nom_du_user

(saisir le mot de passe indiqué lors de la création du user au niveau du système)

Pour afficher l'UID d'un utilisateur, saisir la commande suivante dans une console :

$ echo `grep root /etc/passwd | cut -d: -f3`
0
$

La commande grep root /etc/passwd affiche la ligne du fichier /etc/passwd contenant l'expression root

$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash
$

La commande cut -d: -f3 permet d'extraire uniquement la 3ème valeur -f3 après découpage de la ligne en indiquant le délimiteur -d:

2 sessions GNOME ouverte sur Ubuntu. La seconde session est verrouillée et protégée par un mot de passe.

Pour la fermer, saisir la commande suivante dans une console :

$ sudo skill -KILL -u utilisateur

Pour fermer un terminal dont la connexion a été perdue (ssh par exemple)

Identifier la console à fermer :

$ w
 14:32:16 up 12 days,  6:26,  2 users,  load average: 0,00, 0,00, 0,00
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
toto    pts/0    vm-ssh.quennec. 14:28    4:12   0.29s  0.29s -bash
toto    pts/1    vm-ssh.quennec. 14:28    0.00s  0.24s  0.00s w
$

La commande w permet de visualiser les utilisateurs connectés et la commande en cours d'exécution.
Dans l'exemple ci-dessus, je suis donc actuellement connecté sur 2 terminaux pts/0 & pts/1.
On voit également que la commande w a été exécutée sur le terminal pts/1 et que le terminal pts/0 est inactif depuis 4 min et 12 sec.
Il faut donc fermer le terminal pts/0.

Identifier le processus lié au terminal à fermer :

$ ps -ef | grep toto@pts/0 | grep -v grep
toto    15236 15224  0 14:28 ?        00:00:00 sshd: toto@pts/0
$

Le terminal pts/0 est donc lié au processus 15236.

Fermer le terminal :

$ kill -s 9 15236

Pour changer l'interpréteur de commande d'un utilisateur, saisir dans une console :

Mettre par défaut l'interpréteur de commande BASH pour l'utilisateur toto

$ chsh -s /bin/bash toto

L'option -s permet d'indiquer l'interpréteur de son choix.
Si cette option n'est pas indiquée, le programme chsh s'appuie sur le fichier /etc/shells pour fournir la liste des interpréteurs à utiliser.

$ cat /etc/shells
# /etc/shells: valid login shells
/bin/csh
/bin/sh
/usr/bin/es
/usr/bin/ksh
/bin/ksh
/usr/bin/rc
/usr/bin/tcsh
/bin/tcsh
/usr/bin/esh
/bin/dash
/bin/bash
/bin/rbash
/usr/bin/screen
/bin/ksh93
/bin/zsh
/usr/bin/zsh

Le nouvel interpréteur est renseigné dans le fichier /etc/passwd pour l'utilisateur indiqué.

$ cat /etc/passwd | grep "toto"
toto:x:1020:1020:toto:/home/toto:/bin/bash
$

La commande suivante permet de se loguer en root.

Ouvrir une session avec son  user puis saisir :

$ sudo su -

(Saisir son mot de passe)

Dans une console, pour prendre le rôle d'un user spécifique, saisir la commande suivante :

$ sudo -i -u user

Par exemple, pour prendre le rôle du user www-data

$ sudo -i -u www-data

Via le user root

$ sudo su -
$ su - www-data

Archiver avec TAR

$ tar -cvf mon_archive.tar   nom_du_fichier_a_archiver
$ tar -cvf mon_archive.tar   nom_du_dossier_a_archiver

-c : Create

-v : Verbose

-f : File

Archiver des fichiers avec TAR puis les supprimer

Suppression des fichiers archivés avec l'option --remove-files

$ /bin/tar --create --file=/monDossier/monArchive.tar --remove-files /monDossier/*.jpg

Archive tous les fichiers jpg présents dans le dossier 'monDossier' puis les supprime du dossier

Désarchiver avec TAR

$ tar -xvf mon_archive.tar

-x : eXtract

-v : Verbose

-f : File

Archivage :

Création de la première sauvegarde (sauvegarde complète)

Sauvegarde du dossier /home dans le fichier /backup/archive.1.tar avec détail du contenu dans /backup/backup.list

$ tar --create --file=/backup/archive.1.tar --listed-incremental=/backup/backup.list /home

Création des sauvegardes suivantes (incrémentées uniquement avec les fichiers nouveaux et/ou modifiés)

Sauvegarde des fichiers du dossier /home dans le fichier /backup/archive.2.tar différents de ceux présents dans la liste /backup/backup.list

$ tar --create --file=/backup/archive.2.tar --listed-incremental=/backup/backup.list /home

Utilisation de la date dans le nom de l'archive générée

$ tar --create --file=/backup/archive.`date +%Y_%m_%d_%s`.tar --listed-incremental=/backup/backup.list /home
 

Restauration :

Restaurer la première archive complète

$ tar --extract --listed-incremental=/dev/null --file archive.1.tar

Puis restaurer les archives suivantes

$ tar --extract --listed-incremental=/dev/null --file archive.2.tar

Sur un historique de sauvegarde de 10 archives, pour restaurer l'archive 4, restaurer les archives 1, 2, 3 & 4 et ce dans le bon ordre. Ne pas restaurer directement l'archive 4, elle serait incomplète.

Pour supprimer un fichier ou un dossier dans une archive TAR :

$ tar --delete --file=nom_de_l_archive.tar nom_du_fichier_a_supprimer

Compresser avec TAR & GZIP

$ tar -cvzf mon _archive.tar.gz   nom_du_fichier_a_compresser
$ tar -cvzf mon _archive.tar.gz   nom_du_dossier_a_compresser

-c : Create

-v : Verbose

-z : gZip

-f : File

Décompresser avec TAR & GZIP

$ tar -xvzf mon_archive.tar.gz

-x : eXtract

-v : Verbose

-z : gZip

-f : File

Pour afficher les variables d'environnements, saisir dans la console

$ printenv

Pour créer une variable d'environnement, éditer le fichier $HOME/.bashrc

Y inscrire :

export MA_VARIABLE=/mon_dossier

ou

export MA_VARIABLE=/mon_dossier/mon_fichier

Pour convertir un timestamp en format date :

$ date -d @1320822978 "+%Y-%m-%d %T"
2011-11-09 08:16:18

Pour convertir une date en timestamp :

Date au format AAAAMMJJ

$ date -d "20111109" +%s
1320793200

Voici un exemple qui permet d'exécuter une action en fonction d'un jour bien précis.

Comment recevoir automatiquement un mail tous les vendredi 13 de chaque mois :

$ if [[ `date +%u` == 5 && `date +%d` == 13 ]]; then echo "" | mail -s "Vendredi 13 : Jouer au Loto" moi@gmail.com; fi

Explications :

La fonction `date +%u` retourne le numéro du jour de la semaine. Lundi = 1... Dimanche = 7.

La fonction `date +%d` retourne le jour du mois

Sous Linux, la fonction date permet d'afficher la date du jour ou une date définie sous différentes formes.

Le script suivant (afficheDate.sh), associé au fichier contenant les différentes fonctions utilisées (fonctions.inc.sh) affiche différentes informations sur la date du jour.

$ nl afficheDate.sh
     1  #!/usr/bin/bash
     2  SCRIPTDIR="."
     3  . $SCRIPTDIR/fonctions.inc.sh
     4  echo "Date au format aaaa_mm_jj : `getDate`"
     5  echo "Année : `getYear`"
     6  echo "Mois : `getMonth`"
     7  echo "Jour : `getDay`"
     8  echo "Nous sommes le `getJourDate` `getDay` `getMoisDate` `getYear`"
     9  echo "Nous sommes en semaine `getNumSemaine`"
    10  echo "Nous sommes le `getNumDay` jour de l'année"
    11  echo "Nous sommes le `getNumDayWeek` jour de la semaine"
    12  echo "Cette année il y a `nbJourAnnee` jours"
    13  echo "Il reste `nbResteJour` jour(s) avant la fin de l'année"
    14  echo "Cette année il y a `nbSemAnnee` semaines"
    15  echo "Il reste `nbResteSemaine` semaine(s) avant la fin de l'année"
$

Exécution du script :

$ ./afficheDate.sh
Date au format aaaa_mm_jj : 2011_12_19
Année : 2011
Mois : 12
Jour : 19
Nous sommes le Monday 19 December 2011
Nous sommes en semaine 51
Nous sommes le 353 ème jour de l'année
Nous sommes le 1 er jour de la semaine
Cette année il y a 365 jours
Il reste 12 jour(s) avant la fin de l'année
Cette année il y a 52 semaines
Il reste 1 semaine(s) avant la fin de l'année
$

Problème de lecture / exécution d'un fichier sous Linux créer sous Windows.

Sous Windows (DOS), les lignes de fichier se terminent par les caractères spéciaux "\r\n".
Sous UNIX, les lignes de fichier se terminent par les caractères spéciaux "\n".

Les caractères spéciaux permettant le retour chariot étant différents sous Windows (DOS) et sous Linux (UNIX), il faut penser à les convertir.

Différentes méthodes permettent de le faire.

Avec la commande sed :

$ sed -i 's/\r//g'  /nom_du_fichier

Sinon, le caractère "\r" est représenté par "^M" qui s'obtient par la séquence de touches suivantes : "CTRL-V" + "CTRL-M"

$ sed -i 's/^M//' /nom_du_fichier

Avec la commande tr :

$ tr -d '\r' < /mon_fichier_source > /mon_fichier_destination

A l'inverse, convertir un fichier UNIX vers DOS

$ sed 's/$/^M/' /nom_du_fichier

Source : http://www.commentcamarche.net/faq/5978-sed-conversion-retours-chariots-...

Pour rendre un fichier exécutable

$ sudo chmod +x ./nom_du_fichier

Pour afficher la somme MD5 d'un fichier afin d'en assurer son intégrité, il suffit d'utiliser la commande md5sum.

Exemple avec le fichier "test.txt" :

$ cat test.txt
ceci est une ligne
$

Calcul de la somme MD5 du fichier "test.txt" :

$ md5sum test.txt
2f378979d16de47b9d439149be5623db  test.txt
$

Modification du fichier "test.txt" :

$ echo "une nouvelle ligne" >> test.txt
$ cat test.txt
ceci est une ligne
une nouvelle ligne
$

Re-calcul de la somme MD5 du fichier "test.txt" :

$ md5sum test.txt
5c69442bc1b1084b60a81190a75c6a0e  test.txt
$

Après modification du fichier, la somme MD5 du fichier n'est plus la même.

Il est également possible d'enregistrer la somme MD5 d'un fichier dans un fichier :

$ md5sum test.txt > test.md5
$ cat test.md5
5c69442bc1b1084b60a81190a75c6a0e  test.txt
$

De cette manière, il est possible de controler la somme MD5 d'un fichier :

Utilisation de la commande md5sum avec l'option -c et le fichier contenant la somme MD5 en paramètre.

$ md5sum -c test.md5
test.txt: OK
$

Attention : Les 2 fichiers (celui à controler et celui contenant la somme MD5) doivent être au même endroit.

Si le fichier à controler a été altéré :

$ md5sum -c test.md5
test.txt: FAILED
md5sum: WARNING: 1 of 1 computed checksum did NOT match
$

Sous Unix, les fichiers comportant des espaces dans le nom sont très compliqués à gérer sachant que l'espace est interprété comme étant un séparateur.

Voici un exemple qui permet d'afficher la somme MD5 d'une liste de fichiers dont les noms comportent des espaces.

 # ls -1
20160524 leclerc 1264.pdf             
20160528 boulanger 3290.pdf           
20160528 cofiroute 620.pdf            
20160529 la mie caline 790.pdf        
20160529 le marché aux fleurs 2050.pdf
20160601 cordonnerie leclerc 1000.pdf
20160601 leclerc 990.pdf              
20160601 pharmacie 3830.pdf          

Les 8 fichiers ci-dessus comportent tous des espaces dans leurs noms.

 # while read f; do md5sum "$f"; done <<< $(ls)

57709e696d14838ceeff6500728d1569  20160524 leclerc 1264.pdf
9f870fb12e598c7345cb74c6db15afee  20160528 boulanger 3290.pdf
5bb71357967db84baf6ed4a5fb56c552  20160528 cofiroute 620.pdf
690471607356b9ea798d3d44d69f478d  20160529 la mie caline 790.pdf
519a250059f5d8bc93af22d2ae02512f  20160529 le marché aux fleurs 2050.pdf
a08e6094bc01a34c508761ebbdae6418  20160601 cordonnerie leclerc 1000.pdf
c8f36624113710939365dd0a4daeb30c  20160601 leclerc 990.pdf
387ce36eaa18d383bd1950ee17a4fdff  20160601 pharmacie 3830.pdf

La commande read, dans la boucle while, interprète correctement les noms de fichiers provenant de la commande ls.

Ne pas oublier les 3 chevrons vers la gauche "<<<" entre la commande ls et la boucle while

mcrypt & mdecrypt sont des programmes qui permettent de chiffrer / déchiffer des fichiers avec un mot de passe.

Le programme mcrypt créé un nouveau fichier portant l'extension .nc avec des permissions 0600

Pour l'installer :

$ sudo apt-get install mcrypt

Pour chiffrer un fichier

$ mcrypt monFichier
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase:
Enter passphrase:
 
File monFichier was encrypted.
$ ls -l monFichier*
-rw-r--r-- 1 ronan ronan   0 2011-11-05 15:24 monFichier
-rw------- 1 ronan ronan 109 2011-11-05 15:24 monFichier.nc
$

Pour chiffrer un fichier et supprimer le fichier source

$ mcrypt -u monFichier
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase:
Enter passphrase:
 
File monFichier was encrypted.
$ ls -l monFichier*
-rw------- 1 ronan ronan 109 2011-11-05 15:24 monFichier.nc
$

Pour chiffrer un fichier avec une compression gzip

$ mcrypt -z monFichier
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase:
Enter passphrase:
 
File monFichier was encrypted.
$ ls -l monFichier*
-rw-r--r-- 1 ronan ronan   0 2011-11-05 15:31 monFichier
-rw------- 1 ronan ronan 141 2011-11-05 15:31 monFichier.gz.nc
$

Lister tous les algorithmes utilisable par mcrypt

$ mcrypt --list
cast-128 (16): cbc cfb ctr ecb ncfb nofb ofb
gost (32): cbc cfb ctr ecb ncfb nofb ofb
rijndael-128 (32): cbc cfb ctr ecb ncfb nofb ofb
twofish (32): cbc cfb ctr ecb ncfb nofb ofb
arcfour (256): stream
cast-256 (32): cbc cfb ctr ecb ncfb nofb ofb
loki97 (32): cbc cfb ctr ecb ncfb nofb ofb
rijndael-192 (32): cbc cfb ctr ecb ncfb nofb ofb
saferplus (32): cbc cfb ctr ecb ncfb nofb ofb
wake (32): stream
blowfish-compat (56): cbc cfb ctr ecb ncfb nofb ofb
des (8): cbc cfb ctr ecb ncfb nofb ofb
rijndael-256 (32): cbc cfb ctr ecb ncfb nofb ofb
serpent (32): cbc cfb ctr ecb ncfb nofb ofb
xtea (16): cbc cfb ctr ecb ncfb nofb ofb
blowfish (56): cbc cfb ctr ecb ncfb nofb ofb
enigma (13): stream
rc2 (128): cbc cfb ctr ecb ncfb nofb ofb
tripledes (24): cbc cfb ctr ecb ncfb nofb ofb
$

Chiffrer un fichier en utilisant l'algorithme "DES"

$ mcrypt -a des monFichier
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase:
Enter passphrase:
 
File monFichier was encrypted.
$ ls -l monFichier*
-rw-r--r-- 1 ronan ronan  0 2011-11-05 15:31 monFichier
-rw------- 1 ronan ronan 84 2011-11-05 15:31 monFichier.nc
$

Obtenir des infos sur le fichier chiffré

$ file monFichier.nc
monFichier.nc: mcrypt 2.5 encrypted data, algorithm: des, keysize: 8 bytes, mode: cbc,
$

Déchiffrer un fichier

$ ls -l monFichier*
-rw------- 1 ronan ronan 84 2011-11-05 15:31 monFichier.nc
$ mcrypt -d monFichier.nc
Enter passphrase:
File monFichier.nc was decrypted.
$ ls -l monFichier*
-rw------- 1 ronan ronan  0 2011-11-05 15:31 monFichier
-rw------- 1 ronan ronan 84 2011-11-05 15:31 monFichier.nc
$

Ou en utilisant le programme mdecrypt

$ ls -l monFichier*
-rw------- 1 ronan ronan 84 2011-11-05 15:31 monFichier.nc
$ mdecrypt monFichier.nc
Enter passphrase:
File monFichier.nc was decrypted.
$ ls -l monFichier*
-rw------- 1 ronan ronan  0 2011-11-05 15:31 monFichier
-rw------- 1 ronan ronan 84 2011-11-05 15:31 monFichier.nc
$

Comment savoir si les fichiers présents dans le dossier "DOSSIERX" du serveur "SERVEURA" sont exactement les mêmes que ceux présents dans le dossier "DOSSIERY" du serveur "SERVEURB" ?

Grâce à la commande sha256sum et une connexion ssh correctement configurée.

Exécuter le commande suivante sur le serveur "SERVEURA".

$ find /DOSSIERX -type f -exec sha256sum {} \; | ssh SERVEURB 'cd /DOSSIERY && sha256sum --quiet -c -'

Idem, mais en excluant un dossier de la recherche (.git par exemple):

$ find /DOSSIERX -type f -not -path */.git/* -exec sha256sum {} \; | ssh SERVEURB 'cd /DOSSIERY && sha256sum --quiet -c -'

Pour connaitre la taille d'un dossier :

$ sudo du -hs /nom_du_dossier

Rechercher tous les fichiers *.jpg présents dans le répertoire ~/images (sous-répertoires inclus) et les copier dans le répertoire imagesJPG.

$ find ~/images -name '*.jpg' -print0 | xargs -I '{}' -0 cp {} ~/imagesJPG/

L'option -print0 de la commande find et -0 de la commande xargs permet de prendre en compte les fichiers comportant des espaces dans leurs noms.

La commande dd permet de créer des fichiers d'une taille bien précise.

Créer un fichier vide de 1 Mo (1024 blocs de 1Ko):

$ dd if=/dev/zero of=zzz bs=1k count=1024
1024+0 enregistrements lus
1024+0 enregistrements écrits
1048576 octets (1,0 MB) copiés, 0,0108743 s, 96,4 MB/s
 
$ ls -l zzz
-rw-r--r-- 1 r.quennec mkpasswd 1,0M 23 mai   10:53 zzz
$

Créer un fichier avec des données aléatoires de 1 Mo (1024 blocs de 1Ko):

$ dd if=/dev/urandom of=zzz bs=1k count=1024
1024+0 enregistrements lus
1024+0 enregistrements écrits
1048576 octets (1,0 MB) copiés, 0,239581 s, 4,4 MB/s
 
$ wc zzz
   4074   23182 1048576 zzz
$

Lire un fichier PDF en ligne commande est possible grâce à la commande less

$ less Verne-Le_tour_du_monde_en_80_jours.InLibroVeritas.net_oeuvre18616.pdf
Jules Verne
   
LE TOUR DU
MONDE EN
QUATRE-VINGTS
JOURS
   
- Collection Romans / Nouvelles -
   
Retrouvez cette oeuvre et beaucoup d'autres sur
http://www.inlibroveritas.net
   
^L^LTable des matières
LE TOUR DU MONDE EN QUATRE-VINGTS JOURS......................1
I - DANS LEQUEL PHILEAS FOGG ET PASSEPARTOUT
S'ACCEPTENT RÉCIPROQUEMENT L'UN COMME
MAÎTRE, L'AUTRE COMME DOMESTIQUE...............................2
II - OU PASSEPARTOUT EST CONVAINCU QU'IL A ENFIN
TROUVE SON IDEAL......................................................................8
III - OU S'ENGAGE UNE CONVERSATION QUI POURRA
COUTER CHER A PHILEAS FOGG.............................................12
IV - DANS LEQUEL PHILEAS FOGG STUPEFIE
PASSEPARTOUT, SON DOMESTIQUE.......................................21
V - DANS LEQUEL UNE NOUVELLE VALEUR APPARAÎT
SUR LA PLACE DE LONDRES
...................
$

Pour modifier le propriétaire d'un fichier ou d'un dossier

$ sudo chown root /u

change le propriétaire de /u en « root ».

$ sudo chown root:staff /u

même chose en changeant également le groupe en « staff ».

$ sudo chown -hR root /u

change le propriétaire de /u et ses sous-fichiers en « root ».

OPTIONS

Changer le propriétaire et/ou le groupe de chaque FICHIER en PROPRIÉTAIRE et/ou GROUPE. Avec l’option --reference, modifier le propriétaire et le groupe de chaque fichier en celui du FICHIER-R.

       -c, --changes
              utiliser le mode bavard en ne signalant que les modifications

       --dereference
              affecter la cible de chaque lien  symbolique  (comportement  par
              défaut) plutôt que le lien symbolique lui-même

       -h, --no-dereference
              modifier  les  liens symboliques au lieu des fichiers référencés
              (utile seulement sur  les  systèmes  permettant  de  changer  le
              propriétaire d’un lien symbolique)

       --from=PROPRIETAIRE_COURANT:GROUPE_COURANT
              changer  le  propriétaire  et/ou  le  groupe  de  chaque fichier
              seulement s’il y a concordance avec  le  propriétaire  et/ou  le
              groupe  courant spécifié. Les deux peuvent être omis, auquel cas
              la concordance n’est pas requise pour le paramètre non spécifié

       --no-preserve-root
              ne pas traiter « / » de manière spéciale (par défaut)

       --preserve-root
              ne pas opérer récursivement sur « / »

       -f, --silent, --quiet
              supprimer la plupart des messages d’erreur

       --reference=FICHIER-R
              utiliser le propriétaire et le groupe du FICHIER-R  au  lieu  de
              valeurs explicites PROPRIÉTAIRE:GROUPE

       -R, --recursive
              modifier récursivement fichiers et répertoires

       -v, --verbose
              afficher un diagnostic pour chaque fichier traité

       Les  options  suivantes  modifient  la  façon  dont  est  parcourue  la
       hiérarchie lorsque l’option -R est également spécifiée. Si  plus  d’une
       option est spécifiée, seule la dernière est prise en compte.

       -H     si  un  paramètre de la ligne de commande est un lien symbolique
              vers un répertoire, le parcourir

       -L     parcourir  chaque  lien  symbolique  rencontré   menant   à   un
              répertoire

       -P     ne parcourir aucun lien symbolique (par défaut)

       --help afficher l’aide-mémoire et quitter

       --version
              afficher le nom et la version du logiciel et quitter

       Le  propriétaire  n’est  pas modifié s’il n’est pas spécifié. Le groupe
       reste inchangé s’il n’est pas spécifié, sauf si cela est  implicitement
       demandé avec un « : » suivant un PROPRIÉTAIRE symbolique, auquel cas il
       sera modifié en ce nom de propriétaire. Le PROPRIÉTAIRE  et  le  GROUPE
       peuvent être numériques ou symboliques.

Pour modifier les permissions d'un fichier ou d'un dossier

$ sudo chmod 777 ./nom_du_fichier

modifie les permissions pour le fichier

$ sudo chmod 777 ./nom_du_dossier

modifie les permissions pour le dossier

$ sudo chmod -R 777 ./nom_du_dossier

modifie les permissions pour le dossier et tous les fichiers du dossier

Les permission sont données dans l'ordre user - groupe - autre

La lecture = 4

L'écriture = 2

L'exécution = 1

Tous les droits = 7

Pour connaitre le nom du dossier courant, saisir dans une console la commande :

$ pwd

Pour se rendre dans son répertoire personnel saisir dans une console l'une des 2 commandes suivantes:

$ cd

$ cd ~

Pour retourner au dossier précédent :

$ cd -

Rechercher les dossiers modifiés dans les dernières 24 heures et lister leurs contenus :

$ find /dossier_origine/* -mtime 0 -type d -exec ls -lht {} \;

l'option -mtime permet de spécifier le nombre de période de 24 heures.
l'option -type d permet d'indiquer que la recherche s'effectue uniquement sur les dossiers.
l'option -exec ls -lht {} \; permet d'exécuter la commande ls pour chaque dossier trouvé.

Le principe est simple. La commande find recherche tous les fichiers comportant un espace puis exécute pour chaque fichier trouvé la commande rename qui remplace tous les espaces par des underscores.

$ find ./ -depth -name "* *"  -exec rename 's/ /_/g' "{}" \;

Pour renommer un fichier, il suffit d'utiliser la commande mv.

Exemple :

$ mv ./foo ./bar

Cette commande va renommer le fichier foo en bar.

Voici une petite astuce bien sympa qui consiste à renommer un fichier en y ajoutant une extension quelconque.

$ mv ./foo{,.txt}

Cette commande va donc renommer le fichier foo en foo.txt

En utilisant l'option -delete

$ sudo find /mon-repertoire -name mon-document -delete

ou en utilisant l'option -exec et la fonction rm

$ sudo find /mon-repertoire -name mon-document -exec rm {} \;

la chaine de caractère "{}" est remplacée par le résultat de la recherche

ou en combinant les commandes find, xargs et rm

$ find /mon-repertoire -name '*.txt' -print0 | xargs -0 rm -f
$ find /mon-repertoire -name '*.txt' -print0 | xargs -I '{}' -0 rm -f {}

L'option -print0 de la commande find et -0 de la commande xargs permet de prendre en compte les fichiers comportant des espaces dans leurs noms.

Documentation Ubuntu

La synchronisation de dossiers et/ou de fichiers se fait via le programme RSYNC

$ sudo rsync -av --del /source_a_sauvegarder/    /destination_de_la_sauvegarde/

-a : préserve l'intégralité des dossiers et fichiers

-v : verbose (affiche le détail à l'écran)

--del : supprime les fichiers et dossiers de destination qui ne sont plus dans source

rsync via SSH

$ rsync -a /source/ login@serveur.org:/destination/

SCP (Secure Copy Protocol) est un protocole permettant le transfert de fichiers en toute sécurité d'une machine locale vers une machine distante et inversement. Tous les transferts de fichiers sont effectués via le protocol SSH.

Transférer le fichier local file1.txt vers le répertoire courant de la machine distante 192.168.1.100

$ scp ./file1.txt user@192.168.1.100:./

Transférer le fichier file1.txt de la machine distante vers le répertoire courant de la machine locale

$ scp user@192.168.1.100:./file1.txt ./

Transférer tout le répertoire local /var/test vers le répertoire /tmp de la machine distante 192.168.1.100

$ scp -r /var/test user@192.168.1.100:/tmp/

SSH permet d'utiliser des pipelines de commandes, et d'utiliser des tubes d'entrées/sorties comme toute autre commande, a ceci prêt que la redirection se fait vers, ou depuis la machine distante.

Celà peut, entre autre, servir à transférer des fichiers:

$ ssh serveur "cat fichier_distant" > fichier_local

L'utilité d'une telle commande est discutable, la commande scp faisant exactement la même chose.

Maintenant, imaginons un fichier de plusieurs mégas, et une bande passante assez limitée:

$ ssh serveur "gzip -c fichier_distant" > fichier_local.gz

ici, le serveur compresse le fichier, la commande écrit le fichier compressé sur le client.

On peut pousser encore plus loin, si l'on ne veut pas récupérer un fichier gzipé, mais diminuer quand même l'utilisation de la bande passante:

$ ssh serveur "gzip -c fichier_distant" |gunzip > fichier_local

Pour supprimer les caractères BOM d'un fichier encodé en UTF-8, il suffit de l'ouvrir avec l'éditeur vim et d'exécuter la commande :set nobomb. 

Pour finir, enregistrer les modifications avec la commande :wq.

Télécharger un fichier d'internet

$ wget   adresse_du_fichier_a_telecharger
 
$ fetch   adresse_du_fichier_a_telecharger

Pour aspirer un site internet

$ wget -r -l5 -k -E "http://www.l_adresse_du_site.a_recuperer.com"

-r : récursif sur le site
-l5 : cinq niveaux de récursion au maximum
-k : convertir les destinations des liens pour une lecture locale
-E : convertir les types de fichier au format HTML (pour éviter que la lecture de sites en PHP ne foire en lecture sous Firefox).

A l'aide de l'outil httrack

$ sudo apt-get install httrack

Pour aspirer le site :

$ httrack --mirror http://mon-site.com

Pour mettre à jour le site aspirer (se placer dans le dossier du site):

$ httrack --update

La commande curl est très utile pour afficher, tester etc... un site internet.
On peut également utiliser la commande curl pour afficher les informations SSL des sites internet.

Par exemple, avec mon site internet https://quennec.fr

# curl -I --verbose https://quennec.fr*   Trying 51.159.70.99:443...
* TCP_NODELAY set
* Connected to quennec.fr (51.159.70.99) port 443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
*   CAfile: /etc/ssl/certs/ca-certificates.crt
  CApath: /etc/ssl/certs
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server accepted to use h2
* Server certificate:
*  subject: CN=quennec.fr
*  start date: Mar 11 07:02:14 2024 GMT
*  expire date: Jun  9 07:02:13 2024 GMT
*  subjectAltName: host "quennec.fr" matched cert's "quennec.fr"
*  issuer: C=US; O=Let's Encrypt; CN=R3
*  SSL certificate verify ok.
...
<
* Connection #0 to host quennec.fr left intact

On peut voir qui a émis le certificat, ses dates de validité etc etc ...

Et sinon, la commande openssl permet de récupérer le certificat complet, voir openssl : Récupérer un certificat distant

La commande CURL peut être utilisée pour poster des données via un formulaire WEB.

Exemple avec la commande suivante:

$ curl \
--insecure \
--request POST \
--header 'Content-Type: multipart/form-data' \
'https://www.monsite.com/monformulaire' \
-F 'username=toto' \
-F 'password=pass4toto' \
-F 'date-de-naissance=11-02-82' \
-F "file=@monfichier.txt" \
--include
 

Détail des options:

--insecure permet d'utiliser une connexion sécurisée (https) avec un certificat auto-signé (non reconnu)
--request POST permet d'indiquer le type de la requête
--header 'Content-Type: multipart/form-data' permet d'indiquer l'en-tête de la requête
-F permet d'indiquer les valeurs pour les différents champs du formulaire
--include permet de récupérer l'en-tête de la réponse

Pour poster un fichier, il est nécessaire de préfixer le nom du fichier avec l'arobase (@)

Pour appeler un webservice SOAP avec la commande CURL, il suffit d'indiquer le bon content-type dans le header ainsi que le nom du fichier XML à envoyer.

# curl \
> --header "content-type: application/soap+xml; charset=utf-8" \
> --data @request.xml \
> http://$SERVER:$PORT/$ENDPOINT

Ne pas oublier le symbole '@' devant le nom du fichier XML pour indiquer à la commande CURL qu'il s'agit d'un fichier.

Pour utiliser un serveur proxy avec la commande curl, il suffit tout simplement de créer dans son home un fichier .curlrc

Il est possible d'y ajouter différents paramètres liés à la commande curl

$ cat .curlrc
--proxy-user "user_toto:pass_toto"
--proxy "http://proxy.mondomaine.local:3128/"
--noproxy "localhost,127.0.0.1,mondomaine.local"

Ne pas oublier de paramétrer les accès au fichier

$ chmod 0600 .curlrc

Qu'est ce qu'un sprite CSS ?

En CSS, un sprite est une image unique regroupant plusieurs images différentes.
Cela permet de réduire les requêtes http pour les images insérées dans une page html.
Les positions absolues de chaque images sont indiquées dans un fichier css.
Avec ce procédé, l'insertion d'une image dans une page html ne se fait plus avec la balise <img> mais avec une balise <div>  ayant comme nom de "class" celui correspondant à l'image souhaitée et indiqué dans le fichier css.

Il existe sous Debian/Ubuntu, mais également pour Windows et OSX, une commande qui permet de générer un sprite CSS à partir d'un dossier contenant des images.

Cette commande se nomme Glue.

Pour l'installer sous Debian/Ubuntu :

$ sudo apt-get install libjpeg62 libjpeg62-dev zlib1g-dev python-dev python-pip
$ sudo pip install glue

ou

$ sudo apt-get install glue-sprite

Créer un sprite CSS tout simplement

$ glue source_dir output_dir

Par exemple :

$ glue famfamfam_flag_icons/png sprite

Le dossier famfamfam_flag_icons/png contient exactement 247 images PNG et la commande glue va donc créer un unique fichier PNG dans le dossier sprite regroupant toutes les images et un fichier css indiquant les positions de chaque image.

Il est possible de générer également la page html permettant de visualiser le résultat en ajoutant l'option --html.

$ glue famfamfam_flag_icons/png sprite --html
$ ls -1 sprite/
png.css
png.html
png.png

La commande glue génère les fichiers css, html et png en fonction du nom du dossier indiqué en source.
Par défaut, le nom des "class" commence par sprite-leNomDuDossierSource-leNomDuFichier.

La liste complète des options est disponible avec l'option -h.

$ glue -h

Voici un exemple de l'image globale générée à l'aide de la commande glue.

$ w3m http://adresse_du_site

Pour créer un lien symbolique

Avant toute chose, se mettre dans le répertoire dans lequel on souhaite créer le lien :

$ ln  -s  /nom_du_dossier_source  nom_du_lien
 
$ ln  -s  /emplacement/nom_du_fichier_source  nom_du_lien

Ou en utlisant les chemins absolus :

$ ln -s /emplacement/nom_du_fichier_source /emplacement/nom_du_lien

Pour supprimer un lien symbolique

Se positionner au préalable dans le répertoire contenant le lien symbolique à supprimer :

$ cd mon_repertoire
$ sudo unlink nom_du_lien

Ou avec son chemin absolu :

$ unlink /mon_repertoire/nom_du_lien

Sous GNU/Linux, il existe une commande permettant de générer une séquence de nombre.

Il s'agit de la commande seq.

Cette commande s'utilise avec ou sans options et avec un nombre d'arguments allant de 1 à 3.

Un seul argument indique la fin de la séquence.
Deux arguments indiquent le début et la fin de la séquence.
Trois arguments indiquent le début, le pas et la fin de la séquence.

Générer une séquence simple jusqu'à 10 :

$ seq 10
1
2
3
4
5
6
7
8
9
10

Générer une séquence allant de 5 à 10 :

$ seq 5 10
5
6
7
8
9
10

Générer une séquence allant de 1 à 10 avec un pas de 2 :

$ seq 1 2 10
1
3
5
7
9

Par défaut, le séparateur est le retour chariot. L'option -s permet de modifier ce séparateur :

$ seq -s "-" 1 2 10
1-3-5-7-9

L'option -w permet d'avoir une séquence dont les nombres ont le même nombre de caractères :

$ seq -w 0 100
000
001
002
003
004
005
006
007
008
009
...
098
099
100

Parcourir une séquence avec une boucle for :

$ for i in $(seq 0 2 10); do echo $i; done
0
2
4
6
8
10

Il existe une autre méthode permettant de générer une séquence de nombres, ou de lettres :

$ echo {1..5}
1 2 3 4 5

$ echo {5..-4}
5 4 3 2 1 0 -1 -2 -3 -4

$ echo {a..z}
a b c d e f g h i j k l m n o p q r s t u v w x y z

$ echo "Nombre #"{1..7},
Nombre #1, Nombre #2, Nombre #3, Nombre #4, Nombre #5, Nombre #6, Nombre #7,

$ echo {1..5}{x..z}" +" "..."
1x + 1y + 1z + 2x + 2y + 2z + 3x + 3y + 3z + 4x + 4y + 4z + 5x + 5y + 5z + ...

$ echo {001..090}
001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090

$ for j in {1..10}; do echo $j; done
1
2
3
4
5
6
7
8
9
10

Générer toutes les combinaisons possibles pour les immatriculations automobiles françaises :

$ echo  {A..Z}{A..Z}"-"{001..999}"-"{A..Z}{A..Z}

Attention. Cette commande génère un peu moins de 460 millions de données.

Initialisation du tableau A :

$ TAB_A=(25 46 98 3 9 10 21 15 6)

$ echo ${TAB_A[*]}
25 46 98 3 9 10 21 15 6

Initialisation du tableau B contenant les valeurs triées du tableau A :

$ TAB_B=($(echo ${TAB_A[*]} | sed 's/ /\n/g' | sort -n))

$ echo ${TAB_B[*]}
3 6 9 10 15 21 25 46 98

L'astuce consiste à afficher les valeurs du tableau A, puis substituer les espaces entre les différentes valeurs par des retours à la ligne et enfin utiliser la commande sort pour trier les valeurs.

Sous Debian/Ubuntu, il existe une commande qui permet de transformer la console en calculatrice.

Cette commande s'appelle bc.

Pour l'installer :

$ apt-get install bc

Utilisation (en rouge les résultats affichés) :

$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
5*8
40
15+9
24
45/8
5

Sans option, la commande bc exécute les calculs sans les décimales.

Pour afficher les décimales, il suffit d'utiliser l'option -l

$ bc -l
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
5*8
40
9-5
4
6+8
14
40/5
8.00000000000000000000
45/8
5.62500000000000000000

Par défaut, l'option -l affiche 20 chiffres après la virgule.
Pour modifier cette valeur, il suffit d'utiliser la fonction scale.

Il est également possible d'utiliser des variables.

Calculer la valeur de pi :

pi est égal à 4 fois l'arc tangente de 1 radian.

J'ai récemment été confronté à l'erreur "integer expression expected" lors d'un test de deux entiers dans un de mes scripts.

Après plusieurs tests, j'ai finalement compris d'où venait mon erreur.
La variable que je testais ne contenait pas que des chiffres.
Elle n'était donc pas reconnue comme un entier.

Un simple "echo" de ma variable ne faisait pas apparaître tous les caractères de celle-ci.
Pour m'en apercevoir, j'ai dû utiliser la commande "od".

Exemple :

Je vais générer volontairement une erreur au niveau du contenu de la variable à tester en y insérant un caractère spécifique.

$ a=$(echo -e "20\a")
$ echo $a
20

La commande "echo" ne fait pas apparaitre le caractère spécifique contenu dans ma variable.

Je test si ma variable est égale à 20 (par exemple).

$ test $a -eq 20
-bash: test: 20: integer expression expected

J'ai bien une erreur car effectivement ma variable ne peut pas être considérée comme un entier à cause du caractère spécifique qu'elle contient.

La preuve avec la commande "od -c" ...

$ echo -n $a | od -c
0000000   2   0  \a

... le caractère spécifique "\a" apparait bien.

En conclusion, penser à bien vérifier le contenu des variables avec la commande "od" pour voir si des caractères spécifiques ne s'y sont pas insérés.

Pour envoyer un mail via une console Ubuntu :

$ mail -s "sujet du mail" adresse@destinataire.fr

Appuyer sur Entrée, renseigner si besoin une adresse CC, appuyer à nouveau sur Entrée, saisir le texte du message, appuyer une dernière fois sur Entrée puis appuyer sur les touches ctrl+d

Si cette commande est enregistrée dans un script, et si ce script est exécuté automatiquement via une tâche Cron, il n'y a pas de demande concernant l'adresse CC et le texte du message.

Pour envoyer un mail avec une pièce jointe via une console Ubuntu :

Installer le paquet mutt :

$ sudo apt-get install mutt

Envoyer un mail via cette commande :

$ mutt -s "sujet du mail" adresse@destinataire.fr -a /nom_du_fichier
$ mutt -s "Sujet du mail" -a /mon_dossier/mon_fichier -- destinataire@domaine.com

Valider les différentes étapes puis appuyer sur y pour envoyer le mail.

Si cette commande est utilisée dans un script et exécuté automatiquement via une tâche cron, le message est envoyé sans aucune étape supplémentaire à valider

Attention, dans la commande mutt, l'ajout d'une pièce jointe se fait exclusivement en dernier paramètre sans compter l'adresse du destinataire.

Pour envoyer un mail via Telnet :

$ telnet adresse_ip_du_serveur 25
helo votre_nom
mail from:<votreadresse@votredomaine.fr>
rcpt to:<adressedestinataire@domaine.fr>
data
votre message
. (le point est très important, il indique la fin du message)
quit

Il est quand même plus agréable de recevoir un mail en HTML qu'en texte brut.

La commande mail propose l'option -a qui permet de modifier l'en-tête du message.

Comme des exemples valent mieux qu'une grande explication :

$ echo "<html><head></head><body><p>Mon premier mail en <b>HTML</b></p></body></html>" | mail -a "MIME-Version: 1.0" -a "Content-Type: text/html" -s "Message" moi@gmail.lui

C'est quand même vachement simple.

Ecrire du HTML avec la commande echo, c'est sympa, mais un peu chiant si le message est long et pleins de balises.

Qu'à cela ne tienne, on écrit le HTML dans un fichier et on envoie le contenu du fichier par mail.

$ cat testMail.html
<html>
        <head>
        </head>
        <body>
        <h1>Mon Premier Mail En HTML</h1>
        <p>
                Qu'est ce que c'est chouette de pouvoir écrire des mails en HTML
        </p>
        <P>
                On peut y insérer des liens ... <br />
                <a href="http://www.quennec.fr">Mon Site</a> <br />
                <a href="mailto:moi@gmail.lui">Mon mail</a>
        </p>
        </body>
</html>

$ cat testMail.html | mail -a "MIME-Version: 1.0" -a "Content-Type: text/html" -s "Message" moi@gmail.lui

De mieux en mieux.

Bonus :

Je m'envoie très souvent par mail des données issues de requêtes SQL.
Qu'est ce que c'est moche la représentation des tableaux en texte brut.
L'option -H utilisée avec la commande mysql permet de formater le résultat en tableau HTML.

Le top du top.

$ ( echo -n "<html><head></head><body>" ; echo "select col1, col2, col3 from maTable" | mysql -H -h localhost -u user -ppass maBase ; echo "</body></html>" ) | mail -a "MIME-Version: 1.0" -a "Content-Type: text/html" -s "Le Résultat de ma requête" moi@gmail.lui

Petite explication :

On affiche, avec la commande echo, la balise <html><head> </head> et <body> sans retour à la ligne avec l'option -n.
On enchaine avec la requête SQL (echo "select ...") qu'on transmet à mysql avec un "|" et qu'on exécute avec l'option -H pour afficher le résultat au format HTML.
On enchaine avec la commande echo pour afficher la balise fermante </body> et </html>.
On regroupe toutes ces commandes entre parenthèses afin de les envoyer à la commande mail avec un "|".
On indique à la commande mail d'envoyer le contenu du mail au fromat HTML grâce aux paramètres de l'option -a.

La classe, non ?

$ openssl version
OpenSSL 0.9.8o 01 Jun 2010

$ openssl version -a
OpenSSL 0.9.8o 01 Jun 2010
built on: Mon Feb 11 21:27:58 UTC 2013
platform: debian-i386-i686/cmov
options:  bn(64,32) md2(int) rc4(idx,int) des(ptr,risc1,16,long) blowfish(idx)
compiler: gcc -fPIC -DOPENSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DL_ENDIAN -DTERMIO -O3 -march=i686 -Wa,--noexecstack -g -Wall -DOPENSSL_BN_ASM_PART_WORDS -DOPENSSL_IA32_SSE2 -DSHA1_ASM -DMD5_ASM -DRMD160_ASM -DAES_ASM
OPENSSLDIR: "/usr/lib/ssl"
$

$ openssl help
openssl:Error: 'help' is an invalid command.
 
Standard commands
asn1parse      ca             ciphers        crl            crl2pkcs7
dgst           dh             dhparam        dsa            dsaparam
ec             ecparam        enc            engine         errstr
gendh          gendsa         genrsa         nseq           ocsp
passwd         pkcs12         pkcs7          pkcs8          prime
rand           req            rsa            rsautl         s_client
s_server       s_time         sess_id        smime          speed
spkac          verify         version        x509
 
Message Digest commands (see the `dgst' command for more details)
md2            md4            md5            rmd160         sha
sha1
 
Cipher commands (see the `enc' command for more details)
aes-128-cbc    aes-128-ecb    aes-192-cbc    aes-192-ecb    aes-256-cbc
aes-256-ecb    base64         bf             bf-cbc         bf-cfb
bf-ecb         bf-ofb         cast           cast-cbc       cast5-cbc
cast5-cfb      cast5-ecb      cast5-ofb      des            des-cbc
des-cfb        des-ecb        des-ede        des-ede-cbc    des-ede-cfb
des-ede-ofb    des-ede3       des-ede3-cbc   des-ede3-cfb   des-ede3-ofb
des-ofb        des3           desx           rc2            rc2-40-cbc
rc2-64-cbc     rc2-cbc        rc2-cfb        rc2-ecb        rc2-ofb

Comme indiqué, il est possible d'afficher les détails des sous-commandes dgst et enc.

$ openssl dgst -h
unknown option '-h'
options are
-c              to output the digest with separating colons
-d              to output debug info
-hex            output as hex dump
-binary         output in binary form
-sign   file    sign digest using private key in file
-verify file    verify a signature using public key in file
-prverify file  verify a signature using private key in file
-keyform arg    key file format (PEM or ENGINE)
-signature file signature to verify
-binary         output in binary form
-hmac key       create hashed MAC with key
-engine e       use engine e, possibly a hardware device.
-md5            to use the md5 message digest algorithm (default)
-md4            to use the md4 message digest algorithm
-md2            to use the md2 message digest algorithm
-sha1           to use the sha1 message digest algorithm
-sha            to use the sha message digest algorithm
-sha224         to use the sha224 message digest algorithm
-sha256         to use the sha256 message digest algorithm
-sha384         to use the sha384 message digest algorithm
-sha512         to use the sha512 message digest algorithm
-mdc2           to use the mdc2 message digest algorithm
-ripemd160      to use the ripemd160 message digest algorithm

$ openssl enc -h
unknown option '-h'
options are
-in <file>     input file
-out <file>    output file
-pass <arg>    pass phrase source
-e             encrypt
-d             decrypt
-a/-base64     base64 encode/decode, depending on encryption flag
-k             passphrase is the next argument
-kfile         passphrase is the first line of the file argument
-md            the next argument is the md to use to create a key
                 from a passphrase.  One of md2, md5, sha or sha1
-K/-iv         key/iv in hex is the next argument
-[pP]          print the iv/key (then exit if -P)
-bufsize <n>   buffer size
-engine e      use engine e, possibly a hardware device.
Cipher Types
-aes-128-cbc               -aes-128-cfb               -aes-128-cfb1
-aes-128-cfb8              -aes-128-ecb               -aes-128-ofb
-aes-192-cbc               -aes-192-cfb               -aes-192-cfb1
-aes-192-cfb8              -aes-192-ecb               -aes-192-ofb
-aes-256-cbc               -aes-256-cfb               -aes-256-cfb1
-aes-256-cfb8              -aes-256-ecb               -aes-256-ofb
-aes128                    -aes192                    -aes256
-bf                        -bf-cbc                    -bf-cfb
-bf-ecb                    -bf-ofb                    -blowfish
-cast                      -cast-cbc                  -cast5-cbc
-cast5-cfb                 -cast5-ecb                 -cast5-ofb
-des                       -des-cbc                   -des-cfb
-des-cfb1                  -des-cfb8                  -des-ecb
-des-ede                   -des-ede-cbc               -des-ede-cfb
-des-ede-ofb               -des-ede3                  -des-ede3-cbc
-des-ede3-cfb              -des-ede3-cfb1             -des-ede3-cfb8
-des-ede3-ofb              -des-ofb                   -des3
-desx                      -desx-cbc                  -rc2
-rc2-40-cbc                -rc2-64-cbc                -rc2-cbc
-rc2-cfb                   -rc2-ecb                   -rc2-ofb
-rc4                       -rc4-40

L'option speed permet de tester les capacités du sytème pour encrypter des données avec les différents algorithmes de cryptage pendant une période donnée.

$ openssl speed
Doing md2 for 3s on 16 size blocks: 149573 md2's in 2.54s
Doing md2 for 3s on 64 size blocks: 82254 md2's in 2.74s
Doing md2 for 3s on 256 size blocks: 26039 md2's in 2.58s
Doing md2 for 3s on 1024 size blocks: 8149 md2's in 2.93s
Doing md2 for 3s on 8192 size blocks: 1072 md2's in 2.99s
Doing md4 for 3s on 16 size blocks: 3651107 md4's in 2.87s
Doing md4 for 3s on 64 size blocks: 3393515 md4's in 3.00s
Doing md4 for 3s on 256 size blocks: 2340602 md4's in 2.99s
Doing md4 for 3s on 1024 size blocks: 1045777 md4's in 3.00s
Doing md4 for 3s on 8192 size blocks: 167900 md4's in 2.96s
Doing md5 for 3s on 16 size blocks: 3080791 md5's in 2.99s
Doing md5 for 3s on 64 size blocks: 2599131 md5's in 3.00s
Doing md5 for 3s on 256 size blocks: 1577068 md5's in 2.87s
Doing md5 for 3s on 1024 size blocks: 666677 md5's in 2.99s
Doing md5 for 3s on 8192 size blocks: 102011 md5's in 2.99s
...

Pour l'exemple, mon système est capable d'encrypter 666 677 fichiers de 1024 octets en 3s maximum.

Il est possible d'effectuer le test sur un algorithme précis :

$ openssl speed sha256
Doing sha256 for 3s on 16 size blocks: 1626266 sha256's in 2.94s
Doing sha256 for 3s on 64 size blocks: 958515 sha256's in 3.00s
Doing sha256 for 3s on 256 size blocks: 415732 sha256's in 2.99s
Doing sha256 for 3s on 1024 size blocks: 127673 sha256's in 2.99s
Doing sha256 for 3s on 8192 size blocks: 16527 sha256's in 2.87s
OpenSSL 0.9.8o 01 Jun 2010
built on: Mon Feb 11 21:27:58 UTC 2013
options:bn(64,32) md2(int) rc4(idx,int) des(ptr,risc1,16,long) aes(partial) blowfish(idx)
compiler: gcc -fPIC -DOPENSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DL_ENDIAN -DTERMIO -O3 -march=i686 -Wa,--noexecstack -g -Wall -DOPENSSL_BN_ASM_PART_WORDS -DOPENSSL_IA32_SSE2 -DSHA1_ASM -DMD5_ASM -DRMD160_ASM -DAES_ASM
available timing options: TIMES TIMEB HZ=100 [sysconf value]
timing function used: times
The 'numbers' are in 1000s of bytes per second processed.
type             16 bytes     64 bytes    256 bytes   1024 bytes   8192 bytes
sha256            8850.43k    20448.32k    35594.45k    43724.80k    47173.93k

Il est possible également de tester les performances SSL d'un serveur distant :

$ openssl s_time -connect google.fr:443 -www / -new -ssl3
No CIPHER specified
Collecting connection statistics for 30 seconds
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
 
186 connections in 0.20s; 930.00 connections/user sec, bytes read 183024
186 connections in 31 real seconds, 984 bytes read per connection

Il est possible également de simuler un serveur SSL pour effectuer le test de performance :

1 - Générer un certificat pour le serveur simulé (répondre aux questions posées)

$ openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout cert.pem -out cert.pem

2 - Démarrage du serveur simulé

$ openssl s_server -cert cert.pem -www

3 - Dans un autre terminal, tester les performances du serveur simulé

$ openssl s_time -connect localhost:4433 -www / -new -ssl3
No CIPHER specified
Collecting connection statistics for 30 seconds
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333...
33333333333333333333333333
 
3301 connections in 6.07s; 543.82 connections/user sec, bytes read 8506677
3301 connections in 31 real seconds, 2577 bytes read per connection

Pour encoder une chaîne de caractères en base64, utiliser la commande suivante :

$ echo -n "ceci est mon mot de passe" | openssl base64
Y2VjaSBlc3QgbW9uIG1vdCBkZSBwYXNzZQ==

Pour encoder une chaîne de caractères en md5, utiliser la commande suivante :

$ echo -n 'ceci est un mot de passe' | openssl md5
7c1cc4a1a08c9352b50151dfa5d6edf3

Encodage en BASE64

Encoder le contenu d'un fichier sur la sortie standard :

$ cat fic1
systèmes
$ openssl enc -base64 -in fic1
c3lzdMOobWVzCg==

Encoder le contenu d'un fichier et écrire le résultat dans un autre fichier :

$ openssl enc -base64 -in fic1 -out fic1.enc
$ cat fic1.enc
c3lzdMOobWVzCg==

Encoder une chaine de caractères :

$ echo -n "secret" | openssl enc -base64
c2VjcmV0

Ne pas oublier d'ajouter l'option -n à la commande echo sinon un retour chariot sera ajouté à la chaine encodée.

Décoder une chaine de caractères :

$ echo "c2VjcmV0" | openssl enc -base64 -d
secret

Décoder le contenu d'un fichier sur la sortie standard :

$ openssl enc -base64 -in fic1.enc -d
systèmes

Décoder le contenu d'un fichier et écrire le résultat dans un autre fichier :

$ openssl enc -base64 -d -in fic1.enc -out fic1.dec
$ cat fic1.dec
systèmes

Chiffrer un fichier avec un algorithme de chiffrement et un mot de passe

1 - Choisir un algorithme de chiffrement :

$ openssl list-cipher-commands

Voir également la page de manuel de la commande enc.

2 - Chiffrer un fichier avec l'algorithme DES3 et écrire le contenu dans un autre fichier (génération d'un fichier binaire) :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3
enter des-ede3-cbc encryption password:
Verifying - enter des-ede3-cbc encryption password:
$ cat fic1.des3
Salted__d▒j▒G(▒▒r▒d}▒i▒7▒▒▒▒M▒#

Pour le déchiffrage (indication du mot de passe avec l'option -pass) :

$ openssl enc -des3 -d -salt -in fic1.des3 -out file.txt -pass pass:aaaa
$ cat file.txt
systèmes

Chiffrage DES3 mais avec un encodage en BASE64 (pour un envoi par mail par exemple) :

$ openssl enc -des3 -a -salt -in fic1 -out fic1.des3
enter des-ede3-cbc encryption password:
Verifying - enter des-ede3-cbc encryption password:
$ cat fic1.des3
U2FsdGVkX1/Cl8Jr0Aw/3eDLegGPc7meTjWbUQZcNkw=

Pour le déchiffrage :

$ openssl enc -des3 -d -a -salt -in fic1.des3 -out file.txt
enter des-ede3-cbc decryption password:
$ cat file.txt
systèmes

Pour chiffrer un fichier en indiquant le mot de passe dans la ligne de commande (avec l'option -pass) :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3 -pass pass:aaaa

Pour déchiffrer un fichier en indiquant le mot de passe dans un fichier :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3 -pass file:/root/pass

Dans ce cas, seule la première ligne du fichier est utilisée comme mot de passe ou phrase de passe.

Pour afficher la clé de contrôle d'un fichier, il suffit d'utiliser la sous-commande dgst suivi de l'algorithme voulu.

$ openssl dgst -md5 /var/log/syslog
MD5(/var/log/syslog)= 16973fc98773afeea8b0c9c3be3ab677
$ openssl dgst -sha1 /var/log/syslog
SHA1(/var/log/syslog)= 3b0634f6793d5ed1a6260a585ea92d22badc2070

Il existe également une commande propre à chaque algorithme et qui retourne le même résultat :

$ md5sum /var/log/syslog
16973fc98773afeea8b0c9c3be3ab677  /var/log/syslog
$ sha1sum /var/log/syslog
3b0634f6793d5ed1a6260a585ea92d22badc2070  /var/log/syslog

Il est possible également de signer la clé de contrôle d'un fichier à l'aide d'une clé privée afin d'éviter toute modification sans permission :

Génération du fichier syslog.sha1 contenant la clé de contrôle et sécurisé par une clé privée (mykey2.pem).

Cliquez ici pour la génération des clés.

$ openssl dgst -sha1 -sign mykey2.pem -out syslog.sha1 /var/log/syslog

Il ne faut pas oublier de distribuer avec le fichier contenant la clé de contrôle (syslog.sha1) le fichier contenant la clé publique correspondant à la clé privée utilisée (pubkey.pem).

Par contre, ce qu'il ne faut surtout pas faire : distribuer sa clé privée (mykey2.pem).
Il faut la garder bien au chaud dans un endroit bien secret.

Pour la vérification de la clé de contrôle sécurisée, il suffit d'utiliser la commande suivante en y indiquant la clé publique correspondante à la clé privée utilisée lors de la génération de la clé de contrôle sécurisée.

$ openssl dgst -sha1 -verify pubkey.pem -signature syslog.sha1 /var/log/syslog
Verified OK

Pour exporter un certificat PEM au format PKCS#12 :

1 - Générer le certificat au format PEM :

$ openssl req -x509 -nodes -days 365 -subj '/C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com' -newkey rsa:1024 -keyout mycert.pem -out mycert.pem
Generating a 1024 bit RSA private key
...........++++++
............++++++
writing new private key to 'mycert.pem'
-----

2 - Exporter le certificat au format PKCS#12 :

$ openssl pkcs12 -export -out mycert.pfx -in mycert.pem -name "My Certificate"

Renseigner un phrase de passe si nécessaire.

Convertir un certificat PKCS#12 au format PEM :

$ openssl pkcs12 -in mycert.pfx -out mycert2.pem -nodes

Saisir la phrase de passe si nécessaire.

Pour protéger la clé privée à l'aide d'une phrase de passe :

$ openssl pkcs12 -in mycert.pfx -out mycert2.pem

La saisie d'une phrase de passe pour la protection de la clé privée est obligatoire.

La commande suivante affiche toutes les informations du certificat indiqué :

$ openssl x509 -text -in mycert.pem

Qui a émis le certificat ?

$ openssl x509 -noout -in mycert.pem -issuer
issuer= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com

Pour qui a-t-il été émis ?

$ openssl x509 -noout -in mycert.pem -subject
subject= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com

Quelle est sa période de validité ?

$ openssl x509 -noout -in mycert.pem -dates
notBefore=Apr  9 15:28:28 2013 GMT
notAfter=Apr  9 15:28:28 2014 GMT

Toutes les infos précédentes :

$ openssl x509 -noout -in mycert.pem -issuer -subject -dates
issuer= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com
subject= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com
notBefore=Apr  9 15:28:28 2013 GMT
notAfter=Apr  9 15:28:28 2014 GMT

Quelle est sa valeur de hachage ?

$ openssl x509 -noout -in mycert.pem -hash
bf163efd

Quelle est son empreinte MD5 ?

$ openssl x509 -noout -in mycert.pem -fingerprint
SHA1 Fingerprint=C1:CD:DD:29:D1:8D:23:63:6D:3F:71:AD:7E:29:DE:26:FF:D4:11:17

Et à partir d'un certificat d'un site internet (plus de détail openssl : Récupérer un certificat distant)

$ echo | openssl s_client -connect quennec.fr:443 2>&1 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | openssl x509 -text -noout -in -

Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            04:f8:64:c9:8c:bb:f8:c9:6a:fd:3f:b9:b2:42:a0:c5:9c:ab
        Signature Algorithm: sha256WithRSAEncryption
        Issuer: C = US, O = Let's Encrypt, CN = R3
        Validity
            Not Before: Mar 11 07:02:14 2024 GMT
            Not After : Jun  9 07:02:13 2024 GMT
        Subject: CN = quennec.fr
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                RSA Public-Key: (2048 bit)
                Modulus:
                    00:b3:d3:a3:d3:f3:2c:f8:75:d0:71:5f:8f:8d:c4:
                    ...
                    83:f0:69:50:7a:fe:ce:a5:48:64:e1:5a:41:a0:a3:
                    8b:25
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature, Key Encipherment
            X509v3 Extended Key Usage:
                TLS Web Server Authentication, TLS Web Client Authentication
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Subject Key Identifier:
                F0:5D:1D:A5:87:7D:61:1D:AB:74:A4:DE:14:34:F4:D7:3A:52:56:F5
            X509v3 Authority Key Identifier:
                keyid:14:2E:B3:17:B7:58:56:CB:AE:50:09:40:E6:1F:AF:9D:8B:14:C2:C6

            Authority Information Access:
                OCSP - URI:http://r3.o.lencr.org
                CA Issuers - URI:http://r3.i.lencr.org/

            X509v3 Subject Alternative Name:
                DNS:*.quennec.fr, DNS:quennec.fr
            X509v3 Certificate Policies:
                Policy: 2.23.140.1.2.1

            CT Precertificate SCTs:
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : 3B:53:77:75:3E:2D:B9:80:4E:8B:30:5B:06:FE:40:3B:
                                67:D8:4F:C3:F4:C7:BD:00:0D:2D:72:6F:E1:FA:D4:17
                    Timestamp : Mar 11 08:02:14.835 2024 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:46:02:21:00:C6:D5:B3:6D:A4:45:49:25:9B:47:C9:
                                21:20:61:57:67:E9:EB:5A:EB:3F:80:87:3E:EF:41:F6:
                                7C:CD:2C:46:61:02:21:00:D8:27:12:05:AF:5E:9A:0D:
                                91:E9:DA:C5:5A:27:27:25:1D:31:56:A3:6D:4D:26:21:
                                5D:E9:08:B0:5F:1E:5F:88
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : 76:FF:88:3F:0A:B6:FB:95:51:C2:61:CC:F5:87:BA:34:
                                B4:A4:CD:BB:29:DC:68:42:0A:9F:E6:67:4C:5A:3A:74
                    Timestamp : Mar 11 08:02:14.890 2024 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:44:02:20:41:9E:16:0F:BF:95:4F:FA:23:4F:A4:06:
                                ...
                                0F:CB:99:8B:E9:87
    Signature Algorithm: sha256WithRSAEncryption
         0c:dd:53:bc:97:e0:18:39:94:19:fa:28:7c:67:b9:35:a4:ca:
         ...
         04:ee:d9:9

De nos jours, il est conseillé de générer des clés d'une longueur de 2048 bits pour une meilleure sécurité.

Pour un serveur Apache (configuration SSL), il est conseillé de générer des clés sans phrase de passe. Dans le cas contraire, à chaque démarrage du service Apache, la phrase de passe sera demandée.

Avec OpenSSL, la clé privée contient également les informations de la clé publique. Il n'est donc pas nécessaire de générer la clé publique séparément.

Génération d'une clé RSA

Générer une clé simple :

$ openssl genrsa

Générer une clé de 2048 bits et la sauvegarder dans un fichier :

$ openssl genrsa -out mykey.pem 2048

Idem mais avec un cryptage DES3 et une phrase de passe :

$ openssl genrsa -des3 -out mykey.pem 2048

Génération d'une clé publique RSA

$ openssl rsa -in mykey.pem -pubout

Génération d'une clé DSA

Les clés DSA sont utilisées pour la signature d'objets divers.

Le processus de génération se déroule en deux étapes.

Premièrement, générer les paramètres permettant la génération de la clé :

$ openssl dsaparam -out dsaparam.pem 2048

Puis, générer la clé en fonction des paramètres générés ci-dessus :

$ openssl gendsa -des3 -out privkey.pem dsaparam.pem

Une phrase de passe est demandée lors de la génération de la clé DSA.

Pour ne pas avoir de phrase de passe, il suffit de supprimer le paramètre "-des3".

Supprimer la phrase de passe d'une clé privée RSA

Cette commande permet de générer une nouvelle clé privée (newkey.pem) à partir de celle protégée par une phrase de passe (mykey.pem).

$ openssl rsa -in mykey.pem -out newkey.pem

Supprimer la phrase de passe d'un certificat

Pour l'exemple, nous allons créer un certificat crypté (mycert.pem).
Ce fichier (mycert.pem) contiendra la clé privée et le certificat public et sera protégé par une phrase de passe.

$ openssl req -x509 -days 365 -subj '/C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com' -newkey rsa:2048-keyout mycert.pem -out mycert.pem

Le décryptage du certificat se déroule en deux étapes :

Génération de la clé privée à partir du certificat crypté (mycert.pem) vers le nouveau certificat (newcert.pem) :

$ openssl rsa -in mycert.pem -out newcert.pem

Ajout du certificat public dans le nouveau certificat (newcert.pem) :

$ openssl x509 -in mycert.pem >>newcert.pem

Générer une chaine aléatoire de 128 octets encodée en BASE64 :

$ openssl rand -base64 128
2/X1yDvXHdAsDYPBmToCNYFI9Vjhtt4ynVMFCcMfV0jJm+EytH22MEyMs7XV4rbB
6CdddwCD0T3sYu7hCF+Q5Dy72S3LKhZL5cbB8gaf2l+Guv/GCU/oiYTezRwLsAaN
82Sig1bnsyJeI3q67PsLS2yUhWTXiyRxv6/69EL/i30=

Générer une chaine aléatoire de 16 octets encodée en HEX :

$ openssl rand -hex 16
e114c246088060ef2af0b4f4f518b875

Générer un fichier binaire de 1024 octets :

$ openssl rand -out random-data.bin 1024
$ ls -l random-data.bin
-rw-r--r-- 1 root root 1024 Apr 11 18:21 random-data.bin

Générer une chaine aléatoire de 64 octets en utilisant le fichier spécial /dev/urandom et encodée avec la commande openssl en BASE64 :

$ head -c 64 /dev/urandom | openssl enc -base64
3wZ9RXe5bwCKzfEUElHOEJNb97SNN7QfKetKdSfAXvNhaiyCwWBWBEJupPAM2K/Q
6zx09thfwss2ffCGvencfg==

Un petit enchainement de commandes permettant de générer des mots de passe aléatoires :

$ echo $(head -c 32 /dev/urandom | strings -1) | sed 's/[[:space:]]//g'
18EC2Wl1-W

Générer un fichier d'une taille aléatoire comprise entre 0 et 50 Mo à l'aide de la fonction interne $RANDOM (50 Mo = 1024*1024*50):

$ openssl rand -out random-data.txt $(($RANDOM * 1024 * 1024 * 50 / 32767))

La fonction interne $RANDOM génère un nombre aléatoire compris entre 0 et 32767.

Générer un fichier texte de 10Mo

$ openssl rand -hex $((1024*1024*5)) > 10mbFile

1 byte étant égal à 2 caractères hexadécimal, il faut donc penser à diviser par 2 la taille du fichier désiré.

Crypter simplement un mot de passe :

$ openssl passwd MyPasswd
hMTFVzaMHJcaA

Le mot de passe à crypter ne peut excéder 8 caractères.

Ajouter un "salt" au mot de passe à crypter (mot de passe salé ;o) :

$ openssl passwd -salt 12 MyPasswd
12q97u.MW0POc

Dans ce cas précis, le "salt" ne doit pas excéder 2 caractères.

Crypter un mot de passe avec l'algorithme MD5 :

$ openssl passwd -1 MyPasswd
$1$339eK0sF$MCPIqzRKLIWsKG1kXnQiw1

Pas de limitation au niveau de la longueur du mot de passe.

Idem mais en ajoutant un "salt" :

$ openssl passwd -1 -salt 12345678 MyPasswd
$1$12345678$I3fjXxePlXzjbz7gjOzwW0

Dans ce cas, le "salt" ne doit pas excéder 8 caractères.

Idem, mais avec un "salt" généré aléatoirement :

$ openssl passwd -1 -salt $(openssl rand -base64 8) MyPasswd
$1$nSQ9OINA$1a2pvpNHjYo41N0n6FqbQ.

Par défaut, OpenSSL utilise le fichier de configuration "/etc/ssl/openssl.cnf" pour la génération des certificats.

Pour utiliser un fichier de configuration personnalisé, il suffit d'ajouter l'argument "-config {fichier_de_configuration_personnalisé}" à la commande openssl.

Avant de pouvoir générer un certificat, il faut obligatoirement générer une clé RSA ou DSA.

Tout est expliqué ici.

Dans les exemples suivants, la clé privée "mykey.pem" sera utilisée pour la génération des certificats.

Création d'une autorité de certification (permettant de signer les demandes de certificats)

Pour générer ses propres certificats, sans passer par une autorité de certification externe :

$ openssl req -new -x509 -key mykey.pem -out ca.crt -days 1095

On indique pour le paramètre "-out" le nom de l'autorité de certification à générer puis la durée de validité en jour avec le paramètre "-days"
Cette autorité de certification permettra de signer les futures demandes de certificats auto-signés.
Cette génération est à faire une seule fois.
Le Common Name à indiquer ne doit correspondre à aucun nom de domaine ayant besoin d'un certificat.
Cette autorité de certification peut-être mis à disposition du public afin d'être intégré dans les différents navigateurs comme étant une autorité de certification reconnue.

Création d'une demande de certificat

Une demande de certificat peut être utilisée sur un site comme http://www.cacert.org/ afin d'obtenir un certificat reconnu par une autorité de certification ou afin d'être signé par le certificat ca.crt généré ci-dessus.

$ openssl req -new -key mykey.pem -out mondomaine.csr

La demande "cert.csr" peut ensuite être transmise à l'autorité de certification qui fournira par la suite le certificat résultant.
Le Common Name à indiquer doit correspondre au nom de domaine pour lequel vous souhaitez un certificat.

Génération du certificat final

A l'aide du certificat de certification généré au tout début (ca.crt), nous allons générer le certificat correspondant à la demande (mondomain.csr) générée ci-dessus.

$ openssl x509 -req -in mondomaine.csr -out mondomaine.pem -CA ca.crt -CAkey mykey.pem -CAcreateserial -CAserial ca.srl -days 90

L'option -CAcreateserial est à utiliser seulement la première fois.
Ceci va générer un identifiant (ca.srl).
Lors des prochaines certification (pour renouvellement ou pour d'autres domaines) l'identifiant, contenu dans le fichier ca.srl, sera incrémenté à l'aide de l'option -CAserial ca.srl

Avec Apache, il est possible d'utiliser des fichiers d'authentification pour protéger des répertoires web.

Pour générer ces fichiers d'authentification, il est nécessaire d'utiliser la commande htdigest.

La commande htdigest inscrit les données d'authentification obligatoirement dans un fichier.

Pour afficher ces mêmes informations mais uniquement sur la sortie standard (pour x raisons) il est nécessaire d'utiliser la commande openssl.

Voici un script qui permet de saisir les informations d'authentification et affiche le résultat sur la sortie standard :

$ cat htdigest.sh
#!/bin/bash
 
echo "Creation d'une authentification Apache"
echo "-----------------------------------------------"
 
read -p "Votre nom : " NAME
read -p "Apache AuthName: " AUTHNAME
read -s -p "Votre mot de passe : " PASS; echo
 
printf "%s:%s:%s\n" \
  "$NAME" \
  "$AUTHNAME" \
  $(printf "${NAME}:${AUTHNAME}:${PASS}" | openssl dgst -md5)
 
exit 0

Exécution du script :

$ ./htdigest.sh
Creation d'une authentification Apache
-----------------------------------------------
Votre nom : toto
Apache AuthName: monSite
Votre mot de passe :
toto:monSite:ffdcd4a53fb7dd716ec2d017e93bc563

OpenSSL possède une sous-commande qui permet de tester si le nombre passé en paramètre est un nombre premier.

$ openssl prime 2
2 is prime
$ openssl prime 3
3 is prime
$ openssl prime 4
4 is not prime
$ openssl prime 11
B is prime

Le résultat est retourné sous forme hexadécimale.

En ajoutant l'option "-hex", il est possible de tester une chaine hexadécimale :

$ openssl prime 449
1C1 is prime

La représentation hexadécimale du nombre 449 est donc 1C1

$ openssl prime -hex 1C1
1C1 is prime

En prime, un petit enchainement de commandes permettant d'obtenir la liste des 168 nombres premiers inférieurs à 1000.

$ for i in $(seq 0 1000); do \
result=$(openssl prime $i) \
echo $result | grep  -q "is prime$" \
if [[ $? -eq 0 ]]; then \
echo $i \
fi
done | column -x
2       3       5       7       11      13      17      19      23      29      31      37      41      43      47      53
59      61      67      71      73      79      83      89      97      101     103     107     109     113     127     131
137     139     149     151     157     163     167     173     179     181     191     193     197     199     211     223
227     229     233     239     241     251     257     263     269     271     277     281     283     293     307     311
313     317     331     337     347     349     353     359     367     373     379     383     389     397     401     409
419     421     431     433     439     443     449     457     461     463     467     479     487     491     499     503
509     521     523     541     547     557     563     569     571     577     587     593     599     601     607     613
617     619     631     641     643     647     653     659     661     673     677     683     691     701     709     719
727     733     739     743     751     757     761     769     773     787     797     809     811     821     823     827
829     839     853     857     859     863     877     881     883     887     907     911     919     929     937     941
947     953     967     971     977     983     991     997

Le script suivant permet de récupérer le contenu du certificat du site indiqué en paramètre (le port est facultatif, par défaut le port 443 est utilisé).

$ cat getCertificates.sh
#!/bin/sh
 
HOST=$1
PORT=${2:-443}
 
echo | \
openssl s_client -connect ${HOST}:${PORT} 2>&1 | \
sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p'
 
exit 0
$

On l'exécute en lui indiquant en paramètre le nom du site et le port (facultatif).

$ ./getCertificates.sh youtube.fr 443
-----BEGIN CERTIFICATE-----
MIIF/DCCBWWgAwIBAgIKKZeNqAABAACBuDANBgkqhkiG9w0BAQUFADBGMQswCQYD
VQQGEwJVUzETMBEGA1UEChMKR29vZ2xlIEluYzEiMCAGA1UEAxMZR29vZ2xlIElu
...
Xl7/nc7F5HgE0c+bGsAYuCoYBsDNYs8/AUTnSTeih8U9mSRRDFb9NxMkQqUWPSXO
sh4FktaXQJBJRi4IAfuUDk28c9A0Bv1ygO3FqiSu6QJ3axESCoGmF26XqDwvJtFq
-----END CERTIFICATE-----

et le certificat s'affiche à l'écran.

Voir également CURL: Afficher les informations SSL d'un domaine

Voir également openssl : Extraire les informations d'un certificat

Voici une commande permettant de générer, en une seule fois, une paire de clé (publique/privée) et une demande de certificat CSR afin d'obtenir, auprès de cacert.org par exemple, un certificat X509 associant votre clé publique générée et le nom de domaine que vous souhaitez protéger avec TLS.

$ openssl req -nodes -newkey rsa:2048 -sha256 -keyout ma_cle.key -out ma_demande.csr

Avec cette commande, nous allons créer une clé RSA de 2048 bits.

Les autres arguments de la ligne de commandes indiquent que la clé privée sera stockée dans le fichier ma_cle.key et la demande CSR sera stockée dans le fichier ma_demande.csr.

Une série de questions vous est posée.
Les deux questions les plus importantes sont celles correspondantes au common name et à l'adresse mail de contact.

Ne renseignez surtout pas de mot de passe sinon il vous sera demandé à chaque démarrage du serveur web.
Un peu contraignant lors de tâches de maintenance automatisées.

Pour vérifier la demande CSR:

$ openssl req -text -noout -verify -in ma_demande.csr

Reste à transmettre à l'autorité de certification (cacert.org par exemple - certificat gratuit) la demande CSR.

Il est possible d'utiliser la commande openssl pour se connecter à un serveur STMP en utilisant la sécurité TLS,

Dans l'exemple suivant, l'option -CAfile /etc/ssl/certs/ca-certificates.crt permet d'indiquer l'autorité de certification dans le cas d'un certificat auto signé.

# openssl s_client -starttls smtp -crlf -CAfile /etc/ssl/certs/ca-certificates.crt -connect smtp.server.fr:25

CONNECTED(00000003)
depth=0 CN = localhost.localdomain
verify return:1
---
Certificate chain
 0 s:/CN=localhost.localdomain
   i:/CN=localhost.localdomain
---
Server certificate
-----BEGIN CERTIFICATE-----
MIIBtzCCASACCQCupdgFIYzFVDANBgkqhkiG9w0BAQUFADAgMR4w
b2NhbGhvaW4wHhcNMTEwNDI2MTkxMDM1WhcNMjEwNDIzMTkx
MDM1WjAgMR4wHAYDVQQDExVsb2NhbGhvc3QubG9jYWxkb21ha
hvcNAQEBBQADgY0AMIGJZS3OcCHjbQNa++F/J4WGFk6r7ICl9Ls0
ybT+1CzbFG1xE71NeRhbHkLGigZa5422afsqq/b3LBIpMX17B/gtuo+
QKRckuo+20BUqHFye7ZAVXSsw+bqmm9D0vB4uw9IwyE75jEAqU1
QX7RAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAe1iHUXoGSTj3Fv3
2Yg1EFtNm/RSYxdHV8jY6W6CtwNatN+EQqmWlfhtOSCWgXriUjX5
E4uEocf6x/vDrVkpU11u+0xDUYshmrLyk2nmX6wbopwQttAE9PLw
ahQBiuj+sz38OW8=
-----END CERTIFICATE-----
subject=/CN=localhost.localdomain
issuer=/CN=localhost.localdomain
---
No client certificate CA names sent
---
SSL handshake has read 1021 bytes and written 456 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384
Server public key is 1024 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES256-GCM-SHA384
    Session-ID: D2A784125E749B8C74015978412B9B6E47DDA37BFB83FD4FEE8E6ED21BE79C92
    Session-ID-ctx:
    Master-Key: 631649B5A6A2F5272137C421AFB2F2E86CD483ED2FE8099BCDC9068A11EE7087F
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    Start Time: 1478726847
    Timeout   : 300 (sec)
    Verify return code: 0 (ok)
---
250 DSN
mail from: one@mail.fr
250 2.1.0 Ok
rcpt to: two@mail.fr
250 2.1.5 Ok
data
354 End data with <CR><LF>.<CR><LF>
from: one@mail.fr
to: two@mail.fr
subject: send mail with TLS connection

Voluptatem veniam quasi nisi voluptatum incidunt autem. Sed provident minus ab temporibus sed. Quia blanditiis consequatur assumenda aut hic. Minima cum qui quidem dicta velit quod voluptas. Dolorem aliquam animi consequatur.

Minima alias sint libero et. Et et in ratione similique iusto aut consectetur. Sed voluptatibus modi fuga ut quibusdam ut consectetur voluptas.
.
250 2.0.0 Ok: queued as 145A53700157
quit
221 2.0.0 Bye
closed

Très utile pour tester un serveur STMP

Avant toute chose, ne pas monter le cd-rom

Créer une image ISO avec la commande dd :

$ dd if=/dev/cdrom of=/tmp/monImage.iso

Créer une image ISO avec la commande cat :

$ cat /dev/cdrom > /tmp/monImage.iso

Pour vérifier le contenu de l'image créée :

$ mkdir /media/iso
$ sudo mount -o loop -t iso9660 /tmp/monImage.iso /media/iso/

Installer la boite à outils

$ sudo apt-get install dosfstools

Lister les supports de stockage

$ sudo fdisk -l

Formater en FAT 12 OU 16

$ mkfs.vfat /dev/sdb1

Formater en FAT 32

$ mkfs.vfat -F 32 -n nom_de_ma_cle_usb /dev/sdb1

Pour formater un support de stockage, celui-ci ne doit pas être monté.

$ umount /media/ma_cle_usb

Pour les autres formats :

1. mkfs.bfs     
2. mkfs.ext2    
3. mkfs.ext4    
4. mkfs.minix   
5. mkfs.ntfs
6. mkfs.cramfs  
7. mkfs.ext3    
8. mkfs.ext4dev
9. mkfs.msdos   
10. mkfs.vfat

Formater en NTFS

$ apt-get install ntfs-3g ntfsprogs

$ mkntfs /dev/sde1

Afficher le format/type exact d'une partition

La commande fdisk -l ne permet pas de connaitre le type exact d'une partition.

$ fdisk -l
 
Disk /dev/sda: 1000.2 GB, 1000204886016 bytes
255 heads, 63 sectors/track, 121601 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk identifier: 0x00000000
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          66      524288   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              66      121601   976235712   8e  Linux LVM
 
Disk /dev/sdb: 1500.3 GB, 1500299395072 bytes
255 heads, 63 sectors/track, 182401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00026d5d
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1      182401  1465136001   83  Linux
 
Disk /dev/sdc: 160.0 GB, 160041885696 bytes
255 heads, 63 sectors/track, 19457 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x0008ef40
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sdc1               1       19457   156288321   83  Linux
 
Disk /dev/sdd: 2000.4 GB, 2000396746752 bytes
255 heads, 63 sectors/track, 243201 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00101aa1
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sdd1               1      243201  1953512001   83  Linux
 
Disk /dev/sde: 80.0 GB, 80032038912 bytes
255 heads, 63 sectors/track, 9730 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x000f2c13
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sde1               1        9730    78156193+   b  W95 FAT32

La commande blkid est beaucoup plus précise

$ blkid
/dev/sda1: UUID="cd34d37b-b73c-4ee4-820c-c8006043518a" SEC_TYPE="ext2" TYPE="ext3"
/dev/sda2: UUID="BVYNlC-AQG0-oDe9-I4zu-xVzp-RdV3-W1Fegr" TYPE="LVM2_member"
/dev/sdb1: UUID="a6ea6463-e289-4bbe-afba-572f876497da" TYPE="ext4"
/dev/sdc1: UUID="1a6c5464-6ae1-4205-97c5-edae82649198" SEC_TYPE="ext2" TYPE="ext3"
/dev/sdd1: UUID="8ea1a0ee-c21c-4892-bdc9-bda6186ebd98" TYPE="ext4"
/dev/sde1: UUID="4961B8D578F1B234" TYPE="ntfs"

Sur les distributions type Debian, le programme genisoimage permet de créer une image ISO d'un fichier ou d'un répertoire complet.

Pré-requis

Installer le programme genisoimage

$ apt-get install genisoimage

Exemple

$ genisoimage -r -v -J -o /tmp/image.iso /mon_repertoire

=> Création du fichier /tmp/image.iso contenant toutes les données de /mon_repertoire

Détail des options utilisées

-r : Pour permettre à tous les utilisateurs d'avoir accès aux données du disque, même si l'image est créée en tant qu'administrateur.
-v : Permet d'activer le mode verbeux.
-J : Supporte les noms longs de fichiers.
-o : Permet de spécifier le nom du fichier ISO

Sur les distributions type Debian, le programme wodim permet de graver une image ISO sur un disque.

Pré-requis

Installer le programme wodim

$ apt-get install wodim

Connaitre l'identifiant du graveur

$ wodim --devices
wodim: Overview of accessible drives (1 found) :
-------------------------------------------------------------------------
 0  dev='/dev/scd0'     rwrw-- : 'TSSTcorp' 'CDW/DVD TS-H492B'
-------------------------------------------------------------------------
$

Exemple

Si besoin, créer une image ISO (voir détail ici) :

$ genisoimage -r -v -J -o /tmp/image.iso /mon_repertoire

Puis graver l'image sur un disque :

$ wodim -v -speed=4 dev=/dev/scd0 -data /tmp/image.iso

Détail des options utilisées :

-v : Pour activer le mode verbeux
-speed : Pour indiquer la vitesse de gravure
dev=... : Pour indiquer le fichier identifiant du graveur
-data : Pour indiquer l'image à graver

Pour effacer rapidement un disque RW :

$ wodim -v -speed=4 -force dev=/dev/scd0 blank=fast

Pour effacer complètement un disque RW :

$ wodim -v -speed=4 -force dev=/dev/scd0 blank=all

$ sudo syslinux -sf /dev/sdb1

A remplacer par le bon périphérique

Pour obtenir la liste des périphériques :

$ sudo fdisk -l

Utilisation de la commande ssh-copy-id :

Principe : Copier la clé contenu dans le fichier ~/.ssh/id_rsa.pub dans le fichier ~/.ssh/authorized_keys d'un host distant (ici, 192.168.0.101)

Voir également  "Connexion à une machine distante (ssh, scp, sftp) sans saisir le mot de passe"

$ cd ~/.ssh
$ ls
authorized_keys  id_rsa  id_rsa.pub  known_hosts
$ ssh-copy-id -i id_rsa.pub root@192.168.0.101
root@192.168.0.101's password:#Saisir ici le mot de passe
Now try logging into the machine, with "ssh 'root@192.168.0.101'", and check in:
 
  ~/.ssh/authorized_keys
 
to make sure we haven't added extra keys that you weren't expecting.
 
$

Sécuriser la connexion ssh par clé en associant une adresse IP/un nom de host à la clé RSA dans le fichier ~/.ssh/authorized_keys

Pour plus de sécurité il est possible d'associer une adresse IP et/ou un nom de host à une clé RSA afin d'éviter l'utilisation de cette clé sur une autre machine.

Exemple d'une clé RSA

$ cat ~/.ssh/authorized_keys
ssh-rsa iMEyIOc6TAw3+w/RBkHXbabKYgI1Y4EDEifBdcmGYMe8MshE6D27NouR1hdFyvsT
LLs+DCALHJNxkitS31HO7QlWAX9YRC1D47neCk29E1SCmG9CeWNyztgAmgI91FD6
yWtWSD3MOW27/rC+CxdXoVNSFNVJ+wKuK5QGUMlAMm+nFJi6evlVLBhGKb5LVNQ6
nszYteN5dpp/asSAU+kHyQsNJPyz1m/w8KZujYpkpV3mJh4GYvBiz2A+JWo/FRbo
3LSdFiVxt9V1rqfrYSXFcHS4jky9HSH/c9b9d1iop6lPBShlLjAf2zpQYfU5Ra7u
TQsO3D1z+dZ8NXARJ4WWHkWyIEyN67q4uKMehscDGYKy3hcyRTlJ0sw0bokNMf99
oGcmN5KKasLvUsIfMyNbSC8bcYdsOb+06QDyHHE9h2aYcoBCgvX4zhkAoDSeMsK2
Bg7h2PdV5S5bLPr/hjLgNky6u9TCbDIJOInqJZwk4/gqPOMbffuKeiN1K2lzyrfk
mX3Nnwm/ivb0IBEYLQs4GM8WyamlJtlj5K32mJfflFwnbj5+dGQhjRZ/jJ1D9PsL
U441033CepoXDIf2cV3I34aZ2V7YxEgsk4rRVEX0mGCYezBn1f4IumQ1Il9ixrEf
FktHyk6kfviQC8wOTRsABiH79KSIIqc3cp9zbOSbn+4= root@ma_machine

Exemple d'une clé RSA avec association d'une adresse IP et/ou d'un nom de host

$ cat ~/.ssh/authorized_keys
from="192.168.1.1,ma_machine.mon_domaine.com" ssh-rsa iMEyIOc6TAw3+w/RBkHXbabKYgI1Y4EDEifBdcmGYMe8MshE6D27NouR1hdFyvsT
LLs+DCALHJNxkitS31HO7QlWAX9YRC1D47neCk29E1SCmG9CeWNyztgAmgI91FD6
yWtWSD3MOW27/rC+CxdXoVNSFNVJ+wKuK5QGUMlAMm+nFJi6evlVLBhGKb5LVNQ6
nszYteN5dpp/asSAU+kHyQsNJPyz1m/w8KZujYpkpV3mJh4GYvBiz2A+JWo/FRbo
3LSdFiVxt9V1rqfrYSXFcHS4jky9HSH/c9b9d1iop6lPBShlLjAf2zpQYfU5Ra7u
TQsO3D1z+dZ8NXARJ4WWHkWyIEyN67q4uKMehscDGYKy3hcyRTlJ0sw0bokNMf99
oGcmN5KKasLvUsIfMyNbSC8bcYdsOb+06QDyHHE9h2aYcoBCgvX4zhkAoDSeMsK2
Bg7h2PdV5S5bLPr/hjLgNky6u9TCbDIJOInqJZwk4/gqPOMbffuKeiN1K2lzyrfk
mX3Nnwm/ivb0IBEYLQs4GM8WyamlJtlj5K32mJfflFwnbj5+dGQhjRZ/jJ1D9PsL
U441033CepoXDIf2cV3I34aZ2V7YxEgsk4rRVEX0mGCYezBn1f4IumQ1Il9ixrEf
FktHyk6kfviQC8wOTRsABiH79KSIIqc3cp9zbOSbn+4= root@ma_machine

Les différentes valeurs doivent être séparées par une virgule.
Le point d'interrogation permet d'indiquer un plage d'adresses IP (from="192.168.0.?").
L'astérisque permet d'indiquer tous les sous-domaines d'un domaine (from="*.mon_domaine.com").
Il est possible d'exclure en ajoutant un point d'exclamation avant (from="!autre_domaine.com").

L'outil ssh-keygen permet d'effectuer différentes manipulations sur les clés SSH.

Générer une clé SSH de type RSA:

$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/xxxx/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/xxxx/.ssh/id_rsa
Your public key has been saved in /home/xxxx/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:LSPtPiOIKudk4CuQzD6MdlyJQh3RQc+xvYJTgHWPQ6E xxxx@yyyy
The key's randomart image is:
+---[RSA 3072]----+
|   .*=.=.        |
|   o .B *        |
|  . .E B o       |
| . .  o....      |
|=.  .oo.S..      |
|+= . o.o.o       |
|=.=...  .        |
|+B+o. ..o        |
|==+    ..o       |
+----[SHA256]-----+

Le contenu de la clé privée (attention, celui-ci ne doit jamais être partagé)

$ cat .ssh/id_rsa
-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
NhAAAAAwEAAQAAAYEApgXls7gw98Hr5Q05qB5Dlg7Agzomlm/8Q7k3yawjwgJP5+SNZ0pj
edSm8PnQZnYP00vN8KPLjTWfBo39HRJpylPq8abRs8LeIqAwKOY+7bTGEvcxACvIRd8w/U
wV6XYHVH5w9vT4gW9Lb9J1AOAcaEEcGNUwCPHiqoHa6eA2kg6e36F1ZE9DUYGw2altST7P
smWvFSPMx3eXJLpbsgaGHhzvI6cwpXkbeDILoHjws1GDcmI7X3zya46p3Zrt8cagRi3lKP
cje3xfKoLMLb3zauB8tb7pW41VP4KoplgT7r4bxd/4EkQcG9bv9AoAb7avp6f0ulBvAEw9
...
UZA+eKidhEz4we4ivxwb+GSVbCVBWkWZvEIX5+5tVPJaxi18K6GC+Zw4lOlYe4nwFtDQz8
5KI7LRQSDZrNtNiMJ/R/dOXV9l74ixlafKM1uMd5x23RmSEVzGap/tgwqam+KSeHuKN+zR
O3XW2hyx1TruD3JEcN2/hVUh5bM1q9YcSfrjd/bzFL+tQIs1t9N5TQOn/EYnLHlcsUzhLq
xWp1/EulMM4qMAAAAPcm9uYW5AUEFTUE8wMDg2AQIDBA==
-----END OPENSSH PRIVATE KEY-----

Le contenu de la clé privée (celui ci peut-être partagé avec n'importe qui)

$ cat .ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCmBeWzuDD3wevlDTmoHkOWDsCDOiaWb/xDuTfJrCPCAk/n5I1nSmN51Kbw+dBmdg/TS83wo8uNNZ8Gjf0dEmnKU+rxptGzwt4ioDAo5j7ttMYS9zEAK8hF3zD9TBXpdgdUfnD29PiBb0tv0nUA4BxoQRwY1TAI8eKqgdrp4DaSDp7foXVkT0NRgbDZqW1JPs+yZa8VI8zHd5ckuluyBoYeHO8jpzCleRt4MgugePCzUYNyYjtffPJrjqndmu3xxqBGLeUo9yN7fF8qgswtvfNq4Hy1vulbjVU/gqimWBPuvhvF3/gSRBwb1u/0CgBvtq+np/S6UG8ATD2mBS+mqB687hKB7BzY+SAWgOMfloavV7ms609c5/nQR2UwlQuHDo79Zz3uqbwVh02hRdomZC7Q9Elte9hUgdz5DZOMiC1lOh5Zj+X/POe+Rg/G8eXrbXO0IlaW4MZjqQTG8U7gLrbtkHYxljphI/eGSYnTo5Qmu77EHy0EAe/DE7HGGt0hOEU= xxxx@yyyy

Afficher le fingerprint d'une clé SSH (peu importe la clé fournie, privée ou publique, c'est toujours le fingerprint de la clé publique qui est affiché)

$ ssh-keygen -l -f .ssh/id_rsa
3072 SHA256:LSPtPiOIKudk4CuQzD6MdlyJQh3RQc+xvYJTgHWPQ6E xxxx@yyyy(RSA)
$ ssh-keygen -l -f .ssh/id_rsa.pub
3072 SHA256:LSPtPiOIKudk4CuQzD6MdlyJQh3RQc+xvYJTgHWPQ6E xxxx@yyyy(RSA)

Par défaut le fingerprint est affiché avec le hash SHA256, pour l'afficher avec le hash MD5, il suffit d'ajouter l'option -E avec le paramètre MD5

$ ssh-keygen -l -f .ssh/id_rsa.pub -E md5
3072 MD5:29:3c:60:2a:d2:49:20:82:12:c4:c5:e3:f0:95:2c:b3 xxxx@yyyy(RSA)

Afficher le fingerprint en représentation ASCII

$ ssh-keygen -l -f .ssh/id_rsa.pub -E md5 -v
3072 MD5:29:3c:60:2a:d2:49:20:82:12:c4:c5:e3:f0:95:2c:b3 xxxx@yyyy(RSA)
+---[RSA 3072]----+
|Ooo.. .          |
|=+ = +           |
|. = O            |
| o E o   .       |
|o +   + S        |
|..     o         |
|                 |
|                 |
|                 |
+------[MD5]------+

Recalculer la clé publique d'une clé privée

$ ssh-keygen -y -f .ssh/id_rsa
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCmBeWzuDD3wevlDTmoHkOWDsCDOiaWb/xDuTfJrCPCAk/n5I1nSmN51Kbw+dBmdg/TS83wo8uNNZ8Gjf0dEmnKU+rxptGzwt4ioDAo5j7ttMYS9zEAK8hF3zD9TBXpdgdUfnD29PiBb0tv0nUA4BxoQRwY1TAI8eKqgdrp4DaSDp7foXVkT0NRgbDZqW1JPs+yZa8VI8zHd5ckuluyBoYeHO8jpzCleRt4MgugePCzUYNyYjtffPJrjqndmu3xxqBGLeUo9yN7fF8qgswtvfNq4Hy1vulbjVU/gqimWBPuvhvF3/gSRBwb1u/0CgBvtq+np/S6UG8ATD2mBS+mqB687hKB7BzY+SAWgOMfloavV7ms609c5/nQR2UwlQuHDo79Zz3uqbwVh02hRdomZC7Q9Elte9hUgdz5DZOMiC1lOh5Zj+X/POe+Rg/G8eXrbXO0IlaW4MZjqQTG8U7gLrbtkHYxljphI/eGSYnTo5Qmu77EHy0EAe/DE7HGGt0hOEU= xxxx@yyyy

La preuve que la commande ci-dessus retourne le même résultat que la clé publique d'origine

$ ssh-keygen -y -f .ssh/id_rsa | diff .ssh/id_rsa.pub -
(le retour de la commande est vide indiquant que les contenus sont identiques)

Manipuler le fichier "known_hosts"

Rechercher dans le fichier "known_hosts" l'entrée correspondante à un host particulier

$ ssh-keygen -H -F 192.168.1.101

$ ssh-keygen -H -F machine.domaine.com

Supprimer du fichier "known_hosts" l'entrée correspondante à un host particulier

$ ssh-keygen -R 192.168.1.101

$ ssh-keygen -R machine.domaine.com

Obtenir la clé d'un host encodée en base64

$ ssh-keyscan -t rsa,dsa 192.168.1.100

$ ssh-keyscan -t rsa,dsa machine.domaine.com

Le commande linuxlogo permet d'afficher dans la console de jolis logos colorisés en caractères ASCII.

Pour l'installer :

$ sudo apt-get install linuxlogo

Le manuel de la commande : 

$ man linuxlogo

Exécution :

$ linuxlogo

Avec l'option -l, seul le logo est affiché

$ linuxlogo -l

Avec l'option -u, les informations uptime sont affichées.

$ linuxlogo -u

Avec l'option -y, les informations load average sont affichées.

$ linuxlogo -y

L'option -L list permet d'affiher la liste complète des logos disponibles.

$ linuxlogo -L list

Available Built-in Logos:

Pour afficher le logo souhaité :

$ linuxlogo -L numéro

Tous les logos disponible ICI.

La commande banner permet d'afficher dans la console un message de 10 caractères maximum avec uniquement des caractères "#".

Pour l'installer :

$ sudo apt-get install sysvbanner

Et ça donne ceci :

$ banner Linux

Il existe également la commande printerbanner mais l'affichage se fait verticalement.

decrypt.py est un programme écrit en python qui anime la console en lui donnant un effet "Matrix"

L'animation générée est vraiment très sympa.

Le script peut être téléchargé ICI

Sinon, en ligne de commande :

Avec git :

$ git clone https://github.com/jtwaleson/decrypt.git

ou en téléchargeant le fichier ZIP :

$ wget https://github.com/jtwaleson/decrypt/archive/master.zip
$ unzip master.zip

Copier le script decrypt.py dans le répertoire /usr/local/bin

$ cp decrypt.py /usr/local/bin/

Exécution :

Afficher le contenu d'un fichier

$ cat decrypt.py | decrypt.py

Voir la vidéo : http://youtu.be/xI3JQg5BVtI

Lister le contenu d'un répertoire

$ ls -l | decrypt.py

Voir la vidéo : http://youtu.be/QnljP35j5EQ

Avec une image en ASCII (convertie avec la commande jp2a)

$ jp2a erreur404.jpg | decrypt.py

Voir la vidéo : http://youtu.be/8CAtUdl4Q5I

Pour créer une sauvegarde différentielle

$ rdiff-backup /repertoire_a_sauvegarder /repertoire_de_sauvegarde

Sauvegarder sur une machine distante via    SSH

Remplacer

• /repertoire_de_sauvegarde

Par

• <utilisateur>@<adresse_ip_de_la_machine_distante>::<repertoire_de_sauvegarde_sur_la_machine_distante>

Pour supprimer une sauvegarde différentielle

$ rdiff-backup --remove-older-than 1W --force /repertoire_de_sauvegarde

Ici on enlève toutes les modifications enregistrées vieilles de plus d'une semaine. On peut mettre D(ay),W(eek), M(onth)et Y(ear).

S'il y a plusieurs sauvegardes à supprimer, la commande échoue. C'est pourquoi il faut rajouter le paramètre –forcepour ne pas prendre cette erreur en compte et que rdiff-backup effectue bien ce qu'on lui demande.

Pour afficher l'état d'une sauvegarde différentielle en liste simple

$ rdiff-backup -l /repertoire_de_sauvegarde

Pour afficher l'état d'une sauvegarde différentielle en tableau avec la taille de chaque incrément:

$ rdiff-backup --list-increment-size /repertoire_de_la_sauvegarde

Pour enregistrer le résultat dans un fichier :

$ rdiff-backup --list-increment-size /repertoire_de_la_sauvegarde > /repertoire/etat_sauvegarde.txt

Voir les statistiques des sauvegardes

$ rdiff-backup-statistics /repertoire_de_sauvegarde

Pour restaurer une sauvegarde différentielle

$ rdiff-backup -r now /repertoire_de_sauvegarde /repertoire_de_restauration

L'option -r nowpermet de remettre la version de la sauvegarde la plus récente. On peut remonter dans les sauvegardes, par exemple remettre le repertoire d'il y a 3 jours avec l'option -r 3D.

Rdiff-backup fait une replication parfaite des fichiers dans leur dernière version. Ainsi pour restaurer des données, il suffit de faire

$ cp -a /backupDir /restoredDir

Pour connaitre la version du noyau en cours d'utilisation, saisir dans une console la commande suivante :

$ sudo uname -a
Linux vm-apache 2.6.32-14-pve #1 SMP Tue Aug 21 08:24:37 CEST 2012 i686 GNU/Linux
 

$ cat /etc/os-release

Sur un système GNU/Linux, une locale qui n'est pas correctement configurée entraîne ce genre de message d'erreur :

-bash: warning: setlocale: LC_CTYPE: cannot change locale (en_GB.UTF-8)
-bash: warning: setlocale: LC_CTYPE: cannot change locale (en_GB.UTF-8)

Pour corriger cette erreur, il suffit d'exécuter les 2 commandes suivantes :

$ sudo locale-gen en_GB.UTF-8
$ sudo update-locale LANG=en_GB.UTF-8

Une simple déconnexion / reconnexion suffit pour ne plus avoir le problème.

Sous Linux, la vérification des disques s'effectue avec la commande fsck.

L'utilisation de cette commande nécessite que la partition à controler soit démontée.

Lister les disques et partitions du système

$ fdisk -l
 
Disk /dev/sdb: 1500.3 GB, 1500299395072 bytes
255 heads, 63 sectors/track, 182401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00026d5d
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1               1      182401  1465136001   83  Linux

Identifier le type de la partition

$ blkid
/dev/sdb1: UUID="a6ea6463-e289-4bbe-afba-572f876497da" TYPE="ext4"

Identifier le point de montage de la partition

$ mount
/dev/sdb1 on /volume1 type ext4 (rw)

Démonter la partition et lancer la vérification

$ umount /volume1
$ fsck -t ext4 /dev/sdb1

Si le démontage de la partition n'est pas possible, il existe 2 solutions permettant la vérification des disques.

1 - Redémarrer le système en forçant la vérification :

$ shutdown -r -F now

2 - Créer le fichier forcefsck et redémarrer le système :

$ touch /forcefsck
$ reboot

Après le redémarrage et la vérification des disques, le fichier /forcefsck est automatiquement supprimé.

Par défaut, les pages de manuels utilisent la commande less pour les afficher.

La commande less est une évolution de la commande more.
Elle permet de mettre en gras les rubriques principales des pages de manuels.

La commande most, permet d'ajouter une coloration syntaxique et bien d'autres options supplémentaires.

Pour installer la commande most :

$ sudo apt-get install most

Pour utiliser most pour parcourir les pages de manuels :

$ PAGER=most man cp

Cette commande permet d'utiliser most comme PAGER pour consulter le manuel de la commande cp

Pour utiliser most comme PAGER par défaut :

En BASH, ajouter cette ligne dans le fichier ~/.bashrc

export PAGER=most

Autres options disponibles avec la commande most (partant du principe que most est le PAGER par défaut):

Non seulement most permet de consulter les pages de manuels mais il peut également afficher le contenu de n'importe quel fichier.

$ man cp                       # consultation du manuel avec la commande most si PAGER par défaut
$ most /mon_fichier
 
H : affichage de l'aide most
Espace ou D : défilement page par page vers le bas
Delete ou U : défilement page par page vers le haut
Entrée ou Flèche bas : défilement ligne par ligne vers le bas
Flèche haut : défilement ligne par ligne vers le haut
T : se positionne en haut du document
B : se positionne en bas du document
J ou G : se positionne à la ligne voulue
> : déplacement vers la droite
< : déplacement vers la gauche
S ou f ou / : permet d'effectuer une recherche vers le bas
? : permet d'effectuer une recherche vers le haut
N : recherche les occurences suivantes

En mode affichage de fichier :

E : bascule en mode édition avec l'éditeur par défaut

En mode affichage de logs en continu :

au lieu de

$ tail -f /var/log/access.log

utiliser most puis l'option F

$ most /var/log/access.log
F : simule la commande tail -f

La commande logger permet d'enregistrer des informations dans le fichier /var/log/syslog.

Cette commande est idéale pour journaliser différents évènements pendant l'exécution d'un script.

Elle peut être utilisée tout simplement :

$ logger -t monTag monMessage
$ tail /var/log/syslog
Apr 23 15:23:37 ubuntu10.04 monTag: monMessage

L'option -t permet d'indiquer un tag. Très utile pour effectuer des recherches dans le fichier syslog.

$ logger -t monTag Je peux également écrire un texte avec des espaces
$ tail /var/log/syslog
Apr 23 15:26:12 ubuntu10.04 monTag: Je peux également écrire un texte avec des espaces

La commande logger permet également d'enregistrer dans syslog le contenu d'un fichier.

$ cat fic1
systèmes
coucou
recoucou
$ logger -t FIC1 -f fic1
$ tail /var/log/syslog
Apr 23 15:29:13 ubuntu10.04 FIC1: systèmes
Apr 23 15:29:13 ubuntu10.04 FIC1: coucou
Apr 23 15:29:13 ubuntu10.04 FIC1: recoucou

Utiliser la commande logger dans un script :

$ cat comparaison.sh
#!/bin/bash
logger -t $0 Execution du script
# Test sur le nombre d'arguments
if [[ $# -ne 2 ]]
then
        logger -t $0 Nombre d\'arguments incorrect
        echo "Mauvais nombre d'arguments"
        echo "Utilisation : $0 nbr1 nbr2"
        exit 1
fi
# On compare les nombres
logger -t $0 Comparaison de $1 et $2
if [[ $1 -gt $2 ]]
then
        logger -t $0 $1 est superieur a $2
        echo "Comparaison : $1 est superieur a $2"
else
        logger -t $0 $1 est inferieur a $2
        echo "Comparaison : $1 est inferieur a $2"
fi
logger -t $0 Fin du script
exit 0

Dans ce script, j'utilise le nom du script comme tag (logger -t $0).

Exécution du script :

$ ./comparaison.sh 10 20
Comparaison : 10 est inferieur a 20
$ tail /var/log/syslog
Apr 23 15:51:57 ubuntu10.04 ./comparaison.sh: Execution du script
Apr 23 15:51:57 ubuntu10.04 ./comparaison.sh: Comparaison de 10 et 20
Apr 23 15:51:57 ubuntu10.04 ./comparaison.sh: 10 est inferieur a 20
Apr 23 15:51:57 ubuntu10.04 ./comparaison.sh: Fin du script

Tous mes évènements ont été enregistrés dans sylog.

Il est également possible, dans le script, d'enregistrer les évènements dans un fichier texte avec la commande echo et seulement, à la fin du script, d'utiliser la commande logger pour enregistrer le contenu du fichier texte dans le fichier syslog.

$ cat comparaison.sh
#!/bin/bash
echo "Execution du script" > /root/logComparaison
# Test sur le nombre d'arguments
if [[ $# -ne 2 ]]
then
        echo "Nombre d'arguments incorrect" >> /root/logComparaison
        echo "Mauvais nombre d'arguments"
        echo "Utilisation : $0 nbr1 nbr2"
        exit 1
fi
# On compare les nombres
echo "Comparaison de $1 et $2" >> /root/logComparaison
if [[ $1 -gt $2 ]]
then
        echo "$1 est superieur a $2" >> /root/logComparaison
        echo "Comparaison : $1 est superieur a $2"
else
        echo "$1 est inferieur a $2" >> /root/logComparaison
        echo "Comparaison : $1 est inferieur a $2"
fi
echo "Fin du script" >> /root/logComparaison
logger -t $0 -f /root/logComparaison
exit 0

Tous les évènements sont enregistrés dans le fichier /root/logComparaison à l'aide de la commande echo.
Attention, le premier appel à la commande echo écrase le contenu du fichier /root/logComparaison s'il existe (utilisation d'un seul chevron ">" dans la redirection).
Pour terminer, tout le contenu du fichier est enregistré dans syslog à l'aide de la commande logger et de l'option -f suivi du nom du fichier (utilisation du nom du script en tag).

$ ./comparaison.sh 100 20
Comparaison : 100 est superieur a 20
$ cat logComparaison
Execution du script
Comparaison de 100 et 20
100 est superieur a 20
Fin du script
$ tail /var/log/syslog
Apr 23 16:21:10 ubuntu10.04 ./comparaison.sh: Execution du script
Apr 23 16:21:10 ubuntu10.04 ./comparaison.sh: Comparaison de 100 et 20
Apr 23 16:21:10 ubuntu10.04 ./comparaison.sh: 100 est superieur a 20
Apr 23 16:21:10 ubuntu10.04 ./comparaison.sh: Fin du script

Pour connaitre la version d'Ubuntu installée sur le système, saisir dans une console la commande suivante :

$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 10.04.4 LTS
Release:        10.04
Codename:       lucid

L'information concernant la version installée apparait à la ligne Description

Sinon, il y a le fichier /etc/issue (fonctionne avec Ubuntu et Debian)

$ file /etc/issue
/etc/issue: ASCII text
$ cat /etc/issue
Debian GNU/Linux 6.0 \n \l
 
$ cat /etc/issue
Ubuntu 10.04.4 LTS \n \l

Il y a également le fichier /etc/debian_version

$ file /etc/debian_version
/etc/debian_version: ASCII text
$ cat /etc/debian_version
squeeze/sid

Enfin, il y a le fichier /etc/lsb-release (informations fournies avec la commande lsb_release -a)

$ file /etc/lsb-release
/etc/lsb-release: ASCII text
$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=10.04
DISTRIB_CODENAME=lucid
DISTRIB_DESCRIPTION="Ubuntu 10.04.4 LTS"

Pour connaitre la version du noyau Linux, saisir dans une console la commande suivante :

$ uname -a
Linux vm-apache 2.6.32-14-pve #1 SMP Tue Aug 21 08:24:37 CEST 2012 i686 GNU/Linux
 

Pour arrêter un serveur Ubuntu, saisir la commande suivante dans une console

$ sudo halt

Ou en utilisant la commande shutdown :

$ sudo shutdown -h now

L'indication now permet un arrêt immédiat.

Pour un arrêt dans 1 minute :

$ sudo shutdown -h +1 &

Pour un arrêt à une heure précise :

$ sudo shutdown -h 16:50 &

Pour annuler un arrêt programmé :

$ sudo shutdown -c

Dans le cas d'un arrêt programmé, un message est envoyé toutes les minutes à tous les utilisateurs connectés au système pour annoncer l'arrêt.