Monter sa SeedBox avec Aria2

Nous allons voir dans cet article comment installer et configurer Aria2 avec une interface web. Aria2 est un client extrêmement léger qui permet de télécharger des fichiers via les protocoles HTTP, HTTPS, FTP, torrent et même métalink ! A l’attaque !

apt-get install aria2

Allez dans le dossier /etc/ et créez un dossier aria2 :

cd /etc/ && mkdir aria2

Dans ce dossier on va créer un fichier de configuration pour aria :

cd /etc/aria2/ && touch aria.conf

Éditez le comme suit :

# On reprend les téléchargements préalablement lancés
continue
# On lance aria en tâche de fond
daemon=true
# Dossier où sont stockés les téléchargements
dir=/media/disk/Downloads/Seed
# Fichier où sont stockés les sessions
input-file=/var/log/aria2/session.txt
save-session=/var/log/aria2/session.txt
# Intervalle de temps entre 2 sauvegarde de session
save-session-interval=20
# Type d'allocation d'espace sur le disque
file-allocation=falloc
# Niveau d'alerte des log
log-level=warn
# Nombre de connections simultanées à un serveur
max-connection-per-server=3
# Nombre maximum de téléchargements en même temps
max-concurrent-downloads=100
# Bande passante maximum (0 = aucune) en téléchargement
max-overall-download-limit=0
# Aria découpe les fichiers pour les télécharger en parallèle,
# dans ce cas on découpe les fichiers s'ils font plus de 5 Mo
min-split-size=5M

# On va communiquer avec aria grâce à son RPC, une interface 
# pour communiquer en XML ou JSON
enable-rpc=true
# Le RPC réponds à toutes les adresses IP
rpc-listen-all=true
# Le RPC écoute sur le port 6800
rpc-listen-port=6800
# L'identifiant de connexion au RPC
rpc-user=xxx
# Le mot de passe de connexion au RPC
rpc-passwd=xxx
# Configuration de DHT qui permet de récupérer des informations 
# sur les torrents sans tracker
dht-listen-port=6881
enable-dht=true
# On autorise l'échange de pairs
enable-peer-exchange=true
# Port d'écoute de DHT
listen-port=6881

# Nombre de pairs maximum
bt-max-peers=55
# Timeout de connection à un tracker (en secondes)
bt-tracker-connect-timeout=10
# Intervalle de renouvellement des trackers
bt-tracker-interval=900
# Timeout des trackers (en secondes)
bt-tracker-timeout=10
# Ratio de seed avant qu'un téléchargement soit considéré comme complet
seed-ratio=10.0
# Cache utilisé par aria
disc-cache=32M

On va se rajouter un petit script pour pouvoir utiliser aria en tant que service. Placez vous dans le dossier /etc/init.d/ et créez un fichier aria2 que vous rendrez exécutable :

cd /etc/init.d/ && touch aria2 && chmod +x aria2

Éditez le comme suit :

#! /bin/sh
 
### BEGIN INIT INFO
# Provides: aria2cRPC
# Required-Start: $network $local_fs $remote_fs
# Required-Stop: $network $local_fs $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: aria2c RPC init script.
# Description: Starts and stops aria2 RPC services.
### END INIT INFO
 
RETVAL=0
case "$1" in
 start)
 echo -n "Starting aria2 daemon..."
 # Sans VPN
 aria2c --conf-path=/etc/aria2/aria.conf
 # Avec un VPN (si vous avez suivi le précédent tuto ^^)
 # su vpn -c "aria2c --conf-path=/etc/aria2/aria.conf"
 RETVAL=$?
 echo
 ;;
 stop)
 echo -n "Shutting down aria2 daemon..."
 /usr/bin/killall aria2c
 RETVAL=$?
 echo
 ;;
 restart)
 stop
 sleep 3
 start
 ;;
 *)
 echo $"Usage: $0 {start|stop|restart}"
 RETVAL=1
esac
exit $RETVAL

On peut maintenant démarrer ou arrêter aria comme un service, ie :

service aria2 start
Starting aria2 daemon...

service aria2 stop
Shutting down aria2 daemon...

Ou le lancer automatiquement au démarrage :

update-rc.d aria2 defaults

C’est bien joli me direz-vous, mais comment fait on pour rajouter des téléchargements ? Et bien, étant donné que nous avons configuré aria pour être commandé par son RPC, on va récupérer une interface web qui va se charger de communiquer avec ce RPC.

Récupérons donc une interface web pour aria. Je suppose que vous avez un serveur Apache ou Nginx fonctionnel. On se place dans le dossier /var/www/ :

cd /var/www/

Et on récupère l’interface web (je vous propose celle de ziahamza qui est à mon sens la plus aboutie : https://github.com/ziahamza/webui-aria2 ) :

git clone https://github.com/ziahamza/webui-aria2 aria2webui

Si vous n’avez pas git :

apt-get install git

Vous n’avez plus qu’a vous rendre à l’adresse http://localhost/aria2webui et vous pourrez enfin télécharger des images de Linux dans de bonnes conditions !

Monitorer son réseau avec jnettop

jnettop est un outil pour monitorer votre trafic réseau en proposant une vision interface par interface des paquets.

Pour l’installer on fait comme d’hab !

apt-get install jnettop

Ensuite pour visualiser le trafic en cours sur les différentes interfaces, tapez (il vous faudra avoir des droits root) :

jnettop

Vous pouvez alors à l’aide des touches 1, 2, 3, 4… changer d’interface.

A vous le suivi des paquets !

Rerouter une partie du réseau vers son VPN

Pour le premier article de ce blog nous allons voir comment mettre en place un VPN avec OpenVPN et comment router non pas tout votre trafic vers ce tunnel VPN (je suppose que vous savez déjà le faire) mais uniquement une partie que vous pourrez choisir.

Nous allons pour cela mettre en place une politique de routage permettant qu’un certain utilisateur (on va l’appeler « vpn » pour faire original) ait tout son traffic rerouté vers le VPN.

Tout d’abord installez OpenVPN et resolvconf :

apt-get install openvpn resolvconf

Récupérez ensuite sur le site de votre provider VPN les fichiers de configuration d’OpenVPN. Placez les dans le dossier

/etc/openvpn/

Dans le fichier votrevpn.ovpn, assurez vous d’avoir les lignes suivantes (et surtout celle en rouge qui permet de ne pas modifier notre routage des paquets !) :

client
dev tun
resolv-retry infinite
persist-key
persist-tun
daemon openvpn
route-nopull

Toujours dans le dossier /etc/openvpn/, créez le fichier update-resolv-conf et rendez le executable :

cd /etc/openvpn/
touch update-resolv-conf
chmod +x update-resolv-conf

Editez le fichier comme suit :

#!/bin/bash
# 
# Parses DHCP options from openvpn to update resolv.conf
# To use set as 'up' and 'down' script in your openvpn *.conf:
# up /etc/openvpn/update-resolv-conf
# down /etc/openvpn/update-resolv-conf
#
# Used snippets of resolvconf script by Thomas Hood <jdthood@yahoo.co.uk> 
# and Chris Hanson
# Licensed under the GNU GPL.  See /usr/share/common-licenses/GPL. 
#
# 05/2006 chlauber@bnc.ch
# 
# Example envs set from openvpn:
# foreign_option_1='dhcp-option DNS 193.43.27.132'
# foreign_option_2='dhcp-option DNS 193.43.27.133'
# foreign_option_3='dhcp-option DOMAIN be.bnc.ch'

[ -x /sbin/resolvconf ] || exit 0

case $script_type in

up)
	for optionname in ${!foreign_option_*} ; do
		option="${!optionname}"
		echo $option
		part1=$(echo "$option" | cut -d " " -f 1)
		if [ "$part1" == "dhcp-option" ] ; then
			part2=$(echo "$option" | cut -d " " -f 2)
			part3=$(echo "$option" | cut -d " " -f 3)
			if [ "$part2" == "DNS" ] ; then
				IF_DNS_NAMESERVERS="$IF_DNS_NAMESERVERS $part3"
			fi
			if [ "$part2" == "DOMAIN" ] ; then
				IF_DNS_SEARCH="$IF_DNS_SEARCH $part3"
			fi
		fi
	done
	R=""
	for SS in $IF_DNS_SEARCH ; do
        	R="${R}search $SS
"
	done
	for NS in $IF_DNS_NAMESERVERS ; do
        	R="${R}nameserver $NS
"
	done
	echo -n "$R" | /sbin/resolvconf -a "${dev}.inet"
	;;
down)
	/sbin/resolvconf -d "${dev}.inet"
	;;
esac

Editez le fichier /etc/iproute2/rt_tables :

echo "200 vpn" >> /etc/iproute2/rt_tables

Créez l’utilisateur vpn :

adduser vpn

Revenez dans le dossier /etc/openvpn/, créez le fichier « firewall.sh » et rendez le executable. Editez le comme suit :

#! /bin/bash

# L'interface du tunnel
export INTERFACE="tun0"
# L'interface locale (RJ45)
export NETIF="eth0"
# L'interface dite de loopback
export LOOPBACK="lo"
# L'utilisateur vpn
export VPNUSER="vpn"
# Tous les IP du réseau local
export LANIP="192.168.0.0/24"

# On vide les tables
iptables -F
iptables -F -t nat
iptables -F -t mangle
iptables -F -t filter

#
#   CHAINES OUTPUT
#

# On marque les paquets que l'on va rerouter vers le VPN
# Tous les paquets provenants de l'utilisateur vpn sont routés vers le VPN
iptables -t mangle -A OUTPUT -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x1
# Les paquets sortants par le ports xxx proviennent de l'utilisateur vpn mais ils 
# ne seront pas routés vers le VPN
iptables -t mangle -A OUTPUT -p tcp --sport xxx   -j MARK --set-mark 0x2

# On rejette les connnections avec une IP de réseau local sur le VPN
iptables -A OUTPUT ! --src $LANIP -o $NETIF -j REJECT

# On autorise l access a lo et a la connexion classique pour l utilisateur $VPNUSER
iptables -A OUTPUT -o $LOOPBACK  -m owner --uid-owner $VPNUSER -j ACCEPT
iptables -A OUTPUT -o $INTERFACE -m owner --uid-owner $VPNUSER -j ACCEPT

#
#   CHAINES POSTROUTING
#

# Tout les paquets sur $INTERFACE doivent être flagués MASQUERADE
iptables -t nat -A POSTROUTING -o $INTERFACE -j MASQUERADE

#
#   CHAINES INPUT
#

# On autorise les réponses
iptables -A INPUT -i $INTERFACE -m conntrack --ctstate ESTABLISHED -j ACCEPT

# On autorise via la connexion classique
# SSH
iptables -A INPUT -i $NETIF -p tcp --dport 22   -j ACCEPT
# HTTP
iptables -A INPUT -i $NETIF -p tcp --dport 80   -j ACCEPT
# HTTPS
iptables -A INPUT -i $NETIF -p tcp --dport 443  -j ACCEPT

# On bloque tout le reste qui arrive sur le VPN
iptables -A INPUT -i $INTERFACE -j REJECT

Toujours dans le dossier /etc/openvpn/, créez le fichier « up.sh » et rendez le executable. Editez le comme suit :

#!/bin/sh

sh /etc/openvpn/firewall.sh

VPNIF="tun0"
VPNUSER="vpn"
GATEWAYIP=`ifconfig $VPNIF | egrep -o '([0-9]{1,3}\.){3}[0-9]{1,3}' | egrep -v '255|(127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})' | tail -n1`
ip rule add from all fwmark 0x1 lookup $VPNUSER
ip route replace default via $GATEWAYIP table $VPNUSER
ip route append default via 127.0.0.1 dev lo table $VPNUSER
ip route flush cache

/etc/openvpn/update-resolv-conf

On arrive à la fin (oui c’est long, courage) !!
On va créer un script se lançant au démarrage et permettant de nous connecter à notre VPN.

Allez dans le dossier /etc/init.d/, créez un fichier vpn.sh et rendez le exécutable. Editez le comme suit :

#!/bin/sh
##     Script de lancement du VPN     ##
### BEGIN INIT INFO
# Provides: inso_startVPN.sh
# Required-Start:   $remote_fs $syslog
# Required-Stop: 
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: script perso VPN
# Description: script de lancement du VPN
#             
### END INIT INFO

openvpn --config /etc/openvpn/votrevpn.ovpn --script-security 2 --up /etc/openvpn/up.sh

Et ajoutez le au démarrage :

update-rc.d vpn.sh defaults

On peut redémarrer, on va enfin tester tout ça !

reboot

Au redémarrage, si tout s’est bien passé vous devriez avoir une nouvelle interface (tun0, on peut lister les interfaces avec la commande « ifconfig »).
Tous les paquets provenant de l’utilisateur vpn sont routés vers cette interface.
Testons !

 ins0@mars:~ curl ifconfig.co
82.68.103.132
 ins0@mars:~ su vpn -c "curl ifconfig.co"
Password:
35.49.113.82

NB: les adresses IP données dans le test final sont fictives ^^