精华内容
下载资源
问答
  • web架构设计
    千次阅读
    2022-03-08 13:52:42

    1、数据推送,新数据来时,主动推送数据;用 websocket;
    2、数据查询用 http;
    3、nsql:请求应答模式,发布订阅模式;
    4、查询:分页、排序、条件;
    5、web服务内存:leveldb
    6、枚举功能、模糊搜索功能、时间范围筛选功能;
    7、前后端数据传输以字符串为主
    8、web服务进程间通信:消息队列,管道信号通道,共享内存的复杂数据结构共享
    9、保存布局功能:用户的版本,交易账户,窗口名称,窗口位置,窗口大小等;列的隐藏、列的宽度;用户的筛选条件设置;
    10、交易数据是核心,数据展示链路可伸缩;
    11、需求:人人都是产品经理;开发要经过需求设计历练;全员测试;
    12、使用Http协议涉及到buffer不足;websocket原始协议对客户端约束不足;
    13、UI框架设计React介绍:一个用于构建用户界面的java script库

    更多相关内容
  • 对旅游管理系统进行了总体设计并建立了数据库,给出了E-R图和数据表的结构,在此基础上对前台显示框架、前台订单处理、用户注册和登录和后台管理等关键模块进行了详细的设计并完成了系统的实现,设计和实现表明基于...
  • 服务器、Web、游戏、爬虫、数据分析以及人工智能学习之路还很长技术之路不能回头陷进去就出不来就跟恋爱一般,学习中、项目中印象笔记、有道云笔记、Onenote都记了好多Python属于面向对象解释型高级动态计算机程序...
  • 框架总体架构设计说明书,帮助初学真了解项目框架设计方法及思想!希望能够给大家带来点帮助!
  • Web 前端框架应用课程设计 课程设计总体任务 灵活运用所学知识 HTMLCSSBootstrap联系实际设计制作出具有一定特色的主题网站网站题材不限除主页外至少 3 个子页内容充实完整界面美观结构合理操作方便 任务要求 1创建...
  • 总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计等;详细设计主要包括系统数据库访问的实现,主要功能模块的具体实现,模块实现关键代码等。最后对系统进行功能测试,并对测试结果...
  • 3.1 系统总体设计 9 3.2 系统业务流程图 9 4 系统详细设计 11 4.1 系统功能详解 11 4.1.1 用户功能模块 11 4.1.2 管理员功能模块 12 4.2 数据库设计 12 数据表ER图设计 13 4.2.1数据库表设计 13 5 系统功能的具体...
  • Web前端大作业2.0.zip

    2021-04-03 19:29:15
    首先设计网站主页也就是核心内容index.html,先要设计总体的导航条栏目,并点击对应主题来到其链接的详情页,这里采用href标签,用id进行位置定位。页面总体采用 CSS+DIV 布局,最外层DIV为框架,导航条设计。
  • 网站建设与web设计实验指导书 实验一 网站建设规划和网站建设初步 实验目的 对网站进行目标定位 观察适合在网上销售的商品类别 提出创建网站的商品目录结构 规划网站框架结构 分析建站的步骤与方法 熟悉申请域名的...
  • 系统总体架构图: - 1 - 本系统采用四层架构设计 - 2 - 一、展现层 - 2 - Web前端 - 2 - 二、通讯层 - 2 - 三、服务层 - 3 - 四、数据层 - 4 - 其他系统: - 4 - 1、认证系统: - 4 - 2、日志系统: - 7 - 3、会话...
  • 本音乐网站基于Java Web技术,采用SSH轻量级框架组合进行设计与实现。网站利用UML建模,结合用户体验进行开发。网站的功能模块主要包括:登录注册、个人信息维护、用户/音乐/新闻管理、排行榜、播放器、个人收藏列表...
  • 4.1.1系统管理员结构设计 4.1.2图书管理员结构设计 4.1.3学生结构设计 11 4.2 系统数据库设计 12 4.2.1数据实体关系 12 4.2.2数据库表结构 15 第5章 系统实现 19 5.1 管理员账户管理 19 5.2 跳转页面 19 5.3 ...
  • 2.系统总体设计思路及使用技术 先设计一个主页面,再通过主页面的链接使用<a></a>打开其他网页页面,各个页面可包含不同的web技术。其他网页还可以通过链接再次打开另一个网页。使用CSS样式表实现字体颜色大小的批量...
  • 4.1 系统结构设计 4.2 系统功能模块设计 4.3 系统流程设计 4.3.1 普通用户流程设计 4.3.2 超级用户流程设计 4.4 数据库设计 4.5 本章小结 第五章 系统的详细设计与实现 5.1 连接数据库 5.2 系统界面的搭建...
  • web 体系结构_Web服务体系结构概述

    千次阅读 2020-06-22 19:46:25
    Web服务体系结构描述了三个角色:服务提供者,服务请求者和服务代理。 和三个基本操作:发布,查找和绑定。 网络组件可以扮演任何或所有这些角色。 两个单独的文档描述了Web服务:定义良好的服务(WDS)文档描述...

    web 体系结构

    • Web服务是独立的,模块化的应用程序,可以通过通常是万维网的网络进行描述,发布,定位和调用。
    • Web服务体系结构描述了三个角色:服务提供者,服务请求者和服务代理。 和三个基本操作:发布,查找和绑定。 网络组件可以扮演任何或所有这些角色。
    • 两个单独的文档描述了Web服务:定义良好的服务(WDS)文档描述了非运营服务信息,例如服务类别,服务描述和到期日期,以及有关服务提供商的商业信息,例如公司名称,地址,和联系信息。 网络可访问服务规范语言(NASSL)文档描述了有关服务的操作信息,例如服务接口,实现细节,访问协议和联系端点。
    • Web服务体系结构的实现应允许通过配置一组环境先决条件(例如,身份验证机制,计费等)来控制和管理交互,从而促进增量安全性和服务质量模型。
    • Web Services可以动态地组合成基于运行时基于功能的查找的应用程序,而不是传统的静态绑定。协作的动态性质使实现可以独立于平台和编程语言,并且与通信机制无关,同时创建创新的产品,流程和价值链。

    以前对分布式计算(CORBA,Distributed Smalltalk,Java RMI)的尝试已经产生了这样的系统,其中系统中各个组件之间的耦合过于紧密,以至于无法有效地通过Internet进行低开销,无所不在的B2B电子商务。 这些方法需要来自不同组织的业务系统之间过多的协议和共享的上下文,才能可靠地实现开放的,低开销的B2B电子商务。

    同时,应用程序空间中的当前趋势正在从紧密耦合的单片系统向松散耦合的动态绑定组件的系统发展。 基于这些原则构建的系统更有可能在下一代电子商务系统中占据主导地位,而灵活性是其成功的首要特征。 我们认为,应用程序将基于在运行时动态发现和编组的服务组合(服务的及时集成)。 随着企业利用电子门户和电子市场以及利用XML等新技术,将更多现有的IT应用程序转移到Web上,服务(应用程序)集成成为下一代电子商务的创新。

    这里描述的Web服务概念是我们对下一代Web电子商务体系结构的看法。 Web服务体系结构描述了基于服务创建动态,松耦合系统的原理,但没有单一实现。 通过为Web服务体系结构描述的角色,操作等选择各种实现技术,有很多实例化Web Service的方法。

    设计Web服务时,还必须考虑各种环境因素。 例如,对服务代理的安全要求将根据部署环境而有所不同。 大多数Intranet部署对安全性的要求最低,但是在进行高价值B2B交易的情况下,可能需要更高的安全性。 一种方法是对安全和设计代理进行风险评估,以根据环境的安全基础结构提供不同级别的信息。 (有关Web服务安全性注意事项的更多信息,请参阅附录 。)Web服务工具包的未来版本将支持部分或全部这些安全性注意事项。

    一种新的架构方法

    传统的系统架构在系统中的各个组件之间合并了相对脆弱的耦合。 包括面向Web的系统在内的大部分IT系统都可以描述为紧密耦合的应用程序和子系统。 使用数据结构(数据库记录,平面文件)以紧密耦合的方式构建IBM CICS事务,数据库,报表等。

    像这样的整体系统对变化很敏感。 子系统之一的输出变化通常会导致整个系统崩溃。 切换到子系统的新实现方式通常还会导致旧的,静态绑定的协作(无意中依赖于旧实现的副作用)。 通过技能和人数可以在一定程度上控制这种情况。 随着规模,需求,数量和业务变化率的增加,这种脆弱性就会暴露出来。 这些方面中的任何一个方面的任何重大变化都将导致系统的脆弱性成为危机:网站不可用或响应不及时,新产品和服务的上市速度不足,无法Swift转移到新的商机或竞争威胁。 由于耦合,IT组织将无法应对变化; Web的动态性使这些脆弱的体系结构的管理变得站不住脚。

    我们需要用更灵活的体系结构替换当前的应用程序设计模型,从而产生更易于更改的系统。

    网页服务

    即时整合

    Web服务体系结构描述了下一代电子商务体系结构背后的原理,呈现了从面向对象的系统到服务系统的逻辑演进。 Web服务系统促进了组件之间的显着去耦和动态绑定:系统中的所有组件都是服务,因为它们封装了行为并将消息传递API发布到网络上的其他协作组件。 应用程序使用服务发现对协作进行动态绑定,从而封送服务。 Web服务反映了一种新的面向服务的体系结构方法,该概念基于通过发现和协调网络可用服务或应用程序的即时集成来构建应用程序的概念。

    使用Web服务方法,应用程序设计成为描述网络服务执行功能的功能并描述这些协作者的编排的行为。 在运行时,应用程序执行时需要将协作者的需求转换为发现机制的输入,找到能够提供正确服务的协作者,并编排发送给协作者的消息以调用其服务。 这些新的应用程序本身成为服务,因此创建了可用于发现和协作的聚合服务。

    什么是Web服务?

    Web服务是独立的模块化应用程序,可以通过网络(通常是Web)进行描述,发布,定位和调用。

    Web服务体系结构是面向对象的分析和设计的逻辑演变,而组件的逻辑演变是针对电子商务解决方案的体系结构,设计,实现和部署的。 这两种方法已被证明可以处理大型系统的复杂性。 与面向对象的系统一样,Web服务中的一些基本概念是封装,消息传递,动态绑定以及服务描述和查询。 因此,Web服务的基本概念是一切都是服务,发布网络上供其他服务使用的API并封装实现细节。

    Web服务组件

    在任何面向服务的环境中都需要进行一些基本活动:

    1. 需要创建一个Web服务,并且必须定义其接口和调用方法。
    2. Web服务需要发布到一个或多个Intranet或Internet存储库,以供潜在用户定位。
    3. 需要定位Web服务以供潜在用户调用。
    4. 需要调用Web服务才能带来任何好处。
    5. 当某个Web服务不再可用或不再需要时,可能需要取消发布它。

    然后,Web服务体系结构需要三个基本操作:发布,查找和绑定。 服务提供商将服务发布给服务代理。 服务请求者使用服务代理找到所需的服务并将其绑定 。 这些想法如下图所示。

    发布,查找和绑定
    发布,查找和绑定

    服务描述机制是Web服务体系结构中的关键元素之一。 在两个单独的文档中找到了针对我们体系结构的服务的完整说明:网络可访问服务规范语言(NASSL)文档和定义良好的服务(WDS)文档。 NASSL是用于基于网络的服务的基于XML的接口定义语言(IDL),用于指定Web服务的操作信息,例如服务接口,实现细节,访问协议和联系端点。 WDS文档用于指定服务的非运行信息,例如服务类别,服务描述和到期日期,以及有关服务提供商的商业信息,例如公司名称,地址和联系信息。 WDS文档是对相应的NASSL文档的补充。 这两个文档一起用于指定完整的服务描述,允许服务请求者查找和调用服务。

    Web服务体系结构中的所有协作都可能受到一组可配置的,可协商的环境先决条件的控制。 环境先决条件是在调用服务之前必须使任何非功能性组件或基础结构机制都可运行的-例如,使用特定的通信机制(HTTPS,IBM MQSeries)或使用特定的第三方审核或计费服务。 在实际调用服务之前,必须先放置这些组件(通常将其本身实现为服务)。

    服务可以针对其指定的任何环境先决条件支持多种可能的实现。 例如,服务可以提供通信层的选择,计费服务的选择或其他选项。 然后,服务请求者可以协商或选择使用哪种实现来满足环境先决条件。 通过环境前提条件,协作才能像Web服务体系结构中的两个协作者所要求的一样安全,可靠和安全。

    Web服务的好处

    使用Web服务体系结构具有以下好处:

    • 通过最小化共享理解的要求来促进互操作性

      基于XML的接口定义语言(NASSL),基于XML的服务描述(WDS)以及协作和协商协议是服务提供者和服务请求者之间共享理解的唯一要求。 通过限制互操作性绝对必需的条件,协作Web服务可以真正独立于平台和语言。 通过限制绝对需要的内容,可以使用大量不同的基础结构来实现Web服务。

    • 实现即时整合

      Web服务中的协作在运行时动态绑定。 服务请求者描述所需服务的功能,并使用服务代理基础结构来查找适当的服务。 找到具有所需功能的服务后,该服务的NASSL文档中的信息将用于与其绑定。

      动态服务发现和调用(发布,查找,绑定)以及面向消息的协作产生了松散耦合的应用程序,从而实现了新应用程序和服务的及时集成。 这反过来产生的系统具有自我配置,自适应性和鲁棒性,并且单点故障更少。

    • 通过封装降低复杂性

      Web服务中的所有组件都是服务。 重要的是服务提供的行为类型,而不是服务的实现方式。 WDS文档是描述服务封装的行为的机制。

      封装是实现以下目标的关键:

      • 应对复杂性。 当应用程序设计人员不必担心他们正在调用的服务的实现细节时,可以降低系统的复杂性。
      • 灵活性和可扩展性。 在运行时可以替换相同类型的服务或多个等效服务的不同实现。
      • 可扩展性。 通过为新服务提供相似的服务描述来封装和扩展行为。
    • 实现旧版应用程序的互操作性

      通过允许将遗留应用程序包装在NASSL和WDS文档中并作为服务公开,Web服务体系结构可以轻松实现这些应用程序之间的新互操作性。 此外,可以包装安全性,中间件和通信技术以作为环境先决条件来参与Web服务。 目录技术(例如LDAP)可以进行包装以充当服务代理。

      通过包装底层管道(例如,通信层),服务将应用程序程序员与编程堆栈的下层隔离。 这允许服务使虚拟企业能够根据需要(通过基于http的通信)链接其异构系统和/或参与单个管理域的情况,其中其他通信机制(例如MQSeries)可以提供更丰富的功能。

      在合并情况下可以找到这样的例子,在合并情况下,最终的企业必须集成不同的IT系统和业务流程。 面向服务的体系结构将极大地促进这些系统之间的无缝集成。 另一个例子是旅行业与普适计算的结合,当时大型基于主机的旅行应用程序可以通过包装公开为服务,并可以在面向服务的环境中供各种设备使用。 可以创建新服务,并动态发布和发现新服务,而不会破坏现有环境。

    摘要

    Web服务是电子商务发展的下一阶段-从所有内容都是服务的角度来看系统的结果,该服务是使用网络上的消息传递而动态发现和组织的。

    在Web服务体系结构中,每个组件都被视为一种服务,它封装行为并通过可用于网络调用的API提供行为。 这是面向对象技术(封装,消息传递,动态绑定和反射)向电子商务的逻辑演进。

    Web服务中的基本角色是服务提供者,服务请求者和服务代理。 这些角色具有以下操作:发布,查找和绑定。 操作中介是通过环境先决条件发生的,它介绍了诸如安全性,工作流,事务,计费,服务质量和服务级别协议之类的方面。 服务描述语言的机制是Web服务中基本操作的关键。 Web服务的完整描述出现在两个单独的文档中:网络可访问服务规范语言(NASSL)文档和定义良好的服务(WDS)文档。

    Web服务体系结构具有以下优点:

    • 通过最小化共享理解的要求来促进互操作性
    • 启用即时整合
    • 通过封装降低复杂度
    • 启用旧版应用程序的互操作性

    附录:安全和信任问题

    Web服务体系结构的安全性需要提出对安全性的传统理解的转变,以适应用于支持在开放动态Web环境中查找和执行服务的新模型。 面向服务的体系结构的安全性目标是在角色之间实现可信的交互。 如果将安全性定义为防范威胁,则Web Service将识别其感知到的威胁集,并提出防止对Web Service交互造成威胁的方法。 当两方了解风险并确定威胁和脆弱性并商定一系列保护自己开展业务的对策和保障措施时,便可以在他们之间建立信任。

    捕获威胁和对策的困难之一是,它们以发现新威胁的周期相互作用,从而导致产生可能导致新威胁的对策。 因此,某些对策定义必须基于推测。 在尝试解决我们设计的系统中的安全性之前,我们不能等待所有可能的威胁和对策的识别。 我们将面向Web服务的体系结构的安全性视为挑战,以了解和记录现有威胁和提出的对策。 然后,该架构尝试捕获当前情况背后的想法,并允许灵活实施不同级别的安全机制,并具有与现有中间件和新安全机制集成的控制点。 安全措施的演变对新经济的发展很重要,但是我们有经验表明,要成功,任何实施都必须设计简单,使用简单,无处不在且具有成本效益,否则人们将不会使用它。 因此,它充其量是无效的。

    我们已经确定了一些需要采取对策的威胁领域:

    • 在运行时,代理,请求者和提供者之间共享的信息的安全性
    • 部署运行时的网络的安全性
    • 在设计时编程模型(API,框架,存根等)的安全性。

    除了设计时的应用程序安全模型问题外,应用程序开发环境本身还存在另一组安全问题。 这在安全方面在运行时组件和设计时组件之间造成了压力。 还要求Web服务必须简单,基于开放标准并具有可扩展性。 这三个要求与任何新开发的基本安全性目标相呼应。 试图将旧式安全编程模型和机制作为新设计的一部分而出现困难。

    服务和委派模型的访问控制决策必须存在,并最终在应用程序中实施。 这些工具位于应用程序开发环境中,不是Web服务体系结构的一部分,而是大型B2B环境的一部分。 工具可能能够促进某些设计时问题,将访问控制逻辑添加到应用程序,但可能无法解决所有旧情况。 我们建议服务提供者使用前提条件部分,将请求者需要提供的任何信息传达给服务请求者,以符合访问控制决策的条件。

    设计代理时,可能有几种访问控制模型:

    混杂代理是不检查请求者或发布者身份验证的代理 。 经纪人提供对其数据存储库中信息的公共访问,并且不主张数据正确。 这种实现方式的威胁包括冒充服务请求者,冒充服务提供者,未经授权修改数据,披露信息,拒绝服务以及拒绝采取行动。

    认证的代理是对请求者和发布者都进行认证的代理 。 这允许代理对有关谁正在访问信息做出明智的决定,并且代理能够对其保留的数据实施访问控制。 此类实现的威胁包括冒充请求者,冒充服务提供者,未经授权修改数据,披露信息,拒绝服务以及拒绝采取行动。 这种类型的代理将实现以下要求:使用SSL强制实体的身份验证,通过HTTPS协议调用服务请求。 它还可以集成对XMLDSIG的解析器支持,以验证对定义为消息交换一部分的XML文档的签名。

    完全授权的经纪人是将实施授权范例并将访问信息与每个数据条目一起存储的经纪人 。 它将建立条目的所有权,并强制要求只有授权的代理才能修改数据。 它还可以实现更精细的授权引擎,该引擎仅允许请求者的某些子集访问特定信息。 此类实现的威胁包括冒充请求者,冒充服务提供者,未经授权修改数据,披露信息,拒绝服务以及拒绝采取行动。 这种类型的代理将通过HTTPS提供其服务,使用SSL来对实体进行身份验证,并具有对XMLDSIG的解析器支持,以对定义为消息交换一部分的XML文档进行签名。 中间件基础架构(例如Tivoli / Dascom)和AZN API,以实施企业范围的访问控制决策。


    翻译自: https://www.ibm.com/developerworks/web/library/w-ovr/index.html

    web 体系结构

    展开全文
  • 本项目命名为 Sec-Tools,是一款基于 Python-Django 的多功能 Web 应用渗透测试系统,包含漏洞检测、目录识别、端口扫描、指纹识别、域名探测、旁站探测、信息泄露检测等功能。 项目功能 本系统通过 旁站探测 和 ...

    项目介绍

    系统简介

    本项目命名为 Sec-Tools,是一款基于 Python-Django多功能 Web 应用渗透测试系统,包含漏洞检测、目录识别、端口扫描、指纹识别、域名探测、旁站探测、信息泄露检测等功能。

    项目功能

    本系统通过 旁站探测域名探测 功能对待检测网站进行资产收集,通过 端口扫描指纹识别目录识别信息泄露检测 功能对待检测网站进行信息收集,通过收集的信息分析评估网站存在哪些安全隐患,然后使用 漏洞检测 功能揭示网站存在的漏洞以及危害等级并给出修复建议。通过这一系列的步骤,可以对 Web 应用进行全面检测,从而发现网站存在的安全隐患,因此用户可以针对相应的网络威胁做出应急响应,进而提升站点的安全性。

    相关技术

    名称PythonDjangoSQLiteEChartsTablerLayerDocsifySimpleUIBoostrap Table
    版本3.7.03.1.43.35.25.0.11.0.03.2.04.11.62021.1.11.18.2

    项目首页

    首页采用 ECharts 对漏洞扫描的漏洞等级、指纹识别组件、安全导航数据做了可视化图表展示,图表的风格没有统一,凑合看吧

    身份验证

    新用户想要使用系统功能必须要注册登录,游客只能访问部分页面。本系统有普通用户和超级用户。普通用户可以使用本系统的所有功能,但是不能登录后台管理系统。超级用户不仅可以使用所用功能还可以登录后台管理系统中所有的用户权限和数据。

    设计思路: 登录和注册模块在 Django 自带的认证模块的基础上进行实现,因此在 后台-->用户与授权 就可对注册用户进行权限分配和相应管理。我们使用 Django 自带的数据库 SQLite 来存放账户信息,重构了数据库表 auth_user 表,增加了用户邮箱字段,auth_user 中密码字段是加了 salt 的 sha256 值再经过 base64 编码之后的值,保障了用户的信息安全。

    登录页
    注册页

    重设密码功能调用第三方包 django-password-reset 进行实现

    步骤一
    步骤二

    漏洞检测

    该模块主要是对目标 Web 系统进行安全漏洞扫描,包括 SQL 注入、跨站脚本攻击(XSS)、弱密码、中间件漏洞。中间件漏洞扫描包括对 Weblogic、Struts2、Tomcat 、Jboss、Drupal、Nexus 的已知漏洞进行检测,用户提供目标 URL 并选择 CVE 漏洞编号。

    设计思路

    该模块的全扫描、SQL 注入漏洞扫描、XSS 漏洞扫描、弱口令扫描、仅爬取是调用 AWVS API 进行实现。中间件漏洞扫描是基于脚本模拟网络请求实现。根据漏洞形成的原因,生成一些测试 payload 发送到目标系统,再由返回的状态码和数据来判断 payload 是否有效。

    实现效果

    点击扫描目标跳转到漏洞结果页:

    再点击扫描目标的跳转到漏洞详情页:

    详细实现

    添加扫描目标

    漏洞扫描最开始的工作是添加扫描目标到 AWVS 的扫描队列中。AWVS 提供了一个 API 接口: /api/v1/targets,使用 POST 请求, POST 请求参数为:{"address":"XXXX.XXXX.XXXX","description":"xxxx","criticality":"10"}

    当目标添加成功后会返回一个 target_id ,这个值在所有扫描中是唯一的。通过 target_id 判断目标是否添加成功。添加完目标后并没有开始扫描,需要使用另一个 API 接口:/api/v1/scans,使用 POST 请求,传入刚刚添加目标生成的 target_id 和用户选择的扫描类型,POST 请求参数为:{"target_id":"xxxxxxx","profile_id":"xxxxxxx"}。开始扫描将会返回状态码 200。

    使用 Python 的第三方库 requests 来实现 API 接口访问。核心代码如下:

    # Target: POST请求/api/v1/targets
    try:
    	#data包含目标URL和类型,auth_headers包含API_KEY
       	response = requests.post(targets_api, auth_headers, data, False)
    result = response.json()
    target_id = result.get('target_id')
       	return target_id
    except Exception:
    return None
    # Scan: POST请求/api/v1/scans
    try:
        response = requests.post(scan_api, data, auth_headers, False)
        status_code = 200
    except Exception:
    status_code = 404
    return status_code
    

    API 接口已经实现,还需要获取用户输入的数据。由于本系统是基于 Django 实现的,所以使用 HTML+JavaScript 提供用户界面和接受和发送数据到后端,后端使用 Python 实现。首先在 urls.py 里面加入添加访问路径

    path('vuln_scan', views.vuln_scan, name='vuln_scan')

    views.py 中定义 vuln_scan() 函数接收前端的用户输入,并调用已经写好的 API 函数。用户输入的 url 为扫描的目标,扫描类型包括 SQL 注入、XSS 漏洞、弱口令和全扫描,其中全扫描就是扫描所有类型的漏洞,如果添加成功后返回的 target_id 不是 None,说明添加成功,就可以开始调用开始扫描的 API,开始扫描后返回状态码,为 200 则开始扫描,返回成功否则返回失败。核心代码如下:

    @csrf_exempt
    def vuln_scan(request):
        #通过POST请求获取用户输入的URL和扫描类型
        url = request.POST.get('ip')
        scan_type = request.POST.get('scan_type')
        t = Target(API_URL, API_KEY)
        #将目标URL添加到扫描队列中
        target_id = t.add(url)
        #如果target_id不为None,则开始扫描
        if target_id is not None:
            s = Scan(API_URL, API_KEY)
            status_code = s.add(target_id, scan_type)
            if status_code == 200:
                return success()
        return error()
    

    最后使用 JavaScript 来实现发送用户输入的数据,选择通过 POST 方法发送数据,并在发送之前判断用户输入的合法性,核心代码如下:

    function get_scan_info(ip , scan_type) {
    # 使用POST请求发送用户输入
            $.post('/vuln_scan', {
                ip: ip ,
                scan_type: scan_type
            }, function (data) {
                if (data.code !== 200) {
                    ......
                } else {
                    ...... 
                }
               ......});
        }
    var domain = $('input[name=scan_url]').val();
    # 使用循环判断用户选择的扫描类型
    for(var i=0; i<document.getElementsByName("scan_type").length; i++) {
        if (document.getElementsByName("scan_type")[i].checked) {
          var scan_type=document.getElementsByName("scan_type")[i].value;
        }
    }
    if(domain){
    	get_scan_info(domain,scan_type)
    }else{
    	......
    }
    

    总体来说,通过上述的代码实现,实现了将用户输入通过 JavaScript 传输给后台,后台接收数据后将调用 AWVS API,然后 AWVS 开始根据用户输入开始扫描目标 URL,扫描结束后将结果保存在数据库中。实现效果如下:

    获取扫描结果

    在上一小节中,将目标扫描的结果保存到数据库中,我们需要得到所有的扫描目标,‘/api/v1/scans‘,请求方式为 GET,请求成功后会返回所有扫描目标的信息,利用这个 API 可以实现展示所有扫描目标。要实现展示每个扫描目标的所有漏洞的功能,需要按照 target_id 来在所有扫描目标中搜索。AWVS 也提供了相应的 API,我们需要用到的 API 为:/api/v1/vulnerabilities

    ?q=severity:{int};criticality:{int};status:{string};cvss_score:{logicexpression};cvss_score:{logicexpression};target_id:{target_id};group_id:{group_id}。请求方式为 GET。利用 target_id 搜索每个扫描目标。这也解决了漏洞细节页面的 URL 问题。当使用 target_id 搜索扫描目标成功时将会返回这个目标的所搜漏洞信息,包括这个目标包含的漏洞个数、每个漏洞的危险等级、扫描时间、扫描类型、扫描状态等信息。

    具体实现步骤和添加扫描目标大体相似,首先第一步使用 requests 来实现 API 请求。核心代码如下:

    # 获取所有扫描目标
    response=requests.get(scan_api, self.auth_headers, False) 
    scan_response=response.json().get('scans')
    for scan in scan_response:
       scan['request_url'] = request_url
       scan_list.append(scan)
    return scan_list
    # 搜索状态为“open“,对应target_id的扫描目标
    vuln_search_api=f'{vuln_api}?q=status:{status};target_id:{target_id}'
    try:
    # 使用get方式请求
        response = requests.get(vuln_search_api, auth_headers, False)
    # 返回搜索结果目标的所有漏洞信息
        return response.text
    except Exception:
        return None
    

    urls.py 中加入用户访问的 url ,这个需要提供一个 target_id 方便后续功能的实现,先获取所有目标的 target_id,然后使用循环将所有 target_id 加入到 urlpatterns 列表中。因为在 Django 中 views 函数通常只能使用一个 request 参数,由于这里需要将 target_id 传入到 views 函数中,使用正则匹配的 “(?P<target_id>.*)$” 接收传入的 target_id,在 views 里对应函数的第二个形参名必须和 <> 里的值一致才有效。核心代码如下:

    path('vulnscan', views.vulnscan, name="vulnscan"),
    for target_id in target_ids:
    	  #使用正则匹配获取第二个参数:taget_id
    urlpatterns.append(url(r'^vuln_result/(?P<target_id>.*)$', views.vuln_result, name='vuln_result/'+target_id))
    

    views.py 里定义函数 vulnscan(request) 获取所有对应的目标漏洞信息。使用 API 得到返回的漏洞危险等级、扫描目标 URL、每个漏洞唯一标识的 vuln_id、扫描类型、扫描处理时间,API 返回的扫描处理时间不是标准的时间格式,使用正则匹配的方式,将其转换为 “%Y-%m-%d %H:%M:%S“ 的格式,再定义函数 vuln_result(request,target_id),根据 target_id 获取扫描目标中所有漏洞信息,包括存在漏洞的 URL、漏洞类型、状态和处理时间等信息。核心代码如下:

    @login_required
    def vuln_result(request, target_id):
        d = Vuln(API_URL, API_KEY)
        data = []
        vuln_details = json.loads(d.search(None,None, "open", target_id=str(target_id)))
    
        id = 1
        for target in vuln_details['vulnerabilities']:
            item={
                'id': id,
                'severity': target['severity'],
                'target': target['affects_url'],
                'vuln_id':target['vuln_id'],
                'vuln_name': target['vt_name'],
                'time': re.sub(r'T|\..*$', " ", target['last_seen'])
            }
            id += 1
            data.append(item)
        return render(request,'vuln-reslut.html',{'data': data})
    

    在这个子功能中,前端的数据展示使用的是 Bootstrap Table。这个模板有很多实用的功能,比如表格的搜索功能、分页展示功能等等,增加了用户体验。表格的数据在 HTML 中使用双花括号来接收,在 views.py 函数中返回的到相应的 HTML 页面时,将 data 字典一起返回。这样的返回方式可以将使用字典中的 key 值获取对应的 values 值。还可以是使用 if-else、for 等语句来分类展示数据。核心代码如下:

    {% for item in data %}
    ……………
    # 这个只展示了扫描目标列,其他列类似 
    <a href="/vuln_detail/{{ item.vuln_id }}"> {{ item.target }}</a>
    ……………
    {% endfor %}
    

    最后实现的效果如下图所示,根据每个扫描状态不同有不同的显示,使用红黄蓝绿来分类高危、中危、低危、info 等级的漏洞。最后展示了扫描的处理时间。

    表格中扫描目标列可以点击进入查看目标的所有漏洞信息,如下图所示,展示了特定的扫描目标每个漏洞的危险等级、存在漏洞的 URL、漏洞的类型。

    获取漏洞细节

    在实现漏洞扫描和结果展示后,还需要获取每个漏洞的细节。包括导致漏洞的请求参数、测试的 payload、数据请求包、简要的修复建议等等。因为每个漏洞也存在一个唯一的标识 vuln_id,可以根据这个值查询指定漏洞的所有信息。使用的 API 为:/api/v1/vulnerabilities/{vuln_id},请求方式为 GET。

    同样地,首先使用 requests 来实现 API 的调用,传入 vuln_id 来查询指定漏洞的所有信息,代码如下:

    # 获取指定漏洞的相关信息
    def get(self, vuln_id):
        vuln_get_api = f'{self.vuln_api}/{vuln_id}'
        try:
    		#使用GET请求将vuln_id传给API,结果以json格式返回
            response = requests.get(vuln_get_api, auth_headers, False)
            return response.json()
        except Exception:
            return None
    

    urls.py 中添加漏洞细节的 url,这里与上一节展示扫描目标的所有漏洞类似,都用正则匹配的形式接收 views.py 里函数的第二个形参,但是这里不在使用 target_id 而是使用 vuln_id。代码如下:

    for vuln_id in vuln_ids:
    	urlpatterns.append(url(r'^vuln_detail/(?P<vuln_id>.*)$', views.vuln_detail, name='vuln_detail/' + vuln_id))
    

    views.py 里面定义 vuln_details(request,vuln_id) 函数,根据 vuln_id 查询指定漏洞的相关信息。该函数将 API 返回的值中有用的信息提取出来到字典 data 里,返回给 vuln-details.html 页面,使用 双花括号 来接收该漏洞的受影响的 URL、处理时间、漏洞类型、漏洞测试参数、数据请求包、简要的修复建议等信息。实现效果如下图所示。

    @login_required
    def vuln_detail(request,vuln_id):
        d = Vuln(API_URL,API_KEY)
        data = d.get(vuln_id)
        print(data)
        parameter_list = BeautifulSoup(data['details'], features="html.parser").findAll('span')
        request_list = BeautifulSoup(data['details'], features="html.parser").findAll('li')
        data_dict = {
            'affects_url': data['affects_url'],
            'last_seen': re.sub(r'T|\..*$', " ", data['last_seen']),
            'vt_name': data['vt_name'],
            'details': data['details'].replace("  ",'').replace('</p>',''),
            'request': data['request'],
            'recommendation': data['recommendation'].replace('<br/>','\n')
        }
        try:
            data_dict['parameter_name'] = parameter_list[0].contents[0]
            data_dict['parameter_data'] = parameter_list[1].contents[0]
        except:
            pass
        num = 1
        try:
            Str = ''
            for i in range(len(request_list)):
                Str += str(request_list[i].contents[0])+str(request_list[i].contents[1]).replace('<strong>', '').replace('</strong>', '')+'\n'
                num += 1
        except:
            pass
        data_dict['Tests_performed'] = Str
        data_dict['num'] = num
        data_dict['details'] = data_dict['details'].replace('class="bb-dark"','style="color: #ff0000"')
        return render(request, "vuln-detail.html", {'data': data_dict})
    

    基于 POC 验证的中间件漏洞扫描

    本系统使用 POC 脚本实现对一些中间件的漏洞扫描[7],包括 Weblogic、Tomcat、Drupal、JBoss、Nexus、Struts2 等等。通过每个漏洞的特点,使用 Python 编写不同的 POC 脚本验证目标是否存在该漏洞。

    首先这里的用户界面和基于 AWVS 的漏洞扫描共用,单独加入了中间件漏洞 CVE 编号的选择。使用 JavaScript 发送用户输入的数据到后端。核心代码如下:

    # 使用POST请求提交用户的输入
    function get_Middleware_scan(ip , CVE_id) {
        $.post('/Middleware_scan', {
        ip: ip , #目标URL
        CVE_id: CVE_id  #选择的CVE编号
    }, function (data) {
    # 处理返回结果
          ………
          ………}); 
    }
    

    将目标添加到数据库后,再查询数据库开始扫描,通过 AJAX 来访问 start_Middleware_scan 调用开始扫描的函数,由于扫描时间可能会很长,需要设置足够的 timeout 来等待扫描的结果返回。核心代码如下:

    $.ajax({
    # 使用POST请求发送目标URLCVE编号,设置超时为1秒
        type: "POST",
        url: '/start_Middleware_scan',
        timeout: 10000,
        data: {
        ip: ip,
        CVE_id: CVE_id
        }
    });
    

    urls.py 里加入中间件漏洞扫描的访问路径,需要加入两个路径:’Middleware_scan‘‘start_Middleware_scan’。前者是用户添加扫描目标时的路径,用于接收用户输入的目标和 CVE 编号之后将其插入数据库。后者是将目标插入数据库之后,通过时间戳、状态、目标 URL 以及 CVE 编号查询出来开始扫描。当扫描结束时更新数据库中对应扫描目标的状态。这样的设计可以实时的看到扫描的状态。

    数据库使用的是 SQLite,在 models.py 里创建一个数据库表 Middleware_vuln ,字段包括 ID、目标 URL、状态、结果、CVE 编号、时间戳。在 Django 里定义这个类表示我们需要创建的数据库,在 modles.py 里创建好之后,使用命令 python manage.py makemigrations 来记录 modles.py 的所有改动,并且将这个改动迁移到 migrations 这个文件下生成一个文件例如:0001 文件,如果你接下来还要进行改动的话可能生成就是另外一个文件不一定都是 0001 文件,但是这个命令并没有作用到数据库,再使用命令 python manage.py migrate 将根据刚刚检测到的改动来创建数据库表和字段属性。核心代码如下:

    class Middleware_vuln(models.Model):
    # 类名为数据库表名,变量名为字段名,字段属性定义如下
    	id = models.AutoField(primary_key=True)
    	url = models.CharField(max_length=100, null=True)
    	status = models.CharField(max_length=20, null=True)
    	result = models.CharField(max_length=100, null=True)
    	CVE_id = models.CharField(max_length=100, null=True)
    	time = models.CharField(max_length=100, null=True, unique=True)
    
    

    在添加目标和开始检测的时候我们需要插入数据库和查询数据库,这里使用 Django 的函数来处理数据库的增删查改。对于 Middleware_vule 的插入使用 Middleware_vuln.objects.create(url, status, result, CVE_id, time),更新使用 Middleware_vuln.objects.filter(time).update(status, result)。还需要使用 try-except 来处理异常情况并打印出错信息。

    def insert_Middleware_data(url, CVE_id, Time, result=None, status="runing"):
        try:
            Middleware_vuln.objects.create(url=url, status=status, result=result, CVE_id=CVE_id, time=Time)
            print("insert success")
            return True
        except:
            print("data insert error")
            return False
    
    
    def update_Middleware_data(url, CVE_id, Time, result):
        try:
            Middleware_vuln.objects.filter(url=url, status='runing', CVE_id=CVE_id, time=Time).update(status="completed", result=result)
            print("update success")
        except:
            print("data updata error")
    

    views.py 里定义 Middleware_scan() 获取用户输入,并插入到数据库中,其中时间戳 Time 为全局变量,作为后面开始扫描部分查询数据库的条件,在插入数据成功就返回 success(),否侧返回 error(),这里返回的函数时返回的状态码,success()返回的是 200,error()返回 404,通过上面 JavaScrip t 接收后做出判断,并弹出相应的提示框,核心代码如下:

    Time = 0.0
    @csrf_exempt
    @login_required
    def Middleware_scan(request):
        #使用POST请求获取用户输入,并将其插入数据库中。
        #Time作为全局变量插入到数据库中,作为查询目标信息的条件。
        global Time
        try:
            url= request.POST.get('ip')
            CVE_id = request.POST.get('CVE_id').replace('-',"_")
            Time = time.time()  # time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(t))时间戳转日期格式
            if insert_Middleware_data(url, CVE_id, Time):
                return success()
        except:
            return error()
    

    又定义函数 start_Middleware_scan(),实现将数据库中时间戳为 Time,状态为 run 的目标查询出来,根据 CVE 编号调用对应的 POC 脚本。最后更新数据库的扫描结果和扫描状态,由于在上一步中将数据插入数据库中可能会花费一点时间,所以需要使用 sleep() 等待数据插入后再进行查询工作和扫描工作,保证不遗漏扫描目标。

    @csrf_exempt
    @login_required
    def start_Middleware_scan(request):
        try:
            url = request.POST.get('ip')
            ip, port = urlparse(url).netloc.split(':')
            CVE_id = request.POST.get('CVE_id').replace('-', "_")
            time.sleep(5) #等待数据插入成功后在查询出来扫描
            msg = Middleware_vuln.objects.filter(url=url, status='runing', CVE_id=CVE_id, time=Time)
            print(msg)
            #扫描条目可能不止一条,需要使用循环来扫描
            for target in msg:
                result = POC_Check(target.url, target.CVE_id)
                #将扫描结果和状态更新
                update_Middleware_data(target.url, target.CVE_id, Time, result)
            return success()
        except:
            return error()
    

    端口扫描

    本系统端口扫描当用户指定了目标 IP 地址后,系统正式工作,IP 传入后台对目标进行扫描,扫描完成后将开放端口和对应服务显示到前端界面上。在“按端口分布划分”和“按协议类型划分”两个栏目中对端口划分进行讲解,使用户免于查询的繁琐。同时该模块还将内置常见端口查询表,在此可进行端口及其对应服务和功能的相关查询和筛选,通过这一系列功能用户能够更加清晰的认识到目标主机开放了哪些服务,以此来分析可能存在漏洞的服务。

    设计思路

    本系统端口扫描的实现方法是利用 Python 提供的库函数 Socket 进行调用,通过 TCP 三次握手与目标计算机的端口建立连接。当完成一次完整的三次握手时,则可以推断出端口和对应服务是开放的,反之则没有开放,为了提高了扫描的效率,本系统引入多线程扫描机制。

    实现效果

    详细实现

    端口扫描

    通过 Python 直接定义 socket,尝试与目标端口进行连接。本程序中使用 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM); 的方式进行 TCP 连接,调用 sock.connect_ex((ip,port)),来尝试连接端口,如果端口开放则返回 0,否则返回错误代码。使用 try 语句来捕获异常,如果 socket 连接超时,则返回异常处理信息。核心代码如下:

    def socket_scan(self, hosts):
        '''端口扫描核心代码'''
        global PROBE
        socket.setdefaulttimeout(1)
        ip, port = hosts.split(':')
        try:
            if len(self.port) < 25:
                # 创建套接字
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                # TCP/IP三次握手建立连接
                result = sock.connect_ex((ip, int(port)))   
    # 调用socket.connect_ex((ip, port)),端口开放返回0,否则返回错误代码
    # 实现和nmap的全连接扫描类似的功能。
                if result == 0:                     # 成功建立TCP链接
                    self.port.append(port)          # 结果集中增加端口
                    for i in PROBE:                 # 通过HTTP1.1刺探
                        sock.sendall(i.encode())    # 发送完整的TCP数据包
                        response = sock.recv(256)   # 接受最大256byte
                        sock.close()
                        if response:
                            break
                    if response:
                        for pattern in SIGNS:
                            pattern = pattern.split(b'|')
                            if re.search(pattern[-1],response, re.IGNORECASE): 
    # 正则匹配banner信息与字典中的服务
                                proto = '{}:{}'.format(pattern[1].decode(), port)
                                self.out.append(proto)  # 添加至输出结果
                                break
            else:
                self.num = 1
        except (socket.timeout, ConnectionResetError): # 异常处理
            pass
        except:
            pass
    
    

    如果这样单线程(串行)阻塞运行,会耗费大量时间,因此,通过并发的方式,并发请求,提升扫描速度,通过对比扫描 300 个端口单线程需要 30s 左右,多线程仅需 10s 左右。

    本端口扫描功能中采用了并发 64 条线程来进行扫描,因此,在定义 run 方法时,每个线程扫描的两个端口号间差数为 64,在程序中使用 concurrent.futures 来实现。concurrent.futures 模块提供了一个高水平的接口用于异步执行调用。异步执行可以使用线程实现,使用 ThreadPoolExecutor,或者独立的进程,使用 ProcessPoolExecutor 实现。两者都实现相同接口,都是由抽象 Executor 类定义的。

    THREADNUM = 64  # 线程数
    def run(self, ip):  #多线程扫描
        hosts = []
        global PORTS, THREADNUM
        for i in PORTS:
            hosts.append('{}:{}'.format(ip, i))
        try:
            with concurrent.futures.ThreadPoolExecutor(
                    max_workers=THREADNUM) as executor:
                executor.map(self.socket_scan, hosts)
        except EOFError:
            pass
    

    端口查询表

    端口查询表功能通过收集网上端口信息建立端口查询库,涉及到的端口数据是存储在数据库中,包括端口 ID、端口号、端口对应服务、端口对应协议和端口所属状态。端口查询表结构如下表所示。

    字段名字段类型允许空是否主键备注
    idintegerNot nullTrue端口 ID
    numbigintNot nullFalse端口号
    servicetextNot nullFalse端口对应服务
    protocolVarchar(20)Not nullFalse端口对应协议
    statusVarchar(10)Not nullFalse端口所属状态

    端口查询数据库采用 Django Model 进行建立,字段包含端口号、服务、协议、和状态。实现代码如下:

    class PortList(models.Model):
        '''端口查询表'''
        num=models.BigIntegerField(verbose_name='端口号')
        service=models.TextField(max_length=100,verbose_name='服务')
        protocol=models.CharField(max_length=20,verbose_name='
    协议',blank=True,default='未知')
        status=models.CharField(max_length=10,verbose_name='
    状态',blank=True,default='未知')
        class Meta:  
    	# 后台表头设置
            verbose_name=verbose_name_plural='端口列表'
    

    数据库建立后需要进行后台注册,这样可以进入后台对数据进行管理,实现代码如下:

    @admin.register(PortList)
    class PortListAdmin(ImportExportModelAdmin):
        # 设置哪些字段显示在后台
        list_display = ('num', 'service', 'protocol', 'status',)
        # 设置num字段进入编辑界面 
        list_display_links = ('num',)  
        search_fields = ('num', 'service',)
        # 过滤器,按字段进行筛选
        list_filter = ('protocol','status')
        # 设置num为默认排序字段
        ordering = ('num', )
        list_per_page = 15  #设置每页显示数据条数
    

    指纹识别

    该模块采用提取指纹特征码特征信息来识别 Web 指纹,系统通过构造大量特殊的 HTTP 请求与 Web 服务器交互,从其响应数据包信息中提取提取指纹特征信息,然后通过与指纹数据库进行比对,从而获取到 Web 服务器及应用的组件信息和版本信息。通过发现这些特征信息并对它进行识别可以帮助我们快速地制定渗透策略,是渗透环节中关键的一步。

    设计思路

    国内外对 Web 服务器及应用指纹的研究,主要都是通过构造大量特殊的 HTTP 请求与 Web 服务器交互,从其响应数据包信息中提取提取指纹特征信息,然后通过与指纹数据库进行比对,从而获取到 Web 服务器及应用的组件信息和版本信息。本文采用基于关键字特征匹配的方法实现指纹识别功能,为了使检测结果更加准确,对比网上一些主流的指纹数据库,对本系统的数据库进行了一系列优化。

    实现效果

    详细实现

    指纹识别流程中最关键的就是提取指纹特征这一步骤。提取指纹特征首先需要确定应该提取响应数据报文中的哪些数据。因此需要设计特征提取算法对响应数据报文进行分析,响应数据包是由响应行、响应头、响应体三部分构成。响应行由 HTTP 版本、状态码、状态码描述构成。响应头用于指示客户端如何处理响应体,响应头里面包含很多的组件信息,用于告诉浏览器响应的类型、字符编码服务器类型和字节大小等信息。响应体则是服务器根据客户端的请求返回给客户端的具体数据。响应头和响应体中包含了能够识别 Web 指纹组件的字段内容,因此,对响应头和响应体中关键字段的提取,是实现指纹识别技术的核心。

    指纹识别技术分为信息收集阶段和 Web 指纹识别阶段。

    (I)信息收集阶段:通过用户输入的 URL,收集 Web 应用的特定字段信息,返回页面关键字或者特殊文件和路径等这些特征。收集的关键数据越多对接下来的指纹识别结果越准确。

    (2)Web 指纹识别阶段:该阶段包含两部分,一部分是指纹库的建立,该部分主要负责从已知的 Web 应用程序中收集特征信息,并且建立指纹特征库;本文通过分析 HTTP 响应数据报文,设计了网站指纹的提取规则,通过分析响应头字段和响应体内容构建了一个指纹组件信息库,信息库采用 JSON 格式进行存储。指纹信息是从 Wappalyzer 和 FOFA 等平台上进行收集归纳的。另一部分从待测的 Web 应用程序中收集特征信息,并与指纹特征库中的数据进行比较,从而识别出待测的 Web 应用程序。

    目录扫描

    目录识别参照 dirsearch 实现,包含 PHP、asp、JSP 等网站类型进行扫描,还设置了递归扫描和自定义扫描选项。支持自定义前后缀或者子目录。

    设计思路

    Dirsearch 扫描的结果通过 JSON 的格式保存在对应的路径下,因此我们可以减轻对数据库的依赖。获取的数据被分成 URL 和 TIMR,URL 下又分为 content-length、path、redirect、starus 四个部分。因为在 JSON 格式中被不同类型括号的数据会被 Django 解析为列表、字典等格式,因此我们需要对获得的 JSON 数据进行处理,将其转换为 Django 可以识别的数据,使之在前端进行读取。

    要正确解析数据,需要先理解 Python 数据结构和 JSON 数据的转换方法。我们基于当前的固定的 JSON 格式去解析取得的数据。

    实现效果

    信息泄露

    该模块主要为用户提供常见的信息泄露检查。在前端直观的展示后台地址、配置文件等可能存在泄露的信息,在结果列表中,用户可以非常清晰的知道某个 Web 服务存在的信息泄露问题。

    旁站探测

    该模块主要对通过 IP 地址,直接获取与当前 IP 所在服务器上的其它网站, 本模块直接调用 API 实现

    域名探测

    该模块主要通过调用 API 来扫描网站的子域名

    安全导航

    安全导航页面的灵感来自于 Viggo 大佬开发的 Webstack 项目,该项目是基于 Bootstrap 开发的纯前端页面,因此前端我沿用了 Webstack 的风格并融合了 Tabler UI 风格,并用 Django 写了后台管理,可在线对分类和条目进行管理。

    前端页面

    后台管理页面

    数据库设计

    导航条目-Item

    标题 title 描述 desc 网址 url 分类 category(外键) 图片 img 图片宽度 img_width

    class Item(models.Model):
        '''导航条目'''
        title = models.CharField(max_length=50,verbose_name='名称')
        desc = models.TextField(max_length=100,verbose_name='描述')
        url = models.URLField(verbose_name='网址',blank=True)
        img = models.URLField(default='https://jwt1399.top/favicon.png',verbose_name='logo')
        img_width = models.IntegerField(default=45, verbose_name='图片宽度')
        category = models.ForeignKey(Category, blank=True, null=True, verbose_name='分类', on_delete=models.CASCADE)
        class Meta:
            verbose_name=verbose_name_plural='导航条目'
        #后台条目图片预览
        def img_admin(self):
            return format_html( '<img src="{}" width="50px" height="50px" style="border-radius: 50%;" />',self.img,)
        img_admin.short_description = 'logo预览'
        def __str__(self):
            return self.title
    

    条目分类-Category

    名称 name 排序 sort 是否添加到导航栏 add_menu 图标 icon

    class Category(models.Model):
        """条目分类"""
        name = models.CharField(max_length=20, verbose_name='名称')
        sort = models.IntegerField(default=1, verbose_name='显示顺序')
        add_menu = models.BooleanField(default=True, verbose_name='添加到导航栏')
        icon = models.CharField(max_length=30, default='fas fa-home',verbose_name='图标')
        class Meta:
            verbose_name_plural=verbose_name = '分类'
    
        #统计分类对应条目数,并放入后台
        def get_items(self):
            return len(self.item_set.all())
        get_items.short_description = '条目数'  # 设置后台显示表头
        #后台图标预览
        def icon_data(self):#引入Font Awesome Free 5.11.1
            return format_html('<h1><i class="{}"></i></h1>',self.icon) #转化为<i class="{self.icon}"></i>
        icon_data.short_description = '图标预览'
        def __str__(self):
            return self.name
    

    文档页

    将 Docsify 直接嵌入了 Django 中构造了文档页。

    兼容性

    Phone 端

    竖屏横屏

    Pad 端

    竖屏横屏

    版本变更记录

    v2.7(2021-04-18)

    • 新增 域名探测 功能;
    • 新增 中间件漏洞 扫描;
    • 修复 忘记密码 功能;
    • 优化 AWVS 未启动报错信息;
    • 优化 用户登录 逻辑;
    • 优化 漏扫详情 页 UI;
    • 优化导航栏布局;
    • 优化若干小细节;

    v2.6(2021-03-31)

    • 新增漏洞 扫描详情 功能;
    • 新增首页 仪表盘
    • 安全导航页导航栏 移动端优化
    • 安全导航页目录栏 缩放优化
    • 注册&登录界面优化;
    • 文档页 导航栏优化
    • 新增 UI 夜间模式;
    • 修复若干 UI 显示 Bug;

    v2.5(2021-03-02)

    • 新增了 漏洞扫描 功能;
    • 端口扫描页新增 常见端口查询表
    • 信息泄露页新增 常见信息泄露列表
    • 指纹识别页新增 数据分析 图表;
    • 漏洞扫描页 界面优化

    v2.4(2021-02-22)

    • 新增了 目录识别 功能;
    • 重写 欢迎页
    • 安全导航页 移动端界面 适配;
    • 安全导航页 UI优化
    • 目录识别页 界面优化
    • 指纹识别页新增 常见指纹 显示与搜索;
    • 引入 Boostrap Table 实现分页;
    • 淘汰 LayUI 改用 Layer 进行弹窗;
    • 文档页增加 导航栏

    v2.3(2021-02-08)

    • 全新的 页面布局
    • UI 适配 移动端
    • 优化 导航页布局
    • 优化一系列 UI 显示问题;
      • 优化了 手机端页脚 显示
      • 优化了 平板端导航条 显示
      • 页面底部增加 回到顶部 按钮
      • 按钮 触发跳转 页面相对位置
      • 回车键 触发查询按钮
      • 优化 导航页页脚 显示

    v2.2 (2021-02-03)

    • 新增了 信息泄露探测 功能;
    • 新增了 旁站探测 功能;
    • 新增了导航页 数据分析 功能;
    • 新增了基于 Docsify文档页
    • 重构了 静态文件static 文件结构
    • 优化了项目 文件结构
    • 美化了 注册 页面;
    • 引入了 动态粒子 背景效果;
    • 修复了一些 UI 显示问题;

    v2.1 (2021-01-13)

    • 新增了 指纹识别 功能;
    • 新增了 登录和注册功能 功能;
    • 新增了 欢迎页
    • 新增了 文档页
    • 修复了一些 UI 显示问题;

    v2.0(2021-01-04)

    • 新增了 端口扫描 功能;
    • 新增了 安全导航 功能;
    • 连入了 SQLite 数据库,后续考虑改为 MySQL
    • 修复了一些 UI 显示问题;
    • 修复了后台头部小图标无法显示问题;
    • 新增了后台数据导入导出功能;

    v1.0(2020-12-20)

    • 基于 Tabler 框架构造了前端页面;
    • 采用基于 Python 的 Django 框架编写后端;
    • 引入了 SimpleUi 美化 Django 后台框架;
    • 引入了 Font-Awsome 5.15.1 图标;

    项目部署

    本地部署

    1.使用 Pycharm 打开本项目,在 Pycharm 的 setting—>Project Interpreter 中 add 一个新的虚拟环境。

    2.在该虚拟环境下打开 Pycharm 自带 Terminal 运行 pip install -r requirements.txt 下载项目所需的第三方包。

    3.现在项目已经可以正常运行了,但是想要使用漏洞扫描功能,需要安装 AWVS,并在项目的 setting.py 中配置 AWVS 的 API URLAPI KEY

    4.忘记密码功能相关配置在项目的 setting.py 中修改

    EMAIL_HOST = 'smtp.163.com'
    EMAIL_PORT = 25               # 发件箱的smtp服务器端口
    EMAIL_HOST_USER = 'xxx'       # 你的邮箱账号
    EMAIL_HOST_PASSWORD ="xxx"    # 邮箱授权码
    EMAIL_USE_TLS = True          # 这里必须是 True,否则发送不成功
    EMAIL_FROM = 'xxx'            # 你的邮箱账号
    DEFAULT_FROM_EMAIL = 'xxx'    # 你的邮箱账号
    

    5.创建超级管理员 python manage.py createsuperuser

    6.默认账户:sectools/password…!!

    服务器部署

    请参考:使用宝塔面板快速部署 Django 项目

    TO DO

    不论是开发还是安全感觉都有很长的路要走,路漫漫其修远兮,吾将上下而求索,共勉 !

    • 安全工具页
    • 安全图书页
    • 引入 MySQL 数据库
    • 扫描算法优化
    • 代码变量、数据库结构优化
    • 漏洞报告导出功能
    • 页面异步刷新

    声明 & 感谢

    • 本项目仅供学习, 测试, 交流使用, 勿用于非法用途。
    • 请使用者遵守《中华人民共和国网络安全法》,勿用于非授权测试,如作他用所承受的法律责任一概与作者无关,下载使用即代表使用者同意上述观点。
    • 本项目参考和借鉴和参考了许多师傅的思路/文章/项目,在此感谢给予帮助的大家!!!
    展开全文
  • 一、MVC设计模式1.MVC的概念首先我们需要知道MVC模式并不是javaweb项目中独有的,MVC是一种软件工程中的一种软件架构模式,把软件系统分为三个基本部分:模型(Model)、视图(View)和控制器(Controller),即为MVC。...

    一、MVC设计模式

    1.MVC的概念

    首先我们需要知道MVC模式并不是javaweb项目中独有的,MVC是一种软件工程中的一种软件架构模式,把软件系统分为三个基本部分:模型(Model)、视图(View)和控制器(Controller),即为MVC。它是一种软件设计的典范,最早为Trygve Reenskaug提出,为施乐帕罗奥多研究中心(Xerox PARC)的Smalltalk语言发明的一种软件设计模式。

    64be7ebb5cdbe3af550dcf37cfdd7ff5.png

    2.MVC的详解

    虽然MVC并不是Java当中独有的,但是现在几乎所有的B/S的架构都采用了MVC框架模式,但是MVC在B/S架构中并没有完全地实现,其实我们根本不需要掌握未实现的部分。

    ·控制器Controller:控制器即是控制请求的处理逻辑,对请求进行处理,负责请 求转发;

    ·视图View:视图即是用户看到并与之交互的界面,比如HTML(静态资源),JSP(动态资源)等等。

    ·模型Model:模型代表着一种企业规范,就是业务流程/状态的处理以及业务规则的规定。业务流程的处理过程对其他层来说是不透明的,模型接受视图数据的请求,并返回最终的处理结果。业务模型的设计可以说是MVC的核心。

    3.MVC模式的用武之地

    MVC模式被广泛用于Java的各种框架中,比如Struts2、Spring MVC等等都用到了这种思想。

    Struts2是基于MVC的轻量级的web应用框架。基于MVC,说明基于Struts2开发的Web应用自然就能实现MVC,也说明Struts2着力于在MVC的各个部分为我们的开发提供相应帮助。

    二、Javaweb经典三层架构

    1.Javaweb经历了三个时期

    ①JSP Model1第一代

    JSP Model1是JavaWeb早期的模型,它适合小型Web项目,开发成本低!Model1第一代时期,服务器端只有JSP页面,所有的操作都在JSP页面中,连访问数据库的API也在JSP页面中完成。也就是说,所有的东西都耦合在一起,对后期的维护和扩展极为不利。

    cbdd5c4f54bc707c5653e26da0b018bf.png

    ②JSP Model1第二代

    JSP Model1第二代有所改进,把业务逻辑的内容放到了JavaBean中,而JSP页面负责显示以及请求调度的工作。虽然第二代比第一代好了些,但还让JSP做了过多的工作,JSP中把视图工作和请求调度(控制器)的工作耦合在一起了。

    74dc3b1aaf9b97f35d8c26e94c0c9f4b.png

    ③JSP Model2

    JSP Model2模式已经可以清晰的看到MVC完整的结构了。

    ·JSP:视图层,用来与用户打交道。负责接收用来的数据,以及显示数据给用户;

    ·Servlet:控制层,负责找到合适的模型对象来处理业务逻辑,转发到合适的视图;

    JavaBean:模型层,完成具体的业务工作,例如:开启、转账等。

    b669a09b6e5f75e34f622188df45719f.png

    这就是javaweb经历的三个年代,JSP Model2适合多人合作开发大型的Web项目,各司其职,互不干涉,有利于开发中的分工,有利于组件的重用。但是,Web项目的开发难度加大,同时对开发人员的技术要求也提高了。

    2.JavaWeb经典三层框架

    我们常说的三层框架是由JavaWeb提出的,也就是说这是JavaWeb独有的!

    所谓三层是表述层(WEB层)、业务逻辑层(Business Logic),以及数据访问层(Data Access)。

    ·WEB层:包含JSP和Servlet等与WEB相关的内容;

    ·业务层:业务层中不包含JavaWeb API,它只关心业务逻辑;

    ·数据层:封装了对数据库的访问细节;

    注意,在业务层中不能出现JavaWeb API,例如request、response等。也就是说,业务层代码是可重用的,甚至可以应用到非Web环境中。业务层的每个方法可以理解成一个万能,例如转账业务方法。业务层依赖数据层,而Web层依赖业务层!

    d7033e4d5f35ce27ed1bfeada55cd650.png

    注:网上很多人在讨论MVC究竟是一种框架模式还是一种设计模式(百度百科中强行解释其为一种框架模式而不是一种设计模式),虽然Java中的23种设计模式里并没有MVC,但是我认为讨论这个问题没有太大的必要。我们大可将他作为一种思想,我们需要做的仅仅是理解它,应用它,掌握其中的思想,这才是我们需要做的。

    【编辑推荐】

    【责任编辑:武晓燕 TEL:(010)68476606】

    点赞 0

    展开全文
  • 总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计等;详细设计主要包括系统数据库访问的实现,主要功能模块的具体实现,模块实现关键代码等。最后对系统进行功能测试,并对测试结果...
  • 互联网架构(一)总体架构设计

    千次阅读 2020-10-09 15:14:27
    总体架构设计 架构的基本手段就是分与合,先把系统打散,然后再重新组合。 分的过程是把系统拆分为各个子系统/模块/组件。拆的时候首先要解决每个组件的定位问题,然后才能划分彼此的边界,实现合理的拆分。 合就是...
  • Web前端布局总体架构

    千次阅读 2017-07-02 18:02:08
    7.目录结构清晰,模块化; 8.样式层次结构尽量简单; 9.js 和 cs 缓存 10.动画尽量使用在绝对定位和固定定位的元素上; 11.html文档结构层次尽量少,最好不深入6层; 12.使用webpack打包css和js文件,...
  • Web前端-课程设计-网易严选

    千次阅读 2022-02-07 22:06:14
    1. 项目链接: 2. 项目视频: 3. 项目文档: 本科学生大作业报告 课程名称: Web基础 网站主题: 《网易严选》 小组成员: 1. 2. 3....
  • 基于Web的仓库管理系统的设计与实现

    万次阅读 多人点赞 2019-07-02 20:27:48
    摘 要 仓库物品的管理是与我们的日常生活息息相关的一个重大问题。随着我国经济飞速的发展,改革开放的不断深入,企业要想在...在此篇文章中严格按照软件工程思想,设计并实现了一个仓库信息管理系统。介绍了系统从...
  • 基于django框架web开发环境搭建

    千次阅读 多人点赞 2020-07-23 21:48:47
    Django是基于Python语言开发的web开源框架,是当前python语言最流行的web框架,django本身是基于MVC的设计模式(有的培训机构介也称MTV模式M-model、V-view、T-templates),这只是名称上的区别,总体设计思想相同的...
  • Python web后端开发框架 Django 、Flask、Tornado

    万次阅读 多人点赞 2018-03-07 15:16:25
    深入学习Python ,用Django做Web后端开发现在Python的用途愈来愈广,服务器、Web、游戏、爬虫、数据分析 以及人工智能 学习之路还很长技术之路 不能回头 陷进去 就出不来 就跟恋爱一般,学习中、项目中 印象笔记、...
  • 2020年值得去了解的12个Python Web框架

    万次阅读 2020-01-15 00:17:03
    不过鉴于Python在最近几年的强势地位,了解一下Python的web框架也挺有必要的。万一哪天我自己或者是客户“脑抽”了,真的要用Python来写web应用了呢?框架(Framework)让程序员的生活更容易,常用的功能和方法都...
  • 基于web的香水商城系统的设计与实现(java) 项目介绍: 本作品是市场上香水订购需求制作的,前台使用了bootstrap框架,后台使用了ssm架构,数据库为mysql,项目构建方式为maven,有利于后期维护以及二次开发。 作品...
  • 基于MVC设计模式的WEB应用框架研究

    千次阅读 2011-04-18 10:12:00
    摘要 MVC设计模式是基于J2EE的WEB应用开发的首选模式,当前许多流行的框架也都是基于MVC设计模式的。本文简要介绍了MVC设计模式和Struts 框架,并提出了一种基于MVC模式的新型WEB应用开发框架——WebFramework,并对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,551
精华内容 13,420
关键字:

web网站总体框架结构设计