0x01 问题

这个月在逛着https://stackoverflow.com突然发现个有点意思的一段代码,或者说是有点意思的猴戏
怎么说呢,就是看完以后,不知道为啥子,我就在懵逼中跪下了…
为了解决疑问,快速爬起来,我就决定解决这个疑问

先给你们看看这个问题是啥,你们就知道我为何懵逼了
https://stackoverflow.com/questions/15182496/why-does-this-code-using-random-strings-print-hello-world
翻译过来就是一句话:下面的代码将打印“hello world”,有人能解释一下吗?
大概是这个意思,我也是有道云翻译的….
image.png

给出的代码也超级简单,可以拿idea跑一下看看结果

  1. // 让人懵逼的代码
  2. package Test2;
  4. import java.util.Random;
  6. public class Test1 {
  7.     public static void main(String[] args) {
  8.         System.out.println(randomString(-229985452) + " " + randomString(-147909649));
  9.     }
  11.     public static String randomString(int i) {
  12.         Random ran = new Random(i);
  13.         StringBuilder sb = new StringBuilder();
  14.         while (true) {
  15.             int k = ran.nextInt(27);
  16.             if (k == 0) {
  17.                 break;
  18.             }
  20.             sb.append((char) ('`' + k));
  21.         }
  23.         return sb.toString();
  24.     }
  25. }
  30. // 运行结果
  31. hello world

image.png
就问你…
这个代码给你,你第一眼看到输出个“hello world”懵逼不懵逼?

0x02 解答

0x02.1 初步解答

懵逼完了以后,就可以开始想想为什么了

先看了一眼源码,有点拗口,让我有点懒的思考,于是决定去看看文章的评论
image.png

我这么懒的逼,当然是选择看评论拉,看到一个高赞回答,看看写了啥先
image.png
有道翻译是这么说的:
当使用特定的种子值(seed)(在本例中是-229985452与-147909649)构建java.util.Random的实例时
那么java.util.Random将从指定的种子值(seed)开始生成随机数
用相同的种子值(seed)构建的每一个java.util.Random对象,每次都会产生相同的数字

是不是感觉还是有点懵逼,简单的说就是当这个种子值(seed)是固定的时,那么生成出来的结果也是固定的
这里我们做个小实验,写一段代码,运行一下,你就会恍然大悟说的是啥了

  1. // 随机数固定结果测试
  2. package Test2;
  4. import java.util.Random;
  6. public class Test2 {
  7.     public static void main(String[] args) {
  8.         randomString(-229985452);
  9.         System.out.println("--------------");
  10.         randomString(-229985452);
  11.     }
  13.     private static void randomString(int i) {
  14.         Random ran = new Random(i);
  15.         System.out.println(ran.nextInt());
  16.         System.out.println(ran.nextInt());
  17.         System.out.println(ran.nextInt());
  18.         System.out.println(ran.nextInt());
  19.         System.out.println(ran.nextInt());
  20.     }
  21. }
  26. // 运行结果
  27. -755142161
  28. -1073255141
  29. -369383326
  30. 1592674620
  31. -1524828502
  32. --------------
  33. -755142161
  34. -1073255141
  35. -369383326
  36. 1592674620
  37. -1524828502

image.png
可以发现,我这边在种子值(seed)一致的情况下,运行二次的结果返回都是一致的
当然读者也可以试试运行,你的结果一定也是会和我一致的

也就是说在使用java.util.Random时,如果指定的种子值(seed)是相同的
那么他们生成并返回的其实是看起来是随机的固定数字

而且我们都知道java.util.Random本身就是一个伪随机算法
而当使用特定的种子值(seed)构建java.util.Random的实例时,那就成了一个更加伪的伪随机算法了
这么说是因为如果能猜测出,种子值(seed)或是种子值(seed)泄漏了,那么理论上就可以推测出随机数生成的结果

0x02.2 回看问题

好了前面逼逼那么多,现在也应该知道java.util.Random中指定种子值(seed)的关键了
现在让读者们,随我在回去看看问题,应该就可以看出来是为啥了
image.png
主要看循环里面的代码即可
先了解个基础的小知识,带参的nextInt(int x)会生成一个范围在0~x(不包含x)内的任意正整数
现在看int k = ran.nextInt(27);这句话,这表示k这个变量返回的值一定是[0,26]内的一个正整数
if (k == 0)的意思就是说,如果k这个变量,返回0就退出循环,这个没啥子好说的
在进行下一步之前,打印看看int k = ran.nextInt(27);具体会返回什么
image.png

  1. // int k = ran.nextInt(27);两个种子值(seed)的返回结果
  2. ----------------
  3. 种子值(seed): -229985452
  4. 返回值:8
  5. 返回值:5
  6. 返回值:12
  7. 返回值:12
  8. 返回值:15
  9. 返回值:0
  10. ----------------
  11. 种子值(seed): -147909649
  12. 返回值:23
  13. 返回值:15
  14. 返回值:18
  15. 返回值:12
  16. 返回值:4
  17. 返回值:0
  18. ----------------

有个印象即可,无需特别在意

在看个基础的小知识,Java中的单引号表示字符一般是char类型
现在看(char) ('‘ + k)其中‘'是个char类型,看到char``+``int条件反射的想到ASCII码
而且'‘的ASCII码是96<br />并且k返回的是[0,26]内的一个正整数<br />因此(char) (‘' + k)这个代码的范围就是[96+1,96+26]

去除返回值为0的,最终只需要对照着ASCII码表,就能看出是对其的那些字母了

  1. 96 + 8 = 104 -> h
  2. 96 + 5 =101 -> e
  3. 96 + 12 = 108 -> l
  4. 96 + 12 = 108 -> l
  5. 96 + 15 = 111 -> o
  6. 96 + 23 = 119 -> w
  7. 96 + 15 = 111 -> o
  8. 96 + 18 = 114 -> r
  9. 96 + 12 = 108 -> l
  10. 96 + 4 = 100 -> d

到这里,对于为什么这一段谜一样的代码能输出“hello world”,我们已经了然于胸了
看穿了以后,也就是个小把戏罢了

0x03 思考

然后我就开始想这个东西如果拿来写马子,用于关键字混淆什么的,那不是会很棒?
于是就开始思考如何改造最前面的demo,让它啥子单词都能打出来,因为现在这个代码只能输出“hello world”

所以当务之急是找或写一个可以把字符串变成种子值(seed)的函数
当然我这么懒,所以我选择了找,然后还真被我找到了
image.png
拷贝一下,本地试试
image.png
很好,但是还差点,因为它只能跑a-z,这可不太行啊
因为我们写马的时候,各种特殊符号之类的,可是都要有的,所以还是需要一个小小的改动

  1. // 最终改动完成的代码
  2. // 注意: 种子生成的时间,会因为代码的长度与复杂度的增加而增加
  3. import java.util.*;
  4. import java.util.stream.Collectors;
  6. public class Test3 {
  7.     public static void main(String[] args) {
  8.         long start = System.currentTimeMillis();
  10.         long[] seedList = generateSeedList("java.lang.Runtime");
  11.         for (long seed : seedList) {
  12.             System.out.println("种子值(seed): " + seed);
  13.             System.out.println("对应字符串: " + seedConversionString(seed));
  14.             System.out.println("------");
  15.         }
  17.         System.out.println("种子生成花费时间: " + (double) (System.currentTimeMillis() - start) / 1000 + "秒");
  19.         String data = seedListConversionString(seedList);
  20.         System.out.println("种子列表转换结果: " + data);
  21.     }
  23.     /**
  24.      * 测试使用
  25.      * 输出所有字符的种子与解析结果
  26.      */
  27.     public static void test() {
  28.         String str = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  29.         String[] strs = str.split("");
  30.         for (String s : strs) {
  31.             System.out.println("----");
  32.             long dataSeed = generateSeed(s);
  33.             System.out.println("种子值(seed): " + dataSeed);
  34.             System.out.println("对应字符串: " + seedConversionString(dataSeed));
  35.             System.out.println("-----");
  36.         }
  37.     }
  39.     /**
  40.      * 功能: 输入字符串获取种子数组
  41.      *
  42.      * @param goal 要转为种子的字符串
  43.      * @return
  44.      */
  45.     public static long[] generateSeedList(String goal) {
  46.         List<String> dataSourceList = Arrays.asList(goal.split(""));
  47.         int groupSize = (int) Math.ceil((double) goal.length() / 3);
  49.         List<Long> seedList = new ArrayList<>();
  50.         for (List<String> stringList : listChunkSplit(dataSourceList, groupSize)) {
  51.             long seed = generateSeed(stringList.stream().collect(Collectors.joining("")));
  52.             seedList.add(seed);
  53.         }
  55.         return seedList.stream().mapToLong(t -> t).toArray();
  56.     }
  58.     /**
  59.      * 功能: 输入字符串获取种子
  60.      * 注: 单词越长,需要查找的时间就越长,个人建议1-3个字符为一个种子,可以基本可以无感知的快速生成种子
  61.      *
  62.      * @param goal 要转为种子的字符串
  63.      * @return
  64.      */
  65.     public static long generateSeed(String goal) {
  66.         String str = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  67.         for (String s : goal.split("")) {
  68.             if (!str.contains(s)) {
  69.                 throw new RuntimeException(String.format("%s 该字符,不是符合条件的字符,请修改", s));
  70.             }
  71.         }
  73.         char[] input = goal.toCharArray();
  74.         char[] pool = new char[input.length];
  75.         label:
  76.         for (long seed = Integer.MIN_VALUE; seed < Integer.MAX_VALUE; seed++) {
  77.             Random random = new Random(seed);
  79.             for (int i = 0; i < input.length; i++) {
  80.                 pool[i] = (char) (31 + random.nextInt(96));
  81.             }
  83.             if (random.nextInt(96) == 0) {
  84.                 for (int i = 0; i < input.length; i++) {
  85.                     if (input[i] != pool[i]) {
  86.                         continue label;
  87.                     }
  88.                 }
  89.                 return seed;
  90.             }
  91.         }
  92.         throw new NoSuchElementException("对不起该字符串找不到对应的种子");
  93.     }
  95.     /**
  96.      * 功能: 将种子数组转换字符串
  97.      *
  98.      * @param is 种子数组
  99.      * @return
  100.      */
  101.     public static String seedListConversionString(long[] is) {
  102.         StringBuilder dataSource = new StringBuilder();
  103.         for (long seed : is) {
  104.             dataSource.append(seedConversionString(seed));
  105.         }
  106.         return dataSource.toString();
  107.     }
  109.     /**
  110.      * 功能: 将种子转换字符串
  111.      *
  112.      * @param i 种子
  113.      * @return
  114.      */
  115.     public static String seedConversionString(long i) {
  116.         Random ran = new Random(i);
  117.         StringBuilder sb = new StringBuilder();
  118.         while (true) {
  119.             int k = ran.nextInt(96);
  120.             if (k == 0) {
  121.                 break;
  122.             }
  123.             sb.append((char) (31 + k));
  124.         }
  125.         return sb.toString();
  126.     }
  128.     /**
  129.      * 列表块分割函数
  130.      * 功能: 把列表按照size分割成指定的list快返回
  131.      * 例子1:
  132.      * a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  133.      * listChunkSplit(a, 2)
  134.      * 返回: [[1, 2, 3, 4, 5], [6, 7, 8, 9]]
  135.      * 例子2:
  136.      * a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  137.      * listChunkSplit(a, 10)
  138.      * 返回: [[1], [2], [3], [4], [5], [6], [7], [8], [9]]
  139.      *
  140.      * @param dataSource 数据源
  141.      * @param groupSize  一个整数, 规定最多分成几个list
  142.      * @return List<List < String>>
  143.      */
  144.     public static List<List<String>> listChunkSplit(List<String> dataSource, Integer groupSize) {
  145.         List<List<String>> result = new ArrayList<>();
  147.         if (dataSource.size() == 0 || groupSize == 0) {
  148.             return result;
  149.         }
  151.         // 偏移量
  152.         int offset = 0;
  154.         // 计算 商
  155.         int number = dataSource.size() / groupSize;
  157.         // 计算 余数
  158.         int remainder = dataSource.size() % groupSize;
  160.         for (int i = 0; i < groupSize; i++) {
  161.             List<String> value = null;
  162.             if (remainder > 0) {
  163.                 value = dataSource.subList(i * number + offset, (i + 1) * number + offset + 1);
  164.                 remainder--;
  165.                 offset++;
  166.             } else {
  167.                 value = dataSource.subList(i * number + offset, (i + 1) * number + offset);
  168.             }
  170.             if (value.size() == 0) {
  171.                 break;
  172.             }
  174.             result.add(value);
  175.         }
  177.         return result;
  178.     }
  179. }
  185. // 运行结果
  186. 种子值(seed): -2080435608
  187. 对应字符串: jav
  188. ------
  189. 种子值(seed): -2060785532
  190. 对应字符串: a.l
  191. ------
  192. 种子值(seed): -2147149194
  193. 对应字符串: ang
  194. ------
  195. 种子值(seed): -2107467938
  196. 对应字符串: .Ru
  197. ------
  198. 种子值(seed): -1949527326
  199. 对应字符串: nti
  200. ------
  201. 种子值(seed): -2146859157
  202. 对应字符串: me
  203. ------
  204. 种子生成花费时间: 21.273秒
  205. 种子列表转换结果: java.lang.Runtime

有了上面的代码以后,我们就可以写一个最最简单的混淆马子了

  1. // 这是我能想到的最最最简单的用涂了
  2. // 或是拿来对哥斯拉的流量加密感觉也是可以的
  3. // 其它的自己发挥想象吧
  4. import org.apache.commons.io.IOUtils;
  6. import java.io.InputStream;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.Method;
  9. import java.util.Random;
  11. public class ExecCmdTest {
  12.     public static void main(String[] args) {
  13.         try {
  14.             String cmd = "whoami";
  16.             // java.lang.Runtime 的 种子
  17.             // -2080435608 -> jav
  18.             // -2060785532 -> a.l
  19.             // -2147149194 -> ang
  20.             // -2107467938 -> Ru
  21.             // -1949527326 -> nti
  22.             // -2146859157 -> me
  23.             long[] seedList = {-2080435608, -2060785532, -2147149194, -2107467938, -1949527326, -2146859157};
  24.             String runtimePath = seedListConversionString(seedList);
  26.             // 获取Runtime类对象
  27.             Class runtimeClass = Class.forName(runtimePath);
  29.             // 获取构造方法
  30.             Constructor runtimeConstructor = runtimeClass.getDeclaredConstructor();
  31.             runtimeConstructor.setAccessible(true);
  33.             // 创建Runtime类实例 相当于 Runtime r = new Runtime();
  34.             Object runtimeInstance = runtimeConstructor.newInstance();
  36.             // 获取Runtime的exec(String cmd)方法
  37.             Method runtimeMethod = runtimeClass.getMethod("exec", String.class);
  39.             // 调用exec方法 等于 r.exec(cmd); cmd参数输入要执行的命令
  40.             Process p = (Process) runtimeMethod.invoke(runtimeInstance, cmd);
  42.             // 获取命令执行结果
  43.             InputStream results = p.getInputStream();
  45.             // 输出命令执行结果
  46.             System.out.println(IOUtils.toString(results, "UTF-8"));
  47.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         }
  50.     }
  52.     /**
  53.      * 功能: 将种子数组转换字符串
  54.      *
  55.      * @param is 种子数组
  56.      * @return
  57.      */
  58.     public static String seedListConversionString(long[] is) {
  59.         StringBuilder dataSource = new StringBuilder();
  60.         for (long seed : is) {
  61.             dataSource.append(seedConversionString(seed));
  62.         }
  63.         return dataSource.toString();
  64.     }
  66.     /**
  67.      * 功能: 将种子转换字符串
  68.      *
  69.      * @param i 种子
  70.      * @return
  71.      */
  72.     public static String seedConversionString(long i) {
  73.         Random ran = new Random(i);
  74.         StringBuilder sb = new StringBuilder();
  75.         while (true) {
  76.             int k = ran.nextInt(96);
  77.             if (k == 0) {
  78.                 break;
  79.             }
  80.             sb.append((char) (31 + k));
  81.         }
  82.         return sb.toString();
  83.     }
  84. }

0x04 杂项

有关ASCII码表的内容可以看这一篇文章
https://www.yuque.com/pmiaowu/ppx2er/kfvuhv
里面详细记录了ASCII码对应字符

0x05 总结

偶尔能看看猴戏还是挺有意思的说