Erstellen einer sicheren Anmeldung unter Android mit Google OAuth
Published: 2024-03-11 01:03:50

Angesichts von schätzungsweise 4,55 Milliarden Menschen [, die](https://www.statista.com/statistics/278414/number-of-worldwide-social-network-users/) im Januar 2022 [mindestens ein Social-Media-Profil haben](https://www.statista.com/statistics/278414/number-of-worldwide-social-network-users/), ist es nicht verwunderlich, dass die meisten Anwendungen über eine Art von sozialer Anmeldung verfügen, die es den Nutzern erleichtert, sich anzumelden. Dies ist der Schlüssel zur Verbesserung des Benutzererlebnisses. Aus der Entwicklungsperspektive gibt es eine wichtige Gemeinsamkeit zwischen all diesen Anbietern von Social Sign-Ins, wie Facebook, Twitter und Google. Dieses gemeinsame Puzzlestück ist **OAuth**, genauer gesagt **OAuth 2.0**. Aber es geht nicht nur um die Verwendung von OAuth, sondern auch um das richtige Verständnis von Scopes, OAuth Client ID und dem OAuth Zustimmungsbildschirm für eine optimale Implementierung.

Was ist der Unterschied zwischen Authentifizierung und Autorisierung?
---------------------------------------------------------------------

[Authentifizierung](https://www.pubnub.com/learn/glossary/what-is-authentication/) (authn) bezieht sich auf den Prozess der Identifizierung oder Verifizierung des Nutzers, in diesem Zusammenhang kann dies über Google OAuth erfolgen. Andererseits geht es bei der [Autorisierung](https://www.pubnub.com/learn/glossary/what-is-authorization/) (authz) darum, ob der authentifizierte Nutzer die _\_Berechtigungen\__ hat, _die_ für den Zugriff auf eine bestimmte Ressource _erforderlich sind_. Hier spielen Scopes eine entscheidende Rolle, da sie die Berechtigungen in OAuth definieren.

Sowohl authn als auch authz sind eng miteinander verbunden und finden sich typischerweise innerhalb des OAuth 2.0-Prozesses. Für beide Teile des Prozesses benötigen wir einen Server, auf dem unsere [Client-ID und das Client-Geheimnis](https://www.oauth.com/oauth2-servers/client-registration/client-id-secret/) gespeichert werden, was mit Google Cloud verwaltet werden kann.

Wie Authn und Authz in OAuth passen
-----------------------------------

**OAuth ist der eigentliche Standard für die Autorisierung**. Ein großes Missverständnis unter Entwicklern ist, dass Authn (Authentifizierung) ein Teil davon ist. OAuth 2.0 beinhaltet auch Authn, insbesondere auf sozialen Plattformen wie Google, wo die Prozesse nacheinander mit einer Kombination aus nativen Technologien, Javascript oder Kotlin ausgeführt werden.

Hier ist ein Überblick über den Prozess:

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

Wie Sie sehen können, gibt es zwei Hauptkomponenten. Zunächst benötigen wir die erforderliche Berechtigung des Benutzers. Dies geschieht, wenn der Benutzer angemeldet ist. Viele APIs binden hier den Authentifizierungsanteil von OAuth mit openid ein. Sobald wir die Genehmigung von der Autorität des Benutzerkontos erhalten haben, können wir mit der Kommunikation mit dem Eigentümer der Ressource beginnen. Nachdem wir die Genehmigung an den Autorisierungsserver gesendet haben, erhalten wir ein Zugriffstoken zurück. Mit dem Zugriffstoken können wir nun auf die Informationen zugreifen, die wir in Bezug auf den Benutzer benötigen.

Bei der Implementierung von OAuth 2.0 ist es von entscheidender Bedeutung, die korrekten Redirect-URIs und Callbacks einzurichten, da jeder kleine Fehler in diesen Parametern zum Scheitern des authn- und authz-Prozesses führen kann. Um die Sicherheit und das Nutzererlebnis zu verbessern, bietet Google außerdem eine Chrome-Erweiterung für OAuth 2.0 an.

Authentifizierung mit Google Sign-in auf Android
------------------------------------------------

Die Authentifizierung von Anwendungen für Android, insbesondere mit Google Sign-in, ist eine gängige Sicherheitsmaßnahme. Aber es geht nicht nur darum, Google zu Ihrer Android-Anwendung hinzuzufügen, sondern auch darum, OAuth zu verstehen und sich mit dem SDK und der Google-API auseinanderzusetzen.

Um mit Google Sign-in zu beginnen, verwenden wir [Functions](https://www.pubnub.com/docs/functions/overview), eine Funktion von PubNub, die uns als Server dient. Diese Funktionen werden die Implementierung von Benachrichtigungen im OAuth-Prozess vereinfachen. Die Codeschnipsel für den OAuth-Prozess finden Sie ebenfalls auf GitHub.

Stellen Sie außerdem sicher, dass Sie Ihr [Google-API-Konto](https://developers.google.com/identity/sign-in/android/start-integrating) mit dem richtigen Paketnamen eingerichtet haben und Ihre OAuth-Client-ID und den OAuth-Zustimmungsbildschirm konfiguriert haben.

Als Nächstes fügen wir Google zu unserer Android-Anwendung hinzu, damit wir den Anmeldeprozess starten können. Stellen Sie zunächst sicher, dass Sie die Zeile `repositories { google() }` in Ihrer Gradle-Datei auf Projektebene haben. Dadurch wird Ihre Anwendung geöffnet, um das Google SDK zu nutzen.

Wechseln Sie dann zur Gradle-Datei auf App-Ebene und aktualisieren Sie die Auth-Abhängigkeit von Google Play Services. Die aktuellste Version ist `com.google.android.gms:play-services-auth:19.2.0`(Stand: Januar 2022).

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

Obwohl wir nun die aktualisierte Abhängigkeit zu unserem Projekt hinzugefügt haben, können wir den Anmeldeprozess noch nicht durchführen. Sie müssen die Android-Manifestdatei bearbeiten, um die Internet-Berechtigungen für Firebase hinzuzufügen:

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

### Hinzufügen der Google-Anmeldeschaltfläche

Dieser Schritt ist recht einfach. Fügen Sie die Anmeldekomponente in die Datei `activity_main.xml` ein. Die Anmeldeschaltfläche wird von Google gestaltet, aber lesen Sie sich vorsichtshalber [die Hinweise von Google zur Marke](https://about.google/brand-resource-center/) durch. Denken Sie daran, dass eine gute Nutzererfahrung bei Desktop-Apps entscheidend ist, und dazu gehören auch die Gestaltung und die Bezeichner, die auf der Anmeldeschaltfläche verwendet werden.

```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"
    />
```

In Android-Apps ist die Authentifizierung mit Google Sign-in eine gängige Sicherheitsmaßnahme. Hier sehen Sie ein Beispiel dafür, wie dieser Prozess in der `MainActivity` funktioniert. Dieses Snippet dient als Leitfaden für die Implementierung von Google Sign-in mit 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)
    }
}
```

Mit dem obigen Code ist Ihre Anwendung nun in der Lage, einen Benutzer zu authentifizieren und zu verifizieren! Nach erfolgreicher Authentifizierung besteht der nächste Schritt darin, das Access-Token abzurufen. Dieser Prozess ähnelt dem vorherigen, nur dass Sie diesmal eine `HTTP-POST-Anfrage` an die Token-URL senden - `https://www.googleapis.com/oauth2/v4/token.` Dies kann mit JavaScript durchgeführt werden und der Code kann auf GitHub als Referenz gefunden werden.

Ihre PubNub-Funktion könnte wie die folgende aussehen:

```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.");
    });
};
```

Denken Sie daran, dass Sie den [Autorisierungscode](https://developers.google.com/identity/sign-in/android/backend-auth) von Ihrem Android-Endbenutzer erhalten müssen, was Sie erreichen können, indem Sie diesen Code zu Ihrer `MainActivity.kt-Datei` hinzufügen:

```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)

Und damit sind Sie auf dem besten Weg, die Google-Anmeldung mit OAuth 2.0 in Ihrer Android-App zu implementieren, so dass die Benutzererfahrung reibungslos und die App sicher bleibt.

Nachdem Sie Ihre Anwendung mit dem offenen Internet getestet haben, sollten Sie in der Lage sein, ohne Probleme durch den gesamten Anmeldeprozess zu navigieren. Dieser Prozess kann Google OAuth für die Authentifizierung beinhalten, was eine Vielzahl von Bereichen oder Berechtigungen mit sich bringt, die für Ihre App festgelegt werden können. Denken Sie daran, dass die Benutzererfahrung nahtlos sein sollte.

Nachdem Sie nun alle Schritte durchlaufen haben, sollten Sie den Unterschied zwischen OAuth-Client-ID-basierter Authentifizierung und Autorisierung besser verstehen. Aufbauend auf diesem Wissen können Sie nun untersuchen, was Sie tun können, nachdem sich ein Benutzer über den OAuth-Zustimmungsbildschirm angemeldet hat.

Der Paketname in Ihrem client-seitigen SDK, sei es JavaScript, Kotlin oder nativ für eine andere Plattform, sollte mit dem Namen übereinstimmen, der in Ihrem Google Cloud-Projekt registriert ist. Wenn ein externer Inhalt auf dieser Seite nicht zugänglich ist, können Sie ihn auch unter [https://pubsub-quickstart-app.pubnub.com/signup einsehen.](https://pubsub-quickstart-app.pubnub.com/signup) Diese Seite sollte die korrekte Verwendung der für OAuth erforderlichen Redirect-URIs und Callback-Parameter demonstrieren.

**Benötigen Sie die Hilfe von PubNub?**
---------------------------------------

Unsere Plattform bietet Entwicklern die Ressourcen, um Echtzeit-Interaktivität für Web-Apps, mobile Apps, Desktop-Apps und IoT-Geräte zu erstellen, bereitzustellen und zu verwalten. Binden Sie Benutzer mit Benachrichtigungen ein oder erstellen Sie private Firebase-Anwendungen mit eindeutigen Identifikatoren für erweiterte Interaktionen.

Das Rückgrat unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Es wird von Google Cloud-Services unterstützt und ist für zusätzliche Funktionen in Chrome integriert. Mit über 15 Präsenzpunkten weltweit, der Unterstützung von 800 Millionen monatlich aktiven Nutzern und einer Zuverlässigkeit von 99,999 % müssen Sie sich keine Gedanken über Ausfälle, Gleichzeitigkeitsgrenzen oder Latenzprobleme aufgrund von Verkehrsspitzen machen.

### **Wie Sie mit PubNub beginnen**

Machen Sie sich in weniger als 5 Minuten mit den Kernkonzepten hinter jeder PubNub-basierten Anwendung vertraut, indem Sie die [Live Tour](https://www.pubnub.com/tour/introduction/) besuchen. OpenID kann ein wichtiger Teil dieser Konzepte sein. Melden Sie sich für einen [PubNub-Account](https://admin.pubnub.com/signup/) an, um sofortigen und kostenlosen Zugang zu PubNub-Schlüsseln zu erhalten. Die [PubNub-Dokumente](https://www.pubnub.com/docs) führen Sie durch den Installations- und Einrichtungsprozess, einschließlich der Codeschnipsel oder "Snippets" mit detaillierten Parametern, unabhängig von Ihrem Anwendungsfall oder bevorzugten [SDK](https://www.pubnub.com/docs).

#### Inhalt

[Was ist der Unterschied zwischen Authentifizierung und Autorisierung?](#h-0)[Wie Authn und Authz in OAuth passenAuthentifizierung](#h-1)[mit Google Sign-in auf AndroidHinzufügen](#h-2)[des Google Sign-in](#h-3)[ButtonsBenötigen](#h-4) Sie[die Hilfe von PubNub?](#h-4)[Wie Sie mit PubNub beginnen](#h-5)

Wie kann PubNub Ihnen helfen?
=============================

Dieser Artikel wurde ursprünglich auf [PubNub.com](https://pubnub.com/blog/creating-a-secure-login-on-android-using-google-oauth/) veröffentlicht.

Unsere Plattform hilft Entwicklern bei der Erstellung, Bereitstellung und Verwaltung von Echtzeit-Interaktivität für Webanwendungen, mobile Anwendungen und IoT-Geräte.

Die Grundlage unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Mit über 15 Points-of-Presence weltweit, die 800 Millionen monatlich aktive Nutzer unterstützen, und einer Zuverlässigkeit von 99,999 % müssen Sie sich keine Sorgen über Ausfälle, Gleichzeitigkeitsgrenzen oder Latenzprobleme aufgrund von Verkehrsspitzen machen.

PubNub erleben
--------------

Sehen Sie sich die [Live Tour](https://www.pubnub.com/tour/introduction/) an, um in weniger als 5 Minuten die grundlegenden Konzepte hinter jeder PubNub-gestützten App zu verstehen

Einrichten
----------

Melden Sie sich für einen [PubNub-Account](https://admin.pubnub.com/signup/) an und erhalten Sie sofort kostenlosen Zugang zu den PubNub-Schlüsseln

Beginnen Sie
------------

Mit den [PubNub-Dokumenten](https://www.pubnub.com/docs) können Sie sofort loslegen, unabhängig von Ihrem Anwendungsfall oder [SDK](https://www.pubnub.com/docs)