Tanúsítvány hitelesítő adatainak használata az MSAL-csomóponttal

Az MSAL-csomóponttal (webalkalmazások, démonalkalmazások stb.) bizalmas ügyfélalkalmazásokat hozhat létre. Bizalmas ügyfelek esetében kötelező az ügyfél-hitelesítő adatok megadása.

Prerequisites

A bizalmas ügyfélalkalmazások inicializálásának ismerete.

managed identity: ez egy tanúsítvány nélküli forgatókönyv, amelyben a megbízhatóság a Azure infrastruktúrán keresztül jön létre. Nincs szükség titkos vagy tanúsítványkezelésre. Az MSAL még nem implementálja ezt a funkciót, de használhat Azure Identity SDK-t. Lásd: Az Azure-erőforrások felügyelt identitásai dokumentáció
clientSecret: az alkalmazás regisztrációja során létrehozott, vagy meglévő alkalmazás esetén a regisztrációt követően frissített titkos karakterlánc. Ez nem ajánlott éles környezetben.
clientCertificate: az alkalmazásregisztráció során beállított tanúsítvány. A tanúsítványnak rendelkeznie kell a titkos kulccsal, mert az MSAL által generált állítás aláírására szolgál. A thumbprintSha256 tanúsítvány X.509 SHA-256 ujjlenyomata, a privateKey PEM kódolt titkos kulcsa.
clientAssertion: ahelyett, hogy az MSAL létrehoz egy állítást, az alkalmazás fejlesztője átveszi az irányítást. Hasznos, ha további jogcímeket ad hozzá az állításhoz, vagy a KeyVaultot használja aláíráshoz helyi tanúsítvány helyett. Az állítás aláírásához használt tanúsítványt továbbra is be kell állítani az alkalmazásregisztráció során.

Megjegyzés: Előfordulhat, hogy az 1p-alkalmazásoknak a x5c elemet is el kell küldeniük. Ez az X.509-tanúsítványlánc , amelyet a tulajdonosnév-/kiállítói hitelesítési forgatókönyvekben használnak.

Titkos kódok és tanúsítványok biztonságos használata

A titkos kulcsokat soha nem szabad szigorúan kódolni. A dotenv npm-csomag segítségével titkos kulcsokat vagy tanúsítványokat 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.

A tanúsítványok a NodeJS fs modulján keresztül is beolvashatók a fájlokból. Ezeket azonban soha nem szabad a projekt könyvtárában tárolni. Az éles környezetben futó alkalmazásoknak a tanúsítványokat az Azure Key Vault-ból vagy más biztonságos kulcstárolókból kell lekérniük.

További információért tekintse meg a tanúsítványokat és a titkos kulcsokat .

Lásd az MSAL-mintát: auth-code-with-certs

Tanúsítványok regisztrálása

Ha nem rendelkezik tanúsítvánnyal, létrehozhat egy önaláírt tanúsítványt a PowerShell vagy Azure KeyVault használatával.

Fel kell töltenie a tanúsítványát a Microsoft Entra ID-ba.

Lépjen Azure portálra, és válassza ki Microsoft Entra alkalmazásregisztrációját.
Válassza a Tanúsítványok > titkos kódok panelt a bal oldalon.
Kattintson a Tanúsítvány feltöltése elemre , és válassza ki a feltölteni kívánt tanúsítványfájlt (például example.crt).
Kattintson a Hozzáadás gombra. A tanúsítvány feltöltése után megjelenik az ujjlenyomat (SHA-256), a kezdő dátum és a lejárati érték.

További információért lásd: Regisztrálja a tanúsítványát a Microsoft Identitásplatformon

MSAL-csomópont inicializálása tanúsítványokkal

const msal = require('@azure/msal-node');
require('dotenv').config(); // process.env now has the values defined in a .env file

const config = {
    auth: {
        clientId: "YOUR_CLIENT_ID",
        authority: "https://login.microsoftonline.com/YOUR_TENANT_ID",
        clientCertificate: {
            thumbprintSha256: process.env.thumbprint,
            privateKey: process.env.privateKey,
        }
    }
};

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

A thumbprintSha256 és a privateKey is várhatóan karakterlánc. privateKey várhatóan továbbá a következő formában van (PKCS#8):

Note

Másik lehetőségként a titkos kulcs kezdődhet -----BEGIN PRIVATE KEY----- (titkosítatlan PKCS#8) vagy -----BEGIN RSA PRIVATE KEY----- (PKCS#1). Ezek a formátumok is megengedettek. A kompatibilis kulcsok PKCS#8 kulcstípussá alakításához az alábbiak használhatók:

openssl pkcs8 -topk8 -inform PEM -outform PEM -in example.key -out example.key

Ha a titkos kulcsát (vagy ha a titkos kulcsa már titkosítva van) jelmondattal titkosította, fel kell oldania a titkosítást, mielőtt átadná az MSAL Node számára.

Fontos: A forráskódban soha ne kódoljon jelszavakat. A tanúsítvány titkos kulcsát és az opcionális visszafejtési jelszót biztonságos helyről (például Azure KeyVault) kell lekérni, és biztonságosan üzembe kell helyezni a webes API-val.

Ez a Node titkosítási moduljával végezhető el. A metódus használatával createPrivateKey() elemezheti és exportálhatja a kulcsot:

const fs = require('fs');
const crypto = require('crypto');

const privateKeySource = fs.readFileSync('<path_to_key>/example.key')

const privateKeyObject = crypto.createPrivateKey({
    key: privateKeySource,
    passphrase: process.env.YOUR_PASSPHRASE,
    format: 'pem'
});

const privateKey = privateKeyObject.export({
    format: 'pem',
    type: 'pkcs8'
});

(Nem kötelező) Pfx átalakítása pem-re

Az OpenSSL a pfx kódolású tanúsítványfájlok pem formátumba való konvertálásához használható:

    openssl pkcs12 -in certificate.pfx -out certificate.pem

Ha az átalakításnak programozott módon kell történnie, előfordulhat, hogy egy külső csomagra kell támaszkodnia, mivel Node.js ehhez nem kínál natív módszert. Például egy népszerű TLS-implementáció, például a node-forge használatával a következő műveleteket végezheti el:

const forge = require('node-forge');

/**
 * @param {string} pfx: certificate + private key combination in pfx format
 * @param {string} passphrase: passphrase used to encrypt pfx file
 * @returns {Object}
 */
function convertPFX(pfx, passphrase = null) {

    const asn = forge.asn1.fromDer(forge.util.decode64(pfx));
    const p12 = forge.pkcs12.pkcs12FromAsn1(asn, true, passphrase);

    // Retrieve key data
    const keyData = p12.getBags({ bagType: forge.pki.oids.pkcs8ShroudedKeyBag })[forge.pki.oids.pkcs8ShroudedKeyBag]
        .concat(p12.getBags({ bagType: forge.pki.oids.keyBag })[forge.pki.oids.keyBag]);

    // Retrieve certificate data
    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag })[forge.pki.oids.certBag];
    const certificate = forge.pki.certificateToPem(certBags[0].cert)

    // Convert a Forge private key to an ASN.1 RSAPrivateKey
    const rsaPrivateKey = forge.pki.privateKeyToAsn1(keyData[0].key);

    // Wrap an RSAPrivateKey ASN.1 object in a PKCS#8 ASN.1 PrivateKeyInfo
    const privateKeyInfo = forge.pki.wrapRsaPrivateKey(rsaPrivateKey);

    // Convert a PKCS#8 ASN.1 PrivateKeyInfo to PEM
    const privateKey = forge.pki.privateKeyInfoToPem(privateKeyInfo);

    console.log("Converted certificate: \n", certificate);
    console.log("Converted key: \n", privateKey);

    return {
        certificate: certificate,
        key: privateKey
    };
}

(Nem kötelező) HTTPS-kiszolgáló létrehozása

Az OAuth 2.0 protokoll a HTTPS-kapcsolat használatát javasolja, amikor csak lehetséges. A legtöbb felhőszolgáltatás, például a Azure App Service alapértelmezés szerint HTTPS-kapcsolatot biztosít proxyn keresztül. Ha tesztelési célból saját HTTPS-kiszolgálót szeretne beállítani, a HTTPS-kiszolgáló létrehozásával kapcsolatos útmutatásért tekintse meg a Node.js dokumentációját.

A böngésző biztonsági szabályzatának megkerüléséhez hozzá kell adnia az önaláírt tanúsítványokat az operációs rendszer / kulcsláncához. Előfordulhat, hogy később is megjelenik egy figyelmeztetés a böngészőben (pl. Chrome).

Windows felhasználók számára kövesse a következő útmutatót: Útmutató: Tanúsítványok megtekintése az MMC beépülő modullal.
Linux- és MacOS-felhasználók esetén tekintse meg az operációs rendszer tanúsítványainak telepítésére vonatkozó dokumentációját.

Warning

Előfordulhat, hogy rendszergazdai jogosultságokra van szüksége a fenti parancsok futtatásához.

Gyakori problémák

Bizonyos esetekben előfordulhat, hogy a Microsoft Entra ID hibaüzenetet kap, amikor tanúsítványokkal próbál hitelesítést végezni, például a AADSTS700027: Client assertion contains an invalid signature hibát, amely azt jelzi, hogy az MSAL-csomópont inicializálásához használt tanúsítványok és/vagy titkos kulcsok helytelenek. Ennek gyakori oka, hogy az MSAL-csomópontnak megadott tanúsítvány/ titkoskulcs-sztring nem várt karaktereket tartalmaz, például visszaszállító kocsikat (\r) vagy új vonalakat (\n):

Alternatívaként a tanúsítvány- vagy kulcsfájl bag attribútumokat tartalmazhat:

Bag Attributes
    localKeyID: 28 B5 8E 16 11 88 E9 00 58 D5 76 30 12 B9 59 B8 E4 CE 7C AA
subject=/C=UK/ST=Suffolk/L=Ipswich/O=Example plc/CN=alice
issuer=/C=UK/ST=Suffolk/L=Ipswich/O=Example plc/CN=Certificate Authority/emailAddress=ca@example.com\n
-----BEGIN CERTIFICATE-----
MIIDDzCCAfegAwIBAgIJAMkyzQVK88NHMA0GCSqGSIb3DQEBBQUAMIGCMQswCQYD
VQQGEwJTRTESMBAGA1UECBMJU3RvY2tob2xtMQ4wDAYDVQQHEwVLaXN0YTEQMA4G
0fbkqbKulrchGbNgkankZtEVg4PGjo+Y8MdMjtfSZB29hwYvfMX09jzJ68ZqmpYQ
njvcVtLbEZN5OGCkaslb/f2OxLbsUNgIbws538WnaaufDvKmQe2kUdWmpl9Wn9Bf
bZq7B+njvcVa7SsWF/WLq5AUbw==
-----END CERTIFICATE-----

Ilyen esetekben Ön felelős a karakterlánc megtisztításáért, mielőtt átadná azt az MSAL Node konfigurációnak. Ilyenek például a következők:

const msal = require('@azure/msal-node');
const fs = require('fs');

const privateKeySource = fs.readFileSync('<path_to_key>/certs/example.key');
const privateKey = Buffer.from(privateKeySource, 'base64').toString().replace(/\r/g, "").replace(/\n/g, "");

const config = {
    auth: {
        clientId: "YOUR_CLIENT_ID",
        authority: "https://login.microsoftonline.com/YOUR_TENANT_ID",
        clientCertificate: {
            thumbprintSha256: process.env.thumbprint,
            privateKey: privateKey,
        }
    }
};

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

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-07-02