Spamd ou comment bloquer les spams sans discriminer à priori des adresses IPs et sans remettre en cause la neutralité du réseau.

J'ai écrit une page sur spamd sur le principe de fonctionnement et sa mise en place sur OpenBSD.

Ce tout nouveau wiki cogéré par philpep.org et bender-labs.org est plus adapté que mon blog pour ce genre de choses car vous pouvez aussi apporter votre contribution pour faire part de votre expérience (ne serait-ce que pour corriger d'éventuelles fautes d'orthographes et de grammaires :-) ).

Je viens d'acquérir une carte ALIX 2D3 pour m'en servir comme routeur et pour faire tourner certains services critiques à la place de mon serveur qui pourrait décider de tomber en panne un jour. Cette machine n'ayant pas de cartes graphique il y a deux méthodes pour installer un OS sur la carte flash :

• Installer un OS depuis un autre ordinateur en y branchant la carte flash.
• Boot par PXE (réseau) et communication via le port série.

Si comme moi vous n'avez aucuns adaptateur pour brancher la carte flash sur une autre machine il faut le faire en PXE, vous allez voir que même si ça parait compliqué c'est (après coup) assez facile à faire.

Nous allons installer OpenBSD 4.6 par PXE depuis une machine FreeBSD 7.2 mais n'importe quelle autre machine pourvue d'une interface réseau ferra l'affaire (je vous laisse le soin de trouver la documentation approprié pour votre OS).

Déjà il faut activer le boot PXE dans le bios de la carte alix, donc il vous faudra un cable null-modem (et pas un mini gender changer comme j'ai eu le malheur de faire). Si vous n'avez pas de port série, il vous faut un adaptateur série/USB. Ensuite pour causer au port série j'ai utilisé comms/picocom, lançons le avec la vitesse indiquée dans la doc.

picocom -b38400 -fx /dev/ttyU0

Pendant le memcheck tapez sur s pour afficher l'état du bios. Ensuite e pour activer le boot PXE et q pour enregistrer et quitter.

Pour booter sur le réseau il faut trois choses :

1. Un serveur dhcp
2. Un serveur tftp
3. Que alix et le serveur soient branchées ensembles.

Pour le branchement je me suis pas trop cassé la tête vu que les interfaces de la freebox sont sur le même layer. Il suffit donc de brancher alix sur la freebox (avec l'interface à coté de l'alimentation, je ne sais pas si les autres sont capables de démarrer en PXE).

Ensuite installez le serveur dhcp, moi j'ai utilisé net/isc-dhcp30-server. Ça se configure dans /usr/local/etc/dhcpd.conf

ddns-update-style none;
shared-network LOCAL-NET {
    # Mon DNS cache, utilisez ceux de votre FAI si vous n'en avez pas
    option  domain-name-servers 192.168.0.3;

    # On attribue une adresse sur le réseau de la freebox
    subnet 192.168.0.0 netmask 255.255.255.0 {
            # C'est la freebox qui sert de routeur pour l'instant
            option routers 192.168.0.254;
            filename "pxeboot";
            range 192.168.0.200 192.168.0.202;
            next-server 192.168.0.2; # IP sur serveur de boot PXE
            default-lease-time 86400;
            max-lease-time 90000;
    }
}

Et maintenant le serveur tftp, juste une ligne à décommenter dans /etc/inetd.conf :

tftp    dgram   udp     wait    root    /usr/libexec/tftpd      tftpd -l -s /tftpboot

Maintenant il faut mettre les bons fichiers au bon endroit :

mkdir /tftpboot && cd /tftpboot
ftp ftp://ftp.fr.openbsd.org/pub/OpenBSD/4.6/i386/pxeboot
ftp ftp://ftp.fr.openbsd.org/pub/OpenBSD/4.6/i386/bsd.rd

Maintenant démarrez votre serveur de boot PXE :

echo dhcpd_enable=\"YES\" >> /etc/rc.conf
echo inetd_enable=\"YES\" >> /etc/rc.conf
/usr/local/etc/rc.d/isc-dhcpd start
/etc/rc.d/inetd start

Relancez picocom et redémarrez votre alix. Elle va chercher un serveur DHCP, donc si elle ne trouve pas le votre mais plutôt celui de la freebox, désactivez le dhcp de la freebox momentanément.

Ensuite vous voyez le prompt de boot OpenBSD qui echoue parce qu'il ne trouve pas de fichier bsd sur le serveur tftp. Et heureusement parce qu'on a des options à passer au boot (remarque: on aurrait pu les mettre dans /tftpboot/etc/boot.conf, mais je connais pas parfaitement la syntaxe de ce fichier). Il faut lui dire qu'on est sur un terminal série et lui donner la vitesse de celui ci :

boot> stty com0 38400
boot> set tty com0
boot> bsd.rd

Là il va chercher le bsd.rd et démarre l'installateur OpenBSD et vous pouvez suivre la documentation.

1. Remarque0 : Au moment où j'écris ces lignes la doc d'install n'est pas à jours pour OpenBSD 4.6 , en fait l'installateur est beaucoup plus simple maintenant.
2. Remarque1 : Au moment où il pose la question "Change the default console to com0?" répondez oui, ça évitera de le faire plus tard.

Voilà, sinon j'en suis très heureux de cette petite alix qui me sert maintenant de routeur, j'ai mis un proxy http (privoxy) transparent pour filtrer les pubs sur le web, déplacé le serveur DNS dessus en cas de panne de mon autre machine, un pf, un dhcpd etc .

Enjoy.

L’imprimerie a permis au peuple de lire, Internet va lui permettre d’écrire.

Une nouvelle conférence de Benjamin Bayard, c'est un bon condensé de toutes les précédentes (Minitel 2.0, RMLL 2009, radio libertaire ).

La video est disponible sur linuxfr, une autre avec un son un peu plus propre ici.

Il vous est peut être arrivé de devoir coder et tester des programmes en assembleur ARM (peut être même simplement par curiosité qui sait ?) sur des machine x86. Pour y arriver j'ai du installer arm-elf-as (l'assembleur arm de GNU), arm-elf-ld (edition des liens) et le debugger arm-elf-gdb le tout sur FreeBSD. La démarche n'étant pas triviale voici comment installer tous ces softs :

make -C /usr/ports/devel/cross-binutils TGTARCH=arm TGTABI=elf install clean
make -C /usr/ports/devel/cross-gdb TGTARCH=arm TGTABI=elf install clean

Si tout se passe bien et si le temps le permet vous êtes prêts à compiler et tester votre programme ASM ARM :

# Assemblage pour un cpu arm7tdmi par exemple. Avec les options de debug
arm-elf-as -mcpu=arm7tdmi -gstabs main.s -o main.o
# Edition des liens. Avec les options qui vont bien jetez un coup d'oeil à ld(1) en cas de doute
arm-elf-ld -Ttext=0x2000 -nostartfiles -o main main.o
# Lancement dans gdb
arm-elf-gdb ./main

Et amusez vous avec gdb :

GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "--host=i386-portbld-freebsd7.2 --target=arm-elf"...
(gdb) target sim
Connected to the simulator.
(gdb) load
Loading section .text, size 0x34 vma 0x2000
Start address 0x2000
Transfer rate: 416 bits in <1 sec.
(gdb) run
Starting program: /usr/home/phil/src/asm/main

Program exited normally.
(gdb)

Vite fait un petit aide mémoire gdb (je suis moi même un lecteur de mon blog ça m'aide en cas de doute) :

b étiquette|adresse, créer un breakpoint
d, (delete) supprimer tous les breakpoints
r, (run) lancer le programme
s, (step) avancer d'une instruction
i r, (info register) visualiser les registres
x étiquette|adresse, visualiser la mémoire
quit, quitter

N'oubliez pas qu'on peut lancer des make depuis gdb et recharger le programme avec load.

Je viens d'implémenter dans mon shell un système de ramasse miette. Le choix de faire un tel système est particulièrement adapté pour un shell ou pour tout programme qui est fortement cyclique et avec un cycle assez court où chaque allocation peut être libérée rapidement.

En gros l'astuce consiste à créer des fonctions wrapper pour free(3) et malloc(3). Une fois que tous nos appels d'allocation et de libération de mémoire passent par eux il est facile de créer une structure de type pile qui empile l'adresse de chaque allocation pour ensuite tout libérer d'un coup à la fin du cycle.

Pour cela j'ai utilisé les SLIST de sys/queue.h pour la pile que voilà :

typedef struct stack_s {
    void * adr;
    SLIST_ENTRY(stack_s) next;
} stack_s;

Ensuite le wrapper pour malloc (notez qu'on déclare la tête de pile comme variable globale (dans le fichier avec les fonctions wrapper) pour pouvoir y accéder facilement.

/* déclaration de la pile mstack (qu'on initialise à NULL) */
static SLIST_HEAD(, stack_s) mstack = SLIST_HEAD_INITIALIZER(&mstack);

/* Le wrapper pour malloc */
void *
xmalloc(size_t size)
{
    void *ret;
    stack_s *el; /* l'élément a rajouter dans la pile */

    ret = malloc(size);

    if (!ret)
    {
        perror("Malloc ");
        exit (EXIT_FAILURE);
    }

    el = malloc(sizeof(*el));
    el->adr = ret;
    SLIST_INSERT_HEAD(&mstack, el, next);

    return ret;
}

/* Cette fonction vide toute la pile et libère la mémoire */
void
stack_delete(void)
{
    stack_s *el;

    while (!SLIST_EMPTY(&mstack))
    {
        el = SLIST_FIRST(&mstack);
        SLIST_REMOVE_HEAD(&mstack, next);
        free(el->adr);
        free(el);
    }

    return;
}

Voilà, maintenant faites tous vos allocations temporaires avec _malloc et videz la pile de temps en temps (ie à la fin du cycle général de votre programme).

Par exemple dans la boucle principale ça donne quelque chose comme ça :

for (;;)
{
    machin = xmalloc(sizeof(*machin) * 10);
    /*
        ...
        ...
    */

    stack_delete();
}

J'espère que c'est compréhensible, si vous avez une question n'hésitez surtout pas à me demander plus d'information.