Hallo!

Brauchen Sie Hilfe? Wir sind hier!

Unterstützungssymbol
miniOrange E-Mail-Support
Erfolg

Vielen Dank für Ihre Anfrage. Unser Team wird sich in Kürze mit Ihnen in Verbindung setzen.

Wenn Sie innerhalb von 24 Stunden nichts von uns hören, senden Sie bitte eine Folge-E-Mail an info@xecurify.com

Search Results:

×

OAuth Single Sign-On (SSO) für JavaScript-Frameworks


Die JavaScript OAuth Single Sign-On (SSO)-Lösung von miniOrange ermöglicht eine sichere, nahtlose Authentifizierung für Anwendungen, die mit gängigen JavaScript-Frameworks und -Bibliotheken erstellt wurden, wie React, Vue.js, Next.js und AngularDurch die Verwendung von JSON Web Tokens (JWT) können Benutzer bequem mit nur einem einzigen Satz Anmeldeinformationen auf mehrere Anwendungen zugreifen, was die Sicherheit und das Benutzererlebnis erheblich verbessert.

Integrieren Sie OAuth 2.0 und OpenID Connect mühelos in Ihre bestehenden JavaScript-Anwendungen und verbinden Sie diese nahtlos mit Identitätsanbietern wie Microsoft Entra ID, Okta, AWS Cognito und anderen. Bieten Sie Ihren Nutzern zudem komfortable Anmeldeoptionen über soziale Netzwerke wie Google, Facebook, Twitter und LinkedIn. Vereinfachen Sie Ihre Anmeldeprozesse, erhöhen Sie die Sicherheit und sorgen Sie mit miniOrange für ein reibungsloses Benutzererlebnis in all Ihren JavaScript-basierten Anwendungen. Einmaliges Anmelden.

Mit miniOrange JavaScript OAuth SSO erhalten Sie:

  • Nahtlose Benutzeranmeldung.
  • Endlose Anpassungen Ihrer Anmeldeformulare und -seiten.
  • Vereinfachtes Onboarding von Kunden oder Benutzern.


Mit externer Benutzerquelle verbinden


miniOrange bietet Benutzerauthentifizierung aus verschiedenen externen Quellen, die Verzeichnisse (wie ADFS, Microsoft Active Directory, OpenLDAP, AWS usw.), Identitätsanbieter (wie Microsoft Entra ID, Okta, AWS) und viele mehr. Sie können Ihren bestehenden Verzeichnis-/Benutzerspeicher konfigurieren oder Benutzer in miniOrange hinzufügen.



Voraussetzungen:

Bitte stellen Sie sicher, dass Ihr Organisations-Branding bereits unter Anpassung >> Login- und Registrierungs-Branding im linken Menü des Dashboards.


Konfigurieren Sie die OAuth-Anwendung auf miniOrange

  • Melden Sie sich für miniOrange an Website und melden Sie sich mit Ihren Anmeldeinformationen an, um das folgende Dashboard anzuzeigen.
  • JavaScript OAuth Single Sign-On (SSO) miniOrange Admin-Konsole

  • Navigieren Sie zu der Apps Abschnitt im Menü auf der linken Seite.
  • Klicken Sie auf die Anwendung hinzufügen Schaltfläche in der oberen rechten Ecke der Seite.
  •  JavaScript OAuth Single Sign-On (SSO) Anwendung hinzufügen

  • Suchen Sie nach „OAuth“ und wählen Sie OAuth2/OpenID Connect vom MiniOrange-Symbol.
  • JavaScript OAuth Single Sign-On (SSO) Suchen Sie nach OAuth und wählen Sie OAuth2/OpenID Connect

  • Geben Sie einen Namen für Ihre Anwendung in das Feld Client-Name Feld und geben Sie die Weiterleitungs-URL (das wäre „Ihre_Domäne/sso/callback“) und klicken Sie auf GespeichertSie können auch Abmelde-URIs und geben Sie an, wohin Benutzer nach der Abmeldung umgeleitet werden sollen (z. B. https://Ihre_Domäne/Anmeldung).
  • JavaScript OAuth Single Sign-On (SSO) Geben Sie Ihre App-Details ein

  • Die Toast-Meldung „App wurde erfolgreich konfiguriert.“ wird angezeigt und bestätigt die erfolgreiche Erstellung der OAuth-Anwendung auf miniOrange.
  • JavaScript OAuth Single Sign-On (SSO) – Erhalt einer Nachricht beim Konfigurieren der App

  • Suchen Sie den Namen Ihrer Anwendung in der Anwendungsliste, klicken Sie auf das Menü mit den drei Punkten und wählen Sie Bearbeiten.
  •  JavaScript OAuth Single Sign-On (SSO) Klicken Sie auf die drei Punkte und wählen Sie Bearbeiten

  • Jetzt kopieren Kunden ID und Kundengeheimnis und bewahren Sie es für die weitere Verwendung an einem sicheren Ort auf.
  •  JavaScript OAuth Single Sign-On (SSO) Client-ID und Client-Geheimnis kopieren


Konfigurieren Sie OAuth in JavaScript-Framework-Anwendungen (React, Angular, Vue, Next.js usw.).


1. Installieren Sie den Connector

  • Führen Sie im Stammverzeichnis Ihres Projekts (wo sich die Datei package.json befindet) den folgenden Befehl aus:
                        npm i mo-oauth-sdk
                    

2. Konfigurieren Sie OAuth in Ihrer Anwendung

  • Um OAuth einzurichten, erstellen Sie eine config.js Datei in Ihrem Komponentenordner und importieren Sie die Klasse OAuthConfig, um Ihre OAuth-Konfiguration zu konfigurieren. Die folgenden Details wurden bei der Erstellung der OAuth-Anwendung in miniOrange bereitgestellt.
    Client_ID Ihre Anwendungs-Client-ID, die wir zuvor kopiert haben von werden auf dieser Seite erläutert
    Client_Geheimnis Ihr Anwendungs-Client-Geheimnis, das wir zuvor kopiert haben von werden auf dieser Seite erläutert
    BASE_URL Ihre Basis-URI sollte folgendermaßen aussehen: https://<YOUR_DOMAIN>.xecurify.com/moas. Es ist Ihr Markenname, gefolgt von xecurify.com/moas.
    REDIRECT_URI Dies ist dieselbe Weiterleitungs-URI, die wir bei der Konfiguration der OAuth-App in miniOrange hinzugefügt haben. Sie sollte folgendermaßen aussehen: https:// /sso/callback
    LOGOUT_REDIRECT_URI Dies ist dieselbe Abmelde-URL, die wir bei der Konfiguration der OAuth-App in miniOrange hinzugefügt haben. Sie sollte folgendermaßen aussehen: https:// /Login
    BROKER_URI Wenn Sie einen anderen externen IDP als miniOrange verwenden, gehen Sie zu Apps > OAuth-Endpunkte > Autorisierungsendpunkt > 2. Broker-URL kopieren
  • Schritte zum Abrufen der Broker-URL

    • Navigieren Apps .
    •  JavaScript OAuth Single Sign-On (SSO) Navigieren Sie zu Apps

    • Suchen Sie nach der von Ihnen erstellten App, klicken Sie auf die Menüoption und wählen Sie OAuth-Endpunkte.
    •  JavaScript OAuth Single Sign-On (SSO) Suche nach App und wähle OAuth-Endpunkte

    • Kopieren Sie die zweite URI aus dem Abschnitt „Autorisierungsendpunkt“ unter „OAuth-Endpunkte“. Dabei handelt es sich um Ihre Broker-URI.
    •  JavaScript OAuth Single Sign-On (SSO) Kopieren des Autorisierungsendpunkts


Hinweis: Speichern Sie Ihre App-Anmeldeinformationen sicher in Umgebungsvariablen oder einer Eigenschaftendatei und verwenden Sie sie hier.


config.js

            
              import { OAuthConfig } from 'mo-oauth-sdk';
              const conf = new OAuthConfig();
              conf.setClientId(YOUR_CLIENT_ID);
              conf.setClientSecret(YOUR_CLIENT_SECRET);
              conf.setBaseUrl(YOUR_BASE_URL);
              conf.setRedirectUri(YOUR_REDIRECT_URI);
              conf.setLogoutRedirectUri(YOUR_LOGOUT_URI); //optional
              conf.setBrokerUri(YOUR_BROKER_URI); //optional
              export default config;
            
           


3. Starten Sie den Autorisierungsprozess

  • Erstellen Sie einen Login-Button und verwenden Sie die Startautorisierung Methode aus der mo-oauth-sdk-Bibliothek, um den OAuth-Autorisierungsprozess zu starten. Sie müssen das Konfigurationsobjekt wie unten gezeigt an die Funktion „startAuthorization“ übergeben:
                        
                          import {startAuthorization} from 'mo-oauth-sdk';
                          import conf from './Conf';  //Adjust path accordingly
                          .
                          .
                          .
    
                          const login = ()=>{
                            startAuthorization(conf)
                          }
                        
                    
  • Wenn Benutzer jetzt auf die Anmeldeschaltfläche klicken, beginnt der OAuth-Flow.

4. Rückrufe verarbeiten

Sobald sich der Benutzer erfolgreich authentifiziert hat, leitet der Autorisierungsserver ihn mit Autorisierungsparametern zur /sso/callback-Route Ihrer Anwendung weiter.

So gehen Sie damit um:

  • Definiere das /sso/callback Route in Ihrer Anwendung.
  • Erstellen einer Callback-Komponente und rendern Sie es, wenn auf die obige Route zugegriffen wird.
  • aufrufen handleCallbackUri innerhalb der Rückrufkomponente, um die Autorisierungsantwort zu verarbeiten.
  • Token extrahieren aus der Antwort und speichern Sie sie sicher (vermeiden Sie lokaler Speicher aufgrund von Sicherheitsrisiken; bevorzugen Sie reine HTTP-Cookies oder eine sichere Speicherung).
  • Benutzerattribute abrufen Verwendung der Zugangstoken, erstellen Sie eine Sitzung und leiten Sie den Benutzer zum Dashboard weiter.

5. Schritte zum Einrichten der Rückrufroute in JS-basierten Frontend-Anwendungen

Sie müssen die Route /sso/callback in Ihrer Anwendung definieren und eine Komponente erstellen, die sie verarbeitet.


  • Installieren Sie React Router, falls es noch nicht installiert ist:
                                npm install react-router-dom
                            
  • Callback-Komponente erstellen:
                                
                                import React, { useEffect} from "react";
                                import { handleCallbackUri, TokenHandler} from 'mo-oauth-sdk';
                                import conf from './Conf'; //adjust the path accordingly
    
    
                                function Callback() {
    
    
                                    useEffect(() => {
                                        const handleCallback = async () => {
                                        const { accessToken, refreshToken, error } = await handleCallbackUri(conf, window.location.href);
    
    
                                        if (error) {
                                        // Handle errors if any
                                        return;
                                        }
                                        //Store tokens securely in your preferred storage.
                                        if (accessToken) {
                                        // Process access token and retrieve user details
                                        const { user, error } = await TokenHandler.handleAccessToken(accessToken, conf);
                                        if (user) {
                                        // Store user details securely and navigate to dashboard
                                        } else {
                                        // Handle errors if any
                                        return;
                                        }
                                        }
                                    };
                                    handleCallback();
                                    }, []);
    
    
                                    return (
                                    <div>
                                      <img src="https://i.gifer.com/ZKZx.gif" alt="Loading.." />
                                      </div>
                                    );
                                    }
    
    
                                    export default Callback;
    
                                
                            
  • Definieren Sie die Route in Ihrer App.js oder App.tsx
                                
                                import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
                                import Callback from "./Callback"; //adjust path accordingly
                                import Home from "./Home"; 
                                    function App() {
                                    return (
                                    <Router>
                                    <Routes>
                                        {/* Existing routes..*/}
                                        <Route path="/" element={<Home />} />
                                        
                                        {/* Add new SSO callback handler here*/}
                                        <Route path="/sso/callback" element={<Callback />} />
                                        </Routes>
                                        </Router>
                                    );
                                    }
    
    
                                    export default App;
                                
                            
  • Definieren Sie die Route in app.routes.ts:
                                
                                import { Routes } from '@angular/router';
                                import { CallbackComponent } from './callback/callback.component';
    
    
                                export const routes: Routes = [
                                { path: 'sso/callback', component: CallbackComponent }
                                ];                    
                                
                            
  • Erschaffung callback.component.ts:
                                
                                import { Component, OnInit } from '@angular/core';
                                import { handleCallbackUri, TokenHandler } from 'mo-oauth-sdk';
                                import conf from './Conf';  //adjust the path accordingly
    
    
                                @Component({
                                …
                                })
    
    
                                export class CallbackComponent  implements OnInit {
    
    
                                async ngOnInit(): Promise {
                                const { accessToken, refreshToken, error } = await handleCallbackUri(conf, window.location.href);
    
    
                                if (error) {
                                // Handle errors if any
                                return;
                                }
    
    
                                if (accessToken) {
                                // Store and Process access token to retrieve user details
                                const { user, error } = await TokenHandler.handleAccessToken(accessToken, this.myconfig);
    
    
                                if (user) {
                                    // Store user details securely and navigate to dashboard
                                } else {
                                    // Handle errors if any
                                    return;
                                }
                                }
                                }
                            
                                
                            
  • Vue Router installieren
                                npm install vue-router@4
                            
  • Erschaffung Rückruf.vue Komponente:
                                
                                import { onMounted } from 'vue';
                                import { handleCallbackUri, TokenHandler } from 'mo-oauth-sdk';
                                import conf from './Conf'; //adjust the path accordingly
    
    
                                onMounted(async () => {
                                const { accessToken, refreshToken, error } = await handleCallbackUri(conf, window.location.href);
    
    
                                if (error) {
                                // Handle errors if any
                                return;
                                }
    
    
                                //Store tokens securely in your preferred storage.
                                    if (accessToken) {
                                    // Process access token and retrieve user details
                                    const { user, error } = await TokenHandler.handleAccessToken(accessToken, conf);
                                    if (user) {
                                    // Store user details securely and navigate to dashboard
                                    } else {
                                    // Handle errors if any
                                    return;
                                    }
                                    }
                                }
                                });
                                
                            
  • Erstellen Sie eine Datei router.js oder router.ts, falls noch nicht geschehen, und registrieren Sie die Rückrufroute darin.
                                
                                    import { createRouter, createWebHistory } from 'vue-router';
                                    import Home from './components/Home.vue';
                                    import Dashboard from './components/Dashboard.vue';
    
    
                                    const routes = [
                                    {
                                    // Your existing routes
                                    },
                                    {
                                    //add callback route
                                    path: '/callback',
                                    name: 'Callback',
                                    component: Callback
                                    }
                                    ];
                                    const router = createRouter({
                                    history: createWebHistory(),
                                    routes
                                    });
    
    
                                    export default router;
                                
                            

6. Abmelden (Sitzung löschen) Optional

  • Um den Benutzer abzumelden und die miniOrange-Sitzung aus dem Browser zu löschen, rufen Sie die Abmeldung von der Bibliothek bereitgestellte Funktion.
  • Siehe den Codeausschnitt unten:
                        
                        import { logout} from "mo-oauth-sdk";
                        import conf from './Conf'; //adjust the path accordingly
                        const logoutUser= async()=>{
                            logout(conf);
                        }
                    

7. Sitzung prüfen (optional)

Sitzung prüfen

  • Sie können die Gültigkeit des Zugriffstokens mit der Methode isSessionActive überprüfen. Diese Methode prüft, ob das Token noch gültig oder abgelaufen ist. Sie können diese Prüfung bei jedem Seitenaufruf oder in regelmäßigen Abständen während der Benutzeraktivität durchführen.
  • Sie können diese Prüfung bei jedem Seitenaufruf oder in regelmäßigen Abständen während der Benutzeraktivität durchführen.
                                
                                    import {isSessionActive} from "mo-oauth-sdk";
                                    
                                    const validateToken=async() => {
                                        let response = await isSessionActive(conf, accessToken)
                                        if(response)
                                            //session is active do nothing
                                            else{
                                        //logout user and redirect to session expiration page
                                        }
                                    }
                                
                            
  • Wenn das Token abgelaufen ist, können Sie entweder mithilfe des Aktualisierungstokens ein neues Zugriffstoken erhalten oder den Benutzer abmelden und ihn auf eine Seite mit abgelaufener Sitzung umleiten und ihn auffordern, sich erneut anzumelden.
  • Neues Zugriffstoken anfordern:
                                
                                import {  TokenHandler} from "mo-oauth-sdk";
    
    
    
                                const getNewToken= async()=>{
                                    const refreshToken =  //fetch your stored refresh token
                                    const {error, access_token} = await TokenHandler.getNewAccessToken(refreshToken, conf);
                                    
                                        if(!error){
                                            //update new access token
                                            return;
                                        }
                                        //handle errors if any
                                        console.log("Error in getting new access token..", error)
                                    }
    
                                
                            

8. Testen Sie die OAuth-Authentifizierung

Erwarteter Fluss:

  • Der Benutzer klickt auf die Login .
  • Das Startautorisierung Die Methode leitet sie zur Anmeldeseite des Autorisierungsservers weiter.
  • Nach erfolgreicher Authentifizierung leitet der Autorisierungsserver den Benutzer zurück zum Anwendungsserver. /sso/callback-Route.
  • Der Callback-Handler verarbeitet die Antwort, ruft Token ab und meldet den Benutzer an.

Damit ist der OAuth-Anmeldevorgang abgeschlossen und der Benutzer kann sicher auf die Anwendung zugreifen.


Möchten Sie eine Demo planen?

Demo anfordern
  



Unsere anderen Identity & Access Management-Produkte