Archives de catégorie : Système

Mémo – Raspberry WIFI

Un petit mémo pour configurer plusieurs interfaces WIFI sur un RaspberryPI (raspbian)

#/etc/network/interfaces
auto lo

iface lo inet loopback
iface eth0 inet dhcp

auto wlan0
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf

iface IDunique1 inet dhcp
iface IDunique2 inet dhcp

iface default inet dhcp
#/etc/wpa_supplicant/wpa_supplicant.conf
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

eapol_version=1

network={
    ssid="Mon SSID"
    scan_ssid=1
    mode=0
    proto=WPA2
    auth_alg=OPEN
    pairwise=CCMP
    group=CCMP
    key_mgmt=WPA-PSK
    psk="mon secret partagé"
    id_str="IDunique1"
    priority=1
}

network={
    ssid="Mon SSID"
    scan_ssid=1
    mode=0
    proto=WPA2
    auth_alg=OPEN
    pairwise=CCMP
    group=CCMP
    key_mgmt=WPA-PSK
    psk="mon secret partagé"
    id_str="IDunique2"
    priority=1
}

IPv6 – pare feu

Objectif : profiter de l’ipv6 en conservant un bon niveau de sécurité réseau et sans avoir à gérer les pare-feu de tous ses équipements.

Petite précision avant de commencer. Bien qu’ils allouent un préfixe IPv6 à leur clients, la plupart des certains* FAI ne permettent pas de le segmenter en sous réseaux, ils s’attendent à ce que toutes les machines du réseau soient directement connectés à leur Box, il va donc falloir ruser un peu.

*edit : la situation a changé depuis que j’ai écrit cet article, par exemple avec la Freebox Revolution, Free semble (je ne peux pas tester) offrir un /61 avec possibilité de configurer la délégation, vous trouverez un exemple ici : http://www.goudal.net/?p=6

La suite reste valable dans le cas d’une Freebox V5

Prérequis :

  • une machine sous linux disposant d’au moins 2 interfaces réseaux
  • un préfixe IPv6 (FDN, Free, Nerim, OVH, SFR, … le proposent à leur abonnées)

Il y a 2 principales façon de faire :

  • la première consiste à faire du « brouting ». En gros on transporte les paquets de niveau 2 au travers d’un bridge. Ça revient à brancher tous vos équipements sur un switch capable de faire du filtrage. C’est simple mais assez rigide et pas très propre.
  • la seconde que je vais utiliser ici consiste à faire du routage traditionnel agrémenté d’un proxy NDP.

Ici la machine linux est un Raspberry-Pi sous Debian Wheezy, qui ne dispose que d’une carte réseau. Cette carte sera donc divisée en plusieurs interfaces de VLAN. La connectivité IPv6 sera assurée par une Freebox (v5) configurée en switch (donc pas en routeur).

La passerelle Linux assurera plusieurs fonctions :

  1. routeur-nat pour l’IPv4 : comme le font les box
  2. pare-feu IPv4 : comme ne le font pas les box
  3. routeur IPv6 : comme ne le font pas les box
  4. pare-feu IPv6 : comme ne le font pas les box
  5. proxy NDP : pour leurrer les Box
  6. on pourra compléter l’installation par quelques services de confort (serveur DNS, serveur DHCP, serveur NTP, proxy web, …)

En pratique, notre passerelle va se comporter comme un routeur-firewall IPv4 + IPv6 classique, mais va en plus transporter les annonces NDP (et uniquement ces annonces) de part et d’autre de ses interfaces.

Notes, à remplacer par vos informations :

  • l’interface physique est eth0
  • l’interface connectée à Internet est nommée vlan6
  • l’interface connectée au réseau local est nommée vlan46
  • le préfixe IPv6 de la connexion est 2001:db8:1234:1234::/64
  • le sous réseau 2001:db8:1234:1234::/64 est coté local, avec pour passerelle 2001:db8:1234:1234:1::2
  • le sous réseau 2001:db8:1234:1234::/126 (qui empiète sur le précédent) est notre interco entre notre passerelle et la box qui a pour adresse 2001:db8:1234:1234::1
  • le serveur DNS annoncé est 2001:db8::1
  • l’adresse public IPv4 est 1.1.1.2 avec 1.1.1.1 comme passerelle IPv4 par défaut
  • le réseau local a pour adresses 192.168.0.0/24 en IPv4 et fec0:0:0:ffff::/64 en IPv6
  • la passerelle a pour adresses locale 192.168.0.1 en IPv4 et fec0:0:0:ffff::1 en IPv6

Cette dernière adresse est utile si vous avez des postes sous Windows car ces derniers ne gèrent pas les annonces RDNSS, à la place Microsoft a configuré par défaut 3 adresses de DNS dans sa pile IPv6 : FEC0:0:0: FFFF::1, FEC0:0:0: FFFF::2 et FEC0:0:0:FFFF::3

Cela signifie qu’un poste portant l’une de ses adresses peut devenir automatiquement serveur DNS pour tous les postes d’un réseau local composé de Windows, niveau sécurité on a vu mieux.

En passant, Windows ne gère pas non plus les informations de routage fournie par DHCP en IPv6. Il faut donc annoncer le routeur via NDP et les DNS via DHCP. On ne peut donc pas faire du stateless ni du statefull, il faut combiner les 2 pour avoir un truc qui marche.

Configuration de base

Avant toute chose, assurez vous d’avoir un accès physique à la passerelle et qu’elle est correctement sécurisée (pas de SSH ouvert à tout le monde avec un mot de passe bidon, …).

Installation des paquets

  • Radvd : service d’annonce IPv6
  • NDPpd : proxy pour les paquets NDP (non disponible dans les dépôts Rapsberry, mais il se compile simplement)
  • VLAN : prise en charge du 802.1q (non nécessaire si vous avez plusieurs interfaces physique)

Configuration des services

/etc/radvd.conf

C’est ce service qui va faire de votre machine Linux une passerelle IPv6. Il va annoncer les routes (en particulier la route par défaut) et les serveurs DNS aux machines du réseau local.

interface vlan46 {
    AdvSendAdvert on;
    MinRtrAdvInterval 3;
    MaxRtrAdvInterval 10;
    AdvManagedFlag off;
    AdvOtherConfigFlag off;
    prefix 2001:db8:1234:1234::/64 {
        AdvOnLink on;
        AdvAutonomous on;
        AdvRouterAddr off;
    };
    route 2001:db8:1234:1234::/64 {
    };
    RDNSS 2001:db8::1 {
    };
};

/etc/ndppd.conf

Il va transmettre les annonces NDP de part de d’autre de la passerelle. Notez le /126.

route-ttl 30000
proxy vlan46 {
    router yes
    timeout 500
    ttl 30000
    rule 2001:db8:1234:1234::/126 {
        auto
    }
}
proxy vlan6 {
    router no
    timeout 500
    ttl 30000
    rule 2001:db8:1234:1234::/64 {
        auto
    }
}

Configuration des interfaces

/etc/network/interfaces

Fichier de configuration traditionnel, j’y ai inclus le lancement des services et la configuration noyau nécessaire au routage et au proxy NDP.

auto lo eth0 vlan6 vlan46

iface lo inet loopback

iface eth0 inet manual
    pre-up /sbin/modprobe -q ipv6 ; /bin/true
    pre-up echo 1 > /proc/sys/net/ipv4/ip_forward
    pre-up echo 1 > /proc/sys/net/ipv6/conf/eth0/disable_ipv6
    pre-up echo 1 > /proc/sys/net/ipv6/conf/all/forwarding
    pre-up echo 1 > /proc/sys/net/ipv6/conf/all/forwarding
    pre-up echo 1 > /proc/sys/net/ipv6/conf/default/forwarding
    pre-up echo 1 > /proc/sys/net/ipv6/conf/default/proxy_ndp
    pre-up echo 1 > /proc/sys/net/ipv6/conf/all/proxy_ndp
    up ifconfig eth0 promisc up
    post-up iptables-restore < /etc/iptables.up.rules
    post-up ip6tables-restore < /etc/ip6tables.up.rules
    
iface vlan6 inet manual
    vlan-raw-device eth0
    
iface vlan6 inet static
    vlan-raw-device eth0
    address 1.1.1.2
    netmask 255.255.255.0
    gateway 1.1.1.1
    
iface vlan6 inet6 static
    up ifconfig vlan6 promisc up
    vlan-raw-device eth0
    address 2001:db8:1234:1234::2
    netmask 126
    gateway 2001:db8:1234:1234::1
    
iface vlan46 inet static
    address 192.168.0.2
    netmask 255.255.255.0
    broadcast 192.168.0.255
    network 192.168.0.0
    vlan-raw-device eth0
    
iface vlan46 inet6 static
    up ifconfig vlan46 promisc up
    post-up /usr/local/sbin/ndppd -d
    post-up service radvd start
    address 2001:db8:1234:1234:1::2
    netmask 64
    post-up ip a a fec0:0:0:ffff::1/64 dev vlan46

Filtrage

IPv4

Ici un jeu de règle basique permettant à la passerelle de remplacer la box pour l’accès internet en IPv4 (ce qu’on appelle à tord du NAT). Les règles sont minimalistes, il n’y a pas par exemple de protection contre le flood.

/etc/iptables.up.rules

# Generated by iptables-save
*nat
:INPUT DROP [0:0]
:OUTPUT DROP [0:0]
:PREROUTING ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 192.168.0.0/24 ! -d 192.168.0.0/24 -j MASQUERADE
COMMIT
# Generated by iptables-save
*mangle
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
COMMIT
# Generated by iptables-save
*filter
:localnet - [0:0]
:INPUT DROP [0:0]
:OUTPUT DROP [0:0]
:FORWARD DROP [0:0]
-A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
-A FORWARD -j localnet
-A localnet -s 192.168.0.0/24 -j ACCEPT
-A localnet -s 127.0.0.0/8 -j ACCEPT
-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
-A INPUT -j localnet
-A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
-A OUTPUT -j localnet
COMMIT

IPv6

La même chose en IPv6, sans le « NAT » bien entendu, rien de compliqué.

# Generated by ip6tables-save
*filter
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT DROP [0:0]
#INPUT
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -i vlan46 -j ACCEPT
-A INPUT -s fe80::/10 -j ACCEPT
-A INPUT -s ff00::/8 -j ACCEPT
-A INPUT -i vlan6 -s 2001:db8:1234:1234::/64 -j ACCEPT
#OUTPUT
-A OUTPUT -j ACCEPT
#FORWARD
-A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -o vlan6 -j ACCEPT
-A FORWARD -s 2001:db8:1234:1234::/64 -j ACCEPT
#LOG
-A INPUT -j LOG --log-prefix "[IP6 INPUT] "
-A OUTPUT -j LOG --log-prefix "[IPv6 OUTPUT] "
-A FORWARD -j LOG --log-prefix "[IPv6 FORWARD] "
COMMIT

Il ne reste plus qu’à appliquer le tout, brancher et à vérifier que ça fonctionne.

Plusieurs sites permettent de vérifier si l’on utilise une connexion IPv4 ou IPv6, comme par exemple :

Sources :

Mémo – Juniper NetworkConnect 64bits

Un petit mémo pour configurer un client Linux en 64bits afin que le client VPN Juniper NetworkConnect fonctionne.

————update————

Juniper a mis à jour son client NetworkConnect (depuis la version 7.3) pour qu’il prenne en charge les systèmes 64bits. Il continu à s’exécuter en 32bits, mais la manipulation a changé.

L’article a été mis à jour en conséquences avec plus de détails.

————————————

Installation de JAVA

On commence par installer les 2 versions de JAVA (32 et 64bits), par exemple dans :

  • java 7 32bits : /opt/java/32/…
  • java 7 64bits : /opt/java/64/…

On les déclare au niveau système, sur la plupart des distributions c’est à faire avec update-alternatives –install /usr/bin/java java <chemin vers l’exécutable java> <priority> :

update-alternatives --install /usr/bin/java java /opt/java/32/jdk7/jre/bin/java 327
update-alternatives --install /usr/bin/java java /opt/java/64/jdk7/jre/bin/java 647

Les chemins peuvent changer selon que vous installez le jdk ou la jre.

On spécifie la version de java à utiliser par défaut (normalement celle en 64 bits) :

update-alternatives --config java

Installation des lib 32

Comme le client est en 32bits, il a besoin des librairies 32bits :

Debian (ou dérivée) par trop ancienne :

ln -s /usr/bin/update-alternatives /usr/sbin/
dpkg --add-architecture i386
aptitude update
aptitude install libstdc++6:i386 lib32z1 lib32ncurses5 lib32bz2-1.0 libxext6:i386 libxrender1:i386 libxtst6:i386 libxi6:i386

Debian (ou dérivée) plus ancienne :

aptitude install ia32-libs

Pour RedHat (et ses dérivées) :

yum –y install xterm
yum –y ld-linux.so.2
yum –y libstdc++.so.6
yum –y libz.so.1
yum –y libXext.so.6
yum –y libXrender.so.1
yum –y libXtst.so.6

Pour les SuSE (et ses dérivées) :

zypper install libXi.so.6

Firefox

Pour que Firefox prenne en charge votre nouvelle installation de JAVA il peut être nécessaire de déclarer le plugin JAVA. Normalement update-alternatives s’en occupe, sinon il faut créer un lien dans le dossier des plugins de Firefox, par exemple :

mkdir -p ~/.mozilla/plugins/
ln -s /opt/java/64/jdk7/jre/lib/amd64/libnpjp2.so ~/.mozilla/plugins/libnpjp2.so

NetworkConnect

Juniper SA >= 7.3

Normalement c’est fini.

Juniper < 7.3

On renomme le binaire java 64 en, par exemple, java.orig :

mv /opt/java/64/jdk7/jre/bin/java /opt/java/64/jdk7/jre/bin/java.orig

On créé un nouveau script nommé java au même endroit :

#!/bin/bash
if [ $3x = "NCx" ]
then
/opt/java/32/jdk7/jre/bin/java "$@"
else
/opt/java/64/jdk7/jre/bin/java.orig "$@"
fi

Il ne reste plus qu’à rendre le script exécutable :

chmod a+x /opt/java/64/jdk7/jre/bin/java

En cas de problèmes

Si le client ne fonctionne toujours pas, vérifiez que votre installation de JAVA fonctionne correctement :

En cliquant ici

Avec cette commande :

java -version

En consultant les logs de NetworkConnect (dans ~/.juniper_networks).

sources :

DKIM – Signer ses mails

Je ne vais pas décrire ce qu’est DKIM, ni à quoi ça sert, d’autres le font bien mieux que moi :
Blog Stéphane Bortzmeyer

Il s’agit juste d’un mémo expliquant comment signer les messages sortants, la vérification des mails entrants ne sera pas abordée ici, disons simplement qu’il existe des modules dans la plupart des antispam.

Je note juste ici un exemple de configuration avec dkim-filter et Postfix sur une Debian Squeeze.

On part d’un postfix bien configuré qui envoi directement ses mails sur Internet.

On commence par installer le paquet dkim-filter
apt-get install dkim-filter

Puis on créé un certificat qui va nous servir à signer les mails

mkdir /etc/postfix/dkim/
cd /etc/postfix/dkim/
openssl genrsa -out private.key 1024
openssl rsa -in private.key -pubout -out public.key
chmod 640 private.key
chown dkim-filter private.key

On configure dkim-filter
/etc/default/dkim-filter :

SOCKET="inet:12345@localhost"

/etc/dkim-filter.conf

#On log les actions dans le syslog
Syslog yes
#Utile si vous passez par un socket UNIX
UMask 002
#Les domaines à signer (on peut utiliser un fichier)
Domain mondomaine.tld
#La clef privée, s'il faut signer plusieurs domaines avec plusieurs clefs,
#il faut utiliser le paramètre KeyList à la place de Domain/KeyFile et Selector
KeyFile /etc/postfix/dkim/private.key
#Le selector à utiliser pour vérifier la signature
Selector monselector
#La liste des domaines/ip à signer mais pas à vérifier
InternalHosts /etc/postfix/dkim/InternalHosts.list
#La liste des domaines/ip à ignorer (pas de signature ni de vérification)
PeerList /etc/postfix/dkim/PeerList.list
#On supprimes les anciennes signatures dans le message (en cas de relai)
RemoveOldSignatures yes
#Ces 2 paramètres peuvent être utile pour débugguer
X-Header no
LogWhy no

/etc/postfix/dkim/InternalHosts.list

127.0.0.0/8
192.168.1.0/24

/etc/postfix/dkim/PeerList.list

192.168.2.0/24

S’en est fini de la configuration de dkim-filter, il faut maintenant dire à postfix de l’utiliser :
/etc/postfix/main.cf

smtpd_milters = inet:localhost:12345
non_smtpd_milters = inet:localhost:12345

On relance les 2 daemons

/etc/init.d/dkim-filter restart
/etc/init.d/postfix restart

et on test l’envoi de mails, normalement une signature devrait être présente dans l’entête des messages sortants du serveur.
Si c’est correct, on peut ajouter l’enregistrement DNS contenant la clef public

; DKIM du selector monselector pour le domaine mondomaine.tld
monselector._domainkey.mondomaine.tld. IN TXT "v=DKIM1; k=rsa; p=Afd5g46fdg46fIGfM...9zwIDAQAB"

On peut alors tester en conditions réelles l’envoi de mails vers une domaine qui supporte la vérification DKIM (gmail par exemple)
S’il n’y a pas d’erreurs, on peut ajouter un enregistrement ADSP (Author Domain Signing Practices) dans les DNS, attention, l’enregistrement suivant indique que TOUS les messages non signés venant de mondomaine.tld doivent être jetés !!

; Politique DKIM pour mondomaine.tld
_adsp._domainkey.mondomaine.tld. IN TXT "dkim=discardable"

Cette configuration ne doit pas être installée en production, elle est très incomplète et potentiellement dangereuse pour vos mails !!!
Il s’agit juste d’un mémo, pour le reste RTFM.

sources :