Acquisire i token nel nodo MSAL

Poiché il nodo MSAL supporta varie concessioni di codice di autorizzazione, è disponibile il supporto per diverse API pubbliche per concessione e per la richiesta corrispondente. Questo articolo illustra le diverse API pubbliche disponibili per ogni flusso e il tipo di richiesta corrispondente. È consigliabile implementare il flusso del codice di autorizzazione per l'applicazione.

Flusso del codice di autorizzazione

API pubbliche

  • getAuthCodeUrl(): Questa API è la prima fase del authorization code grant di MSAL Node. La richiesta è di tipo AuthorizationUrlRequest. All'applicazione viene inviato un URL che può essere utilizzato per generare un authorization code. Questo URL può essere aperto in un browser a scelta, in cui l'utente può immettere le proprie credenziali e verrà reindirizzato a redirectUri (registrato durante la registrazione dell'app) con un oggetto authorization code. L'oggetto authorization code può ora essere riscattato per un token oggetto con il passaggio seguente. Si noti che se il flusso del codice di autorizzazione viene eseguito per un'applicazione client pubblica, è consigliabile usare PKCE .

  • acquireTokenByCode(): Questa API è la seconda fase di authorization code grant per MSAL Node. La richiesta costruita qui deve essere del tipo AuthorizationCodeRequest. L'applicazione ha passato l'oggetto authorization code ricevuto come parte del passaggio precedente e lo scambia per un oggetto token. Si noti che, se il flusso del codice di autorizzazione viene utilizzato per un'applicazione client pubblica, è consigliato 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);
    });

Flusso di codice del dispositivo

API pubbliche

  • acquireTokenByDeviceCode():questa API consente all'applicazione di acquisire un token con concessione del codice del dispositivo. La richiesta è di tipo DeviceCodeRequest. Questa API acquisisce un token dall'autorità tramite il flusso del codice del dispositivo di OAuth 2.0. Questo flusso è progettato per i dispositivi che non hanno accesso a un browser o hanno vincoli di input. Il server di autorizzazione rilascia un oggetto DeviceCode con un codice di verifica, un codice utente finale e l'URI di verifica dell'utente finale. L'oggetto DeviceCode viene fornito tramite un callback e l'utente finale deve essere incaricato di usare un altro dispositivo per passare all'URI di verifica per immettere le credenziali. Poiché il client non può ricevere richieste in ingresso, esegue ripetutamente il polling del server di autorizzazione fino al completamento dell'input delle credenziali da parte dell'utente finale.
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));
});

Flusso del token di aggiornamento

API pubbliche

  • acquireTokenByRefreshToken: questa API acquisisce un token scambiando il token di aggiornamento fornito per un nuovo set di token. La richiesta è di tipo RefreshTokenRequest. Il refresh token non viene mai restituito all'utente nella risposta, ma è possibile accedervi dalla cache dell'utente. È consigliabile usare acquireTokenSilent() per scenari non interattivi. Quando si usa acquireTokenSilent(), MSAL gestirà automaticamente la memorizzazione nella cache e l'aggiornamento dei 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));
});

Flusso silenzioso

API pubbliche

  • acquireTokenSilent: questa API acquisisce automaticamente un token, nel caso in cui la cache venga fornita dall'utente o quando la cache viene creata prima di questa chiamata con qualsiasi altro flusso interattivo (ad esempio, flusso del codice di autorizzazione). La richiesta è di tipo SilentFlowRequest. token viene acquisito in modo invisibile quando un utente specifica l'account per cui è richiesto il token.
/**
 * 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);
});

Flusso delle credenziali client

API pubbliche

  • acquireTokenByClientCredential: questa API acquisisce un token usando le credenziali dell'applicazione client riservata per l'autenticazione (invece di rappresentare un utente) quando si chiama un altro servizio Web. In questo scenario, il client è in genere un servizio Web di livello intermedio, un servizio daemon o un'applicazione Web back-end. Per un livello più elevato di sicurezza, Microsoft Identity Platform consente anche al servizio chiamante di usare un certificato (invece di un segreto condiviso) come credenziale. La richiesta è di tipo ClientCredentialRequest.

Uso sicuro dei segreti

I segreti non devono mai essere codificati direttamente nel codice. Il pacchetto dotenv npm può essere usato per archiviare i segreti in un file con estensione env (che si trova nella directory radice del progetto) che deve essere incluso in .gitignore per impedire caricamenti accidentali dei segreti.

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

Per conto di Flow

  • acquireTokenOnBehalfOf: questa API implementa on behalf of flow, che viene usata quando un'applicazione richiama un'API Web/servizio, che a sua volta deve chiamare un altro servizio/API Web che usa qualsiasi altro flusso di autenticazione (codice del dispositivo, nome utente/password e così via). Il token di accesso viene acquisito inizialmente dall'API Web (da uno dei flussi api Web) e l'API Web può quindi scambiare questo token per un altro token tramite OBO. La richiesta è di tipo OnBehalfOfRequest

Consultare l'esempio del flusso On Behalf Of per le istruzioni sull'uso:

  • Last updated on