精华内容
下载资源
问答
  • 主要介绍了C#对称加密与非对称加密实例,详细分析了对称加密与非对称加密的原理与具体实现方法,具有一定的实用价值,需要的朋友可以参考下
  • 对称加密:DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES 非对称加密:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)
  • 非对称加密的理论知识,可以参考笔者前面的文章《NODEJS进阶:CRYPTO模块之理论篇》。 完整的代码可以在 《Nodejs学习笔记》 找到,也欢迎大家关注 程序猿小卡的GitHub。 加密、解密方法 在Node.js中,负责安全的...
  • 6.用对方的公钥对称密钥进行加密加密密钥) 7.将密文(5)和加密密钥(6)一起发给对方 接收方: 1.用自己的私钥对加密密钥进行解密,得到对称密钥--也只有自己才能解密。 2.用对称密钥对密文进行解密,得到...
  • * RAS用来加密机密数据:密码/转账资金... * RAS对唱加密Java实现: * 1.采用分组加密的方式,明文可以比较长,理论上无线长,但是太耗费时间 * 2. 不采用分组加密,直接整个元数据加密的话,每次最多加 117 bytes,
  • 对称加密非对称加密的区别以及应用。了解哪些常用的加密算法?能简单介绍一种吗? 内推军P186 P192 1.分类 加密算法首先分为两种:单向加密、双向加密。 单向加密是不可逆的,也就是只能加密,不能解密。通常...

    对称加密和非对称加密的区别以及应用。了解哪些常用的加密算法?能简单介绍一种吗?

    内推军P186  P192

    1.分类

    加密算法首先分为两种:单向加密、双向加密。

    单向加密是不可逆的,也就是只能加密,不能解密。通常用来传输类似用户名和密码,直接将加密后的数据提交到后台,因为后台不需要知道用户名和密码,可以直接将收到的加密后的数据存储到数据库。

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

    2对称加密和非对称加密的区别以及应用。

    对称加密:双方使用的同一个密钥,既可以加密又可以解密,这种加密方法称为对称加密,也称为单密钥加密。

    优点:速度快,对称性加密通常在消息发送方需要加密大量数据时使用,算法公开、计算量小、加密速度快、加密效率高。

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

    在对称加密算法中常用的算法有:DES、AES等。

    AES:密钥的长度可以为128、192和256位,也就是16个字节、24个字节和32个字节

    DES:密钥的长度64位,8个字节。

    非对称加密:一对密钥由公钥和私钥组成(可以使用很多对密钥)。私钥解密公钥加密数据,公钥解密私钥加密数据(私钥公钥可以互相加密解密)。

    私钥只能由一方保管,不能外泄。公钥可以交给任何请求方。

    在非对称加密算法中常用的算法有: 

    RSA、Elgamal、背包算法、Rabin、Diffie-Hellman、ECC(椭圆曲线加密算法)。
    使用最广泛的是RSA算法,Elgamal是另一种常用的非对称加密算法。

    缺点:速度较慢

    优点:安全

    常用算法

    几种对称性加密算法:AES,DES,3DES

    1 、DES是一种分组数据加密技术(先将数据分成固定长度的小数据块,之后进行加密),速度较快,适用于大量数据加密,

    2、 而3DES是一种基于DES的加密算法,使用3个不同密匙对同一个分组数据块进行3次加密,如此以使得密文强度更高。

    3、 相较于DES和3DES算法而言,AES算法有着更高的速度和资源使用效率,安全级别也较之更高了,被称为下一代加密标准。

    几种非对称性加密算法:RSA,DSA,ECC

    RSA和DSA的安全性及其它各方面性能都差不多,而ECC较之则有着很多的性能优越,包括处理速度,带宽要求,存储空间等等。

    几种线性散列算法(签名算法):MD5,SHA1,HMAC

    这几种算法只生成一串不可逆的密文,经常用其效验数据传输过程中是否经过修改,因为相同的生成算法对于同一明文只会生成唯一的密文,若相同算法生成的密文不同,则证明传输数据进行过了修改。通常在数据传说过程前,使用MD5和SHA1算法均需要发送和接收数据双方在数据传送之前就知道密匙生成算法,而HMAC与之不同的是需要生成一个密匙,发送方用此密匙对数据进行摘要处理(生成密文),接收方再利用此密匙对接收到的数据进行摘要处理,再判断生成的密文是否相同。

    4 Md5原理

    摘要哈希生成的正确姿势是什么样呢?分三步:

    1.收集相关业务参数,在这里是金额和目标账户。当然,实际应用中的参数肯定比这多得多,这里只是做了简化。

    2.按照规则,把参数名和参数值拼接成一个字符串,同时把给定的密钥也拼接起来。之所以需要密钥,是因为攻击者也可能获知拼接规则。

    3.利用MD5算法,从原文生成哈希值。MD5生成的哈希值是128位的二进制数,也就是32位的十六进制数。

    第三方支付平台如何验证请求的签名?同样分三步:

    1.发送方和请求方约定相同的字符串拼接规则,约定相同的密钥。

    2.第三方平台接到支付请求,按规则拼接业务参数和密钥,利用MD5算法生成Sign。

    3.用第三方平台自己生成的Sign和请求发送过来的Sign做对比,如果两个Sign值一模一样,则签名无误,如果两个Sign值不同,则信息做了篡改。这个过程叫做验签

    原理

    MD5算法的过程分为四步:处理原文设置初始值循环加工,拼接结果

    第一步:处理原文

    首先,我们计算出原文长度(bit)对512求余的结果,如果不等于448,就需要填充原文使得原文对512求余的结果等于448。填充的方法是第一位填充1,其余位填充0。填充完后,信息的长度就是512*N+448。

    之后,用剩余的位置(512-448=64位)记录原文的真正长度,把长度的二进制值补在最后。这样处理后的信息长度就是512*(N+1)。

    第二步:设置初始值

    MD5的哈希结果长度为128位,按每32位分成一组共4组。这4组结果是由4个初始值A、B、C、D经过不断演变得到。MD5的官方实现中,A、B、C、D的初始值如下(16进制):

    A=0x01234567

    B=0x89ABCDEF

    C=0xFEDCBA98

    D=0x76543210

    第三步:循环加工

    这一步是最复杂的一步,我们看看下面这张图,此图代表了单次A,B,C,D值演变的流程。

    图中,A,B,C,D就是哈希值的四个分组。每一次循环都会让旧的ABCD产生新的ABCD。一共进行多少次循环呢?由处理后的原文长度决定。

    假设处理后的原文长度是M

    主循环次数 = M / 512

    每个主循环中包含 512 / 32 * 4 = 64 次 子循环。

    上面这张图所表达的就是单次子循环的流程。

    下面对图中其他元素一一解释:

    1.绿色F
    图中的绿色F,代表非线性函数。官方MD5所用到的函数有四种:

    F(X, Y, Z) =(X&Y) | ((~X) & Z)
    G(X, Y, Z) =(X&Z) | (Y & (~Z))
    H(X, Y, Z) =X^Y^Z
    I(X, Y, Z)=Y^(X|(~Z))

    在主循环下面64次子循环中,F、G、H、I 交替使用,第一个16次使用F,第二个16次使用G,第三个16次使用H,第四个16次使用I。

    2.红色“田”字
    很简单,红色的田字代表相加的意思。

    3.Mi
    Mi是第一步处理后的原文。在第一步中,处理后原文的长度是512的整数倍。把原文的每512位再分成16等份,命名为M0~M15,每一等份长度32。在64次子循环中,每16次循环,都会交替用到M1~M16之一。

    4.Ki
    一个常量,在64次子循环中,每一次用到的常量都是不同的。

    5.黄色的<<

    第一轮:
        FF(a,b,c,d,M0,7,0xd76aa478)     s[0]=7,   K[0] = 0xd76aa478
      FF(a,b,c,d,M1,12,0xe8c7b756)   s[1]=12,  K[1] = 0xe8c7b756
      FF(a,b,c,d,M2,17,0x242070db)
      FF(a,b,c,d,M3,22,0xc1bdceee)
      FF(a,b,c,d,M4,7,0xf57c0faf)
      FF(a,b,c,d,M5,12,0x4787c62a)
      FF(a,b,c,d,M6,17,0xa8304613)
      FF(a,b,c,d,M7,22,0xfd469501)
      FF(a,b,c,d,M8,7,0x698098d8)
      FF(a,b,c,d,M9,12,0x8b44f7af)
      FF(a,b,c,d,M10,17,0xffff5bb1)
      FF(a,b,c,d,M11,22,0x895cd7be)
      FF(a,b,c,d,M12,7,0x6b901122)
      FF(a,b,c,d,M13,12,0xfd987193)
      FF(a,b,c,d,M14,17, 0xa679438e)
      FF(a,b,c,d,M15,22,0x49b40821)
    第二轮:
      GG(a,b,c,d,M1,5,0xf61e2562)
      GG(a,b,c,d,M6,9,0xc040b340)
      GG(a,b,c,d,M11,14,0x265e5a51)
      GG(a,b,c,d,M0,20,0xe9b6c7aa)
      GG(a,b,c,d,M5,5,0xd62f105d)
      GG(a,b,c,d,M10,9,0x02441453)
      GG(a,b,c,d,M15,14,0xd8a1e681)
      GG(a,b,c,d,M4,20,0xe7d3fbc8)
      GG(a,b,c,d,M9,5,0x21e1cde6)
      GG(a,b,c,d,M14,9,0xc33707d6)
      GG(a,b,c,d,M3,14,0xf4d50d87)
      GG(a,b,c,d,M8,20,0x455a14ed)
      GG(a,b,c,d,M13,5,0xa9e3e905)
      GG(a,b,c,d,M2,9,0xfcefa3f8)
      GG(a,b,c,d,M7,14,0x676f02d9)
      GG(a,b,c,d,M12,20,0x8d2a4c8a)
    第三轮:
      HH(a,b,c,d,M5,4,0xfffa3942)
      HH(a,b,c,d,M8,11,0x8771f681)
      HH(a,b,c,d,M11,16,0x6d9d6122)
      HH(a,b,c,d,M14,23,0xfde5380c)
      HH(a,b,c,d,M1,4,0xa4beea44)
      HH(a,b,c,d,M4,11,0x4bdecfa9)
      HH(a,b,c,d,M7,16,0xf6bb4b60)
      HH(a,b,c,d,M10,23,0xbebfbc70)
      HH(a,b,c,d,M13,4,0x289b7ec6)
      HH(a,b,c,d,M0,11,0xeaa127fa)
      HH(a,b,c,d,M3,16,0xd4ef3085)
      HH(a,b,c,d,M6,23,0x04881d05)
      HH(a,b,c,d,M9,4,0xd9d4d039)
      HH(a,b,c,d,M12,11,0xe6db99e5)
      HH(a,b,c,d,M15,16,0x1fa27cf8)
      HH(a,b,c,d,M2,23,0xc4ac5665)
    第四轮:
      Ⅱ(a,b,c,d,M0,6,0xf4292244)
      Ⅱ(a,b,c,d,M7,10,0x432aff97)
      Ⅱ(a,b,c,d,M14,15,0xab9423a7)
      Ⅱ(a,b,c,d,M5,21,0xfc93a039)
      Ⅱ(a,b,c,d,M12,6,0x655b59c3)
      Ⅱ(a,b,c,d,M3,10,0x8f0ccc92)
      Ⅱ(a,b,c,d,M10,15,0xffeff47d)
      Ⅱ(a,b,c,d,M1,21,0x85845dd1)
      Ⅱ(a,b,c,d,M8,6,0x6fa87e4f)
      Ⅱ(a,b,c,d,M15,10,0xfe2ce6e0)
      Ⅱ(a,b,c,d,M6,15,0xa3014314)
      Ⅱ(a,b,c,d,M13,21,0x4e0811a1)
      Ⅱ(a,b,c,d,M4,6,0xf7537e82)
      Ⅱ(a,b,c,d,M11,10,0xbd3af235)
      Ⅱ(a,b,c,d,M2,15,0x2ad7d2bb)
      Ⅱ(a,b,c,d,M9,21,0xeb86d391)

     

    第四步:拼接结果

    这一步就很简单了,把循环加工最终产生的A,B,C,D四个值拼接在一起,转换成字符串即可。

    MD5不可逆

    “就目前来看,MD5加密算法是不可逆的。MD5不可逆的原因是由于它是一种散列函数(也叫哈希函数,他是一个单向密码体制,即从明文到密文的不可逆映射,只有加密过程没有解密过程。可以将任意长度的输入经过变化后得到固定长度的输出)。”

    展开全文
  • java对称加密与非对称加密

    万次阅读 2017-11-26 22:25:49
    java对称加密与非对称加密加密方式大致分为两种,对称加密和对称加密。对称加密是最快速、最简单的一种加密方式,加密(encryption)与解密(decryption)用的是同样的密钥(secret key)。对称加密为数据的加密...

    java对称加密与非对称加密

    加密方式大致分为两种,对称加密和非对称加密。对称加密是最快速、最简单的一种加密方式,加密(encryption)与解密(decryption)用的是同样的密钥(secret key)。非对称加密为数据的加密与解密提供了一个非常安全的方法,它使用了一对密钥,公钥(public key)和私钥(private key)。私钥只能由一方安全保管,不能外泄,而公钥则可以发给任何请求它的人。因此安全性大大提高。


    对称加密

    所谓对称加密算法即:加密和解密使用相同密钥的算法。常见的有DES、3DES、AES、PBE等加密算法,这几种算法安全性依次是逐渐增强的。

    DES加密

    DES是一种对称加密算法,是一种非常简便的加密算法,但是密钥长度比较短。DES加密算法出自IBM的研究,后来被美国政府正式采用,之后开始广泛流传,但是近些年使用越来越少,因为DES使用56位密钥,以现代计算能力,24小时内即可被破解。虽然如此,在某些简单应用中,我们还是可以使用DES加密算法.简单的DES加密算法实现:

    public class DESUtil {
    
        private static final String KEY_ALGORITHM = "DES";
        private static final String DEFAULT_CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";//默认的加密算法
    
        /**
         * DES 加密操作
         *
         * @param content 待加密内容
         * @param key 加密密钥
         * @return 返回Base64转码后的加密数据
         */
        public static String encrypt(String content, String key) {
            try {
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes("utf-8");
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return Base64.encodeBase64String(result);//通过Base64转码返回
            } catch (Exception ex) {
                Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * DES 解密操作
         *
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content, String key) {
    
            try {
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化,设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
                //执行操作
                byte[] result = cipher.doFinal(Base64.decodeBase64(content));
    
                return new String(result, "utf-8");
            } catch (Exception ex) {
                Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * 生成加密秘钥
         *
         * @return
         */
        private static SecretKeySpec getSecretKey(final String key) {
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
    
            try {
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    
                //DES 要求密钥长度为 56
                kg.init(56, new SecureRandom(key.getBytes()));
    
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
    
                return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DES专用密钥
            } catch (NoSuchAlgorithmException ex) {
                Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        public static void main(String[] args) {
            String content = "hello,您好";
            String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";
            System.out.println("content:" + content);
            String s1 = DESUtil.encrypt(content, key);
            System.out.println("s1:" + s1);
            System.out.println("s2:"+ DESUtil.decrypt(s1, key));
    
        }
    
    }

    3DES加密

    3DES是一种对称加密算法,在 DES 的基础上,使用三重数据加密算法,对数据进行加密,它相当于是对每个数据块应用三次 DES 加密算法。由于计算机运算能力的增强,原版 DES 密码的密钥长度变得容易被暴力破解;3DES 即是设计用来提供一种相对简单的方法,即通过增加 DES 的密钥长度来避免类似的攻击,而不是设计一种全新的块密码算法这样来说,破解的概率就小了很多。缺点由于使用了三重数据加密算法,可能会比较耗性能。简单的3DES加密算法实现:

    public class TripDESUtil {
    
        private static final String KEY_ALGORITHM = "DESede";
        private static final String DEFAULT_CIPHER_ALGORITHM = "DESede/ECB/PKCS5Padding";//默认的加密算法
    
        /**
         * DESede 加密操作
         *
         * @param content 待加密内容
         * @param key 加密密钥
         * @return 返回Base64转码后的加密数据
         */
        public static String encrypt(String content, String key) {
            try {
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes("utf-8");
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return Base64.encodeBase64String(result);//通过Base64转码返回
            } catch (Exception ex) {
                Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * DESede 解密操作
         *
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content, String key) {
    
            try {
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化,设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
                //执行操作
                byte[] result = cipher.doFinal(Base64.decodeBase64(content));
    
                return new String(result, "utf-8");
            } catch (Exception ex) {
                Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * 生成加密秘钥
         *
         * @return
         */
        private static SecretKeySpec getSecretKey(final String key) {
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
    
            try {
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    
                //DESede
                kg.init(new SecureRandom(key.getBytes()));
    
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
    
                return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DESede专用密钥
            } catch (NoSuchAlgorithmException ex) {
                Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        public static void main(String[] args) {
            String content = "hello,您好";
            String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";
            System.out.println("content:" + content);
            String s1 = TripDESUtil.encrypt(content, key);
            System.out.println("s1:" + s1);
            System.out.println("s2:"+ TripDESUtil.decrypt(s1, key));
    
        }
    
    }

    AES加密

    AES是一种对称加密算法,在 DES 的基础上,使用三重数据加密算法,对数据进行加密,它相当于是对每个数据块应用三次 DES 加密算法。由于计算机运算能力的增强,原版 DES 密码的密钥长度变得容易被暴力破解;3DES 即是设计用来提供一种相对简单的方法,即通过增加 DES 的密钥长度来避免类似的攻击,而不是设计一种全新的块密码算法这样来说,破解的概率就小了很多。缺点由于使用了三重数据加密算法,可能会比较耗性能。简单的AES加密算法实现:

    public class AESUtil {
    
        private static final String KEY_ALGORITHM = "AES";
        private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
    
        /**
         * AES 加密操作
         *
         * @param content 待加密内容
         * @param key 加密密钥
         * @return 返回Base64转码后的加密数据
         */
        public static String encrypt(String content, String key) {
            try {
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes("utf-8");
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return Base64.encodeBase64String(result);//通过Base64转码返回
            } catch (Exception ex) {
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * AES 解密操作
         *
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content, String key) {
    
            try {
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化,设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
                //执行操作
                byte[] result = cipher.doFinal(Base64.decodeBase64(content));
    
                return new String(result, "utf-8");
            } catch (Exception ex) {
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * 生成加密秘钥
         *
         * @return
         */
        private static SecretKeySpec getSecretKey(final String key) {
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
    
            try {
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    
                //AES 要求密钥长度为 128
                kg.init(128, new SecureRandom(key.getBytes()));
    
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
    
                return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
            } catch (NoSuchAlgorithmException ex) {
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        public static void main(String[] args) {
            String content = "hello,您好";
            String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";
            System.out.println("content:" + content);
            String s1 = AESUtil.encrypt(content, key);
            System.out.println("s1:" + s1);
            System.out.println("s2:"+AESUtil.decrypt(s1, key));
    
        }
    
    }
    

    非对称加密

    非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。一般公钥是公开的,私钥是自己保存。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。安全性相对对称加密来说更高,是一种高级加密方式。

    RSA加密

    RSA是一种非对称加密算法.RSA有两个密钥,一个是公开的,称为公开密钥;一个是私密的,称为私密密钥。公开密钥是对大众公开的,私密密钥是服务器私有的,两者不能互推得出。用公开密钥对数据进行加密,私密密钥可解密;私密密钥对数据加密,公开密钥可解密。速度较对称加密慢。简单的RSA加密算法实现:

    /**
     * <p>
     * RSA公钥/私钥/签名工具包
     * </p>
     * <p>
     * 罗纳德·李维斯特(Ron [R]ivest)、阿迪·萨莫尔(Adi [S]hamir)和伦纳德·阿德曼(Leonard [A]dleman)
     * </p>
     * <p>
     * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
     * 由于非对称加密速度极其缓慢,一般文件不使用它来加密而是使用对称加密,<br/>
     * 非对称加密算法可以用来对对称加密的密钥加密,这样保证密钥的安全也就保证了数据的安全
     * </p>
     *
     * @author IceWee
     * @date 2012-4-26
     * @version 1.0
     */
    public class RSAUtils {
    
        /**
         * 加密算法RSA
         */
        public static final String KEY_ALGORITHM = "RSA";
    
        /**
         * 签名算法
         */
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        /**
         * 获取公钥的key
         */
        private static final String PUBLIC_KEY = "RSAPublicKey";
    
        /**
         * 获取私钥的key
         */
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        /**
         * RSA最大加密明文大小
         */
        private static final int MAX_ENCRYPT_BLOCK = 117;
    
        /**
         * RSA最大解密密文大小
         */
        private static final int MAX_DECRYPT_BLOCK = 128;
    
        /**
         * <p>
         * 生成密钥对(公钥和私钥)
         * </p>
         *
         * @return
         * @throws Exception
         */
        public static Map<String, Object> genKeyPair() throws Exception {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(1024);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        }
    
        /**
         * <p>
         * 用私钥对信息生成数字签名
         * </p>
         *
         * @param data 已加密数据
         * @param privateKey 私钥(BASE64编码)
         *
         * @return
         * @throws Exception
         */
        public static String sign(byte[] data, String privateKey) throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateK);
            signature.update(data);
            return Base64Utils.encode(signature.sign());
        }
    
        /**
         * <p>
         * 校验数字签名
         * </p>
         *
         * @param data 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @param sign 数字签名
         *
         * @return
         * @throws Exception
         *
         */
        public static boolean verify(byte[] data, String publicKey, String sign)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicK);
            signature.update(data);
            return signature.verify(Base64Utils.decode(sign));
        }
    
        /**
         * <P>
         * 私钥解密
         * </p>
         *
         * @param encryptedData 已加密数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
        /**
         * <p>
         * 公钥解密
         * </p>
         *
         * @param encryptedData 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
        /**
         * <p>
         * 公钥加密
         * </p>
         *
         * @param data 源数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /**
         * <p>
         * 私钥加密
         * </p>
         *
         * @param data 源数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /**
         * <p>
         * 获取私钥
         * </p>
         *
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
        /**
         * <p>
         * 获取公钥
         * </p>
         *
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
    }
    public class Base64Utils {
    
        /**
         * 文件读取缓冲区大小
         */
        private static final int CACHE_SIZE = 1024;
    
        /**
         * <p>
         * BASE64字符串解码为二进制数据
         * </p>
         *
         * @param base64
         * @return
         * @throws Exception
         */
        public static byte[] decode(String base64) throws Exception {
            return Base64.decode(base64.getBytes());
        }
    
        /**
         * <p>
         * 二进制数据编码为BASE64字符串
         * </p>
         *
         * @param bytes
         * @return
         * @throws Exception
         */
        public static String encode(byte[] bytes) throws Exception {
            return new String(Base64.encode(bytes));
        }
    
        /**
         * <p>
         * 将文件编码为BASE64字符串
         * </p>
         * <p>
         * 大文件慎用,可能会导致内存溢出
         * </p>
         *
         * @param filePath
         *            文件绝对路径
         * @return
         * @throws Exception
         */
        public static String encodeFile(String filePath) throws Exception {
            byte[] bytes = fileToByte(filePath);
            return encode(bytes);
        }
    
        /**
         * <p>
         * BASE64字符串转回文件
         * </p>
         *
         * @param filePath
         *            文件绝对路径
         * @param base64
         *            编码字符串
         * @throws Exception
         */
        public static void decodeToFile(String filePath, String base64) throws Exception {
            byte[] bytes = decode(base64);
            byteArrayToFile(bytes, filePath);
        }
    
        /**
         * <p>
         * 文件转换为二进制数组
         * </p>
         *
         * @param filePath
         *            文件路径
         * @return
         * @throws Exception
         */
        public static byte[] fileToByte(String filePath) throws Exception {
            byte[] data = new byte[0];
            File file = new File(filePath);
            if (file.exists()) {
                FileInputStream in = new FileInputStream(file);
                ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
                byte[] cache = new byte[CACHE_SIZE];
                int nRead = 0;
                while ((nRead = in.read(cache)) != -1) {
                    out.write(cache, 0, nRead);
                    out.flush();
                }
                out.close();
                in.close();
                data = out.toByteArray();
            }
            return data;
        }
    
        /**
         * <p>
         * 二进制数据写文件
         * </p>
         *
         * @param bytes
         *            二进制数据
         * @param filePath
         *            文件生成目录
         */
        public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
            InputStream in = new ByteArrayInputStream(bytes);
            File destFile = new File(filePath);
            if (!destFile.getParentFile().exists()) {
                destFile.getParentFile().mkdirs();
            }
            destFile.createNewFile();
            OutputStream out = new FileOutputStream(destFile);
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
            out.close();
            in.close();
        }
    
    }
    

    展开全文
  • 支持Java文件遇见的敏感字段的加密 包括对称和非对称加密
  • 对称加密与非对称加密结合应用

    千次阅读 2016-11-15 15:32:02
    对此加密与非对称加密结合应用

    对称加密与非对称加密组合使用

    1. 明文+对称密钥=对称加密后的明文
    2. 对称密钥+非对称公钥=非对称加密后的对称密钥
    3. 非对称私钥+非对称加密后的对称密钥=对称密钥
    4. 对称密钥+对称加密后的明文=明文

    注意

    1. 其中对称密钥是一次性的,每次操作都会生成新的对称密钥对明文进行加密
    2. 需要管理非对称加密中公钥与私钥的配对

    =================================================

    实际应用

    1. 用户在客户端请求查看文章,此请求会带上加密狗的唯一标识
    2. 服务端收到请求后,确保该请求有附带加密狗的唯一标识
    3. 服务端从数据库获取指定的文章(如果加密存储,则获取后进行解密)
    4. 服务端生成一个对称密钥
    5. 服务端使用对称密钥对明文的文章进行对称加密
    6. 服务端根据加密狗的唯一标识从数据库获取公钥
    7. 服务端使用公钥对对称密钥进行非对称加密
    8. 服务端将密文的对称密钥传回客户端
    9. 客户端将密文的对称密钥传入加密狗(存储着私钥),并获得明文的对称密钥
    10. 客户端使用明文的对称密钥对密文的文章进行解密获得明文的文章

    注意

    1. 客户端:加密狗(加密狗中有非对称私钥)
    2. 网络传输:加密后的对称密钥、加密后的明文
    3. 服务器:非对称公私钥的配对、明文
    展开全文
  • 目录 一、对称加密(Symmetric Cryptography) 优缺点 二、非对称加密(asymmetric Cryptography) ...非对称加密算法使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢,解决加密解密慢的...

    目录

    一、对称加密(Symmetric Cryptography)

    优缺点

    二、非对称加密(asymmetric Cryptography)

    优缺点

    三、Hash加密算法(摘要算法)


    对称加密算法的加密与解密使用的是同样的密钥,加密解密速度较快。但由于需要将密钥在网络传输,所以安全性不高

    非对称加密算法使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢,解决加密解密慢的办法是将对称加密的密钥使用非对称加密的公钥进行加密,然后发送出去,接收方使用私钥进行解密得到对称加密的密钥,然后双方可以使用对称加密来进行沟通。这样既解决了对称加密密钥在网络中传输导致安全性不高的问题,也保证了使用对称加密使加密解密速度较快。

     

    一、对称加密(Symmetric Cryptography

    对称加密是最快速、最简单的一种加密方式,加密(encryption)与解密(decryption)用的是同样的密钥(secret key),这种方法在密码学中叫做对称加密算法。它的特点是文件加密和解密使用相同的密钥加密。

    采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密加密方式,常见的对称加密算法有:DES3DESBlowfishIDEARC4RC5RC6AES

    其中数据加密标准(DES)是比较常用的一种对称加密算法,另一个对称密钥加密系统是国际数据加密算法(IDEA),它比DES的加密性好,而且对计算机功能要求也没有那么高 

     

    优缺点

    • 优点是算法公开、计算量小、加密速度快、加密效率高。
    • 缺点在数据传送前,发送方和接收方必须商定好密钥,然后使双方都能保存好密钥。其次如果一方的密钥被泄露,那么加密信息也就不安全了。另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的唯一秘密钥,也就是说每一组收发方所使用的密钥都是唯一的,例如:A电脑与B、C、D都有通信,那么A就得存储与B、C、D三台电脑通信所用的密钥。这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担

     

    对称加密算法在电子商务交易过程中存在几个问题:

      1、要求提供一条安全的渠道使通讯双方在首次通讯时协商一个共同的密钥。直接的面对面协商可能是不现实而且难于实施的,所以双方可能需要借助于邮件和电话等其它相对不够安全的手段来进行协商;

      2、密钥的数目难于管理。因为对于每一个合作者都需要使用不同的密钥,很难适应开放社会中大量的信息交流;

      3、对称加密算法一般不能提供信息完整性的鉴别。它无法验证发送者和接受者的身份,它只能保证数据的保密性;

      4、对称密钥的管理和分发工作是一件具有潜在危险的和烦琐的过程。对称加密是基于共同保守秘密来实现的,采用对称加密技术的贸易双方必须保证采用的是相同的密钥,保证彼此密钥的交换是安全可靠的,同时还要设定防止密钥泄密和更改密钥的程序。

    假设两个用户需要使用对称加密方法加密然后交换数据,则用户最少需要2个密钥并交换使用,如果企业内用户有n个,则整个企业共需要n×(n-1) 个密钥,密钥的生成和分发将成为企业信息部门的恶梦。

     

    二、非对称加密(asymmetric Cryptography

    也叫公钥密码体系公钥加密算法。与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。

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

    非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开;得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方;甲方再用自己保存的另一把私有密钥对加密后的信息进行解密。甲方只能用其私有密钥解密由其公用密钥加密后的任何信息。

     非对称加密的典型应用是数字签名

     常见的非对称加密算法有:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)

     

    优缺点

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

     

    三、Hash加密算法(摘要算法)

    Hash算法特别的地方在于它是一种单向算法,用户可以通过hash算法对目标信息生成一段特定长度的唯一hash值,却不能通过这个hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。

    md5是一种不可逆的加密,一定记住是不可逆的。虽然现在很多算法也可以将md5解密出来但是md5还是具有很大程度上的不可逆,而且加大解密难度可以使用双重加密,很多登录的地方用到md5加密,那么有些人会问我用md5加密了服务器怎么解密呢,你要是这么想就错了。登录时输入用户的密码这个密码被md5加密后在服务器也存的是这个md5的字符格式,也就是说服务器的数据库存的就是这个格式的字符串,所以服务器那边为什么要解密呢,只要比较你客户端发送的md5字符串和它数据库字符串进行比较就行了,而且现在APP运营商也很多都不敢保存用户的明文密码,因为保存用户的明文密码是对用户信息的不负责。所以在这里一定记住md5加密是不可逆的。很多网上的解密也只是简单的解密,比如你解密得到9,你知道是1+8=9还是2+7=9还是3+6=9呢,想解密也就不用md5了,现在md5也只是用于数据库存储数据。上面这个1+8=2+7=9的例子就是我们为什么每次用md5加密都加一个salt随机数的原因。

     

    像上面讲的对称加密和非对称加密算法都是可以解密的加密算法

    对称的加密算法,现在大多用的是AES和DES等,因为不管服务端还是客户端都用的是一个相同的密钥所以可以说是对称加密,比如客户端用这个密钥给一段文字加密服务端收到这段字符串后会用同样的密钥进行解密;

    另外一种非对称加密用的多的就是RSA,这个加密之所以叫非对称是因为客户端和服务器用的不是同样的密钥分为公钥和秘钥。打个比方,甲方生成了一对密钥然后把公钥公开提供给乙方也可以是乙1,乙2,乙3...,然后乙方拿着公钥进行加密,甲方拿着秘钥进行解密,支付宝接入就是用的RSA。所以RSA还是用的很普及的,比较适合于一些平台的加密。

    常见的Hash算法有MD2、MD4、MD5、HAVAL、SHA


    相关文章:【计算机网络】详解SSL协议


    参考资料: 计算机网络(第7版)-谢希仁
                       https://blog.csdn.net/lg2179/article/details/52535965
                       https://www.cnblogs.com/zhang0807/p/10270209.html

    展开全文
  • 对称加密与非对称加密

    千次阅读 2020-03-29 12:13:52
    对称加密与非对称加密 在数字加密算法中,可划分为对称加密和对称加密。 对称加密 对称加密算法中对于数据的加密与解密使用同一密钥,即使用相同的密码对内容进行加密解密。 内容 + 密钥 = 密文 密文 - 密钥 = ...
  • 对称加密与非对称加密的区别

    千次阅读 2019-11-07 11:08:53
    非对称加密如下图: 例如:“屌丝”要给“高富帅”传输数据,屌丝的加密密码为“123”,此时通过加密工具(RSA)生成一个公钥A和私钥A,“高富帅”也一样生成一个公钥B和私钥B,“屌丝”会用对方的公钥B和自己...
  • 基于.Net的MVC模拟登录,RSA非对称加密,web前端加密,C#后端解密。
  • Https的加密过程 / 对称加密非对称加密

    千次阅读 多人点赞 2018-12-24 11:21:00
    client请求服务端(指定SSL版本和加密组件) server返回CA证书+公钥 client用机构公钥认证server返回的CA证书上的签名是否正确 client生成一个密钥R,用公钥对密钥R加密发送给server server用服务器的私钥解密...
  • 1、DES(Data Encryption Standard):对称算法,数据加密标准,速度较快,适用于加密大量数据的场合; 2、3DES(Triple DES):是基于DES的对称算法,对一块数据用三个不同的密钥进行三次加密,强度更高; 3、RC2和...
  • 最近在工作中涉及到椭圆曲线...网络---Https和Http区别和对称加密非对称加密)其中大部分图片都是从该文中截图后修改 1.密钥加密算法之间的关系 这个东西是总被一些人解读的有问题,导致让人区分不开密钥和...
  • 对称加密非对称加密有什么区别?

    千次阅读 2020-01-10 17:31:43
    非对称加密是有公钥和私钥两个秘钥的. 对称加密速度相对更快,但安全性较低,如果一方的秘钥泄露,那密文就相当于明码了. 而非对称加密速度相对较慢,但安全性更高.(速度我自测过SHA256RSA,签名和验签大约0-10ms,性能...
  • 对称加密 非对称加密 需要的jar包
  • 对称加密非对称加密的详细说明

    千次阅读 2018-12-17 09:55:57
    为了保密,一般在网络上传输的重要数据文件都可以对其进行加密,但数据加密也不一定是为了在网络间传输文件,而是为了保证机密文件即使失窃后也不泄漏其中的重要信息。 数据加密的作用:  ...
  • 生成密钥及加密解密选择密钥时不支持中文路径 其它都已经实现。 C++代码,VS2013做的mfc程序, 调用openssl库的RSA算法实现非对称加密 公钥加密,私钥解密(私钥解密时需要密码) 支持大文件
  • 区块链加/解密 三对称加密与非对称加密的比较与应用推荐博客 对称加密与非对称加密的比较与应用 由于时间关系,之前准备的资料暂时没找到,我后面会进行补充 推荐博客 讲解的挺不错的,缺少了生活应用 ...
  • 对称加密非对称加密、公钥、私钥究竟是个啥?

    千次阅读 多人点赞 2020-06-07 23:29:20
    世界上有没有不能破解的密码或加密方式?还真有一种,叫做一次性密码本,这时唯一一种不能破解的加密方式,而其他的密码只要时间无限理论上都是可破解的,如果你也对加密这个领域感兴趣,可以简单了解下这些概念...
  • 什么是对称加密技术? 对称加密采用了对称密码编码技术,它的特点是文件加密和解密使用相同的密钥加密 也就是密钥也可以用作解密密钥,这种方法在密码学中叫做对称加密算法,对称加密算法使用起来简单快捷,密钥较...
  • 对称加密与非对称加密,以及RSA的原理

    万次阅读 多人点赞 2017-03-10 06:22:32
    例如,最古老的斯巴达加密棒,广泛应用于公元前7世纪的古希腊。16世纪意大利数学家卡尔达诺发明的栅格密码,基于单表代换的凯撒密码、猪圈密码,基于多表代换的维吉尼亚密码,二战中德军广泛使用的恩格玛加密机….但...
  • 众所周知,WEB服务存在http和https两种通信方式,http默认采用80作为通讯端口,对于传输采用不加密的方式,https默认采用443,对于传输的数据进行加密传输 目前主流的网站基本上开始默认采用HTTPS作为通信方式,...
  • 用js实现了非对称加密 aescbc加密 代码片段 function getScrKey(pubExponent,modulus,srcStr){ var publicKey = RSAUtils.getKeyPair(pubExponent, '', modulus); var enStr = RSAUtils.encryptedString(public...
  • 非对称加密概述

    万次阅读 多人点赞 2018-07-29 16:16:15
    非对称加密概述 前言 在阅读《精通比特币》的过程中,我发现比特币系统中有两个重要的概念需要利用非对称加密技术: 比特币地址的生成 交易合法性的验证 因此,我用了几天时间学习了密码学基础知识,尤其是非...
  • 根据密码算法所使用的加密密钥和解密密钥是否相同,分为对称加密非对称加密 对称密钥密码体制 对称密钥加密体制中,发送和接收数据的双方必须使用相同的或对称的密钥对明文进行加密和解密 特点 加密强度低 效率高...
  • 对称加密与非对称加密混合使用

    千次阅读 2019-03-20 00:42:39
    对称与非对称秘钥混合使用保证数据安全甲想给乙发送加密数据,首先甲给乙发送消息说明它要使用混合加密方式发送数据,此时乙会生成一个公钥和一个私钥并把公钥发给甲,甲使用乙发过来的公钥对对称秘钥进行加密发过去...
  • 对称加密非对称加密

    千次阅读 2019-06-15 20:36:31
    对称加密 什么是对称加密对称加密就是指,加密和解密使用同一个密钥的加密方式。 对称加密的工作过程 发送方使用密钥将明文数据加密成密文,然后发送出去,接收方收到密文后,使用同一个密钥将密文解密成明文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,748
精华内容 41,499
关键字:

对称加密与非对称加密的实际应用