精华内容
下载资源
问答
  • SAFE-BookStore, 安全重新加载的安全堆栈项目的工作示例 为开发者的快乐设计一个网页栈设计下面的文档描述了安全堆栈示例项目。 安全是将若干技术集成到单一的。一致的栈中的技术堆栈,它们是一个面向对象的灵活的...
  • 物联网安全 物联网安全堆栈 安全 TLS选项和ACL认证 客户端配置在MQTTX中需要是这样的:
  • 堆栈(Stack)代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时,则使用堆栈。当您在列表中添加一项,称为推入元素,当您从列表中移除一项时,称为弹出元素。 Stack 类的方法和属性 Stack 类的...

    一、Stack
    堆栈(Stack)代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时,则使用堆栈。当您在列表中添加一项,称为推入元素,当您从列表中移除一项时,称为弹出元素。

    Stack 类的方法和属性
    Stack 类的一些常用的 属性:

    属性描述
    Count获取 Stack 中包含的元素个数。

    Stack 类的一些常用的 方法:

    方法描述
    public virtual void Clear();从 Stack 中移除所有的元素。
    public virtual bool Contains( object obj );判断某个元素是否在 Stack 中。
    public virtual object Peek();返回在 Stack 的顶部的对象,但不移除它。
    public virtual object Pop();移除并返回在 Stack 的顶部的对象。
    public virtual void Push( object obj );向 Stack 的顶部添加一个对象。
    public virtual object[] ToArray();复制 Stack 到一个新的数组中。

    实例

    using System;
    using System.Collections;
    
    namespace CollectionsApplication
    {
        class Program
        {
            static void Main(string[] args)
            {
                Stack st = new Stack();
    
                st.Push('A');
                st.Push('M');
                st.Push('G');
                st.Push('W');
               
                Console.WriteLine("Current stack: ");
                foreach (char c in st)
                {
                    Console.Write(c + " ");
                }
                Console.WriteLine();
               
                st.Push('V');
                st.Push('H');
                Console.WriteLine("The next poppable value in stack: {0}",
                st.Peek());
                Console.WriteLine("Current stack: ");          
                foreach (char c in st)
                {
                   Console.Write(c + " ");
                }
                Console.WriteLine();
    
                Console.WriteLine("Removing values :{0}", st.Pop());
                Console.WriteLine("Removing values :{0}", st.Pop());
                Console.WriteLine("Removing values :{0}", st.Pop());
               
                Console.WriteLine("Current stack: ");
                foreach (char c in st)
                {
                   Console.Write(c + " ");
                }
            }
        }
    }
    

    结果

    Current stack: 
    W G M A
    The next poppable value in stack: H
    Current stack: 
    H V W G M A
    Removing values :H
    Removing values :V
    Removing values :W
    Current stack: 
    G M A
    

    二、ConcurrentStack

    由于Stack是线程不安全的集合,在进行多线程多任务操作集合时会出现数据丢失等问题。通常的解决方法是添加lock锁。lock 确保当一个线程位于代码的临界区时,另一个线程不进入临界区。如果其他线程试图进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。但锁的引入,带来了一定的开销和性能的损耗,并降低了程序的扩展性,而且还会有死锁的可能。

    在.NET Framework 4提供了新的线程安全和扩展的并发集合,它们能够解决潜在的死锁问题和竞争条件问题,因此在很多复杂的情形下它们能够使得并行代码更容易编写,这些集合尽可能减少使用锁的次数,从而使得在大部分情形下能够优化为最佳性能,不会产生不必要的同步开销。(需要注意:在串行代码中不要使用并发集合,会增加不必要的开销)

    Stack对应的线程安全的并发集合就是 ConcurrentStack,命名空间:System.Collections.Concurrent
    ConcurrentStack类的常用方法:

    方法描述
    public void Push(Object obj)向 ConcurrentStack的顶部添加一个对象。
    public bool TryPop()移除并返回在 ConcurrentStack的顶部的对象。

    关于ConcurrentStack是如何实现线程安全的,可参考文章C# ConcurrentStack实现

    展开全文
  • 强化TCP/IP堆栈安全

    2021-03-04 22:58:31
    可以在Windows注册表内配置各种TCP/IP参数,以便保护服务器免遭网络级别的拒绝服务攻击,包括SYS洪水攻击、ICMP攻击和SNMP攻击。...TCP/IP天生就是一个不安全的协议。但是,Windows2000版本允许您配
  • 堆栈攻击 八层网络安全防御
  • 堆栈方面入手进行的网络攻防 分享加备份
  • //既然 大家对堆栈达成共识才看到这了 再来看下调用函数,继续反汇编 观察堆栈变化    ShowEsp(&arg1,&arg2);    //a)入栈操作 (esp寄存器的变化) 用的是push 每次push后esp减4 压入返回地址后 jmp到...
    [cpp]  view plain  copy
    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include <string.h>  
    4. #include <windows.h>  
    5.   
    6. int ShowEsp(int* arg1,int* arg2);  
    7.   
    8. /* 
    9. 引言 各种面试宝典上都会说 又说栈在进程空间的高地址部分,向下扩展;  
    10. 堆在进程空间的低地址部分,堆向上扩展 
    11. 来验证一下是否正如所说这些变量在内存中如何分布? 
    12. */  
    13. int main()  
    14. {  
    15.   
    16.     //0)  
    17.     int i=0xABCDABCD;  
    18.     //int* j = (int*)malloc(sizeof(int)); //malloc为什么被我注掉了?  
    19.     //memcpy(j,&i,sizeof(int));  
    20.     int* k = (int*)VirtualAlloc(NULL,sizeof(int),MEM_COMMIT,PAGE_READWRITE);  
    21.     int* ptr = NULL;  
    22.     ptr = (int*)&i;  
    23.     //ptr = j;   
    24.     /* 
    25.     malloc 是crt运行库实现 系统为crt库在进程靠近2G的高地址处保留大块堆内存 用链表管理  
    26.     调用malloc时,单独从此处抽取分配给调用者 
    27.     */  
    28.     ptr = k;  
    29.   
    30.     //1) 忽略malloc这另类 看看实际系统定义诺干栈变量后,查看他们在内存中的分布  
    31.     int arg1=0x40302010;  
    32.     int arg2=0x20;  
    33.     int* ptr1=NULL;  
    34.     int* ptr2=NULL;  
    35.     char str[] = {"1234567"};  
    36.     printf("arg1:%x\narg2:%x\n",&arg1,&arg2);  
    37.     printf("ptr1:%x\nptr2:%x\n",&ptr1,&ptr2);  
    38.     printf("str:%x\n",str);  
    39.     //结论:变量的地址是连续并且向下扩展  
    40.     //编译器通过sub esp,immd来开辟栈空间  
    41.     //再来看下变量地址存放的内容 arg1  
    42.     char* arg1Ptr = (char*)&arg1;  
    43.     printf("arg1Ptr[0]:%02x\narg1Ptr[1]:%02x\narg1Ptr[2]:%02x\narg1Ptr[3]:%02x\n",*arg1Ptr,*(arg1Ptr+1),*(arg1Ptr+2),*(arg1Ptr+3));  
    44.     //程序没问题吧,感觉在用arg1Ptr取arg1各个字节的内容,看下arg1在内存中的分布  
    45.     //.........................................................................  
    46.     //intel cpu小端机 (题外话 网络编程时 ip/port转换即为大小端字节转换) 数据在内存中按高高低低分布 高字节 在高位 低字节在低位  
    47.   
    48.     //2) 知道了变量在内存中的分布 再看下如何存取变量,alt-8  
    49.     //  
    50.     arg1 = 0x80706050;  
    51.     arg2 = arg1;  
    52.     arg2 = 0x20;  
    53.   
    54.     //程序编译后 用[ebp-N]相对偏移取变量 why?   
    55.     //intel CPU用esp指向当前函数栈顶,变量又保存在栈中,理所当然的可以用esp取变量。  
    56.     //但是变量在不断扩充esp在不断减小 ------  
    57.     //假设 现在要取arg1变量值 可能会编译成 mov eax,[esp+0x40],意思是arg1离栈顶esp相差0x40个字节  
    58.     //如果程序又新定义一个栈变量,栈顶向下移动,即esp=esp-4 此时 esp离arg1的距离为0x44   
    59.     //如果再次取arg1的值 会编译成 mov eax,[esp+0x44] 这样编译起来太麻烦了    
    60.     //a) intel CPU用ebp做当前函数帧[不是强制约定 习惯],也就是栈底,某些面试宝典会写  
    61.     //函数栈底不改变,说的就是ebp再当前函数中不改变。栈变量编译后内存位置固定下来,现在ebp又是固定不变的准绳  
    62.     //这样无论程序怎样扩展栈变量,ebp到各个变量之间的距离都不会改变  
    63.       
    64.     //3) 面试宝典还说 c++参数入栈顺序是 从右往左压栈 全部入完后 压入函数返回地址  
    65.     //既然 大家对堆栈达成共识才看到这了 再来看下调用函数,继续反汇编 观察堆栈变化  
    66.     ShowEsp(&arg1,&arg2);  
    67.     //a)入栈操作 (esp寄存器的变化) 用的是push 每次push后esp减4 压入返回地址后 jmp到ShowEsp  
    68.     //程序jmp到ShowEsp 这里也跟到esp  
    69.       
    70.     //5) 堆栈平衡的收尾  
    71.     /* 
    72.     来看下函数返回后当前栈顶还剩啥 
    73.     指令执行顺序-|esp变化------|保存ebp后变量相对于新栈帧ebp的距离------- 
    74.     push &arg2   |1次esp=esp-4 | ebp+0x0C 
    75.     push &arg1   |2次esp=esp-4 | ebp+0x08 
    76.     */  
    77.     /*函数参数已经显得不重要了可以忽略不计,再说main函数中依然可以通过[ebp-N]的形式访问这些变量 
    78.     但是目前堆栈还没有恢复到函数调用前的样子 还倒欠main函数8个字节,于是编译器采用了一种简单粗暴 
    79.     却有行之有效的办法 
    80.     add esp,0x08 
    81.     于是堆栈平衡 
    82.     还有一个问题,函数范围值在哪?eax中 
    83.     eax 4字节 不管返回什么都没问题 
    84.     */  
    85.     exit(0);  
    86. }  
    87.   
    88. int ShowEsp(int* arg1,int* arg2)  
    89. {  
    90.     //进入到ShowEsp后 先是取形参,然后赋值给局部变量  
    91.     //局部变量访问 已经不是这里的重点 此处重点看下如何取形参  
    92.     int op1,op2,res;  
    93.     //atl-8  
    94.     op1 = *arg1;  
    95.     op2 = *arg2;  
    96.     /* 
    97.     访问arg1 arg2 被翻译成mov eax,[ebp+8],[ebp+0x0c] 
    98.     之前访问变量是用[ebp-N]的形式 现在怎么变成使用[ebp+N]的形式? 
    99.     解释这个 还是得看反汇编的结果 
    100.     反汇编的前几句如下 
    101.     push ebp 
    102.     mov ebp,esp 
    103.     sub esp,4Ch 
    104.     上面2-a)处写到过 intel CPU用ebp做当前函数帧,刚才指令流是在main函数中,因此ebp是基于main函数的 
    105.     现在进入到ShowEsp函数中,要形成新的函数帧,因此先用push ebp把前一个函数的函数帧保存起来,然后 
    106.     mov ebp,esp把当前的栈顶esp赋值给ebp形成新的函数帧 最后的sub esp,4Ch 为本函数创建栈空间 
    107.      
    108.     如果把之前main函数中的函数调用和参数入栈 以及此处生成新的函数帧一系列动作联合起来 并查看esp在此期间的 
    109.     变化: 
    110.     指令执行顺序-|esp变化------|保存ebp后变量相对于新栈帧ebp的距离------- 
    111.     push &arg2   |1次esp=esp-4 | ebp+0x0C 
    112.     push &arg1   |2次esp=esp-4 | ebp+0x08 
    113.     call ShowEsp |3次esp=esp-4 | ebp+0x04 
    114.     push ebp     |4次esp=esp-4 | ebp+0x00 
    115.      
    116.     这应该能解释函数取形参用mov eax,[ebp+0x08]等形式 
    117.     */  
    118.     res = op1+op2;  
    119.   
    120.     //4)堆栈平衡的下半段  
    121.     /* 
    122.     还是拿某宝典说事,说c++是_stdcall c是_cdcel call 
    123.     区别是函数执行结束 一个由被调用的函数恢复堆栈 另一个是由调用者恢复堆栈 
    124.     这代码是_cdcel call 由调用者恢复堆栈 
    125.     来看下这函数怎么恢复堆栈 继续返回编 
    126.     */  
    127.     return res;  
    128.     /* 
    129.     程序结尾处看到 
    130.     mov esp ebp 
    131.     pop ebp 
    132.     ret 8 
    133.     还记得函数入口处的? 
    134.     push ebp 
    135.     mov ebp esp 
    136.     都说是堆栈操作了,所有的操作要呼应对吧,执行了 
    137.     mov esp ebp 
    138.     pop ebp 
    139.     这两句之后,函数堆栈恢复到发生调用ShowEsp的情景,虽然ShowEsp分配的栈变量还存在,但 
    140.     已经处在esp指向的范围之外,换句话说,此时再新建栈变量,以前栈上的变量就会覆盖。当然 
    141.     很少有人这么做。这也是有时候函数返回了,还能得到函数内部变量的原因。注意,所谓的宝典 
    142.     会说,函数返回会自动清栈变量,反正c的代码,我没看到这种语句 
    143.  
    144.     最后的ret语句会使程序返回到函数调用的地方,这个地方由谁指定? 
    145.     还记得3-a)处调用ShowEsp时,把下一条指令压入堆栈?就是那个时候指定函数返回地址,翻阅intel手册 
    146.     说发生ret时,返回到当前栈顶指向的值 
    147.  
    148.     来看下当前栈顶还剩啥 
    149.     指令执行顺序-|esp变化------|保存ebp后变量相对于新栈帧ebp的距离------- 
    150.     push &arg2   |1次esp=esp-4 | ebp+0x0C 
    151.     push &arg1   |2次esp=esp-4 | ebp+0x08 
    152.     call ShowEsp |3次esp=esp-4 | ebp+0x04 
    153.     栈顶还剩call ShowEsp时压入的返回地址,ret执行后 相当于pop eax, jmp eax 弹出一个栈值。 
    154.     于是我们乘坐这个传送门返回到main函数中 
    155.      
    156.     [题外话]如果修改这个返回地址会得到意想不到的结果,这是后面要讲的缓冲区溢出 
    157.     */  
    158. }  
    159.   
    160. //文章结尾感谢同事yj同志 帮我做义务审校,并提出修改建议  
    展开全文
  • 基于深度堆栈编码器和反向传播算法的网络安全态势要素识别.pdf
  • 本书利用著名的开放系统互连(OSI)协议堆栈模型,以独特而新颖的观点看待网络安全,将这一综合性的大课题细分到了OSI模型中的每个独立层次当中。作者从分析网络每一层的漏洞出发,假想攻击这些漏洞的各种可能性,在...
  • 自动化ELK堆栈部署 该存储库中的文件用于配置以下所示的网络。 ![azure environment](Azure Environment.png) 这些文件已经过测试,并用于在Azure上生成实时ELK部署。 它们可用于重新创建上图所示的整个部署。 ...
  • 【C/C++笔记】之多线程中的堆栈问题

    千次阅读 2019-03-28 11:38:10
    那在多线程环境下的堆栈是如何分配的呢? 我们只需要记住以下两点: 1.每个线程一个栈,每个进程一个堆。 2.请看典型的内存分布图。不同的段可能被加载器映射到相距很遥远的位置。 1.变量在内存地址的分布为:堆-...

    一般的由C/C++编译的程序占用的内存分为以下几个部分
    1、栈区(stack)。
    2、堆区(heap)。
    3、静态数据区(全局)。
    5、程序代码区。

    那在多线程环境下的堆栈是如何分配的呢?

    我们只需要记住以下两点:

    1. 每个线程一个栈,每个进程一个堆。
    2. 请看典型的内存分布图。不同的段可能被加载器映射到相距很遥远的位置。

    1.      变量在内存地址的分布为:堆-栈-代码区-全局静态-常量数据

    2.      同一区域的各变量按声明的顺序在内存的中依次由低到高分配空间(只有未赋值的全局变量是个例外)。

    3.      全局变量和静态变量如果不赋值,默认为0。 栈中的变量如果不赋值,则是一个随机的数据。

    4.      编译器会认为全局变量和静态变量是等同的,已初始化的全局变量和静态变量分配在一起,未初始化的全局变量和静态变量分配在另一起。
    而且主函数中栈的地址都要高于子函数中参数及栈地址,证明了栈的伸展方向是由高地址向低地址扩展的。主函数和子函数中静态数据的地址也是相邻的,说明程序会将已初始化的全局变量和表态变量分配在一起,未初始化的全局变量和表态变量分配在另一起。

    参考:https://blog.csdn.net/morewindows/article/details/6851681

    展开全文
  • 堆栈攻击—八层网络安全防御(影印) 效果还可以 比某5分资源值多了 敬请下载
  • 按OSI分层角度探讨网络安全,深入研究OSI堆栈,从物理层开始直到应用层。从分析每一层的漏洞出发,假想攻击这些漏洞的各种可能性,在此基础上讨论各个网络层次的安全防御手段。在讨论了所有的技术环节后,并没有忘记...
  • day17.什么是堆栈

    2018-02-10 18:36:08
    第17节:什么是堆栈在前面的课程中应该知道每一个程序都有一个4G的内存空间,如果不知道的话可以看前面的章节,那么是不是当前的这个程序的4G内存空间可以独立使用呢?答案:不是的。虽然说有4G内存,但是你真正要...
    第17节:什么是堆栈
    


    在前面的课程中应该知道每一个程序都有一个4G的内存空间,如果不知道的话可以看前面的章节,那么是不是当前的这个程序的4G内存空间可以独立使用呢?答案:不是的。虽然说有4G内存,但是你真正要用到某一块内存空间的时候,你一定要向操作系统申请,换句话说你要告诉操作系统。我们管这个过程叫做内存申请,那不同的语言申请的形式也是不同的,但是本质上是相同的。那么至于怎么写后面会讲到,你只要记住进程有一个4G内存,但应用程序想使用某一块内存,一定要申请,那么这个申请过程就是所提到的内存申请。


    那堆栈有是怎么一回事呢?堆栈就好比一块内存,只不过是程序员申请的,它只有在你的程序启动执行的时候,操作系统会给你分配好的,所以堆栈和其他内存不同的地方。别的内存是程序员自己申请的,但堆栈是程序启动时分配的。堆栈是给程序执行的时候使用的,你的程序在执行过程中肯定要执行临时数据等等,这些信息存储在哪里呢?答案:是在堆栈中。(注意:这里提到的堆栈不要和数据结构的堆栈搞混淆)


    任何程序在执行过程中使用到的数据都会在堆栈中体现出来,所以我们可以这样理解,堆栈可以做程序的心脏,无论你是做病毒和反病毒,或者是漏洞扫描,堆栈是我们必须理解的。对于正向的普通程序员,他们对堆栈并没有怎么关注,因为操作系统给他们分配好的,他们只管取使用就可以了,他们不管细节是什么样的。如果你是做安全或者底层开发的人你就会了解到堆栈。


    举例:
    1)打开olldebug工具
    2)托入一个程序
    3)看寄存器中的S位(FS位) 
    4)32bit对应着是B2B000(FFF) 注意:这里你们可能跟我不一样因为程序不一样
    5)B2B000这个值在指令窗口中输入dd B2B000
    6)可以看到B2B000下的B2B004=009F000 的值加上4就是和B2B008=09E6000
    7)这两个值就是操作系统为我们分配的内存空间(注意:在堆栈窗口中最后的值是009EFFFC 的值加上4就是009F000)
    8)所以以上的例子就是我反复提到的堆栈




    这块内存还有一个特征,都是从小到大的排列,这个排列顺序是从后往前的,如果当程序中的内存不够用的时候就会出错(也就是内存溢出),比如:写递归的时候写太大了就会出现内存溢出的情况。




    1、ESP指令(称为:栈指针寄存器)
    什么叫栈指针寄存器,就是我们讲的当你程序可以用,那么程序用到那里了,需要记录的这个地址称为栈指针寄存器,记录地址存在ESP内。


    举例:
    1)存储1和2的值
    2)mov dword ptr ds:[0x18FFFC8],1
    3)mov dword ptr ds:[0x18FFFC4],2
    4)SUB ESP,8
    5)看堆栈的值变化
    6)看ESP寄存器的变化




    2、PUSH指令
    功能
    1)向堆栈中存入数据
    2)修改栈顶指针ESP寄存器的值
    也就是前面说的ESP指令的例子,只是这里是简写形式


    3、POP指令
    POP指令是将数据拿出来存到一个地方,esp再加4
    举例:
    mov eax,10
    mov ecx,dword ptr ds:[esp]
    add esp,4


    简写是:
    pop eax





    展开全文
  • future.scala是的精神继任者,它以纯函数形式提供了堆栈安全的异步编程。 我们放弃了Stateless Future内置的async / await支持,转而使用了提供的更通用的monadic / each语法。 future.scala提供类似于scala....
  • 快速且类型安全的全堆栈框架,用于TypeScript 为什么要弗鲁里奥(frourio)? 即使您同时在TypeScript中编写前端和后端,也无法静态地对API的稀疏性进行类型检查。 我们总是被迫编写“ Two TypeScript”。 我们在...
  • 堆栈:C#中的堆栈实现
  • 此存储库包含的规范, 是模块化的对等消息传递堆栈,重点是安全消息传递。 有关vac及其设计目标的详细说明,请参见。 参见 。 贡献 请参阅了解一般准则和规格生命周期。 本地建筑 确保您拥有Hugo扩展版( ),然后...
  • java内存模型和线程安全,详细解析java的 堆栈模型和线程机制
  • S2OPC是一个开放源代码的OPC UA工具包,包括OPC UA通信堆栈,客户端/服务器,发布者/订阅者,它是按照B方法实现的。 S2OPC OPC UA工具包是研发项目INGOPCS(2016-2018)的结果,其目标是:-开发OPC-UA标准(IEC ...
  • Dsiem是用于的安全事件相关引擎,允许将该平台用作专用且功能齐全的系统。 Dsiem为标准化的日志/事件提供风格的关联,对威胁情报和漏洞信息源执行查找/查询,并生成风险调整后的警报。 产品特点 以作为前端节点和...
  • 此存储库包含的规范, 是模块化的对等消息传递堆栈,重点是安全消息传递。 有关vac及其设计目标的详细说明,请参见。 状态 整个vac协议正在积极开发中,每个规范都有其自己的status ,这可以通过每个文档顶部的版本...
  • 一个安全可靠的 Node.js 应用程序的简单堆栈。 TL; 博士 后端堆栈 表示 待补充... 前端堆栈 鲍尔 浏览器化 React 手写笔 公共栈 吞咽 ESLint 笑话 执照 麻省理工学院许可证 (MIT) 版权所有 (c) 2014
  • 公共堆栈与线程的私有堆栈 在启动线程时,变量的值是存在于公共堆栈及线程的私有堆栈中。在JVM被设置为-server 模式时为了线程运行的效率,线程一直在私有堆栈中取变量的值,即使有其他线程将变量的值进行了修改,...
  • holberton-system_engineering-devops
  • 践踏堆栈攻防总结

    2012-02-29 17:09:27
    该文档总结了常见的基于堆栈的漏洞攻击及其防御机制
  • 对于操作系统内存中的缓存区溢出的基本原理进行阐述,内嵌有小例子
  • 堆栈方法区详解

    2020-08-20 18:15:58
    2) 堆栈(stack):位于通用RAM中,但通过它的“堆栈指针”可以从处理器哪里获得支持。堆栈指针若向下移动,则分配新的内存;若向上移动,则释放那些内存。这是一种快速有效的分配存储方法,仅次于寄存器。创建程序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 148,189
精华内容 59,275
关键字:

安全堆栈