python8爬虫框架,适用于WebApi的SQL注入过滤器

开发工具:Visual Studio 20一七
C#版本:C#7.1

爬虫框架

  1. ##### BeautifulSoup

  2. 功能
    BeautifulSoup是用来从HTML或XML中领到数据的Python库。

  3. 导入
  4. 应用办法:
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(html)
  5. 目的体系
    有八种档案的次序:Tag,NavigableString,BeautifulSoup,Comment。
    BeautifulSoup将文书档案转化为树形结构,种种节点都以上述各个档案的次序的Python对象。
  • Tag
    与XML和HTML中Tag对象一样。
    如:
    soup = BeautifulSoup(<b class="boldest">Extremely bold</b>)
    soup.b正是二个Tag对象。

      1. Name
        tag.name 可获取,可更改
      1. Attribute
        八个Tag对象能够有四个属性,操作方法和字典同样,如上述Tag对象b就有1个class属性:
        soup.b['class']
        依然应用get方法soup.b.get(‘class’)
        获得具备属性键值对
        soup.b.attrs
        tag的习性可增加、删除(del
        soup.b[‘class’])、修改,和字典方法一致。
        只要一天性质key对应七个value,则赶回3个value的list,如:

css_soup = BeautifulSoup('<p class="body strikeout" name="lzy"></p>') 
print css_soup.p.attrs
输出:{'class': ['body', 'strikeout'], 'name': 'lzy'}

这种多个值的性质是索要在HTML中有定义的,假设并不曾被定义为多值属性,则赶回字符串:

id_soup = BeautifulSoup('')
id_soup.p['id']
输出'my id'

若是调换的是XML文书档案,则不会设有多值属性,重回字符串。
可以运用list或字符串对质量赋值。

  • NavigableString
    Tag中的字符串即为NavigableString对象。
    tag.string
    在BeautifulSoup之外使用该项目,推荐转换为Unicode:
    unicode(Tag.string)
    tag中蕴藏的字符串不得编辑,只可以替换
    tag.string.replace_with(new string)
    tag能够包涵其余tag或字符串,而NavigableString则不能够包蕴其余对象。不支持.content,.string,find(),只辅助部分遍历文书档案树和查找文书档案树中的属性。

  • BeautifulSoup
    意味着的是2个文书档案的全体内容,一大半情状可看做Tag对象,辅助遍历文书档案树和搜索文书档案树的绝大许多性质。
    而在HTML或XML中并从未名字为BeautifulSoup的Tag,所以并未name和attribute属性,可是有个新鲜性质:

soup.name
输出u'[document]'
  • Comment
    Comment类型是NavigableString类型的子类,BeautifulSoup中也有雷同道理的某些其它类型。

<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>
 Elsie 
<class 'bs4.element.Comment'>

大家在运用前最佳做一下剖断,剖断代码如下

if type(soup.a.string)==bs4.element.Comment:
    print soup.a.string
  1. 遍历文书档案树
    BeautifulSoup对象作为一棵树,有多少个节点。对于七个节点,相对于它所在的职责,有子节点、父节点、兄弟节点。
  • 子节点
    贰个Tag可含蓄多少个Tag以及字符串,这个都是那些Tag的子节点。而NavigableString不会有子节点。
    如若想要得到有个别Tag,上述已涉嫌方法:
    soup.tag_name
    透过点取属性,只好获得当前名字的第一个tag,
    若要获取具有,必要利用寻找文书档案树中的方法:
    soup.find_all('tag_name')
    tag的.contents属性可将全部子节点以列表的措施出口。
    可因而tag的.children生成器,对全部子节点开始展览遍历。
    .contents和.children只对得到Tag的直接子节点,.descendants可用于对Tag的具备子孙节点进行遍历。
    如果tag唯有三个NavigableString类型子节点,则可用.string获取。如果带有八个,使用.strings遍历。若输出的字符串中蕴藏空格或空行,使用.stripped_strings去除。
  • 父节点
    近来节点的父节点:.parent
    当前节点的具有父辈节点:.parents
  • 兄弟节点
    具备同等父节点的节点之间。
    .next_sibling
    .previous_sibling
    同理,全体兄弟节点:
    .next_siblings
    .previous_siblings
    本着下二个或上3个解析对象:不区分层级
    .next_element
    .previous_element
    .next_elements
    .previous_elements
  1. 追寻文书档案树
    时常应用的二种办法: find(str)find_all(str)
    里头的str,代表了tag的name。能够是纯字符串、正则表达式、列表(任一匹配就满意条件,是或运算)、True(重临全体Tag节点不回去字符串节点)
    另1种入参不是str,而是method。此办法是贰个函数,只接受一个要素入参,若此函数再次回到True表示入参匹配供给。举个例子:

def has_class_but_no_id(tag): 
return tag.has_attr('class') and not tag.has_attr('id')

综上,过滤器包涵:纯字符串、正则表达式、列表、True、方法那两种。

  1. find_all(name,attrs,recursive,text,kwargs)
    该办法寻找
    眼下节点的兼具tag子节点。**

- name参数:

指的是tag的name属性,字符串对象活动忽略。
过滤器能够采纳壹切连串。

  • keyword参数:
    比如3个入参钦定了名字,但是并不是上述提到的入参名字,寻找时会把该入参当做是tag的质量来探求。比方:
    soup.find_all(id='link2')
    会重回tag中存在属性id,并且id对应的值是link2的tag。
    以上措施可应用除方法之外的享有过滤器。
  • 少数特殊属性不可能这么一直利用,则应用如下方法:
    soup.find_all(attrs={"key":"value"})
    譬如说要选取class属性实行检索,由于class是python中的保留字,无法直接写成入参,近期有二种办法:

    soup.findall(‘tag.name’,class=’class_value’)
    soup.find_all(‘tag.name’,attrs={‘class’:’class_value’})

class_措施能够选取任何过滤器。
其余,因为class是叁个多值属性,所以只供给协作2个值,就能够赢得结果,所谓的不完全同盟。
接纳完全相称时,过滤器中的字符顺序要求和实际相契合本领得到相应结果。

  • text参数:
    寻觅的是Tag中的字符串内容,可应用全数过滤器。
  • limit参数:
    界定重返数量。
  • recursive参数:
    find_all()暗中同意是找出当前节点的装有子孙节点,若只须要研究间接的子节点,则设置recursive=False

    find_all()是实际受骗中用的最布满的。

从而有了等价的简化版:

soup('a')```

  2. find(name,attrs,recursive,text,**kwargs)
find()方法等价于find_all(limit=1),返回符合条件的第一个对象。
区别在于,前者直接返回结果,后者返回只有一个元素的列表。若没有对象符合条件,前者返回None,后者返回空列表。
它也有简化版:

soup.find(‘head’).find(‘title’)
soup.head.title

除了find()和find_all()之外还有一些搜索的方法:
find_parent()
find_next_sibling()
find_previous_sibling()
上面三种可以在后面加's'表示所有。
find_next()
find_previous()
find_all_next()
find_all_previous()

  3. CSS选择器
Tag或BeautifulSoup对象的.select()方法。

7. **输出**
prettify()将文档树格式化之后输出。
若不注重格式,则可使用python的str()或unicode()。
如果想得到tag中包含的文本内容,使用get_text(),可获取到当前节点的文本,以及子孙节点中的文本。返回的是Unicode。
可以指定参数设置分隔符如get_text("|")是以“|”作为分隔符。
get_text(strip=True)可去除文本前后的空白。
或者用.stripped_strings进行遍历。

7. **文档解析器**
BeautifulSoup的第一个入参是文档,第二个入参是文档解析器,默认情况下的优先顺序是:lxml, html5lib,python标准库。其中只有lxml支持xml文档的解析。

不久前径直在用BeautifulSoup,可是语法很轻易忘记。在那边做个学习计算吧。

最可行的警务器材SQL注入的法子是调用数据库时使用参数化查询。
但是1旦是继任二个旧的WebApi项目,不想改很多的数据库访问层的代码,应该怎么办。

参考:

我的消除方案是加3个过滤器。

Beautiful Soup 4.2.0
文档

先写过滤方法,上代码

功能

BeautifulSoup是用来从HTML或XML中领取数额的Python库。


using System;
using System.Collections.Generic;
using System.Web;

namespace Test
{
    /// <summary>
    /// 防止SQL注入
    /// </summary>
    public class AntiSqlInject
    {
        public static AntiSqlInject Instance = new AntiSqlInject();

        /// <summary>
        /// 初始化过滤方法
        /// </summary>
        static AntiSqlInject()
        {
            SqlKeywordsArray.AddRange(SqlSeparatKeywords.Split('|'));
            SqlKeywordsArray.AddRange(Array.ConvertAll(SqlCommandKeywords.Split('|'), h => h + " "));
            SqlKeywordsArray.AddRange(Array.ConvertAll(SqlCommandKeywords.Split('|'), h => " " + h));
        }

        private const string SqlCommandKeywords = "and|exec|execute|insert|select|delete|update|count|chr|mid|master|" +
                                                  "char|declare|sitename|net user|xp_cmdshell|or|create|drop|table|from|grant|use|group_concat|column_name|" +
                                                  "information_schema.columns|table_schema|union|where|select|delete|update|orderhaving|having|by|count|*|truncate|like";

        private const string SqlSeparatKeywords = "'|;|--|\'|\"|/*|%|#";

        private static readonly List<string> SqlKeywordsArray = new List<string>();

        /// <summary>
        /// 是否安全
        /// </summary>
        /// <param name="input">输入</param>
        /// <returns>返回</returns>
        public bool IsSafetySql(string input)
        {
            if (string.IsNullOrWhiteSpace(input))
            {
                return true;
            }
            input = HttpUtility.UrlDecode(input).ToLower();

            foreach (var sqlKeyword in SqlKeywordsArray)
            {
                if (input.IndexOf(sqlKeyword, StringComparison.Ordinal) >= 0)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 返回安全字符串
        /// </summary>
        /// <param name="input">输入</param>
        /// <returns>返回</returns>
        public string GetSafetySql(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return string.Empty;
            }
            if (IsSafetySql(input)) { return input; }
            input = HttpUtility.UrlDecode(input).ToLower();

            foreach (var sqlKeyword in SqlKeywordsArray)
            {
                if (input.IndexOf(sqlKeyword, StringComparison.Ordinal) >= 0)
                {
                    input = input.Replace(sqlKeyword, string.Empty);
                }
            }
            return input;
        }
    }
}

导入

动用情势:
from bs4 import BeautifulSoup
soup = BeautifulSoup(html)


接下来是过滤器,先上代码

编码

soup使用Unicode编码。


using System.Web.Http.Controllers;
using System.Web.Http.Filters;

namespace Test
{
    /// <inheritdoc>
    ///     <cref></cref>
    /// </inheritdoc>
    /// <summary>
    /// SQL注入过滤器
    /// </summary>
    public class AntiSqlInjectFilter : ActionFilterAttribute
    {
        /// <inheritdoc />
        /// <summary>
        /// </summary>
        /// <param name="filterContext"></param>
        public override void OnActionExecuting(HttpActionContext filterContext)
        {
            base.OnActionExecuting(filterContext);
            var actionParameters = filterContext.ActionDescriptor.GetParameters();

            var actionArguments = filterContext.ActionArguments;

            foreach (var p in actionParameters)
            {
                var value = filterContext.ActionArguments[p.ParameterName];

                var pType = p.ParameterType;

                if (value == null)
                {
                    continue;
                }
                //如果不是值类型或接口,不需要过滤
                if (!pType.IsClass) continue;

                if (value is string)
                {
                    //对string类型过滤
                    filterContext.ActionArguments[p.ParameterName] = AntiSqlInject.Instance.GetSafetySql(value.ToString());
                }
                else
                {
                    //是一个class,对class的属性中,string类型的属性进行过滤
                    var properties = pType.GetProperties();
                    foreach (var pp in properties)
                    {
                        var temp = pp.GetValue(value);
                        if (temp == null)
                        {
                            continue;
                        }
                        pp.SetValue(value, temp is string ? AntiSqlInject.Instance.GetSafetySql(temp.ToString()) : temp);
                    }
                }
            }

        }
    }
}

对象类别

有柒类别型:Tag,NavigableString,BeautifulSoup,Comment。
BeautifulSoup将文书档案转化为树形结构,每一个节点都是上述7类别型的Python对象。

思路是,加过滤器承袭ActionFilterAttribute,重写OnActionExecuting方法,获取入参,对入参中的string类型的具有数据举行过滤。三种情形,壹是参数是string类型,二是类的习性。过滤器解决。

1.Tag

与XML和HTML中Tag对象一样。
如:
soup = BeautifulSoup(<b class=”boldest”>Extremely
bold</b>)

soup.b正是一个Tag对象。

  1. Name
    tag.name 可获取,可更改

  2. Attribute
    三个Tag对象能够有多少个天性,操作方法和字典同样,如上述Tag对象b就有二个class属性:
    soup.b[‘class’]
    要么采纳get方法soup.b.get(‘class’)

赢得具有属性键值对:
soup.b.attrs

tag的特性可拉长、删除(del soup.b[‘class’])、修改,和字典方法一样。

若果1个性子key对应多个value,则赶回两个value的list,如:
css_soup = BeautifulSoup(‘<p class=”body
strikeout”></p>’)

css_soup.p[‘class’]
输出:[“body”, “strikeout”]

那种多个值的性格是亟需在HTML中有定义的,假使并不曾被定义为多值属性,则赶回字符串:
id_soup = BeautifulSoup(‘<p id=”my id”></p>’)
id_soup.p[‘id’]
输出‘my id’
假定转变的是XML文档,则不会存在多值属性,重回字符串。

能够应用list或字符串对性能赋值。

过滤器有二种接纳情势,1种是在具体的秘技上加多

2. NavigableString

Tag中的字符串即为NavigableString对象。
tag.string
在BeautifulSoup之外使用该品种,推荐转变为Unicode:
unicode(Tag.string)

tag中隐含的字符串不可编辑,只好替换:
tag.string.replace_with(new string)

tag能够包含别的tag或字符串,而NavigableString则不能够包蕴其余对象。不帮忙.content,.string,find(),只帮助部分遍历文书档案树和探索文书档案树中的属性。

        [HttpPut,Route("api/editSomething")]
        [AntiSqlInjectFilter]
        public async Task<bool> EditSomeThingAsync([FromBody]SomeThingmodel)
        {
            var response = await SomeThingBusiness.Editsync(model);
            return response;
        }
3. BeautifulSoup

代表的是一个文书档案的全体内容,超越十分之5景色可视作Tag对象,协助遍历文书档案树和查究文书档案树的许多属性。
而在HTML或XML中并不曾名称为BeautifulSoup的Tag,所以并不曾name和attribute属性,不过有个奇脾品质:
soup.name
输出u'[document]’

1种是大局配置,在WebApiConfig.cs文件中的Register方法中增加过滤器

4. Comment

Comment类型是NavigableString类型的子类,BeautifulSoup中也有平等道理的部分其余项目。


using System.Web.Http;

namespace Test
{
    /// <summary>
    /// WebApi配置
    /// </summary>
    public static class WebApiConfig
    {
        /// <summary>
        /// 注册配置服务
        /// </summary>
        /// <param name="config"></param>
        public static void Register(HttpConfiguration config)
        {                      
            // Web API 路由
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            //全局配置防止SQL注入过滤
            config.Filters.Add(new AntiSqlInjectFilter());
        }
    }
}

遍历文书档案树

BeautifulSoup对象作为1棵树,有八个节点。对于1个节点,相对于它所在的职务,有子节点、父节点、兄弟节点。

测试有效。

1. 子节点

一个Tag可含蓄三个Tag以及字符串,那个都以那些Tag的子节点。而NavigableString不会有子节点。

壹经想要得到有个别Tag,上述已关乎方法:
soup.tag_name
通过点取属性,只好得到当前名字的第一个tag,若要获取具有,需求使用搜索文书档案树中的方法:
soup.find_all(‘tag_name’)

tag的.contents性情可将全部子节点以列表的格局出口。
可通过tag的.children生成器,对全部子节点举行遍历。

.contents.children只对得到Tag的直接子节点,.descendants可用来对Tag的享有子孙节点进行遍历。

只要tag唯有二个NavigableString类型子节点,则可用.string赢得。假若带有多个,使用.strings遍历。若输出的字符串中包含空格或空行,使用.stripped_strings去除。

2. 父节点

当前节点的父节点:.parent
当下节点的富有父辈节点:.parents

3. 小兄弟节点

抱有同样父节点的节点之间。
.next_sibling
.previous_sibling
同理,全部兄弟节点:
.next_siblings
.previous_siblings

针对下二个或上一个剖析对象:
.next_element
.previous_element
.next_elements
.previous_elements


检索文档树

不时应用的二种办法:find(str)和find_all(str)。
其间的str,代表了tag的name。能够是纯字符串、正则表达式、列表(任1匹配就满意条件,是或运算)、True(再次来到全体Tag节点不回去字符串节点)。

另1种入参不是str,而是method。此方法是2个函数,只接受一个成分入参,若此函数再次来到True表示入参相配供给。举个例子:
*def has_class_but_no_id(tag): *
return tag.has_attr(‘class’) and not tag.has_attr(‘id’)

综上,过滤器包蕴:纯字符串、正则表达式、列表、True、方法那两种。

1. find_all(name,attrs,recursive,text,**kwargs)

该方法寻觅当前节点的具备tag子节点。

name参数:
指的是tag的name属性,字符串对象活动忽略。
过滤器可以应用全数品类。

keyword参数:
一经三个入参钦点了名字,不过并不是上述提到的入参名字,找寻时会把该入参当做是tag的习性来找出。比如:
soup.find_all(id=’link2′)
会回去tag中设有属性id,并且id对应的值是link二的tag。
上述措施可利用除方法之外的拥有过滤器。

一些特殊性质无法那样直接运用,则运用如下方法:
soup.find_all(attrs={“key”:”value”})

比如要利用class属性进行搜寻,由于class是python中的保留字,无法直接写成入参,近期有三种格局:
soup.find_all(‘tag.name’,class_=’class_value’)
soup.find_all(‘tag.name’,attrs={‘class’:’class_value’})
class_情势能够应用全部过滤器。
除此以外,因为class是3个多值属性,所以只需求相配七个值,就能够收获结果,所谓的不完全合作。
应用完全匹配时,过滤器中的字符顺序需求和骨子里相契合才能博得相应结果。

text参数:
搜索的是Tag中的字符串内容,可利用成套过滤器。

limit参数:
限制重临数量。

recursive参数:
find_all()暗中认可是探索当前节点的兼具子孙节点,若只需求寻觅间接的子节点,则设置recursive=False

find_all()是事实受愚中用的最常见的。
故而有了等价的简化版:
soup.find_all(‘a’)
soup(‘a’)

2. find(name,attrs,recursive,text,**kwargs)

find()方法等价于find_all(limit=一),再次来到符合条件的率先个对象。
不一样在于,前者间接重返结果,后者再次来到唯有二个因素的列表。若未有目的符合条件,前者重返None,后者再次回到空列表。

它也有简化版:
soup.find(‘head’).find(‘title’)
soup.head.title

除了find()和find_all()之外还有壹对招来的不二等秘书籍:
find_parent()
find_next_sibling()
find_previous_sibling()
地点两种能够在前面加’s’表示具备。
find_next()
find_previous()
find_all_next()
find_all_previous()

3. CSS选择器

Tag或BeautifulSoup对象的.select()方法。


修改文书档案树

暂略


输出

prettify()将文书档案树格式化之后输出。
若不讲究格式,则可选择python的str()unicode()88bifa必发唯一官网,。

假诺想获得tag中包蕴的文件内容,使用get_text(),可获取到当下节点的文件,以及子孙节点中的文本。重临的是Unicode。
能够钦赐参数设置分隔符如get_text(“|”)是以“|”作为分隔符。
get_text(strip=True)可去除文本前后的空域。
或者用.stripped_strings开始展览遍历。


文书档案解析器

BeautifulSoup的率先个入参是文书档案,第二个入参是文书档案解析器,私下认可情形下的事先顺序是:lxml,
html5lib,python标准库。在那之中唯有lxml扶助xml文书档案的分析。


编码

soup使用Unicode编码。
BeautifulSoup进行了编码检查实验并自行转为Unicode。
BeautifulSoup对象的.original_encoding特性来获取自动识别编码的结果。
当然如此相当的慢,有时候会出错。能够在开立BeautifulSoup对象时,钦命入参from_encoding来报告文书档案的编码格局。

偶然转码时有点与众不同字符替换来了超过常规规的Unicode,可因而BeautifulSoup对象的.contains_repalcement_characters天性来判别是或不是有此情状,为True即为有标新立异替换。

出口编码统1为UTF8,若想要其他的编码,则和一般的python字符串同样,须求实行手动设置。

应用chartdet库可抓牢编码检测频率。