node-forge

Os fatos e as verificações por trás deles

Nada abaixo foi copiado da documentação. A verificação content/libraries/verify/node-forge/run.sh executou node-forge 1.4.0 em Node.js 24.22.0 na imagem de contêiner node:24.22.0-bookworm-slim em 20 de outubro de 2026; a página precisa corresponder ao que a verificação imprimiu, e cada fato lista essas linhas.

• Curvas ECDSA

  none

  Sem implementação de ECDSA: forge.pki tem rsa e ed25519 e nada para as curvas do NIST nem para secp256k1.

  Registrado pela verificação

  fact ecdsa-curves = none
  evidence ecdsa-curves: forge.pki members: ed25519, rsa

• Certificados com chaves EC

  rejected

  certificateFromPem() em um certificado P-256 lança Cannot read public key. OID is not RSA.; com uma chave pública EC, a exceção é Cannot read public key. Unknown OID.

  Registrado pela verificação

  fact ec-certificate = rejected
  evidence ec-certificate: Cannot read public key. OID is not RSA.
  evidence ec-certificate: the same certificate parses at the ASN.1 level: true
  evidence ec-certificate: publicKeyFromPem on an EC SPKI: Cannot read public key. Unknown OID.

• EdDSA

  Ed25519

  Ed25519 por meio de forge.pki.ed25519.

  Registrado pela verificação

  fact eddsa = Ed25519

• Ed25519 conforme a RFC 8032

  yes

  Para a mesma semente de 32 bytes, o forge produziu exatamente a mesma assinatura que o node:crypto, como exige o esquema determinístico da RFC 8032.

  Registrado pela verificação

  fact ed25519-matches-rfc8032 = yes
  evidence ed25519-matches-rfc8032: forge and node:crypto signatures for the same seed are identical: true

• Estrutura da chave privada Ed25519

  expanded-64

  As chaves privadas Ed25519 têm 64 bytes: a semente seguida da chave pública.

  Registrado pela verificação

  fact ed25519-private-key = expanded-64

• Assinatura Ed25519 com S não canônico

  rejected

  Uma assinatura Ed25519 cujo S foi substituído por S + L — a forma maleável que a RFC 8032 proíbe — foi rejeitada, assim como no node:crypto; a 1.4.0 acrescentou essa verificação (CVE-2026-33895).

  Registrado pela verificação

  fact ed25519-non-canonical-s = rejected
  evidence ed25519-non-canonical-s: forge: false; node:crypto: false

• Algoritmos pós-quânticos

  none

  Nenhum algoritmo pós-quântico.

  Registrado pela verificação

  fact pqc = none

• Esquemas de assinatura RSA

  PKCS1-v1_5PSS

  Assinaturas PKCS#1 v1.5 e PSS feitas com SHA-256 foram verificadas no node:crypto; o PSS exige tamanho de salt e digest do MGF1 explícitos.

  Registrado pela verificação

  fact rsa-signature-schemes = PKCS1-v1_5, PSS

• Elemento extra em um DigestInfo do PKCS #1

  accepted-in-algorithm-identifier

  Um bloco PKCS#1 v1.5 com um elemento extra dentro do AlgorithmIdentifier do DigestInfo foi verificado no forge, mas não no node:crypto; um elemento extra depois do digest foi rejeitado. Esse é o alerta de segurança em aberto GHSA-86w9-cpqp-85rv.

  Registrado pela verificação

  fact pkcs1-digestinfo-extra-element = accepted-in-algorithm-identifier
  evidence pkcs1-digestinfo-extra-element: well-formed block: forge true, node:crypto true
  evidence pkcs1-digestinfo-extra-element: extra element inside AlgorithmIdentifier: forge true, node:crypto false
  evidence pkcs1-digestinfo-extra-element: extra element after the digest: forge throws ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value., node:crypto false

• Formatos de chave pública RSA

  spki-pempkcs1x509

  Chaves públicas RSA foram carregadas de SPKI em PEM, PKCS#1 RSA PUBLIC KEY em PEM e certificados.

  Registrado pela verificação

  fact rsa-public-key-formats = spki-pem, pkcs1, x509

• Formatos de chave privada RSA

  pkcs8-pemencrypted-pkcs8pkcs1pkcs12

  Chaves privadas RSA foram carregadas de PKCS#8 em PEM, PKCS#8 criptografado (decryptRsaPrivateKey), PKCS#1 RSA PRIVATE KEY em PEM e PKCS#12.

  Registrado pela verificação

  fact rsa-private-key-formats = pkcs8-pem, encrypted-pkcs8, pkcs1, pkcs12

Uso

import { constants, generateKeyPairSync, verify } from "node:crypto";
import forge from "node-forge";

const message = "order #1042 approved";
const { privateKey, publicKey } = generateKeyPairSync("rsa", { modulusLength: 2048 });
const key = forge.pki.privateKeyFromPem(privateKey.export({ type: "pkcs8", format: "pem" }));

// RSA-PSS: SHA-256 for the digest and for MGF1, 32-byte salt. The verifier
// must use the same three parameters.
const sha256 = () => forge.md.sha256.create();
const pss = forge.pss.create({ md: sha256(), mgf: forge.mgf.mgf1.create(sha256()), saltLength: 32 });
const signature = Buffer.from(key.sign(sha256().update(message, "utf8"), pss), "binary");
const options = { key: publicKey, padding: constants.RSA_PKCS1_PSS_PADDING, saltLength: 32 };
console.log("PSS verified by node:crypto:", verify("sha256", Buffer.from(message), options, signature));

// forge has no elliptic-curve support: EC keys and certificates throw.
const ec = generateKeyPairSync("ec", { namedCurve: "P-256" }).publicKey.export({ type: "spki", format: "pem" });
try {
  forge.pki.publicKeyFromPem(ec);
} catch (error) {
  console.log("EC key:", error.message);
}