visaljs 0.0.9 → 0.0.11

package/node/prelude/https.js

@@ -18,10 +18,11 @@ class ServerClass extends TlsServer {
       options = {};
     } else if (options === undefined || options === null) {
       options = {};
-    } else if (typeof options !== "object") {
+    } else if (typeof options !== "object" || Array.isArray(options)) {
       throw invalidArgType("options", "of type object", options);
     }
-    super({ noDelay: true, ALPNProtocols: ["http/1.1"], ...options });
+    /* only one of ALPNProtocols and ALPNCallback can be set: the default only when neither is */
+    super({ noDelay: true, ALPNProtocols: options.ALPNProtocols || options.ALPNCallback ? undefined : ["http/1.1"], ...options });
     this._initHttp(options, requestListener, "secureConnection");
     /* a handshake that fails is the client's error, as a request that does */
     this.on("tlsClientError", (err, conn) => {
@@ -84,17 +85,25 @@ const nameOptions = ["ca", "cert", "clientCertEngine", "ciphers", "key", "pfx",
   "maxVersion", "secureProtocol", "crl", "honorCipherOrder", "ecdhCurve", "dhparam", "secureOptions", "sessionIdContext", "sigalgs",
   "privateKeyIdentifier", "privateKeyEngine"];
 
+/* the options a value of which, false or 0 too, names a different connection */
+const nameDefined = new Set(["rejectUnauthorized", "honorCipherOrder", "secureOptions"]);
+
+function pfxAgentKey(pfx, passphrase) {
+  if (!Array.isArray(pfx)) return pfx;
+  return pfx.map((value) => `:${value?.buf || value}:${value?.passphrase || passphrase}`).join("");
+}
+
 Agent.prototype.getName = function getName(options = {}) {
   let name = HttpAgent.prototype.getName.call(this, options);
   for (const key of nameOptions) {
     name += ":";
     const value = options[key];
-    if (key === "rejectUnauthorized") {
+    if (nameDefined.has(key)) {
       if (value !== undefined) name += value;
     } else if (key === "servername") {
       if (value && value !== options.host) name += value;
     } else if (value) {
-      name += value;
+      name += key === "sigalgs" ? JSON.stringify(value) : key === "pfx" ? pfxAgentKey(value, options.passphrase) : value;
     }
   }
   return name;

package/node/prelude/internal/console_class.js

@@ -0,0 +1,7 @@
+// console.Console on the global console, as node:console puts it there: a feature module, linked
+// into programs that name Console without importing node:console.
+import { Console } from "../console.js";
+
+if (globalThis.console.Console === undefined) {
+  Object.defineProperty(globalThis.console, "Console", { value: Console, writable: true, configurable: true });
+}

package/node/prelude/internal/console_global.js

@@ -0,0 +1,25 @@
+// The global console as Node's (lib/internal/console/global.js): Console's methods bound to an
+// instance writing to process.stdout and process.stderr, looked up when first written to, and
+// its _stdout and _stderr settable. A feature module (implicitModules in node/index.ts): linked
+// into a program that replaces a stdio stream's write, which the runtime's console, writing to
+// the fds, wouldn't go through. The runtime's console object stays the global (code may hold it).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { Console, kBindProperties, kBindStreamsLazy } from "../console.js";
+
+const global = globalThis.console;
+const instance = Object.create(Console.prototype);
+instance[kBindStreamsLazy](globalThis.process);
+instance[kBindProperties](true, "auto");
+
+for (const key of Object.keys(Console.prototype)) {
+  const method = Console.prototype[key].bind(instance);
+  Object.defineProperty(method, "name", { value: key });
+  Object.defineProperty(global, key, { value: method, writable: true, enumerable: true, configurable: true });
+}
+for (const name of ["_stdout", "_stderr"]) {
+  Object.defineProperty(global, name, {
+    get: () => instance[name],
+    set: (stream) => { instance[name] = stream; },
+    configurable: true,
+  });
+}

package/node/prelude/internal/crypto/key_encryption.js

@@ -0,0 +1,217 @@
+// Encrypted private keys, as OpenSSL writes and reads them for Node: PKCS#8's
+// EncryptedPrivateKeyInfo (PBES2, RFC 8018: PBKDF2 and a CBC cipher; "ENCRYPTED PRIVATE KEY" in
+// PEM), and the PEM headers of a PKCS#1 or SEC1 key (Proc-Type, DEK-Info; the key from OpenSSL's
+// EVP_BytesToKey with MD5). The ciphers and digests are the runtime's; the DER here is only these
+// structures'.
+import {
+  cryptoCipherFinal, cryptoCipherInfo, cryptoCipherNew, cryptoCipherUpdate, cryptoDigestFinal, cryptoDigestUpdate, cryptoHashNew,
+  cryptoPbkdf2, cryptoRandomFill,
+} from "visaljs:host";
+import { codeError, notSupported } from "../errors.js";
+
+/* OpenSSL 3's choices for PEM_write_bio_PKCS8PrivateKey with a cipher */
+const PBKDF2_ITERATIONS = 2048;
+const SALT_LENGTH = 16;
+/* the buffer OpenSSL's PEM password callback reads into */
+const PEM_PASSPHRASE_MAX = 1024;
+
+/* object identifiers' contents, in hex */
+const OID_PBES2 = "2a864886f70d01050d";
+const OID_PBKDF2 = "2a864886f70d01050c";
+const PRFS = {
+  "2a864886f70d0207": "sha1", "2a864886f70d0208": "sha224", "2a864886f70d0209": "sha256", "2a864886f70d020a": "sha384",
+  "2a864886f70d020b": "sha512",
+};
+const OID_HMAC_SHA256 = "2a864886f70d0209";
+const CIPHERS = {
+  "608648016503040102": "aes-128-cbc", "608648016503040116": "aes-192-cbc", "60864801650304012a": "aes-256-cbc",
+  "2a864886f70d0307": "des-ede3-cbc", "2b0e030207": "des-cbc",
+};
+const CIPHER_OIDS = Object.fromEntries(Object.entries(CIPHERS).map(([oid, name]) => [name, oid]));
+
+export const missingPassphrase = () => codeError(TypeError, "ERR_MISSING_PASSPHRASE", "Passphrase required for encrypted key");
+/* OpenSSL 3's PEM reader without a passphrase: its password callback gives up */
+const pemCancelled = () => codeError(Error, "ERR_OSSL_CRYPTO_INTERRUPTED_OR_CANCELLED", "error:07880109:common libcrypto routines::interrupted or cancelled");
+const badDecrypt = () => codeError(Error, "ERR_OSSL_BAD_DECRYPT", "error:1C800064:Provider routines::bad decrypt");
+const decodeError = () => codeError(Error, "ERR_OSSL_ASN1_WRONG_TAG", "error:0680007B:asn1 encoding routines::wrong tag");
+
+/* ---- DER: just the shapes above ---------------------------------------------------------------- */
+
+function tlv(tag, body) {
+  const n = body.length;
+  const len = n < 0x80 ? [n] : n < 0x100 ? [0x81, n] : n < 0x10000 ? [0x82, n >> 8, n & 0xff] : [0x83, n >> 16, (n >> 8) & 0xff, n & 0xff];
+  return Buffer.concat([Buffer.from([tag, ...len]), body]);
+}
+const seq = (...items) => tlv(0x30, Buffer.concat(items));
+const oid = (hex) => tlv(0x06, Buffer.from(hex, "hex"));
+const octets = (bytes) => tlv(0x04, bytes);
+function integer(n) {
+  const bytes = [];
+  do {
+    bytes.unshift(n & 0xff);
+    n = Math.floor(n / 256);
+  } while (n > 0);
+  if (bytes[0] & 0x80) bytes.unshift(0);
+  return tlv(0x02, Buffer.from(bytes));
+}
+
+/** The elements of the TLV at `pos`: { tag, body, end }; a decode error past the input. */
+function read(der, pos) {
+  if (pos + 2 > der.length) throw decodeError();
+  const tag = der[pos];
+  let len = der[pos + 1];
+  let start = pos + 2;
+  if (len & 0x80) {
+    const n = len & 0x7f;
+    if (n === 0 || n > 3 || start + n > der.length) throw decodeError();
+    len = 0;
+    for (let i = 0; i < n; i++) len = len * 256 + der[start + i];
+    start += n;
+  }
+  if (start + len > der.length) throw decodeError();
+  return { tag, body: der.subarray(start, start + len), end: start + len };
+}
+
+function children(der) {
+  const out = [];
+  for (let pos = 0; pos < der.length;) {
+    const el = read(der, pos);
+    out.push(el);
+    pos = el.end;
+  }
+  return out;
+}
+
+function expect(el, tag) {
+  if (el === undefined || el.tag !== tag) throw decodeError();
+  return el.body;
+}
+
+/** Whether DER PKCS#8 is an EncryptedPrivateKeyInfo: its first element is an AlgorithmIdentifier
+ *  (a SEQUENCE), where a PrivateKeyInfo's is its version (an INTEGER). */
+export function isEncryptedPkcs8(der) {
+  try {
+    const [first] = children(expect(read(der, 0), 0x30));
+    return first !== undefined && first.tag === 0x30;
+  } catch {
+    return false;
+  }
+}
+
+/* ---- the primitives ---------------------------------------------------------------------------- */
+
+function cipherInfo(name) {
+  const info = cryptoCipherInfo(name);
+  if (info === null) throw codeError(Error, "ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher");
+  const [canonical, , , , ivLength, keyLength] = info;
+  return { name: canonical, ivLength, keyLength };
+}
+
+function runCipher(name, encrypt, key, iv, data) {
+  const handle = cryptoCipherNew(name, encrypt, key, iv, -1);
+  if (typeof handle === "number") throw notSupported(`The cipher ${name} for a private key`);
+  const head = cryptoCipherUpdate(handle, data);
+  const tail = cryptoCipherFinal(handle);
+  if (typeof head === "number" || typeof tail === "number") throw badDecrypt();
+  return Buffer.concat([head, tail]);
+}
+
+function pbkdf2(digest, passphrase, salt, iterations, keyLength) {
+  const key = cryptoPbkdf2(digest, passphrase, salt, iterations, keyLength);
+  if (!key) throw decodeError();
+  return key;
+}
+
+/* OpenSSL's EVP_BytesToKey with MD5 and one iteration: D(i) = MD5(D(i-1) ‖ passphrase ‖ salt) */
+function bytesToKey(passphrase, salt, keyLength) {
+  const parts = [];
+  let total = 0;
+  let prev = Buffer.alloc(0);
+  while (total < keyLength) {
+    const md5 = cryptoHashNew("md5", undefined);
+    cryptoDigestUpdate(md5, prev);
+    cryptoDigestUpdate(md5, passphrase);
+    cryptoDigestUpdate(md5, salt);
+    prev = cryptoDigestFinal(md5);
+    parts.push(prev);
+    total += prev.length;
+  }
+  return Buffer.concat(parts).subarray(0, keyLength);
+}
+
+function random(n) {
+  const b = Buffer.alloc(n);
+  cryptoRandomFill(b, 0, n);
+  return b;
+}
+
+/* ---- PKCS#8 ------------------------------------------------------------------------------------ */
+
+/** A PrivateKeyInfo in an EncryptedPrivateKeyInfo, as OpenSSL 3 writes one. */
+export function encryptPkcs8(der, cipherName, passphrase) {
+  const { name, ivLength, keyLength } = cipherInfo(cipherName);
+  const cipherOid = CIPHER_OIDS[name];
+  if (cipherOid === undefined) throw notSupported(`Encrypting a private key with ${cipherName}`);
+  const salt = random(SALT_LENGTH);
+  const iv = random(ivLength);
+  const key = pbkdf2("sha256", passphrase, salt, PBKDF2_ITERATIONS, keyLength);
+  const encrypted = runCipher(name, true, key, iv, der);
+  const kdf = seq(oid(OID_PBKDF2), seq(octets(salt), integer(PBKDF2_ITERATIONS), seq(oid(OID_HMAC_SHA256), Buffer.from([5, 0]))));
+  return seq(seq(oid(OID_PBES2), seq(kdf, seq(oid(cipherOid), octets(iv)))), octets(encrypted));
+}
+
+/** The PrivateKeyInfo an EncryptedPrivateKeyInfo holds (PBES2 with PBKDF2). */
+export function decryptPkcs8(der, passphrase) {
+  if (passphrase === undefined) throw missingPassphrase();
+  const [algorithm, data] = children(expect(read(der, 0), 0x30));
+  const [scheme, params] = children(expect(algorithm, 0x30));
+  if (expect(scheme, 0x06).toString("hex") !== OID_PBES2) throw notSupported("A private key encrypted without PBES2");
+  const [kdf, enc] = children(expect(params, 0x30));
+  const [kdfOid, kdfParams] = children(expect(kdf, 0x30));
+  if (expect(kdfOid, 0x06).toString("hex") !== OID_PBKDF2) throw notSupported("A private key encrypted without PBKDF2");
+  const [salt, iterations, ...rest] = children(expect(kdfParams, 0x30));
+  let digest = "sha1";  /* RFC 8018's default PRF */
+  for (const el of rest) {
+    if (el.tag !== 0x30) continue;  /* keyLength: the cipher's anyway */
+    const prf = PRFS[expect(children(el.body)[0], 0x06).toString("hex")];
+    if (prf === undefined) throw notSupported("This private key's PBKDF2 digest");
+    digest = prf;
+  }
+  const [cipherOid, iv] = children(expect(enc, 0x30));
+  const name = CIPHERS[expect(cipherOid, 0x06).toString("hex")];
+  if (name === undefined) throw notSupported("This private key's cipher");
+  const count = expect(iterations, 0x02).reduce((n, b) => n * 256 + b, 0);
+  const { keyLength } = cipherInfo(name);
+  const key = pbkdf2(digest, passphrase, expect(salt, 0x04), count, keyLength);
+  return runCipher(name, false, key, expect(iv, 0x04), expect(data, 0x04));
+}
+
+/* ---- PEM's own encryption (PKCS#1, SEC1) ------------------------------------------------------- */
+
+/** The headers and body of an encrypted PEM key, as OpenSSL's PEM_write_bio_PrivateKey writes them. */
+export function encryptPemBody(der, cipherName, passphrase) {
+  const { name, ivLength, keyLength } = cipherInfo(cipherName);
+  const iv = random(ivLength);
+  const key = bytesToKey(passphrase, iv.subarray(0, 8), keyLength);
+  const body = runCipher(name, true, key, iv, der);
+  return { headers: `Proc-Type: 4,ENCRYPTED\nDEK-Info: ${name.toUpperCase()},${iv.toString("hex").toUpperCase()}\n\n`, body };
+}
+
+/** The DER of an encrypted PEM key: its DEK-Info header names the cipher and the IV. */
+export function decryptPemBody(headers, body, passphrase) {
+  if (passphrase === undefined) throw pemCancelled();
+  if (passphrase.length > PEM_PASSPHRASE_MAX) throw codeError(Error, "ERR_OSSL_PEM_BAD_PASSWORD_READ", "error:0480006D:PEM routines::bad password read");
+  const dek = /^DEK-Info:\s*([A-Za-z0-9-]+),([0-9A-Fa-f]+)\s*$/m.exec(headers);
+  if (dek === null) throw codeError(Error, "ERR_OSSL_PEM_BAD_DECRYPT", "error:04800065:PEM routines::bad decrypt");
+  const { name, keyLength } = cipherInfo(dek[1].toLowerCase());
+  const iv = Buffer.from(dek[2], "hex");
+  const key = bytesToKey(passphrase, iv.subarray(0, 8), keyLength);
+  return runCipher(name, false, key, iv, body);
+}
+
+export function checkPemPassphrase(passphrase) {
+  if (passphrase === undefined) throw pemCancelled();
+  if (passphrase !== undefined && passphrase.length > PEM_PASSPHRASE_MAX) {
+    throw codeError(Error, "ERR_OSSL_PEM_BAD_PASSWORD_READ", "error:0480006D:PEM routines::bad password read");
+  }
+}

package/node/prelude/internal/crypto/keys.js

@@ -4,12 +4,13 @@
 // here; DER is the runtime's.
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
-  cryptoHashInfo, cryptoKeyEquals, cryptoRandomFill, cryptoKeyExport, cryptoKeyFromParts, cryptoKeyGenerate, cryptoKeyHandleOf, cryptoKeyInfo,
+  cryptoCipherInfo, cryptoEcPoint, cryptoHashInfo, cryptoKeyEquals, cryptoRandomFill, cryptoKeyExport, cryptoKeyFromParts, cryptoKeyGenerate, cryptoKeyHandleOf, cryptoKeyInfo,
   cryptoKeyParse, cryptoKeyParts, cryptoKeyPublic, cryptoKeySecret, cryptoKeySecretBytes, cryptoToCryptoKey,
 } from "visaljs:host";
 import { codeError, invalidArgType, invalidArgValue, notSupported, outOfRange, validateFunction, validateString } from "../errors.js";
 import { dhKeyParts, dhParameters } from "./diffiehellman.js";
 import { kKeyType } from "./key_type.js";
+import { checkPemPassphrase, decryptPemBody, decryptPkcs8, encryptPemBody, encryptPkcs8, isEncryptedPkcs8 } from "./key_encryption.js";
 import { isAnyArrayBuffer, isArrayBufferView, kHandle, validateNumber, validateObject } from "./util.js";
 
 const kAsymmetricKeyType = Symbol("kAsymmetricKeyType");
@@ -130,6 +131,8 @@ export class KeyObject {
   }
 }
 
+Object.defineProperty(KeyObject.prototype, Symbol.toStringTag, { configurable: true, value: "KeyObject" });
+
 class SecretKeyObject extends KeyObject {
   constructor(handle) {
     super("secret", handle);
@@ -201,6 +204,7 @@ class PublicKeyObject extends AsymmetricKeyObject {
 
   export(options) {
     if (options && options.format === "jwk") return exportJwk(this[kHandle], false);
+    if (options && options.format === "raw-public") return exportRawPublic(this[kHandle], options.type);
     const { format, type } = parseKeyEncoding(options, this.asymmetricKeyType, true);
     return exportKey(this[kHandle], format, type, false);
   }
@@ -212,13 +216,13 @@ class PrivateKeyObject extends AsymmetricKeyObject {
   }
 
   export(options) {
-    if (options && options.format === "jwk") {
-      if (options.passphrase !== undefined) throw incompatible("jwk", "does not support encryption");
-      return exportJwk(this[kHandle], true);
+    if (options?.passphrase !== undefined && options.format !== "pem" && options.format !== "der") {
+      throw incompatible(options.format, "does not support encryption");
     }
-    const { format, type, cipher } = parseKeyEncoding(options, this.asymmetricKeyType, false);
-    if (cipher != null) throw notSupported("Encrypting a private key");
-    return exportKey(this[kHandle], format, type, true);
+    if (options && options.format === "jwk") return exportJwk(this[kHandle], true);
+    if (options && (options.format === "raw-private" || options.format === "raw-seed")) return exportRawPrivate(this[kHandle], options.format);
+    const { format, type, cipher, passphrase } = parseKeyEncoding(options, this.asymmetricKeyType, false);
+    return exportKey(this[kHandle], format, type, true, cipher, passphrase);
   }
 }
 
@@ -268,31 +272,66 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
   const format = parseKeyFormat(enc.format, isInput ? "pem" : undefined, option("format", objName));
   const isRequired = (!isInput || format === "der") && format !== "jwk";
   const type = parseKeyType(enc.type, isRequired, keyType, isPublic, option("type", objName));
-  let cipher, passphrase;
+  let cipher, passphrase, encoding;
   if (isPublic !== true) {
-    ({ cipher, passphrase } = enc);
+    ({ cipher, passphrase, encoding } = enc);
     if (!isInput) {
       if (cipher != null) {
         if (typeof cipher !== "string") throw invalidArgValue(option("cipher", objName), "is invalid", cipher);
         if (format === "der" && (type === "pkcs1" || type === "sec1")) throw incompatible(type, "does not support encryption");
       } else if (passphrase !== undefined) {
-        throw invalidArgValue(option("cipher", objName), "is invalid", cipher);
+        throw invalidArgValue(option("cipher", objName), "is required when a passphrase is specified", cipher);
       }
     }
+    if ((isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) || (!isInput && cipher != null && !isStringOrBuffer(passphrase))) {
+      throw invalidArgValue(option("passphrase", objName), "is invalid", passphrase);
+    }
+    /* as Node's: an unknown cipher before any work (a key pair isn't generated for nothing) */
+    if (!isInput && cipher != null && cryptoCipherInfo(cipher) === null) throw codeError(Error, "ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher");
   }
+  if (passphrase !== undefined) passphrase = passphraseBytes(passphrase, encoding);
   return { format, type, cipher, passphrase };
 }
 
 const PEM_LABELS = { [SPKI]: "PUBLIC KEY", [PKCS8]: "PRIVATE KEY", [SEC1]: "EC PRIVATE KEY" };
 
-function exportKey(handle, format, type, isPrivate) {
+/* Node's IsRSAPrivateKey: an RSAPrivateKey begins with its version, a one-byte INTEGER 0 or 1, where
+ * an RSAPublicKey begins with its modulus */
+function isRsaPrivateDer(der) {
+  if (der.length < 2 || der[0] !== 0x30) return false;
+  const lengthBytes = der[1] & 0x80 ? der[1] & 0x7f : 0;
+  const i = 2 + lengthBytes;
+  return der[i] === 0x02 && der[i + 1] === 1 && (der[i + 2] === 0 || der[i + 2] === 1);
+}
+
+/* an ArrayBuffer's or a view's (a DataView too) bytes, not copied */
+const viewBytes = (v) => (isAnyArrayBuffer(v) ? Buffer.from(v) : Buffer.from(v.buffer, v.byteOffset, v.byteLength));
+
+/* Node's getArrayBufferOrView: a passphrase's bytes (a string in `encoding`, else UTF-8) */
+function passphraseBytes(passphrase, encoding) {
+  if (typeof passphrase === "string") return Buffer.from(passphrase, Buffer.isEncoding(encoding) ? encoding : "utf8");
+  return viewBytes(passphrase);
+}
+
+const pem = (label, headers, der) => {
+  const body = der.toString("base64").replace(/(.{64})/g, "$1\n").replace(/\n$/, "");
+  return `-----BEGIN ${label}-----\n${headers}${body}\n-----END ${label}-----\n`;
+};
+
+function exportKey(handle, format, type, isPrivate, cipher, passphrase) {
   const encoding = ENCODING_NAMES[type];
-  const der = cryptoKeyExport(handle, encoding);
+  let der = cryptoKeyExport(handle, encoding);
   if (typeof der === "number") throw keyError(der);
+  const encrypt = cipher != null;
+  if (encrypt && encoding === PKCS8) {
+    der = encryptPkcs8(der, cipher, passphrase);
+    return format === "der" ? der : pem("ENCRYPTED PRIVATE KEY", "", der);
+  }
   if (format === "der") return der;
   const label = encoding === PKCS1 ? (isPrivate ? "RSA PRIVATE KEY" : "RSA PUBLIC KEY") : PEM_LABELS[encoding];
-  const body = der.toString("base64").replace(/(.{64})/g, "$1\n").replace(/\n$/, "");
-  return `-----BEGIN ${label}-----\n${body}\n-----END ${label}-----\n`;
+  if (!encrypt) return pem(label, "", der);
+  const { headers, body } = encryptPemBody(der, cipher, passphrase);
+  return pem(label, headers, body);
 }
 
 /* A PEM's label → the encoding it holds, and whether it is private */
@@ -307,25 +346,101 @@ const PEM_TYPES = {
 
 /** A key handle from PEM or DER: the private key when `wantPrivate`, else a public one (a
  *  private key's public part, as createPublicKey takes it). */
-function parseKey(data, format, type, wantPrivate) {
+function parseKey(data, format, type, wantPrivate, passphrase) {
   if (format === "der") {
     const encoding = ENCODING_NAMES[type];
-    const isPrivate = encoding === PKCS8 || encoding === SEC1 || (encoding === PKCS1 && wantPrivate);
+    const isPrivate = encoding === PKCS8 || encoding === SEC1 || (encoding === PKCS1 && (wantPrivate || isRsaPrivateDer(viewBytes(data))));
+    if (encoding === PKCS8) {
+      const bytes = viewBytes(data);
+      if (isEncryptedPkcs8(bytes)) data = decryptPkcs8(bytes, passphrase);
+    }
     const handle = cryptoKeyParse(data, encoding, isPrivate);
     if (typeof handle === "number") throw keyError(handle);
     return wantPrivate || !isPrivate ? handle : cryptoKeyPublic(handle);
   }
-  const text = typeof data === "string" ? data : Buffer.from(isAnyArrayBuffer(data) ? new Uint8Array(data) : data).toString("latin1");
-  const m = /-----BEGIN ([A-Z0-9 ]+)-----\r?\n([\s\S]*?)-----END \1-----/.exec(text);
+  const text = typeof data === "string" ? data : viewBytes(data).toString("latin1");
+  /* the first block that holds a key, as OpenSSL's PEM reader: an EC PARAMETERS block may come before it */
+  const m = [...text.matchAll(/-----BEGIN ([A-Z0-9 ]+)-----\r?\n([\s\S]*?)-----END \1-----/g)]
+    .find((b) => b[1] === "ENCRYPTED PRIVATE KEY" || Object.hasOwn(PEM_TYPES, b[1])) ?? null;
   if (m === null) throw keyError(1);
-  if (m[1] === "ENCRYPTED PRIVATE KEY" || m[2].includes(":")) throw notSupported("An encrypted private key");
-  const known = PEM_TYPES[m[1]];
+  let label = m[1], body = m[2], der;
+  if (label === "ENCRYPTED PRIVATE KEY") {
+    checkPemPassphrase(passphrase);
+    der = decryptPkcs8(Buffer.from(body, "base64"), passphrase);
+    label = "PRIVATE KEY";
+  } else if (/^Proc-Type:\s*4,ENCRYPTED/m.test(body)) {
+    const split = body.search(/\r?\n\r?\n/);
+    der = decryptPemBody(body.slice(0, split), Buffer.from(body.slice(split), "base64"), passphrase);
+  } else {
+    der = Buffer.from(body, "base64");
+  }
+  const known = PEM_TYPES[label];
   if (known === undefined || (wantPrivate && !known[1])) throw keyError(1);
-  const handle = cryptoKeyParse(Buffer.from(m[2], "base64"), known[0], known[1]);
+  const handle = cryptoKeyParse(der, known[0], known[1]);
   if (typeof handle === "number") throw keyError(handle);
   return known[1] && !wantPrivate ? cryptoKeyPublic(handle) : handle;
 }
 
+/* ---- raw keys (Node 24): the public point or key, the private scalar or key -------------------- */
+
+/* the curves raw keys name (Node takes the JWK names too): [OpenSSL's name, JWK's, scalar bytes] */
+const P256 = ["prime256v1", "P-256", 32], P384 = ["secp384r1", "P-384", 48], P521 = ["secp521r1", "P-521", 66];
+const RAW_CURVES = {
+  "P-256": P256, prime256v1: P256, "P-384": P384, secp384r1: P384, "P-521": P521, secp521r1: P521, secp256k1: ["secp256k1", "secp256k1", 32],
+};
+const RAW_KINDS = new Set(["ec", "ed25519", "x25519"]);
+const rawUnsupported = (format) => incompatible(format, "is not supported for this key type");
+
+function exportRawPublic(handle, type = "uncompressed") {
+  const [, kind, namedCurve] = cryptoKeyInfo(handle);
+  if (!RAW_KINDS.has(kind)) throw rawUnsupported("raw-public");
+  const point = cryptoKeyParts(handle)[0];
+  if (kind !== "ec") return point;
+  if (type !== "compressed" && type !== "uncompressed") throw invalidArgValue("options.type", "must be one of: 'compressed', 'uncompressed'", type);
+  return type === "uncompressed" ? point : cryptoEcPoint(namedCurve, point, 2);
+}
+
+function exportRawPrivate(handle, format) {
+  const [, kind] = cryptoKeyInfo(handle);
+  if (format === "raw-seed" || !RAW_KINDS.has(kind)) throw rawUnsupported(format);
+  return cryptoKeyParts(handle)[1];
+}
+
+/** A key handle from raw bytes: { key, format, asymmetricKeyType, namedCurve }. */
+function rawKeyHandle(key, format, wantPrivate) {
+  const { key: data, asymmetricKeyType: kind } = key;
+  if (wantPrivate && format === "raw-public") throw invalidArgValue("key.format", "is invalid", format);
+  if (!isArrayBufferView(data) && !isAnyArrayBuffer(data)) {
+    throw invalidArgType("key.key", "an instance of ArrayBuffer, Buffer, TypedArray, or DataView", data);
+  }
+  validateString(kind, "key.asymmetricKeyType");
+  if (kind === "ec") validateString(key.namedCurve, "key.namedCurve");
+  if (kind === "rsa" || kind === "rsa-pss" || kind === "dsa" || kind === "dh") throw rawUnsupported(format);
+  if (!RAW_KINDS.has(kind)) throw invalidArgValue("key.asymmetricKeyType", "is invalid: Invalid asymmetricKeyType", kind);
+  if (format === "raw-seed") throw rawUnsupported(format);
+  const bytes = viewBytes(data);
+  const isPrivate = format === "raw-private";
+  let handle;
+  if (kind === "ec") {
+    const curve = RAW_CURVES[key.namedCurve];
+    if (curve === undefined) throw codeError(TypeError, "ERR_CRYPTO_INVALID_CURVE", "Invalid EC curve name");
+    const [name, jwk, size] = curve;
+    let point;
+    if (isPrivate) {
+      if (bytes.length !== size) throw invalidArgValue("key.key", "is invalid", data);
+    } else {
+      point = cryptoEcPoint(name, bytes, 4);
+      if (typeof point === "number") throw invalidArgValue("key.key", "is invalid", data);
+    }
+    handle = cryptoKeyFromParts("ec", isPrivate, jwk, isPrivate ? [undefined, bytes] : [point]);
+  } else {
+    if (bytes.length !== 32) throw invalidArgValue("key.key", "is invalid", data);
+    handle = cryptoKeyFromParts(kind, isPrivate, undefined, isPrivate ? [undefined, bytes] : [bytes]);
+  }
+  if (typeof handle === "number") throw invalidArgValue("key.key", "is invalid", data);
+  return isPrivate && !wantPrivate ? cryptoKeyPublic(handle) : handle;
+}
+
 /* ---- JWK --------------------------------------------------------------------------------------- */
 
 const b64u = (buf) => buf.toString("base64url");
@@ -445,12 +560,13 @@ function prepareAsymmetricKey(key, ctx) {
       validateObject(data, "key.key");
       return { key: keyFromJwk(data, !wantPrivate) };
     }
+    if (format === "raw-public" || format === "raw-private" || format === "raw-seed") return { key: rawKeyHandle(key, format, wantPrivate) };
     if (!isStringOrBuffer(data)) {
       throw invalidArgType("key.key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", data);
     }
-    const { format: fmt, type } = parseKeyEncoding(key, undefined, wantPrivate ? false : undefined, "key");
+    const { format: fmt, type, passphrase } = parseKeyEncoding(key, undefined, wantPrivate ? false : undefined, "key");
     const bytes = typeof data === "string" && fmt === "der" ? Buffer.from(data, encoding ?? "utf8") : data;
-    return { key: parseKey(bytes, fmt, type, wantPrivate) };
+    return { key: parseKey(bytes, fmt, type, wantPrivate, passphrase) };
   }
   /* Node 24 lists URL where a private key is wanted (an OpenSSL store's; not visaljs's yet) */
   const expected = ctx === CREATE_PRIVATE
@@ -526,17 +642,34 @@ export function generateKey(type, options, callback) {
   later(() => callback(null, key));
 }
 
+/* Node's parseKeyFormatAndType for the raw formats of a key pair's encodings */
+function rawEncoding(enc, isPublic) {
+  const { format, type } = enc;
+  const name = isPublic ? "options.publicKeyEncoding" : "options.privateKeyEncoding";
+  if (format === "raw-public") {
+    if (!isPublic) throw invalidArgValue(`${name}.format`, "is invalid", format);
+    if (type !== undefined && type !== "uncompressed" && type !== "compressed") throw invalidArgValue(`${name}.type`, "is invalid", type);
+    return { format, type };
+  }
+  if (format === "raw-private" || format === "raw-seed") {
+    if (isPublic) throw invalidArgValue(`${name}.format`, "is invalid", format);
+    if (type !== undefined) throw invalidArgValue(`${name}.type`, "is invalid", type);
+    if (enc.cipher != null || enc.passphrase !== undefined) throw incompatible("raw format", "does not support encryption");
+    return { format };
+  }
+  return undefined;
+}
+
 function pairEncodings(keyType, options) {
   const { publicKeyEncoding, privateKeyEncoding } = options ?? {};
   let pub, priv;
   if (publicKeyEncoding != null) {
     if (typeof publicKeyEncoding !== "object") throw invalidArgValue("options.publicKeyEncoding", "is invalid", publicKeyEncoding);
-    pub = publicKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(publicKeyEncoding, keyType, true, "options.publicKeyEncoding");
+    pub = publicKeyEncoding.format === "jwk" ? { format: "jwk" } : rawEncoding(publicKeyEncoding, true) ?? parseKeyEncoding(publicKeyEncoding, keyType, true, "options.publicKeyEncoding");
   }
   if (privateKeyEncoding != null) {
     if (typeof privateKeyEncoding !== "object") throw invalidArgValue("options.privateKeyEncoding", "is invalid", privateKeyEncoding);
-    priv = privateKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(privateKeyEncoding, keyType, false, "options.privateKeyEncoding");
-    if (priv.cipher != null) throw notSupported("Encrypting a private key");
+    priv = privateKeyEncoding.format === "jwk" ? { format: "jwk" } : rawEncoding(privateKeyEncoding, false) ?? parseKeyEncoding(privateKeyEncoding, keyType, false, "options.privateKeyEncoding");
   }
   return { pub, priv };
 }
@@ -644,3 +777,5 @@ export function generateKeyPair(type, options, callback) {
   }
   later(() => callback(null, result.publicKey, result.privateKey));
 }
+/* as Node's: util.promisify(generateKeyPair) resolves to { publicKey, privateKey } */
+Object.defineProperty(generateKeyPair, Symbol.for("visaljs.util.customPromisifyArgs"), { value: ["publicKey", "privateKey"] });

package/node/prelude/internal/crypto/random.js

@@ -111,6 +111,30 @@ export function randomInt(min, max, callback) {
   }
 }
 
+let hexBytes = null;
+
+/* Node's getUnbufferedUUIDv7: 48 bits of Date.now(), then version 7, the variant and random bits */
+export function randomUUIDv7(options) {
+  if (options !== undefined) validateObject(options, "options");
+  const { disableEntropyCache = false } = options || {};
+  validateBoolean(disableEntropyCache, "options.disableEntropyCache");
+  const b = randomFillSync(new Uint8Array(16), 6);
+  const now = Date.now();
+  const msb = now / 2 ** 32;
+  b[0] = msb >>> 8;
+  b[1] = msb;
+  b[2] = now >>> 24;
+  b[3] = now >>> 16;
+  b[4] = now >>> 8;
+  b[5] = now;
+  b[6] = (b[6] & 0x0f) | 0x70;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  hexBytes ??= Array.from({ length: 256 }, (_, i) => (i < 16 ? "0" : "") + i.toString(16));
+  let out = "";
+  for (let i = 0; i < 16; i++) out += (i === 4 || i === 6 || i === 8 || i === 10 ? "-" : "") + hexBytes[b[i]];
+  return out;
+}
+
 export function randomUUID(options) {
   if (options !== undefined) validateObject(options, "options");
   const { disableEntropyCache = false } = options || {};

package/node/prelude/internal/crypto/util.js

@@ -36,8 +36,9 @@ export function validateEncoding(data, enc) {
   }
 }
 
+/** Node's validateObject: an object, not null nor an array. */
 export function validateObject(value, name) {
-  if (value === null || typeof value !== "object") throw invalidArgType(name, "of type object", value);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw invalidArgType(name, "of type object", value);
 }
 
 export function validateBoolean(value, name) {