Pour accéder à distance au bureau Ubuntu ou d'une autre ditribution Linux même si la session est verouillée, il faut utiliser vnc4server

Procédure à suivre :

Paramétrage coté serveur

1 - Installer vnc4server

$ sudo apt-get install vnc4server

2 - Création du répertoire .vnc dans le home

$ cd ~
$ mkdir .vnc

3 - Création du fichier xstartup dans le répertoire .vnc avec des droits d'exécution

$ touch .vnc/xstartup
$ chmod a+x .vnc/xstartup

4 - Edition du fichier xstartup

$ gedit ~/.vnc/xstartup

5 - Y inscrire ce contenu

#!/bin/sh
# Uncomment the following two lines for normal desktop:
unset SESSION_MANAGER
exec sh /etc/X11/xinit/xinitrc
[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources
xsetroot -solid grey
vncconfig -iconic &
xterm -geometry 80x24+10+10 -ls -title "$VNCDESKTOP Desktop" &
#twm &
gnome-session &

Action coté client

1. Se connecter à la machine serveur via ssh en utilisant putty par exemple (pour Windows)
2. S'identifier puis taper la commande vncserver
3. La commande retourne à l'écran l'adresse à utiliser pour s'y connecter (nom_de_la_machine:1 par exemple)
4. Se connecter sur l'adresse indiquée via vnc_viewer par exemple (pour Windows)

Il est possible, également, d'utiliser sous GNU/Linux le programme xrdp qui émule parfaitement le protocole RDP (Remote Desktop Protocol Server).

$ apt-get install xrdp

Pour la connexion, n'importe quel client de connexions bureau à distance compatible RDP peut être utiliser.
Le très célèbre mstsc de Windows, mRemoteNG, Remmina (installé par défaut dans Ubuntu depuis la 12.04) etc etc...

Par défaut, le verrouillage du pavé numérique n'est pas activé.

Pour le faire, installer le paquet numlockx

$ sudo apt-get install numlockx

Ensuite, éditer le fichier /etc/gdm/Init/Default

$ sudo gedit /etc/gdm/Init/Default

Ajouter les lignes suivantes à la fin du fichier avant la ligne "exit 0"

L'enchainement des commandes suivantes permet d'afficher à l'écran toutes les adresses ip bloquées par iptables, triées numériquement et  numérotées :

$ iptables -L -n | grep 'DROP' | awk '{print $4}' | sort -n | uniq | nl
     1  37.59.20.164
     2  61.38.252.112
     3  85.118.62.43
     4  91.236.74.176
     5  91.236.74.249
     6  93.182.139.42
     7  93.182.147.141
     8  93.182.174.159
     9  93.182.175.25
    10  117.21.225.66
    11  173.242.126.130
    12  199.15.234.138
    13  199.15.234.143
    14  199.15.234.145
    15  199.15.234.146
    16  199.15.234.147
    17  199.15.234.213
    18  208.177.72.206
$

Explications :

La commande suivante permet d'afficher les règles iptables (option -L) avec les ip au format numérique (option -n) :

$ iptables -L -n
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
DROP       all  --  173.242.126.130      0.0.0.0/0
DROP       all  --  199.15.234.146       0.0.0.0/0
DROP       all  --  93.182.139.42        0.0.0.0/0
DROP       all  --  93.182.175.25        0.0.0.0/0
DROP       all  --  93.182.174.159       0.0.0.0/0
DROP       all  --  93.182.147.141       0.0.0.0/0
DROP       all  --  208.177.72.206       0.0.0.0/0
DROP       all  --  199.15.234.138       0.0.0.0/0
DROP       all  --  91.236.74.176        0.0.0.0/0
DROP       all  --  85.118.62.43         0.0.0.0/0
DROP       all  --  91.236.74.249        0.0.0.0/0
DROP       all  --  37.59.20.164         0.0.0.0/0
DROP       all  --  117.21.225.66        0.0.0.0/0
DROP       all  --  199.15.234.143       0.0.0.0/0
DROP       all  --  199.15.234.145       0.0.0.0/0
DROP       all  --  199.15.234.147       0.0.0.0/0
DROP       all  --  61.38.252.112        0.0.0.0/0
DROP       all  --  199.15.234.213       0.0.0.0/0
 
Chain FORWARD (policy ACCEPT)
target     prot opt source               destination
 
Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Suivi de la commande suivante, seules les chaines DROP sont affichées :

$ iptables -L -n | grep 'DROP'
DROP       all  --  173.242.126.130      0.0.0.0/0
DROP       all  --  199.15.234.146       0.0.0.0/0
DROP       all  --  93.182.139.42        0.0.0.0/0
DROP       all  --  93.182.175.25        0.0.0.0/0
DROP       all  --  93.182.174.159       0.0.0.0/0
DROP       all  --  93.182.147.141       0.0.0.0/0
DROP       all  --  208.177.72.206       0.0.0.0/0
DROP       all  --  199.15.234.138       0.0.0.0/0
DROP       all  --  91.236.74.176        0.0.0.0/0
DROP       all  --  85.118.62.43         0.0.0.0/0
DROP       all  --  91.236.74.249        0.0.0.0/0
DROP       all  --  37.59.20.164         0.0.0.0/0
DROP       all  --  117.21.225.66        0.0.0.0/0
DROP       all  --  199.15.234.143       0.0.0.0/0
DROP       all  --  199.15.234.145       0.0.0.0/0
DROP       all  --  199.15.234.147       0.0.0.0/0
DROP       all  --  61.38.252.112        0.0.0.0/0
DROP       all  --  199.15.234.213       0.0.0.0/0

Suivi de la commande suivante, seule la 4ème colonne (celle contenant les ip) est affichées :

$ iptables -L -n | grep 'DROP' | awk '{print $4}'
173.242.126.130
199.15.234.146
93.182.139.42
93.182.175.25
93.182.174.159
93.182.147.141
208.177.72.206
199.15.234.138
91.236.74.176
85.118.62.43
91.236.74.249
37.59.20.164
117.21.225.66
199.15.234.143
199.15.234.145
199.15.234.147
61.38.252.112
199.15.234.213

Suivi de la commande suivante (sort), les ip sont triées numériquement (option -n) et les doublons sont exclus avec la commande uniq:

$ iptables -L -n | grep 'DROP' | awk '{print $4}' | sort -n | uniq
37.59.20.164
61.38.252.112
85.118.62.43
91.236.74.176
91.236.74.249
93.182.139.42
93.182.147.141
93.182.174.159
93.182.175.25
117.21.225.66
173.242.126.130
199.15.234.138
199.15.234.143
199.15.234.145
199.15.234.146
199.15.234.147
199.15.234.213
208.177.72.206

Enfin, la commande suivante numérote toutes les lignes affichées :

$ iptables -L -n | grep 'DROP' | awk '{print $4}' | sort -n | uniq | nl
     1  37.59.20.164
     2  61.38.252.112
     3  85.118.62.43
     4  91.236.74.176
     5  91.236.74.249
     6  93.182.139.42
     7  93.182.147.141
     8  93.182.174.159
     9  93.182.175.25
    10  117.21.225.66
    11  173.242.126.130
    12  199.15.234.138
    13  199.15.234.143
    14  199.15.234.145
    15  199.15.234.146
    16  199.15.234.147
    17  199.15.234.213
    18  208.177.72.206

Au total, ce sont donc 5 commandes qui sont utilisées pour afficher le résultat souhaité.

Si la liste est trop longue pour être affichée en une seule fois, une petite commande supplémentaire fera très bien l'affaire :

$ iptables -L -n | grep 'DROP' | awk '{print $4}' | sort -n | uniq | nl | less

Pré-requis :

Installer le programme ccze

$ apt-get install ccze

Utilisation :

$ tail -f /var/log/apache2/access.log | ccze

La commande tail permet d'afficher les 10 dernières lignes d'un fichier.

L'option -f associée à la commande tail permet d'afficher le fichier en continu.

Enfin, l'envoi à la commande ccze via un tube permet la colorisation des données.

Astuce supplémentaire :

Dans les logs du proxy Squid, la date et l'heure sont enregistrés au format timestamp.
Pas très pratique à lire.

Pour convertir le timestamp dans un format plus lisible pour l'homme, il suffit d'utiliser la commande ccze avec l'option -C

$ tail -f /var/log/squid/access.log | ccze -C

Pour filtrer en continu uniquement les adresses IP des logs Apache, saisir les commandes suivantes :

$ tail -f /var/log/apache2/access.log | egrep -o '^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'

ou

$ tail -f /var/log/apache2/access.log | egrep -o '^([0-9]{1,3}\.){3}[0-9]{1,3}'

La commande tail suivie de l'option -f permet d'afficher le contenu d'un fichier en continu.

La commande egrep suivie de l'option -o permet d'afficher uniquement la regex recherchée.

Voici les deux manières les plus simple pour ajouter une clé au gestionnaire des clés APT.

Exemple avec la clé webmin.

1 - On télécharge le fichier contenant la clé :

$ wget http://www.webmin.com/jcameron-key.asc

2 - On ajoute la clé contenu dans le fichier :

$ sudo apt-key add jcameron-key.asc

Sinon, en envoyant la clé récupérée par la commande wget directement à la commande apt-key en passant par un tube :

$ wget -O- http://www.webmin.com/jcameron-key.asc | sudo apt-key add -

Pour lister toutes les clés installées dans le gestionnaire :

$ sudo apt-key list

Pour supprimer une clé : 

Récupérer l'identifiant public de la clé à supprimer avec l'option list de la commande apt-key :

$ sudo apt-key list

Par exemple, pour la clé webmin, son identifiant public est le "1024D/11F63C51"

On supprime la clé avec la commande suivante :

$ sudo apt-key del 11F63C51

Sous Linux, la commande ftp permet de se connecter à un serveur FTP.

Pour le mode passif, il est possible d'utiliser directement la commande pftp.

$ ftp mon-serveur-ftp.com

Les informations de connexions, utilisateur et mot de passe, doivent ensuite être saisis.

Pour éviter ce comportement et permettre l'authentification automatique, il est nécessaire de créer le fichier ~/.netrc avec les informations suivantes:

$ cat ~/.netrc
machine mon-serveur-ftp.com login mon-login password mot-mot-de-passe

Et ne pas oublier de modifier les permissions du fichier comme suit:

$ chmod 600 ~/.netrc

Et voilà, plus besoin de saisir son nom d'utilisateur et son mot de passe

Pour X raisons, il peut être intéressant d'avoir une session automatiquement ouverte au démarrage du serveur.

Pour activer cette option :

1 - Localiser le programme login

2 - Modifier le fichier /etc/inittab

Pour une ouverture de session automatique sur la console tty6 (par exemple), commenter la ligne :
#6:23:respawn:/sbin/getty 38400 tty6
Et ajouter au dessous de cette ligne :
6:23:respawn:/bin/login -f root tty6 </dev/tty6 >/dev/tty6 2>&1

Attention à renseigner correctement le chemin d'accès au programme login (/bin/login) obtenu grâce à la commande `which login` ci-dessus et le numéro de la console à utiliser (tty6).

3 - Sauvegarder les modifications et redémarrer le serveur (pour vérification).
Une session root devrait être automatiquement ouverte sur la console tty6.

Pour rappel, sur une version serveur, il existe 6 consoles (tty1 ... tty6).
Pour basculer d'une console à une autre, il suffit d'utiliser les combinaisons de touches suivantes [ctrl]+[alt]+[F1] pour la console tty1, [ctrl]+[alt]+[F2] pour la console tty2 et ainsi de suite jusqu'à [ctrl]+[alt]+[F6] pour la console tty6.

Il est possible d'exécuter une requête MySql en BASH grâce à la commande echo et au client MySql.

Inconvénient

Mot de passe en clair dans la commande.

Avantage

Automatisation possible avec crontab.

Pré-requis

Un client MySql installé sur la poste

$ apt-get install mysql-client

Au préalable

En fonction de l'inconvénient cité ci-dessus, il est conseillé de créer un utilisateur MySql spécifique pour l'occasion. C'est à dire, un utilisateur ayant uniquement le privilège "SELECT" sur la base à utiliser. Affiner les privilèges sur les champs d'une table de la base pour plus de sécurité.

Pour cela, plusieurs solutions :

• avec phpmyadmin
• en ligne de commande

Exemple en ligne de commande :

Dans l'exemple, je souhaite utiliser les champs "champ1", "champ3" et "champ6" de la table "ma_table" de la base "ma_base". Je créé un user "toto" avec le mot de passe "pass" ayant le privilège "SELECT" sur les champs "champ1", "champ3" et "champ6" de la table "ma_table" de la base "ma_base". Pour terminer, je recharge les privilèges.

$ mysql -u root -p
mysql> CREATE USER 'toto'@'%' IDENTIFIED BY 'pass';
Query OK, 0 rows affected (0.00 sec)
 
mysql> GRANT SELECT ( `champ1` , `champ3` , `champ6` ) ON `ma_base`.`ma_table` TO 'toto'@'%';
Query OK, 0 rows affected (0.00 sec)
 
mysql> FLUSH PRIVILEGES ;
Query OK, 0 rows affected (0.00 sec)
 
mysql> Bye
$

Exemple

Dans l'exemple ci-dessous, je vais donc effectuer une requête avec echo et le client MySql sur les champs "champ1", "champ3" et "champ6" de la table "ma_table" de la base "ma_base" sur mon serveur MySql avec l'utilisateur toto, mettre le résultat en forme grâce à awk et à la commande pr et enfin, envoyer le résulat par mail avec la commande mail.

$ echo "select champ1, champ3, champ6 from ma_base.ma_table order by 3 desc;" | mysql -h mon_serveur_mysql -u toto -ppass | awk 'BEGIN{printf("%-15s %-35s %-5s\n","COL1","COL2","COL3")}NR>1{printf("%15d %-35s %5d\n",$1,$2,$3)}' | pr -h "Le resultat de ma requete SQL" | mail -s "Le resultat de ma requete SQL" moi@domaine.fr

Avec la commande awk, j'ajoute des en-têtes de champs personnalisés dans la section BEGIN et je récupère uniquement les données de la requête en supprimant la première ligne qui contient les noms des champs MySql (NR>1) et le tout mis en forme avec la fonction printf.

Pour ne pas afficher la première ligne contenant le nom des champs, il est également possible d'utiliser la commande mysql avec l'option -N.

Avec la commande pr et l'option -h, j'ajoute un titre à mon rapport.

Petite astuce trouvée sur le site http://www.it-connect.fr/ajouter-un-horodatage-a-la-commande-history/

Sous Linux, la commande history permet d'afficher l'historique des commandes utilisées dans le shell.

$ history
  475  java sdz1
  476  ll -tr
  477  cat tokill.java
  478  ll
  479  ll -tr
  480  vim sdz1.class
  481  java sdz1.class
  482  java sdz1
  483  w

Pour ajouter l'horodatage, il suffit d'ajouter cette ligne au fichier .bashrc

$ echo 'export HISTTIMEFORMAT="%F %T : "' >> ~/.bashrc

Résultat, après s'être bien-sûr reconnecté

$ history
  472  2016-11-03 11:51:45 : java sdz1
  473  2016-11-03 11:51:45 : ll -tr
  474  2016-11-03 11:51:45 : cat tokill.java
  475  2016-11-03 11:51:45 : ll
  476  2016-11-03 11:51:45 : ll -tr
  477  2016-11-03 11:51:45 : vim sdz1.class
  478  2016-11-03 11:51:45 : java sdz1.class
  479  2016-11-03 11:51:45 : java sdz1
  480  2016-11-03 11:51:45 : w

A l'aide de la commande grep, il est très facile de retrouver une commande exécutée un jour précis, voir même à une heure précise.

Voici quelques fonctions bien utiles permettant de manipuler différentes variables et pouvant être inclues dans des scripts.

Le script est disponible ici.

Détail du script

Par exemple, vérifier qu'une variable est numérique, qu'une variable est de type int, qu'une variable est un booléen etc etc...
Ces fonctions (quelques unes) ont été inspirées de PHP.

Ce script peut être inclu dans d'autres scripts de cette manière (l'une ou l'autre des deux méthodes):

source functions.inc
. functions.inc

Le fichier peut également être inclu dans le fichier ~/.bashrc (de la même manière) afin de disposer de toutes ces fonctions directement dans le prompt.

Exemples:

$ is_numeric azerty ; echo $?
1
$ is_numeric ee55ee ; echo $?
1
$ is_numeric 65465484 ; echo $?
0

N'hésiter pas à me faire part de vos commentaires.
Penser à vérifier régulièrement si des nouvelles fonctions ont été ajoutées.
Si vous avez des idées de nouvelles fonctions, partager les.

Les commandes suivantes permettent de redimensionner tout un lot d'images (jpg/png) en indiquant une taille maximum à ne pas dépasser pour la largeur et la hauteur.

Les commandes identify et mogrify sont disponibles dans le paquet imagemagick.

Dans l'exemple suivant, je vais redimensionner toutes les images PNG avec une taille de 700px maxi pour la largeur et la hauteur.

# identify *.png | awk '{split($3, TAB, "x"); W = TAB[1]; H = TAB[2]; if(W > 700){system("mogrify -resize 700x "$1)} if (H > 700){system("mogrify -resize x700 "$1)}}'

Explications:

La commande identify permet d'afficher les caractéristiques d'une ou plusieurs images.
A l'aide de la commande awk, on extrait les dimensions de l'image (fonction split) et si la largeur est supérieur à 700px on redimensionne l'image (700x) à l'aide de la commande mogrify (via la fonction system) - Idem pour la hauteur de l'image (x700).

La commande mogrify modifie directement le fichier d'origine.
Plus de détail ici sur les commandes imagemagick.

Avec bash, pour effectuer ce genre de regex avec grep, j'ai trouvé l'astuce suivante:

# cat monfichier.xml | tr -d "\n" | grep -Po "<desc>.*?</desc>"

Dans mon fichier xml, mes balises <desc> sont étalées sur 3 lignes

...
    <desc>
        13.0 km, 0:13
    </desc>
    <desc>
        4.0 km, 0:6
    </desc>
...

du coup, pour les extraire correctement de mon fichier, je suis obligé de faire une recherche avec une regex qui ne tient pas compte des retours à la ligne et qui n'est surtout pas gourmande (non-greedy) afin de ne pas extraire en une seule fois toutes les balises <desc>

Pour le problème des retours à la ligne, j'utilise la commande tr pour les supprimer.

Pour le problème du "non-greedy", j'utilise grep avec l'option -P, afin d'indiquer à grep d'utiliser la regex comme une regex Perl pour pouvoir interpréter correctement l'indicateur "?" qui permet justement d'obtenir le comportement "non-greedy"

Créer une configuration propre à chaque session SSH est très utile dans le cas où les paramètres de connexions sont très hétérogènes.

Par exemple:

1 - Connexion SSH sur le serveur A avec le user USERA sur le port 2000
2 - Connexion SSH sur le serveur B avec le user USERA sur le port 22
3 - Connexion SSH sur le serveur C avec le user USERB sur le port 443 via un proxy
etc etc...

Ca fait beaucoup de paramètres à mémoriser pour chaque connexion.

Il existe donc un fichier config se trouvant dans le répertoire utilisateur ~/.ssh/ (le créer s'il n'existe pas) et dans lequel il est possible d'y paramétrer toutes les connexions SSH.

voir man 5 ssh_config pour plus de détail.

Détail de la config pour la connexion 1 (en rouge, les paramètres à modifier):

Host serveurA
    Hostname mon.serveur.mon.domaine.com (ou l'ip 10.10.10.10)
    User USERA
    Port 2000
   TCPKeepAlive yes

Bien respecter l'indentation

La variable Host accepte n'importe quelle valeur. C'est un identifiant pour le serveur.
La variable Hostname correspond au serveur distant sur lequel on se connecte. On peut y renseigner soit un nom de domaine soit une adresse IP.
La variable User correspond au user avec lequel on se connecte.
La variable Port correspond au port sur lequel on se connecte.

En fonction de cette configuration, la connexion SSH au serveur A s'effectue de cette manière:

$ ssh serveurA

On précise donc uniquement le nom renseigné dans la variable Host du fichier ~/.ssh/config

Détail de la config pour la connexion 3 (en rouge, les paramètres à modifier):

Host serveurC
    Hostname mon.serveur.mon.domaine.com (ou l'ip 12.12.12.12)
    User USERB
    Port 443
   TCPKeepAlive yes
    ProxyCommand corkscrew proxy.domaine.com 8080 %h %p

La variable ProxyCommand contient la ligne de commande à exécuter pour se connecter via le proxy indiqué en rouge. La commande utilise le programme corkscrew. Penser à l'installer s'il ne l'est pas déjà.

$ apt-get install corkscrew

Pour se connecter au serveur C:

$ ssh serveurC

C'est quand même vachement simple ;)

Pour pouvoir se connecter à une machine distante sans être obligé de saisir un mot de passe, il faut utiliser un système d'authentification par clé privée / publique.

Ce système est très pratique dans le cas où vous utilisez les commandes ssh, scp et sftp dans des scripts.

Pour cela, il suffit d'utiliser la commande ssh-keygen.

Pré-requis :

Avoir un client SSH sur le poste client (openssh-client installé par défaut sur Ubuntu)
Sinon, installé le paquet suivant :

$ sudo apt-get install openssh-client

Avoir un serveur SSH sur la machine distante.
Installé, par exemple, openssh-server :

$ sudo apt-get install openssh-server

Génération d'une paire de clé privée / publique sur la machine client :

Dans l'exemple suivant, le poste client se nomme zeus et la machine distante zimbra.

$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):# Laisser la valeur par défaut
Enter passphrase (empty for no passphrase):# Appuyer directement sur "Entrée"
Enter same passphrase again:# Appuyer directement sur "Entrée"
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
a0:f3:e4:93:12:c4:41:5e:f3:ea:23:0e:79:f0:02:35 root@zeus
The key's randomart image is:
+--[ RSA 2048]----+
|   .o o          |
|   o o o         |
|  E + . .        |
| . o . o         |
|. . + o S        |
| . + B .         |
|  + = B          |
|   = o o         |
|    .            |
+-----------------+
$

Vérifier que les clés privée et publique ont bien été créées :

Les clés id_rsa et id_rsa.pub sont générées dans le répertoire $HOME/.ssh

$ cd $HOME/.ssh
$ ls -l
total 16
-rw------- 1 root root 1675 2011-12-21 19:43 id_rsa
-rw-r--r-- 1 root root  391 2011-12-21 19:43 id_rsa.pub
-rw-r--r-- 1 root root 4420 2011-11-02 21:25 known_hosts
$

Copier la clé publique id_rsa.pub du poste client dans le réperoire $HOME/.ssh de la machine distante via ssh-copy-id :

$ ssh-copy-id -i id_rsa.pub root@zimbra
root@zimbra's password:    # Saisir le mot de passe et appuyer sur "Entrée"
Now try logging into the machine, with "ssh 'root@zimbra'", and check in:
 
     .ssh/authorized_keys
 
to make sure we haven't added extra keys that you weren't expecting.
 
$

Comme indiqué dans le message précédent, se connecter au serveur distant afin de vérifier que la clé publique a bien été ajoutée au fichier ".ssh/authorized_keys" (si la procédure a fonctionnée correctement, aucun mot de passe ne doit être demandé) :

$ ssh -l root zimbra

Se rendre dans le répertoire $HOME/.ssh :

$ cd $HOME/.ssh
$ ls -l
total 12
-rw-r--r-- 1 root root 391 2011-12-21 20:40 authorized_keys
-rw-r--r-- 1 root root 442 2011-05-20 08:53 known_hosts
-rw-r--r-- 1 root root 391 2011-12-21 20:26 ma_cle_publique
$ cat authorized_keys       # Contenu du fichier "authorized_keys"
ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA492yBTCnwE3B7Xws0+bLYJt5G3tBI2P1v1Ld7Alp7FpJmBGzwwF
/dTwv+zh5Xr6ti2ElLQaotKj2YsR8WhFBAQqWcUR4J5/RLhMFttkANVp+3ixeDI8Id609JYcTACMz1h/lOFs38lp17KwwPZW1+tWBFovR4bwVpBNMucbuFy30LsarzdZsWnAiYfU/sLHRm/4cBZq1BF/fHjvaU3PT5NVsEuDyQg3vloW4vkAHErg6CUhp9GEUbBAPXqw== root@zeus
$ exit       # On quitte la machine distante

Pour se connecter à un serveur par un autre port que celui par défaut, utiliser la commande suivante :

$ ssh-copy-id -i id_rsa.pub "-p 10022 root@zimbra"

ou

$ ssh-copy-id -i id_rsa.pub -p 10022 root@zimbra

La procédure est terminée.

Vous pouvez désormais vous connecter à cette machine distante via ssh, scp ou sftp sans avoir à saisir un mot de passe.

Par contre, il faut être conscient des risques que cela peut engendrer.
N'importe qui ayant accès à la machine client aura automatiquement accès à la machine distante.
Ceci est à faire dans le cas où vous n'avez pas d'autres solutions.

Voir également cet article.

Dans l'exemple précédent, l'authentification automatique concernait l'utilisateur root de la machine zeus entre l'utilisateur root de la machine zimbra mais il est tout à fait possible de paramétrer une authentification automatique pour des utilisateurs différents entre le poste client et la machine distante.

Exemple :

Paramétrer une authentification automatique entre l'utilisateur toto du poste client client1 et l'utilisateur tutu de la machine distante serveur1.

Pour cela, il suffit de générer les clés privée/publique pour l'utilisateur toto sur le poste client client1 et de copier le contenu de la clé publique id_rsa.pub dans le fichier "authorized_keys" dans le répertoire $HOME/.ssh de l'utilisateur tutu de la machine distante serveur1.

La connexion suivante se fera sans saisie de mot de passe :

toto@client1:~$ ssh -l tutu serveur1

Pour générer des pages HTML colorisées contenant les différentes logs du système, il suffit d'utiliser la commande ccze.

Pour l'installer :

$ apt-get install ccze

Pour créer une page HTML contenant les données du fichier de log /var/log/syslog :

$ ccze -h < /var/log/syslog > /var/www/logsccze/syslog.html

Penser à créer auparavant le répertoire /var/www/logsccze

$ mkdir /var/www/logsccze

Utiliser un navigateur pour admirer le résultat en vous connectant sur votre serveur apache.

Sous Debian/Ubuntu, les paquets sont au format DEB.

A l'inverse, sous Red Hat (et ses dérivés), les paquets sont au format RPM.

Il arrive parfois que les paquets permettant l'installation d'applications ne soient disponible qu'au format RPM.

Pas de panique, sous Debian/Ubuntu, il existe une application qui permet de convertir des paquets RPM en DEB.

Cette application se nomme alien.

Pour l'installer :

$ sudo apt-get install alien

Convertir un paquet RPM en DEB :

$ alien --to-deb package.rpm

Convertir un paquet DEB en RPM :

$ alien --to-rpm package.deb

Convertir un paquet RPM en DEB et l'installer automatiquement :

$ alien -i package.rpm

La conversion vers le format DEB étant la conversion par défaut, il n'est pas nécessaire de le préciser.

Si, lors de l'installation du système, vous avez sous-estimé la taille de la partition d'échange SWAP (il est recommandé d'avoir une partition d'échange SWAP équivalent à la quantité de mémoire vive installée sur le système), il est possible de créer des fichiers supplémentaires post-installation.

Pour l'exemple, je vais créer un fichier SWAP d'1 Go dans le répertoire /mnt (avec le user root)

$ cd /mnt
$ dd if=/dev/zero of=1G.swap bs=1k count=1024000
$ du -sh ./1G.swap
1001M   ./1G.swap
$ chmod 600 /mnt/1G.swap
$ mkswap 1G.swap -f
$ swapon /mnt/1G.swap
$ swapon -s

Explications:

1. Avec la commande dd, je créé un fichier vide d'1 Go
2. Avec la commande du, je vérifie la taille de mon fichier créé
3. Avec la commande chmod, j'autorise la lecture et l'écriture uniquement pour le user root
4. Avec la commande mkswap, je convertis mon fichier en fichier d'échange SWAP
5. Avec la commande swapon, j'active mon nouveau fichier d'échange SWAP
6. Avec la commande swapon et le paramètre -s, je liste tous les fichiers SWAP actifs sur le système

Ajuster la configuration du swap

$ cat /proc/sys/vm/swappiness
60

Par défaut, dès 40% d'utilisation de la RAM (60% de mémoire libre), les données sont écrites dans la swap.

Avec un serveur équipé de 16Go de RAM, il est intéressant de diminuer cette valeur.

$ sysctl vm.swappiness=10

Utilisation de la swap à partir de 90% d'utilisation de la ram.

Pour une modification permanente, éditer le fichier /etc/sysctl.conf

$ echo "vm.swappiness=10" >> /etc/sysctl.conf

Pour effacer un disque dur de manière sûre, il suffit d'utiliser la commande dd et le fichier spécial /dev/urandom.

Premièrement, il faut identifier le disque à effacer et être certain de ne pas se tromper car la commande dd va détruire tout ce qui se trouve sur le disque.

$ 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: 640.1 GB, 640135028736 bytes
255 heads, 63 sectors/track, 77825 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: 0x3d4b96dc
 
   Device Boot      Start         End      Blocks   Id  System
/dev/sdd1               1       77825   625129312   83  Linux
 
$

Dans mon cas, je souhaite détruire toutes les données de mon disque de 160 GB. La commande fdisk -l m'indique qu'il s'agit du périphérique /dev/sdc.

J'exécute ensuite la commande suivante :

$ for n in `seq 7`; do dd if=/dev/urandom of=/dev/sdc bs=8b conv=notrunc; done

La commande précédente va donc écrire 7 fois de suite sur tout le disque des données aléatoires rendant ainsi illisible toutes les données précédentes.

Pour coloriser la commande grep, il existe 2 méthodes :

1 - Préciser l'option --color=always à chaque utilisation de la commande grep

$ cat .bashrc | grep --color=always '^alias'
alias ls='ls $LS_OPTIONS'
alias ll='ls $LS_OPTIONS -la'
alias l='ls $LS_OPTIONS -lA'
alias maj='apt-get update && apt-get upgrade'
$

2 - Ajouter un alias au fichier .bashrc

$ echo "alias grep='grep --color=always'" >> .bashrc
$ cat .bashrc
...
alias grep='grep --color=always'
$

Puis recharger le fichier .bashrc

$ . .bashrc
$

La colorisation sera automatique à chaque utilisation de la commande grep

$ cat .bashrc | grep '^alias'
alias ls='ls $LS_OPTIONS'
alias ll='ls $LS_OPTIONS -la'
alias l='ls $LS_OPTIONS -lA'
alias maj='apt-get update && apt-get upgrade'
alias grep='grep --color=always'
$

Pour forcer la coloration du prompt dans une distribution type Debian, il suffit de décommenter la ligne suivante dans le fichier ~/.bashrc

$ cat .bashrc
...
# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
force_color_prompt=yes
...
$ 

Si on utilise un projet GIT via une connexion http(s) nécessitant une authentification, il est donc nécessaire de s'authentifier à chaque pull et commit effectués.

Ca devient vite contraignant au bout d'un moment.

Il est donc possible d'enregistrer dans un fichier les paramètres de connexion.

Le fichier ~/.gitconfig :

[user]
        name = monNom
        email = monEmail
[credential]
        helper = store
[http]
        sslVerify = false
        postBuffer = 524288000
[credential "http://monDepotGit.com"]
        username = monUser
[credential "https://monDepotGit.com"]
        username = monUser

- La section [user] contient les infos personnelles (nom, email etc etc ...)
- Le fichier doit contenir la section [credential] avec la variable helper = store
- La section [http] avec la variable sslVerify = false permet de se connecter en https sur un dépot GIT avec un certificat non reconnu (auto-signé)
La variable postBuffer = 524288000 permet de résoudre l'erreur suivante lors des commits:
error: RPC failed; result=22, HTTP code = 411
Cela permettra à tous les projets locaux d'envoyer jusqu'à 500 Mo de données.
- Enfin, la section [credential "adresse http(s)"] contient l'adresse http(s) du dépot GIT ainsi que le username correspondant. La section est répétée autant de fois qu'il y a d'adresses différentes de dépots GIT.

Le fichier ~/.git-credentials :

Ce fichier contient le username associé au mot de passe et à l'adresse http(s) renseignée dans le fichier ~/.gitconfig

Ce fichier doit être lisible uniquement par le user concerné (chmod 0600).

http://monUser:monPassword@monDepotGit.com
https://monUser:monPassword@monDepotGit.com

Si le username et/ou le password contient un des caractères spécifiques à la chaine de connexion (:/@), il est obligatoire de l'écrire en hexadécimal.

@ = %40 en hexadécimal

Sinon, le simple fait de créer le fichier ~/.git-credentials et de lui attribuer le bon mode 0600, il sera automatiquement complété avec le bonne combinaison user:password@adresseHttps à la première utilisation de la comme git pull (par exemple).

Gammu est un utilitaire permettant d'utiliser un téléphone portable via le port USB.

Pour installer gammu :

$ apt-get install gammu

Quelques commandes utiles :

Envoyer un sms

$ echo "Mon premier SMS" | gammu --sendsms TEXT 06xxxxxxxx

Afficher les dossiers SMS du téléphone

$ gammu getsmsfolders

Afficher tous les sms du téléphone

$ gammu getallsms

Astuce :

Un vieux téléphone qui ne sert à rien + une carte sim Free avec un forfait 2H à 0€ = un système de communication pour un serveur afin d'avertir l'administrateur système en cas de défaillance et permettre également à l'administrateur d'envoyer des commandes au serveur. La classe !!!

Par exemple, avertir en cas d'intrusion, démarrer un service SSH ou autre, avertir en cas de défaillance réseau (internet), avertir en cas de coupure de courant (disposer d'un UPS bien sûr) etc etc ... Le potentiel est énorme.

Le seul inconvénient, pour que gammu fonctionne parfaitement (via des scripts exécutés automatiquement), il faut avoir une session constamment ouverte sur le système.

Pour gérer les services qui se lancent automatiquement au démarrage, il suffit d'utiliser le programme SYSV-RC-CONF.

Pour l'installer :

$ sudo apt-get install sysv-rc-conf

Utilisation :

$ sudo sysv-rc-conf

Les services lancés automatiquement au démarrage ont un niveau d'exécution de 2 à 5

Pour désactiver un service au démarrage, il suffit de décocher tous les niveaux d'exécution de 2 à 5 en se positionnant sur les "X" à l'aide des flèches du clavier et en appuyant ensuite sur la barre espace.

Pour faire défiler les pages, il suffit d'appuyer sur les touches CTRL + N pour la page suivante ou CTRL + P pour la page précédente.

CAcert.org est une association qui fourni gratuitement des certificats ssl (signature, chiffrement, connexion, certificats https).

Pour un bon fonctionnement du service, il est nécessaire d'installer les certificats racine de CAcert.org.

Sur Debian/Ubuntu, tous les certificats racine sont installés dans le répertoire /etc/ssl/certs.

Pour x raisons, il peut être nécessaire d'inverser le contenu d'un fichier texte.
Par exemple, pour afficher le contenu d'un fichier de logs dans l'ordre inverse.

Suite à la remarque de barbay, la commande tac permet d'inverser le contenu d'un fichier texte.

$ tac /var/log/syslog

Sinon, pour inverser le contenu d'un fichier texte, il est possible d'utiliser l'enchainement de commandes suivant :

Pour commencer, j'affiche le contenu du fichier avec la commande cat :

$ cat /var/log/syslog

J'enchaine avec la commande nl qui permet de numéroter les lignes du fichier :

$ cat /var/log/syslog | nl

J'enchaine avec la commande sort qui permet de trier le contenu du fichier numériquement (avec l'option -n) et en ordre inverse (avec l'option -r) sur la première colonne du fichier contenant les numéros de lignes générés par la commande nl :

$ cat /var/log/syslog | nl | sort -n -r

Il reste maintenant à supprimer la première colonne du fichier contenant les numéros de lignes avec la commande cut :

$ cat /var/log/syslog | nl | sort -n -r | cut -f2

Et voilà, le fichier s'affiche à l'écran dans l'ordre inverse.

Sous Linux, que ce soit sur une version Desktop ou Server, 6 terminaux sont en permanence à disposition.

Pour les activer, rien de plus simple.

Sur un version Desktop ou Server, les différents terminaux sont accessibles
via les combinaisons des touches suivantes :

• Ctrl + Alt + F1 : terminal 1 (tty1)
• Ctrl + Alt + F2 : terminal 2 (tty2)
• Ctrl + Alt + F3 : terminal 3 (tty3)
• Ctrl + Alt + F4 : terminal 4 (tty4)
• Ctrl + Alt + F5 : terminal 5 (tty5)
• Ctrl + Alt + F6 : terminal 6 (tty6)

Sur une version Desktop, une fois basculé en mode console, il est possible de revenir au mode graphique grâce à la combinaison des touches suivantes :

• Ctrl + Alt + F7 : retour au mode graphique

Le fait d'utiliser la mémoire vive d'une machine comme espace de stockage permet d'accéder aux données à des vitesses défiant toute concurrence.

Si l'avantage est grand, l'inconvénient l'est tout autant. Effectivement, en cas de coupure de courant, toutes les données se trouvant en mémoire vive sont perdues à jamais.

C'est pour cette raison que je préconise l'usage de cette méthode à des fins de lecture uniquement.
Ce qui est déjà un bon compromis.

Un autre inconvénient réside dans le fait que la taille des données à stocker est limitée à la taille de la mémoire vive disponible.
Sur les systèmes récents, la quantité de mémoire vive disponible étant assez conséquente, ça ne devrait donc pas être un problème.

Si vous devez utiliser une base de données sqlite et/ou des fichiers textes pour y lire des données, pourquoi ne pas les stocker dans la mémoire vive afin d'y accéder plus rapidement.

Voici la marche à suivre (on utilise comme type de système de fichier tmpfs):

On créé le répertoire qui servira de point de montage

# mkdir /tmpfs

On monte le répertoire en mémoire

# mount -t tmpfs no-device /tmpfs

Dorénavant, tout ce qui sera stocké dans le répertoire /tmpfs sera automatiquement stocké dans la mémoire vive.

Un petit script au démarrage du système qui se charge d'effectuer le point de montage et d'y copier les fichiers (fichiers textes, base de données sqlite etc etc...) et le tour est joué.

Le site www.iana.org recense la liste complète des extensions de domaines.

Il peut-être utile d'en avoir une copie dans un fichier (pour l'utiliser avec la commande grep par exemple).

Pré requis:

$ apt-get install curl html2text awk

Création du fichier ROOT:

$ curl http://www.iana.org/domains/root/db -o - 2>/dev/null | html2text | awk '$1 ~ "^\\." {printf("\\%s\n",$1)}' > ROOT

$ head ROOT
\.abbott
\.abogado
\.ac
\.academy
\.accountant
\.accountants
\.active
\.actor
\.ad
\.ads

Ce fichier peut ensuite être utilisé avec la commande grep pour filtrer des adresses web par exemple.

$ grep -f ROOT monFichierLog

Un ajout dans crontab permet d'avoir cette liste constamment à jour.

Configurer Postfix sous Ubuntu est un jeu d'enfant grâce à la commande

$ dpkg-reconfigure postfix

Quand il s'agit d'ajouter l'anti-spam spamassassin à la configuration de Postfix, ça se complique un peu.

Dans un premier temps, il faut installer spamassassin

$ apt-get install spamassassin

Il faut ensuite créer le répertoire de spamassassin, ajouter le user et le group suivant au système et enfin régler les permissions sur le répertoire

$ mkdir /var/spool/spamassassin
$ useradd -d /var/spool/spamassassin -s /bin/false spamassassin
$ chown spamassassin:spamassassin /var/spool/spamassassin -Rc

Il faut activer spamassassin en modifiant le fichier suivant comme indiqué

$ cat /etc/default/spamassassin | egrep -v '^(#|$)'
ENABLED=1
OPTIONS="--create-prefs --max-children 5 --helper-home-dir -u spamassassin -g spamassassin"
PIDFILE="/var/run/spamd.pid"
CRON=1

J'ai également modifié le fichier /etc/spamassassin/local.cf afin de ré-écrire le début de l'objet des mails considérés comme du spam
    rewrite_header Subject __SPAM__

Redémarrer spamassassin afin de prendre en compte la nouvelle configuration

$ service spamassassin restart

Il faut ensuite modifier le fichier /etc/postfix/master.cf afin d'ajouter les éléments suivants
1 - Remplacer la ligne smtp par celle-ci
    smtp      inet  n       -       n       -       -       smtpd   -o content_filter=spamassassin
2 - A la fin du fichier, ajouter la ligne suivante
    spamassassin unix -     n       n       -       -       pipe user=spamassassin argv=/usr/bin/spamc -f -e /usr/sbin/sendmail -oi -f ${sender} ${recipient}

Reste à redémarrer Postfix

$ service postfix restart

Dorénavant, tous les spams auront la mention __SPAM__ dans l'objet, reste à faire une règle dans son client mail afin de les placer directement dans le dossier spam

Dans Linux, pour modifier le clavier à utiliser, saisir dans une console :

Pour un passage de qwerty en azerty

$ loadkeys fr
$ apt-get install console-data (si besoin)
$ dpkg-reconfigure console-setup
$ loadkeys fr
$ dpkg-reconfigure console-data

Pour un passage de azerty en qwerty

$ loadkeys us
$ apt-get install console-data (si besoin)
$ dpkg-reconfigure console-setup
$ loadkeys fr
$ dpkg-reconfigure console-data

Clavier AZERTY

Clavier QWERTY

Tout dépend du niveau de sécurité configuré pour SELinux.

Il existe 3 modes différents:
- enforcing
- permissive
- disabled

Dans le cas des 2 derniers (permissive & disabled) il ne devrait pas y avoir de problème pour activer et démarrer un nouveau service systemd.

Par contre, si le mode est enforcing, il y a de grandes chances pour que cela empêche le démarrage d'un nouveau service.

Pour le vérifier:

$ sestatus
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   enforcing
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Memory protection checking:     actual (secure)
Max kernel policy version:      33

Donc, si le mode SELinux est enforcing et que vous avez créé un nouveau service et que celui-ci n'arrive pas à démarrer, suivre la procédure ci-dessous.

Exemple avec une distribution AlmaLinux:

Installer le paquet policycoreutils-python-utils.noarch

$ sudo dnf install -y policycoreutils-python-utils.noarch

Exécuter les 2 commandes suivantes:

$ sudo ausearch -m avc -ts today | audit2allow -M le_nom_de_mon_service
$ sudo semodule -i le_nom_de_mon_service.pp

En théorie, l'exécution de la première commande indique d'exécuter la seconde commande.
Modifier le terme le_nom_de_mon_service

Et enfin:

$ sudo systemctl start le_nom_de_mon_service.service
$ sudo systemctl status le_nom_de_mon_service.service

Le problème devrait être réglé.

Récapitulatifs des différentes manières de supprimer les retours à la ligne dans une chaine de caractères.

$ A=$(echo -e "Ceci est une chaine\navec des retours\nà la ligne.")
$ echo "$A"
Ceci est une chaine
avec des retours
à la ligne.

Avec la commande tr

Suppression du retour à la ligne :

$ tr -d "\n" <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ tr "\n" " " <<< "$A"
Ceci est une chaine avec des retours à la ligne.

Avec la commande sed

Suppression du retour à la ligne :

$ sed ':a;N;$!ba;s/\n//g' <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ sed ':a;N;$!ba;s/\n/ /g' <<< "$A"
Ceci est une chaine avec des retours à la ligne.

Avec la commande read

Suppression du retour à la ligne :

$ while read L; do printf "%s" "$L"; done <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ while read L; do printf "%s" "$L "; done <<< "$A"
Ceci est une chaine avec des retours à la ligne.

Avec la commande perl

Suppression du retour à la ligne :

$ perl -p -e 's/\n//' <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ perl -p -e 's/\n/ /' <<< "$A"
Ceci est une chaine avec des retours à la ligne.

Avec la commande paste

Suppression du retour à la ligne :

$ paste -s -d '' <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ paste -s -d ' ' <<< "$A"
Ceci est une chaine avec des retours à la ligne.

Avec la commande awk

Suppression du retour à la ligne :

$ awk 1 ORS='' <<< "$A"
Ceci est une chaineavec des retoursà la ligne.

Remplacement du retour à la ligne par un espace :

$ awk 1 ORS=' ' <<< "$A"
Ceci est une chaine avec des retours à la ligne.

.

Le changement régulier du password permettant la connexion à son serveur SSH est la garantie d'avoir une haute sécurité.

Le dire, c'est bien mais le faire, c'est mieux.

Le faire tous les combiens de temps ? Que mettre en password ? Vais-je m'en souvenir ?

Voici un petit enchainement de commandes, à enregistrer dans crontab et qui permet de générer aléatoirement un password pour le user désiré grâce à la commande pwgen, de le modifier automatiquement grâce à la commande chpasswd puis de l'envoyer par mail.

$ passwd="user1:`/usr/bin/pwgen -s -y -c 14 1`" && /bin/echo $passwd | /usr/sbin/chpasswd && /bin/echo $passwd | /usr/bin/mail -s "Il fait beau aujourd\'hui" user1@domaine.fr && passwd=""

Pour installer la commande pwgen (par défaut sur Ubuntu) :

$ apt-get install pwgen

Détail de la commande pwgen :

-s : génère des mots de passe complètement aléatoires
-y : insère au moins 1 caractère spécial
-c : insère au moins 1 lettre majuscule
Le nombre 14 indique que l'on veut générer un mot de passe de 14 caractères
Le chiffre 1 indique que l'on veut générer 1 seul mot de passe

L'envoi par mail peut être remplacé par un envoi par sms grâce à la commande gammu.

Pour récupérer les données sur un disque ayant des secteurs défectueux, il est possible d'utiliser la commande dd comme ceci.

L'opération doit être effectuée sur un disque ou une partition non montée.

Première méthode :
On recopie les données de disque à disque.

if=/dev/hdx : correspond au disque source (défectueux)
of=/dev/hdy : correspond au disque cible

Attention à ne pas inverser le if et le of

if pour input (entrée)
of pour output (sortie)

$ dd bs=4k if=/dev/hdx of=/dev/hdy conv=noerror,sync

L'exemple ci-dessus utilise des disques entiers mais il est possible d'effectuer l'opération sur des partitions.

Seconde méthode :
On recopie les données du disque vers un fichier.

$ dd bs=4k if=/dev/hdx of=/path/to/image conv=noerror,sync

Idem avec des partitions.

Je me suis acheté une enceinte bluetooth JBL Flip 5 et quand je l'ai connecté sur mon portable équipé de Ubuntu 20, grosse déception, aucun son, le néant.

Alors que sur mon smartphone, aucun problème.

Une petite recherche sur internet m'a permis de trouver la solution ci-dessous:

$ sudo apt-get install pavucontrol

Formidable, problème réglé....

Un bastion SSH, qu'est-ce que c'est que ce truc là ?

Dans le cadre d'une grappe de serveurs devant être administrés à distance, un bastion SSH est un serveur sur lequel un serveur SSH (openssh-server par exemple) est installé et par lequel on peut accèder en SSH aux autres serveurs.

Le but est d'utiliser ce serveur comme serveur de rebond afin d'accéder aux différents serveurs.

Dans un premier temps, il est nécessaire de créer un nouveau serveur sur lequel nous installerons un serveur SSH.

Pour l'exemple, je vais créer un nouveau serveur avec OpensSUSE 15.5 et installer openssh-server.

Une machine virtuelle sous Proxmox équipée d'un CPU, de 8 Go de disque et 512 Mo de mémoire vive suffira amplement.

Faire en sorte que ce serveur et seulement ce serveur soit accessible, de l'extérieur, via le port SSH 22 (ou autre si vous souhaitez sécuriser encore plus l'accès au bastion SSH).

# zypper in openssh-server

Pour la configuration du serveur SSH, quelques lignes suffisent.

# cat /etc/ssh/sshd_config
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no
AuthorizedKeysFile      .ssh/authorized_keys
PrintMotd no
Subsystem       sftp    /usr/lib/ssh/sftp-server
AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES
AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT
AcceptEnv LC_IDENTIFICATION LC_ALL
AllowUsers toto

Quelques petites explications:
Ligne 1, on interdit la connexion avec le compte "root"
Ligne 2, on autorise la connexion à l'aide d'une clé SSH
Ligne 3, 4 et 5, on interdit l'authentification par mot de passe
Ligne 6, permet d'indiquer le fichier contenant les clés autorisées à se connecter
Ligne 7, on désactive l'affichage du contenu du fichier /etc/motd
Ligne 8 à 11, divers paramètres
Ligne 12, permet d'indiquer le ou les utilisateurs autorisés à se connecter

Ensuite, il est nécessaire de créer l'utilisateur avec lequel on se connectera au serveur SSH.

L'important est de créer un utiilisateur n'ayant aucun droit de se connecter au serveur SSH servant de bastion.

# useradd -m -s /bin/false toto

Sur le serveur client, ou n'importe quel autre serveur, créer un clé ssh qui sera utilisée pour se connecter au bastion SSH.
Voir un exemple ici https://isbeta.fr/LsUB2 (créer une clé SSH avec ou sans protection par mot de passe, à vous de choisir)

Pour la suite des opérations, je vais partir du principe que la clé ssh permettant de se connecter au bastion SSH se nommera id_rsa.toto et la clé publique id_rsa.toto.pub

Ensuite, il est nécessaire de copier la clé publique (celle créée ci-dessus id_rsa.toto.pub) dans le fichier authorized_keys du bastion SSH.

Créer le dossier .ssh dans le dossier de l'utilisateur toto du bastion SSH.

# mkdir /home/toto/.ssh
# chown toto /home/toto/.ssh
# chmod 0700 /home/toto/.ssh

Créer ensuite le fichier authorized_keys et y copier la clé publique

# touch /home/toto/.ssh/authorized_keys
# vim /home/toto/.ssh/authorized_keys
# cat /home/toto/.ssh/authorized_keys
ssh-rsa xxxx...lgjgdlkffgjdlkg=
# chown toto /home/toto/.ssh/authorized_keys
# chmod 0600 /home/toto/.ssh/authorized_keys

En théorie, la configuration du bastion SSH est terminée.
Le serveur SSH a été paramétré, le user "toto" autorisé à se connecter a été créé et la clé SSH  a été renseignée dans le fichier .ssh/authorized_keys du user "toto".

Maintenant, coté client, il est nécessaire de configurer l'accès au bastion SSH.

Modifier le fichier .ssh/config du client.

# cat .ssh/config
Host monbastion.loc
    Hostname monbastion.loc
    User toto
    Port 22
    TCPKeepAlive yes
    IdentityFile ~/.ssh/id_rsa.toto
Host mon_serveur_nginx
    Hostname 192.168.1.50
    User root
    Port 22
    TCPKeepAlive yes
    ProxyJump monbastion.loc
    IdentityFile ~/.ssh/id_rsa
Host mon_serveur_mariadb
    Hostname 192.168.1.60
    User root
    Port 22
    TCPKeepAlive yes
    ProxyJump monbastion.loc
    IdentityFile ~/.ssh/id_rsa

Quelques explications:

Le premier host correspond au bastion SSH accessible via internet, rien de bien compliqué, excepté peut-être le paramètre IdentityFile faisant référence à la clé SSH id_rsa.toto, l'unique clé autorisée à se connecter au bastion SSH avec le user toto.

Le second host, est celui qui correspond, pour l'exemple, à mon serveur nginx, inaccessible via internet en SSH, seulement en HTTP et HTTPS.
Pour pouvoir y acccéder, j'indique via le paramètre ProxyJump, d'utiliser le host monbastion.loc pour pouvoir y accéder en SSH. Le paramètre IdentityFile permet d'indiquer une autre clé SSH autorisée à se connecter au serveur nginx.

Idem pour le troisième host.

Les adresses IP indiquées pour les hosts 2 et 3 doivent être accessible via le bastion SSH.

Il est possible de renseigner différents serveurs utilisant le bastion SSH commme serveur de rebond.

Et voilà, la configuration est enfin terminée.
Pour se connecter au serveur nginx, par exemple:

# ssh mon_serveur_nginx

C'est tout simple, la connexion via monbastion.loc est complètement transparente.

Mon dash (tableau de bord) est planté.

Les applications ne sont plus affichées. 

Résultat, je ne peux plus lancer mes applications via le dash. C'est vraiment pas très pratique.

Pour corriger les anomalies du dash, une seule chose à faire. Le restaurer.

Pour cela, il suffit juste de supprimer le fichier ~/.local/share/zeitgeist/activity.sqlite

$ cp -a ~/.local/share/zeitgeist/activity.sqlite ~/
$ rm ~/.local/share/zeitgeist/activity.sqlite

Bien entendu, avant toute suppression, on le sauvegarde. Juste au cas où.
Prudence est mère de sûreté.

On redémarre la machine et normalement, tout est rentré dans l'ordre.
Enfin, j'espère ;o)

J'en ai rêvé, Harel Ben-Attia l'a fait.

Utiliser des fichiers texte comme des tables SQL.
C'est ce que propose de faire la commande q.

Ce programme est développé en python.
Pour fonctionner, il utilise donc python 2.4 (minimum) et le module sqlite3.

Il est possible d'utiliser des fichiers texte dont le séparateur de colonne (par défaut) est l'espace.
N'importe quel autre séparateur est utilisable à condition de l'indiquer à l'aide de l'option -d
Si le fichier texte contient une ligne d'en-tête, il est possible de l'indiquer à l'aide de l'option -H et cela permet d'utiliser les en-têtes comme nom de colonne dans les requêtes SQL.
L'option -z permet d'utiliser des fichiers compressés avec gzip.

Le projet est disponible ici.

Un paquet RPM est disponible pour l'installation.
Pour les distributions Debian/Ubuntu, utiliser le programme alien pour convertir le paquet RPM en DEB.

Pour l'installtion, sous Debian/Ubuntu, après conversion du paquet :

$ dpkg --install q_xxx_all.deb

Les différentes utilisations possibles :

Utiliser la commande q derrière un pipe

Par exemple, la commande ls -l retourne le contenu d'un répertoire structuré en colonne.

Par conséquent, du fait que le retour de cette commande soit structuré, il est possible de l'envoyer à la commande q via un pipe et d'y effectuer des petites requêtes SQL.

$ ls -l /var/log
-rw-r--r-- 1 root   root    3554 Mar 12 14:09 alternatives.log
-rw-r--r-- 1 root   root    1208 Feb 21 10:51 alternatives.log.1
-rw-r--r-- 1 root   root     246 Jan 27 18:17 alternatives.log.2.gz
-rw-r--r-- 1 root   root     385 Jan  6 21:10 alternatives.log.3.gz
-rw-r--r-- 1 root   root     539 Nov 22 08:16 alternatives.log.4.gz
-rw-r--r-- 1 root   root     276 Oct 24 16:47 alternatives.log.5.gz
-rw-r--r-- 1 root   root     948 Sep 23 22:35 alternatives.log.6.gz
drwxr-xr-x 2 root   root    4096 Mar  1 05:00 apt
-rw-r----- 1 syslog adm   370529 Mar 12 14:16 auth.log

Envoyer un mail via la commande telnet permet de tester la configuration d'un serveur SMTP.

En rouge, les informations à saisir.

$ telnet smtp.free.fr 25
Trying 212.27.48.4...
Connected to smtp.free.fr.
Escape character is '^]'.
220 smtp4-g21.free.fr ESMTP Postfix
HELO test.domain.com
250 smtp4-g21.free.fr
MAIL FROM:<test@domain.com>
250 2.1.0 Ok
RCPT TO:<toto@domain.fr>
250 2.1.5 Ok
DATA
354 End data with <CR><LF>.<CR><LF>
Subject: test message
This is the body of the message!
.
250 2.0.0 Ok: queued as 2D8FD4C80FF
quit
221 2.0.0 Bye
Connection closed by foreign host.

Explications :

1. Connexion au serveur SMTP sur le port 25
2. Le serveur nous renvoie quelques informations
3. Exécution de la commande HELO avec le nom de notre domaine en paramètre
4. Le serveur nous répond qu'il est OK
5. On indique l'émetteur grâce à la commande MAIL FROM
6. Le serveur nous répond qu'il est OK
7. On indique le destinataire grâce à la commande RCPT TO
8. Le serveur nous répond qu'il est OK
9. On indique le début du message grâce à la commande DATA
10. Le serveur nous indique qu'il faut saisir un point (.) pour terminer le message
11. On indique le sujet du message
12. On saisie le corp du message
13. On saisi un point (.) pour indiquer la fin du message
14. Le serveur nous répond qu'il est OK
15. On ferme la connexion grâce à la commande quit

Si une authentification est nécessaire, après avoir envoyé la commande HELO, il suffit d'envoyer la commande AUTH LOGIN (après le point 4).

Le serveur répond en affichant "334 VXNlcm5hbWU6".
Cette chaine est encodée en base64. 
Traduction en langage humain : "334 Username:"
Il suffit donc de répondre en renseignant son username encodé, bien sûr, en base64.
Le serveur répond ensuite en affichant "334 UGFzc3dvcmQ6".
Cette chaine est également encodée en base64.
Traduction en langage humain : "334 Password:"
Il suffit donc de répondre en renseignant son password encodé, également, en base64.
Si tout se passe bien, le serveur doit répondre "235 Authentication successful"
Reste à continuer la procédure à partir du point 5.

Pour l'encodage en base64, toutes les infos ici.

Pour utiliser un serveur FTP dans un script, il faut que l'identification se fasse également via le script.
Par contre, la sécurité du serveur FTP est diminuée du fait d'avoir en clair dans le script les identifiants de connexion.
Cette méthode est donc à utiliser avec des serveurs FTP ne contenant pas de données sensibles.

L'exemple suivant permet de télécharger du serveur ftp "ftp.tutu.fr" le fichier "fichier.txt" en utilisant l'identifiant "toto" et le mot de passe "tata"

#!/bin/bash
loginftp="toto"
motdepassftp="tata"
host_ftp="ftp.tutu.fr"
mon_fichier="fichier.txt"
# On se positionne dans le dossier /tmp
# où sera téléchargé le fichier du serveur FTP
cd /tmp
ftp -in <<EOF
open $host_ftp
user $loginftp $motdepassftp
get $mon_fichier
close
bye
EOF
# Je peux ensuite exécuter d'autres commandes
# sur le fichier téléchargé
exit 0

Il ne reste plus qu'à automatiser le script avec une tâche cron.

La commande watch permet d'exécuter à intervalle régulière n'importe quelle commande passée en paramètre.

La période de rafraichissement par défaut est de 2 secondes.

L'option -n permet d'indiquer une période de rafraichissement en secondes.
L'option -d permet de mettre en surbrillance les différences survenues entre 2 périodes de rafraichissement.

Surveiller le contenu d'un répertoire :

$ watch -d ls -l /tmp

Cette commande  affiche à l'écran le contenu du répertoire /tmp et raffraichit l'affichage toutes les 2 secondes en mettant les différences en surbrillance (option -d).
Dès qu'un fichier/répertoire est créé/modifié/supprimé l'information apparait à l'écran.

Idem mais toutes les 10 secondes :

$ watch -n 10 -d ls -l /tmp

Surveiller la reconstruction d'un volume RAID :

$ watch cat /proc/mdstat

Surveiller les connexions et l'utilisation d'un serveur :

$ watch -d w
$ watch -d uptime

Qu'est ce que Windigo ?

Windigo est un "virus" infectant les serveurs UNIX (entre autres) et qui utilise ces derniers pour envoyer des spams en grosse quantité.

Pour que le virus soit actif, une backdoor OpenSSH dénommée "Ebury" doit être installée manuellement sur les serveurs par les hackers.

Pour vérifier l'infection du système, il est nécessaire d'exécuter la commande suivante :

$ ssh -G 2>&1 | grep -e illegal -e unknown > /dev/null && echo "System clean" || echo "System infected"

Cette commande peut paraitre compliquée alors qu'elle est, au contraire, toute simple.

Que fait-elle exactement ?

Si le système est infecté, la backdoor OpenSSH utilise l'option -G de la commande ssh qui normalement n'existe pas si le système est sain.

Pour faire simple, il suffit donc d'exécuter la commande ssh avec cette fameuse option (-G) pour voir si le système est compromis.

$ ssh -G
ssh: illegal option -- G

Si la commande retourne une erreur, comme celle indiquée ci-dessus, c'est que le système est sain.

A l'inverse, si aucune erreur n'est retournée par la commande, c'est que le système est compromis et qu'il faut donc, rapidement, y remédier.
Pour cela, il est nécessaire de formater le serveur et d'y réinstaller un système complet.
Il faut également changer tous les mots de passe et clés privées.

Utiliser des applications graphiques d'un serveur (Ubuntu/Debian/CentOS) sur un poste Windows via une connexion SSH.

Pré-requis coté server :

$ sudo apt-get install openssh-server
$ sudo apt-get install xvfb xdm xfonts-base
$ sudo apt-get install twm "xfonts-100dpi*" xterm

Activer X11Forwarding dans la configuration du serveur SSH distant:

# cat /etc/ssh/sshd_config | grep X11
X11Forwarding yes

Pré-requis coté client (Windows par exemple) :

Putty

Xming

Mise en oeuvre :

Ouvrir Xming

Ouvrir Putty

Saisir l'adresse IP du serveur

Dans "Connexion" --> "SSH" --> "X11", cocher "Enable X11 forwarding"

Ciquer sur "OPEN"

Dans la console Putty, saisir "Login" et "Password"

Pour ouvrir une console par exemple saisir :

$ xterm &

La variable $DISPLAY permet de vérifier que le X11Forwarding est bien activé:

# echo $DISPLAY
localhost:10.0

La commande xauth list permet d'afficher le magic cookie indispensable au X11Forwarding :

# xauth list
monServeur/unix:10  MIT-MAGIC-COOKIE-1  17e3926a07573d0c51be57158896cf4c

Conserver le X11Forwarding et le magic cookie après avoir changé d'utilisateur:

Dans le cas où vous auriez besoin de lancer une application avec un utilisateur différent de celui utilisé pour la connexion SSH, il faut obligatoirement transmettre au nouvel utilisateur le magic cookie.

Utiliser la commande précédente pour afficher le magic cookie (xauth list):

Changer d'utilisateur et ajouter le magic cookie à l'aide de la commande xauth add et en paramètre, le résultat de la commande xauth list:

# su - user1

$ xauth add monServeur/unix:10  MIT-MAGIC-COOKIE-1  17e3926a07573d0c51be57158896cf4c

gocr est une commande qui permet de faire de la reconnaissance de caractères sous GNU/Linux.

Elle utilise des fichiers au format pnm.

Pré requis :

Pour utiliser gocr, il est nécessaire d'installer le programme djpeg qui permet de convertir un fichier jpeg en pnm.

$ sudo apt-get install gocr libjpeg-progs

Utilisation :

Je vais partir du cas le plus complet c'est à dire effectuer une reconnaissance de caractères à partir d'un fichier PDF (une facture par exemple).

Je dois donc convertir ce fichier PDF en fichier PNM.

Je vais utiliser la commande convert qui permet de convertir un fichier PDF en JPEG, puis la commande djpeg pour convertir mon fichier JPEG en PNM.

Il faut que le fichier JPEG généré à partir du fichier PDF soit d'une excellente qualité ( -density 500).

Pour finir, conversion du fichier JPEG en PNM avec la commande djpeg puis envoi du résulat à la commande gocr qui va écrire le contenu dans un fichier texte.

Le résultat obtenu est assez satisfaisant.

jigl est un programme qui permet de générer une gallerie photo HTML à partir d'images se trouvant dans un répertoire.

Un petit exemple de ce qu'il est possible de faire avec jigl.

Installation :

$ apt-get install jigl

Générer sa première gallerie :

1 - Copier toutes les images dans un répertoire (dans l'exemple suivant les images se trouvent dans le répertoire "testJigl").

2 - Générer la gallerie en exécutant la commande suivante :

$ jigl testJigl

Une fois l'opération terminée, 3 répertoires ont été créés dans le répertoire "testJigl"

testJigl/slides
testJigl/thumbs
testJigl/web

C'est dans le répertoire "web" que se trouvent la gallerie HTML.
2 pages HTML ont été créées par images ainsi qu'un page "index.html".

Il est possible d'ajouter des options afin de personnaliser sa gallerie, comme par exemple :

- Spécifier le titre de la page index.html avec l'option --index-title "Mon Titre"
- Spécifier le nombre de lignes affichées sur la page index.html avec l'option --index-row 5 (permet d'afficher 5 lignes).
- Spécifier le thème à utiliser avec l'option --theme nomDuTheme (black, jovotek, white)
- Spécifier le répertoire web de destination avec l'option --web-dir nomDuRepertoire

Plus d'info avec :

$ jigl --help

Pixelize

Pixelize est une application permettant de pixeliser une image en utilisant d'autres images référencées dans sa base de données.

Pré-requis

Installer l'application pixelize

$ apt-get install pixelize

Configuration

Avant d'utiliser pixelize, il est nécessaire de mettre à jour sa base de données. Il s'agit d'un fichier nommé pic_db.dat situé dans le répertoire home (~/pic_db.dat).
Pour le mettre à jour, rien de plus simple. Il suffit d'utiliser l'utilitaire make_db de pixelize.
Pixelize reconnait les formats d'images les plus courants.

Pour mettre à jour la base de données avec le contenu d'un répertoire contenant des images :

$ make_db /mon_repertoire/*.jpg

Ou pour mettre à jour la base de données avec des images se trouvant dans un ensemble de sous-répertoires :

$ find /mon_repertoire -iname "*.jpg" -print | xargs make_db

Plus il y aura d'images référencées dans la base de données, meilleure sera la pixelisation.

Utilisation

Pour utiliser pixelize, il est recommandé de lancer l'application à partir d'un terminal

$ pixelize

De cette manière, en cas d'erreur, celles-ci s'afficheront dans le terminal.

Pour pixeliser une image, utiliser le menu "File => Open" puis sélectionner l'image souhaitée.
Pour lancer la pixelisation cliquer sur "Options => Render"

Le temps de pixelisation est fonction de la taille de la photo à pixeliser et de la quantité d'images référencées dans sa base de données.

Pour sauvegarder l'image pixelisée, cliquer sur "File => Save". Il faut obligatoirement indiquer l'extension du fichier (jpeg, bmp, png ...)

Exemple

Image d'origine

Pixelisation effectuée avec une base de 400 photos

Pixelisation effectuée avec une base de 11 000 photos

Documentation Ubuntu

Site de l'auteur

Sur les systèmes Debian et dérivés, pour corriger l'erreur
    syslog-ng: Error setting capabilities, capability management disabled; error='Operation not permitted'
il suffit de décommenter la ligne SYSLOGNG_OPTS="--no-caps" dans le fichier /etc/default/syslog-ng.

$ cat /etc/default/syslog-ng
# If a variable is not set here, then the corresponding
# parameter will not be changed.
# If a variables is set, then every invocation of
# syslog-ng's init script will set them using dmesg.

# log level of messages which should go to console
# see syslog(3) for details
#
#CONSOLE_LOG_LEVEL=1
 
# Command line options to syslog-ng
SYSLOGNG_OPTS="--no-caps"

On relance syslog-ng

$ service syslog-ng restart