security languages Asegure el desencadenador http de Google Cloud Functions con auth




http request cloud functions (3)

Después de seguir investigando esto, y siguiendo una pista de la respuesta de @Ricka, decidí implementar una verificación de autenticación para mis funciones en la nube con un token JWT pasado en la forma de un token de acceso de encabezado de autorización.

Aquí está la implementación en Nodo:

const client = jwksClient({
  cache: true,
  rateLimit: true,
  jwksRequestsPerMinute: 5,
  jwksUri: "https://<auth0-account>.auth0.com/.well-known/jwks.json"
});

function verifyToken(token, cb) {
  let decodedToken;
  try {
    decodedToken = jwt.decode(token, {complete: true});
  } catch (e) {
    console.error(e);
    cb(e);
    return;
  }
  client.getSigningKey(decodedToken.header.kid, function (err, key) {
    if (err) {
      console.error(err);
      cb(err);
      return;
    }
    const signingKey = key.publicKey || key.rsaPublicKey;
    jwt.verify(token, signingKey, function (err, decoded) {
      if (err) {
        console.error(err);
        cb(err);
        return
      }
      console.log(decoded);
      cb(null, decoded);
    });
  });
}

function checkAuth (fn) {
  return function (req, res) {
    if (!req.headers || !req.headers.authorization) {
      res.status(401).send('No authorization token found.');
      return;
    }
    const parts = req.headers.authorization.split(' ');
    if (parts.length != 2) {
      res.status(401).send('Bad credential format.');
      return;
    }
    const scheme = parts[0];
    const credentials = parts[1];

    if (!/^Bearer$/i.test(scheme)) {
      res.status(401).send('Bad credential format.');
      return;
    }
    verifyToken(credentials, function (err) {
      if (err) {
        res.status(401).send('Invalid token');
        return;
      }
      fn(req, res);
    });
  };
}

Utilizo jsonwebtoken para verificar el token JWT, y jwks-rsa para recuperar la clave pública. Yo uso Auth0, por lo que jwks-rsa llega a la lista de claves públicas para recuperarlas.

La función checkAuth se puede usar para proteger la función de nube como:

exports.get = checkAuth(function (req, res) {
    // do things safely here
});

Puede ver este cambio en mi repositorio de github en https://github.com/tnguyen14/functions-datastore/commit/a6b32704f0b0a50cd719df8c1239f993ef74dab6

El token de acceso / JWT se puede recuperar de varias maneras. Para Auth0, la documentación de la API se puede encontrar en https://auth0.com/docs/api/authentication#authorize-client

Una vez que esté en su lugar, puede activar la función de nube (si tiene la suya habilitada con el activador de http) con algo como

curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer access-token" \
-d '{"foo": "bar"}' \
"https://<cloud-function-endpoint>.cloudfunctions.net/get"

Hoy estoy probando Google Cloud Functions siguiendo esta guía: https://cloud.google.com/functions/docs/quickstart

Creé una función con un activador HTTP y pude realizar una solicitud POST para activar una función para escribir en el almacén de datos.

Me preguntaba si hay alguna manera de asegurar este punto final HTTP. Actualmente parece que aceptará una solicitud desde cualquier lugar / cualquiera.

Cuando busco en Google, veo que la mayoría de los resultados hablan sobre cómo proteger las cosas con Firebase. Sin embargo, no estoy usando el servicio Firebase aquí.

¿Mis opciones serían dejarlas abiertas y esperar que nadie conozca el punto final de la URL (seguridad por oscuridad), o implementar mi propia verificación de autenticación en la función en sí?



Parece que actualmente hay 2 formas de asegurar un punto final HTTP de Google Cloud Function.

1) Use un nombre de función difícil de adivinar (por ejemplo, my-function-vrf55m6f5Dvkrerytf35)

2) Verifique la contraseña / credenciales / solicitud firmada dentro de la propia función (usando un encabezado o parámetro)

Probablemente sea mejor hacer ambas cosas.





google-cloud-functions