So implementieren Sie eine sichere REST-API mit node.js.

Ich beginne mit der Planung einer REST-API mit node.js, express und mongodb. Die API stellt Daten für eine Website (öffentlicher und privater Bereich) und möglicherweise später für eine mobile App bereit. Das Frontend wird mit AngularJS entwickelt.

Einige Tage habe ich viel über das Sichern von REST-APIs gelesen, aber ich komme nicht zu einer endgültigen Lösung. Soweit ich weiß, ist die Verwendung von HTTPS zur Bereitstellung einer grundlegenden Sicherheit. Aber wie kann ich die API in diesen Anwendungsfällen schützen:

• Nur Besucher / Benutzer der Website / App dürfen Daten für den öffentlichen Bereich der Website / App abrufen

• Nur authentifizierte und autorisierte Benutzer dürfen Daten für den privaten Bereich abrufen (und nur Daten, für die der Benutzer Berechtigungen erteilt hat).

Im Moment denke ich darüber nach, nur Benutzern mit einer aktiven Sitzung die Verwendung der API zu erlauben. Um die Benutzer zu autorisieren, verwende ich den Reisepass und für die Erlaubnis muss ich etwas für mich selbst implementieren. Alles auf HTTPS.

Kann jemand Best Practices oder Erfahrungen liefern? Fehlt meine „Architektur“?

Ich hatte das gleiche Problem, das Sie beschreiben. Auf die Website, die ich erstelle, kann über ein Mobiltelefon und über den Browser zugegriffen werden. Daher benötige ich eine API, damit Benutzer sich anmelden, anmelden und bestimmte Aufgaben ausführen können. Außerdem muss ich die Skalierbarkeit unterstützen, den gleichen Code, der auf verschiedenen Prozessen / Maschinen ausgeführt wird.

Da Benutzer Ressourcen (auch als POST / PUT-Aktionen bezeichnet) erstellen können, müssen Sie Ihre API sichern. Sie können oauth verwenden oder Ihre eigene Lösung erstellen. Beachten Sie jedoch, dass alle Lösungen beschädigt werden können, wenn das Kennwort wirklich leicht zu ermitteln ist. Die Grundidee besteht darin, Benutzer mit dem Benutzernamen, dem Kennwort und einem Token, auch Apitoken genannt, zu authentifizieren. Dieses Apitoken kann mit node- uuid generiert werden und das Passwort mit pbkdf2 gehasht werden

Dann müssen Sie die Sitzung irgendwo speichern. Wenn Sie es im Speicher eines einfachen Objekts speichern, wenn Sie den Server beenden und erneut starten, wird die Sitzung zerstört. Auch dies ist nicht skalierbar. Wenn Sie Haproxy zum Lastausgleich zwischen Computern verwenden oder einfach Worker verwenden, wird dieser Sitzungsstatus in einem einzelnen Prozess gespeichert. Wenn derselbe Benutzer zu einem anderen Prozess / Computer umgeleitet wird, muss er sich erneut authentifizieren. Daher müssen Sie die Sitzung an einem gemeinsamen Ort speichern. Dies erfolgt normalerweise mit redis.

Wenn der Benutzer authentifiziert ist (Benutzername + Passwort + Apitoken), generieren Sie ein weiteres Token für die Sitzung, auch bekannt als accesstoken. Wieder mit Node-UUID. Senden Sie dem Benutzer das Zugangsformular und die Benutzer-ID. Die Benutzer-ID (Schlüssel) und der Zugriff (Wert) werden in Redis mit einer Ablaufzeit von z. B. 1 Stunde gespeichert.

Jedes Mal, wenn der Benutzer eine Operation mit der restlichen API ausführt, muss er die Benutzer-ID und den Zugriff senden.

Wenn Sie den Benutzern erlauben, sich mit der restlichen API anzumelden, müssen Sie ein Administratorkonto mit einem Administrator-Apitoken erstellen und diese in der mobilen App speichern (Benutzername + Passwort + Apitoken verschlüsseln), da neue Benutzer zu diesem Zeitpunkt kein Apitoken haben sie melden sich an.

Das Web verwendet auch diese API, aber Sie müssen keine Apitokens verwenden. Sie können Express mit einem Redis-Store verwenden oder dieselbe oben beschriebene Technik verwenden, jedoch die Apitoken-Prüfung umgehen und die Benutzer-ID + Zugriff in einem Cookie an den Benutzer zurückgeben.

Wenn Sie private Bereiche haben, vergleichen Sie den Benutzernamen mit den zulässigen Benutzern, wenn diese sich authentifizieren. Sie können den Benutzern auch Rollen zuweisen.

Zusammenfassung:

Eine Alternative ohne Apitoken wäre die Verwendung von HTTPS und das Senden des Benutzernamens und des Kennworts im Authorization-Header und das Zwischenspeichern des Benutzernamens in redis.

Ich möchte diesen Kodex als strukturelle Lösung für die gestellte Frage gemäß (ich hoffe es) zur akzeptierten Antwort beitragen. (Sie können es sehr einfach anpassen).

// ------------------------------------------------------
// server.js 

// .......................................................
// requires
var fs = require('fs');
var express = require('express'); 
var myBusinessLogic = require('../businessLogic/businessLogic.js');

// .......................................................
// security options

/*
1. Generate a self-signed certificate-key pair
openssl req -newkey rsa:2048 -new -nodes -x509 -days 3650 -keyout key.pem -out certificate.pem

2. Import them to a keystore (some programs use a keystore)
keytool -importcert -file certificate.pem -keystore my.keystore
*/

var securityOptions = {
    key: fs.readFileSync('key.pem'),
    cert: fs.readFileSync('certificate.pem'),
    requestCert: true
};

// .......................................................
// create the secure server (HTTPS)

var app = express();
var secureServer = require('https').createServer(securityOptions, app);

// ------------------------------------------------------
// helper functions for auth

// .............................................
// true if req == GET /login 

function isGETLogin (req) {
    if (req.path != "/login") { return false; }
    if ( req.method != "GET" ) { return false; }
    return true;
} // ()

// .............................................
// your auth policy  here:
// true if req does have permissions
// (you may check here permissions and roles 
//  allowed to access the REST action depending
//  on the URI being accessed)

function reqHasPermission (req) {
    // decode req.accessToken, extract 
    // supposed fields there: userId:roleId:expiryTime
    // and check them

    // for the moment we do a very rigorous check
    if (req.headers.accessToken != "you-are-welcome") {
        return false;
    }
    return true;
} // ()

// ------------------------------------------------------
// install a function to transparently perform the auth check
// of incoming request, BEFORE they are actually invoked

app.use (function(req, res, next) {
    if (! isGETLogin (req) ) {
        if (! reqHasPermission (req) ){
            res.writeHead(401);  // unauthorized
            res.end();
            return; // don't call next()
        }
    } else {
        console.log (" * is a login request ");
    }
    next(); // continue processing the request
});

// ------------------------------------------------------
// copy everything in the req body to req.body

app.use (function(req, res, next) {
    var data='';
    req.setEncoding('utf8');
    req.on('data', function(chunk) { 
       data += chunk;
    });
    req.on('end', function() {
        req.body = data;
        next(); 
    });
});

// ------------------------------------------------------
// REST requests
// ------------------------------------------------------

// .......................................................
// authenticating method
// GET /login?user=xxx&password=yyy

app.get('/login', function(req, res){
    var user = req.query.user;
    var password = req.query.password;

    // rigorous auth check of user-passwrod
    if (user != "foobar" || password != "1234") {
        res.writeHead(403);  // forbidden
    } else {
        // OK: create an access token with fields user, role and expiry time, hash it
        // and put it on a response header field
        res.setHeader ('accessToken', "you-are-welcome");
        res.writeHead(200); 
    }
    res.end();
});

// .......................................................
// "regular" methods (just an example)
// newBook()
// PUT /book

app.put('/book', function (req,res){
    var bookData = JSON.parse (req.body);

    myBusinessLogic.newBook(bookData, function (err) {
        if (err) {
            res.writeHead(409);
            res.end();
            return;
        }
        // no error:
        res.writeHead(200);
        res.end();
    });
});

// .......................................................
// "main()"

secureServer.listen (8081);

Dieser Server kann mit Curl getestet werden:

echo "----   first: do login "
curl -v "https://localhost:8081/login?user=foobar&password=1234" --cacert certificate.pem

# now, in a real case, you should copy the accessToken received before, in the following request

echo "----  new book"
curl -X POST  -d '{"id": "12341324", "author": "Herman Melville", "title": "Moby-Dick"}' "https://localhost:8081/book" --cacert certificate.pem --header "accessToken: you-are-welcome" 

Ich habe gerade eine Beispiel-App fertiggestellt, die dies auf eine ziemlich einfache, aber klare Weise tut. Es verwendet Mungo mit Mongodb, um Benutzer und Reisepass für die Authentifizierungsverwaltung zu speichern.

https://github.com/Khelldar/Angular-Express-Train-Seed

Es gibt viele Fragen zu REST-Authentifizierungsmustern hier auf SO. Dies sind die relevantesten für Ihre Frage:

• Sichern der REST-API meiner Node.js-App?
• RESTful Authentifizierung

Grundsätzlich müssen Sie zwischen der Verwendung von API-Schlüsseln (am wenigsten sicher, da der Schlüssel möglicherweise von einem nicht autorisierten Benutzer erkannt wird), einer Kombination aus App-Schlüssel und Token (mittel) oder einer vollständigen OAuth-Implementierung (am sichersten) wählen.

Wenn Sie Ihre Anwendung sichern möchten, sollten Sie auf jeden Fall HTTPS anstelle von HTTP verwenden . Dies stellt sicher, dass ein sicherer Kanal zwischen Ihnen und den Benutzern erstellt wird, der verhindert, dass die an die Benutzer gesendeten Daten abgehört werden, und dass die Daten erhalten bleiben vertraulich ausgetauscht.

Sie können JWTs (JSON Web Tokens) verwenden, um RESTful-APIs zu sichern . Dies hat im Vergleich zu serverseitigen Sitzungen viele Vorteile. Die Vorteile sind hauptsächlich:

1- Skalierbarer, da Ihre API-Server nicht für jeden Benutzer Sitzungen verwalten müssen (was bei vielen Sitzungen eine große Belastung sein kann).

2- JWTs sind in sich geschlossen und haben die Ansprüche, die beispielsweise die Benutzerrolle definieren und auf die er zugreifen kann und die zum Datum und Ablaufdatum ausgestellt wurden (danach ist JWT nicht mehr gültig).

3- Einfachere Handhabung über Load-Balancer hinweg. Wenn Sie über mehrere API-Server verfügen, müssen Sie weder Sitzungsdaten freigeben noch den Server so konfigurieren, dass die Sitzung an denselben Server weitergeleitet wird, wenn eine Anforderung mit einem JWT einen Server trifft, kann diese authentifiziert werden & autorisiert

4- Weniger Druck auf Ihre Datenbank und Sie müssen nicht ständig Sitzungs-IDs und -Daten für jede Anforderung speichern und abrufen

5- Die JWTs können nicht manipuliert werden, wenn Sie einen starken Schlüssel zum Signieren der JWT verwenden. Sie können also den Ansprüchen in der JWT vertrauen, die mit der Anforderung gesendet werden, ohne die Benutzersitzung überprüfen zu müssen und ob er autorisiert ist oder nicht Sie können einfach die JWT überprüfen und dann wissen Sie, wer und was dieser Benutzer tun kann.

Viele Bibliotheken bieten einfache Möglichkeiten zum Erstellen und Validieren von JWTs in den meisten Programmiersprachen, zum Beispiel: In node.js ist jsonwebtoken eine der beliebtesten

Da REST-APIs im Allgemeinen darauf abzielen, den Server zustandslos zu halten, sind JWTs mit diesem Konzept besser kompatibel, da jede Anforderung mit einem eigenständigen Autorisierungstoken (JWT) gesendet wird, ohne dass der Server die Benutzersitzung im Vergleich zu Sitzungen, in denen der Server ausgeführt wird, verfolgen muss Server statusbehaftet, damit er sich an den Benutzer und seine Rolle erinnert. Sitzungen sind jedoch auch weit verbreitet und haben ihre Vorteile, nach denen Sie suchen können, wenn Sie möchten.

Eine wichtige Sache, die Sie beachten sollten, ist, dass Sie das JWT mithilfe von HTTPS sicher an den Client senden und an einem sicheren Ort speichern müssen (z. B. im lokalen Speicher).

Weitere Informationen zu JWTs finden Sie unter diesem Link

Wenn Sie einen vollständig gesperrten Bereich Ihrer Webanwendung haben möchten, auf den nur Administratoren Ihres Unternehmens zugreifen können, ist die SSL-Autorisierung möglicherweise für Sie. Dadurch wird sichergestellt, dass niemand eine Verbindung zur Serverinstanz herstellen kann, es sei denn, in seinem Browser ist ein autorisiertes Zertifikat installiert. Letzte Woche habe ich einen Artikel über die Einrichtung des Servers geschrieben: Artikel

Dies ist eine der sichersten Einstellungen, die Sie finden werden, da keine Benutzernamen / Kennwörter beteiligt sind, sodass niemand Zugriff erhalten kann, es sei denn, einer Ihrer Benutzer übergibt die Schlüsseldateien einem potenziellen Hacker.