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 ⁨Januar 2020⁩.

* Some parts of this feature may have varying levels of support.

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 entgegen. Sie gibt ein Promise zurück, das mit einem booleschen Wert erfüllt wird, der angibt, ob die Signatur gültig ist oder nicht.

Syntax

verify(algorithm, key, signature, data)

Parameter

algorithm

Ein String oder Objekt, das den zu verwendenden Algorithmus definiert und für einige Algorithmen zusätzliche Parameter. Die angegebenen Werte für die zusätzlichen Parameter müssen mit denen im entsprechenden sign()-Aufruf übereinstimmen.

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, der den Schlüssel enthält, der zur Überprüfung der Signatur verwendet wird. Es handelt sich um den geheimen Schlüssel für einen symmetrischen Algorithmus und den öffentlichen Schlüssel für ein Public-Key-System.

signature

Ein ArrayBuffer, der die zu überprüfende Signatur enthält.

data

Ein ArrayBuffer, der 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, false anderenfalls.

Ausnahmen

Das Promise wird abgelehnt, wenn die folgende Ausnahme auftritt:

InvalidAccessError DOMException: Wird ausgelöst, wenn der Verschlüsselungsschlüssel nicht für den angeforderten Überprüfungsalgorithmus geeignet ist oder wenn versucht wird, einen Algorithmus zu verwenden, der entweder unbekannt ist oder sich nicht für eine Überprüfungsoperation eignet.

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. Sehen Sie den vollständigen Code auf GitHub.

/*
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. Sehen Sie den vollständigen Code auf GitHub.

/*
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. Sehen Sie den vollständigen Code auf GitHub.

/*
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. Sehen Sie den vollständigen Code auf GitHub.

/*
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 Daten zu signieren, und dann den öffentlichen Schlüssel verwendet, um die Signatur zu überprüfen.

Der nachstehende Auszug zeigt den Teil, der für die Überprüfung der Signatur mit dem öffentlichen Schlüssel und den kodierten 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 Level 2 # SubtleCrypto-method-verify

Browser-Kompatibilität

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.

Help improve MDN

Learn how to contribute Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden