Heroku NodeJS http a https ssl redirección forzada

A partir de hoy, 10 de octubre de 2014, usando Heroku Cedar stack, y ExpressJS ~3.4.4, aquí hay un conjunto de código de trabajo.

Lo principal a recordar aquí es que nos estamos desplegando a Heroku. La terminación SSL ocurre en el balanceador de carga, antes de que el tráfico cifrado llegue a su aplicación node. Es posible probar si se usó https para hacer la solicitud con req.headers ['x-forwarded-proto'] = = = 'https' .

No necesitamos preocuparnos con tener certificados SSL locales dentro de la aplicación, etc., como lo haría si se alojara en otros entornos. Sin embargo, primero debe obtener un complemento SSL aplicado a través de Complementos Heroku si usa su propio certificado, subdominios, etc.

Luego simplemente agregue lo siguiente para hacer el redireccionamiento de cualquier otra cosa que no sea HTTPS a HTTPS. Esto está muy cerca de la respuesta aceptada arriba, pero:

1. Se asegura de que utilice " aplicación.use" (para todas las acciones, no solo get)
2. Externaliza explícitamente la lógica forceSsl en una función declarada
3. No usa ' * ' con " app.usar " - esto realmente falló cuando lo probé.
4. Aquí, solo quiero SSL en producción. (Cambiar según sus necesidades)

Código:

 var express = require('express'),
   env = process.env.NODE_ENV || 'development';

 var forceSsl = function (req, res, next) {
    if (req.headers['x-forwarded-proto'] !== 'https') {
        return res.redirect(['https://', req.get('Host'), req.url].join(''));
    }
    return next();
 };

 app.configure(function () {

    if (env === 'production') {
        app.use(forceSsl);
    }

    // other configurations etc for express go here...
}

Nota para SailsJS (0.10.x) usuarios. Simplemente puede crear una política (enforceSsl.js) dentro de api / políticas:

module.exports = function (req, res, next) {
  'use strict';
  if ((req.headers['x-forwarded-proto'] !== 'https') && (process.env.NODE_ENV === 'production')) {
    return res.redirect([
      'https://',
      req.get('Host'),
      req.url
    ].join(''));
  } else {
    next();
  }
};

Luego referencia desde config/policies.js along with any other policies, e. g:

'*': ['autenticado', 'enforceSsl']

La respuesta aceptada tiene un dominio hardcoded en ella, que no es demasiado bueno si usted tiene el mismo código en varios dominios (por ejemplo: dev-yourapp.com, test-yourapp.com, yourapp.com).

Usa esto en su lugar:

/* Redirect http to https */
app.get('*', function(req,res,next) {
  if(req.headers['x-forwarded-proto'] != 'https' && process.env.NODE_ENV === 'production')
    res.redirect('https://'+req.hostname+req.url)
  else
    next() /* Continue to other routes if we're not redirecting */
});

Https://blog.mako.ai/2016/03/30/redirect-http-to-https-on-heroku-and-node-generally/

He escrito un pequeño módulo de nodo que impone SSL en proyectos express. Funciona tanto en situaciones estándar como en caso de proxies inversos (Heroku, nodejitsu, etc.).)

Https://github.com/florianheinemann/express-sslify

Si desea probar el encabezado x-forwarded-proto en su localhost, puede usar nginx para configurar un archivo vhost que proxy todas las solicitudes a su aplicación node. Su archivo de configuración nginx vhost podría tener este aspecto

NginX

server {
  listen 80;
  listen 443;

  server_name dummy.com;

  ssl on;
  ssl_certificate     /absolute/path/to/public.pem;
  ssl_certificate_key /absolute/path/to/private.pem;

  access_log /var/log/nginx/dummy-access.log;
  error_log /var/log/nginx/dummy-error.log debug;

  # node
  location / {
    proxy_pass http://127.0.0.1:3000/;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

Los bits importantes aquí son que está proxy todas las solicitudes al puerto 3000 de localhost (aquí es donde se ejecuta su aplicación de nodo) y está configurando un montón de encabezados que incluyen X-Forwarded-Proto

A continuación, en su aplicación detectar que cabecera como de costumbre

Express

var app = express()
  .use(function (req, res, next) {
    if (req.header('x-forwarded-proto') == 'http') {
      res.redirect(301, 'https://' + 'dummy.com' + req.url)
      return
    }
    next()
  })

Koa

var app = koa()
app.use(function* (next) {
  if (this.request.headers['x-forwarded-proto'] == 'http') {
    this.response.redirect('https://' + 'dummy.com' + this.request.url)
    return
  }
  yield next
})

Hosts

Finalmente tienes que añadir esta línea a tu archivo hosts

127.0.0.1 dummy.com

Si está utilizando cloudflare.com como CDN en combinación con heroku, puede habilitar la redirección ssl automática dentro de cloudflare fácilmente de la siguiente manera:

1. Inicie sesión y vaya a su panel

2. Seleccionar Reglas de página

   

3. Agregue su dominio, p. ej. www.example.com y cambiar siempre use https a encendido

Los usuarios de Loopback pueden usar una versión ligeramente adaptada de arcseldon answer como middleware:

Servidor/middleware/forcessl.js

module.exports = function() {  
  return function forceSSL(req, res, next) {
    var FORCE_HTTPS = process.env.FORCE_HTTPS || false;
      if (req.headers['x-forwarded-proto'] !== 'https' && FORCE_HTTPS) {
        return res.redirect(['https://', req.get('Host'), req.url].join(''));
      }
      next();
    };
 };

Servidor/Servidor.js

var forceSSL = require('./middleware/forcessl.js');
app.use(forceSSL());

Deberías echar un vistazo a heroku-ssl-redirect. Funciona como un encanto!

var sslRedirect = require('heroku-ssl-redirect');
var express = require('express');
var app = express();

// enable ssl redirect
app.use(sslRedirect());

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

app.listen(3000);

Comprobar el protocolo en la cabecera X-Forwarded-Proto funciona bien en Heroku, tal como Derek ha señalado. Por si sirve de algo, aquí hay un resumen del middleware Express que uso y su prueba correspondiente.

app.all('*',function(req,res,next){
  if(req.headers['x-forwarded-proto']!='https') {
    res.redirect(`https://${req.get('host')}`+req.url);
  } else {
    next(); /* Continue to other routes if we're not redirecting */
  }
});

Una forma más expresa y específica de hacer esto.

  app.enable('trust proxy');
  app.use('*', (req, res, next) => {
    if (req.secure) {
      return next();
    }
    res.redirect(`https://${req.hostname}${req.url}`);
  });