Informatique

IWLA 0.5

Thursday, 16 April 2020
|
Écrit par
Grégory Soutadé

Capture d'écran IWLA

3 ans se sont écoulés depuis la dernière version d'IWLA. C'est avant tout une histoire de flemme avec des commits restés trop longtemps en test (notamment la série d'août 2019), mais cela prouve aussi que le logiciel est relativement stable et répond au besoin. Cette nouvelle mouture apporte :

  • L'ajout d'un mode test (dry run)
  • De nouvelles règles pour la détection des robots (plus de 10 erreurs 404, affichage d'une page sans élément (hit), pas de page et pas de hit)
  • Un nouveau format de base de données qui réduit considérablement la taille à stocker : les statistiques de pages (vues et non vues), de hits (vus et non vus) ainsi que la bande passante sont désormais cumulés et non plus stockés jour par jour. Cette modification entraîne une incompatibilité avec les versions précédentes
  • La mise à jour des données depuis la branche de développement d'AWSTATS
  • Plugin top_pages_diff
  • La possibilité d'exclure une IP des statistiques
  • L'utilisation de cPickle à la place de Pickle
  • Les requêtes des robots ne sont plus sauvegardées (gain de place)
  • Quelques corrections de bug

Comme mentionnées, les modifications visent avant tout à réduire l'empreinte mémoire et disque du logiciel, ce dernier devant tourner sur un serveur avec seulement 1GB de RAM.

À vos téléchargements !

Gnome Shell Generic Monitor

Sunday, 05 April 2020
|
Écrit par
Grégory Soutadé

La crise sanitaire actuelle pousse les entreprises à recourir autant que possible au télétravail. En tant qu'ingénieur logiciel, mon activité s'y prête plus facilement que dans d'autres domaines : un SSH/VNC auquel on pourra adjoindre Jabber, un webmail et un webex pour les réunion audio et roulez jeunesse ! Néanmoins, mon environnement de bureau principal est légèrement différent, de XFCE au travail, je passe à Gnome 3 à la maison. Ainsi, un gadget devenu indispensable n'est plus disponible : le Generic Monitor alias genmon. Indispensable car il me permet de connaître en temps réel le nombre de mail non lus de ma boîte mail.

Ce plugin XFCE permet d'exécuter à intervalle régulier un script, récupère sa sortie et l'affiche (avec un formatage HTML) dans la barre des tâches (en réalité, là où le plugin est instancié). S'il a plutôt tendance à être épuré, le bureau Gnome 3 permet de créer facilement des extensions en Javascript. Un équivalent de genmon n'existant pas, j'ai pris mon courage à deux mains pour le développer.

L'extension Gnome Shell Generic Monitor vient d'être officiellement acceptée !

Capture Gnome Shell Generic Monitor

Les sources (sous licence GPL) sont disponibles sur la forge.

Contrairement au plugin XFCE, celui de Gnome 3 ne lance pas de script, il ne fait qu'écouter via DBUS des requêtes applicatives. Cela ajoute de la souplesse en faisant tourner un ou des scripts simples "métiers", plutôt que d'avoir à développer des extensions spécifiques à chaque fois.

Un exemple Python est fourni, c'est un extrait du script qui tourne chez moi. En plus du nombre de mail, j'affiche également une icône lors de la réception d'un message Pidgin (pratique quand on a raté la notification sonore ou que l'on n'a pas le casque sur les oreilles). Autant j'ai pu être traumatisé à l'époque (plus de 10 ans, certes...) par CORBA, trouvé SOAP assez lourd, autant les wrappers DBUS (du moins Python et Javascript) sont simples à mettre en œuvre. Le seul point négatif : la documentation des extensions n'est pas très fournie, il faut souvent passer par la documentation GNOME (pour le langage C) ou directement regarder les exemples.

gPass 0.9

Monday, 16 March 2020
|
Écrit par
Grégory Soutadé

Logo gPass

Petit rappel : gPass est un gestionnaire de mot de passes en ligne. C'est une alternative libre à lastpass. Il permet d'héberger un serveur de mot de passe, qui stockera un mot de passe fort et unique pour chaque site web. Les mots de passes sont chiffrés par une "clé maître" que seul l'utilisateur connaît et sont remplacés à la volée dans le formulaire d'authentification.

Bonne nouvelle ! La version 0.9 de gPass a été validée par l'équipe de Chrome (j'attendais une notification par mail, mais il ont fait ça en douce !). Cette version aurait du sortir plus tôt, mais plein de petites fonctionnalités sont venues se greffer.

Quelles sont les nouveautés ?

Tout d'abord, derrière le rideau, avec une ré architecture du code. Désormais, l'ensemble du code se situe dans la page d'arrière plan (background.js) et les fonctions sont appelées via l'échange de messages.

Ensuite, il y a eu des changements plus visibles. La partie la plus intéressante se situe dans l'ajout d'un popup (en cliquant sur l'icône gPass en haut à droite), qui permet de faire une requête au serveur de mot de passe en de hors du formulaire courant. Ainsi, si du code malveillant est intégré à la page web que l'on visite, il ne verra jamais transiter la clé maître. Dans la mesure du possible, le champ "nom d'utilisateur" du popup est rempli automatiquement avec la valeur contenu du formulaire cible. Si cela est possible, une fois que le mot de passe est récupéré, il est directement injecté dans le formulaire, lui même automatiquement validé (sauf à utiliser le préfixe @_). Si ce n'est pas possible, il est copié dans le presse-papier.

Fonctionnalité simple, mais très utilise lorsque l'on souhaite ajouter une nouvelle entrée dans le serveur de mot de passe, le popup crée automatiquement un lien vers l'adresse de notre serveur avec le nom de domaine courant et (si disponible), le nom d'utilisateur.

Ensuite, toujours dans l'objectif d'améliorer la sécurité quant à la fuite de la clé maître, l'icône de gPass devient verte lorsque l'extension est capable de gérer le champs "mot de passe" du formulaire courant, lorsque celui-ci obtient le focus, sinon elle reste jaune.

Finalement, deux entrées ont été ajoutées au menu contextuel de l'icône : les paramètres de l'extension et la possibilité d'activer/désactiver l'extension pour le site web courant (doit être paramétré pour chaque navigateur).

Les addons sont disponibles ici (firefox) et (Chrome). La partie serveur est à télécharger sur la page du projet, elle doit être mise à jour.

Upgrade Cubox-i Linux kernel

Saturday, 05 October 2019
|
Écrit par
Grégory Soutadé

In the beginning of October, Debian pushed a security update for libssl. After installing it, all new SSH connections fails with message (even with correct password, or root login) :

fatal: privsep_preauth: preauth child terminated by signal 31

After searching on Internet, I found that nor SSH, nor libssl were in cause. It was due to an old kernel. I was running Linux 3.14 kernel because http://repo.r00t.website is not maintained.

Fortunately, Solid Run still maintains Linux kernel source tree on Github. Next instructions are based on this page.

First, mount Cubox-i filesystem from SDcard (assume it's in /mnt/cubox).

At startup, uBoot is configured to load zImage and dtb/$dtb_file. zImage is a symbolic link allowing us to have multiple kernel in /boot, let's do the same for dtb directory :

cd /mnt/cubox
cd boot
sudo mv dtb/ 3.4.14
sudo mkdir dtbs
sudo mv 3.4.14 dtbs
sudo ln -s dtbs/3.4.14/ dtb

Next, kernel compilation. The linked page suggest to do a git clone which is very big (~3GB), I suggest to download a snapshot from Github. Now, we'll follows Solid Run instructions :

sudo apt install crossbuild-essential-armhf
cd linux_sources
export CROSS_COMPILE=arm-linux-gnueabihf-
export ARCH=arm
make imx_v7_cbi_hb_defconfig
make -j4 zImage dtbs modules

Then, install compiled files :

export INSTALL_PATH=$PWD/linux_install
export INSTALL_MOD_PATH=$PWD/modules_install
mkdir linux_install
make install modules_install dtbs_install
cp arch/arm/boot/zImage linux_install/vmlinuz-4.9.124
sudo cp -r linux_install/* /mnt/cubox/boot/
sudo cp -r modules_install/lib/modules/4.9.124/ /mnt/cubox/lib/modules/

Linux creates an image compressed with lzop which not seems to be supported by my version of uBoot, so we need to manually copy created zImage.

Modules installation can be done in one line :

sudo make modules_install INSTALL_MOD_PATH=/mnt/cubox/

Optionally, you can export headers :

sudo make headers_install INSTALL_HDR_PATH=/mnt/cubox/usr/local/include

Switch kernel

cd /mnt/cubox
sudo rm dtb
sudo ln -s dtbs/4.9.124/ dtb
sudo rm zImage
sudo ln -s vmlinuz-4.9.124 zImage
sync

Unmount and unplug SDcard. Power up. It should now run new Linux kernel !

Solid Run also have a repository for a Debian package for kernel, but for now I didn't saw any binary repository available on Internet.

Warning, Github kernel make my server crash a lot of time due to an error in ext4/fs driver. I compiled a vanilla kernel, from linux-4.19.y branch (same as Debian stable one). Use the same instructions for compilation (just add dtbs_install to make install command). My .config is available here. I didn't test HDMI, Bluetooth nor IR (red LED is off). Last thing : root partition is now on /dev/mmcblk1p1, don't forget to update kernel command line !

Enabling serial console

The serial console seems to not work anymore. To enable it, first edit /etc/inittab and add at then end :

1:2345:respawn:/sbin/getty -L ttymxc0 115200 vt100

Then, we need to enable getty with SystemD to have login prompt at startup :

sudo systemctl enable "getty@ttymxc0"

Finally, we need to update kernel command line. Edit /boot/boot.cmd and put :

consoleconsole=ttymxc0,115200n8

Build boot.scr from boot.cmd, documentation here:

mkimage -C none -A arm -T script -d boot.cmd boot.scr
sync

Max stack usage for C program

Wednesday, 10 April 2019
|
Écrit par
Grégory Soutadé

Another day, another script. This one helps to compute the maximum stack usage of a C program. In facts, it combines the output of cflow and GCC GNAT to find the heaviest path used (which is not necessary the deepest). The first one compute target software call graph while option -fstack-usage of GCC creates .su files containing stack usage of all functions.

Targets software are simple embedded software. This script is a simple base not intended to run on all cases, handle dynamic stack nor recursive functions (if you wish to add it...).

A file version is available here.

#!/usr/bin/env python

import os
import re
import argparse

class SUInfo:
    def __init__(self, filename, line, func_name, stack_size):
        self.filename = filename
        self.line = line
        self.func_name = func_name
        self.stack_size = stack_size

    def __str__(self):
        s = '%s() <%s:%s> %d' % (self.func_name, self.filename, self.line, self.stack_size)
        return s

class FlowElement:
    def __init__(self, root, depth, stack_size, suinfo):
        self.root = root
        self.depth = depth
        self.stack_size = stack_size
        self.suinfo = suinfo
        self.childs = []

    def append(self, suinfo):
        self.childs.append(suinfo)

    def __str__(self):
        spaces = '    ' * self.depth
        su = self.suinfo
        res = '%s-> %s() %d <%s:%d>' % (spaces, su.func_name, su.stack_size,
                                        su.filename, su.line)
        return res

def display_max_path(element):
    print('Max stack size %d' % (element.stack_size))
    print('Max path :')
    res = ''
    while element:
        res = str(element) + '\n' + res
        element = element.root
    print(res)

cflow_re = re.compile(r'([ ]*).*\(\) \<.* at (.*)\>[:]?')

def parse_cflow_file(path, su_dict):
    root = None
    cur_root = None
    current = None
    cur_depth = 0
    max_stack_size = 0
    max_path = None
    with open(path) as f:
        while True:
            line = f.readline()
            if not line: break
            match = cflow_re.match(line)
            if not match: continue

            spaces = match.group(1)
            # Convert tab into 4 spaces
            spaces = spaces.replace('\t', '    ')
            depth = len(spaces)/4
            filename = match.group(2)
            (filename, line) = filename.split(':')
            filename = '%s:%s' % (os.path.basename(filename), line)

            suinfo = su_dict.get(filename, None)
            # Some functions may have been inlined
            if not suinfo:
                # print('WARNING: Key %s not found in su dict"' % (filename))
                continue

            if not root:
                root = FlowElement(None, 0, suinfo.stack_size, suinfo)
                cur_root = root
                current = root
                max_path = root
                max_stack_size = suinfo.stack_size
            else:
                # Go back
                if depth < cur_depth:
                    while cur_root.depth > (depth-1):
                        cur_root = cur_root.root
                # Go depth
                elif depth > cur_depth:
                    cur_root = current
                cur_depth = depth
                stack_size = cur_root.stack_size + suinfo.stack_size
                element = FlowElement(cur_root, cur_depth,
                                      stack_size,
                                      suinfo)
                current = element
                if stack_size > max_stack_size:
                    max_stack_size = stack_size
                    max_path = current
                cur_root.append(element)
    display_max_path(max_path)

su_re = re.compile(r'(.*)\t([0-9]+)\t(.*)')

def parse_su_files(path, su_dict):
    for root, dirs, files in os.walk(path):
        for sufile in files:
            if sufile[-2:] != 'su': continue
            with open(os.path.join(path, sufile)) as f:
                while True:
                    line = f.readline()
                    if not line: break
                    match = su_re.match(line)
                    if not match:
                        # print('WARNING no match for "%s"' % (line))
                        continue
                    infos = match.group(1)
                    (filename, line, size, function) = infos.split(':')
                    stack_size = int(match.group(2))
                    key = '%s:%s' % (filename, line)
                    su_info = SUInfo(filename, int(line), function, stack_size)
                    su_dict[key] = su_info


if __name__ == '__main__':
    optparser = argparse.ArgumentParser(description='Max static stack size computer')
    optparser.add_argument('-f', '--cflow-file', dest='cflow_file',
                           help='cflow generated file')
    optparser.add_argument('-d', '--su-dir', dest='su_dir',
                           default='.',
                           help='Directory where GNAT .su files are generated')
    options = optparser.parse_args()

    su_dict = {}

    parse_su_files(options.su_dir, su_dict)
    parse_cflow_file(options.cflow_file, su_dict)

Usage & example

Let's take this simple software as example.

First, compile your software using -fstack-usage options in CFLAGS. It will creates an .su file for each object file. Then, launch cflow on your software. Finally, call my script.

mkdir test
cd test
gcc -fstack-usage gget.c -lpthread -lcurl
cflow gget.c > cflow.res
./cflow.py -f cflow.res

Result:

Max stack size 608
Max path :
-> main() 352 <gget.c:493>
    -> do_transfert() 160 <gget.c:228>
        -> progress_cb() 96 <gget.c:214>