精华内容
下载资源
问答
  • 软件安全技术 示范性软件学院软件技术系 郭建东 第2部分 典型软件安全问题 2.1 安全问题的来源 2.2 常见的设计问题 2.3 语言问题 2.4 平台问题 2.5 OWASP 2.1 安全问题的来源 安全问题的根本来源 漏洞 漏洞是软件的...
  • 你应该了解的安全编码典型问题

    千次阅读 2020-05-14 20:48:23
    目录前言问题总览典型问题分析及处理措施1. 缓存区溢出2. 整数溢出或回绕3. 命令注入4. 引用空指针5. 跨站脚本6. 未正确清理特定内容7. 日志文件信息泄露8. SQL注入9. 不正确的资源关闭和释放10. 不正确的数组索引...

    前言

    对这几年编码过程中,遇到的典型安全编码问题进行归纳总结,以飨诸君。

    问题总览

    在这里插入图片描述

    典型问题分析及处理措施

    1. 缓存区溢出

    在这里插入图片描述
    在这里插入图片描述

    2. 整数溢出或回绕

    在这里插入图片描述
    在这里插入图片描述

    3. 命令注入

    在这里插入图片描述
    在这里插入图片描述

    4. 引用空指针

    在这里插入图片描述
    几种常见示例:

    1. 代码中未对由外部可控的对象判空,直接使用导致引用空指针异常。
      推荐做法为:对于可能出现为null的对象,在使用前判空
    2. 待码中未对可能返回NULL的函数返回值判空,直接使用导致引用空指针异常。
      推荐做法为:对于可能出现为NULL的函数返回值,在使用前判空
    3. 内存申请函数一般不会失败,但是万一失败了,后面代码直接产生空指针异常。
      推荐做法为:对内存申请的指针进行判空处理。
    4. 全局变量或全局变量结构体成员是否为指针依赖其他的流程处理,可能出现空指针的情况,使用前未判空导致程序异常。
      推荐做法为:对于可能为NULL的全局变量、局部变量、结构体成员指针在使用前进行判空处理。

    5. 跨站脚本

    在这里插入图片描述
    存储型XSS示意图如下:
    存储型XSS示意图
    反射型XSS示意图如下:
    在这里插入图片描述
    在这里插入图片描述

    6. 未正确清理特定内容

    在这里插入图片描述
    在这里插入图片描述

    7. 日志文件信息泄露

    在这里插入图片描述

    8. SQL注入

    在这里插入图片描述
    在这里插入图片描述

    9. 不正确的资源关闭和释放

    在这里插入图片描述
    在这里插入图片描述

    10. 不正确的数组索引验证

    在这里插入图片描述
    在这里插入图片描述

    11. 缓存区大小计算不正确

    在这里插入图片描述
    在这里插入图片描述

    THE END

    如果你有更好的补充,欢迎后台留言交流。

    展开全文
  • 浏览器安全问题分析

    2017-11-20 12:53:00
    事端–安全漏洞穿透用户桌面 2009年2月,微软发布了广受关注的MS09-002安全漏洞公告,并随之马上提供了针对...这一问题典型性在于,面向浏览器的恶意攻击已经成为过去一年当中增长最为迅猛的一类桌面安全威胁。同...

     

    事端 – 安全漏洞穿透用户桌面
    20092月,微软发布了广受关注的MS09-002安全漏洞公告,并随之马上提供了针对该漏洞的更新补丁。当访问者使用IE 7浏览器访问特定规格的网页时,MS09-002漏洞会允许远程恶意代码执行,从而破坏访问者的计算机系统。这一问题的典型性在于,面向浏览器的恶意攻击已经成为过去一年当中增长最为迅猛的一类桌面安全威胁。同时,在该威胁发布后的,各大防病毒产品厂商都截获了大量基于该漏洞的攻击。甚至一些以前流行过的恶意软件,都开始集成针对MS09-002的攻击机制生成新变种,试图卷土重来。
     
    其它近期值得关注的安全漏洞
    MS09-002漏洞发布之前,还有一些值得关注的针对浏览器的安全漏洞。比如去年年底出现的微软0day漏洞,其影响的浏览器版本比MS09-002还要广泛。而目前最新爆出的Adobe安全漏洞,则利用了PDF文档中嵌入的可执行浏览器脚本,将会引起非常广泛的安全影响。
     
     
    缘起 – 安全爆炸点的轮回
    在整个2008年当中,桌面安全的最主要问题集中于木马下载器等等以Web访问为载体的病毒程序。据不完全统计,在过去的三年间,基于Web的病毒程序每年都保持着至少翻一番的增长水平。而2008年作为病毒大爆发的一年,所出现的超过一千万种新病毒中,有超过百分之二十都是下载器程序。其实下载器程序并不是一个新鲜产物,在很早之前就有使用这类机制的恶意程序存在。但是之所以在近年来变得如此“繁荣”,核心的原因还在于桌面安全攻防两大阵营的角力,所带来的整个安全环境的变化。作为最古老也是最基本的互联网应用,网页访问无疑拥有最庞大的用户群体和最高的使用频率。但是随着浏览器软件的功能不断丰富、家族成员不断增长,反而成为在安全防护上相对薄弱的一环。与电子邮件、即时通讯等主流互联网应用相比,网页访问保护工具虽然数量不少,但在深度和精度上却难以匹敌其它专项工具。由于网页访问表面的简单性,反而掩盖了用户误用行为所带来的危害,以及纷繁的技术功能所带来的安全隐患。
     
    画像 – 浏览器上的安全风险
    为了提供更丰富的功能,在Web页面中使用了越来越多的客户端脚本和组件技术。这一方面带来了更好的功能和用户体验,同时也使用户在使用浏览器软件时要面对更多的安全问题。木秀玉林,风必摧之,JavaScript客户端脚本技术已经成为事实标准上的标准,自然也是被恶意软件利用的主要对象。由于JavaScript对操作系统的使用范围和权限受到了较为严格的限制,所以很难利用其直接进行破坏。但是下载器程序往往利用JavaScript到互联网上下载实际的攻击代码。ActiveX作为浏览器软件与其它平台进行交互的重要技术,也有着悠久的安全问题历史。由于具有比浏览器脚本更强的系统操纵能力,基于ActiveX组件的病毒程序往往更具破坏力,而且可以直接对操作系统展开攻击。很多企业级的软件系统将ActiveX组件作为实现客户端功能的核心技术,使安全保护体系的搭建变得更加复杂。除此之外,利用Windows Script HostVBScript以及目前已经较少使用的Java Applet小程序等等,都可以基于浏览器开展破坏活动。同样值得关注的是,作为桌面计算机上最常用的应用程序,浏览器现在与操作系统的结合越来越紧密。除了与Windows操作系统紧密集成的IE浏览器之外,其它的浏览器同样也利用很多操作系统的底层组件来提升自身的功能价值。这也是为什么利用浏览器问题的安全攻击可以如此具有破坏力的重要原因,很多漏洞允许攻击代码可以直接破坏或利用操作系统核心。特别对于那些厂商尚未发布更新补丁的0day攻击来说,桌面计算机将完全暴露在攻击之下几无还手之力,这也是目前云安全技术被寄予厚望的原因。趋势科技在截获微软浏览器的0day攻击漏洞时只花了几分钟时间,这给漏洞补丁的及时发布提供了良好的前提。而几乎已经成为标准功能的基于云设施的Web地址过滤,则可以有效地防止用户访问那些带有安全威胁的网站,这样即使计算机在存在漏洞的情况下也有更大的几率在面对攻击时生存。
     
    走向 – 互联网入口的安全变革
    一直依赖,对于浏览器这个最重要的互联网访问入口,用户主要依赖于安全厂商提供的软件产品来获得安全保护。不过可以看到,浏览器厂商们也在不断补充自身产品的安全特性,这可以给用户带来层次更丰富的保护。对于各种利用客户端脚本的安全攻击,特别是利用ActiveX这样可能直接实现安全攻击的恶意程序,浏览器产品以及操作系统本身的安全机制往往显得更加重要。微软在新推出的IE8浏览器当中,会对传统的ActiveX控件机制作出调整。在新的浏览器版本中,ActiveX控件的安装将不再需要管理员权限,而使用当前登录用户的权限安装。这样可以实现更符合逻辑的权限分割,一旦当恶意程序利用了ActiveX感染了计算机,也不会轻易的获得管理权限。而且如果一个ActiveX插件不在该机制的白名单中,其操作本地系统的功能将受到很大的限制,这可以很好的缓解利用ActiveX机制破坏操作系统的问题。这一改变的衍生意义在于,用户和厂商都可以更好地对FlexSilverlight等流行的富客户端访问插件进行控制,从而在一定程度上避免浏览器上不断增加的可执行能力所带来的安全风险。不过,这项改进也存在一些限制,比如目前只有在Vista或更高版本的操作系统中才能使用该机制,而目前占有率还比较高的XP操作系统则无法使用。
    以网络钓鱼为代表的各种网络欺诈,也是目前主要的安全威胁之一。浏览器软件正在广泛地集成各种识别欺骗性网址的功能,其中较为典型的当属FireFox。由于提供插件开发机制,用户除了可以使用FireFox自身提供的防网络钓鱼功能,还可以下载很多提供类似功能的插件,从而获得较为适合自己的防欺诈保护。在微软的IE8浏览器当中,还提供了一项独特的功能改进。用户在浏览器的地址栏输入网址之后,IE8会识别网址中的顶级域名部分并将其用高亮的形式显示。虽然这项改进看起来非常的小,但是在实际使用过程中的效果缺出乎意料的有效。这能够明显地提高用户的注意力,从而判别自己是否正确输入了网址。同时,在IE8中提供的增强的安全过滤器,也可以完成对网址的分析。最重要的是,通过设置安全策略,可以将这个安全过滤器的防护等级提高,从而更大限度的屏蔽可疑网址。
     
     
    上网行为安全袖珍指南
        事实上除了注意更新操作系统漏洞和使用有效的安全防护产品等技术手段之外,想提高访问互联网时的安全性,要重点控制上网时的用户行为。注意应用情景是首要的原则,虽然在自己的个人计算机上记忆密码相对比较安全,但是养成不使用记忆密码功能的习惯还是更加稳妥。如果是在公共场合上网,即使没有使用密码记忆,也建议对访问历史进行清除。不要注册帐号时使用相同的信息是另一个好习惯,这样可以避免一点被突破破层层被突破。同时,对于不需要提供真实信息的网络服务,在注册的时候还是应该适当的保留个人信息。
     
     
    展望 – 浏览器的明日危机
     

        富客户端技术的不断发展,越来越多的应用使用浏览器作为访问媒介,包括很多企业级应用。据此分析,浏览器软件的安全功能还会不断增加,新增功能和插件可能会爆出的安全漏洞也会随之增加。由于浏览器的遍布性和应用规范的不统一,希望通过简单的方式获得高安全性是非常困难的。除了各个方面要密切配合之外,在系统层面实现更加强大的安全模型才能够让浏览器获得足够的安全动力。一个好消息是当前的互联网用户群体已经在使用习惯和警惕性上有了很大提升,不过还需要在系统平台上更好的固化和管理用户上网行为。即将发布的Windows 7等新系统平台,将带给我们新一轮答案。



    本文转自 离子翼 51CTO博客,原文链接:http://blog.51cto.com/ionwing/288753,如需转载请自行联系原作者

    展开全文
  • 问题1: glibc中的strdup实现如下: ...t1在析构时会抛出异常,我们在remove一个对象时,要保证链表还是合法的,也就是保证异常安全性。 如上图,我们期望打印的链表长度为2。 示例程序: 1 #include <i...

    问题1:

    glibc中的strdup实现如下:

    没有对参数s进行空指针判断。

    我们的Exception.cpp中应做改进:

    在第12行进行判断空指针操作。

     问题2:

    t1在析构时会抛出异常,我们在remove一个对象时,要保证链表还是合法的,也就是保证异常安全性。

    如上图,我们期望打印的链表长度为2。

    示例程序:

     1 #include <iostream>
     2 #include "LinkList.h"
     3 
     4 using namespace std;
     5 using namespace DTLib;
     6 
     7 class Test : public Object
     8 {
     9     int m_id;
    10 public:
    11     Test(int id = 0)
    12     {
    13         m_id = id;
    14     }
    15 
    16     ~Test()
    17     {
    18         if( m_id == 1 )
    19         {
    20             throw m_id;
    21         }
    22     }
    23 };
    24 
    25 int main()
    26 {
    27     LinkList<Test> list;
    28     Test t0(0), t1(1), t2(2);
    29 
    30     try
    31     {
    32         list.insert(t0);
    33         list.insert(t1);
    34         list.insert(t2);
    35 
    36         list.remove(1);
    37     }
    38     catch(int e)
    39     {
    40         cout << e << endl;
    41         cout << list.length() << endl;
    42     }
    43 
    44     return 0;
    45 }

    结果如下:

    程序直接崩溃了。

     

    vc下的运行结果如下:

    打印e的值为1,链表长度为3,意味着单链表的状态出问题了。

    我们的remove函数没有考虑异常安全性。

    修改LinkList.h:

      1 #ifndef LINKLIST_H
      2 #define LINKLIST_H
      3 
      4 #include "List.h"
      5 #include "Exception.h"
      6 
      7 namespace DTLib
      8 {
      9 
     10 template < typename T >
     11 class LinkList : public List<T>
     12 {
     13 protected:
     14     struct Node : public Object
     15     {
     16         T value;
     17         Node* next;
     18     };
     19 
     20     mutable struct : public Object
     21     {
     22         char reserved[sizeof(T)];
     23         Node* next;
     24     }m_header;
     25 
     26     int m_length;
     27     int m_step;
     28     Node* m_current;
     29 
     30     Node* position(int i) const    //  O(n)
     31     {
     32         Node* ret = reinterpret_cast<Node*>(&m_header);
     33 
     34         for(int p = 0; p < i; p++)
     35         {
     36             ret = ret->next;
     37         }
     38 
     39         return ret;
     40     }
     41 
     42     virtual Node* create()
     43     {
     44         return new Node();
     45     }
     46 
     47     virtual void destroy(Node* pn)
     48     {
     49         delete pn;
     50     }
     51 
     52 public:
     53     LinkList()
     54     {
     55         m_header.next = NULL;
     56         m_length = 0;
     57         m_step = 1;
     58         m_current = NULL;
     59     }
     60 
     61     bool insert(const T& e)
     62     {
     63         return insert(m_length, e);
     64     }
     65 
     66     bool insert(int i, const T& e)   // O(n)
     67     {
     68         bool ret = ((0 <= i) && (i <= m_length));
     69 
     70         if( ret )
     71         {
     72             Node* node = create();
     73 
     74             if( node != NULL )
     75             {
     76                 Node* current = position(i);
     77 
     78                 node->value = e;
     79                 node->next = current->next;
     80                 current->next = node;
     81 
     82                 m_length++;
     83             }
     84             else
     85             {
     86                 THROW_EXCEPTION(NoEnoughMemoryException, "No memery to insert new element...");
     87             }
     88         }
     89 
     90         return ret;
     91     }
     92 
     93     bool remove(int i)   // O(n)
     94     {
     95         bool ret = ((0 <= i) && (i < m_length));
     96 
     97         if( ret )
     98         {
     99             Node* current = position(i);
    100 
    101             Node* toDel = current->next;
    102 
    103             current->next = toDel->next;
    104 
    105             m_length--;
    106 
    107             destroy(toDel);
    108 
    109         }
    110 
    111         return ret;
    112     }
    113 
    114     bool set(int i, const T& e)   //  O(n)
    115     {
    116         bool ret = ((0 <= i) && (i < m_length));
    117 
    118         if( ret )
    119         {
    120             position(i)->next->value = e;
    121         }
    122 
    123         return ret;
    124     }
    125 
    126     T get(int i) const
    127     {
    128         T ret;
    129 
    130         if( get(i, ret) )
    131         {
    132             return ret;
    133         }
    134         else
    135         {
    136             THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ...");
    137         }
    138 
    139         return ret;
    140     }
    141 
    142     bool get(int i, T& e) const    // O(n)
    143     {
    144         bool ret = ((0 <= i) && (i < m_length));
    145 
    146         if( ret )
    147         {
    148             e = position(i)->next->value;
    149         }
    150 
    151         return ret;
    152     }
    153 
    154     int find(const T& e) const    //  O(n)
    155     {
    156         int ret = -1;
    157         int i = 0;
    158 
    159         Node* node = m_header.next;
    160 
    161         while( node )
    162         {
    163             if( node->value == e )
    164             {
    165                 ret = i;
    166                 break;
    167             }
    168             else
    169             {
    170                 node = node->next;
    171                 i++;
    172             }
    173         }
    174 
    175         return ret;
    176     }
    177 
    178     int length() const   // O(1)
    179     {
    180         return m_length;
    181     }
    182 
    183     void clear()    //  O(n)
    184     {
    185         while( m_header.next )
    186         {
    187             Node* toDel = m_header.next;
    188 
    189             m_header.next = toDel->next;
    190 
    191             m_length--;
    192 
    193             destroy(toDel);
    194         }
    195 
    196         // m_length = 0;
    197     }
    198 
    199     bool move(int i, int step = 1)
    200     {
    201         bool ret = (0 <= i) && (i < m_length) && (step > 0);
    202 
    203         if( ret )
    204         {
    205             m_current = position(i)->next;
    206             m_step = step;
    207         }
    208 
    209         return ret;
    210     }
    211 
    212     bool end()
    213     {
    214         return (m_current == NULL);
    215     }
    216 
    217     T current()
    218     {
    219         if( !end() )
    220         {
    221             return m_current->value;
    222         }
    223         else
    224         {
    225             THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
    226         }
    227     }
    228 
    229     bool next()   //每次移动step步
    230     {
    231         int i = 0;
    232 
    233         while((i < m_step) && !end())
    234         {
    235             m_current = m_current->next;
    236             i++;
    237         }
    238 
    239         return (i == m_step);
    240     }
    241 
    242     ~LinkList()   //  O(n)
    243     {
    244         clear();
    245     }
    246 };
    247 
    248 }
    249 
    250 #endif // LINKLIST_H

    在remove函数中,先让m_length--,再做摧毁节点的操作。

    在clear函数中,注释掉原来的196行,添加第191行,每次摧毁前让m_length--。

     

    问题3:

    测试程序如下:

    结果如下:

    删除之后,游标m_current指向这个释放之后的内存,current函数返回的是这个释放了的内存中保存的value。

     图解:

    删除之后current函数返回的这块被释放了的堆内存中的value的值,所以会打印出随机值。

    修改LinkList.h中的remove函数:

     1 bool remove(int i)   // O(n)
     2     {
     3         bool ret = ((0 <= i) && (i < m_length));
     4 
     5         if( ret )
     6         {
     7             Node* current = position(i);
     8 
     9             Node* toDel = current->next;
    10 
    11             if( m_current == toDel )
    12             {
    13                 m_current = toDel->next;
    14             }
    15 
    16             current->next = toDel->next;
    17 
    18             m_length--;
    19 
    20             destroy(toDel);
    21 
    22         }
    23 
    24         return ret;
    25     }

    我们添加了第11-14行,在删除时,先进行判断,如果m_current和toDel指向的是同一个节点,那么先将m_current指向toDel的下一个节点,然后再删除。

    运行结果如下:

     

     问题4:

     

     程序改进:

     1 void destroy(Node* pn)
     2     {
     3         SNode* space = reinterpret_cast<SNode*>(m_space);
     4         SNode* psn = dynamic_cast<SNode*>(pn);
     5 
     6         for(int i = 0; i<N; i++)
     7         {
     8             if( psn == (space + i))
     9             {
    10                 m_used[i] = 0;
    11                 psn->~SNode();
    12                 break;
    13             }
    14         }
    15     }

    添加了第12行的break。

     

    问题5:

    StaticLinkList的构造函数中没有申请系统资源,从资源方面来看不用提供析构函数。

    不提供析构函数的第二个条件是,该类为一个独立的类,没有任何继承关系,但是我们StaticLinkList不满足。

    StaticLinkList继承自LinkList,LinkList中有析构函数,且这个析构函数调用了一个虚函数,但是多态是不会发生的。

    构造函数和析构函数中不会发生多态。

    StaticLinkList类中没有clear函数,因此,默认的析构函数会调用到LinkList的析构函数,进一步调用到clear函数,这个clear函数在子类和在父类中调用是一样的。

    如果子类StaticLinkList中也有一个clear函数版本,那就要提供析构函数了。因为这两个含本的析构函数都要调用到。

    但是我们再仔细观察可以发现,在clear函数中还调用了destroy函数,而这个函数在子类和父类中各有一个版本。

    子类中的版本是:

    父类中提供的版本是:

     

     这意味着父类中的析构函数被调用的时候,调用到的destroy一直是父类中的destroy。子类中的destroy无法被调用到,因为析构函数中不能发生多态。

    析构时父类中的destroy直接delete掉申请的空间,而这个空间是在我们的预留区域中申请的,不是堆空间,因此,可能会出现bug,造成程序的不稳定,因为delete关键字只能释放堆空间。

    改进程序,添加子类的析构函数:

     1 #ifndef STATICLINKLIST_H
     2 #define STATICLINKLIST_H
     3 
     4 #include "LinkList.h"
     5 
     6 namespace DTLib
     7 {
     8 
     9 template< typename T, int N >
    10 class StaticLinkList : public LinkList<T>
    11 {
    12 protected:
    13     // Node和泛指类型T有关系,因此,不能直接在子类中使用sizeof(Node),而应该
    14     // sizeof(LinkList<T>::Node)
    15     // unsigned char m_space[sizeof(typename LinkList<T>::Node) * N];  // 预留空间
    16     typedef typename LinkList<T>::Node Node;
    17 
    18     struct SNode : public Node
    19     {
    20         void* operator new(unsigned int size, void* loc)
    21         {
    22             (void)size; // 消除 size没有使用的警告
    23             return loc;
    24         }
    25     };
    26 
    27     unsigned char m_space[sizeof(SNode) * N];  // 预留空间
    28     int m_used[N];   //预留空间的标记数组
    29 
    30     Node* create()
    31     {
    32         SNode* ret = NULL;
    33 
    34         for(int i = 0; i < N; i++)
    35         {
    36             if( !m_used[i] )
    37             {
    38                 ret = reinterpret_cast<SNode*>(m_space) + i;
    39                 ret = new(ret)SNode(); //在指定空间ret上调用SNode类的构造函数。
    40                 m_used[i] = 1;
    41                 break;
    42             }
    43         }
    44 
    45         return ret;
    46     }
    47 
    48     void destroy(Node* pn)
    49     {
    50         SNode* space = reinterpret_cast<SNode*>(m_space);
    51         SNode* psn = dynamic_cast<SNode*>(pn);
    52 
    53         for(int i = 0; i<N; i++)
    54         {
    55             if( psn == (space + i))
    56             {
    57                 m_used[i] = 0;
    58                 psn->~SNode();
    59                 break;
    60             }
    61         }
    62     }
    63 
    64 public:
    65     StaticLinkList()
    66     {
    67         for(int i = 0; i < N; i++)
    68         {
    69             m_used[i] = 0;
    70         }
    71     }
    72 
    73     int capacity()
    74     {
    75         return N;
    76     }
    77 
    78     ~StaticLinkList()
    79     {
    80         this->clear();
    81     }
    82 };
    83 
    84 }
    85 
    86 #endif // STATICLINKLIST_H

    添加了第78-81行的析构函数,这时的clear是从父类继承来的,但是clear中的destroy函数就是子类自己实现的了。

    这样的话析构时,先调用子类的析构函数,然后是子类继承过来的clear函数,然后子类的destroy函数。子类的析构函数执行完时,再调用父类的析构函数,然后父类的clear函数,最后调用父类的destroy函数。但是单步执行时,我们发现并没有调用到父类的destroy函数,这里可能令人迷惑,其实是因为调用父类的析构函数时,clear函数中的while循环已经不成立的,也就不会再调用父类的destroy函数了。单步执行时要注意这一点,调用不到父类的destroy是因为条件不成立,而不是其他的机制导致的。如下:

    从子类的析构函数执行完,到调用到父类的析构函数时,clear函数中的190行的条件已经不成立了。

     

    我们在子类的析构函数和destroy函数,父类的析构函数和destroy函数加上打印,测试程序如下:

     1 #include <iostream>
     2 #include "StaticLinkList.h"
     3 
     4 using namespace std;
     5 using namespace DTLib;
     6 
     7 
     8 int main()
     9 {
    10     StaticLinkList<int, 10> list;
    11 
    12     list.insert(0);
    13 
    14     cout << list.get(0) << endl;
    15 
    16     return 0;
    17 }

    结果如下:

     

     

    问题6:

    没有必要定义多维数组的类,由一位数组就可以构成。

    示例程序:

     1 #include <iostream>
     2 #include "StaticLinkList.h"
     3 #include "DynamicArray.h"
     4 
     5 using namespace std;
     6 using namespace DTLib;
     7 
     8 
     9 int main()
    10 {
    11     StaticLinkList<int, 10> list;
    12 
    13     DynamicArray< DynamicArray<int> > d;
    14 
    15     d.resize(3);
    16 
    17     for(int i=0; i < d.length(); i++)
    18     {
    19         d[i].resize(3);
    20     }
    21 
    22     for(int i=0; i<d.length(); i++)
    23     {
    24         for(int j=0; j<d[i].length(); j++)
    25         {
    26             d[i][j] = i * j;
    27         }
    28     }
    29 
    30     for(int i=0; i<d.length(); i++)
    31     {
    32         for(int j=0; j<d[i].length(); j++)
    33         {
    34             cout << d[i][j] << " ";
    35         }
    36 
    37         cout << endl;
    38     }
    39 
    40     return 0;
    41 }

    结果如下:

     

    还可以构造不规则的数组:

     

     1 #include <iostream>
     2 #include "StaticLinkList.h"
     3 #include "DynamicArray.h"
     4 
     5 using namespace std;
     6 using namespace DTLib;
     7 
     8 
     9 int main()
    10 {
    11     StaticLinkList<int, 10> list;
    12 
    13     DynamicArray< DynamicArray<int> > d;
    14 
    15     d.resize(3);
    16 
    17     for(int i=0; i < d.length(); i++)
    18     {
    19         d[i].resize(i + 1);
    20     }
    21 
    22     for(int i=0; i<d.length(); i++)
    23     {
    24         for(int j=0; j<d[i].length(); j++)
    25         {
    26             d[i][j] = i + j;
    27         }
    28     }
    29 
    30     for(int i=0; i<d.length(); i++)
    31     {
    32         for(int j=0; j<d[i].length(); j++)
    33         {
    34             cout << d[i][j] << " ";
    35         }
    36 
    37         cout << endl;
    38     }
    39 
    40     return 0;
    41 }

    第19行使得每个数组元素大小不一样,运行结果如下:

    实践经验:

     

    转载于:https://www.cnblogs.com/wanmeishenghuo/p/9651435.html

    展开全文
  • 本文重点分析了目前几种典型的局域网安全问题及原因,从网络安全技术角度,就确保网络安全与防范网络攻击提出了解决措施
  • 典型相关分析matlab实现代码很棒的课程 介绍 在遍布互联网的大学页面中,藏有很多隐藏的宝藏。 该清单旨在揭示那些很棒的课程,这些课程可以免费在线提供其高质量的材料,例如作业,演讲,笔记,阅读和考试。 目录 ...
  • 对多种典型的带有滚动轴承的电机隔爆结构从轴承安装、隔爆接合面火焰通路角度进行了分析,从电动机设计、制造、装配、检验等过程入手,对涉及隔爆间隙、最小径向间隙和最大径向间隙、注油孔、密封沟槽等安全问题进行了...
  • 综采工作面的采煤机械化程度、单产量以及功效得到很大提高,然而重生产轻安全的观念是煤矿安全隐患的源头,以综采工作面的人、机和环境因素为安全问题的3个要素,系统分析了这3个因素对煤矿安全造成的深刻影响。...
  • 一、点击劫持 ...2. 典型点击劫持攻击流程 1)攻击者构建了一个非常有吸引力的网页 2)将被攻击的页面放置在当前页面的 iframe 中 3)使用样式将 iframe 叠加到非常有吸引力内容的上方 4)将iframe设置为100...

    一、点击劫持

    1. 点击劫持

    1)点击劫持是指在一个Web页面中隐藏了一个透明的iframe,用外层假页面诱导用户点击,实际上是在隐藏的frame上触发了点击事件进行一些用户不知情的操作

    2. 典型点击劫持攻击流程

    1)攻击者构建了一个非常有吸引力的网页
    2)将被攻击的页面放置在当前页面的 iframe 中
    3)使用样式将 iframe 叠加到非常有吸引力内容的上方
    4)将iframe设置为100%透明
    5)你被诱导点击了网页内容,你以为你点击的是***,而实际上,你成功被攻击了

    3. 点击劫持防御

    1)frame busting
    HTML5中iframe的 sandbox 属性、IE中iframe的security 属性等,都可以限制iframe页面中的JavaScript脚本执行,从而可以使得 frame busting 失效
    实例代码:

    if ( top.location != window.location ){
       top.location = window.location
    }
    

    2)X-Frame-Options
    X-FRAME-OPTIONS是微软提出的一个http头,专门用来防御利用iframe嵌套的点击劫持攻击。并且在IE8、Firefox3.6、Chrome4以上的版本均能很好的支持
    可以设置为以下值:

    • DENY: 拒绝任何域加载
    • SAMEORIGIN: 允许同源域下加载
    • ALLOW-FROM: 可以定义允许frame加载的页面地址
    4. 安全扫描工具

    1)Arachni
    Arachni是基于Ruby的开源,功能全面,高性能的漏洞扫描框架,Arachni提供简单快捷的扫描方式,只需要输入目标网站的网址即可开始扫描。它可以通过分析在扫描过程中获得的信息,来评估漏洞识别的准确性和避免误判。
    Arachni默认集成大量的检测工具,可以实施 代码注入、CSRF、文件包含检测、SQL注入、命令行注入、路径遍历等各种攻击,同时,它还提供了各种插件,可以实现表单爆破、HTTP爆破、防火墙探测等功能
    针对大型网站,该工具支持会话保持、浏览器集群、快照等功能,帮助用户更好实施渗透测试
    2)Mozilla HTTP Observatory
    Mozilla HTTP Observatory,是Mozilla最近发布的一款名为Observatory的网站安全分析工具,意在鼓励开发者和系统管理员增强自己网站的安全配置,用法非常简单:输入网站URL,即可访问并分析网站HTTP标头,随后可针对网站安全性提供数字形式的分数和字母代表的安全级别
    检查的主要范围:

    • Cookie
    • 跨源资源共享(CORS)
    • 内容安全策略(CSP)
    • HTTP公钥固定(Public Key Pinning)
    • HTTP严格安全传输(HSTS)状态
    • 是否存在HTTP到HTTPs的自动重定向
    • 子资源完整性(Subresource Integrity)
    • X-Frame-Options
    • X-XSS-Protection

    3)w3af
    W3af是一个基于Python的Web应用安全扫描器。可帮助开发人员,有助于开发人员和测试人员识别Web应用程序中的漏洞
    扫描器能够识别200多个漏洞,包括跨站点脚本、SQL注入和操作系统命令

    展开全文
  • 一、SYN攻击 1. SYN攻击 1)SYN攻击:攻击客户端在短时间内伪造大量不存在的IP地址,向服务器不断地发送SYN包,服务器回复确认包,并等待客户的确认。...SYN 攻击是一种典型的DoS/DDoS攻击。 2. 检测SYN攻...
  • 基于探究如何提升大学生对校园典型安全问题的自主应急能力,分析当前国内大学生在日常生活和学习中的三种校园典型安全问题,包括涉及领域广的消防安全、近几年较为大众关注的群体性踩踏事件和与师生财产安全最密切的...
  • 分析了煤矿供电系统的结构特点和煤矿电网在运行中常遇到的问题,提出了煤矿电网安全稳定性分析的内容及具体的计算方法。针对典型煤矿电网的具体实例,用PSASP软件进行建模,计算分析验证所提出的观点,及时发现该典型...
  • 以下分析基于JDK1.8 0. 哈希表数据结构 数据的物理存储结构主要分两种: 顺序存储和链式存储: 顺序存储: 在内存中分配连续的内存空间存储数据, JAVA中的数组就是顺序存储结构的典型应用. 顺序存储结构对于指定位置的...
  • 典型相关分析matlab实现代码课程 介绍 在遍布互联网的大学页面中,藏有很多隐藏的宝藏。 该清单旨在揭示那些很棒的课程,这些课程可以免费在线提供其高质量的材料,例如作业,演讲,笔记,阅读和考试。 目录 算法...
  • 典型相关分析matlab实现代码很棒的课程 介绍 这里有很多隐珍藏在散布在互联网上的大学网页内。 该清单旨在揭示那些很棒的课程,这些课程可以免费在线提供其高质量的材料,例如作业,演讲,笔记,阅读和考试。 目录 ...
  • Docker容器安全分析

    2020-08-16 10:28:50
    本文对Docker容器在应用中可能面临的安全问题和风险进行了研究,并将Docker容器应用环境中的安全机制与相关解决方案分为容器虚拟化安全、容器安全管理、容器网络安全三部分进行分析。 一、从虚拟化安全到容器安全 1...
  • 摘要:当前个人计算机在我国已经基本普及人们的工作和生活和计算机的联系愈来愈紧密与此同时计算机信息安全问题也愈来愈凸显有鉴于此本文就对计算机在应用的过程中出现的一些常见典型安全问题进行了梳理与分析研究在...
  • 通过分析通信业发生的几起典型用户信息安全事件,研究目前用户信息安全存在的威胁,归纳总结问题原因,并从用户信息保护、安全技术手段、敏感信息保护、安全管理体系等几个方面提出解决办法,为制定通信业用户信息...
  • GraphQL访问安全分析

    千次阅读 2019-03-25 14:46:03
    本文以GraphQL中一些容易让初学者与典型Web API(为了便于理解,下文以目前流行的RESTful API为例代指)混淆或错误理解的概念特性进行内容划分,由我从安全的角度抛出GraphQL应该注意的几点安全问题,而@图南则会更...
  • 针对煤矿安全事故人因因素众多、复杂且呈现出典型的灰色系统特征的问题,将HFACS与灰色系统理论相结合,以从汾西煤矿集团获取的45起煤矿安全事故报告为对象,在利用HFACS对事故调查报告分析的基础上,利用灰色关联研究...
  • Web网络安全攻击分析

    2020-03-20 15:24:28
    1. Web应用的概念 ... 典型的Web应用是三层架构模型:Web层(View)、业务逻辑层(Controller、Service)、数据层(Model) ...发生Web安全问题一般出现在Web层和业务逻辑层,因为Web层和业务逻辑...
  • SIEM期待实时安全分析

    2012-04-11 15:39:55
    2012年4月3日,SearchSecurity发布了一篇名为“Security information management systems aspire to real-time security”的文章,谈到了实时分析,以及实时安全分析问题。正好,昨天看到TT安全已经有人将它翻译并...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 747
精华内容 298
关键字:

安全典型问题分析