Programmation
Wednesday, 27 November 2013
|
Écrit par
Grégory Soutadé

Logo Wireshark

Wireshark (previously Ethereal) is the best open source protocol dissector/analyzer. You can analyze an incredible amount of protocols, not only Internet ones, but every stream based protocols. Moreover you can add your own filters/dissectors written either in C or in Lua. Nevertheless, the documentation on the net concerning Lua dissectors is light and sparse. It's been hard for me to make something that works even if it's, at the end, not really complicated. I'll try to explain the basis of Lua dissectors.

1) Installation

You need to have a wireshark that supports Lua support (wireshark -v). After that, create or edit ~/.wireshark/init.lua. To load a new plugin, just type

dofile("mydissector.lua")

Create the new file ~/.wireshark/mydissector.lua

2) Post Dissector

There are three types of dissectors :

  • Dissector : you add your own protocol
  • Chained dissector : you add new fields to an existing protocol
  • Post dissector : you interact after all packets has been parsed

An example for each of one can be found here. I'll describe a post dissector, but other types of dissectors has pretty the same format.

Tip 1
If you want to display someting on the console, just do

print(something)


Tip 2
If the base array is not defined, add this to ~/.wireshark/init.lua

-- Display Bases base = { ["NONE"] = 0, ["DEC"] = 1, ["HEX"] = 2, ["OCT"] = 3, ["DEC_HEX"] = 4, ["HEX_DEC"] = 5, }

First, you need to define your protocol : Proto(<internal name>, <displayed name>)

p_dummyproto = Proto("dummyproto","DummyProto")


Then, define your fields : ProtoField.TYPE(<internal name>, <displayed name>, [base], [values], [mask])
TYPE are defined here

-- Simple field without value local f_X = ProtoField.uint16("dummyproto.f_X","Field X") -- Simple field displayed in hex format local f_Y = ProtoField.uint8("dummyproto.f_Y","Field Y", base.HEX) -- Field with precomputed values and bitfield local VALS_ZZ = {[0] = "Single", [1] = "Dual"} local f_Z = ProtoField.uint8("dummyproto.f_Z","Field Z", base.HEX, VALS_ZZ, 0x3)

Third step is to register each field

p_dummyproto.fields = {f_X, f_Y, f_Z}


After that, the big part : protocol dissection. Fields are organized as a tree. You have to parse each byte (or range of bytes) in the given buffer and append your fields. Be careful : objects returned by :add function has userdata type and cannot be directly manipulated.

function p_dummyproto.dissector(buffer,pinfo,tree) -- Access to another field local f_udp_port = Field.new("udp.port") -- If it exists and has the right value if f_udp_port and tostring(f_udp_port) == tostring(5555) then -- Add our protocol dissection with data in buffer[17, 17+14] local subtree = tree:add(p_dummyproto, buffer(17,14)) -- Add a subtree to our root for the first two bytes local t = subtree:add(f_X, buffer(17, 2)) -- Add a sub subtree local t2 = t:add(f_Y, buffer(17, 1)) -- Parse sub data parse_data(t, buffer, 18) end end function parse_data(tree, buffer, start) -- Wireshark integrate bitop from luajit http://bitop.luajit.org/ field_1 = buffer(start, 1):uint() field_1 = bit.band(field_1, 0x3) -- You can also append free text information to current field if field_1 < 16 then tree:append_text(" field information") end end

Finally register your post dissector

register_postdissector(p_dummyproto)


A complete example can be found here. It's a full reimplementation of ARP protocol dissector in Lua.

Friday, 18 October 2013
|
Écrit par
Grégory Soutadé

Logo gPass

Depuis le début de l'informatique, la façon la plus courante d'accéder à une ressource (compte) est d'utiliser le couple nom d'utilisateur/mot de passe. Pour l'anecdote, Richard Stallman ne mettait (volontairement) pas de mot de passe à son compte UNIX. Pour chaque service, il faut donc rentrer ce couple afin d'être authentifié. Le problème, c'est qu'il y a de plus en plus de services que nous utilisons quotidiennement. Il faut donc inlassablement répéter toujours les mêmes actions même si, la plupart du temps, on se facilite la tâche avec une connexion automatique gérée par le navigateur.

Pour tous ces services il faudrait, en théorie, avoir un mot de passe fort (compliqué) et différent. Mais en tant que bon fainéants, on utilise juste un sous ensemble récurrent. Problème : si le mot de passe est trop simple et/ou que le site se fait voler sa base de données, un hacker pourra (après déchiffrage) se connecter sur tous vos comptes.

Afin de répondre à cette problématique, j'ai développé gPass (global Password). Il s'agit d'un serveur de mot de passe. Quand on veut se connecter à un service, il faudra rentrer une clé maître qui va permettre de récupérer le mot de passe associé au couple site/nom d'utilisateur. Mot de passe qui sera évidemment complexe (il y a un générateur intégré) et unique par service (du moins ceux que l'on aura configurés). Concernant la sécurité, la base de données ne contient que des valeurs chiffrées (AES 256). Chiffrement qui s'effectue sur le client (sauf lors de l'insertion dans la base). la clé de chiffrement est une dérivation (PKBDF2) de la clé maître. De plus, les mots de passes sont salés. Donc, si on a une clé maître forte, il est quasiment impossible de déchiffrer la base.

En fait, il s'agit d'un concurrent plus ou moins proche de lastPass. Ses avantages sont qu'il est open source (c'est l'origine du projet), auto hébergable, que l'on peut gérer plusieurs comptes, avoir plusieurs clés maître. L'inconvénient c'est qu'il n'y a qu'un seul plugin disponible pour firefox. Pour ceux qui connaissent, on peut rapprocher cette solution d'un SSO (Single Sign On) pour les sites qui ne le proposent pas. C'est à dire que l'on s'authentifie une seule fois via un service unique pour accéder à un panel d'autres services.

Fonctionnement gPass


Lors de l'hébergement d'un serveur, il est important de garantir la disponibilité de ce dernier (s'il n'y a plus de connexion, plus de mot de passe...). Néanmoins, si on n'a pas le plugin installé (changement de PC), on peut toujours aller consulter les mots de passe directement en ligne. Attention cependant à ne pas perdre la base de données ou la clé maître, il serait impossible de retrouver la valeur des mots de passe (sauf système de récupération propre à chaque service) !

Un serveur de démonstration est disponible ici (c'est celui configuré par défaut par le plugin), vous noterez les couleurs chatoyantes utilisées (j'ai participé au design d'iOS7). Le client (extension firefox) est disponible ici. Le code source est . Il s'agit de la version 0.1, donc il est possible qu'elle ne fonctionne pas pour tous les sites et/ou qu'il y ait des évolutions à l'avenir.

Thursday, 19 September 2013
|
Écrit par
Grégory Soutadé

Nokia 7373

After 6 years of wonderful services I decided to change my superb Nokia 7373 by a Nexus 4 (thanks to the last price down). Welcome to the 21th century with a big smartphone running Android. One problem : how to transfer my contacts from Nokia to Android ? After reading some articles on the net I didn't find any simple solution. So I developped a perl script that will convert contacts extracted from Nokia Suite to vCad format (.vcf). The procedure is bellow :

  • Extract your contacts with Nokia Suite into a CSV file
  • Run this script (you can see help with -h switch)
  • Copy vcf files to your phone (you can copy them in DCIM directory if you have a Nexus 4, it works)
  • Go to "contact" application and import all vcf files

Now you can use your mobile phone as before. Personally I deactivated contact synchronisation because I do not want to give phone numbers of my friends to Google (even if I suppose it already has). *Beware* this script has been developped for French people : default call prefix is +33 (you can change it) and a cell phone numbers starts with 6 in France (you can change it). If you're in another country you may have to tweak it. Currently it can extract first name, last name, phone numbers and email. Have fun !

Nexus 4

Friday, 06 September 2013
|
Écrit par
Grégory Soutadé

Au boulot, je suis souvent amené à lire du binaire. Sous GNU/Linux, il y a l'utilitaire hexdump. S'il est très pratique, je ne supporte pas le formatage par défaut (8 colonnes, 2 octets par colonne, big endian), lui préférant celui d'EMACS (qui est bien plus naturel). En cherchant ici et là, j'ai trouvé comment avoir un résultat un peu plus sympa :

Simple formatage 16 colonnes, 1 octet par colonne

hexdump -v -e '16/1 "%02x " "\n"' test
cd 7d 3a 34 2f 9c b7 17 b2 46 0f 13 96 dc 29 2c
a7 38 15 c1 40 74 07 1d 34 c8 a2 c6 01 e8 ff e1
0c 52 72 66 4c 6d 55 9a 13 9a 3c fb 09 cc f8 5e

Simple formatage 16 colonnes, 2 octets par colonne (affichage big endian)

hexdump -v -e '16/2 "%04x " "\n"' test
7dcd 343a 9c2f 17b7 46b2 130f dc96 2c29 38a7 c115 7440 1d07 c834 c6a2 e801 e1ff
520c 6672 6d4c 9a55 9a13 fb3c cc09 5ef8 c8b5 f747 c076 3a64 4363 ba02 3cc3 b899
2fdd 0c04 15f0 26fc 4840 de08 5682 0795 f938 dfbd 97e0 6219 4dc1 bd11 a217 48a2

Simple formatage 16 colonnes, 4 octets par colonne (affichage big endian)

hexdump -v -e '8/4 "%08x " "\n"' test
343a7dcd 17b79c2f 130f46b2 2c29dc96 c11538a7 1d077440 c6a2c834 e1ffe801
6672520c 9a556d4c fb3c9a13 5ef8cc09 f747c8b5 3a64c076 ba024363 b8993cc3
0c042fdd 26fc15f0 de084840 07955682 dfbdf938 621997e0 bd114dc1 48a2a217
0b2a4ba6 92e126e3 41b390bb c6715665 513d27ce ac133bf9 c4110439 2617d3eb
6be79814 3c87391d 950461d9 e4fc7027 dcd0bf46 0d690fdc eb5b68d7 3d5d0bee
8d78785d 97e315ee f801f1ac b1d8247a 02bd5328 91acb913 0f6b4024 8eadb09d

Avec l'affichage des adresses

hexdump -v -e '"%08_ax " ' -e '16/1 "%02x " "\n"' test
00000000    cd 7d 3a 34 2f 9c b7 17 b2 46 0f 13 96 dc 29 2c
00000010    a7 38 15 c1 40 74 07 1d 34 c8 a2 c6 01 e8 ff e1
00000020    0c 52 72 66 4c 6d 55 9a 13 9a 3c fb 09 cc f8 5e
00000030    b5 c8 47 f7 76 c0 64 3a 63 43 02 ba c3 3c 99 b8

Affichage par octet sans retour à la ligne

hexdump -v -e '/1 "%02x "' test
cd 7d 3a 34 2f 9c b7 17 b2 46 0f 13 96 dc 29 2c a7 38 15 c1 40 74 07

Avec l'affichage des caractères

head -n 3 gpl-3.0.txt| hexdump -e '8/1 "%02X " "\t\t"' -e '8/1 "%c" "\n"'
20 20 20 20 20 20 20 20                
*
20 20 20 20 47 4E 55 20            GNU
47 45 4E 45 52 41 4C 20        GENERAL
50 55 42 4C 49 43 20 4C        PUBLIC L
49 43 45 4E 53 45 0A 20        ICENSE

Variante (sans les étoiles)

head -n 3 gpl-3.0.txt| hexdump -v -e '8/1 "%02X " "\t\t"' -e '8/1 "%c" "\n"'
20 20 20 20 20 20 20 20                
20 20 20 20 20 20 20 20               
20 20 20 20 47 4E 55 20            GNU
47 45 4E 45 52 41 4C 20        GENERAL
50 55 42 4C 49 43 20 4C        PUBLIC L
49 43 45 4E 53 45 0A 20        ICENSE

On peut ainsi combiner les formatages à l'infini pour avoir le résultat souhaité !

Wednesday, 12 June 2013
|
Écrit par
Grégory Soutadé

Fenêtre principale de KissCount

Sortie annuelle de KissCount. Pour ceux qui ne s'en souviennent pas, il s'agit d'un logiciel de comptabilité personnelle dont l'objectif est d'être le plus simple possible : je l'ouvre, je rentre les données (dans une seule fenêtre), je le ferme. Des versions (.deb) pour i386 et amd64 ainsi que pour Windows sont disponibles. Cette version marque une certaine maturité du projet. En effet, les changements sont assez peu nombreux :

  • Ré écriture du composant principal (grille)
  • Export au format CSV
  • Icônes basse résolution
  • Affichage des statistiques dans la recherche
  • Quelques bugs en moins


Quid de la suite ? Probablement une migration vers Qt5. Pour le moment il n'y a pas de nouvelles fonctionnalités de prévu.