Créer une copie sécurisée de ses données

C'est parti pour une petite explication sur la création d'une copie sécurisée de ses données (enfin à ma façon). Il "existe" 3 règles de sauvegarde simples :

• 3 copie de sauvegarde des données à conserver, parce qu'une copie peut se corrompre (les CD peuvent s'abîmer assez facilement par exemple) .. ou se perdre bêtement lorsqu'on tente d'y récupérer les données (oups, j'ai supprimé les mauvais fichiers .. Gnééé )
• 2 support de stockage différents, pour éviter qu'un type de support vous lâche ; par exemple disque dur, mémoire flash (SSD, SD), CD/DVD, bande magnétique, en ligne.
• 1 site de stockage "hors site", càd pas chez vous : ben oui, si les 3 sauvegardes sont dans la même maison qui brûle, c'est fini.

Ici, l'idée c'est de faire une sauvegarde hors site (chez une personne de la famille) sur un disque dur, avec une petite variante, la sauvegarde sera chiffrée pour ne pas être lisible "hors ligne", en cas de vol par exemple. Cette sauvegarde se fait depuis un autre disque dur qui lui reste avec moi.

Note : je n'ai pas fait de lien dans l'article pour chaque annexe, mais elles font références à des remarques dans cet article, il peut donc être utile d'y jeter un œil.

Grosso-modo, voici les étapes :

1. ranger la source
2. la vérifier (chkdsk), faire un audit (fslog)
3. enlever ce disque source, préparer la destination (ici avec TrueCrypt)
4. remettre et monter la source en ReadOnly
5. lancer la copie (environ une bonne nuit pour 750Go)
6. vérifier cette copie (les fichiers, le filesystem, le conteneur chiffré)
7. remonter la source en RW

Ranger la source : simplement car c'est plus facile de le faire avant la réplication qu'après ; par exemple voici la racine de mon disque : 

Albums        Jeux             Photos                     !En vrac
Albums - tmp  Jeux Steam       Steam                      !Tmp
Archives      Jeux console     System Volume Information  $RECYCLE.BIN
Docs          Logiciels        Vidéos                     _fslog
ATEPI         Mangas           Wii
Images        Matériel         ZTE Blade
Info          Personalisation  !Backup - Wuala

Vérifier la source, faire un audit : pour ne pas être emmerdé lors de la copie (un fichier corrompu qui gène ou serait copié, ..) et l'audit (contenant la liste des fichiers et leur propriétés) pour garder une trace du contenu à ce moment.
Pour l'audit j'utilise un petit batch perso "fslog" qui me récupère et me compresse pour un lecteur :

• Tree /A et Tree /A /F : la liste des fichiers et dossiers sous forme d'arbre
• Dir /A /S : le contenu des répertoires (avec les heures de modification donc)
• Attrib /D /S : les attributs des fichiers
• Streams -s et Streams -s -d : enregistre les flux alternatifs avant de les supprimer (indésirables)

Compressé cela me donne un fichier que je date, de quelques mégaoctets. Si ça intéresse quelqu'un je peux le passer.

Enlever la source/préparer la destination : ici la destination est amenée à être formatée, ça serait dommage de se tromper de disque et perdre la source avant même de l'avoir copié .. Donc on l'enlève.
On peut s'occuper de la destination, vérifier que le disque ne contient pas d'erreurs si il n'a jamais été utilisé et finalement préparer le conteneur TrueCrypt.
J'ai choisi de le placer dans une partition de type NTFS Cachée (0x17) que Windows n'essayera pas de monter : j'ai supprimé toute partition du disque, créé une partition simple, changé son type avec un éditeur comme Active@ Partition Manager :

Puis j'ai créé le conteneur TrueCrypt sur cette partition :

• Créer une volume
• Chiffer une partition non système
• choisir le type de volume, choisir le périphérique (de la forme \Device\Harddisk1\Partition1 du coup)
• Create encrypted volume and format it (ne va pas essayer de convertir un éventuel contenu)
• choisir le chiffrement/hashage (AES/SHA-512 convient très bien et AES est accéléré matériellement sur mon PC) ; voir le lien en annexe
• confirmer la sélection, choisir une/des clefs (et ne pas les oublier !)
• enfin choisir le système de fichier : je recommande NTFS qui est robuste et lisible au minimum partout, en formatage rapide (utile surtout si les traces d'anciens fichier qui pourraient persister peuvent rester avant de se faire écraser), puis c'est parti !

Quand c'est terminé, le conteneur peut être monté et devient accessible via le lecteur choisi.

Remonter la source en ReadOnly : la destination est prête, on peut s'attaquer à la copie, mais a mon avis une étape importante est de bien placer la source en lecture seule pour éviter des erreurs bête telles que supprimer dans la source au lieu de la destination ou inverser source et destination lorsqu'on utilise robocopy en mode miroir (ce qui revient a supprimer la source si la destination est vide).
Sous Windows (7) cela peut être fait assez simplement, en lançant une invite de commande en mode admin, pour accéder a diskpart :

diskpart
list volume
select volume <x>
att vol set readonly

Puis vérifier qu'aucune création/suppression de fichier n'est possible.

Lancer la copie : la source est "sécurisée", la copie peut être faite sans risque ; pour ma part j'ai utilisé Robocopy. Celui-ci est fourni dans Win7, mais bugg..featuré d'un log unicode illisible, j'ai donc utilisé la version précédente, XP026 trouvable dans Easy RoboCopy par exemple (avec un p'tit coup de Winrar/7-zip sur le fichier d'install).

It's not a bug, it's a feature 

Et pour la ligne de commande :

robocopy.xp026.exe H:\ G:\ /MIR /V /ETA /R:3 /XD "H:\$RECYCLE.BIN" "H:\System Volume Information" /X /TS /FP /BYTES /NP /TEE /UNILOG+:C:\tmp\robocopy.log

Explications :

• Lecteur H source, G destination
• MIR : G aura exactement le même contenu que H, des fichiers peuvent donc être supprimés sur G si besoin (attention donc à ne pas inverser source et destination)
• ETA : affiche les heures et un ETA pour chaque fichier (peut servir pour trouver ce qui prend du temps à copier)
• R:3 : ne pas essayer de copier un fichier plus de 3 fois (! 1 million par défaut, et quand on oublie d'exclure System Volume Information, bah ça bloque)
• XD : exclut ces chemins (liés à Windows, chaque volume possède sa version)
• TS : affiche l'horodatage du fichier source
• FP : affiche le chemin complet de chaque fichier
• BYTES : affiche la taille en octets, pas d'affichage "humain" en mega/giga
• NP : pas de progression (pourrit les logs avec des lignes de 1% 2% 3%)
• TEE : permet d'afficher les informations tout en enregistrant dans un fichier de log
• UNILOG+ : enregistre l'affichage dans un fichier de log, en unicode ; dans mon cas le fichier faisait ~80Mo non compressé au final
• ah, et /L permet de faire une simulation de ce qui serait fait.

Plus qu'a laisser tourner une nuit.

Vérifications (fichiers, filesystem, conteneur) : la copie terminée, pour Robocopy la même commande peut être relancée (en changeant le fichier de log de préférence) pour vérifier en 10 mins que la destination est bien un miroir, aucune modification ne devrait alors être faite. On peut aussi lancer un fslog sur la destination et comparer les Tree /A /F qui doivent être identiques à 1-2 lignes près.

Ensuite un chkdsk peut être utile ("Vérifier" dans TC si ça ne fonctionne pas) pour s'assurer que le système de fichier est sain.

Enfin on peut démonter le volume chiffré pour essayer de le remonter et s'assurer qu'il est bien lisible.

Remonter la source en RW : bon, ben c'est fini pour la copie, on peut remonter la source en modification, ce qui donne dans diskpart

att vol clear readonly

And it's done !

A côté, on peut se rendre ce volume accessible à distance en étant relié à un petit serveur linux par exemple. TrueCrypt n'est pas très apprécié sous Linux il semblerait, j'ai utilisé tc-play qui s'installe en 5 secs sous linux (yum install tcplay de mémoire). Ensuite pour s'en servir, pas très compliqué (on retrouve les infos dans la man page) :
tcplay -i -d /dev/sdc1 pour des infos sur le volume et
tcplay -m tc_Teranium -d /dev/sdc1 pour le rendre accessible dans /dev/mapper/tc_Teranium, puis il reste à le monter avec mount /dev/mapper/tc_Teranium /media/Teranium par exemple :)
Dans les 2 cas la clef est demandée pour pouvoir lire le volume.

[alex@Virgo Teranium]$ ls -la /dev/mapper/
lrwxrwxrwx  1 root root      7 Dec  1 15:47 tc_Teranium -> ../dm-2

[alex@Virgo Teranium]$ ls -la /dev/disk/by-uuid/
lrwxrwxrwx 1 root root  10 Dec  1 15:47 6234BB7C34BB51B1 -> ../../dm-2

[alex@Virgo Teranium]$ mount
/dev/mapper/tc_Teranium on /media/Teranium type fuseblk (rw,noexec,nosuid,nodev,allow_other,blksize=4096,default_permissions)

Me voici donc avec 2 copies de mes fichiers à 2 emplacements, et pour les plus importants, j'utilise Wuala, qui fait un chiffrement côté client, de la synchro, backup, .., un client java qui est d'ailleurs disponible sur un peu toutes les plateformes.

3 sauvegardes, 2 supports différents, 3 emplacements différents (au moins, je ne sais pas ce fait Wuala), pas trop mal non ? Et sans forcément se ruiner ..

Les annexes : 
https://fedoraproject.org/wiki/Forbidden_items?rd=ForbiddenItems#TrueCrypt
https://github.com/bwalex/tc-play#readme
https://ask.fedoraproject.org/question/358/tcplay-usb-clean-unmount
http://leaf.dragonflybsd.org/cgi/web-man?command=tcplay&section=8

http://superuser.com/questions/213005/how-to-mount-an-ntfs-partition-read-only-in-windows
http://superuser.com/questions/383333/truecrypt-ripemd-160-vs-sha-512-vs-whirlpool
http://superuser.com/questions/295934/robocopy-unilog-output-is-gibberish
http://christ-offer.blogspot.fr/2011/01/simple-backups-with-robocopy.html
http://technet.microsoft.com/en-us/magazine/2009.04.utilityspotlight.aspx
http://tribblesoft.com/EasyRoboCopy.php (1.0.13)

Simplifier la sécurisation de son système (MAJ)

Au menu d'aujourd'hui, quelques idées pour garder simplifier la sécurisation de son système (Windows 7 j'entend) et l'optimiser. Au programme :

• ouverture de session automatique mais sécurisée
• sécurisation de la fermeture du capot
• garder facilement ses mots de passe sous la main
• se connecter facilement aux serveurs

Les 3 premiers points reposent sur la sureté du mot de passe de session, mais de toute façon le cran au dessus est probablement le chiffrage des données, qui est un poil plus lourd ..

Ouverture de session automatique mais sécurisée

Je redémarre rarement mon système (la magie de la mise en veille quand les drivers fonctionnent <3), mais quand ça arrive j'ai tendance à appuyer sur le bouton démarrer et revenir quand c'est démarré ; le problème avec un mot de passe sur la session (mais aussi sans, je crois me rappeler qu'une mise à jour désactive la connexion automatique même sans mot de passe), c'est qu'il faut encore attendre que les programmes se chargent une fois la session ouverte.
Le problème d'activer la connexion automatique, c'est qu'il suffit de rebooter le système pour ouvrir la session. La solution est simple : locker la session à son ouverture.

Bon, dans un premier temps, l'ouverture automatique :

1. Executer (Démarrer>Executer ou Win+R) "control userpasswords2" (ou netplwiz)
2. Décocher la case "Les utilisateurs doivent entrer un nom d'utilisateur et une mot de passe pour utiliser cet ordinateur."
3. On vous demande alors les informations pour se connecter automatiquement

Ensuite, le lock à l'ouverture ; pour cela on fait appel au petit nircmd (l'utilitaire se cache en bas de la page) et son option lockws (lock workstation). Pour l'executer au démarrage de la session, 2 choix, le dossier "Démarrage" de l'utilisateur ou la clé de registre "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run". J'ai choisi la clé de registre, ça évite de l'enlever par erreur est c'est plus chiant à enlever qu'un simple fichier (avec un live cd par exemple ..) : 

1. Lancer l'éditeur de registre "regedit"
2. Naviguer jusqu'à la clé mentionnée
3. Créer une valeur chaîne, la nommer "BootLock" par exemple, et en valeur : "<le chemin vers nircmd.exe> lockws"

Exemple de clé extraite : 

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run]
"BootLock"="\"C:\\Utils\\nircmd.exe\" lockws"

Voila, la session démarre en même temps que le système, sans pour autant être accessible sans le mot de passe.

Sécurisation de la fermeture du capot

Un truc bête, mais sans histoire de truc "AwayMode" (qui semble garder le PC éveillé ou un truc comme ça), pas possible de verouiller la session à la fermeture du capot. Et trouver le petit utilitaire qui fait ça sur internet n'est pas très évident, il se cache le petit !
Mais j'ai fini par le trouver : http://akhaliq.com/?p=198, LCLock.exe.
La source du programme est plus ou moins donnée sur la page, et au final comme pour le lock, il suffit de créer en entrée registre dans Run qui pointe vers ce programme qui tournera en tache de fond et lockera la session dès que l'écran est fermé.

Exemple de clé extraite : 

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run]
"Lock"="\"C:\\Utils\\LCLock.exe\""

Edit : un certain "Num" propose une version un peu améliorée (LidLock.exe) en VB.net qui offre ces changements :

• disparition de la fenêtre fantôme "Form1"
• ajout d'une icone dans le tray
• option démarrage en même temps que la session dans le menu tray

J'en fais un miroir ici (source : http://skoffie.servebeer.com/LidLock.exe, n'existe plus), il fait 30ko.

Garder facilement ses mots de passe sous la main

Même si je me souviens d'une bonne partie de mes mots de passe, ça peut être utile de les stocker quelque part, comme dans KeePass dont la base peut être lisible sur toutes les plateformes. Et si on utilisait RoboForm, on peut les importer en utilisant ce script : http://ubuntuforums.org/showthread.php?t=722102 (version FR page 2, et il semble exister ce script maintenant : http://code.google.com/p/robo2keepass/).

Bref, bien pratique d'avoir ses mots de passe sous la main, mais ouvrir la base à chaque fois est plutôt pénible, même au démarrage surtout avec un mot de passe/une clé un peu longue (et je ne parle pas de la possibilité d'utiliser un fichier clé sur une clé USB par exemple, qui est contraignant).

Mais hier, en cherchant comment démarrer KeePass minimisé, je suis tombé sur un argument plutot sympa : "-pw-enc". Celui-ci permet d'ouvrir la base en utilisant le mot de passe chiffré avec les informations de la session de l'utilisateur actuel, il faut donc en théorie entrer dans la session pour que la base s'ouvre avec cette clé. J'ai testé, effectivement sur un autre PC la clé que j'avais généré n'était pas du tout valable :)

Assez de bla bla, au final il faut créer une entrée temporaire dans KeePass qui contient le passe de la base, mettre "{PASSWORD_ENC}" comme URL, puis sur cette entrée créer, clic droit, URL, copier dans le presse-papier.

On obtient alors un identifiant de la forme

AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAAZ1QJmadtMEySLktoapckawAAAAACAAAAAAAQZgAAAAEAACAAAADxHsY7Co20ZPpMx/5ddzoBEX+pi3siw6EmJHIQyS8QbwAAAAAOgAAAAAIAACAAAACg7dldnb+L7nW24ogbs9MwMRglkJIoucPUx+kt4NSxTyAAAABtXX/TfO8xus3/FcXXDfbl9WrgEVR5PBRekHW9FzcMBUAAAACRDR7DBaT76gSxK8r1BXimMSBaXP+eOyNHBk5JQfQnbTJ9a80z906fiWery5YfS37uSpjFM+rJk7zxFTym7WRr

Pour l'utiliser pour un lancement au démarrage par exemple, pas possible d'utiliser un raccourci dans démarrer cette fois, l'identifiant ne tient pas dans le raccourci, et après test, il semble que ça ne fonctionne pas non plus dans le registre (la clé est bien présente mais le programme pas lancé), 3ème solution : un petit fichier batch KeePass.bat dans le dossier Démarrage contenant :

start "" C:\Users\Alexandre\Softs\KeePass\KeePass.exe -minimize -pw-enc:"AQAAANC[..]ym7WRr" "C:\Users\Alexandre\Privé\Pass.kdbx"

Notez le « "" » qui sert à indiquer le titre de la fenêtre (start /?), autrement c'est la prochaine chaîne entre guillemet qui pourrait être utilisée (ici le fichier) et le lancement ne fonctionnerait pas.
Et voila donc une base qui s'ouvre toute seule en même temps que la session, minimisée :)

Se connecter facilement aux serveurs

Enfin, pour ceux qui s'amusent avec des serveurs ou a faire des transferts de fichiers via SFTP/SCP, un moyen simple pour s'authentifier est d'utiliser l'authentification par clé privée/publique. On trouve plein de tuto sur internet (plus ou moins bien faits mais bon), et au final c'est le petit utilitaire Pageant (ce truc dont on se demande bien a quoi il sert quand on utilise PuTTY) qui permet de garder les clés en mémoire.

Encore une fois le plus simple est de le faire démarrer en même temps que la session, en lui indiquant en paramètre les clés a charger, ainsi au démarrage il suffit d'ouvrir les clés une fois, et les programmes tels que PuTTY ou WinSCP pourront s'en servir directement.

C:\Users\Alexandre\Softs\PuTTY\pageant.exe "C:\Users\Alexandre\Privé\Keys\key1.ppk" "C:\Users\Alexandre\Privé\Keys\key2.ppk"

Enfin, un petit plus pour gérer les clés et certificats est le programme XCA : http://xca.sourceforge.net/ qui remplace très bien la ligne de commande pour la génération de certificats :)

Serveur FTP simple et limitation de débit

[Les configurations sont à la fin]
Bon alors voila, sur mon OpenG@te Pyxis (qui tourne sous Amahi, une Fedora 14 customisée pour en faire facilement une box centrale à la maison ; trop même dès fois puisqu'elle remplace le serveur DHCP par défaut), y'a un disque dur qui contient 2To de données que j'ai envie de rendre accessible à quelques personnes en lecture seule sans me prendre la tête.
J'avais d'abord pensé proposer un accès SFTP/SCP, mais c'est pas forcément le plus simple (il faut créer des utilisateurs et s'assurer que ceux-ci n'ont accès qu'au partage) et surtout, je n'ai pas trouvé le moyen de brider le débit pour ne pas ralentir la connexion au quotidien (parce que quand l'upload est a fond, la navigation devient chiante).

Je me suis donc tourné vers le bon vieux FTP, dans un premier temps en clair, puis ensuite en chiffré, à l'aide du simple mais efficace et sécurisé VsFTPd. Il propose une gestion des utilisateurs anonyme qui convient très bien à mon usage : un utilisateur commun avec une liste de mots de passes valides (-> 1/personne) dans un fichier texte : c'est facile à maintenir.
Pour le gestion des utilisateurs, c'est bon, il reste la gestion de la bande passante ; j'avais dans un premier temps pensé utiliser la directive "anon_max_rate" pour brider les anonymes .. le problème est qu'elle s'applique par connexion -> cela oblige à limiter l'accès au serveur à 1 connexion/client et 1 client. En plus, pour proposer le SSL explicite et implicite en IPv4 et IPv6, ce sont 4 instances du daemon qui tournent .. chacune ayant sa limitation .. Pas bon toussa.

Je me dis qu'il y a bien un autre serveur qui proposera cette option, je retourne donc voir mes autres options :

• ProFTPd : configuration Apache-style qui me semble une usine à gaz, on oublie
• glFTPd : semble presque abandonné, la gestion des utilisateurs ne me convient pas et semble prévue pour gérer du warez
• Pure-FTPd : semble sympa, même si en mode virtuel il faut créer des utilisateurs dans une BDD spécifique, je vois une option "anonymousbandwidth" sympa .. seulement en jetant un œil dans la FAQ, on y trouve
  

  * Global bandwidth limitation.
  -> How do I limit the *total* bandwidth for FTP?
  Pure-FTPd can limit bandwidth usage of every session. But limiting the total bandwidth is intentionally not implemented, because most operating systems already have very efficient algorithms to handle bandwidth throttling.

  Comme pour VsFTPd, la limitation est par session, et avec cette gestion des utilisateurs, c'est encore moins bon.

Visiblement, un serveur simple avec une limitation globale de la BP ça n'existe pas, je décide donc de garder VsFTPD mais en suivant la méthode proposée par Pure-FTPd à base de TC (traffic control) pour limiter la BP.

Après une après-midi pour comprendre comment fonctionnent les QDisc, Class, Filter et pour ne pas casser le réglage qui semble exister par défaut (qdisc pfifo_fast 0: dev eth0 root refcnt 2 bands 3 priomap  1 2 2 2 1 2 0 0 1 1 1 1 1 1 1 1), j'ai enfin une limitation du débit qui fonctionne !

En résumé, sur mon interface eth0 j'ai une qdisc htb qui me permet d'avoir 2 classes htb filles qui permettent une gestion du débit, l'une est à 100MBit/s (i.e. sans limite), par défaut, l'autre est bridée à 90kbps et accueillera les paquets selectionnés. Sous ces classes, je remet une gestion des priorités (dépendant du champ TOS) à l'aide de prio.

              1:0      htb envoi vers 1:1 par défaut
             /   \
            /     \
          1:1     1:2  htb rate 100mbit et rate 90kbps
           |       |
          10:     20:  
         (prio)  (prio)

Si j'ai compris, la racine de cet arbre est à la fois l'entrée et la sortie des paquets : le noyau les envoi puis ils sont rangés et ressortis des files par les différents moteurs selon les paramétrages (1:, 1:2, 20:, 1:2: 1:0 par exemple).

Ensuite un filtre vient placer les paquets marqués par iptables dans la classe limitée ; ainsi, tout les paquets concernant le FTP (e/issl, ipv4/6) se retrouvent dans cette classe et partagent le même débit.

Bref, fini les explications, voici les confs :

[root@Pyxis vsftpd]# ls conf*
conf_ipv4_essl.conf  conf_ipv4_issl.conf  conf_ipv6_essl.conf  conf_ipv6_issl.conf
[root@Pyxis vsftpd]# cat conf_ipv4_essl.conf
# Hey, Listen !
listen=YES
listen_ipv6=NO
implicit_ssl=NO
listen_port=21
#pasv_addr_resolve=no
pasv_address=78.232.184.204 #vela.lxdr.net
max_per_ip=4
max_clients=10
# Default
pam_service_name=vsftpd
userlist_enable=YES
tcp_wrappers=YES
#
anonymous_enable=YES
local_enable=YES
local_umask=022
dirmessage_enable=YES
connect_from_port_20=YES
# Changes
banner_file=/etc/vsftpd/banner.txt
setproctitle_enable=YES
write_enable=NO
xferlog_enable=YES
dual_log_enable=YES
pasv_min_port=9800
pasv_max_port=9850
# Share
secure_email_list_enable=YES
#email_password_file=/etc/vsftpd/email_passwords
anon_root=/media/2t/Medias/
#anon_max_rate=87040
# SSL
ssl_enable=YES
#debug_ssl=YES
require_ssl_reuse=NO
#ssl_request_cert=NO
ssl_ciphers=HIGH
rsa_cert_file=/etc/vsftpd/wildcard.13x.fr.crt
rsa_private_key_file=/etc/vsftpd/wildcard.13x.fr.pem
allow_anon_ssl=YES
force_anon_logins_ssl=YES
force_anon_data_ssl=YES
#force_local_logins_ssl=YES
#force_local_data_ssl=YES

Ensuite il suffit d'adapter pour chacune des instances :

[root@Pyxis vsftpd]# diff conf_ipv4*
4,5c4,5
< implicit_ssl=NO
< listen_port=21
---
> implicit_ssl=YES
> listen_port=990
[root@Pyxis vsftpd]# diff conf_ipv4_essl.conf conf_ipv6_essl.conf
2,3c2,3
< listen=YES
< listen_ipv6=NO
---
> listen=NO
> listen_ipv6=YES
6,7d5
< #pasv_addr_resolve=no
< pasv_address=78.232.184.204 #vela.lxdr.net

Avec une jolie banner :

[root@Pyxis vsftpd]# cat banner.txt
Hey, Listen !
\\
.........|''-,............................................,-''|
.........|:.:.\........................................./:.:|
.........'|:\:|:.\...................................../:\,/.|
..........'|:.'-,:.\................................./:.\/:.'/
...........\,,_\:.:\............................./-,:/,--:|...,-~~~~~~~~~-,
.............'\,_\,-:'\........................./:./',,---/'...| .Look! Listen! |
................''-,:\:.\.....,,--~~--,,...../:,-'_:.,-'.....'~-----,. . .,-----~'
....................''-,\.\,-'':.. . . . ..:''-/,-/,,--'''...........,,-'. . ,-'
....C201............'''',':.. . . . . . ..::','''............--''',,--~'''
.........................;:.. . . . . . . ..::;.__
...................,-~---',:. . . . . . ..::,''''.\:-,'''''/
...................'--,/,,'-''-,,:. . . ..:,,-'.¯'''''~~'
...............................¯'''''''''''''¯
//

Et la configuration réseau :

iptables -t mangle -A OUTPUT -p tcp --sport 20:21 -j MARK --set-mark 21
iptables -t mangle -A OUTPUT -p tcp --sport 990 -j MARK --set-mark 21
iptables -t mangle -A OUTPUT -p tcp --sport 9800:9850 -j MARK --set-mark 21

ip6tables -I INPUT 5 -p tcp --dport ftp -m state --state NEW -j ACCEPT
ip6tables -I INPUT 6 -p tcp --dport ftps -m state --state NEW -j ACCEPT
ip6tables -I INPUT 7 -p tcp --dport 9800:9850 -m state --state NEW -j ACCEPT
ip6tables -t mangle -A OUTPUT -p tcp --sport 20:21 -j MARK --set-mark 21
ip6tables -t mangle -A OUTPUT -p tcp --sport 990 -j MARK --set-mark 21
ip6tables -t mangle -A OUTPUT -p tcp --sport 9800:9850 -j MARK --set-mark 21
service iptables save
service ip6tables save

Les paquets sont marqués, il reste à les filtrer :

[root@Pyxis etc]# cat init.d/perso_ftp-throttling
#!/bin/sh

DEV=eth0
MAX=100mbit
FTP=90kbps

if [ $# -ne 1 ]; then
    echo "Usage: "$0" (start|stop|status|monitor)"
    exit 1
fi

case "$1" in
start)
  echo "TC start dev $DEV"
  # QDisc HTB principal, par défaut la sous classe 1 est utilisée
  tc qdisc add dev $DEV root handle 13:0 htb default 1

  # Ses classes, permettant de brider le débit
  tc class add dev $DEV parent 13:0 classid 13:1 htb rate $MAX
  tc class add dev $DEV parent 13:0 classid 13:2 htb rate $FTP

  # Et on conserve les prio en fonction du TOS
  tc qdisc add dev $DEV parent 13:1 handle 131 prio
  tc qdisc add dev $DEV parent 13:2 handle 132 prio

  # Les flux FTP marqués (21) sortants sont envoyés dans la classe 2 qui bride
  tc filter add dev $DEV parent 13: protocol ip handle 21 fw classid 13:2
  tc filter add dev $DEV parent 13: protocol ipv6 handle 21 fw classid 13:2

  # Marquage des flux, table mangle (utilisée pour l'alteration des paquets)
  #iptables -t mangle -A OUTPUT -p tcp --sport 20:21 -j MARK --set-mark 21
  #iptables -t mangle -A OUTPUT -p tcp --sport 990 -j MARK --set-mark 21
  #iptables -t mangle -A OUTPUT -p tcp --sport 9800:9850 -j MARK --set-mark 21
  #ip6tables -I INPUT 5 -p tcp --dport ftp -m state --state NEW -j ACCEPT
  #ip6tables -I INPUT 6 -p tcp --dport ftps -m state --state NEW -j ACCEPT
  #ip6tables -I INPUT 7 -p tcp --dport 9800:9850 -m state --state NEW -j ACCEPT
  #ip6tables -t mangle -A OUTPUT -p tcp --sport 20:21 -j MARK --set-mark 21
  #ip6tables -t mangle -A OUTPUT -p tcp --sport 990 -j MARK --set-mark 21
  #ip6tables -t mangle -A OUTPUT -p tcp --sport 9800:9850 -j MARK --set-mark 21

;;

status)
  echo -e "\\tTC status dev $DEV"
  echo
  tc qdisc show dev $DEV
  tc class show dev $DEV
  tc filter show dev $DEV
;;

monitor)
  CMD="
    echo -e \\\t\\\tTC dev $DEV;
    echo -e \\\tQDisk;
    tc -s qdisc show dev $DEV;
    echo;
    echo -e \\\tClass;
    tc -s class show dev $DEV
  "
  watch -n1 "$CMD"
;;

stop)
  echo "TC stop dev $DEV"
  tc qdisc del dev $DEV root
;;

*)
  echo "Usage: "$0" (start|stop|status|monitor)"
  exit 1
;;
esac

exit 0

[root@Pyxis etc]# cat rc.local
#!/bin/sh
#
# This script will be executed *after* all the other init scripts.
# You can put your own initialization stuff in here if you don't
# want to do the full Sys V style init stuff.

touch /var/lock/subsys/local

/etc/init.d/perso_ftp-throttling start

Voila !

Oh j'ai failli oublier, une anecdote et des liens utiles, plein :

VRRP, c'est bien mais pas que :
0-1024 -> 192.168.0.240 (ip virtuelle vrrp)
9000-9999 -> 192.168.0.9 (ip réelle)

Connexion au FTP, port 21 = utilisation de l'IP virtuelle pour arriver dessus

vsftpd, je lui dis pas quelle est mon IP externe, c'est le NAT de la box qui s'amuse a trafiquer ça dans les paquets pour que le mode passif fonctionne (Passive Mode (192,168,0,240,37,251) -> Passive Mode (78,232,184,204,37,251)) ; mais en SSL, la box ne peut plus toucher aux paquets et alors forcément ça foire en passif.

Donc je met pasv_address=78.232.184.204, comme ça vsftpd donne bien directement l'ip externe (la box n'a plus à toucher), le client se connecte port 21 (->0.240), demande a passer en passif (port 9xxx -> 0.9) et comme vsftpd s'attend a recevoir la connexion passive sur l'interface 0.240 (comme les commandes), mais que les ports 9xxx vont vers l'ip réelle 0.9, ben ça foire :)

Bref, maintenant tout fonctionne (et vivement que le NAT saute avec IPv6).

http://linux-ip.net/articles/Traffic-Control-HOWTO/
http://www.linuxembedded.fr/2011/06/utiliser-tc-pour-optimiser-lupload/
http://www.cyberciti.biz/faq/linux-traffic-shaping-ftp-server-port-21-22/
http://mirrors.bieringer.de/Linux+IPv6-HOWTO/x2523.html
http://download.pureftpd.org/pub/pure-ftpd/doc/FAQ * Global bandwidth limitation.

http://sys-log.bencane.com/2012/07/tc-adding-simulated-network-latency-to-your-linux-server/
http://www.linuxfoundation.org/collaborate/workgroups/networking/netem

http://lartc.org/howto/lartc.qdisc.filters.html
http://www.inetdoc.net/guides/lartc/

http://linux-ip.net/articles/Traffic-Control-HOWTO/classful-qdiscs.html
htb hfsc prio cbq
pfifo, bfifo, pfifo_fast, sfq, esfq, gred, tbf
drr, red

http://www.inetdoc.net/guides/lartc/lartc.cookbook.ultimate-tc.html
http://www.inetdoc.net/guides/lartc/lartc.qdisc.html
http://www.inetdoc.net/guides/lartc/lartc.qdisc.classful.html
http://www.inetdoc.net/guides/lartc/lartc.cookbook.icmp-ratelimit.html
http://www.inetdoc.net/guides/lartc/lartc.qdisc.filters.html
http://opalsoft.net/qos/DS.htm Linux Queuing Disciplines

http://linuxfr.org/wiki/Une-introduction-au-contrôle-du-trafic-réseau-avec-Linux
http://www.cyberciti.biz/faq/linux-traffic-shaping-ftp-server-port-21-22/
http://www.linuxembedded.fr/2011/06/utiliser-tc-pour-optimiser-lupload/

http://linuxmanpages.net/manpages/fedora14/man8/tc.8.html
http://linuxmanpages.net/manpages/fedora14/man8/tc-prio.8.html

http://mirrors.bieringer.de/Linux+IPv6-HOWTO/x2523.html
http://linuxfr.org/wiki/pages?page=6
http://linuxfr.org/wiki/Exemple-de-script-pour-de-la-QoS
http://wiki.openwrt.org/doc/howto/packet.scheduler/packet.scheduler

Statistiques sur les SMS Android

Il y a quelques jours, je me suis "amusé" à faire des statistiques sur la fréquence des échanges par sms avec une personne, voici donc comment je m'y suis pris.

En premier, il faut localiser la base contenant les SMS : il s'agit d'une base unique à toutes les applications, en cherchant un peu on a trouve à cet emplacement :

/data/data/com.android.providers.telephony/databases/mmssms.db

Maintenant, 2 choix : travailler directement dessus ou sur une copie. J'avais d'abord pensé récupérer la base mmssms.db pour la lire avec un logiciel tel que  ou , mais la version utilisée par Android semble plus récente et ils n'ont pas réussis à ouvrir la base, j'ai donc fait un dump en utilisant sqlite3 du téléphone (.dump), puis j'ai importé ce dump dans une nouvelle base pour utiliser ces résultats plus facilement.

On peut lire la base, c'est ensuite assez simple, une requête pour connaitre le nombre de sms reçu et une autre pour le nombre de sms émis par jour :

select date(date/1000,'unixepoch'), count(*) from sms where address = "<TEL>" and person is not null group by date(date/1000,'unixepoch') order by _id asc;

select date(date/1000,'unixepoch'), count(*) from sms where address = "<TEL>" and person is null group by date(date/1000,'unixepoch') order by _id asc;

Explications :

• on selectionne la date et le nombre d'enregistrements concernés par ce groupement, depuis la table sms
• on selectionne l'interlocuteur (address) et : person est null pour les sms envoyés, c'est un nombre sinon
• la date est au format timestamp unix ("unixepoch"), mais en millisecondes, il faut les retirer pour les traiter avec les fonctions SQLite (/1000)
• on groupe les résultat par date identique (group by)

Le résultat nous donne le nombre de sms jour par jour, il suffit ensuite d'importer ces colonnes dans un excel (en bataillant un peu avec le type des données dans les dernières versions), de faire un petit graphe et voila :).