Uwierzytelnianie i autoryzacja przy użyciu narzędzi i narzędzi firmy Flatiron

Question

Chcę zaimplementować uwierzytelnianie i autoryzację w stosie Flatiron (przy użyciu Flatiron, Resourceful i Restful). Chcę wymagać, aby użytkownik miał niezbędne uprawnienia podczas próby zmiany zasobu. W relaksującego pliku Readme, tam note about authorization:

Istnieje kilka sposobów, aby zapewnić bezpieczeństwo i pozwolenie na użytkowanie zasobów metod narażonych z spokojny. Zalecany wzorzec do autoryzacji polega na użyciu hooków dla zaradczych zasobów dla before i after. W tych hakach można dodać dodatkową logikę biznesową , aby ograniczyć dostęp do metod zasobów.

Jest nie Zaleca się umieścić logiki autoryzacji w routingu warstwy, jak w idealnym świecie router będzie odzwierciedlone interfejs zasobu. Teoretycznie bezpieczeństwo samego routera powinno być w pewnym stopniu nieistotne, ponieważ zasób mógłby mieć wiele odbitych interfejsów, które wymagałyby tej samej logiki biznesowej.

TL; DR; W celu zapewnienia bezpieczeństwa i autoryzacji należy użyć haczyków resourceful: before i after.

Autoryzacja może być obsługiwana przez system zahaczania Resourceful.

Moim rzeczywistym problemem jest proces uwierzytelniania na początku każdego żądania HTTP.

Załóżmy, że mam zasób Post, User i zasób Session. Interfejs API REST jest definiowany za pomocą Restful. Moją główną troską o to pytanie jest zapewnienie, że użytkownik ma sesję podczas tworzenia postu. Inne metody, takie jak save, lub inne zasoby, takie jak tworzenie użytkownika, powinny działać analogicznie.

app.js pliku:

var flatiron = require('flatiron'); 
var app = flatiron.app; 

app.resources = require('./resources.js'); 

app.use(flatiron.plugins.http); 
app.use(restful); 
app.start(8080, function(){ 
    console.log('http server started on port 8080'); 
}); 

pliku resources.js:

var resourceful = require('resourceful'); 

var resources = exports; 

resources.User = resourceful.define('user', function() { 
    this.restful = true; 
    this.string('name'); 
    this.string('password'); 
}); 

resources.Session = resourceful.define('session', function() { 
    // note: this is not restful 
    this.use('memory'); 
    this.string('session_id'); 
}); 

resources.Post = resourceful.define('post', function() { 
    this.restful = true; 
    this.use('memory'); 
    this.string('title'); 
    this.string('content'); 
}); 

resources.Post.before('create', function authorization(post, callback) { 
    // What should happen here? 
    // How do I ensure, a user has a session id? 

    callback(); 
}); 

Jest też runnable version of the code (dzięki @generalhenry).

Załóżmy, że użytkownik próbujący utworzyć wpis, otrzymał już identyfikator sesji, który jest wysyłany przy każdym żądaniu, które tworzy przez nagłówek pliku cookie. W jaki sposób mogę uzyskać dostęp do tego pliku cookie w poprzednim haczyku (to jest wywołanie zwrotne authorization)?

Przykład można uruchomić za pomocą node app.js, a żądania HTTP można wykonać za pomocą curl.

Answer 1

Należy pamiętać, że niniejsze wytyczne dotyczą procesu autoryzacji. Jeśli potrzebujesz użyć sessionId, możesz uzyskać do niego dostęp w dowolny sposób: req.sessionID, req.cookies["connect.sid"].

Sprawdzając żądania w ten sposób, będziesz mieć pewność, że każdy użytkownik ma prawidłowy identyfikator sesji.

app.use(flatiron.plugins.http, { 
    before: [ 
    connect.favicon(), 
    connect.cookieParser('catpsy speeds'), 
    function(req, res) { 
     if (req.originalUrl === undefined) { 
     req.originalUrl = req.url; 
     } 
     res.emit('next'); 
    }, 
    connect.session({secret : 'secter'}), 
    function(req, res) { 
     console.log('Authenticating...'); 
     console.dir(req.session); 
     //any other validation logic 
     if (req.url !== '/login' && typeof req.session.user == 'undefined') { 
     res.redirect('/login'); 
     } else { 
     res.emit('next'); 
     } 
    } 
    ] 
}); 

Oto project example za pomocą tego podejścia.