Hämta token i MSAL-noden

Eftersom MSAL Node stöder olika auktoriseringskodsbidrag finns det stöd för olika offentliga API:er per beviljande och motsvarande begäran. Den här artikeln beskriver de olika offentliga API:er som är tillgängliga för varje flöde och motsvarande typ av begäran. Vi rekommenderar starkt att du implementerar auktoriseringskodflödet för ditt program.

Auktoriseringskodflöde

Offentliga API:er

  • getAuthCodeUrl(): Det här API:et är den första delen av authorization code grant för MSAL-noden. Begäran är av typen AuthorizationUrlRequest. Applikationen får en URL som kan användas för att generera en authorization code. Den här URL:en kan öppnas i en webbläsare där användaren kan ange sina autentiseringsuppgifter och omdirigeras tillbaka till redirectUri (registreras under appregistreringen) med en authorization code. Den authorization code kan nu lösas in mot en token genom följande steg. Observera att om auktoriseringskodflödet görs för ett offentligt klientprogram rekommenderar vi PKCE .

  • acquireTokenByCode(): Det här API:et är den andra delen av authorization code grant för MSAL-noden. Den begäran som skapas här bör vara av typen AuthorizationCodeRequest. Applikationen vidarebefordrade authorization code som togs emot i föregående steg och byter ut det mot ett token. Observera att om auktoriseringskodflödet används för ett offentligt klientprogram rekommenderas PKCE.


    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);
    });

Flöde för enhetskod

Offentliga API:er

  • acquireTokenByDeviceCode(): Med det här API:et kan programmet hämta en token med enhetskodsbidrag. Begäran är av typen DeviceCodeRequest. Det här API:et hämtar en token från auktoriseringsservern med OAuth 2.0:s enhetskodflöde. Det här flödet är utformat för enheter som inte har åtkomst till en webbläsare eller har indatabegränsningar. Auktoriseringsservern utfärdar ett DeviceCode-objekt med en verifieringskod, en slutanvändarkod och URI för slutanvändarverifiering. DeviceCode-objektet tillhandahålls via ett återanrop och slutanvändaren bör instrueras att använda en annan enhet för att navigera till verifierings-URI:n för att ange autentiseringsuppgifter. Eftersom klienten inte kan ta emot inkommande begäranden avsöker den auktoriseringsservern upprepade gånger tills slutanvändaren har slutfört indata för autentiseringsuppgifter.
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));
});

Uppdatera tokenflöde

Offentliga API:er

  • acquireTokenByRefreshToken: Det här API:et hämtar en token genom att byta ut uppdateringstoken som tillhandahålls för en ny uppsättning token. Begäran är av typen RefreshTokenRequest. refresh token Returneras aldrig till användaren i ett svar, men kan nås från användarens cacheminne. Vi rekommenderar att du använder acquireTokenSilent() för icke-interaktiva scenarier. När du använder acquireTokenSilent()hanterar MSAL cachelagring och uppdatering av token automatiskt.
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));
});

Tyst flöde

Offentliga API:er

  • acquireTokenSilent: Det här API:et hämtar en token tyst, om cachen tillhandahålls av användaren eller när cachen skapas genom att föregå det här anropet med något annat interaktivt flöde (t.ex. auktoriseringskodflöde). Begäran är av typen SilentFlowRequest. token Hämtas tyst när en användare anger det konto som token begärs för.
/**
 * 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);
});

Flöde för klientautentiseringsuppgifter

Offentliga API:er

  • acquireTokenByClientCredential: Det här API:et hämtar en token med autentiseringsuppgifterna för det konfidentiella klientprogrammet för att autentisera (i stället för att personifiera en användare) när en annan webbtjänst anropas. I det här scenariot är klienten vanligtvis en mellannivåwebbtjänst, en daemontjänst eller ett serverdelswebbprogram. För en högre säkerhetsnivå tillåter Microsofts identitetsplattform även att den anropande tjänsten använder ett certifikat (i stället för en delad hemlighet) som autentiseringsuppgifter. Begäran är av typen ClientCredentialRequest.

Använda hemligheter på ett säkert sätt

Hemligheter ska aldrig hårdkodas. Dotenv npm-paketet kan användas för att lagra hemligheter i en .env-fil (finns i projektets rotkatalog) som ska ingå i .gitignore för att förhindra oavsiktliga uppladdningar av hemligheterna.

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));
});

På Flows vägnar

  • acquireTokenOnBehalfOf: Det här API:et implementerar On Behalf Of Flow, som används när ett program anropar en tjänst/webb-API, som i sin tur måste anropa ett annat tjänst-/webb-API som använder andra autentiseringsflöden (enhetskod, användarnamn/lösenord osv.). Åtkomsttoken hämtas från början av webb-API:et (av något av webb-API-flödena) och webb-API:et kan sedan byta ut denna token mot en annan token via OBO. Begäran är av typen OnBehalfOfRequest

Se exemplet på On Behalf Of-flödet för användningsanvisningar:

  • Last updated on