java8 filter 取反_Java逆向基础之条件跳转位运算循环

最新推荐文章于 2023-02-24 14:06:30 发布
最新推荐文章于 2023-02-24 14:06:30 发布
阅读量101 收藏
点赞数
文章标签： java8 filter 取反
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39640395/article/details/114232752
版权
本文详细介绍了Java字节码中条件跳转指令和位运算的实现，通过实例分析了if条件判断、取反、循环等操作在反编译后的字节码表示，揭示了Java代码与字节码之间逻辑的反转特点。
摘要由CSDN通过智能技术生成

条件跳转的例子，绝对值public class abs

{

public static int abs(int a)

{

if (a<0)

return -a;

return a;

}

}

编译javac abs.java

反编译javap -c -verbose abs.classpublic static int abs(int);

descriptor: (I)I

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=1, locals=1, args_size=1

0: iload_0

1: ifge          7

4: iload_0

5: ineg

6: ireturn

7: iload_0

8: ireturn

其中ifge 7 意思是，当栈顶的值大于等于0的时候跳转到偏移位7，任何的ifXX指令都会将栈中的值弹出用于进行比较

其中ineg 意思是将栈顶int型数值取负并将结果压入栈顶

再看一个例子，取最小值public class min

{

public static int min (int a, int b)

{

if (a>b)

return b;

return a;

}

}

反编译public static int min(int, int);

descriptor: (II)I

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=2, args_size=2

0: iload_0

1: iload_1

2: if_icmple     7

5: iload_1

6: ireturn

7: iload_0

8: ireturn

if_icmple会从栈中弹出两个值进行比较，如果第二个(a,iload_0)小于或者等于第一个(b,iload_1)，那么跳转到偏移位7

从上面例子可以看出在Java代码中if条件中的测试与在字节码中是完全相反的

max函数例子public class max

{

public static int max (int a, int b)

{

if (a>b)

return a;

return b;

}

}

反编译public static int max(int, int);

descriptor: (II)I

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=2, args_size=2

0: iload_0

1: iload_1

2: if_icmple     7

5: iload_0

6: ireturn

7: iload_1

8: ireturn

代码和min的差不多，唯一的区别是最后两个iload指令(偏移位5和偏移位7)互换了

更复杂的例子public class cond

{

public static void f(int i)

{

if (i<100)

System.out.print("<100");

if (i==100)

System.out.print("==100");

if (i>100)

System.out.print(">100");

if (i==0)

System.out.print("==0");

}

}

反编译public static void f(int);

descriptor: (I)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=1, args_size=1

0: iload_0

1: bipush        100

3: if_icmpge     14

6: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

9: ldc           #3                  // String <100

11: invokevirtual #4                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V

14: iload_0

15: bipush        100

17: if_icmpne     28

20: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

23: ldc           #5                  // String ==100

25: invokevirtual #4                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V

28: iload_0

29: bipush        100

31: if_icmple     42

34: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

37: ldc           #6                  // String >100

39: invokevirtual #4                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V

42: iload_0

43: ifne          54

46: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

49: ldc           #7                  // String ==0

51: invokevirtual #4                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V

54: return

if_icmpge 14 栈顶弹出两个值，并且比较两个数值，如果第的二个值大于或等于第一个，跳转到偏移位14

if_icmpne  28 栈顶弹出两个值，并且比较两个数值，如果第的二个值不等于第一个，跳转到偏移位28

ifne 54 当栈顶int型数值不等于0时跳转到偏移位54

传参例子public class minmax

{

public static int min (int a, int b)

{

if (a>b)

return b;

return a;

}

public static int max (int a, int b)

{

if (a>b)

return a;

return b;

}

public static void main(String[] args)

{

int a=123, b=456;

int max_value=max(a, b);

int min_value=min(a, b);

System.out.println(min_value);

System.out.println(max_value);

}

}

反编译public static void main(java.lang.String[]);

descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=5, args_size=1

0: bipush        123

2: istore_1

3: sipush        456

6: istore_2

7: iload_1

8: iload_2

9: invokestatic  #2                  // Method max:(II)I

12: istore_3

13: iload_1

14: iload_2

15: invokestatic  #3                  // Method min:(II)I

18: istore        4

20: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;

23: iload         4

25: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V

28: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;

31: iload_3

32: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V

35: return

istore_1 将栈顶元素弹出并存到本地变量数组1号元素，因为0号给了this

位操作public class bitop

{

public static int set (int a, int b)

{

return a | 1<

}

public static int clear (int a, int b)

{

return a & (~(1<

}

}

反编译public static int set(int, int);

descriptor: (II)I

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=3, locals=2, args_size=2

0: iload_0

1: iconst_1

2: iload_1

3: ishl

4: ior

5: ireturn

LineNumberTable:

line 5: 0

public static int clear(int, int);

descriptor: (II)I

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=3, locals=2, args_size=2

0: iload_0

1: iconst_1

2: iload_1

3: ishl

4: iconst_m1

5: ixor

6: iand

7: ireturn

LineNumberTable:

line 10: 0

set函数的指令解释

0: iload_0 //载入第0个参数即a，压入栈

1: iconst_1 //数字1压入栈

2: iload_1 ///载入第1个参数即b，压入栈

3: ishl //弹出栈顶两个元素，将int型数值左移位指定位数并将结果压入栈顶，第一个弹出值(b)为左移的位数，第二个弹出的值(1)为要对其进行左移的数，即对1左移b位

4: ior //将栈顶两int型数值作“按位或”并将结果压入栈顶

5: ireturn //返回栈顶值

clear函数中iconst_m1指令将-1压入栈，-1就是16进制的0xFFFFFFFF， ixor是进行异或操作，操作结果相当于取反

将上面的例子扩展成long类型public class longbitop

{

public static long lset (long a, int b)

{

return a | 1<

}

public static long lclear (long a, int b)

{

return a & (~(1<

}

}

反编译public static long lset(long, int);

descriptor: (JI)J

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=4, locals=3, args_size=2

0: lload_0

1: iconst_1

2: iload_2

3: ishl

4: i2l

5: lor

6: lreturn

LineNumberTable:

line 5: 0

public static long lclear(long, int);

descriptor: (JI)J

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=4, locals=3, args_size=2

0: lload_0

1: iconst_1

2: iload_2

3: ishl

4: iconst_m1

5: ixor

6: i2l

7: land

8: lreturn

LineNumberTable:

line 9: 0

需要注意的指令

i2l 将栈顶int型数值强制转换成long型数值并将结果压入栈顶

32位需要升级为64位值时，会使用i21指令把整型扩展成64位长整型.

循环

看个简单的例子public class Loop

{

public static void main(String[] args)

{

for (int i = 1; i <= 10; i++)

{

System.out.println(i);

}

}

}

反编译public static void main(java.lang.String[]);

descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=2, args_size=1

0: iconst_1

1: istore_1

2: iload_1

3: bipush        10

5: if_icmpgt     21

8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

11: iload_1

12: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V

15: iinc          1, 1

18: goto          2

21: return

指令解释

0: iconst_1 //常数1压入栈

1: istore_1 //栈顶弹出存入本地变量数组1号元素

2: iload_1 //本地变量1号元素压入栈顶

3: bipush        10 //常数10压入栈顶

5: if_icmpgt     21 //  比较栈顶两int型数值大小，当结果大于0时跳转到偏移位21，比较都是拿第二个弹出值与第一个比较即i与10比较

8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

11: iload_1

12: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V //8~12这里输出变量i

15: iinc          1, 1  //将指定int型变量增加指定值(常用于i++,i--,i+=2) ，这里指本地变量1号元素加1

18: goto          2 //跳转到偏移位2

21: return

多说一句，我们调用println打印数据类型是整型，我们看注释，“(I)V”，I的意思是整型，V的意思是返回void

再看个复杂的，斐波那契数列public class Fibonacci

{

public static void main(String[] args)

{

int limit = 20, f = 0, g = 1;

for (int i = 1; i <= limit; i++)

{

f = f + g;

g = f - g;

System.out.println(f);

}

}

}

反编译public static void main(java.lang.String[]);

descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=5, args_size=1

0: bipush        20

2: istore_1

3: iconst_0

4: istore_2

5: iconst_1

6: istore_3

7: iconst_1

8: istore        4

10: iload         4

12: iload_1

13: if_icmpgt     37

16: iload_2

17: iload_3

18: iadd

19: istore_2

20: iload_2

21: iload_3

22: isub

23: istore_3

24: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

27: iload_2

28: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V

31: iinc          4, 1

34: goto          10

37: return

拿几个指令说一下

if_icmpgt 37 比较栈顶两int型数值大小，当结果大于0时跳转到偏移位37，比较都是拿栈的第二个弹出值(本地变量4号)与第一个比较(本地变量1号)

isub 栈顶的两个元素相减并将结果压入栈顶，谁减谁，仍然是栈顶弹出的第二个减第一个

iinc 4, 1 表示是本地变量4号元素加1，结果存在本地变量4号

这里的英文作者又吐槽了一下

8: istore        4

10: iload         4

这两句中的iload 4，感觉多余。。

switch例子public class tableswitch {

public static void f(int a) {

switch (a) {

case 0:

System.out.println("zero");

break;

case 1:

System.out.println("one\n");

break;

case 2:

System.out.println("two\n");

break;

case 3:

System.out.println("three\n");

break;

case 4:

System.out.println("four\n");

break;

default:

System.out.println("something unknown\n");

break;

}

}

}

反编译public static void f(int);

descriptor: (I)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=1, args_size=1

0: iload_0

1: tableswitch   { // 0 to 4

0: 36

1: 47

2: 58

3: 69

4: 80

default: 91

}

36: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

39: ldc           #3                  // String zero

41: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

44: goto          99

47: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

50: ldc           #5                  // String one\n

52: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

55: goto          99

58: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

61: ldc           #6                  // String two\n

63: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

66: goto          99

69: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

72: ldc           #7                  // String three\n

74: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

77: goto          99

80: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

83: ldc           #8                  // String four\n

85: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

88: goto          99

91: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;

94: ldc           #9                  // String something unknown\n

96: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

99: return

其中需要注意的是tableswitch是在JVM级别上直接支持switch 语句，非常有意思的是，编译器编译的时候，会根据case条件的不同翻译成tableswitch或者lookupswitch

1: tableswitch   { // 0 to 4

0: 36

1: 47

2: 58

3: 69

4: 80

default: 91

}

的意思，将栈顶元素与大括号内冒号前的元素逐个比较，若相等，则跳转到右边对应的偏移块号

break对应其中的goto 99，如果没有这句，栈顶元素会继续和后面的大括号内后续元素进行比较

weixin_39640395
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
带你阅读Java字节码
吴庆龙的个人博客
11-06 292
文章目录概述一、如何生成字节码？二、字节码指令1、加载和存储指令2、运算指令（运算结果会自动入栈）3、类型转换4、对象的创建及访问5、数组6、流程控制7、方法调用和返回指令（调用之后数据依然在操作数栈中）8、返回值指令三、阅读字节码文件四、指令总结 概述 java bytecode 由单字节（byte）的指令组成，理论上最多支持 256 个操作码（opcode），实际上 Java 只使用了 200 个左右的操作码，还有一些操作码则保留给调试操作。 根据指令的性质，主要分为四大类： 栈操作指令，包括与局部变
java8 filter 取反_Java8新特性-用法详解（一）Stream
weixin_35000379的博客
02-13 1689
JAVA8新特性-用法详解JAVA8新特性-用法详解Predicate接口Predicate 接口只能接收一个参数，且返回 boolean 类型。类似于 Assert 的自定义断言例子：Predicate predicate = new Predicate() {@Overridepublic boolean test(String s) {return s.equals("张三");}};Pre...
java ifne_Java逆向基础之条件跳转位运算循环
weixin_39540934的博客
02-16 327
条件跳转的例子，绝对值publicclassabs{publicstaticintabs(inta){if(a<0)return-a;returna;}}编译javacabs.java反编译javap-c-verboseabs.classpublicstaticintabs(int...
java8 filter 取反_Java8-6-Predicate接口详解
weixin_35012566的博客
02-13 872
上一篇我们学习了Function和BiFunction函数式接口，本篇继续了解下其他常用的函数式接口。先来看下PredicatePredicate函数式接口的主要作用就是提供一个test方法，接受一个参数返回一个布尔类型，Predicate在stream api中进行一些判断的时候非常常用。@FunctionalInterfacepublic interface Predicate {/*** E...
stream filter_恕我直言你可能真的不会java第3篇：Stream的Filter与谓词逻辑
weixin_39955421的博客
11-26 264
一、基础代码准备 建立一个实体类，该实体类有五个属性。下面的代码使用了lombok的注解Data、AllArgsConstructor，这样我们就不用写get、set方法和全参构造函数了。lombok会帮助我们在编译期生成这些模式化的代码。 @Data @AllArgsConstructor public class Employee { private Integer id; p...
Android逆向-实战so分析-某洲_v3.5.8_unidbg学习
哔_哩哩!的博客
07-20 5117
文章目录1.unidbg的介绍2.unidbg的安装2.1.下载unidbg工具2.2.导入IDEA2.3.验证导入是否成功3.unidbg的使用3.1.目标方法静态分析3.2.模拟执行目标方法3.3.算法分析3.3.1.OLLVM去混淆3.3.2.指令级TraceJNIEnv、jobject、jclassJNIEnv指针是什么东西？jobject和jclass又有什么区别？ 1.unidbg的介绍 unidbg是一款基于unicorn的用来模拟执行so的逆向工具，可以让安全研究人员直接在PC上运行andr
Java面试题整理
ZHAOHUODIAN888的博客
08-29 460
动态代理就是，在程序运行期，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。反射是动态获取信息以及动态调用对象方法的一种机制。Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。...
2022Java后端实习春招面试题整理(含答案) 备战秋招
uuqaz的博客
06-28 2537
既是编译性语言（需要由编译器编译为.class字节码文件），又是解释性语言（需要由JVM读一行执行一行，由解释器解释为操作系统能执行的命令）Java的编译器是javac.exe，解释器是java.exe简称散列算法，是将一个大文件映射成一个小串字符。与指纹一样，就是以较短的信息来保证文件的唯一性的标志，这种标志与文件的每一个字节都相关，而且难以找到逆向规律。好处：1） 在庞大的数据库中，由于哈希值更为短小，被找到更为容易，因此，哈希使数据的存储与查询速度更快。2） 哈希能对信息进行加密处理，使得数据传播更为
Java开发面试题——很有帮助的
m0_46891419的博客
06-19 3242
面试题 一、Java 1.运行机制 1)Java跨平台原理 Java实现跨平台是JVM(Java虚拟机)起的作用。如果是C/C++的编译方式，一旦换了一个平台，那么就需要重新编译一份对应的可执行代码，但是Java则不同，编译好了一份Java字节码，换到不同的平台上时，并不需要重新编译，前提是这些平台上都安装了相应平台的JVM，JVM不是跨平台的。 2)垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？ 垃圾回收器通常是作为一个单独的低级别的线程运行，在不可预知的
java8 filter 取反_「java8系列」神奇的函数式接口
weixin_31856441的博客
02-13 611
前言在上一篇Lambda的讲解中我们就提到过函数式接口，比如：Consumer consumer = (s) -> System.out.println(s);其中Consumer就是一个函数式接口。这里是通过Lambda表达式创建了一个函数式接口的对象。如果不知道什么是Lambda，请看《神秘的Lambda》。函数式接口是什么？有且只有一个抽象方法的接口被称为函数式接口，函数式接口适用于函...
Java运算符、if
最新发布
等,一起的博客
02-24 201
程序运算的符号： 赋值运算、算术运算、关系运算、逻辑运算、三目运算 流程控制语句： 流程，程序的执行流程：
java字节码提取if语句_终于找到了！有了它你就可以读懂字节码了！
weixin_39849153的博客
02-28 273
该楼层疑似违规已被系统折叠隐藏此楼查看此楼0x80 ior 将栈顶两int型数值作“按位或”并将结果压入栈顶0x81 lor 将栈顶两long型数值作“按位或”并将结果压入栈顶0x82 ixor 将栈顶两int型数值作“按位异或”并将结果压入栈顶0x83 lxor 将栈顶两long型数值作“按位异或”并将结果压入栈顶0x84 iinc 将指定int型变量增加指定值(i++,i--,i+=2)0x...
Java：通过字节码看if-else和switch-case
bdmh的专栏
03-26 1006
条件语句是我们使用非常频繁的语法之一，其中if-else和switch-case最为常用，那很多同学也会有疑惑，这两种方式有什么区别，哪个效率更高一些呢。接下来我们就从字节码的角度，看看这两种方法的实现。 先来看看if-else。 public void foo(int i) { if (i == 1) System.out.println(1); else ...
linux 表达式(= <> > < >= <=)
Daniel's Blog
12-17 2884
eq   等于; ne 不等于 ; gt   大于;lt  小于;ge 大于等于 ;le 小于等于;
java8 filter 取反_java8新特性之stream的collect实战教程
weixin_31616803的博客
02-16 1002
1、list转换成list不带return方式List ids=wrongTmpList.stream().map(c->c.getId()).collect(Collectors.toList());带return方式// spu集合转化成spubo集合//java8的新特性List spuBos=spuList.stream().map(spu -> {SpuBo spuBo = ...
java将不规律的文字放在数组_java层逆向分析方Dalvik指令集
weixin_31446915的博客
01-26 1058
点击蓝字默默关注Dalvik的指令格式：基础字节码 - 名称后缀/字节码后缀 目的寄存器 源寄存器(连接符号“- ”在有的指令里是可以不存在的)名称后缀是wide，表示数据宽度为64位字节码后缀是from16，表示源寄存器为16位例如：move-wide/from16 vAA,VBBBB：move为基础字节码:即opcode。wide为名称后缀:标识指令操作的数据宽度为64位。from...
java8 filter 取反_java8之Stream API（filter,map和flatMap方法）
weixin_29619665的博客
02-13 1083
流转换是指从一个流中读取数据，并将转换后的数据写入到另一个流中。前面介绍过过滤器转换，它会产生一个新的流，其中包含符合某个特定条件的所有元素：ListwordList=......;Streamwords=wordList.stream();StreamlongWords=words.filter(w->w.length()>12);filter方法的参数是一...
Java命令里面的EQ、NE、GT、LT、GE、LE分别代表含义
热门推荐
无名
01-12 14万+
不废话，直接上车:EQ 就是 EQUAL等于 NE就是 NOT EQUAL不等于 GT 就是 GREATER THAN大于　 LT 就是 LESS THAN小于 GE 就是 GREATER THAN OR EQUAL 大于等于 LE 就是 LESS THAN OR EQUAL 小于等于关注博客关注更多文章
Java8 Stream API详解：高效数据处理与并行运算
"java8 Stream特性讲解" Java 8 引入了 Stream API，这是一个强大的工具，允许开发者以声明式的方式处理数据源，如集合、数组等。Stream API的核心理念是创建一个数据处理的管道，其中数据源（如集合、数组）通过一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值