Index: test/openwebauth.test.js
===================================================================
--- test/openwebauth.test.js	(revision 192fe2845b731c1eee4186336305399b52e0f4b1)
+++ test/openwebauth.test.js	(revision 598f09038f721164997d5a888801e65d93c1acb2)
@@ -74,8 +74,9 @@
   assert.ok(!/[+/]/.test(versleuteld), 'en URL-veilig');
 
-  const terug = crypto.privateDecrypt(
-    { key: privateKey, padding: crypto.constants.RSA_PKCS1_PADDING },
-    Buffer.from(versleuteld.replace(/-/g, '+').replace(/_/g, '/'), 'base64'),
-  ).toString('utf8');
+  // Door ONZE eigen uitpakker, niet rechtstreeks door crypto.privateDecrypt:
+  // die weigert PKCS#1 v1.5 sinds de mitigatie voor CVE-2023-46809, en de
+  // revert-vlag bestaat alleen op Node 18/20/21 -- allemaal EOL. decryptToken
+  // haalt het omhulsel zelf af en werkt dus op een Node die nog leeft.
+  const terug = OWA.decryptToken(versleuteld, privateKey.export({ type: 'pkcs8', format: 'pem' }));
   assert.equal(terug, token);
 
@@ -83,20 +84,24 @@
   // de voor de hand liggende toets (assert.throws) is hier fout.
   //
-  // PKCS#1 v1.5 gooit bij een verkeerde sleutel geen fout: OpenSSL 3 doet aan
-  // "implicit rejection" en geeft afgeleide onzin terug in plaats van te falen,
-  // juist zodat een aanvaller niet aan het foutgedrag kan aflezen of zijn gok
-  // klopte (Bleichenbacher/Marvin). Gemeten: 200 vreemde sleutels, 0 fouten,
-  // 200 keer bytes -- en 0 keer het token.
+  // Bij een verkeerde sleutel hoort er geen FOUT te komen maar afgeleide onzin:
+  // implicit rejection. Anders leest een aanvaller aan het foutgedrag af of zijn
+  // gok klopte (Bleichenbacher/Marvin).
+  //
+  // LET OP waar dat vandaan komt. OpenSSL doet dit pas zelf vanaf 3.2; op 3.0.19
+  // -- wat Node 20 meebrengt en wat wij draaien -- WERPT hij gewoon. Gemeten op
+  // 19-8-2026. Een eerdere versie van deze test ging uit van OpenSSL's gedrag en
+  // was daarmee afhankelijk van welke Node de meting toevallig deed. Nu maakt
+  // decryptToken de implicit rejection ZELF, dus de eigenschap staat vast
+  // ongeacht de OpenSSL eronder.
   //
   // De eigenschap die telt is dus niet "het knalt" maar "er komt iets anders
   // uit". Wat de home instance daarna terugstuurt matcht geen enkel opgeslagen
   // token, en de inlog mislukt gewoon.
-  const ruw = Buffer.from(versleuteld.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
   for (let i = 0; i < 5; i++) {
-    const vreemde = crypto.generateKeyPairSync('rsa', { modulusLength: 2048 }).privateKey;
+    const vreemde = crypto.generateKeyPairSync('rsa', { modulusLength: 2048 })
+      .privateKey.export({ type: 'pkcs8', format: 'pem' });
     let uit = null;
-    try {
-      uit = crypto.privateDecrypt({ key: vreemde, padding: crypto.constants.RSA_PKCS1_PADDING }, ruw).toString('utf8');
-    } catch { uit = null; }                     // een fout mag, maar is niet de regel
+    assert.doesNotThrow(() => { uit = OWA.decryptToken(versleuteld, vreemde); },
+      'werpen is het signaal waar Bleichenbacher op draait');
     assert.notEqual(uit, token, 'andermans sleutel levert nooit het token');
   }
Index: test/owa-decrypt-v15.test.js
===================================================================
--- test/owa-decrypt-v15.test.js	(revision 598f09038f721164997d5a888801e65d93c1acb2)
+++ test/owa-decrypt-v15.test.js	(revision 598f09038f721164997d5a888801e65d93c1acb2)
@@ -0,0 +1,111 @@
+// PKCS#1 v1.5 zelf uitpakken (shaer-r15).
+//
+// Node weigert privateDecrypt met RSA_PKCS1_PADDING sinds de mitigatie voor
+// CVE-2023-46809, en de revert-vlag bestaat alleen op 18/20/21 -- allemaal EOL.
+// FEP-61cf schrijft v1.5 voor, dus OAEP breekt de interop. Blijft over: het
+// omhulsel zelf afhalen, met implicit rejection erin.
+//
+// DEZE TESTS DRAAIEN ZONDER --security-revert. Dat is de hele inzet: als ze
+// groen zijn, werkt gastlogin op een Node die nog ondersteund wordt.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import crypto from 'node:crypto';
+import { decryptToken, encryptTokenFor, _nepUitkomst } from '../src/services/OpenWebAuthService.js';
+
+const paar = () => crypto.generateKeyPairSync('rsa', {
+  modulusLength: 2048,
+  publicKeyEncoding: { type: 'spki', format: 'pem' },
+  privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+});
+const A = paar();
+const TOKEN = 'abcdefghijklmnopqrstuvwxyz0123456789._~-';
+
+test('een echt token komt er heel uit, zonder revert-vlag', () => {
+  const ct = encryptTokenFor(TOKEN, A.publicKey);
+  assert.equal(decryptToken(ct, A.privateKey), TOKEN);
+});
+
+test('een verkeerde sleutel WERPT niet maar levert niets op', () => {
+  const B = paar();
+  const ct = encryptTokenFor(TOKEN, A.publicKey);
+  // Werpen is het signaal waar Bleichenbacher op draait. Dat mag hier niet.
+  assert.doesNotThrow(() => decryptToken(ct, B.privateKey));
+  assert.equal(decryptToken(ct, B.privateKey), null);
+});
+
+// Dezelfde meting als waar het oude commentaar op stond, nu tegen de nieuwe weg.
+test('300 vreemde sleutels: geen enkele worp, geen enkel token', () => {
+  const ct = encryptTokenFor(TOKEN, A.publicKey);
+  let worpen = 0, tokens = 0;
+  for (let i = 0; i < 300; i++) {
+    try { if (decryptToken(ct, paar().privateKey) !== null) tokens++; } catch { worpen++; }
+  }
+  assert.equal(worpen, 0, 'geen enkele aanroep mag werpen');
+  assert.equal(tokens, 0, 'afgeleide onzin mag nooit als token doorgaan');
+});
+
+// De eigenschap waar implicit rejection op staat of valt.
+test('de nep-uitkomst is DETERMINISTISCH, niet vers willekeurig', () => {
+  const ct = Buffer.from('een-ciphertext-om-te-herhalen');
+  assert.equal(_nepUitkomst(A.privateKey, ct), _nepUitkomst(A.privateKey, ct),
+    'dezelfde ciphertext moet hetzelfde antwoord geven; anders verklikt herhaling het verschil');
+  assert.notEqual(_nepUitkomst(A.privateKey, ct), _nepUitkomst(paar().privateKey, ct),
+    'en hij moet aan de sleutel hangen, anders is hij te voorspellen');
+  assert.notEqual(_nepUitkomst(A.privateKey, ct), _nepUitkomst(A.privateKey, Buffer.from('iets anders')));
+});
+
+test('rommel erin werpt ook niet', () => {
+  for (const rommel of ['', 'geen base64!!', 'a'.repeat(10), 'x'.repeat(400), null, undefined]) {
+    assert.doesNotThrow(() => decryptToken(rommel, A.privateKey), String(rommel).slice(0, 12));
+    assert.equal(decryptToken(rommel, A.privateKey), null);
+  }
+});
+
+// De regels van het omhulsel, ECHT getoetst. Met RSA_NO_PADDING kun je een blok
+// naar keuze versleutelen (rauw m^e mod n), dus we kunnen precies bepalen wat er
+// na ontsleuteling uit komt -- en dus elke regel apart uitproberen.
+const rauwVersleutel = (blok) =>
+  crypto.publicEncrypt({ key: A.publicKey, padding: crypto.constants.RSA_NO_PADDING }, blok)
+    .toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+/**
+ * 00 02 <ps bytes vulling> 00 <boodschap>, met de vulling instelbaar.
+ *
+ * De boodschap staat tegen het EINDE van het blok: bij PKCS#1 vult hij precies
+ * de rest op. Zet je hem er los achter, dan houd je staartnullen over en die
+ * sneuvelen terecht op de tekenset-controle -- daar liep mijn eerste opzet op
+ * vast, en dat is meteen het bewijs dat deze test iets doet.
+ */
+function bouwBlok({ kop = [0x00, 0x02], ps = 200, scheider = true } = {}) {
+  const k = 256;
+  const boodschap = 'a'.repeat(k - 3 - ps);
+  const b = Buffer.alloc(k, 0x00);
+  b[0] = kop[0]; b[1] = kop[1];
+  for (let i = 2; i < 2 + ps; i++) b[i] = 0xAB;      // vulling, nooit nul
+  b[2 + ps] = scheider ? 0x00 : 0xAB;
+  Buffer.from(boodschap).copy(b, 2 + ps + 1);
+  return { blok: b, boodschap };
+}
+
+test('een handgemaakt GELDIG omhulsel levert de boodschap op', () => {
+  const { blok, boodschap } = bouwBlok({ ps: 200 });
+  assert.equal(decryptToken(rauwVersleutel(blok), A.privateKey), boodschap,
+    'dit bewijst dat de uitpakker echt uitpakt');
+});
+
+test('te korte PS wordt geweigerd: RFC 8017 eist er acht', () => {
+  const kort = bouwBlok({ ps: 7 });     // scheider op 9, grens ligt op 10
+  assert.equal(decryptToken(rauwVersleutel(kort.blok), A.privateKey), null);
+  const net = bouwBlok({ ps: 8 });      // scheider op 10, precies goed
+  assert.equal(decryptToken(rauwVersleutel(net.blok), A.privateKey), net.boodschap);
+});
+
+test('een verkeerde kop wordt geweigerd', () => {
+  for (const kop of [[0x00, 0x01], [0x01, 0x02], [0x00, 0x00]])
+    assert.equal(decryptToken(rauwVersleutel(bouwBlok({ kop }).blok), A.privateKey), null, String(kop));
+});
+
+test('zonder scheidende nulbyte komt er niets uit', () => {
+  const { blok } = bouwBlok({ ps: 200, scheider: false });   // nergens een nulbyte
+  assert.equal(decryptToken(rauwVersleutel(blok), A.privateKey), null);
+});