前言
不知道各位小伙伴有没有看过巴伦·博·欧达尔执导的悬疑推理片——《我是谁：没有绝对安全的系统》，电影中的主人公和他的朋友们一起组建了黑客组织 CLAY（Clawn Laghing At You 意思是小丑的嘲笑），并且先后入侵了国际安全系统、国际金融系统、国际金融评估系统、德国安全局、德国情报局。身为一名程序员的我在看到电影中的主人公利用系统漏洞进行入侵时，不由自主的就想到了自己参与开发的系统软件肯定或多或少也存在漏洞（估计这些软件在人家手里撑不过三分钟吧😂）。我们无法保证系统一点漏洞都没有，更无法保证系统是绝对安全的，我们能做的只有尽可能的去发现漏洞并修复漏洞，让我们的系统尽可能的安全一些。那么今天就跟大家总结一下常见的漏洞以及对应的解决方案💪。
P.S. 虽然这只是一部电影，其中的剧情会有所虚构，但是当我看完电影以后还是说出了这句话：这群人太🐂批了（已经无法用其他言语来形容了）！这确实是一部值得二刷三刷的电影
常见安全漏洞及解决方案
SQL 注入
什么是 SQL 注入
SQL注入是比较常见的网络攻击方式之一，它不是利用操作系统的 BUG 来实现的攻击，而是针对程序员编写时的一时大意，通过SQL语句来进行入侵，实现无账号登录，甚至篡改数据库。
咱们举个例子：比如现在有一个登录的功能，我们在代码中对用户提交进来的参数（账号、密码等）进行拼接，最终拼接成完整的 SQL 语句对用户身份进行校验👇
String sql = “select * from user where username=’ “+userName+” ’ and password=’ “+password+” '”;
如果这时候有人输入了非法参数进行提交，就有可能让上面的语句变成这样👇
select * from user where username=‘xxx’ or 1 = 1 - - and password=’ ’
我们来分析一下这条SQL语句：where 条件后面的 username=‘xxx’ or 1 = 1 的含义就是“用户名等于xxx或者1=1”，那么此时这个条件就变成了永真的状态；咱们在往后看，and 关键字前面多了两个小横线，这个横线肯定都不陌生吧？在 SQL 语句中两条小横线代表了注释，这样一来就使得 and 后面对密码的校验失效了，也就是说上面的语句是一条一定可以执行成功的语句，这样也就达成了 SQL 注入的目的。
这还是一个比较温柔的 SQL 注入，那如果 SQL 语句变成了这样呢？👇
select * from user where username=‘xxx’ ; DROP DATABASE (DB Name); - - and password=’ ’
如果真的将这句 SQL 成功的在数据库内执行了，那后果就不堪设想了…
SQL 注入的解决方案
但凡有 SQL 注入漏洞的程序，都是因为程序要接受来自客户端用户输入的变量或者 URL 传递的参数，并且这个变量或参数是组成SQL语句的一部分，对于用户输入的内容或传递的参数，我们应该要时刻保持警惕，要严格遵循外部数据不可信任的原则，纵观 Web 安全领域的各种攻击方式，大多数都是因为开发者违反了这个原则而导致的，所以自然能想到的，就是从参数的检测、过滤、验证下手，确保参数是开发者所预想的安全参数。
① 检查变量数据类型和格式：如果你的 SQL 语句是类似于 where id={$id} 的形式，数据库里所有的 id 都是数字，那么就应该在 SQL 语句被执行前，检查接受到的 id 参数的类型是不是 int 类型；如果是接受手机号码参数，那就应该检查并严格确保参数一定是手机号码的格式，其他类型的参数也是一个道理。总之就是一句话：只要是有固定格式的参数（数字、手机号码、邮箱等等），在 SQL 语句执行前，应该严格按照固定格式去检查，确保变量是我们预想的格式，这样就可以在很大程度上防止 SQL 注入攻击。
我们一开始举了一个校验用户名和密码的例子，如果我们在产品的设计阶段有一个用户名的规则，比如规定了用户名的长度必须是5-15个字符，而且用户名只能由大小写字母、数字以及一些安全的符号组成，不包含特殊字符。那么此时我们就应该写一个check_username（检查用户名）的方法，用该方法对接收到的用户名参数进行统一检查。但是在文章发布系统，评论系统等必须要允许用户提交任意字符串的场景下，上述的校验方式就不合适了，此时就需要采用过滤器等其他方案了。
P.S. 关于固定格式参数的校验可以使用 Hutool 工具类库，让你的代码变得“甜甜的”~ 没接触过 Hutool 的小伙伴可以参考大聪明教你学Java | Hutool - A set of tools that keep Java sweet
②过滤特殊符号：这句话就很好理解了，对于一些没有固定格式的参数，我们就需要对其进行特殊字符的过滤，禁止用户传递不安全的特殊符号。
③使用预编译语句：所谓预编译语句就是将 SQL 语句中的变量值用占位符替代，可以说是将 SQL 语句模板化或者说参数化，一般称这类语句叫Prepared Statements或者 Parameterized Statements。绑定变量使用预编译语句是预防 SQL 注入的最佳方式，使用预编译的 SQ L语句的语义不会发生改变，在SQL语句中，变量用问号?表示，这时候就算黑客本事再大，即便传递进来了 SQL 注释符号（也就是上面提到的两条横线），那也无法改变整个 SQL 语句的结构。
④ 如果使用了Mybatis，那么在编写映射语句时，尽量采用 #{xxx} 这样的格式：在MyBatis中， $ {xxx}这样格式的参数会直接参与 SQL 编译，从而不能避免注入攻击。但涉及到动态表名和列名时，只能使用 ${xxx} 这样的参数格式。所以，这样的参数需要我们在代码中手工进行处理来防止出现 SQL 注入。
跨站脚本漏洞
什么是跨站脚本漏洞
跨站脚本漏洞(Cross-site scripting，通常简称为XSS)发生在客户端，可被用于进行窃取隐私、钓鱼欺骗、窃取密码、传播恶意代码等攻击。XSS 攻击使用到的技术主要为 HTML 和 Javascript，也包括 VBScript 和 ActionScript 等。XSS 攻击对 WEB 服务器虽无直接危害，但是它借助网站进行传播，使网站的使用用户受到攻击，导致网站用户帐号被窃取，从而对网站也产生了较严重的危害。
说白了 XSS 攻击就是往 Web 页面里插入恶意脚本代码，当用户浏览该页之时，嵌入其中的恶意脚本代码会被执行，从而达到恶意攻击用户的目的。XSS 攻击一共分为以下三类👇
- 反射型XSS<非持久化>：攻击者事先制作好攻击链接, 需要欺骗用户自己去点击链接才能触发XSS代码（服务器中没有这样的页面和内容），一般容易出现在搜索页面，或者出现在垃圾短信。（未知链接不要随意点击哦，很危险的🈲）
- 存储型XSS<持久化> ：这种 XSS 攻击是将代码存储到了服务器中的，比如黑客在修改个人信息或发表文章等地方上传了恶意代码，此时如果没有过滤或过滤不严，那么这些代码将储存到服务器中，每当有用户访问该页面的时候都会触发代码执行，这种 XSS 攻击就非常危险了，容易造成蠕虫或者是导致大量 Cookie 失窃。
- DOM型XSS：是一种发生在客户端 DOM（Document Object Model 文档对象模型）中的跨站漏洞，很大原因是因为客户端脚本处理逻辑导致的安全问题。
跨站脚本漏洞的解决方案
与SQL注入防护的建议一样，我们依然要严格遵循外部数据不可信任的原则，必须对所有输入中的script、iframe 等字样进行严格的检查。这里的输入不仅仅是用户可以直接交互的输入接口，也包括 HTTP 请求中的 Cookie 中的变量，HTTP 请求头部中的变量等。这里就推荐使用过滤器来进行参数校验了，毕竟需要检查校验的地方这么多，总不能一个一个的写吧~ 直接上代码👇
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class HTMLFilter {
/** regex flag union representing /si modifiers in php **/
private static final int REGEX_FLAGS_SI = Pattern.CASE_INSENSITIVE | Pattern.DOTALL;
private static final Pattern P_COMMENTS = Pattern.compile("<!--(.*?)-->", Pattern.DOTALL);
private static final Pattern P_COMMENT = Pattern.compile("^!--(.*)--$", REGEX_FLAGS_SI);
private static final Pattern P_TAGS = Pattern.compile("<(.*?)>", Pattern.DOTALL);
private static final Pattern P_END_TAG = Pattern.compile("^/([a-z0-9]+)", REGEX_FLAGS_SI);
private static final Pattern P_START_TAG = Pattern.compile("^([a-z0-9]+)(.*?)(/?)$", REGEX_FLAGS_SI);
private static final Pattern P_QUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)=([\"'])(.*?)\\2", REGEX_FLAGS_SI);
private static final Pattern P_UNQUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)(=)([^\"\\s']+)", REGEX_FLAGS_SI);
private static final Pattern P_PROTOCOL = Pattern.compile("^([^:]+):", REGEX_FLAGS_SI);
private static final Pattern P_ENTITY = Pattern.compile("&#(\\d+);?");
private static final Pattern P_ENTITY_UNICODE = Pattern.compile("&#x([0-9a-f]+);?");
private static final Pattern P_ENCODE = Pattern.compile("%([0-9a-f]{2});?");
private static final Pattern P_VALID_ENTITIES = Pattern.compile("&([^&;]*)(?=(;|&|$))");
private static final Pattern P_VALID_QUOTES = Pattern.compile("(>|^)([^<]+?)(<|$)", Pattern.DOTALL);
private static final Pattern P_END_ARROW = Pattern.compile("^>");
private static final Pattern P_BODY_TO_END = Pattern.compile("<([^>]*?)(?=<|$)");
private static final Pattern P_XML_CONTENT = Pattern.compile("(^|>)([^<]*?)(?=>)");
private static final Pattern P_STRAY_LEFT_ARROW = Pattern.compile("<([^>]*?)(?=<|$)");
private static final Pattern P_STRAY_RIGHT_ARROW = Pattern.compile("(^|>)([^<]*?)(?=>)");
private static final Pattern P_AMP = Pattern.compile("&");
private static final Pattern P_QUOTE = Pattern.compile("<");
private static final Pattern P_LEFT_ARROW = Pattern.compile("<");
private static final Pattern P_RIGHT_ARROW = Pattern.compile(">");
private static final Pattern P_BOTH_ARROWS = Pattern.compile("<>");
// @xxx could grow large... maybe use sesat's ReferenceMap
private static final ConcurrentMap<String,Pattern> P_REMOVE_PAIR_BLANKS = new ConcurrentHashMap<String, Pattern>();
private static final ConcurrentMap<String,Pattern> P_REMOVE_SELF_BLANKS = new ConcurrentHashMap<String, Pattern>();
/** set of allowed html elements, along with allowed attributes for each element **/
private final Map<String, List<String>> vAllowed;
/** counts of open tags for each (allowable) html element **/
private final Map<String, Integer> vTagCounts = new HashMap<String, Integer>();
/** html elements which must always be self-closing (e.g. "<img />") **/
private final String[] vSelfClosingTags;
/** html elements which must always have separate opening and closing tags (e.g. "<b></b>") **/
private final String[] vNeedClosingTags;
/** set of disallowed html elements **/
private final String[] vDisallowed;
/** attributes which should be checked for valid protocols **/
private final String[] vProtocolAtts;
/** allowed protocols **/
private final String[] vAllowedProtocols;
/** tags which should be removed if they contain no content (e.g. "<b></b>" or "<b />") **/
private final String[] vRemoveBlanks;
/** entities allowed within html markup **/
private final String[] vAllowedEntities;
/** flag determining whether comments are allowed in input String. */
private final boolean stripComment;
private final boolean encodeQuotes;
private boolean vDebug = false;
/**
* flag determining whether to try to make tags when presented with "unbalanced"
* angle brackets (e.g. "<b text </b>" becomes "<b> text </b>"). If set to false,
* unbalanced angle brackets will be html escaped.
*/
private final boolean alwaysMakeTags;
/** Default constructor.
*
*/
public HTMLFilter() {
vAllowed = new HashMap<>();
final ArrayList<String> a_atts = new ArrayList<String>();
a_atts.add("href");
a_atts.add("target");
vAllowed.put("a", a_atts);
final ArrayList<String> img_atts = new ArrayList<String>();
img_atts.add("src");
img_atts.add("width");
img_atts.add("height");
img_atts.add("alt");
vAllowed.put("img", img_atts);
final ArrayList<String> no_atts = new ArrayList<String>();
vAllowed.put("b", no_atts);
vAllowed.put("strong", no_atts);
vAllowed.put("i", no_atts);
vAllowed.put("em", no_atts);
vSelfClosingTags = new String[]{"img"};
vNeedClosingTags = new String[]{"a", "b", "strong", "i", "em"};
vDisallowed = new String[]{};
vAllowedProtocols = new String[]{"http", "mailto", "https"}; // no ftp.
vProtocolAtts = new String[]{"src", "href"};
vRemoveBlanks = new String[]{"a", "b", "strong", "i", "em"};
vAllowedEntities = new String[]{"amp", "gt", "lt", "quot"};
stripComment = true;
encodeQuotes = true;
alwaysMakeTags = true;
}
/** Set debug flag to true. Otherwise use default settings. See the default constructor.
*
* @param debug turn debug on with a true argument
*/
public HTMLFilter(final boolean debug) {
this();
vDebug = debug;
}
/** Map-parameter configurable constructor.
*
* @param conf map containing configuration. keys match field names.
*/
public HTMLFilter(final Map<String,Object> conf) {
assert conf.containsKey("vAllowed") : "configuration requires vAllowed";
assert conf.containsKey("vSelfClosingTags") : "configuration requires vSelfClosingTags";
assert conf.containsKey("vNeedClosingTags") : "configuration requires vNeedClosingTags";
assert conf.containsKey("vDisallowed") : "configuration requires vDisallowed";
assert conf.containsKey("vAllowedProtocols") : "configuration requires vAllowedProtocols";
assert conf.containsKey("vProtocolAtts") : "configuration requires vProtocolAtts";
assert conf.containsKey("vRemoveBlanks") : "configuration requires vRemoveBlanks";
assert conf.containsKey("vAllowedEntities") : "configuration requires vAllowedEntities";
vAllowed = Collections.unmodifiableMap((HashMap<String, List<String>>) conf.get("vAllowed"));
vSelfClosingTags = (String[]) conf.get("vSelfClosingTags");
vNeedClosingTags = (String[]) conf.get("vNeedClosingTags");
vDisallowed = (String[]) conf.get("vDisallowed");
vAllowedProtocols = (String[]) conf.get("vAllowedProtocols");
vProtocolAtts = (String[]) conf.get("vProtocolAtts");
vRemoveBlanks = (String[]) conf.get("vRemoveBlanks");
vAllowedEntities = (String[]) conf.get("vAllowedEntities");
stripComment = conf.containsKey("stripComment") ? (Boolean) conf.get("stripComment") : true;
encodeQuotes = conf.containsKey("encodeQuotes") ? (Boolean) conf.get("encodeQuotes") : true;
alwaysMakeTags = conf.containsKey("alwaysMakeTags") ? (Boolean) conf.get("alwaysMakeTags") : true;
}
private void reset() {
vTagCounts.clear();
}
private void debug(final String msg) {
if (vDebug) {
Logger.getAnonymousLogger().info(msg);
}
}
//---------------------------------------------------------------
// my versions of some PHP library functions
public static String chr(final int decimal) {
return String.valueOf((char) decimal);
}
public static String htmlSpecialChars(final String s) {
String result = s;
result = regexReplace(P_AMP, "&", result);
result = regexReplace(P_QUOTE, """, result);
result = regexReplace(P_LEFT_ARROW, "<", result);
result = regexReplace(P_RIGHT_ARROW, ">", result);
return result;
}
//---------------------------------------------------------------
/**
* given a user submitted input String, filter out any invalid or restricted
* html.
*
* @param input text (i.e. submitted by a user) than may contain html
* @return "clean" version of input, with only valid, whitelisted html elements allowed
*/
public String filter(final String input) {
reset();
String s = input;
debug("************************************************");
debug(" INPUT: " + input);
s = escapeComments(s);
debug(" escapeComments: " + s);
s = balanceHTML(s);
debug(" balanceHTML: " + s);
s = checkTags(s);
debug(" checkTags: " + s);
s = processRemoveBlanks(s);
debug("processRemoveBlanks: " + s);
s = validateEntities(s);
debug(" validateEntites: " + s);
debug("************************************************\n\n");
return s;
}
public boolean isAlwaysMakeTags(){
return alwaysMakeTags;
}
public boolean isStripComments(){
return stripComment;
}
private String escapeComments(final String s) {
final Matcher m = P_COMMENTS.matcher(s);
final StringBuffer buf = new StringBuffer();
if (m.find()) {
final String match = m.group(1); //(.*?)
m.appendReplacement(buf, Matcher.quoteReplacement("<!--" + htmlSpecialChars(match) + "-->"));
}
m.appendTail(buf);
return buf.toString();
}
private String balanceHTML(String s) {
if (alwaysMakeTags) {
//
// try and form html
//
s = regexReplace(P_END_ARROW, "", s);
s = regexReplace(P_BODY_TO_END, "<$1>", s);
s = regexReplace(P_XML_CONTENT, "$1<$2", s);
} else {
//
// escape stray brackets
//
s = regexReplace(P_STRAY_LEFT_ARROW, "<$1", s);
s = regexReplace(P_STRAY_RIGHT_ARROW, "$1$2><", s);
//
// the last regexp causes '<>' entities to appear
// (we need to do a lookahead assertion so that the last bracket can
// be used in the next pass of the regexp)
//
s = regexReplace(P_BOTH_ARROWS, "", s);
}
return s;
}
private String checkTags(String s) {
Matcher m = P_TAGS.matcher(s);
final StringBuffer buf = new StringBuffer();
while (m.find()) {
String replaceStr = m.group(1);
replaceStr = processTag(replaceStr);
m.appendReplacement(buf, Matcher.quoteReplacement(replaceStr));
}
m.appendTail(buf);
s = buf.toString();
// these get tallied in processTag
// (remember to reset before subsequent calls to filter method)
for (String key : vTagCounts.keySet()) {
for (int ii = 0; ii < vTagCounts.get(key); ii++) {
s += "</" + key + ">";
}
}
return s;
}
private String processRemoveBlanks(final String s) {
String result = s;
for (String tag : vRemoveBlanks) {
if(!P_REMOVE_PAIR_BLANKS.containsKey(tag)){
P_REMOVE_PAIR_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?></" + tag + ">"));
}
result = regexReplace(P_REMOVE_PAIR_BLANKS.get(tag), "", result);
if(!P_REMOVE_SELF_BLANKS.containsKey(tag)){
P_REMOVE_SELF_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?/>"));
}
result = regexReplace(P_REMOVE_SELF_BLANKS.get(tag), "", result);
}
return result;
}
private static String regexReplace(final Pattern regex_pattern, final String replacement, final String s) {
Matcher m = regex_pattern.matcher(s);
return m.replaceAll(replacement);
}
private String processTag(final String s) {
// ending tags
Matcher m = P_END_TAG.matcher(s);
if (m.find()) {
final String name = m.group(1).toLowerCase();
if (allowed(name)) {
if (!inArray(name, vSelfClosingTags)) {
if (vTagCounts.containsKey(name)) {
vTagCounts.put(name, vTagCounts.get(name) - 1);
return "</" + name + ">";
}
}
}
}
// starting tags
m = P_START_TAG.matcher(s);
if (m.find()) {
final String name = m.group(1).toLowerCase();
final String body = m.group(2);
String ending = m.group(3);
if (allowed(name)) {
String params = "";
final Matcher m2 = P_QUOTED_ATTRIBUTES.matcher(body);
final Matcher m3 = P_UNQUOTED_ATTRIBUTES.matcher(body);
final List<String> paramNames = new ArrayList<String>();
final List<String> paramValues = new ArrayList<String>();
while (m2.find()) {
paramNames.add(m2.group(1)); //([a-z0-9]+)
paramValues.add(m2.group(3)); //(.*?)
}
while (m3.find()) {
paramNames.add(m3.group(1)); //([a-z0-9]+)
paramValues.add(m3.group(3)); //([^\"\\s']+)
}
String paramName, paramValue;
for (int ii = 0; ii < paramNames.size(); ii++) {
paramName = paramNames.get(ii).toLowerCase();
paramValue = paramValues.get(ii);
if (allowedAttribute(name, paramName)) {
if (inArray(paramName, vProtocolAtts)) {
paramValue = processParamProtocol(paramValue);
}
params += " " + paramName + "=\"" + paramValue + "\"";
}
}
if (inArray(name, vSelfClosingTags)) {
ending = " /";
}
if (inArray(name, vNeedClosingTags)) {
ending = "";
}
if (ending == null || ending.length() < 1) {
if (vTagCounts.containsKey(name)) {
vTagCounts.put(name, vTagCounts.get(name) + 1);
} else {
vTagCounts.put(name, 1);
}
} else {
ending = " /";
}
return "<" + name + params + ending + ">";
} else {
return "";
}
}
// comments
m = P_COMMENT.matcher(s);
if (!stripComment && m.find()) {
return "<" + m.group() + ">";
}
return "";
}
private String processParamProtocol(String s) {
s = decodeEntities(s);
final Matcher m = P_PROTOCOL.matcher(s);
if (m.find()) {
final String protocol = m.group(1);
if (!inArray(protocol, vAllowedProtocols)) {
// bad protocol, turn into local anchor link instead
s = "#" + s.substring(protocol.length() + 1, s.length());
if (s.startsWith("#//")) {
s = "#" + s.substring(3, s.length());
}
}
}
return s;
}
private String decodeEntities(String s) {
StringBuffer buf = new StringBuffer();
Matcher m = P_ENTITY.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.decode(match).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
buf = new StringBuffer();
m = P_ENTITY_UNICODE.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.valueOf(match, 16).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
buf = new StringBuffer();
m = P_ENCODE.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.valueOf(match, 16).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
s = validateEntities(s);
return s;
}
private String validateEntities(final String s) {
StringBuffer buf = new StringBuffer();
// validate entities throughout the string
Matcher m = P_VALID_ENTITIES.matcher(s);
while (m.find()) {
final String one = m.group(1); //([^&;]*)
final String two = m.group(2); //(?=(;|&|$))
m.appendReplacement(buf, Matcher.quoteReplacement(checkEntity(one, two)));
}
m.appendTail(buf);
return encodeQuotes(buf.toString());
}
private String encodeQuotes(final String s){
if(encodeQuotes){
StringBuffer buf = new StringBuffer();
Matcher m = P_VALID_QUOTES.matcher(s);
while (m.find()) {
final String one = m.group(1); //(>|^)
final String two = m.group(2); //([^<]+?)
final String three = m.group(3); //(<|$)
m.appendReplacement(buf, Matcher.quoteReplacement(one + regexReplace(P_QUOTE, """, two) + three));
}
m.appendTail(buf);
return buf.toString();
}else{
return s;
}
}
private String checkEntity(final String preamble, final String term) {
return ";".equals(term) && isValidEntity(preamble)
? '&' + preamble
: "&" + preamble;
}
private boolean isValidEntity(final String entity) {
return inArray(entity, vAllowedEntities);
}
private static boolean inArray(final String s, final String[] array) {
for (String item : array) {
if (item != null && item.equals(s)) {
return true;
}
}
return false;
}
private boolean allowed(final String name) {
return (vAllowed.isEmpty() || vAllowed.containsKey(name)) && !inArray(name, vDisallowed);
}
private boolean allowedAttribute(final String name, final String paramName) {
return allowed(name) && (vAllowed.isEmpty() || vAllowed.get(name).contains(paramName));
}
}
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
* XSS过滤
*
*/
public class XssFilter implements Filter {
@Override
public void init(FilterConfig config) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request);
chain.doFilter(xssRequest, response);
}
@Override
public void destroy() {
}
}
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.MediaType;
/**
* XSS过滤处理
*
*/
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
private static final List<String> EXCLUSIVE_FIELDS = Arrays.asList("matter,remark".split(","));
//没被包装过的HttpServletRequest（特殊场景，需要自己过滤）
HttpServletRequest orgRequest;
//html过滤
private final static HTMLFilter htmlFilter = new HTMLFilter();
public XssHttpServletRequestWrapper(HttpServletRequest request) {
super(request);
orgRequest = request;
}
@Override
public ServletInputStream getInputStream() throws IOException {
//非json类型，直接返回
if(!super.getHeader("Content-Type").equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)){
return super.getInputStream();
}
//为空，直接返回
String json = IOUtils.toString(super.getInputStream(), "utf-8");
if (StringUtils.isBlank(json)) {
return super.getInputStream();
}
//xss过滤
json = xssEncode(json);
final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes());
return new ServletInputStream() {
@Override
public boolean isFinished() {
return true;
}
@Override
public boolean isReady() {
return true;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() throws IOException {
return bis.read();
}
};
}
@Override
public String getParameter(String name) {
String value = super.getParameter(xssEncode(name));
if (StringUtils.isNotBlank(value)) {
value = xssEncode(value);
}
return value;
}
@Override
public String[] getParameterValues(String name) {
String[] parameters = super.getParameterValues(name);
if (parameters == null || parameters.length == 0) {
return null;
}
/**
* 添加不过滤的字段值
*/
if (EXCLUSIVE_FIELDS.contains(name)) {
return parameters;
}
for (int i = 0; i < parameters.length; i++) {
parameters[i] = xssEncode(parameters[i]);
}
return parameters;
}
@Override
public Map<String,String[]> getParameterMap() {
Map<String,String[]> map = new LinkedHashMap<>();
Map<String,String[]> parameters = super.getParameterMap();
for (String key : parameters.keySet()) {
String[] values = parameters.get(key);
for (int i = 0; i < values.length; i++) {
values[i] = xssEncode(values[i]);
}
map.put(key, values);
}
return map;
}
@Override
public String getHeader(String name) {
String value = super.getHeader(xssEncode(name));
if (StringUtils.isNotBlank(value)) {
value = xssEncode(value);
}
return value;
}
private String xssEncode(String input) {
return htmlFilter.filter(input);
}
/**
* 获取最原始的request
*/
public HttpServletRequest getOrgRequest() {
return orgRequest;
}
/**
* 获取最原始的request
*/
public static HttpServletRequest getOrgRequest(HttpServletRequest request) {
if (request instanceof XssHttpServletRequestWrapper) {
return ((XssHttpServletRequestWrapper) request).getOrgRequest();
}
return request;
}
}
P.S. 三个 .java 文件缺一不可，代码可以直接使用，保证让你不再为 XSS 漏洞而头疼✌
其他漏洞及其解决方案
上面所讲的 SQL 注入和 XSS 漏洞都是最常见也是遇到次数最多的两种漏洞，所以说的就多了一些，接下来再跟大家简单说说其他漏洞及其解决方案~
LDAP注入
LDAP 注入是利用输入验证存在的漏洞注入可执行查询的攻击方式。LDAP 是轻量级目录访问协议，是一种开放的、跨平台的用于目录服务认证的协议。LDAP 是一种通信语言，应用程序可以利用它访问目录服务器。这些目录服务器通常存储用户名、密码、帐户详细信息和其他可以与网络上的其他实体共享的信息。当应用程序将未经处理的输入直接插入LDAP语句时，就会发生LDAP注入。在这种情况下，攻击者可以使用LDAP筛选器语法，这种语法可以让服务器执行其他查询和LDAP语句。
防止LDAP注入最简单的方法是确保LDAP特殊字符( ) ! | & *在验证时被转义或拒绝。
文件上传漏洞
文件上传漏洞通常由于网页代码中的文件上传路径变量过滤不严造成的，如果文件上传功能实现代码没有严格限制用户上传的文件后缀或者文件类型，攻击者可通过 Web 访问的目录上传任意文件，包括网站后门文件（webshell），进而远程控制网站服务器。
因此，在开发网站及应用程序过程中，需严格限制和校验上传的文件，禁止上传恶意代码的文件。同时限制相关目录的执行权限，防范webshell攻击。
未加密登录请求
由于 Web 配置不安全，登陆请求把诸如用户名和密码等敏感字段未加密进行传输，攻击者可以窃听网络以劫获这些敏感信息。所以就需要将这些敏感参数加密后在进行传输。
DDoS 攻击
DoS 攻击大家肯定都耳熟能详，它的全称是拒绝服务（Denial of Service），简单的说就是让一个公开网站无法访问，而 DDoS 攻击（分布式拒绝服务 Distributed Denial of Service）是 DoS 的升级版。这二者的区别也不大， DoS 攻击就是攻击者不断地提出服务请求，让合法用户的请求无法及时处理，从而让网站无法访问；DDoS 攻击则是攻击者使用多台计算机或者计算机集群进行 DoS 攻击。
防止 DDoS 攻击最直接的思路就是限流，限制单个用户的流量（包括 IP 等）。
XXE 漏洞（较为少见）
XXE 漏洞全称是 XML 外部实体漏洞（XML External Entity），当应用程序解析 XML 输入时，如果没有禁止外部实体的加载，导致可加载恶意外部文件和代码，就会造成任意文件读取、命令执行、内网端口扫描、攻击内网网站等攻击。这个漏洞只在能够接收 XML 格式参数的接口才会出现。其解决办法也比较直接，就是禁用外部实体。
P.S. XXE 漏洞比较少见，而且我对其也不是很了解，所以关于这个漏洞的解决办法就一笔带过了，各位见谅哈😂 如果有了解这个漏洞的小伙伴，欢迎在评论区留言。
弱密码漏洞
这个漏洞就很简单了，因为弱密码（Weak Password）很容易被别人（对你很了解的人等）猜到或被破解工具暴力破解，所以也就很容易让你的系统软件处于一个极度不安全的状态。这个漏洞的解决方案也很简单，就是让你的密码有足够大的复杂度和足够的隐蔽性，同时可以限制尝试密码的次数。
HTTP 报头追踪漏洞
HTTP/1.1（RFC2616）规范定义了 HTTP TRACE 方法，主要是用于客户端通过向 Web 服务器提交 TRACE 请求来进行测试或获得诊断信息。当 Web 服务器启用 TRACE 时，提交的请求头会在服务器响应的内容（Body）中完整的返回，其中 HTTP 头很可能包括 Session Token、Cookies 或其它认证信息，进而攻击者就可以利用此漏洞来欺骗合法用户并得到他们的私人信息。我们只需要禁用 HTTP TRACE 方法即可解决此漏洞。
系统相关业务漏洞
由于系统的设计存在缺陷，因此就会导致系统中的某些业务模块存在漏洞，比如重放攻击（伪装支付）、权限控制（越权操作）等等。解决此类漏洞就没有统一的办法了，只能辛苦小伙伴们一点一点排查了😂。
小结
最后总结起来就是一句话：世界上没有绝对安全的系统，是人都会犯错，再🐂批的人也会写出存在问题的代码，所以系统安全问题不容忽视，一个小小的漏洞就可能会引发巨大的灾难。
本人经验有限，有些地方可能讲的没有特别到位，如果您在阅读的时候想到了什么问题，欢迎在评论区留言，我们后续再一一探讨🙇
希望各位小伙伴动动自己可爱的小手，来一波点赞+关注 (✿◡‿◡) 让更多小伙伴看到这篇文章~ 蟹蟹呦(●’◡’●)
如果文章中有错误，欢迎大家留言指正；若您有更好、更独到的理解，欢迎您在留言区留下您的宝贵想法。
你在被打击时，记起你的珍贵，抵抗恶意；
你在迷茫时，坚信你的珍贵，抛开蜚语；
爱你所爱 行你所行 听从你心 无问东西
9327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
