加密算法

为了保护信息安全，在如今数据流动频繁的当今我们往往会对数据进行加密。在学习的过程中做了一些整理归纳。

加密概要

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法。加密算法主要分为摘要算法（不可逆算法）、对称算法以及非对称算法。

摘要算法

摘要算法是一个不可逆过程，就是无论多大数据，经过算法运算后都是生成固定长度的数据,一般结果使用16进制进行显示。 常用的摘要算法有MD5，SHA1。

MD5和SHA1的区别：MD5结果是128位摘要，SHa1是160位摘要。可以看出MD5的速度更快，而SHA1的强度更高。

下面统一使用MD5算法进行说明，SHA1类似。

主要用途有：验证消息完整性，安全访问认证，数据签名。

消息完整性：由于每一份数据生成的MD5值不一样，因此发送数据时可以将数据和其MD5值一起发送，然后就可以用MD5验证数据是否丢失、修改。

安全访问认证：这是使用了算法的不可逆性质，（就是无法从MD5值中恢复原数据）对账号登陆的密码进行MD5运算然后保存，这样可以保证除了用户之外，即使数据库管理人员都无法得知用户的密码。

数字签名：这是结合非对称加密算法和CA证书的一种使用场景。

一般破解方法：字典法，就是将常用密码生成MD5值字典，然后反向查找达到破解目的，因此建议使用强密码。

http://www.cmd5.com/

此站点针对md5、sha1等全球通用公开的加密算法进行反向查询，通过穷举字符组合的方式，创建了明文密文对应查询数据库，创建的记录约90万亿条，占用硬盘约450TB，查询成功率95%以上。

 MD5

MD5 即 Message Digest Algorithm5 (信息摘要算法5),一种数字摘要的实现，摘要长度为128位，由MD4,MD3,MD2改进而来，主要增强了算法复杂度和不可逆性。

基于Java 的MD5算法使用：

public static String md5(String content) throws Exception{

    MessageDigest md = MessageDigest.getInstance("MD5");

    byte[] bytes =md.digest(content.getBytes("utf-8"));

    String md5Str = new BigInteger(1,bytes).toString(16);//16进制编码后

    return md5Str;

}

SHA

SHA 全称是Secure Hash Algorithm（安全散列算法）,1995年又发布了一个修订版FIPS PUB 180-1 通常称之为SHA-1，是基于MD4算法。是现在公认的最安全的散列算法之一，被广泛使用。

比较MD5: SHA-1算法生成的摘要信息长度为160位，由于摘要信息更长，运算过程更加复杂，相同的硬件上，SHA-1比 MD5更慢，但是更为安全。

基于Java 的SHA算法使用：

public static String sha(String content) throws Exception{

    MessageDigest md = MessageDigest.getInstance("SHA-1");

    byte[] bytes =md.digest(content.getBytes("utf-8"));

    String shaStr = new BigInteger(1, bytes).toString(16);//16进制编码后

    return shaStr;

}

彩虹表破解Hash算法

彩虹表（Rainbow Table）法是一种破解哈希算法的技术，从原理上来说能够对任何一种Hash算法进行攻击。简单说，彩虹表就是一张采用各种Hash算法生成的明文和密文的对照表。本文不做赘述，详细内容可参考：

http://www.aiezu.com/system/windows/rainbow-table_knowledge.html

运行示例

public static void main(String[] args) throws Exception {

    String content = "hello,world!";

    System.out.println("原文："+content);

    System.out.println("MD5:"+md5(content));

    System.out.println("SHA:"+sha(content));

}

输出

原文：hello,world!

MD5:c0e84e870874dd37ed0d164c7986f03a

SHA:4518135c05e0706c0a34168996517bb3f28d94b5

对称加密算法

 对称加密算法：对加密和解密使用相同密钥的加密算法。由于其速度，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。

加密过程： 

将明文分成N个组，然后对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。

优点： 

算法公开、计算量小、加密速度快、加密效率高

缺点： 

交易双方都使用同样钥匙，安全性得不到保证

密钥管理困难，尤其是在分布式网络中

常用算法： 

DES、3DES（Triple DES）、AES、RC2、RC4、RC5和Blow fish

DES算法

DES算法属于对称加密算法，一共有三个参数入口（原文，密钥，加密模式）。明文按64位进行分组，密钥长64位，事实上只有56位参与DES运算（第8, 16, 24, 32, 40, 48, 56, 64位是校验位，使得每个密钥都有奇数个1)，分组后的明文和56位的密钥按位替代或交换的方法形成密文。

3DES： 是DES向AES过渡的加密算法，使用3条56位的密钥对数据进行3次加密。

基于Java的DES 算法的使用

	/**
	 * 生成DES 密钥
	 */
	public static SecretKey loadKeyDES() throws Exception{
		KeyGenerator keyGen = KeyGenerator.getInstance("DES");
		keyGen.init(56);
		SecretKey key = keyGen.generateKey();
		String base64Key = byte2base64(key.getEncoded());
		byte[] bytes = base642byte(base64Key);
		key = new SecretKeySpec(bytes,"DES");
		return key;
	}
	//DES加密
	public static byte[] encryptDES(byte[] source,SecretKey key) throws Exception{
		Cipher cipher = Cipher.getInstance("DES");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.ENCRYPT_MODE, key);
		// 现在，获取数据并加密
		byte[] bytes = cipher.doFinal(source);
		return bytes;
	}
	//DES解密
	public static byte[] decryptDES(byte[] source,SecretKey key) throws Exception{
		Cipher cipher = Cipher.getInstance("DES");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.DECRYPT_MODE, key);
		// 真正开始解密操作
		byte[] bytes = cipher.doFinal(source);
		return bytes;
	}
	
	
	public static void main(String[] args) throws Exception {
		String context = "Hello,World!";
　　　　　　　　　 // 密钥
		SecretKey key = loadKeyDES();
		
		byte[] encryptBytes = encryptDES(context.getBytes(),key);
		System.out.println("加密后:"+new String(encryptBytes));
		
		byte[] decryptBytes = decryptDES(encryptBytes,key);
		System.out.println("解密后:"+new String(decryptBytes));
	}

运行结果如下：

加密后:���9�iP�ﱹp
解密后:Hello,World!

 AES算法

AES算法 全称是Advanced Encryption Standard，即高级加密标准，又称为Rijndael加密算法，是美国联邦政府采用的一种对称加密标准，这个标准用来替代原先的DES算法，目前已成为对称加密算法中最流行的算法之一。

对比DES算法，AES算法作为新一代的数据加密标准，汇聚了强安全性、高性能、高效率、易用和灵活等优点，设计有三个密钥长度（128，192，256位），比DES算法加密强度更高，更加安全。

基于Java的AES算法：

　　　　　/**
	 * 生成AES 密钥
	 */
	public static SecretKey loadKeyAES() throws Exception{
		KeyGenerator keyGen = KeyGenerator.getInstance("AES");
		keyGen.init(128);//DES为56
		SecretKey key = keyGen.generateKey();
		String base64Key = byte2base64(key.getEncoded());
		byte[] bytes = base642byte(base64Key);
		key = new SecretKeySpec(bytes,"AES");
		return key;
	}
	//AES加密
	public static byte[] encryptAES(byte[] source,SecretKey key) throws Exception{
		Cipher cipher = Cipher.getInstance("AES");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.ENCRYPT_MODE, key);
		// 现在，获取数据并加密
		byte[] bytes = cipher.doFinal(source);
		return bytes;
	}
	//AES解密
	public static byte[] decryptAES(byte[] source,SecretKey key) throws Exception{
		Cipher cipher = Cipher.getInstance("AES");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.DECRYPT_MODE, key);
		// 真正开始解密操作
		byte[] bytes = cipher.doFinal(source);
		return bytes;
	}
	
	
	public static void main(String[] args) throws Exception {
		String context = "Hello,World!";
		SecretKey key = loadKeyAES();
		
		byte[] encryptBytes = encryptAES(context.getBytes(),key);
		System.out.println("加密后:"+new String(encryptBytes));
		
		byte[] decryptBytes = decryptAES(encryptBytes,key);
		System.out.println("解密后:"+new String(decryptBytes));
	}

运行结果如下：

加密后:T�l�X���2�zEO�
解密后:Hello,World!

 

非对称加密算法

非对称加密算法：又称为公开密钥加密算法，需要两个密钥，一个为公开密钥(PublicKey）即公钥，一个为私有密钥（PrivateKey)即私钥。两者需要配对使用。用其中一者加密，则必须用另一者解密。

使用过程： 

乙方生成两把密钥（公钥和私钥）

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

乙方得到加密后的信息，用私钥解密，乙方也可用私钥加密字符串

甲方获取乙方私钥加密数据，用公钥解密

优点： 

更安全，密钥越长，它就越难破解

缺点： 

加密速度慢

常用算法： 

RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法)

RSA 算法

由于非对称加密的密钥生成麻烦，所以无法做到一次一密，而且其加密速度很慢，无法对大量数据加密。因此最常用的使用场景就是数字签名和密码传输，用作数字签名时使用私钥加密，公钥解密；用作加密解密时，使用公钥加密，私钥解密。

需要注意的是RSA加密是有长度限制的，1024位密钥可以加密128字节（1024位），不满128字节的使用随机数填充，但是RSA实现中必须要加随机数（11字节以上），所以明文长度最大为117字节，然后剩下的加入随机数。这也产生了每次加密结果每一次都不一样的特点。

如果明文长度超过限制怎么办？

1.可以与对称加密混合使用，一次一密产生对称加密的密钥，然后使用此密钥进行数据对称加密，再使用RSA私钥对对称密钥加密，一起保存。解密时使用公钥解密出密钥，然后进行数据解密。

2.可以分段加密。将明文按117字节分成多段，加密后再拼接起来。由于每一段密文长度都是128字节，所以解密时按照128字节分段解密。

java的RSA密钥生成与使用

下面是java中的使用方法，先是生成密钥对，然后加密，再解密。需要注意的是这个方法是不能跨语言使用的，因为里面对公钥和私钥用到的序列化是java的序列化。 由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。

public class RSAUtil {
    /** 指定加密算法为RSA */
    private static String ALGORITHM = "RSA";
    /*指定加密模式和填充方式*/
    private static String ALGORITHM_MODEL = "RSA/ECB/PKCS1Padding";
    /** 指定key的大小，一般为1024，越大安全性越高 */
    private static int KEYSIZE = 1024;
    /** 指定公钥存放文件 */
    private static String PUBLIC_KEY_FILE = "PublicKey";
    /** 指定私钥存放文件 */
    private static String PRIVATE_KEY_FILE = "PrivateKey";

    /**
     * 生成密钥对
     */
    private static void generateKeyPair() throws Exception {
        /** RSA算法要求有一个可信任的随机数源 */
        SecureRandom sr = new SecureRandom();
        /** 为RSA算法创建一个KeyPairGenerator对象 */
        KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
        /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
        kpg.initialize(KEYSIZE, sr);
        /** 生成密匙对 */
        KeyPair kp = kpg.generateKeyPair();
        /** 得到公钥 */
        Key publicKey = kp.getPublic();
        /** 得到私钥 */
        Key privateKey = kp.getPrivate();
        /** 用对象流将生成的密钥写入文件 */
        ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(
                PUBLIC_KEY_FILE));
        ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(
                PRIVATE_KEY_FILE));
        oos1.writeObject(publicKey);
        oos2.writeObject(privateKey);
        /** 清空缓存，关闭文件输出流 */
        oos1.close();
        oos2.close();
    }

    /**
     * 加密方法 source： 源数据
     */
    public static byte[] encrypt(String source) throws Exception {

        /** 将文件中的公钥对象读出 */
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                PUBLIC_KEY_FILE));
        Key key = (Key) ois.readObject();
        ois.close();
        /** 得到Cipher对象来实现对源数据的RSA加密 */
        Cipher cipher = Cipher.getInstance(ALGORITHM_MODEL);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] b = source.getBytes();
        /** 执行加密操作 */
        byte[] b1 = cipher.doFinal(b);
        return b1;
    }

    /**
     * 解密算法 cryptograph:密文
     */
    public static String decrypt(byte[] cryptograph) throws Exception {
        /** 将文件中的私钥对象读出 */
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                PRIVATE_KEY_FILE));
        Key key = (Key) ois.readObject();
        /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
        Cipher cipher = Cipher.getInstance(ALGORITHM_MODEL);
        cipher.init(Cipher.DECRYPT_MODE, key);
        /** 执行解密操作 */
        byte[] b = cipher.doFinal(cryptograph);
        return new String(b);
    }

    public static void main(String[] args) throws Exception {
        generateKeyPair();//生成密钥对
        String source = "Hello World!";// 要加密的字符串
        byte[] cryptograph = encrypt(source);// 生成的密文

        //可以将密文进行base64编码进行传输
        System.out.println(new String(Base64.encode(cryptograph)));

        String target = decrypt(cryptograph);// 解密密文
        System.out.println(target);
    }
}

RSA密钥使用Base64编码

要灵活使用肯定不能使用java的序列化保存了，我们对上面的generateKeyPair()方法进行改写。通过密钥生成器生成公钥，私钥后，调用publicKey.getEncoded()和privateKey.getEncoded()，此时它生成的比特编码是有独特格式的（公钥是X.509，私钥是PKCS#8）可以使用publicKey.getFormat()，privateKey.getFormat();进行查看。之后对字节码进行Base64编码就行了。

密钥生成方法：

//以base64编码密钥
    public Map<String ,String> generateKeyPair1() throws Exception{
        SecureRandom sr = new SecureRandom();
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        kpg.initialize(1024, sr);
        KeyPair kp = kpg.generateKeyPair();
        Key publicKey = kp.getPublic();
        Key privateKey = kp.getPrivate();
        byte[] pb = publicKey.getEncoded();
        String pbStr =  new String(Base64.encode(pb));
        byte[] pr = privateKey.getEncoded();
        String prStr =  new String(Base64.encode(pr));
        Map<String, String> map = new HashMap<String, String>();
        map.put("publicKey",pbStr);
        map.put("privateKey", prStr);
        return map;
    }

 恢复密钥方法，使用各自不同的编码形式恢复：

    //从base64编码的公钥恢复公钥
    public PublicKey getPulbickey(String key_base64) throws Exception{
        byte[] pb = Base64.decode(key_base64).getBytes();
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pb);
        KeyFactory  keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(keySpec);
    }

    //从base64编码的私钥恢复私钥
    public PrivateKey getPrivatekey(String key_base64) throws Exception{
        byte[] pb = Base64.decode(key_base64).getBytes();
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pb);
        KeyFactory  keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePrivate(keySpec);
    }

加密解密方法都类似下面，PrivateKey和PublicKey是Key的子接口。

    //执行加密操作
    public static byte[] encrypt(Key key,byte[] source) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] ciphertext = cipher.doFinal(source);
        return ciphertext;
    }

    //执行加密操作 
    public static byte[] decrypt(Key key,byte[] ciphertext) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] source = cipher.doFinal(ciphertext);
        return source;
    }

记录RSA的密钥特征值并进行密码恢复

所谓特征值就是RSA中公钥（N,e）私钥（N,d）的三个值：N,e,d。只要有这三个值我们就可以恢复密钥了。这是实际开发中常用的方法。首先是提取特征值，我们需要将PublicKey强制转换为RSAPublicKey.然后获取，看代码。

        //提取特征值保存，以base64编码密钥
        public static Map<String ,String> generateKeyPair2() throws Exception{
            SecureRandom sr = new SecureRandom();
            KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
            kpg.initialize(1024, sr);
            KeyPair kp = kpg.generateKeyPair();
            Key publicKey = kp.getPublic();
            Key privateKey = kp.getPrivate();
            RSAPublicKey rpk = (RSAPublicKey)publicKey;
            RSAPrivateKey rpr= (RSAPrivateKey)privateKey;
            //三个特征值都是BigInteger类型。
            BigInteger N = rpk.getModulus();//N值
            BigInteger e = rpk.getPublicExponent();//e值
            BigInteger d  = rpr.getPrivateExponent();//d值
            Map<String, String> map = new HashMap<String, String>();
            //将BigInteger转为byte[],然后以base64保存
            map.put("N",new String(Base64.decode(N.toByteArray())));
            map.put("e", new String(Base64.decode(e.toByteArray())));
            map.put("d", new String(Base64.decode(d.toByteArray())));
            return map;
        }

 利用三个特征值就可以非常容易恢复密钥了。

    //从base64编码的特征值(N,e)恢复公钥
    public static PublicKey getPulbickey(String N_Str,String e_Str) throws Exception{
        BigInteger N = new BigInteger(1, Base64.decode(N_Str.getBytes()));
        BigInteger e = new BigInteger(1, Base64.decode(e_Str.getBytes()));
        KeyFactory kf = KeyFactory.getInstance("RSA");
        RSAPublicKeySpec ps = new RSAPublicKeySpec(N, e);
        PublicKey pkey = kf.generatePublic(ps);
        return pkey;
    }
    
    //从base64编码的特征值（N,d）恢复私钥
    public static PrivateKey getPrivatekey(String N_Str,String d_Str) throws Exception{
        BigInteger N = new BigInteger(1, Base64.decode(N_Str.getBytes()));
        BigInteger d = new BigInteger(1, Base64.decode(d_Str.getBytes()));
        KeyFactory kf = KeyFactory.getInstance("RSA");
        RSAPrivateKeySpec ps = new RSAPrivateKeySpec(N, d);
        PrivateKey pkey = kf.generatePrivate(ps);
        return pkey;
    }

RSA 算法 与 数字签名

RSA 是目前最有影响力的非对称加密算法，能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA 算法是基于一个十分简单的数论事实：将两个大素数想乘十分容易，但反过来想要对其乘积进行因式分解却极其困难。

常见的数字签名有两种：

1、MD5 + RSA ：采用MD5 算法生成需要发送正文的数字摘要，并且使用RSA算法来对摘要进行加密和解密。

2、SHA1 + RSA：采用SHA-1算法生成正文的数字摘要，并且使用RSA算法来对摘要进行加密和解密。

两者算法的流程完全一致，只是签名算法换成了对应的算法。这里只对MD5withRSA做出代码示例。

基于Java的RSA算法使用

        private static final String RSA = "RSA";
	private static final String MD5 = "MD5";
	private static final String SHA1 = "SHA1";
	private static final String MD5withRSA = "MD5withRSA";
	private static final String SHA1withRSA = "SHA1withRSA";
	
	public static String byte2base64(byte[] bytes){
		Base64 base = new Base64();
		return base.encodeAsString(bytes);
	}
	public static byte[] base642byte(String base64){
		Base64 base = new Base64();
		return base.decode(base64);
	}
	//初始化KeyPairGenerator ，生成KeyPair
	public static KeyPair getKeyPair() throws Exception{
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
		keyPairGenerator.initialize(512);
		KeyPair keypair = keyPairGenerator.generateKeyPair();
		return keypair;
	}
	//获取公钥
	public static String getPublicKey(KeyPair keyPair){
		PublicKey publicKey = keyPair.getPublic();
		byte[] bytes = publicKey.getEncoded();
		return byte2base64(bytes);
	}
	//获取私钥
	public static String getPrivateKey(KeyPair keyPair){
		PrivateKey privateKey = keyPair.getPrivate();
		byte[] bytes = privateKey.getEncoded();
		return byte2base64(bytes);
	}
 
	//MD5withRSA   签名，可将MD5 替换成 SHA1 数字签名
	public static byte[] sign4MD5(byte[] content,PrivateKey privateKey) throws Exception{
		MessageDigest md = MessageDigest.getInstance(MD5);
		byte[] bytes = md.digest(content);
		Cipher cipher = Cipher.getInstance(RSA);
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		byte[] encryptBytes = cipher.doFinal(bytes);
		return encryptBytes;
	}
	//MD5withRSA  验证签名，可将MD5 替换成 SHA1 数字签名
	public static boolean verify4MD5(byte[] content,byte[] sign, PublicKey publicKey) throws Exception{
		MessageDigest md = MessageDigest.getInstance(MD5);
		byte[] bytes = md.digest(content);
		Cipher cipher = Cipher.getInstance(RSA);
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		byte[] decrypeBytes = cipher.doFinal(sign);
		return byte2base64(decrypeBytes).equals(byte2base64(bytes));
	}
	//基于JAVA的Signature API的使用 将MD5withRSA 替换成 SHA1withRSA 数字签名
	public static byte[] sign4Signature(byte[] content,PrivateKey privateKey) throws Exception{
		Signature signature = Signature.getInstance(MD5withRSA);
		signature.initSign(privateKey);;
		signature.update(content);
		return signature.sign();
	}
	public static boolean verify4Signature(byte[] content,byte[] sign, PublicKey publicKey) throws Exception{
		Signature signature = Signature.getInstance(MD5withRSA);
		signature.initVerify(publicKey);
		signature.update(content);
		return signature.verify(sign);
	}
	
	public static void main(String[] args) throws Exception {
		KeyPair keyPair = getKeyPair();
		System.out.println("privateKey:"+getPrivateKey(keyPair));
		System.out.println("publicKey:"+getPublicKey(keyPair));
		
		String content = "hello,World";
		byte[] signMd5 = sign4MD5(content.getBytes(), keyPair.getPrivate());
		System.out.println("signMd5:"+new String(signMd5));
		System.out.println("verifyMd5:"+verify4MD5(content.getBytes(), signMd5, keyPair.getPublic()));
		byte[] signSignature = sign4Signature(content.getBytes(), keyPair.getPrivate());
		System.out.println("sign4Signature:"+new String(signSignature));
		System.out.println("verify4Signature:"+verify4Signature(content.getBytes(), signSignature, keyPair.getPublic()));
	}

运行结果如下： 

privateKey:MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAiD/p5rsULwF3CNQNnh0Y3rUd5v7JSTWwt6RpIP6uoucwa1nI9pMU7IUF+PPgrMY3l6KJmfUdLSLx23/1286QYQIDAQABAkAk91pJvJY0TqxyG756GKDnw7ISOyx3jXadzKCtUAwnrDYXK3kyPpYW4Hnovw0bDF2GhFDs1l3DHk4dAfeFDXJxAiEA0FAesbxDSKaRePdlOTloMN6dm9cw3VJRK765TRVP8IUCIQCncKDGNA1OVSWZZicCaXSBuKlej+krjCavtJ/HWur1LQIhALPtsEV2xmsXLKnejnkaA8vKTTpRaeyQ8HmneGiDUxP9AiBTMzbgZfr6onqlZ8oYe7glwVF/qHjPZ7vNcS43zCiWHQIhAK0u7LLh2lzQNZ7eFGyHpsBQae5gfJMxzVY0/AyLvmtb
publicKey:MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIg/6ea7FC8BdwjUDZ4dGN61Heb+yUk1sLekaSD+rqLnMGtZyPaTFOyFBfjz4KzGN5eiiZn1HS0i8dt/9dvOkGECAwEAAQ==
signMd5:f��ߜ��L>^�\���o��@���:E�±�X��z���p�d��+����{�?�hg�|Jk
verifyMd5:true
sign4Signature:��oa̠��eH>:4����W]����?@���?zh���j�4�˰�L��i �h,
verify4Signature:true

 

参考文章

https://blog.csdn.net/qwe6112071/article/details/53576584

RSA非对称加密算法详解

https://blog.csdn.net/starryheavens/article/details/8536238

RSA算法详解（详细的说明了算法的数学基础）

https://blog.csdn.net/chengbinbbs/article/details/78640589

java对称加密与非对称加密（内含Java实现代码）

https://blog.csdn.net/hdhai9451/article/details/11481721

MD5、SHA256、SHA512加密算法，以及可逆算法

https://blog.csdn.net/mengfanzhundsc/article/details/62046559

常用的安全算法－数字摘要、对称加密、非对称加密详解

https://blog.csdn.net/u013565368/article/details/53081195

常用加密解密算法【RSA、AES、DES、MD5】介绍和使用

http://www.cnblogs.com/hjgods/p/3998570.html

MD5加密算法原理及实现（C++代码实现）

https://blog.csdn.net/tanyunlong_nice/article/details/52864019

加密方式之MD5

https://blog.csdn.net/w13505963128/article/details/79243484

MD5加密理解以及前台后台例子各一个

https://blog.csdn.net/smilefyx/article/details/49507179

html中使用js进行登录md5加密提交并重定向新页面