621 Stimmen

Aktivieren von HTTPS auf express.js

Ich versuche, HTTPS auf express.js für Knoten zu erhalten, und ich kann es nicht herausfinden.

Dies ist mein app.js Code.

var express = require('express');
var fs = require('fs');

var privateKey = fs.readFileSync('sslcert/server.key');
var certificate = fs.readFileSync('sslcert/server.crt');

var credentials = {key: privateKey, cert: certificate};

var app = express.createServer(credentials);

app.get('/', function(req,res) {
    res.send('hello');
});

app.listen(8000);

Wenn ich ihn ausführe, scheint er nur auf HTTP-Anfragen zu reagieren.

Ich schrieb einfache Vanille node.js basierte HTTPS-Anwendung:

var   fs = require("fs"),
      http = require("https");

var privateKey = fs.readFileSync('sslcert/server.key').toString();
var certificate = fs.readFileSync('sslcert/server.crt').toString();

var credentials = {key: privateKey, cert: certificate};

var server = http.createServer(credentials,function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});

server.listen(8000);

Und wenn ich diese Anwendung ausführe, dann tut auf HTTPS-Anfragen reagieren. Beachten Sie, dass ich nicht glaube, dass die toString() auf das fs-Ergebnis zählt, da ich Kombinationen von beiden und immer noch keine es bueno verwendet habe.


ÄNDERUNG ZUM ZUSATZ:

Für Produktionssysteme ist es wahrscheinlich besser, Nginx oder HAProxy als Proxy für Anfragen an Ihre Nodejs-Anwendung zu verwenden. Sie können Nginx so einrichten, dass es die SSL-Anfragen bearbeitet und nur http zu Ihrer nodejs-App spricht.

BEARBEITEN, UM HINZUZUFÜGEN (4/6/2015)

Für Systeme, die AWS nutzen, ist es besser, EC2 Elastic Load Balancers zu verwenden, um SSL-Termination zu handhaben und regulären HTTP-Verkehr zu Ihren EC2-Webservern zu ermöglichen. Für noch mehr Sicherheit richten Sie Ihre Sicherheitsgruppe so ein, dass nur der ELB HTTP-Datenverkehr an die EC2-Instanzen senden darf, wodurch verhindert wird, dass externer unverschlüsselter HTTP-Datenverkehr auf Ihre Rechner gelangt.


13voto

DragonFire Punkte 2748

Diese Antwort ist der von Setthase sehr ähnlich, gilt aber für LetsEncrypt (Ubuntu)

// Dependencies
const fs = require('fs');
const http = require('http');
const https = require('https');
const express = require('express');

const app = express();

// Certificate
const privateKey = fs.readFileSync('/etc/letsencrypt/live/yourdomain.com/privkey.pem', 'utf8');
const certificate = fs.readFileSync('/etc/letsencrypt/live/yourdomain.com/cert.pem', 'utf8');
const ca = fs.readFileSync('/etc/letsencrypt/live/yourdomain.com/chain.pem', 'utf8');

const credentials = {
    key: privateKey,
    cert: certificate,
    ca: ca
};

app.use((req, res) => {
    res.send('Hello there !');
});

// Starting both http & https servers
const httpServer = http.createServer(app);
const httpsServer = https.createServer(credentials, app);

httpServer.listen(80, () => {
    console.log('HTTP Server running on port 80');
});

httpsServer.listen(443, () => {
    console.log('HTTPS Server running on port 443');
});

Möglicherweise werden Sie feststellen: EACCES: Berechtigung verweigert, open '/etc/letsencrypt/live/yourdeomain.com/privkey.pem'

Die Antwort auf diese Frage finden Sie hier: Let's encrypt SSL konnte nicht gestartet werden durch "Error: EACCES: Berechtigung verweigert, open '/etc/letsencrypt/live/domain.net/privkey.pem'"

Was bei mir funktioniert hat, ist folgendes im ubuntu ssh terminal Benutzer holen whoami

// Create group with root and nodeuser as members
$ sudo addgroup nodecert
$ sudo adduser ubuntu nodecert
$ sudo adduser root nodecert

// Make the relevant letsencrypt folders owned by said group.
$ sudo chgrp -R nodecert /etc/letsencrypt/live
$ sudo chgrp -R nodecert /etc/letsencrypt/archive

// Allow group to open relevant folders
$ sudo chmod -R 750 /etc/letsencrypt/live
$ sudo chmod -R 750 /etc/letsencrypt/archive

sudo reboot

10voto

coolaj86 Punkte 69032

Verwenden Sie greenlock-express: Kostenloses SSL, automatisiertes HTTPS

Grünlock kümmert sich um die Ausstellung und Erneuerung von Zertifikaten (über Let's Encrypt) und die http => https-Umleitung, sofort einsatzbereit.

express-app.js :

var express = require('express');
var app = express();

app.use('/', function (req, res) {
  res.send({ msg: "Hello, Encrypted World!" })
});

// DO NOT DO app.listen()
// Instead export your app:
module.exports = app;

server.js :

require('greenlock-express').create({
  // Let's Encrypt v2 is ACME draft 11
  version: 'draft-11'
, server: 'https://acme-v02.api.letsencrypt.org/directory'

  // You MUST change these to valid email and domains
, email: 'john.doe@example.com'
, approveDomains: [ 'example.com', 'www.example.com' ]
, agreeTos: true
, configDir: "/path/to/project/acme/"

, app: require('./express-app.j')

, communityMember: true // Get notified of important updates
, telemetry: true       // Contribute telemetry data to the project
}).listen(80, 443);

Screencast

Sehen Sie sich die QuickStart-Demonstration an: https://youtu.be/e8vaR4CEZ5s

Für Localhost

Ich möchte diese Frage nur vorwegnehmen, weil sie häufig gestellt wird:

Sie können keine SSL-Zertifikate auf localhost haben. Sie können jedoch etwas verwenden wie Telebit die es Ihnen ermöglicht, lokale Anwendungen als echte Anwendungen auszuführen.

Sie können mit Greenlock auch private Domains über DNS-01-Challenges verwenden, was in der README zusammen mit verschiedenen Plugins, die dies unterstützen, erwähnt wird.

Nicht-Standard-Ports (d.h. keine 80 / 443)

Lesen Sie den obigen Hinweis zu localhost - Sie können auch mit Let's Encrypt keine Nicht-Standard-Ports verwenden.

Sie können jedoch Ihre internen Nicht-Standard-Ports als externe Standard-Ports über Port-Forward, Sni-Route oder etwas wie Telebit verwenden, das SNI-Routing und Port-Forwarding/Relaying für Sie übernimmt.

Sie können auch DNS-01-Challenges verwenden. In diesem Fall brauchen Sie überhaupt keine Ports freizugeben, und Sie können auf diese Weise auch Domains in privaten Netzen sichern.

4voto

Tobias Bergkvist Punkte 1070

Sie können auch ein selbstsigniertes Zertifikat erzeugen, indem Sie node-forge

Im folgenden Code wird beim Start ein neues Zertifikat generiert, d. h. Sie erhalten bei jedem Neustart des Servers ein neues Zertifikat.

const https = require('https')
const express = require('express')
const forge = require('node-forge')

;(function main() {
  const server = https.createServer(
    generateX509Certificate([
      { type: 6, value: 'http://localhost' },
      { type: 7, ip: '127.0.0.1' }
    ]), 
    makeExpressApp()
  )
  server.listen(8443, () => {
    console.log('Listening on https://localhost:8443/')
  })
})()

function generateX509Certificate(altNames) {
  const issuer = [
    { name: 'commonName', value: 'example.com' },
    { name: 'organizationName', value: 'E Corp' },
    { name: 'organizationalUnitName', value: 'Washington Township Plant' }
  ]
  const certificateExtensions = [
    { name: 'basicConstraints', cA: true },
    { name: 'keyUsage', keyCertSign: true, digitalSignature: true, nonRepudiation: true, keyEncipherment: true, dataEncipherment: true },
    { name: 'extKeyUsage', serverAuth: true, clientAuth: true, codeSigning: true, emailProtection: true, timeStamping: true },
    { name: 'nsCertType', client: true, server: true, email: true, objsign: true, sslCA: true, emailCA: true, objCA: true },
    { name: 'subjectAltName', altNames },
    { name: 'subjectKeyIdentifier' }
  ]
  const keys = forge.pki.rsa.generateKeyPair(2048)
  const cert = forge.pki.createCertificate()
  cert.validity.notBefore = new Date()
  cert.validity.notAfter = new Date()
  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1)
  cert.publicKey = keys.publicKey
  cert.setSubject(issuer)
  cert.setIssuer(issuer)
  cert.setExtensions(certificateExtensions)
  cert.sign(keys.privateKey)
  return {
    key: forge.pki.privateKeyToPem(keys.privateKey),
    cert: forge.pki.certificateToPem(cert)
  }
}

function makeExpressApp() {
  const app = express()
  app.get('/', (req, res) => {
    res.json({ message: 'Hello, friend' })
  })
  return app
}

2voto

justcodin Punkte 740

Vergessen Sie nicht Ihre PEM-Passphrase in den Anmeldedaten!

Wenn Sie Ihre Anmeldedaten mit OpenSSL generieren (vergessen Sie nicht die -sha256 Flagge) :

OpenSSL> req -x509 -sha256 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365
Generating a RSA private key

writing new private key to 'key.pem'
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:

Ihr JS/TS-Code :

const credentials = {key: privateKey, cert: certificate, passphrase: 'YOUR passphrase'};

Referenz

-2voto

hoogw Punkte 4200

Dies ist mein Arbeitscode para express 4.0 .

express 4.0 unterscheidet sich stark von 3.0 und anderen.

4.0 haben Sie die Datei /bin/www, die Sie hier um https erweitern werden.

"npm start" ist die Standardmethode zum Starten eines Express 4.0-Servers.

readFileSync()-Funktion sollte verwenden __dirname aktuelles Verzeichnis holen

while require() verwenden ./ beziehen sich auf das aktuelle Verzeichnis.

Zuerst legen Sie die Dateien private.key und public.cert im Ordner /bin ab, Es ist derselbe Ordner wie die WWW-Datei .

CodeJaeger.com

CodeJaeger ist eine Gemeinschaft für Programmierer, die täglich Hilfe erhalten..
Wir haben viele Inhalte, und Sie können auch Ihre eigenen Fragen stellen oder die Fragen anderer Leute lösen.

Powered by:

X