Partager via

Ajouter l’authentification à votre application Android

  • Article

Résumé

Dans ce tutoriel, vous ajoutez l’authentification au projet de démarrage rapide todolist sur Android à l’aide d’un fournisseur d’identité pris en charge. Ce didacticiel est basé sur le didacticiel Prise en main de Mobile Apps, que vous devez commencer par effectuer.

Inscrire votre application pour l’authentification et configurer Azure App Service

Tout d’abord, vous devez inscrire votre application sur le site d’un fournisseur d’identité, puis définir les informations d’identification générées par le fournisseur dans le back-end Mobile Apps.

  1. Configurez votre fournisseur d’identité préféré en suivant les instructions spécifiques au fournisseur :

  2. Répétez les étapes précédentes pour chaque fournisseur que vous souhaitez prendre en charge dans votre application.

Ajouter votre application aux URL de redirection externe autorisées

L’authentification sécurisée nécessite que vous définissiez un nouveau schéma d’URL pour votre application. Cela permet au système d’authentification de revenir à votre application une fois le processus d’authentification terminé. Dans ce tutoriel, nous utilisons le schéma d’URL nom d’application dans l’ensemble. Toutefois, vous pouvez utiliser n’importe quel schéma d’URL que vous choisissez. Il doit être unique à votre application mobile. Pour activer la redirection côté serveur :

  1. Dans le portail Azure, sélectionnez votre App Service.

  2. Cliquez sur l’option de menu Authentification /Autorisation.

  3. Dans les URL de redirection externe autorisées , entrez appname://easyauth.callback. Le nom d’application dans cette chaîne est le schéma d’URL de votre application mobile. Il doit suivre la spécification d’URL normale pour un protocole (utilisez uniquement des lettres et des chiffres, puis commencez par une lettre). Vous devez noter la chaîne que vous choisissez, car vous devez ajuster votre code d’application mobile avec le schéma d’URL à plusieurs endroits.

  4. Cliquez sur OK.

  5. Cliquez sur Enregistrer.

Restreindre les autorisations aux utilisateurs authentifiés

Par défaut, les API d’un back-end Mobile Apps peuvent être appelées anonymement. Ensuite, vous devez restreindre l’accès aux clients authentifiés uniquement.

  • Node.js back-end (via le portail Azure) :

    Dans vos paramètres Mobile Apps, cliquez sur Tables faciles et sélectionnez votre table. Cliquez sur Modifier les autorisations, sélectionnez accès authentifié uniquement pour toutes les autorisations, puis cliquez sur Enregistrer.

  • serveur principal .NET (C#):

    Dans le projet de serveur, accédez à Controllers>TodoItemController.cs. Ajoutez l’attribut [Authorize] à la classe TodoItemController, comme suit. Pour restreindre l’accès uniquement à des méthodes spécifiques, vous pouvez également appliquer cet attribut uniquement à ces méthodes au lieu de la classe. Republiez le projet de serveur.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js back-end (via Node.js code) :

    Pour exiger l’authentification pour l’accès aux tables, ajoutez la ligne suivante au script serveur Node.js :

      table.access = 'authenticated';

    Pour plus d’informations, consultez Procédure : Exiger l’authentification pour l’accès aux tables. Pour savoir comment télécharger le projet de code de démarrage rapide à partir de votre site, consultez Guide pratique pour télécharger le projet de code de démarrage rapide principal Node.js à l’aide de Git.

  • Dans Android Studio, ouvrez le projet que vous avez effectué avec le didacticiel Bien démarrer avec Mobile Apps. Dans le menu Exécuter, cliquez sur Exécuter l’application, puis vérifiez qu’une exception non gérée avec un code d’état 401 (non autorisé) est déclenchée une fois l’application démarrée.

    Cette exception se produit parce que l’application tente d’accéder au serveur principal en tant qu’utilisateur non authentifié, mais la table TodoItem nécessite désormais l’authentification.

Ensuite, vous mettez à jour l’application pour authentifier les utilisateurs avant de demander des ressources à partir du serveur principal Mobile Apps.

Ajouter l’authentification à l’application

  1. Ouvrez le projet dans Android Studio.

  2. Dans Explorateur de projets dans Android Studio, ouvrez le fichier ToDoActivity.java et ajoutez les instructions d’importation suivantes :

    import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceAuthenticationProvider;
import com.microsoft.windowsazure.mobileservices.authentication.MobileServiceUser;

  3. Ajoutez la méthode suivante à la classe ToDoActivity :

    // You can choose any unique number here to differentiate auth providers from each other. Note this is the same code at login() and onActivityResult().
public static final int GOOGLE_LOGIN_REQUEST_CODE = 1;

private void authenticate() {
    // Sign in using the Google provider.
    mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the login request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

    Ce code crée une méthode pour gérer le processus d’authentification Google. Une boîte de dialogue affiche l’ID de l’utilisateur authentifié. Vous ne pouvez procéder qu’à une authentification réussie.

    Remarque

    Si vous utilisez un fournisseur d’identité autre que Google, remplacez la valeur transmise à la méthode de connexion par l’une des valeurs suivantes : MicrosoftAccount, Facebook, Twitterou windowsazureactivedirectory.

  4. Dans la méthode onCreate, ajoutez la ligne de code suivante après le code qui instancie l’objet MobileServiceClient.

    authenticate();

    Cet appel démarre le processus d’authentification.

  5. Déplacez le code restant après authenticate(); dans la méthode onCreate vers une nouvelle méthode createTable :

    private void createTable() {

    // Get the table instance to use.
    mToDoTable = mClient.getTable(ToDoItem.class);

    mTextNewToDo = (EditText) findViewById(R.id.textNewToDo);

    // Create an adapter to bind the items with the view.
    mAdapter = new ToDoItemAdapter(this, R.layout.row_list_to_do);
    ListView listViewToDo = (ListView) findViewById(R.id.listViewToDo);
    listViewToDo.setAdapter(mAdapter);

    // Load the items from Azure.
    refreshItemsFromTable();
}

  6. Pour garantir que la redirection fonctionne comme prévu, ajoutez l’extrait de code de RedirectUrlActivity suivant à AndroidManifest.xml:

    <activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="{url_scheme_of_your_app}"
            android:host="easyauth.callback"/>
    </intent-filter>
</activity>

  7. Ajoutez redirectUriScheme à build.gradle de votre application Android.

    android {
    buildTypes {
        release {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
        debug {
            // ...
            manifestPlaceholders = ['redirectUriScheme': '{url_scheme_of_your_app}://easyauth.callback']
        }
    }
}

  8. Ajoutez com.android.support:customtabs:23.0.1 aux dépendances de votre build.gradle:

    dependencies {
    // ...
    compile 'com.android.support:customtabs:23.0.1'
}

  9. Dans le menu Exécuter, cliquez sur Exécuter l’application pour démarrer l’application et vous connecter avec le fournisseur d'identité de votre choix.

Avertissement

Le schéma d'URL mentionné est sensible à la casse. Assurez-vous que toutes les occurrences de {url_scheme_of_you_app} utilisent le même cas.

Lorsque vous êtes connecté, l’application doit s’exécuter sans erreur, et vous devez être en mesure d’interroger le service back-end et d’effectuer des mises à jour des données.

Cache des jetons d’authentification sur le client

L’exemple précédent montre une connexion standard, ce qui oblige le client à contacter le fournisseur d’identité et le service Azure principal chaque fois que l’application démarre. Cette méthode est inefficace et vous pouvez rencontrer des problèmes liés à l’utilisation si de nombreux clients essaient de démarrer votre application simultanément. Une meilleure approche consiste à mettre en cache le jeton d’autorisation retourné par le service Azure et à essayer d’utiliser ce dernier avant d’utiliser une connexion basée sur un fournisseur.

Remarque

Vous pouvez mettre en cache le jeton émis par le service Azure principal, que vous utilisiez l’authentification gérée par le client ou gérée par le service. Ce tutoriel utilise l’authentification gérée par le service.

  1. Ouvrez le fichier ToDoActivity.java et ajoutez les instructions d’importation suivantes :

    import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

  2. Ajoutez les membres suivants à la classe ToDoActivity.

    public static final String SHAREDPREFFILE = "temp";
public static final String USERIDPREF = "uid";
public static final String TOKENPREF = "tkn";

  3. Dans le fichier ToDoActivity.java, ajoutez la définition suivante pour la méthode cacheUserToken.

    private void cacheUserToken(MobileServiceUser user)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    Editor editor = prefs.edit();
    editor.putString(USERIDPREF, user.getUserId());
    editor.putString(TOKENPREF, user.getAuthenticationToken());
    editor.commit();
}

    Cette méthode stocke l’ID utilisateur et le jeton dans un fichier de préférence marqué comme privé. Cela doit protéger l’accès au cache afin que d’autres applications sur l’appareil n’aient pas accès au jeton. La préférence est bac à sable pour l’application. Toutefois, si quelqu’un obtient l’accès à l’appareil, il est possible qu’il puisse accéder au cache de jetons par d’autres moyens.

    Remarque

    Vous pouvez protéger davantage le jeton avec chiffrement, si l’accès au jeton à vos données est considéré comme hautement sensible et qu’une personne peut accéder à l’appareil. Toutefois, une solution complètement sécurisée dépasse le cadre de ce didacticiel et dépend de vos exigences de sécurité.

  4. Dans le fichier ToDoActivity.java, ajoutez la définition suivante pour la méthode loadUserTokenCache.

    private boolean loadUserTokenCache(MobileServiceClient client)
{
    SharedPreferences prefs = getSharedPreferences(SHAREDPREFFILE, Context.MODE_PRIVATE);
    String userId = prefs.getString(USERIDPREF, null);
    if (userId == null)
        return false;
    String token = prefs.getString(TOKENPREF, null);
    if (token == null)
        return false;

    MobileServiceUser user = new MobileServiceUser(userId);
    user.setAuthenticationToken(token);
    client.setCurrentUser(user);

    return true;
}

  5. Dans le fichier ToDoActivity.java, remplacez les méthodes authenticate et onActivityResult par les méthodes suivantes, qui utilisent un cache de jetons. Modifiez le fournisseur de connexion si vous souhaitez utiliser un compte autre que Google.

    private void authenticate() {
    // We first try to load a token cache if one exists.
    if (loadUserTokenCache(mClient))
    {
        createTable();
    }
    // If we failed to load a token cache, sign in and create a token cache
    else
    {
        // Sign in using the Google provider.
        mClient.login(MobileServiceAuthenticationProvider.Google, "{url_scheme_of_your_app}", GOOGLE_LOGIN_REQUEST_CODE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // When request completes
    if (resultCode == RESULT_OK) {
        // Check the request code matches the one we send in the sign-in request
        if (requestCode == GOOGLE_LOGIN_REQUEST_CODE) {
            MobileServiceActivityResult result = mClient.onActivityResult(data);
            if (result.isLoggedIn()) {
                // sign-in succeeded
                createAndShowDialog(String.format("You are now signed in - %1$2s", mClient.getCurrentUser().getUserId()), "Success");
                cacheUserToken(mClient.getCurrentUser());
                createTable();
            } else {
                // sign-in failed, check the error message
                String errorMessage = result.getErrorMessage();
                createAndShowDialog(errorMessage, "Error");
            }
        }
    }
}

  6. Générez l’application et testez l’authentification à l’aide d’un compte valide. Exécutez-le au moins deux fois. Lors de la première exécution, vous devez recevoir une invite pour vous connecter et créer le cache de jetons. Après cela, chaque exécution tente de charger le cache de jetons pour l’authentification. Vous ne devez pas être obligé de vous connecter.

Étapes suivantes

Maintenant que vous avez terminé ce didacticiel d’authentification de base, envisagez de passer à l’un des didacticiels suivants :