Création d'une connexion sécurisée sur Android à l'aide de Google OAuth
Published: 2024-03-11 01:08:52

Avec une estimation de 4,55 milliards de personnes [ayant au moins un profil de média social](https://www.statista.com/statistics/278414/number-of-worldwide-social-network-users/) en janvier 2022, il n'est pas surprenant que la majorité des applications aient une sorte de connexion sociale comme moyen facile pour leurs utilisateurs de se joindre à eux. Il s'agit d'un élément clé pour améliorer l'expérience de l'utilisateur. Du point de vue du développement, il existe un point commun majeur entre tous ces fournisseurs de connexion sociale, tels que Facebook, Twitter et Google. Cette pièce de puzzle commune est **OAuth**, plus précisément **OAuth 2.0**. Mais il ne s'agit pas seulement d'utiliser OAuth, il faut aussi comprendre correctement les scopes, l'ID client OAuth et l'écran de consentement OAuth pour une mise en œuvre optimale.

Quelle est la différence entre l'authentification et l'autorisation ?
---------------------------------------------------------------------

L'[authentification](https://www.pubnub.com/learn/glossary/what-is-authentication/) (authn) fait référence au processus d'identification ou de vérification de l'utilisateur, dans ce contexte, elle peut être effectuée via Google OAuth. D'autre part, l'[autorisation](https://www.pubnub.com/learn/glossary/what-is-authorization/) (authz) concerne la question de savoir si l'utilisateur authentifié a les _\_permissions nécessaires\__ pour accéder à une ressource particulière. C'est là que les champs d'application jouent un rôle crucial, car ils définissent les permissions dans OAuth.

Authn et authz sont étroitement liés et se retrouvent généralement dans le processus OAuth 2.0. Pour les deux parties du processus, nous aurons besoin d'un serveur pour conserver notre [identifiant et notre secret client](https://www.oauth.com/oauth2-servers/client-registration/client-id-secret/), qui peut être géré à l'aide de Google Cloud.

Comment Authn et Authz s'intègrent dans OAuth
---------------------------------------------

**OAuth est strictement la norme pour l'autorisation**, une idée fausse majeure parmi les développeurs est que l'authn (authentification) en fait partie. OAuth 2.0 intègre également l'authn, en particulier sur les plateformes sociales comme Google, où les processus sont exécutés successivement en utilisant une combinaison de technologies natives, Javascript ou Kotlin.

Voici un aperçu du processus :

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jgb/a9cc177f71949ce3ab9e9117b59323be/Oauth-Flow.png)

Comme vous pouvez le voir, il y a deux composantes principales. Dans un premier temps, nous devons obtenir l'autorisation requise de l'utilisateur. C'est ce qui se passe si l'utilisateur est connecté, et c'est à ce moment-là que de nombreuses API intègrent l'élément d'authentification d'OAuth à l'aide d'openid. Une fois que nous avons obtenu l'autorisation de l'autorité du compte de l'utilisateur, nous pouvons commencer à communiquer avec le propriétaire de la ressource. Lorsque nous envoyons l'autorisation au serveur d'autorisation, nous recevons un jeton d'accès en retour. Avec ce jeton d'accès, nous pouvons accéder aux informations dont nous avons besoin concernant l'utilisateur.

Lors de la mise en œuvre d'OAuth 2.0, il est essentiel de configurer correctement les URI de redirection et le rappel, car toute erreur mineure dans ces paramètres peut entraîner l'échec des processus authn et authz. En outre, dans le cadre de l'amélioration de la sécurité et de l'expérience utilisateur, Google fournit l'extension chrome pour OAuth 2.0.

S'authentifier avec Google Sign-in sur Android
----------------------------------------------

L'authentification des applications pour Android, en particulier avec Google Sign-in, est une mesure de sécurité courante. Mais il ne s'agit pas seulement d'ajouter Google à votre application Android, il faut d'abord comprendre OAuth, puis se plonger dans le SDK et l'API de Google.

Pour commencer avec Google Sign-in, nous allons utiliser [Functions](https://www.pubnub.com/docs/functions/overview), une fonctionnalité de PubNub qui nous sert de serveur. Ces fonctions simplifieront la mise en œuvre des notifications dans le processus OAuth. Les extraits de code pour le processus OAuth peuvent également être trouvés sur GitHub.

En outre, assurez-vous que votre [compte Google API](https://developers.google.com/identity/sign-in/android/start-integrating) est configuré avec le nom de paquetage correct et que votre ID client OAuth et votre écran de consentement OAuth sont configurés.

Ensuite, nous allons ajouter Google à notre application Android afin de pouvoir lancer le processus de connexion. Tout d'abord, assurez-vous d'avoir la ligne `repositories { google() }` dans votre fichier Gradle au niveau du projet. Cela permettra à votre application d'exploiter le SDK de Google.

Ensuite, allez dans le fichier Gradle au niveau de l'application et mettez à jour la dépendance authentification des services Google Play. En janvier 2022, la version la plus récente est `com.google.android.gms:play-services-auth:19.2.0`.

```js
    implementation 'com.google.android.gms:play-services-auth:19.2.0'
```

Maintenant, même si nous avons ajouté la dépendance mise à jour à notre projet, nous ne serons pas en mesure de passer par le processus de connexion tout de suite. Vous devez éditer le fichier manifeste Android pour ajouter les permissions Internet concernant Firebase :

```js
    <uses-permission android:name="android.permission.INTERNET" />
```

### Ajout du bouton de connexion Google

Cette étape est assez simple. Ajoutez le composant de connexion au fichier `activity_main.xml`. Le bouton de connexion est stylisé par Google, mais vérifiez les [conseils de Google en matière de marque](https://about.google/brand-resource-center/), au cas où. N'oubliez pas qu'une bonne expérience utilisateur est essentielle dans les applications de bureau et que cela inclut les styles et les identifiants utilisés sur le bouton de connexion.

```js
    <com.google.android.gms.common.SignInButton
                android:id="@+id/sign_in_button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginBottom="8dp"
                app:layout_constraintBottom_toBottomOf="parent" android:layout_marginTop="8dp"
                app:layout_constraintTop_toTopOf="parent" app:layout_constraintStart_toStartOf="parent"
                android:layout_marginStart="8dp" app:layout_constraintEnd_toEndOf="parent" android:layout_marginEnd="8dp"
                app:layout_constraintVertical_bias="0.665"
    />
```

Dans les applications Android, l'authentification par Google Sign-in est une mesure de sécurité courante. Ici, vous pouvez voir un exemple de la façon dont ce processus fonctionne dans l'`activité principale`. Cet extrait sert de guide pour la mise en œuvre de l'authentification Google à l'aide de Kotlin.

```js
class MainActivity : AppCompatActivity() {
    private val RC_SIGN_IN = 9001
    private var mGoogleSignInClient: GoogleSignInClient? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.server_client_id))
            .requestEmail()
            .build()
        mGoogleSignInClient = GoogleSignIn.getClient(this, gso);
    }
    public override fun onStart() {
        super.onStart()
        val mGmailSignIn = findViewById<SignInButton>(R.id.sign_in_button)
        val account = GoogleSignIn.getLastSignedInAccount(this)
        Log.w("Sign In: ", account.toString())
        mGmailSignIn.setOnClickListener {
                signIn()
        }
    }
    public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == RC_SIGN_IN) {
            val task = GoogleSignIn.getSignedInAccountFromIntent(data)
            handleSignInResult(task)
        }
    }
    private fun handleSignInResult(completedTask: Task<GoogleSignInAccount>) {
        Log.w("Sign In: ", completedTask.toString())
        try {
            val account = completedTask.getResult(ApiException::class.java)
            val idToken = account!!.idToken
            Log.w("Sign In: ", idToken.toString())
            authCheck(idToken.toString())
        } catch (e: ApiException) {
            Log.w("Sign In: ", "signInResult:failed code=" + e.statusCode)
        }
    }
    private fun signIn() {
        val signInIntent = mGoogleSignInClient!!.signInIntent
        startActivityForResult(signInIntent, RC_SIGN_IN)
    }
    private fun authCheck(token: String) {
        // Instantiate the RequestQueue.
        val queue = newRequestQueue(this)
        val url = "https://pubsub.pubnub.com/v1/blocks/sub-key/sub-c-87dbd99c-e470-11e8-8d80-3ee0fe19ec50/google?token=$token"
        // Request a string response from the provided URL.
        val stringRequest = StringRequest(
            Request.Method.GET, url,
            Response.Listener<String> { response ->
                // Display the first 500 characters of the response string.
                Log.d("Response: ", response)
            },
            Response.ErrorListener {Log.d("Response: ", "Didn't Work!")})
        // Add the request to the RequestQueue.
        queue.add(stringRequest)
    }
}
```

Avec le code ci-dessus, votre application est désormais capable d'authentifier et de vérifier un utilisateur ! Une fois l'authentification réussie, l'étape suivante consiste à récupérer le jeton d'accès. Ce processus est assez similaire au précédent, mais cette fois, vous devez soumettre une requête `HTTP POST` à l'URL du jeton - `https://www.googleapis.com/oauth2/v4/token.` Cela peut être fait en utilisant JavaScript et le code peut être trouvé sur GitHub pour référence.

Votre fonction PubNub pourrait ressembler à ce qui suit :

```js
export default (request, response) => {
    const pubnub = require('pubnub');
    const xhr = require('xhr');
    let headersObject = request.headers;
    let paramsObject = request.params;
    let methodString = request.method;
    let bodyString = request.body;
    // Set the status code - by default it would return 200
    response.status = 200;
    // Set the headers the way you like
    
    var client_id = "your google client id"
    var client_secret = "your google client secret";
    var redirect = "https://pubsub.pubnub.com/v1/blocks/sub-key/sub-c-87dbd99c-e470-11e8-8d80-3ee0fe19ec50/Auth";
    
    response.headers['X-Custom-Header'] = 'CustomHeaderValue';
    var dataString = `client_id=${client_id}&client_secret=${client_secret}&redirect_uri=${redirect}&grant_type=authorization_code&code=CODE`;
    var url = `https://www.googleapis.com/oauth2/v4/token${dataString}`;
    var options = {
        "method": 'POST',
        "body": dataString,
    };
    
    console.log(dataString);
    return xhr.fetch(url, options).then((x) => {
        const body = JSON.parse(x.body);
        console.log(body);
         return response.send(body);
    }).catch((err) => {
        // console.log(err)
        return response.send("Malformed JSON body.");
    });
};
```

Rappelez-vous que vous devez obtenir le [code d'autorisation](https://developers.google.com/identity/sign-in/android/backend-auth) de votre utilisateur final Android, ce que vous pouvez faire en ajoutant ce code à votre fichier `MainActivity.kt`:

```js
Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data);
try {
    GoogleSignInAccount account = task.getResult(ApiException.class);
    String authCode = account.getServerAuthCode();
    // Show signed-un UI
    updateUI(account);
    // TODO(developer): send code to server and exchange for access/refresh/ID tokens
} catch (ApiException e) {
    Log.w(TAG, "Sign-in failed", e);
    updateUI(null);
}
```

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jgc/58eca79bde501d62117171964a0f2a36/Google-Oauth-Sign-in.gif?w=700&h=550)

Et avec cela, vous êtes sur la bonne voie pour mettre en œuvre la connexion Google en utilisant OAuth 2.0 dans votre application Android, en gardant l'expérience de l'utilisateur lisse et l'application sécurisée.

Après avoir testé votre application sur Internet, vous devriez être en mesure de naviguer dans l'ensemble du processus d'inscription sans aucun problème. Ce processus peut impliquer Google OAuth pour l'authentification, qui s'accompagne d'une variété de champs d'application, ou de permissions, qui peuvent être définis pour votre application. N'oubliez pas que l'expérience utilisateur doit être transparente.

Maintenant que vous avez franchi toutes les étapes, vous devriez mieux comprendre la différence entre l'authentification et l'autorisation basées sur l'identifiant du client OAuth. En vous appuyant sur ces connaissances, vous pouvez commencer à explorer ce que vous pouvez faire après qu'un utilisateur s'est connecté via l'écran de consentement OAuth.

Le nom du package de votre SDK côté client, qu'il s'agisse de JavaScript, de Kotlin ou d'une plateforme native, doit correspondre à celui enregistré dans votre projet Google Cloud. Si un contenu externe n'est pas accessible sur cette page, vous pouvez également le consulter à l'[adresse https://pubsub-quickstart-app.pubnub.com/signup.](https://pubsub-quickstart-app.pubnub.com/signup) Cette page doit démontrer l'utilisation correcte des URI de redirection et des paramètres de rappel requis pour OAuth.

**Besoin de l'assistance de PubNub ?**
--------------------------------------

Notre plateforme offre aux développeurs les ressources nécessaires pour construire, fournir et gérer l'interactivité en temps réel pour les applications web, les applications mobiles, les applications de bureau et les appareils IoT. Engagez les utilisateurs avec des notifications ou créez des applications Firebase privées avec des identifiants uniques pour des interactions avancées.

L'épine dorsale de notre plateforme est le réseau de messagerie périphérique en temps réel le plus vaste et le plus évolutif du secteur. Alimenté par les services Google Cloud et intégré à Chrome pour des capacités supplémentaires, il est complet avec plus de 15 points de présence dans le monde, supportant 800 millions d'utilisateurs actifs mensuels, et une fiabilité de 99,999%, vous n'aurez pas à vous soucier des pannes, des limites de concurrence, ou des problèmes de latence dus à des pics de trafic.

### **Comment commencer avec PubNub**

Familiarisez-vous avec les concepts de base de chaque application alimentée par PubNub en moins de 5 minutes en consultant le [Live Tour](https://www.pubnub.com/tour/introduction/). OpenID peut être un élément important de ces concepts. Créez un [compte PubNub](https://admin.pubnub.com/signup/) pour un accès instantané et gratuit aux clés PubNub. La [documentation PubNub](https://www.pubnub.com/docs) vous guidera tout au long du processus d'installation et de configuration, y compris les extraits de code ou "snippets" avec des paramètres détaillés, quel que soit votre cas d'utilisation ou votre [SDK](https://www.pubnub.com/docs) préféré.

#### Contenu

Quelle est la[différence entre l'authentification et l'autorisation ?](#h-0)[Comment Authn et Authz s'intègrent dans OAuthAuthentification](#h-1)[avec Google Sign-in sur AndroidAjouter le](#h-2)[bouton Google Sign-inAu](#h-3)[besoin de l'assistance de](#h-4)[PubNub](#h-5)[?](#h-4)

Comment PubNub peut-il vous aider ?
===================================

Cet article a été publié à l'origine sur [PubNub.com](https://pubnub.com/blog/creating-a-secure-login-on-android-using-google-oauth/)

Notre plateforme aide les développeurs à construire, fournir et gérer l'interactivité en temps réel pour les applications web, les applications mobiles et les appareils IoT.

La base de notre plateforme est le réseau de messagerie en temps réel le plus grand et le plus évolutif de l'industrie. Avec plus de 15 points de présence dans le monde, 800 millions d'utilisateurs actifs mensuels et une fiabilité de 99,999 %, vous n'aurez jamais à vous soucier des pannes, des limites de concurrence ou des problèmes de latence causés par les pics de trafic.

Découvrez PubNub
----------------

Découvrez le [Live Tour](https://www.pubnub.com/tour/introduction/) pour comprendre les concepts essentiels de chaque application alimentée par PubNub en moins de 5 minutes.

S'installer
-----------

Créez un [compte PubNub](https://admin.pubnub.com/signup/) pour un accès immédiat et gratuit aux clés PubNub.

Commencer
---------

La [documentation PubNub](https://www.pubnub.com/docs) vous permettra de démarrer, quel que soit votre cas d'utilisation ou votre [SDK](https://www.pubnub.com/docs).