Come generare un CSR in Node.js

Questo tutorial ti mostra come generare un CSR per un’applicazione Node.js. Node.js non dispone di uno strumento integrato per la generazione del CSR, quindi devi creare la chiave privata e la Certificate Signing Request con OpenSSL sulla macchina che eseguirà Node, inviare il CSR alla tua Certificate Authority e poi caricare il certificato emesso nella tua app con fs.readFileSync() e https.createServer().

I passaggi indicati di seguito funzionano su qualsiasi sistema operativo che include OpenSSL, il che copre tutte le distribuzioni Linux attuali, macOS e Windows (tramite i binari ufficiali di OpenSSL o Git Bash). Le versioni moderne di OpenSSL firmano le richieste con SHA-256 per impostazione predefinita, quindi non è necessario aggiungere un flag per il digest.

Passaggio 1: Assicurati che OpenSSL sia installato

Verifica che OpenSSL sia disponibile sulla macchina che eseguirà la tua app Node.js:

openssl version

Dovresti vedere una riga simile a OpenSSL 3.0.x o versione successiva. Se il comando non viene trovato, installalo per la tua piattaforma:

• Debian, Ubuntu: sudo apt update && sudo apt install openssl
• RHEL, AlmaLinux, Rocky Linux, Amazon Linux: sudo dnf install openssl (oppure sudo yum install openssl nelle versioni più vecchie)
• macOS: OpenSSL (LibreSSL in alcune versioni, OpenSSL 3 se installato tramite Homebrew) è già presente nel Terminale. Per installare la build ufficiale: brew install openssl@3.
• Windows: installa i binari ufficiali di OpenSSL, oppure usa Git Bash, che include OpenSSL preinstallato.

Passaggio 2: Genera la chiave privata e il CSR

Genera la chiave e il CSR sulla macchina che eseguirà Node.js. La chiave privata viene creata insieme al CSR e deve rimanere su quella macchina. Eseguire questi comandi altrove e poi copiare la chiave in giro vanifica lo scopo di avere una chiave privata.

Esegui il seguente comando. Crea una chiave privata RSA a 2048 bit e un CSR corrispondente in un solo passaggio, con il soggetto e i Subject Alternative Names (SAN) forniti in linea, in modo che OpenSSL non si fermi a fare domande:

openssl req -new -newkey rsa:2048 -nodes 
-keyout yourdomain.key 
-out yourdomain.csr 
-subj "/C=US/ST=YourState/L=YourCity/O=YourCompany/CN=yourdomain.com" 
-addext "subjectAltName=DNS:yourdomain.com,DNS:www.yourdomain.com"

Cosa fa ogni parte:

• -newkey rsa:2048 genera una nuova chiave RSA a 2048 bit. 2048 bit è il minimo attualmente accettato dalle CA pubbliche; puoi usare rsa:4096 per una chiave più grande, oppure passare a ECDSA (vedi sotto).
• -nodes lascia la chiave privata non cifrata, in modo che Node.js possa leggerla all’avvio senza richiedere una passphrase. Il modulo https di Node supporta effettivamente un’opzione passphrase per una chiave cifrata, ma la passphrase deve comunque provenire da qualche parte sulla macchina (un file di configurazione, una variabile d’ambiente o un secret manager).
• -keyout e -out assegnano il nome ai file della chiave privata e del CSR.
• -subj fornisce il soggetto del certificato. Inserisci qui il nome reale della tua azienda, lo stato e la città, non i segnaposto. CN (Common Name) è il tuo dominio principale.
• -addext “subjectAltName=…” elenca ogni nome host che il certificato deve coprire. Le CA pubbliche effettuano la validazione in base all’elenco SAN, quindi includi qui anche il Common Name. Il flag -addext richiede OpenSSL 1.1.1 o versione successiva, disponibile in ogni sistema operativo attuale.

Sostituisci yourdomain.com con il tuo dominio effettivo ovunque. Per coprire ulteriori nomi host, aggiungili all’elenco SAN separati da virgole, ad esempio DNS:api.yourdomain.com. Per un wildcard, includi sia il wildcard che il dominio semplice: DNS:*.yourdomain.com,DNS:yourdomain.com.

Se preferisci una chiave ECDSA (più piccola e veloce, con P-256 ampiamente supportato), genera la chiave e il CSR in questo modo:

openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -pkeyopt ec_param_enc:named_curve -nodes 
-keyout yourdomain.key 
-out yourdomain.csr 
-subj "/C=US/ST=YourState/L=YourCity/O=YourCompany/CN=yourdomain.com" 
-addext "subjectAltName=DNS:yourdomain.com,DNS:www.yourdomain.com"

Modalità interattiva (senza -subj)

Se preferisci che OpenSSL ti chieda ogni campo, rimuovi il flag -subj:

openssl req -new -newkey rsa:2048 -nodes 
-keyout yourdomain.key -out yourdomain.csr 
-addext "subjectAltName=DNS:yourdomain.com,DNS:www.yourdomain.com"

OpenSSL richiederà i seguenti dettagli:

• Country Name (C): il codice ISO a due lettere del paese della tua organizzazione (ad esempio, US).
• State or Province Name (S): il nome completo dello stato o della provincia dove è registrata la tua azienda (ad esempio, California). Non abbreviare.
• Locality Name (L): la città dove è registrata la tua attività (ad esempio, San Jose).
• Organization Name (O): il nome legale della tua azienda (ad esempio, GPI Holding LLC). Per un certificato DV (Domain Validated), lascia vuoto e premi Invio.
• Organizational Unit Name (OU): deprecato da settembre 2022 e ignorato dalle CA pubbliche. Lascia vuoto.
• Common Name (CN): il nome di dominio completamente qualificato (FQDN) che stai proteggendo, ad esempio yourdomain.com. Per un wildcard, usa *.yourdomain.com.
• Email Address: opzionale. Lascia vuoto.
• A challenge password: obsoleto. Lascia vuoto.

Passaggio 3: Individua e proteggi i tuoi file

Elenca la directory corrente per confermare che entrambi i file siano stati creati:

ls

Dovresti vedere due nuovi file:

• yourdomain.key: la tua chiave privata. Mantienila sul server, eseguine un backup sicuro e non inviarla a nessuno, inclusa la Certificate Authority. Chiunque possieda la chiave può impersonare il tuo sito.
• yourdomain.csr: la tua Certificate Signing Request. Questo è il file che invii al provider SSL.

Su Linux o macOS, imposta immediatamente permessi restrittivi sulla chiave privata, in modo che solo l’utente che esegue Node.js possa leggerla:

chmod 600 yourdomain.key

Se Node.js viene eseguito con un account di servizio dedicato (ad esempio, node o www-data), imposta anche il proprietario in modo che il processo possa leggere la chiave:

sudo chown node:node yourdomain.key

Passaggio 4: Verifica il CSR (opzionale ma consigliato)

Prima di inviarlo, verifica che il CSR contenga il soggetto e i SAN corretti e che la sua firma sia valida. Questo comando decodifica la richiesta localmente con OpenSSL:

openssl req -noout -text -verify -in yourdomain.csr

Verifica che la riga Subject mostri i tuoi dati, che X509v3 Subject Alternative Name elenchi ogni nome host previsto e che il controllo della firma stampi verify OK. L’algoritmo di firma dovrebbe essere sha256WithRSAEncryption (o ecdsa-with-SHA256 per una chiave ECDSA). Se preferisci non usare la riga di comando, incolla il CSR nel nostro decodificatore CSR online per leggere gli stessi campi in un browser.

Passaggio 5: Invia il tuo CSR

Per copiare il CSR per il tuo ordine, stampa il suo contenuto:

cat yourdomain.csr

Vedrai un blocco di testo simile a questo:

-----BEGIN CERTIFICATE REQUEST-----
MIIBozCB... (a long string of characters)
-----END CERTIFICATE REQUEST-----

Copia l’intero blocco, incluse le righe —–BEGIN CERTIFICATE REQUEST—– e —–END CERTIFICATE REQUEST—– (ogni marcatore ha cinque trattini su entrambi i lati). Quell’intero blocco è il tuo CSR. Incollalo nel modulo d’ordine durante l’acquisto, e mantieni la chiave privata corrispondente al suo posto sul server.

Se preferisci non usare la riga di comando, puoi anche creare la richiesta con il nostro CSR Generator online. Nota che genera la chiave privata nel tuo browser, quindi salva quella chiave da solo e trasferiscila sul server Node.js.

Cosa succede dopo che la CA emette il certificato

Una volta che la CA valida il CSR ed emette il certificato, riceverai in genere il tuo certificato server (un file .crt con il nome del tuo dominio) più uno o più certificati intermedi, a volte raggruppati in un file .ca-bundle. Node.js carica questi elementi in JavaScript: concatena il certificato server e gli intermedi in un unico file fullchain.crt, quindi leggilo con fs.readFileSync() e passalo a https.createServer():

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('/path/to/yourdomain.key'),
  cert: fs.readFileSync('/path/to/fullchain.crt'),
  minVersion: 'TLSv1.2'
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('Welcome to a Node.js HTTPS servern');
}).listen(443);

Questo schema fullchain è quello utilizzato dalla maggior parte delle configurazioni di produzione. La procedura completa (che include un esempio con moduli ES, un approccio alternativo con l’array ca: e un esempio Express) è illustrata nel nostro tutorial per l’installazione SSL su Node.js.

Una nota sui deployment in produzione. Nel 2026 la maggior parte delle app Node.js che gestiscono traffico pubblico funziona dietro un reverse proxy o un load balancer cloud (NGINX, HAProxy, Caddy, AWS ALB, Cloudflare, Fastly) che termina il TLS ai margini della rete e trasmette HTTP semplice o HTTP/2 a Node su una porta locale alta. In questo schema, il certificato (e il CSR che hai generato sopra) risiede sul proxy o sul load balancer, non sul processo Node stesso. Lasciare che Node.js termini il TLS direttamente è perfettamente adatto per lo sviluppo, i servizi interni e i deployment di piccole dimensioni; per un’app di produzione pubblica, terminare il TLS ai margini della rete è la configurazione più comune.