As you may know, my work consists in developing software for embedded devices. We usually says that an embedded device is a peace of hardware with low resources (memory, CPU, flash...) taking in example phones. Nowaday, smartphones have only core software that is really embedded, the rest is sometimes more powerful than the computer I wrote this post. But, don't care, I don't work in telephony. Here (at Neotion), we do really embedded software, with chipsets clocked from 100Mhz to 200Mhz, with available RAM from 1MB to 32MB, and flash up to 8MB.

After years of developments, we can have one or more software that became too big to fit in its allocated flash partition. So, to find the guilty functions, I wrote a simple PERL script (~130 lines) that will count number of instructions for each function from objdump's output (with -ld switch) and displays statistics per function and per file (it doesn't focus on .data or .bss section). To correctly use the script, you have to compile your program with -ggdb option (to have line numbers and file paths), but you can also set optimisations (-OX).

Example with main.c

#include <stdio.h>

int function1(int a, int b)
{
    return a*b+4;
}

int function2(int a, int b, char* c)
{
    printf("Result %d*%d+4 = %s\n", a, b, c);

    return 0;
}

int main(int argc, char** argv)
{
    char buf[32];

    sprintf(buf, "%d", function1(5, 4));

    function2(5, 4, buf);
}
    

> gcc main.c -ggdb -o test
> objdump -ld test > test.txt
> ./binstats.pl --in test.txt

Total instructions 63

63	(100.00%)   /home/soutade/main.c
	38	 main
	16	 function2
	9	 function1

There are also options to filter small files, small functions and paths that helps to focus on big ones. Have fun !

L'intégration dans la liste des addons officiels de Firefox a été longue et difficile, et après deux versions (depuis la 0.2), gPass a enfin été accepté ! Le tag vient un peu tard puisque cela fait presque un mois qu'il n'y a plus de restrictions sur le site de Mozilla, mais il y a eu quelques petites améliorations concernant le client web. Désormais tout semble stable.

Cette intégration donne une bonne visibilité à l'addon avec une trentaine d'utilisateurs quotidiens (je ne suis pas inclus dans ces statistiques). Si cela peut paraître dérisoire, il n'en reste pas moins mon projet le plus largement déployé ! Bien sûr, c'est un peu frustrant de ne pas savoir où sont les serveurs hôtes et leurs nombres, mais c'est le but ! Ma grande satisfaction est que gPass est utilisé "partout" dans le monde.

À priori il n'y aura pas d'évolutions hors demandes particulières (pas de retours pour le moment) ou compatibilité avec Firefox, car le projet est "fini", c'est à dire qu'il fait ce qu'on lui demande (et il le fait plutôt bien).

Voilà ma première application Android : Silent Night*. Enfin presque... En réalité, je n'ai fais que reprendre une application déjà existante pour l'améliorer. Et c'est toute la force du logiciel libre : pouvoir analyser, adapter, corriger et améliorer l'existant pour nos propres besoins. Le cas de Silent Night est typique : l'application n'est plus compatible avec la dernière version d'Android, l'auteur n'a pas envie de s'y replonger. Pourtant, c'est une application simple, efficace et qui ne demande pas de lire vos SMS... Ni une, ni deux, je dégaine eclipse et met à jour l'application.

Même sans sortie officielle, je m'étais déjà penché sur le SDK d'Android. Personnellement, je trouve que c'est du bon gros bricolage. J'avoue n'avoir lu les tutoriaux que rapidement, mais j'ai quand même l'habitude de réaliser des applications pour PC. Les concepts pour mobile sont peut être différents, néanmoins, je trouve que l'API est une horreur à prendre en main (même si la documentation est très jolie). Rien ne semble clair (Intent, Fragment, Services...), surtout quand on rajoute la lourdeur des constructeurs à la Java. Pire encore : les applications sont incompatibles d'une version sur l'autre ! Le tout saupoudré d'un eclipse bien lourd (avec des bibliothèques qui ne sont compilées qu'en 32 bits !).

En 9 ans, Google n'a pas su redresser la barre pour proposer quelque chose de propre. Comme Microsoft avec Windows, le produit est trop répandu sur le marché pour changer radicalement. Même si le système en lui même est "beau", stable et performant (à grand coup d'optimisations), créer une application est un vrai calvaire (pour un débutant du moins). De plus, malgré qu'il soit open source, c'est un système assez fermé où l'utilisateur est régulièrement piégé entre le tout Google et le racket d'informations de la part des applications (lire vos SMS et accéder à Facebook est absolument indispensable pour une application qui allume le flash de l'appareil photo !). À ce propos, je ne peux que conseiller d'installer f-droid qui ne contient que des applications open source (comme Silent Night). Elles ne sont pas forcément de meilleure qualité, mais au moins on évite d'alimenter un carnet d'informations personnelles qui sera revendu plus tard par l'éditeur.

Mais que fait la concurrence ?

Propriétaires

• iOS : tout le monde connait. C'est du Apple, fermé au possible.
• WindowsPhone : peu utilisé, mais l'interface semble particulièrement bien adapté (et n'est pas une simple copie du premier).
• OS 10.2 de BlackBerry : il faut un BlackBerry.

Libres

• Firefox OS : comme ChromeOS, il est basé autour d'un navigateur. L'idée est intéressante, mais limité aux téléphones bas de gamme (pour le moment?). Faire des applications en HTML5/JavaScript, ce n'est pas trop mon truc.
• Sailfish OS : Peut être le meilleur futur concurrent d'Android. Enfin un SDK en Qt ! Mais pour le moment, rien ne pointe à l'horizon.
• Ubuntu Touch : Grosse déception pour ce dernier. Les performances et la qualité générale sont décevantes (test de novembre). Il y a eu beaucoup de promesses et pas grand chose au final...

En attendant, il y a Android... Jusqu'à ce, qu'un jour, peut être, Samsung décide de migrer l'ensemble de ses appareils vers un autre système... Le seul avantage, est que la réalisation d'applications sur mobile donne à manger à plein de développeurs.

*Silent Night permet de couper le son et/ou de passer en mode avion pendant une période donnée (configurable). C'est le mode avion qui était cassé sur les versions récentes d'Android. Pour l'activer, il faudra quand même avoir un téléphone rooté (merci Google).

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.

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.

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 là. 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.