dimanche 19 mai 2013

fun_plug sur clé USB pour D-Link DNS-320LW

Comme moi, vous avez peut-être profité de l'offre de TopAchat proposant un NAS D-Link DNS-320LW + 2x2To (soit 4To) à 200€ (soit le prix des 2 disque sur, en fait).
De base, le NAS propose déjà pas mal de fonctions (FTPS, SMB, NFS, DLNA, des droits suffisamment fin, JBOD, interface de téléchargement, et j'en passe pas mal), mais il est possible (merci à D-Link pour cela) d'augmenter encore ses capacités !

Une petite information au passage, parce que j'ai cherché moi aussi : matériellement, la version 320L (et W pour white of course) est très proche du 320, mais possède le double de mémoire (256Mo) et un processeur de 1Ghz (contre 800MHz). Le firmware semble être vraiment différent cependant, peut-être pas au niveau de l'interface, mais le 320 en est à la 2 alors que le 320L à la 1.

Revenons à ce qui nous intéresse : fun_plug (ffp). Grâce à D-Link, il est possible d’exécuter un script au démarrage du NAS, parce que si un fichier fun_plug est présent sur le volume 1, il est appelé à la fin du démarrage, justement pour tolérer ce fonctionnement. Des gens ont donc compilé des binaires fonctionnants sur le NAS et on peut retrouver un vrai petit environnement Linux.

Dans le fonctionnement de base, un place fun_plug et une archive fun_plug.tgz à la racine du volume 1, au 1er boot celle-ci est décompressé puis supprimé et offre un accès telnet, ce fut ma 1ère tentative (en passant par l'interface web d'envoi de fichier, qui own les fichier en root:root et mode en 777). Bien, on retrouve un accès root, un shell, c'est gagné.

Mais au reboot, le 320L devient chiant car un effectue un chmod 777 -R sur tout les volumes, nos fichiers (ah oui au fait, en interne c'est de l'ext4) perdent donc leurs modes et par exemple :
  • tout les scripts de /ffp/start/ (le init.d de ffp) sont +x, les services se retrouvent tous lancés au 2ème reboot
  • les fichiers clés d'sshd sont aussi en 777, accès libre pour tous, et comme sshd n'aime pas cela, il refuse de se lancer, plus de ssh, ou renvoi des erreurs dans les logs.
Autre petit souci, les scripts/binaires étant situés sur les disque dur, cela oblige ces derniers à être relancés régulièrement, on perd une partie du coté "éco". Il est possible de placer fun_plug sur une clé USB, et c'est ce que je vais expliquer (du moins, à ma façon). Arrivé ici, j'ai déjà un fun_plug installé sur le disque dur, rebooté seulement pour son installation (avant le 2ème reboot qui chmod tout), avec juste le telnet. Sur le 320L, la clé USB est monté sur /mnt/USB/USB_c1 (il faut adapter).

Formater la clé USB

umount /dev/sdxx
fdisk /dev/sdx
d
c
p
1
w
mkfs.ext4 -O ^has_journal -E stride=2,stripe-width=1024 -b 4096 /dev/sdxx
En me fiant à http://blogofterje.wordpress.com/2012/01/14/optimizing-fs-on-sd-card/ pour les options de formattage car ma clé USB est en fait un lecteur de carte, mais je pense que ça s'applique de la même façon à une "vrai" clé USB.

Installer fun_plug dessus

cd /mnt/USB/USB1_c1
wget http://ffp.inreto.de/ffp/0.7/arm/fun_plug.tgz
tar xzf fun_plug.tgz -C ffp/
/ffp/bin/tar xzf fun_plug.tgz -C ffp/

Utiliser un fun_plug compatible USB

J'ai utilisé ce fun_plug (venant d'ici) qui est une variante de l'original a peine modifié (je préfère) pour fonctionner en USB lorsque c'est possible. Le fichier fun_plug lui reste sur le volume 1 (c'est ici que le firmware le cherchera), mais tout le dossier /ffp/ sera situé sur la clé USB. Celle-ci se trouve d'ailleurs dans /mnt/USB/USB_c1/ et non HD_c1, il faut donc modifier le fichier fun_plug : 
sed -ie 's#USB/HD_c1#USB/USB1_c1#g' /mnt/HD/HD_a2/fun_plug
Je l'ai aussi modifié pour qu'il remonte la clé USB en noatime et nodiratime (qui feraient trop d'accès sur la clé) et sauve une copie du dmesg au boot, au final on obtient ceci : 

#!/bin/sh

# switch to safe working directory on ramdisk
cd /

# fichier de trace
exec >>/mnt/HD/HD_a2/ffp.log 2>&1

# Bootlog
dmesg > /var/log/boot.log

# Activation de autoboot USB (O ou N)
AUTOBOOT_USB=O
# Emplacement du repertoire FFP
FFP_USB_DRIVE=/mnt/USB/USB1_c1
FFP_PATH_USB=$FFP_USB_DRIVE/ffp
FFP_PATH=/mnt/HD/HD_a2/ffp

# Si on utilise ffp sur USB et qu'elle est présente, on change les options de montage
if [ "$AUTOBOOT_USB" = "O" ] && [ -d $FFP_PATH_USB ]; then
  FFP_PATH=$FFP_PATH_USB
  mount -o remount,noatime,nodiratime $FFP_USB_DRIVE
fi

# where to search for the install tarball
FFP_TARBALL=/mnt/HD/HD_a2/fun_plug.tgz

# rc file path
FFP_RC=/ffp/etc/rc

echo "**** fun_plug script for DNS-320/325  ****"
echo "Demarrage sur $FFP_PATH"
date

# create /ffp link
echo "ln -snf $FFP_PATH /ffp"
ln -snf $FFP_PATH /ffp

# install tarball
if [ -r $FFP_TARBALL ]; then
    echo "* Installing $FFP_TARBALL ..."
    mkdir -p $FFP_PATH && tar xzf $FFP_TARBALL -C $FFP_PATH && /ffp/bin/tar xzf $FFP_TARBALL -C $FFP_PATH
    if [ $? -eq 0 ]; then
        echo "* OK"
    fi
    rm $FFP_TARBALL
fi

# suid busybox
if [ -x /ffp/bin/busybox ]; then
    chown root.root /ffp/bin/busybox
    chmod 0755 /ffp/bin/busybox
    chmod u+s /ffp/bin/busybox
fi

# run fun_plug.init, if present
if [ -x /ffp/etc/fun_plug.init ]; then
    echo "* Running /ffp/etc/fun_plug.init ..."
    /ffp/etc/fun_plug.init
fi

# run fun_plug.local, if present
if [ -x /ffp/etc/fun_plug.local ]; then
    echo "* Running /ffp/etc/fun_plug.local ..."
    /ffp/etc/fun_plug.local
fi

# run commands
if [ -x $FFP_RC ]; then
    echo "* Running $FFP_RC ..."
    $FFP_RC
    echo "*  OK"
else
    echo "$FFP_RC: Not found or not executable"
fi

Empêcher le chmod 777

Comme je disais, le NAS effectue un bon gros chmod 777 sur tout les volumes, cela inclut la clé USB, il faut modifier un peu le système pour l'empêcher d'effectuer ceci au moins sur la clé USB, on commence par créer le fichier qui remplace chmod : 
cd /usr/local/config/
vi chmod_usb.sh

#!/bin/sh

# log everything to a file
exec >>/usr/local/config/chmod.log 2>&1

args="$@"
NOW=$(date +"%Y-%m-%d %T")
HD=USB1_c1

#these are the chmod args we want to suppress
suppress_args="777 -R /mnt/USB/$HD"

if [ "$args" != "$suppress_args" ]; then
    echo "[$NOW] Executing chmod $args"
    /bin/busybox chmod $@
else
   echo "[$NOW] Suppressing chmod $args"
fi
Suivi d'un chmod 777 chmod_usb.sh

Puis on effectuera le "remplacement" à chaque démarrage grâce au rc.init.sh (on conserve une copie du init.rc) :

cd /usr/local/config/
cp -pf rc.init.sh rc.init.sh.orig
echo "# USB chmod Patch" >>rc.init.sh
echo "[ -x /usr/local/config/chmod_usb.sh ] && ln -nfs /usr/local/config/chmod_usb.sh /bin/chmod">>rc.init.sh

On peut effectuer le ln -nfs /usr/local/config/chmod_usb.sh /bin/chmod et s'assurer que la commande chmod fonctionne toujours.

Supprimer fun_plug du disque dur

Dans mon cas, je ne veux pas que fun_plug puisse fonctionner sur le disque dur, seulement la clé USB, la solution est donc simple et à effectuer avant le redémarrage qui lancera fun_plug depuis la clé USB : 
rm -rf /mnt/HD/HD_a2/ffp/

On peut redémarrer le NAS, on devrait retrouver l'accès telnet au bout de 2-3 minutes mais cette fois avec un fun_plug contenu dans la clé USB !

Personnaliser SSH

Un des avantages de fun_plug est d'avoit un accès SSH au NAS, il y a cependant quelques modifications à effectuer (maintenant et pas avant car on modifie des fichiers de la clé) ; pour ma part j'utilise une clé privé pour me connecter en SSH, je laisse donc le mot de passe root intouché (ie. vide), mais ce n'est pas gênant.

mkdir -p /ffp/home/root/.ssh
chmod og-w -R /ffp/home/root/.ssh
vi authorized_keys
cd /usr/local/config
sed -ie 's#:/home/root:#:/ffp/home/root:#g' passwd
sed -ie 's#root:/bin/sh#root:/ffp/bin/sh#g' passwd
cd /etc
cd /usr/local/config
sed -ie 's#:/home/root:#:/ffp/home/root:#g' passwd
sed -ie 's#root:/bin/sh#root:/ffp/bin/sh#g' passwd
pwconv

On défini la/les clés ssh autorisés pour le compte root, puis on modifie le HOME (c'est ici que sshd cherchera les clés) et le shell (pour un beau bash) de root dans le dossier permanent (/usr/local/config qui est dans la flash du NAS) et dans le dossier chargé actuellement (pour éviter un reboot), on assure la prise en compte avec un pwconv.

Ah, il faut aussi changer un petit test dans /ffp/start/sshd.sh car il y a une référence à /etc/ssh et non /ffp/etc/ssh.

Enfin j'assure la sécurité en modifiant /ffp/etc/ssh/sshd_config

PermitRootLogin yes
PermitEmptyPasswords no
# Perso
AllowUsers root Alex

Root peut se connecter, pas de mot de passe vide possible (ça tombe bien, celui de root est vide, on ne pourra donc utiliser que la clé privé). Enfin seul root et Alex peuvent faire du SSH (si un utilisateur à un mot de passe faible, il pourrait offrir un accès SSH, on limite donc).

Enfin on peut lancer SSH : 

chmod +x /ffp/start/sshd.sh
/ffp/start/sshd.sh start

On peut de nouveau redémarrer le NAS, on attend 2-3 minutes puis on s'assure de l'accès SSH. Si c'est ok, on peut couper telnet : 

/ffp/start/telnetd.sh stop
chmod -x /ffp/start/telnetd.sh

Et voila !
Je n'ai pour l'instant pas été beaucoup plus moins, mais j'ai déjà un accès ssh root, tout est donc possible à partir de maintenant :)
Oh, et le NAS est parfaitement compatible IPv6 (l'interface web aussi !).

Quelques liens



jeudi 9 mai 2013

Mises à jour Windows Defender automatiques sous Windows 8

Je n'utilise pas le paramètre recommandé "Installer les mises à jour automatiquement" pour Windows Update, principalement parce que celui-ci génère un message invitant à redémarrer le PC lorsque des mises à jour le demandent.
C'est donc "Télécharger les mises à jour mais me laisser choisir s'il convient de les installer" que j'utilise. Un des effets de ce paramètre est que les mises à jour Windows Defender, proposant chaque jour un nouveau fichier de définitions, ne sont pas non plus installées et je suis donc invité chaque jour à les installer ... Enfin j'étais.


Le problème était le même sous Windows 7 et j'avais trouvé le "truc", et visiblement sous Windows 8 certaines personnes cherchent aussi comment faire :

Ma solution ne permet pas d'avoir les mises à jour "manuelles" mais seulement d'avoir les mises à jour majeures en manuel (celles qui demandent un redémarrage), les mineures comme les définitions de Defender seront automatiques.

Cela consiste donc à : 
  • mettre le paramètre sur "Télécharger les mises à jour mais me laisser choisir s'il convient de les installer" pour toutes les autres
  • et pour les mineures, ajouter une clé dans le registre dans :
    HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU
    créez une valeur DWORD "AutoInstallMinorUpdates" avec la valeur 1
    (Doc WSUS : http://technet.microsoft.com/en-us/library/dd939844(v=ws.10).aspx)
Cette clé autorise donc l'installation automatique des mise à jour ne nécessitant pas de redémarrage.
On retrouve aussi ce paramètre dans gpedit.msc (Windows Components/Windows Update).

Mises à jour automatiques : oui, mais sans être dérangé (cette option devrait être disponible tiens).

Migrer ses jeux Steam lors d'une réinstallation

Besoin de réinstaller ou changer de PC, mais pas envie de re-télécharger 150Go de jeux Steam ?
C'est possible, et sans utiliser la fonction d'exportation des jeux (qui plante en plus) :).


Les étapes :
  • Faire une copie du dossier SteamApps qui se trouve dans le dossier de Steam (C:\Program Files (x86)\Steam par exemple) vers la nouvelle destination (lecteur, mais pas le dossier final)
  • Supprimer les fichiers appmanifest_<id-jeu>.acf qui s'y trouvent : il est possible de les conserver, mais alors Steam n’exécutera pas les actions effectuées au 1er lancement et qui peuvent être nécessaires (installation d'OpenAL, création de clés dans le registre, définition de l'emplacement des executables, ...)
  • Réinstaller Steam (SteamInstall.msi demande la langue à utiliser) à l'emplacement voulu (qui peut-être dans Program Files, mais aussi sur une autre partition)
  • Le lancer, attendre les mises à jour du client, le fermer complètement
  • Remettre le dossier SteamApps en place dans le nouveau dossier d'installation de Steam
    Note : depuis une mise à jour, il est possible pour certains jeux (les non-steam principalement) de les installer à un autre emplacement, il suffit alors d'indiquer dans les préférences cet emplacement pour ces jeux.
  • Relancer Steam, attendre plusieurs minutes pour les jeux qu'il détecte tout seul, pour les autres il suffit de lancer la demande d'installation, il va alors découvrir les fichiers déjà présents sur le disque et les valider ; normalement il ne lui reste quasiment rien à télécharger
  • Voilà, les jeux sont de nouveaux disponibles en quelques heures et non en quelques jours de téléchargement :)

vendredi 7 décembre 2012

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)

lundi 19 novembre 2012

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 :)

dimanche 14 octobre 2012

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


    mercredi 8 février 2012

    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 :).