RsaPssParams — Schnittstelle · JavaScript-Referenz

Signatur

interface RsaPssParams extends Algorithm

Beschreibung

RsaPssParams ist ein Wörterbuch (Dictionary) des Web Crypto API und keine Klasse, die man mit new erzeugt. Man übergibt ein einfaches Objekt der Form { name: "RSA-PSS", saltLength: 32 } als ersten Parameter an crypto.subtle.sign() oder crypto.subtle.verify(), wenn mit einem RSA-PSS-Schlüsselpaar signiert oder geprüft werden soll.

RSA-PSS (Probabilistic Signature Scheme) ist der moderne, beweisbar sichere Nachfolger von RSASSA-PKCS1-v1_5. Durch einen zufälligen Salt ergibt jede Signatur derselben Nachricht einen anderen Wert. Die Hash-Funktion wird nicht in RsaPssParams angegeben, sondern beim Erzeugen oder Importieren des Schlüssels festgelegt (über RsaHashedKeyGenParams bzw. RsaHashedImportParams).

Man verwendet RSA-PSS, wenn Interoperabilität mit RSA-basierten Systemen nötig ist (z. B. JWS mit PS256, Signaturen für Backends oder Zertifikate). Für neue Projekte ohne RSA-Zwang sind ECDSA oder Ed25519 meist kompakter und schneller.

Parameter

Name	Typ	Default	Beschreibung
$name Pflicht	string		Muss `"RSA-PSS"` sein (Groß-/Kleinschreibung wird normalisiert).
$saltLength Pflicht	number		Länge des zufälligen Salts in Bytes (nicht Bits). Üblich ist die Ausgabelänge des Hashs: 32 für SHA-256, 48 für SHA-384, 64 für SHA-512. Maximal zulässig: `Math.ceil((modulusLength - 1) / 8) - hashLength - 2`. Beim Prüfen muss derselbe Wert wie beim Signieren verwendet werden.

Rückgabewert

Typ

object

Beschreibung

Kein Rückgabewert – RsaPssParams ist ein reines Konfigurationsobjekt, das an sign()/verify() übergeben wird.

Beispiele

Schlüsselpaar erzeugen und Nachricht signieren

const keyPair = await crypto.subtle.generateKey(
  {
    name: "RSA-PSS",
    modulusLength: 2048,
    publicExponent: new Uint8Array([1, 0, 1]),
    hash: "SHA-256" // Hash wird hier festgelegt, nicht in RsaPssParams
  },
  true,
  ["sign", "verify"]
);

// RsaPssParams: Salt-Länge = Hash-Länge (32 Bytes bei SHA-256)
const pssParams = { name: "RSA-PSS", saltLength: 32 };

const data = new TextEncoder().encode("Bestellung #4711");
const signature = await crypto.subtle.sign(pssParams, keyPair.privateKey, data);

console.log(signature.byteLength);

256

Signatur prüfen

const isValid = await crypto.subtle.verify(
  { name: "RSA-PSS", saltLength: 32 },
  keyPair.publicKey,
  signature,
  data
);
console.log(isValid);

// Manipulierte Daten schlagen fehl
const fake = new TextEncoder().encode("Bestellung #9999");
console.log(await crypto.subtle.verify({ name: "RSA-PSS", saltLength: 32 }, keyPair.publicKey, signature, fake));

true false

Wiederverwendbare Hilfsfunktion mit Base64-Ausgabe (z. B. für PS256)

const toBase64Url = (buf) =>
  btoa(String.fromCharCode(...new Uint8Array(buf)))
    .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");

const signPs256 = async (privateKey, text) => {
  const sig = await crypto.subtle.sign(
    { name: "RSA-PSS", saltLength: 32 },
    privateKey,
    new TextEncoder().encode(text)
  );
  return toBase64Url(sig);
};

const token = await signPs256(keyPair.privateKey, "header.payload");
console.log(token.length);

342

// Wichtig · Fallstricke

Bytes statt Bits: saltLength wird in Bytes angegeben. Ein häufiger Fehler ist saltLength: 256 in der Annahme, es seien Bits – das führt bei 2048-Bit-Schlüsseln zu einem OperationError.
Gleicher Salt-Wert beim Prüfen: verify() gibt false zurück, wenn die Salt-Länge von der beim Signieren verwendeten abweicht. Andere Bibliotheken (OpenSSL, Java) nutzen teils die maximale Salt-Länge als Standard – Werte bei Interoperabilität abstimmen.
saltLength: 0 ist erlaubt, macht die Signatur aber deterministisch und verzichtet auf den Sicherheitsvorteil von PSS.
Der Schlüssel muss mit name: "RSA-PSS" erzeugt oder importiert sein; ein RSASSA-PKCS1-v1_5-Schlüssel führt zu einem InvalidAccessError.
Das Web Crypto API ist nur in sicheren Kontexten (HTTPS, localhost) verfügbar; crypto.subtle ist sonst undefined.
Empfehlung: mindestens 2048 Bit Modulus, besser 3072 Bit für langfristige Sicherheit.

Siehe auch

SubtleCrypto.sign() SubtleCrypto.verify() SubtleCrypto.generateKey() RsaHashedKeyGenParams RsaHashedImportParams EcdsaParams SubtleCrypto