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: Diese Funktion ist in Web Workers verfügbar.

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

js
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" }.
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.

js
/*
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.

js
/*
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.

js
/*
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.

js
/*
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:

js
// 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