iamops.dev
Argo auf X RSS-Feed
DEDeutsch

Labs Technisch 6 Min. Lesezeit

Microsoft-Entra-On-Behalf-of-Ablauf für die mittlere Schicht eines Agenten: Zertifikat statt Client Secrets

Labor im Testmandanten: Device Code, die Agenten-API tauscht das Token On-Behalf-of per Zertifikat ohne Secret, ein nicht genehmigter Scope scheitert.

Zwei Aufnahmen aus meinem Entra-Lab: die Seite mit den API-Berechtigungen der mittleren App und eine Terminaltabelle, die Audience, App-ID und Scope des Benutzer-Tokens und der beiden On-Behalf-of-Tokens vergleicht.
Kurz gesagtFür Agenten, die APIs im Namen eines angemeldeten Nutzers aufrufen,…
  • Für Agenten, die APIs im Namen eines angemeldeten Nutzers aufrufen, lautet Entras aktuelle Antwort der On-Behalf-of-Ablauf (OBO); ID-JAG ist dort heute nur eine Bereitschaftsumfrage.
  • Die Middle API weist sich mit einer zertifikatsignierten Assertion aus und hält null Client Secrets.
  • Eine Anmeldung ergibt je Audience eigene Tokens: Der Nutzer bleibt gleich, die aufrufende Anwendung wechselt.
  • Ein Scope ohne Einwilligung scheitert mit AADSTS65001; entscheidend ist die Einwilligung am Service Principal.
  • OBO-Tokens behalten den ursprünglichen Client nicht, daher müssen Audits Anmeldeprotokolle verknüpfen.
Dieses Lab nachbauen 6 Schritte

Dieses Lab habe ich so geschrieben, dass Sie es selbst nachbauen können. Jeder Schritt enthält die Befehle zum Kopieren und die Ausgabe, die ich bekommen habe, und Sie können ihn als erledigt abhaken. Die Haken bleiben nur in diesem Browser.

Zu den Schritten

So funktioniert es

Kopiert einen fertigen Prompt für Claude Code, Cursor, Codex oder einen anderen Coding-Agenten. Nur für Testumgebungen.

Prompt anzeigen
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: Microsoft-Entra-On-Behalf-of-Ablauf für die mittlere Schicht eines Agenten: Zertifikat statt Client Secrets
Read the whole lab here (Markdown): https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier.md

What the lab needs before the first step:
- A separate test tenant (Entra ID Free is enough) where you are Global Administrator
- Never do this in a production tenant: OBO tokens carry real user claims
- Values I have to set myself (the lab uses placeholders): <TENANT_ID>, <CLIENT_APP_ID>, <MIDDLE_API_APP_ID>, <RESOURCE_API_APP_ID>

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

Am 14. November 2026 hat Microsoft einen Learn-Artikel veröffentlicht, der erstmals ID-JAG neben Microsoft Entra Agent ID nennt und ein Interessenformular dafür öffnet. Das ist eine Bereitschaftsumfrage, keine ausgelieferte Funktion: Entra stellt ID-JAGs heute weder aus noch akzeptiert es sie. Für Agenten, die APIs für einen angemeldeten Nutzer aufrufen müssen, lautet Entras aktuelle Antwort der On-Behalf-of-Ablauf (OBO). Ich habe ihn in einem Wegwerf-Mandanten komplett durchgespielt und notiert, was jeder Schritt tut.

Was das Labor zeigt#

Drei App-Registrierungen stehen für ein Agentensystem:

App Rolle Anmeldedaten
Client Oberfläche oder Kommandozeile des Agenten. Öffentlicher Client, Anmeldung per Device Code. Keine
Agent Middle API Das Backend des Agenten. Führt den OBO-Tausch aus. Ein X.509-Zertifikat, null Client Secrets
Resource API Die nachgelagerte API. Stellt den delegierten Scope Data.Read bereit. n. z.

Der Nutzer meldet sich einmal am Client an. Der Client hält ein Token, dessen Audience nur die Middle API ist. Die Middle API tauscht es gegen ein Token für die Resource API und ein weiteres für Microsoft Graph und weist sich dabei mit einer zertifikatsignierten Assertion aus statt mit einem Secret.

Einrichtung#

Verwenden Sie einen separaten Testmandanten (Entra ID Free genügt, Azure-Ressourcen sind nicht nötig). OBO-Tokens enthalten echte Nutzer-Claims, und ein Wegwerf-Mandant hält Experimente von Einwilligungen, Conditional Access und Audit-Logs der Produktion fern. Im Portal:

  1. Registrieren Sie die Resource API und stellen Sie einen delegierten Scope Data.Read bereit (Administratoren und Nutzer).
  2. Registrieren Sie die Agent Middle API, stellen Sie access_as_user bereit und fügen Sie die delegierten Berechtigungen Data.Read und Microsoft Graph User.Read hinzu; erteilen Sie dann die Administratoreinwilligung.
  3. Erzeugen Sie mit openssl einen 2048-Bit-RSA-Schlüssel und ein selbstsigniertes Zertifikat mit 60 Tagen Laufzeit, behalten Sie den privaten Schlüssel auf dem Rechner (Modus 0600) und laden Sie nur das öffentliche Zertifikat unter Certificates & secrets hoch.
  4. Registrieren Sie den Client als öffentlichen Client (Umleitung http://localhost, Allow public client flows an) mit Berechtigung für access_as_user und User.Read.
Terminalausgabe von openssl mit Zertifikats-Subject und SHA-1-Fingerabdruck, der durch einen Platzhalter ersetzt ist.
Die Anmeldedaten. Ein selbstsigniertes Zertifikat ist die einzige Anmeldeinformation der Middle API. Der Fingerabdruck ist durch einen Platzhalter ersetzt; der private Schlüssel wird nie gezeigt.
Microsoft Entra Admin Center, Seite Certificates and secrets der Agent Middle API mit geöffnetem Reiter Client secrets, der null Client Secrets zeigt.
Keine Secrets. Der Reiter Client secrets zeigt 0. Ein Zertifikat beweist den Besitz eines Schlüssels, der nie übertragen wird; ein Secret ist eine wiederverwendbare Zeichenkette, die in Konfigurationen und Logs landet.
Microsoft Entra Admin Center, API permissions der Agent Middle API: User.Read für Microsoft Graph und Data.Read für die Resource API, beide delegiert und für das Verzeichnis erteilt.
Was die mittlere Schicht anfordern darf. Entra prüft diese delegierten Berechtigungen beim Tausch. Was nicht aufgeführt und freigegeben ist, lässt sich nachgelagert nicht erhalten.
Microsoft Entra Admin Center, Enterprise applications, Permissions des Service Principals der Agent Middle API mit Administratoreinwilligung für User.Read und Data.Read.
Was sie tatsächlich bekam. App-Registrierungen zeigen, was eine App anfordert; die Berechtigungen des Service Principals zeigen, was ihr gewährt wurde. Governance-Werkzeuge sollten Letzteres lesen.

Der Ablauf#

Anmeldung per Device Code. Der Client fordert beim v2.0-Endpunkt devicecode einen Code an. Die Anfrage enthält nur die ID des Clients und den Scope der Middle API, kein Secret. Der Nutzer gibt den Code auf einem zweiten Gerät ein, und Entra zeigt eine Prüfung „Anmeldung auf einem anderen Gerät genehmigen“, die App und Standort nennt; der Nutzer muss sie von Hand bestätigen.

Terminalausgabe der Geräteautorisierungsanfrage und ihrer Antwort, mit Mandant, Client-ID und Benutzercode als Platzhalter.
Geräteautorisierung. Kennungen und Benutzercode sind Platzhalter.

Das Nutzer-Token. Nach der Genehmigung fragt der Client den Token-Endpunkt ab. Sein Token ist direkt gegen die Resource API oder Graph nutzlos, weil seine Audience die Middle API ist.

Dekodierte Claims des Nutzer-Tokens: Die Audience ist die Middle API, appid ist der Client, der Scope ist access_as_user. Kennungen und Name des Nutzers sind durch Platzhalter ersetzt.
Das einzige Token des Clients. Audience: die Middle API. Anwendung: der Client. Scope: access_as_user.

Der Tausch. Die Middle API baut eine Client-Assertion (ein RS256-JWT mit dem Fingerabdruck des Zertifikats in x5t; Aussteller und Subject sind ihre eigene Client-ID; Audience ist der Token-Endpunkt; zehn Minuten Lebensdauer), signiert sie mit dem privaten Schlüssel und sendet die OBO-Anfrage:

text
POST https://login.microsoftonline.com/<tenant-id>/oauth2/v2.0/token
  grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer
  client_id=<middle-api-id>
  client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
  client_assertion=<RS256 JWT with x5t in the header>
  assertion=<the user token>
  scope=api://<resource-api-id>/Data.Read
  requested_token_use=on_behalf_of
Dekodierte Claims des OBO-Tokens für die Resource API: Audience ist die Resource API, appid die Middle API, Scope Data.Read, gleiche Objekt-ID des Nutzers. Kennungen sind Platzhalter.
Token für die Resource API. Audience: die Resource API. Anwendung: die Middle API. Scope: Data.Read. Gleicher Nutzer.

Dieselbe Assertion mit dem Scope https://graph.microsoft.com/User.Read liefert ein Graph-Token, das das Labor einmal für GET /v1.0/me nutzt.

Dekodierte Claims des OBO-Tokens für Microsoft Graph und die Antwort des Graph-Aufrufs me, mit Name und Prinzipalnamen des Nutzers als Platzhalter.
Token für Microsoft Graph, dann ein Aufruf von /me. Eine Anmeldung verzweigt sich in mehrere Tokens, die jeweils an eine Audience gebunden sind. Name und Prinzipalname des Nutzers sind Platzhalter.

Die drei Tokens im Vergleich. Der Nutzer ändert sich nie. Die Audience folgt der aufgerufenen API, und appid wechselt vom Client zur Middle API.

Tabelle nebeneinander mit Audience, appid, Scope, Objekt-ID und Mandanten-ID für das Nutzer-Token und die beiden OBO-Tokens. Kennungen sind Platzhalter.
Drei Tokens nebeneinander. Gleicher Nutzer und Mandant; bei jedem Schritt wechseln Audience und aufrufende Anwendung.

Der Negativtest. Die Anforderung von https://graph.microsoft.com/Mail.Read, dem niemand zugestimmt hat, scheitert am Token-Dienst:

Terminalausgabe eines Fehlers invalid_grant AADSTS65001: Nutzer oder Administrator hat der Nutzung der Anwendung nicht zugestimmt. Anwendungs-ID, Trace-ID und Correlation-ID sind Platzhalter.
AADSTS65001. Die Einwilligung wird zur Token-Zeit am Service Principal der mittleren Schicht geprüft. Für einen nicht interaktiven Agenten gibt es keinen Rückfall auf eine interaktive Abfrage.

Stolperfallen#

  • Der ursprüngliche Client geht verloren. OBO-Tokens der Version 1 halten nur die letzte Anwendung fest (appid). Es gibt keinen act-Claim wie bei einer RFC-8693-Implementierung; ein Audit muss daher Anmelde-Logs verknüpfen, um die Kette zu rekonstruieren.
  • Die eingehende Audience muss die Middle API sein. Ein Token für eine andere App wird abgelehnt, das ist der Schutz gegen den Confused Deputy.
  • Device Code braucht „Allow public client flows“. Es ist auch der Ablauf, den Device-Code-Phishing ausnutzt. Der Bildschirm „Anmeldung auf einem anderen Gerät genehmigen“ ist Microsofts Gegenmaßnahme; schulen Sie Nutzer, „Das war ich nicht“ zu drücken, und beschränken Sie den Ablauf mit Conditional Access dort, wo Agenten ihn nicht brauchen.
  • Entscheidend ist die Administratoreinwilligung am Service Principal, nicht das, was die Registrierung auflistet.

Sicherheitserkenntnisse#

  1. Verwenden Sie für die mittlere Schicht ein Zertifikat oder eine föderierte Anmeldeinformation. Kein Secret heißt: nichts Wiederverwendbares, das aus Konfiguration, CI-Variablen oder Logs abfließen kann.
  2. Halten Sie die delegierten Scopes der mittleren Schicht minimal und prüfen Sie sie am Service Principal.
  3. Lassen Sie den Client ohne Anmeldedaten. Er kann immer nur das Token des Nutzers für die Middle API halten, nie ein nachgelagertes Token.
  4. Planen Sie die Audit-Verknüpfung (Nutzer, Agent, nachgelagerte Audience), denn OBO-Tokens behalten den ersten Schritt nicht.
  5. Halten Sie fest, welche Berechtigung jeder Schritt nutzt (heute OBO; ID-JAG, sobald Entra es unterstützt) und wo die Einwilligung liegt, damit Zugriffsüberprüfungen die Berechtigungen von Service Principals sehen.

Was nicht ausgeführt wurde#

Nicht ausgeführt wurden Entra-Agent-ID-Blueprints und Agentenidentitäten (dasselbe Labor mit vererbbaren Berechtigungen). Die Conditional-Access-Richtlinie, die Device Code blockiert, wurde nicht getestet. Die Zusatzaufgaben (Einwilligung entfernen und den Tausch wiederholen, optionale Claims, v2-Tokens) wurden nicht ausgeführt. Die Portal-Screenshots sind auf den Seiteninhalt zugeschnitten: Browserleiste, Profilmenü und alle Kennungen von Mandant, Anwendungen und Nutzern sind entfernt. Für dieses Labor wird keine Aufzeichnung veröffentlicht.

Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen sind durch Platzhalter ersetzt. Die Portal-Screenshots zeigen nur den Seiteninhalt.

Dieses Lab nachbauen#

Für dieses Lab brauchen Sie einen Wegwerf-Entra-Tenant, openssl, curl, jq und Python 3, sonst nichts. Planen Sie etwa 60 Minuten ein, die meisten davon für einmal Durchklicken im Portal. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie die Ausgabe mit meiner.

Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.

Variablen einmal setzen

bash · env.sh
# Paste into every terminal you use for this lab. Replace each <PLACEHOLDER> with the value from your own test tenant.
export TENANT_ID='<TENANT_ID>'
export CLIENT_ID='<CLIENT_APP_ID>'          # the public client (the agent's UI)
export MIDDLE_ID='<MIDDLE_API_APP_ID>'      # the agent's middle API
export RESOURCE_ID='<RESOURCE_API_APP_ID>'  # the downstream Resource API
export AUTHORITY="https://login.microsoftonline.com/$TENANT_ID"
export KEY_FILE="middle-api.key"
export CERT_FILE="middle-api.pem"
Schritt 1Die drei Apps in einem Test-Tenant registrieren

Ziel. Legen Sie die Resource-API, die Agent-Middle-API und den Client an. Nur die Middle-API bekommt ein Credential, und das ist ein Zertifikat.

Voraussetzungen

  • Ein separater Test-Tenant (Entra ID Free reicht), in dem Sie Global Administrator sind
  • Mach das nie in einem Produktions-Tenant: OBO-Tokens enthalten echte Benutzer-Claims
text · portal-checklist.txt
Resource API
  Entra admin center > App registrations > New registration, single tenant.
  Expose an API > Application ID URI: api://<RESOURCE_API_APP_ID>
  Add a scope: Data.Read (admins and users can consent).

Agent Middle API
  New registration, single tenant.
  Expose an API > Application ID URI: api://<MIDDLE_API_APP_ID>, scope access_as_user.
  API permissions > Add: your Resource API / Data.Read (delegated) and Microsoft Graph / User.Read (delegated).
  Grant admin consent for the tenant.
  Certificates & secrets: leave the Client secrets tab empty (0 secrets). The certificate comes in the next step.

Client
  New registration, single tenant, redirect URI (public client): http://localhost
  Authentication > Allow public client flows: Yes.
  API permissions > Add: Agent Middle API / access_as_user and Microsoft Graph / User.Read (delegated).

Copy the three Application (client) IDs and the Directory (tenant) ID into env.sh.

Erwartete Ausgabe

Ausgabe
Three app registrations, each with an Application (client) ID.
Agent Middle API > Certificates & secrets > Client secrets: 0
Agent Middle API > API permissions: Data.Read and User.Read, both "Granted for <tenant name>"
Schritt 2Das Zertifikat der Middle-API erzeugen

Ziel. Erzeugen Sie einen 2048-Bit-Schlüssel und ein selbstsigniertes Zertifikat für 60 Tage. Der private Schlüssel bleibt auf diesem Rechner, nur das öffentliche Zertifikat geht an Entra.

Voraussetzungen

  • openssl 1.1 oder neuer
  • env.sh in diesem Terminal geladen
bash · make-cert.sh
umask 077
openssl req -x509 -newkey rsa:2048 -nodes -keyout "$KEY_FILE" -out "$CERT_FILE" -days 60 -subj "/CN=agent-middle-api"
openssl x509 -in "$CERT_FILE" -outform DER -out middle-api.cer
openssl x509 -in "$CERT_FILE" -noout -subject -startdate -enddate -fingerprint -sha1
text · upload-steps.txt
# Upload only the public part: middle-api.cer
# Agent Middle API > Certificates & secrets > Certificates > Upload certificate.
# The private key ($KEY_FILE) never leaves this machine.

Erwartete Ausgabe

Ausgabe
subject=CN = agent-middle-api
notBefore=<start-date>
notAfter=<end-date>
sha1 Fingerprint=<certificate-thumbprint>
Schritt 3Den Benutzer per Device Code anmelden

Ziel. Der Client fragt einen Device Code an, nur mit seiner ID und dem Scope der Middle-API. Sie bestätigen die Anmeldung im Browser auf einem anderen Gerät, das Skript wartet darauf.

Voraussetzungen

  • Beim Client ist Allow public client flows aktiviert
  • Ein Testbenutzer im Tenant, der sich anmelden kann
bash · devicecode.sh
curl -s "$AUTHORITY/oauth2/v2.0/devicecode" \
  -d client_id="$CLIENT_ID" \
  -d scope="api://$MIDDLE_ID/access_as_user openid profile offline_access" > devicecode.json
jq '{verification_uri, expires_in, interval, message}' devicecode.json
bash · poll.sh
#!/usr/bin/env bash
# Poll the token endpoint every 5 seconds until you have approved the sign-in in the browser.
DC=$(jq -r .device_code devicecode.json)
for i in $(seq 1 170); do
  curl -s -X POST "$AUTHORITY/oauth2/v2.0/token" -d grant_type=urn:ietf:params:oauth:grant-type:device_code \
    -d client_id="$CLIENT_ID" -d device_code="$DC" > user_token.json
  if grep -q access_token user_token.json; then echo GOT; exit 0; fi
  grep -q authorization_pending user_token.json || { jq . user_token.json; exit 1; }
  sleep 5
done
bash · run-poll.sh
chmod +x poll.sh && ./poll.sh   # now open the verification URI, enter the code and approve

Erwartete Ausgabe

Ausgabe
{
  "verification_uri": "https://login.microsoft.com/device",
  "expires_in": 900,
  "interval": 5,
  "message": "To sign in, use a web browser to open https://login.microsoft.com/device and enter the code <user-code> to authenticate."
}
GOT
Schritt 4Das Token im Namen des Benutzers tauschen

Ziel. Die Middle-API signiert eine Client Assertion mit dem Zertifikat und tauscht das Benutzer-Token gegen eines für die Resource-API und eines für Microsoft Graph.

Voraussetzungen

  • user_token.json aus dem vorigen Schritt und das in die Middle-API hochgeladene Zertifikat
  • Python 3.9 oder neuer; keine Pakete nötig
python · obo.py
"""On-behalf-of exchange with a certificate-signed client assertion. Standard library plus openssl only."""
import base64, hashlib, json, os, subprocess, time, urllib.error, urllib.parse, urllib.request, uuid

TENANT, MIDDLE, RESOURCE = os.environ["TENANT_ID"], os.environ["MIDDLE_ID"], os.environ["RESOURCE_ID"]
KEY, PEM = os.environ["KEY_FILE"], os.environ["CERT_FILE"]
b64 = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=").decode()

der = subprocess.check_output(["openssl", "x509", "-in", PEM, "-outform", "DER"])
x5t = b64(hashlib.sha1(der).digest())                       # certificate thumbprint for the JWT header
token_endpoint = f"https://login.microsoftonline.com/{TENANT}/oauth2/v2.0/token"
now = int(time.time())
header = {"alg": "RS256", "typ": "JWT", "x5t": x5t}
payload = {"aud": token_endpoint, "iss": MIDDLE, "sub": MIDDLE, "jti": str(uuid.uuid4()), "nbf": now, "exp": now + 600}
signing_input = (b64(json.dumps(header).encode()) + "." + b64(json.dumps(payload).encode())).encode()
signature = subprocess.run(["openssl", "dgst", "-sha256", "-sign", KEY], input=signing_input, capture_output=True, check=True).stdout
assertion = signing_input.decode() + "." + b64(signature)
user_token = json.load(open("user_token.json"))["access_token"]


def obo(scope):
    data = urllib.parse.urlencode({
        "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer", "client_id": MIDDLE,
        "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer", "client_assertion": assertion,
        "assertion": user_token, "scope": scope, "requested_token_use": "on_behalf_of"}).encode()
    try:
        return json.load(urllib.request.urlopen(token_endpoint, data))
    except urllib.error.HTTPError as e:
        return json.load(e)


def claims(token):
    part = token.split(".")[1]
    return json.loads(base64.urlsafe_b64decode(part + "=" * (-len(part) % 4)))


keep = ["aud", "iss", "appid", "azp", "scp", "roles", "oid", "upn", "preferred_username", "name", "tid", "ver", "idtyp", "exp", "iat"]
show = lambda c: {k: c[k] for k in keep if k in c}
out = {"step1_user_token_for_middle_api": show(claims(user_token))}

r = obo(f"api://{RESOURCE}/Data.Read")
out["step2_obo_for_resource_api"] = show(claims(r["access_token"])) if "access_token" in r else r

g = obo("https://graph.microsoft.com/User.Read")
out["step3_obo_for_graph"] = show(claims(g["access_token"])) if "access_token" in g else {k: g.get(k) for k in ("error", "error_description")}
if "access_token" in g:
    req = urllib.request.Request("https://graph.microsoft.com/v1.0/me?$select=displayName,userPrincipalName",
                                 headers={"Authorization": "Bearer " + g["access_token"]})
    out["step4_graph_me"] = json.load(urllib.request.urlopen(req))

# negative test: a scope the middle API has no consent for
n = obo("https://graph.microsoft.com/Mail.Read")
out["step5_negative_mail_read"] = {k: (n.get(k) or "")[:300] for k in ("error", "error_description")} if "access_token" not in n else {"unexpected": "token issued"}
print(json.dumps(out, indent=2))
bash · run-obo.sh
python3 obo.py > obo_result.json
jq '.step2_obo_for_resource_api, .step3_obo_for_graph, .step4_graph_me' obo_result.json

Erwartete Ausgabe

Ausgabe
{
  "iss": "https://sts.windows.net/<tenant-id>/",
  "aud": "api://<resource-api-id>",
  "appid": "<middle-api-id>",
  "scp": "Data.Read",
  "oid": "<user-object-id>",
  "name": "<user-display-name>",
  "tid": "<tenant-id>",
  "ver": "1.0"
}
{
  "aud": "https://graph.microsoft.com",
  "iss": "https://sts.windows.net/<tenant-id>/",
  "appid": "<middle-api-id>",
  "scp": "User.Read profile openid email",
  "oid": "<user-object-id>",
  "name": "<user-display-name>",
  "tid": "<tenant-id>",
  "idtyp": "user"
}
{
  "displayName": "<user-display-name>",
  "userPrincipalName": "<user-principal-name>"
}
Schritt 5Die Tokens vergleichen und einen Scope ohne Zustimmung anfordern

Ziel. Lesen Sie die drei Tokens nebeneinander und sehen Sie sich dann den Fehler AADSTS65001 für Mail.Read an.

Voraussetzungen

  • obo_result.json aus dem vorigen Schritt
  • column (aus util-linux oder bsdmainutils) für die Tabelle
bash · compare.sh
jq '.step5_negative_mail_read' obo_result.json
echo "--- claims across the three tokens"
jq -r '[.step1_user_token_for_middle_api, .step2_obo_for_resource_api, .step3_obo_for_graph]
  | (["claim","user token","OBO resource","OBO graph"] | @tsv),
    (["aud","appid","scp","oid","tid"] as $ks | $ks[] as $k | [$k] + map(.[$k] // "-") | @tsv)' obo_result.json | column -t -s$'\t'

Erwartete Ausgabe

Ausgabe
{
  "error": "invalid_grant",
  "error_description": "AADSTS65001: The user or administrator has not consented to use the application with ID '<middle-api-id>' named '<middle-api-name>'. Send an interactive authorization request for this user and resource. Trace ID: <trace-id> Correlation ID: <correlation-id>"
}
--- claims across the three tokens
claim  user token             OBO resource           OBO graph
aud    api://<middle-api-id>  api://<resource-api-id>  https://graph.microsoft.com
appid  <client-app-id>        <middle-api-id>        <middle-api-id>
scp    access_as_user         Data.Read              User.Read profile openid email
oid    <user-object-id>       <user-object-id>       <user-object-id>
tid    <tenant-id>            <tenant-id>            <tenant-id>
Schritt 6Aufräumen

Ziel. Löschen Sie Schlüssel, Zertifikat, Token-Dateien und App-Registrierungen.

Voraussetzungen

  • Sie sind im Verzeichnis, in dem Sie das Lab ausgeführt haben
bash · cleanup.sh
rm -f "$KEY_FILE" "$CERT_FILE" middle-api.cer devicecode.json user_token.json obo.py obo_result.json poll.sh
ls "$KEY_FILE" 2>&1   # check: the key is gone
unset TENANT_ID CLIENT_ID MIDDLE_ID RESOURCE_ID
# Portal: delete the three app registrations (App registrations > select > Delete),
# or delete the whole test tenant if you created it just for this lab.

Erwartete Ausgabe

Ausgabe
ls: cannot access 'middle-api.key': No such file or directory

Quellen#

Diesen Beitrag diskutieren#

Hat es dir geholfen? Teile es und sag mir, was du denkst.

Auf X folgen

Neue Beiträge per E-Mail

Eine E-Mail pro Woche mit neuen Beiträgen und Labs. Jederzeit abbestellbar.

Ihre Adresse wird bei Kit gespeichert, dem Dienst, der die E-Mails versendet. Details

Verwandte Beiträge und Labs