Comment puis-je utiliser un certificat auto-signé pour un HTTPS Node.js le serveur?

J'ai commencé à écrire un wrapper pour une API qui exige que toutes les demandes soient sur HTTPS. Au lieu de faire des requêtes à l'API réel alors que je suis en train d'élaborer et de le tester, je voudrais que mon propre serveur localement qui se moque de l'réponses.

Je suis confus sur la façon de générer les certificats-je besoin de créer un serveur HTTPS et d'envoyer des demandes.

Mon serveur ressemble à quelque chose comme ceci:

var options = {
  key: fs.readFileSync('./key.pem'),
  cert: fs.readFileSync('./cert.pem')
};

https.createServer(options, function(req, res) {
  res.writeHead(200);
  res.end('OK\n');
}).listen(8000);

Le pem fichiers ont été générés avec:

openssl genrsa 1024 > key.pem
openssl req -x509 -new -key key.pem > cert.pem

Et une demande ressemble à quelque chose comme ceci:

var options = {
  host: 'localhost',
  port: 8000,
  path: '/api/v1/test'
};

https.request(options, function(res) {
  res.pipe(process.stdout);
}).end();

Avec cette configuration, j'obtiens Error: DEPTH_ZERO_SELF_SIGNED_CERT, donc je pense que j'ai besoin d'ajouter un ca option pour la demande.

Donc ma question est comment dois-je générer les suivantes:

  1. Le serveur key?
  2. Le serveur cert?
  3. La ca de la demande?

J'ai lu quelques choses à propos de générer les certificats auto-signés avec openssl, mais ne semble pas possible d'envelopper ma tête autour de lui et de déterminer qui des clés et des certificats à utiliser où dans mon nœud de code.

Mise à jour

L'API fournit un certificat d'autorité de certification à utiliser à la place des valeurs par défaut. Le code suivant fonctionne à l'aide de leur certificat et c'est ce que je veux reproduire localement.

var ca = fs.readFileSync('./certificate.pem');

var options = {
  host: 'example.com',
  path: '/api/v1/test',
  ca: ca
};
options.agent = new https.Agent(options);

https.request(options, function(res) {
  res.pipe(process.stdout);
}).end();
InformationsquelleAutor Brett | 2013-10-29
  1. 59

    Mise à jour (Novembre 2018): avez-vous besoin auto-signé certs?

    Ou seraient de véritables certificats d'obtenir le travail fait mieux? Avez-vous pensé à l'un de ces?

    (Note: Let's Encrypt peut également délivrer des certificats à des réseaux privés)

    ScreenCast

    https://coolaj86.com/articles/how-to-create-a-csr-for-https-tls-ssl-rsa-pems/

    Complet, exemple de Travail

    • crée des certificats
    • pistes node.js serveur
    • pas d'avertissements ou d'erreurs dans les node.js client
    • pas d'avertissements ou d'erreurs dans cURL

    https://github.com/coolaj86/nodejs-self-signed-certificate-example

    À l'aide de localhost.greenlock.domains comme un exemple (il pointe vers 127.0.0.1):

    server.js

    'use strict';

var https = require('https')
  , port = process.argv[2] || 8043
  , fs = require('fs')
  , path = require('path')
  , server
  , options
  ;

require('ssl-root-cas')
  .inject()
  .addFile(path.join(__dirname, 'server', 'my-private-root-ca.cert.pem'))
  ;

options = {
  //this is ONLY the PRIVATE KEY
  key: fs.readFileSync(path.join(__dirname, 'server', 'privkey.pem'))
  //You DO NOT specify `ca`, that's only for peer authentication
//, ca: [ fs.readFileSync(path.join(__dirname, 'server', 'my-private-root-ca.cert.pem'))]
  //This should contain both cert.pem AND chain.pem (in that order) 
, cert: fs.readFileSync(path.join(__dirname, 'server', 'fullchain.pem'))
};


function app(req, res) {
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, encrypted world!');
}

server = https.createServer(options, app).listen(port, function () {
  port = server.address().port;
  console.log('Listening on https://127.0.0.1:' + port);
  console.log('Listening on https://' + server.address().address + ':' + port);
  console.log('Listening on https://localhost.greenlock.domains:' + port);
});

    client.js

    'use strict';

var https = require('https')
  , fs = require('fs')
  , path = require('path')
  , ca = fs.readFileSync(path.join(__dirname, 'client', 'my-private-root-ca.cert.pem'))
  , port = process.argv[2] || 8043
  , hostname = process.argv[3] || 'localhost.greenlock.domains'
  ;

var options = {
  host: hostname
, port: port
, path: '/'
, ca: ca
};
options.agent = new https.Agent(options);

https.request(options, function(res) {
  res.pipe(process.stdout);
}).end();

    Et le script qui fait que les fichiers de certificat:

    make-certs.sh

    #!/bin/bash
FQDN=$1
# make directories to work from
mkdir -p server/ client/ all/
# Create your very own Root Certificate Authority
openssl genrsa \
-out all/my-private-root-ca.privkey.pem \
2048
# Self-sign your Root Certificate Authority
# Since this is private, the details can be as bogus as you like
openssl req \
-x509 \
-new \
-nodes \
-key all/my-private-root-ca.privkey.pem \
-days 1024 \
-out all/my-private-root-ca.cert.pem \
-subj "/C=US/ST=Utah/L=Provo/O=ACME Signing Authority Inc/CN=example.com"
# Create a Device Certificate for each domain,
# such as example.com, *.example.com, awesome.example.com
# NOTE: You MUST match CN to the domain name or ip address you want to use
openssl genrsa \
-out all/privkey.pem \
2048
# Create a request from your Device, which your Root CA will sign
openssl req -new \
-key all/privkey.pem \
-out all/csr.pem \
-subj "/C=US/ST=Utah/L=Provo/O=ACME Tech Inc/CN=${FQDN}"
# Sign the request from Device with your Root CA
openssl x509 \
-req -in all/csr.pem \
-CA all/my-private-root-ca.cert.pem \
-CAkey all/my-private-root-ca.privkey.pem \
-CAcreateserial \
-out all/cert.pem \
-days 500
# Put things in their proper place
rsync -a all/{privkey,cert}.pem server/
cat all/cert.pem > server/fullchain.pem         # we have no intermediates in this case
rsync -a all/my-private-root-ca.cert.pem server/
rsync -a all/my-private-root-ca.cert.pem client/
# create DER format crt for iOS Mobile Safari, etc
openssl x509 -outform der -in all/my-private-root-ca.cert.pem -out client/my-private-root-ca.crt

    Par exemple:

    bash make-certs.sh 'localhost.greenlock.domains'

    J'espère que cela met le clou dans le cercueil sur celui-ci.

    Et un peu plus d'explication: https://github.com/coolaj86/node-ssl-root-cas/wiki/Painless-Self-Signed-Certificates-in-node.js

    Installer privé cert sur iOS Mobile Safari

    Vous devez créer une copie de l'autorité de certification racine d'un format DER avec un .crt extension:

    # create DER format crt for iOS Mobile Safari, etc
openssl x509 -outform der -in all/my-private-root-ca.cert.pem -out client/my-private-root-ca.crt

    Alors vous pouvez simplement servir de ce fichier avec votre serveur web. Lorsque vous cliquez sur le lien, il vous sera demandé si vous souhaitez installer le certificat.

    Pour un exemple de comment cela fonctionne, vous pouvez essayer d'installer MIT de l'Autorité de certification: https://ca.mit.edu/mitca.crt

    Des Exemples Liés À

    • Malheureusement, cela ne semble pas être suffisant. Ajouter dans les websockets puis essayez d'accéder à partir de Safari. Même si je sers le cert, je vais obtenir un message vous demandant si je veux installer le cert, mais après l'installation de la sécurité les websockets échouer. Avez-vous eu de la chance avec auto-signé certs + safari iOS?
    • Si vous souhaitez l'utiliser dans safari, vous devez ajouter votre autorité de certification racine. J'ai mis à jour le tutoriel avec un iOS section.
    • Si vous avez besoin pour obtenir le CA pem pour le serveur que vous appelez utilisation de cette commande (sa dernière certificat dans la sortie) openssl s_client -showcerts -connect www.example.com:443 </dev/null
    • Votre réponse vaut un article, très utile!
    InformationsquelleAutor CoolAJ86
  2. 10

    Essayez d'ajouter cette page à vos options de demande de

    var options = {
host: 'localhost',
port: 8000,
path: '/api/v1/test',
//These next three lines
rejectUnauthorized: false,
requestCert: true,
agent: false
};
    InformationsquelleAutor Loourr
  3. 3

    Votre génération de la clé semble ok. Vous ne devriez pas besoin d'un ca parce que vous n'êtes pas rejeter unsigned demandes.

    Ajouter .toString() à la fin de votre readFileSync méthodes de sorte que vous êtes en fait du passage d'une chaîne, pas un objet de fichier.

    • Au cours des dernières version de Nœud de l'rejectUnauthorized option est définie à true par défaut pour les demandes rejetées. Le toString est inutile, car readFileSync retourne une mémoire Tampon lors de l'encodage n'est pas spécifié, et le ca, cert et les principales options d'accepter un Tampon ou une Chaîne.
    • Donc, est-ce à dire que vous faites rejeter unsigned demandes faux et il était en train de travailler?
    • Oui, je peux le faire mais ce n'est pas ce que je veux. L'API je suis aide m'a fourni avec un certificat d'autorité de certification que je peux utiliser pour l'autorisation, et je veux le miroir de cette installation en local.
    InformationsquelleAutor binderbound
  4. 3

    Cette procédure permet de créer à la fois une autorité de certification & un certificat :

    1. saisir cette ca.cnf fichier à utiliser comme un raccourci configuration :

      wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

    1. créer une nouvelle autorité de certification à l'aide de cette configuration :

      openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

    1. maintenant que nous avons notre autorité de certification dans ca-key.pem et ca-cert.pem, nous allons générer une clé privée pour le serveur :

      openssl genrsa -out key.pem 4096

    1. saisir cette server.cnf fichier à utiliser comme un raccourci configuration :

      wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

    1. générer de la demande de signature de certificat à l'aide de cette configuration :

      openssl req -new -config server.cnf -key key.pem -out csr.pem

    1. signer la demande :

      openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

    J'ai trouvé cette procédure ici, avec plus d'informations sur la façon d'utiliser ces certificats.

    • Puis-je utiliser cette approche dans la production?
    InformationsquelleAutor John Slegers
  5. 3

    Essayez d'ajouter 

      agent: false,
rejectUnauthorized: false
    • Ce n'est pas différent de ce que @Loourr suggéré.
    InformationsquelleAutor user1570577