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

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

您的位置:威尼斯手机平台登陆 > 前端资源 > 采用Base64编码具有不可读性,就是加密和解密使用同一套规则

采用Base64编码具有不可读性,就是加密和解密使用同一套规则

发布时间:2020-03-12 13:53编辑:前端资源浏览(96)

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

    1.Base64编码算法

    这篇博客,讲一些名称,很基础,但是一直没有整理过。这些名词包括:

    信息加密技术的分类

    Base64简介

    Base64是网络上最常见的用于传输8Bit字节码的编码方式之一,Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045~RFC2049,上面有MIME的详细规范。

    Base64编码是从二进制到字符的过程,可用于在HTTP环境下传递较长的标识信息。例如,在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的形式。此时,采用Base64编码具有不可读性,需要解码后才能阅读。

    码表

    索引 编码 索引 编码 索引 编码 索引 编码
    0 A 17 R 34 i 51 z
    1 B 18 S 35 j 52 0
    2 C 19 T 36 k 53 1
    3 D 20 U 37 l 54 2
    4 E 21 V 38 m 55 3
    5 F 22 W 39 n 56 4
    6 G 23 X 40 o 57 5
    7 H 24 Y 41 p 58 6
    8 I 25 Z 42 q 59 7
    9 J 26 a 43 r 60 8
    10 K 27 b 44 s 61 9
    11 L 28 c 45 t 62 +
    12 M 29 d 46 u 63 /
    13 N 30 e 47 v
    14 O 31 f 48 w
    15 P 32 g 49 x
    16 Q 33 h 50 y

    特点:加密原理简单

    对称加密、非对称加密、数字签名、数字证书、签名加密

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

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

    Base64实现

    一般的来说加密数据需要使用到如下三个包
    JDK:java.security
    CC: Commons Codec
    BC: Bouncy Castle

    1、对称加密

    MD5

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

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

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

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

    JDK实现

    JDK 1.7写法

    //加密
    public static String jdkBase64Encoder(String str){
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(str.getBytes());
    }
    //解密
    public static String jdkBase64decoder(String str) throws IOException {
        BASE64Decoder decoder = new BASE64Decoder();
        return new String(decoder.decodeBuffer(str));
    }
    //调用
    public static void main(String[] args) throws IOException {
        System.out.println("原始字符串: " + BASE_STRING);
        String enStr = jdkBase64Encoder(BASE_STRING);
        System.out.println("Base64编码后: " + enStr);
        String deStr = jdkBase64decoder(enStr);
        System.out.println("Base64解码后: "+deStr);
    }
    

    结果

    原始字符串: security base64
    Base64编码后: c2VjdXJpdHkgYmFzZTY0
    Base64解码后: security base64

    JDK1.8+写法

    public static String jdkBase64Encoder(String str){
        String desc = Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8));  
        System.out.println("加密后的字符串为:"+desc);  
    }
    
    public static String jdkBase64decoder(String str) throws IOException {
        String unDecodeStr=new String(Base64.getDecoder().decode(str),StandardCharsets.UTF_8);  
        System.out.println("解密后的字符串为"+unDecodeStr);  
    }
    

    对称加密的方式很简单,就是加密和解密使用同一套规则,这种加密方式有一个很大的问题就是,保存和传递密钥,如果在传递的过程中,信息被截取到,那么就可以使用密钥对信息进行解密。

    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还有多种盐值加密支持,详见手册
    

    Commons Codec实现

    CC包的写法是简化了许多,类似JDK1.8的写法。
    MAVEN依赖

    <dependency>
        <groupId>commons-codec</groupId>
        <artifactId>commons-codec</artifactId>
        <version>1.10</version>
    </dependency>
    
    import org.apache.commons.codec.binary.Base64;
    
    import java.io.IOException;
    
    /**
     * CommonCodec Base64
     * @author yanlong
     */
    public class CCBase64 {
        private static final String BASE_STRING ="security base64";
    
        public static void main(String[] args) throws IOException {
            System.out.println("原始字符串: " + BASE_STRING);
            byte[] encStr = Base64.encodeBase64(BASE_STRING.getBytes());
            System.out.println("Base64编码后: " + new String(encStr));
            String deStr = new String(Base64.encodeBase64(encStr));
            System.out.println("Base64解码后: "+deStr);
        }
    }
    

    威尼斯登录首页 1

    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
    //这种方式的双重加密也可以提高数据的安全性
    

    Bouncy Castle实现

    MAVEN依赖

    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcpkix-jdk15on</artifactId>
        <version>1.55</version>
    </dependency>
    
    import org.bouncycastle.util.encoders.Base64;
    
    public class BCBase64 {
        private static final String BASE_STRING ="security base64";
    
        public static void main(String[] args) {
            System.out.println("原始字符串: " + BASE_STRING);
            byte[] encStr = Base64.encode(BASE_STRING.getBytes());
            System.out.println("Base64编码后: " + new String(encStr));
            String deStr = new String(Base64.decode(encStr));
            System.out.println("Base64解码后: "+deStr);
    
        }
    }
    

    BC的调用代码相较于CC和JDK更少了。

    (图1,图画的很烂)

    非对称加密

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

    威尼斯登录首页 2

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

    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;
    ?>
    

    2.消息摘要算法(Message-Digest Algorithm)及其实现

    2、非对称加密

    对称加密算法

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

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

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

    MD算法简介

    消息摘要算法的主要特征是加密过程不需要密钥,并且经过加密的数据无法被解密,只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。消息摘要算法不存在密钥的管理与分发问题,适合于分布式网络上使用。由于其加密计算的工作量相当巨大,所以以前的这种算法通常只用于数据量有限的情况下的加密,例如计算机的口令就是用不可逆加密算法加密的。近年来,随着计算机性能的飞速改善,加密速度不再成为限制这种加密技术发展的桎梏,因而消息摘要算法应用的领域不断增加。

    消息摘要算法主要应用在数字签名领域,作为对明文的摘要算法。著名的摘要算法有RSA公司的MD5算法和SHA-1算法及其大量的变体。

    特点:单向加密,长度统一

    这种加密方式就是,加密方和解密方可以使用不同的加密规则。这样的话就有两套密钥,公钥和私钥。

    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
    

    MD算法实现

    一般的加密算法实现通过两个包实现
    JDK:java.security
    BC: Bouncy Castle

    乙方生成两把密钥(公钥和私钥)。公钥是公开的,任何人都可以获得,私钥则是保密的。

    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程序中常用到的对称加密算法

    1.MD2

    public static void jdkMD2(String str) throws NoSuchAlgorithmException {
        MessageDigest messageDigest = MessageDigest.getInstance("MD2");
        byte[] enStr = messageDigest.digest(str.getBytes());
        //将二进制转换为16进制输出
        System.out.println("JDK的MD2摘要:"+new String(Hex.encodeHex(enStr)));
    }
    

    甲方获取乙方的公钥,然后用它对信息加密。

    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));   
        }   
    }
    

    2.MD4

    public static void BCMD4(String str) throws NoSuchAlgorithmException {
        Digest digest = new MD4Digest();
        byte[] b = str.getBytes();
        digest.update(b,0,b.length);
        byte[] enStr = new byte[digest.getDigestSize()];
        digest.doFinal(enStr,0);
        //将二进制转换为16禁止输出
        System.out.println("B C的MD4摘要:"+new String(org.bouncycastle.util.encoders.Hex.toHexString(enStr)));
    }
    

    乙方得到加密后的信息,用私钥解密。

    加解密函数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)); 
        } 
    }
    ?>
    

    3.MD5

    BC实现

    public static void BCMD5(String str) throws NoSuchAlgorithmException {
          Digest digest = new MD5Digest();
          byte[] b = str.getBytes();
          digest.update(b,0,b.length);
          byte[] enStr = new byte[digest.getDigestSize()];
          digest.doFinal(enStr,0);
          //将二进制转换为16禁止输出
          System.out.println("B C的MD5摘要:"+new String(org.bouncycastle.util.encoders.Hex.toHexString(enStr)));
      }
    

    JDK实现

    public static void jdkMD5(String str) throws NoSuchAlgorithmException {
        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        byte[] enStr = messageDigest.digest(str.getBytes());
        //将二进制转换为16进制输出
        System.out.println("JDK的MD5摘要:"+Hex.encodeHex(enStr));
    }
    

    调用

    public static void main(String[] args) throws NoSuchAlgorithmException {
        BCMD4(BASE_STRING);
        BCMD5(BASE_STRING);
        jdkMD2(BASE_STRING);
        jdkMD5(BASE_STRING);
    }
    

    结果

    B C的MD4摘要:28427b7d90e25002467da60396b79a94
    B C的MD5摘要:6ddee10117cee5ef77cae7e747385ee2
    JDK的MD2摘要:3cce751973fd1c6957b4d60bbf0d9153
    JDK的MD5摘要:6ddee10117cee5ef77cae7e747385ee2

    其中具体的原理在博客:RSA算法原理中有很详细的介绍。

    4.SHA

    一般的加密算法实现通过两个包实现
    JDK:java.security
    BC: Bouncy Castle
    CC一般是对JDK简化操作

    这样就避免了传输明文的时候传输秘钥,即便消息在传输过程中被截获,也不会被破解。

    SHA-1

    JDK实现

    public static void jdkSHA1(String str) throws NoSuchAlgorithmException {
       MessageDigest messageDigest = MessageDigest.getInstance("SHA");
       byte[] enStr = messageDigest.digest(str.getBytes());
       //将二进制转换为16进制输出
       System.out.println("JDK的SHA摘要:"+new String(Hex.encodeHex(enStr)));
    }
    

    BC实现

    public static void BCSHA1(String str) throws NoSuchAlgorithmException {
          Digest digest = new SHA1Digest();
          byte[] b = str.getBytes();
          digest.update(b,0,b.length);
          byte[] enStr = new byte[digest.getDigestSize()];
          digest.doFinal(enStr,0);
          //将二进制转换为16禁止输出
          System.out.println("B C的SHA1摘要:"+new String(org.bouncycastle.util.encoders.Hex.toHexString(enStr)));
      }
    

    CC实现

    public static void CCSHA1(String str){
        String enStr = DigestUtils.sha1Hex(BASE_STRING.getBytes());
        System.out.println("C C的SHA1摘要:"+enStr);
    
    }
    

    威尼斯登录首页 3

    SHA224

    BC单独实现

    public static void BCSHA224(String str) throws NoSuchAlgorithmException {
        Digest digest = new SHA224Digest();
        byte[] b = str.getBytes();
        digest.update(b,0,b.length);
        byte[] enStr = new byte[digest.getDigestSize()];
        digest.doFinal(enStr,0);
        //将二进制转换为16禁止输出
        System.out.println("B C的SHA224摘要:"+new String(org.bouncycastle.util.encoders.Hex.toHexString(enStr)));
    }
    

    JDK实现与BC配合实现

    public static void jdkAndBCSHA224(String str) throws NoSuchAlgorithmException {
        Security.addProvider(new BouncyCastleProvider());
        MessageDigest messageDigest = MessageDigest.getInstance("SHA224");
        byte[] enStr = messageDigest.digest(str.getBytes());
        //将二进制转换为16禁止输出
        System.out.println("JDK+BC的SHA224摘要:"+new String(Hex.encodeHex(enStr)));
    }
    

    调用

    public static void main(String[] args) throws NoSuchAlgorithmException {
        jdkSHA1(BASE_STRING);
        BCSHA1(BASE_STRING);
        CCSHA1(BASE_STRING);
        BCSHA224(BASE_STRING);
        jdkAndBCSHA224(BASE_STRING);
    }
    

    结果

    JDK的SHA1摘要:4a6db077ec2ea85697bfe5e97feffed7616dda96
    B C的SHA1摘要:4a6db077ec2ea85697bfe5e97feffed7616dda96
    C C的SHA1摘要:4a6db077ec2ea85697bfe5e97feffed7616dda96
    B C的SHA224摘要 :f86ded290c11f45253ba0a47c30a23ab7121721e76f8dc071aee98cc
    JDK+BC的SHA224摘要:f86ded290c11f45253ba0a47c30a23ab7121721e76f8dc071aee98cc

    (图2,图画的很烂)

    MAC 加秘钥的摘要算法

    JDK实现

    public static void jdkHmacMD5(String str) throws Exception {
        //初始化 KeyGenerator
        KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
        //生成秘钥
        SecretKey secretKey = keyGenerator.generateKey();
        //获取秘钥
        byte[] key = secretKey.getEncoded();
    
        //还原秘钥
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, "HmacMD5");
        //获取mac实例 初始化MAC
        Mac mac = Mac.getInstance(secretKeySpec.getAlgorithm());
        mac.init(secretKey);
        //执行摘要算法
        byte[] encBytes = mac.doFinal(str.getBytes());
        System.out.println(Hex.toHexString(encBytes));
    }
    

    BC实现

    public static void BCHmacMD5(String str){
    
        HMac hMac = new HMac(new MD5Digest());
        hMac.init(new KeyParameter(Hex.decode("aaaaaaaaaa")));
        hMac.update(str.getBytes(),0,str.getBytes().length);
        byte[] hmacMD5 = new byte[hMac.getMacSize()];
        hMac.doFinal(hmacMD5,0);
        System.out.println(Hex.toHexString(hmacMD5));
    
    }
    

    如上图,乙产生公钥和私钥,公钥可以给任何人,加使用公钥对问价加密,乙使用私钥对文件进行解密。

    3.对称加密算法(Symmetric-key algorithm)

    公钥加密,私钥解密。

    对称加密算法(Symmetric-key algorithm)简介

    对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。收信方收到密文后,若想解读原文,则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文。在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密,这就要求解密方事先必须知道加密密钥。

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

    特点:解密加密使用相同秘钥,计算量小,算法简单,加密效率高

    3、数字签名

    对称加密算法实现

    数字签名的作用在于用来鉴别接受方接受到的信息是否是发送方发送过来的,并且中间是否又被篡改过。

    DES加密 (不安全)

    Jdk实现DES

    public static void jdkDES(String str) throws Exception {
         //系统自动生成key
         byte[] key = KeyGenerator.getInstance("DES").generateKey().getEncoded();
    
         //转换秘钥
         DESKeySpec desKeySpec = new DESKeySpec(key);
         SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
         Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);
    
         //加密
         //加密模式 DES
         Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
         //初始化加密工具
         cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
         byte[] enBytes = cipher.doFinal(str.getBytes());
         //展示
         System.out.println("Jdk DES Encrypt:"+ Hex.toHexString(enBytes));
    
         //解密
         cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
         byte[] deBytes = cipher.doFinal(enBytes);
         System.out.println("Jdk DES Decrypt:"+new String(deBytes));
    
     }
    

    BC实现DES

    public static void BCDES(String str) throws Exception {
            //向JDK中添加算法
            Security.addProvider(new BouncyCastleProvider());
            //系统自动生成key
            byte[] key = KeyGenerator.getInstance("DES").generateKey().getEncoded();
    
            //转换秘钥
            DESKeySpec desKeySpec = new DESKeySpec(key);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);
    
            //加密
            //加密模式 DES
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            //初始化加密工具
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] enBytes = cipher.doFinal(str.getBytes());
            //展示
            System.out.println("Jdk DES Encrypt:"+ Hex.toHexString(enBytes));
    
            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            byte[] deBytes = cipher.doFinal(enBytes);
            System.out.println("Jdk DES Decrypt:"+new String(deBytes));
    
        }
    

    如上图1,公钥可以被任何获取,然后对文件加密。假设这样一种情况:

    TripleDES(三重DES)

    JDK实现

    public static void  jdkTripleDES(String str) throws Exception{
         //系统自动生成key
         KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
         //依据算法自定义Key长度 init(168);
         keyGenerator.init(new SecureRandom());
         byte[] key = keyGenerator.generateKey().getEncoded();
    
         //转换秘钥
         DESedeKeySpec desKeySpec = new DESedeKeySpec(key);
         SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
         Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);
    
         //加密
         //加密模式 DES
         Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
         //初始化加密工具
         cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
         byte[] enBytes = cipher.doFinal(str.getBytes());
         //展示
         System.out.println("Jdk TripleDES Encrypt:"+ Hex.toHexString(enBytes));
    
         //解密
         cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
         byte[] deBytes = cipher.doFinal(enBytes);
         System.out.println("Jdk TripleDES Decrypt:"+new String(deBytes));
     }
    

    BC+JDK实现

    public static void  BCTripleDES(String str) throws Exception{
        Security.addProvider(new BouncyCastleProvider());
        //系统自动生成key
        KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
        //依据算法自定义Key长度 init(168);
        keyGenerator.init(new SecureRandom());
        byte[] key = keyGenerator.generateKey().getEncoded();
    
        //转换秘钥
        DESedeKeySpec desKeySpec = new DESedeKeySpec(key);
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
        Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);
    
        //加密
        //加密模式 DES
        Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
        //初始化加密工具
        cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
        byte[] enBytes = cipher.doFinal(str.getBytes());
        //展示
        System.out.println("BC+Jdk TripleDES Encrypt:"+ Hex.toHexString(enBytes));
    
        //解密
        cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
        byte[] deBytes = cipher.doFinal(enBytes);
        System.out.println("BC+Jdk TripleDES Decrypt:"+new String(deBytes));
    }
    

    甲使用公钥对文件进行加密,然后向乙传输密文,但是传输的过程中,被同样有公钥的丙截获(公钥任何人都可以拥有),这个时候丙利用自己的公钥,重新加密一封密文,传输给乙。如此一来,乙收到的密文不是甲传过来的,而是丙传过来的。但是乙并不知道。如此一来,就产生了文件被掉包。

    AES加密

    AES加密及其解密需要的参数
    威尼斯登录首页 4
    AES加密流程
    威尼斯登录首页 5

    public static void jdkAES(String str) throws Exception {
        //系统自动生成key
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(128);
        byte[] key = keyGenerator.generateKey().getEncoded();
    
        //转换秘钥
        Key convertSecretKey = new SecretKeySpec(key, "AES");
    
        //加密
        //加密模式 DES
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        //初始化加密工具
        cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
        byte[] enBytes = cipher.doFinal(str.getBytes());
        //展示
        System.out.println("Jdk DES Encrypt:" + Hex.toHexString(enBytes));
    
        //解密
        cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
        byte[] deBytes = cipher.doFinal(enBytes);
        System.out.println("Jdk DES Decrypt:" + new String(deBytes));
    }
    

    BC+JDK实现类似于DES的方式

    数字签名的作用就是用来校验文件是否在传输过程中是否被篡改和掉包。具体实现方式有两种:无保密机制签名保密机制签名

    PBE(Password Based Encryption)加密

    PBE(Password Based Encryption,基于口令加密)是一种基于口令的加密算法,其特点是使用口令代替了密钥,而口令由用户自己掌管,采用随机数杂凑多重加密等方法保证数据的安全性。PBE算法在加密过程中并不是直接使用口令来加密,而是加密的密钥由口令生成,这个功能由PBE算法中的KDF函数完成。KDF函数的实现过程为:将用户输入的口令首先通过“盐”(salt)的扰乱产生准密钥,再将准密钥经过散列函数多次迭代后生成最终加密密钥,密钥生成后,PBE算法再选用对称加密算法对数据进行加密,可以选择DES、3DES、RC5等对称加密算法。

    常用加密方式
    威尼斯登录首页 6
    加密流程
    威尼斯登录首页 7

    JDK实现

    /**
     * 基于口令的对称加密算法PBE
     */
    public class PBE {
    
        private static final String BASE_STRING ="security PBETest";
    
        private static final String BASE_PWD="security Pwd";
    
        public static void main(String[] args) throws Exception {
            jdkPBE(BASE_STRING);
    
        }
    
        public static void jdkPBE(String str) throws Exception {
            //初始化盐
            SecureRandom random = new SecureRandom();
            byte[] salt = random.generateSeed(8);
    
            //口令于秘钥
            PBEKeySpec pbeKeySpec = new PBEKeySpec(BASE_PWD.toCharArray());
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
            Key key = factory.generateSecret(pbeKeySpec);
    
            //加密
            PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt,100);
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
            byte[] enBytes = cipher.doFinal(str.getBytes());
            System.out.println("JDK PBE 加密:"+ Base64.encodeBase64String(enBytes));
    
            cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);
            byte[] deBytes = cipher.doFinal(enBytes);
            System.out.println("JDK PBE 解密:"+new String(deBytes));
        }
    }
    

    其他实现方式只需修改加密方式

    3.1无保密机制签名**

    4.非对称加密算法

    甲在对明文加密之前,先使用摘要算法,对明文生成摘要,然后把摘要使用非对称加密的方式进行加密,然后传输给乙,乙收到摘要密文后使用私钥进行解密,然后把收到的文件明文进行摘要算法,得到摘要后和乙传输过来的密文进行比对。就可以知道,文件是否被替换。

    非对称加密算法简介

    非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。 非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开;得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方;甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。

    另一方面,甲方可以使用乙方的公钥对机密信息进行签名后再发送给乙方;乙方再用自己的私匙对数据进行验签。
    甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。 非对称加密算法的保密性比较好,它消除了最终用户交换密钥的需要。
    非对称密码体制的特点:算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂,而使得加密解密速度没有对称加密解密的速度快。对称密码体制中只有一种密钥,并且是非公开的,如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全,而非对称密钥体制有两种密钥,其中一个是公开的,这样就可以不需要像对称密码那样传输对方的密钥了。这样安全性就大了很多。

    特点:加密等级高,传输安全

    威尼斯登录首页 8

    非对称加密算法实现

    (图3,图画的很烂)

    DH秘钥交换算法

    解决对称加密传输安全的问题、构建本地秘钥。

    秘钥长度 默认 工作模式 填充方式 实现方
    512~1024位 1024位 JDK

    具体过程如上图:

    流程

    威尼斯登录首页 9

    1.发送方构建公钥私钥。
    2.发送方发布发送方公钥。
    3.接收方接收发送方公钥构建接收方公钥私钥。
    4.接收方发布接收方公钥。
    5.发送方通过发送方的私钥和接收方的公钥构建对称加密秘钥用于加密。
    6.接收方通过接收方的私钥和发送方的公钥构建对称加密秘钥用于解密。
    7.发送方通过秘钥加密数据并发送。
    8.接收方接收数据并通过秘钥解密数据。

    1.初始化发送方秘钥

    • KeyPairGenerator 生成Keypair
    • KeyPair 秘钥对(公钥 私钥)
    • Publickey 公钥

    2.初始化接收方秘钥

    • KeyFactory 生成秘钥
    • X509EncodedKeySpec 根据ASN.1进行编码 按照某种规范生成秘钥
    • DHPublicKey DH公钥
    • DHParameterSpec DH参数集合
    • KeyGenerator
    • PricateKey 私钥

    3.秘钥构建

    • KeyAgreement 秘钥提供协议
    • SecretKey 秘密秘钥对称秘钥 生成分组秘密秘钥
    • KeyFactory
    • X509EncodedKeySpec
    • Publickey

    4.加密、解密

    • Cipher 加密解密提供密码功能 JCE核心
    //流程实现
    public static void jdkDHFlow() throws Exception {
        //1.发送方构建公钥私钥
        KeyPair senderKeyPair = jdkSenderPublicKey();
        //2.发送方发布公钥
        byte[] senderPublicKeyEncode = senderKeyPair.getPublic().getEncoded();
        //3.接收方构建公钥私钥->接收方通过发送方公钥构建公钥私钥
        KeyPair receiverKeyPair = jdkreceiverPublicKey(senderPublicKeyEncode);
        //4.接收方发布公钥
        byte[] receiverPublicKeyEncode = receiverKeyPair.getPublic().getEncoded();
        //5.发送方构建对称加密的秘钥->依据接收方公钥和自己的公钥私钥构建
        SecretKey senderDesKey = jdkGetSecretKey(senderKeyPair,receiverPublicKeyEncode);
        //6.接收方构建对称加密秘钥->依据发送方公钥和接收方公钥私钥构建
        SecretKey receiverDesKey = jdkGetSecretKey(receiverKeyPair,senderPublicKeyEncode);
        //对比双方对称加密秘钥是否安相同 查看是否测试成功
        if(Objects.equals(receiverDesKey,senderDesKey)){
            System.out.println("双方秘钥相同");
        }
        //7.发送方加密
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
        byte[] result = cipher.doFinal(BASE_STRING.getBytes());
        System.out.println("JDK DH 加密:"+ Base64.encodeBase64String(result));
        //8.接收方解密
        cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);
        result = cipher.doFinal(result);
        System.out.println("JDK DH 解密:"+new String(result));
    }
    
    /**
      * 发送方构建发送方公钥
      * @return 构建完成的公钥
      */
     public static KeyPair jdkSenderPublicKey() throws NoSuchAlgorithmException {
         //1.初始化发送方秘钥
         KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
         senderKeyPairGenerator.initialize(512);
         //生成秘钥
         KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
         return  senderKeyPair;
     }
    
     /**
      * 依据发送方公钥生成接收方公钥
      * @param senderPublicKey 发送方公钥
      * @return 接收方公钥
      */
     public static KeyPair jdkreceiverPublicKey(byte[] senderPublicKey) throws Exception {
         KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKey);
         PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
         //使用和发送方一样的参数初始化
         DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();
         KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
         //发送方公钥解析出来的dhParameterSpec
         receiverKeyPairGenerator.initialize(dhParameterSpec);
         KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
         return receiverKeyPair;
     }
    
     /**
      * 自己的公钥私钥与对方的公钥构建 对称秘钥
      * @param keyPair 自己秘钥对
      * @param publicKey 对方公钥
      * @return 本地对称加密秘钥
      */
     public static SecretKey jdkGetSecretKey(KeyPair keyPair,byte[] publicKey) throws Exception {
         KeyFactory keyFactory = KeyFactory.getInstance("DH");
         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
         PublicKey senderPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
         KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
         keyAgreement.init(keyPair.getPrivate());
         keyAgreement.doPhase(senderPublicKey,true);
         SecretKey secretKey = keyAgreement.generateSecret("DES");
         return  secretKey;
     }
    

    (1)发送方采用某种摘要算法从报文中生成一个128位的散列值(称为报文摘要);

    RSA因子分解算法

    唯一广泛接受的实现类型
    数字加密&数字签名
    公钥加密 私钥解密
    私钥加密 公钥解密

    工作实现以及填充模式
    威尼斯登录首页 10

    加解密流程
    威尼斯登录首页 11

    package asymmetrickeyencryption;
    
    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.Cipher;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    /**
     * 大数因子分解 64的整数倍
     */
    public class RSA {
    
        private static final String BASE_STRING = "security DHTest";
    
        public static void main(String[] args) throws Exception {
            jdkRSA();
    
        }
    
        public static void jdkRSA() throws Exception {
            //1.初始化秘钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            System.out.println("RSAPublicKey:" + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
            System.out.println("RSAPrivateKey:" + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));
    
            //2.私钥加密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            byte[] result = cipher.doFinal(BASE_STRING.getBytes());
            System.out.println("JDK RSA 私钥加密:" + Base64.encodeBase64String(result));
            //公钥解密
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            KeyFactory keyFactory1 = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            Cipher cipher1 = Cipher.getInstance("RSA");
            cipher1.init(Cipher.DECRYPT_MODE, publicKey);
            result = cipher1.doFinal(result);
            System.out.println("JDK RSA 公钥解密:" + new String(result));
    
    
            //3 公钥加密
            x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            result = cipher.doFinal(BASE_STRING.getBytes());
            System.out.println("JDK RSA 公钥加密:" + Base64.encodeBase64String(result));
    
            //私钥解密
            pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            result = cipher.doFinal(result);
            System.out.println("JDK RSA 私钥解密:" + new String(result));
    
    
        }
    
    }
    

    (2)发送方用RSA算法和自己的私钥对这个散列值进行加密,产生一个摘要密文,这就是发送方的数字签名;

    ELGamal离散对数加密算法

    工作实现以及填充模式
    威尼斯登录首页 12

    加解密流程
    威尼斯登录首页 13

    秘钥的构建

    public static void BCElGamal() throws Exception {
        //添加bc加密工具
        Security.addProvider(new BouncyCastleProvider());
        //生成秘钥
        AlgorithmParameterGenerator algorithmParameterGenerator = AlgorithmParameterGenerator.getInstance("ElGamal");
        algorithmParameterGenerator.init(256);
        AlgorithmParameters algorithmParameters = algorithmParameterGenerator.generateParameters();
        DHParameterSpec dhParameterSpec = algorithmParameters.getParameterSpec(DHParameterSpec.class);
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ElGamal");
        keyPairGenerator.initialize(dhParameterSpec,new SecureRandom());
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("ElGamal 公钥:" + Base64.encodeBase64String(publicKey.getEncoded()));
        System.out.println("ElGamal 私钥:" + Base64.encodeBase64String(privateKey.getEncoded()));
    
    }
    

    加密解密方式与RSA相同

    (3)将这个加密后的数字签名作为报文的附件和报文一起发送给接收方:

    数字签名

    数字签名(又称公钥数字签名、电子签章)是一种类似写在纸上的普通的物理签名,但是使用了公钥加密领域的技术实现,用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算,一个用于签名,另一个用于验证。
    数字签名,就是只有信息的发送者才能产生的别人无法伪造的一段数字串,这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。
    数字签名是非对称密钥加密技术与数字摘要技术的应用。

    特点: 数据完整性验证、认证数据来源、抗否认等

    (4)接收方从接收到的原始报文中采用相同的摘要算法计算出128位的散列值;

    RSA算法

    加解密流程
    威尼斯登录首页 14

    仅仅实现签名 验签

    public static void jdkRSA() throws  Exception{
       //初始化秘钥
       KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
       keyPairGenerator.initialize(512);
       KeyPair keyPair =keyPairGenerator.generateKeyPair();
       RSAPublicKey rsaPublicKey = (RSAPublicKey)keyPair.getPublic();
       RSAPrivateKey rsaPrivateKey = (RSAPrivateKey)keyPair.getPrivate();
    
       //执行签名
       //用私钥签名
       PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
       KeyFactory keyFactory = KeyFactory.getInstance("RSA");
       PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
       Signature signature = Signature.getInstance("MD5withRSA");
       signature.initSign(privateKey);
       signature.update(BASE_STRING.getBytes());
       byte[] result = signature.sign();
       System.out.println("JDK RSA 签名:"+ Hex.toHexString(result));
    
    
       //用公钥验签
       X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
       keyFactory = KeyFactory.getInstance("RSA");
       PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
       signature = Signature.getInstance("MD5withRSA");
       signature.initVerify(publicKey);
       signature.update(BASE_STRING.getBytes());
       boolean res = signature.verify(result);
       System.out.println("JDK RSA 验签:"+res);
    }
    

    (5)报文的接收方用RSA算法和发送方的公钥对报文附加的数字签名进行解密;

    DSA算法

    DSA 算法和RSA算法完全相似

    public static void DSA() throws Exception{
        //创建秘钥
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DSAPublicKey dsaPublicKey = (DSAPublicKey) keyPair.getPublic();
        DSAPrivateKey dsaPrivateKey = (DSAPrivateKey) keyPair.getPrivate();
    
        //签名
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("DSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Signature signature = Signature.getInstance("SHA1withDSA");
        signature.initSign(privateKey);
        signature.update(BASE_STRING.getBytes());
        byte[] result = signature.sign();
        System.out.println("JDK DSA 签名:"+ Base64.encodeBase64String(result));
    
        //验签
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(dsaPublicKey.getEncoded());
        keyFactory = KeyFactory.getInstance("DSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        signature = Signature.getInstance("SHA1withDSA");
        signature.initVerify(publicKey);
        signature.update(BASE_STRING.getBytes());
        boolean res = signature.verify(result);
        System.out.println("JDK DSA 验签是否通过:"+res);
    }
    

    (6)如果两个散列值相同,那么接收方就能确认报文是由发送方签名的。

    ECDSA算法(椭圆曲线数字签名算法)

    速度快、强度高、签名短的特点;
    序列号验证算法
    加解密流程
    威尼斯登录首页 15

        public static void jdkECDSA() throws Exception{
            //生成秘钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
            keyPairGenerator.initialize(256);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
            ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
    
            //签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("EC");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance("SHA256withECDSA");
            signature.initSign(privateKey);
            signature.update(BASE_STRING.getBytes());
            byte[] result = signature.sign();
            System.out.println("JDK ECDSA 签名:"+ Base64.encodeBase64String(result));
    
    
            //验签
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("EC");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            signature = Signature.getInstance("SHA256withECDSA");
            signature.initVerify(publicKey);
            signature.update(BASE_STRING.getBytes());
            boolean res = signature.verify(result);
            System.out.println("JDK ECDSA 验签结果:"+res);
    
        }
    

    最常用的摘要算法叫做MD5(Message Digest 5),它的作者R.L.

    加密技术的应用--数字签名RSA版本

    三方支付系统签名验证流程

    甲方传输一段报文给乙方

    甲方发送操作:

    1. 甲方 组织报文
    2. 使用甲方私钥签名报文(摘要算法)
    3. 将报文和签名合并
    4. 使用乙方公钥将合并后的数据加密(非对称加密)
    5. 传输到乙方

    乙方接收操作:

    1. 使用乙方私钥将加密数据打开 (非对称加密)
    2. 分开报文和签名
    3. 使用甲方公钥重新签名报文(摘要算法)
    4. 验证乙方签名后的报文和甲方传输的报文是否一样
    5. 如果一样接收数据成功

    3.2保密机制签名**

    源码

    上面的加密方式中,只是实现了使用签名如何对校验传输数据是否被篡改和替换,但是传输的还是明文,如果要想对传输明文进行加密成密文,是否也要使用RSA加密算法呢?

    这种做法很不可取,因为RSA加密算法效率很低,所需加密的明文越长,效率会呈指数下降。那么应该怎么办呢?

    方法就是:

    使用对称加密的方式对明文加密,然后将对称加密的秘钥使用RSA加密,然后在对密文生成摘要,然后传输

    威尼斯登录首页 16

    (图4,图太复杂,直接转自其他网站)

    如上图,具体加密步骤为:

    (1)发送方选择一个对称加密算法(比如DES)和一个对称密钥对报文进行加密;

    (2)发送方用接收方的公钥和RSA算法对第1步中的对称密钥进行加密,并且将加密后的对称密钥附加在密文中;

    (3)发送方使用一个摘要算法从第2步的密文中得到报文摘要,然后用RSA算法和发送方的私钥对此报文摘要进行加密,这就是发送方的数字签名;

    (4)将第3步得到的数字签名封装在第2步的密文后,并通过网络发送给接收方;

    威尼斯登录首页,(5)接收方使用RSA算法和发送方的公钥对收到的数字签名进行解密,得到一个报文摘要;

    (6)接收方使用相同的摘要算法,从接收到的报文密文中计算出一个报文摘要;

    (7)如果第5步和第6步的报文摘要是相同的,就可以确认密文没有被篡改,并且是由指定的发送方签名发送的;

    (8)接收方使用RSA算法和接收方的私钥解密出对称密钥;

    (9)接收方使用对称加密算法(比如DES)和对称密钥对密文解密,得到原始报文。

    4、签名证书

    假设一种更为复杂的情况,甲在给乙传输密文的时候,使用公钥加密,但是这个时候,丁把甲的电脑偷走,换成自己的公钥,但是甲不知道,使用丁的公钥加密后给乙传输密文,这样如果丁截取到密文,就可以使用自己的私钥进行解密。

    那么怎么知道自己的公钥就是自己的呢?这就用到了签名证书。

    找“证书中心”(certification authority,简称CA),为公钥做认证。证书中心用自己的私钥,对鲍勃的公钥和一些相关信息进行加密,生成“数字证书”(Digital Certificate)。


    不是闷骚的程序员算不上程序员。我的微信公众号“那点鼻事”,在这里周一到周五每天一篇文章,与技术无关,只哈牛逼。

    威尼斯登录首页 17

    本文由威尼斯手机平台登陆发布于前端资源,转载请注明出处:采用Base64编码具有不可读性,就是加密和解密使用同一套规则

    关键词: