RsaHashedKeyGenParams — Schnittstelle · JavaScript-Referenz

Signatur

interface RsaHashedKeyGenParams extends Algorithm

Beschreibung

RsaHashedKeyGenParams ist keine Klasse, die man instanziiert, sondern ein einfaches Objekt (Dictionary) mit festgelegten Eigenschaften. Man übergibt es als ersten Parameter an crypto.subtle.generateKey(), wenn man ein RSA-Schlüsselpaar für einen der Algorithmen RSASSA-PKCS1-v1_5, RSA-PSS (Signaturen) oder RSA-OAEP (Verschlüsselung) erzeugen möchte.

Das Dictionary legt fest, welcher RSA-Algorithmus verwendet wird (name), wie lang der Modulus in Bit ist (modulusLength), welcher öffentliche Exponent gilt (publicExponent) und welche Hash-Funktion an den Schlüssel gebunden wird (hash). Die Hash-Funktion ist fester Bestandteil des erzeugten Schlüssels – ein mit SHA-256 erzeugter Schlüssel kann später nicht mit SHA-512 genutzt werden.

Das Ergebnis von generateKey() ist ein CryptoKeyPair mit publicKey und privateKey. Die Eigenschaft algorithm der erzeugten CryptoKey-Objekte entspricht dann einem RsaHashedKeyAlgorithm, das die hier übergebenen Werte widerspiegelt.

Parameter

Name	Typ	Beschreibung
$name Pflicht	string	Name des Algorithmus: `"RSASSA-PKCS1-v1_5"`, `"RSA-PSS"` oder `"RSA-OAEP"`.
$modulusLength Pflicht	number	Länge des RSA-Modulus in Bit. Empfohlen sind mindestens `2048`, für langfristige Sicherheit `3072` oder `4096`.
$publicExponent Pflicht	Uint8Array	Öffentlicher Exponent als Big-Endian-Byte-Array. Praktisch immer `new Uint8Array([1, 0, 1])` (= 65537) verwenden.
$hash Pflicht	string \| { name: string }	Hash-Funktion, die an den Schlüssel gebunden wird: `"SHA-256"`, `"SHA-384"` oder `"SHA-512"` (`"SHA-1"` nur für Altsysteme).

Rückgabewert

Typ

void

Beschreibung

Ein Dictionary hat keinen Rückgabewert. crypto.subtle.generateKey() liefert mit diesem Parameter ein Promise<CryptoKeyPair>.

Beispiele

RSA-OAEP-Schlüsselpaar zum Verschlüsseln erzeugen

const params = {
  name: 'RSA-OAEP',
  modulusLength: 3072,
  publicExponent: new Uint8Array([1, 0, 1]), // 65537
  hash: 'SHA-256'
};

const { publicKey, privateKey } = await crypto.subtle.generateKey(
  params,
  true,                    // exportierbar
  ['encrypt', 'decrypt']
);

console.log(publicKey.algorithm.name, publicKey.algorithm.modulusLength);
console.log(privateKey.usages);

RSA-OAEP 3072 ["decrypt"]

Nachricht mit RSA-OAEP ver- und entschlüsseln

const keyPair = await crypto.subtle.generateKey(
  { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
  false,
  ['encrypt', 'decrypt']
);

const data = new TextEncoder().encode('Geheime Nachricht');
const cipher = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, keyPair.publicKey, data);
const plain = await crypto.subtle.decrypt({ name: 'RSA-OAEP' }, keyPair.privateKey, cipher);

console.log(cipher.byteLength);
console.log(new TextDecoder().decode(plain));

256 Geheime Nachricht

RSA-PSS-Signatur erstellen und prüfen

const { publicKey, privateKey } = await crypto.subtle.generateKey(
  { name: 'RSA-PSS', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
  true,
  ['sign', 'verify']
);

const doc = new TextEncoder().encode('Rechnung #4711');
const signature = await crypto.subtle.sign({ name: 'RSA-PSS', saltLength: 32 }, privateKey, doc);
const ok = await crypto.subtle.verify({ name: 'RSA-PSS', saltLength: 32 }, publicKey, signature, doc);

console.log('Signatur gültig:', ok);

Signatur gültig: true

Öffentlichen Schlüssel als JWK exportieren

const { publicKey } = await crypto.subtle.generateKey(
  { name: 'RSASSA-PKCS1-v1_5', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
  true,
  ['sign', 'verify']
);

const jwk = await crypto.subtle.exportKey('jwk', publicKey);
console.log(jwk.kty, jwk.alg, jwk.e);

RSA RS256 AQAB

// Wichtig · Fallstricke

Sicherer Kontext: crypto.subtle steht nur unter HTTPS bzw. localhost zur Verfügung; auf HTTP-Seiten ist es undefined.
publicExponent: Muss ein Uint8Array sein (kein number). Viele Browser akzeptieren nur 3 oder 65537; andere Werte führen zu einem OperationError.
Performance: RSA-Schlüsselerzeugung ist teuer – 4096 Bit kann mehrere Sekunden dauern. Nicht im kritischen Render-Pfad aufrufen; für schnelle Signaturen sind ECDSA/Ed25519 oft die bessere Wahl.
Schlüsselverwendung: keyUsages müssen zum Algorithmus passen (encrypt/decrypt/wrapKey/unwrapKey nur für RSA-OAEP, sign/verify für PSS und PKCS1-v1_5), sonst wird ein SyntaxError geworfen.
Nachrichtengröße: RSA-OAEP kann nur kurze Daten verschlüsseln (bei 2048 Bit und SHA-256 max. 190 Byte). Für größere Daten hybrid arbeiten: AES-GCM-Schlüssel erzeugen und diesen mit RSA-OAEP umhüllen.
Sicherheit: Keine Modulus-Längen unter 2048 Bit und kein SHA-1 für neue Anwendungen. Private Schlüssel möglichst mit extractable: false erzeugen und in IndexedDB speichern.

Siehe auch

SubtleCrypto.generateKey() SubtleCrypto CryptoKey CryptoKeyPair RsaHashedImportParams