Commandes

Quelques commandes pour bien utiliser Linux

Utilisateurs

Ajouter un utilisateur au système

Ajouter un utilisateur au système

$ sudo   adduser   nom_du_user

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

Etiquettes: 

Ajouter un utilisateur Samba

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)

Etiquettes: 

Afficher l'UID d'un utilisateur

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:

Etiquettes: 

Fermer une session utilisateur via la console (Ubuntu)

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

Etiquettes: 

Modifier l'interpréteur de commande d'un utilisateur

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
$

 

Prendre le rôle ROOT en mode console

La commande suivante permet de se loguer en root.

Ouvrir une session avec son  user puis saisir :

$ sudo su -

(Saisir son mot de passe)

Etiquettes: 

Prendre le rôle d'un user en mode console

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

Etiquettes: 

Partage NFS

Partage NFS

Pré-requis

$ sudo apt-get install nfs-common

Afficher les partages NFS du serveur

$ showmount -e   adresse_ip_du_serveur

Démarrer le serveur NFS

$ sudo /etc/init.d/nfs-kernel-server   start

Redémarrer le serveur NFS

$ sudo /etc/init.d/nfs-kernel-server   restart

Monter un partage NFS

à renseigner dans /etc/fstab

  • adresse_ip_serveur  :  /nom_du_partage_nfs  /point_de_montage_sur_client  nfs  defaults  0  0

Monter un partage NFS via SSH

Installer sshfs

$ sudo apt-get install sshfs

Créer le répertoire servant au montage

$ sudo mkdir /mnt/ssh

Monter le partage NFS distant via SSH

$ sudo sshfs $USER@adresse_de_la_machine_distante:/nom_du_partage_nfs /mnt/ssh

Pour démonter le partage NFS

$ sudo fusermount -u /mnt/ssh

Etiquettes: 

FSTAB

Documentation Ubuntu

Modifier le fichier FSTAB

$ sudo gedit /etc/fstab
$ sudo nano /etc/fstab

Activer les modifications du fichier FSTAB

$ sudo mount -a

Etiquettes: 

TAR

Archiver avec TAR

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

Etiquettes: 

Désarchiver avec TAR

Désarchiver avec TAR

$ tar -xvf mon_archive.tar

-x : eXtract

-v : Verbose

-f : File

Etiquettes: 

Archivage incrémentiel avec TAR

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.

Etiquettes: 

Supprimer un fichier dans une archive TAR

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

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

Etiquettes: 

TAR & GZIP

Compresser avec TAR & GZIP

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

Décompresser avec TAR & GZIP

$ tar -xvzf mon_archive.tar.gz

-x : eXtract

-v : Verbose

-z : gZip

-f : File

Variables d'environnement

Afficher les variables d'environnements

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

$ printenv

Etiquettes: 

Créer une variable d'environnement

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

Etiquettes: 

Date & heure

Conversion timestamp

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

Effectuer une action à une date et un jour précis de la semaine

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

Etiquettes: 

Les différents formats de date sous Linux

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"
$

$ nl fonctions.inc.sh
     1  function getDate {
     2          date '+%Y_%m_%d'
     3  }
     4  function getYear {
     5          date '+%Y'
     6  }
     7  function getMonth {
     8          date '+%m'
     9  }
    10  function getDay {
    11          date '+%d'
    12  }
    13  function getJourDate {
    14          date '+%A'
    15  }
    16  function getMoisDate {
    17          date '+%B'
    18  }
    19  function getNumSemaine {
    20          date '+%V'
    21  }
    22  function getNumDay {
    23          typeset jour
    24          jour=`date '+%j'`
    25          case "$jour" in
    26                  1)
    27                          echo "1 er"
    28                          ;;
    29                  *)
    30                          echo "$jour ème"
    31                          ;;
    32          esac
    33  }
    34  function getNumDayWeek {
    35          typeset jour
    36          jour=`date '+%u'`
    37          case "$jour" in
    38                  1)
    39                          echo "1 er"
    40                          ;;
    41                  *)
    42                          echo "$jour ème"
    43                          ;;
    44          esac
    45  }
    46  function nbJourAnnee {
    47          typeset jour
    48          typeset mois
    49          typeset annee
    50          jour=31
    51          mois=12
    52          annee=`getYear`
    53          date -d $mois'/'$jour'/'$annee '+%j'
    54  }
    55  function nbResteJour {
    56          typeset jour
    57          typeset nbJourAnnee
    58          typeset nbJourRestant
    59          jour=`date '+%j'`
    60          nbJourAnnee=`nbJourAnnee`
    61          ((nbJourRestant=nbJourAnnee-jour))
    62          echo $nbJourRestant
    63  }
    64  function nbSemAnnee {
    65          typeset jour
    66          typeset mois
    67          typeset annee
    68          jour=31
    69          mois=12
    70          annee=`getYear`
    71          date -d $mois'/'$jour'/'$annee '+%V'
    72  }
    73  function nbResteSemaine {
    74          typeset numSem
    75          typeset nbSem
    76          typeset nbSemReste
    77          numSem=`getNumSemaine`
    78          nbSem=`nbSemAnnee`
    79          ((nbSemReste=nbSem-numSem))
    80          echo $nbSemReste
    81  }
$

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
$

Etiquettes: 

Fichiers / Dossiers

Convertir un fichier Windows en Linux et inversement

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-...

Rendre un fichier exécutable

Pour rendre un fichier exécutable

$ sudo chmod +x ./nom_du_fichier

Etiquettes: 

Afficher la somme MD5 d'un 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
$

Etiquettes: 

BASH: Gérer des fichiers dont les noms comportent des espaces

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.

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

Etiquettes: 

Chiffrer / Déchiffrer des fichiers

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
$

Etiquettes: 

Connaitre la taille d'un dossier

Pour connaitre la taille d'un dossier :

$ sudo du -hs /nom_du_dossier

Etiquettes: 

Copier des fichiers résultant d'une recherche avec find

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.

Etiquettes: 

Créer un fichier d'une taille précise

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
$

Etiquettes: 

Lire un fichier PDF en ligne de commande

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
...................
$

Etiquettes: 

Modifier le propriétaire d'un fichier ou d'un dossier

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.
Etiquettes: 

Modifier les permissions d'un fichier ou d'un dossier

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

Etiquettes: 

Quelques commandes pour les dossiers

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é.

Etiquettes: 

Remplacer les espaces dans les noms de fichiers par des underscores

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' "{}" \;

Etiquettes: 

Renommer un fichier

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

Supprimer le résultat d'une recherche (console)

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.

Synchroniser des dossiers et des fichiers

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/

Transfert de fichiers via SCP

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/

Transférer un fichier via SSH

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

Etiquettes: 

VIM : Supprimer les caractères BOM dans un fichier encodé en UTF-8

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.

Etiquettes: 

Imprimer via la console

Pour imprimer un document via la console, il faut utiliser le commande LPR

Impression avec l'imprimante par défaut

$ lpr /mon-document

Impression en choisissant une imprimante

$ lpr -P nom-de-l-imprimante /mon-document

Impression avec un autre USER

$ lpr -U $USER /mon-document

Impression en mode mirroir

$ lpr -o mirror /mon-document

Etiquettes: 

Internet

Télécharger un fichier d'internet

Télécharger un fichier d'internet

$ wget   adresse_du_fichier_a_telecharger
 
$ fetch   adresse_du_fichier_a_telecharger

Etiquettes: 

Aspirer un site internet

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

Etiquettes: 

CURL: Poster des données et des fichiers via un formulaire

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

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

Etiquettes: 

CURL: appeler un webservice SOAP

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

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

Etiquettes: 

Créer un sprite CSS sans se prendre la tête

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.

$ ls -1 famfamfam_flag_icons/png
ad.png
ae.png
af.png
ag.png
ai.png
al.png
am.png
an.png
ao.png
...
$ ls -1 sprite/
png.css
png.png
 

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.

$ head sprite/png.css 
/* glue: 0.4 hash: 1c2ef5e4ec */
.sprite-png-zw,
.sprite-png-zm,
.sprite-png-za,
.sprite-png-yt,
.sprite-png-ye,
.sprite-png-ws,
.sprite-png-wf,
.sprite-png-wales,
.sprite-png-vu,
 
Il est possible de modifier le nommage des "class" avec l'option --namespace=NAMESPACE.
 

$ glue famfamfam_flag_icons/png sprite --namespace=monSprite

$ head sprite/png.css 
/* glue: 0.4 hash: d6adc62ab7 */
.monSprite-png-zw,
.monSprite-png-zm,
.monSprite-png-za,
.monSprite-png-yt,
.monSprite-png-ye,
.monSprite-png-ws,
.monSprite-png-wf,
.monSprite-png-wales,
.monSprite-png-vu,

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.

sprite

Navigateur en ligne de commande

$ w3m http://adresse_du_site

Etiquettes: 

La commande mount

Monter une clé USB ou un disque dur externe en ligne de commande avec la commande mount.

  • Brancher la clé USB ou le disque dur externe
  • Avec la commande fdisk et l'option -l, afficher à l'écran la liste des périphériques connectés afin d'obtenir les informations nécessaires au montage.
    Rechercher dans la liste le périphérique concerné.
    Dans mon cas, il s'agit d'une clé USB de 4 Go et correspondant au dernier périphérique de la liste (/dev/sdd)

$ sudo fdisk -l
...
Disque /dev/sdd: 4009 Mo, 4009754624 octets
23 têtes, 23 secteurs/piste, 14804 cylindres
Unités = cylindres de 529 * 512 = 270848 octets
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Identifiant de disque : 0xc3072e18
     
Périphérique Amorce  Début        Fin      Blocs     Id  Système
/dev/sdd1   *          16       14805     3911744    b  W95 FAT32
$

  • Les infos nécessaires au montage sont celles indiquées en rouge.
    C'est à dire, le fichier correspondant à la partition de la clé ou du disque externe (/dev/sdd1).
    Dans le cas d'un périphérique ayant plusieurs partitions, la liste des périphériques contiendrait plusieurs lignes (/dev/sddx).
    Et enfin, le système de fichiers (FAT32)

La syntaxe de la commande mount est la suivante :

mount -t type device dir

type correspond au système de fichiers du périphérique à monter.
device correspond au fichier de la partition à monter.
dir correspond au répertoire dans lequel sera monté le périphérique.

Pour le paramètre type, il existe différents formats pris en charge :

adfs,  affs,  autofs, cifs, coda, coherent, cramfs, debugfs, devpts, efs, ext, ext2, ext3, ext4, hfs, hfsplus, hpfs,iso9660, jfs, minix, msdos,  ncpfs,  nfs,  nfs4,  ntfs,  proc,  qnx4,ramfs,  reiserfs,  romfs,  squashfs,smbfs, sysv, tmpfs, ubifs, udf, ufs, umsdos, usbfs, vfat, xenix, xfs,xiafs

  • Créer, s'il n'existe pas déjà, le répertoire destiné à recevoir le montage.

$ sudo mkdir /mnt/ma_cle_usb
$

  • Pour terminer, procéder au montage de la partition /dev/sdd1 dans le répertoire /mnt/ma_cle_usb avec le système de fichiers vfat.
    vfat correspondant au système de fichiers FAT32.

$ sudo mount -t vfat /dev/sdd1 /mnt/ma_cle_usb/
$

Pour vérifier la bonne exécution du montage

$ mount
...
/dev/sdd1 on /mnt/ma_cle_usb type vfat (rw)
$

Avec cette commande, on s'aperçoit que le prériphérique est monté en RW (lecture/écriture).
Pour monter le périphérique en lecture seule, il suffit d'utiliser l'option -r.

$ sudo mount -r -t vfat /dev/sdd1 /mnt/ma_cle_usb/
$ mount
...
/dev/sdd1 on /mnt/ma_cle_usb type vfat (ro)
$

Pour démonter le périphérique

$ sudo umount -f /mnt/ma_cle_usb/
$

L'option -f permet de forcer le démontage

Une erreur souvent rencontrée

Un périphérique est monté et l'erreur suivante apparait lors du démontage

$ sudo umount /mnt/ma_cle_usb/
démontage : /mnt/ma_cle_usb: périphérique occupé.
       (Dans certains cas, des infos sur les processus l'utilisant
        sont récupérables par lsof(8) ou fuser(1))
$

Vérifier le répertoire dans lequel on se trouve

$ pwd
/mnt/ma_cle_usb
$

La commande pwd indique que je me trouve dans le répertoire que je veux démonter.
Le démontage est donc impossible car le répertoire concerné est en cours d'utilisation.
Il suffit donc de se placer dans un autre répertoire et d'exécuter à nouveau la commande umount.

$ cd
$ sudo umount /mnt/ma_cle_usb/
$


La commande mount utilisée avec l'option -a permet d'exécuter tous les points de montage inscrits dans le fichier /etc/fstab

$ sudo mount -a

Très pratique pour vérifier toutes les modifications effectuées dans le fichier /etc/fstab


Si une partition n'a plus d'espace libre disponible, elle est montée en lecture seule.

# mount
...
/dev/sdb1 on /mnt/datas type ext4 (ro)
...

Pour pouvoir y faire le ménage, il est nécessaire de pouvoir y accéder en écriture.

Pour ce faire,  la partition doit être remontée en écriture de cette manière:

# mount -o remount,rw /mnt/datas
# mount
...
/dev/sdb1 on /mnt/datas type ext4 (rw)
...

Etiquettes: 

Liens symboliques

Etiquettes: 

Créer un lien symbolique

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

Etiquettes: 

Supprimer un lien symbolique

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

Les nombres

Générer une séquence de nombre

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.

Etiquettes: 

Trier un tableau de valeurs numériques

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.

 

Une calculatrice en ligne de commande

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.

$ 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'. 
scale=5
45/8
5.62500

Il est également possible d'utiliser des variables.

$ 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'. 
scale=5
a=10
b=3
c=a+b
d=a-b
e=a*b
f=a/b
c
13
d
7
e
30
f
3.33333
 
Les différentes fonctions mathématiques ne sont pas oubliées.
 
$ 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'. 
scale=5
5^3         #PUISSANCE
125
sqrt(9)     #RACINE CARREE
3.00000
45%8        #MODULO
0
scale=0
45%8        #MODULO
5
 
ATTENTION, pour le modulo, initialiser le scale à 0 avant l'opération.
 

Calculer la valeur de pi :

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

$ 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'. 
pi=4*a(1)     # On calcul la valeur de pi
pi
3.14159265358979323844
 
Convertir des degrés en radian et inversement :
 
$ 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'. 
pi=4*a(1)     # On calcul la valeur de pi
pi
3.14159265358979323844
45*(pi/180)     # 45 degrés en radian
.78539816339744830920
.78539816339744830920*(180/pi)     # 0.78.... radian en degrés
44.99999999999999997650
 
et les sinus, cosinus et arc tangente
 
$ 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'. 
pi=4*a(1)     # On calcul la valeur de pi
r=45*(pi/180)     # On convertit les degrés en radian (45°)
s(r)    # On calcul le sinus
.70710678118654752410
c(r)     # On calcul le cosinus
.70710678118654752469
a(r)     # On calcul l'arc tangente
.66577375002835386333
 
Toute l'aide disponible avec : 
 
$ man bc
 
Il est également possible d'utiliser la commande bc pour initialiser une variable bash :
 
$ PI=$(echo "scale=10; 4*a(1)" | bc -l)
$ echo $PI
3.1415926532

 

Etiquettes: 

test - integer expression expected

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.

Etiquettes: 

Mail

Etiquettes: 

Envoyer un mail

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

Etiquettes: 

Envoyer un mail en HTML

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 ?

Etiquettes: 

OpenSSL

OpenSSL est un programme utilisant les protocoles de chiffrement SSL (v2/v3)  et TLS (v1).

Il est utilisé principalement pour :

  • Créer des clés RSA, DH et DSA.
  • Créer des certificats X509, CSR et CRL.
  • Calculer des sommes de fichiers.
  • Chiffrer et déchiffrer des chaines de caractères/des fichiers.
  • Effectuer des tests SSL/TLS entre un client et un serveur.

Quelques liens consernant SSL

Autorités de certification:

cacert.org
let's encrypt

Tests de sécurité SSL:

SSL Labs

Générateur de configuration SSL pour apache, nginx, haproxy, aws elb:

Mozilla SSL Configuration Generator

 

Etiquettes: 

openssl : Afficher la version installée

$ 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"
$
Etiquettes: 

openssl : Afficher les sous-commandes disponibles

$ 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
Etiquettes: 

openssl : Tester les performances de son système

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:1024 -keyout mycert.pem -out mycert.pem

2 - Démarrage du serveur simulé

$ openssl s_server -cert mycert.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
Etiquettes: 

openssl : Encoder une chaîne de caractères en base64/md5

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
Etiquettes: 

openssl : Chiffrer-Déchiffrer une chaine de caractères ou un fichier

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.

Etiquettes: 

openssl : Clé de contrôle MD5 ou SHA1 d'un fichier

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

 

openssl : Exporter ou importer un certificat au format PKCS#12

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.

 

Etiquettes: 

openssl : Extraire les informations d'un certificat

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

 

Etiquettes: 

openssl : Générer des clés

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

 

Etiquettes: 

openssl : Générer des données aléatoires

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.

 

Etiquettes: 

openssl : Générer des mots de passe cryptés

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.

 

Etiquettes: 

openssl : Générer un certificat auto-signé

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

Etiquettes: 

openssl : Générer une authentification Apache

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

 

Etiquettes: 

openssl : Les nombres premiers

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
Etiquettes: 

openssl : Récupérer un certificat distant

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.

Etiquettes: 

openssl: Générer une paire de clé et une demande de certificat CSR

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 ronanisquennec.key -out ronanisquennec.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 ronanisquennec.key et la demande CSR sera stockée dans le fichier ronanisquennec.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.

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

openssl: connexion SMTP avec TLS

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

Périphériques externes

Créer une image ISO d'un CD et/ou DVD

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/

Etiquettes: 

Formater un support de stockage

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"

Créer une image ISO d'un répertoire

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