44 votes

Sécuriser http avec authentification sur Google Cloud Functions http

J'essaie de Google Cloud fonctionne aujourd'hui de suivre ce guide: https://cloud.google.com/functions/docs/quickstart

J'ai créé une fonction avec un HTTP déclencheur, et a été en mesure d'effectuer une requête POST pour déclencher une fonction pour écrire à la banque de données.

Je me demandais si il y a un moyen pour que je puisse fixer ce point de terminaison HTTP? Actuellement, il semble qu'il acceptera une demande à partir de n'importe où/n'importe qui.

Lorsque googler autour, je vois la plupart des résultats de parler de la sécurisation des choses avec Firebase. Cependant, je ne suis pas à l'aide de la Firebase service ici.

Mes options: soit laisser ouvert, et espère que personne ne connaît l'URL de point de terminaison (la sécurité par l'obscurité), ou mettre en place mes propres auth vérifier dans la fonction elle-même?

14voto

Tri Nguyen Points 338

Lorsque l'on regarde plus loin, et prendre un soupçon de @ricka réponse, j'ai décidé de mettre en œuvre un contrôle d'authentification de mon nuage fonctions avec un JWT jeton passé sous la forme d'un en-tête d'Autorisation jeton d'accès.

Voici la mise en œuvre du Nœud:

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

J'utilise jsonwebtoken pour vérifier la JWT jeton, et jwks-rsa pour récupérer la clé publique. J'utilise Auth0, alors jwks-rsa atteint à la liste des clés publiques pour les récupérer.

L' checkAuth fonction peut ensuite être utilisées pour protéger la fonction cloud comme:

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

Vous pouvez voir ce changement sur mon dépôt github à https://github.com/tnguyen14/functions-datastore/commit/a6b32704f0b0a50cd719df8c1239f993ef74dab6

Le JWT / jeton d'accès peuvent être récupérées dans un certain nombre de chemin. Pour Auth0, l'API doc peut être trouvé à https://auth0.com/docs/api/authentication#authorize-client

Une fois cela en place, vous pouvez déclencher la fonction cloud (si vous avez le vôtre activé avec http trigger) avec quelque chose comme

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

1voto

ricka Points 133

Il semble qu'il existe actuellement deux moyens de sécuriser un point de terminaison HTTP Google Cloud Function.

1) Utilisez un nom de fonction difficile à deviner (ex: my-function-vrf55m6f5Dvkrerytf35)

2) Vérifier le mot de passe / informations d'identification / demande signée dans la fonction elle-même (en utilisant un en-tête ou un paramètre)

Probablement mieux faire les deux.

1voto

Darren Points 381

Vous ne devriez pas "le laisser ouvert et espérer que personne ne le sache". Vous pouvez implémenter votre propre contrôle de sécurité ou essayer le module Google Function Authorizer ( https://www.npmjs.com/package/google-function-authorizer ).

0voto

Berkay Points 1396

Vous pouvez créer un algorithme d'authentification personnalisé pour vérifier le client.

Découvrez l'algorithme de; https://security.stackexchange.com/q/210085/22239

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X