Tutoriel La Poste IDentité Numérique

Société anonyme à capitaux publics depuis le 1er mars 2010, La Poste est un modèle original de groupe structuré autour de cinq branches : Services-Courrier-Colis, La Banque Postale, Réseau La Poste, GeoPost, Numérique.

Le Groupe est présent dans plus de 40 pays sur 4 continents.

Chaque jour, les 17 000 points de contact de La Poste, soit le 1er réseau commercial de proximité de France, accueillent 1,7 million de clients.

La Poste distribue 25 milliards d'objets par an dans le monde (lettres, imprimés publicitaires et colis), 6 jours par semaine.

En 2013, le Groupe La Poste a réalisé un chiffre d'affaires de 22,08 milliards d'euros, dont 17 % à l'international, et emploie plus de 266 000 collaborateurs.

Le Groupe La Poste, dans son plan stratégique « La Poste 2020 : Conquérir l'avenir » s'est donné pour objectif d'accélérer le développement de ses cinq branches et de conquérir de nouveaux territoires.

La Poste met le facteur humain et la confiance au cœur de la relation avec ses clients. Grâce à la convergence de ses réseaux, présente pour tous, partout et tous les jours, elle accompagne ses clients pour leur simplifier l'avenir.

La Poste est ainsi prestataire de services numériques via ses offres en ligne (MonTimbrenligne, Lettre recommandée électronique, …) disponibles sur laposte.fr, ses applications mobiles, les réseaux sociaux, mais aussi son webmail laposte.net, son coffre-fort électronique Digiposte et ses filiales BtoB : Mediapost Communication et Docapost.

L'IDentité Numérique peut être définie comme un lien technologique entre une entité réelle (personne, organisme ou entreprise) et une entité virtuelle (sa ou ses représentations numériques).

Le développement et l'évolution des moyens de communication, au travers notamment de la multiplication des blogs et des réseaux sociaux, changent le rapport de l'individu à autrui. Ainsi, l'IDentité Numérique permet l'identification de l'individu en ligne et la mise en relation de celui-ci avec cet ensemble de communautés virtuelles qu'est Internet.

Dès lors, l'IDentité Numérique peut être divisée en trois catégories :

• l'identité déclarative, qui se réfère aux données saisies par l'utilisateur comme son nom, sa date de naissance, ou autres informations personnelles directement renseignées par l'individu ;
• l'identité agissante, qui est indirectement renseignée par les activités de l'utilisateur sur la toile ;
• l'identité calculée, qui résulte d'une analyse de l'identité agissante par le système, comme le nombre de communautés virtuelles dans lesquelles l'individu évolue ou bien son nombre d'amis sur les réseaux sociaux.

Le décalage ou du moins les divergences qui peuvent subsister entre l'identité déclarative et l'identité agissante soulèvent une question majeure. Qui est vraiment l'individu auquel nous avons affaire sur la toile ?

Enfin, Internet étant accessible par tous et offrant de plus en plus de services, se pose le problème de la sécurité de l'information et plus particulièrement des données personnelles. La gestion de l'identité numérique devient alors un enjeu majeur.

Voilà le principe du l'IDentité Numérique, pour plus d'informations, visitez le lien Wikipédia.

Ainsi, La Poste propose une solution sécurisée pour les internautes avec son système de compte vérifié en face à face. Pour obtenir une IDentité Numérique de La Poste, l'internaute doit créer un compte sur www.laposte.fr/identitenumerique et faire vérifier son identité par un postier afin d'activer ce compte (un postier est un agent assermenté). En utilisant son IDentité Numérique pour s'authentifier sur un site partenaire, il choisit de partager ses données vérifiées à ce site et atteste ainsi que sa réelle identité et que son adresse postale ont été vérifiées. L'internaute garde la main sur ses données, La Poste les sécurise et ne trace pas ses actions.

Grâce à ce service, La Poste donne à l'internaute la possibilité d'accéder à plus de services sécurisés comme la réception des lettres recommandées en ligne en toute légalité.

Le langage utilisé durant ce tutoriel est Java. Vous pourrez réviser vos bases sur la section Développez prévue à cet effet : Cours et tutoriels Java

L'IDentité Numérique de La Poste : une identité vérifiée en face à face par le facteur au domicile des internautes.

C'est un service permettant à son détenteur de prouver qui il est grâce à l'identifiant et au mot de passe qu'il a choisis lors de son inscription, sans dévoiler son identité aux autres internautes.

II-A-1. Comment ça marche ?▲

L'utilité de ce service est donc de fournir un identifiant numérique qui permet d'attester de son identité sur le web !

II-B-1. Quels sont les usages actuels ?▲

Pour créer une application cliente, il vous faudra les clés de développement qui vous seront données après votre inscription et qui ressembleront par exemple à ça :

CONSUMER_KEY : _kdvsazaaphmytp4gzoi8jdbal02pfgfh5l0w12iud

CONSUMER_SECRET : _vofna5navs92smal88obo2c2s4mah1k99i5r1xls

Il y a de nombreux clients OAuth2 disponible pour la plupart des langages de programmation. Afin de ne pas réinventer la roue, nous allons utiliser une bibliothèque Java, “Scribe”, disponible sur github ( https://github.com/fernandezpablo85/scribe-java ).

La bibliothèque “Scribe” fournit un ensemble de fonctionnalités utiles à la communication avec les serveurs d'identifications pour accéder aux services de l'API Anywhere. Il s'agit notamment de rendre transparente l'utilisation du protocole d'autorisation OAuth2, et de se concentrer sur la logique du service à fournir aux utilisateurs finaux.

En supprimant la nécessité de gérer les jetons d'accès manuellement, “Scribe” simplifie énormément le processus d'authentification et d'autorisation des utilisateurs de notre application cliente.

“Scribe” est développé en Java et peut être intégré aux framework les plus courants.

Notre projet de démonstration utilisera aussi le SDK Java App Engine ( https://cloud.google.com/appengine/docs/java/gettingstarted/introduction ) pour faciliter la mise en ligne.

Toute la documentation pour son installation et son utilisation est disponible, en anglais, à cette url : https://cloud.google.com/appengine/docs/java/gettingstarted/introduction

Nous utiliserons aussi maven, une référence dans le monde Java, pour faciliter la gestion des dépendances et la création du projet ( http://maven.apache.org/ ).

Afin de ne pas se focaliser sur une plateforme dédiée, ce document utilise la notation {{base_url}} pour référencer le serveur IDN cible. Par exemple, pour cibler la plateforme de recette, {{base_url}} est égal à l'adresse qui vous sera envoyée par e-mail dès votre demande d'adhésion au service IDN soumise, dans notre cas : https://anywhere-sandbox.idn.laposte.fr/.

Vous pouvez installer facilement les dépendances via Maven :

Création du projet :

mvn archetype:generate -Dappengine-version=1.9.15 -Dapplication-id=your-app-id -Dfilter=com.google.appengine.archetypes:

Afin de pouvoir utiliser Maven, il suffit d'ajouter ces éléments à votre fichier pom.xml :

<!-- repository -->
<repositories>
  <repository>
    <id>scribe-java-mvn-repo</id>
    <url>https://raw.github.com/fernandezpablo85/scribe-java/mvn-repo/</url>
    <snapshots>
      <enabled>true</enabled>
      <updatePolicy>always</updatePolicy>
    </snapshots>
  </repository>
</repositories>

<!-- dependency ->

<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.1.1</version>
</dependency>

<dependency>
  <groupId>org.scribe</groupId>
  <artifactId>scribe</artifactId>
  <version>1.3.6</version>
</dependency>

Vous pouvez enfin lancer la gestion des dépendances :

mvn clean install

On peut alors utiliser “Scribe” avec pour configuration minimum, la clef et le secret de l'application partenaire (CONSUMER_KEY et CONSUMER_SECRET).

Pour ce qui concerne l'authentification et l'autorisation, IDN possède la fonctionnalité SSO OAuth2. Il est alors possible de déléguer l'authentification de l'utilisateur au serveur IDN, puis d'utiliser la session établie.

Pour commencer, nous allons créer un fichier JSP, laposte.jsp, dans le dossier webapp “src/main/webapp/WEB-INF/”.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="com.google.appengine.api.users.User" %>
<%@ page import="com.google.appengine.api.users.UserService" %>
<%@ page import="com.google.appengine.api.users.UserServiceFactory" %>
<%@ page import="java.util.List" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<html>
<head>
    <title>La Poste</title>
</head>

<body>

<a href="/laposte">Identification</a>

</body>
</html>

Nous allons ensuite configurer les Servlet à venir via “web.xml” présent dans

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <servlet>
        <servlet-name>laposte</servlet-name>
        <servlet-class>com.laposte.LaposteServlet</servlet-class>
    </servlet>
    <servlet>
        <servlet-name>callback</servlet-name>
        <servlet-class>com.laposte.CallbackOAuthProcessServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>laposte</servlet-name>
        <url-pattern>/laposte</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>callback</servlet-name>
        <url-pattern>/callback</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>laposte.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Scribe ne reconnaît pas encore par défaut l'identification La Poste. Nous allons donc créer dans le répertoire “src/main/java/com/laposte/” le fichier API nécessaire à Scribe. DefaultApi20 correspond à Oauth2.

package com.laposte;

import org.scribe.builder.api.DefaultApi20;
import org.scribe.extractors.AccessTokenExtractor;
import org.scribe.extractors.JsonTokenExtractor;

import org.scribe.model.*;

import org.scribe.utils.*;

public class LaposteApi extends DefaultApi20
{

    private static final String AUTHORIZE_URL = "{{base_url}}/oauth/v2/authorize?response_type=code&client_id=%s&redirect_uri=%s&scope=openid+email+phone+profile&state=123456";
    private static final String SCOPED_AUTHORIZE_URL = AUTHORIZE_URL + "&scope=%s";

    @Override
    public String getAccessTokenEndpoint() {
        return "{{base_url}}/v2";
    }

    @Override
    public Verb getAccessTokenVerb() {
        return Verb.POST;
    }

    @Override
    public String getAuthorizationUrl(OAuthConfig config) {
        Preconditions.checkValidUrl(config.getCallback(), "Must provide a valid url as callback. Laposte does not support OOB");

        // Append scope if present
        if(config.hasScope())
        {
            return String.format(SCOPED_AUTHORIZE_URL, config.getApiKey(), OAuthEncoder.encode(config.getCallback()), OAuthEncoder.encode(config.getScope()));
        }
        else
        {
            return String.format(AUTHORIZE_URL, config.getApiKey(), OAuthEncoder.encode(config.getCallback()));
        }
    }

}

Concernant notre application nous allons créer un fichier LaposteServlet.java, dans le même répertoire que ci-dessus. Ce nouveau fichier contenant le code nécessaire à l'identification. Sa mission est de rediriger l'utilisateur vers le formulaire d'identification La Poste, le serveur d'autorisation.

Il s'agit donc de l'application cliente. Si La Poste autorise l'accès, le serveur d'autorisation envoie un code d'autorisation à notre application cliente via l'url callback.

package com.laposte;

import java.io.IOException;
import java.util.Properties;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.scribe.builder.*;
import org.scribe.builder.api.*;
import org.scribe.model.*;
import org.scribe.oauth.*;

import java.io.IOException;
import java.util.Arrays;

public class LaposteServlet extends HttpServlet {

  private static final Token EMPTY_TOKEN = null;

  @Override
  public void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws IOException {
         OAuthService service = new ServiceBuilder()
                    .provider(LaposteApi.class)
                    .apiKey("_API_KEY_")
                    .apiSecret("_API_SECRET_")
                    .callback("http://127.0.0.1/callback")
                    .build();

        resp.getWriter().println("=== Laposte's OAuth Workflow ===");
        resp.getWriter().println("Fetching the Authorization URL...");
        String authorizationUrl = service.getAuthorizationUrl(EMPTY_TOKEN);
        resp.getWriter().println("Got the Authorization URL!");
        resp.getWriter().println("Now go and authorize here:");
        resp.getWriter().println(authorizationUrl);
        resp.sendRedirect(authorizationUrl);

  }
}

Le fichier CallbackOAuthProcessServlet.java, toujours dans “src/main/java/com/laposte/“ pour la démonstration permet d'échanger le code par un token d'accès. Enfin, notre application utilise ce token d'accès pour accéder aux données du profil de l'utilisateur par le serveur de ressources. Enfin, cette classe permet d'afficher les données de type : nom, prénom, téléphone…

package com.laposte;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import org.scribe.builder.*;
import org.scribe.builder.api.*;
import org.scribe.model.*;
import org.scribe.oauth.*;


public class CallbackOAuthProcessServlet extends HttpServlet {

    private Log log = LogFactory.getLog(getClass());
    private static final String PROTECTED_RESOURCE_URL = "{{base_url}}/v2/me";

    protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {

        String code = req.getParameter(OAuthConstants.VERIFIER);

         OAuthService service = new ServiceBuilder()
                    .provider(LaposteApi.class)
                    .apiKey("_API_KEY_")
                    .apiSecret("_API_SECRET_")
                    .callback("http://127.0.0.1/callback")
                    .build();

        Token requestToken = service.getRequestToken();

        Verifier verifier = new Verifier(code);

        Token accessToken = service.getAccessToken(requestToken, verifier);

        OAuthRequest request = new OAuthRequest(Verb.GET, PROTECTED_RESOURCE_URL);
        service.signRequest(accessToken, request);

        Response response = request.send();

    System.out.printin(response.getcode());
    System.out.printin(response.getBody());
    }
}

Dans une application en production, l'utilisateur ne doit pas avoir accès au token d'accès, à vous de le stocker. La Poste envoie également d'autres informations en dehors du token d'accès comme la durée de validité du token d'accès.

Pour lancer l'application : mvn appengine:devserver

Si vous avez correctement configuré la variable PROTECTED_RESOURCE_URL et les méthodes apiKey, apiSecret et callback, vous devez voir le lien “identification” si vous ouvrez votre navigateur sur l'adresse http://localhost:3000, un simple clic vous redirigera vers le site d'identification de laposte. Une fois identifié, vous serez redirigé vers votre application qui affichera simplement les données de votre compte.