精华内容
下载资源
问答
  • 基于矩形安全邻域的智能车移动仿真研究,熊升华,赵海良,提出了一种基于矩形安全邻域的智能车移动仿真方法。首先,结合智能车行驶环境可能的传感信息,对几种常用的安全邻域进行了数学描
  • 整个过程形成了一套基于矩形安全邻域的智能车移动仿真方法, 并对智能车实时搜索矩形安全邻域及据之决策行进的过程进行了仿真。结果表明, 该方法可以实时规划智能车的行驶路线, 有效地应对突发行驶障碍等问题。
  • 为提高篡改检测性能和协调安全性与不可见性之间的矛盾,提出一种利用邻域比较判定图像块真实性的JPEG脆弱水印算法.该算法将原始图像分成8 8的图像块,基于图像块保护DCT系数生成的4比特水印基于密钥随机嵌入到其他4个...
  • 通过分析灰度空域图像隐写直接扩展至彩色空域图像潜在的安全问题,提出了针对彩色空域图像隐写的隐写分析特征。首先,计算颜色通道内邻域像素差分矩阵的 Markov 转移概率矩阵,提取颜色通道内特征并进行融合;然后,...
  • 根据超高压系统3/2接线变电站结构特点,提出基于邻域信息的按串配置断路器保护方案及其实现方法,提升近后备保护的选择性、速动性和可靠性。按串配置断路器保护方案包括3种优化策略:消除死区的断路器分合优化策略、...
  • 级联失效对物流网络的安全运作具有重要影响。基于节点领域信息构建相应的级联失效模型, 分析研究物流网络的级联失效问题。数值仿真结果表明:较低的安全负载能力配置可很大程度上抵御级联失效的破坏; 重要度越大的...
  • 文章分析了在智能电网中引入认知无线传感器网络(WCSN)的必要性,列举了智能电网、认知无线电网络和无线传感器网络的相关研究成果,描述了智能电网WCSN分层结构包括家域网、邻域网和广域网,提出了智能电网WCSN安全架构...
  • 通过引入最优解邻域扩张机制增加解的多样性,对基本智能水滴算法进行改进,避免算法在寻优过程中陷入局部最优解导致算法"早熟".利用改进的智能水滴算法对已知环境进行全局航线决策,再利用交互速度障碍法根据遇到的动态...
  • 特征码检测技术依赖邻域专家的行业经验和个人能力提取恶意软件的特征码,让该特征码唯一性的映射到对应的恶意软件。该技术的前提 是必须先捕获恶意软件样本,捕获样本的常见方法有用户上报、蜜罐技术、定向采集等,...

    一、恶意软件检测

    3.1 常用恶意软件检测技术

    目前,常用的恶意软件检测技术有特征码检测技术、校验和技术、行为分析技术、虚拟机技术、启发式检测技术等。

    (1)特征码检测技术

    特征码检测技术依赖邻域专家的行业经验和个人能力提取恶意软件的特征码,让该特征码唯一性的映射到对应的恶意软件。该技术的前提 是必须先捕获恶意软件样本,捕获样本的常见方法有用户上报、蜜罐技术、定向采集等,然后根据恶意软件样本进行特征码抽取,在抽取时需要遵循“在保持特征代码唯一性的前提下,尽量使特征代码长度短些,以减少时空开销”的原则。

    (2)校验和技术

    校验和技术采用文件的校验和作为检测恶意软件的依据,在系统中建立新文件时,计算并保存正常文件的校验和。在文件使用时,计算文件当前的校验和,并将其与先前的校验和进行比较,如果不一致,判断该文件感染了恶意软件。

    (3)行为分析技术

    行为分析技术采用行为特征序列来作为判别恶意软件的依据,根据邻域专家多年经验找出恶意软件的一些共通性行为来建立行为序列特征库。该技术在检测恶意软件时,监测程序运行过程中产生的行为信息,分析程序的执行流程及其对系统的影响,构建程序行为特征序列,并将该行为序列与特征库进行比较,如有一致,则判断正在执行的程序为恶意软件。

    (4)虚拟机技术

    虚拟机技术采用程序代码虚拟CPU寄存器和硬件端口,用调试程序调入可疑恶意程序样本,将每个语句放到虚拟环境中执行,通过虚拟的内存、寄存器以及端口的变化来了解程序的执行,可以让变种病毒特别是加密病毒自动解密露出原形,而不用研究各个恶意软件的解密算法及密钥。

    (5)启发式检测技术

    启发式检测技术采用邻域专家分析的经验,建立经典指令集,如典型感染指令集、典型传播指令集、典型破坏指令集等,对每个经典指令集赋以不同的权值。在检测恶意软件时,在用恶意软件特征码未查到已知恶意软件的情况下,再搜索这个指令集库,如果找到符合的记录的权值之和超过某一阈值,则判断被检测文件是恶意软件。启发式检测技术能够对特征码检测技术形成有效补充。

    3.2 恶意软件特征提取技术

    1.恶意软件特征表达

    对恶意软件的特征表达通常有静态特征和动态特征两种表达方式

    (1)静态特征

    静态特征指在不运行程序的情况下,将程序的指令、代码、控制流或者其他特征抽取出来。
    该方法优点是:样本覆盖率高,提取速度快。缺点是:对于一些采用变形或多态技术的恶意软件识别需要多角度分析。

    (2)动态特征

    动态特征指将程序在真实环境或虚拟环境下运行起来,并监视其各种行为。
    该方法的优点是:能准确捕获运行程序的行为,对采用变形或多态技术的恶意软件具有较强的识别能力。缺点是:样本覆盖率低,特征提取速度慢。
    特征提取一定要有效、自动、高效,因此静态特征更适合于作为大规模样本识别的特征表达。

    2.恶意软件特征提取

    (1) Win API函数

    下面介绍从引入表中静态提取PE文件(可移植的可执行的文件)所包含的Win API函数的具体提取步骤:
    检验文件是否是有效的PE→从DOS Header 定位到PE Header→获取位于Optional Header 的数据目录地址→转至数据目录的第二个成员,提取其Virtual Address值→利用上值定位第一个IMAGE_IMPORT_DESCRIPTOR结构→检查OriginalFirstThunk值:若不为0,沿着OriginalFirstThunk里的RVA值转入RVA对应的数组;否则,改用FirstThunk值→对每个数组元素,判断其元素值的最高二进制是否为1,若是,则函数是由序数引入的,可以从该值的低字节提取序数;若不是(既元素值的最高二进制位为0),则可将该值作为RVA转入IMAGE_IMPORT_BY_NAME数组,跳过Hint即为函数名。→跳至下一个数组元素提取函数名一直到数组底部(以null结尾)→当遍历完一个DLL的引入函数,接下去处理下一个DLL;既跳转到下一个IMAGE_IMPORT_DESCRIPTOR并处理它,循环直到数组底部(IMAGE_IMPORT_DESCRIPTOR数组以一个全0域元素结尾)

    (2)文件字符串信息

    文件字符串特征是指PE文件中同一字符集的连续字符序列,文件字符串特征提取方法为:通过反编译PE文件,从文件头开始读取文件连续的字符,直到遇见“0X00”或字符与前面的字符序列不在同一个字符集为止。

    (3)文件资源信息

    可以按照文件资源的树状结构进行相应资源信息的提取,提取的资源信息主要有:cursor\bitmap\icon\menu\dialog等。提取后的资源信息,转换为整型向量,并存储于数据库中以便相应的分类算法进行学习。

    (4)文件指令信息

    文件的指令信息是指将文件进行反汇编之后,从其代码段提取相应的汇编指令信息。

    3.3 数据挖掘在恶意软件检测中的应用

    3.3.1 基于分类方法的恶意软件检测

    常用分类算法:决策树归纳算法、朴素贝叶斯算法、K-近邻分类算法、集成分类器Boosted J4.8等

    3.3.2 基于聚类分析方法的恶意软件归类

    常用聚类算法:k-均值聚类、层次聚类等
    1.层次聚类方法在恶意软件归类中的应用
    (1)恶意软件特征 (2)行为特征近似度计算 (3)构建层次聚类关系树 (4) 恶意软件归类
    加权子空间的k-medoids聚类方法在恶意软件归类的应用
    (1)提取样本文件特征 (2)使用聚类算法

    3.3.3 基于数据挖掘技术的钓鱼网站检测

    1.钓鱼网站检测技术
    (1)基于黑白名单的钓鱼网站检测技术
    该技术核心在于维护黑名单库,在库中出现的URL/IP被认为是不可信的。
    优点:高效、准确、简单 缺点:滞后性、失效率高
    (2)基于页面的启发式钓鱼检测技术
    该算法从各个方面挖掘钓鱼网站页面存在的特征,利用机器学习算法和训练样本对分类模型进行训练,从而区别正常网页和钓鱼网页。
    (3)基于视觉相似的钓鱼检测技术
    主要有:基于HTML的检测、基于网页图像的检测

    展开全文
  • 如今,能源需求不断增加,加速...智能电网涉及电力、通信及应用等多个层次,涵盖家庭区域网(HAN)、邻域网(NAN)和广域网(WAN)等不同类型。双向通信智能电表的部署,有助于推动以HAN为基础的智能家庭市场的增长。
  • 如今,全球能源需求不断增加,加速...智能电网涉及电力、通信及应用等多个层次,涵盖家庭区域网(HAN)、邻域网(NAN)和广域网(WAN)等不同类型。双向通信智能电表的部署,有助于推动以HAN为基础的智能家庭市场的增
  • UUV)作为一种高技术手段,在海洋这块未来极具价值的发展空间中起着至关重要的作用,而路径规划是自主式水下航行器的关键技术之一,是自主式水下航行器能在所处的环境中安全、有效地行驶,顺利完成给定任务的重要保证...

    0af5f8e57b47d40a248343ac0b74bca4.gif

    本发明涉及的是一种UUV全局路径规划方法。

    背景技术:

    无人水下航行器(Unmanned underwater vehicle,UUV)作为一种高技术手段,在海洋这块未来极具价值的发展空间中起着至关重要的作用,而路径规划是自主式水下航行器的关键技术之一,是自主式水下航行器能在所处的环境中安全、有效地行驶,顺利完成给定任务的重要保证。

    UUV全局路径规划本质是在规划区域内,在给定的障碍物和约束条件下,寻找一条从起始点到目标点的最优或可行的路径。传统的路径规划算法,如人工势场法、图搜索法、粒子群算法等大多有一些不足之处,例如容易陷入局部极小及计算量大等问题。在以栅格法环境建模的基础上,采用可搜索连续领域的A*算法进行UUV全局路径规划,可以有效地解决传统UUV路径规划算法容易陷入局部最优点、计算量大等问题。

    技术实现要素:

    本发明的目的在于提供一种能缩短UUV路径、节约时间、提高效率的基于可搜索连续邻域A*算法的路径规划方法。

    本发明的目的是这样实现的:

    步骤一、根据存在的障碍物采用栅格法建立环境模型获得的环境模型,对以UUV为质点、障碍物的最长宽度为直径、障碍物的重心为原点的圆形障碍物,利用公式获得各圆形障碍物的面积Si,其中li为第i障碍物的最大直径;

    步骤二、根据步骤一获得的各圆形障碍物的面积,确定栅格大小l;

    其中:S表示为环境的总面积,lmax是障碍物最大边长,lmin=min(lminobs,dr)是障碍物的最小边长,dr是UUV直径,l为最终确定的栅格边长;

    步骤三、A*算法的估价函数为:

    f(x)=g(x)+h(x)

    其中,f(x)是从初始点经由x节点到目标点的估价函数,估价函数为f,g(x)是在状态空间中从初始点到x节点的实际代价,实际代价为g,h(x)是从x节点到目标点最优路径的估计代价,估价代价为h;

    步骤四、根据步骤三获得的A*算法的估价函数,将每个栅格的边线定义为可访问的节点,可搜索领域A*算法的估价代价为

    h(y)=d×h(X2)+(l-d)×h(X1) d∈[0 l]

    其中,h(X1)为节点X1的估计代价,h(X2)为节点X2的估计代价,y是点X2X1线段上的任意一点,d是点y到X1的距离,X1,X2...X8是当前节点X的相邻的八个边线交点的节点;

    步骤五、根据步骤四获得的可搜索连续领域A*算法的g值、f值和h值,依次找到优化的节点,直到目标点为止,这条路径即为最短路径。

    本发明是为了解决UUV在海洋全局环境中路径规划中存在光滑度差以及路径非最短的问题而提出的。

    本发明的有益效果:

    通过计算障碍物所占的面积和整个环境面积,确定栅格环境的栅格大小,既避免了计算机实时处理和储存的数据增加的问题,也提高了UUV路径规划的准确度。

    通过将传统的A*算法与可搜索连续领域相结合,缩短了UUV路径,节约了时间,提高了效率。

    附图说明

    图1为本发明中栅格环境建模示意图;

    图2为本发明中可搜索领域节点是边线交点的示意图;

    图3为本发明中可搜索领域节点为相邻边线与当前边线垂直的示意图;

    图4为本发明中可搜索领域节点为相邻边线与当前边线平行的示意图;

    图5为本发明中UUV路径规划仿真图。

    具体实施方式

    下面举例对本发明做更详细的描述。

    结合图1、图2、图3、图4和图5,本实施方式所述的一种基于可搜索连续邻域A*算法的路径规划方法,该方法的具体步骤为:

    步骤一:根据存在障碍物采用栅格法建立环境模型获得的环境模型,在地图上选取任意一个障碍物,并判断其是否为圆形;如果不是,则在第i个障碍物的所有顶点中选出在环境地图坐标系下坐标的最大值和最小值xmax,ymax,xmin,ymin,然后比较||xmax-xmin||与||ymax-ymin||获得最大直径,最后以重心为原点形成圆形障碍物。利用公式:

    获得各圆形障碍物的面积Si,li为第i障碍物的最大直径。

    步骤二:计算栅格的大小为

    其中,S表示为环境的总面积,lmax是障碍物最大边长,lmin=min(lminobs,dr)是障碍物的最小边长,dr是移动机器人的直径,l为最终确定的栅格边长。

    不考虑UUV的高度信息,将工作环境用二维平面表示,其中工作环境的东西方向为X轴,南北方向为Y轴,建立直角坐标系XOY,设二维平面的水平和垂直最大值对应在平面坐标系中为Xmax和Ymax,由于定义的栅格边长为l的正方形。

    步骤三:根据已建立的栅格图,A*算法的估价函数为:

    f(x)=g(x)+h(x) (4)

    其中:x为节点,f(x)是从初始点经由节点到目标点的估价函数,g(x)是在状态空间中从初始点到节点的实际代价,h(x)是从节点到目标点最优路径的估计代价。当h(x)估计代价不大于节点到目标点的实际距离值时,搜索的点数多,效率低,但是能得到最优解;当h(x)大于节点到目标点的实际距离值时,搜索的点数少,效率高,但是不能保证得到最优解;对于实际环境中,可以选取两节点间的欧几里得距离直线距离)作为估计代价,即

    其中(xG,yG)是目标点G的坐标,(xi,yi)是任意节点Xi的坐标。

    步骤四:根据步骤三获得的A*算法的估价函数,将A*算法与可搜索连续邻域相结合,使每个栅格的边线定义为可访问的节点,一段边线上的任意点y的估计代价值h(y)是其两端点估价值的线性组合,即

    h(y)=d×h(X2)+(l-d)×h(X1) d∈[0 l] (6)

    其中,h(X1)为节点X1的估计代价,h(X2)为节点X2的估计代价,y是点X2X1线段上的任意一点,d是点y到X1的距离,X1,X2...X8是当前节点X的相邻的八个边线交点的节点。对于边线XXi上的代价为min(a,b)。其子节点可以是这些相邻节点中的任意一个,于是可移动方向角也就拓展为了连续任意方向。对于不同的位置节点y的g值、f值和h值不同。

    当节点X是边线交点的情况时,节点X到边线X2X1上任意节点y的代价可以表示为

    其中,g(X)是在状态空间中从初始点到X节点的实际代价,g(y)是在状态空间中从初始点到y节点的实际代价,a,b是边线XXi上的代价。

    当节点X不是边线交点而是与该段边线垂直的情况时,边线节点X到边线X2X1上任意节点y的代价可以表示为

    其中,t∈[0,l]而

    当节点X不是边线交点节点而是与该段边线平行的情况时,边线节点X到边线X2X3上任意节点y的代价可以表示为

    其中m∈[0,l],而

    通过以上不同情况的计算,可以比较得到fmin和g。

    步骤五:创建两个表:open表和closed表,open表用于保存所有己生成而未考察的节点,closed表用于记录己访问过不需再考察的节点。然后按照以下的步骤进行操作:

    将起点A添加进open表中,并且将与A点相邻的栅格点X1,X2...X8以及边线上的任意点y添加open进表。将起点A从open表移到closed表中,并定义其为它相邻扩展的栅格的父节点。通过公式(7、8、9、10、11、12)求解open表中栅格点的g值、f值和h值。从open表中选择f值最小的栅格点,记为当前节点X,并将其从open列表移到closed表中。分别考察当前节点X的所有相邻节点(记为S,如果点既不在closed表中也不在open表中,将其添加open进表,求解其g值、f值和h值,并置当前节点X为其父节点;如果S点己经存在于open表中,则比较g(X)+c(X,S)(其中,c(X,S)为从X点到S点的代价)和g(S)的大小,当g(X)+c(X,S)<g(S)时,令g(S)=g(X)+c(X,S),并相应更新点S的f值,且置点X为其父节点,否则,则不做任何处理;如果S已经存在于closed表中,也不做任何处理。重复上述直到当前节点X为目标点G为止。从目标点G开始,依次找到其父节点,直到起点A为止,这条路径即为该算法求解出的最短路径。

    具体实例:

    UUV从起点(10,10)航行到终点(80,80),起始航向45°,设计了多个与障碍物O1,O2....,利用公式(1)得到障碍物的面积,利用公式(2)得到栅格的大小,利用公式(3)得到估价函数中。然后,利用可搜索连续邻域A*算法的估价函数寻找可搜索连续邻域估价函数最小的节点,作为下一航路点,逐步实现UUV航路规划。仿真轨迹如图5所示。

    展开全文
  • 使用Openssl的AES加密算法

    万次阅读 2013-11-01 10:44:13
    在网络应用的信息安全是基于密码学的,所以如果想做安全方面的邻域需要有一定的密码学基础。当然最好的学习方法就是边看书边尝试。 我的学习过程有三个阶段: 看书、通过使用一些软件了解基本的流程。 深入算法...

    转自:http://www.thinkemb.com/wordpress/?p=18

    参考:http://blog.csdn.net/shuanyancao/article/details/8985963

    http://stackoverflow.com/questions/18152913/aes-aes-cbc-128-aes-cbc-192-aes-cbc-256-encryption-decryption-with-openssl-c


    Openssl是很常见的C接口的库,个人觉得易用。以下是AES加密的使用备忘。如果你有一定的密码学基础,那么就很好理解。代码是从网上弄下来的(原始地址已经忘记了),然后在尝试的过程中改了一点东西。其它的cbc、cfb、ecb加密方式的用法都是类似的,只是函数名有点区别,就不一一列举了。

    【yasi】IV: Initialization Vector,即初始化向量

    一、接口简介

    //设置加密密钥,使用字符缓冲区
    int AES_set_encrypt_key(
            const unsigned char *userKey,
            const int bits,
            AES_KEY *key);
     
    //设置解密密钥,同样适用字符缓冲区
    int AES_set_decrypt_key(
            const unsigned char *userKey,
            const int bits,
            AES_KEY *key);
     
    //加解密的接口,通过最后的enc来区分是加密还是解密操作
    //每次执行AES_cbc_encrypt后,iv(向量)会被更新,
    //所以需要自己保存它。
    void AES_cbc_encrypt(
            const unsigned char *in,
            unsigned char *out,
            const unsigned long length,
            const AES_KEY *key,
            unsigned char *ivec,
            const int enc);
    ?

    二、一个简单的Makefile

    【yasi】针对CentOS环境,做了修改

    LNK_OPT = -g -L/usr/lib64/ -lssl
    
    all:
            rm -f codec
            g++ -g aes_codec.cpp -o codec $(LNK_OPT)
    
    clean:
            rm -f codec

    三、示例代码
    【yasi】对源链接的代码做了点修改:随机明码 改 静态明码

    #include <stdio.h>
    #include <string.h>
    #include <openssl/aes.h>
    #include <openssl/rand.h>
    
    /* file testaes.cpp */
    
    static void hexdump(
                    FILE *f,
                    const char *title,
                    const unsigned char *s,
                    int l)
    {
        int n = 0;
    
        fprintf(f, "%s", title);
        for (; n < l; ++n) {
            if ((n % 16) == 0) {
                    fprintf(f, "\n%04x", n);
            }
            fprintf(f, " %02x", s[n]);
        }
    
        fprintf(f, "\n");
    }
    
    int main(int argc, char **argv)
    {
            //128bits key.
            unsigned char   rkey[16];
            //Internal key.
            AES_KEY         key;
    
            //Testdata.
            // [yasi] Make static content instead of random text
            unsigned char   plaintext[AES_BLOCK_SIZE * 4] =
            {
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i',
                    '0', '1', '2', '3', '4', '5', '6', '7', '0', '1', '2', '3', '4', '5', '6', '7',
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i',
                    '0', '1', '2', '3', '4', '5', '6', '7', '0', '1', '2', '3', '4', '5', '6', '7'
            };
            unsigned char   ciphertext[AES_BLOCK_SIZE * 4];
            unsigned char   checktext[AES_BLOCK_SIZE * 4];
    
            //Init vector.
            unsigned char   iv[AES_BLOCK_SIZE * 4];
            //Save vector.
            unsigned char   saved_iv[AES_BLOCK_SIZE * 4];
    
            int nr_of_bits = 0;
            int nr_of_bytes = 0;
    
            //Zeror buffer.
            memset(ciphertext, 0, sizeof ciphertext);
            memset(checktext, 0, sizeof checktext);
    
            //Generate random
            RAND_pseudo_bytes(rkey, sizeof rkey);
            RAND_pseudo_bytes(saved_iv, sizeof saved_iv);
    
            hexdump(stdout, "== rkey ==",
                            rkey,
                            sizeof(rkey));
            hexdump(stdout, "== iv ==",
                            saved_iv,
                            sizeof(saved_iv));
            printf("\n");
    
            hexdump(stdout, "== plaintext ==",
                            plaintext,
                            sizeof(plaintext));
            printf("\n");
    
            //Entrypt
            memcpy(iv, saved_iv, sizeof(iv));
            nr_of_bits = 8 * sizeof(rkey);
            AES_set_encrypt_key(rkey, nr_of_bits, &key);
            nr_of_bytes = sizeof(plaintext);
            AES_cbc_encrypt(plaintext,
                            ciphertext,
                            nr_of_bytes,
                            &key,
                            iv,
                            AES_ENCRYPT);
    
            hexdump(stdout, "== ciphertext ==",
                            ciphertext,
                            sizeof(ciphertext));
            printf("\n");
            // [yasi] iv is changed in encryption
            hexdump(stdout, "== iv changed ==",
                            iv,
                            sizeof(iv));
            printf("\n");
    
            //Decrypt
            memcpy(iv, saved_iv, sizeof(iv));       // [yasi] without this line, decrypt will fail because iv is changed in encryption
            nr_of_bits = 8 * sizeof(rkey);
            AES_set_decrypt_key(rkey, nr_of_bits, &key);
            nr_of_bytes = sizeof(ciphertext);
    
            AES_cbc_encrypt(ciphertext,
                            checktext,
                            nr_of_bytes,
                            &key, iv,
                            AES_DECRYPT);
            hexdump(stdout, "== checktext ==",
                            checktext,
                            sizeof(checktext));
            printf("\n");
    
            return 0;
    }

    【yasi 运行结果】
    [root@ampcommons02 aes-codec]# ./codec
    == rkey ==
    0000 81 ac 9b 38 1c 02 c5 c8 1d 7c a0 3f 87 be f2 c6
    == iv ==
    0000 34 a2 f1 f5 f3 93 76 32 cd 77 ad fb c8 82 f2 1b
    0010 f3 cc 51 f6 35 f3 49 8d 44 97 8c 2c 89 50 0d d7
    0020 68 21 d7 2f 0a 90 29 c1 dd c9 39 bc 7c 4f 18 2f
    0030 04 cc 42 5e 84 8e fe a9 c5 49 00 9f 30 55 94 c0
    
    == plaintext ==
    0000 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    
    == ciphertext ==
    0000 c4 63 72 29 21 28 7b a2 27 24 4a e4 bb 95 1a d1
    0010 b8 13 0e 77 0c 8a a4 09 2f ca 85 43 41 b5 5b d5
    0020 a3 60 92 58 5b dd 45 0c e2 62 af f9 43 81 d7 06
    0030 41 8e 85 28 3e eb 72 b5 ee 84 8c 27 7e 67 20 f6
    
    == iv changed ==
    0000 41 8e 85 28 3e eb 72 b5 ee 84 8c 27 7e 67 20 f6
    0010 f3 cc 51 f6 35 f3 49 8d 44 97 8c 2c 89 50 0d d7
    0020 68 21 d7 2f 0a 90 29 c1 dd c9 39 bc 7c 4f 18 2f
    0030 04 cc 42 5e 84 8e fe a9 c5 49 00 9f 30 55 94 c0
    
    == checktext ==
    0000 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    可见,encryption之后,IV立即被修改了。所以,为了能正确decrypt,在decrypt时,必须使用先前encrypt时的IV,即代码第98行。

    【第二次运行的结果】
    [root@ampcommons02 aes-codec]# ./codec
    == rkey ==
    0000 29 68 75 4d a5 9e 83 9a ed f8 ec bc 2e b8 09 7e
    == iv ==
    0000 b8 21 09 de 8f 58 6e be 73 be a7 10 fb 91 87 65
    0010 65 9c d7 0e 4c 88 d2 65 ae de 0b 49 40 c7 75 df
    0020 19 69 53 0b 11 5d ac e7 08 f6 ae df 16 66 e0 13
    0030 75 41 f7 bb be 56 a1 dd a7 3e fb 4e 5d 9e e4 a2
    
    == plaintext ==
    0000 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    
    == ciphertext ==
    0000 5e 85 9c e8 65 d6 3b f9 03 9a a0 b5 78 bd f6 d4
    0010 11 70 94 c1 c3 78 9a 1d 12 9a 84 48 3a 70 88 13
    0020 d6 b5 bf c6 e8 e1 76 dc 3c b9 b0 4e b9 bb c4 74
    0030 35 3d ac fc 29 e3 a0 64 d7 76 ab 76 c7 af dd 39
    
    == iv changed ==
    0000 35 3d ac fc 29 e3 a0 64 d7 76 ab 76 c7 af dd 39
    0010 65 9c d7 0e 4c 88 d2 65 ae de 0b 49 40 c7 75 df
    0020 19 69 53 0b 11 5d ac e7 08 f6 ae df 16 66 e0 13
    0030 75 41 f7 bb be 56 a1 dd a7 3e fb 4e 5d 9e e4 a2
    
    == checktext ==
    0000 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    可见,两次运行,虽然encrypt的明码是一样的,但encrypt出来的结果是不同的。随机明码 改 静态明码 的目的就是为了比较两次encrypt的结果。即,相同的明码用不同的IV做encrypt,结果是不同的。

    【屏蔽第98行重新编译后的执行结果】
    [root@ampcommons02 aes-codec]# ./codec
    == rkey ==
    0000 69 ef eb 49 25 5a c2 5e 0d 77 8a cb e6 fe ad 1d
    == iv ==
    0000 8e 05 8c 50 2f 69 9d fb 64 3e cd e6 2d 38 26 1c
    0010 6e 21 00 e6 32 3f c6 ca 93 8b c1 e3 47 9a bd 81
    0020 d7 e5 0b 63 dc f8 9d 1f 13 49 35 25 70 4e 64 c2
    0030 ea 0c d0 78 e7 6c 65 64 41 4d db 2b 50 4d b4 06
    
    == plaintext ==
    0000 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    
    == ciphertext ==
    0000 a4 ed ba 4b 9f e9 74 bd 6d f6 03 76 79 9f 17 4f
    0010 0c cd f3 b8 da 69 44 81 c9 f2 8b 03 83 0d 9d 77
    0020 12 48 ea 46 3f eb 58 fd 48 c5 cc 2d 74 6c 99 4f
    0030 93 bd 0d 06 f3 55 40 11 cb e7 d4 29 3b 8f 15 76
    
    == iv changed ==
    0000 93 bd 0d 06 f3 55 40 11 cb e7 d4 29 3b 8f 15 76
    0010 6e 21 00 e6 32 3f c6 ca 93 8b c1 e3 47 9a bd 81
    0020 d7 e5 0b 63 dc f8 9d 1f 13 49 35 25 70 4e 64 c2
    0030 ea 0c d0 78 e7 6c 65 64 41 4d db 2b 50 4d b4 06
    
    == checktext ==
    0000 7c da e2 32 b9 5a ba 83 ce bb 7a ab 73 d1 54 03
    0010 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    0020 61 62 63 64 65 66 67 69 61 62 63 64 65 66 67 69
    0030 30 31 32 33 34 35 36 37 30 31 32 33 34 35 36 37
    可见,decrypt时使用和encrypt时不同的IV,不能正确decrypt出先前的明码。
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    【yasi】Openssl官方wiki,《EVP Symmetric Encryption and Decryption》中,有个的简单例子,整理如下(Linux下运行):(代码下载)
    algo_aes.h
    #ifndef ALGO_AES_H
    #define ALGO_AES_H
    
    int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
      unsigned char *iv, unsigned char *ciphertext);
    
    int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
      unsigned char *iv, unsigned char *plaintext);
    
    #endif

    algo_aes.c
    #include <stdlib.h>
    #include <stdio.h>
    #include "algo_aes.h"
    #include <openssl/evp.h>
    
    void handleErrors(void)
    {
      ERR_print_errors_fp(stderr);
      abort();
    }
    
    int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
      unsigned char *iv, unsigned char *ciphertext)
    {
      EVP_CIPHER_CTX *ctx;
    
      int len;
    
      int ciphertext_len;
    
      /* Create and initialise the context */
      if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    
      /* Initialise the encryption operation. IMPORTANT - ensure you use a key
       * and IV size appropriate for your cipher
       * In this example we are using 256 bit AES (i.e. a 256 bit key). The
       * IV size for *most* modes is the same as the block size. For AES this
       * is 128 bits */
      if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
        handleErrors();
    
      /* Provide the message to be encrypted, and obtain the encrypted output.
       * EVP_EncryptUpdate can be called multiple times if necessary
       */
      if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
        handleErrors();
      ciphertext_len = len;
    
      /* Finalise the encryption. Further ciphertext bytes may be written at
       * this stage.
       */
      if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
      ciphertext_len += len;
    
      /* Clean up */
      EVP_CIPHER_CTX_free(ctx);
    
      return ciphertext_len;
    }
    
    int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
      unsigned char *iv, unsigned char *plaintext)
    {
      EVP_CIPHER_CTX *ctx;
    
      int len;
    
      int plaintext_len;
    
      /* Create and initialise the context */
      if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
    
      /* Initialise the decryption operation. IMPORTANT - ensure you use a key
       * and IV size appropriate for your cipher
       * In this example we are using 256 bit AES (i.e. a 256 bit key). The
       * IV size for *most* modes is the same as the block size. For AES this
       * is 128 bits */
      if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
        handleErrors();
    
      /* Provide the message to be decrypted, and obtain the plaintext output.
       * EVP_DecryptUpdate can be called multiple times if necessary
       */
      if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
        handleErrors();
      plaintext_len = len;
    
      /* Finalise the decryption. Further plaintext bytes may be written at
       * this stage.
       */
      if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
      plaintext_len += len;
    
      /* Clean up */
      EVP_CIPHER_CTX_free(ctx);
    
      return plaintext_len;
    }

    main.c
    #include "algo_aes.h"
    #include <stdio.h>
    #include <string.h>
    //#include <openssl/evp.h>
    
    int main(int arc, char *argv[])
    {
      /* Set up the key and iv. Do I need to say to not hard code these in a
       * real application? :-)
       */
    
      /* A 256 bit key */
      unsigned char *key = "01234567890123456789012345678901";
    
      /* A 128 bit IV */
      unsigned char *iv = "01234567890123456";
    
      /* Message to be encrypted */
      unsigned char *plaintext =
        "The quick brown fox jumps over the lazy dog1234";
    
      /* Buffer for ciphertext. Ensure the buffer is long enough for the
       * ciphertext which may be longer than the plaintext, dependant on the
       * algorithm and mode
       */
      unsigned char ciphertext[64];
    
      /* Buffer for the decrypted text */
      unsigned char decryptedtext[64];
    
      int decryptedtext_len, ciphertext_len;
    
      /* Initialise the library */
    /*  ERR_load_crypto_strings();
      OpenSSL_add_all_algorithms();
      OPENSSL_config(NULL);*/
    
      printf("Plaintext is:\n%s~\n", plaintext);
    
      /* Encrypt the plaintext */
      ciphertext_len = encrypt(plaintext, strlen(plaintext), key, iv,
        ciphertext);
    
      /* Do something useful with the ciphertext here */
      printf("Ciphertext is %d bytes long:\n", ciphertext_len);
      BIO_dump_fp(stdout, ciphertext, ciphertext_len);
    
      /* Decrypt the ciphertext */
      decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv,
        decryptedtext);
    
      /* Add a NULL terminator. We are expecting printable text */
      decryptedtext[decryptedtext_len] = '\0';
    
      /* Show the decrypted text */
      printf("Decrypted text is:\n");
      printf("%s~\n", decryptedtext);
    
      /* Clean up */
      EVP_cleanup();
      ERR_free_strings();
    
      return 0;
    }
    Mekefile:
    OBJ_DIR = ./obj
    BIN_DIR = ./bin
    SRC_DIR = ./
    OBJS = \
    	$(OBJ_DIR)/algo_aes.o \
    	$(OBJ_DIR)/main.o
    TARGET = $(BIN_DIR)/main
    INC_OPT = -I./
    LNK_OPT = -lssl 
    
    $(TARGET) : clean chkobjdir chkbindir $(OBJS)
    	gcc -g -o $@ $(OBJS) $(LNK_OPT)
    
    $(OBJ_DIR)/%.o : $(SRC_DIR)/%.c
    	gcc -g $(INC_OPT) -c -o $@ $<
    
    chkobjdir :
    	@if test ! -d $(OBJ_DIR) ; \
    	then \
    		mkdir $(OBJ_DIR) ; \
    	fi
    
    chkbindir :
    	@if test ! -d $(BIN_DIR) ; \
    	then \
    		mkdir $(BIN_DIR) ; \
    	fi
    
    clean :
    	-rm -f $(TARGET)
    	-rm -rf $(OBJ_DIR)
    运行结果:
    Plaintext is:
    The quick brown fox jumps over the lazy dog1234~
    Ciphertext is 48 bytes long:
    0000 - e0 6f 63 a7 11 e8 b7 aa-9f 94 40 10 7d 46 80 a1   .oc.......@.}F..
    0010 - 17 99 43 80 ea 31 d2 a2-99 b9 53 02 d4 39 b9 70   ..C..1....S..9.p
    0020 - e9 29 d5 a8 03 bd 71 31-b8 c3 6f 3d 39 3a 3d 3d   .)....q1..o=9:==
    Decrypted text is:
    The quick brown fox jumps over the lazy dog1234~

    注意:参考

    AES算法的块(block)的长度固定为16字节。假设一个字符串在AES加密前的长度为cleanLen,加密后的长度为cipherLen,则二者有下面的关系,其中的“/”是整除。

    cipherLen = (clearLen/16 + 1) * 16

    比如:(注意第二行,即使48刚好能被16整除,也要额外追加一个16字节的块)
    clearLen cipherLen 
    47 48
    48 64
    49 64

    可见,对于AES算法:
    1)加密后的长度>=加密前的长度
    2)解密后的长度<=解密前的长度
    这对于写代码时的指导意义在于:
    1)假如我们要做AES加密的字符串为“The quick brown fox jumps over the lazy dog”,它的长度(不带/0)为43字节,则我们可以计算出加密后的串的长度为 (43 / 16 + 1) * 16 = 48 字节,于是就可以申明加密后的数组如下
    unsigned char ciphertextp[48];
    2)假如我们知道AES加密后的串的长度为64字节,那么就可以申明解密后的数组如下
    unsigned char decryptedtext[64];

    展开全文
  • 随着现在现代社会发展,数据计算分析在各个行业应用越来越广泛,但是单机计算性能总是很有限,特别是在安全,医疗,物理,天文计算等邻域,必须使用大型机,巨型机来完成计算任务,...
    随着现在现代社会发展,数据计算分析在各个行业应用越来越广泛,但是单机计算性能总是很有限,特别是在安全,医疗,物理,天文计算等邻域,必须使用大型机,巨型机来完成计算任务,但是一般的民企是无力购买的。计算集群MOSIX,就能很好完成这一工作,他能把很多普通计算机组成集群,看来就像一台计算机一样!
     下面介绍下 MOSIX-3.1.1.1 安装,
    操作系统使用CENTOS 6.3    64位
    集群软件 MOSIX-3.1.1.1.for_kernel-3.2.23 (www.mosix.cs.huji.ac.il  下载)

    2台虚拟机(每台虚拟机4核,4GB内存,160GB硬盘)

    # 下载MOSIX和kernel代码,准备编译
    wget  http://www.kernel.org/pub/linux/kernel/v3.0/linux-3.2.23.tar.bz2

    和 MOSIX-3.1.1.1.for_kernel-3.2.23-longterm.tbz

    # 解压到指定目录
    tar xjf linux-3.2.23.tar.bz2  -C /usr/src/
    tar xjvf MOSIX-3.1.1.1.for_kernel-3.2.23-longterm.tbz  -C /usr/src/

    注意:如果是centos 5.x升级过来的,在内核安装时,要特别注意。还需要额外安装  glibc-2.8 (wget http://ftp.gnu.org/pub/gnu/glibc/glibc-2.8.tar.gz  )。


    #进入源代码所在目录
    cd /usr/src/

    #这里需要注意的是,具体打补丁方法和linux内核配置方法一定要看MOSIX README文档,不然会导致内核编译奔溃
    #给kernel打上mosix补丁
    patch -p1 < /usr/src/mosix-3.1.1.1/other/patch-3.2.23

    #进入源代码目录,开始编译
    cd linux-3.2.23
    #生成配置文件
    make menuconfig
    配置文件选项如下(只针对MOSIX-3.1.1.1.for_kernel-3.2.23版本):
    Configure the following option:

          CONFIG_FUSE_FS
            File systems  ---&gt  FUSE (Filesystem in Userspace) support
          CONFIG_SYSVIPC
            General setup  ---&gt  System V IPC

       But make sure that the following is NOT CONFIGURED:

       CONFIG_HEADERS_CHECK"
            'Kernel hacking' ---&gt 'Run 'make headers_check' when building vmlinux'

    #生成依赖关系
    # make dep

    #编译内核
    # make bzImage

    #编译内核模块
    # make modules

    #安装内核模块
    # make modules_install


    #安装内核
    # make install

    #进入mosix目录
     cd ../mosix-3.1.1.1

    #安装mosix,一路回车,只用安装,记得把你常用级别的mosix服务打开就可以了.配置以后再说
    # ./mosix.install

    安装完成。

    后面会有文章继续介绍配置和应用。

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/8183550/viewspace-751006/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/8183550/viewspace-751006/

    展开全文
  • 基于粒子群优化和邻域约简的入侵检测日志数据特征选择.pdf 基于无监督聚类算法的入侵检测.pdf 网络安全入侵检测研究综述.pdf 一种基于事务模板的恶意事务检测方法.pdf 一种基于无线网络的动态主动防御系统设计方法....
  • 在本文中,我们提出了一种用于智能电网的轻量级认证通信方案,该方案可确保智能电表与邻域网关之间的安全双向通信。由于在提出的方案中,智能电表只需要执行按位异或运算就可以对收集到的使用数据进行加密,并且使用...
  • LSB匹配通过随机地修改像素值的LSB,打破了LSB替换的值对关系,使得安全性有了质的提高。针对灰度图像空间域LSB匹配算法,以8邻域内像素与中心像素的像素值差值定义区域内像素之间的相关性,分析嵌入信息对相关性的影响,...
  • 为了解决无线传感器网络的安全问题, 提出了一种基于规范的入侵检测算法。该算法根据概率论的有关理论, 对邻域节点的单位时间特征量设定阈值, 阈值的设定方法具有通用性, 并且阈值自适应更新, 符合传感节点性能随着...
  • 在对图像以二维Arnold变换置乱的基础上,根据八邻域内像素之间的相关性来确定LSB(最低有效位)的替换方式,提取时只需提取置乱图像的LSB即可。该算法结合了图像置乱技术和改进的LSB嵌入方案,使嵌入的数据获得了抗...
  • 将SVM模型参数作为蚂蚁的位置向量,采用动态随机抽取的方法来确定目标个体引导蚁群进行全局搜索,同时在最优蚂蚁邻域内进行小步长局部搜索,找到SVM最优参数,采用最优参数建立网络入侵检测模型。利用KDDCUP99数据集...
  • 该模型引入了MAC 无线信道争用机制和邻域通信距离因素,描述了节点差异度对恶意软件在无线传感网传播扩散的影响。分析仿真实验表明,大规模无线传感网络的节点差异度、无线信道争用机制都对传播行为产生了重要影响,...
  • 为提高图像自适应隐写的安全性,根据最小化嵌入失真原则,提出了一种基于小波系数相关性的图像自适应空域隐写术。首先以一维高通、低通滤波器为工具构造方向滤波器;然后沿水平、垂直、对角线方向对图像进行方向滤波...
  • 基于数据挖掘

    2018-12-20 12:21:57
     传统的日志分析需要专业的1知识,通过数据挖掘,它们能够发现日志文件中与安全相关的有趣模式,而不需要确切知道我们所要找的。 11.2数据挖掘简介  在数据库和计算机科学中也称为知识发现,是发现大量数据中...
  • 针对恶意剪切/涂鸦攻击,同时提出一种基于邻域相邻像素特性的恢复算法。应用评价指标对加密效果与安全性进行分析。实验结果与理论分析表明,该算法运行效率较高,密钥空间巨大,具有良好的加密效果、统计特性与安全性,且...
  • 其主要思想是根据图像自身特征生成自适应水印序列,利用模糊核聚类、支持向量机对NSCT低频系数进行分类,选取适合嵌入水印的低频系数,然后利用支持向量机建立NSCT邻域系数的关系模型,自适应地完成水印嵌入。...
  • 博客园之路开启

    2013-12-03 17:24:00
     到目前为止梳理我所学,所知信息安全专业,先后深入学习了汇编、C/C++,熟悉数据结构全篇,通读Linux 0.99源码,曾经实现B*树查询算法,基于线性四叉树邻域搜索算法。对网络编程,高并发,异步编程,分布式,云...
  • 兼顾水印嵌入容量和安全性,提出一种水印容量可变的数字图像可恢复水印算法.该算法提取2×2图像块特征生成变容量恢复水印———平滑块6比特,纹理块12比特.图像块的恢复水印基于密钥随机嵌入在其它图像块的低有效位,...
  • 考虑到这一现实要求,结合岸桥作业禁止跨越与安全距离等特有约束,以最小化装卸作业的makespan为目标,构建了新的岸桥作业调度混合整数规划模型。针对问题的NP-hard特性,设计了一种混合模拟退火算法,运用启发式...
  • 基于邻域的社会化推荐需要同时依赖用户的历史行为数据和完善的社交网络拓扑图,但通常这些数据分别属于不同平台,如推荐系统服务提供商和社交网络服务提供商。出于维护自身数据价值及保护用户隐私的考虑,他们并不...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

安全邻域