JWT öffentlicher Schlüssel und Signaturvalidierung für privaten Schlüssel - was ist der Unterschied?

Question

Ich verwende diese Bibliothek, node-jwks-rsa, um JWT-Schlüssel aus meiner auth0 jwks.json-Datei abzurufen, um zu überprüfen, dass das ID_Token meine Anwendung abruft, nachdem die Authentifizierung tatsächlich von meinem Auth-Provider kommt.

Unter der Haube nutzt sie diese Methode einen öffentlichen Schlüssel PEM

export function certToPEM(cert) { 
    cert = cert.match(/.{1,64}/g).join('\n'); 
    cert = `-----BEGIN CERTIFICATE-----\n${cert}\n-----END CERTIFICATE-----\n`; 
    return cert; 
} 

(Unter Verwendung des x50c als Argument aus der .jwks-Datei) zu bauen.

die ich dann in Kombination mit jsonwebtoken verwenden, um zu überprüfen, dass der JWT (id_token) gültig ist.

Wie unterscheidet sich diese Verifikationsmethode von der Generierung eines privaten Schlüssels (RSA) aus dem Modul und Exponenten der jwks.json-Datei und deren Verwendung zur Verifizierung? (Als Beispiel siehe diese library)

Zusätzlich ist hier Funktion als Beweis dafür, dass

export function rsaPublicKeyToPEM(modulusB64, exponentB64) { 
    const modulus = new Buffer(modulusB64, 'base64'); 
    const exponent = new Buffer(exponentB64, 'base64'); 
    const modulusHex = prepadSigned(modulus.toString('hex')); 
    const exponentHex = prepadSigned(exponent.toString('hex')); 
    const modlen = modulusHex.length/2; 
    const explen = exponentHex.length/2; 

    const encodedModlen = encodeLengthHex(modlen); 
    const encodedExplen = encodeLengthHex(explen); 
    const encodedPubkey = '30' + 
     encodeLengthHex(modlen + explen + encodedModlen.length/2 + encodedExplen.length/2 + 2) + 
     '02' + encodedModlen + modulusHex + 
     '02' + encodedExplen + exponentHex; 

    const der = new Buffer(encodedPubkey, 'hex') 
     .toString('base64'); 

    let pem = `-----BEGIN RSA PUBLIC KEY-----\n`; 
    pem += `${der.match(/.{1,64}/g).join('\n')}`; 
    pem += `\n-----END RSA PUBLIC KEY-----\n`; 

    return pem; 
    }; 

Die zuvor erwähnte jsonwebtoken Bibliothek eine PEM von einem mod und Exponent (von http://stackoverflow.com/questions/18835132/xml-to-pem-in-node-js genommen) erzeugt, kann eine JWT überprüfen entweder - aber warum? Wenn beide Verifizierungsmethoden eine JWT-Signatur validieren können, warum gibt es beide? Was sind die Kompromisse zwischen ihnen? Ist einer sicherer als der andere? Welches sollte ich am besten verwenden?

Answer 1

Mit einem RSA assymetrischen Schlüsselpaar wird der JWT mit dem privaten Schlüssel signiert und mit der Öffentlichkeit verifiziert. Sie können eine digitale Signatur mit dem privaten Schlüssel nicht überprüfen

Modul und Exponent sind die Komponenten des öffentlichen Schlüssels und Sie können es verwenden, um den öffentlichen Schlüssel im PEM-Format zu erstellen, das eine Base64-Darstellung des öffentlichen Schlüssels (Modulus) ist und Exponent) im binären DER-Format kodiert. Sie können PEM, DER oder Modulus und Exponent verwenden, weil die gleichen Informationen enthalten

Aber jeder kann den privaten Schlüssel mit Modul und Exponent nicht erstellen. Er würde die privaten RSA-Elemente benötigen, die geheim gehalten werden müssen, damit niemand für dich unterschreiben kann.