Tokenek beszerzése az MSAL Node-ban

Mivel az MSAL Node különféle engedélyezésikód-jogosultságokat támogat, az egyes jogosultságokhoz és a hozzájuk tartozó kérésekhez eltérő nyilvános API-k állnak rendelkezésre. Ez a cikk végigvezeti az egyes folyamatokhoz elérhető különböző nyilvános API-kon és a megfelelő kérelemtípuson. Erősen ajánlott implementálni az alkalmazás engedélyezési kódfolyamatát.

Engedélyezési kódfolyamat

Nyilvános API-k

• getAuthCodeUrl(): Ez az API a(z) authorization code grant első lépése az MSAL Node esetében. A kérelem típusa AuthorizationUrlRequest. Az alkalmazás egy URL-címet kap, amely felhasználható egy authorization code létrehozásához. Ez az URL bármely böngészőben megnyitható, ahol a felhasználó megadhatja a hitelesítő adatait, majd a rendszer visszairányítja a redirectUri-hoz az alkalmazás regisztrációja során regisztrált módon, egy authorization code-val. A authorization code most beváltható egy token-ra a következő lépéssel. Vegye figyelembe, hogy ha egy nyilvános ügyfélalkalmazás engedélyezési kódjának folyamata folyamatban van, a PKCE használata ajánlott.

• acquireTokenByCode(): Ez az API a authorization code grant második lépése az MSAL Node esetében. Az itt létrehozott kérésnek AuthorizationCodeRequest típusúnak kell lennie. Az alkalmazás a fenti lépés részeként kapott authorization code továbbítja, és azt egy token-re cseréli. Vegye figyelembe, hogy ha az engedélyezési kód folyamatot nyilvános kliensalkalmazás esetén használják, a PKCE használata ajánlott.

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

Eszközkód-folyamat

Nyilvános API-k

• acquireTokenByDeviceCode(): Ez az API lehetővé teszi, hogy az alkalmazás az Eszközkód-hitelesítési folyamattal tokent szerezzen. A kérés típusa DeviceCodeRequest. Ez az API az OAuth 2.0 eszközkód-folyamatával kér le egy token a hitelesítésszolgáltatótól. Ez a folyamat olyan eszközökhöz készült, amelyek nem férnek hozzá a böngészőhöz, vagy bemeneti korlátozásokkal rendelkeznek. Az engedélyezési kiszolgáló egy DeviceCode-objektumot ad ki egy ellenőrző kóddal, egy végfelhasználói kóddal és a végfelhasználói ellenőrzési URI-val. A DeviceCode objektumot egy visszahívás biztosítja, és a végfelhasználót arra kell utasítani, hogy egy másik eszközzel lépjen az ellenőrző URI-ra a hitelesítő adatok beviteléhez. Mivel az ügyfél nem tud bejövő kéréseket fogadni, ismételten lekérdezi az engedélyezési kiszolgálót, amíg a végfelhasználó be nem fejezi a hitelesítő adatok bevitelét.

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

Jogkivonat-folyamat frissítése

Nyilvános API-k

• acquireTokenByRefreshToken: Ez az API a megadott frissítési tokent egy új tokenkészletre cserélve szerez tokent. A kérés típusa RefreshTokenRequest. A refresh token rendszer soha nem adja vissza a felhasználónak válaszként, de elérhető a felhasználói gyorsítótárból. Nem interaktív forgatókönyvekhez ajánlott használni acquireTokenSilent() . Az acquireTokenSilent() használatakor az MSAL automatikusan kezeli a tokenek gyorsítótárazását és megújítását.

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

Csendes folyamat

Nyilvános API-k

• acquireTokenSilent: Ez az API felhasználói beavatkozás nélkül kér le egy tokent, ha a felhasználó gyorsítótárat biztosít, vagy ha a gyorsítótár e hívást megelőzően bármely más interaktív folyamat (pl. engedélyezésikód-folyamat) során jön létre. A kérés típusa SilentFlowRequest. A token felhasználói beavatkozás nélkül lesz lekérve, amikor a felhasználó megadja azt a fiókot, amelyhez a tokent kéri.

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

Ügyfél hitelesítő adatainak folyamata

Nyilvános API-k

• acquireTokenByClientCredential: Ez az API tokent szerez be a bizalmas kliensalkalmazás hitelesítő adatainak felhasználásával történő hitelesítéshez (felhasználó megszemélyesítése helyett) egy másik webszolgáltatás meghívásakor. Ebben a forgatókönyvben az ügyfél általában egy középső szintű webszolgáltatás, egy démonszolgáltatás vagy egy háttérbeli webalkalmazás. A magasabb szintű megbízhatóság érdekében a Microsoft Identitásplatform lehetővé teszi, hogy a hívó szolgáltatás hitelesítő adatként tanúsítványt használjon (a megosztott titkos kód helyett). A kérelem típusa ClientCredentialRequest.

Titkos kódok biztonságos használata

A titkos kulcsokat soha nem szabad szigorúan kódolni. A dotenv npm-csomag segítségével titkos kulcsokat tárolhat egy .env fájlban (amely a projekt gyökérkönyvtárában található), amelyet a .gitignore-ban kell elhelyezni a titkos kódok véletlen feltöltésének megakadályozása érdekében.

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

A Flow nevében

• acquireTokenOnBehalfOf: Ez az API az On-Behalf-Of folyamatot valósítja meg, amelyet akkor használnak, amikor egy alkalmazás meghív egy szolgáltatást vagy webes API-t, amelynek viszont meg kell hívnia egy másik szolgáltatást vagy webes API-t, amely valamilyen más hitelesítési folyamatot használ (eszközkód, felhasználónév/jelszó stb.). A hozzáférési jogkivonatot kezdetben a webes API szerezte be (bármelyik webes API-folyamat), majd a webes API ezt a jogkivonatot egy másik jogkivonatra cserélheti az OBO-val. A kérelem típusa OnBehalfOfRequest

A használati útmutatóért tekintse meg az „On Behalf Of” folyamat mintáját:

• WebAPI-mintakód
• WebApp-mintakód