Beispielcode-Freigabe für Node.js zum Einrichten einer Whitelist für mehrere Domänennamen in domänenübergreifenden CORS-Anfragen

In diesem Artikel wird hauptsächlich die Methode von Node.js zum Einrichten einer Multi-Domain-Namens-Whitelist in CORS-Cross-Domain-Anfragen vorgestellt Ich glaube, es wird für jeden nützlich sein. Freunde, die es brauchen, können einen Blick darauf werfen.

CORS

Apropos CORS: Ich glaube, jeder ist mit dem Frontend vertraut, daher werde ich hier nicht auf Details eingehen. Weitere Informationen finden Sie in diesem Artikel.

CORS konfiguriert hauptsächlich das Access-Control-Allow-Origin-Attribut im Antwortheader für den Domänennamen, auf den Sie der Schnittstelle Zugriff gewähren. Die gebräuchlichsten Einstellungen sind:

res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Credentials', 'true'); // 允许服务器端发送Cookie数据

Diese Einstellung ist jedoch die einfachste und grobste und auch die am wenigsten sichere. Das bedeutet, dass die Schnittstelle allen Domänennamen erlaubt, domänenübergreifende Anfragen an sie zu stellen. In der Praxis wird jedoch im Allgemeinen davon ausgegangen, dass die Schnittstelle nur das Öffnen domänenübergreifender Anforderungsberechtigungen für eine oder einige wenige Websites zulässt, nicht für alle.

Ihr schlauen Leute fragt euch bestimmt: Ist es nicht einfach, mehrere Domainnamen auf die Whitelist zu setzen? Schreiben Sie einfach eine reguläre Regel. Wenn das nicht funktioniert, wäre es dann nicht besser, das Access-Control-Allow-Origin-Attribut direkt für mehrere durch Kommas getrennte Domänennamen zu konfigurieren?

So:

res.header('Access-Control-Allow-Origin', '*.666.com'); 

// 或者如下
res.header('Access-Control-Allow-Origin', 'a.666.com,b.666.com,c.666.com');

Ich muss Ihnen leider mitteilen, dass diese Schreibweise ungültig ist. In Node.js kann das Access-Control-Allow-Origin-Attribut im Res-Antwortheader nicht mit regulären Ausdrücken außer (*) übereinstimmen und Domänennamen können nicht durch Kommas getrennt werden. Mit anderen Worten, der Attributwert von Access-Control-Allow-Origin darf nur auf einen einzelnen bestimmten Domänennamen Zeichenfolge oder (*) festgelegt werden.

Da wir mehrere Domänennamen zulassen möchten und nicht bereit sind, den unsicheren Platzhalter * zu verwenden, ist es dann wahr, dass wir CORS nicht für die Whitelist mehrerer Domänennamen konfigurieren können?

CORS mit mehreren Whitelists für Domainnamen ist tatsächlich erreichbar. Es ist nur eine kleine Wendung, das Land zu retten.

CORS-Implementierungsprinzip der Multi-Domain-Whitelist

Spezifische Prinzipien finden Sie im Kerncode der CORS-Bibliothek:

(function () {

 'use strict';

 var assign = require('object-assign');
 var vary = require('vary');

 var defaults = {
 origin: '*',
 methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
 preflightContinue: false,
 optionsSuccessStatus: 204
 };

 function isString(s) {
 return typeof s === 'string' || s instanceof String;
 }

 function isOriginAllowed(origin, allowedOrigin) {
 if (Array.isArray(allowedOrigin)) {
 for (var i = 0; i < allowedOrigin.length; ++i) {
 if (isOriginAllowed(origin, allowedOrigin[i])) {
  return true;
 }
 }
 return false;
 } else if (isString(allowedOrigin)) {
 return origin === allowedOrigin;
 } else if (allowedOrigin instanceof RegExp) {
 return allowedOrigin.test(origin);
 } else {
 return !!allowedOrigin;
 }
 }

 function configureOrigin(options, req) {
 var requestOrigin = req.headers.origin,
 headers = [],
 isAllowed;

 if (!options.origin || options.origin === &#39;*&#39;) {
 // allow any origin
 headers.push([{
 key: &#39;Access-Control-Allow-Origin&#39;,
 value: &#39;*&#39;
 }]);
 } else if (isString(options.origin)) {
 // fixed origin
 headers.push([{
 key: &#39;Access-Control-Allow-Origin&#39;,
 value: options.origin
 }]);
 headers.push([{
 key: &#39;Vary&#39;,
 value: &#39;Origin&#39;
 }]);
 } else {
 isAllowed = isOriginAllowed(requestOrigin, options.origin);
 // reflect origin
 headers.push([{
 key: &#39;Access-Control-Allow-Origin&#39;,
 value: isAllowed ? requestOrigin : false
 }]);
 headers.push([{
 key: &#39;Vary&#39;,
 value: &#39;Origin&#39;
 }]);
 }

 return headers;
 }

 function configureMethods(options) {
 var methods = options.methods;
 if (methods.join) {
 methods = options.methods.join(&#39;,&#39;); // .methods is an array, so turn it into a string
 }
 return {
 key: &#39;Access-Control-Allow-Methods&#39;,
 value: methods
 };
 }

 function configureCredentials(options) {
 if (options.credentials === true) {
 return {
 key: &#39;Access-Control-Allow-Credentials&#39;,
 value: &#39;true&#39;
 };
 }
 return null;
 }

 function configureAllowedHeaders(options, req) {
 var allowedHeaders = options.allowedHeaders || options.headers;
 var headers = [];

 if (!allowedHeaders) {
 allowedHeaders = req.headers[&#39;access-control-request-headers&#39;]; // .headers wasn&#39;t specified, so reflect the request headers
 headers.push([{
 key: &#39;Vary&#39;,
 value: &#39;Access-Control-Request-Headers&#39;
 }]);
 } else if (allowedHeaders.join) {
 allowedHeaders = allowedHeaders.join(&#39;,&#39;); // .headers is an array, so turn it into a string
 }
 if (allowedHeaders && allowedHeaders.length) {
 headers.push([{
 key: &#39;Access-Control-Allow-Headers&#39;,
 value: allowedHeaders
 }]);
 }

 return headers;
 }

 function configureExposedHeaders(options) {
 var headers = options.exposedHeaders;
 if (!headers) {
 return null;
 } else if (headers.join) {
 headers = headers.join(&#39;,&#39;); // .headers is an array, so turn it into a string
 }
 if (headers && headers.length) {
 return {
 key: &#39;Access-Control-Expose-Headers&#39;,
 value: headers
 };
 }
 return null;
 }

 function configureMaxAge(options) {
 var maxAge = options.maxAge && options.maxAge.toString();
 if (maxAge && maxAge.length) {
 return {
 key: &#39;Access-Control-Max-Age&#39;,
 value: maxAge
 };
 }
 return null;
 }

 function applyHeaders(headers, res) {
 for (var i = 0, n = headers.length; i < n; i++) {
 var header = headers[i];
 if (header) {
 if (Array.isArray(header)) {
  applyHeaders(header, res);
 } else if (header.key === &#39;Vary&#39; && header.value) {
  vary(res, header.value);
 } else if (header.value) {
  res.setHeader(header.key, header.value);
 }
 }
 }
 }

 function cors(options, req, res, next) {
 var headers = [],
 method = req.method && req.method.toUpperCase && req.method.toUpperCase();

 if (method === &#39;OPTIONS&#39;) {
 // preflight
 headers.push(configureOrigin(options, req));
 headers.push(configureCredentials(options, req));
 headers.push(configureMethods(options, req));
 headers.push(configureAllowedHeaders(options, req));
 headers.push(configureMaxAge(options, req));
 headers.push(configureExposedHeaders(options, req));
 applyHeaders(headers, res);

 if (options.preflightContinue ) {
 next();
 } else {
 res.statusCode = options.optionsSuccessStatus || defaults.optionsSuccessStatus;
 res.end();
 }
 } else {
 // actual response
 headers.push(configureOrigin(options, req));
 headers.push(configureCredentials(options, req));
 headers.push(configureExposedHeaders(options, req));
 applyHeaders(headers, res);
 next();
 }
 }

 function middlewareWrapper(o) {
 if (typeof o !== &#39;function&#39;) {
 o = assign({}, defaults, o);
 }

 // if options are static (either via defaults or custom options passed in), wrap in a function
 var optionsCallback = null;
 if (typeof o === &#39;function&#39;) {
 optionsCallback = o;
 } else {
 optionsCallback = function (req, cb) {
 cb(null, o);
 };
 }

 return function corsMiddleware(req, res, next) {
 optionsCallback(req, function (err, options) {
 if (err) {
  next(err);
 } else {
  var originCallback = null;
  if (options.origin && typeof options.origin === &#39;function&#39;) {
  originCallback = options.origin;
  } else if (options.origin) {
  originCallback = function (origin, cb) {
  cb(null, options.origin);
  };
  }

  if (originCallback) {
  originCallback(req.headers.origin, function (err2, origin) {
  if (err2 || !origin) {
  next(err2);
  } else {
  var corsOptions = Object.create(options);
  corsOptions.origin = origin;
  cors(corsOptions, req, res, next);
  }
  });
  } else {
  next();
  }
 }
 });
 };
 }

 // can pass either an options hash, an options delegate, or nothing
 module.exports = middlewareWrapper;

}());

Das Implementierungsprinzip ist wie folgt:

Da das Access-Control-Allow-Origin-Attribut klargestellt hat, dass es nicht mehrere Domänennamen geben kann gesetzt, dann müssen wir diesen Weg aufgeben.

Die beliebteste und effektivste Methode besteht darin, auf der Serverseite zu bestimmen, ob der Origin-Attributwert (req.header.origin) im angeforderten Header in unserer Domainnamen-Whitelist enthalten ist. Wenn es sich in der Whitelist befindet, setzen wir Access-Control-Allow-Origin auf den aktuellen Origin-Wert, der die Anforderung eines einzelnen Domänennamens von Access-Control-Allow-Origin erfüllt und sicherstellt, dass auf die aktuelle Anforderung zugegriffen wird nicht in der Whitelist enthalten ist, wird eine Fehlermeldung zurückgegeben.

Auf diese Weise übertragen wir die Verifizierung domänenübergreifender Anfragen vom Browser auf den Server. Die Überprüfung der Ursprungszeichenfolge entspricht der Überprüfung einer regulären Zeichenfolge. Wir können nicht nur die Überprüfung der Array -Liste verwenden, sondern auch den regulären Abgleich.

Der spezifische Code lautet wie folgt:

// 判断origin是否在域名白名单列表中
function isOriginAllowed(origin, allowedOrigin) {
 if (_.isArray(allowedOrigin)) {
 for(let i = 0; i < allowedOrigin.length; i++) {
  if(isOriginAllowed(origin, allowedOrigin[i])) {
  return true;
  }
 }
 return false;
 } else if (_.isString(allowedOrigin)) {
 return origin === allowedOrigin;
 } else if (allowedOrigin instanceof RegExp) {
 return allowedOrigin.test(origin);
 } else {
 return !!allowedOrigin;
 }
}


const ALLOW_ORIGIN = [ // 域名白名单
 &#39;*.233.666.com&#39;,
 &#39;hello.world.com&#39;,
 &#39;hello..*.com&#39;
];

app.post(&#39;a/b&#39;, function (req, res, next) {
 let reqOrigin = req.headers.origin; // request响应头的origin属性

 // 判断请求是否在域名白名单内
 if(isOriginAllowed(reqOrigin, ALLOW_ORIGIN)) {
 // 设置CORS为请求的Origin值
 res.header("Access-Control-Allow-Origin", reqOrigin);
 res.header(&#39;Access-Control-Allow-Credentials&#39;, &#39;true&#39;);

 // 你的业务代码逻辑代码 ...
 // ...
 } else {
 res.send({ code: -2, msg: &#39;非法请求&#39; });
 }
});

Oh ja, es ist perfekt~

Zusammenfassung

Das obige ist der detaillierte Inhalt vonBeispielcode-Freigabe für Node.js zum Einrichten einer Whitelist für mehrere Domänennamen in domänenübergreifenden CORS-Anfragen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!