xss - npm Package Compare versions

Comparing version 0.0.9 to 0.1.1

benchmark/vs_validator.js

@@ -13,3 +13,3 @@ /**
 var timeStart = Date.now();
-for (var i = 0; i < 100; i++) {
+for (var i = 0; i < 200; i++) {
   var ret = sanitize(html).xss();
@@ -16,0 +16,0 @@ }

build/xss.js

 ;(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
 /**
- * 过滤XSS攻击
+ * 默认配置
  *
@@ -8,7 +8,5 @@ * @author 老雷<[e-mail]>
 
-/*
- * 默认HTML标签白名单
- * 标签名=>属性列表
- */
-var defaultWhiteList = {
+
+// 默认白名单
+var whiteList = {
   h1:     [],
@@ -53,28 +51,72 @@ h2:     [],
 
-// 正则表达式
-var REGEXP_LT = /</g;
-var REGEXP_GT = />/g;
-var REGEXP_QUOTE = /"/g;
-var REGEXP_ATTR_NAME = /[^a-zA-Z0-9_:\.\-]/img;
-var REGEXP_ATTR_VALUE_1 = /&#([a-zA-Z0-9]*);?/img;
-var REGEXP_ATTR_VALUE_COLON = /&colon;?/img;
-var REGEXP_ATTR_VALUE_NEWLINE = /&newline;?/img;
-var REGEXP_DEFAULT_ON_TAG_ATTR_1 = /\/\*|\*\//mg;
-var REGEXP_DEFAULT_ON_TAG_ATTR_2 = /^[\s"'`]*((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_3 = /\/\*|\*\//mg;
-var REGEXP_DEFAULT_ON_TAG_ATTR_4 = /((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_5 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_6 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:\s*image\//ig;
+/**
+ * 匹配到标签时的处理方法
+ *
+ * @param {String} tag
+ * @param {String} html
+ * @param {Object} options
+ * @return {String}
+ */
+function onTag (tag, html, options) {
+  // do nothing
+}
 
+/**
+ * 匹配到不在白名单上的标签时的处理方法
+ *
+ * @param {String} tag
+ * @param {String} html
+ * @param {Object} options
+ * @return {String}
+ */
+function onIgnoreTag (tag, html, options) {
+  // do nothing
+}
 
 /**
- * 过滤属性值
+ * 匹配到标签属性时的处理方法
  *
- * @param {String} tag 标签名
- * @param {String} attr 属性名
- * @param {String} value 属性值
- * @return {String} 若不需要修改属性值，不返回任何值
+ * @param {String} tag
+ * @param {String} name
+ * @param {String} value
+ * @return {String}
  */
-function defaultOnTagAttr (tag, attr, value) {
-  if (attr === 'href' || attr === 'src') {
+function onTagAttr (tag, name, value) {
+  // do nothing
+}
+
+/**
+ * 匹配到不在白名单上的标签属性时的处理方法
+ *
+ * @param {String} tag
+ * @param {String} name
+ * @param {String} value
+ * @return {String}
+ */
+function onIgnoreTagAttr (tag, name, value) {
+  // do nothing
+}
+
+/**
+ * HTML转义
+ *
+ * @param {String} html
+ */
+function escapeHtml (html) {
+  return html.replace(REGEXP_LT, '&lt;').replace(REGEXP_GT, '&gt;');
+}
+
+/**
+ * 安全的标签属性值
+ *
+ * @param {String} tag
+ * @param {String} name
+ * @param {String} value
+ * @return {String}
+ */
+function safeAttrValue (tag, name, value) {
+  // 转换为友好的属性值，再做判断
+  value = friendlyAttrValue(value);
+
+  if (name === 'href' || name === 'src') {
     // 过滤 href 和 src 属性
@@ -100,3 +142,3 @@ // javascript:
     }
-  } else if (attr === 'style') {
+  } else if (name === 'style') {
     // 过滤 style 属性 （这个xss漏洞较老了，可能已经不适用）
@@ -114,42 +156,31 @@ // javascript:
   }
-}
 
-/**
- * 过滤非白名单的标签
- *
- * @param {String} tag 标签名
- * @param {String} html 标签HTML代码（包括属性值）
- * @param {Object} options 更多属性：
- *                   position：在返回的HTML代码中的开始位置
- *                   originalPosition：在原HTML代码中的开始位置
- *                   isClosing：是否为闭合标签，如</a>
- * @return {String} 若不返回任何值，则默认替换<>为&lt;&gt;
- */
-function defaultOnIgnoreTag (tag, html, options) {
-  return noTag(html);
+  // 输出时需要转义<>"
+  value = escapeAttrValue(value);
+  return value;
 }
 
+// 正则表达式
+var REGEXP_LT = /</g;
+var REGEXP_GT = />/g;
+var REGEXP_QUOTE = /"/g;
+var REGEXP_QUOTE_2 = /&quot;/g;
+var REGEXP_ATTR_VALUE_1 = /&#([a-zA-Z0-9]*);?/img;
+var REGEXP_ATTR_VALUE_COLON = /&colon;?/img;
+var REGEXP_ATTR_VALUE_NEWLINE = /&newline;?/img;
+var REGEXP_DEFAULT_ON_TAG_ATTR_1 = /\/\*|\*\//mg;
+var REGEXP_DEFAULT_ON_TAG_ATTR_2 = /^[\s"'`]*((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
+var REGEXP_DEFAULT_ON_TAG_ATTR_3 = /\/\*|\*\//mg;
+var REGEXP_DEFAULT_ON_TAG_ATTR_4 = /((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
+var REGEXP_DEFAULT_ON_TAG_ATTR_5 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:/ig;
+var REGEXP_DEFAULT_ON_TAG_ATTR_6 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:\s*image\//ig;
 
 /**
- * 转换<>为&lt; &gt
+ * 对双引号进行转义
  *
- * @param {String} text
- * @return {String}
- */
-function noTag (text) {
-  return text.replace(REGEXP_LT, '&lt;').replace(REGEXP_GT, '&gt;');
-}
-
-/**
- * 清除不可见字符
- *
  * @param {String} str
- * @return {String}
+ * @return {String} str
  */
-function clearNonPrintableCharacter (str) {
-  var str2 = '';
-  for (var i = 0, len = str.length; i < len; i++) {
-    str2 += str.charCodeAt(i) < 32 ? ' ' : str.charAt(i);
-  }
-  return str2.trim();
+function escapeQuote (str) {
+  return str.replace(REGEXP_QUOTE, '&quote;');
 }
@@ -163,4 +194,4 @@
  */
-function escapeQuotes (str) {
-  return str.replace(REGEXP_QUOTE, '&quote;');
+function unescapeQuote (str) {
+  return str.replace(REGEXP_QUOTE_2, '"');
 }
@@ -194,3 +225,3 @@
 /**
- * 对属性值进行转义
+ * 清除不可见字符
  *
@@ -200,18 +231,21 @@ * @param {String} str
  */
-function safeAttrValue (str) {
-  // 去掉两边的空白字符
-  str = str.trim();
+function clearNonPrintableCharacter (str) {
+  var str2 = '';
+  for (var i = 0, len = str.length; i < len; i++) {
+    str2 += str.charCodeAt(i) < 32 ? ' ' : str.charAt(i);
+  }
+  return str2.trim();
+}
 
-  // 过滤双引号
-  str = escapeQuotes(str);
-
-  // 转换HTML实体编码
-  str = escapeHtmlEntities(str);
-
-  // 转换危险的HTML5新增实体编码
-  str = escapeDangerHtml5Entities(str);
-
-  // 清除不可见字符
-  str = clearNonPrintableCharacter(str);
-
+/**
+ * 将标签的属性值转换成一般字符，便于分析
+ *
+ * @param {String} str
+ * @return {String}
+ */
+function friendlyAttrValue (str) {
+  str = unescapeQuote(str);             // 双引号
+  str = escapeHtmlEntities(str);         // 转换HTML实体编码
+  str = escapeDangerHtml5Entities(str);  // 转换危险的HTML5新增实体编码
+  str = clearNonPrintableCharacter(str); // 清除不可见字符
   return str;
@@ -221,176 +255,207 @@ }
 /**
- * XSS过滤对象
+ * 转义用于输出的标签属性值
  *
- * @param {Object} options 选项：whiteList, onTagAttr, onIgnoreTag
+ * @param {String} str
+ * @return {String}
  */
-function FilterXSS (options) {
-  'use strict';
+function escapeAttrValue (str) {
+  str = escapeQuote(str);
+  str = escapeHtml(str);
+  return str;
+}
 
-  this.options = options = options || {};
-  this.whiteList = options.whiteList || exports.whiteList;
-  this.onTagAttr = options.onTagAttr || exports.onTagAttr;
-  this.onIgnoreTag = options.onIgnoreTag || exports.onIgnoreTag;
+/**
+ * 去掉不在白名单中的标签onIgnoreTag处理方法
+ */
+function onIgnoreTagStripAll () {
+  return '';
 }
 
 /**
- * 过滤不合法的属性
+ * 删除标签体
  *
- * @param {String} tagName 标签名称
- * @param {String} attrs 标签属性部分
- * @return {String}
+ * @param {array} tags 要删除的标签列表
+ * @param {function} next 对不在列表中的标签的处理函数，可选
  */
-FilterXSS.prototype.filterAttributes = function (tagName, attrs) {
-  'use strict';
+function StripTagBody (tags, next) {
+  if (typeof(next) !== 'function') {
+    next = function () {};
+  }
 
-  tagName = tagName.toLowerCase();
-  var me = this;
-  var whites = this.whiteList[tagName];
-  var lastPos = 0;
-  var _attrs = '';
-  var tmpName = false;
-  var hasSprit = false;
+  var isRemoveAllTag = !Array.isArray(tags);
+  function isRemoveTag (tag) {
+    if (isRemoveAllTag) return true;
+    return tags.indexOf(tag) !== -1;
+  }
 
-  var addAttr = function (name, value) {
-    name =  name.trim();
-    if (!hasSprit && name === '/') {
-      hasSprit = true;
-      return;
-    }
-    name = name.replace(REGEXP_ATTR_NAME, '').toLowerCase();
-    if (name.length < 1) return;
-    if (whites.indexOf(name) !== -1) {
-      if (value) {
-        // 先对属性值进行转义
-        value = safeAttrValue(value);
-        // 使用用户自定义的 onTagAttr 再过滤
-        var newValue = me.onTagAttr(tagName, name, value);
-        if (typeof newValue !== 'undefined') {
-          value = newValue;
-        }
-      }
-      _attrs += name + (value ? '="' + value + '"' : '') + ' ';
-    }
-  };
+  var removeList = [];   // 要删除的位置范围列表
+  var posStart = false;  // 当前标签开始位置
 
-  for (var i = 0, len = attrs.length; i < len; i++) {
-    var c = attrs.charAt(i),v;
-    if (tmpName === false && c === '=') {
-      tmpName = attrs.slice(lastPos, i);
-      lastPos = i + 1;
-      continue;
-    }
-    if (tmpName !== false) {
-      if (i === lastPos && (c === '"' || c === "'")) {
-        var j = attrs.indexOf(c, i + 1);
-        if (j === -1) {
-          break;
+  return {
+    onIgnoreTag: function (tag, html, options) {
+      if (isRemoveTag(tag)) {
+        if (options.isClosing) {
+          var ret = '[/removed]';
+          var end = options.position + ret.length;
+          removeList.push([posStart || options.position, end]);
+          posStart = false;
+          return ret;
         } else {
-          v = attrs.slice(lastPos + 1, j).trim();
-          addAttr(tmpName, v);
-          tmpName = false;
-          i = j;
-          lastPos = i + 1;
-          continue;
+          if (!posStart) {
+            posStart = options.position;
+          }
+          return '[removed]';
         }
-      }
-    }
-    if (c === ' ') {
-      v = attrs.slice(lastPos, i).trim();
-      if (tmpName === false) {
-        addAttr(v);
       } else {
-        addAttr(tmpName, v);
+        return next(tag, html, options);
       }
-      tmpName = false;
-      lastPos = i + 1;
-      continue;
+    },
+    remove: function (html) {
+      var rethtml = '';
+      var lastPos = 0;
+      removeList.forEach(function (pos) {
+        rethtml += html.slice(lastPos, pos[0]);
+        lastPos = pos[1];
+      });
+      rethtml += html.slice(lastPos);
+      return rethtml;
     }
-  }
+  };
+};
 
-  if (lastPos < attrs.length) {
-    if (tmpName === false) {
-      addAttr(attrs.slice(lastPos));
-    } else {
-      addAttr(tmpName, attrs.slice(lastPos));
-    }
-  }
-  if (hasSprit) _attrs += '/';
 
-  return _attrs.trim();
-};
+exports.whiteList = whiteList;
+exports.onTag = onTag;
+exports.onIgnoreTag = onIgnoreTag;
+exports.onTagAttr = onTagAttr;
+exports.onIgnoreTagAttr = onIgnoreTagAttr;
+exports.safeAttrValue = safeAttrValue;
+exports.escapeHtml = escapeHtml;
+exports.escapeQuote = escapeQuote;
+exports.unescapeQuote = unescapeQuote;
+exports.escapeHtmlEntities = escapeHtmlEntities;
+exports.escapeDangerHtml5Entities = escapeDangerHtml5Entities;
+exports.clearNonPrintableCharacter = clearNonPrintableCharacter;
+exports.friendlyAttrValue = friendlyAttrValue;
+exports.escapeAttrValue = escapeAttrValue;
+exports.onIgnoreTagStripAll = onIgnoreTagStripAll;
+exports.StripTagBody = StripTagBody;
 
+},{}],2:[function(require,module,exports){
 /**
- * 检查标签是否合法
+ * 模块入口
  *
- * @param {String} tag 标签文本，如“<a”
- * @param {Number} currentPos 原HTML的当前位置
- * @param {Number} targetPos 生成的HTML的当前位置
+ * @author 老雷<[e-mail]>
  */
-FilterXSS.prototype.addNewTag = function (tag, currentPos, targetPos) {
-  'use strict';
 
-  var rethtml = '';
-  var tagName;
-  var hasSprit;
-  var spos = tag.slice(0, 2) === '</' ? 2 : 1;
+var DEFAULT = require('./default');
+var parser = require('./parser');
+var FilterXSS = require('./xss');
 
-  var i = tag.indexOf(' ');
-  if (i === -1) {
-    tagName = tag.slice(spos, tag.length - 1).trim();
-  } else {
-    tagName = tag.slice(spos, i + 1).trim();
-  }
-  tagName = tagName.toLowerCase();
 
-  // 检查标签是否以“/”结尾
-  if (tagName.slice(-1) === '/') {
-    tagName = tagName.slice(0, -1);
-    hasSprit = true;
-  } else {
-    hasSprit = false;
+/**
+ * XSS过滤
+ *
+ * @param {String} html 要过滤的HTML代码
+ * @param {Object} options 选项：whiteList, onTag, onTagAttr, onIgnoreTag, onIgnoreTagAttr, safeAttrValue, escapeHtml
+ * @return {String}
+ */
+function filterXSS (html, options) {
+  var xss = new FilterXSS(options);
+  return xss.process(html);
+}
+
+
+// 输出
+exports = module.exports = filterXSS;
+exports.FilterXSS = FilterXSS;
+for (var i in DEFAULT) exports[i] = DEFAULT[i];
+for (var i in parser) exports[i] = parser[i];
+
+
+// 在浏览器端使用
+if (typeof window !== 'undefined') {
+  // 低版本浏览器支持
+  if (!Array.indexOf) {
+    Array.prototype.indexOf = function (item) {
+      for(var i=0;i<this.length;i++){
+        if(this[i] == item) return i;
+      }
+      return -1;
+    };
   }
+  if (!Array.forEach) {
+    Array.prototype.forEach = function (fn) {
+      for (var i = 0; i < this.length; i++) fn(this[i], i, this);
+    };
+  }
+  if(!String.trim){
+    String.prototype.trim = function () {
+      return this.replace(/(^\s*)|(\s*$)/g, '');
+    };
+  }
+  // 输出
+  window.filterXSS = module.exports;
+}
 
-  if (tagName in this.whiteList) {
-    // 过滤不合法的属性
-    if (i === -1) {
-      rethtml += tag.slice(0, spos) + tagName + (hasSprit ? ' />' : '>');
-    } else {
-      var attrs = this.filterAttributes(tagName, tag.slice(i + 1, tag.length - 1).trim());
-      rethtml += tag.slice(0, spos) + tagName + (attrs.length > 0 ? ' ' + attrs : '') + '>';
-    }
+},{"./default":1,"./parser":3,"./xss":4}],3:[function(require,module,exports){
+/**
+ * 简单 HTML Parser
+ *
+ * @author 老雷<[e-mail]>
+ */
+
+
+/**
+ * 获取标签的名称
+ *
+ * @param {String} html 如：'<a hef="#">'
+ * @return {String}
+ */
+function getTagName (html) {
+  var i = html.indexOf(' ');
+  if (i === -1) {
+    var tagName = html.slice(1, -1);
   } else {
-    // 过滤不合法的标签
-    var options = {
-      isClosing:        (spos === 2),
-      position:         targetPos,
-      originalPosition: currentPos - tag.length + 1
-    };
-    var tagHtml = this.onIgnoreTag(tagName, tag, options);
-    if (typeof tagHtml === 'undefined') {
-      tagHtml = noTag(tag);
-    }
-    rethtml += tagHtml;
+    var tagName = html.slice(1, i + 1);
   }
+  tagName = tagName.trim().toLowerCase();
+  if (tagName[0] === '/') tagName = tagName.slice(1);
+  if (tagName[tagName.length - 1] === '/') tagName = tagName.slice(0, -1);
+  return tagName;
+}
 
-  return rethtml;
-};
+/**
+ * 是否为闭合标签
+ *
+ * @param {String} html 如：'<a hef="#">'
+ * @return {Boolean}
+ */
+function isClosing (html) {
+  return (html.slice(0, 2) === '</');
+}
 
 /**
- * 开始处理
+ * 分析HTML代码，调用相应的函数处理，返回处理后的HTML
  *
  * @param {String} html
+ * @param {Function} onTag 处理标签的函数
+ *   参数格式： function (sourcePosition, position, tag, html, isClosing)
+ * @param {Function} escapeHtml 对HTML进行转义的韩松
  * @return {String}
  */
-FilterXSS.prototype.process = function (html) {
-  'use strict';
+function parseTag (html, onTag, escapeHtml) {
+  'user strict';
 
-  var rethtml = '';
-  var lastPos = 0;
-  var tagStart = false;
-  var quoteStart = false;
-  var currentPos = 0;
-  var len = 0;
+  var rethtml = '';        // 待返回的HTML
+  var lastPos = 0;         // 上一个标签结束位置
+  var tagStart = false;    // 当前标签开始位置
+  var quoteStart = false;  // 引号开始位置
+  var currentPos = 0;      // 当前位置
+  var len = html.length;   // HTML长度
+  var currentHtml = '';    // 当前标签的HTML代码
+  var currentTagName = ''; // 当前标签的名称
 
   // 逐个分析字符
-  for (currentPos = 0, len = html.length; currentPos < len; currentPos++) {
+  for (currentPos = 0; currentPos < len; currentPos++) {
     var c = html.charAt(currentPos);
@@ -405,3 +470,3 @@ if (tagStart === false) {
         if (c === '<') {
-          rethtml += noTag(html.slice(lastPos, currentPos));
+          rethtml += escapeHtml(html.slice(lastPos, currentPos));
           tagStart = currentPos;
@@ -412,4 +477,10 @@ lastPos = currentPos;
         if (c === '>') {
-          rethtml += noTag(html.slice(lastPos, tagStart));
-          rethtml += this.addNewTag(html.slice(tagStart, currentPos + 1), currentPos, rethtml.length);
+          rethtml += escapeHtml(html.slice(lastPos, tagStart));
+          currentHtml = html.slice(tagStart, currentPos + 1);
+          currentTagName = getTagName(currentHtml);
+          rethtml += onTag(tagStart,
+                           rethtml.length,
+                           currentTagName,
+                           currentHtml,
+                           isClosing(currentHtml));
           lastPos = currentPos + 1;
@@ -432,105 +503,257 @@ tagStart = false;
   if (lastPos < html.length) {
-    rethtml += noTag(html.substr(lastPos));
+    rethtml += escapeHtml(html.substr(lastPos));
   }
 
   return rethtml;
-};
+}
 
+// 不符合属性名称规则的正则表达式
+var REGEXP_ATTR_NAME = /[^a-zA-Z0-9_:\.\-]/img;
+
 /**
- * XSS过滤
+ * 分析标签HTML代码，调用相应的函数处理，返回HTML
  *
- * @param {String} html 要过滤的HTML代码
- * @param {Object} options 选项：whiteList, onTagAttr, onIgnoreTag
+ * @param {String} html 如标签'<a href="#" target="_blank">' 则为 'href="#" target="_blank"'
+ * @param {Function} onAttr 处理属性值的函数
+ *   函数格式： function (name, value)
  * @return {String}
  */
-function filterXSS (html, options) {
-  var xss = new FilterXSS(options);
-  return xss.process(html);
-}
+function parseAttr (html, onAttr) {
+  'user strict';
 
-// 默认配置
-exports = module.exports = filterXSS;
-exports.FilterXSS = FilterXSS;
-exports.whiteList = defaultWhiteList;
-exports.onTagAttr = defaultOnTagAttr;
-exports.onIgnoreTag = defaultOnIgnoreTag;
+  var lastPos = 0;        // 当前位置
+  var retAttrs = [];      // 待返回的属性列表
+  var tmpName = false;    // 临时属性名称
+  var len = html.length;  // HTML代码长度
 
-// 工具函数
-exports.utils = require('./utils');
+  function addAttr (name, value) {
+    name =  name.trim();
+    name = name.replace(REGEXP_ATTR_NAME, '').toLowerCase();
+    if (name.length < 1) return;
+    retAttrs.push(onAttr(name, value || ''));
+  };
 
-// 在浏览器端使用
-if (typeof window !== 'undefined') {
-  if(!Array.indexOf){
-    Array.prototype.indexOf = function(item){
-        for(var i=0;i<this.length;i++){
-            if(this[i] == item) return i;
+  // 逐个分析字符
+  for (var i = 0; i < len; i++) {
+    var c = html.charAt(i),v;
+    if (tmpName === false && c === '=') {
+      tmpName = html.slice(lastPos, i);
+      lastPos = i + 1;
+      continue;
+    }
+    if (tmpName !== false) {
+      if (i === lastPos && (c === '"' || c === "'")) {
+        var j = html.indexOf(c, i + 1);
+        if (j === -1) {
+          break;
+        } else {
+          v = html.slice(lastPos + 1, j).trim();
+          addAttr(tmpName, v);
+          tmpName = false;
+          i = j;
+          lastPos = i + 1;
+          continue;
         }
-        return -1;
-    };
+      }
+    }
+    if (c === ' ') {
+      v = html.slice(lastPos, i).trim();
+      if (tmpName === false) {
+        addAttr(v);
+      } else {
+        addAttr(tmpName, v);
+      }
+      tmpName = false;
+      lastPos = i + 1;
+      continue;
+    }
   }
-  if(!Array.forEach){
-    Array.prototype.forEach = function(fn){
-       for(var i=0;i<this.length;i++) fn(this[i],i,this);
-    };
+
+  if (lastPos < html.length) {
+    if (tmpName === false) {
+      addAttr(html.slice(lastPos));
+    } else {
+      addAttr(tmpName, html.slice(lastPos));
+    }
   }
-  if(!String.trim){
-    String.prototype.trim = function(){
-        return this.replace(/(^\s*)|(\s*$)/g,"");
+
+  return retAttrs.join(' ').trim();
+}
+
+exports.parseTag = parseTag;
+exports.parseAttr = parseAttr;
+
+},{}],4:[function(require,module,exports){
+/**
+ * 过滤XSS
+ *
+ * @author 老雷<[e-mail]>
+ */
+
+var DEFAULT = require('./default');
+var parser = require('./parser');
+var parseTag = parser.parseTag;
+var parseAttr = parser.parseAttr;
+
+
+/**
+ * 返回值是否为空
+ *
+ * @param {Object} obj
+ * @return {Boolean}
+ */
+function isNull (obj) {
+  return (obj === undefined || obj === null);
+}
+
+/**
+ * 取标签内的属性列表字符串
+ *
+ * @param {String} html
+ * @return {Object}
+ *   - {String} html
+ *   - {Boolean} closing
+ */
+function getAttrs (html) {
+  var i = html.indexOf(' ');
+  if (i === -1) {
+    return {
+      html:    '',
+      closing: (html[html.length - 2] === '/')
     };
   }
-  window.filterXSS = module.exports;
+  html = html.slice(i + 1, -1).trim();
+  var isClosing = (html[html.length - 1] === '/');
+  if (isClosing) html = html.slice(0, -1).trim();
+  return {
+    html:    html,
+    closing: isClosing
+  };
 }
 
-},{"./utils":2}],2:[function(require,module,exports){
 /**
- * 工具函数
+ * XSS过滤对象
  *
- * @author 老雷<[e-mail]>
+ * @param {Object} options 选项：whiteList, onTag, onTagAttr, onIgnoreTag,
+ *                               onIgnoreTagAttr, safeAttrValue, escapeHtml
+ *                               stripIgnoreTagBody
  */
+function FilterXSS (options) {
+  options = options || {};
 
-var utils = module.exports;
+  if (options.stripIgnoreTag) {
+    if (options.onIgnoreTag) {
+      console.error('Notes: cannot use these two options "stripIgnoreTag" and "onIgnoreTag" at the same time');
+    }
+    options.onIgnoreTag = DEFAULT.onIgnoreTagStripAll;
+  }
 
+  options.whiteList = options.whiteList || DEFAULT.whiteList;
+  options.onTag = options.onTag || DEFAULT.onTag;
+  options.onTagAttr = options.onTagAttr || DEFAULT.onTagAttr;
+  options.onIgnoreTag = options.onIgnoreTag || DEFAULT.onIgnoreTag;
+  options.onIgnoreTagAttr = options.onIgnoreTagAttr || DEFAULT.onIgnoreTagAttr;
+  options.safeAttrValue = options.safeAttrValue || DEFAULT.safeAttrValue;
+  options.escapeHtml = options.escapeHtml || DEFAULT.escapeHtml;
+  this.options = options;
+}
+
 /**
- * 过滤代码块
+ * 开始处理
  *
- * @param {array} tags 要隐藏的标签列表
- * @param {function} next 对不在列表中的标签的处理函数
+ * @param {String} html
+ * @return {String}
  */
-utils.tagFilter = function (tags, next) {
-  if (typeof(next) !== 'function') {
-    next = function () {};
+FilterXSS.prototype.process = function (html) {
+  var me = this;
+  var options = me.options;
+  var whiteList = options.whiteList;
+  var onTag = options.onTag;
+  var onIgnoreTag = options.onIgnoreTag;
+  var onTagAttr = options.onTagAttr;
+  var onIgnoreTagAttr = options.onIgnoreTagAttr;
+  var safeAttrValue = options.safeAttrValue;
+  var escapeHtml = options.escapeHtml
+
+  // 如果开启了stripIgnoreTagBody
+  if (options.stripIgnoreTagBody) {
+    var stripIgnoreTagBody = DEFAULT.StripTagBody(options.stripIgnoreTagBody, onIgnoreTag);
+    onIgnoreTag = stripIgnoreTagBody.onIgnoreTag;
+  } else {
+    stripIgnoreTagBody = false;
   }
-  var hidden = [];
-  var posStart = false;
-  return {
-    onIgnoreTag: function (tag, html, options) {
-      if (tags.indexOf(tag) !== -1) {
-        var ret = '[removed]';
-        if (posStart !== false && options.isClosing) {
-          var end = options.position + ret.length;
-          hidden.push([posStart, end]);
-          posStart = false;
+
+  var retHtml = parseTag(html, function (sourcePosition, position, tag, html, isClosing) {
+    var info = {
+      sourcePosition: sourcePosition,
+      position:       position,
+      isClosing:      isClosing,
+      isWhite:        (tag in whiteList)
+    };
+
+    // 调用onTag处理
+    var ret = onTag(tag, html, info);
+    if (!isNull(ret)) return ret;
+
+    // 默认标签处理方法
+    if (info.isWhite) {
+      // 白名单标签，解析标签属性
+      // 如果是闭合标签，则不需要解析属性
+      if (info.isClosing) {
+        return '</' + tag + '>';
+      }
+
+      var attrs = getAttrs(html);
+      var whiteAttrList = whiteList[tag];
+      var attrsHtml = parseAttr(attrs.html, function (name, value) {
+
+        // 调用onTagAttr处理
+        var isWhiteAttr = (whiteAttrList.indexOf(name) !== -1);
+        var ret = onTagAttr(tag, name, value, isWhiteAttr);
+        if (!isNull(ret)) return ret;
+
+        // 默认的属性处理方法
+        if (isWhiteAttr) {
+          // 白名单属性，调用onIgnoreTagAttr过滤属性值
+          value = safeAttrValue(tag, name, value);
+          if (value) {
+            return name + '="' + value + '"';
+          } else {
+            return name;
+          }
         } else {
-          posStart = options.position;
+          // 非白名单属性，调用onIgnoreTagAttr处理
+          var ret = onIgnoreTagAttr(tag, name, value, isWhiteAttr);
+          if (!isNull(ret)) return ret;
+          return;
         }
-        return ret;
-      } else {
-        return next(tag, html, options);
-      }
-    },
-    filter: function (html) {
-      var rethtml = '';
-      var lastPos = 0;
-      hidden.forEach(function (pos) {
-        rethtml += html.slice(lastPos, pos[0]);
-        lastPos = pos[1];
       });
-      rethtml += html.slice(lastPos);
-      return rethtml;
+
+      // 构造新的标签代码
+      var html = '<' + tag;
+      if (attrsHtml) html += ' ' + attrsHtml;
+      if (attrs.closing) html += ' /';
+      html += '>';
+      return html;
+
+    } else {
+      // 非白名单标签，调用onIgnoreTag处理
+      var ret = onIgnoreTag(tag, html, info);
+      if (!isNull(ret)) return ret;
+      return escapeHtml(html);
     }
-  };
+
+  }, escapeHtml);
+
+  // 如果开启了stripIgnoreTagBody，需要对结果再进行处理
+  if (stripIgnoreTagBody) {
+    retHtml = stripIgnoreTagBody.remove(retHtml);
+  }
+
+  return retHtml;
 };
 
 
-},{}]},{},[1])
+module.exports = FilterXSS;
+},{"./default":1,"./parser":3}]},{},[2])
 ;

lib/cli.js

 /**
  * 命令行测试工具
+ *
+ * @author 老雷<[e-mail]>
  */
@@ -4,0 +6,0 @@

lib/index.js

 /**
- * 过滤XSS攻击
+ * 模块入口
  *
@@ -7,427 +7,12 @@ * @author 老雷<[e-mail]>
 
-/*
- * 默认HTML标签白名单
- * 标签名=>属性列表
- */
-var defaultWhiteList = {
-  h1:     [],
-  h2:     [],
-  h3:     [],
-  h4:     [],
-  h5:     [],
-  h6:     [],
-  hr:     [],
-  span:   [],
-  strong: [],
-  b:      [],
-  i:      [],
-  br:     [],
-  p:      [],
-  pre:    [],
-  code:   [],
-  a:      ['target', 'href', 'title'],
-  img:    ['src', 'alt', 'title', 'width', 'height'],
-  div:    [],
-  table:  ['width', 'border'],
-  tr:     ['rowspan'],
-  td:     ['width', 'colspan'],
-  th:     ['width', 'colspan'],
-  tbody:  [],
-  thead:  [],
-  ul:     [],
-  li:     [],
-  ol:     [],
-  dl:     [],
-  dt:     [],
-  em:     [],
-  cite:   [],
-  section:[],
-  header: [],
-  footer: [],
-  blockquote: [],
-  audio:  ['autoplay', 'controls', 'loop', 'preload', 'src'],
-  video:  ['autoplay', 'controls', 'loop', 'preload', 'src', 'height', 'width']
-};
+var DEFAULT = require('./default');
+var parser = require('./parser');
+var FilterXSS = require('./xss');
 
-// 正则表达式
-var REGEXP_LT = /</g;
-var REGEXP_GT = />/g;
-var REGEXP_QUOTE = /"/g;
-var REGEXP_ATTR_NAME = /[^a-zA-Z0-9_:\.\-]/img;
-var REGEXP_ATTR_VALUE_1 = /&#([a-zA-Z0-9]*);?/img;
-var REGEXP_ATTR_VALUE_COLON = /&colon;?/img;
-var REGEXP_ATTR_VALUE_NEWLINE = /&newline;?/img;
-var REGEXP_DEFAULT_ON_TAG_ATTR_1 = /\/\*|\*\//mg;
-var REGEXP_DEFAULT_ON_TAG_ATTR_2 = /^[\s"'`]*((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_3 = /\/\*|\*\//mg;
-var REGEXP_DEFAULT_ON_TAG_ATTR_4 = /((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_5 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:/ig;
-var REGEXP_DEFAULT_ON_TAG_ATTR_6 = /^[\s"'`]*(d\s*a\s*t\s*a\s*)\:\s*image\//ig;
 
-
 /**
- * 过滤属性值
- *
- * @param {String} tag 标签名
- * @param {String} attr 属性名
- * @param {String} value 属性值
- * @return {String} 若不需要修改属性值，不返回任何值
- */
-function defaultOnTagAttr (tag, attr, value) {
-  if (attr === 'href' || attr === 'src') {
-    // 过滤 href 和 src 属性
-    // javascript:
-    REGEXP_DEFAULT_ON_TAG_ATTR_1.lastIndex = 0;
-    if (REGEXP_DEFAULT_ON_TAG_ATTR_1.test(value)) {
-      return '#';
-    }
-    // /*注释*/
-    REGEXP_DEFAULT_ON_TAG_ATTR_2.lastIndex = 0;
-    if (REGEXP_DEFAULT_ON_TAG_ATTR_2.test(value)) {
-      return '#';
-    }
-    // data:
-    REGEXP_DEFAULT_ON_TAG_ATTR_5.lastIndex = 0;
-    if (REGEXP_DEFAULT_ON_TAG_ATTR_5.test(value)) {
-      // 允许 data: image/* 类型
-      REGEXP_DEFAULT_ON_TAG_ATTR_6.lastIndex = 0;
-      if (!REGEXP_DEFAULT_ON_TAG_ATTR_6.test(value)) {
-        return '#';
-      }
-    }
-  } else if (attr === 'style') {
-    // 过滤 style 属性 （这个xss漏洞较老了，可能已经不适用）
-    // javascript:
-    REGEXP_DEFAULT_ON_TAG_ATTR_3.lastIndex = 0;
-    if (REGEXP_DEFAULT_ON_TAG_ATTR_3.test(value)) {
-      return '#';
-    }
-    // /*注释*/
-    REGEXP_DEFAULT_ON_TAG_ATTR_4.lastIndex = 0;
-    if (REGEXP_DEFAULT_ON_TAG_ATTR_4.test(value)) {
-      return '';
-    }
-  }
-}
-
-/**
- * 过滤非白名单的标签
- *
- * @param {String} tag 标签名
- * @param {String} html 标签HTML代码（包括属性值）
- * @param {Object} options 更多属性：
- *                   position：在返回的HTML代码中的开始位置
- *                   originalPosition：在原HTML代码中的开始位置
- *                   isClosing：是否为闭合标签，如</a>
- * @return {String} 若不返回任何值，则默认替换<>为&lt;&gt;
- */
-function defaultOnIgnoreTag (tag, html, options) {
-  return noTag(html);
-}
-
-
-/**
- * 转换<>为&lt; &gt
- *
- * @param {String} text
- * @return {String}
- */
-function noTag (text) {
-  return text.replace(REGEXP_LT, '&lt;').replace(REGEXP_GT, '&gt;');
-}
-
-/**
- * 清除不可见字符
- *
- * @param {String} str
- * @return {String}
- */
-function clearNonPrintableCharacter (str) {
-  var str2 = '';
-  for (var i = 0, len = str.length; i < len; i++) {
-    str2 += str.charCodeAt(i) < 32 ? ' ' : str.charAt(i);
-  }
-  return str2.trim();
-}
-
-/**
- * 对双引号进行转义
- *
- * @param {String} str
- * @return {String} str
- */
-function escapeQuotes (str) {
-  return str.replace(REGEXP_QUOTE, '&quote;');
-}
-
-/**
- * 对html实体编码进行转义
- *
- * @param {String} str
- * @return {String}
- */
-function escapeHtmlEntities (str) {
-  return str.replace(REGEXP_ATTR_VALUE_1, function replaceUnicode (str, code) {
-    return (code[0] === 'x' || code[0] === 'X')
-            ? String.fromCharCode(parseInt(code.substr(1), 16))
-            : String.fromCharCode(parseInt(code, 10));
-  });
-}
-
-/**
- * 对html5新增的危险实体编码进行转义
- *
- * @param {String} str
- * @return {String}
- */
-function escapeDangerHtml5Entities (str) {
-  return str.replace(REGEXP_ATTR_VALUE_COLON, ':')
-            .replace(REGEXP_ATTR_VALUE_NEWLINE, ' ');
-}
-
-/**
- * 对属性值进行转义
- *
- * @param {String} str
- * @return {String}
- */
-function safeAttrValue (str) {
-  // 去掉两边的空白字符
-  str = str.trim();
-
-  // 过滤双引号
-  str = escapeQuotes(str);
-
-  // 转换HTML实体编码
-  str = escapeHtmlEntities(str);
-
-  // 转换危险的HTML5新增实体编码
-  str = escapeDangerHtml5Entities(str);
-
-  // 清除不可见字符
-  str = clearNonPrintableCharacter(str);
-
-  return str;
-}
-
-/**
- * XSS过滤对象
- *
- * @param {Object} options 选项：whiteList, onTagAttr, onIgnoreTag
- */
-function FilterXSS (options) {
-  'use strict';
-
-  this.options = options = options || {};
-  this.whiteList = options.whiteList || exports.whiteList;
-  this.onTagAttr = options.onTagAttr || exports.onTagAttr;
-  this.onIgnoreTag = options.onIgnoreTag || exports.onIgnoreTag;
-}
-
-/**
- * 过滤不合法的属性
- *
- * @param {String} tagName 标签名称
- * @param {String} attrs 标签属性部分
- * @return {String}
- */
-FilterXSS.prototype.filterAttributes = function (tagName, attrs) {
-  'use strict';
-
-  tagName = tagName.toLowerCase();
-  var me = this;
-  var whites = this.whiteList[tagName];
-  var lastPos = 0;
-  var _attrs = '';
-  var tmpName = false;
-  var hasSprit = false;
-
-  var addAttr = function (name, value) {
-    name =  name.trim();
-    if (!hasSprit && name === '/') {
-      hasSprit = true;
-      return;
-    }
-    name = name.replace(REGEXP_ATTR_NAME, '').toLowerCase();
-    if (name.length < 1) return;
-    if (whites.indexOf(name) !== -1) {
-      if (value) {
-        // 先对属性值进行转义
-        value = safeAttrValue(value);
-        // 使用用户自定义的 onTagAttr 再过滤
-        var newValue = me.onTagAttr(tagName, name, value);
-        if (typeof newValue !== 'undefined') {
-          value = newValue;
-        }
-      }
-      _attrs += name + (value ? '="' + value + '"' : '') + ' ';
-    }
-  };
-
-  for (var i = 0, len = attrs.length; i < len; i++) {
-    var c = attrs.charAt(i),v;
-    if (tmpName === false && c === '=') {
-      tmpName = attrs.slice(lastPos, i);
-      lastPos = i + 1;
-      continue;
-    }
-    if (tmpName !== false) {
-      if (i === lastPos && (c === '"' || c === "'")) {
-        var j = attrs.indexOf(c, i + 1);
-        if (j === -1) {
-          break;
-        } else {
-          v = attrs.slice(lastPos + 1, j).trim();
-          addAttr(tmpName, v);
-          tmpName = false;
-          i = j;
-          lastPos = i + 1;
-          continue;
-        }
-      }
-    }
-    if (c === ' ') {
-      v = attrs.slice(lastPos, i).trim();
-      if (tmpName === false) {
-        addAttr(v);
-      } else {
-        addAttr(tmpName, v);
-      }
-      tmpName = false;
-      lastPos = i + 1;
-      continue;
-    }
-  }
-
-  if (lastPos < attrs.length) {
-    if (tmpName === false) {
-      addAttr(attrs.slice(lastPos));
-    } else {
-      addAttr(tmpName, attrs.slice(lastPos));
-    }
-  }
-  if (hasSprit) _attrs += '/';
-
-  return _attrs.trim();
-};
-
-/**
- * 检查标签是否合法
- *
- * @param {String} tag 标签文本，如“<a”
- * @param {Number} currentPos 原HTML的当前位置
- * @param {Number} targetPos 生成的HTML的当前位置
- */
-FilterXSS.prototype.addNewTag = function (tag, currentPos, targetPos) {
-  'use strict';
-
-  var rethtml = '';
-  var tagName;
-  var hasSprit;
-  var spos = tag.slice(0, 2) === '</' ? 2 : 1;
-
-  var i = tag.indexOf(' ');
-  if (i === -1) {
-    tagName = tag.slice(spos, tag.length - 1).trim();
-  } else {
-    tagName = tag.slice(spos, i + 1).trim();
-  }
-  tagName = tagName.toLowerCase();
-
-  // 检查标签是否以“/”结尾
-  if (tagName.slice(-1) === '/') {
-    tagName = tagName.slice(0, -1);
-    hasSprit = true;
-  } else {
-    hasSprit = false;
-  }
-
-  if (tagName in this.whiteList) {
-    // 过滤不合法的属性
-    if (i === -1) {
-      rethtml += tag.slice(0, spos) + tagName + (hasSprit ? ' />' : '>');
-    } else {
-      var attrs = this.filterAttributes(tagName, tag.slice(i + 1, tag.length - 1).trim());
-      rethtml += tag.slice(0, spos) + tagName + (attrs.length > 0 ? ' ' + attrs : '') + '>';
-    }
-  } else {
-    // 过滤不合法的标签
-    var options = {
-      isClosing:        (spos === 2),
-      position:         targetPos,
-      originalPosition: currentPos - tag.length + 1
-    };
-    var tagHtml = this.onIgnoreTag(tagName, tag, options);
-    if (typeof tagHtml === 'undefined') {
-      tagHtml = noTag(tag);
-    }
-    rethtml += tagHtml;
-  }
-
-  return rethtml;
-};
-
-/**
- * 开始处理
- *
- * @param {String} html
- * @return {String}
- */
-FilterXSS.prototype.process = function (html) {
-  'use strict';
-
-  var rethtml = '';
-  var lastPos = 0;
-  var tagStart = false;
-  var quoteStart = false;
-  var currentPos = 0;
-  var len = 0;
-
-  // 逐个分析字符
-  for (currentPos = 0, len = html.length; currentPos < len; currentPos++) {
-    var c = html.charAt(currentPos);
-    if (tagStart === false) {
-      if (c === '<') {
-        tagStart = currentPos;
-        continue;
-      }
-    } else {
-      if (quoteStart === false) {
-        if (c === '<') {
-          rethtml += noTag(html.slice(lastPos, currentPos));
-          tagStart = currentPos;
-          lastPos = currentPos;
-          continue;
-        }
-        if (c === '>') {
-          rethtml += noTag(html.slice(lastPos, tagStart));
-          rethtml += this.addNewTag(html.slice(tagStart, currentPos + 1), currentPos, rethtml.length);
-          lastPos = currentPos + 1;
-          tagStart = false;
-          continue;
-        }
-        if (c === '"' || c === "'") {
-          quoteStart = c;
-          continue;
-        }
-      } else {
-        if (c === quoteStart) {
-          quoteStart = false;
-          continue;
-        }
-      }
-    }
-  }
-  if (lastPos < html.length) {
-    rethtml += noTag(html.substr(lastPos));
-  }
-
-  return rethtml;
-};
-
-/**
  * XSS过滤
  *
  * @param {String} html 要过滤的HTML代码
- * @param {Object} options 选项：whiteList, onTagAttr, onIgnoreTag
+ * @param {Object} options 选项：whiteList, onTag, onTagAttr, onIgnoreTag, onIgnoreTagAttr, safeAttrValue, escapeHtml
  * @return {String}
@@ -440,33 +25,33 @@ */
 
-// 默认配置
+
+// 输出
 exports = module.exports = filterXSS;
 exports.FilterXSS = FilterXSS;
-exports.whiteList = defaultWhiteList;
-exports.onTagAttr = defaultOnTagAttr;
-exports.onIgnoreTag = defaultOnIgnoreTag;
+for (var i in DEFAULT) exports[i] = DEFAULT[i];
+for (var i in parser) exports[i] = parser[i];
 
-// 工具函数
-exports.utils = require('./utils');
 
 // 在浏览器端使用
 if (typeof window !== 'undefined') {
-  if(!Array.indexOf){
-    Array.prototype.indexOf = function(item){
-        for(var i=0;i<this.length;i++){
-            if(this[i] == item) return i;
-        }
-        return -1;
+  // 低版本浏览器支持
+  if (!Array.indexOf) {
+    Array.prototype.indexOf = function (item) {
+      for(var i=0;i<this.length;i++){
+        if(this[i] == item) return i;
+      }
+      return -1;
     };
   }
-  if(!Array.forEach){
-    Array.prototype.forEach = function(fn){
-       for(var i=0;i<this.length;i++) fn(this[i],i,this);
+  if (!Array.forEach) {
+    Array.prototype.forEach = function (fn) {
+      for (var i = 0; i < this.length; i++) fn(this[i], i, this);
     };
   }
   if(!String.trim){
-    String.prototype.trim = function(){
-        return this.replace(/(^\s*)|(\s*$)/g,"");
+    String.prototype.trim = function () {
+      return this.replace(/(^\s*)|(\s*$)/g, '');
     };
   }
+  // 输出
   window.filterXSS = module.exports;
 }

package.json

 {
   "name":           "xss",
   "main":           "./lib/index.js",
-  "version":        "0.0.9",
+  "version":        "0.1.1",
   "description":    "XSS攻击代码过滤 Remove XSS attack vectors from user-supplied HTML",
@@ -6,0 +6,0 @@ "author":         "leizongmin <[e-mail]> (http://ucdok.com)",

README.md

 [![Build Status](https://secure.travis-ci.org/leizongmin/js-xss.png?branch=master)](http://travis-ci.org/leizongmin/js-xss)
 
-过滤XSS攻击
+XSS代码过滤
 ======
@@ -8,3 +8,12 @@
 
+**注意：0.1.x版本与0.0.x版本在自定义配置（除白名单配置外）格式上有较大改动，如果
+要使用新版本，请详细阅读下文的使用说明**
 
+
+## 特性
+
++ 白名单控制允许的HTML标签及各标签的属性
++ 通过自定义处理函数，可对任意标签及其属性进行处理
+
+
 ## 参考资料
@@ -19,67 +28,130 @@
 
-## 安装
+## 使用方法
 
-**npm install xss**
+### 在Node.js中使用
 
+安装：
 
-## 原理
+```bash
+$ npm install xss
+```
 
-通过标签白名单及属性白名单来过滤HTML标签，同时对包含特殊字符的属性值进行处理。默认配置可过滤大多数的XSS攻击代码，可根据实际应用场景来定制白名单及过滤方法。
+简单使用方法：
 
+```JavaScript
+var xss = require('xss');
+var html = xss('<script>alert("xss");</script>');
+console.log(html);
+```
 
-## 使用方法
+### 在浏览器端使用
 
-### 载入模块
-
-```javascript
-var xss = require('xss');
+```HTML
+<script src="https://raw.github.com/leizongmin/js-xss/master/build/xss.js"></script>
+<script>
+// 使用函数名 filterXSS，用法一样
+var html = filterXSS('<script>alert("xss");</scr' + 'ipt>');
+alert(html);
+</script>
 ```
 
-### 使用默认的配置
 
-```javascript
-var html = xss('<script>alert("xss");</script>');
-console.log(html);
+## 自定义过滤规则
+
+在调用 `xss()` 函数进行过滤时，可通过第二个参数来设置自定义规则：
+
+```JavaScript
+options = {};  // 自定义规则
+html = xss('<script>alert("xss");</script>', options);
 ```
 
-### 修改默认配置
+具体用法详见下文。
 
-```javascript
-// 添加或更新白名单中的标签 标签名（小写） = ['允许的属性列表（小写）']
-xss.whiteList['p'] = ['class', 'style'];
-// 删除默认的白名单标签
-delete xss.whiteList['div'];
+### 白名单
 
-// 自定义处理属性值函数
-xss.onTagAttr = function (tag, attr, vaule) {
-  // tag：当前标签名（小写）
-  // attr：当前属性名（小写）
-  // value：当前属性值
-  // 返回新的属性值，如果想使用默认的处理方式，不返回任何值即可
-  // 比如把属性值中的双引号替换为&amp;quote;：return value.replace(/"/g, '&amp;quote;');
-  // 以下为默认的处理代码：
-  if (attr === 'href' || attr === 'src') {
-    if (/\/\*|\*\//mg.test(value)) {
-      return '#';
-    }
-    if (/^[\s"'`]*((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a):/ig.test(value)) {
-      return '#';
-    }
-  } else if (attr === 'style') {
-    if (/\/\*|\*\//mg.test(value)) {
-      return '#';
-    }
-    if (/((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a):/ig.test(value)) {
-      return '';
-    }
+通过 `whiteList` 来指定，格式为：`{'标签名': ['属性1', '属性2']}`。不在白名单上
+的标签将被过滤，不在白名单上的属性也会被过滤。以下是示例：
+
+```JavaScript
+// 只允许a标签，该标签只允许href, title, target这三个属性
+var options = {
+  whiteList: {
+    a: ['href', 'title', 'target']
   }
 };
+// 使用以上配置后，下面的HTML
+// <a href="#" onclick="hello()"><i>大家好</i></a>
+// 将被过滤为
+// <a href="#">大家好</a>
+```
 
-// 自定义处理不在白名单中的标签
-xss.onIgnoreTag = function (tag, html) {
-  // tag：当前标签名（小写），如：a
-  // html：当前标签的HTML代码，如：<a href="ooxx">
-  // 返回新的标签HTML代码，如果想使用默认的处理方式，不返回任何值即可
-  // 比如将标签替换为[removed]：return '[removed]';
-  // 以下为默认的处理代码：
+默认白名单参考 `xss.whiteList`。
+
+### 自定义匹配到标签时的处理方法
+
+通过 `onTag` 来指定相应的处理函数。以下是详细说明：
+
+```JavaScript
+function onTag (tag, html, options) {
+  // tag是当前的标签名称，比如<a>标签，则tag的值是'a'
+  // html是该标签的HTML，比如<a>标签，则html的值是'<a>'
+  // options是一些附加的信息，具体如下：
+  //   isWhite    boolean类型，表示该标签是否在白名单上
+  //   isClosing  boolean类型，表示该标签是否为闭合标签，比如</a>时为true
+  //   position        integer类型，表示当前标签在输出的结果中的起始位置
+  //   sourcePosition  integer类型，表示当前标签在原HTML中的起始位置
+  // 如果返回一个字符串，则当前标签将被替换为该字符串
+  // 如果不返回任何值，则使用默认的处理方法：
+  //   在白名单上：  通过onTagAttr来过滤属性，详见下文
+  //   不在白名单上：通过onIgnoreTag指定，详见下文
+}
+```
+
+### 自定义匹配到标签的属性时的处理方法
+
+通过 `onTagAttr` 来指定相应的处理函数。以下是详细说明：
+
+```JavaScript
+function onTagAttr (tag, name, value, isWhiteAttr) {
+  // tag是当前的标签名称，比如<a>标签，则tag的值是'a'
+  // name是当前属性的名称，比如href="#"，则name的值是'href'
+  // value是当前属性的值，比如href="#"，则value的值是'#'
+  // isWhiteAttr是否为白名单上的属性
+  // 如果返回一个字符串，则当前属性值将被替换为该字符串
+  // 如果不返回任何值，则使用默认的处理方法
+  //   在白名单上：  调用safeAttrValue来过滤属性值，并输出该属性，详见下文
+  //   不在白名单上：通过onIgnoreTagAttr指定，详见下文
+}
+```
+
+### 自定义匹配到不在白名单上的标签时的处理方法
+
+通过 `onIgnoreTag` 来指定相应的处理函数。以下是详细说明：
+
+```JavaScript
+function onIgnoreTag (tag, html, options) {
+  // 参数说明与onTag相同
+  // 如果返回一个字符串，则当前标签将被替换为该字符串
+  // 如果不返回任何值，则使用默认的处理方法（通过escape指定，详见下文）
+}
+```
+
+### 自定义匹配到不在白名单上的属性时的处理方法
+
+通过 `onIgnoreTagAttr` 来指定相应的处理函数。以下是详细说明：
+
+```JavaScript
+function onIgnoreTagAttr (tag, name, value, isWhiteAttr) {
+  // 参数说明与onTagAttr相同
+  // 如果返回一个字符串，则当前属性值将被替换为该字符串
+  // 如果不返回任何值，则使用默认的处理方法（删除该属）
+}
+```
+
+### 自定义HTML转义函数
+
+通过 `escapeHtml` 来指定相应的处理函数。以下是默认代码 **（不建议修改）** ：
+
+```JavaScript
+function escapeHtml (html) {
   return html.replace(/</g, '&lt;').replace(/>/g, '&gt;');
@@ -89,51 +161,155 @@ }
 
-### 使用临时配置
+### 自定义标签属性值的转义函数
 
-```javascript
-var options = {
-  whiteList:   {},        // 若不指定则使用默认配置，可参考xss.whiteList
-  onTagAttr:   function () {},  // 若不指定则使用默认配置，可参考xss.onTagAttr
-  onIgnoreTag: function () {}   // 若不指定则使用默认配置，可参考xss.onIgnoreTag
-};
-var html = xss('<script>alert("xss");</script>', options);
-console.log(html);
+通过 `safeAttrValue` 来指定相应的处理函数。以下是详细说明：
+
+```JavaScript
+function safeAttrValue (tag, name, value) {
+  // 参数说明与onTagAttr相同（没有options参数）
+  // 返回一个字符串表示该属性值
+}
 ```
 
-### 在浏览器端使用
+### 快捷配置
 
+#### 去掉不在白名单只的标签
+
+通过 `stripIgnoreTag` 来设置：
+
++ `true`：（默认），去掉不在白名单上的标签
++ `false`：使用配置的`escape`函数对该标签进行转义
+
+示例：
+
+当设置 `stripIgnoreTag = true`时，以下代码
+
+```HTML
+code:<script>alert(/xss/);</script>
 ```
-<script src="https://raw.github.com/leizongmin/js-xss/master/build/xss.js"></script>
-<script>
-// 使用函数名 filterXSS，用法一样
-var html = filterXSS('<script>alert("xss");</scr' + 'ipt>');
-alert(html);
-</script>
+
+过滤后将输出
+
+```HTML
+code:alert(/xss/);
 ```
 
+#### 去掉不在白名单上的标签及标签体
 
-## 其他应用
+通过 `stripIgnoreTagBody` 来设置：
 
++ `false|null|undefined`：（默认），不特殊处理
++ `'*'|true`：去掉所有不在白名单上的标签
++ `['tag1', 'tag2']`：仅去掉指定的不在白名单上的标签
 
-## 测试
+示例：
 
-### 单元测试
+当设置 `stripIgnoreTagBody = ['script']`时，以下代码
 
-在源码目录执行命令： **npm test**
+```HTML
+code:<script>alert(/xss/);</script>
+```
 
-### 在线测试
+过滤后将输出
 
-在源码目录执行命令： **node lib/cli.js** ，可在命令行中输入HTML代码，并看到过滤后的代码
+```HTML
+code:
+```
 
 
+## 应用实例
+
+### 允许标签以data-开头的属性
+
+```JavaScript
+var source = '<div a="1" b="2" data-a="3" data-b="4">hello</div>';
+var html = xss(source, {
+  onIgnoreTagAttr: function (tag, name, value, isWhiteAttr) {
+    if (name.substr(0, 5) === 'data-') {
+      // 通过内置的escapeAttrValue函数来对属性值进行转义
+      return name + '="' + xss.escapeAttrValue(value) + '"';
+    }
+  }
+});
+
+console.log('%s\nconvert to:\n%s', source, html);
+```
+
+运行结果：
+
+```
+<div a="1" b="2" data-a="3" data-b="4">hello</div>
+convert to:
+<div data-a="3" data-b="4">hello</div>
+```
+
+### 允许名称以x-开头的标签
+
+```JavaScript
+var source = '<x><x-1>he<x-2 checked></x-2>wwww</x-1><a>';
+var html = xss(source, {
+  onIgnoreTag: function (tag, html, options) {
+    if (tag.substr(0, 2) === 'x-') {
+      // 不对其属性列表进行过滤
+      return html;
+    }
+  }
+});
+
+console.log('%s\nconvert to:\n%s', source, html);
+```
+
+运行结果：
+
+```
+<x><x-1>he<x-2 checked></x-2>wwww</x-1><a>
+convert to:
+&lt;x&gt;<x-1>he<x-2 checked></x-2>wwww</x-1><a>
+```
+
+### 分析HTML代码中的图片列表
+
+```JavaScript
+var source = '<img src="img1">a<img src="img2">b<img src="img3">c<img src="img4">d';
+var list = [];
+var html = xss(source, {
+  onTagAttr: function (tag, name, value, isWhiteAttr) {
+    if (tag === 'img' && name === 'src') {
+      // 使用内置的friendlyAttrValue函数来对属性值进行转义，可将&lt;这类的实体标记转换成打印字符<
+      list.push(xss.friendlyAttrValue(value));
+    }
+    // 不返回任何值，表示还是按照默认的方法处理
+  }
+});
+
+console.log('image list:\n%s', list.join(', '));
+```
+
+运行结果：
+
+```
+image list:
+img1, img2, img3, img4
+```
+
+
 ## 性能
 
-解析速度为 **5.81MB/s** ，而另外一个 **validator** 模块的xss()函数速度仅为 **2.48MB/s** 。
++ xss模块：6.01 MB/s
++ validator@0.3.7模块的xss()函数：4.62 MB/s
 
-测试代码参考 **benchmark** 目录
+测试代码参考 benchmark 目录
 
 
-## 授权协议
+## 单元测试
 
-基于MIT协议发布：
+在源码目录执行命令： `npm test`
 
+
+## 在线测试
+
+在源码目录执行命令： `node lib/cli.js` ，可在命令行中输入HTML代码，并看到过滤后的代码
+
+
+## MIT协议
+
 ```
@@ -140,0 +316,0 @@ Copyright (c) 2012-2014 Zongmin Lei(雷宗民) <[e-mail]>

test/test_xss.js

 /**
  * 测试XSS
+ *
+ * @author 老雷<[e-mail]>
  */
@@ -37,3 +39,3 @@
     // 属性内的特殊字符
-    assert.equal(xss('<a href="\'<<>>">'), '<a href="\'<<>>">');
+    assert.equal(xss('<a href="\'<<>>">'), '<a href="\'&lt;&lt;&gt;&gt;">');
     assert.equal(xss('<a href=""">'), '&lt;a href=\"\"\"&gt;');
@@ -55,3 +57,3 @@ assert.equal(xss('<a h=href="oo">'), '<a>');
     assert.equal(xss('<img src="#" />'), '<img src="#" />');
-    assert.equal(xss('<img src="#"//>'), '<img src="#">');
+    assert.equal(xss('<img src="#"//>'), '<img src="#" />');
     assert.equal(xss('<br/>'), '<br />');
@@ -73,64 +75,2 @@ assert.equal(xss('<br />'), '<br />');
 
-  // 自定义过滤属性函数
-  it('#process attribute value', function () {
-
-    assert.equal(xss('<a href="ignore:ooxx">abc</a><a href="ooxx">', {
-      onTagAttr: function (tag, attr, value) {
-        if (tag === 'a' && attr === 'href') {
-          if (value.substr(0, 7) === 'ignore:') {
-            return '#';
-          }
-        }
-      }
-    }), '<a href="#">abc</a><a href="ooxx">');
-
-  });
-
-  // 自定义处理不在白名单中的标签
-  it('#process ignore tag', function () {
-
-    // 过滤标签
-    assert.equal(xss('<ooxx xxyy>ookk</ooxx><img>', {
-      onIgnoreTag: function (tag, html) {
-        return '';
-      }
-    }), 'ookk<img>');
-    assert.equal(xss('<ooxx xxyy>ookk</ooxx><img>', {
-      onIgnoreTag: function (tag, html) {
-        return '[removed]';
-      }
-    }), '[removed]ookk[removed]<img>');
-
-    // 检验附加属性
-    var isClosing = [];
-    var position = [];
-    var originalPosition = [];
-    var html = xss('TTG:<ooxx href="ooy" >ds</ooxx>--ds  d<yy hh uu>', {
-      onIgnoreTag: function (tag, html, options) {
-        isClosing.push(options.isClosing);
-        position.push(options.position);
-        originalPosition.push(options.originalPosition);
-      }
-    });
-    //console.log(html);
-    assert.deepEqual(isClosing, [false, true, false]);
-    assert.deepEqual(position, [4, 30, 50]);
-    assert.deepEqual(originalPosition, [4, 24, 38]);
-
-    // 替换检验 utils.tagFilter()
-    var filter = xss.utils.tagFilter(['script']);
-    var html = xss('<b >script is <script t="d">alert("xss"); ooxx()</script>, wahaha!!</b>', {
-      onIgnoreTag:  filter.onIgnoreTag
-    });
-    assert.equal(filter.filter(html), '<b>script is , wahaha!!</b>');
-
-    var filter = xss.utils.tagFilter(['x2']);
-    var html = xss('<x1></b><x2>dds</x2><x3>fd</x3>', {
-      onIgnoreTag:  filter.onIgnoreTag
-    });
-    assert.equal(filter.filter(html), '&lt;x1&gt;</b>&lt;x3&gt;fd&lt;/x3&gt;');
-
-  });
-
-
   // XSS攻击测试：https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
@@ -137,0 +77,0 @@ it('#XSS_Filter_Evasion_Cheat_Sheet', function () {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

184858

increased by19.35%

Number of package files

22

increased by46.67%

Lines of code

2013

increased by66.36%

Number of lines in readme file

336

increased by110%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes