JAVA安全与加密

一. 随机数

随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

Random类中实现的随机是伪随机，也就是有规则的随机，因为它的种子是System.currentTimeMillis()，所以它的随机数都是可预测的。相同种子数的Random对象，相同次数生成的随机数字是完全相同的。所以在需要频繁生成随机数，或者安全要求较高的时候，不要使用Random。

SecureRandom类提供加密的强随机数生成器 (RNG)。当然，它的许多实现都是伪随机数生成器 (PRNG) 形式，这意味着它们将使用确定的算法根据实际的随机种子生成伪随机序列，也有其他实现可以生成实际的随机数，还有另一些实现则可能结合使用这两项技术。

SecureRandom和Random如果种子一样，产生的随机数也一样：因为种子确定，随机数算法也确定，因此输出是确定的。只是说，SecureRandom类收集了一些随机事件，比如鼠标点击，键盘点击等等，SecureRandom 使用这些随机事件作为种子，因此种子是不可预测的，而不像Random默认使用系统当前时间的毫秒数作为种子，有规律可寻。

1. 创建SecureRandom

内置两种随机数算法，NativePRNG和SHA1PRNG。

(1) new

通过new来初始化，默认会使用NativePRNG算法生成随机数。
SecureRandom secureRandom = new SecureRandom()

(2) getInstance

SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG")//传算法名，如果不存在算法会抛出异常

2. SecureRandom的使用

SecureRandom继承自Random，所以也有nextInt之类的方法。

nextBytes(byte[] bytes) void //获取随机的一个byte数组，传入瓶子（产生的随机数放入了入参bytes）
generateSeed(int numBytes) byte[] //获取一个随机的byte数组，这个数组中的数通常可以用来做其他随机生成器的种子
SecureRandom.getSeed(int numBytes) byte[] //直接获得随机数，本质是包含了创建和使用两步
setSeed(byte[] seed) void //设置种子数
nextInt(int bound) int //生成[0,bound)之间的随机数

3. 实例

  /**
     * 生成一个随机数矩阵
     *
     * @param num        行数
     * @param rowLen     列数
     * @param seedLength 种子数长度
     * @author yaohuix
     * @time 2018/3/30 16:02
     */
    private List<List<Integer>> generateCakes(int num, int seedLength, int rowLen) {
        SecureRandom random = new SecureRandom();
        byte[] seeds = SecureRandom.getSeed(seedLength); //获取随机的byte数组，用来后续作为种子
        int counter = 0;
        int tmprows = 0;
        List<List<Integer>> CakesList = new ArrayList<List<Integer>>();
        while (num > tmprows) {
            List<Integer> list = new ArrayList<Integer>();
            while (counter < rowLen) {
                random.setSeed(seeds); //设置种子
                int cake = random.nextInt(38); //随机生成0-37的数字
                if (!list.contains(cake) && 0 != cake) {
                    list.add(cake);
                    counter++;
                }
                random.nextBytes(seeds); //随机获取新的byte数组用以作为下次的种子，不断循环
            }
            Collections.sort(list);
            tmprows++;
            counter = 0;
            CakesList.add(list);
        }
        return CakesList;
    }

4. 关于种子seed获取思路

产生高强度的随机数，有两个重要的因素：种子和算法。当然算法是可以有很多的，但是如何选择种子是非常关键的因素。那么如何得到一个近似随机的种子？这里有一个思路：收集计算机的各种信息，如键盘输入时间，CPU时钟，内存使用状态，硬盘空闲空间，IO延时，进程数量，线程数量等信息，来得到一个近似随机的种子。这样的话，除了理论上有破解的可能，实际上基本没有被破解的可能。而事实上，现在的高强度的随机数生成器都是这样实现的

二. 散列算法

散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特性的散列结果就可以用于验证信息是否被修改。

散列算法可以用来加密token生成签名，以便token信息不暴露在网络同时还能验证登录的有效性。

1. MD5

全写： Message Digest Algorithm MD5（消息摘要算法第五版）
输出： 128bit

特点：
a) 压缩性：任意长度的数据，算出的MD5值长度都是固定的。
b) 容易计算：从原数据计算出MD5值很容易。
c) 抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
d) 弱抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。
e) 强抗碰撞：想找到两个不同的数据，使它们具有相同的MD5值，是非常困难的。

缺陷：
Md5一度被认为十分靠谱。2009年，冯登国、谢涛二人利用差分攻击，将MD5的碰撞算法复杂度降低到2^{21，极端情况下甚至可以降低至2}10。仅仅2^21的复杂度意味着即便是在2008年的计算机上，也只要几秒便可以找到一对碰撞。MD5已老，在安全性要求较高的场合，不建议使用。

应用场景：
一致性验证
数字签名
安全访问认证

(1) 算法实现

MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] bytes = md5.digest(string.getBytes());

或者

InputStream in = new FileInputStream(file);
while ((len = in.read(buffer)) != -1) {
    md5.update(buffer, 0, len);
}
byte[] bytes = md5.digest();

(2) MD5加密安全性探讨

虽然说MD5加密本身是不可逆的，但并不是不可破译的，网上有关MD5解密的网站数不胜数，破解机制采用穷举法，就是我们平时说的跑字典。所以如何才能加大MD5破解的难度呢？

i）对字符串多次MD5加密

public static String md5(String string, int times) {
    if (TextUtils.isEmpty(string)) {
        return "";
    }
    String md5 = md5(string);
    for (int i = 0; i < times - 1; i++) {
        md5 = md5(md5);
    }
    return md5(md5);
}

ii） MD5加盐

所谓加盐，就是在原本需要加密的信息基础上，糅入其它内容salt：string+key（盐值key）然后进行MD5加密，加盐的方式也是多种多样。

用string明文的hashcode作为盐，然后进行MD5加密
随机生成一串字符串作为盐，然后进行MD5加密

public static String md5(String string, String slat) {
    if (TextUtils.isEmpty(string)) {
        return "";
    }
    MessageDigest md5 = null;
    try {
        md5 = MessageDigest.getInstance("MD5");
        byte[] bytes = md5.digest((string + slat).getBytes());
        String result = "";
        for (byte b : bytes) {
            String temp = Integer.toHexString(b & 0xff);
            if (temp.length() == 1) {
                temp = "0" + temp;
            }
            result += temp;
        }
        return result;
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return "";
}

2. SHA1

全名：安全哈希算法（Secure Hash Algorithm）
输出：160bit

(1) 与MD5比较

相同点：
因为二者均由MD4导出，SHA-1和MD5彼此很相似。相应的，他们的强度和其他特性也是相似。

不同点：
a) 对强行攻击的安全性：最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2^{128数量级的操作，而对SHA-1则是2}160数量级的操作。这样，SHA-1对强行攻击有更大的强度。
b) 对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。
c) 速度：在相同的硬件上，SHA-1的运行速度比MD5慢。

三. 对称加密

1. AES加密

高级加密标准（Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

接下来我们来实际看下具体怎么实现：

(1) 获取密钥生成器

KeyGenerator kg = KeyGenerator.getInstance("DESede")
分析：KeyGenerator类中提供了创建对称密钥的方法。getInstance(String algorithm)的参数指定加密算法的名称，可以是 “AES”、“DES”、“DESede”等。这些算法都可以实现加密。其中“DES”是目前最常用的对称加密算法，但安全性较差。“AES”是一种替代DES算法的新算法，可提供很好的安全性。

(2) 初始化密钥生成器

kg.init(168)或init(int keysize, SecureRandom random)
分析：该步骤一般指定密钥的长度。如果该步骤省略的话，会根据算法自动使用默认的密钥长度。指定长度时，若第一步密钥生成器使用的是“DES”算法，则密钥长度必须是56位；若是“DESede”，则可以是112或168位，其中112位有效；若是“AES”，可以是128, 192或256位。

(3) 生成密钥

SecretKey k = kg.generateKey( )
分析：使用第一步获得的KeyGenerator类型的对象中generateKey()方法可以获得密钥。其类型为SecretKey类型，可用于以后的加密和解密。

i) 通过对象序列化方式将密钥保存在文件中

FileOutputStream  f = new FileOutputStream("key1.dat");
ObjectOutputStream b = new  ObjectOutputStream(f);
b.writeObject(k);

分析：ObjectOutputStream类中提供的writeObject方法可以将对象序列化，以流的方式进行处理。这里将文件输出流作为参数传递给ObjectOutputStream类的构造器，这样创建好的密钥将保存在文件key1.dat中。

代码与分析：

public static void main(String args[])
            throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance("DESede");
        kg.init(168);
        SecretKey k = kg.generateKey();
        FileOutputStream f = new FileOutputStream("key1.dat");
        ObjectOutputStream b = new ObjectOutputStream(f);
        b.writeObject(k);
    }

ii) 以字节保存对称密钥

★ 编程思路：
Java中所有的密钥类都有一个getEncoded( )方法，通过它可以从密钥对象中获取主要编码格式，其返回值是字节数组。其主要步骤为：

获取主要编码格式
byte[] kb=k.getEncoded()
分析：执行SecretKey类型的对象k的getEncoded( )方法，返回的编码放在byte类型的数组中。
保存密钥编码格式

FileOutputStream  f2=new FileOutputStream("keykb1.dat");
f2.write(kb);

(4) 转换为AES专用密钥

SecretKeySpec secretKeyspec = new SecretKeySpec(secretKey.getEncoded(), "AES")

(5) 创建密码器

//实例化
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
//使用密钥初始化，设置为加密模式/解密模式（Cipher.DECRYPT_MODE）
cipher.init(Cipher.ENCRYPT_MODE, secretKeyspec);

(6) 加密/解密

byte[] doFinal(byte[] input)

实例：

    //Cipher密码  encrypt加密 decrypt解密 crypto秘密
    private final static String HEX = "0123456789ABCDEF";
    //AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
    private static final String CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";
    private static final String AES = "AES";//AES 加密
    private static final String SHA1PRNG = "SHA1PRNG";//// SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

    /*
     * 生成随机数，可以当做动态的密钥 加密和解密的密钥必须一致，不然将不能解密
     */
    public static String generateKey() {
        try {
            SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
            byte[] bytes_key = new byte[20];
            localSecureRandom.nextBytes(bytes_key);
            String str_key = toHex(bytes_key);
            return str_key;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // 对密钥进行处理
    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance(AES);
        //for android
        SecureRandom sr = null;
        // 在4.2以上版本中，SecureRandom获取方式发生了改变
         if (android.os.Build.VERSION.SDK_INT >= 17) {
             sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
         } else {
            sr = SecureRandom.getInstance(SHA1PRNG);
         }
        // for Java
        // secureRandom = SecureRandom.getInstance(SHA1PRNG);
        sr.setSeed(seed);
        kgen.init(128, sr); //256 bits or 128 bits,192bits
        //AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }

    /*
     * 加密
     */
    public static String encrypt(String key, String cleartext) {
        if (TextUtils.isEmpty(cleartext)) {
            return cleartext;
        }
        try {
            byte[] result = encrypt(key, cleartext.getBytes());
            return Base64.encode(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
    * 加密
    */
    private static byte[] encrypt(String key, byte[] clear) throws Exception {
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    /*
    * 解密
    */
    public static String decrypt(String key, String encrypted) {
        if (TextUtils.isEmpty(encrypted)) {
            return encrypted;
        }
        try {
            byte[] enc = Base64.decodeToBytes(encrypted);
            byte[] result = decrypt(key, enc);
            return new String(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /*
     * 解密
     */
    private static byte[] decrypt(String key, byte[] encrypted) throws Exception {
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }


    //二进制转字符
    public static String toHex(byte[] buf) {
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }


    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,088评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,715评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,361评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,099评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 60,987评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,063评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,486评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,175评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,440评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,518评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,305评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,190评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,550评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,880评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,152评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,451评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,637评论 2赞 335