威尼斯手机平台登陆-官方网站登录

威尼斯手机平台登陆为您带来世界三大博彩公司最新相关资讯,威尼斯官方网站登录充分考虑到不同地域网民的不同需求,威尼斯手机平台登陆良好的用户界面,人性化的操作,实用的功能设计使其广泛受到欢迎,推动实体出版、影视、动漫、游戏等相关文化产业的发展。

您的位置:威尼斯手机平台登陆 > 威尼斯在线注册平台 > 【威尼斯在线注册平台】非对称加密算法供给多少个密钥来扩充加密和解密,算法是将普通的音信或然可以见到的新

【威尼斯在线注册平台】非对称加密算法供给多少个密钥来扩充加密和解密,算法是将普通的音信或然可以见到的新

发布时间:2020-03-04 19:11编辑:威尼斯在线注册平台浏览(146)

    同样是一道面试答错的问题,面试官问我非对称加密算法中有哪些经典的算法? 当时我愣了一下,因为我把非对称加密与单项散列加密的概念弄混淆了,所以更不用说什么非对称加密算法中有什么经典算法,结果当然也让面试官愣了一下,所以今天就花点时间说说PHP中的信息加密技术

    概述

    加密技术包括两个元素:算法和密钥。算法是将普通的信息或者可以理解的信息与一串数字(密钥)结合,产生不可理解的密文的步骤,密钥是用来对数据进行编码和解密的一种算法。在安全保密中,可通过适当的钥加密技术和管理机制来保证网络的信息通信安全。

    软件的加密与解密是一个迷人的研究领域,它几乎可以与任意一种计算机技术紧密结合——密码学、程序设计语言、操作系统、数据结构。而由于这样或者那样的原因,对于这一领域的关注程度一直还处于低温状态。而看雪技术论坛相信会为更多对知识怀有渴望的朋友多开辟一条走向这个领域的道路,并且进而推动这个领域的不断发展。

    随着对于安全度的不断要求,对于数据加解密与破解之间的斗争,加解密的方式也在不断发生着变化,来看看现在流行的一些加解密算法。

    信息加密技术的分类

    什么是加密技术?

    加密技术是电子商务采取的主要安全保密措施,是最常用的安全保密手段,利用技术手段把重要的数据变为乱码(加密)传送,到达目的地后再用相同或不同的手段还原(解密)。加密技术包括两个元素:算法和密钥。算法是将普通的文本(或者可以理解的信息)与一串数字(密钥)的结合,产生不可理解的密文的步骤,密钥是用来对数据进行编码和解码的一种算法。在安全保密中,可通过适当的密钥加密技术和管理机制来保证网络的信息通讯安全。密钥加密技术的密码体制分为对称密钥体制和非对称密钥体制两种。相应地,对数据加密的技术分为两类,即对称加密(私人密钥加密)和非对称加密威尼斯在线注册平台,(公开密钥加密)。对称加密以数据加密标准(DES,Data Encryption Standard)算法为典型代表,非对称加密通常以RSA(Rivest Shamir Ad1eman)算法为代表。对称加密的加密密钥和解密密钥相同,而非对称加密的加密密钥和解密密钥不同,加密密钥可以公开而解密密钥需要保密。

    - 加解密定义

    加解密的定义是在密码学中的术语,以下为维基百科的定义:

    加密(英语:Encryption)是将明文信息改变为难以读取的密文内容,使之不可读;只有拥有解密方法的对象,经由解密过程,才能将密文还原为正常可读的内容。(引自)。

    解密,或称解码,是密码学中的一个术语,是指将一种已经经过加密的语言,解成自己的语言或想要的语言。一般认为解密是加密的一种逆向活动。

    1.加密算法通常分为对称性加密算法和非对称性加密算法:对于对称性加密算法,信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的,之后便是对数据进行 加解密了。非对称算法与之不同,发送双方A,B事先均生成一堆密匙,然后A将自己的公有密匙发送给B,B将自己的公有密匙发送给A,如果A要给B发送消息,则先需要用B的公有密匙进行消息加密,然后发送给B端,此时B端再用自己的私有密匙进行消息解密,B向A发送消息时为同样的道理。

    2.关于公钥私钥和数字签名, 通过一个发送邮件的故事让大家有一个深刻的理解,非常棒的案例:http://www.blogjava.net/yxhxj2006/archive/2012/10/15/389547.html看完这个之后, 相信你会明白非对称加密在网络传输中的安全性的体现, 当然就是之前谈到的https。总而言之:公钥与私钥的作用是:用公钥加密的内容只能用私钥解密,用私钥加密的内容只能 用公钥解密。**公钥加密私钥解密, 没问题,也可以说是"公共密钥加密系统"私钥加密公钥解密,一般不这么说,应叫"私钥签名,公钥验证",也可以说是“公共密钥签名系统”

    • <h1>加解密方法</h1>
      加密信息的两种基本方法 ︰ 对称加密 (也称为密钥加密) 和非对称加密 (也称为公钥加密)。

    • <h2>对称加密</h2>

      • <h4>定义</h4>

      采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。

      • <h4>工作过程</h4>

      下面举个例子来简要说明一下对称加密的工作过程。甲和乙是一对生意搭档,他们住在不同的城市。由于生意上的需要,他们经常会相互之间邮寄重要的货物。为了保证货物的安全,他们商定制作一个保险盒,将物品放入其中。他们打造了两把相同的钥匙分别保管,以便在收到包裹时用这个钥匙打开保险盒,以及在邮寄货物前用这把钥匙锁上保险盒。

      上面是一个将重要资源安全传递到目的地的传统方式,只要甲乙小心保管好钥匙,那么就算有人得到保险盒,也无法打开。这个思想被用到了现代计算机通信的信息加密中。在对称加密中,数据发送方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。接收方收到密文后,若想解读原文,则需要使用加密密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文。在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密。

      • <h4>常用算法</h4>

      在对称加密算法中常用的算法有:DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等。
      DES是一种分组数据加密技术(先将数据分成固定长度的小数据块,之后进行加密),速度较快,适用于大量数据加密,而3DES是一种基于DES的加密算法,使用3个不同密匙对同一个分组数据块进行3次加密,如此以使得密文强度更高。
      相较于DES和3DES算法而言,AES算法有着更高的速度和资源使用效率,安全级别也较之更高了,被称为下一代加密标准。

      • <h4>优缺点</h4>

      对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。

      对称加密算法的缺点是在数据传送前,发送方和接收方必须商定好秘钥,然后使双方都能保存好秘钥。其次如果一方的秘钥被泄露,那么加密信息也就不安全了。另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的唯一秘钥,这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担。

    • <h2>非对称加密</h2>

      • <h4>定义</h4>

      与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

      • <h4>工作过程</h4>

      如下图所示,甲乙之间使用非对称加密的方式完成了重要信息的安全传输。

      威尼斯在线注册平台 1

      非对称加密工作过程简要示意图

      1、乙方生成一对密钥(公钥和私钥)并将公钥向其它方公开。
      2、得到该公钥的甲方使用该密钥对机密信息进行加密后再发送给乙方。
      3、乙方再用自己保存的另一把专用密钥(私钥)对加密后的信息进行解密。乙方只能用其专用密钥(私钥)解密由对应的公钥加密后的信息。
      在传输过程中,即使攻击者截获了传输的密文,并得到了乙的公钥,也无法破解密文,因为只有乙的私钥才能解密密文。
      同样,如果乙要回复加密信息给甲,那么需要甲先公布甲的公钥给乙用于加密,甲自己保存甲的私钥用于解密。

      • <h4>常用算法</h4>

      在非对称加密中使用的主要算法有:RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)等。

      • <h4>优缺点</h4>

      非对称加密的缺点是加密和解密花费时间长、速度慢,只适合对少量数据进行加密。
      非对称加密与对称加密相比,其安全性更好:对称加密的通信双方使用相同的秘钥,如果一方的秘钥遭泄露,那么整个通信就会被破解。而非对称加密使用一对秘钥,一个用来加密,一个用来解密,而且公钥是公开的,秘钥是自己保存的,不需要像对称加密那样在通信之前要先同步秘钥。

    • <h1>摘要算法</h1>
      现在流行的加密方式有

      - MD5加密

      MD5的全称是Message-Digest Algorithm 5,在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明,经MD2、MD3和MD4发展而来。

      MD5将任意长度的“字节串”变换成一个128bit的大整数,并且它是一个不可逆的字符串变换算法,换句话说就是,即使你看到源程序和算法描述,也无法将一个MD5的值变换回原始的字符串,从数学原理上说,是因为原始的字符串有无穷多个,这有点象不存在反函数的数学函数。

      MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹),以防止被“篡改”。举个例子,你将一段话写在一个叫 readme.txt文件中,并对这个readme.txt产生一个MD5的值并记录在案,然后你可以传播这个文件给别人,别人如果修改了文件中的任何内容,你对这个文件重新计算MD5时就会发现。如果再有一个第三方的认证机构,用MD5还可以防止文件作者的“抵赖”,这就是所谓的数字签名应用。

      MD5还广泛用于加密和解密技术上,在很多操作系统中,用户的密码是以MD5值(或类似的其它算法)的方式保存的, 用户Login的时候,系统是把用户输入的密码计算成MD5值,然后再去和系统中保存的MD5值进行比较,而系统并不“知道”用户的密码是什么。

      - RSA加密

      ### 定义

      RSA是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作,也很流行。算法的名字以发明者的名字命名:Ron Rivest, Adi Shamir 和Leonard Adleman。但RSA的安全性一直未能得到理论上的证明。它经历了各种攻击,至今未被完全攻破。

      威尼斯在线注册平台 2

      RSA算法结构

      ### 分析

      RSA加密算法是目前最有影响力的公钥加密算法,并且被普遍认为是目前最优秀的公钥方案之一。RSA是第一个能同时用于加密和数宇签名的算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准。RSA加密算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。

      具体详细文章可以参考链接http://witcheryne.iteye.com/blog/2171850http://www.cocoachina.com/bbs/read.php?tid=166990在支付宝支付过程中就使用了RSA加密。

      - Base64

      ### 定义

      Base64加密算法是网络上最常见的用于传输8bit字节代码的编码方式之一,Base64编码可用于在HTTP环境下传递较长的标识信息。例如,在JAVAPERSISTENCE系统HIBEMATE中,采用了Base64来将一个较长的唯一标识符编码为一个字符串,用作HTTP表单和HTTPGETURL中的参数。在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的形式。此时,采用Base64编码不仅比较简短,同时也具有不可读性,即所编码的数据不会被人用肉眼所直接看到。

      - DES加密

      ### 定义

      DES算法为密码体制中的对称密码体制,又被称为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位, 使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

      威尼斯在线注册平台 3

      DES算法结构

      ### 基本原理

    其入口参数有三个:key、data、mode。key为加密解密使用的密钥,data为加密解密的数据,mode为其工作模式。当模式为加密模式时,明文按照64位进行分组,形成明文组,key用于对数据加密,当模式为解密模式时,key用于对数据解密。实际运用中,密钥只用到了64位中的56位,这样才具有高的安全性。

    单项散列加密技术(不可逆的加密)

    属于摘要算法,不是一种加密算法,作用是把任意长的输入字符串变化成固定长的输出串的一种函数

    什么是对称加密技术?

           采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。

           所谓对称,就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。算法是一组规则,规定如何进行加密和解密。

           因此加密的安全性不仅取决于加密算法本身,密钥管理的安全性更是重要。因为加密和解密都使用同一个密钥,如何把密钥安全地传递到解密者手上就成了必须要解决的问题。

           在对称加密算法中常用的算法有:DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等。

    分析

    DES加密算法是一种分组密码,以64位为分组对数据加密,它的密钥长度是56位,加密解密用同一算法。DES加密算法是对密钥进行保密,而公开算法,包括加密和解密算法。这样,只有掌握了和发送方相同密钥的人才能解读由DES加密算法加密的密文数据。因此,破译DES加密算法实际上就是搜索密钥的编码。对于56位长度的密钥来说,如果用穷举法来进行搜索的话,其运算次数为256。
    随着计算机系统能力的不断发展,DES的安全性比它刚出现时会弱得多,然而从非关键性质的实际出发,仍可以认为它是足够的。不过,DES现在仅用于旧系统的鉴定,而更多地选择新的加密标准。

    MD5

    string md5 ( string $str [, bool $raw_output = false ] ); //MD5加密,输入任意长度字符串返回一个唯一的32位字符
    

    md5()为单向加密,没有逆向解密算法,但是还是可以对一些常见的字符串通过收集,枚举,碰撞等方法破解;所以为了让其破解起来更麻烦一些,所以我们一般加一点盐值(salt)并双重MD5;

    md5(md5($password).'sdva');
    

    sdva就是盐值,该盐值应该是随机的,比如md5常用在密码加密上,所以在注册的时候我会随机生成这个字符串,然后通过上面的方法来双重加密一下;

    优缺点:

           对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。

           对称加密算法的缺点是在数据传送前,发送方和接收方必须商定好秘钥,然后使双方都能保存好秘钥。其次如果一方的秘钥被泄露,那么加密信息也就不安全了。另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的唯一秘钥,这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担。

    - SHA1加密

    ###定义
    
    >安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。
    

    Crypt

    很少看到有人用这个函数,如果要用的话有可能是用在对称或非对称的算法里面,了解一下既可;

    string crypt ( string $str [, string $salt ] ) //第一个为需要加密的字符串,第二个为盐值(就是加密干扰值,如果没有提供,则默认由PHP自动生成);返回散列后的字符串或一个少于 13 字符的字符串,后者为了区别盐值
    
    <?php
    $password='testtest.com';
    echo crypt($password);
    //输出:$1$DZ3.QX2.$CQZ8I.OfeepKYrWp0oG8L1
    /*第二个$与第三个$之间的八个字符是由PHP生成的,每刷新一次就变一次
    */
    echo "<hr>";
    
    echo crypt($password,"testtest");
    //输出:tesGeyALKYm3A
    //当我们要加自定义的盐值时,如例子中的testtest作为第二个参数直接加入, 超出两位字符的会截取前两位
    echo "<hr>";
    
    echo  crypt($password,'$1$testtest$');
    //输出:$1$testtest$DsiRAWGTHiVH3O0HSHGoL1
    /*crypt加密函数有多种盐值加密支持,以上例子展示的是MD5散列作为盐值,该方式下
    盐值以$1$$的形式加入,如例子中的testtest加在后两个$符之间,
    超出八位字符的会截取前八位,总长为12位;crypt默认就是这种形式。
    */
    echo "<hr>";
    //crypt还有多种盐值加密支持,详见手册
    

    什么是非对称加密技术?

            对称加密算法在加密和解密时使用的是同一个秘钥;而非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(public key,简称公钥)和私有密钥(private key,简称私钥)。

            与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

    如下图所示,甲乙之间使用非对称加密的方式完成了重要信息的安全传输。

    分析

    SHA1加密算法可以采用不超过264位的数据输入,并产生一个160位的摘要。输入被划分为512位的块,并单独处理。160位缓冲器用来保存散列函数的中间和最后结果。缓冲器可以由5个32位寄存器(A、B、C、D和E)来表示。SHA1是一种比MD5的安全性强的算法,理论上,凡是采取“消息摘要”方式的数字验证算法都是有“碰撞”的——也就是两个不同的东西算出的消息摘要相同,互通作弊图就是如此。但是安全性高的算法要找到指定数据的“碰撞”很困难,而利用公式来计算“碰撞”就更困难一目前为止通用安全算法中仅有MD5被破解。


    下面是一个完整的代码示例

    #import <Foundation/Foundation.h>
    @interface Helper : NSObject
    //MD5
    + (NSString *) md5:(NSString *)str;
    //Base64
    + (NSString *)base64StringFromText:(NSString *)text;
    + (NSString *)textFromBase64String:(NSString *)base64;
    + (NSString *)base64EncodedStringFrom:(NSData *)data;
    //DES加密
    +(NSString *)encryptSting:(NSString *)sText key:(NSString *)key andDesiv:(NSString *)ivDes;
    //DES解密
    +(NSString *)decryptWithDESString:(NSString *)sText key:(NSString *)key andiV:(NSString *)iv;
    //AES加密
    + (NSData *)AES128EncryptWithKey:(NSString *)key iv:(NSString *)iv withNSData:(NSData *)data;
    //AES解密
    + (NSData *)AES128DecryptWithKey:(NSString *)key iv:(NSString *)iv withNSData:(NSData *)data;
    @end
    
    #import "Helper.h"
    #import <CommonCrypto/CommonHMAC.h>
    #import<CommonCrypto/CommonCryptor.h>
    static const char encodingTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    #define LocalStr_None  @""
    @implementation Helper
    
    //Md5
    + (NSString *) md5:(NSString *)str {
        if (str == nil) {
            return nil;
        }
        const char *cStr = [str UTF8String];
        unsigned char result[16];
        CC_MD5( cStr, strlen(cStr), result );
        return [NSString stringWithFormat:
                @"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
                result[0], result[1], result[2], result[3],
                result[4], result[5], result[6], result[7],
                result[8], result[9], result[10], result[11],
                result[12], result[13], result[14], result[15]
                ];
    }
    
    //转化为Base64
    + (NSString *)base64StringFromText:(NSString *)text
    {
        if (text && ![text isEqualToString:LocalStr_None]) {
            //取项目的bundleIdentifier作为KEY  改动了此处
            //NSString *key = [[NSBundle mainBundle] bundleIdentifier];
            NSData *data = [text dataUsingEncoding:NSUTF8StringEncoding];
            //IOS 自带DES加密 Begin  改动了此处
            //data = [self DESEncrypt:data WithKey:key];
            //IOS 自带DES加密 End
            return [self base64EncodedStringFrom:data];
        }
        else {
            return LocalStr_None;
        }
    }
    
    //由base64转化
    + (NSString *)textFromBase64String:(NSString *)base64
    {
        if (base64 && ![base64 isEqualToString:LocalStr_None]) {
            //取项目的bundleIdentifier作为KEY   改动了此处
            //NSString *key = [[NSBundle mainBundle] bundleIdentifier];
            NSData *data = [self dataWithBase64EncodedString:base64];
            //IOS 自带DES解密 Begin    改动了此处
            //data = [self DESDecrypt:data WithKey:key];
            //IOS 自带DES加密 End
            return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
        }
        else {
            return LocalStr_None;
        }
    }
    
    //DES加密
    +(NSString *)encryptSting:(NSString *)sText key:(NSString *)key andDesiv:(NSString *)ivDes
    {
        if ((sText == nil || sText.length == 0)
            || (sText == nil || sText.length == 0)
            || (ivDes == nil || ivDes.length == 0)) {
            return @"";
        }
        //gb2312 编码
        NSStringEncoding encoding =CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingGB_18030_2000);
        NSData* encryptData = [sText dataUsingEncoding:encoding];
        size_t  dataInLength = [encryptData length];
        const void *   dataIn = (const void *)[encryptData bytes];
    
        CCCryptorStatus ccStatus = nil;
        uint8_t *dataOut = NULL; //可以理解位type/typedef 的缩写(有效的维护了代码,比如:一个人用int,一个人用long。最好用typedef来定义)
        size_t dataOutMoved = 0;
        size_t    dataOutAvailable = (dataInLength + kCCBlockSizeDES) & ~(kCCBlockSizeDES - 1);  dataOut = malloc( dataOutAvailable * sizeof(uint8_t));
        memset((void *)dataOut, 0x0, dataOutAvailable);//将已开辟内存空间buffer的首 1 个字节的值设为值 0
        const void *iv = (const void *) [ivDes cStringUsingEncoding:NSASCIIStringEncoding];
        //CCCrypt函数 加密/解密
        ccStatus = CCCrypt(kCCEncrypt,//  加密/解密
                           kCCAlgorithmDES,//  加密根据哪个标准(des,3des,aes。。。。)
                           kCCOptionPKCS7Padding,//  选项分组密码算法(des:对每块分组加一次密  3DES:对每块分组加三个不同的密)
                           [key UTF8String],  //密钥    加密和解密的密钥必须一致
                           kCCKeySizeDES,//   DES 密钥的大小(kCCKeySizeDES=8)
                           iv, //  可选的初始矢量
                           dataIn, // 数据的存储单元
                           dataInLength,// 数据的大小
                           (void *)dataOut,// 用于返回数据
                           dataOutAvailable,
                           &dataOutMoved);
    
        //编码 base64
        NSData *data = [NSData dataWithBytes:(const void *)dataOut length:(NSUInteger)dataOutMoved];
        Byte *bytes = (Byte *)[data bytes];
        //下面是Byte 转换为16进制。
        NSString *hexStr=@"";
        for(int i=0;i<[data length];i++){
            NSString *newHexStr = [NSString stringWithFormat:@"%x",bytes[i]&0xff];///16进制数
            if([newHexStr length]==1)
                hexStr = [NSString stringWithFormat:@"%@0%@",hexStr,newHexStr];
            else
                hexStr = [NSString stringWithFormat:@"%@%@",hexStr,newHexStr];
        }
        free(dataOut);
        return hexStr;
    }
    
    //DES解密
    +(NSString *)decryptWithDESString:(NSString *)sText key:(NSString *)key andiV:(NSString *)iv
    {
        if ((sText == nil || sText.length == 0)
            || (sText == nil || sText.length == 0)
            || (iv == nil || iv.length == 0)) {
            return @"";
        }
        const void *dataIn;
        size_t dataInLength;
        char *myBuffer = (char *)malloc((int)[sText length] / 2 + 1);
        bzero(myBuffer, [sText length] / 2 + 1);
        for (int i = 0; i < [sText length] - 1; i += 2) {
            unsigned int anInt;
            NSString * hexCharStr = [sText substringWithRange:NSMakeRange(i, 2)];
            NSScanner * scanner = [[NSScanner alloc] initWithString:hexCharStr];
            [scanner scanHexInt:&anInt];
            myBuffer[i / 2] = (char)anInt;
        }
    
        NSData *decryptData =[NSData dataWithBytes:myBuffer length:[sText length] / 2 ];//转成utf-8并decode
        dataInLength = [decryptData length];
        dataIn = [decryptData bytes];
        free(myBuffer);
        CCCryptorStatus ccStatus = nil;
        uint8_t *dataOut = NULL; //可以理解位type/typedef 的缩写(有效的维护了代码,比如:一个人用int,一个人用long。最好用typedef来定义)
        size_t dataOutAvailable = 0; //size_t  是操作符sizeof返回的结果类型
        size_t dataOutMoved = 0;
    
        dataOutAvailable = (dataInLength + kCCBlockSizeDES) & ~(kCCBlockSizeDES - 1);
        dataOut = malloc( dataOutAvailable * sizeof(uint8_t));
        memset((void *)dataOut, 0x0, dataOutAvailable);//将已开辟内存空间buffer的首 1 个字节的值设为值 0
    
        const void *ivDes = (const void *) [iv cStringUsingEncoding:NSASCIIStringEncoding];
        //CCCrypt函数 加密/解密
        ccStatus = CCCrypt(kCCDecrypt,//  加密/解密
                           kCCAlgorithmDES,//  加密根据哪个标准(des,3des,aes。。。。)
                           kCCOptionPKCS7Padding,//  选项分组密码算法(des:对每块分组加一次密  3DES:对每块分组加三个不同的密)
                           [key UTF8String],  //密钥    加密和解密的密钥必须一致
                           kCCKeySizeDES,//   DES 密钥的大小(kCCKeySizeDES=8)
                           ivDes, //  可选的初始矢量
                           dataIn, // 数据的存储单元
                           dataInLength,// 数据的大小
                           (void *)dataOut,// 用于返回数据
                           dataOutAvailable,
                           &dataOutMoved);
    
        NSStringEncoding encoding =CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingGB_18030_2000);
    
        NSString *result  = [[NSString alloc] initWithData:[NSData dataWithBytes:(const void *)dataOut length:(NSUInteger)dataOutMoved] encoding:encoding];
        free(dataOut);
        return result;
    }
    
    //AES加密
    + (NSData *)AES128EncryptWithKey:(NSString *)key iv:(NSString *)iv withNSData:(NSData *)data
    {
        char keyPtr[kCCKeySizeAES128+1];
        bzero(keyPtr, sizeof(keyPtr));
    
        [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];
    
        char ivPtr[kCCKeySizeAES128+1];
        bzero(ivPtr, sizeof(ivPtr));
    
        [iv getCString:ivPtr maxLength:sizeof(ivPtr) encoding:NSUTF8StringEncoding];
    
        NSUInteger dataLength = [data length];
        int diff = kCCKeySizeAES128 - (dataLength % kCCKeySizeAES128);
        int newSize = 0;
    
        if(diff > 0)
        {
            newSize = (int)(dataLength + diff);
        }
    
        char dataPtr[newSize];
        memcpy(dataPtr, [data bytes], [data length]);
        for(int i = 0; i < diff; i++)
        {
            dataPtr[i + dataLength] = 0x00;
        }
    
        size_t bufferSize = newSize + kCCBlockSizeAES128;
        void *buffer = malloc(bufferSize);
    
        size_t numBytesEncrypted = 0;
        CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt,
                                              kCCAlgorithmAES128,
                                              0x00, //No padding
                                              keyPtr,
                                              kCCKeySizeAES128,
                                              ivPtr,
                                              dataPtr,
                                              sizeof(dataPtr),
                                              buffer,
                                              bufferSize,
                                              &numBytesEncrypted);
    
        if(cryptStatus == kCCSuccess)
        {
            //        NSData *data =[NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
            //        NSString *str = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
    
            return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
        }
    
        return nil;
    }
    
    //AES解密
    + (NSData *)AES128DecryptWithKey:(NSString *)key iv:(NSString *)iv withNSData:(NSData *)data
    {
        char keyPtr[kCCKeySizeAES128+1];
        bzero(keyPtr, sizeof(keyPtr));
    
        [key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];
    
        char ivPtr[kCCKeySizeAES128+1];
        bzero(ivPtr, sizeof(ivPtr));
    
        [iv getCString:ivPtr maxLength:sizeof(ivPtr) encoding:NSUTF8StringEncoding];
    
        NSUInteger dataLength = [data length];
    
        size_t bufferSize = dataLength + kCCBlockSizeAES128;
        void *buffer = malloc(bufferSize);
    
        size_t numBytesEncrypted = 0;
        CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,
                                              kCCAlgorithmAES128,
                                              0x00, //No padding
                                              keyPtr,
                                              kCCKeySizeAES128,
                                              ivPtr,
                                              [data bytes],
                                              dataLength,
                                              buffer,
                                              bufferSize,
                                              &numBytesEncrypted);
    
        if(cryptStatus == kCCSuccess)
        {
            //        NSData *data =[NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
            // NSString *str = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
            return [NSData dataWithBytesNoCopy:buffer length:numBytesEncrypted];
        }
        return nil;
    
    }
    
    /******************************************************************************
     函数名称 : + (NSData *)dataWithBase64EncodedString:(NSString *)string
     函数描述 : base64格式字符串转换为文本数据
     输入参数 : (NSString *)string
     输出参数 : N/A
     返回参数 : (NSData *)
     备注信息 :
     ******************************************************************************/
    + (NSData *)dataWithBase64EncodedString:(NSString *)string
    {
        if (string == nil)
            [NSException raise:NSInvalidArgumentException format:nil];
        if ([string length] == 0)
            return [NSData data];
    
        static char *decodingTable = NULL;
        if (decodingTable == NULL)
        {
            decodingTable = malloc(256);
            if (decodingTable == NULL)
                return nil;
            memset(decodingTable, CHAR_MAX, 256);
            NSUInteger i;
            for (i = 0; i < 64; i++)
                decodingTable[(short)encodingTable[i]] = i;
        }
    
        const char *characters = [string cStringUsingEncoding:NSASCIIStringEncoding];
        if (characters == NULL)     //  Not an ASCII string!
            return nil;
        char *bytes = malloc((([string length] + 3) / 4) * 3);
        if (bytes == NULL)
            return nil;
        NSUInteger length = 0;
    
        NSUInteger i = 0;
        while (YES)
        {
            char buffer[4];
            short bufferLength;
            for (bufferLength = 0; bufferLength < 4; i++)
            {
                if (characters[i] == '')
                    break;
                if (isspace(characters[i]) || characters[i] == '=')
                    continue;
                buffer[bufferLength] = decodingTable[(short)characters[i]];
                if (buffer[bufferLength++] == CHAR_MAX)      //  Illegal character!
                {
                    free(bytes);
                    return nil;
                }
            }
    
            if (bufferLength == 0)
                break;
            if (bufferLength == 1)      //  At least two characters are needed to produce one byte!
            {
                free(bytes);
                return nil;
            }
    
            //  Decode the characters in the buffer to bytes.
            bytes[length++] = (buffer[0] << 2) | (buffer[1] >> 4);
            if (bufferLength > 2)
                bytes[length++] = (buffer[1] << 4) | (buffer[2] >> 2);
            if (bufferLength > 3)
                bytes[length++] = (buffer[2] << 6) | buffer[3];
        }
    
        bytes = realloc(bytes, length);
        return [NSData dataWithBytesNoCopy:bytes length:length];
    }
    
    /******************************************************************************
     函数名称 : + (NSString *)base64EncodedStringFrom:(NSData *)data
     函数描述 : 文本数据转换为base64格式字符串
     输入参数 : (NSData *)data
     输出参数 : N/A
     返回参数 : (NSString *)
     备注信息 :
     ******************************************************************************/
    + (NSString *)base64EncodedStringFrom:(NSData *)data
    {
        if ([data length] == 0)
            return @"";
    
        char *characters = malloc((([data length] + 2) / 3) * 4);
        if (characters == NULL)
            return nil;
        NSUInteger length = 0;
    
        NSUInteger i = 0;
        while (i < [data length])
        {
            char buffer[3] = {0,0,0};
            short bufferLength = 0;
            while (bufferLength < 3 && i < [data length])
                buffer[bufferLength++] = ((char *)[data bytes])[i++];
    
            //  Encode the bytes in the buffer to four characters, including padding "=" characters if necessary.
            characters[length++] = encodingTable[(buffer[0] & 0xFC) >> 2];
            characters[length++] = encodingTable[((buffer[0] & 0x03) << 4) | ((buffer[1] & 0xF0) >> 4)];
            if (bufferLength > 1)
                characters[length++] = encodingTable[((buffer[1] & 0x0F) << 2) | ((buffer[2] & 0xC0) >> 6)];
            else characters[length++] = '=';
            if (bufferLength > 2)
                characters[length++] = encodingTable[buffer[2] & 0x3F];
            else characters[length++] = '=';
        }
    
        return [[NSString alloc] initWithBytesNoCopy:characters length:length encoding:NSASCIIStringEncoding freeWhenDone:YES];
    }
    
    @end
    

    以上是接口和实现文件, 现在我们来看看调用

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    
        //MD5
        NSString *md5Str = [Helper md5:@"我爱你"];
        NSLog(@"md5Str is %@",md5Str);//Log is 4F2016C6B934D55BD7120E5D0E62CCE3
    
        //Base64
        NSString *Base64Str = [Helper base64StringFromText:@"我爱你"];
        NSLog(@"Base64Str is %@",Base64Str);//Log is 5oiR54ix5L2g
    
        NSString *oriBase64Str = [Helper textFromBase64String:Base64Str];
        NSLog(@"oriBase64Str is %@",oriBase64Str);//Log is  我爱你
    
        //DES
        NSString *desEnStr = [Helper encryptSting:@"我爱你" key:@"521" andDesiv:@"521"];
        NSLog(@"desEnStr is %@",desEnStr);//Log is  389280aa791ee933
        NSString *desDeStr =[Helper decryptWithDESString:desEnStr key:@"521" andiV:@"521"];
        NSLog(@"desDeStr is %@",desDeStr);//Log is  我爱你
    
        //AES
        NSData *aesEnData = [Helper AES128EncryptWithKey:@"521" iv:@"521" withNSData:[@"我爱你" dataUsingEncoding:NSUTF8StringEncoding]];
        NSString *aesEnStr = [Helper base64EncodedStringFrom:aesEnData];
        NSLog(@"aesEnStr is %@",aesEnStr);//Log is HZKhnRLlQ8XjMjpelOAwsQ==
    
        NSData *aesDeData = [Helper AES128DecryptWithKey:@"521" iv:@"521" withNSData:aesEnData];
        NSString *aesDEStr = [Helper base64EncodedStringFrom:aesDeData];
        NSString *result = [Helper textFromBase64String:aesDEStr];
        NSLog(@"aesDEStr is %@ and result is %@",aesDEStr,result);//Log is aesDEStr is 5oiR54ix5L2gAAAAAAAAAA== and result is 我爱你
    
        return YES;
    }
    

    参考文章:
    常用加解密技术介绍
    各种加解密算法比较
    几种常用加密算法比较
    对称加密和非对称加密介绍和区别
    和安全有关的那些事(非对称加密、数字摘要、数字签名、数字证书、SSL、HTTPS及其他)
    3个著名加密算法(MD5、RSA、DES)的解析
    iOS--加解密(对称,非对称)(AES DES base64这里都有),数字签名,cookie

    Sha1加密:

    string sha1 ( string $str [, bool $raw_output = false ]); //跟md5很像,不同的是sha1()默认情况下返回40个字符的散列值,传入参数性质一样,第一个为加密的字符串,第二个为raw_output的布尔值,默认为false,如果设置为true,sha1()则会返回原始的20 位原始格式报文摘要
    <?php
    $my_intro="zhouxiaogang";
    echo sha1($my_intro); // b6773e8c180c693d9f875bcf77c1202a243e8594
    echo "<hr>";
    //当然,可以将多种加密算法混合使用
    echo md5(sha1($my_intro));
    //输出:54818bd624d69ac9a139bf92251e381d
    //这种方式的双重加密也可以提高数据的安全性
    

    加解密过程:

    非对称加密工作过程简要示意图

    威尼斯在线注册平台 4

    1、乙方生成一对密钥(公钥和私钥)并将公钥向其它方公开。

    2、得到该公钥的甲方使用该密钥对机密信息进行加密后再发送给乙方。

    3、乙方再用自己保存的另一把专用密钥(私钥)对加密后的信息进行解密。乙方只能用其专用密钥(私钥)解密由对应的公钥加密后的信息。

    在传输过程中,即使攻击者截获了传输的密文,并得到了乙的公钥,也无法破解密文,因为只有乙的私钥才能解密密文。

    同样,如果乙要回复加密信息给甲,那么需要甲先公布甲的公钥给乙用于加密,甲自己保存甲的私钥用于解密。

    非对称加密

    非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(public key,简称公钥)和私有密钥(private key,简称私钥);

    威尼斯在线注册平台 5

    如图所示,甲乙之间使用非对称加密的方式完成了重要信息的安全传输。

    1. 乙方生成一对密钥(公钥和私钥)并将公钥向其它方公开。
    2. 得到该公钥的甲方使用该密钥对机密信息进行加密后再发送给乙方。
    3. 乙方再用自己保存的另一把专用密钥(私钥)对加密后的信息进行解密。乙方只能用其专用密钥(私钥)解密由对应的公钥加密后的信息。

    在传输过程中,即使攻击者截获了传输的密文,并得到了乙的公钥,也无法破解密文,因为只有乙的私钥才能解密密文
    同样,如果乙要回复加密信息给甲,那么需要甲先公布甲的公钥给乙用于加密,甲自己保存甲的私钥用于解密。

    在非对称加密中使用的主要算法有:RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)等。 其中我们最见的算法是RSA算法

    以下是从网上摘抄的一段PHP通过openssl实现非对称加密的算法

    <?php
    /**
     * 使用openssl实现非对称加密
     * @since 2010-07-08
     */
    class Rsa {
        /**
         * private key
         */
        private $_privKey;
        /**
         * public key
         */
        private $_pubKey;
        /**
         * the keys saving path
         */
        private $_keyPath;
        /**
         * the construtor,the param $path is the keys saving path
         */
        public function __construct($path) {
            if (empty($path) || !is_dir($path)) {
                throw new Exception('Must set the keys save path');
            }
            $this->_keyPath = $path;
        }
        /**
         * create the key pair,save the key to $this->_keyPath
         */
        public function createKey() {
            $r = openssl_pkey_new();
            openssl_pkey_export($r, $privKey);
            file_put_contents($this->_keyPath . DIRECTORY_SEPARATOR . 'priv.key', $privKey);
            $this->_privKey = openssl_pkey_get_public($privKey);
            $rp = openssl_pkey_get_details($r);
            $pubKey = $rp['key'];
            file_put_contents($this->_keyPath . DIRECTORY_SEPARATOR . 'pub.key', $pubKey);
            $this->_pubKey = openssl_pkey_get_public($pubKey);
        }
        /**
         * setup the private key
         */
        public function setupPrivKey() {
            if (is_resource($this->_privKey)) {
                return true;
            }
            $file = $this->_keyPath . DIRECTORY_SEPARATOR . 'priv.key';
            $prk = file_get_contents($file);
            $this->_privKey = openssl_pkey_get_private($prk);
            return true;
        }
        /**
         * setup the public key
         */
        public function setupPubKey() {
            if (is_resource($this->_pubKey)) {
                return true;
            }
            $file = $this->_keyPath . DIRECTORY_SEPARATOR . 'pub.key';
            $puk = file_get_contents($file);
            $this->_pubKey = openssl_pkey_get_public($puk);
            return true;
        }
        /**
         * encrypt with the private key
         */
        public function privEncrypt($data) {
            if (!is_string($data)) {
                return null;
            }
            $this->setupPrivKey();
            $r = openssl_private_encrypt($data, $encrypted, $this->_privKey);
            if ($r) {
                return base64_encode($encrypted);
            }
            return null;
        }
        /**
         * decrypt with the private key
         */
        public function privDecrypt($encrypted) {
            if (!is_string($encrypted)) {
                return null;
            }
            $this->setupPrivKey();
            $encrypted = base64_decode($encrypted);
            $r = openssl_private_decrypt($encrypted, $decrypted, $this->_privKey);
            if ($r) {
                return $decrypted;
            }
            return null;
        }
        /**
         * encrypt with public key
         */
        public function pubEncrypt($data) {
            if (!is_string($data)) {
                return null;
            }
            $this->setupPubKey();
            $r = openssl_public_encrypt($data, $encrypted, $this->_pubKey);
            if ($r) {
                return base64_encode($encrypted);
            }
            return null;
        }
        /**
         * decrypt with the public key
         */
        public function pubDecrypt($crypted) {
            if (!is_string($crypted)) {
                return null;
            }
            $this->setupPubKey();
            $crypted = base64_decode($crypted);
            $r = openssl_public_decrypt($crypted, $decrypted, $this->_pubKey);
            if ($r) {
                return $decrypted;
            }
            return null;
        }
        public function __destruct() {
            @fclose($this->_privKey);
            @fclose($this->_pubKey);
        }
    }
    //以下是一个简单的测试demo,如果不需要请删除
    $rsa = new Rsa('ssl-key');
    //私钥加密,公钥解密
    echo 'source:我是老鳖<br />';
    $pre = $rsa->privEncrypt('我是老鳖');
    echo 'private encrypted:<br />' . $pre . '<br />';
    $pud = $rsa->pubDecrypt($pre);
    echo 'public decrypted:' . $pud . '<br />';
    //公钥加密,私钥解密
    echo 'source:干IT的<br />';
    $pue = $rsa->pubEncrypt('干IT的');
    echo 'public encrypt:<br />' . $pue . '<br />';
    $prd = $rsa->privDecrypt($pue);
    echo 'private decrypt:' . $prd;
    ?>
    

    优缺点:

    非对称加密与对称加密相比,其安全性更好:对称加密的通信双方使用相同的秘钥,如果一方的秘钥遭泄露,那么整个通信就会被破解。而非对称加密使用一对秘钥,一个用来加密,一个用来解密,而且公钥是公开的,秘钥是自己保存的,不需要像对称加密那样在通信之前要先同步秘钥。

    非对称加密的缺点是加密和解密花费时间长、速度慢,只适合对少量数据进行加密。

    在非对称加密中使用的主要算法有:RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)等。

    对称加密算法

    对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法,就是加密密钥能够从解密密钥中推算出来,同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中,加密密钥和解密密钥是相同的,所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前,商定一个密钥。对称算法的安全性依赖于密钥,泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密,所以密钥的保密性对通信性至关重要。

    对称加密的常用算法有: DES算法,3DES算法,TDEA算法,Blowfish算法,RC5算法,IDEA算法

    在PHP中也有封装好的对称加密函数

    Urlencode/Urldecode

    string urlencode ( string $str ) 
    /*
    1. 一个参数,传入要加密的字符串(通常应用于对URL的加密)
    2. urlencode为双向加密,可以用urldecode来加密(严格意义上来说,不算真正的加密,更像是一种编码方式)
    3. 返回字符串,此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号(%)后跟两位十六进制数,空格则编码为加号(+)。
    */
    

    通过Urlencode函数解决链接中带有&字符引起的问题:

    <?php
    $pre_url_encode="zhougang.com?username=zhougang&password=zhou"; //在实际开发中,我们很多时候要构造这种URL,这是没有问题的
    $url_decode    ="zhougang.com?username=zhou&gang&password=zhou";//但是这种情况下用$_GET()来接受是会出问题的;
    /*
    Array
    (
      [username] => zhou
      [gang] => 
      [password] => zhou
    )
     */
    
    //如下解决问题:
    $username="zhou&gang";
    $url_decode="zhougang.com?username=".urlencode($username)."&password=zhou";
    ?>
    

    常见的urlencode()的转换字符

    ?=> %3F
    = => %3D
    % => %25
    & => %26
     => %5C
    

    base64

    string base64_decode ( string $encoded_data )
    
    1. base64_encode()接受一个参数,也就是要编码的数据(这里不说字符串,是因为很多时候base64用来编码图片)
    2. base64_encode()为双向加密,可用base64_decode()来解密
    $data=file_get_contents($filename);
    echo base64_encode($data);
    /*然后你查看网页源码就会得到一大串base64的字符串,
    再用base64_decode()还原就可以得到图片。这也可以作为移动端上传图片的处理方案之一(但是不建议这样做哈)
    */
    

    严格的来说..这两个函数其实不算是加密,更像是一种格式的序列化

    以下是我们PHP程序中常用到的对称加密算法

    discuz经典算法

    <?php
    function authcode($string, $operation = 'DECODE', $key = '', $expiry = 0) {   
        // 动态密匙长度,相同的明文会生成不同密文就是依靠动态密匙   
        $ckey_length = 4;   
    
        // 密匙   
        $key = md5($key ? $key : $GLOBALS['discuz_auth_key']);   
    
        // 密匙a会参与加解密   
        $keya = md5(substr($key, 0, 16));   
        // 密匙b会用来做数据完整性验证   
        $keyb = md5(substr($key, 16, 16));   
        // 密匙c用于变化生成的密文   
        $keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): 
    substr(md5(microtime()), -$ckey_length)) : '';   
        // 参与运算的密匙   
        $cryptkey = $keya.md5($keya.$keyc);   
        $key_length = strlen($cryptkey);   
        // 明文,前10位用来保存时间戳,解密时验证数据有效性,10到26位用来保存$keyb(密匙b), 
    //解密时会通过这个密匙验证数据完整性   
        // 如果是解码的话,会从第$ckey_length位开始,因为密文前$ckey_length位保存 动态密匙,以保证解密正确   
        $string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) :  
    sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;   
        $string_length = strlen($string);   
        $result = '';   
        $box = range(0, 255);   
        $rndkey = array();   
        // 产生密匙簿   
        for($i = 0; $i <= 255; $i++) {   
            $rndkey[$i] = ord($cryptkey[$i % $key_length]);   
        }   
        // 用固定的算法,打乱密匙簿,增加随机性,好像很复杂,实际上对并不会增加密文的强度   
        for($j = $i = 0; $i < 256; $i++) {   
            $j = ($j + $box[$i] + $rndkey[$i]) % 256;   
            $tmp = $box[$i];   
            $box[$i] = $box[$j];   
            $box[$j] = $tmp;   
        }   
        // 核心加解密部分   
        for($a = $j = $i = 0; $i < $string_length; $i++) {   
            $a = ($a + 1) % 256;   
            $j = ($j + $box[$a]) % 256;   
            $tmp = $box[$a];   
            $box[$a] = $box[$j];   
            $box[$j] = $tmp;   
            // 从密匙簿得出密匙进行异或,再转成字符   
            $result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));   
        }   
        if($operation == 'DECODE') {  
            // 验证数据有效性,请看未加密明文的格式   
            if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) &&  
    substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {   
                return substr($result, 26);   
            } else {   
                return '';   
            }   
        } else {   
            // 把动态密匙保存在密文里,这也是为什么同样的明文,生产不同密文后能解密的原因   
            // 因为加密后的密文可能是一些特殊字符,复制过程可能会丢失,所以用base64编码   
            return $keyc.str_replace('=', '', base64_encode($result));   
        }   
    }
    

    加解密函数encrypt()

    <?php
    //$string:需要加密解密的字符串;$operation:判断是加密还是解密,E表示加密,D表示解密;$key:密匙
    function encrypt($string,$operation,$key=''){ 
        $key=md5($key); 
        $key_length=strlen($key); 
          $string=$operation=='D'?base64_decode($string):substr(md5($string.$key),0,8).$string; 
        $string_length=strlen($string); 
        $rndkey=$box=array(); 
        $result=''; 
        for($i=0;$i<=255;$i++){ 
               $rndkey[$i]=ord($key[$i%$key_length]); 
            $box[$i]=$i; 
        } 
        for($j=$i=0;$i<256;$i++){ 
            $j=($j+$box[$i]+$rndkey[$i])%256; 
            $tmp=$box[$i]; 
            $box[$i]=$box[$j]; 
            $box[$j]=$tmp; 
        } 
        for($a=$j=$i=0;$i<$string_length;$i++){ 
            $a=($a+1)%256; 
            $j=($j+$box[$a])%256; 
            $tmp=$box[$a]; 
            $box[$a]=$box[$j]; 
            $box[$j]=$tmp; 
            $result.=chr(ord($string[$i])^($box[($box[$a]+$box[$j])%256])); 
        } 
        if($operation=='D'){ 
            if(substr($result,0,8)==substr(md5(substr($result,8).$key),0,8)){ 
                return substr($result,8); 
            }else{ 
                return''; 
            } 
        }else{ 
            return str_replace('=','',base64_encode($result)); 
        } 
    }
    ?>
    

    本文由威尼斯手机平台登陆发布于威尼斯在线注册平台,转载请注明出处:【威尼斯在线注册平台】非对称加密算法供给多少个密钥来扩充加密和解密,算法是将普通的音信或然可以见到的新

    关键词: