node.js API-Authentifizierung

Question

Ich arbeite an einer iOS-Anwendung, die mit einer Nodejs-Backend-Server-REST-API kommuniziert, und ich denke über API-Authentifizierung nach.

Ich möchte, dass nur die iOS-Anwendung mit der API kommunizieren kann.

Auf der iOS-Anwendungsseite werden Benutzer durch Facebook-Login authentifiziert. Sie erhalten somit nach der Authentifizierung in der iOS App ein fb access_token und ein fbid.

Für die API-Authentifizierung, plane ich es auf diese Weise zu machen:

• Wenn sich der Benutzer anmeldet in die iOS-App, ein Aufruf an/api/Auth mit seinem fb access_token und FBID getan wird;
• Wenn der Benutzer neu ist, erstelle ich ein zufälliges api_token für diesen Benutzer, speichere es in der Benutzerdatenbank und sende es zurück an die iOS App;
• Wenn der Benutzer bereits in der DB ist, aktualisiere ich das fb access_token in meiner DB und dem api_token und sende es zurück an die iOS App;
• Für jeden API-Aufruf gebe ich das api_token als POST-Parameter und auf der Serverseite überprüfe ich, ob es gültig ist, indem ich in der Datenbank vor dem Ausführen des API-Aufrufs abrufe.

Fehle ich etwas, genug gesichert zu sein?

Jede Rückmeldung oder Verbesserung wird sehr willkommen sein.

Grüße,

EDIT:

• On/api/Auth ich auf FacebookB API (/ me) geprüft, ob die fb access_token noch gültig ist:

Eine weitere Möglichkeit, die folgende wäre ;

Wenn nicht, lehne ich die Authentifizierung ab;

Wenn ja, erstelle und verwalte ich mein api_token mit JSON Web Token.

Answer 1

Wenn jemand interessiert ist, habe ich endlich die zweite Lösung implementiert. Sehr einfach und mach den Job!

config.js

module.exports = { 
    'secret': 'apisupersecrethere', 
}; 

route.js

var config = require('./config'); 
app.set('api_secret', config.secret); 
api = express.Router(); 

// function that checks the api_token 
api.use(function(req, res, next) { 
    var token = req.headers['x-access-token']; 
    if (token) { 
     jwt.verify(token,app.get('api_secret'),function(err, decoded) { 
      if (err) { 
       return res.json({ 
        success: false, 
        message: 'Failed to authenticate token.' 
       }); 
      } else { 
       req.decoded = decoded; 
       next(); 
      } 
     }); 
    } else { 
     return res.status(403).send({ 
      success: false, 
      message: 'No token provided.' 
     }); 
    } 
}); 

// route protected by the authentication 
router.use('/users', api); 

// authentication route 
router.post('/auth', function(req, res) { 
    verifyFacebookUserAccessToken(req.body.access_token). 
     then(function(user) { 
      var token = jwt.sign(user, app.get('api_secret'), { 
       expiresIn: 1440*60 // expires in 24 hours 
      }); 
      res.status(200).json({ 
       success: true, 
       message: "Authentication success!", 
       token: token 
      }); 
     }, function(error) { 
      res.status(401).json({ 
       success: false, 
       message: error.message 
      }); 
     }). 
     catch(function(error){ 
      res.status(500).json({ 
       success: false, 
       message: error.message 
      }); 
     }); 
    }); 

// Call facebook API to verify the token is valid 
function verifyFacebookUserAccessToken(token) { 
    var deferred = Q.defer(); 
    var path = 'https://graph.facebook.com/me?access_token=' + token; 
    request(path, function (error, response, body) { 
     var data = JSON.parse(body); 
     if (!error && response && response.statusCode && response.statusCode == 200) { 
      var user = { 
       facebookUserId: data.id, 
       username: data.username, 
       firstName: data.first_name, 
       lastName: data.last_name, 
       email: data.email 
     }; 
      deferred.resolve(user); 
     } 
     else { 
      deferred.reject({ 
       code: response.statusCode, 
       message: data.error.message 
      }); 
     } 
    }); 
    return deferred.promise; 
} 

Jede begrüßt Feedback.

Grüße