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

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

SubtleCrypto: `encrypt()` Methode - Web-APIs

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 encrypt() Methode des SubtleCrypto-Interfaces verschlüsselt Daten.

Sie nimmt als Argumente einen Schlüssel zum Verschlüsseln, einige algorithmen-spezifische Parameter und die zu verschlüsselnden Daten (auch bekannt als "Klartext"). Sie gibt ein Promise zurück, das mit den verschlüsselten Daten (auch bekannt als "Chiffre") erfüllt wird.

encrypt(algorithm, key, data)

algorithm

Ein Objekt, das den zu verwendenden Algorithmus und alle zusätzlichen Parameter, falls erforderlich, angibt:

• Um RSA-OAEP zu verwenden, geben Sie ein RsaOaepParams-Objekt an.
• Um AES-CTR zu verwenden, geben Sie ein AesCtrParams-Objekt an.
• Um AES-CBC zu verwenden, geben Sie ein AesCbcParams-Objekt an.
• Um AES-GCM zu verwenden, geben Sie ein AesGcmParams-Objekt an.

key

Ein CryptoKey mit dem Schlüssel, der für die Verschlüsselung verwendet werden soll.

data

Ein ArrayBuffer, ein TypedArray oder ein DataView, das die zu verschlüsselnden Daten (auch bekannt als Klartext) enthält.

Ein Promise, das mit einem ArrayBuffer erfüllt wird, das die "Chiffre" enthält.

Das Promise wird abgelehnt, wenn die folgenden Ausnahmen auftreten:

InvalidAccessError DOMException

Wird ausgelöst, wenn die angeforderte Operation für den bereitgestellten Schlüssel nicht gültig ist (z.B., ungültiger Verschlüsselungsalgorithmus oder ungültiger Schlüssel für den angegebenen Verschlüsselungsalgorithmus).

OperationError DOMException

Wird ausgelöst, wenn die Operation aus einem operationsspezifischen Grund fehlschlägt (z.B., Algorithmenparameter ungültiger Größe oder AES-GCM Klartext länger als 2³⁹−256 Bytes).

Die Web Crypto API bietet vier Algorithmen, die die encrypt() und decrypt() Operationen unterstützen.

Einer dieser Algorithmen — RSA-OAEP — ist ein Public-Key-Kryptosystem.

Die anderen drei hier vorgestellten Verschlüsselungsalgorithmen sind alle symmetrische Algorithmen und basieren alle auf derselben zugrunde liegenden Verschlüsselung, AES (Advanced Encryption Standard). Der Unterschied zwischen ihnen liegt im Modus. Die Web Crypto API unterstützt drei verschiedene AES-Modi:

• CTR (Counter Mode)
• CBC (Cipher Block Chaining)
• GCM (Galois/Counter Mode)

Es wird dringend empfohlen, authentifizierte Verschlüsselung zu verwenden, die Überprüfungen umfasst, dass die Chiffre nicht von einem Angreifer verändert wurde. Authentifizierung hilft, sich gegen gewählte-Chiffre Angriffe zu schützen, bei denen ein Angreifer das System auffordern kann, beliebige Nachrichten zu entschlüsseln und das Ergebnis nutzen kann, um Informationen über den geheimen Schlüssel zu gewinnen. Während es möglich ist, Authentifizierung zu CTR- und CBC-Modi hinzuzufügen, bieten diese standardmäßig keine und bei der manuellen Implementierung kann man leicht kleine, aber schwerwiegende Fehler machen. GCM bietet eingebaute Authentifizierung und ist daher oft gegenüber den anderen beiden AES-Modi empfohlen.

Das RSA-OAEP Public-Key-Verschlüsselungssystem ist in RFC 3447 spezifiziert.

Dies stellt AES im Counter-Modus dar, wie in NIST SP800-38A spezifiziert.

AES ist ein Blockverschlüsselungsverfahren, das bedeutet, dass es die Nachricht in Blöcke aufteilt und jeden Block einzeln verschlüsselt. Im CTR-Modus wird jedes Mal, wenn ein Block der Nachricht verschlüsselt wird, ein zusätzlicher Datenblock eingemischt. Dieser zusätzliche Block wird "Counter Block" genannt.

Ein bestimmter Counter Block-Wert darf mit demselben Schlüssel niemals mehr als einmal verwendet werden:

• Bei einer Nachricht, die n Blöcke lang ist, muss für jeden Block ein anderer Counter Block verwendet werden.
• Wenn derselbe Schlüssel verwendet wird, um mehr als eine Nachricht zu verschlüsseln, muss für alle Blöcke über alle Nachrichten hinweg ein anderer Counter Block verwendet werden.

Typischerweise wird dies erreicht, indem der Initialwert des Counter Blocks in zwei verkettete Teile aufgeteilt wird:

• Eine Nonce (also eine Zahl, die nur einmal verwendet werden darf). Der Nonce-Teil des Blocks bleibt für jeden Block in der Nachricht gleich. Jedes Mal, wenn eine neue Nachricht verschlüsselt werden soll, wird ein neuer Nonce gewählt. Nonces müssen nicht geheim sein, dürfen aber nicht mit demselben Schlüssel erneut verwendet werden.
• Ein Zähler. Dieser Teil des Blocks wird jedes Mal, wenn ein Block verschlüsselt wird, erhöht.

Im Wesentlichen: Die Nonce sollte sicherstellen, dass Counter Blocks nicht von einer Nachricht zur nächsten wiederverwendet werden, während der Zähler sicherstellen sollte, dass Counter Blocks nicht innerhalb einer einzelnen Nachricht wiederverwendet werden.

Hinweis: Siehe Anhang B des NIST SP800-38A Standards für weitere Informationen.

Dies stellt AES im Cipher Block Chaining-Modus dar, wie in NIST SP800-38A spezifiziert.

Dies stellt AES im Galois/Counter-Modus dar, wie in NIST SP800-38D spezifiziert.

Ein wesentlicher Unterschied zwischen diesem Modus und den anderen ist, dass GCM ein "authentifizierter" Modus ist, was bedeutet, dass es Überprüfungen enthält, dass die Chiffre nicht von einem Angreifer verändert wurde.

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

Dieser Code holt den Inhalt einer Textbox, codiert ihn zur Verschlüsselung und verschlüsselt ihn mit RSA-OAEP. Sehen Sie den kompletten Code auf GitHub.

function getMessageEncoding() {
  const messageBox = document.querySelector(".rsa-oaep #message");
  let message = messageBox.value;
  let enc = new TextEncoder();
  return enc.encode(message);
}

function encryptMessage(publicKey) {
  let encoded = getMessageEncoding();
  return window.crypto.subtle.encrypt(
    {
      name: "RSA-OAEP",
    },
    publicKey,
    encoded,
  );
}

Dieser Code holt den Inhalt einer Textbox, codiert ihn zur Verschlüsselung und verschlüsselt ihn im CTR-Modus mit AES. Sehen Sie den kompletten Code auf GitHub.

function getMessageEncoding() {
  const messageBox = document.querySelector(".aes-ctr #message");
  let message = messageBox.value;
  let enc = new TextEncoder();
  return enc.encode(message);
}

function encryptMessage(key) {
  let encoded = getMessageEncoding();
  // counter will be needed for decryption
  counter = window.crypto.getRandomValues(new Uint8Array(16));
  return window.crypto.subtle.encrypt(
    {
      name: "AES-CTR",
      counter,
      length: 64,
    },
    key,
    encoded,
  );
}

let iv = window.crypto.getRandomValues(new Uint8Array(16));
let key = window.crypto.getRandomValues(new Uint8Array(16));
let data = new Uint8Array(12345);
// crypto functions are wrapped in promises so we have to use await and make sure the function that
// contains this code is an async function
// encrypt function wants a cryptokey object
const key_encoded = await window.crypto.subtle.importKey(
  "raw",
  key.buffer,
  "AES-CTR",
  false,
  ["encrypt", "decrypt"],
);
const encrypted_content = await window.crypto.subtle.encrypt(
  {
    name: "AES-CTR",
    counter: iv,
    length: 128,
  },
  key_encoded,
  data,
);

// Uint8Array
console.log(encrypted_content);

Dieser Code holt den Inhalt einer Textbox, codiert ihn zur Verschlüsselung und verschlüsselt ihn im CBC-Modus mit AES. Sehen Sie den kompletten Code auf GitHub.

function getMessageEncoding() {
  const messageBox = document.querySelector(".aes-cbc #message");
  let message = messageBox.value;
  let enc = new TextEncoder();
  return enc.encode(message);
}

function encryptMessage(key) {
  let encoded = getMessageEncoding();
  // iv will be needed for decryption
  iv = window.crypto.getRandomValues(new Uint8Array(16));
  return window.crypto.subtle.encrypt({ name: "AES-CBC", iv }, key, encoded);
}

Dieser Code holt den Inhalt einer Textbox, codiert ihn zur Verschlüsselung und verschlüsselt ihn im GCM-Modus mit AES. Sehen Sie den kompletten Code auf GitHub.

function getMessageEncoding() {
  const messageBox = document.querySelector(".aes-gcm #message");
  const message = messageBox.value;
  const enc = new TextEncoder();
  return enc.encode(message);
}

function encryptMessage(key) {
  const encoded = getMessageEncoding();
  // iv will be needed for decryption
  const iv = window.crypto.getRandomValues(new Uint8Array(12));
  return window.crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
}

• SubtleCrypto.decrypt().
• RFC 3447 spezifiziert RSAOAEP.
• NIST SP800-38A spezifiziert den CTR-Modus.
• NIST SP800-38A spezifiziert den CBC-Modus.
• NIST SP800-38D spezifiziert den GCM-Modus.

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