Tive um problema semelhante com o SSL a trabalhar num porto que não o 443. No meu caso, eu tinha um certificado de pacote, bem como um certificado e uma chave. O certificado de pacote é um arquivo que detém vários certificados, nó requer que você quebre esses certificados em elementos separados de um array.

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

    var options = {
      ca: [fs.readFileSync(PATH_TO_BUNDLE_CERT_1), fs.readFileSync(PATH_TO_BUNDLE_CERT_2)],
      cert: fs.readFileSync(PATH_TO_CERT),
      key: fs.readFileSync(PATH_TO_KEY)
    };

    app = express()

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

    var server = https.createServer(options, app);

    server.listen(8001, function(){
        console.log("server running at https://IP_ADDRESS:8001/")
    });

Na aplicação.js você precisa especificar https e criar o servidor de acordo. Além disso, certifique-se que o porto que você está tentando usar está realmente permitindo o tráfego de entrada.

Incluindo Pontos:

1. configuração SSL
   1. em config/local.js
   2. em config/env / production.js

Tratamento de

HTTP e WS

1. o aplicativo deve ser executado em HTTP em desenvolvimento para que possamos facilmente depurar o nosso aplicacao.
A aplicação deve funcionar em HTTPS em produção por motivos de segurança.
2. o pedido HTTP de produção de aplicações deve sempre redireccionar para https.

Configuração de SSL

Em Sailsj há duas maneiras. para configurar todas as coisas, primeiro é configurar na pasta de configuração com cada um tem seus arquivos separados (como a conexão de banco de dados em relação a configuração está dentro de conexões.js ). E a segunda é a configuração na estrutura de ficheiros de base do ambiente, cada ficheiro de Ambiente apresenta na pasta config/env e cada ficheiro contém configuração para uma dada env.

Navega primeiro na pasta de configuração/env e depois aguarda para ver a configuração/ *.js

Agora vamos configurar o ssl config/local.js.

var local = {
   port: process.env.PORT || 1337,
   environment: process.env.NODE_ENV || 'development'
};

if (process.env.NODE_ENV == 'production') {
    local.ssl = {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: require('fs').readFileSync(__dirname + '/path/to/ca.crt','ascii'),
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key','ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt','ascii')
    };
    local.port = 443; // This port should be different than your default port
}

module.exports = local;

Alternativa pode adicionar isto em configuração / env / produção.js também. (Este excerto também mostra como lidar com vários certificados de caramelo)

Ou em produção.js

module.exports = {
    port: 443,
    ssl: {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: [
            require('fs').readFileSync(__dirname + '/path/to/AddTrustExternalCARoot.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSAAddTrustCA.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSADomainValidationSecureServerCA.crt', 'ascii')
        ],
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key', 'ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt', 'ascii')
    }
};

Http / https & ws/wss redirection

Aqui o WS é um 'Socket' Web e o wss representa um 'Socket' Web seguro, uma vez que configuramos o ssl e agora o http e o ws ambos os pedidos tornam-se seguros e transformam-se em https e wss respectivamente.

Há muitas fontes do nosso aplicativo vai receber pedido como qualquer post de blog, post de mídia social, mas o nosso servidor é executado apenas em https assim, quando qualquer pedido vem de http que dá "este site não pode ser alcançado" erro no navegador cliente. E perdemos o tráfego do nosso site. Então devemos redirecionar a solicitação http para https, as mesmas regras permitem websocket caso contrário o socket vai falhar.

Então precisamos de executar o mesmo servidor na porta 80 (http), e desviar todos os pedidos para a porta 443(https). Sails first compile config / bootstrap.js ficheiro Antes de levantar o servidor. Aqui podemos iniciar o nosso servidor expresso na porta 80.

In config/bootstrap.js (criar um Servidor http e redireccionar todos os pedidos para https)

module.exports.bootstrap = function(cb) {
    var express = require("express"),
        app = express();

    app.get('*', function(req, res) {  
        if (req.isSocket) 
            return res.redirect('wss://' + req.headers.host + req.url)  

        return res.redirect('https://' + req.headers.host + req.url)  
    }).listen(80);
    cb();
};

Agora podes visitar-me. http://www.yourdomain.com vai redireccionar para ... https://www.yourdomain.com

É assim que funciona para mim. O redirecionamento usado irá redirecionar todos os http normais também.

const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const http = require('http');
const app = express();
var request = require('request');
//For https
const https = require('https');
var fs = require('fs');
var options = {
  key: fs.readFileSync('certificates/private.key'),
  cert: fs.readFileSync('certificates/certificate.crt'),
  ca: fs.readFileSync('certificates/ca_bundle.crt')
};

// API file for interacting with MongoDB
const api = require('./server/routes/api');

// Parsers
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));

// Angular DIST output folder
app.use(express.static(path.join(__dirname, 'dist')));

// API location
app.use('/api', api);

// Send all other requests to the Angular app
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'dist/index.html'));
});
app.use(function(req,resp,next){
  if (req.headers['x-forwarded-proto'] == 'http') {
      return resp.redirect(301, 'https://' + req.headers.host + '/');
  } else {
      return next();
  }
});


http.createServer(app).listen(80)
https.createServer(options, app).listen(443);

Usar greenlock-express: SSL livre, HTTPS automatizados

O Greenlock lida com a emissão e renovação de certificados (através do Let's Encrypt) e http => https redireccionamento, fora da caixa.

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: '[email protected]'
, 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

Veja a demonstração de arranque rápido: https://youtu.be/e8vaR4CEZ5s

Para Localhost

Só estou a responder a isto antes do tempo, porque é um seguimento comum. pergunta: Não podes ter certificados SSL no localhost. No entanto, você pode usar algo como Telebit que lhe permitirá executar aplicativos locais como reais.

Você também pode usar domínios privados com Greenlock via DNS-01 challenges, que é mencionado no README, juntamente com vários plugins que o suportam.

Portos não normalizados (ou seja, n. o 80 / 443)

Leia a nota acima sobre localhost-você não pode usar portas não-padrão com o 'Let's Encrypt' ou.

No entanto, pode expor os seus portos internos não-normalizados como portos externos através de port-forward, sni-route, ou usar algo como Telebit que faz SNI-routing e port-forwarding / relaying para si.

Você também pode usar desafios DNS-01, caso em que você não vai precisar expor os portos de todo e você também pode proteger domínios em redes privadas desta forma.

Esta é minha código de trabalho para express 4.0.

O Express 4.0 é muito diferente de 3.0 e outros.

4, 0 tem o ficheiro /bin / www, que irá adicionar https aqui.

"npm start" é a forma normal de iniciar o servidor express 4.0.

A função ReadFileSync () deve usar __Nome do utilizador obter a pasta actual

Embora necessite() use ./ consultar o actual Directorio.

primeiro, põe em privado.chave e público.certificado ficheiro sob a pasta /bin, É a mesma pasta que o ficheiro WWW.

Primeiro, vá para Criar um certificado SSL Autossignado

• Ir para o terminal e executar o seguinte comando.

Sudo openssl req-x509-nodos-dias 365-newkey rsa:2048-keyout .- autossignado.porta-chaves selfsigned.crt

• e colocar a seguinte informação
• Nome do país (código de 2 Letras) [AU]: US
• Nome do Estado ou da Província (nome completo) [algum-Estado]: NY
• Nome da localidade (eg, cidade) []: NY
• Nome da organização (eg, empresa) [Internet Widgits Pty Ltd]: xyz (your-Organization)
• Nome da Unidade Organizacional (eg, secção) []: xyz (nome da sua Unidade)
• Nome Comum (por exemplo, servidor FQDN ou o seu nome) []: www.xyz.com (o seu URL)
• endereço de E-mail []: o seu email

Após a criação adicionar um ficheiro chave & cert no seu código, a minha aparência de ficheiro bin/www comer.

     var app = require('../app'); 
    var debug = require('debug')('driftApp:server');
    //var http = require('http');
    var http = require('https');
    var fs = require('fs');

    var key = fs.readFileSync(__dirname + '/../certs/selfsigned.key');
    var cert = fs.readFileSync(__dirname + '/../certs/selfsigned.crt');
    var options = {
     key: key,
     cert: cert
    };

    var port = normalizePort(process.env.PORT || '3000');
    app.set('port', port);
    console.log("Server Started On Port: ", port);
    //var server = http.createServer(app);
    var server = http.createServer(options, app);
    server.listen(port);
    server.on('error', onError);
    server.on('listening', onListening);
    function normalizePort(val) {
    var port = parseInt(val, 10);

    if (isNaN(port)) {
     // named pipe
     return val;
    }
    if (port >= 0) {
     // port number
     return port;
    }
    return false;
    }
    function onError(error) {
    if (error.syscall !== 'listen') {
     throw error;
    }
    var bind = typeof port === 'string' ?
     'Pipe ' + port :
     'Port ' + port;
    // handle specific listen errors with friendly messages
    switch (error.code) {
     case 'EACCES':
        console.error(bind + ' requires elevated privileges');
        process.exit(1);
        break;
     case 'EADDRINUSE':
        console.error(bind + ' is already in use');
        process.exit(1);
        break;
     default:
        throw error;
      }
     }
    function onListening() {
    var addr = server.address();
    var bind = typeof addr === 'string' ?
     'pipe ' + addr :
     'port ' + addr.port;
     debug('Listening on ' + bind);
    }

• finalmente execute a sua aplicação usando https