Heroku NodeJS http a https ssl redireccionamiento forzado

Tengo una aplicación en funcionamiento en heroku con express en el nodo con https. ¿Cómo identifico el protocolo para forzar una redirección a https con nodejs en heroku?

Mi aplicación es solo un servidor http simple, (todavía) no se da cuenta de que heroku le está enviando solicitudes https:

/* Heroku provides the port they want you on in this environment variable (hint: it's not 80) */
app.listen(process.env.PORT || 3000);

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

Lo principal para recordar aquí es que ESTAMOS implementando en Heroku. La terminación de SSL ocurre en el balanceador de carga, antes de que el tráfico cifrado llegue a su aplicación de nodo. Es posible probar si se utilizó https para realizar la solicitud con req.headers ['x-fordered-proto'] === 'https' .

No es necesario que nos preocupemos por tener certificados SSL locales dentro de la aplicación, etc., como lo haría si estuviera alojando en otros entornos. Sin embargo, primero debe aplicar un complemento SSL a través de los complementos de Heroku si usa su propio certificado, subdominios, etc.

Luego, simplemente agregue lo siguiente para hacer la redirección de cualquier cosa que no sea HTTPS a HTTPS. Esto está muy cerca de la respuesta aceptada anterior, pero:

1. Garantiza que utilice "app.use" (para todas las acciones, no solo para obtener)
2. Externaliza explícitamente la lógica forceSsl en una función declarada
3. No usa '*' con "app.use" - esto realmente falló cuando lo probé.
4. Aquí, solo quiero SSL en producción. (Cambie 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 los usuarios de SailsJS (0.10.x). Simplemente puede crear una política (enforceSsl.js) dentro de api / policies:

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, haga referencia a config / policies.js junto con cualquier otra política, por ejemplo:

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

La respuesta es usar el encabezado de 'x-fordered-proto' que Heroku transmite como lo hace con su proxy thingamabob. (nota al margen: también pasan varias otras variables x que pueden ser útiles, compruébalo )

Mi código:

/* At the top, with other redirect methods before other routes */
app.get('*',function(req,res,next){
  if(req.headers['x-forwarded-proto']!='https')
    res.redirect('https://mypreferreddomain.com'+req.url)
  else
    next() /* Continue to other routes if we're not redirecting */
})

Gracias Brandon, estaba esperando ese retraso de 6 horas que no me dejaba responder mi propia pregunta.

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

Use 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/

Escribí un pequeño módulo de nodo que aplica 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 x-forwarded-protoencabezado en su localhost, puede usar nginx para configurar un archivo vhost que envía todas las solicitudes a su aplicación de nodo. Su archivo de configuración de nginx vhost podría verse así

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;
  }
}

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

Luego, en su aplicación, detecte ese encabezado como de costumbre

Rápido

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
})

Hospedadores

Finalmente tienes que agregar esta línea a tu hostsarchivo

127.0.0.1 dummy.com

Debería echar un vistazo a heroku-ssl-redirect . ¡Funciona a las mil maravillas!

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);

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

1. Inicie sesión y vaya a su panel

2. Seleccionar reglas de página

   

3. Agregue su dominio, por ejemplo, www.example.com y cambie usar siempre https a activado

Los usuarios de loopback pueden usar una versión ligeramente adaptada de la respuesta de arcseldon 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();
    };
 };

server / server.js

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

Esta es una forma más específica de Express para hacer esto.

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

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 */
  }
});

Con app.use y url dinámica. Funciona tanto localmente como en Heroku para mí

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

Verificar el protocolo en el encabezado X-Fordered-Proto funciona bien en Heroku, tal como lo ha señalado Derek. Por lo que vale, aquí hay una idea general del middleware Express que utilizo y su prueba correspondiente.