python Django kindEditor，双层视图查找，CMDB开发，JSONP，XSS攻击

本文链接：https://blog.csdn.net/qq_42124842/article/details/101727341

Django kindEditor，CMDB开发，JSONP，XSS攻击

kindEditor
双层视图查找
CMDB 开发
JSONP
XSS攻击

1，kindEditor

pip3 install beautifulsoup4
beautifulsoup4 对标签进行过滤
单例模式

实例：

@check_login
def add_article(request):
    """
    添加文章
    :param request:
    :return:
    """
    if request.method == 'GET':
        form = ArticleForm(request=request)
        return render(request, 'backend_add_article.html', {'form': form})
    elif request.method == 'POST':
        form = ArticleForm(request=request, data=request.POST)
        if form.is_valid():

            with transaction.atomic():
                tags = form.cleaned_data.pop('tags')
                content = form.cleaned_data.pop('content')
                print(content)
                content = XSSFilter().process(content)
                form.cleaned_data['blog_id'] = request.session['user_info']['blog__nid']
                obj = models.Article.objects.create(**form.cleaned_data)
                models.ArticleDetail.objects.create(content=content, article=obj)
                tag_list = []
                for tag_id in tags:
                    tag_id = int(tag_id)
                    tag_list.append(models.Article2Tag(article_id=obj.nid, tag_id=tag_id))
                models.Article2Tag.objects.bulk_create(tag_list)

            return redirect('/backend/article-0-0.html')
        else:
            return render(request, 'backend_add_article.html', {'form': form})
    else:
        return redirect('/')

2，双层视图查找

函数形式 + 前后端语言

在这里插入图片描述
实例：

filter.py

from django import template
from django.utils.safestring import mark_safe

register = template.Library()

@register.simple_tag
def filter_all(arg_dict,k):
    """
    {% if arg_dict.article_type_id == 0 %}
        <a class="active" href="/article-0-{{ arg_dict.category_id }}.html">全部</a>
    {% else %}
        <a  href="/article-0-{{ arg_dict.category_id }}.html">全部</a>
    {% endif %}
    :return:
    """
    if k == 'article_type_id':
        n1 = arg_dict['article_type_id']
        n2 = arg_dict['category_id']
        if n1 == 0:
            ret = '<a class="active" href="/article-0-%s.html">全部</a>' % n2
        else:
            ret = '<a href="/article-0-%s.html">全部</a>' % n2
    else:
        n1 = arg_dict['category_id']
        n2 = arg_dict['article_type_id']
        if n1 == 0:
            ret = '<a class="active" href="/article-%s-0.html">全部</a>' % n2
        else:
            ret = '<a href="/article-%s-0.html">全部</a>' % n2

    return mark_safe(ret)

@register.simple_tag
def filter_article_type(article_type_list,arg_dict):
    """
    {% for row in article_type_list %}
        {% if row.id == arg_dict.article_type_id %}

        {% else %}
            <a  href="/article-{{ row.id  }}-{{ arg_dict.category_id }}.html">{{ row.caption }}</a>
        {% endif %}
    {% endfor %}
    :return:
    """
    ret = []
    for row in article_type_list:
        if row.id == arg_dict['article_type_id']:
            temp = '<a class="active" href="/article-%s-%s.html">%s</a>' %(row.id,arg_dict['category_id'],row.caption,)
        else:
            temp = '<a href="/article-%s-%s.html">%s</a>' %(row.id,arg_dict['category_id'],row.caption,)
        ret.append(temp)
    return mark_safe(''.join(ret))

article.html

{% load filter %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .condition a{
            display: inline-block;
            padding: 3px 5px;
            border: 1px solid #ddd;
            margin: 5px;
        }
        .condition a.active{
            background-color: brown;
        }
    </style>
</head>
<body>
    <h1>过滤条件</h1>
    <div class="condition">
        <div>
            {% filter_all arg_dict 'article_type_id' %}
            {% filter_article_type article_type_list arg_dict %}
        </div>

        <div>
            {% filter_all arg_dict 'category_id' %}
            {% for row in category_list %}
                {% if row.id == arg_dict.category_id %}
                    <a class="active" href="/article-{{ arg_dict.article_type_id }}-{{ row.id  }}.html">{{ row.caption }}</a>
                {% else %}
                    <a href="/article-{{ arg_dict.article_type_id }}-{{ row.id  }}.html">{{ row.caption }}</a>
                {% endif %}
            {% endfor %}
        </div>
    </div>
{% comment %}
<div class="condition">
        <div>
            {% if arg_dict.article_type_id == 0 %}
                <a class="active" href="/article-0-{{ arg_dict.category_id }}.html">全部</a>
            {% else %}
                 <a href="/article-0-{{ arg_dict.category_id }}.html">全部</a>

            {% endif %}

            {% for row in article_type_list %}

                {% if row.id == arg_dict.article_type_id %}
                    <a class="active" href="/article-{{ row.id }}-{{ arg_dict.category_id }}.html">{{ row.caption }}</a>
                {% else %}
                    <a href="/article-{{ row.id }}-{{ arg_dict.category_id }}.html">{{ row.caption }}</a>
                {% endif %}

            {% endfor %}

        <div>
            {% if arg_dict.category_id == 0 %}
                <a class="active" href="/article-{{ arg_dict.article_type_id }}-0.html">全部</a>
            {% else %}
                 <a href="/article-{{ arg_dict.article_type_id }}-0.html">全部</a>
            {% endif %}


            {% for row in category_list %}

                {% if row.id == arg_dict.category_id %}
                    <a class="active" href="/article-0-{{ arg_dict.category_id }}.html">{{ row.caption }}</a>
                {% else %}
                    <a href="/article-{{ arg_dict.article_type_id}}-{{ row.id }}.html">{{ row.caption }}</a>
                {% endif %}

            {% endfor %}
        </div>
    </div>
    {% endcomment %}

    <h1>查询结果</h1>
    <ul>
    {% for row in result %}
        <li>{{ row.id }}-{{ row.title }}</li>
    {% endfor %}
    </ul>

</body>
</html>

views.py

from django.shortcuts import render
from app01 import models
# Create your views here.

def article(request,*args,**kwargs):
    # print(request.path_info) #获取当前URL
    # from django.urls import reverse
    # # {'article_type_id':'0','category_id':'0'}
    # url = reverse('article',kwargs={'article_type_id':'1','category_id':'0'})
    # print(url)

    print(kwargs) # {'article_type_id':'0','category':'0'}

    condition = {}

    for k,v in kwargs.items():
        kwargs[k] = int(v)
        if v == '0':
            pass
        else:
            condition[k] = v

    article_type_list = models.ArticleType.objects.all()
    category_list = models.Category.objects.all()

    result = models.Article.objects.filter(**condition)
    return render(
        request,
        'article.html',
        {
            'result':result,
            'article_type_list':article_type_list,
            'category_list':category_list,
            'arg_dict':kwargs,
        }
    )

models.py

from django.db import models

# Create your models here.
class Category(models.Model):
    # caption 说明文字
    # category 种类，类别
    caption = models.CharField(max_length=16)

class ArticleType(models.Model):
    caption = models.CharField(max_length=16)

class Article(models.Model):
    title = models.CharField(max_length=64)
    content = models.CharField(max_length=255)

    category = models.ForeignKey(to='Category',to_field='id',on_delete='CASCADE')
    article_type = models.ForeignKey(to='ArticleType',to_field='id',on_delete='CASCADE')

    # 删除 表ArticleType 也可以用下面的代替，其中相应的就要变为row.[0]之类
    # type_choice = {
    #     (1,'Python'),
    #     (2,'OpenStack'),
    #     (3,'Linux'),
    # }
    # article_type_id = models.IntegerField(choices=type_choice)

事务操作

 from django.db import transaction
 def home(request, site):

筛选条件

 利用数据库内置函数实现筛选

3，CMDB 开发

浅谈ITIL

    TIL即IT基础架构库(Information Technology Infrastructure Library, ITIL，信息技术基础架构库),主要适用于IT服务管理（ITSM）。ITIL为企业的IT服务管理实践提供了一个客观、严谨、可量化的标准和规范。
    1、事件管理（Incident Management）
    事故管理负责记录、归类和安排专家处理事故并监督整个处理过程直至事故得到解决和终止。事故管理的目的是在尽可能最小地影响客户和用户业务的情况下使IT系统恢复到服务级别协议所定义的服务级别。
    目标是：在不影响业务的情况下，尽可能快速的恢复服务，从而保证最佳的效率和服务的可持续性。事件管理流程的建立包括事件分类，确定事件的优先级和建立事件的升级机制。
    2、问题管理（Problem Management）
    问题管理是指通过调查和分析IT基础架构的薄弱环节、查明事故产生的潜在原因，并制定解决事故的方案和防止事故再次发生的措施，将由于问题和事故对业务产生的负面影响减小到最低的服务管理流程。与事故管理强调事故恢复的速度不同，问题管理强调的是找出事故产生的根源，从而制定恰当的解决方案或防止其再次发生的预防措施。
    目标是：调查基础设施和所有可用信息，包括事件数据库，来确定引起事件发生的真正潜在原因，一起提供的服务中可能存在的故障。
    3、配置管理（Configuration Management）
    配置管理是识别和确认系统的配置项，记录和报告配置项状态和变更请求，检验配置项的正确性和完整性等活动构成的过程，其目的是提供IT基础架构的逻辑模型，支持其它服务管理流程特别是变更管理和发布管理的运作。
    目标是：定义和控制服务与基础设施的部件，并保持准确的配置信息。
    4、变更管理（Change Management）
    变更管理是指为在最短的中断时间内完成基础架构或服务的任一方面的变更而对其进行控制的服务管理流程。变更管理的目标是确保在变更实施过程中使用标准的方法和步骤，尽快地实施变更，以将由变更所导致的业务中断对业务的影响减小到最低。
    目标是：以受控的方式，确保所有变更得到评估、批准、实施和评审。
    5、发布管理（Release Management）
     发布管理是指对经过测试后导入实际应用的新增或修改后的配置项进行分发和宣传的管理流程。发布管理以前又称为软件控制与分发。
    目标是：在实际运行环境的发布中，交付、分发并跟踪一个或多个变更。

CMDB

Configuration Management Database 配置管理数据库配置管理数据库,
CMDB存储与管理企业IT架构中设备的各种配置信息，
它与所有服务支持和服务交付流程都紧密相联，支持这些流程的运转、
发挥配置信息的价值，同时依赖于相关流程保证数据的准确性。

1，资产自动收集
2，API URL
3，可视化管理

1，资产自动收集

-paramiko,ansible,fabric
 通过API获取主机名，利用paramiko链接服务获取数据库，解析成字典
 优点：无依赖
 缺点：慢

-saltstack
 通过API获取主机名，利用salt api 链接服务获取数据，解析成字典
 优点：无依赖
 缺点：有点慢

 -puppet
     - 知识概要：
      master
      slave:certname
      slave:certname
      配置文件：30分钟 master 和 slave 进行一次连接

     -report 报表
      配置文件
         report：cmdb #每30分钟交互时，会执行目录下的cmdb.rb 文件中的process函数
     -自定义factor
 -Agent
     - 缺点：每台有agent
     - 优点：快
     v =  subprocess.output('hostname')
-------- 执行 shell 命令[网卡][硬盘]...获取结果 -------

-资产采集
-API(API认证)
-可视化管理

4，JSONP - 棘手的问题

import requests
request.get('http://www.baidu.com')
request.post('http://www.baidu.com')

同源策略

	由于浏览器具有同源策略（阻止浏览器直接发Ajax请求，但是无法阻止<script src='...'></script> ）
同源策略，也就是浏览器向自己域名下发送请求，而不能向其他域名发送请求，拿取数据
（也可以通过 自己的服务端（views.py 函数）请求后把数据放上去（放到前端页面上））

跨域请求

巧妙：
-创建 script 标签
-src = 远程地址
-返回的数据必须是js格式

实例：

account.py

def jsonp(request):
    func = request.GET.get('callback')
    content = '%s(100000)' %(func,)
    return HttpResponse(content)

req.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>

</head>
<body>
<h1>后台获取的结果</h1>
{{ result }}
<h1>js 直接获取结果</h1>
<input type="button" value="获取数据" onclick="getContent();">
<div id="container"></div>

<script src="/static/jquery-3.4.1.js"></script>
<script>
    function getContent() {

        /*
        var xhr = new XMLHttpRequest();
        xhr.open('GET','http://wupeiqi.com:8001/jsonp.html?k1=v1&k2=v2');
        xhr.onreadystatechange = function () {
            console.log(xhr.responseText);
        };
        xhr.send();
        */
        /*
        var tag = document.createElement('script');
        tag.src ='http://www.jxntv.cn/data/jmd-jxtv2.html?callback=list&_=1454376870403';
        document.head.appendChild(tag);
        document.head.removeChild(tag);
        */
        $.ajax({
            url:'http://www.jxntv.cn/data/jmd-jxtv2.html',
            type:'POST',
            dataType:'jsonp',
            jsonp:'callback',
            jsonpCallback:'list'
        });
        function list(arg) {
            console.log(arg)
        }
    }
</script>
</body>
</html>

5，XSS攻击（过滤的函数和类）

特殊标签过滤
白名单

实例：

test.py

__author__ = 'baobaohui'
content="""
<p class='c1' id='i1'>
   asdfaa<span style="font-family:NSimSun;">sdf<a>a</a>sdf</span>sdf
</p>
<p>
   <strong class='c2' id='i2'>asdf</strong>
   <script>alert(123)</script>
</p>
<h2>
   asdf
</h2>
"""
#白名单
tags = {
   'p': ['class'],
   'strong': ['id',]
}
from bs4 import BeautifulSoup
soup = BeautifulSoup(content, 'html.parser')

for tag in soup.find_all():
   if tag.name in tags:
      pass
   else:
      tag.hidden = True
      tag.clear()
      continue

   input_attrs = tag.attrs      # {'class': 'c1', 'id': 'i1'}
   valid_attrs = tags[tag.name] # ['class']
   for k in list(input_attrs.keys()):
      if k in valid_attrs:
         pass
      else:
         del tag.attrs[k]

content = soup.decode()
print(content)

#特殊标签过滤
# pip3 install beatifulsoup4
# from bs4 import BeautifulSoup
# soup = BeautifulSoup(content, 'html.parser')
# tag = soup.find('script')
# tag.hidden = True
# tag.clear()
#
# span = soup.find('span')
# # print(span.attrs)
# del span.attrs['style']
#
# content = soup.decode()
# print(content)

xss.py

from bs4 import BeautifulSoup


class XSSFilter(object):
    __instance = None

    def __init__(self):
        # XSS白名单
        self.valid_tags = {
            "font": ['color', 'size', 'face', 'style'],
            'b': [],
            'div': [],
            "span": [],
            "table": [
                'border', 'cellspacing', 'cellpadding'
            ],
            'th': [
                'colspan', 'rowspan'
            ],
            'td': [
                'colspan', 'rowspan'
            ],
            "a": ['href', 'target', 'name'],
            "img": ['src', 'alt', 'title'],
            'p': [
                'align'
            ],
            "pre": ['class'],
            "hr": ['class'],
            'strong': []
        }

    def __new__(cls, *args, **kwargs):
        """
        单例模式
        :param cls:
        :param args:
        :param kwargs:
        :return:
        """
        if not cls.__instance:
            obj = object.__new__(cls, *args, **kwargs)
            cls.__instance = obj
        return cls.__instance

    def process(self, content):
        soup = BeautifulSoup(content, 'html.parser')
        # 遍历所有HTML标签
        for tag in soup.find_all(recursive=True):
            # 判断标签名是否在白名单中
            if tag.name not in self.valid_tags:
                tag.hidden = True
                if tag.name not in ['html', 'body']:
                    tag.hidden = True
                    tag.clear()
                continue
            # 当前标签的所有属性白名单
            attr_rules = self.valid_tags[tag.name]
            keys = list(tag.attrs.keys())
            for key in keys:
                if key not in attr_rules:
                    del tag[key]

        return soup.decode()


if __name__ == '__main__':
    html = """<p class="title">
                        <b>The Dormouse's story</b>
                    </p>
                    <p class="story">
                        <div name='root'>
                            Once upon a time there were three little sisters; and their names were
                            <a href="http://example.com/elsie" class="sister c1" style='color:red;background-color:green;' id="link1"><!-- Elsie --></a>
                            <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
                            <a href="http://example.com/tillie" class="sister" id="link3">Tilffffffffffffflie</a>;
                            and they lived at the bottom of a well.
                            <script>alert(123)</script>
                        </div>
                    </p>
                    <p class="story">...</p>"""

    obj = XSSFilter()
    v = obj.process(html)
    print(v)