ZenTech - linux

Bruce Schneier knows Alice and Bob's shared secret

hr — Mon, 13 Oct 2008 14:50:00 +0200

Comment faire lorsqu'on souhaite se constituer un petit espace très personnel sur une machine linux. Que faire quand on souhaite que cet espace soit conservé à l'abris des yeux indiscrets. Je vous propose une petite recette simple et efficace. Il suffit d'utiliser des ingrédients que vous trouverez dans votre cuisine !!

L'environnement système est une debian etch installée en 64bits sur une dedibox. Je vais utiliser le chiffrement de bloc avec LUKS utilisant dm-crypt. Nous ne chiffrerons pas la partition racine du système mais bien une partition de données.

Il faut tout d'abord vérifier qu'on a les outils nécessaires au chiffrement de partition.

# apt-get install cryptsetup dmsetup hashalot
[...]

Maintenant que les outils de base sont installés, on vérifie leur compatibilité avec l'utilisation qu'on souhaite en faire.

# cryptsetup --help
cryptsetup-luks 1.0.5
[...]
# dmsetup targets
zero             v1.0.0
mirror           v1.0.20
snapshot-origin  v1.6.0
snapshot         v1.6.0
crypt            v1.5.0
striped          v1.1.0
linear           v1.0.2
error            v1.0.1

# cat /proc/crypto | grep name
name         : aes
name         : sha256
name         : sha224
name         : sha1
name         : md5

la commande cryptsetup installée supporte bien LUKS et le noyau est capable de supporter le chiffrement.

Pour les architectures supportant le 64bit.

# modprobe aes-x86_64
# cat /proc/crypto
name         : aes
driver       : aes-asm
module       : aes_x86_64
priority     : 200
refcnt       : 1
type         : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32
[...]

Le module peut-être éventuellement ajouté au fichier /etc/modules.

Je dois maintenant créer la partition qui va être chiffrée et la déclarer au système grâce à partprobe.

# cfdisk /dev/sda
[...]
# apt-get install parted
[...]
# partprobe /dev/sda

Pour chiffrer une partition avec LUKS, il faut la "formater" avec cryptsetup et ensuite la déclarer au système "device mapper". Il est conseillé d'utiliser une phrase de mot de passe complexe.

# cryptsetup luksFormat /dev/sda8

WARNING!
========
This will overwrite data on /dev/sda8 irrevocably.

Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase:
Verify passphrase:
Command successful.
# cryptsetup luksOpen /dev/sda8 data
Enter LUKS passphrase: 
key slot 0 unlocked.
Command successful.
# ls /dev/mapper/
control  data

C'est gagné, la partition est maintenant accessible grâce au chemin /dev/mapper/data.

Il faut formater la partition, ici j'utilise ext3.

# mkfs.ext3 -m 0 /dev/mapper/data

La partition peut maintenant être utilisée par le système.

Pour assurer le montage de la partition au démarrage, il faut la déclarer dans le fichier /etc/crypttab. Cette déclaration permet de faire l'ouverture LUKS et la déclaration à "dev mapper" en une opération. Ensuite /etc/fstab pourra prendre le relais.

# cat /etc/crypttab
# <target name> <source device>         <key file>      <options>
data    /dev/sda8       none            luks,timeout=1

Ps: Le titre vient des "Bruce Schneier facts".
Ps2: Le formatage de la partition peut également se faire avec un version plus longue de la commande cryptsetup :

# cryptsetup --verify-passphrase --verbose --hash=sha256 --cipher=aes-cbc-essiv:sha256 --key-size=256 luksFormat /dev/sda8
[...]

HAL> Affirmative, Dave, I read you.

hr — Fri, 11 Jan 2008 17:39:00 +0100

Ah la vacuité d'une session IRC sur un canal dirigé par un automate. Quoi de plus extraordinaire que pouvoir connaitre la météo de Felletin dans la Creuse ou d'avoir une blague carambar à la demande. En ce moment je fais beaucoup de python, donc je me suis penché sur le problème pour un ami. Je vais essayer de vous exposer les clés de l'utilisation d'irclib pour construire un automate irc simple.

L'automate est présenté ci-après, ses fonctions sont simplement la connexion à un serveur irc local sur le port 6667 et l'entrée dans le canal #test. L'automate s'attend à lire des commandes préfixées de '!' dans le canal. La commande !cycle demande à l'automate de partir et revenir sur le canal, la commande !die provoque la déconnexion du serveur puis l'arrêt de l'automate. Le script de l'automate ci-après se trouve en téléchargement ici et peut être lancé par la commande python mybot.py.

import sys
try:
    from ircbot import SingleServerIRCBot
    import irclib
except ImportError, e:
    print e
    sys.exit(1)

class pybot(SingleServerIRCBot):
    def __init__(self, server, nick, realname, chan):
        SingleServerIRCBot.__init__(self, server, nick, realname)
        self.chan = chan
        self.nick = nick

    ## Event callbacks
    def on_welcome(self, c, e):
        if self.chan:
            c.join(self.chan)

    def on_join(self, c, e):
        who = e.source().split('!', 1)
        if who[0] == self.nick:
            c.privmsg(e.target(), 'Hello world!')

    def on_pubmsg(self, c, e):
        msg = e.arguments()[0].strip()
        if msg.startswith('!'):
            cmd = msg[1:].split(' ', 1)[0]
            self.trigger(c, e, cmd)

    ## Command triggers
    def trigger(self, c, e, cmd):
        try:
            getattr(self, 'cmd_%s' % cmd)(c, e)
        except AttributeError:
            pass

    def cmd_cycle(self, c, e):
        chan = e.target()
        c.part(chan, 'cycle')
        c.join(chan)

    def cmd_die(self, c, e):
        SingleServerIRCBot.die(self, 'Argh')

## Here comes the real script
if __name__ == '__main__':
    server = [('localhost', 6667)]
    nick = 'monbot'
    realname = 'monbot'
    channel = '#test'

    bot = pybot(server, nick, realname, channel)
    try:
        bot.start()
    except KeyboardInterrupt:
        bot.connection.disconnect("Ctrl-C m'a tuer")
        bot.connection.close()

La librairie irclib est basée sur la gestion d'évènements, des méthodes vont être lancées sur apparition d'un évènement au sens IRC. Les méthodes de l'objet pybot commençant par 'on_' sont les méthodes de gestion d'évènements, par exemple lorsqu'un message est envoyé sur un canal (PUBMSG) la méthode on_pubsmg() est appelée. La création de l'automate se base sur la surcharge des méthodes de gestion d'évènements. Ces méthodes ont toutes la même définition d'appel :

def on_foo(self, c, e):
    [...]

La variable c est un objet ServerConnection, cet objet permet de manipuler tout ce qui concerne le serveur irc d'où provient l'évènement. On peut par exemple rejoindre un canal (c.join()) ou envoyer un message à un canal ou une personne (commande PRIVMSG via c.privmsg()). La variable e est un objet Event, elle permet d'obtenir toutes les informations sur l'évènement qui a provoqué l'appel de la méthode. L'origine de l'évènement (e.source()), la destination de cet évènement (e.target()) ou encore les arguments de cet évènement (e.arguments()). Toutes les informations sur ces 2 méthodes se trouvent dans le module irclib (pydoc irclib).

A partir de la connaissance de ces éléments de base, la construction d'un automate devient assez simple. Si l'automate doit effectuer des tâches régulières, les méthodes execute_at() et execute_delayed() (héritage de l'objet IRC parent de SingleServerIRCBot) peuvent être utilisées. Plus d'information sur irclib devrait se trouver sur mon wiki.

Il est également possible d'utiliser twisted.words pour effectuer la même chose mais ça me semble une librairie un peu imposante pour un simple automate.

Il faut noter qu'on peut faire également le même genre de chose en Perl.

WOPR> Global Thermonuclear War

hr — Thu, 03 Jan 2008 18:33:00 +0100

Dans mon parcours d'initiation à python, je me suis retrouvé face à un problème existentiel (ce qui donne tout le caractère initiatique au parcours, le problème, parce qu'il est existentiel ... laisse tomber). Lors de l'utilisation du module cmd, comment gérer correctement les interruptions classiques que sont ctrl+D (EOF) et ctrl-C (SIGINT).

Ci-après, un squelette pour la gestion des 2 signaux évoqués. Juste après ci-après, les quelques explications qui s'imposent.

import sys
import cmd

class shell(cmd.Cmd):
    def __init__(self):
        cmd.Cmd.__init__(self)

    # Let's handle ctrl+D signals and quit gently
    def do_EOF(self, str):
        # CLEAN HERE
        return 1

if __name__ == "__main__":
    console = shell()
    try:
        console.cmdloop()
    except KeyboardInterrupt:
        # CLEAN HERE
        sys.exit(0)

`ctrl-D` ou la fin du monde

Le manuel de cmd nous dit :

An end-of-file on input is passed back as the string 'EOF'.

Ce qui signifie que la combinaison de touches ctrl+D revient à gérer la commande EOF, la méthode appelée est donc do_EOF().
Une autre information à propos de cmdloop() donnée dans le manuel est :

This method will return when the postcmd() method returns a true value. The stop argument to postcmd() is the return value from the command's corresponding do_*() method.

Donc si la méthode do_EOF() retourne simplement 1, la boucle va tout bêtement s'arrêter.

`ctrl-C` ou la fin de l'univers

En Python, l'utilisation de ctrl-C lève l'exception KeyboardInterrupt, en capturant cette interruption, on permet au script de sortir de façon maitrisée.

Evolution

Il est conseillé d'ajouter des actions de nettoyage au niveau des commentaires # CLEAN HERE pour permettre une sortie de la console vraiment sans encombre. Il reste encore à trouver un moyen élégant d'utiliser ctrl-c pour annuler la ligne en cours et récupérer l'invite vierge sans quitter cmd.cmdloop()
Attention toutefois, ce code n'a pas été testé dans un environnement microsoft. Les signaux ne sont surement pas traités de la même façon, ça n'étonnera personne.

Colle toi ça dans les oreilles

hr — Fri, 30 Nov 2007 17:21:00 +0100

Je suis l'heureux possesseur d'un iAUDIO X5L de 30Go, cet appareil est vraiment génial. Sauf quand il vous claque des montages en lecture seule, là c'est un peu pénible.

Nov 30 16:36:09 ewok kernel: [23799.560000] FAT: Filesystem panic (dev sdb1)
Nov 30 16:36:09 ewok kernel: [23799.560000]     fat_get_cluster: invalid cluster chain (i_pos 0)
Nov 30 16:36:09 ewok kernel: [23799.560000]     File system has been set read-only

Pas de problème, il suffit de faire une petite vérification du système de fichier après avoir démonté la partition :

$ sudo umount /media/IAUDIO
$ sudo fsck.vfat -a -v /dev/sdb1
dosfsck 2.11 (12 Mar 2005)
dosfsck 2.11, 12 Mar 2005, FAT32, LFN
Checking we can access the last sector of the filesystem
Boot sector contents:
System ID "MSDOS5.0"
Media byte 0xf8 (hard disk)
[...]
Reclaiming unconnected clusters.
Reclaimed 18671 unused clusters (305905664 bytes) in 73 chains.
Checking free cluster summary.
Free cluster summary wrong (98499 vs. really 98722)
  Auto-correcting.
Performing changes.
/dev/sdb1: 6625 files, 1731289/1830011 clusters

La reconnexion du lecteur à mon port USB et des mouvements de fichiers sur le disque me confirment que le problème a disparu. YATAAAAAAAAAAAA.