# uname -a - Informatique

WordPress : Migrate from The Events Calendar to Events Manager

Mathieu — Tue, 31 Mar 2026 18:09:00 +0200

A quick snippet to switch all my events created with The Events Calendar to Events Manager, which offers more functionnalities in its free version.

It is a single-file plugin that you can activate in WordPress. Use it at your own risks, and with a backup available before starting.

<?php
/**
 * Plugin Name: TEC → Events Manager Migration
 * Description: Auto migration of The Events Calendar to Events Manager.
 * Version: 1.0
 */

if (!defined('ABSPATH')) exit;

class TEC_To_EM_Migration {

    const DRY_RUN = false;
    const LOG_FILE = WP_CONTENT_DIR . '/tec-em-migration.log';

    public function __construct() {
        add_action('admin_menu', [$this, 'add_admin_page']);
    }

    public function add_admin_page() {
        add_menu_page(
            'Migration TEC → EM',
            'TEC → EM',
            'manage_options',
            'tec-em-migration',
            [$this, 'admin_page']
        );
    }

    public function admin_page() {
        if (isset($_POST['run_migration'])) {
            $this->log("=== START MIGRATION ===");
            $this->migrate_events();
            $this->log("=== END MIGRATION ===");
            echo "<div class='updated'><p>Migration finished. See log file.</p></div>";
        }

        echo '<h1>Migration TEC → Events Manager</h1>';
        echo '<form method="post">';
        echo '<p><strong>DRY RUN :</strong> ' . (self::DRY_RUN ? 'YES' : 'NO') . '</p>';
        echo '<input type="submit" name="run_migration" class="button button-primary" value="Start migration">';
        echo '</form>';
    }

    private function migrate_events() {
        $events = get_posts([
            'post_type'      => 'tribe_events',
            'post_status' => 'publish',
            'posts_per_page' => -1,
        ]);

        foreach ($events as $event) {
            $this->log("The Event Calendar: {$event->post_title}");

            // Dates
            $start = get_post_meta($event->ID, '_EventStartDate', true);
            $end   = get_post_meta($event->ID, '_EventEndDate', true);

            // Location
            $venue_id = get_post_meta($event->ID, '_EventVenueID', true);
            $location_id = $this->migrate_location($venue_id);

            // Create EM event
            $new_post_id = $this->create_em_event($event, $start, $end, $location_id);

            // Thumbnail
            $thumbnail_id = get_post_thumbnail_id($event->ID);
            set_post_thumbnail($new_post_id, $thumbnail_id);
        }
    }

    private function migrate_location($venue_id) {
        if (!$venue_id) return 0;

        $venue = get_post($venue_id);
        if (!$venue) return 0;

        $address = get_post_meta($venue_id, '_VenueAddress', true);
        $city    = get_post_meta($venue_id, '_VenueCity', true);
        $country = 'FR';

        $this->log(" → Location: {$venue->post_title}");

        if (self::DRY_RUN) return 0;

        global $wpdb;
        $existing_id = $wpdb->get_var(
            $wpdb->prepare(
                "SELECT location_id FROM {$wpdb->prefix}em_locations WHERE location_name = %s LIMIT 1", $venue->post_title
            )
        );
 
        if ($existing_id) {
            $this->log("   → Existing location, ID = {$existing_id}");
            return $existing_id;
        } else {

            $EM_Location = new EM_Location();

            $EM_Location->location_name    = $venue->post_title;
            $EM_Location->location_address = $address;
            $EM_Location->location_town    = $city;
            $EM_Location->location_country = $country;

            $lat = get_post_meta($venue_id, '_VenueLatitude', true);
            $lng = get_post_meta($venue_id, '_VenueLongitude', true);
            if ($lat && $lng) {
                $EM_Location->location_latitude  = $lat;
                $EM_Location->location_longitude = $lng;
            }

            $EM_Location->save();

            $this->log("   → New location created, ID = {$EM_Location->location_id}");

            return $EM_Location->location_id;
        }
    }

    private function extract_time($datetime) {
        if (!$datetime) return '00:00:00';

        // Normalize datetime
        $datetime = str_replace('T', ' ', $datetime);

        // Extract hours
        $parts = explode(' ', trim($datetime));
        if (count($parts) < 2) return '00:00:00';

        $time = $parts[1];

        // Add missing seconds
        if (preg_match('/^\d{2}:\d{2}$/', $time)) {
            $time .= ':00';
        }

        // Only keep HH:MM:SS
        if (preg_match('/^\d{2}:\d{2}:\d{2}/', $time, $m)) {
            return $m[0];
        }

        return '00:00:00';
    }

    private function create_em_event($event, $start, $end, $location_id) {
        $this->log(" → Creating EM: {$event->post_title}");

        $start_date = substr($start, 0, 10);
        $end_date   = substr($end, 0, 10);

        $start_time = $this->extract_time($start);
        $end_time   = $this->extract_time($end);

        if (self::DRY_RUN) return 0;

        // Create new EM event

        $EM_Event = new EM_Event();
        $EM_Event->event_type = 'single';
        $EM_Event->event_archetype = 'event';
        $EM_Event->event_name = $event->post_title;
        $EM_Event->post_content = $event->post_content;
        $EM_Event->event_date_created = $event->post_date;
        $EM_Event->event_start_date = $start_date;
        $EM_Event->event_start_time = $start_time;
        $EM_Event->event_end_date = $end_date;
        $EM_Event->event_end_time = $end_time;
        $EM_Event->start = strtotime($EM_Event->event_start_date.' '.$EM_Event->event_start_time);
        $EM_Event->end = strtotime($EM_Event->event_end_date.' '.$EM_Event->event_end_time);
        $EM_Event->event_rsvp = false;
        $EM_Event->event_rsvp_time = $start_time;
        $EM_Event->location_id = $location_id;
        $EM_Event->event_status = 1;
        $EM_Event->save();

        return $EM_Event->post_id;
    }

    private function log($msg) {
        file_put_contents(self::LOG_FILE, date('[Y-m-d H:i:s] ') . $msg . "\n", FILE_APPEND);
    }
}

new TEC_To_EM_Migration();

Drupal 8 / 9 / 10 : Programmatically render a view with contextual and exposed filters input

Mathieu — Sun, 10 Mar 2024 19:45:00 +0100

Exposed Input and Contextual Input are two different ways of providing input to Drupal Views.

Contextual filters work with an ordered list of parameters, while Exposed Input works with a form that has a couple name/value for every input parameter.

Contextual Filters

The right way to render a view result with contextual filters is to generate a render array:

$render_array = [
  '#type' => 'view',
  '#name' => 'YOUR_VIEW_NAME',
  '#display_id' => 'YOUR_VIEW_DISPLAY',
  '#arguments' => [CONTEXTUAL_FILTER_1, CONTEXTUAL_FILTER_2, ...],
];

You can then send the render array to a Twig variable, or render it programatically:

$result = \Drupal::service('renderer')->render($render_array);
return $result->__toString();

We are using the __toString() function to get the rendered HTML because the result returned by Drupal Render service is an object containing cache metadata.

Exposed Filters

The right way to render a view result with exposed filters is to generate a render array, and set the '#view#' parameter with a view object where you can initialize the filters:

$view = \Drupal\views\Views::getView('YOUR_VIEW_NAME');
$view->setExposedInput([
    'YOUR_FILTER_NAME' => 'YOUR_FILTER_VALUE',
]);
$render_array = [
  '#type' => 'view',
  '#name' => 'YOUR_VIEW_NAME',
  '#view' => $view,
  '#display_id' => 'YOUR_VIEW_DISPLAY',
  '#arguments' => [CONTEXTUAL_FILTER_1, CONTEXTUAL_FILTER_2, ...],
];

You can then send the render array to a Twig variable, or render it programatically:

$result = \Drupal::service('renderer')->render($render_array);
return $result->__toString();

We are using the __toString() function to get the rendered HTML because the result returned by Drupal Render service is an object containing cache metadata.

Leaked Metadata and Early Rendering

If you render a view while rendering a controller output that is suppose to provide its own cache metadata (CacheableJsonResponse for instance), and run on the error:

LogicException: The controller result claims to be providing relevant cache metadata, but leaked metadata was detected. Please ensure you are not rendering content too early.

Just wrap the rendering in a render context:

$context = new Drupal\Core\Render\RenderContext\RenderContext();
$html = \Drupal::service('renderer')->executeInRenderContext($context, function () {
  $render_array = [
    '#type' => 'view',
    '#name' => 'YOUR_VIEW_NAME',
    '#display_id' => 'YOUR_VIEW_DISPLAY',
    '#arguments' => [CONTEXTUAL_FILTER_1, CONTEXTUAL_FILTER_2, ...],
  ];
  $result = \Drupal::service('renderer')->render($render_array);
  return $result->__toString();
});

Sources

Configurer Visual Studio Code pour utiliser xdebug avec PHP FPM et SSHFS

Mathieu — Fri, 28 May 2021 14:46:00 +0200

Bonjour,

Une note à moi-même et à mes stagiaires pour utiliser xdebug avec un point de montage SSHFS, et PHP FPM.

S'assurer que PHP est bien installé sur la machine du développeur, c'est nécessaire pour la coloration syntaxique et la vérification de syntaxe.
Installer PHP xdebug sur la machine distante
Configurer xdebug pour PHP FPM sur la machine distante. Attention, cela change selon la version de xdebug.
1. Modifier le fichier de configuration FPM pour xdebug, par exemple pour Debian c'est /etc/php/7.3/fpm/conf.d/20-xdebug.ini
2. Y placer les instructions suivantes :
  Pour xdebug v3 :
```
[xdebug]
zend_extension="xdebug.so"
xdebug.mode=debug
xdebug.start_with_request = yes
xdebug.client_host=127.0.0.1
xdebug.client_port="9003"
```
  Pour xdebug v2 :
```
[xdebug]
zend_extension="xdebug.so"
xdebug.remote_enable=1
xdebug.remote_autostart=1
xdebug.remote_host=127.0.0.1
xdebug.remote_port="9003"
```
3. Redémarrer PHP FPM.
Sur la machine du développeur, installer le module PHP xdebug pour Visual Studio : https://marketplace.visualstudio.com/items?itemName=felixfbecker.php-debug
Connecter en SSHFS le dossier distant (la machine qui exécute PHP) sur la machine (locale) du développeur : sshfs login@distant:dossier_distant dossier_local
Connecter un tunnel SSH pour forward le port xdebug vers la machine locale : ssh -R 9003:localhost:9003 login@distant
Ouvrir dans Visual Studio le dossier monté avec SSHFS
Ouvrir un fichier, puis le debugger dans les onglets à gauche

Cliquer sur "create a json launch file", et vérifier le port de xdebug pour pointer sur le bon port. Ajouter le pathMapping pour mettre en correspondance le chemin local (ouvert dans Visual Studio Code) et le chemin distant (monté en SSHFS) :

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Listen for Xdebug",
            "type": "php",
            "request": "launch",
            "port": 9003,
            "pathMappings": {
                "dossier_distant": "${workspaceFolder}/"
            }
        },
        {
            "name": "Launch currently open script",
            "type": "php",
            "request": "launch",
            "program": "${file}",
            "cwd": "${fileDirname}",
            "port": 9003,
            "pathMappings": {
                "chemin_distant": "${workspaceFolder}/"
            }
        }
    ]
}

Redémarrer Visual Studio par sécurité.
Lancer l'écoute via le debugger, ajouter les breakpoints dans Visual Studio, puis charger la page du site distant via le navigateur. Visual Studio devrait stopper l'exécution au niveau des breakpoints, pour permettre l'affichage de la pile, et le lancement des commandes.

Sources

La délégation NS d'un sous-domaine, cet illustre inconnu

Mathieu — Tue, 05 Mar 2019 09:15:00 +0100

Un billet un peu technique aujourd'hui. Si vous travaillez dans le Web, vous n'êtes pas sans savoir que c'est le mécanisme des DNS qui fait en sorte que vos noms de domaine soient résolus en adresses vers votre hébergement.

Vous savez aussi peut-être ce qu'est une zone DNS. Une zone DNS est un bête fichier présent sur le serveur DNS, et qui contient l'ensemble des enregistrements du domaine¹.

Vous savez aussi certainement ce qu'est un sous-domaine, par exemple pour le domaine example.com, des sous-domaines seraient :

www.example.com
test.example.com
sousdomaine.example.com

Parfois, pour séparer les services, on souhaite aller encore plus loin et dédier un sous-domaine entier à une tâche, par exemple on souhaite faire en sorte que compta.example.com soit totalement indépendant, c'est à dire :

Qu'on puisse recevoir sur l'email facturation@compta.example.com ,
Qu'on puisse avoir des mini-sites dédiés sous ce sous-domaine, comme urssaf.compta.example.com ou creances.compta.example.com
Que le sous-domaine puisse servir tout autre usage tel que permis par les DNS (enregistrements SRV, etc)

Bien sûr, ces usages sont possibles à partir de la zone DNS du domaine parent, mais à mesure que le sous-domaine grandit en indépendance (et donc en nombre d'enregistrements), il peut être nécessaire de poser les bases d'une délégation plus avancée, pour éviter de maintenir une zone avec tous les enregistrements. On peut aussi vouloir déléguer à un prestataire la gestion de ce sous-domaine.

Pour ce qui est des mini-sites, il est relativement simple de déclarer un wildcard pour rediriger tous les enregistrements d'un sous-domaine vers un même serveur. Mais lorsqu'on veut plus de souplesse, ou que l'on veut aussi déléguer tous les enregistrements de ce sous-domaine, un wildcard est trop "brutal" et pas toujours supporté par toutes les spécifications, il faut alors déléguer la zone via une délégation NS.

En deux images

Requête DNS classique : le serveur répond au client avec un enregistrement A

Requête DNS déléguée : le serveur répond d'aller interroger un autre serveur,
le client transmet la requête à l'autre serveur et obtient l'enregistrement A.

En exemple

Prenons un exemple de la vie réelle. Sortez votre commande dig, et examinez le domaine pingveno.net :

dig +trace pingveno.net @8.8.8.8

pingveno.net.        172800    IN    NS    ns-197-a.gandi.net.
pingveno.net.        172800    IN    NS    ns-150-b.gandi.net.
pingveno.net.        172800    IN    NS    ns-153-c.gandi.net.
;; Received 733 bytes from 192.52.178.30#53(k.gtld-servers.net) in 46 ms

pingveno.net.        3600    IN    A    xx.xx.xx.xx
;; Received 57 bytes from 217.70.187.154#53(ns-153-c.gandi.net) in 45 ms

Dans l'exemple ci-dessus, j'ai retiré les appels du root server car ils ne sont pas pertinents pour notre exemple. On constate que la requête est transmise aux serveurs de Gandi, qui répondent directement avec l'enregistrement A du domaine.

Nouvel exemple, avec le sous-domaine uname.pingveno.net :

dig +trace pingveno.net @8.8.8.8

pingveno.net.        172800    IN    NS    ns-197-a.gandi.net.
pingveno.net.        172800    IN    NS    ns-150-b.gandi.net.
pingveno.net.        172800    IN    NS    ns-153-c.gandi.net.
;; Received 737 bytes from 2001:501:b1f9::30#53(m.gtld-servers.net) in 114 ms

pingveno.net.        3600    IN    A    xx.xx.xx.xx
www.pingveno.net.    10800    IN    CNAME    pingveno.net.
;; Received 75 bytes from 217.70.187.154#53(ns-153-c.gandi.net) in 44 ms

Cette fois le serveur répond avec un CNAME vers pingveno.net, c'est la méthode "pas chère" de déléguer le sous-domaine à un autre enregistrement. Ce n'est pas un wildcard, puisque l'enregistrement est seul, mais le résultat aurait été le même avec un wildcard.

Enfin, essayons avec ishimaru.pingveno.net :

dig +trace ishimaru.pingveno.net @8.8.8.8

pingveno.net.        172800    IN    NS    ns-197-a.gandi.net.
pingveno.net.        172800    IN    NS    ns-150-b.gandi.net.
pingveno.net.        172800    IN    NS    ns-153-c.gandi.net.
;; Received 742 bytes from 192.41.162.30#53(l.gtld-servers.net) in 45 ms

ishimaru.pingveno.net.    10800    IN    NS    a.ns.wellhosted.ch.
ishimaru.pingveno.net.    10800    IN    NS    b.ns.wellhosted.ch.
;; Received 98 bytes from 213.167.230.151#53(ns-150-b.gandi.net) in 44 ms

ishimaru.pingveno.net.    60    IN    A    xx.xx.xx.xx
ishimaru.pingveno.net.    3600    IN    NS    b.ns.wellhosted.ch.
ishimaru.pingveno.net.    3600    IN    NS    a.ns.wellhosted.ch.
;; Received 130 bytes from 2a03:2040:d:121::1#53(a.ns.wellhosted.ch) in 49 ms

Cette fois, le serveur a répondu en deux temps : il a indiqué un enregistrement NS sur le sous-domaine, puis le client (ici la commande dig) a continué la requête vers les serveurs indiqués dans l'enregistrement NS pour retourner finalement l'adresse IP.

C'est une délégation NS. Cela signifie que tout le sous-domaine (la zone complète) de ishimaru.pingveno.net n'est pas gérée par gandi.net, mais par a.ns.wellhosted.ch . De cette manière, le sous-domaine est totalement indépendant, et peut être utilisé pour tous les usages d'un domaine de niveau supérieur.

Conclusion

C'est tout, ce court article sert juste à démystifier l'enregistrement NS, qui est très peu souvent utilisé, d'une part par la méconnaissance de la plupart des "webdesigners" se contentant de pointer des sous-domaines en A ou en AAAA, et ensuite parce qu'il faut pouvoir déléguer à un serveur DNS, tous les prestataires ne sont pas équipés pour accueillir un domaine de cette façon.

Notes

¹ : L'ensemble, ou presque, le serveur DNS ne portant que la zone sur laquelle il a autorité, tout le travail du client DNS consiste justement à interroger les serveurs DNS en cascade, pour arriver à l'enregistrement qui fait autorité. Pas d'exposé là dessus aujourd'hui, mais vous pouvez lire la doc.

Utiliser l'Object Storage d'OVH (Openstack Swift) avec Updraft Plus

Mathieu — Tue, 26 Feb 2019 17:48:00 +0100

J'ai expérimenté cette semaine l'Object Storage d'OVH avec le module de sauvegarde de Wordpress UpdraftPlus, et le moins que l'on puisse dire c'est qu'on n'est pas aidé : pas de documentation de A à Z, les noms de configuration qui souffrent à la traduction, bref.

Voilà comment faire, simplement et du premier coup.

Créer un Projet dans le manager OVH

Aller sur le manager OVH, choisir "Cloud" en haut, accepter les contrats, et créer un projet :

Dans l'onglet "Stockage", cliquer sur "Créer un conteneur" :

Choisir la zone et le stockage, donner un nom au conteneur.

Attention, le stockage à froid à bas prix, bien que plus économique sur le prix du stockage, facture les données en entrée, contrairement au conteneur "privé".

Aller ensuite dans l'onglet "Gestion technique", puis "Openstack Users" et choisir "Ajouter un utilisateur" :

En face du nom d'utilisateur, ouvrez le menu secondaire, puis choisissez "Ouvrir Openstack Horizon" pour tester les identifiants :

Téléchargez ensuite le fichier de configuration OpenStack et ouvrez-le avec un éditeur de texte.

Vous êtes prêt à configurer UpdraftPlus. Ouvrez les paramètres d'UpdraftPlus et choisissez "OpenStack (Swift)" :

Dans "URI d’authentification", renseignez le contenu de OS_AUTH_URL : https://auth.cloud.ovh.net/v2.0/

Dans "Projet", renseignez le contenu de OS_TENANT_NAME

Dans "Région", renseignez la région que vous aviez choisi (SBG5, GRA, etc)

Dans "Identifiant", renseignez l'identifiant que vous avez créé dans le manager (attention aux espaces en faisant copier-coller)

Dans "Mot de passe", renseignez le mot de passe de l'identifiant que vous avez créé dans le manager (attention aux espaces en faisant copier-coller)

Dans "Contenant", renseignez le nom de votre containeur (dans l'exemple, mon_containeur).

Testez la connexion, si ça marche, la sauvegarde vers Openstack est configurée.

The war on SPAM: an review of the real world tools

Mathieu — Tue, 12 Sep 2017 02:54:00 +0200

Anti-spam techniques review: a few hints and tools review from my own experience.

Spam mesage are very common these days, but filtering them out is not as easy as it seems. The filtering techniques have evolved at the same rate than the spammers' evasive techniques, and the risk of filtering out a legitimate message is greater than ever.

It is also quite difficult to find good and up-to-date counter-measures list that anyone can implement.

Here is a summary of the anti-spam strategies I used / am still using. I hope it will help you understanding today's threats, and build your own solutions.

Definitions

MTA : Mail Transport Agent : this is the software that will actually do mail delivery. It is listening on port 25 and answers to SMTP commands. Some common MTAs : Postfix, Exim. More about MTA.
MX : MX records are DNS entries that are identifying the server responsible for mail delivery for the domain. More about MX records.
RBL : Realtime Blackhole List : a list of blacklisted IPs, that should be considered as spam sources. It is called Realtime because they are constantly updated. More about RBL.
RFC : Request For Comments, these are proposal for norms, some of them become norms. More about RFC.
IPS : Intrusion Protection System : these are "smart firewalls" that are blocking malicious requests, often based on behavioral rules. More about IPS.

The goals

My personal goals on SPAM war are pretty short:

Minimum false positive: having a spam is better than missing an important mail, try keeping the "permanent bashing" as low as possible
Hit harder on reoffending: coming-back spammers should be slapped harder
Internet neutrality: try not to encourage big mail farm, and let fair little providers doing their business

Available techniques

Blacklist / Blackhole Lists

Blacklists, Blackhole Lists (or RBLs) are the most ancient and most common measures for reducing spam. They are still pretty accurate, but:

It depends A LOT on the quality of the list, trashy lists are very common and they would end up sucking resources for no result, or worse, blocking legitimate emails
They are only accurate when updated often. I mean, very often (the R in RBL).
You should not use it directly on the MTA, these lists are an aggressive artefact of the past, where spam did not come from mail farms.
Very few are implementing IPv6, I agree that IPv6 spam is quite anecdotal, but it will probably change pretty soon (believe me)

Greylist

Greylisting is issuing a temporary REJECT code to force the foreign server to keep the message and send it back later. It aims at increasing the "cost per mail" for spam farms, as they cannot "hit and run" as fast as before.

The main culprits are that some providers are not implementing it well (hello Facebook) and so it needs an educated whitelist to work properly.

Some spammers are also re-sending the same mail several times in case of failure, looking like a legitimate mail server, and making Greylisting inefficient.

It is also hurting the fastness of the mail transmission, as the retry may occur several tens minutes after, slowing the mail delivery with little control on delays.

Also, some legitimate mail farms (hello OVH) are distributing their retry on several servers, making Greylisting inapplicable without fully whitelisting them.

RFC compliance

Spammers are often running special softwares for their crafted emails, tightening RFC compliance may be a good way to kick them out.

It can be as simple as forcing an HELO on SMTP protocol, or more tricky like checking the mail headers or enforcing a valid reverse.

In the majority of cases, it is very efficient, but:

Some home-made servers, especially Synology or Windows servers may be blocked while they are sending legitimate email. These servers are often ran by people who doesn't know or care on how to correctly setup a mail server. These buggy setups are more common than you think, and they are often legitimate senders, who have no clue of what is wrong, and are not willing to fix it (did I mentioned banking companies?).
In the vast majority of cases, IPv6-ready servers have no reverse on their IPv6 addresses and/or the IPv6 reverse is wrong.

SPF and DKIM

SPF and DKIM are anti-spoofing techniques. They does not guarantee that a mail is legitimate, but if the controls are showing an anomaly, it is very likely to be spam (or worse : scam or social engineering tentative).

The SPF technique is based on IP or sending domain whitelist: the sending email domain publishes a list of servers allowed to send email, along with a hint on what is expected if it does not pass (soft or hard reject).
DKIM is much more complex as the sending mail server has to cryptographically sign every message with a domain-specific key, which is then published in a special domain record.

SPF has been proven efficient at its beginnings, but today many spammers are just using stolen email accounts or custom domains that does not publish any SPF records, making it less pertinent.

DKIM is, like SPF, an anti spoofing technique, and spammers may be likely to sign mails from their custom domain if it becomes a necessity. Like SPF, a signed mail is not necessarily a clean mail. By the way, signature problems are pretty comon, and trashing an offending DKIM may not be the right behavior: Yahoo broke a lot of mailing lists when they enforced their DMARC policy.

To conclude, DKIM is relevant if you need to certify outgoing mails or if you are enforcing policies inside your company (to block spoofed email targeting your organisation) but it is definitely not an efficient anti-spam measure. And the recipient's servers may decide to simply ignore your painfully-configured DKIM headers.

Bayesian filters

Bayesian filters are frequency-based spam detection mechanisms. The idea is to sort out ham and spam for a short period of time, to let it "learn" what spam is made of, for efficient content-based detection. It has the benefit of being organisation-specific, as what is ham and what is spam may vary from one company to another (a company selling drugs may not be willing to filter out every message containing the word "pill").

But the learning process has to be taken seriously, and many end-users are just deleting spam instead of marking it for feeding the learning. By the way, the learning process needs IMAP folders to sort mails, and it will not work properly if all users are using POP mailboxes.

Spammers techniques

Or "the today's weapons of this war" .

Here is a short review of the spammers techniques I know, and some counter measures.

Address guessing

Some spammers are taking random web domains from their crawling, and then try to send their mails to commonly used addresses patterns. It can be webmaster@ ; ceo@ or whatever. These are easy to spot in log files, and a well configured MTA can take counter measures to lock out these guesses. Free (French ISP) is actually implementing this: postmaster.free.fr/index_en.html

Unfortunately, some legitimate email are sometimes sent to non existent addresses (typo, user deleted, etc) and legitimate MTA sometimes get blocked if the ban trigger is too low.

Moreover, nowadays' spammers are distributing their guesses trough zombie machines to stay under triggers, making it hard to spot.

Botnets

A lot of spammers are using zombies machines to send a high amount of mail in a short amount of time. Commercial ISP are taking the problem seriously, and many are blocking or filtering port 25 on their dynamic ranges, making impossible to have a custom mail server at home, but also preventing infected machines from sending direct-to-SMTP queries.

Direct to SMTP connections, ignoring MXes

Some spammers are just scanning IP ranges and directly talking to MTA, even if these MTAs are internal and pointed by no MX records. You may think that an authoritarian firewall is the neat solution, but it may be worth collecting these feisty IPs and feed them to an IPS, to protect the network from their guesses on the real MTAs.

Fake bounces and backsquatting

Sometimes you get an Undelivered Message notice (DSN) for a mail you never sent. This is probably backsquatting.
Backsquatting is sending email to a buggy address with a valid "from" address. An incorrectly configured mailserver would reply straight away to the from address to notify the failed delivery, instead of rejecting the mail and letting the foreign server doing the dirty job.

These configuration errors are pretty common, sometimes in defaut configurations or example configurations, but they can be easily avoided (look for documentation about backsquatting for your MTA, and test if your y server is vulnerable).

Real life advices

I am sorry, I don't have the magic wand to stop all Spam. A good spam fighting solution is always a combination of techniques, SpamAssassin for instance uses scoring from RBL as well as a bayesian filter and SPF checks.

I think that constant monitoring is important. Not just automated monitoring, but also clever log reading and mind openness on what can be a better solution for each problem. You never know what can happen in a spammer mind, and what works today may not work tomorrow. The Internet of Things is already a game changer.

I also advise you to be careful. Some decisions on our implementations may really hurt the Internet. Locking whole countries out is not without consequences, and the rise of IPv6 Internet has to be take into consideration from now.

Things are often not that pretty in mail servers, the temptation is great for a default blocking policy (hello MailInBlack). But as sysadmins, it is our responsability to not abuse and not hurting the smallest actors in the market (mails not coming from big farms). That may be a big word, but in my opinion, the freedom of the Internet also count on our neutrality on mail processing.

Thanks for reading.

SSL vs TLS vs STARTTLS

Mathieu — Mon, 13 Jun 2016 17:03:00 +0200

Cet article est une traduction libre de https://www.fastmail.com/help/technical/ssltlsstarttls.html

J'ai réalisé cette traduction pour fournir à mes clients une explication simple mais complète sur le pourquoi du comment de SSL/TLS/STARTTLS lors de la configuration de leur client mail.

Attention, l'article original date de 2012.

Définitions

Protocole : un protocole de communication est un format de données, un "langage" permettant à deux machine de communiquer entre elles. Les deux machines doivent être en capacité de parler le même protocole pour pouvoir échanger des données. SSL est un protocole de communication sécurisé ("chiffrés"), popularisé par le célèbre "cadenas" visible sur les pages web.
Port : un port est un numéro de service sur lequel les logiciels vous pouvoir communiquer entre eux. La plupart des numéros de port sont associés à des protocoles précis.

Introduction

Il y a souvent de la confusion autour des différents termes SSL, TLS and STARTTLS.

SSL et TLS fournissent tous deux un moyen de chiffrer le canal de communication entre deux ordinateurs (par exemple votre ordinateur et votre serveur mail). TLS est le successeur de SSL et les termes SSL et TLS sont interchangeables, à moins que vous ne fassiez référence à une version particulière du protocole.

STARTTLS est un moyen de prendre une connexion non chiffrée existante, et la "mettre à jour" vers une connexion sécurisée en utilisant SSL/TLS. Notez que même s'il contient TLS dans son nom, STARTTLS ne signifie pas que vous devez obligatoirement utiliser TLS, vous pouvez utiliser SSL.

Numéros de version SSL/TLS

La numérotation des versions du protocole est inconsistante entre SSL et TLS. Lorsque TLS a remplacé SSL comme protocole préférentiel pour les communications chiffrées, il a commencé avec une nouvelle numérotation de versions, et a également commencé à utiliser des sous-versions. L'ordre des versions des protocoles du plus ancien au plus récent est donc : SSL v2, SSL v3, TLS v1.0, TLS v1.1, TLS v1.2.

Lorsque vous vous connectez sur un port chiffré avec SSL/TLS, ou que vous utilisez STARTTLS pour convertir la connexion en connexion chiffrée, les deux systèmes vont négocier quel protocole et quelle version utiliser, en se basant ce qui a été configuré et sur ce que chaque système supporte.

Le support pour SSL/TLS est "virtuellement" universel de nos jours, mais le support des versions est variable. Pratiquement tous les systèmes supportent SSL v3 (à part quelques rares appareils Palm Treo comme nous avons pu le constater). La plupart des systèmes supportent TLS v1.0. À la date de Mai 2012, le support pour TLS v1.1 et TLS v1.2 est beaucoup plus restreint.

Dénomination incorrecte TLS vs STARTTLS

Pour compliquer les choses, certains logiciels de mail utilisent incorrectement le terme TLS à la place de STARTTLS. Les plus vieilles versions de Thunderbird en particulier utilisent "TLS" pour dire « utiliser STARTTLS pour chiffrer la connexion dès que possible et abandonner si STARTTLS n'est pas supporté » et « TLS, si disponible » signifie « utiliser STARTTLS pour chiffrer la connexion dès que possible si le serveur déclare le supporter, sinon utiliser simplement une connexion non chiffrée ».

Numéros de ports SSL/TLS vs plaintext/STARTTLS

Le problème du dessus est particulièrement problématique lorsque vous devez configurer des ports différents pour chaque protocole.

Pour ajouter de la sécurité à certains protocoles (e.g. IMAP, POP, etc.), il a été décidé d'ajouter nativement une couche de chiffrement SSL/TLS dans le protocole. Cependant, pour identifier que le logiciel doit parler la version nativement chiffrée du protocole au lieu de la version non chiffrée, un port différent a été déclaré pour chaque protocole. Vous avez donc :

IMAP utilise le port 143, mais IMAP avec SSL/TLS utilise le port 993.
POP utilise le port 110, mais POP avec SSL/TLS utilise le port 995.
SMTP utilise le port 25, mais SMTP avec SSL/TLS utilise le port 465.

Au bout d'un moment, il a été décidé qu'utiliser deux ports pour chaque protocole était du gaspillage, et qu'à la place il devrait y avoir un seul port sur lequel commencer la communication de manière non chiffrée, puis proposer au système distant de mettre à jour vers la version chiffrée. C'est ce pour quoi STARTTLS a été créé.

Il y a eu quelques problèmes avec cette proposition. Il y avait déjà des logiciels qui utilisaient les numéros de port alternatifs avec une connexion SSL/TLS native. Les logiciels clients peuvent avoir une durée de vie très longue, donc vous ne pouvez pas juste désactiver les ports chiffrés avant que tous les logiciels ne soient remplacés ou mis à jour.

Des mécanismes ont été mis en place sur chaque protocole pour dire aux systèmes que le protocole non chiffré supportait STARTTLS, et qu'ils ne doivent pas essayer de se connecter avant de démarrer la négociation STARTTLS. Cela créa deux situations malheureuses :

Certains logiciels ignoraient simplement l'instruction « login désactivé jusqu'à ce que la connexion soit convertie en SSL avec STARTTLS » et essayaient de se connecter tout de même, envoyant leur login et mot de passe à travers la connexion non chiffrée. Même si le serveur à ce moment là rejette le login, les informations sont déjà passées en clair sur Internet.
D'autres logiciels voyaient l'annonce « login désactivé jusqu'à conversion en SSL », mais ne mettaient pas à jour leur connexion automatiquement, et renvoyaient des erreurs « mot de passe incorrect » à l'utilisateur, ce qui provoqua de la confusion sur ce qui était incorrect dans la configuration.

Ces deux problèmes causèrent finalement d'importantes incompatibilités entre les logiciels existants, et la plupart des administrateurs systèmes continuèrent d'utiliser les connexions exclusivement non sécurisés sur le port d'origine, et les connexions SSL natives sur un port alternatif.

C'est donc devenu de fait le standard que tout le monde utilise. IMAP SSL/TLS chiffré sur le port993 ou POP SSL/TLS chiffré sur le port 995. Beaucoup de sites (dont FastMail) désactive à présent le port IMAP non sécurisé (port 143) et le port POP non sécurisé (port 110) pour que les utilisateurs utilisent obligatoirement une connexion chiffrée SSL/TLS. En désactivant les ports 143 et 110, cela supprime également complètement STARTTLS, même en tant qu'option pour les connexions IMAP/POP.

SMTP STARTTLS comme une exception

La seule vraie exception à ce qui précède est SMTP. Cependant, c'est pour une raison différente. La plupart des logiciels email utilisent utilisaient le port 25 pour soumettre des messages à envoyer au serveur mail. Cependant, SMTP a été créé à l'origine comme un protocole d'échange de messages, et non de soumission. Un autre port (587) a donc été déclaré pour la soumission de messages. Bien que le port 587 ne nécessite pas explicitement STARTTLS, l'utilisation du port 587 est devenu populaire au même moment où l'utilisation de SSL/TLS était devenue un enjeu important de sécurité et de confidentialité.

Le résultat c'est que dans la plupart des cas, les systèmes qui proposent la soumission par le port 587 nécessitent que les logiciels utilisent STARTTLS pour chiffre la connexion, et nécessitent aussi un login et un mot de passe pour s'identifier. Il y a plusieurs avantages à cette approche. En écartant les utilisateurs du port 25, les FAI ont été en mesure de bloquer le port 25 pour prévenir les envois automatiques de SPAM causés par l'infection des postes de leurs utilisateurs.

Actuellement, les choses semblent encore aléatoires, divisées entre les gens qui utilisent SMTP SSL/TLS chiffré sur le port 465, et les gens qui utilisent SMTP avec STARTTLS sur le port 587.

NDLR : SMTPS sur le port 465 est aujourd'hui définitivement obsolète.

C'est l'histoire d'un spam Partie 1: petit cours d'anatomie

Mathieu — Mon, 02 May 2016 15:48:00 +0200

Le SPAM par mail, c'est pénible. C'est du travail à temps plein si on veut s'en débarrasser en gênant le moins les utilisateurs. De la stricte application des RFC aux paramètres secrets de spamassassin, je vais essayer dans cette nouvelle série d'articles essayer de vous en faire mieux comprendre les techniques, et proposer à mon échelle les quelques solutions "qui marchent", du moins pour moi.

Voici donc pour cette première partie un cours d'autopsie. Le SPAM que nous décortiquer aujourd'hui est un mail est est resté coincé en queue sur le serveur mail. Bien que tous les mails en queue ne soient pas du SPAM, il est important de surveiller la taille de cette liste de mails "en transit" ; un grand nombre de mails dans cette liste indiquant souvent un problème d'envoi ou de réception.

Affichons donc la queue :

# mailq
1430281C33     8589 Thu Apr 28 14:51:58  MAILER-DAEMON
             (connect to serveurspamserveur.net.ae[86.96.xxx.xxx]:25: Connection refused)
                                         spammeur@serveurspamserveur.net.ae

Première constatation : l'adresse source ne correspond pas à une adresse gérée par le serveur, ce n'est donc pas un mail envoyé par un des utilisateurs du serveur. Mais alors comment ça se fait que je route des mails qui ne viennent pas de chez moi, et qui ne vont pas chez moi ? Mon serveur serait configuré en OpenRelay (ça serait inquiétant) ?

Examinons le contenu brut du mail à partir de son ID. La commande postcat permet de le faire pour Postfix, à adapter selon votre MTA.

# postcat -q 1430281C33

Ci-dessous la sortie de la commande postcat que j'ai colorisée :

*** ENVELOPE RECORDS deferred/1/1430281C33 ***
message_size:            8589             234               1               0            8589
message_arrival_time: Thu Apr 28 14:51:58 2016
create_time: Thu Apr 28 14:51:58 2016
named_attribute: log_message_origin=local
named_attribute: trace_flags=0
sender:
original_recipient: spammeur@spamserveur.net.ae
recipient: spammeur@spamserveur.net.ae
*** MESSAGE CONTENTS deferred/1/1430281C33 ***
Received: by monserveur.com (Postfix)
    id 1430281C33; Thu, 28 Apr 2016 14:51:58 +0200 (CEST)
Date: Thu, 28 Apr 2016 14:51:58 +0200 (CEST)
From: MAILER-DAEMON@monserveur.com (Mail Delivery System)
Subject: Undelivered Mail Returned to Sender
To: spammeur@spamserveur.net.ae
Auto-Submitted: auto-replied
MIME-Version: 1.0
Content-Type: multipart/report; report-type=delivery-status;
    boundary="B25FA81C32.1461847918/monserveur.com"
Content-Transfer-Encoding: 8bit
Message-Id: <20160428125158.1430281C33@monserveur.com>

This is a MIME-encapsulated message.

--B25FA81C32.1461847918/monserveur.com
Content-Description: Notification
Content-Type: text/plain; charset=us-ascii

This is the mail system at host monserveur.com.

I'm sorry to have to inform you that your message could not
be delivered to one or more recipients. It's attached below.

For further assistance, please send mail to postmaster.

If you do so, please include this problem report. You can
delete your own text from the attached returned message.

                   The mail system

<monclient@gmail.com>: host
    gmail-smtp-in.l.google.com[2a00:1450:400c:xxxx::xxxx] said: 552-5.7.0 This
    message was blocked because its content presents a potential 552-5.7.0
    security issue. Please visit 552-5.7.0
    https://support.google.com/mail/answer/6590 to review our message 552 5.7.0
    content and attachment content guidelines. cw9si10769736wjb.20 - gsmtp (in
    reply to end of DATA command)

--B25FA81C32.1461847918/monserveur.com
Content-Description: Delivery report
Content-Type: message/delivery-status

Reporting-MTA: dns; monserveur.com
X-Postfix-Queue-ID: B25FA81C32
X-Postfix-Sender: rfc822; spammeur@spamserveur.net.ae
Arrival-Date: Thu, 28 Apr 2016 14:51:57 +0200 (CEST)

Final-Recipient: rfc822; monclient@gmail.com
Original-Recipient: rfc822;monclient@gmail.com
Action: failed
Status: 5.7.0
Remote-MTA: dns; gmail-smtp-in.l.google.com
Diagnostic-Code: smtp; 552-5.7.0 This message was blocked because its content
    presents a potential 552-5.7.0 security issue. Please visit 552-5.7.0
    https://support.google.com/mail/answer/6590 to review our message 552 5.7.0
    content and attachment content guidelines. cw9si10769736wjb.20 - gsmtp

--B25FA81C32.1461847918/monserveur.com
Content-Description: Undelivered Message
Content-Type: message/rfc822
Content-Transfer-Encoding: 8bit

Return-Path: <spammeur@spamserveur.net.ae>
Received: from localhost (localhost [127.0.0.1])
    by monserveur.com (Postfix) with ESMTP id B25FA81C32
    for <monclient@gmail.com>; Thu, 28 Apr 2016 14:51:57 +0200 (CEST)
X-Virus-Scanned: Debian amavisd-new at monserveur.com
Received: from monserveur.com ([127.0.0.1])
    by localhost (monserveur.com [127.0.0.1]) (amavisd-new, port 10024)
    with ESMTP id vn_xZRLJ3EKq for <monclient@gmail.com>;
    Thu, 28 Apr 2016 14:51:51 +0200 (CEST)
Received: by monserveur.com (Postfix, from userid 5000)
    id BE51181C31; Thu, 28 Apr 2016 14:51:51 +0200 (CEST)
X-Sieve: Pigeonhole Sieve 0.4.2
X-Sieve-Redirected-From: contact@monclient.com
Delivered-To: contact@monclient.com
Received: from localhost (localhost [127.0.0.1])
    by monserveur.com (Postfix) with ESMTP id 95E2581C33
    for <contact@monclient.com>; Thu, 28 Apr 2016 14:51:51 +0200 (CEST)
X-Virus-Scanned: Debian amavisd-new at monserveur.com
Received: from monserveur.com ([127.0.0.1])
    by localhost (monserveur.com [127.0.0.1]) (amavisd-new, port 10024)
    with ESMTP id 8agkFLPzF_vy for <contact@monclient.com>;
    Thu, 28 Apr 2016 14:51:44 +0200 (CEST)
Received: from bba148580.serveurspam.net.ae (bba148580.serveurspam.net.ae [217.165.xxx.xxx])
    by monserveur.com (Postfix) with ESMTP id 774C481C27
    for <contact@monclient.com>; Thu, 28 Apr 2016 14:51:44 +0200 (CEST)
Received: from www.serveurspam.net.ae ([127.0.0.1]) by AMAZONA-F00CA66 with Microsoft SMTPSVC(7.5.7601.17514);
     Thu, 28 Apr 2016 16:51:42 +0400
Date: Thu, 28 Apr 2016 16:51:42 +0400
To: "contact@monclient.com" <contact@monclient.com>
From: xxxx xxxx <spammeur@spamserveur.net.ae>
Subject: [SPAM] FW: Invoice
Message-ID: <be0fa65c2e77bf81d3fd1b0216e8e742@www.serveurspam.net.ae>
X-Priority: 3
X-Mailer: PHPMailer [version 1.73]
MIME-Version: 1.0
Content-Type: multipart/mixed;
    boundary="b1_be0fa65c2e77bf81d3fd1b0216e8e742"
X-OriginalArrivalTime: 28 Apr 2016 16:51:42.0538 (UTC) FILETIME=[40C0DFC0:01D1A068]

--b1_be0fa65c2e77bf81d3fd1b0216e8e742
Content-Type: multipart/alternative;
    boundary="b2_be0fa65c2e77bf81d3fd1b0216e8e742"

--b2_be0fa65c2e77bf81d3fd1b0216e8e742
Content-Type: text/plain; charset = "iso-8859-1"
Content-Transfer-Encoding: 8bit

Please find attached invoice #726990

Have a nice day

Rowena Pittman
Executive Director Sales Account Management Training Performance Support

--b2_be0fa65c2e77bf81d3fd1b0216e8e742
Content-Type: text/html; charset = "iso-8859-1"
Content-Transfer-Encoding: 8bit

<html>
<body>
<p>Please find attached invoice #726990<br><br><br>Have a nice day<br><br><br>Rowena Pittman<br>
Executive Director Sales Account Management Training Performance Support</p>
</body></html>

--b2_be0fa65c2e77bf81d3fd1b0216e8e742--
--b1_be0fa65c2e77bf81d3fd1b0216e8e742
Content-Type: application/zip; name="B1095_scan-invoice_0B0C3F.zip"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="B1095_scan-invoice_0B0C3F.zip"

UEsDBBQAAAAIAIRenEiR5N/wYgcAAHQTAAAKAAAAMTk0MGMwOS5qc9VYaW/TMBj+DBL/IUQC
ElYGLacoCNJr7Wh6LKVrixBKHCdxDid17oz9d+ys45IzBN+YtmWLX7/v4+c93Uwnwgha4xSe

...

--b1_be0fa65c2e77bf81d3fd1b0216e8e742--

--B25FA81C32.1461847918/monserveur.com--
*** HEADER EXTRACTED deferred/1/1430281C33 ***
named_attribute: encoding=8bit
*** MESSAGE FILE END deferred/1/1430281C33 ***

Les lignes que j'ai mises en gris ne sont pas très intéressantes : il s'agit de l'enveloppe et des informations fournies par le système qui gère la queue, intéressons-nous plutôt au reste.

Les lignes en bleu sont les en-têtes, ce sont elles qui retracent à la fois le format du message, mais aussi leur trajet à travers les différents serveurs mails qui l'ont manipulé. Comme une liste de tampons sur un passeport. Ce sont en particulier les lignes commençant par Received, qui tracent le trajet des mails à travers les échanges entre les serveurs. La première ligne Received correspondant au dernier échange réalisé, et la dernière ligne Received au premier échange réalisé.

Dans l'en-tête on retrouve aussi l'ID du message, 1430281C33, et son parcours entre les seveurs mail. Chaque serveur par lequel le mail passe va rajouter une ligne, la première ligne correspondant au dernier serveur ayant reçu le message.

Les lignes en rouge sont ce que l'on appelle les boundaries (et leurs déclarations). Ce sont des lignes de séparation permettant de dissocier les pièces jointes du reste du message. Ici on en a plusieurs, parce qu'en fait à chaque échange, le mail s'est fait attacher à un autre mail. Ce n'est pas courant, à moins que le mail n'ai été enrichi d'informations supplémentaire après un "rejet" du serveur de destination. Ici, il s'est donc probablement fait "jeter" plusieurs fois !

Commençons notre analyse par la fin du message. Le mail original contenait visiblement lui aussi une pièce jointe, et à en juger par le texte invitant à ouvrir la pièce jointe, il est fort possible que ça soit un SCAM. Un message vous invitant à ouvrir un faux fichier PDF qui va infecter l'ordinateur. Heureusement donc que ce mail n'est pas arrivé jusqu'à sa destination.

Remontons un peu, on constate que le mail a été envoyé avec PHPMailer, et qu'il a été marqué en [SPAM] dans le sujet par mon filtre antispam. La première trace de l'arrivée du mail est la suivante :

Received: from bba148580.serveurspam.net.ae (bba148580.serveurspam.net.ae [217.165.xxx.xxx]) by monserveur.com (Postfix) with ESMTP id 774C481C27 for <contact@monclient.com>; Thu, 28 Apr 2016 14:51:44 +0200 (CEST)
Received: from www.serveurspam.net.ae ([127.0.0.1]) by AMAZONA-F00CA66 with Microsoft SMTPSVC(7.5.7601.17514); Thu, 28 Apr 2016 16:51:42 +0400

La ligne au-dessus, c'est la trace du passage à l'antispam et à l'antivirus :

Received: from localhost (localhost [127.0.0.1]) by monserveur.com (Postfix) with ESMTP id 95E2581C33 for <contact@monclient.com>; Thu, 28 Apr 2016 14:51:51 +0200 (CEST) X-Virus-Scanned: Debian amavisd-new at monserveur.com
Received: from monserveur.com ([127.0.0.1]) by localhost (monserveur.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8agkFLPzF_vy for <contact@monclient.com>; Thu, 28 Apr 2016 14:51:44 +0200 (CEST)

Rien de spécial, l'antivirus et l'antispam sont installés en local et ont fait leur job dès que le message a été reçu. Continuons.

X-Sieve: Pigeonhole Sieve 0.4.2
X-Sieve-Redirected-From: contact@monclient.com

Ça c'est le mécanisme qui gère les alias de mon serveur. Sieve va rediriger l'adresse contact@monclient.com vers la bonne adresse de destination, l'adresse contact@monclient.com étant un alias.

Received: from monserveur.com ([127.0.0.1]) by localhost (monserveur.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id vn_xZRLJ3EKq for <monclient@gmail.com>; Thu, 28 Apr 2016 14:51:51 +0200 (CEST)
Received: by monserveur.com (Postfix, from userid 5000) id BE51181C31; Thu, 28 Apr 2016 14:51:51 +0200 (CEST)

On transfère tout ça au MTA local pour envoi à la destination finale :

Received: from localhost (localhost [127.0.0.1]) by monserveur.com (Postfix) with ESMTP id B25FA81C32 for <monclient@gmail.com>; Thu, 28 Apr 2016 14:51:57 +0200 (CEST)

Fin du premier message, on traverse la boundary pour voir ce qu'il s'est passé ensuite :

<monclient@gmail.com>: host gmail-smtp-in.l.google.com[2a00:1450:400c:xxxx::xxxx] said: 552-5.7.0 This message was blocked because its content presents a potential 552-5.7.0 security issue.

Ça c'est moins cool. En gros, gmail a jeté le message, parce que la pièce jointe était sans doute contaminée. Mon antivirus n'a rien vu, il va falloir chercher pourquoi (plus tard).

On continue de remonter, et au-dessus de la dernière boundary, on a :

Received: by monserveur.com (Postfix) id 1430281C33; Thu, 28 Apr 2016 14:51:58 +0200 (CEST)

Ok, gmail m'a renvoyé le message plus ou moins gentiement en m'expliquant qu'il n'en voulait pas, et mon serveur essaie de le transférer au spammeur original qui nous a fermé sa porte. Le mail reste donc en queue jusqu'à son expiration... Voilà pourquoi il traîne dans la queue des mails et qu'il n'a été envoyé ni par moi ni pour moi...

Conclusion

J'espère que cette courte plongée dans les en-têtes d'un mail vous a permis de vous familiariser avec le "vrai" contenu d'un mail.

Ici je ne peux plus faire grand chose avec ce mail à part le supprimer de la queue mail, le spammeur ayant certainement déjà été bloqué par son hébergeur ou changé d'adresse IP pour continuer à envoyer sans se faire prendre par les blacklists.

À bientôt pour un nouvel article.

Diminuer le taux de rejet des mails sortants pour un fournisseur de boîtes mail

Mathieu — Tue, 09 Feb 2016 21:06:00 +0100

En théorie, tout le monde peut s’improviser fournisseur d’emails, il suffit d’une machine avec les ports ouverts sur Internet et de quelques connaissances pour configurer le serveur mail (Postfix, Exim…)

En pratique, les fournisseurs de mails subissent la « concurrence déloyale » de leur camarades, car envoyer un mail c’est bien, faire en sorte qu’il soit reçu c’est mieux. Les « concurrents » ce sont les fournisseurs de service comme Hotmail, Gmail, Yahoo, et bien d’autres. Afin de lutter contre le SPAM, ces sociétés sont de plus en plus strictes sur la source des mails qui sont reçus par leurs services.

Une des conséquences c’est que les petits opérateurs, comme une start-up qui fournit de l’hébergement, un FAI associatif, ou même un particulier qui veut se réapproprier Internet, se font bloquer assez rapidement avec peu de solutions de recours, le support faisant souvent la sourde oreille.

Dans cet article, je vais donc explorer quelques pistes pour vous permettre d’abord d’éviter de vous retrouver bloqués, et ensuite contourner le blocage le cas échéant.

Ce billet est le produit de mes expériences avec l'hébergeur wellhosted.

Réputation (et monitoring)

Déjà, si vous avez une adresse IP dynamique, oubliez l’envoi de mails. Il est très difficile avec une IP dynamique d’assurer à la fois une réception correcte (même avec un MX pointant sur un DynDNS), et un envoi qui réussisse à tous les coups. D’ailleurs, la plupart des opérateurs proposant des IPs dynamiques bloquent le port 25, rendant l’envoi des mails « entre serveurs » impossible.

Ensuite, la seconde bonne raison pour avoir une IP fixe, c’est que les contrôlent antispam reposent en grande partie sur la réputation des IPs qui leur envoient des mails. Ce mécanisme s’appelle le RBL pour Realtime Block List. Les serveurs s’abonnent à des listes d'adresses IP connues pour émettre du SPAM, et refusent de recevoir les mails depuis ces IPs. Pas de chance si vous avez hérité d’une IP « qui pue », il vous faudra patiemment demander votre retrait de la liste de blocage au cas par cas.

Il existe des outils pour tester votre IP sur un grand nombre de RBL : mxtoolbox.com/blacklists.aspx

Vous pouvez également mettre en place une surveillance automatique de votre réputation sur plusieurs blocklists, soit avec un simple plugin Nagios, soit avec un outil comme RBLMon.

A noter que certaines listes ne permettent pas de faire « retirer » votre IP de la liste. Pas d’inquiétude pour ces listes, personne ne les utilise. Il existe par contre des fournisseurs de service qui ne publient pas leurs listes, et qui ont un processus contraignant pour se faire débloquer (Microsoft par exemple).

Une fois que votre IP est fixe et qu'elle est propre, l’étape suivante c’est conserver la réputation de votre IP et être irréprochable sur les mails que vous envoyez, mail nous verrons cela dans la suite.

IPv6

Même si ce n’est pas indispensable, IPv6 est le futur d'Internet, et de nombreux serveurs mails parlent IPv6. En utilisant IPv6, vous aurez aussi l’avantage que beaucoup de RBL ne sont pas prêtes pour IPv6, et donc votre IP ne sera certainement pas bloquée sur ces listes.

Revers de la médaille : oubliez l’utilisation d’une IPv6 exclusive, certains fournisseurs de mail utilisent encore exclusivement IPv4, il vous faudra donc une configuration réseau supportant les deux adressages pour être certain de pouvoir livrer vos mails.

Reverse, PTR, et Hostname

Le « Reverse », parfois nommé « PTR », est une résolution DNS inverse. De la même façon qu'une résolution DNS permet de passer d'un nom de domaine à une adresse IP, le DNS inverse permet de passer d'une adresse IP à un nom de domaine. Ce mécanisme existe aussi bien pour IPv4 que pour IPv6.

Si votre fournisseur de service (la personne chez qui vous louez les IPs ou les serveurs) ne vous permet pas de changer le Reverse, changez de prestataire immédiatement ! L'envoi d'un mail à partir d'une adresse IP sans Reverse est souvent rédhibitoire pour le serveur mail de destination (pas de reverse, pas de livraison).

De plus, votre Reverse doit être consistant :

L'adresse IP doit résoudre vers un domaine, et ce même domaine doit résoudre vers l'adresse IP.
Le serveur mail doit également fournir son nom de domaine principal dans le processus de négociation, et ce nom doit résoudre correctement vers son IP. Réglez donc les /etc/hostname ; /etc/mailname et myhostname (pour Postfix) correctement.

Une inconsistance à un quelconque niveau est pire qu'une absence de reverse : le serveur de destination considérera qu'il y a peut-être usurpation de l'IP.

Encore une fois, n'oubliez pas de régler aussi le reverse IPv6 si vous utilisez IPv6 sur votre serveur.

Postmaster, Hostmaster, et RFC

Certains serveurs mails sont un peu soupe au lait. Par exemple, il peut arriver que votre réputation descende en flèche juste parce que le propriétaire du serveur n’a pas de moyen automatisé de vous contacter.

J’explique : dans les RFC (Request For Comment, la base des normes et protocoles sur Internet), il est prévu qu’un serveur mail émettant du courrier possède des adresses particulières, à savoir postmaster@ledomaine.com et hostmaster@ledomaine.com permettant de recevoir les mails envoyés automatiquement par ses pairs.

postmaster recevra principalement les plaintes pour SPAM, notification de traffic inhabituel sur les mails, et autres requêtes relatives aux mails
hostmaster recevra les mails relatifs à la gestion du nom de domaine lui-même (demandes de transfert, contact légal du propriétaire - même si on préfère souvent écrire aux contacts du whois), ou parfois pour la réservation d’un certificat SSL (vérification de la propriété du nom de domaine avant délivrance automatique du certificat).

L’absence d’une adresse postmaster@ valide sur votre serveur vous fait donc paraître pour le serveur mail de destination comme un spammeur qui n’a même pas pris la peine d’implémenter correctement le protocole mail.

A noter qu’un alias de postmaster@ vers une adresse de votre choix fonctionne aussi, même si cette adresse est un trou noir. Mais vous ne devriez pas ignorer les notifications automatiques de blocage et de plaintes envoyées à postmaster…

De la même façon, préférez un logiciel de serveur mail respectueux des standards (Postfix, Exim) au tout-dernier-serveur-mail-a-la-mode, dont les réponses ne sont peut-être pas entièrement conformes aux RFC.

Limites

Là on touche au grand dilemme du fournisseur de mails en serveur mutualisé : offrir plus de possibilités aux utilisateurs, ou se protéger contre les usages abusifs ?

Concrètement, imaginons qu’un de vos utilisateurs décide d’envoyer de la publicité aux 500 adresses mail de sa liste de contacts. Les serveurs recevant un tel volume de messages d’un seul coup ne vont peut-être pas apprécier ce trafic non sollicité et encombrant (de la pub ? du SPAM ? Paf, bloqué).

Pire : imaginez qu’un de vos utilisateurs se fasse pirater sa boîte mail, et devienne un émetteur de SPAM ou de virus à partir de votre serveur mail ? Vous pensez que les serveurs de destinations seront compréhensifs s’ils reçoivent des centaines de mails par seconde provenant de votre serveur mail ? Ils ne chercheront pas à comprendre : paf, bloqué.

La solution dans un premier temps c’est de limiter le nombre de mails envoyés par votre serveur, par adresse et par jour. Chaque utilisateur ne devrait par exemple envoyer que 300 mails par jour. Au-delà, le compte sera bloqué en attendant que l’on détermine si c’est une utilisation légitime ou non. La limite est bien entendu à calibrer selon les utilisateurs et les services que vous voulez offrir.

Il existe plusieurs solutions pour implémenter ce comportement, voici la mienne : github.com/mpellegrin/ratelimit-policyd

Diminuer la vitesse d’envoi

Ça peut paraître un comble au moment où l’on veut recevoir les informations le plus vite possible, et pourtant c’est souvent nécessaire pour l’envoi de mails. Afin d’éviter d’envoyer trop vite un grand volume de mail d’un coup, il peut être nécessaire de mettre en place une limite de mails sortants par seconde et par domaine de destination. Ainsi, le serveur mail de destination ne sera pas inondé sous le poids des mails à traiter, et sera plus coopératif pour les recevoir (en résumé : il ne vous bloquera pas pour usage abusif de sa bande passante).

La mitigation du taux d’envoi peut être faite au moyen de simples paramètres pour le serveur mail steam.io/2013/04/01/postfix-rate-limiting/

DKIM et SPF

Avoir un enregistrement SPF valide pour le domaine avec lequel vous envoyez vos mails est pratiquement obligatoire : non seulement cela vous permettra de confirmer que le serveur qui envoie vos mails y est bien autorisé, mais cela vous protégera (un peu) contre les usurpations d'adresses mail. Un exemple de SPF serait :

v=spf1 +a +mx -all

Si vous voulez un effet positif maximal, préférez un réglage strict ("-all") au réglage de debug ("?all"), quitte à élargir votre jeu de règles en insérant toutes vos IPs. Par contre, ne mettez pas un TTL trop haut sur les enregistrements SPF, on ne sait jamais.

Attention également, pour configurer votre domaine, le champ de type "SPF" est obsolète, utilisez un champ de type TXT pour vos enregistrements SPF.

En complément au mécanisme SPF, parce que le SPF n'est pas toujours suffisant pour assurer au serveur de destination que le mail est légitime, vous pouvez mettre en place le DKIM pour tous vos mails sortants. La configuration est plus complexe, mais elle vaut largement le coup pour vous faire sortir de l'ornière d'une réputation trop faible de votre adresse IP dans les premiers mois.

Le principe du DKIM c'est d'ajouter une signature aux mails, cette signature étant calculée à partir d'une clef privée. La clef publique est quant à elle publiée dans un enregistrement TXT dans le nom de domaine, permettant au serveur recevant le mail de vérifier la validité de la signature, et donc la légitimité du message envoyé à partir du nom de domaine.

Smarthosts

Si finalement tout ce dont j'ai parlé plus haut n'a pas fonctionné, et que vous vous êtes fait bloquer sur le réseau d'un des grands fournisseurs de boîtes mail (Google, Microsoft, yahoo...), voici votre dernier recours.

Outre changer d'adresse IP, ce qui pose souvent d'autres problèmes, votre solution c'est d'utiliser un Smarthost. Le Smarthost, c'est tout simplement un serveur mail qui transfère des mails. C'est ce que l'on appelle aussi un relay mail, qui va renvoyer tous vos mails à la place de votre serveur bloqué.

Dans l'idéal vous devriez avoir plusieurs smarthosts, pour pouvoir répartir la charge de traitement, et les échanger lorsque l'adresse IP de l'un d'eux se fait bloquer. Ainsi vous ne touchez pas à vos MX, et vous avez un réseau permettant de faire sortir des mails indépendemment de votre réseau de réception.

Le routage vers le Smarthost se règle très simplement dans Postfix, en utilisant la directive transport_maps de Postfix et en configurant un second serveur mail (le smarthost) en mode Relay.

Attention cependant au moment de créer votre smarthost à ne pas créer de configuration en "Open Relay", qui permettrait à n'importe qui d'envoyer des mails à travers le smarthost, la sentence sera immédiate lorsque des spammeurs s'en apercevront. Réglez bien votre mynetwork, et sender_restrictions (par exemple avec Postfix).

Pour aller plus loin

Voici une liste d'outils assez pratique lorsque l'on configure ou que l'on cherche la cause d'un problème de délivrance sur un serveur mail :

Mail Tester (indispensable pour vérifier votre configuration)
MXToolbox (le couteau suisse des tests sur les serveurs mails)
Quelques conseils de Google

Quelques liens pour (essayer de) se faire retirer de la Blocklist :

Pour se faire dé-bannir par Microsoft (sans garanties...)
Pour se faire dé-bannir par Google (sans garanties)
Pour se faire débannir par Yahoo (sans garanties)
Pour se faire débannir par AOL (sans garanties)

Les programmes de monitoring de réputation :

Remarques et opinions à propos du patriotisme économique en informatique

Mathieu — Sun, 01 Nov 2015 15:46:00 +0100

Le patriotisme économique c’est le fait de préférer faire travailler une entreprise nationale, quitte à payer un peu plus, plutôt qu’une entreprise étrangère moins chère.

Cela se justifie en termes politiques : contribuer à l’économie de son pays ; mais aussi en termes économiques : le prestataire national comprend certainement mieux votre besoin qu’une entreprise du bout du monde, et les échanges sont donc facilités. De plus, vous aurez beaucoup plus de facilités à rencontrer votre prestataire (si ça se passe bien), ou à l’assigner en justice (si ça se passe mal) s’il opère sur le même territoire que vous.

Mais où est la limite ? Est-ce que votre prestataire peut sous-traiter à une entreprise étrangère sans trahir votre confiance ? Comment le mode de sous-traitance choisi impacte le projet ? Et surtout, dans le contexte du service en informatique, quelles sont les implications politiques et juridiques vis à vis de l’emplacement de stockage et de traitement des données ?

De nombreux exemples de sous-traitance abusive ont déjà fait polémique [1] [2] [3], mais remettons les choses à plat.

Note : ce billet est une opinion personnelle concernant un sujet auquel j’ai été confronté en tant que prestataire, il ne reflète que ma propre opinion.

Une économie mondialisée

Lorsque l’on parle de prestataire national, de quoi parle-t-on ? S’agit-il d’une entreprise côtée en bourse dont le siège social (et donc en théorie les impôts) se trouve dans votre pays ? Ou cela peut être une entreprise étrangère disposant d’un bureau et d’employés dans votre pays ?

Et quand bien même l’entreprise serait nationale, avec aucun bureaux à l’étranger, est-ce que cette entreprise externalise sa comptabilité ? Est-ce que son mécanisme de recrutement passe par une agence ? Achète-t-il des produits sur son propre territoire ? D’une manière ou d’une autre, il n’y a aucun moyen d’être certain qu’une partie du chiffre d’affaire que vous allez générer en tant que client ne va pas partir à l’étranger.

La limite se placera donc ici sur l’éthique et la responsabilité du prestataire :

A-t-il montré son implication dans la vie politique du pays (en interpellant les hommes politiques sur un sujet lié à son activité) ?
Quel est le pourcentage (estimé) de son activité à l’étranger, et quel est son historique ?
L’entreprise est-elle dans une perspective de croissance ou de réduction de son activité dans le pays ?

Le statut du salarié

Le prestataire peut être une entreprise ou un travailleur indépendant. Dans le cas d’un indépendant, il est plutôt évident si celui-ci travaille sur le territoire ou pas. Mais dans le cas d’une enterprise ? Emploi-t-elle un commercial chez vous pour ensuite faire effectuer le travail à l’étranger ?

Il existe trois moyens de faire travailler des salariés internationaux :

L’entreprise nationale sous-traite à une entreprise étrangère ou un travailleur indépendant à l’étranger. Il s’agit d’un contrat de sous-traitance classique.
Le salarié étranger est recruté par l’entreprise nationale et vient travailler dans l’entreprise sur le territoire national. Dans ce cas, il est considéré comme un salarié national, il est soumis aux mêmes règles, cotisations sociales, et taxes (mais pas nécessairement le même salaire), et sa venue nécessite l’obtention d’un permis de travail.
L’entreprise emploie des travailleurs détachés : ce sont des salariés d’un pays étranger qui viennent effectuer le travail dans un pays d’accueil le temps d’une mission, en conservant le statut juridique et social (et les salaires) de leur pays d’origine. Ce type de travail est très peu fréquent en informatique car il signifie des défraiements supplémentaires et se justifie pour les entreprises ayant besoin d’une présence physique de l’employé, comme le BTP ou l’événementiel.

Alors comment s’assurer du patriotisme de l’entreprise au niveau de la gestion de son salariat ?

L’entreprise a une adresse dans votre pays ?
Vous pouvez vérifier que ses ingénieurs travaillent bien dans ces bureaux ? Vous leur avez rendu visite pour signer le contrat ?
Le travail ne nécessite pas de pièces ou de savoir-faire particulier venant de l’étranger ?

« Patriotisme logiciel » ?

Le fait que les salariés soient des citoyens de votre pays, c’est bien. Qu’ils utilisent des services et des produits nationaux, c’est mieux. Mais sans aller jusqu’à ne pas utiliser les logiciels des géants américains (Cisco, IBM, Microsoft, Apple, etc), est-ce que le logiciel que vous avez commandé a bien été conçu et développé sur le territoire national ?

La plupart des logiciels d’entreprise (Microsoft Office, SAP, Oracle…) sont des logiciels existants pour lesquels le prestataire a acquis une licence, et dont il se charge de la personnalisation, la mise en service, et la maintenance. Le problème de ces logiciels c’est qu’ils ont une facheuse tendance à vous cacher des choses : ce sont souvent des boîtes noires dans lesquels le prestataire national n’a que peu de contrôle et peu de marge de manoeuvre. Vous n’aimez pas quand votre prestataire vous dit qu’il n’y peut rien faire et qu’il faut voir avec l’éditeur ? Alors ne transférez pas votre confiance à l’éditeur.

Au-delà du risque lié à la méconnaissance du fonctionnement du logiciel ou de la fragilisation délibérée du logiciel par l’éditeur pour pouvoir vendre ses patchs et correctifs, ou encore de la dépendance à l’éditeur du logiciel par l’utilisation de formats et protocoles de données propriétaires, le risque d’espionnage industriel est bien réel. Feriez-vous confiance à un logiciel chinois pour équiper vos centrales nucléaires ? ~~À un logiciel coréen pour vos smartphones~~ (ah non ça c’est déjà le cas). Acceptez-vous que’une entreprise d’amérique du nord ai un accès privilégié au back-office de votre logiciel ?

Pour limiter l’impact d’une société externe sur votre logiciel, privilégiez les logiciels libres ou les solutions à base de logiciels libres. Les logiciels libres et ouverts offrent de meilleurs garanties pour votre entreprise parce que justement ils sont ouverts : un audit interne et externe du logiciel est plus facile, il n’est pas contrôlé par une seule entreprise, et il offre souvent plus de marge de manoeuvre au prestataire (donc moins de temps facturable pour arriver à faire quelque chose). De plus, la documentation souvent abondante des projets libres et l’aspect ouvert du programme de base (pas de “balles d’argent”) vous permettra de changer plus facilement de prestataire si besoin. Enfin, l’utilisation d’un logiciel libre n’implique pas forcément une obligation de redistribuer votre logiciel gratuitement ou d’en divulguer les secrets de fabrication (en particulier s’il s’agit d’un logiciel interne qui n’est pas distribué aux clients).

Traitements humains et traitements informatiques

D’accord les opérateurs sont nationaux, les logiciels sont nationaux, mais où et comment sont traitées les données ? En informatique, le travail humain ne représente qu’une petite partie du travail qui va être effectué sur les données manipulées par le logiciel. C’est justement le logiciel qui va effectuer les transformations sur vos données, et donc le travail.

L’emplacement de stockage et de traitement des données est donc important. Le logiciel pourrait être installé dans les locaux du prestataire, ou alors sur un serveur externe dans un territoire étranger. De même, les données pourraient être stockées sur le territoire national ou dans un centre de données à l’étranger. À l’échelle d’internet, ces détails techniques sont invisibles, et ils font déjà la fortune des fournisseurs de “cloud”.

Mais ces décentralisations sont parfois nécessaires, tout simplement parce que le prestataire n’a pas toujours l’infrastructure ou l’expertise lui permettant de fournir un stockage fiable et sécurisé des données. Une couche de chiffrement réalisé par le logiciel au moment de la transmission et du stockage des données permet de limiter les risques liés à une interception ou à un vol physique des données (saisie du disque dur, etc), et peut rendre la chose acceptable.

Des hommes et des lois

Le stockage et le traitement dans un pays étranger a également un autre impact, politique cette fois-ci.

Selon le gouvernement en place et les mesures prises pour protéger la vie privée ou se prémunir du terrorisme (deux visions souvent antagonistes), il peut exister des lois obligeant le propriétaire du centre de données à fournir des “tuyaux” vers les “grandes oreilles” du gouvernement. De même, il peut exister une obligation de rétention des fichiers logs et meta données même après résilisation du contrat.

Il peut aussi exister une restriction sur le type de contenus stockés (contenus à caractère politique ou pornographique), et une obligation d’accepter un contrôle des autorités sans décision de justice. Il pourrait aussi être demandé de fournir le mot de passe de déchiffrement pour accéder à ces contenus, et en cas de refus une saisie des disques durs pourrait être réalisée.

Cela représente donc aussi un risque supplémentaire vis à vis de l’espionnage industriel [4], du blocage et/ou du contrôle des infrastructures [5], ou de la perte des données (saisie abusive du disque dur).

Qu’en disent les institutions publiques ?

Dans le doute, il est bon de se renseigner auprès des institutions gouvernementales, pour éviter de prendre des décisions sous le coup de l’émotion. La CNIL française a par exemple émis un ensemble de recommandations pour les entreprises souhaitant utiliser des services “cloud” (stockage ou traitement externalisé). On peut le synthétiser par :

Identifier quelles sont les données à stocker dans le cloud (sensibles ou non).
Définir ses exigences de sécurité technique et juridique (contraintes légales et techniques à la mise en oeuvre).
Conduire une analyse de risques (perte de contrôle, dépendence technologique, faille dans la sécurité des données, réquisitions judiciaires…).
Bien choisir l’offre correspondant à son besoin (cloud public vs cloud privé).
Bien choisir son prestataire (celui qui offre les garanties suffisantes), avec une liste des éléments devant figurer au contrat.
Former ses employés à ce nouveau mode de gestion des données.
Faire de la veille et de l’audit sur le service fourni.

De même, l’ANSSI (française aussi) a émis un référentiel de ses exigences concernant la mise en oeuvre d’un service “cloud”.

Conclusion

En conclusion, je pense qu’il ne faut pas vouloir être plus royaliste que le roi.

Oui, en informatique de nombreux services sont décentralisés, et il est difficile de contrôler qui aura accès à vos données au cours de leur saisie, leur traitement, et leur stockage.
Si cela vous pose problème, vous pouvez signer une charte ou une clause de confidentialité avec le prestataire, et chiffrer extensivement vos données pour les sécuriser.
Dans le cas de risque d’espionnage industriel, n’oubliez pas de former vos équipes, ça serait dommage de barricader la porte et de laisser la fenêtre ouverte.
Si les informations sont vitales et confidentielles, utilisez les mécanismes de double authentification et de cloisonnement des responsabilités (voir les recommandations de l’ANSSI), ou demandez à votre prestataire de se faire certifier.
Et si vous travaillez dans un domaine relevant du secret défense… Qu’est-ce que vous espérez apprendre ici ?

Mais,

Oui, les prestataires nationaux travaillant avec des logiciels libres offrent de meilleures garanties de sécurité, condentialité, et pérénnité des données.
Oui, les prestataires nationaux comprennent mieux votre besoin, ils sont meilleurs en support et en assistance client, ils sont meilleurs pour vous renseigner sur les conséquences juridiques liés à votre application (rétention de données, rétention de fichiers log, obligation de chiffrement, etc).
Les données internes sensibles devraient rester en interne : stockées et traitées sur un serveur situé dans vos locaux derrière un pare-feu, avec votre politique de sécurité, d’alarmes, et de contrôle physique des accès. N’oubliez pas de donner un badge d’accès au prestataire si besoin, et de réaliser des audits.

De la difficulté d'écrire un logiciel

Mathieu — Sat, 19 Jul 2014 12:31:00 +0200

Source de l’image : monmacon.tumblr.com

Écrire un logiciel, construire une voiture, dessiner un pont, construire une maison, tracer une route, finalement ces métier relèvent de la compétence d’un ingénieur. Alors pourquoi en informatique on arrive à des retards records, qui vont jusqu’à l’abandon pur et simple du projet par le client, dans certains cas ?

Parce que justement, ingénieur en informatique, c’est pas un métier comme les autres. Explications.

Nota Bene : dans cet article, les allégories et paraboles douteuses seront mises en italique.

Le travail de l’architecte

Le fond du problème c’est qu’écrire un logiciel est un exercice aussi compliqué que rédiger une démonstration mathématique. C’est vrai pour tout logiciel, qu’il s’agisse d’une interface Web avec des boutons colorés de partout, ou d’un contrôleur robotique avec interpolation de mouvements.

Écrire un logiciel logiciel c’est d’abord formaliser un problème, le décrire totalement, en apprivoiser tous les contours pour en voir la forme. Quand on a l’aspect général, on peut commencer à construire la structure qui servira de base pour tisser le reste du programme. La phase de compréhension du problème est cruciale : mieux elle est faite, plus les choses seront faciles. Il ne doit pas rester un seul point de doute, au risque de remettre en cause la structure. C’est très difficile de changer une table basse en armoire, pourtant à la base c’est la même chose : c’est des planches de bois, non ?

Une maison “vivante”

La base du logiciel, c’est le code source. Du moins, pour ce qui est de le faire exécuter sur un ordinateur. Mais un logiciel c’est pas juste du code, c’est surtout des idées, des principes, des mécanismes, des flux, des signaux, des “choses qui bougent” à l’intérieur au moment de l’exécution. Le code n’est que le support, la matrice sur laquelle vont naviguer les informations. Le travail de l’informaticien c’est de réaliser cette matrice, mais surtout de la rendre utilisable et compréhensible pour d’autres. La question qu’on se pose quand on écrit un logiciel c’est “comment”, celle quand on lit un logiciel c’est “pourquoi”.

Reprendre un logiciel existant pour lequel il n’y a pas de documentation, c’est arriver dans une cathédrale, et essayer de retrouver les murs porteurs sans l’aide de plans. Ensuite il faut arriver à rajouter un étage sans que la toiture s’effondre, tout ça bien sûr en respectant scrupuleusement la forme originale du bâtiment, les matériaux d’origine, et les techniques précédemment utilisées.

Une maison modulable

Source de l’image : monmacon.tumblr.com

Une autre chose que les gens ne comprennent pas vis à vis des logiciels, c’est que l’on ne crée pas un logiciel comme on crée un objet. Un objet a nécessairement une utilité et un périmètre d’utilisation fixe et définitif lorsqu’il est terminé. Une salière pourra devenir une sucrière, mais globalement on ne s’en servira pas d’arrosoir. Pourtant dans le fond c’est pareil, c’est un réservoir avec grille trouée posée dessus, non ? Un logiciel par contre devra évoluer, s’adapter aux autres logiciels qui changent autour de lui, ou aux besoins des utilisateurs qui changent avec le temps.

Cela explique que les logiciels sont composés à 30% de code pour répondre au besoin actuel, et à 70% de code prévu pour les besoins futurs. Tous les outils de développement, les mécanismes de création d’interfaces, les APIs, toutes ces “couches” logicielles contiennent environ 80% de code qui ne sera pas utilisé, mais qui est là pour prévoir l’utilisation que l’on pourrait en faire.

Oui, avec certains outils logiciels (frameworks), on peut écrire très rapidement un logiciel qui répond à un besoin simple et précis, tout est pratiquement déjà fait. Mais s’il est construit trop vite, il sera alors difficile de de faire évoluer, le réparer, assurer sa maintenance, ou même arriver à le réécrire entièrement en conservant les données qui y ont déjà été saisies. C’est pour ça que les programmes complexes “rament”, ils sont construits avec des couches et des couches de fragments qui ont été rajoutés à parti d’une idée simple, sans avoir eu la réflexion global sur le pourquoi et le comment. N’oubliez pas que les logiciels que vous achetez sont souvent vendus “en l’état”.

De leur côté, les clients veulent juste “que ça marche”, mais un bâtiment que l’on voit terminé dès la première phase de conception, c’est une maquette, on ne peut pas s’en servir comme habitation. Pourquoi quand il s’agit d’informatique les clients ont pris l’habitude d’habiter dans des maisons en cartons ? Pourquoi crier quand la maison s’effondre à la première pluie, plutôt que de se demander pourquoi on n’a pas écouté l’architecte qui vous a dit qu’habiter dans du carton ça allait vous poser des problèmes ?

C’est vrai il existe le phénomène inverse. Certains clients habitent dans des maisons en béton armé, fruit de plusieurs d’années d’études et de construction, et ne comprennent pas pourquoi il est si difficile d’ajouter une nouvelle pièce, surtout quand leur voisin qui a une maison en bois a terminé ses travaux d’extension en un temps record.

Quand t’as pas de Ferrari, t’as une Logan

Une autre chose que les clients ne comprennent pas, c’est que créer un système logiciel entier à partir de rien est un millier de fois plus compliqué que d’assembler des briques existantes. Le problème vient alors de la connaissance des briques, qui fait souvent défaut, et qui ramène au cas précédent : on fait trop vite avec des outils que l’on ne maîtrise pas.

Dans la majorité des cas, les informaticiens qui sortent des écoles ont surtout appris à écrire du code. À partir de ce constat, il serait illusoire de vouloir leur faire réécrire des concepts qui fonctionnent déjà très bien dans des briques de base, au risque de leur faire inventer la roue carrée.

Si vous avez les moyen de vous payer des ingénieurs-enseignants-chercheurs en informatique, alors oui vous pouvez construire votre Ferrari logicielle sur mesure. Sinon, embauchez simplement des ingénieurs en informatique, ils vous feront une Logan logicielle, en utilisant les outils inventés par les ingénieurs-enseignant-chercheurs (moteur, autoradio, carrosserie). Utilisez des solutions génériques, ne demandez pas à vos ingénieurs d’inventer le moteur à eau.

Vous travaillez sur et avec de l’humain

Source de l’image : monmacon.tumblr.com

N’oubliez jamais que derrière votre jolie interface que vous avez imaginée vous-même il y a des êtres humains. Les êtres humains sont par nature faillibles, ils sont sensibles au stress, ainsi qu’à la fatigue.

Contrairement à un travail à la chaîne ou un travail de manoeuvre, la conception logicielle requiert une attention continue pendant plusieurs heures, une baisse de l’attention produira un bug.

Lorsque l’on compresse les coûts de développement, on n’a que deux variables d’ajustement : le salaire de l’ingénieur, et son temps de travail. À partir de ce concept est né l’unité jour-homme, on donne un prix fixe pour une journée de travail, et le reste c’est du temps nécessaire à la tâche qui est facturé en multipliant le coût journalier par le nombre de personnes qui travaillent, et par le nombre de jours travaillé.

Mais de la même manière qu’on ne peut pas avoir un enfant en un mois, même en demandant à neuf femmes de regrouper leurs efforts, les coûts de travail ne sont pas linéaires lorsqu’on travaille en groupe : deux personnes ne vont pas deux fois plus vite, au mieux elles vont 1,8 fois plus vite. Vendre en jours-homme est une erreur encore lus flagrante en informatique, si on considère que le coût nécessaire pour assembler le travail réalisé par deux personnes sur un même logiciel est parfois supérieur au coût dépensé par les deux personnes.

Vendre au nombre de jours un logiciel est une erreur : en informatique on peut garantir les délais, on peut garantir les fonctionnalités, mais on ne peut pas garantir les deux. Toute tentative de mettre un ensemble de fonctionnalités facturées à l’unité dans un grand budget de plusieurs jour échouera avec une probabilité de retard proportionnel au temps donné pour le projet. Pour peu que le client pressé veuille une livraison partielle et décide que “telle fonctionnalité n’est pas prioritaire, faites moi celle-ci à la place” : le client vient de faire tomber le château de cartes, il faut réécrire une partie du logiciel. Si on ne réécrit pas tout (on ne le fait jamais), on fragilise la cohérence de l’ensemble. Si on avait prévu que le client change d’avis, alors on a dépensé du budget de développement potentiellement en pure perte. Donc on facture plus cher, au cas où.

Chaque logiciel est unique

Un logiciel est une création originale. À partir de là, deux logiciels ne se ressembleront pas, même si tous les efforts ont été fait pour que cela soit le cas. S’ils étaient strictement identiques, alors il n’y en aurait qu’un seul.

Un logiciel, contrairement à un pont ou une voiture, c’est différent non pas seulement dans ce que l’on voit mais aussi dans toute la technique qui est derrière, et qui est unique pour chaque logiciel. C’est comme si vous demandiez une création originale, du moteur jusqu’aux jantes, et donc vous allez avoir besoin d’apprendre à l’utiliser.

Peut importe quel type de logiciel vous demandez, peut importe que les interfaces aient été décrites à l’avance, peut importe l’anticipation que vous en faites : vous allez avoir besoin d’apprendre à l’utiliser. C’est à la fois stressant pour les utilisateurs à qui on n’a pas donné le temps de monter en compétences sur le logiciel, et les concepteurs du logiciel à qui on demande après la livraison de “refaire comme le logiciel faisait avant”, en bref ré-implémenter une fonction obsolète dans un logiciel neuf.

Les coûts liés à la conception d’un nouveau logiciel sont souvent sous-évalués car ils ne prennent justement pas en compte les temps de formation, et de rédaction des documentation, pourtant indispensables pour utiliser efficacement le logiciel.

Conclusions

Source de l’image : monmacon.tumblr.com

L’informatique est aussi difficile que l’ingénierie et difficile. Avec un handicap supplémentaire sur le fait que les méthodes et les processus de fabrication des logiciels ne sont pas encore éprouvés au niveau des méthodes de l’ingénierie civile.

La majorité des clients et des utilisateurs ont une vision tellement déformée de l’informatique qu’ils font de mauvais choix, ou exigent des choses impossibles.

S’il est difficile de construire un logiciel, il est difficile aussi pour le client de savoir à quoi s’attendre au milieu des réponses à son appel d’offre. Le fossé entre les techniciens et les clients ne pourra se faire que par une sensibilisation du client aux impératifs du logiciel. Le mécanisme MOA/MOE peut dans certains cas aider à améliorer cet état de fait, à condition que les différents interlocuteurs s’écoutent, respectent leurs décisions respectives, et soient composées de gens compétents.

Dans un logiciel, on ne paie pas juste le type qui va écrire des lignes de code au kilomètre, on paie aussi (et surtout) pour ceux qui vont définir ce que va être le logiciel, qui vont réaliser l’intégration du logiciel, les tests de qualité, la maintenance, la formation des utilisateurs. Un logiciel est fondamentalement plus un service qu’un produit.

Profil et résultats de recherche : réflexion sur la possibilité de reverse-engineering du PageRank dans le contexte du marketing ciblé

Mathieu — Sun, 12 Jan 2014 23:32:00 +0100

Si vous avez lu mon billet précédent, vous savez que la mesure d’audience utilise les cookies.

Il y a quelques jours, dans une conversation par mail à propos du référencement, je me suis souvenu de l’effet du « filter bubble » (voir aussi), c’est à dire que les résultats de recherche sont personnalisés en fonction de votre profil marketing, et le profil est directement construit à partir des outils de mesure d’audience.

Mais alors, comment faire du reverse-engineering sur les réponses des moteurs de recherche, pour comprendre les leviers permettant de positionner son contenu dans le bon profil marketing (“top keywords”, etc) ? Pour pouvoir faire ses expérimentations, il faut acheter des profils “tout prêts”, ou en construire un.

Note après relecture : En y repensant, je me suis dit qu’avec cet article j’étais en train de construire quelque chose de similaire au « nettoyeur » de la nouvelle intitulée « Scroogled », écrit par Cory Doctorow (voir le lien en fin d’article).

La construction d’un profil, comment ça marche ?

À la base de tout profil marketing sur Internet, il y a les cookies. Les cookies sont des informations au format texte qui sont stockées sur votre ordinateur lorsque vous visitez un site.

Les plate-formes marketing utilisent des services gratuit d’analyse d’audience (Xiti, Google Analytics…), de publicités (DoubleClick…), ou de réseaux sociaux (Facebook, Twitter…) pour collecter des informations sur la navigation des internautes, et lier un identifiant, stocké dans un cookie, à un profil de consommateur stocké sur leur serveur.

Étape 1 : Création de l’identifiant unique de suivi

Lors de la première rencontre entre l’utilisateur et le système de suivi marketing, un identifiant unique d’utilisateur est créé, et envoyé dans un cookie pour y être enregistré.

Étape 2 : Reconnaissance de l’utilisateur, enrichissement de la base de données

Une fois que le cookie contenant l’identifiant de suivi est placé dans l’ordinateur de l’utilisateur, celui-ci va être envoyé chaque fois que le système de suivi en fera la demande, même en consultant un autre site.

Premières difficultés…

Mais il y a plusieurs types de cookies : il y a les cookies “simples” qui peuvent être déclarés aussi bien depuis le Javascript que les entêtes HTTP, et il y a les autres, tous les autres. À savoir :

Les cookies Flash
Les cookies des applets Java
Les “super cookies” HTML5
Ce que vous n’avez jamais imaginé.

Construire un profil marketing signifierai pouvoir tracer, aspirer, et réinjecter tous ces cookies d’un navigateur à l’autre après la construction du profil.

Pour mimer totalement le comportement d’un utilisateur, il faudrait d’utiliser une “macro” qui cliquerait dans une vraie fenêtre de navigateur, et qui exporterai ensuite les fichiers de profil du navigateur (historique, cookies, cache, etc). La complétion du profil ne ferait alors aucun doute, mais celui-ci risque d’être assez volumineux et peu pratique à manipuler par la suite. De plus, les solutions de clic automatique (“macros”) ont leurs limites, quoi que vous fassiez, il vous faudra certainement créer vos profils à la main.

Autre limite : une fois le profil construit, commencer à l’étudier c’est aussi commencer à l’abîmer. En effet, réaliser des requêtes qui ne collent pas tout à fait au profil va avoir pour effet un recentrage du profil par les régies tout au long des requêtes, pour finalement arriver à un profil différent de celui qu’on a construit. Les requêtes sont vraiment dans ce cas du “one shot”. Comme en physique quantique, on ne pourra pas connaître l’état du système avant de l’avoir mesuré, et en le mesurant on l’aura détruit.

Comment construire un profil marketing ?

Les outils

Pour pouvoir construire de toute pièce un profil il nous faut :

Un navigateur web que l’on peut scripter facilement : Firefox ~~ou Chrome~~. Non, oubliez Chrome, son API de script ne permet pas de bloquer des ressources avant le chargement des pages, ce qui rend l’exécution des filtres de régie non fiables.
Une connexion internet la plus classique possible : pas de serveur ou de centre de calcul, une IP classique, localisée dans le pays ciblé pour l’étude.
Une idée du profil à construire : requêtes, durées de connexion, clics à effectuer, etc.

Approche brute

L’approche brute consiste à construire un profil en ne mimant que les données de clic de l’utilisateur. Principalement, elle se distingue de l’approche connectée par son absence d’utilisation des réseaux sociaux. Cela inclut aussi un blocage systématique de tous les mécanismes intégrés par ces réseau sociaux, qui traquent les utilisateurs, même lorsqu’ils ne sont pas membres.

C’est donc plus qu’une approche non-connectée, c’est pour cela que je ‘appelle l’approche brute. On ne va donc cibler que certaines régies marketing, et seulement celles-ci.

Il est nécessaire de partir d’un profil de navigateur vide, puis de configurer le logiciel de clic automatique avec des requêtes et des comportement prédéfinis. Le navigateur sur lequel sera exécuté la macro devra avoir un bloqueur sélectif de contenu installé, pour bloquer les régies tierces, et ne se faire suivre que par les régies que l’on souhaite. Je déconseille la mise en place d’un “Do-not-track”, cette seule information pouvant servir à identifier l’utilisateur sur un profil particulier (“utilisateur éduqué à internet cherchant à se « protéger des malwares »”), et pouvant changer les résultats construits après un partage de données entre régies.

Le blocage des régies tierces se fera donc via un filtre AdblockPlus spécialement créé, ou les projets Ghostery/Disconnect, correctement configurés eux aussi.

Approche “connectée”

L’approche connectée fait une utilisation totale de l’interconnexion des régies. Tout d’abord on va s’inscrire sur les réseaux sociaux pour identifier précisément son “personnage”, puis laisser les réseaux sociaux connectés lors de la navigation.

De cette manière, le croisement des informations du profil avec les informations collectées lors des clics de l’utilisateur pourra se faire, et la simulation du profil sera parfaite.

Limites

Il est très difficile de construire un profil cohérent « à partir de rien » : il faut avoir à la base une idée des requêtes à effectuer et du comportement de l’utilisateur, ce qui biaise l’étude puisqu’elle se basera sur un profil construit à partir de nos propres préjugés, et non pas sur la réalité.

De plus, lors de la création d’un profil pour l’approche connectée peut prendre énormément de temps, et n’est pas toujours possible automatiquement (les réseaux sociaux se protègent contre les robots).

Utilisez des profils existants !

Et si la solution la plus simple était tout simplement la meilleure ? Pourquoi s’embêter à construire des profils quand on peut utiliser ceux que construisent les internautes eux-mêmes ?

Avec un peu de persuasion, on peut « emprunter » les cookies d’un ami ou d’un proche, afin de tester ses requêtes directement à partir du profil qu’il a construit !

Sauvegarde du profil de navigateur

Le mode le plus simple pour récupérer à coup sûr tous les cookies d’un internaute c’est enregistrer le profil navigateur, qui inclut cookies, cache, mots de passe, favoris, et historique.

Évidemment, parfois ce n’est pas possible pour des raisons diplomatiques, mais lorsque c’est possible, c’est toujours la le meilleur moyen de s’assurer une complétude des données de base.

La procédure pour y parvenir dépend du navigateur de l’internaute à qui on emprunte ses cookies :

Sauvegarde sélective

La sauvegarde sélective consiste, comme son nom l’indique, à sélectionner les cookies traceurs, et à n’exporter que ceux-ci.

Cela permet d’avoir facilement des informations cohérentes, sans avoir à exporter tout le profil, cache et historique compris.

Identifier les cookies traceurs

L’identification des cookies traceur peut être un problème en soi. Ce n’est plus le cas depuis que les projets comme Ghostery/Disconnect existent : ces derniers énumèrent dans leur code source l’ensemble des cookies et webbugs nécessaires au tracking, triés par régie !

Aspirer tous les cookies

Aspire les cookies est le point délicat, puisque la procédure dépend de quel navigateur est utilisé. Il pourrait être utile de faire une extension pour navigateur, afin de pouvoir exporter et importer facilement les cookies désirés.

Réinjecter les cookies aspirés dans un profil vide

Là encore, une extension pourra faire l’affaire, car la procédure manuelle risque d’être fastidieuse et varie d’un navigateur à l’autre.

Conclusion

Nous avons vu qu’il était en théorie possible de construire un profil marketing pour faire du reverse engineering sur les résultats personnalisés en fonction du profil d’un utilisateur.

Nous avons vu qu’il était quand même plus simple, de récupérer les cookies d’un utilisateur donné, à condition qu’il soit d’accord.

Les données de profil nous suivent de plus en plus. Des téléphones aux navigateurs internet, les données collectées sur les utilisateurs n’ont jamais été aussi nombreuses, jusqu’à en devenir invasives. Ces données, d’une précision jamais égalée, commencent petit à petit à devenir ce qui nous définit en ligne, plus que notre nom ou notre pseudo. Et si un jour on pouvait vendre son profil marketing comme on vendrait une fausse carte d’identité ? Pour aller plus loin, je vous invite à lire la nouvelle Srooggled de Cory Doctorow.

Ce que vous ne savez pas sur les mesures d'audience sur Internet

Mathieu — Sat, 14 Dec 2013 15:38:00 +0100

Les mesures d’audiences répondent à une problématique qui est ancienne. De tous temps, les créateurs de contenu ont cherché à savoir quelle était la valeur de ce qu’ils produisaient. Les artistes comptaient donc le nombre de personnes présentes à leur vernissage pour déterminer la cote de leurs créations, on mesurait les concerts publics à l’applaudimètre, et l’affluence d’un magasin au moment des soldes montrait l’impact de la marque sur son segment de marché.

De tous temps on a pu constater des failles au mécanisme de mesure d’audience : les invités qui viennent pour le buffet lors du vernissage, et non pas pour les œuvres, la faible précision de l’applaudimètre, etc.

Pourtant, ces statistiques sur l’audience des produits a petit à petit gagné la confiance des investisseurs, jusqu’à en devenir une référence qui ne mesurait plus simplement l’audience, mais aussi la pertinence. Un produit qui n’a pas une audience suffisante est jugé non pertinent, et est donc écarté du marché. Peu importe s’il est rentable ou non, puisqu’on vous a dit qu’il n’était pas pertinent. La sacro-sainte pertinence s’est alors couplée avec le concept de croissance, et la course à la mesure d’audience s’est engagée.

Mais les mesures d’audiences, comment ça marche ?

Approche passive/active

Source de l’image

L’approche passive c’est les sondages : après l’exposition on va demander aux gens quelle a été leur œuvre préférée, s’ils ont apprécié la galerie, ou s’ils ont des suggestions à faire pour l’améliorer. Les inconvénients de l’approche passive, c’est d’abord le délai qui s’écoule entre l’événement et sa mesure, ensuite c’est l’impossibilité d’avoir un couvrement complet de la population considérée (on ne peut pas demander à tout le monde), et enfin c’est la forte subjectivité et le manque de précision des réponses.

L’approche active c’est la collecte à la source : on va mesurer directement la pertinence d’un événement, en utilisant des données issues de sources provenant de l’événement. Pour un magasin, cela peut consister à mesurer le temps passé par chaque personne dans le magasin, le panier moyen, le nombre d’articles différents au moment du passage en caisse, etc.

L’approche qui donne les meilleures données pour les mesures d’audiences c’est évidemment l’approche active. Non seulement elle fournie souvent des données chiffrées directement exploitables, mais elle a aussi la force de pouvoir couvrir une population plus large, et donc d’être plus fiable qu’une approche passive.

De plus, comme elle est bien souvent indolore, l’approche active a aussi l’avantage de ne pas gêner le client dans son “expérience d’achat”.

Dans la vraie vie, et sur Internet

La course aux mesures d’audiences ne va pas au même rythme dans le monde réel et sur Internet.

Dans le monde réel, l’approche active fera l’objet d’un consentement préalable à la fois de la CNIL et de vous-même (même implicitement). Quant à l’approche passive, vous êtes forcément au courant puisque c’est vous qui produisez les données en répondant aux questions.

Sur Internet, les choses sont différentes, et elles méritent d’abord de raconter un morceau d’histoire.

Au début, furent les fichiers logs

Source de l’image

L’analyse d’audience, en informatique, vient du Reporting. Le Reporting c’est la surveillance des systèmes. En effet, aux débuts de l’informatique, lorsque les machines fonctionnaient personne ne se posait de questions, mais lorsqu’elles tombaient en panne, deux questions se posaient (et se posent toujours ) :

Pourquoi la machine est cassée ?
Comment éviter que cela ne se reproduise ?

Pour répondre à ces questions, les logiciels se sont mis à produire des “traces”, ces traces ce sont les fichiers log. Les fichiers log, ce sont des fichiers texte contenant des informations techniques. En particulier, pour un serveur web, cela peut être l’adresse IP qui a initié la connexion, la page consultée, le navigateur de l’internaute, la taille de la requête, la méthode, etc.

L’analyse des fichiers logs permettait (et permet toujours) de savoir quand le logiciel a un problème, et bien souvent pourquoi.

Et puis un jour, quelqu’un a eu l’idée d’utiliser les fichiers logs pour avoir des statistiques sur la performance de son système (combien de temps il est en marche, combien de donnée ont été traitée, etc). C’est le tournant de l’histoire.

À partir de là une autre personne s’est dit que puisque dans les fichiers logs il y a la page consultée, la date, et un moyen relativement fiable de déterminer l’unicité d’un utilisateur (l’adresse IP), alors pourquoi ne pas réaliser les mêmes statistiques pour savoir quelles sont les pages qui sont le plus consultées ? Partant d’un bon sentiment, et souhaitant éviter de produire du contenu inutile, l’idée a plu à la fois au techniciens et aux commerciaux. Surtout aux commerciaux.

Vers la fin des années 90, la couverture ADSL du grand public a permis à Internet d’exploser en audience. Et les fichiers logs sont devenus insuffisants. En effet, comment savoir avec fiabilité le temps passé par l’utilisateur sur la page ? Comment gérer le cas des ordinateurs partagés (cybercafés, bibliothèques…) qui partagent la même IP ? Comment partager des données pour effectuer le suivi des utilisateurs sur plusieurs sites en même temps ?

Les navigateurs Web commençant à s’harmoniser en terme de technologie et de fonctionnalités (en particulier en terme de support du Javascript), c’est à ce moment là que les systèmes basé sur les cookies ont pu tirer leur épingle du jeu.

L’ère des cookies

Source de l’image

Mais avant tout, quelques définitions :

Un navigateur web, c’est le logiciel qui vous permet “d’aller sur internet” : c’est celui que vous utilisez quand vous lisez ces lignes.
Le Javascript est un langage de programmation sur le Web, il est exécuté après le chargement de la page par le navigateur, et permet donc une interaction riche avec l’utilisateur.
Les cookies sont des fichiers de données au format texte. Ce sont des données que le navigateur stocke à la demande de programmes Javascript (ou autres), et qui sont réutilisées par la page que vous consultez ensuite.

Les avantages des cookies sont multiples par rapport aux fichiers log :

Le cookie est manipulé à la fois par Javacript et par les langages plus lourds côté serveur, ce qui permet une portabilité de l’information contenu dans le cookie sur de nombreux langages et “univers” de programmation différents.
Le cookie est persistant : il ne se réinitialise pas quand on change de page, et on peut donc stocker des données dans la durée, de manière fiable, et avec une relative confiance dans leur contenu.
Le cookie peut être partagé ! En effet, on peut intégrer un cookie tiers dans une page, ce qui signifie que la donnée portée par un cookie peut appartenir à un autre site : le partage de données est possible !

Avec enthousiasme, les commerciaux et les techniciens ont commencé à intégrer des systèmes de suivi d’audience basés sur les cookies. Après tout, rien de très différent de ce qui existait déjà avec les fichiers logs, juste des statistiques.

Les statistiques ont pu gagner en pertinence et en volume de données. On pouvait alors savoir précisément d’où l’utilisateur venait, quelle était la page sur laquelle il quittait le site, quel était son chemin dans ses décisions d’achat. De simple statistiques de “hit” sur les pages se sont transformées petit à petit en suivi et traçage des comportements de l’internaute.

Et c’est là le problème. Il s’agit d’une analyse d’audience :

Active
Indolore
Fortement invasive : TOUT ce que vous faites sur la page est susceptible d’être enregistré
Persistante : le cookie est persistant
Partagée : le cookie peut être partagé
En temps réel : l’analyse peut se faire via un mécanisme de collecte en temps réel

Lorsque plusieurs sites se mettent à échanger les informations de suivi, cela constitue un véritable “réseau de suivi” qui surveille vos moindres gestes… Mais pour quoi faire, dans le fond ?

Et l’on exploita les données…

Source de l’image

Au début les commerciaux ont demandé à collecter le plus de données possible, « en attendant de savoir comment on allait les utiliser », et ce n’est que très récemment, avec le Cloud Computing et les systèmes de Data Mining et Big Data que cela a commencé à prendre tout son sens.

Les systèmes Big Data, comme leur nom l’indique, sont ds systèmes capables de calculer des quantités astronomiques de données, de quoi pouvoir gérer l’immense volume de données collectés.
Le Cloud Computing a permis de se défaire du surcoût lié à l’exploitation de machines assez puissantes pour traiter des Big Data : il suffit de louer des machines surpuissantes en salle serveur pour une heure ou deux, juste le temps qu’il faut.
Enfin, le Data Mining, comme son nom l’indique, c’est une discipline qui vise l’extraction de données pertinentes à l’intérieur d’une immense masse de données. Juste ce dont on a besoin pour la suite.

N’oublions pas que le but principal des commerciaux, c’est de vendre. Pour les aider à vendre, ils trouvèrent les statistiques plaisantes. Ils pouvaient savoir quels étaient les produits qui marchaient le mieux, ils s’amusaient à « découper le marché en segments », pour pouvoir cibler tel ou tel profil de consommateur, mais ils manquaient de données. Ils n’avaient pas la possibilité de cerner un utilisateur dans leur segment dès l’entrée du magasin, ils ne pouvaient pas vérifier que le produit qu’ils avaient placé sur un segment était adapté avant la fin de la période commerciale. Ils étaient pratiquement aveugles, et se basaient en grande partie sur leur expérience personnelle.

Mais les données issues du suivi ont changé la donne. À présent, chaque achat, chaque mouvement, chaque action de l’utilisateur sur leur boutique en ligne pouvait être suivie, analysée, comprise pour en extraire le profil de l’utilisateur, ses centres d’intérêt, et ce qu’il était susceptible d’acheter. Mieux : lorsque l’utilisateur quittait la boutique puis revenait, on pouvait à présent lui proposer des produits qui lui plairont, en fonction de son parcours précédent dans le magasin. Ou comment avoir la proximité du commerçant de quartier, qui connaît tous ses clients, avec une boutique à plusieurs milliers d’utilisateurs.

La question n’était à présent plus de savoir quels étaient les produits qui marchaient, mais de savoir les produits qui allaient marcher.

Alors on a commencé à voir fleurir les publicités ciblées. Vous savez, cette publicité qui vous suit partout. Vous consultez sur une marque de chocolat dans votre magasin favori, puis vous quittez le magasin. Vous allez surfer sur Internet, et la publicité pour le chocolat que vous avez regardé apparaît sur le côté. Vous allez regarder une vidéo, et le chocolat revient dans les publicités de la vidéo. Vous consultez la météo du lendemain, et le chocolat vous nargue encore dans son coin, vous murmurant « tu n’as pas fini tout à l’heure, achète moi s’il te plaît ».

Et puis, forcément, au bout d’un moment, les utilisateurs sont devenus méfiants. Ils se sont mis à vider leurs cookies à la fermeture de leur navigateur. Ils se sont mis à activer des bloqueurs de publicités. Ils se sont mis à se défendre, et à demander un contrôle de leurs données. La CNIL a commencé à se réveiller et exiger une information des utilisateurs. Mais le commercial avait plus d’un tour dans son sac.

De l’invisible au consenti

Source de l’image

Cela embêtait bien les commerciaux que les utilisateurs se mettent à bloquer leurs mécanismes de traçage. Mais à ce moment là est apparu un nouveau phénomène qui allait tout changer : les réseaux sociaux.

On cite souvent Facebook en premier, mais les réseaux sociaux sont plus anciens que ça. Facebook est par contre le premier à avoir sans scrupules et aux yeux de tous commencé à exploiter les données que les internautes produisaient sur son réseau.

Le principe est simple :

Vous vous inscrivez sur le réseau social, vous indiquez vos information personnelles. Ces informations ont une certaine valeur, mais assez faible dans le fond : il y a votre âge, votre catégorie professionnelle, votre sexe, qui sont des informations utiles.
Vous commencez à réaliser des interactions avec d’autres utilisateurs du réseau, vous discutez avec certains et pas avec d’autres, vous créez des affinités.
Vous cliquez de temps en temps sur une publicité ou sur un lien externe, seulement ceux qui vous intéressent.
À partir de ce que vous avez cliqué, de ce que les gens avec qui vous avez interagit on cliqué, en fonction de ce qu’ils sont et de ce qu’ils font, le réseau peut vous proposer des contenus que vous trouverez pertinents, et que vous êtes susceptible d’acheter.

C’est très fort parce que :

La dimension sociale d’un achat est mesurée : vous n’achetez pas seulement parce que vous êtes un consommateur, vous achetez au sein d’un groupe : connaître le groupe c’est connaître vos attentes.
Vous y consentez passivement lors de votre entrée dans le réseau : vous cochez une petite case qui dit que votre activité peut être enregistrée, et c’est tout. Le réseau peut à présent exploiter son infrastructure pour proposer à la fois un service agréable à l’utilisateur (les interactions avec les gens), mais aussi un service commercial aux annonceurs (les interactions avec les produits).

Toujours plus proche de vous

On arrête pas le progrès. Après avoir acquis les segments temporels et sociaux, les commerciaux ont commencé à regarder avec intérêt le développement des smartphones. Ils ont même contribué de manière active à leur essor. Pourquoi ? Pour le segment de position.

Les smartphones sont à présent tous géo-localisables. Après tout, ce n’est qu’une donnée de plus à exploiter. En utilisant votre téléphone pour faire une recherche d’itinéraire, quoi de plus simple pour le site que de vous proposer les commerçants partenaires qui se trouvent sur votre chemin ? Vous avez des amis sur les réseaux sociaux, ils sont proches de vous, et vous vous rendez à un événement marketing ? Invitez les !

En intégrant un suivi des internautes jusqu’à un objet personnel, le plus intime de tous les objets, celui qu’on ne prête pas et qu’on garde toujours sur soi, les commerciaux ont à présent réussi à définitivement intégrer l’aspect individuel du ciblage de la publicité, la position géographique, et la dimension sociale.

Quelle est la morale ?

Finalement, qu’est-ce que tout cela nous apprend ?

~~Il faut brûler les commerciaux~~
~~On vit dans un monde de merde~~
Pourquoi je me laisse faire ?

J’ai souvent l’impression que les internautes ont arrêté de se battre après leur découverte des cookies. Pensant que c’était suffisant, et que le reste était lié par cette pièce maîtresse, comme une clef de voûte de la mesure d’audience.

C’est faux, comme nous venons de le voir. C’est d’autant plus faux à mesure qu’arrivent sur le marché les objets connectés, qui interagissent toujours plus avec les réseaux sociaux et les régies publicitaires.

Alors, comment faire changer les choses ? Exigez.

Exigez de pouvoir désactiver les fonctionnalités connectées, tout en continuant à utiliser votre matériel normalement. Exigez que les informations que vous fournissez soient correctement utilisées. Exigez de pouvoir utiliser un service même sans donner vos informations. Exigez d’avoir le contrôle de votre matériel et de vos logiciels. Refusez d’acheter un produit qui ne correspond pas à votre vision de la vie privée. Refusez d’installer une application qui accède à vos données si elle n’en a pas besoin pour faire ce que vous lui demandez.

Le jour où les consommateurs exigeront les produits qui leur donnent le contrôle, plutôt que des produits avilissants, les commerciaux changeront leur manière de les concevoir pour pouvoir continuer à les vendre.

Personnellement, chaque jour les internautes me désespèrent encore plus…

Voir aussi

How Cookies works

Comment avoir un haut ratio avec bittorrent (presque) sans tricher

Mathieu — Mon, 14 Oct 2013 18:55:00 +0200

Ce billet est sponsorisé par l'organisme national de promotion des usages responsables sur les réseaux a-centrés.

Non, Bittorrent n'est pas mort, et le peer to peer c'est même l'avenir pour les nouveaux modes de distribution. En attendant que les maisons de disque s'en rendent compte, prenons de l'avance et expliquons 2-3 bricoles.

Sur la plupart des trackers privés, le ratio est un élément important, voire critique. Sur ces sites de téléchargement, si votre ratio up/down est inférieur à un certain nombre (à priori aux alentours de 1), votre compte est bloqué.

Mais alors, comment s'assurer un ratio confortable ? Quels sont les secrets de ceux qui réussissent et de ceux qui échouent ? Voici quelques astuces.

Nota Bene : Vous avez besoin d'un navigateur moderne pour afficher les formules dans ce article.

Définitions

Le peer to peer est le nom du mécanisme par lequel vous obtenez le fichier : en échangeant des fragments de fichier avec les autres utilisateurs du réseau.

Bittorrent est un protocole de peer to peer. Celui-ci fonctionne avec un serveur central, nommé le Tracker, et un groupe d'utilisateurs que l'on appelle les peers.

Le ratio est un indicateur qui sert de référence pour définir les "bon" utilisateurs d'un réseau peer to peer des "mauvais". La plupart des trackers bannissent les utilisateurs ayant un ratio trop faible.

Le tracker est le serveur central de l'essaim. Le tracker contient les signatures des fichiers et la liste des peers qui en possèdent au moins un fragment du fichier. Ce serveur sert à la mise en relation des peers pour amorcer leurs échanges dans l'essaim.

Un essaim est un ensemble de peers qui échangent des fragments.

Une signature de fichier, c'est une somme de contrôle : c'est le résultat d'un opération arithmétique qui produira toujours le même résultat si on lui donne le même fichier en entrée. Si le fichier d'entrée est différent, même à 1 bit de différence, la somme de contrôle sera différente, et donc on pourra conclure que le fichier est corrompu (incomplet ou incorrect). Ce mécanisme sert donc à vérifier l'intégrité du fichier reçu, ou des fragments.

Un fragment est une portion du fichier à partager, en général tous les fragments ont une taille fixe, et un certain nombre de fragments est donc créé pour chaque fichier à partager, suivant la taille du fichier.

Les trackers, les torrents, le ratio.

Bittorrent est un mécanisme de partage de fichiers par peer to peer. Je dis bien de partage, pas de téléchargement, car le mot est important. Le concept c'est que vous téléchargez de fragments de fichiers depuis un ensemble d'utilisateur qui possèdent le fichier complet, et que vous les assemblez pour obtenir à votre tour le fichier complet. Ensuite, vous pouvez fournir des fragments de fichier aux autres utilisateurs qui n'ont pas encore le fichier complet. Ça nécessite qu'il y ai au moins une personne dans l'essaim qui possède le fichier complet, et qu'il le partage suffisamment longtemps pour distribuer tous ses fragments au moins une fois.

Lorsque vous téléchargez un fichier, vous êtes en position de leecher, c'est à dire que vous consommez des ressources dans l'essaim. Cela a pour effet de faire monter votre compteur de down (comme download : téléchargement en anglais).

Lorsque vous partagez des fragments de fichier, vous êtes ce que l'on appelle un seeder, c'est à dire que vous fournissez des ressources dans l'essaim. Cela a pour effet de faire monter votre compteur de up (comme upload : téléversement en anglais).

Le ratio est tout simplement le résultat du calcul `u/d` où `d` est le total en down et `u` le total en up. Ainsi, un ratio supérieur à 1 signifiera que vous avez plus fourni que consommé, et à l'inverse un ratio inférieur à 1 signifiera que vous avez plus consommé que fourni.

La plupart des trackers privés nécessitent de conserver un ratio de 1, pour éviter que les fichiers du réseau ne disparaissent au bout de quelques heures, et que les utilisateurs continuent de fournir les fragments après leur téléchargement, pour faire vivre l'essaim.

Alors, comment s'assurer un ratio supérieur à 1 ? Comment obtenir un ratio de 2 voire plus sans efforts ? Comment éviter de sombrer dans une mauvaise passe ?

Le principe

Tout le but du jeu va être d'augmenter son ratio sans tricher. Il faut voir ça comme un jeu d'achat / vente ou de bonus/malus. Chaque fois que vous téléchargez (que vous faites monter votre compteur down) cela représente un investissement ou un achat : vous consommez sur votre compteur et vous allez devoir "rendre" en "vendant" du up pour conserver votre avance. Vous devrez donc rentabiliser votre mise soit en fournissant à d'autres le torrent que vous venez de télécharger, soit en apportant du capital d'une autre manière. Dans tous les cas, ce que vous avez payé, vous ne l'avez plus.

Allez, voici la méthode.

Votre assurance : l'anticipation

La plupart des utilisateurs qui tombent en dessous de 1 sont des utilisateurs qui l'ont quand même un peu cherché. La première des choses à faire quand on investit c'est l'anticipation. En général vous avez lorsque vous arrivez sur un tracker, on vous "offre" une certain quantité en up (capital de départ) qui va vous permettre de commencer à télécharger. Choisissez bien vos premiers téléchargements, le but va être de faire fructifier cette somme de départ, et d'en obtenir une véritable plus-value.

Ainsi lorsque vous téléchargez et que votre ratio est faible, ou que vous venez de commencer, surveillez toujours vos compteurs up/down, et calculez systématiquement votre nouveau ratio après le téléchargement. Le calcul est facile à faire : `u / (d + P_f)` avec `d` le total down, `u` le total up et `P_f` le poids du fichier transféré. Vous verrez ainsi rapidement si vous allez tomber dans le rouge après le téléchargement ou pas.

Si votre ratio après le téléchargement se rapproche de la ligne rouge et que vous n’êtes pas sûr de faire une plus-value intéressante, abstenez vous, et gardez ce fichier pour plus tard.

Les règles pour une plus-value intéressante

Il y a deux paramètres qui vont influencer la plus-value que vous ferez sur le torrent : sa popularité, et le nombre de seeders.

La popularité d'un torrent est le nombre de leechers potentiels qui vont vouloir obtenir le torrent (mais qui ne sont pas encore là).

Le nombre de seeders, vous l'avez compris, c'est le nombre de peers qui vont être en mesure de fournir un fichier complet.

Plus le torrent est populaire, plus il est intéressant. Cela veut dire que une fois le téléchargement terminé, vous allez avoir une quantité conséquente de peers qui vont vous demander des fragments, et donc que vous allez faire monter très rapidement votre compteur de up.

Par contre, plus le torrent a de seeders, moins il est intéressant, parce que cela veut dire que vous devrez partager la distribution avec les autres peers. Pire, dans la réalité nous ne sommes pas tous des peers égaux, et certains peers ont des vitesses pour fournir du contenu beaucoup plus importante que la vôtre. Ainsi, plus il y a de peers sur un torrent, plus il y a de chance qu'il y en ai un qui ai une vitesse pour fournir du contenu très importante, et qu'il vous "vole" les leechers qui auraient pu vous demander des pièces, parce qu'il arrive à satisfaire la demande du leecher plus rapidement (la loi de l'offre et la demande).

Comment calculer le potentiel du torrent

Il y a une astuce simple pour trouver les torrents qui vous assureront une plus-value maximale, nous allons faire un modèle. Un modèle en mathématiques est une représentation simplifiée de la réalité issue d'hypothèses de départ. Les modèles sont utilisés en général à des fins de prédiction (on appelle ça une projection).

On va supposer que chaque seeder fourni à la même vitesse la même quantité de contenu. Le fichier est donc fourni en parts égales par tous les leechers. S'il y a 3 leechers par exemple, chacun donnera 1/3 du fichier.

On va supposer que l'on n'a qu'un leecher à la fois, et qu'à la fin du téléchargement, chaque leecher devient seeder pour une durée illimitée.

Avec ce modèle, après que vous ayez acquis le fichier (il faut bien le télécharger), votre part de up potentiel sur le fichier sera `P_f / (S_i + 1)` avec `P_f` le poids du fichier téléchargé, et `S_i` le nombre de seeders initial. Oui, "+1" parce que à présent vous faites partie de seeders vous aussi.

À présent, on peut faire des calculs. Dans ce modèle, le premier leecher qui viendra après votre téléchargement obtiendra de votre part `P_f / (S_i + 1)`

Le suivant obtiendra `P_f / (S_i + 2)` puisque le leecher de tout à l'heure est devenu seeder.

Le suivant `P_f / (S_i + 3)`

Etc.

Ainsi vous aurez pu envoyer au total : `P_f / (S_i + 1) + P_f / (S_i + 2) + P_f / (S_i + 3) + ...`

Si on factorise, on obtient la formule suivante : `P_f * ( 1/(S_i + 1) + 1/(S_i + 2) + 1/(S_i + 3) + ...) = P_f * sum_(k=1)^oo(1/ ( S_i + k ))`

Vous l'aurez compris, c'est les premiers coups qui comptent. Avec un tel modèle, on peut se rendre rapidement compte de l'intérêt pour vous qu'il y ai très peu de seeder sur le fichier (passer de 1/2 à 1/3 c'est une perte énorme), et l'intérêt d'avoir un nombre de seeders initial faible, pour éviter que tout le fichier soit dilué dans l'essaim et pour que vous restiez un fournisseur important.

Attention, le modèle a ses limites :

en pratique il est très rare qu'un leecher soit seul, en général il y en a plusieurs dans l'essaim, et ces leechers peuvent eux aussi fournir des fragments au cours de leur téléchargement, augmentant ainsi "artificiellement" le nombre de seeders, le modèle fournit toujours un résultat plus optimiste que dans la réalité.
Le nombre de leechers potentiels sur un torrent, c'est toujours vous qui le déterminez, c'est un peu comme prendre un pari : ça marche pas à tous les coups.

Attention : la taille du tuyau

Attention également à la capacité de votre bande passante en upload : on peut être tenté, quand on commence à avoir compris le truc, à miser sur plusieurs torrents en même temps, jusqu'à dépasser sa capacité d'envoi. Dans ce cas, vous avez travaillé en pure perte, n'oubliez pas que votre bande passante en upload est limitée, misez sur un torrent à la fois, et montez en volume petit à petit, il ne sert à rien de devenir un super-seeder si vous n'êtes pas capable d'assurer le partage correct des fichiers que vous avez déjà.

De plus, le mécanisme des torrents a tendance à privilégier les peers qui ont des partages rapides, essayez de rester de ceux là.

Meilleur moyen de s'assurer une plus-value maximale : fournir du contenu "gratuit"

Tous les décideurs vous le diront, quand on peut faire payer pour quelque chose qu'on a obtenu gratuitement, c'est intéressant quoi qu'il arrive !

Sur un tracker peer to peer, quels sont les contenus que l'ont peut obtenir gratuitement ? C'est ceux que l'on n'a pas "payés" sur ce tracker !

Ainsi, vous pouvez récupérer du contenu depuis d'autres sources : créations personnelles, agrégation de contenu, compilations, et les proposer sur le tracker, vous obtiendrez tout le bénéfice du up si votre contenu a du succès, et vous n'aurez pas dépensé une seule goutte de down pour l'obtenir.

Attention ceci dit, cela nécessite de bien lire les règles de publication du tracker, de soigner la publication, de ne pas proposer n'importe quoi et d'avoir un peu l'intuition de ce qui va marcher ou non (si vous vous faites basher après votre publication, vous pourriez le vivre assez mal).

Jouer sur les tendances

Attention, ça c'est un secret bien gardé. Comme dans tout marché, il y a des tendances. Seuls les uploadeurs expérimentés les connaissent, mais c'est une loi universelle en marketing : des produits se vendent mieux à certains périodes qu'à d'autres.

Alors, Quelles sont les tendances d'un tracker torrent ?

Déjà il y a la tendance globale, vous pourriez avoir déjà remarqué que vos uploads ralentissaient en veille de week-end, ou étaient rapide en fin de semaine et débuts de vacances scolaires.

Mais la tendance la plus intéressante est toujours celle qui s'obtient de manière locale, c'est à dire celle qui est lié à la combinaison "au bon endroit au bon moment". Ainsi, les téléchargements de contenus qui viennent d’être publié ailleurs font toujours un bond. Si un contenu fait l'objet d'une publicité quelconque, il obtiendra immédiatement un intérêt particulier qui se fera sentir.

Tout le but du jeu est d'arriver à deviner ces tendances pour récupérer le fichier avant tout le monde, et faire une plus-value maximale sur tous ceux qui voudront l'obtenir après le coup de buzz.

Vous pouvez aussi créer la tendance : par exemple poser naïvement sur le forum une question à propos des cinq films (libres de droits) cultes de tous les temps, et être prêt à fournir le contenu aux gens qui auront envie de le télécharger après avoir lu les réponses des autres membres sur le forum (mais il faut avoir déjà une idée de la réponse, et avoir préparé les contenus).

Une seule règle d'or : la durée

Dans une économie en croissance, vous ne pouvez pas perdre d'argent si vous misez sur le long terme.

Si le tracker est sain et qu'il a de nombreux utilisateurs, il y aura forcément un moment où vous récupérerez votre mise, les seeders originaux vont abandonner le fichier une fois leur plus-value faite, et vous vous retrouverez avec un fichier complet, sur un torrent qui est encore intéressant, et avec peu de seeders. Il suffit d'attendre.

Bien sûr ce n'est vrai que pour les fichiers "au long cours", c'est à dire ceux qui conservent une attractivité après les premiers mois de publication (oubliez les webséries).

L’essoufflement du modèle ?

Tiens, et si on parlait macro-économie ?

Supposons encore une fois que le ce mécanisme soit un système monétaire. Les "down" c'est ce que vous dépensez, les "up" ce que vous vendez. Avec un ratio de 1, vous êtes donc à 0 sur votre compte, inférieur à 1 vous êtes à découvert, et supérieur à 1 vous avez de l'argent, donc du pouvoir d'achat.

On l'a vu, tout le monde cherche à obtenir un ratio important. Mais supposons que tout le monde ai un ratio proche de 1, que ce ratio soit la limite avant bannissement du compte, et qu'un nouveau fichier arrive : plus personne ne voudra le télécharger ! Les échanges ralentiront au milieu de l'essaim ! Des fichiers resteront sans leechers ! Plus aucun membre ne pourra remonter son ratio ! Effondrement ! Crise ! Récession ! Mort du tracker !

Situation utopique ? Pas tellement, il suffit que la taille des fichiers proposés dépasse la capacité de téléchargement (le "up") des peers, et c'est perdu, le réseau est mort (schéma de crise : plus personne ne consomme).

Alors, comment les trackers font pour éviter l'asphyxie ? Il y a quatre techniques :

Les nouveau arrivant ont un quota de "up" qui leur est fourni, ça revient à "remettre de l'argent dans le système", et leur permettre de consommer, et dépenser leur "up" chez les autres. Les membres bannis peuvent être autorisés à revenir, et ainsi obtenir à nouveau du "up", et le réinjecter dans le système en téléchargeant.
Certains torrents ou certains événements donnent lieu à un freeleech, ça revient à télécharger sans que cela compte dans le "down", mais que le "up" compte. Pareil, cela revient à fournir gratuitement du pouvoir d'achat, remettre de l'argent dans le système, sans contrepartie. C'est équivalent à acheter quelque chose sans le payer, mais que le propriétaire de départ soit quand même payé. Vous pouvez alors le revendre et être payé, sans que la personne à qui vous le vendez ne verse un centime, c'est une sorte de subvention permanente.
Certains événements donnent lieu à des "cadeaux" en "up" : on donne à tous les membres du pouvoir d'achat, comme par magie, il vont donc le consommer avec frénésie, parce que cela a lieu en général au moment où les gens en ont besoin (noël, vacances, les tendances quoi). Vive la planche à billets.
Il arrive que certains trackers vous fournissent du "up" quand vous leur donnez des monnaies sonnantes et trébuchantes. Cela revient à remettre de l'argent dans le circuit en apportant de la richesse par un biais transverse qui n'agit pas en temps normal (ouverture des vannes dans une banque centrale).

En conclusion

Voilà, j'espère vous avoir montré par quelques principes simples comment briller sur les réseaux peer-to-peer.

J'ajoute que mes divagations monétaires ont un sens, elles ont pour but de vous aider à prendre conscience du fait que BitTorrent est un système basé sur l'échange et que dans un système basé sur l'échange, il faut d'abord être capable de fournir pour pouvoir recevoir. Rien ne sert de courir, il faut seeder à point.

Le monitoring sous Debian avec Nagios et Munin (Puppet en guest star) : de A à Z - Partie 5 : NSCA

Mathieu — Sun, 13 Oct 2013 16:04:00 +0200

Voir l’ensemble des articles de la série — Voir l’article précédent : Munin.

Cet article est le dernier de la série.

Dans l’article précédent, nous avons vu comment configurer Munin pour qu’il collecte des données et affiche ses graphes. Il nous reste à présent à configurer la communication entre Munin et Nagios, grâce à l’agent NSCA.

Introduction

Tests passifs, tests actifs

Nagios distingue deux type de tests à effectuer sur les hôtes, par le biais de ses déclarations de services : les tests actifs et les tests passifs.

Les tests actifs sont les tests réalisés par Nagios via un de ses plugins : ça peut être le test d’un port ou le contrôle de la réponse d’un service. Ces tests sont synchrones (effectués à intervalle fixe).
Les tests passifs sont les tests dont les résultats sont reportés à Nagios par d’autres programmes : là ça sera NSCA. Ces tests sont asynchrones (effectués “quand on peut”, pas forcément régulièrement).

NSCA

NSCA est littéralement « Nagios Service Check Acceptor ». C’est un démon qui tourne en arrière plan, et qui va recevoir les résultats des tests passifs, pour le retransmettre à Nagios.

Pour plus de simplicité, NSCA sera installé sur la même machine que le serveur Maître de Nagios.

Munin <=> NSCA

Le serveur maître de Munin va communiquer à NSCA les résultats des tests grâce à la commande send_nsca, utilisant le protocole NSCA.

Pour encore plus de simplicité, nous allons supposer que le serveur maître de Munin et le serveur NSCA (et donc Nagios aussi) se trouvent sur la même machine (comme ça, pas besoin de chiffrer les communications entre Munin et NSCA).

NSCA <=> Nagios

NSCA va communiquer avec Nagios via un tube nommé, c’est à dire un fichier dans lequel il va écrire, et qui va être lu par Nagios à intervalle régulier.

On peut faire porter ce tube par une socket pour réaliser une installation de NCA et Nagios sur deux machines différentes, mais ce n’est pas le sujet de cet article.

Installation et configuration de NSCA

Installation

NSCA se trouve dans les dépôts : sudo apt-get install nsca

Configuration

La configuration de NSCA se trouve dans /etc/nsca.cfg. Voici les valeurs à retenir :

#Ne jouez pas à changer ça pid_file=/var/run/nsca.pid # Notre master Munin se trouve sur la même machine, donc on bind sur 127.0.0.1 et ça suffit server_address=127.0.0.1 # Il est important que cet utilisateur puisse écrire dans le tube nommé pour communiquer avec Nagios ! nsca_user=nagios # Ce fichier spécial devra aussi être mentionné dans la configuration de Nagios, et le nsca_user doit pouvoir y écrire command_file=/var/lib/nagios3/rw/nagios.cmd

Ouvrez le fichier /etc/init.d/nsca et vérifiez que le PIDFILE est le même que celui de la configuration :

PIDFILE="/var/run/nsca.pid"

Configuration de Munin

Ouvrez le fichier /etc/munin/munin.conf.

Normalement, vus avez déjà configuré un “contact” pour être avertit en cas de défaillance d’un service contrôlé par Munin. Nous allons à la suite en rajouter un second :

contact.nagios.command /usr/sbin/send_nsca -H localhost contact.nagios.always_send ok warning critical contact.nagios.max_messages 1

Petite information qui vous fera gagner une journée de travail : max_messages doit être à 1 sous Debian 7. Ceci parce que le NSCA des dépôts a été mis jour, et est devenu incompatible avec la version du protocole NSCA implémentée par Munin. On peut bidouiller NSCA pour corriger ça, mais la solution de contournement la plus simple est de n’envoyer qu’un message à la fois à NSCA.

Ici Munin enverra les résultats “OK”, “Warning” et “Critical” de ses module. Nous allons également faire en sorte qu’un Munin muet déclenche une erreur UNKNOWN chez Nagios, pour s’assurer que le “OK” correspond bien à un test “OK” et non à l’absence de “Warning” et de “Critical”.

Ok, on triche un peu. En fait, les tests de Munin sont synchrones. On a donc un mécanisme synchrone (Munin) qui va envoyer de manière synchrone les résultats au mécanisme asynchrone de collecte (NSCA). L’aspect synchrone va nous permettre de détecter le moment où on aurait dût recevoir un résultat, et alerter si ce n’a pas été le cas.

Configuration de Nagios

Communication avec NSCA

Ouvrez le fichier de configuration /etc/nagios3/nagios.cfg et vérifiez que la ligne suivante est bien présente et dé-commentée :

command_file=/var/lib/nagios3/rw/nagios.cmd

Les services

Si vous avez déjà redémarré les services après chaque modification de la configuration, vous pourrez voir dans les logs de Nagios les erreurs suivantes :

[1381670602] Warning: Passive check result was received for service 'some service' on host 'hostname.ext', but the service could not be found!

La bonne nouvelle c’est que Nagios reçoit les notifications de NSCA !

La mauvaise c’est qu’il ne peut pas le lier à un service et à un hôte, parce qu’ils ne sont tout simplement pas déclarés. Il va nous falloir déclarer un service Nagios pour chaque service Munin que nous lui transmettons, sinon celui-ci ne sera pas capable de le traiter.

Créez le fichier /etc/nagios3/conf.d/services/munin-services.cfg et placez à l’intérieur la configuration suivante :

# generic service template definition define service{ name generic-munin-service ; The 'name' of this service template use generic-service check_command return-unknown!"No Data from passive check" active_checks_enabled 0 ; Active service checks are disabled check_freshness 1 freshness_threshold 360 flap_detection_options n max_check_attempts 2 register 0 ; DONT REGISTER THIS DEFINITION - ITS NOT A REAL SERVICE, JUST A TEMPLATE! ;first_notification_delay 6 ; Delay first notification for false positives (will execute 2 checks : munin sends 1 check every 5 minutes) } define service { hostgroup_name munin service_description Disk latency per device :: Average latency for /dev/sda use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { service_description Disk latency per device :: Average latency for /dev/sdb use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { hostgroup_name munin service_description Disk usage in percent use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { hostgroup_name munin service_description Inode usage in percent use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { hostgroup_name munin service_description File table usage use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { hostgroup_name munin service_description eth0 errors use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified } define service { hostgroup_name munin service_description Exim Mailqueue use generic-munin-service notification_interval 0 ; set > 0 if you want to be renotified }

Ce fichier est bien évidemment à compléter selon les plugins et les checks que vous avez activé dans Munin. Le service_description est le nom complet du service dans Munin.

La configuration du template générique nous assure qu’une erreur “UNKNOWN : No data from passive check” sera retournée en cas d’absence de résultat après le délai du “freshness_threshold”, avec 2 essais avant d’alerter du problème.

Les groupes d’hôtes

Les plus attentifs d’entre-vous ont remarqué la présence d’un hostgroup dans la configuration, mais nous ne l’avons pas encore déclaré. Allons-y, rajoutez dans le fichier /etc/nagios3/conf.d/groups.cfg :

# Hostgroup for Munin define hostgroup { hostgroup_name munin alias Munin reporting clients }

Les hôtes

Maintenant qu’on a le hostgroup, il ne reste plus qu’à modifier vos fichiers /etc/nagios3/conf.d/hosts/*.cfg pour rajouter le hostgroup sur les hôtes sur lesquels munin-node est installé.

Débuggage

En principe, après avoir redémarré tous les services, vous devriez recevoir assez vite les notifications de NSCA et voir passer vos indicateurs du gris vers le vert dans Nagios.

Si ce n’est pas le cas et que ces derniers passent au orange, c’est qu’il y a un problème de communication entre Nagios et Munin. Mon problème principal a été le non démarrage de NSCA au démarrage de la machine, pour de histoires de PID que le script de démarrage n’arrivait à écrire ou à supprimer.

Il arrive aussi que le tube nommé soit inaccessible en écriture à l’utilisateur qui lance NSCA, vérifiez bien que l’utilisateur nagios est celui qui fait tourner à la fois Nagios et NSCA.

Enfin, pour vérifier que le problème ne vient pas d’une mauvaise configuration de Nagios, faites un envoi de données “manuellement” avec la commande send_nsca :

echo -e "monhote.ext\tNom complet du service Munin\t1\t0\n\n" | /usr/sbin/send_nsca -H localhost

Pour conclure

En conclusion, nous avons terminé notre installation de Munin, Nagios, et NSCA ! Munin communique à présent ses alertes à Nagios, et Nagios est capable d’alerter si ces alertes ne sont pas remontées. Le reste est dans les billets précédents !

N’hésitez pas à me faire part dans les commentaires des problèmes que vous pourriez rencontrer en déroulant cette suite d’articles, ou à me corriger si vous constatez des erreurs dans la série d’article.

Voir l’ensemble des articles de la série.

Configure Munin graphs with Nginx, FastCGI, and Debian 7

Mathieu — Sun, 25 Aug 2013 11:40:00 +0200

Setting up Munin with Nginx can be a little harsh. Here is the ready-to-go solution for Debian Wheezy.

I will make the assumption that you have already configured Munin and Munin-node. I also assume that you didn’t change the CGI and CRON params in the Munin default configuration provided by the Debian package.

Abstract

In the default configuration, the HTML files for Munin graphes are generated by Cron, and are stored in /var/cache/munin/www/
To display Munin graphs, you have to call the munin-cgi-graph program located in /usr/lib/munin/cgi/
To display Munin extra HTML, you have to call the munin-cgi-html program located in /usr/lib/munin/cgi/
The configuration I use is an adapted version of Apache configuration delivered with the Debian package at /etc/munin/apache2.conf.
Unlike Apache, Nginx does not spawn CGI processes, you will have to make a startup script to create the appropriate sockets.
The spawned sockets run with the munin user, you will have to chown some logfiles and change logrotate configuration.

Installation

Let’s start with a basic Ningx installation : apt-get install nginx

Next, add fcgiwrap, the Ningx CGI wrapper : apt-get install fcgiwrap. Note that in the dependencies, you have spawn-fcgi. we will use it to create the CGI sockets.

The CGI sockets

To spawn the munin-cgi-graph and munin-cgi-html processes, create a startup script at /etc/init.d/munin-fastcgi :

#! /bin/sh ### BEGIN INIT INFO # Provides: munin-fastcgi # Required-Start: $remote_fs $network # Required-Stop: $remote_fs $network # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: starts munin-fastcgi # Description: Spawn Munin FCGI sockets for Web access ### END INIT INFO # # munin-fastcgi Startup script for Munin CGI services # # chkconfig: - 84 15 # description: Loading Munin CGI services using spawn-cgi # HTML files and CGI. # # Author: Ryan Norbauer <ryan.norbauer@gmail.com> # Modified: Geoffrey Grosenbach http://topfunky.com # Modified: David Krmpotic http://davidhq.com # Modified: Kun Xi http://kunxi.org # Modified: http://drumcoder.co.uk/ # Modified: http://uname.pingveno.net/ DAEMON=/usr/bin/spawn-fcgi FCGI_GRAPH_SOCK=/var/run/munin/fastcgi-munin-graph.sock FCGI_HTML_SOCK=/var/run/munin/fastcgi-munin-html.sock WWW_USER=www-data FCGI_USER=munin FCGI_GROUP=munin FCGI_SPAWN_GRAPH=/usr/lib/munin/cgi/munin-cgi-graph FCGI_SPAWN_HTML=/usr/lib/munin/cgi/munin-cgi-html PIDFILE_GRAPH=/var/run/munin/fastcgi-munin-graph.pid PIDFILE_HTML=/var/run/munin/fastcgi-munin-html.pid DESC="Munin FCGI for Graph an HTML" # Gracefully exit if the package has been removed. test -x $DAEMON || exit 0 test -x $FCGI_SPAWN_GRAPH || exit 0 test -x $FCGI_SPAWN_HTML || exit 0 start() { $DAEMON -s $FCGI_GRAPH_SOCK -U $WWW_USER -u $FCGI_USER -g $FCGI_GROUP -P $PIDFILE_GRAPH $FCGI_SPAWN_GRAPH 2> /dev/null || echo "Graph Already running" $DAEMON -s $FCGI_HTML_SOCK -U $WWW_USER -u $FCGI_USER -g $FCGI_GROUP -P $PIDFILE_HTML $FCGI_SPAWN_HTML 2> /dev/null || echo "HTML Already running" } stop() { kill -QUIT `cat $PIDFILE_GRAPH` || echo "Graph not running" kill -QUIT `cat $PIDFILE_HTML` || echo "HTML Not running" } restart() { kill -HUP `cat $PIDFILE_GRAPH` || echo "Can't reload Graph" kill -HUP `cat $PIDFILE_HTML` || echo "Can't reload HTML" } case "$1" in start) echo "Starting $DESC: " start ;; stop) echo "Stopping $DESC: " stop ;; restart|reload) echo "Restarting $DESC: " stop # One second might not be time enough for a daemon to stop, # if this happens, d_start will fail (and dpkg will break if # the package is being upgraded). Change the timeout if needed # be, or change d_stop to have start-stop-daemon use --retry. # Notice that using --retry slows down the shutdown process somewhat. sleep 1 start ;; *) echo "Usage: $SCRIPTNAME {start|stop|restart|reload}" >&2 exit 3 ;; esac exit $?

Don’t forget to set it executable : chmod +x /etc/init.d/munin-fastcgi

Finally, add your startup script to runlevels : update-rc.d munin-fastcgi defaults

And start it : service munin-fastcgi start

Fix for log files

The log files are owned by www-data user. In our configuration, the CGI process is run by munin.

Change the owner of logfiles : chown munin /var/log/munin/munin-cgi-graph.log && chown munin /var/log/munin/munin-cgi-html.log

Change the logrotate configuration : open /etc/logrotate.d/munin and change create 640 www-data adm to create 640 munin adm for the two logfiles.

Nginx VirtualHost configuration

Create the following /etc/nginx/sites-available/munin :

server { #listen 80; ## listen for ipv4; this line is default and implied #listen [::]:80 default_server ipv6only=on; ## listen for ipv6 # Make site accessible from http://localhost/ server_name localhost; # Here, the whole vhost has auth requirements. # You can duplicate it to the graph and html locations if you have # something else that doesn't need auth. auth_basic "Private access"; auth_basic_user_file /etc/munin/munin_htpasswd; location /munin/ { alias /var/cache/munin/www/; # not authenticated => no rewrite (back to auth) if ($remote_user ~ ^$) { break; } # is on the right subtree ? set $ok "no"; # admin can see it all if ($remote_user = 'admin') { set $ok "yes"; } # only allow given path if ($uri ~ /munin/([^/]*)) { set $path $1; } if ($path = $remote_user) { set $ok "yes"; } # not allowed here ? redirect them where they should land if ($ok != "yes") { # redirect to where they should be rewrite / /munin/$remote_user/ redirect; } } location ^~ /munin-cgi/munin-cgi-graph/ { # not authenticated => no rewrite (back to auth) if ($remote_user ~ ^$) { break; } # is on the right subtree ? set $ok "no"; # admin can see it all if ($remote_user = 'admin') { set $ok "yes"; } # only allow given path if ($uri ~ /munin-cgi/munin-cgi-graph/([^/]*)) { set $path $1; } if ($path = $remote_user) { set $ok "yes"; } # not allowed here ? redirect them where they should land if ($ok != "yes") { # redirect to where they should be rewrite / /munin-cgi/munin-cgi-graph/$remote_user/ redirect; } fastcgi_split_path_info ^(/munin-cgi/munin-cgi-graph)(.*); fastcgi_param PATH_INFO $fastcgi_path_info; fastcgi_pass unix:/var/run/munin/fastcgi-munin-graph.sock; include fastcgi_params; } location ^~ /munin-cgi/munin-cgi-html/ { # not authenticated => no rewrite (back to auth) if ($remote_user ~ ^$) { break; } # is on the right subtree ? set $ok "no"; # admin can see it all if ($remote_user = 'admin') { set $ok "yes"; } # only allow given path if ($uri ~ /munin-cgi/munin-cgi-html/([^/]*)) { set $path $1; } if ($path = $remote_user) { set $ok "yes"; } # not allowed here ? redirect them where they should land if ($ok != "yes") { # redirect to where they should be rewrite / /munin-cgi/munin-cgi-html/$remote_user/ redirect; } fastcgi_split_path_info ^(/munin-cgi/munin-cgi-html)(.*); fastcgi_param PATH_INFO $fastcgi_path_info; fastcgi_pass unix:/var/run/munin/fastcgi-munin-html.sock; include fastcgi_params; } location /munin/static/ { alias /etc/munin/static/; } }

Don’t forget to enable your VirtualHost : ln -s /etc/nginx/sites-available/munin /etc/nginx/sites-enabled/munin

And to restart Nginx : service nginx restart

Htaccess creation

To protect our stats, the VirtualHost includes HTTP authentication. But you have to create the htpasswd file in /etc/munin/munin_htpasswd. To do so, you can install Apache Utils.

Install Apache utils : apt-get install apache2-utils

Create the htpasswd : touch /etc/munin/munin_htpasswd && chown root:www-data /etc/munin/munin_htpasswd && chmod 640 /etc/munin/munin_htpasswd

And add your admin password : htpasswd /etc/munin/munin_htpasswd

Conclusion

Your Munin installation will be available at http://localhost/munin/ with your admin password.

I hope I saved you from a headhache.

Sources

http://munin.readthedocs.org/en/latest/example/webserver/nginx.html

http://drumcoder.co.uk/blog/2010/aug/04/debian-initd-script-fcgi/

Personne ne comprend l'informatique - Partie 4 : Programmes et compilation

Mathieu — Fri, 23 Aug 2013 18:40:00 +0200

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

Dans le fond, comment ça s’écrit un programme ?

Programmes et algorithmes

Nous l’avons vu, un programme est une suite d’instructions écrites dans le but de réaliser un traitement.

Un programme a des points d’entrée et de sortie de l’information, et les instructions sont rédigées dans un certain ordre avec certaines conditions pour pour voir effectuer le traitement. Ces instructions peuvent être très simples ou alors très complexes.

Pour écrire un programme, on utilise un moyen de description que l’on appelle l’algorithme. Un algorithme c’est une suite d’instructions reliées entre elles avec des conditions, décrivant le comportement du programme dans toutes les situations, et l’ensemble des sorties possibles pour toutes les entrées possibles. Ça implique forcément que le nombre d’entrées différentes que peut traiter un programme est un nombre fini. Il faut que tous les cas d’entrée soient décris dans le programme comme soit des cas d’échec (sortie “poubelle”), soit des cas qui renvoient de l’information transformée sur les sorties.

Écrire un algorithme est similaire à la rédaction d’une solution à un problème mathématique. Une fois qu’on a la solution pour transformer les données, il faut la décrire, en reprenant les données de départ, et en les transformant pour obtenir les données d’arrivée.

Un algorithme simple avec deux entrées numériques et une sortie.

L’image ci-dessus est un algorigramme, c’est un schéma décrivant un algorithme simple, comme il pourrait s’exécuter sur un ordinateur. Ce programme ne fait pas grand chose d’utile, et il est très simple, mais c’est un exemple.

Langages et compilation

Comment transformer un algorithme en instructions compréhensibles par un ordinateur ? Il faut savoir que le processeur d’un ordinateur ne sait exécuter que des opérations simples (lire de la mémoire, réaliser des calculs avec la mémoire, etc). Ces instructions sont des codes binaires qui sont envoyés au processeur. Bon, sauf que les informaticiens n’écrivent pas directement de codes binaires pour le processeur.

Pour écrire un programme, les informaticiens utilisent ce que l’on appelle un langage. Un langage informatique est un ensemble de mots (écrits avec des vraies lettres) que l’on assemble pour décrire l’algorithme. Voici un petit exemple de notre algorithme dans un langage informatique qui pourrait exister :

DÉBUT Si entree1 = 0 alors sortie1 = 0, FIN Si entree1 < 0 alors val1= entree1 - 2 Si entree1 > 0 alors val1 = entree1 + 2 val2 = entree2 + 3 val3 = val1 + val2 sortie1 = val3 FIN

Bien évidemment, un processeur ne comprend pas le français, donc il ne comprend pas ce que veut dire “Si entree1 = 0”. Pour transformer ce texte en programme, il faut réaliser une traduction que l’on appelle la compilation.

La compilation est le processus par lequel un texte écrit dans un langage informatique devient un programme exécutable par un ordinateur. Chaque “phrase” est traduite en code compréhensible par le processeur, et le programme peut se lancer. Ce processus peut paraître simple, mais il y là aussi des aspects fondamentaux et formels pour que ce processus puisse avoir lieu (syntaxe, optimisations, etc).

C’est grâce à de tels outils que l’on arrive à écrire sans trop d’efforts des programmes efficaces dans la majorité des cas.

En conclusion

Nous avons vu que les programmes se modélisent sous forme d’algorithme et s’écrivent ensuite dans un langage compréhensible pour être ensuite traduits pour être exécutés par l’ordinateur.

La partie suivante … Je n’ai pas encore décidé quoi mettre dedans, et pourtant il y a encore plein de choses à dire !

Restez attentifs (abonnez-vous au blog), ou proposez moi de nouveaux sujets, les articles suivants n’en seront que plus intéressants.

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

Personne ne comprend l'informatique - Partie 3 : Système d'exploitation et programmes

Mathieu — Thu, 22 Aug 2013 16:30:00 +0200

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

Donnée, traitement de l’information, tout ça c’est bien joli, mais concrètement, comment ça se passe ?

Comment un ordinateur démarre ? Pourquoi il met du temps à s’allumer ?

Introduction

On fait souvent la différence entre deux disciplines dans l’informatique : les logiciels (software) et le matériel (hardware). En informatique, on parle indépendamment de logiciel ou de programme, ce sont des synonymes.

Le matériel est tout ce que vous pouvez acheter sous forme d’objets physiques pour votre ordinateur (l’ordinateur en lui même, des clefs USB, un disque dur…), et le logiciel c’est tout ce que vous allez installer sur votre ordinateur.

Fondamentalement, un logiciel ne se “touche” pas (bon sauf s’il est écrit sur un CD), mais pourtant vous manipulez certainement chaque jour des logiciels sans le savoir. Votre téléphone portable lui même, en vous présentant une interface pour saisir des numéros comporte un petit logiciel.

Il faut savoir que comme avec les anges, il y a une hiérarchie dans les logiciels. Déjà, tous les logiciels ne sont pas dédiés à la même tâche, mai surtout certains logiciels dépendent fortement d’autres logiciels pour pouvoir fonctionner. Il n’y en a qu’un qui n’a besoin de rien d’autre qu’un ordinateur : c’est le programme d’amorçage qui va démarrer votre ordinateur.

L’amorce

Le programme d’amorce est exécuté par la carte mère. Pour rappel, la carte mère est le composant qui s’occupe des entrées et sorties d’informations dans l’ordinateur.

Quand vous appuyez sur le bouton pour démarrer votre ordinateur, la carte mère est alimentée, et un petit logiciel indispensable va alors se charger. Ce programme c’est l’amorce.

Au démarrage, l’amorce va :

Faire l’inventaire des périphériques (composants) présents sur la carte mère, et faire des “bips” s’il manque quelque chose qui pourrait être d’important (genre de la RAM).
Une fois que l’amorce est certaine que l’ordinateur peut démarrer, elle va se mettre à la recherche du programme qui va effectivement démarrer l’ordinateur (le système d’exploitation).
Celui-ci se trouve en général le disque dur. une fois trouvé, elle va le charger en mémoire, demander au processeur de lire cette mémoire, puis jeter l’éponge. La suite c’est plus son problème.

Le système d’exploitation

Le système d’exploitation est le premier programme complexe à être exécuté sur votre ordinateur. Son rôle est de servir de couffin aux autres programmes : le système d’exploitation s’installe en mémoire et prépare tout ce qu’il faut pour que les programmes qui s’exécuteront ensuite se sentent chez eux.

Ça peut passer par la mise à disposition de petits utilitaires résidant en mémoire aidant les programmes à exécuter des actions avec les composants (on appelle ça des “pilotes” : accéder au disque dur, recevoir des frappes clavier, utiliser l’imprimante…), ou carrément la création de “services” dédié au opérations complexes (dessiner une fenêtre à l’écran, etc).

Forcément, mettre tout ça en place prend du temps. La plupart des informations nécessaires pour la mise en place de cet environnement se trouve sur le disque dur. Voilà pourquoi votre ordinateur a besoin d’un certain temps pour pouvoir être utilisable, à la différence de votre aspirateur où il suffit de le brancher.

Les programmes

Les programmes sont tous les logiciels qui se lancent après le système d’exploitation, et qui sont d’ailleurs lancés par le système d’exploitation.

En fait, 98% du temps, vous utilisez des programmes : pour aller sur internet, écrire du texte, retoucher une photo, ce sont des programmes qui réalisent ces choses là.

Les programmes sont faciles à écrire, parce que le système d’exploitation s’est chargé de tout le travail pénible (comment écrire octet par octet sur le disque, comment parler avec l’imprimante, comment afficher une fenêtre à l’écran). Les créateurs de programmes peuvent donc se concentrer sur quelque chose qui plaît aux commerciaux : ajouter de la valeur à votre travail.

Il faut voir les programmes comme des outil qui va prendre de l’information, le traiter, et vous fournir de l’information transformée. Un logiciel de traitement de texte va utiliser vos frappes sur les touches pour écrire du texte à l’écran, et vous permettre de l’imprimer. Un navigateur web va vous permettre d’accéder aux informations contenus sur Internet. Un logiciel de retouche photo va travailler à partir des informations contenus dans le fichier que vous modifiez, et de vos instructions avec la souris.

Chaque fois que vous utilisez un programme, quelqu’un a conçu les points d’entrée de l’information (clavier, souris, fichier…), et les méthodes de la transformer (retoucher la photo, écrire un texte), mais aussi les points de sortie de l’information : écran, imprimante, etc.

En conclusion

Nous avons vu que les programmes se sont pas tous égaux dans un ordinateur. un programme en particulier est au dessus des autres, c’est le système d’exploitation.

Les outils que vous utilisez quand vous utilisez un ordinateur sont des logiciels, ils dépendent du système d’exploitation pour fonctionner, et la seule chose qu’ils savent faire c’est transformer de l’information.

Mais un programme ça ne vient pas tout seul, quelqu’un a rédigé les instructions lui permettant de traiter l’information d’une certain façon, et il a également défini les points d’entrée et de sortie de cette information.

Dans la partie suivante, nous verrons concrètement comment les informaticiens rédigent des programmes, et pourquoi il ne faut pas en avoir peur (ni des programmes ni des informaticiens).

Lire la suite : Partie 4 : Programmes et compilation.

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

Personne ne comprend l'informatique - Partie 2 : Signal, encodage, donnée, information

Mathieu — Wed, 21 Aug 2013 18:12:00 +0200

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

On a vu que l’informatique c’était la science du traitement de l’information. Bon, mais c’est quoi une information ?

Signal

Tous les ordinateurs interagissent avec leur environnement (incluant d’autres ordinateurs) en utilisant des signaux électriques. Les composants de l’ordinateur s’envoient eux-même entre eux des signaux électriques, tous ces signaux constituent la base des ordinateurs pour communiquer (si on compare à un langage, ce sont comme des sons).

Un signal est un changement de tension sur un fil électrique. Ce changement peut provenir d’un capteur, ou d’une réaction du système lui même (signal en sortie), toujours est-il qu’il y a eu un changement d’état.

Le signal qui sort ou qui rentre d’un ordinateur est particulier : on dit qu’il est binaire. Cela veut dire que le signal n’a que deux valeurs possibles : une que l’on va appeler “vraie” ou “1”, et l’autre que l’on va appeler “faux”, ou “0”.

Cette limitation vient du mécanisme de traitement des ordinateurs. En effet les transistors (similaires aux relais dont nous avons parlé précédemment) présents dans le processeur ne sont capables de n’exprimer que deux états : ouvert (“faux” : le courant ne passe pas) ou fermé (“vrai” : le courant passe).

À partir de là, comment représenter des choses comme les lettres tapées sur un clavier, ou les couleurs de l’écran ? Le secret est : encodage.

Donnée

L’encodage est le processus par lequel un signal va se transformer en donnée.

Une donnée est un événement informatique représenté sous une certaine forme. La frappe d’un utilisateur sur le clavier va provoquer un ensemble de signaux électriques vers l’ordinateur, mais la frappe sur une certaine touche provoquera toujours toujours la même série de signaux électriques, on appelle ça un code.

Pour faire une analogie, c’est similaire au code morse. Le code morse est composé de “mots” ternaires (trois états : long, court, silence) codant des lettres. Par exemple la lettre A s’écrit : court, silence, long.

Ainsi un événement se produisant sur le clavier (frappe de touche) va se traduire par une suite de signaux électriques, toujours la même suite pour une même touche. La transformation de l’événement en suite de signaux est appelé l’encodage, et le produit en est la donnée.

Information

La donnée en elle-même n’apporte rien. C’est un code, un simple événement qui s’est produit à un moment donnée. L’apport de sens à cette donnée la transforme en information.

Reprenons la frappe sur une touche de clavier. Le code qui est produit en lui même ne veut pas dire grand chose (pas plus que “court, silence, long”). Mais lors de l’élaboration de l’ordinateur, on a décidé par convention que cette suite de signaux voudrait dire que l’utilisateur a frappé une certaine touche.

On peut donc convertir l’événement en lettre affichée à l’écran, et inversement. On a interprété la donnée comme une lettre frappée par l’utilisateur, on en a fait une information.

De la notion d’information viendra également la notion de protocole, où une suite de données sert à transmettre une information plus complexe qu’une simple lettre.

Conclusion

Nous avons vu comment une information est construite dans un ordinateur.

L’information est un concept théorique qui sert à dessiner tout plein de schémas, mais surtout à comprendre et modéliser les interactions dans un système. Votre ordinateur ne sait qu’exécuter les modèles issus de ces schémas, et transformer de l’information à partir de ces modèles.

Le genre de schémas que les informaticiens aiment bien faire, avec des flèches partout. Source de l’image.

Comment fait-il ? Comment un ordinateur gère-t-il la gigantesque quantité d’information que vous lui transmettez à chaque seconde ? Comment une image de plusieurs milliers d’octets (autrement dit, de “mots”) peut être transformée par l’ordinateur juste en cliquant avec votre souris sur votre écran ? Un clic de souris n’est certainement pas suffisant !

La partie suivante va éclaircir cette question en vous expliquant comment est structuré un ordinateur au niveau logique. La partie suivante va également tenter d’apporter un peu plus d’enthousiasme (selon mes calculs, la majorité d’entre vous trouve mes articles chiants).

Lire la suite : Partie 3 : Système d’exploitation et programmes

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Voir le lexique.

Personne ne comprend l'informatique - Partie 0 : Lexique

Mathieu — Wed, 21 Aug 2013 15:32:00 +0200

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique.

Parce que vous en aurez forcément besoin un jour : voici le lexique.

A

B

C

D

E

F

G

H

I

J

K

L

Logiciel : un logiciel (ou programme) est une suite d’instructions logiques permettant de transformer l’information.

M

N

O

P

Processeur : dans un ordinateur, le processeur est le composant qui va exécuter la transformation de l’information à partir des instructions fournies par les programmes.

Programme : voir Logiciel.

Q

R

S

Système d’exploitation : le système d’exploitation est le premier programme exécuté au démarrage de l’ordinateur. Il met en place tout ce dont les autres programmes ont besoin pour fonctionner.

T

Traitement : on appelle traitement la transformation de l’information par un logiciel.

U

V

W

X

Y

Z

Voir l’ensemble des articles sur ce sujet : Personne ne comprend l’informatique