Zum Inhalt springen

OBS/Kostenpflichtige Module/REST-Server/Beispiele/Daten-Abruf mit JWT-Anmeldung: Unterschied zwischen den Versionen

Aus OBS Wiki
MINERVA-Rademacker (Diskussion | Beiträge)
Navigationsvorlage mit Vorlage:-Praefix [Volltext ersetzt] [Styleguide-Abweichung: Seitenkopf der Altseite]
MINERVA-Rademacker (Diskussion | Beiträge)
Überschrift an den neuen Titel angeglichen, Links auf die neuen Titel umgestellt, Umlaute in Kommentaren und Meldungstexten [Volltext ersetzt]
 
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
{{Vorlage:Kostenpflichtige Module}}
{{Vorlage:Kostenpflichtige Module}}
{{Seitentyp|Referenz}}
= Daten-Abruf mit JWT-Anmeldung =


=Beispiel 1: Daten-Abruf mit JWT-Authentifizierung=
In diesem Beispiel zeigt eine Webseite Steuerungs-Variablen aus OBS an – live, ohne Export und ohne eigene Datenbank. Der Zugang verlangt eine JWT-Anmeldung: Jeder Benutzer meldet sich zuerst an und ruft die Daten dann mit seinem Token ab.


In diesem Beispiel werden Steuerungs-Variablen aus OBS abgerufen und auf einer Webseite ausgegeben. Der Zugang ist mit JWT-Pflicht eingerichtet, der Konsument muss sich daher zuerst anmelden und einen Token bezogen haben.
== Einrichtung in OBS ==
 
* '''Server-Profil:''' TLS-Profil ''Public-API'' mit einer Bindung auf Port 443
==Einrichtung in OBS==
 
* '''Server-Profil:''' Standard-TLS-Profil ''Public-API'' mit Bindung 0.0.0.0:443
* '''Zugang:''' ''Web-Dashboard''
* '''Zugang:''' ''Web-Dashboard''
** API-Key: zufällig generiert
** '''API-Key:''' vom System erzeugt
** JWT aktiv, JWT-Endpunkt ''oauth'', JWT-Key zufällig, JWT-Exp 60 (Minuten)
** Haken '''JWT-Authentifizierung''' gesetzt, '''Endpunkt''' <code>/oauth</code>, '''Secret-Key''' zufällig, '''Lebenszeit (Min)''' ''60''
** CORS-Origins: ''https://dashboard.firma.de''
** '''CORS-Origin:''' <code><nowiki>https://dashboard.example.com</nowiki></code>
* '''Endpunkt:''' ''steuerung/v1'', dem Profil ''Public-API'' zugeordnet
* '''Endpunkt:''' '''Pfad-Template''' <code>/steuerung/v1</code>, '''Server''' ''Public-API''
* '''Berechtigung:''' Zugang ''Web-Dashboard'' für Endpunkt ''steuerung/v1'' freigeschaltet
* '''Berechtigung:''' Zugang ''Web-Dashboard'' für den Endpunkt <code>/steuerung/v1</code> freigeschaltet


==JWT-Authentifizierungs-Skript (Zugang)==
Felder und Bedienung: [[OBS/Kostenpflichtige Module/REST-Server/Zugänge|Zugänge]] und [[OBS/Kostenpflichtige Module/REST-Server/Endpunkte|Endpunkte]].


Wird über die Zugänge-Liste mit '''F7''' geöffnet. Prüfen, ob Benutzername/Passwort gegen die OBS-Benutzerverwaltung passen.
== Anmeldeskript des Zugangs ==
Das Anmeldeskript öffnen Sie in der Zugänge-Liste mit {{F7}}. Es prüft Benutzername und Passwort und schreibt bei Erfolg die Angaben für das Token. Tabelle, Felder und <code>HashPasswort</code> stehen für Ihre eigene Prüfung. Den vollständigen Ablauf mit Erneuern und Abmelden beschreibt [[OBS/Kostenpflichtige Module/REST-Server/Anmeldung mit JWT|Anmeldung mit JWT]].


<syntaxhighlight lang="pascal" line>
<syntaxhighlight lang="delphi">
procedure Authenticate(oReader: TxRestReader; oWriter: TxRestWriter);
procedure Authenticate(oReader: TxRestReader; oWriter: TxRestWriter);
var cUser : string;
var cUser: string;
     cPass : string;
     cPass: string;
     cSql : string;
     cSql : string;
     qUser : TxFQuery;
     qUser: TxFQuery;
     lOk   : Boolean;
     lOk : Boolean;
begin
begin
     cUser := '';
     cUser := '';
Zeile 32: Zeile 32:
     oReader.Str('password', cPass);
     oReader.Str('password', cPass);


     cSql := 'SELECT u_nr, u_name FROM benutzer' +
     cSql := 'SELECT u_nr, u_name FROM BENUTZER' +
             ' WHERE u_login = ' + DB_SQLVal(cUser) +
             ' WHERE u_login = '         + DB_SqlVal(cUser, 'C') +
             ' AND u_passwort_hash = ' + DB_SQLVal(HashPasswort(cPass)) +
             '   AND u_passwort_hash = ' + DB_SqlVal(HashPasswort(cPass), 'C') +
             ' AND u_aktiv = ' + DB_SQLVal('1');
             '   AND u_aktiv = '         + DB_SqlVal('1', 'C');


     // DB_SOpen liefert true, wenn die ABFRAGE lief - nicht, wenn ein
     // DB_SOpen meldet nur, dass die Abfrage lief. Gefunden ist erst bei not EoF.
    // Datensatz gefunden wurde. Ohne die EoF-Pruefung wuerde jede
    // Anmeldung gelingen, sobald das SQL fehlerfrei ist.
     lOk := false;
     lOk := false;
     if (DB_SOpen(oDB, cSql, qUser)) then begin
     if (DB_SOpen(oDB, cSql, qUser)) then begin
Zeile 59: Zeile 57:
</syntaxhighlight>
</syntaxhighlight>


{{Hinweis|Hier steht in ''_OBS_JWT_ID'' die Benutzernummer - derselbe Wert also bei
Das Skript schreibt kein <code>_OBS_JWT_REFRESH_ID</code>. Die Antwort enthält deshalb kein Refresh-Token, und der Benutzer meldet sich nach Ablauf der '''Lebenszeit (Min)''' neu an.
jeder Anmeldung desselben Benutzers. Das ist zulässig: der Server führt seine
Sitzungen über eigene Kennungen (''sid''/''rid''), nicht über das ''jti'' des
Skripts. Mehrfache und parallele Anmeldungen eines Benutzers sind damit
unproblematisch.}}
 
==Endpunkt-Skript ''steuerung/v1''==


Liefert eine Liste von Steuerungs-Werten zurück. Die Auswertung der JWT-Claims sorgt dafür, dass nur Audience ''dashboard'' Daten erhält.
== Endpunkt-Skript ==
 
Das Skript des Endpunkts <code>/steuerung/v1</code> liefert eine Liste von Steuerungs-Werten. Es beantwortet nur Token mit der Audience ''dashboard''.
<syntaxhighlight lang="pascal" line>
//------------------------------------------------------------------------------
// Ein Wert als Listeneintrag. Der Helfer bekommt den WRITER und schreibt an
// der Stelle hinein, an der er aufgerufen wird - er gibt kein Fragment zurueck.
// Der leere Feldname ist der Eintrag einer Liste.
//------------------------------------------------------------------------------


<syntaxhighlight lang="delphi">
// Schreibt eine Variable als Listeneintrag an die aktuelle Stelle des Writers
procedure _AddVar(oWriter: TxRestWriter; const cVar: string);
procedure _AddVar(oWriter: TxRestWriter; const cVar: string);
var cTitel : string;
var cTitel : string;
Zeile 95: Zeile 83:
procedure Get(oReader: TxRestReader; oWriter: TxRestWriter);
procedure Get(oReader: TxRestReader; oWriter: TxRestWriter);
begin
begin
     // Audience-Pruefung: nur Dashboard-Tokens akzeptieren. Die Ablehnung ist
     // Nur Token, die für das Dashboard ausgestellt wurden
    // ein 403 und keine 200 mit Fehlertext - oWriter.Error baut dieselbe
    // Huelle, die auch die Server-eigenen Fehler tragen.
     if (oReader.Param('_OBS_JWT_AUDIENCE') <> 'dashboard') then begin
     if (oReader.Param('_OBS_JWT_AUDIENCE') <> 'dashboard') then begin
         oWriter.Error(403, 'FORBIDDEN_ROLE', 'Token nicht für diese Anwendung ausgestellt');
         oWriter.Error(403, 'FORBIDDEN_ROLE', 'Token nicht für diese Anwendung ausgestellt');
Zeile 103: Zeile 89:
     end;
     end;


     // Die Antwort ist eine nackte Liste, kein Objekt: RootArr sagt das, und
     // Die Antwort ist eine Liste: RootArr vor dem ersten Eintrag, ohne ArrEnd
    // zwar VOR dem ersten Eintrag. Ein ArrEnd gibt es dazu nicht - die
    // Wurzelklammer setzt der Server.
     oWriter.RootArr();
     oWriter.RootArr();
     _AddVar(oWriter, 'WERT_1');
     _AddVar(oWriter, 'WERT_1');
Zeile 114: Zeile 98:
</syntaxhighlight>
</syntaxhighlight>


==JavaScript-Client (Browser)==
Werte, deren Name mit <code>_OBS_</code> beginnt, kann der Client weder über Header noch über Query-Parameter setzen. Die Prüfung der Audience ist deshalb verlässlich.


Im Browser werden zwei Aufrufe gemacht: erst Token holen, dann Daten lesen.
== Aufruf aus JavaScript ==
Die Webseite meldet sich an und liest dann die Daten. Die Anmeldung ist ein <code>POST</code> an den JWT-Endpunkt und braucht keinen <code>Idempotency-Key</code>; der Datenabruf ist ein <code>GET</code>.


<syntaxhighlight lang="javascript" line>
<syntaxhighlight lang="javascript">
const API_BASE = 'https://api.meinserver.de';
const API_BASE = 'https://obs.example.com';
const API_KEY  = '[API-KEY]';
const API_KEY  = 'abcdef-ghij-klmn-opqr-stuvwx';
 
// Wirft bei einer Fehlerantwort den Code aus dem error-Objekt
async function pruefeAntwort(res) {
    if (res.ok) {
        return res.json();
    }
    let code = 'HTTP_' + res.status;
    try {
        const fehler = await res.json();
        code = fehler.error.code;
    } catch (e) {
        // Antwort ohne JSON-Körper
    }
    throw new Error(code + ' (X-Trace-Id ' + res.headers.get('X-Trace-Id') + ')');
}


async function login(username, password) {
async function login(username, password) {
     const res = await fetch(`${API_BASE}/oauth/`, {
     const res = await fetch(`${API_BASE}/oauth`, {
         method:  'POST',
         method:  'POST',
         headers: { 'Content-Type': 'application/json', 'apikey': API_KEY },
         headers: { 'Content-Type': 'application/json', 'apikey': API_KEY },
         body:    JSON.stringify({ username, password })
         body:    JSON.stringify({ username, password })
     });
     });
    if (!res.ok) throw new Error('Login fehlgeschlagen');
     const data = await pruefeAntwort(res);
     const data = await res.json();
     return data.accessToken;
     return data.token;
}
}


Zeile 136: Zeile 135:
     const res = await fetch(`${API_BASE}/steuerung/v1`, {
     const res = await fetch(`${API_BASE}/steuerung/v1`, {
         method:  'GET',
         method:  'GET',
         headers: {
         headers: { 'apikey': API_KEY, 'Authorization': 'Bearer ' + token }
            'apikey':       API_KEY,
            'Authorization': 'Bearer ' + token
        }
     });
     });
     if (!res.ok) throw new Error('Abruf fehlgeschlagen: ' + res.status);
     return pruefeAntwort(res);
    return res.json();
}
}


async function zeigeTabelle() {
async function zeigeTabelle(username, password) {
     const token = await login('mitarbeiter', 'geheim');
     const token = await login(username, password);
     const werte = await ladeSteuerung(token);
     const werte = await ladeSteuerung(token);


Zeile 156: Zeile 151:
     });
     });
}
}
zeigeTabelle();
</syntaxhighlight>
</syntaxhighlight>


==Test mit curl==
Der Aufruf aus dem Browser gelingt nur, wenn die Adresse der Webseite im Feld '''CORS-Origin''' des Zugangs steht. Sonst antwortet der Server mit 403.


Token holen:
== Test mit curl ==
Anmelden:


curl -X POST -H "apikey: [API-KEY]" -H "Content-Type: application/json" ^
<syntaxhighlight lang="bash">
      -d "{\"username\":\"mitarbeiter\",\"password\":\"geheim\"}" ^
curl -X POST \
      https://api.meinserver.de/oauth/
    -H "apikey: abcdef-ghij-klmn-opqr-stuvwx" \
    -H "Content-Type: application/json" \
    -d '{"username":"mitarbeiter","password":"geheim"}' \
    https://obs.example.com/oauth
</syntaxhighlight>


Antwort:
Antwort:


{"token":       "eyJhbGciOi...",
<syntaxhighlight lang="json">
   "accessToken": "eyJhbGciOi...",
{
   "expiresIn":   3600,
  "token": "eyJhbGciOiJIUzI1NiIs...",
   "serverTime": "2026-08-19T09:12:33+02:00"}
   "accessToken": "eyJhbGciOiJIUzI1NiIs...",
   "expiresIn": 3600,
   "serverTime": "2026-11-17T09:12:33+01:00"
}
</syntaxhighlight>


Da das Skript kein ''_OBS_JWT_REFRESH_ID'' liefert, enthält die Antwort kein
Daten abrufen:
''refreshToken'' - der Client meldet sich nach Ablauf der 60 Minuten neu an.


Daten abrufen:
<syntaxhighlight lang="bash">
curl -H "apikey: abcdef-ghij-klmn-opqr-stuvwx" \
    -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..." \
    https://obs.example.com/steuerung/v1
</syntaxhighlight>


curl -H "apikey: [API-KEY]" -H "Authorization: Bearer eyJhbGciOi..." ^
Ein falsches Passwort beantwortet der Server mit 401 <code>AUTH_FAILED</code> und dem Text aus dem Anmeldeskript. Ein Abruf ohne Token ergibt 401 <code>AUTH_REQUIRED</code>, ein abgelaufenes Token 401 <code>AUTH_EXPIRED</code>. Alle Codes: [[OBS/Kostenpflichtige Module/REST-Server/HTTP-Schnittstelle|HTTP-Schnittstelle]].
      https://api.meinserver.de/steuerung/v1


==Was zeigt das Beispiel?==
== Was zeigt das Beispiel? ==
* Zweistufiger Zugriff: API-Key für den Zugang, JWT für den einzelnen Benutzer.
* Ein Anmeldeskript je Zugang, das die Benutzer gegen eigene Daten prüft.
* Trennung von Anwendungen über die Audience des Tokens.
* Eine Liste als Antwort über <code>oWriter.RootArr</code> und einen Helfer, der den Writer als Parameter bekommt.
* Fehlerantworten über <code>oWriter.Error</code> im einheitlichen Fehlerformat.
* Browser-Zugriff über ein erlaubtes '''CORS-Origin'''.
* Anmeldung ohne Refresh-Token: der einfachste Fall.


* Zweistufige Anmeldung: API-Key + JWT.
== Siehe auch ==
* Sichere Trennung von Konsumenten-Gruppen über die Audience-Claim.
* [[OBS/Kostenpflichtige Module/REST-Server/Anmeldung mit JWT|Anmeldung mit JWT]]
* Eigenes Authentifizierungs-Skript pro Zugang.
* [[OBS/Kostenpflichtige Module/REST-Server/HTTP-Schnittstelle|HTTP-Schnittstelle]]
* Browser-Zugriff über CORS-erlaubtes Origin.
* [[OBS/Kostenpflichtige Module/REST-Server/Scripting|Scripting]]
* Anmeldung ohne Refresh-Token: einfachster Fall, der Token läuft nach der Zeit aus ''JWT-Exp'' ab.
* [[OBS/Kostenpflichtige Module/REST-Server/Zugänge|Zugänge]]
* [[OBS/Kostenpflichtige Module/REST-Server/Beispiele/Schreibzugriff mit Statuscodes, ETag und Idempotenz|Beispiel 5: Schreibzugriff mit Statuscodes, ETag und Idempotenz]]

Aktuelle Version vom 17. November 2026, 07:23 Uhr

Daten-Abruf mit JWT-Anmeldung

In diesem Beispiel zeigt eine Webseite Steuerungs-Variablen aus OBS an – live, ohne Export und ohne eigene Datenbank. Der Zugang verlangt eine JWT-Anmeldung: Jeder Benutzer meldet sich zuerst an und ruft die Daten dann mit seinem Token ab.

Einrichtung in OBS

  • Server-Profil: TLS-Profil Public-API mit einer Bindung auf Port 443
  • Zugang: Web-Dashboard
    • API-Key: vom System erzeugt
    • Haken JWT-Authentifizierung gesetzt, Endpunkt /oauth, Secret-Key zufällig, Lebenszeit (Min) 60
    • CORS-Origin: https://dashboard.example.com
  • Endpunkt: Pfad-Template /steuerung/v1, Server Public-API
  • Berechtigung: Zugang Web-Dashboard für den Endpunkt /steuerung/v1 freigeschaltet

Felder und Bedienung: Zugänge und Endpunkte.

Anmeldeskript des Zugangs

Das Anmeldeskript öffnen Sie in der Zugänge-Liste mit F7. Es prüft Benutzername und Passwort und schreibt bei Erfolg die Angaben für das Token. Tabelle, Felder und HashPasswort stehen für Ihre eigene Prüfung. Den vollständigen Ablauf mit Erneuern und Abmelden beschreibt Anmeldung mit JWT.

procedure Authenticate(oReader: TxRestReader; oWriter: TxRestWriter);
var cUser: string;
    cPass: string;
    cSql : string;
    qUser: TxFQuery;
    lOk  : Boolean;
begin
    cUser := '';
    cPass := '';
    oReader.Str('username', cUser);
    oReader.Str('password', cPass);

    cSql := 'SELECT u_nr, u_name FROM BENUTZER' +
            ' WHERE u_login = '         + DB_SqlVal(cUser, 'C') +
            '   AND u_passwort_hash = ' + DB_SqlVal(HashPasswort(cPass), 'C') +
            '   AND u_aktiv = '         + DB_SqlVal('1', 'C');

    // DB_SOpen meldet nur, dass die Abfrage lief. Gefunden ist erst bei not EoF.
    lOk := false;
    if (DB_SOpen(oDB, cSql, qUser)) then begin
        if (not qUser.EoF) then begin
            lOk := true;
            oWriter.Int('status'           , 1);
            oWriter.Str('_OBS_JWT_ID'      , qUser.A2C('u_nr'));
            oWriter.Str('_OBS_JWT_SUBJECT' , qUser.A2C('u_name'));
            oWriter.Str('_OBS_JWT_AUDIENCE', 'dashboard');
        end;
    end;
    DB_Close(qUser);

    if (not lOk) then begin
        oWriter.Int('status', 9);
        oWriter.Str('error' , 'Benutzer oder Passwort ist falsch');
    end;
end;

Das Skript schreibt kein _OBS_JWT_REFRESH_ID. Die Antwort enthält deshalb kein Refresh-Token, und der Benutzer meldet sich nach Ablauf der Lebenszeit (Min) neu an.

Endpunkt-Skript

Das Skript des Endpunkts /steuerung/v1 liefert eine Liste von Steuerungs-Werten. Es beantwortet nur Token mit der Audience dashboard.

// Schreibt eine Variable als Listeneintrag an die aktuelle Stelle des Writers
procedure _AddVar(oWriter: TxRestWriter; const cVar: string);
var cTitel : string;
    cData  : string;
    cEinh  : string;
    lString: Boolean;
    lAlign : Boolean;
begin
    if (ST_Variable(oDB, cVar, cTitel, cData, cEinh, lString, lAlign)) then begin
        oWriter.ObjBegin('');
            oWriter.Str('variable', cVar);
            oWriter.Str('titel'   , cTitel);
            oWriter.Str('wert'    , cData);
            oWriter.Str('einheit' , cEinh);
        oWriter.ObjEnd;
    end;
end;

procedure Get(oReader: TxRestReader; oWriter: TxRestWriter);
begin
    // Nur Token, die für das Dashboard ausgestellt wurden
    if (oReader.Param('_OBS_JWT_AUDIENCE') <> 'dashboard') then begin
        oWriter.Error(403, 'FORBIDDEN_ROLE', 'Token nicht für diese Anwendung ausgestellt');
        exit;
    end;

    // Die Antwort ist eine Liste: RootArr vor dem ersten Eintrag, ohne ArrEnd
    oWriter.RootArr();
    _AddVar(oWriter, 'WERT_1');
    _AddVar(oWriter, 'WERT_2');
    _AddVar(oWriter, 'WERT_3');
    _AddVar(oWriter, 'WERT_4');
end;

Werte, deren Name mit _OBS_ beginnt, kann der Client weder über Header noch über Query-Parameter setzen. Die Prüfung der Audience ist deshalb verlässlich.

Aufruf aus JavaScript

Die Webseite meldet sich an und liest dann die Daten. Die Anmeldung ist ein POST an den JWT-Endpunkt und braucht keinen Idempotency-Key; der Datenabruf ist ein GET.

const API_BASE = 'https://obs.example.com';
const API_KEY  = 'abcdef-ghij-klmn-opqr-stuvwx';

// Wirft bei einer Fehlerantwort den Code aus dem error-Objekt
async function pruefeAntwort(res) {
    if (res.ok) {
        return res.json();
    }
    let code = 'HTTP_' + res.status;
    try {
        const fehler = await res.json();
        code = fehler.error.code;
    } catch (e) {
        // Antwort ohne JSON-Körper
    }
    throw new Error(code + ' (X-Trace-Id ' + res.headers.get('X-Trace-Id') + ')');
}

async function login(username, password) {
    const res = await fetch(`${API_BASE}/oauth`, {
        method:  'POST',
        headers: { 'Content-Type': 'application/json', 'apikey': API_KEY },
        body:    JSON.stringify({ username, password })
    });
    const data = await pruefeAntwort(res);
    return data.accessToken;
}

async function ladeSteuerung(token) {
    const res = await fetch(`${API_BASE}/steuerung/v1`, {
        method:  'GET',
        headers: { 'apikey': API_KEY, 'Authorization': 'Bearer ' + token }
    });
    return pruefeAntwort(res);
}

async function zeigeTabelle(username, password) {
    const token = await login(username, password);
    const werte = await ladeSteuerung(token);

    const tbl = document.getElementById('steuerung');
    werte.forEach(w => {
        const tr = document.createElement('tr');
        tr.innerHTML = `<td>${w.titel}</td><td>${w.wert} ${w.einheit}</td>`;
        tbl.appendChild(tr);
    });
}

Der Aufruf aus dem Browser gelingt nur, wenn die Adresse der Webseite im Feld CORS-Origin des Zugangs steht. Sonst antwortet der Server mit 403.

Test mit curl

Anmelden:

curl -X POST \
     -H "apikey: abcdef-ghij-klmn-opqr-stuvwx" \
     -H "Content-Type: application/json" \
     -d '{"username":"mitarbeiter","password":"geheim"}' \
     https://obs.example.com/oauth

Antwort:

{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "accessToken": "eyJhbGciOiJIUzI1NiIs...",
  "expiresIn": 3600,
  "serverTime": "2026-11-17T09:12:33+01:00"
}

Daten abrufen:

curl -H "apikey: abcdef-ghij-klmn-opqr-stuvwx" \
     -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..." \
     https://obs.example.com/steuerung/v1

Ein falsches Passwort beantwortet der Server mit 401 AUTH_FAILED und dem Text aus dem Anmeldeskript. Ein Abruf ohne Token ergibt 401 AUTH_REQUIRED, ein abgelaufenes Token 401 AUTH_EXPIRED. Alle Codes: HTTP-Schnittstelle.

Was zeigt das Beispiel?

  • Zweistufiger Zugriff: API-Key für den Zugang, JWT für den einzelnen Benutzer.
  • Ein Anmeldeskript je Zugang, das die Benutzer gegen eigene Daten prüft.
  • Trennung von Anwendungen über die Audience des Tokens.
  • Eine Liste als Antwort über oWriter.RootArr und einen Helfer, der den Writer als Parameter bekommt.
  • Fehlerantworten über oWriter.Error im einheitlichen Fehlerformat.
  • Browser-Zugriff über ein erlaubtes CORS-Origin.
  • Anmeldung ohne Refresh-Token: der einfachste Fall.

Siehe auch