Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://developer.mozilla.org/de/docs/Web/API/SubtleCrypto/verify below:

SubtleCrypto: verify()-Methode - Web-APIs | MDN

Baseline Widely available *

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.

verify(algorithm, key, signature, data)

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.

Ein Promise, das mit einem booleschen Wert erfüllt wird: true, wenn die Signatur gültig ist, sonst false.

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.

Die verify()-Methode unterstützt die gleichen Algorithmen wie die sign()-Methode.

Hinweis: Sie können die funktionierenden Beispiele auf GitHub ausprobieren.

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");
}

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");
}

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");
}

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");
}

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.

• SubtleCrypto.sign().
• RFC 3447 spezifiziert RSASSA-PKCS1-v1_5.
• RFC 3447 spezifiziert RSA-PSS.
• FIPS-186 spezifiziert ECDSA.
• FIPS 198-1 spezifiziert HMAC.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4