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

Lecteur de SmartCards : KorriGo, Navigo, Carte Vitale, CB, ...

Il y a quelques jours, j'ai acheté un lecteur de Smartcards KorriGo, en partie car il permet de recharger sa carte en ligne, mais aussi par curiosité. Il s'agit d'un lecteur Teo by RIXING, vendu 8€ (soit le prix proposé par le constructeur). La RATP propose (ou proposait) aussi un lecteur au même prix.

Pour le fonctionnement de ces smartcards (carte Navigo/KorriGo, carte sim, carte de décodeur, carte vitale, carte bleu, ...), je vous renvoi vers l'article Wikipédia en question et ce "How-To".

Après quelques recherches (et des tentatives avec des packages "muscle"), j'ai finalement trouvé le logiciel CardPeek (utilisé sous Ubuntu; il faut probablement rajouter le paquet pcscd pour qu'il fonctionne), qui permet de lire et d'interpréter une partie du contenu des cartes monétaires, cartes Monéo, cartes vitales et cartes de type Calypso, telles que Navigo et KorriGo. Pas forcément très utile, mais ça a satisfait ma curiosité :).

Informations contenues dans les cartes type Calypso

A titre d'information, voici donc les différents contenus qu'on peut retrouver dans les cartes (du moins, ceux que CardPeek sait interpréter) :

• KorriGo : id de la carte, information sur l'abonnement (création [agent, date, appareil], zone, dates), des listes de contrats (abonnements ?), des listes d'évènements spéciaux (?), les 6 derniers "compostages" (horodatage, type [entrée train], fournisseur [SNCF], lieu, contrat utilisé, id réseau), informations a propos de la carte (id réseau [France], date de validité, date de naissance du détenteur, et probablement aussi nom/prénom [non parsé par CardPeek]).
• Navigo : id de la carte, information sur l'abonnement (création [agent, date, appareil], zone, dates),  les 3 derniers "compostages" (horodatage, type [entrée metro], fournisseur [RATP], lieu, appareil, route, contrat utilisé), informations a propos de la carte (id réseau [France], date de validité, et probablement aussi nom/prénom.
• Carte Vitale : nom, prénom, date de naissance, numéro de sécurité sociale, photo (supposé, chiffrée), nationalité, date de validité, et probablement d'autres infos non parsées.
• Carte bleu (EMV) : un historique assez important des dernières transactions (35, avec montant, pays, devise, date), langue préférée, pays, la liste des usages (CB, Visa, Moneo), date de création/expiration, numéro de la carte, nom/prénom (ou initiale)/genre du détenteur, le nombre d'essais restant;
• Carte Moneo : pour le moment, des données brutes.

J'ai aussi découvert que certains pays comme la Belgique semblent utiliser ce type de carte comme carte d'identité, ça semble plutôt sympa (et ça doit ouvrir des possibilités sur les services en ligne). Après il y a les histoires de vie privée, notamment car certaines de ces cartes peuvent communiquer sans contact (apparenté, différences).
Bref.

Pour finir, quelques liens divers que je n'ai pas pu caser dans l'article (utilisation pour authentification ?) :
http://forums.gentoo.org/viewtopic-t-361844-start-0.html
http://www.openscdp.org/scripts/musclecard/index.html

Nb : tout les liens de cet articles sont uniques ;)

Connexion pair-à-pair "Réseau non identifié" dans Windows 7

Il semble que Windows 7 supporte assez mal les réseaux pair-à-pair (ie. relier 2 PC directement via un câble) : le type de réseau n'est pas détecté ("Réseau non identifié"), il prend donc sa valeur par défaut c'est-à-dire Public ... et ce n'est pas modifiable !
Il en résulte que le partage de fichier ou même la réponse au ping sont désactivés sur cette interface réseau.

Petites astuces pour Blogger

Blogger n'est pas parfait, mais quand on ne dispose pas d'un hébergement correct (@home) ou qui ne permet pas d'utiliser un sous domaine sans devoir importer tout le domaine (1&1 ..), qu'on veut utiliser son domaine perso et qu'on veut avoir des articles dédiés a plus d'un élément (Tumblr&co), il peut faire l'affaire.

Les thèmes maintenant proposés par défaut ne sont pas trop moches, on peut se servir d'un template comme base pour arriver a un résultat correct, mais il reste toujours la navbar et dans le cas d'un blog un minimum technique, il faut une coloration syntaxique.

Ubuntu 10.10 (Maverick), Samba 3.5.4 et Windows 7

Ubuntu permet grâce à Samba d'accéder aux fichiers partagés sur un poste Windows, seulement si on rajoute Windows Live Sign-in Assistant a Windows 7, Samba ne gère alors plus correctement la négociation de la sécurité et n'arrive pas à s'authentifier et accéder aux fichiers alors qu'ils sont publiques. Plus d'informations ici.

Ce bug a été corrigé dans la version 3.5.6 de Samba (le code a été corrigé avant la 3.5.5, mais il semble qu'elle ne soit qu'une release de sécurité), cependant elle n'est pas encore proposée pour Ubuntu 10.10 (ni même la 3.5.5 apparemment), voici donc un petit workaround pour ceux qui souhaitent à la fois conserver cet assistant (ou qui ne peuvent le retirer, du moins pas simplement, comme dans Windows Live 2011) et accéder a leurs fichiers.

On peut trouver une version compilée de Samba 3.5.6 ici et c'est donc ce que j'ai utilisé (j'imagine que pour la version 64bits ce lien fonctionnera de la même façon).
Les fichiers à récupérer pour la fonction client sont :

libsmbclient_3.5.6~dfsg-1ubuntu1_i386.deb
libwbclient0_3.5.6~dfsg-1ubuntu1_i386.deb
winbind_3.5.6~dfsg-1ubuntu1_i386.deb
samba-common_3.5.6~dfsg-1ubuntu1_all.deb
samba-common-bin_3.5.6~dfsg-1ubuntu1_i386.deb
smbclient_3.5.6~dfsg-1ubuntu1_i386.deb

et pour pouvoir servir de serveur (non installé par défaut), il faut rajouter

samba_3.5.6~dfsg-1ubuntu1_i386.deb

Puis on installe tout cela avec

dpkg -i <paquet>

qui bronchera un peu moins à propos de dépendances cassées (temporairement), en commençant par les libs et winbind qui seront requises par les autres paquets. L'ordre des fichiers donné plus haut devrait être bon.
Un redémarrage est peut-être nécessaire.
On peut peut-être faire ça un peu plus proprement, mais je ne connais pas assez le système de paquet Ubuntu pour ça.

Et voilà, vous vous retrouvez normalement avec la version 3.5.6 de Samba, qui ne pose plus de problèmes avec Windows 7 et son assistant :).