精华内容
下载资源
问答
  • 加密方式很多,总的来说,分为2种:对称和非对称。我们先来看一下,这两种加密方式分别是什么?他们什么区别? 对称加密: 对称加密,即采用对称的密码编码技术,他的特点是,加密解密使用相同的秘钥。 ...

    一般金融类的产品,涉及前端和后端交互的时候,都会都严格的数据安全保证。防止黑客攻击,信息篡改。

    加密方式有很多,总的来说,分为2种:对称和非对称。我们先来看一下,这两种加密方式分别是什么?他们有什么区别?

    对称加密:

    对称加密,即采用对称的密码编码技术,他的特点是,加密和解密使用相同的秘钥。

     

    常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES。对称加密算法使用起来简单快捷,密钥较短,且破译困难。

    但是对称秘钥在使用过程中存在以下问题:

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

    2、对称密钥的管理和分发工作是一件具有潜在危险的和烦琐的过程。如何防止秘钥泄露是一个难点。

    非对称加密:

    非对称加密技术,需要两个秘钥,公钥和私钥。公钥和私钥成对出现。

     

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

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

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

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

    对称+非对称:

    现在,我们已经对对称和非对称加密有了一定的了解。接下来,我将会给大家介绍一下,我在项目中使用的一种加密方式:对称+非对称。

    先看一张流程图:

    先看发送方:

    这里,我们主要有2步操作。

    1、报文原文使用对称加密技术。对称加密的秘钥(避免混淆,这里称对称密码)。根据随机数生成。每次发起请求时,会重新产生一个随机数,进一步降低被破解的风险。      

    2、对称密码通过非对称加密方式进行加密。公钥由后台产生,匹配的私钥由后台保管。这样产生一个加密后的对称密码。前端在发送给后端之后,后端需要用匹配的私钥才能解开。

    再看接收方:

    接收方在接收到数据包之后,同样有两步操作:

    1、会使用匹配的私钥解密加密的对称密码,获取到真实的对称密码。

    2、使用对称密码,解密加密报文,获取原报文内容。

     

    这样做的好处是:

    1、因为我们的对称密码是使用非对称加密的,因此,想要破解,需要找到相应的公钥才行。

    2、每次请求会重新生成一个对称密码,这就加大了破解的难度。

     

    代码实现:

    工具类:

    非对称加密:

    public class RSA1 {
        /**
         * 随机生成公钥和私钥
         */
    
        public static final String publicKeyString  = "publicKeyString";
        public static final String privateKeyString = "privateKeyString";
    
    
        public static HashMap<String, String> getRandomKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            keyPairGen.initialize(1024);//生成大小 1024
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();//获取公钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();//获取私钥
            HashMap<String, String> keyMap = new HashMap<String, String>();
            keyMap.put(publicKeyString, new String(Base64.encode(publicKey.getEncoded(), Base64.DEFAULT)));//获取公钥Base64编码
            keyMap.put(privateKeyString, new String(Base64.encode(privateKey.getEncoded(), Base64.DEFAULT)));//获取密钥Base64编码
            return keyMap;
        }
    
        /**
         * 通过字符串生成私钥
         */
        public static PrivateKey getPrivateKey(String privateKeyData) {
            PrivateKey privateKey = null;
            try {
                byte[] decodeKey = Base64.decode(privateKeyData, Base64.DEFAULT); //将字符串Base64解码
                PKCS8EncodedKeySpec x509 = new PKCS8EncodedKeySpec(decodeKey);//创建x509证书封装类
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");//指定RSA
                privateKey = keyFactory.generatePrivate(x509);//生成私钥
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeySpecException e) {
                e.printStackTrace();
            }
            return privateKey;
        }
    
    
        /**
         * 通过字符串生成公钥
         */
        public static PublicKey getPublicKey(String publicKeyData) {
            PublicKey publicKey = null;
            try {
                byte[] decodeKey = Base64.decode(publicKeyData, Base64.DEFAULT);
                X509EncodedKeySpec x509 = new X509EncodedKeySpec(decodeKey);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                publicKey = keyFactory.generatePublic(x509);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeySpecException e) {
                e.printStackTrace();
            }
            return publicKey;
        }
    
        /**
         * 加密
         */
        public static byte[] encrypt(String data, Key key) {
            try {
                //取公钥
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm(),"BC");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                return cipher.doFinal(data.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 解密
         */
        public static byte[] decrypt(byte[] data, Key key) {
            try {
                Cipher cipher = Cipher.getInstance("RSA","BC");
                cipher.init(Cipher.DECRYPT_MODE, key);
                return cipher.doFinal(data);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    对称加密:

    public class AES_2 {
    
        public static byte[] genPrivateKey(String password) throws NoSuchAlgorithmException {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            byte[] bytes = tohash256Deal(password);
            SecureRandom securerandom = new SecureRandom(bytes);
            kgen.init(128, securerandom);
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            return key.getEncoded();
        }
    
        public static byte[] encrypt(String content, SecretKeySpec key) {
            try {
                //创建一个实现指定转换的 Cipher对象,该转换由指定的提供程序提供。
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byte[] byteContent = content.getBytes("utf-8");
                byte[] cryptograph = cipher.doFinal(byteContent);
                return Base64.encode(cryptograph, Base64.DEFAULT);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static String decrypt(byte[] cryptograph, SecretKeySpec key) {
            try {
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
                cipher.init(Cipher.DECRYPT_MODE, key);
                byte[] content = cipher.doFinal(Base64.decode(cryptograph, Base64.DEFAULT));
                return new String(content);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static byte[] encrypt(String content, String password) {
            try {
                //"AES":请求的密钥算法的标准名称
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                //256:密钥生成参数;securerandom:密钥生成器的随机源
                SecureRandom securerandom = new SecureRandom(tohash256Deal(password));
                kgen.init(128, securerandom);
                //生成秘密(对称)密钥
                SecretKey secretKey = kgen.generateKey();
                //返回基本编码格式的密钥
                byte[] enCodeFormat = secretKey.getEncoded();
                //根据给定的字节数组构造一个密钥。enCodeFormat:密钥内容;"AES":与给定的密钥内容相关联的密钥算法的名称
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                //将提供程序添加到下一个可用位置
                Security.addProvider(new BouncyCastleProvider());
                //创建一个实现指定转换的 Cipher对象,该转换由指定的提供程序提供。
                //"AES/ECB/PKCS7Padding":转换的名称;"BC":提供程序的名称
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byte[] byteContent = content.getBytes("utf-8");
                byte[] cryptograph = cipher.doFinal(byteContent);
                return Base64.encode(cryptograph, Base64.DEFAULT);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static String decrypt(byte[] cryptograph, String password) {
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                SecureRandom securerandom = new SecureRandom(tohash256Deal(password));
                kgen.init(128, securerandom);
                SecretKey secretKey = kgen.generateKey();
                byte[] enCodeFormat = secretKey.getEncoded();
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                Security.addProvider(new BouncyCastleProvider());
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");
                cipher.init(Cipher.DECRYPT_MODE, key);
                byte[] content = cipher.doFinal(Base64.decode(cryptograph, Base64.DEFAULT));
                return new String(content);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static String parseByte2HexStr(byte buf[]) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < buf.length; i++) {
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            return sb.toString();
        }
    
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1)
                return null;
            byte[] result = new byte[hexStr.length() / 2];
            for (int i = 0; i < hexStr.length() / 2; i++) {
                int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
                int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
    
        public static byte[] tohash256Deal(String datastr) {
            try {
                MessageDigest digester = MessageDigest.getInstance("SHA-256");
                digester.update(datastr.getBytes());
                byte[] hex = digester.digest();
                return hex;
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException(e.getMessage());
            }
        }
    
    }  

    发送方和接收方的实现:

            String content = "000";
            JSONObject jsonObject = new JSONObject();
            try {
                LogT.i("++++++++++++++++++++++发送方+++++++++++++++++++++++++=");
                //产生私钥
                int random = (int) ((Math.random() * 9 + 1) * 100000);
                //私钥字节
                byte[] bytes = AES_2.genPrivateKey(String.valueOf(random));
                //传输报文加密
                SecretKeySpec key1 = new SecretKeySpec(bytes, "AES");
                byte[] content_encrypt = AES_2.encrypt(content, key1);
                //公钥对私钥加密
                PublicKey publicKey = RSA1.getPublicKey(public_key);
                sKey_encrypt = RSA1.encrypt(Base64.encodeToString(bytes, Base64.DEFAULT), publicKey);
                //数据组装
                jsonObject.put("key", Base64.encodeToString(sKey_encrypt, Base64.DEFAULT));
                jsonObject.put("content", AES_2.parseByte2HexStr(content_encrypt));
    
                LogT.i("+++++++++++++++++++++++接收方++++++++++++++++++++++++=");
    
                //解析获取私钥
                PrivateKey privateKey = RSA1.getPrivateKey(private_key);
                //解析接收到的key数据
                byte[] decode = Base64.decode(Base64.encodeToString(sKey_encrypt, Base64.DEFAULT), Base64.DEFAULT);
                //私钥解密
                byte[] decrypt = RSA1.decrypt(decode, privateKey);
                //解码私钥字节
                byte[] decode_orig = Base64.decode(new String(decrypt), Base64.DEFAULT);
                //加密的报文
                byte[] HexStrByte = AES_2.parseHexStr2Byte(AES_2.parseByte2HexStr(content_encrypt));
                SecretKeySpec key2 = new SecretKeySpec(decode_orig, "AES");
                //解密后的报文
                String decrypt1 = AES_2.decrypt(HexStrByte, key2);
                LogT.i(decrypt1);//000
            } catch (Exception e) {
                e.printStackTrace();
            }

     

                                                                                    扫码关注,共同进步

     

     

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

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

    对称加密

    • 什么是对称加密?
      对称加密就是指,加密和解密使用同一个密钥的加密方式。
    • 对称加密的工作过程
      发送方使用密钥将明文数据加密成密文,然后发送出去,接收方收到密文后,使用同一个密钥将密文解密成明文读取。
    • 对称加密的优点
      加密计算量小、速度块,适合对大量数据进行加密的场景。

    常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES。

    对称加密的两大不足

    • 密钥传输问题:如上所说,由于对称加密的加密和解密使用的是同一个密钥,所以对称加密的安全性就不仅仅取决于加密算法本身的强度,更取决于密钥是否被安全的保管,因此加密者如何把密钥安全的传递到解密者手里,就成了对称加密面临的关键问题。(比如,我们客户端肯定不能直接存储对称加密的密钥,因为被反编译之后,密钥就泄露了,数据安全性就得不到保障,所以实际中我们一般都是客户端向服务端请求对称加密的密钥,而且密钥还得用非对称加密加密后再传输。)
    • 密钥管理问题:再者随着密钥数量的增多,密钥的管理问题会逐渐显现出来。比如我们在加密用户的信息时,不可能所有用户都用同一个密钥加密解密吧,这样的话,一旦密钥泄漏,就相当于泄露了所有用户的信息,因此需要为每一个用户单独的生成一个密钥并且管理,这样密钥管理的代价也会非常大。
    AES加密

    AES加密算法就是众多对称加密算法中的一种,它的英文全称是Advanced Encryption Standard,翻译过来是高级加密标准,它是用来替代之前的DES加密算法的。
    AES为分组密码,分组密码也就是把明文分成一组一组的,每组长度相等,每次加密一组数据,直到加密完整个明文。在AES标准规范中,分组长度只能是128位,也就是说,每个分组为16个字节(每个字节8位)。密钥的长度可以使用128位、192位或256位。密钥的长度不同,推荐加密轮数也不同。如AES-128,也就是密钥的长度为128位,加密轮数为10轮。
    在这里插入图片描述
    关于AES加密,详细可参考博客:
    https://blog.csdn.net/gulang03/article/details/81175854

    非对称加密

    与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(public key)和私有密钥(private key)。

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

    非对称密钥加密的使用过程:

    • A要向B发送信息,A和B都要产生一对用于加密和解密的公钥和私钥。
    • A的私钥保密,A的公钥告诉B;B的私钥保密,B的公钥告诉A。
    • A要给B发送信息时,A用B的公钥加密信息,因为A知道B的公钥。
    • A将这个消息发给B(已经用B的公钥加密消息)。
    • B收到这个消息后,B用自己的私钥解密A的消息,其他所有收到这个报文的人都无法解密,因为只有B才有B的私钥。
    • 反过来,B向A发送消息也是一样。

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

    总结

    从上面大家应该可以看出对称加密和非对称加密的区别,下面稍微进行一下总结:

    (1) 对称加密加密与解密使用的是同样的密钥,所以速度快,但由于需要将密钥在网络传输,所以安全性不高。
    (2) 非对称加密使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢。
    (3) 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密,然后发送出去,接收方使用私钥进行解密得到对称加密的密钥,然后双方可以使用对称加密来进行沟通。

    参考:
    1.https://www.jianshu.com/p/3840b344b27c?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation
    2.https://blog.csdn.net/u013320868/article/details/54090295

    展开全文
  • 数据传输加密  在开发应用过程中,客户端与服务端经常需要进行数据传输,涉及到重要隐私信息时,开发者自然会想到对其进行加密,即使传输过程中被“有心人”截取,也不会将信息泄露。对于加密算法,相信不少开发者...

    本篇文章已授权微信公众号 guolin_blog (郭霖)独家发布

    转载请注明出处:http://blog.csdn.net/chay_chan/article/details/58605605

    数据传输加密

      在开发应用过程中,客户端与服务端经常需要进行数据传输,涉及到重要隐私信息时,开发者自然会想到对其进行加密,即使传输过程中被“有心人”截取,也不会将信息泄露。对于加密算法,相信不少开发者也有所耳闻,比如MD5加密,Base64加密,DES加密,AES加密,RSA加密等等。在这里我主要向大家介绍一下我在开发过程中使用到的加密算法,RSA加密算法+AES加密算法。简单地介绍一下这两种算法吧。

    RSA

      之所以叫RSA算法,是因为算法的三位发明者RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密标准,主要的算法原理就不多加介绍,如果对此感兴趣的话,建议去百度一下RSA算法。需要了解的是RSA算法属于非对称加密算法,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。简单的说是“公钥加密,私钥解密;私钥加密,公钥解密”。

    AES

      高级加密标准(英语:Advanced Encryption Standard,缩写:AES),在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一。

    为什么要结合使用这两种算法

      如果不清楚非对称算法和对称算法,也许你会问,为什么要结合使用这两种算法,单纯使用一种算法不行吗?这就要结合不同的场景和需求了。

    客户端传输重要信息给服务端,服务端返回的信息不需加密的情况

      客户端传输重要信息给服务端,服务端返回的信息不需加密,例如绑定银行卡的时候,需要传递用户的银行卡号,手机号等重要信息,客户端这边就需要对这些重要信息进行加密,使用RSA公钥加密,服务端使用RSA解密,然后返回一些普通信息,比如状态码code,提示信息msg,提示操作是成功还是失败。这种场景下,仅仅使用RSA加密是可以的。

    客户端传输重要信息给服务端,服务端返回的信息需加密的情况

      客户端传输重要信息给服务端,服务端返回的信息需加密,例如客户端登录的时候,传递用户名和密码等资料,需要进行加密,服务端验证登录信息后,返回令牌token需要进行加密,客户端解密后保存。此时就需要结合这两种算法了。至于整个流程是怎样的,在下面会慢慢通过例子向你介绍,因为如果一开始就这么多文字类的操作,可能会让读者感到一头雾水。

    使用RSA加密和解密

    产生公钥和私钥

      产生RSA公钥和密钥的方法有很多,在这里我直接使用我封装好的方法产生,都最后我会将两个算法的工具类赠送给大家。

    /**
     * 生成公钥和私钥
     * 
     * @throws Exception
     * 
     */
    public static void getKeys() throws Exception {
    	KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
    	keyPairGen.initialize(1024);
    	KeyPair keyPair = keyPairGen.generateKeyPair();
    	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
    	String publicKeyStr = getPublicKeyStr(publicKey);
    	String privateKeyStr = getPrivateKeyStr(privateKey);
    
    	System.out.println("公钥\r\n" + publicKeyStr);
    	System.out.println("私钥\r\n" + privateKeyStr);
    }
    
    public static String getPrivateKeyStr(PrivateKey privateKey)
    		throws Exception {
    	return new String(Base64Utils.encode(privateKey.getEncoded()));
    }
    
    public static String getPublicKeyStr(PublicKey publicKey) throws Exception {
    	return new String(Base64Utils.encode(publicKey.getEncoded()));
    }
    

    公钥

    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCRQZ5O/AOAjeYAaSFf6Rjhqovws78I716I9oGF7WxCIPmcaUa1YuyLOncCCuPsaw69+RMWjdbOBp8hd4PPM/d4mKTOVEYUE0SfxhhDTZaM5CzQEUXUyXy7icQTGR5wBjrbjU1yHCKOf5PJJZZQWB06husSFZ40TdL7FdlBpZ1u1QIDAQAB
    

    私钥

    MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJFBnk78A4CN5gBpIV/pGOGqi/CzvwjvXoj2gYXtbEIg+ZxpRrVi7Is6dwIK4+xrDr35ExaN1s4GnyF3g88z93iYpM5URhQTRJ/GGENNlozkLNARRdTJfLuJxBMZHnAGOtuNTXIcIo5/k8klllBYHTqG6xIVnjRN0vsV2UGlnW7VAgMBAAECgYBMoT9xD8aRNUrXgJ7YyFIWCzEUZN8tSYqn2tPt4ZkxMdA9UdS5sFx1/vv1meUwPjJiylnlliJyQlAFCdYBo7qzmib8+3Q8EU3MDP9bNlpxxC1go57/q/TbaymWyOk3pK2VXaX+8vQmllgRZMQRi2JFBHVoep1f1x7lSsf2TpipgQJBANJlO+UDmync9X/1YdrVaDOi4o7g3w9u1eVq9B01+WklAP3bvxIoBRI97HlDPKHx+CZXeODx1xj0xPOK3HUz5FECQQCwvdagPPtWHhHx0boPF/s4ZrTUIH04afuePUuwKTQQRijnl0eb2idBe0z2VAH1utPps/p4SpuT3HI3PJJ8MlVFAkAFypuXdj3zLQ3k89A5wd4Ybcdmv3HkbtyccBFALJgs+MPKOR5NVaSuF95GiD9HBe4awBWnu4B8Q2CYg54F6+PBAkBKNgvukGyARnQGc6eKOumTTxzSjSnHDElIsjgbqdFgm/UE+TJqMHmXNyyjqbaA9YeRc67R35HfzgpvQxHG8GN5AkEAxSKOlfACUCQ/CZJovETMmaUDas463hbrUznp71uRMk8RP7DY/lBnGGMeUeeZLIVK5X2Ngcp9nJQSKWCGtpnfLQ==
    

      很明显,公钥字符串长度比较短,私钥的比较长。生成完密钥后,公钥可以存放在客户端,即使被别人知道公钥,也是没有问题的;私钥则一定要保存在服务端。如果到时公司面临人事变动,避免私钥被离职人员泄露,可以重新生成公钥和密钥。

    使用公钥加密,私钥解密

      这里在客户端模拟加密的情况,对字符串"Beyond黄家驹"使用RSA加密,调用RSAUtils的encryptByPublicKey()方法,输出结果为:

    密文: BRFjf3tUqRqlwuP5JtzxZinf7lp+AHuHM9JSabM5BNFDxuUe9+uuO6RpCHVH5PibifqQHzGNsyZn1G9QcIENT9Tbm+PZwAbNUlMPZRDBU1FSnOtY8dBdeW/lJdnY9sJVwNvIBnOLQk66hxRh6R2149dwlgdsGUpWMOMBzcP3vsU=
    

      在服务端,可以使用RSAUtils的decryptByPrivateKey()方法进行解密,现在模拟服务端解密

      在这里虽然没有完全模拟数据传输过程,比如说客户端发起一个网络请求,传递参数给服务端,服务端接收参数并进行处理,也是为了让大家可以更加容易明白,所以这里只是进行简单的模拟。可以看到android客户端端和java服务端的RSA加密解密算法是可以互通的,原因是他们所使用到的base64加密类是一致的,所以才可以实现加密和解密的算法互通。

      使用到的jar包都是javabase64-1.3.1.jar,相信不少人都知道,java中有自带的Base64算法类,但是安卓中却没有,之前出现的情况是,使用的Base64类不统一,比如在安卓客户端开发使用的Base64算法是使用第三方提供的jar包,而java服务端中使用的是JDK自带的Base64,导致从客户端传过来的密文,服务端解析出错。

      上面的例子展示了客户端使用公钥加密,服务端使用私钥解密的过程。也许你会这么想,既然可以如此,那服务端那边信息也可以通过RSA加密后,传递加密信息过来,客户端进行解密。但是,这样做,显示是不安全的。原因是,由于客户端并没有保存私钥,只有公钥,只可以服务端进行私钥加密,客户端进行公钥解密,但由于公钥是公开,别人也可以获取到公钥,如果信息被他们截取,他们同样可以通过公钥进行解密,那么这样子加密,就毫无意义了,所以这个时候,就要结合对称算法,实现客户端与服务端之前的安全通信了。

    使用AES加密解密
    加密

      模拟客户端进行AES加密,我们通过调用AESUtils中的generateKey()方法,随机产生一个密钥,用于对数据进行加密。输出的结果为:

    密钥: 6446c69c0f914a57
    密文: GECDQOsc22yV48hdJENTMg==
    
    解密

      模拟服务端进行AES解密,由于AES属于对称算法,加密和解密需要使用同一把密钥,所以,服务端要解密传递过来的内容,就需要密钥 + 密文。这里模拟一下服务端解密。

      到这里也许你会问,客户端使用AES进行加密,服务端要进行解密的话,需要用到产生的密钥,那密钥必须从客户端传输到服务端,如果不对密钥进行加密,那加密就没有意义了。所以这里终于谈到了重点,RSA算法+AES算法结合使用。

    RSA算法+AES算法的使用

      举一个简单的例子来说明一下吧,例如实名认证功能,需要传递用户真实姓名和身份证号,对于这种重要信息,需要进行加密处理。

    客户端使用RSA + AES对重要信息进行加密

    客户端加密过程主要分为以下三个步骤:

    1.客户端随机产生AES的密钥;

    2.对身份证信息(重要信息)进行AES加密;

    3.通过使用RSA对AES密钥进行公钥加密。

      这样在传输的过程中,即时加密后的AES密钥被别人截取,对其也无济于事,因为他并不知道RSA的私钥,无法解密得到原本的AES密钥,就无法解密用AES加密后的重要信息。

    服务端使用RSA + AES对重要信息进行解密

    服务端解密过程主要分为以下两个步骤:

    1.对加密后的AES密钥进行RSA私钥解密,拿到密钥原文;

    2.对加密后的重要信息进行AES解密,拿到原始内容。

      现实开发中,服务端有时也需要向客户端传递重要信息,比如登录的时候,返回token给客户端,作为令牌,这个令牌就需要进行加密,原理也是差不多的,比上面多一个步骤而已,就是将解密后的AES密钥,对将要传递给客户端的数据token进行AES加密,返回给客户端,由于客户端和服务端都已经拿到同一把AES钥匙,所以客户端可以解密服务端返回的加密后的数据。如果客户端想要将令牌进行保存,则需要使用自己定义的默认的AES密钥进行加密后保存,需要使用的时候传入默认密钥和密文,解密后得到原token。

      上面提及到客户端加密,服务端返回数据不加密的情况,上面说到仅仅使用RSA是可以,但是还是建议同时使用这两种算法,即产生一个AES密钥,使用RSA对该密钥进行公钥加密,对重要信息进行AES加密,服务端通过RSA私钥解密拿到AES密钥,再对加密后的重要信息进行解密。如果仅仅使用RSA,服务端只通过RSA解密,这样会对于性能会有所影响,原因是RSA的解密耗时约等于AES解密数据的100倍,所以如果每个重要信息都只通过RSA加密和解密,则会影响服务端系统的性能,所以建议两种算法一起使用。

    同时还有相应的JS版RSA和AES算法,使用方式也差不多,在这里简单演示一下:

    下面是一个html页面的代码,引入了rsa.js和aes.js

    <!DOCTYPE html>
    <html>
      <head>
        <title>RSA+AES.html</title>
    	
        <meta name="keywords" content="keyword1,keyword2,keyword3">
        <meta name="description" content="this is my page">
        <meta name="content-type" content="text/html; charset=UTF-8">
        <script type="text/javascript" src="./js/rsa.js"></script>
        <script type="text/javascript" src="./js/aes.js"></script>
        <script type="text/javascript">
            var key = getKey();//随机产生AES密钥
            var encryptKey = RSA(key);//对AES密钥进行RSA加密
            console.log("encryptKey: " + encryptKey);
            
            //测试AES加密和解密
            var cipherText = AESEnc(key,"123456");
            var plainText = AESDec(key,cipherText);
            console.log("密文: " + cipherText);
            console.log("明文: " + plainText);
        </script>
      </head>
      
      <body>
        This is my HTML page. <br>
      </body>
    </html>
    

    打开页面后,查看控制台输出:

    同时,模拟服务端解密,运行结果如下:

      在这里将我自己封装的RSAUtils、AESUtils以及使用第三方jar包的Base64Utils还有JS版的RSAHE AES分享给大家,希望可以帮助到大家,由于刚注册博客不久,没有多少积分,下载一些资料的时候需要积分,所以收取大家1积分,谢谢了。

    http://download.csdn.net/detail/chay_chan/9766486

    需要注意的是:

    1.RSAUtils中配置公钥和密钥,可以使用getKeys()方法产生。如果是客户端,则无须配置私钥,把没有私钥的RSAUtils放到客户端,因为仅需要用到公钥加密的方法。

    2.AESUtils中配置偏移量IV_STRING;

    3.rsa.js中最底部配置公钥,须和上面RSAUtils配置的公钥一致;

    4.aes.js中的底部var iv = CryptoJS.enc.Utf8.parse(“16-Bytes–String”); //加密向量中,替换里面的字符串,加密向量须和
    是上面的AESUtils中的偏移量一致。

      为了完成这篇博客,花费了接近半天的时间,相当于总结自己在数据传输这一方面的经验,希望可以帮助到更多的开发者,一起交流学习,互相提升和进步。

    展开全文
  • 对称加密和非对称加密原理

    千次阅读 2019-02-22 19:14:47
    **私钥加密(对称加密 symmetric cryptography):**私钥加密算法使用单个私钥来加密解密数据。由于具有密钥的任意一方都可以使用该密钥解密数据,因此必须保护密钥不被未经授权的代理得到。私钥加密又称为对称...

    对称加密和非对称加密原理

    私钥加密(对称加密 symmetric cryptography):私钥加密算法使用单个私钥来加密和解密数据。由于具有密钥的任意一方都可以使用该密钥解密数据,因此必须保护密钥不被未经授权的代理得到。私钥加密又称为对称加密 ,因为同一密钥既用于加密又用于解密。私钥加密算法非常快(与公钥算法相比),特别适用于对较大的数据流执行加密转换。Well-known secret key cryptographic algorithms include the Data Encryption Standard (DES), triple-strength DES (3DES), Rivest Cipher 2 (RC2), and Rivest Cipher 4 (RC4).

    通常,私钥算法(称为块密码)用于一次加密一个数据块。块密码(如 RC2、DES、TripleDES 和 Rijndael)通过加密将 n 字节的输入块转换为加密字节的输出块。如果要加密或解密字节序列,必须逐块进行。由于 n 很小(对于 RC2、DES 和 TripleDES,n = 8 字节;n = 16 [默认值];n = 24;对于 Rijndael,n = 32),因此必须对大于 n 的数据值一次加密一个块。
    基类库中提供的块密码类使用称作密码块链 (CBC) 的链模式,它使用一个密钥和一个初始化向量 (IV) 对数据执行加密转换。对于给定的私钥k,一个不使用初始化向量的简单块密码将把相同的明文输入块加密为同样的密文输出块。如果在明文流中有重复的块,那么在密文流中将存在重复的块。如果未经授权的用户知道有关明文块的结构的任何信息,就可以使用这些信息解密已知的密文块并有可能发现您的密钥。若要克服这个问题,可将上一个块中的信息混合到加密下一个块的过程中。这样,两个相同的明文块的输出就会不同。由于该技术使用上一个块加密下一个块,因此使用了一个 IV 来加密数据的第一个块。使用该系统,未经授权的用户有可能知道的公共消息标头将无法用于对密钥进行反向工程。

    可以危及用此类型密码加密的数据的一个方法是,对每个可能的密钥执行穷举搜索。根据用于执行加密的密钥大小,即使使用最快的计算机执行这种搜索,也极其耗时,因此难以实施。使用较大的密钥大小将使解密更加困难。虽然从理论上说加密不会使对手无法检索加密的数据,但这确实极大增加了这样做的成本。如果执行彻底搜索来检索只在几天内有意义的数据需要花费三个月的时间,那么穷举搜索的方法是不实用的。
    私钥加密的缺点是它假定双方已就密钥和 IV 达成协议,并且互相传达了密钥和 IV 的值。并且,密钥必须对未经授权的用户保密。由于存在这些问题,私钥加密通常与公钥加密一起使用,来秘密地传达密钥和 IV 的值。

    最早、最著名的保密密钥或对称密钥加密算法DES(Data Encryption Standard)/DESede是由IBM公司在70年代发展起来的,并经政府的加密标准筛选后,于1976年11月被美国政府采用,DES随后被美国国家标准局和美国国家标准协会(American National Standard Institute,ANSI)承认。DES使用56位密钥对64位的数据块进行加密,并对64位的数据块进行16轮编码。与每轮编码时,一个48位的"每轮"密钥值由56位的完整密钥得出来。

    .NET 提供以下实现类以提供对称的密钥加密算法:
    • DESCryptoServiceProvider

    • RC2CryptoServiceProvider

    • RijndaelManaged

    • TripleDESCryptoServiceProvider

    公钥加密(不对称加密, RSA, DSA, DH asymmetric cryptography ):公钥加密使用一个必须对未经授权的用户保密的私钥和一个可以对任何人公开的公钥。公钥和私钥都在数学上相关联;用公钥加密的数据只能用私钥解密,而用私钥签名的数据只能用公钥验证。公钥可以提供给任何人;公钥用于对要发送到私钥持有者的数据进行加密。两个密钥对于通信会话都是唯一的。公钥加密算法也称为不对称算法,原因是需要用一个密钥加密数据而需要用另一个密钥来解密数据。对称算法的根本原理就是单向函数,f(a)=b,但是用b很难得到a。
    公钥加密算法使用固定的缓冲区大小,而私钥加密算法使用长度可变的缓冲区。公钥算法无法像私钥算法那样将数据链接起来成为流,原因是它只可以加密少量数据。因此,不对称操作不使用与对称操作相同的流模型。

    双方(小红和小明)可以按照下列方式使用公钥加密。首先,小红生成一个公钥/私钥对。如果小明想要给小红发送一条加密的消息,他将向她索要她的公钥。小红通过不安全的网络将她的公钥发送给小明,小明接着使用该密钥加密消息。(如果小明在不安全的信道如公共网络上收到小红的密钥,则小明必须同小红验证他具有她的公钥的正确副本。)小明将加密的消息发送给小红,而小红使用她的私钥解密该消息。
    但是,在传输小红的公钥期间,未经授权的代理可能截获该密钥。而且,同一代理可能截获来自小明的加密消息。但是,该代理无法用公钥解密该消息。该消息只能用小红的私钥解密,而该私钥没有被传输。小红不使用她的私钥加密给小明的答复消息,原因是任何具有公钥的人都可以解密该消息。如果小红想要将消息发送回小明,她将向小明索要他的公钥并使用该公钥加密她的消息。然后,小明使用与他相关联的私钥来解密该消息。

    在一个实际方案中,小红和小明使用公钥(不对称)加密来传输私(对称)钥,而对他们的会话的其余部分使用私钥加密(由于对称加密快捷,用于实际的数据加密,而利用不对称加密的方式解决对称加密中私钥传递的不安全性,此为对称和不对称加密结合的加密方式)。
    公钥加密具有更大的密钥空间(或密钥的可能值范围),因此不大容易受到对每个可能密钥都进行尝试的穷举攻击。由于不必保护公钥,因此它易于分发。公钥算法可用于创建数字签名以验证数据发送方的身份。但是,公钥算法非常慢(与私钥算法相比),不适合用来加密大量数据。公钥算法仅对传输很少量的数据有用。公钥加密通常用于加密一个私钥算法将要使用的密钥和 IV。传输密钥和 IV 后,会话的其余部分将使用私钥加密。

    RSA系统是诸多此类算法中最著名、最多使用的一种。RSA公开密钥密码系统是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是来自于这三位发明者的姓的第一个字母RSA(Rivest-Shamir-Adleman)算法是基于大数不可能被质因数分解假设的公钥体系。简单地说就是找两个很大的质数。一个对外公开的为“公钥”(Prblic key) ,另一个不告诉任何人,称为"私钥”(Private key)。这两个密钥是互补的,也就是说用公钥加密的密文可以用私钥解密,反过来也一样。

    公钥的传输:要启动安全通讯,通信两端必须首先得到相同的共享密钥(主密钥),但共享密钥不能通过网络相互发送,因为这种做法极易泄密。Diffie-Hellman算法是用于密钥交换的最早最安全的算法之一。

    RSA算法:RSA算法是基于大数难于分解的原理。不但可以用于认证,也可以用于密钥传输,例子可以参考RSAUtil.java文件。那么用户A和B如何利用RSA算法来传输密钥呢?

    1:A产生一个密钥K,用B的公钥加密K,然后将得到的密文发送给B。

    2:B用自己的私钥解密收到的密钥,就可以得到密钥。

    DH算法:DH算法的出现就是用来进行密钥传输的。DH算法是基于离散对数实现的。DH算法的基本工作原理是:通信双方公开或半公开交换一些准备用来生成密钥的"材料数据",在彼此交换过密钥生成"材料"后,两端可以各自生成出完全一样的共享密钥。在任何时候,双方都绝不交换真正的密钥。通信双方交换的密钥生成"材料",长度不等,"材料"长度越长,所生成的密钥强度也就越高,密钥破译就越困难。除进行密钥交换外,IPSec还使用DH算法生成所有其他加密密钥。

    在通信前,用户A和B双方约定2个大整数n和g,其中1<g<n,这两个整数可以公开

    1. A随机产生一个大整数a,然后计算Ka=ga mod n(a需要保密)

    2. B随机产生一个大整数b,然后计算Kb=gb mod n(b需要保密)

    3. A把Ka发送给B,B把Kb发送给A

    4. A计算K=Kba mod n

    5. B计算K=Kab mod n

    由于Kba mod n= (gb mod n)a mod n= (ga mod n)b mod n,因此可以保证双方得到的K是相同的,K即是共享的密钥。可以参考JCE文档中的DH 3 party的例子。

    实际的一个用DH算法传递DES私钥的JAVA例子参看“JAVA上加密算法的实现用例”一文中的末一个例子,过程如下:假设A和B通信(JCE中只支持DH算法作为传递私钥的算法)

    A利用KeyPairGenerator类生成一个钥对类KeyPair并可通过generatePublic方法产生公钥PublicKey(puA)和getPrivate方法私钥PrivateKey(prA)。A把puA发给B。B用类X509EncodedKeySpec解码,然后利用KeyFactory类生成puA,转换成DHPublicKey类利用其getParams方法取得参数类DHParameterSpec,B再利用此参数类,通过KeyPairGenerator类的initialize方法生成KeyPairGenerator实例从而用generateKeyPair方法生成B的KeyPair。进而B生成puB和prB,B把puB发给A。A利用puB和prA作为参数,分别调用KeyAgreement类的init和doPhase方法初始化,然后用generateSecret方法生成各自的DES的密钥SecretKey,此密钥是相同的,即可用Cipher类进行加解密了。

    .NET 通过抽象基类 (System.Security.Crytography.AsymmetricAlgorithm) 提供下列非对称(公钥/私钥)加密算法:
    • DSACryptoServiceProvider

    • RSACryptoServiceProvider

    数字签名
    公钥算法还可用于构成数字签名。数字签名验证发送方的身份(如果您信任发送方的公钥)并帮助保护数据的完整性。

    为了使用公钥加密对消息进行数字签名,小红首先将哈希算法应用于该消息以创建消息摘要。该消息摘要是数据的紧凑且唯一的表示形式。然后,小红用她的私钥加密该消息摘要以创建她的个人签名。在收到消息和签名时,小明使用小红的公钥解密签名以恢复消息摘要,并使用与小红所使用的相同的哈希算法来散列消息。如果小明计算的消息摘要与从小红那里收到的消息摘要完全一致,小明就可以确定该消息来自私钥的持有人,并且数据未被修改过。如果小明相信小红是私钥的持有人,则他知道该消息来自小红。

    请注意,由于发送方的公钥为大家所周知,并且它通常包含在数字签名格式中,因此任何人都可以验证签名。此方法不保守消息的机密;若要使消息保密,还必须对消息进行加密。

    .NET Framework 提供以下实现数字签名算法的类:

    DSACryptoServiceProvider
    RSACryptoServiceProvider

    CA证书 Public Key Certificates(参考这里)

    A public key certificate provides a safe way for an entity to pass on its public key to be used in asymmetric cryptography. The public key certificate avoids the following situation: if Charlie creates his own public key and private key, he can claim that he is Alice and send his public key to Bob. Bob will be able to communicate with Charlie, but Bob will think that he is sending his data to Alice.

    A public key certificate can be thought of as the digital equivalent of a passport. It is issued by a trusted organization and provides identification for the bearer. A trusted organization that issues public key certificates is known as a certificate authority (CA). The CA can be likened to a notary public. To obtain a certificate from a CA, one must provide proof of identity. Once the CA is confident that the applicant represents the organization it says it represents, the CA signs the certificate attesting to the validity of the information contained within the certificate.

    A public key certificate contains several fields, including:

    Issuer - The issuer is the CA that issued the certificate. If a user trusts the CA that issues a certificate, and if the certificate is valid, the user can trust the certificate.

    Period of validity - A certificate has an expiration date, and this date is one piece of information that should be checked when verifying the validity of a certificate.

    Subject - The subject field includes information about the entity that the certificate represents.

    Subject’s public key - The primary piece of information that the certificate provides is the subject’s public key. All the other fields are provided to ensure the validity of this key.

    Signature - The certificate is digitally signed by the CA that issued the certificate. The signature is created using the CA’s private key and ensures the validity of the certificate. Because only the certificate is signed, not the data sent in the SSL transaction, SSL does not provide for non-repudiation.
    If Bob only accepts Alice’s public key as valid when she sends it in a public key certificate, Bob will not be fooled into sending secret information to Charlie when Charlie masquerades as Alice.

    Multiple certificates may be linked in a certificate chain. When a certificate chain is used, the first certificate is always that of the sender. The next is the certificate of the entity that issued the sender’s certificate. If there are more certificates in the chain, each is that of the authority that issued the previous certificate. The final certificate in the chain is the certificate for a root CA. A root CA is a public certificate authority that is widely trusted. Information for several root CAs is typically stored in the client’s Internet browser. This information includes the CA’s public key. Well-known CAs include VeriSign, Entrust, and GTE CyberTrust.

    哈希值
    哈希算法将任意长度的二进制值映射为固定长度的较小二进制值,这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希计算都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的。

    消息身份验证代码 (MAC) 哈希函数通常与数字签名一起用于对数据进行签名,而消息检测代码 (MDC) 哈希函数则用于数据完整性。

    双方(小红和小明)可按下面的方式使用哈希函数来确保数据的完整性。如果小红对小明编写一条消息并创建该消息的哈希,则小明可以在稍后散列该消息并将他的哈希与原始哈希进行比较。如果两个哈希值相同,则该消息没有被更改;如果值不相同,则该消息在小红编写它之后已被更改。为了使此系统发挥作用,小红必须对除小明外的所有人保密原始的哈希值。

    When sending encrypted data, SSL typically uses a cryptographic hash function to ensure data integrity. The hash function prevents Charlie from tampering with data that Alice sends to Bob.

    A cryptographic hash function is similar to a checksum. The main difference is that while a checksum is designed to detect accidental alterations in data, a cryptographic hash function is designed to detect deliberate alterations. When data is processed by a cryptographic hash function, a small string of bits, known as a hash, is generated. The slightest change to the message typically makes a large change in the resulting hash. A cryptographic hash function does not require a cryptographic key. Two hash functions often used with SSL are Message Digest 5 (MD5) and Secure Hash Algorithm (SHA). SHA was proposed by the US National Institute of Science and Technology (NIST).

    Message Authentication Code: A message authentication code (MAC) is similar to a cryptographic hash, except that it is based on a secret key. When secret key information is included with the data that is processed by a cryptographic hash function, the resulting hash is known as an HMAC.
    If Alice wants to be sure that Charlie does not tamper with her message to Bob, she can calculate an HMAC for her message and append the HMAC to her original message. She can then encrypt the message plus the HMAC using a secret key she shares with Bob. When Bob decrypts the message and calculates the HMAC, he will be able to tell if the message was modified in transit. With SSL, an HMAC is used with the transmission of secure data.

    .NET Framework 提供以下实现数字签名算法的类:

    HMACSHA1
    MACTripleDES
    MD5CryptoServiceProvider
    SHA1Managed
    SHA256Managed
    SHA384Managed
    SHA512Managed

    摘要函数(MD2、MD4和MD5,还有SHA1等算法(产生一个20字节的二进制数组))
    摘要是一种防止改动的方法,其中用到的函数叫摘要函数。这些函数的输入可以是任意大小的消息,而输出是一个固定长度的摘要。摘要有这样一个性质,如果改变了输入消息中的任何东西,甚至只有一位,输出的摘要将会发生不可预测的改变,也就是说输入消息的每一位对输出摘要都有影响。总之,摘要算法从给定的文本块中产生一个数字签名(fingerprint或message digest),数字签名可以用于防止有人从一个签名上获取文本信息或改变文本信息内容。摘要算法的数字签名原理在很多加密算法中都被使用,如S/KEY和PGP(pretty good privacy)。

    现在流行的摘要函数有MD4和MD5。MD2摘要算法的设计是出于下面的考虑:利用32位RISC结构来最大其吞吐量,而不需要大量的替换表(substitution table)。MD4算法将消息的给予对长度作为输入,产生一个128位的"指纹"或"消息化"。要产生两个具有相同消息化的文字块或者产生任何具有预先给定"指纹"的消息,都被认为在计算上是不可能的。MD5摘要算法是个数据认证标准。MD5的设计思想是要找出速度更快但更不安全的MD4中潜在的不安全,MD5的设计者通过使MD5在计算上慢下来,以及对这些计算做了一些基础性的改动来解决这个问题。MD5在RFC1321中给出文档描述,是MD4算法的一个扩展。美国国家标准技术研究所的SHA1和麻省理工学院Ronald Rivest提出的MD5是为代表。HMAC-MD5算法(消息摘要5)基于RFC1321。MD5对MD4做了改进,计算速度比MD4稍慢,但安全性能得到了进一步改善。MD5在计算中使用了64个32位常数,最终生成一个128位的完整性检查和。

    HMAC-SHA算法:安全Hash算法定义在NIST FIPS 180-1,其算法以MD5为原型。SHA在计算中使用了79个32位常数,最终产生一个160位完整性检查和。SHA检查和长度比MD5更长,因此安全性也更高。

    随机数生成
    随机数生成是许多加密操作不可分割的组成部分。例如,加密密钥需要尽可能地随机,以便使生成的密钥很难再现。加密随机数生成器必须生成无法以计算方法推算出(低于 p < .05 的概率)的输出;即,任何推算下一个输出位的方法不得比随机猜测具有更高的成功概率。.NET Framework 中的类使用随机数生成器生成加密密钥。

    在商务领域的应用

    许多人都知道NETSCAPE公司是Internet商业中领先技术的提供者,该公司提供了一种基于RSA和保密密钥的应用于因特网的技术,被称为安全插座层(Secure Sockets Layer,SSL)。

    也许很多人知道Socket,它是一个编程界面,并不提供任何安全措施,而SSL不但提供编程界面,而且向上提供一种安全的服务,SSL3.0现在已经应用到了服务器和浏览器上,SSL2.0则只能应用于服务器端。

    SSL3.0用一种电子证书(electric certificate)来实行身份进行验证后,双方就可以用保密密钥进行安全的会话了。它同时使用“对称”和“非对称”加密方法,在客户与电子商务的服务器进行沟通的过程中,客户会产生一个Session Key,然后客户用服务器端的公钥将Session Key进行加密,再传给服务器端,在双方都知道Session Key后,传输的数据都是以Session Key进行加密与解密的,但服务器端发给用户的公钥必需先向有关发证机关申请,以得到公证。

    基于SSL3.0提供的安全保障,用户就可以自由订购商品并且给出信用卡号了,也可以在网上和合作伙伴交流商业信息并且让供应商把订单和收货单从网上发过来,这样可以节省大量的纸张,为公司节省大量的电话、传真费用。在过去,电子信息交换(Electric Data Interchange,EDI)、信息交易(information transaction)和金融交易(financial transaction)都是在专用网络上完成的,使用专用网的费用大大高于互联网。正是这样巨大的诱惑,才使人们开始发展因特网上的电子商务,但不要忘记数据加密。

    SSL(Secure Sockets Layer) or TSL (Transport Layer Security)

    Secure Sockets Layer (SSL) is the most widely used protocol for implementing cryptography on the Web. SSL uses a combination of cryptographic processes to provide secure communication over a network. This section provides an introduction to SSL and the cryptographic processes it uses.

    SSL provides a secure enhancement to the standard TCP/IP sockets protocol used for Internet communications. As shown in the “TCP/IP Protocol Stack With SSL” figure below, the secure sockets layer is added between the transport layer and the application layer in the standard TCP/IP protocol stack. The application most commonly used with SSL is Hypertext Transfer Protocol (HTTP), the protocol for Internet Web pages.

    SSL was developed by Netscape in 1994, and with input from the Internet community, has evolved to become a standard. It is now under the control of the international standards organization, the Internet Engineering Task Force (IETF). The IETF has renamed SSL to Transport Layer Security (TLS), and released the first specification, version 1.0, in January 1999. TLS 1.0 is a modest upgrade to the most recent version of SSL, version 3.0. The differences between SSL 3.0 and TLS 1.0 are minor.

    One of the reasons SSL is effective is that it uses several different cryptographic processes. SSL uses public key cryptography to provide authentication, and secret key cryptography and digital signatures to provide for privacy and data integrity. Before you can understand SSL, it is helpful to understand these cryptographic processes.

    常用算法比较

    数据加密标准(DES)是一个古老的对称密钥加密算法,目前已经不再使用。它不是一个很安全的算法。

    三重DES(Triple-DES)仍然是很安全的,但是也只是在别无他法的情况下的一个较好的选择。显然高级加密标准(AES)是一个更好的加密算法,NIST用AES代替Triple-DES作为他们的标准(下面有更详细的讨论)。其他较好的算法包括另外两个AES的变种算法Twofish和Serpent-也称为CAST-128,它是效率和安全的完美结合。这几个算法不仅比DES更安全,而且也比DES的速度更快。为什么要使用一些又慢又不安全的算法呢

    SHA1是一个哈希函数,而不是一个加密函数。作为一个哈希函数,SHA1还是相当优秀的,但是还需要几年的发展才能用作加密算法。如果你正在设计一个新系统,那么谨记你可能会在若干年后用SHA1代替目前的算法。我再重复一遍:只是可能。

    RSA是一个公开密钥加密算法。RSA的密钥长度一般为2048-4096位。如果你现在的系统使用的是1024位的公开密钥,也没有必要担心,但是你可以加长密钥长度来达到更好的加密效果。

    高级加密标准(AES)是一个用来代替数据加密标准(DES)的算法。目前使用的一般为128,196和256位密钥,这三种密钥都是相当安全的。而且美国政府也是这样认为的。他们批准将128位密钥的AES算法用于一般数据加密,196位和256位密钥的AES算法用于秘密数据和绝密数据的加密。

    DESX是DES的一个改进版本。DESX的原理是利用一个随机的二进制数与加密前的数据以及解密后的数据异或。虽然也有人批评这种算法,但是与DES相比DESX确实更安全,不过DESX在许多情况下并不适用。我曾经处理过一个硬件支持DES的系统,由于有些环节不能容忍三重DES的慢速,我们在这些地方使用了DESX来代替DES。然而,这是一个非常特殊的情况。如果你需要使用DESX,理由显而易见(可能和我不得不使用DESX的原因类似)。但我建议你使用AES或者上面我提到的一些算法。

    RC4是一种常用于SSL连接的数据流加密算法。它已经出现很多年了,而且有很多已知和可能的缺陷,因此在一些新的工程中不要使用它。如果你目前正在使用它而且可以轻易的卸载它,那么情况也不是很坏。不过,我怀疑如果你现在正在使用它,你不可能轻易的卸载它。如果不能将它从系统中轻易的卸载,那么你还是考虑今后怎样升级它,但是不要感到很惊慌。我不会拒绝在一个使用RC4算法来加密SSL连接的网站购买东西,但是如果我现在要新建一个系统,那么我会考虑使用其他的算法,例如:AES。

    对于下面两个算法MD5-RSA和SHA1-DSA,他们是用于数字签名的。但是不要使用MD5,因为它有很多缺陷。很多年前大家就知道MD5中存在漏洞,不过直到今年夏天才破解出来。我们可以将SHA1和RSA或DSA配合在一起使用,目前DSA的密钥位数高达1024位,这个密钥位数已经足够长了,因此不需要担心安全问题。然而,如果NIST实现了更长的密钥位数当然更好。

    X.509证书是一个数据结构,常用于规定比特和字节的顺序,它本身不是一个密码系统。它通常包含一个RSA密钥,也可能包含一个DSA密钥。但是X.509证书内部以及证书本身并不是加密技术。对称加密和不对称加密原理
    私钥加密(对称加密 symmetric cryptography):私钥加密算法使用单个私钥来加密和解密数据。由于具有密钥的任意一方都可以使用该密钥解密数据,因此必须保护密钥不被未经授权的代理得到。私钥加密又称为对称加密,因为同一密钥既用于加密又用于解密。私钥加密算法非常快(与公钥算法相比),特别适用于对较大的数据流执行加密转换。Well-known secret key cryptographic algorithms include the Data Encryption Standard (DES), triple-strength DES (3DES), Rivest Cipher 2 (RC2), and Rivest Cipher 4 (RC4).

    通常,私钥算法(称为块密码)用于一次加密一个数据块。块密码(如 RC2、DES、TripleDES 和 Rijndael)通过加密将 n 字节的输入块转换为加密字节的输出块。如果要加密或解密字节序列,必须逐块进行。由于 n 很小(对于 RC2、DES 和 TripleDES,n = 8 字节;n = 16 [默认值];n = 24;对于 Rijndael,n = 32),因此必须对大于 n 的数据值一次加密一个块。
    基类库中提供的块密码类使用称作密码块链 (CBC) 的链模式,它使用一个密钥和一个初始化向量 (IV) 对数据执行加密转换。对于给定的私钥k,一个不使用初始化向量的简单块密码将把相同的明文输入块加密为同样的密文输出块。如果在明文流中有重复的块,那么在密文流中将存在重复的块。如果未经授权的用户知道有关明文块的结构的任何信息,就可以使用这些信息解密已知的密文块并有可能发现您的密钥。若要克服这个问题,可将上一个块中的信息混合到加密下一个块的过程中。这样,两个相同的明文块的输出就会不同。由于该技术使用上一个块加密下一个块,因此使用了一个 IV 来加密数据的第一个块。使用该系统,未经授权的用户有可能知道的公共消息标头将无法用于对密钥进行反向工程。

    可以危及用此类型密码加密的数据的一个方法是,对每个可能的密钥执行穷举搜索。根据用于执行加密的密钥大小,即使使用最快的计算机执行这种搜索,也极其耗时,因此难以实施。使用较大的密钥大小将使解密更加困难。虽然从理论上说加密不会使对手无法检索加密的数据,但这确实极大增加了这样做的成本。如果执行彻底搜索来检索只在几天内有意义的数据需要花费三个月的时间,那么穷举搜索的方法是不实用的。
    私钥加密的缺点是它假定双方已就密钥和 IV 达成协议,并且互相传达了密钥和 IV 的值。并且,密钥必须对未经授权的用户保密。由于存在这些问题,私钥加密通常与公钥加密一起使用,来秘密地传达密钥和 IV 的值。

    最早、最著名的保密密钥或对称密钥加密算法DES(Data Encryption Standard)/DESede是由IBM公司在70年代发展起来的,并经政府的加密标准筛选后,于1976年11月被美国政府采用,DES随后被美国国家标准局和美国国家标准协会(American National Standard Institute,ANSI)承认。DES使用56位密钥对64位的数据块进行加密,并对64位的数据块进行16轮编码。与每轮编码时,一个48位的"每轮"密钥值由56位的完整密钥得出来。

    .NET 提供以下实现类以提供对称的密钥加密算法:
    • DESCryptoServiceProvider

    • RC2CryptoServiceProvider

    • RijndaelManaged

    • TripleDESCryptoServiceProvider

    公钥加密(不对称加密, RSA, DSA, DH asymmetric cryptography ):公钥加密使用一个必须对未经授权的用户保密的私钥和一个可以对任何人公开的公钥。公钥和私钥都在数学上相关联;用公钥加密的数据只能用私钥解密,而用私钥签名的数据只能用公钥验证。公钥可以提供给任何人;公钥用于对要发送到私钥持有者的数据进行加密。两个密钥对于通信会话都是唯一的。公钥加密算法也称为不对称算法,原因是需要用一个密钥加密数据而需要用另一个密钥来解密数据。对称算法的根本原理就是单向函数,f(a)=b,但是用b很难得到a。
    公钥加密算法使用固定的缓冲区大小,而私钥加密算法使用长度可变的缓冲区。公钥算法无法像私钥算法那样将数据链接起来成为流,原因是它只可以加密少量数据。因此,不对称操作不使用与对称操作相同的流模型。

    双方(小红和小明)可以按照下列方式使用公钥加密。首先,小红生成一个公钥/私钥对。如果小明想要给小红发送一条加密的消息,他将向她索要她的公钥。小红通过不安全的网络将她的公钥发送给小明,小明接着使用该密钥加密消息。(如果小明在不安全的信道如公共网络上收到小红的密钥,则小明必须同小红验证他具有她的公钥的正确副本。)小明将加密的消息发送给小红,而小红使用她的私钥解密该消息。
    但是,在传输小红的公钥期间,未经授权的代理可能截获该密钥。而且,同一代理可能截获来自小明的加密消息。但是,该代理无法用公钥解密该消息。该消息只能用小红的私钥解密,而该私钥没有被传输。小红不使用她的私钥加密给小明的答复消息,原因是任何具有公钥的人都可以解密该消息。如果小红想要将消息发送回小明,她将向小明索要他的公钥并使用该公钥加密她的消息。然后,小明使用与他相关联的私钥来解密该消息。

    在一个实际方案中,小红和小明使用公钥(不对称)加密来传输私(对称)钥,而对他们的会话的其余部分使用私钥加密(由于对称加密快捷,用于实际的数据加密,而利用不对称加密的方式解决对称加密中私钥传递的不安全性,此为对称和不对称加密结合的加密方式)。
    公钥加密具有更大的密钥空间(或密钥的可能值范围),因此不大容易受到对每个可能密钥都进行尝试的穷举攻击。由于不必保护公钥,因此它易于分发。公钥算法可用于创建数字签名以验证数据发送方的身份。但是,公钥算法非常慢(与私钥算法相比),不适合用来加密大量数据。公钥算法仅对传输很少量的数据有用。公钥加密通常用于加密一个私钥算法将要使用的密钥和 IV。传输密钥和 IV 后,会话的其余部分将使用私钥加密。

    RSA系统是诸多此类算法中最著名、最多使用的一种。RSA公开密钥密码系统是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是来自于这三位发明者的姓的第一个字母RSA(Rivest-Shamir-Adleman)算法是基于大数不可能被质因数分解假设的公钥体系。简单地说就是找两个很大的质数。一个对外公开的为“公钥”(Prblic key) ,另一个不告诉任何人,称为"私钥”(Private key)。这两个密钥是互补的,也就是说用公钥加密的密文可以用私钥解密,反过来也一样。

    公钥的传输:要启动安全通讯,通信两端必须首先得到相同的共享密钥(主密钥),但共享密钥不能通过网络相互发送,因为这种做法极易泄密。Diffie-Hellman算法是用于密钥交换的最早最安全的算法之一。

    RSA算法:RSA算法是基于大数难于分解的原理。不但可以用于认证,也可以用于密钥传输,例子可以参考RSAUtil.java文件。那么用户A和B如何利用RSA算法来传输密钥呢?

    1:A产生一个密钥K,用B的公钥加密K,然后将得到的密文发送给B。

    2:B用自己的私钥解密收到的密钥,就可以得到密钥。

    DH算法:DH算法的出现就是用来进行密钥传输的。DH算法是基于离散对数实现的。DH算法的基本工作原理是:通信双方公开或半公开交换一些准备用来生成密钥的"材料数据",在彼此交换过密钥生成"材料"后,两端可以各自生成出完全一样的共享密钥。在任何时候,双方都绝不交换真正的密钥。通信双方交换的密钥生成"材料",长度不等,"材料"长度越长,所生成的密钥强度也就越高,密钥破译就越困难。除进行密钥交换外,IPSec还使用DH算法生成所有其他加密密钥。

    在通信前,用户A和B双方约定2个大整数n和g,其中1<g<n,这两个整数可以公开

    1. A随机产生一个大整数a,然后计算Ka=ga mod n(a需要保密)

    2. B随机产生一个大整数b,然后计算Kb=gb mod n(b需要保密)

    3. A把Ka发送给B,B把Kb发送给A

    4. A计算K=Kba mod n

    5. B计算K=Kab mod n

    由于Kba mod n= (gb mod n)a mod n= (ga mod n)b mod n,因此可以保证双方得到的K是相同的,K即是共享的密钥。可以参考JCE文档中的DH 3 party的例子。

    实际的一个用DH算法传递DES私钥的JAVA例子参看“JAVA上加密算法的实现用例”一文中的末一个例子,过程如下:假设A和B通信(JCE中只支持DH算法作为传递私钥的算法)

    A利用KeyPairGenerator类生成一个钥对类KeyPair并可通过generatePublic方法产生公钥PublicKey(puA)和getPrivate方法私钥PrivateKey(prA)。A把puA发给B。B用类X509EncodedKeySpec解码,然后利用KeyFactory类生成puA,转换成DHPublicKey类利用其getParams方法取得参数类DHParameterSpec,B再利用此参数类,通过KeyPairGenerator类的initialize方法生成KeyPairGenerator实例从而用generateKeyPair方法生成B的KeyPair。进而B生成puB和prB,B把puB发给A。A利用puB和prA作为参数,分别调用KeyAgreement类的init和doPhase方法初始化,然后用generateSecret方法生成各自的DES的密钥SecretKey,此密钥是相同的,即可用Cipher类进行加解密了。

    .NET 通过抽象基类 (System.Security.Crytography.AsymmetricAlgorithm) 提供下列非对称(公钥/私钥)加密算法:
    • DSACryptoServiceProvider

    • RSACryptoServiceProvider

    数字签名
    公钥算法还可用于构成数字签名。数字签名验证发送方的身份(如果您信任发送方的公钥)并帮助保护数据的完整性。

    为了使用公钥加密对消息进行数字签名,小红首先将哈希算法应用于该消息以创建消息摘要。该消息摘要是数据的紧凑且唯一的表示形式。然后,小红用她的私钥加密该消息摘要以创建她的个人签名。在收到消息和签名时,小明使用小红的公钥解密签名以恢复消息摘要,并使用与小红所使用的相同的哈希算法来散列消息。如果小明计算的消息摘要与从小红那里收到的消息摘要完全一致,小明就可以确定该消息来自私钥的持有人,并且数据未被修改过。如果小明相信小红是私钥的持有人,则他知道该消息来自小红。

    请注意,由于发送方的公钥为大家所周知,并且它通常包含在数字签名格式中,因此任何人都可以验证签名。此方法不保守消息的机密;若要使消息保密,还必须对消息进行加密。

    .NET Framework 提供以下实现数字签名算法的类:

    DSACryptoServiceProvider
    RSACryptoServiceProvider

    CA证书 Public Key Certificates(参考这里)

    A public key certificate provides a safe way for an entity to pass on its public key to be used in asymmetric cryptography. The public key certificate avoids the following situation: if Charlie creates his own public key and private key, he can claim that he is Alice and send his public key to Bob. Bob will be able to communicate with Charlie, but Bob will think that he is sending his data to Alice.

    A public key certificate can be thought of as the digital equivalent of a passport. It is issued by a trusted organization and provides identification for the bearer. A trusted organization that issues public key certificates is known as a certificate authority (CA). The CA can be likened to a notary public. To obtain a certificate from a CA, one must provide proof of identity. Once the CA is confident that the applicant represents the organization it says it represents, the CA signs the certificate attesting to the validity of the information contained within the certificate.

    A public key certificate contains several fields, including:

    Issuer - The issuer is the CA that issued the certificate. If a user trusts the CA that issues a certificate, and if the certificate is valid, the user can trust the certificate.

    Period of validity - A certificate has an expiration date, and this date is one piece of information that should be checked when verifying the validity of a certificate.

    Subject - The subject field includes information about the entity that the certificate represents.

    Subject’s public key - The primary piece of information that the certificate provides is the subject’s public key. All the other fields are provided to ensure the validity of this key.

    Signature - The certificate is digitally signed by the CA that issued the certificate. The signature is created using the CA’s private key and ensures the validity of the certificate. Because only the certificate is signed, not the data sent in the SSL transaction, SSL does not provide for non-repudiation.
    If Bob only accepts Alice’s public key as valid when she sends it in a public key certificate, Bob will not be fooled into sending secret information to Charlie when Charlie masquerades as Alice.

    Multiple certificates may be linked in a certificate chain. When a certificate chain is used, the first certificate is always that of the sender. The next is the certificate of the entity that issued the sender’s certificate. If there are more certificates in the chain, each is that of the authority that issued the previous certificate. The final certificate in the chain is the certificate for a root CA. A root CA is a public certificate authority that is widely trusted. Information for several root CAs is typically stored in the client’s Internet browser. This information includes the CA’s public key. Well-known CAs include VeriSign, Entrust, and GTE CyberTrust.

    哈希值
    哈希算法将任意长度的二进制值映射为固定长度的较小二进制值,这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希计算都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的。

    消息身份验证代码 (MAC) 哈希函数通常与数字签名一起用于对数据进行签名,而消息检测代码 (MDC) 哈希函数则用于数据完整性。

    双方(小红和小明)可按下面的方式使用哈希函数来确保数据的完整性。如果小红对小明编写一条消息并创建该消息的哈希,则小明可以在稍后散列该消息并将他的哈希与原始哈希进行比较。如果两个哈希值相同,则该消息没有被更改;如果值不相同,则该消息在小红编写它之后已被更改。为了使此系统发挥作用,小红必须对除小明外的所有人保密原始的哈希值。

    When sending encrypted data, SSL typically uses a cryptographic hash function to ensure data integrity. The hash function prevents Charlie from tampering with data that Alice sends to Bob.

    A cryptographic hash function is similar to a checksum. The main difference is that while a checksum is designed to detect accidental alterations in data, a cryptographic hash function is designed to detect deliberate alterations. When data is processed by a cryptographic hash function, a small string of bits, known as a hash, is generated. The slightest change to the message typically makes a large change in the resulting hash. A cryptographic hash function does not require a cryptographic key. Two hash functions often used with SSL are Message Digest 5 (MD5) and Secure Hash Algorithm (SHA). SHA was proposed by the US National Institute of Science and Technology (NIST).

    Message Authentication Code: A message authentication code (MAC) is similar to a cryptographic hash, except that it is based on a secret key. When secret key information is included with the data that is processed by a cryptographic hash function, the resulting hash is known as an HMAC.
    If Alice wants to be sure that Charlie does not tamper with her message to Bob, she can calculate an HMAC for her message and append the HMAC to her original message. She can then encrypt the message plus the HMAC using a secret key she shares with Bob. When Bob decrypts the message and calculates the HMAC, he will be able to tell if the message was modified in transit. With SSL, an HMAC is used with the transmission of secure data.

    .NET Framework 提供以下实现数字签名算法的类:

    HMACSHA1
    MACTripleDES
    MD5CryptoServiceProvider
    SHA1Managed
    SHA256Managed
    SHA384Managed
    SHA512Managed

    摘要函数(MD2、MD4和MD5,还有SHA1等算法(产生一个20字节的二进制数组))
    摘要是一种防止改动的方法,其中用到的函数叫摘要函数。这些函数的输入可以是任意大小的消息,而输出是一个固定长度的摘要。摘要有这样一个性质,如果改变了输入消息中的任何东西,甚至只有一位,输出的摘要将会发生不可预测的改变,也就是说输入消息的每一位对输出摘要都有影响。总之,摘要算法从给定的文本块中产生一个数字签名(fingerprint或message digest),数字签名可以用于防止有人从一个签名上获取文本信息或改变文本信息内容。摘要算法的数字签名原理在很多加密算法中都被使用,如S/KEY和PGP(pretty good privacy)。

    现在流行的摘要函数有MD4和MD5。MD2摘要算法的设计是出于下面的考虑:利用32位RISC结构来最大其吞吐量,而不需要大量的替换表(substitution table)。MD4算法将消息的给予对长度作为输入,产生一个128位的"指纹"或"消息化"。要产生两个具有相同消息化的文字块或者产生任何具有预先给定"指纹"的消息,都被认为在计算上是不可能的。MD5摘要算法是个数据认证标准。MD5的设计思想是要找出速度更快但更不安全的MD4中潜在的不安全,MD5的设计者通过使MD5在计算上慢下来,以及对这些计算做了一些基础性的改动来解决这个问题。MD5在RFC1321中给出文档描述,是MD4算法的一个扩展。美国国家标准技术研究所的SHA1和麻省理工学院Ronald Rivest提出的MD5是为代表。HMAC-MD5算法(消息摘要5)基于RFC1321。MD5对MD4做了改进,计算速度比MD4稍慢,但安全性能得到了进一步改善。MD5在计算中使用了64个32位常数,最终生成一个128位的完整性检查和。

    HMAC-SHA算法:安全Hash算法定义在NIST FIPS 180-1,其算法以MD5为原型。SHA在计算中使用了79个32位常数,最终产生一个160位完整性检查和。SHA检查和长度比MD5更长,因此安全性也更高。

    随机数生成
    随机数生成是许多加密操作不可分割的组成部分。例如,加密密钥需要尽可能地随机,以便使生成的密钥很难再现。加密随机数生成器必须生成无法以计算方法推算出(低于 p < .05 的概率)的输出;即,任何推算下一个输出位的方法不得比随机猜测具有更高的成功概率。.NET Framework 中的类使用随机数生成器生成加密密钥。

    在商务领域的应用

    许多人都知道NETSCAPE公司是Internet商业中领先技术的提供者,该公司提供了一种基于RSA和保密密钥的应用于因特网的技术,被称为安全插座层(Secure Sockets Layer,SSL)。

    也许很多人知道Socket,它是一个编程界面,并不提供任何安全措施,而SSL不但提供编程界面,而且向上提供一种安全的服务,SSL3.0现在已经应用到了服务器和浏览器上,SSL2.0则只能应用于服务器端。

    SSL3.0用一种电子证书(electric certificate)来实行身份进行验证后,双方就可以用保密密钥进行安全的会话了。它同时使用“对称”和“非对称”加密方法,在客户与电子商务的服务器进行沟通的过程中,客户会产生一个Session Key,然后客户用服务器端的公钥将Session Key进行加密,再传给服务器端,在双方都知道Session Key后,传输的数据都是以Session Key进行加密与解密的,但服务器端发给用户的公钥必需先向有关发证机关申请,以得到公证。

    基于SSL3.0提供的安全保障,用户就可以自由订购商品并且给出信用卡号了,也可以在网上和合作伙伴交流商业信息并且让供应商把订单和收货单从网上发过来,这样可以节省大量的纸张,为公司节省大量的电话、传真费用。在过去,电子信息交换(Electric Data Interchange,EDI)、信息交易(information transaction)和金融交易(financial transaction)都是在专用网络上完成的,使用专用网的费用大大高于互联网。正是这样巨大的诱惑,才使人们开始发展因特网上的电子商务,但不要忘记数据加密。

    SSL(Secure Sockets Layer) or TSL (Transport Layer Security)

    Secure Sockets Layer (SSL) is the most widely used protocol for implementing cryptography on the Web. SSL uses a combination of cryptographic processes to provide secure communication over a network. This section provides an introduction to SSL and the cryptographic processes it uses.

    SSL provides a secure enhancement to the standard TCP/IP sockets protocol used for Internet communications. As shown in the “TCP/IP Protocol Stack With SSL” figure below, the secure sockets layer is added between the transport layer and the application layer in the standard TCP/IP protocol stack. The application most commonly used with SSL is Hypertext Transfer Protocol (HTTP), the protocol for Internet Web pages.

    SSL was developed by Netscape in 1994, and with input from the Internet community, has evolved to become a standard. It is now under the control of the international standards organization, the Internet Engineering Task Force (IETF). The IETF has renamed SSL to Transport Layer Security (TLS), and released the first specification, version 1.0, in January 1999. TLS 1.0 is a modest upgrade to the most recent version of SSL, version 3.0. The differences between SSL 3.0 and TLS 1.0 are minor.

    One of the reasons SSL is effective is that it uses several different cryptographic processes. SSL uses public key cryptography to provide authentication, and secret key cryptography and digital signatures to provide for privacy and data integrity. Before you can understand SSL, it is helpful to understand these cryptographic processes.

    常用算法比较

    数据加密标准(DES)是一个古老的对称密钥加密算法,目前已经不再使用。它不是一个很安全的算法。

    三重DES(Triple-DES)仍然是很安全的,但是也只是在别无他法的情况下的一个较好的选择。显然高级加密标准(AES)是一个更好的加密算法,NIST用AES代替Triple-DES作为他们的标准(下面有更详细的讨论)。其他较好的算法包括另外两个AES的变种算法Twofish和Serpent-也称为CAST-128,它是效率和安全的完美结合。这几个算法不仅比DES更安全,而且也比DES的速度更快。为什么要使用一些又慢又不安全的算法呢

    SHA1是一个哈希函数,而不是一个加密函数。作为一个哈希函数,SHA1还是相当优秀的,但是还需要几年的发展才能用作加密算法。如果你正在设计一个新系统,那么谨记你可能会在若干年后用SHA1代替目前的算法。我再重复一遍:只是可能。

    RSA是一个公开密钥加密算法。RSA的密钥长度一般为2048-4096位。如果你现在的系统使用的是1024位的公开密钥,也没有必要担心,但是你可以加长密钥长度来达到更好的加密效果。

    高级加密标准(AES)是一个用来代替数据加密标准(DES)的算法。目前使用的一般为128,196和256位密钥,这三种密钥都是相当安全的。而且美国政府也是这样认为的。他们批准将128位密钥的AES算法用于一般数据加密,196位和256位密钥的AES算法用于秘密数据和绝密数据的加密。

    DESX是DES的一个改进版本。DESX的原理是利用一个随机的二进制数与加密前的数据以及解密后的数据异或。虽然也有人批评这种算法,但是与DES相比DESX确实更安全,不过DESX在许多情况下并不适用。我曾经处理过一个硬件支持DES的系统,由于有些环节不能容忍三重DES的慢速,我们在这些地方使用了DESX来代替DES。然而,这是一个非常特殊的情况。如果你需要使用DESX,理由显而易见(可能和我不得不使用DESX的原因类似)。但我建议你使用AES或者上面我提到的一些算法。

    RC4是一种常用于SSL连接的数据流加密算法。它已经出现很多年了,而且有很多已知和可能的缺陷,因此在一些新的工程中不要使用它。如果你目前正在使用它而且可以轻易的卸载它,那么情况也不是很坏。不过,我怀疑如果你现在正在使用它,你不可能轻易的卸载它。如果不能将它从系统中轻易的卸载,那么你还是考虑今后怎样升级它,但是不要感到很惊慌。我不会拒绝在一个使用RC4算法来加密SSL连接的网站购买东西,但是如果我现在要新建一个系统,那么我会考虑使用其他的算法,例如:AES。

    对于下面两个算法MD5-RSA和SHA1-DSA,他们是用于数字签名的。但是不要使用MD5,因为它有很多缺陷。很多年前大家就知道MD5中存在漏洞,不过直到今年夏天才破解出来。我们可以将SHA1和RSA或DSA配合在一起使用,目前DSA的密钥位数高达1024位,这个密钥位数已经足够长了,因此不需要担心安全问题。然而,如果NIST实现了更长的密钥位数当然更好。

    X.509证书是一个数据结构,常用于规定比特和字节的顺序,它本身不是一个密码系统。它通常包含一个RSA密钥,也可能包含一个DSA密钥。但是X.509证书内部以及证书本身并不是加密技术。

    转自:https://www.cnblogs.com/lvdongjie/p/4241107.html

    展开全文
  • 对称加密和非对称加密详解

    千次阅读 2018-09-01 18:33:57
    数据加密算法主要分为两大类:对称加密和非对称加密 下面我们来看一下他们的区别的各自的作用   下面详细介绍两种加密方式的具体过程 (1)交易加密或者区块加密(对称加密) 为了让区块链中的交易信息或者...
  • 对称加密和非对称加密的区别

    万次阅读 多人点赞 2018-08-13 17:53:37
    非对称加密:与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)私有密钥(privatekey)。 对称加密算法: 密钥较短,破译困难,除了数据加密标准(DES),另一个对称密钥加密系统是国际数据...
  • 对称加密和非对称加密总结

    千次阅读 2016-08-04 14:17:19
    对称加密含义:对称加密是最快速、最简单的一种加密方式,加密(encryption)与解密...非对称加密含义:非对称加密为数据的加密与解密提供了一个非常安全的方法,它使用了一对密钥,公钥(public key)私钥(pr
  • 对称加密和非对称加密的区别以及应用。了解哪些常用的加密算法?能简单介绍一种吗? 内推军P186 P192 1.分类 加密算法首先分为两种:单向加密、双向加密。 单向加密是不可逆的,也就是只能加密,不能解密。通常...
  • 也就是密钥也可以用作解密密钥,这种方法在密码学中叫做对称加密算法,对称加密算法使用起来简单快捷,密钥较短,且破译困难,除了数据加密标准(DES),另一个对称密钥加密系统是国际数据加密算法(IDEA),它比DES...
  • 对称加密和非对称加密的比较

    千次阅读 2015-03-16 09:54:49
    对称加密和非对称加密的比较
  • AES 对称加密对加密数据没有长度限制 RSA 非对称加密对加密数据有长度限制(128字节)
  • 首先说明一下对称加密和非对称加密的概念。 对称加密: 采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密解密,这种加密方法称为对称加密,也称为单密钥加密。 非对称加密: 非对称加密算法需要...
  • 模型量化-对称量化和非对称量化

    千次阅读 2021-03-07 14:19:06
    本文的模型量化是优化深度学习模型推理过程的内存容量内存带宽问题的概念,通过将模型参数的浮点数类型转换称整型存储的一种模型压缩技术。以可以接受的精度损失换取更少的存储开销带宽需求,更快的计算速度,更...
  • 对称数据加密技术

    千次阅读 2017-04-01 09:51:48
    对称数据加密技术是当前应用最广泛、使用频率最高的加密技术,对称加密算法是双向可逆的,加密密钥解密密钥相同是最大的特点。对称加密算法由古典加密算法演变而来,大部分加密算法的解密算法是逆运算。特点对称...
  • 非对称加密算法: 加密解密使用不同的密钥。公钥只能用来加密,而私钥只能用来解密。私钥由用户自己拥有。公钥公开配送,只要需求即可获得。 优点: 算法安全性高,公钥公开,私钥自己保存 缺点: 加密...
  • 对称加密和非对称加密!

    千次阅读 2011-03-03 11:13:00
    主要是对称加密和非对称加密两种。可供各位参考: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Security.Cryptography; using System.IO; namespace ...
  • 加密方式两种:对称加密 非对称加密 对称加密 原理: 加密算法是公开的,靠的是密钥来加密数据,使用一个密钥加密,必须使用相同的密钥才解密。 常用的对称加密算法: DES、3DES、AES 优点: 计算...
  • Android安全-对称加密和非对称加密

    千次阅读 2016-01-07 19:31:44
    秘钥:分为加密秘钥解密秘钥 明文:没有进行加密,能够直接代表原文含义的信息 密文:经过加密处理之后,隐藏原文含义的信息 加密:将明文转换为密文的过程 解密:将密文转换为明文...RSA:非对称加密,公钥私钥
  • 对称加密和非对称加密的详细说明

    千次阅读 2018-12-17 09:55:57
    对计算机而言,信息表现为各种各样的数据,是否采用了适当的方法对数据进行加密,已成为保障数据安全的首要方法。为了保密,一般在网络上传输的重要数据文件都可以对其进行加密,但数据加密也不一定是为了在网络间...
  • 众所周知,WEB服务存在httphttps两种通信方式,http默认采用80作为通讯端口,对于传输采用不加密的方式,https默认采用443,对于传输的数据进行加密传输 目前主流的网站基本上开始默认采用HTTPS作为通信方式,...
  • 对称加密和非对称加密(一)初步理解

    万次阅读 多人点赞 2018-12-26 23:23:21
    先查大范围 专业术语 再查小范围 便于... 从而出现了:对称加密和非对称加密。 二、对称加密和非对称加密 1. 对称加密 对称加密指的就是加密解密使用同一个秘钥,所以叫做对称加密。对称加密只有一个秘钥,...
  • 对称加密和非对称加密介绍区别

    千次阅读 2017-11-13 11:42:18
    它的特点是文件加密解密使用相同的密钥,即加密密钥也可以用作解密密钥,这种方法在密码学中叫做对称加密算法,对称加密算法使用起来简单快捷,密钥较短,且破译困难,除了数据加密标准(DES),另一个对称密钥...
  • java对称加密与非对称加密

    万次阅读 2017-11-26 22:25:49
    java对称加密与非对称加密加密...非对称加密为数据的加密与解密提供了一个非常安全的方法,它使用了一对密钥,公钥(public key)私钥(private key)。私钥只能由一方安全保管,不能外泄,而公钥则可以发给任何请
  • 对称加密算法中,数据发信方将明文(原始数据加密密钥(mi yue)一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。常用的对称加密算法:AES,RC4,3DES传输的示意图如下所示:如上图所示,此种...
  • 在该保存方法中,只有数据的接收者需要进行数据的读取处理。 “加密是密码学的核心概念,以“除了接收者以外谁都无法解密”的方式对消息进行编码。 其他人无法理解信息格式,因此可以防止数据被窃听者窃听” ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 217,167
精华内容 86,866
关键字:

对称数据和非对称数据有哪些