~rom1v/blog

Chiffrer un disque dur externe (ou une clé USB) avec LUKS

2014-07-20T21:03:33+02:00

Un disque dur externe contenant vos données n’a pas de raisons de ne pas être chiffré. Voici quelques commandes utiles pour l’utilisation de LUKS.

Prérequis

Le paquet cryptsetup doit être installé :

sudo apt-get install cryptsetup

Initialisation

Trouver le disque

Tout d’abord, il faut déterminer l’emplacement du disque dur dans /dev. Pour cela, avant de le brancher, exécuter la commande :

sudo tail -f /var/log/messages

Lors du branchement du disque, plusieurs lignes similaires à celles-ci doivent apparaître :

Jul 20 21:25:29 pc kernel: [  678.139988] sd 7:0:0:0: [sdb] 976754645 4096-byte logical blocks: (4.00 TB/3.63 TiB)

Ici, [sdb] signifie que l’emplacement est /dev/sdb. Dans la suite, je noterai cet emplacement /dev/XXX.

Il est très important de ne pas se tromper d’emplacement, afin de ne pas formater un autre disque…

Effacer le disque

Si des données étaient présentes sur ce disque, il est plus sûr de tout supprimer physiquement :

sudo dd if=/dev/zero of=/dev/XXX bs=4K

Cette commande peut prendre beaucoup de temps, puisqu’elle consiste à réécrire physiquement tous les octets du disque dur.

Créer la partition chiffrée

Pour initialiser la partition chiffrée :

sudo cryptsetup luksFormat -h sha256 /dev/XXX

La passphrase de déchiffrement sera demandée.

Maintenant que nous avons une partition chiffrée, ouvrons-la :

sudo cryptsetup luksOpen /dev/XXX lenomquevousvoulez

Cette commande crée un nouveau device dans /dev/mapper/lenomquevousvoulez, contenant la version déchiffrée (en direct).

Formater

Pour formater cette partition en ext4 :

sudo mkfs.ext4 /dev/mapper/lenomquevousvoulez -L unlabel

Pour l’initialisation, c’est fini, nous pouvons fermer la vue déchiffrée :

sudo cryptsetup luksClose lenomquevousvoulez

Montage manuel

Il est possible de déchiffrer et monter la partition manuellement en ligne de commande :

sudo cryptsetup luksOpen /dev/XXX lenomquevousvoulez
sudo mkdir -p /media/mydisk
sudo mount -t ext4 /dev/mapper/lenomquevousvoulez /media/mydisk

Le contenu est alors accessible dans /media/mydisk.

Pour démonter et fermer, c’est le contraire :

sudo umount /media/mydisk
sudo cryptsetup luksClose /dev/XXX lenomquevousvoulez

Mais c’est un peu fastidieux. Et je n’ai pas trouvé de solution pour permettre le luksOpen par un utilisateur (non-root) en ligne de commande.

Montage semi-automatique

Les environnement de bureau permettent parfois de monter un disque dur chiffré simplement, avec la demande de la passphrase lors de l’ouverture du disque. Voici ce que j’obtiens avec XFCE :

Mais par défaut, le nom du point de montage est peu pratique : /media/rom/ae74bc79-9efe-4325-8b4d-63d1506fa928. Heureusement, il est possible de le changer. Pour cela, il faut déterminer le nom de la partition déchiffrée :

$ ls /dev/mapper/luks-*
/dev/mapper/luks-8b927433-4d4f-4636-8a76-06d18c09723e

Le nom très long correspond en fait à l’UUID du disque, qui peut aussi être récupéré grâce à :

sudo cryptsetup luksUUID /dev/XXX

ou encore :

sudo blkid /dev/XXX

L’emplacement désiré, ainsi que les options qui-vont-bien, doivent être rajoutés dans /etc/fstab :

/dev/mapper/luks-8b927433-4d4f-4636-8a76-06d18c09723e /media/mydisk ext4 user,noauto

Ainsi, le disque sera désormais monté dans /media/mydisk.

Si en plus, nous souhaitons spécifier un nom user-friendly pour la partition déchiffrée (celui dans /dev/mapper/), il faut ajouter une ligne dans /etc/crypttab (en adaptant l’UUID) :

mydisk UUID=8b927433-4d4f-4636-8a76-06d18c09723e none luks,noauto

Et utiliser celle-ci à la place dans /etc/fstab :

/dev/mapper/mydisk /media/mydisk ext4 user,noauto

Gestion des passphrases

Il est possible d’utiliser plusieurs passphrases (jusqu’à 8) pour déchiffrer le même disque.

Pour en ajouter une :

sudo cryptsetup luksAddKey /dev/XXX

Pour en supprimer une :

sudo cryptsetup luksRemoveKey /dev/XXX

Pour changer une unique passphrase, il suffit d’en ajouter une nouvelle puis de supprimer l’ancienne.

Ou alors d’utiliser :

sudo cryptsetup luksChangeKey /dev/XXX

mais man cryptsetup dit qu’il y a un risque.

État

Pour consulter l’état d’une partition LUKS :

sudo cryptsetup luksDump /dev/XXX

Gestion de l’en-tête

L’en-tête LUKS est écrit au début du disque. L’écraser empêche définivement le déchiffrement de la partition.

Il est possible d’en faire une sauvegarde dans un fichier :

cryptsetup luksHeaderBackup /dev/XXX --header-backup-file fichier

Et de les restaurer :

cryptsetup luksHeaderRestore /dev/XXX --header-backup-file fichier

Pour supprimer l’en-tête (et donc rendre les données définitivement inaccessibles s’il n’y a pas de backup) :

cryptsetup luksErase /dev/XXX

Conclusion

Une fois configuré la première fois, et après les quelques modifications pénibles pour choisir les noms pour le déchiffrement et le montage, l’utilisation au quotidien est vraiment très simple : il suffit de rentrer la passphrase directement à partir du navigateur de fichiers.

SSHFS inversé (rsshfs)

2014-06-15T13:30:27+02:00

SSHFS permet de monter un répertoire d’une machine distance dans l’arborescence locale en utilisant SSH :

sshfs serveur:/répertoire/distant /répertoire/local

Mais comment monter un répertoire local sur une machine distante ?

Une solution simple serait de se connecter en SSH sur la machine distante et d’exécuter la commande sshfs classique.

Mais d’abord, ce n’est pas toujours directement possible : la machine locale peut ne pas être accessible (non adressable) depuis la machine distante. Ça se contourne en créant un tunnel SSH utilisant la redirection de port distante (option -R).

Et surtout, ce n’est pas toujours souhaitable : cela nécessite que la clé privée autorisée sur la machine locale soit connue de la machine distante. Or, dans certains cas, nous ne voulons pas qu’une machine esclave puisse se connecter à notre machine maître.

Reverse SSHFS

En me basant sur la commande donnée en exemple, j’ai donc écrit un petit script Bash (rsshfs, licence GPLv3) qui permet le reverse SSHFS : rsshfs.

git clone https://github.com/rom1v/rsshfs
cd rsshfs
sudo install rsshfs /usr/local/bin

Les paquets sshfs et fuse doivent être installés sur la machine distante (et l’utilisateur doit appartenir au groupe fuse). Le paquet openssh-sftp-server doit être installé sur la machine locale.

Son utilisation se veut similaire à celle de sshfs :

rsshfs /répertoire/local serveur:/répertoire/distant

Comme avec sshfs, /répertoire/distant doit exister sur serveur et doit être vide.

Il est également possible de monter le répertoire en lecture seule :

rsshfs /répertoire/local serveur:/répertoire/distant -o ro

Contrairement à sshfs, étant donné que rsshfs agit comme un serveur, cette commande ne retourne pas tant que le répertoire distant n’est pas démonté.

Pour démonter, dans un autre terminal :

rsshfs -u serveur:/répertoire/distant

Ou plus simplement en pressant Ctrl+C dans le terminal de la commande de montage.

Amélioration

J’ai choisi la facilité en écrivant un script indépendant qui appelle la commande qui-va-bien.

L’idéal serait d’ajouter cette fonctionnalité à sshfs directement.

Duplicity : des backups incrémentaux chiffrés

2013-08-14T14:59:42+02:00

Quiconque s’auto-héberge doit maintenir un système de sauvegarde de son serveur, permettant de tout remettre en place dans le cas d’un crash de disque dur, d’un piratage ou d’un cambriolage.

Objectifs

Il est nécessaire de sauvegarder à la fois des fichiers (les mails, les services hébergés, les fichiers de config…) et le contenu de bases de données (associées aux services hébergés).

Le système de sauvegarde doit conserver les archives durant un certain temps (par exemple 2 mois). En effet, un piratage ou une erreur de manipulation peuvent n’être détectés que quelques jours plus tard : il est important de pouvoir restaurer un état antérieur.

La sauvegarde doit être régulière (par exemple quotidienne).

Seule une infime partie des données étant modifiées d’un jour à l’autre, la sauvegarde a tout intérêt à être incrémentale.

Pour résister aux cambriolages, une sauvegarde doit être réalisée sur (au moins) une machine distante. Il est donc préférable que ces données soient chiffrées.

Duplicity

Vous l’aurez compris, duplicity répond à tous ces besoins.

Je ne vais pas expliquer tout ce qu’il sait faire, mais plutôt comment je l’utilise et pourquoi.

Mes choix d’utilisation

Sauvegarde locale

Personnellement, je n’effectue qu’une sauvegarde locale dans une tâche cron, c’est-à-dire que les fichiers de backups sont stockés sur le serveur lui-même.

En effet, une sauvegarde automatique vers un serveur distant, par SSH par exemple, nécessiterait une clé privée en clair sur le serveur. Cette configuration ne résisterait pas à certains piratages : une intrusion sur le serveur donnerait également accès aux sauvegardes, permettant à un pirate d’effacer à la fois les données et les backups.

C’est donc une autre machine, à l’initiative de la connexion, qui rapatrie les backups. Évidemment, elle ne doit pas synchroniser localement les backups supprimés du serveur (elle serait vulnérable à la suppression des backups par un pirate), mais doit plutôt supprimer les anciennes sauvegardes de sa propre initiative.

Chiffrement

Duplicity utilise GPG pour le chiffrement, permettant :

soit un chiffrement asymétrique (une paire de clés publique/privée, la clé privée pouvant elle-même être chiffrée par une passphrase) ;
soit un chiffrement symétrique (une simple passphrase).

Le premier choix nécessite à la fois quelque chose que je possède (la clé, de forte entropie) et quelque chose que je connais (la passphrase, de plus faible entropie). Le second ne nécessite que la passphrase à retenir.

L’utilisation d’une clé privée autorise donc une meilleure sécurité, notamment si vous souhaitez envoyer vos backups sur un serveur américain.

Néanmoins, les backups sont surtout utiles lors de la perte de données, notamment dans le cas d’un cambriolage, où la clé GPG a potentiellement également disparu. Et les sauvegardes distantes ne seront d’aucune utilité sans la clé…

Il peut donc être moins risqué d’opter, comme je l’ai fait, pour une simple passphrase.

À vous de placer le curseur entre la protection de vos données et le risque de ne plus pouvoir les récupérer.

Installation

Sur une Debian :

sudo apt-get install duplicity

Fonctionnement

Duplicity effectue des sauvegardes complètes et incrémentales. Les sauvegardes incrémentales nécessitent toutes les sauvegardes depuis la dernière complète pour être restaurées.

Personnellement, j’effectue une sauvegarde complète tous les mois, et une incrémentale tous les jours.

Pour choisir le mode :

duplicity full … force une sauvegarde complète ;
duplicity incr … force une sauvegarde incrémentale (échoue si aucune complète n’est trouvée) ;
duplicity … effectue une sauvegarde incrémentale si possible, complète sinon.

Exemple (à exécuter en root pour avoir accès à tous les fichiers) :

duplicity / file:///var/backups/duplicity/ \
    --include-globbing-filelist filelist.txt \
    --exclude '**'

Duplicity va sauvegarder à partir de la racine (/) tous les fichiers selon les règles d’inclusion et d’exclusion définies dans filelist.txt. Ce fichier contient simplement la liste des fichiers et répertoires à sauvegarder, ainsi que ceux à exclure. Par exemple :

/usr/local/bin/
/home/rom/Maildir/
/home/rom/.procmailrc
- /var/www/blog/wp-content/cache/
/var/www/blog/

Attention : les fichiers et répertoires à exclure doivent apparaître avant l’inclusion d’un répertoire parent. En effet, duplicity s’arrête à la première règle qui matche un chemin donné pour déterminer s’il doit l’inclure ou l’exclure.

Pour restaurer :

duplicity restore file:///var/backups/duplicity/ /any/directory/

(utiliser l’option -t pour restaurer à une date particulière)

Pour supprimer les anciennes sauvegardes (ici de plus de 2 mois) :

duplicity remove-older-than 2M file:///var/backups/duplicity/ --force

Bases de données

Tout comme pour les fichiers, il est préférable de sauvegarder incrémentalement les bases de données (seule une toute petite partie des données change d’un jour à l’autre).

Une première solution serait d’utiliser la fonctionnalité-qui-va-bien de votre SGBD.

Mais si le contenu de vos bases de données ne dépasse pas quelques Go (ce qui est très probable pour de l’auto-hébergement), duplicity permet de faire beaucoup plus simple.

Il suffit en effet de générer un dump complet des bases de données vers des fichiers .sql et d’inclure leur chemin dans la liste des fichiers à sauvegarder. Et là, c’est magique, duplicity va ne sauvegarder que les parties de ces (gros) fichiers qui ont changées, grâce à rsync et à son algorithme qui utilise des rolling checksums.

Bien sûr, il ne faut pas compresser ces fichiers avant de les donner à manger à duplicity (sinon l’intégralité du fichier risque de changer) ; c’est lui qui va s’en charger. De même, il vaut mieux éviter d’inclure dans les fichies SQL des informations liées au dump, comme sa date de génération.

Pour exporter une base de données MySQL par exemple :

mysql -uroot -ppassword --skip-comments -ql my_database > my_database.sql

Script

Il reste donc à écrire un script qui exporte les bases de données et qui appelle duplicity avec la liste de ce qu’il y a à sauvegarder.

Voici un prototype, à sauvegarder dans /usr/local/bin/backup :

#!/bin/bash
BACKUP_HOME=/var/backups
TMP_DBDIR="$BACKUP_HOME/dbdump"
BACKUP_DIR="$BACKUP_HOME/duplicity"
MYSQLPW=mon_password_mysql
PASSPHRASE=ma_passphrase_de_chiffrement_des_backups
DATABASES='blog autre_base'
FILELIST="/usr/local/bin/
/home/rom/Maildir/
/home/rom/.procmailrc
- /var/www/blog/wp-content/cache/
/var/www/blog/
$TMP_DBDIR/"

# databases
mkdir -p "$TMP_DBDIR"
for dbname in $DATABASES
do
  printf "## Dump database $dbname...\n"
  mysqldump -uroot -p"$MYSQLPW" --skip-comments -ql "$dbname" \
    > "$TMP_DBDIR/$dbname.sql"
done

# duplicity
printf '## Backup using duplicity...\n'
unset mode
[ "$1" = full ] && mode=full && printf '(force full backup)\n'
mkdir -p "$BACKUP_DIR"
export PASSPHRASE
duplicity $mode / file://"$BACKUP_DIR"/ \
  --include-globbing-filelist <(echo "$FILELIST") --exclude '**'

printf '## Delete old backups\n'
duplicity remove-older-than 2M file://"$BACKUP_DIR"/ --force

# backups are encrypted, we can make them accessible
chmod +r "$BACKUP_DIR"/*.gpg

# remove temp files
rm "$TMP_DBDIR"/*.sql

Une fois configuré, ne pas oublier de tester : exécuter le script et restaurer les données dans un répertoire de test, puis vérifier que tout est OK. Cette vérification doit être effectuée de temps en temps : il serait dommage de s’apercevoir, lorsqu’on en a besoin, que les backups sont inutilisables ou qu’un répertoire important a été oublié.

Cron

Pour démarrer automatiquement une sauvegarde complète le premier jour du mois et une incrémentale tous les autres jours, cron est notre ami :

sudo crontab -e

Ajouter les lignes :

0 1 1    * * /usr/local/bin/backup full
0 1 2-31 * * /usr/local/bin/backup

La première colonne correspond aux minutes, la deuxième aux heures : le script sera donc exécuté à 1h du matin. La 3e correspond au numéro du jour dans le mois. Les deux suivantes sont le numéro du mois dans l’année et le jour de la semaine.

Il peut être préférable d’exécuter le script en priorité basse :

0 1 1    * * nice -15 ionice -c2 /usr/local/bin/backup full
0 1 2-31 * * nice -15 ionice -c2 /usr/local/bin/backup

Copies

Il ne reste plus qu’à effectuer des copies des fichiers de backups ailleurs.

À partir d’une autre machine, le plus simple est d’utiliser rsync (sans l’option --delete !) :

rsync -rvP --partial-dir=/my/local/tmpbackup --ignore-existing --stats \
    -h server:/var/backups/duplicity/ /my/local/backup/

--ignore-existing évite de récupérer des modifications malicieuses des backups sur le serveur (ils ne sont pas censés être modifiés). Du coup, il faut aussi faire attention à sauvegarder les transferts partiels ailleurs (--partial-dir), sans quoi ils ne se termineront jamais.

Pour supprimer les anciens backups sur cette machine, c’est la même commande que sur le serveur :

duplicity remove-older-than 2M file:///my/local/backup/ --force

Conclusion

La génération de sauvegardes à la fois incrémentales et chiffrées, y compris pour les bases de données, font de duplicity une solution de backup idéale pour l’auto-hébergement.

Je l’utilise depuis plusieurs mois, et j’en suis très satisfait (même si je n’ai pas encore eu besoin de restaurer les backups en situation réelle).

À vos backups !

GIT : squasher des merges

2013-05-30T15:40:50+02:00

Supposons que je souhaite ajouter une fonctionnalité à un projet sur GIT.

Je prends la version actuelle de la branche master (A), puis ajoute sur ma branche topic les commits X et Y.

    X---Y  topic
   /
--A  master

Je propose la fonctionnalité upstream (par un git request-pull ou une pull request), qui met un peu de temps à être revue.

Pendant ce temps, la branche master a avancé, et malheureusement les modifications effectuées entrent en conflit avec mon travail sur topic.

    X---Y  topic
   /
--A---B---C  master

Une fois mon code revu et accepté, les mainteneurs vont alors me demander de résoudre les conflits avec la branche master avant de merger ma branche topic.

Si j’avais eu à prendre en compte les mises à jour de master avant d’avoir rendu public mon topic, j’aurais simplement rebasé mon travail par-dessus master. Mais là, impossible.

Je dois donc merger. Très bien. Je merge et je résous les conflits.

    X---Y---M  topic
   /       /
--A---B---C  master

Mais, alors que je n’ai pas encore rendu M public, je m’aperçois qu’il y a un nouveau commit D sur master, que je veux intégrer dans topic.

    X---Y---M  topic
   /       /
--A---B---C---D  master

La solution la plus évidente est de merger à nouveau.

    X---Y---M---N  topic
   /       /   /
--A---B---C---D  master

Mais je voudrais éviter un commit de merge inutile. Pour un seul, ce n’est pas très gênant, mais si on maintient une branche suffisamment longtemps avant qu’elle ne soit mergée, ces commits inutiles vont se multiplier.

Une solution serait de revenir à Y et de le merger avec D :

git checkout topic
git reset --hard Y
git merge master

Ce qui donne :

    X---Y---M'  topic
   /         \
--A---B---C---D  master

Mais dans ce cas, pour créer M', je vais devoir résoudre à nouveau les conflits que j’avais déjà résolu en créant M.

Comment éviter ce problème ?

rerere

Une solution est d’avoir activé rerere avant d’avoir résolu les conflits de M :

git config rerere.enabled true

Ainsi, lorsque je tenterai de merger à nouveau Y et D, les conflits entre Y et C seront automatiquement résolus de la même manière que précédemment.

Cependant, cette méthode a ses inconvénients.

Tout d’abord, il ne s’agit que d’un cache local de résolutions des conflits, stocké pendant une durée déterminée (par défaut à 60 jours pour les conflits résolus), ce qui est peu pratique si on clone son dépôt sur plusieurs machines (les conflits ne seront résolus automatiquement que sur certaines).

Ensuite, elle est inutilisable lorsqu’on souhaite squasher un merge conflictuel alors que rerere était désactivé lors de sa création.

Enfin, cette fonctionnalité est encore récente, et la fonction git rerere forget (pour permettre de résoudre autrement des conflits déjà résolus), a la fâcheuse tendance à segfaulter (un patch a été proposé).

Rebranchement

La solution que j’utilise est donc la suivante.

    X---Y---M---N  topic
   /       /   /
--A---B---C---D  master

Une fois obtenus les deux merges M et N, le principe est de remplacer le parent de N, qui était M, par Y, sans rien changer d’autre au contenu.

          -----
         /     \
    X---Y---M   N' topic
   /       /   /
--A---B---C---D  master

Ainsi, M devient inatteignable, et c’est exactement le résultat souhaité :

    X---Y-------N' topic
   /           /
--A---B---C---D  master

Pour faire cela, il faut déplacer le HEAD (pointant vers topic) sur Y, faire croire à GIT qu’on est en phase de merge avec D en modifiant la référence MERGE_HEAD, puis commiter :

git checkout N
git reset --soft Y
git update-ref MERGE_HEAD D
git commit -eF <(git log ..HEAD@{1} ^master --pretty='# %H%n%s%n%n%b')

Il n’y a plus qu’à éditer le message de commit de merge.

La fin de la ligne du git commit permet de concaténer l’historique des commits intermédiaires (a priori uniquement des merges) comme lors d’un squash avec git rebase (pour pouvoir conserver les messages de merges intermédiaires, contenant nontamment les conflits).

En utilisant les références plutôt que les numéros de commit, cela donne :

git checkout feature
git reset --soft HEAD~2
git update-ref MERGE_HEAD master
git commit -eF <(git log ..HEAD@{1} ^master --pretty='# %H%n%s%n%n%b')

Si vous avez plus simple, je suis preneur…

Merci aux membres de stackoverflow.

Formater du code C avec indent et Vim

2012-11-15T12:23:54+01:00

Pour suivre des règles de codage et s’y tenir, rien de tel qu’un outil qui formate automatiquement le code (c’est plus rapide et sans erreurs). Sous Eclipse par exemple, la combinaison de touches Ctrl+Shift+F est indispensable. Mon but est d’obtenir la même fonctionnalité sous Vim pour le langage C.

Indent

L’outil indent permet de formater un source C selon des règles définies par des paramètres en ligne de commande. Ces options sont très nombreuses. Heureusement, il y a quelques styles bien connus prédéfinis, comme le style K&R (option -kr).

Pour illustrer son fonctionnement, voici un code source écrit n’importe comment (et qui fait n’importe quoi) :

#include <stdio.h>

void f (  int* x  )
  {
 *x=4;}

void g(int x)
{goto mylabel;
        /* my comment */
    if(x>10)x=10;
       mylabel:
    printf ("%d\n",x *2);
switch(x){case 1:x=4;break;case 2:x=1;}
    while   ( * ( &x ) <10)x++; /* what? */
}

void h(char ( * ( * x ( ) ) [ ] ) ( ) ) {
char ( * ( * y ) [ ] ) ( ) = \
x ( ) ; char ( * z ) ( ) = * \
( * y ) ; char c = z ( ); putchar \
(c);
}

int main(){
int i=  2;  f(&i);
  g(i);

        return    0;
}

Pour formater :

indent -st -kr -ts4 file.c

-st affiche le résultat sur la sortie standard au lieu de modifier le fichier ;
-kr utilise le style K&R ;
-ts4 considère 4 espaces comme une tabulation.

Voici le résultat :

#include <stdio.h>

void f(int *x)
{
    *x = 4;
}

void g(int x)
{
    goto mylabel;
    /* my comment */
    if (x > 10)
        x = 10;
  mylabel:
    printf("%d\n", x * 2);
    switch (x) {
    case 1:
        x = 4;
        break;
    case 2:
        x = 1;
    }
    while (*(&x) < 10)
        x++;                    /* what? */
}

void h(char (*(*x())[])())
{
    char (*(*y)[]) () = x();
    char (*z) () = *(*y);
    char c = z();
    putchar(c);
}

int main()
{
    int i = 2;
    f(&i);
    g(i);

    return 0;
}

C’est plus joli, non ?

vim

Pour pouvoir reformater directement dans Vim, il suffit d’ajouter dans ~/.vimrc la ligne suivante :

autocmd BufNewFile,BufRead *.c set formatprg=indent\ -kr\ -ts4

Ensuite, la commande gq formate (u annule).

Par exemple, sur le fichier source mal formaté ci-dessus :

placer le curseur sur la ligne 7 ;
appuyer sur V ;
descendre avec j (ou la flèche du bas) jusqu’à la ligne 15 ;
taper gq.

Ainsi, seule la fonction g est formatée.

À partir de la ligne 7, le même résultat est obtenu en tapant directement gq8j (descendre de 8 lignes) ou gq15G (jusqu’à la ligne 15).

Pour reformater un bloc, le plus simple est de se placer sur une accolade { ou } et de taper gq% (% navigue entre les {}, () et [] ouvrant et fermant).

Pour reformater tout le fichier, il faut taper gggqG :

gg amène le curseur au début du fichier ;
gq formate jusqu’à… ;
G va à la fin du fichier.

:wq

Utiliser Wireshark sous Debian

2012-06-02T12:48:21+02:00

Wireshark est un outil incontournable pour connaître les paquets qui transitent sur le réseau. Mais on se retrouve vite bloqué à cause d’un problème de droits.

En effet, en démarrant wireshark avec un compte utilisateur non-root, l’interface graphique s’affiche, mais il est impossible de capturer les trames : aucune interface réseau n’est disponible.

Devant ce problème, que fait l’utilisateur pressé ? Il démarre wireshark en root, bien sûr (c’est ce que je faisais sous Ubuntu) ! Eh bien pas de chance :

$ sudo wireshark
No protocol specified

(wireshark:27210): Gtk-WARNING **: cannot open display: :0

Déjà, c’est bien fait pour lui : on n’essaie pas de démarrer une interface graphique en root !

Mais comment faire alors ? En non-root on ne peut pas capturer, en root on ne peut pas démarrer…

Alors on lit la doc, qui propose deux solutions :

less /usr/share/doc/wireshark/README.Debian

EDIT : Une troisième solution, donnée en commentaire, me semble encore meilleure :

sudo tcpdump -pni eth0 -s0 -U -w - | wireshark -k -i -

Utiliser dumpcap pour capturer

Avec cette méthode, il faut d’abord capturer les paquets réseau et les sauver dans un fichier, grâce à dumpcap (en root), puis ouvrir ce fichier dans wireshark (non-root).

Pour démarrer la capture de l’interface eth0 dans le fichier /tmp/mycapture :

sudo dumpcap -i eth0 -w /tmp/mycapture

Pour connaître la liste des interfaces réseau capturables :

$ sudo dumpcap -D 
eth0
wlan0
nflog (Linux netfilter log (NFLOG) interface)
any (Pseudo-device that captures on all interfaces)
lo

Ctrl+C arrête la capture.

Le fichier généré n’est lisible que par root. Avant de l’ouvrir dans Wireshark, il faut donc changer ses droits :

sudo chmod +r /tmp/mycapture

C’est la méthode configurée par défaut sous Debian.

Autoriser les utilisateurs non-root

Si on souhaite à la fois capturer et analyser à partir de Wireshark (et permettre les captures “en live”), sans passer par dumpcap en ligne de commande, il faut autoriser les utilisateur non-root à capturer des paquets.

Pour cela :

sudo dpkg-reconfigure wireshark-common

Ce qui affiche :

 ┌─────────────────────┤ Configuration de wireshark-common ├──────────────────────┐
 │                                                                                │
 │ Dumpcap peut être installé afin d'autoriser les membres du groupe              │
 │ « wireshark » à capturer des paquets. Cette méthode de capture est préférable  │
 │ à l'exécution de Wireshark ou Tshark avec les droits du superutilisateur, car  │
 │ elle permet d'exécuter moins de code avec des droits importants.               │
 │                                                                                │
 │ Pour plus d'informations, veuillez consulter                                   │
 │ /usr/share/doc/wireshark-common/README.Debian.                                 │
 │                                                                                │
 │ Cette fonctionnalité constitue un risque pour la sécurité, c'est pourquoi      │
 │ elle est désactivée par défaut. En cas de doute, il est suggéré de la laisser  │
 │ désactivée.                                                                    │
 │                                                                                │
 │ Autoriser les utilisateurs non privilégiés à capturer des paquets ?            │
 │                                                                                │
 │                      <Oui>                         <Non>                       │
 │                                                                                │
 └────────────────────────────────────────────────────────────────────────────────┘

Après avoir répondu Oui, tous les utilisateurs du groupe wireshark (aucun, par défaut) seront autorisés à capturer les paquets.

Remarque : un programme non-root sera donc en théorie capable de savoir tout ce qui passe sur le réseau (déjà qu’il est capable de connaître tout ce qui est tapé au clavier).

Il ne reste donc plus qu’à ajouter son compte utilisateur au groupe wireshark :

sudo addgroup $USER wireshark

Cette modification ne sera prise en compte qu’après une reconnexion du compte utilisateur (il faut donc fermer la session et en démarrer une nouvelle).

Configurer le thème des applications GTK sous KDE

2012-05-15T20:08:19+02:00

Après être passé de KDE à Gnome il y a un peu plus de 4 ans, j’ai décidé de revenir à KDE. Mais de la même manière que les applications prévues pour KDE ne s’intègrent pas correctement à Gnome, les applications prévues pour Gnome sont horribles sur KDE : elles n’ont pas de thème du tout (sauf si vous appelez “thème” l’apparence de Windows 95).

Voici par exemple à quoi ressemble GIMP :

Le problème doit être résolu deux fois : une première pour les applications utilisant GTK2 et une seconde pour celles utilisant GTK3.

GTK2

Pour GTK2, c’est facile. Sous Debian :

sudo apt-get install gtk2-engines-oxygen gtk-chtheme

(le nom des paquets peut varier selon votre distribution)

Il ne reste alors plus qu’à exécuter :

gtk-chtheme

et choisir le thème oxygen-gtk :

Le thème des applications telles que Firefox/Iceweasel, GIMP, Ario ou Eclipse sera alors totalement cohérent avec celui des applications prévues pour KDE :

Pour pousser plus loin l’intégration de Firefox/Iceweasel, il y a même un module complémentaire.

GTK3

Pour GTK3, ce devrait être presque pareil… sauf que le paquet gtk3-engines-oxygen (ou oxygen-gtk3) n’est pas encore dans les dépôts Debian (il est par contre dans d’autres distributions, comme Ubuntu ou Arch Linux).

Il est bien sûr possible de télécharger les sources pour l’installer manuellement.

Mais nous pouvons nous contenter du thème natif de Gnome. Pour le configurer, il suffit d’installer gnome-themes-standard :

sudo apt-get install gnome-themes-standard

et de créer un fichier ~/.config/gtk-3.0/settings.ini contenant :

[Settings]
gtk-theme-name=Adwaita
gtk-fallback-icon-theme=gnome

(voir GtkSettings)

Gedit avant :

Gedit après :

En attendant qu’Oxygen GTK3 soit disponible dans les dépôts, c’est mieux que rien…

EDIT : oxygen-gtk3 est maintenant disponible dans les dépôts.

Lire des images et des vidéos sans serveur X (dans un TTY)

2012-04-07T23:01:55+02:00

Saviez-vous qu’il était possible de lire des images et des vidéos dans un TTY, sans serveur X ? Je ne parle pas de les afficher en ASCII-art, mais bien de les afficher “graphiquement” :

Je ne le savais pas jusqu’à aujourd’hui. En fait, c’est possible grâce à des programmes qui écrivent directement dans le framebuffer.

Pour tester les outils suivants, lancez un TTY grâce aux raccourcis Ctrl+Alt+F[1-6]. Pour revenir à votre session graphique, faites Ctrl+Alt+F7 (sur certaines distributions, par défaut la session graphique est plutôt accessible avec Ctrl+Alt+F1, Ctrl+Alt+F8 ou Ctrl+Alt+F9, essayez…).

Images

Pour afficher des images, il faut installer le paquet fbi (framebuffer imageviewer) :

sudo apt-get install fbi

Puis simplement exécuter :

fbi monimage.jpg

ou même

fbi *.jpg

(PgUp et PgDown permettent de naviguer entre les images)

Cet outil est vraiment très rapide (sauf pour le zoom). C’est un peu l’équivalent de feh qui, lui, fonctionne en mode graphique.

Vidéos

Pour les vidéos, nous avons besoin de MPlayer :

sudo apt-get install mplayer

En lançant dans un TTY :

mplayer mavidéo.avi

MPlayer choisit le pilote fbdev. Nous pouvons aussi le choisir explicitement :

mplayer -vo fbdev mavidéo.avi

Par contre, la vidéo s’affiche à sa taille originale, alors que nous la voulons en plein écran. Il faut donc la mettre à l’échelle, grâce aux paramètres de mplayer. Sur un écran 1680×1050 par exemple :

mplayer -fs -vf scale=1680:-3 mavidéo.avi

-3 permet de calculer la seconde composante à partir de la première et de l’aspect-ratio. C’est dans le man :

 0: largeur/hauteur dimmensionnées à d_width/d_height
-1: largeur/hauteur originales
-2: Calcule l/h en utilisant l'autre dimension et le rapport hauteur/largeur
    redimensionné.
-3: Calcule l/h en utilisant l'autre dimension et le rapport hauteur/largeur
    original.
-(n+8): Comme -n ci-dessus, mais en arrondissant les dimensions au plus
        proche multiple de 16.

Sur mon pc portable, j’arrive sans problème à lire dans un TTY une vidéo 1080p (j’ai testé avec Big Buck Bunny en MP4, redimensionnée lors de la lecture à la taille de mon écran, 1680×1050).

Par contre, sur une machine moins puissante (une EeeBox, qui hébergeait ce blog par le passé), MPlayer saccade, même sur des vidéos basse définition, que VLC lit sans problèmes. Pour améliorer les performances de lecture de MPlayer, il est possible de changer l’algorithme de zoom logiciel, grâce à l’option -sws. Par exemple, pour utiliser bilinéaire rapide au lieu de bicubique :

mplayer -fs -vf scale=1680:-3 -sws 0 mavidéo.avi

Avec ce paramètre, ça ne saccade plus.

Cependant, sur la EeeBox, dans ce cas les couleurs sont incorrectes apparemment à cause d’un bug de pilote vidéo Intel. J’ai donc quand même installé un serveur X avec un gestionnaire de fenêtres minimaliste, awesome. Mais c’est une autre histoire…

ASCII-art

Je vous parlais d’ASCII-art au début du billet, il est également possible de lire les images ou les vidéos en ASCII (c’est juste moins joli), grâce à des commandes d’une élégance toute particulière.

Pour les images, nous pouvons installer le paquet caca-utils

sudo apt-get install caca-utils

Puis utiliser cacaview :

cacaview monimage.jpg

Pour les vidéos :

mplayer -vo caca mavidéo.avi

Conclusion

Je n’en revenais pas qu’il soit possible de lire des vidéos sans serveur X. Sur une machine destinée à une utilisation multimédia (branchée sur la TV par exemple), il n’y a donc nullement besoin d’un serveur X (paradoxalement).

Prompt Bash pour GIT

2012-04-04T23:22:55+02:00

J’utilise git depuis quelques mois, et je trouve ça vraiment génial. Si vous ne connaissez pas, ou peu, vous ne pouvez pas ne pas lire le livre Pro Git (sous licence cc-by-nc-sa). Les explications très claires permettent en quelques heures de maîtriser toutes les fonctions de base, et d’être à l’aise avec la gestion des branches (et bien plus encore).

Branches visibles

Le but de ce billet est de répondre à un problème particulier : par manque d’attention, il m’est arrivé plusieurs fois de commiter des changements sur une mauvaise branche (j’étais persuadé d’être sur une branche, en fait j’étais sur une autre). Ce n’est pas très grave (on peut s’en sortir), mais c’est pénible.

Je souhaiterais donc avoir le nom de la branche dans le prompt bash.

Des solutions existent déjà : le paquet git embarque même un script qui répond au besoin. Certains utilisent aussi des scripts personnalisés. Mais aucun de ceux que j’ai trouvés ne me convenait. J’ai donc écrit mon propre script.

Mes prompts

Version simple

J’ai commencé par une version simple, qui ajoute en couleur @nomdelabranche à la fin du prompt. Un exemple vaut mieux qu’un long discours :

rom@rom-laptop:~/dev$ cd myproject/
rom@rom-laptop:~/dev/myproject@master$ git checkout testing
Switched to branch 'testing'
rom@rom-laptop:~/dev/myproject@testing$ cd img
rom@rom-laptop:~/dev/myproject/img@testing$

Dans une arborescence ayant plusieurs projets GIT imbriqués (dans le cas de l’utilisation de sous-modules), la branche des projets parents n’est pas affichée :

rom@rom-laptop:~/dev$ cd mybigproject/
rom@rom-laptop:~/dev/mybigproject@master$ cd submodule/
rom@rom-laptop:~/dev/mybigproject/submodule@master$ git checkout exp
Switched to branch 'exp'
rom@rom-laptop:~/dev/mybigproject/submodule@exp$ cd ..
rom@rom-laptop:~/dev/mybigproject@master$

Version améliorée

Dans cette version simple, le nom de la branche est toujours affiché à la fin. Cela ne me convient pas, je le voudrais toujours à la racine du projet en question. C’est ce que permet la version améliorée.

Voici le résultat avec les mêmes commandes :

rom@rom-laptop:~/dev$ cd myproject/
rom@rom-laptop:~/dev/myproject@master$ git checkout testing
Switched to branch 'testing'
rom@rom-laptop:~/dev/myproject@testing$ cd img
rom@rom-laptop:~/dev/myproject@testing/img$

Et avec des sous-modules, la branche des projets parents est affichée :

rom@rom-laptop:~/dev$ cd mybigproject/
rom@rom-laptop:~/dev/mybigproject@master$ cd submodule/
rom@rom-laptop:~/dev/mybigproject@master/submodule@master$ git checkout exp
Switched to branch 'exp'
rom@rom-laptop:~/dev/mybigproject@master/submodule@exp$ cd ..
rom@rom-laptop:~/dev/mybigproject@master$

En image :

Script

Le script, sous licence WTFPL, est disponible sur ce dépôt git : [gitbashprompt].

Une fois cloné, éditez le fichier ~/.bashrc pour remplacer l’initialisation de la variable PS1 :

        PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '

par :

        . full/path/to/your/gitbashprompt

Pour tester, ouvrir un nouveau terminal.

Conclusion

Tout d’abord, je suis content d’avoir exactement le comportement que je souhaitais pour mon git.

Ensuite, j’ai découvert le fonctionnement du prompt, avec notamment les subtilités d’échappement de caractères de la variable PS1 et la prise en compte des caractères de contrôle \[ et \].

Enfin, je me suis enfin décidé à étudier la gestion des couleurs de Bash (qui, à première vue, est assez repoussante, il faut bien l’avouer). Mes scripts seront donc plus jolis à l’avenir ;-)

Héberger un serveur Jabber simplement (prosody)

2012-01-06T22:12:58+01:00

J’ai enfin décidé d’héberger mon propre serveur Jabber, pour plusieurs raisons :

la liste de mes contacts est mieux sur mon serveur que sur un autre ;
le serveur que j’utilisais (jabber.fr) rencontre parfois quelques difficultés ;
mon adresse Jabber sera ainsi la même que mon adresse mail (rom suivi de @rom1v.com).

Et c’est simple !

Installation et configuration

Tout d’abord, installer le paquet prosody :

apt-get install prosody

Puis ajouter à la fin du fichier /etc/prosody/prosody.cfg.lua :

Host "nom.de.domaine"

Pour moi :

Host "rom1v.com"

Créer un utilisateur en ligne de commande et choisir un mot de passe :

prosodyctl adduser utilisateur@nom.de.domaine

Certificat

Un certificat TLS/SSL est créé par défaut, mais les champs sont renseignés avec des valeurs non pertinentes (localhost au lieu de nom.de.domaine par exemple). Il est donc préférable d’en générer un nouveau.

Dans le répertoire /etc/prosody/certs, exécuter :

openssl req -new -x509 -nodes -out nom.de.domaine.cert -keyout \
    nom.de.domaine.key -days 1000

Renseigner les champs demandés (« . » pour laisser un champ vide). En particulier, indiquer dans Common Name le nom de domaine pour lequel ce certificat sera utilisé.

Remplacer le certificat dans le fichier de configuration :

ssl = {
        key = "/etc/prosody/certs/nom.de.domaine.key";
        certificate = "/etc/prosody/certs/nom.de.domaine.cert";
}

Empreinte

Comme c’est un certificat auto-signé, les clients Jabber ne lui feront pas confiance : ils demanderont une confirmation, en présentant son empreinte. Il faudra alors vérifier que le certificat présenté est bien le bon, c’est-à-dire que l’empreinte est la même.

Pour la connaître :

openssl x509 -fingerprint -noout -in nom.de.domaine.cert

Par exemple :

$ openssl x509 -fingerprint -noout -in rom1v.com.cert
SHA1 Fingerprint=C3:6D:9B:65:06:55:C4:84:B4:A5:8D:4B:12:68:2F:08:71:7E:AC:DD

Ports

Les ports TCP 5222 et 5269 doivent être ouverts.

Démarrer

Il ne reste plus qu’à démarrer le service.

service prosody start

Clients

Il est maintenant possible de se connecter en utilisant le nom d’utilisateur et le mot de passe créés :

Backup

Les données du serveur sont stockées dans /var/lib/prosody. Il est donc important de ne pas oublier ce répertoire dans le processus de sauvegarde.

Merci à Cyrille Borne et nicolargo.