Token mit MSAL Node abrufen

Da MSAL Node verschiedene Autorisierungscodeerteilungen unterstützt, gibt es Unterstützung für verschiedene öffentliche APIs pro Grant und die entsprechende Anforderung. In diesem Artikel werden Sie durch die verschiedenen öffentlichen APIs geführt, die für jeden Fluss und den entsprechenden Anforderungstyp verfügbar sind. Es wird dringend empfohlen, den Autorisierungscodefluss für Ihre Anwendung zu implementieren.

Autorisierungscode-Flow

Öffentliche APIs

  • getAuthCodeUrl(): Diese API ist der erste Schritt des authorization code grant für MSAL Node. Die Anforderung ist vom Typ AuthorizationUrlRequest. Der Anwendung wird eine URL gesendet, mit der ein authorization code generiert werden kann. Diese URL kann in einem Browser ihrer Wahl geöffnet werden, in dem der Benutzer seine Zugangsdaten eingeben kann, und wird dann zu redirectUri (registriert während der App-Registrierung) mit einem authorization code zurückgeleitet. Die authorization code kann jetzt mithilfe des folgenden Schritts für einen token eingelöst werden. Beachten Sie, dass PKCE empfohlen wird, wenn der Autorisierungscodefluss für eine öffentliche Clientanwendung durchgeführt wird.

  • acquireTokenByCode(): Diese API ist der zweite Schritt des authorization code grant für MSAL Node. Die hier erstellte Anforderung sollte vom Typ AuthorizationCodeRequest sein. Die Anwendung übergibt das authorization code, das im obigen Schritt erhalten wurde, und tauscht es gegen ein token aus. Wenn der Autorisierungscodefluss für eine öffentliche Clientanwendung durchgeführt wird, wird PKCE empfohlen.


    const authCodeUrlParameters = {
        scopes: ["sample_scope"],
        redirectUri: "your_redirect_uri",
    };

    // get url to sign user in and consent to scopes needed for application
    cca.getAuthCodeUrl(authCodeUrlParameters).then((response) => {
        console.log(response);
    }).catch((error) => console.log(JSON.stringify(error)));

    const tokenRequest = {
        code: "authorization_code",
        redirectUri: "your_redirect_uri",
        scopes: ["sample_scope"],
    };

    // acquire a token by exchanging the code
    cca.acquireTokenByCode(tokenRequest).then((response) => {
        console.log("\nResponse: \n:", response);
    }).catch((error) => {
        console.log(error);
    });

Gerätecodefluss

Öffentliche APIs

  • acquireTokenByDeviceCode(): Mit dieser API kann die Anwendung ein Token mit Device Code Grant abrufen. Die Anforderung ist vom Typ DeviceCodeRequest. Diese API fordert über den OAuth 2.0-Device-Code-Flow ein token von der Autorisierungsinstanz an. Dieser Fluss wurde für Geräte entwickelt, die keinen Zugriff auf einen Browser haben oder Eingabeeinschränkungen haben. Der Autorisierungsserver gibt ein DeviceCode-Objekt mit einem Überprüfungscode, einem Endbenutzercode und dem Endbenutzerüberprüfungs-URI aus. Das DeviceCode-Objekt wird über eine Callback-Funktion bereitgestellt, und der Endbenutzer sollte angewiesen werden, ein anderes Gerät zu verwenden, um die Bestätigungs-URI aufzurufen und Anmeldeinformationen einzugeben. Da der Client eingehende Anforderungen nicht empfangen kann, fragt er den Autorisierungsserver wiederholt ab, bis der Endbenutzer die Eingabe der Anmeldeinformationen abgeschlossen hat.
const msalConfig = {
    auth: {
        clientId: "your_client_id_here",
        authority: "your_authority_here",
    }
};

const pca = new msal.PublicClientApplication(msalConfig);

const deviceCodeRequest = {
    deviceCodeCallback: (response) => (console.log(response.message)),
    scopes: ["user.read"],
};

pca.acquireTokenByDeviceCode(deviceCodeRequest).then((response) => {
    console.log(JSON.stringify(response));
}).catch((error) => {
    console.log(JSON.stringify(error));
});

Aktualisierungstokenablauf

Öffentliche APIs

  • acquireTokenByRefreshToken: Diese API erwirbt ein Token, indem das für einen neuen Tokensatz bereitgestellte Aktualisierungstoken ausgetauscht wird. Die Anforderung ist vom Typ "RefreshTokenRequest". Die refresh token Wird niemals in einer Antwort an den Benutzer zurückgegeben, kann aber über den Benutzercache aufgerufen werden. Es wird empfohlen, für nicht interaktive Szenarien zu verwenden acquireTokenSilent() . Bei Verwendung von acquireTokenSilent(), verarbeitet MSAL automatisch das Zwischenspeichern und Aktualisieren von Token.
const config = {
    auth: {
        clientId: "your_client_id_here",
        authority: "your_authority_here",
    }
};

const pca = new msal.PublicClientApplication(config);

const refreshTokenRequest = {
    refreshToken: "",
    scopes: ["user.read"],
};

pca.acquireTokenByRefreshToken(refreshTokenRequest).then((response) => {
    console.log(JSON.stringify(response));
}).catch((error) => {
    console.log(JSON.stringify(error));
});

Stiller Fluss

Öffentliche APIs

  • acquireTokenSilent: Diese API erwirbt ein Token im Hintergrund, falls der Cache vom Benutzer bereitgestellt wird, oder wenn der Cache durch vorangehenden Aufruf mit einem anderen interaktiven Fluss erstellt wird (z. B. Autorisierungscodefluss). Die Anforderung ist vom Typ SilentFlowRequest. Die token wird stillschweigend abgerufen, wenn ein Benutzer das Konto angibt, für das das Token angefordert wird.
/**
 * Cache Plugin configuration
 */
const cachePath = "path_to_your_cache_file/msal_cache.json"; // Replace this string with the path to your valid cache file.

const readFromStorage = () => {
    return fs.readFile(cachePath, "utf-8");
};

const writeToStorage = (getMergedState) => {
    return readFromStorage().then(oldFile =>{
        const mergedState = getMergedState(oldFile);
        return fs.writeFile(cachePath, mergedState);
    })
};

const cachePlugin = {
    readFromStorage,
    writeToStorage
};

/**
 * Public Client Application Configuration
 */
const publicClientConfig = {
    auth: {
        clientId: "your_client_id_here",
        authority: "your_authority_here",
        redirectUri: "your_redirectUri_here",
    },
    cache: {
        cachePlugin
    },
};

/** Request Configuration */

const scopes = ["your_scopes"];

const authCodeUrlParameters = {
    scopes: scopes,
    redirectUri: "your_redirectUri_here",
};

const pca = new msal.PublicClientApplication(publicClientConfig);
const msalCacheManager = pca.getCacheManager();
let accounts;

pca.getAuthCodeUrl(authCodeUrlParameters)
    .then((response) => {
        console.log(response);
    }).catch((error) => console.log(JSON.stringify(error)));

const tokenRequest = {
    code: req.query.code,
    redirectUri: "http://localhost:3000/redirect",
    scopes: scopes,
};

pca.acquireTokenByCode(tokenRequest).then((response) => {
    console.log("\nResponse: \n:", response);
    return msalCacheManager.writeToPersistence();
}).catch((error) => {
    console.log(error);
});

// get Accounts
accounts = msalCacheManager.getAllAccounts();

// Build silent request
const silentRequest = {
    account: accounts[0], // You would filter accounts to get the account you want to get tokens for
    scopes: scopes,
};

// Acquire Token Silently to be used in MS Graph call
pca.acquireTokenSilent(silentRequest).then((response) => {
    console.log("\nSuccessful silent token acquisition:\nResponse: \n:", response);
    return msalCacheManager.writeToPersistence();
}).catch((error) => {
        console.log(error);
});

Clientanmeldeinformationen-Flow

Öffentliche APIs

  • acquireTokenByClientCredential: Diese API erwirbt ein Token mit den Anmeldeinformationen der vertraulichen Clientanwendung, um sich zu authentifizieren (anstatt einen Benutzer zu imitieren) beim Aufrufen eines anderen Webdiensts. In diesem Szenario ist der Client in der Regel ein Webdienst der mittleren Ebene, ein Daemondienst oder eine Back-End-Webanwendung. Für ein höheres Maß an Sicherheit bietet die Microsoft Identity Platform auch die Möglichkeit, dass der aufrufende Dienst ein Zertifikat (statt eines gemeinsamen Geheimnisses) als Anmeldeinformationen verwendet. Die Anforderung ist vom Typ "ClientCredentialRequest".

Sicheres Verwenden von geheimen Schlüsseln

Geheime Schlüssel sollten niemals hartcodiert werden. Das dotenv npm-Paket kann verwendet werden, um geheime Schlüssel in einer env-Datei (im Stammverzeichnis des Projekts) zu speichern, die in gitignore enthalten sein sollte, um versehentliche Uploads der geheimen Schlüssel zu verhindern.

import "dotenv/config"; // process.env now has the values defined in a .env file

const config = {
    auth: {
        clientId: "your_client_id_here",
        authority: "your_authority_here",
        clientSecret: process.env.clientSecret
    }
};

// Create msal application object
const cca = new msal.ConfidentialClientApplication(config);

// With client credentials flows permissions need to be granted in the portal by a tenant administrator.
// The scope is always in the format "<resource>/.default"
const clientCredentialRequest = {
    scopes: ["https://graph.microsoft.com/.default"], // replace with your resource
};

cca.acquireTokenByClientCredential(clientCredentialRequest).then((response) => {
    console.log("Response: ", response);
}).catch((error) => {
    console.log(JSON.stringify(error));
});

Im Auftrag von Flow

  • acquireTokenOnBehalfOf: Diese API implementiert den On Behalf Of Flow, der verwendet wird, wenn eine Anwendung einen Dienst/Web-API aufruft, der wiederum einen anderen Dienst/Web-API aufruft, der einen anderen Authentifizierungsfluss verwendet (Gerätecode, Benutzername/Kennwort usw.). Das Zugriffstoken wird zunächst von der Web-API (von einem der Web-API-Flüsse) abgerufen, und die Web-API kann dieses Token dann über OBO für ein anderes Token austauschen. Die Anforderung ist vom Typ "OnBehalfOfRequest"

Bitte sehen Sie sich das Beispiel für den „Im Auftrag von“-Ablauf an, um Nutzungshinweise zu erhalten:

  • Last updated on