加密算法（Android用法）

加密算法可以归结为三大类：哈希算法，对称加密算法，非对称加密算法

Hash算法

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

常见的Hash算法：MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1

    @Test
    public void test() throws NoSuchAlgorithmException {
        String result= Sha2Crypt.sha256Crypt("sven".getBytes());
        System.out.println(result);
    }

对称加密

指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。

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

public class AES {

    public static String ALGORITHM="AES";

    @Test
    public void test() throws Exception{
        String content = "svendafsdfasdfasdfasdfasdfasdfas2598237532985723498573248";
        String password="1232351325123";
        //加密
        byte[] encrypt = encrypt(content, password);
        System.out.println("加密后的数据:"+new String(encrypt));
        //解密
        byte[] decrypt = decrypt(encrypt, password);
        System.out.println("解密后的内容:"+new String(decrypt));
    }

    public static byte[] encrypt(String content,String password) throws Exception{
        //创建AES的key生产者
        KeyGenerator kgen=KeyGenerator.getInstance(ALGORITHM);
        //利用用户密码作为随机数初始化
        kgen.init(128,new SecureRandom(password.getBytes()));
        //根据用户密码，生成一个密钥  (所有对称算法通用的)
        SecretKey secretKey=kgen.generateKey();

        //对秘钥进行基本的编码
        byte[] keyEncoded = secretKey.getEncoded();
        //转换成AES专用的密钥 RoundKey
        SecretKeySpec key = new SecretKeySpec(keyEncoded,ALGORITHM);
        //创建一个密码器
        Cipher cipher= Cipher.getInstance(ALGORITHM);
        //开始加密
        byte[] byteContent=content.getBytes();
        //初始化为加密模式
        cipher.init(Cipher.ENCRYPT_MODE,key);
        //加密
        byte[] result = cipher.doFinal(byteContent);
        //如果数据很多，就用 cipher.update(),最后才用cipher.doFinal()
        return result;
    }

    public static byte[] decrypt(byte[] content,String password) throws Exception{
        //创建AES的key生产者
        KeyGenerator kgen=KeyGenerator.getInstance(ALGORITHM);
        //利用用户密码作为随机数初始化
        kgen.init(128,new SecureRandom(password.getBytes()));
        //根据用户密码，生成一个密钥  (所有对称算法通用的)
        SecretKey secretKey=kgen.generateKey();
        //对密钥进行基本的编码
        byte[] enCodeFormat=secretKey.getEncoded();
        //转换成AES专用的密钥 RoundKey
        SecretKeySpec key=new SecretKeySpec(enCodeFormat,ALGORITHM);
        //创建一个密码器
        Cipher cipher=Cipher.getInstance(ALGORITHM);
        //解密
        cipher.init(Cipher.DECRYPT_MODE,key);
        byte[] result=cipher.doFinal(content);
        return result;
    }
}

非对称加密

指加密和解密使用不同密钥的加密算法，也称为公私钥加密。假设两个用户要加密交换数据，双方交换公钥，使用时一方用对方的公钥加密，另一方即可用自己的私钥解密。如果企业中有n个用户，企业需要生成n对密钥，并分发n个公钥。由于公钥是可以公开的，用户只要保管好自己的私钥即可，因此加密密钥的分发将变得十分简单。同时，由于每个用户的私钥是唯一的，其他用户除了可以可以通过信息发送者的公钥来验证信息的来源是否真实，还可以确保发送者无法否认曾发送过该信息。非对称加密的缺点是加解密速度要远远慢于对称加密，在某些极端情况下，甚至能比对称加密慢上1000倍。

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

public class RSA {

    public static String ALGORITHM = "RSA";
    //指定key的位数
    public static int KEYSIZE = 1024;//65536
    //指定公钥的存放文件
    public static String PUBLIC_KEY_FILE = "public_key.dat";
    //指定私钥的存放文件
    public static String PRIVATE_KEY_FILE = "private_key.dat";
    
    @Test
    public void test() throws Exception{
        //客户端用公钥加密
        String content = "sven";
        String encrypt = encrypt(content);
        System.out.println("密文："+encrypt);
        //到了服务器后，用私钥解密
        String target = decrypt(encrypt);
        System.out.println("明文："+target);
    }

    /**
     * 生成秘钥对 公  私
     *
     * @throws Exception
     */
    public static void generateKeyPair() throws Exception {
        SecureRandom sr = new SecureRandom();
        //需要一个KeyPairGenerator对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(KEYSIZE, sr);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //得到公钥
        PublicKey keyPublic = keyPair.getPublic();
        //得到私钥
        PrivateKey keyPrivate = keyPair.getPrivate();

        //可以写入文件后，这两个文件分别放到服务器和客户端
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));
        ObjectOutputStream objectOutputStream1 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));
        objectOutputStream.writeObject(keyPublic);
        objectOutputStream1.writeObject(keyPrivate);
        objectOutputStream.close();
        objectOutputStream1.close();
    }

    /**
     * 加密
     */
    public static String encrypt(String source) throws Exception {
        generateKeyPair();
        //取出公钥
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
        Key key = (Key) ois.readObject();
        ois.close();
        //开始用公钥
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] bytes = source.getBytes();
        byte[] aFinal = cipher.doFinal(bytes);
        Base64.Encoder encoder = Base64.getEncoder();
        return encoder.encodeToString(aFinal);
    }

    /**
     * 解密
     * @param cryptText
     * @return
     * @throws Exception
     */
    public static String decrypt(String cryptText) throws Exception {
        //读文件，取到私钥
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
        Key key = (Key) ois.readObject();
        ois.close();
        //解密
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);

        Base64.Decoder decoder = Base64.getDecoder();
        byte[] decode = decoder.decode(cryptText);
        byte[] bytes = cipher.doFinal(decode);
        return new String(bytes);
    }
}

各种加密算法对比

Hash算法比较

名称	安全性	速度
SHA-1	高	慢
MD5	中	快

对称加密算法比较

名称	秘钥名称	运行速度	安全性	资源消耗
DES	56位	较快	低	中
3DES	112位或168位	慢	中	高
AES	128，192，256位	快	高	低

非对称加密算法比较

名称	成熟度	安全性	运算速度	资源消耗
RSA	高	高	中	中
ECC	高	高	慢	高

对称加密算法与非对称加密算法对比

对称算法

1，秘钥管理：比较难，不适合互联网，一般用于内部系统

2，安全性：中

3，加密速度：快，适合大数据量的加解密处理

非对称算法

1，秘钥管理：秘钥容易管理

2，安全性：高

3，加密速度：比较慢，适合小数据量加解密或数据签名