SubtleCrypto: verify()-Methode
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Sicherer Kontext: Diese Funktion ist nur in sicheren Kontexten (HTTPS) in einigen oder allen unterstützenden Browsern verfügbar.
Hinweis: Dieses Feature ist verfügbar in Web Workers.
Die verify()
-Methode des SubtleCrypto
-Interfaces überprüft eine digitale Signatur.
Sie nimmt als Argumente einen Schlüssel zur Überprüfung der Signatur, einige algorithmenspezifische Parameter, die Signatur und die ursprünglich signierten Daten.
Sie gibt ein Promise
zurück, das mit einem booleschen Wert erfüllt wird, der angibt, ob die Signatur gültig ist.
Syntax
verify(algorithm, key, signature, data)
Parameter
algorithm
-
Ein String oder Objekt, das den Algorithmus definiert, sowie bei einigen Algorithmusoptionen zusätzliche Parameter. Die für die zusätzlichen Parameter angegebenen Werte müssen mit denen übereinstimmen, die im entsprechenden
sign()
-Aufruf übergeben wurden.- Um RSASSA-PKCS1-v1_5 zu verwenden, übergeben Sie den String
"RSASSA-PKCS1-v1_5"
oder ein Objekt der Form{ "name": "RSASSA-PKCS1-v1_5" }
. - Um RSA-PSS zu verwenden, übergeben Sie ein
RsaPssParams
-Objekt. - Um ECDSA zu verwenden, übergeben Sie ein
EcdsaParams
-Objekt. - Um HMAC zu verwenden, übergeben Sie den String
"HMAC"
oder ein Objekt der Form{ "name": "HMAC" }
. - Um Ed25519 zu verwenden, übergeben Sie ein Objekt der Form
{ "name": "Ed25519" }
.
- Um RSASSA-PKCS1-v1_5 zu verwenden, übergeben Sie den String
key
-
Ein
CryptoKey
, das den Schlüssel enthält, der zur Überprüfung der Signatur verwendet wird. Es ist der geheime Schlüssel für einen symmetrischen Algorithmus und der öffentliche Schlüssel für ein Public-Key-System. signature
-
Ein
ArrayBuffer
, der die Signatur enthält, die überprüft werden soll. data
-
Ein
ArrayBuffer
, das die Daten enthält, deren Signatur überprüft werden soll.
Rückgabewert
Ein Promise
, das mit einem booleschen Wert erfüllt wird: true
, wenn die Signatur gültig ist, sonst false
.
Ausnahmen
Das Promise wird abgelehnt, wenn die folgende Ausnahme auftritt:
InvalidAccessError
DOMException
-
Wird ausgelöst, wenn der Verschlüsselungsschlüssel kein Schlüssel für den angeforderten Verifizierungsalgorithmus ist oder wenn versucht wird, einen Algorithmus zu verwenden, der entweder unbekannt oder für eine Verifizierungsoperation nicht geeignet ist.
Unterstützte Algorithmen
Die verify()
-Methode unterstützt die gleichen Algorithmen wie die sign()
-Methode.
Beispiele
Hinweis: Sie können die funktionierenden Beispiele auf GitHub ausprobieren.
RSASSA-PKCS1-v1_5
Dieser Code verwendet einen öffentlichen Schlüssel, um eine Signatur zu überprüfen. Den vollständigen Code auf GitHub ansehen.
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsassa-pkcs1 #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(
".rsassa-pkcs1 .signature-value",
);
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
"RSASSA-PKCS1-v1_5",
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
RSA-PSS
Dieser Code verwendet einen öffentlichen Schlüssel, um eine Signatur zu überprüfen. Den vollständigen Code auf GitHub ansehen.
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsa-pss #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(".rsa-pss .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
{
name: "RSA-PSS",
saltLength: 32,
},
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
ECDSA
Dieser Code verwendet einen öffentlichen Schlüssel, um eine Signatur zu überprüfen. Den vollständigen Code auf GitHub ansehen.
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".ecdsa #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(".ecdsa .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
{
name: "ECDSA",
hash: { name: "SHA-384" },
},
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
HMAC
Dieser Code verwendet einen geheimen Schlüssel, um eine Signatur zu überprüfen. Den vollständigen Code auf GitHub ansehen.
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".hmac #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(key) {
const signatureValue = document.querySelector(".hmac .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
"HMAC",
key,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
Ed25519
Das Ed25519 Live-Beispiel in SubtleCrypto.sign()
zeigt, wie man öffentliche und private Schlüssel generiert, den privaten Schlüssel verwendet, um einige Daten zu signieren, und anschließend den öffentlichen Schlüssel verwendet, um die Signatur zu überprüfen.
Der unten gezeigte Auszug zeigt den Teil, der für die Überprüfung der Signatur mit dem öffentlichen Schlüssel und den codierten Daten relevant ist:
// Verify the signature using the public key
const verifyResult = await crypto.subtle.verify(
{
name: "Ed25519",
},
publicKey,
signature,
encodedData,
);
// True if the signature is valid.
Spezifikationen
Specification |
---|
Web Cryptography API # SubtleCrypto-method-verify |
Browser-Kompatibilität
BCD tables only load in the browser
Siehe auch
SubtleCrypto.sign()
.- RFC 3447 spezifiziert RSASSA-PKCS1-v1_5.
- RFC 3447 spezifiziert RSA-PSS.
- FIPS-186 spezifiziert ECDSA.
- FIPS 198-1 spezifiziert HMAC.