精华内容
下载资源
问答
  • java反汇编指令.doc

    2020-06-04 15:45:09
    java反汇编指令
  • 反汇编指令与机器码对照表,按字母排序,有索引,有对应的英文解释,非常方便,可以用360极速浏览器打开
  • 反汇编指令与机器码对照表

    热门讨论 2011-07-20 22:02:33
    反汇编指令与机器码对照表,按字母排序,有索引,非常方便
  •  objdump命令参考:https://blog.csdn.net/zoomdy/article/details/50563680 本文以最简单的程序开始,剖析反汇编之后的程序最小执行系统以及初始化、判断语句、循环语句以及函数及其调用过程在反汇编指令集中的...

            因近期工作需要,需要利用objdump工具剖析程序指定可执行程序,以检查错误函数(语句)。

            objdump命令参考:https://blog.csdn.net/zoomdy/article/details/50563680


            本文以最简单的程序开始,剖析反汇编之后的程序最小执行系统以及初始化、判断语句、循环语句以及函数及其调用过程在反汇编指令集中的形式,方便在工作过程中的异常程序中寻找异常地址。

            文件组成:

            最简文件组成:main.c Makefile

            Makefile代码:

    TRGET = main.out
    
    all: clean $(TRGET)
    
    $(TRGET):main.o
    	cc main.o -o $(TRGET) 
    main.o:
    
    clean:
    	rm -f *.o;rm -f *.out
    
    

            编辑方式:以挂载的方式挂载到linux系统上,编辑在Window上的NotePad++

            从最简程序开始:(这是我能想到最简单的程序了)

    #include <stdio.h>
    
    int main()
    {
    	return 0;
    }

            反汇编指令:

            objdump -C -S main.out > objdump_main_00.txt

            反汇编结果:

    main.out:     file format elf32-i386
    
    Disassembly of section .init:
    
    08048254 <_init>:
     8048254:	55                   	push   %ebp
     8048255:	89 e5                	mov    %esp,%ebp
     8048257:	83 ec 08             	sub    $0x8,%esp
     804825a:	e8 51 00 00 00       	call   80482b0 <call_gmon_start>
     804825f:	e8 a4 00 00 00       	call   8048308 <frame_dummy>
     8048264:	e8 87 01 00 00       	call   80483f0 <__do_global_ctors_aux>
     8048269:	c9                   	leave  
     804826a:	c3                   	ret    
    Disassembly of section .plt:
    
    0804826c <__libc_start_main@plt-0x10>:
     804826c:	ff 35 20 95 04 08    	pushl  0x8049520
     8048272:	ff 25 24 95 04 08    	jmp    *0x8049524
     8048278:	00 00                	add    %al,(%eax)
    	...
    
    0804827c <__libc_start_main@plt>:
     804827c:	ff 25 28 95 04 08    	jmp    *0x8049528
     8048282:	68 00 00 00 00       	push   $0x0
     8048287:	e9 e0 ff ff ff       	jmp    804826c <_init+0x18>
    Disassembly of section .text:
    
    0804828c <_start>:
     804828c:	31 ed                	xor    %ebp,%ebp
     804828e:	5e                   	pop    %esi
     804828f:	89 e1                	mov    %esp,%ecx
     8048291:	83 e4 f0             	and    $0xfffffff0,%esp
     8048294:	50                   	push   %eax
     8048295:	54                   	push   %esp
     8048296:	52                   	push   %edx
     8048297:	68 ac 83 04 08       	push   $0x80483ac
     804829c:	68 58 83 04 08       	push   $0x8048358
     80482a1:	51                   	push   %ecx
     80482a2:	56                   	push   %esi
     80482a3:	68 34 83 04 08       	push   $0x8048334
     80482a8:	e8 cf ff ff ff       	call   804827c <__libc_start_main@plt>
     80482ad:	f4                   	hlt    
     80482ae:	90                   	nop    
     80482af:	90                   	nop    
    
    080482b0 <call_gmon_start>:
     80482b0:	55                   	push   %ebp
     80482b1:	89 e5                	mov    %esp,%ebp
     80482b3:	53                   	push   %ebx
     80482b4:	e8 00 00 00 00       	call   80482b9 <call_gmon_start+0x9>
     80482b9:	5b                   	pop    %ebx
     80482ba:	81 c3 63 12 00 00    	add    $0x1263,%ebx
     80482c0:	52                   	push   %edx
     80482c1:	8b 83 fc ff ff ff    	mov    0xfffffffc(%ebx),%eax
     80482c7:	85 c0                	test   %eax,%eax
     80482c9:	74 02                	je     80482cd <call_gmon_start+0x1d>
     80482cb:	ff d0                	call   *%eax
     80482cd:	58                   	pop    %eax
     80482ce:	5b                   	pop    %ebx
     80482cf:	c9                   	leave  
     80482d0:	c3                   	ret    
     80482d1:	90                   	nop    
     80482d2:	90                   	nop    
     80482d3:	90                   	nop    
    
    080482d4 <__do_global_dtors_aux>:
     80482d4:	55                   	push   %ebp
     80482d5:	89 e5                	mov    %esp,%ebp
     80482d7:	83 ec 08             	sub    $0x8,%esp
     80482da:	80 3d 38 95 04 08 00 	cmpb   $0x0,0x8049538
     80482e1:	74 0f                	je     80482f2 <__do_global_dtors_aux+0x1e>
     80482e3:	eb 1f                	jmp    8048304 <__do_global_dtors_aux+0x30>
     80482e5:	8d 76 00             	lea    0x0(%esi),%esi
     80482e8:	83 c0 04             	add    $0x4,%eax
     80482eb:	a3 34 95 04 08       	mov    %eax,0x8049534
     80482f0:	ff d2                	call   *%edx
     80482f2:	a1 34 95 04 08       	mov    0x8049534,%eax
     80482f7:	8b 10                	mov    (%eax),%edx
     80482f9:	85 d2                	test   %edx,%edx
     80482fb:	75 eb                	jne    80482e8 <__do_global_dtors_aux+0x14>
     80482fd:	c6 05 38 95 04 08 01 	movb   $0x1,0x8049538
     8048304:	c9                   	leave  
     8048305:	c3                   	ret    
     8048306:	89 f6                	mov    %esi,%esi
    
    08048308 <frame_dummy>:
     8048308:	55                   	push   %ebp
     8048309:	89 e5                	mov    %esp,%ebp
     804830b:	83 ec 08             	sub    $0x8,%esp
     804830e:	a1 4c 94 04 08       	mov    0x804944c,%eax
     8048313:	85 c0                	test   %eax,%eax
     8048315:	74 19                	je     8048330 <frame_dummy+0x28>
     8048317:	b8 00 00 00 00       	mov    $0x0,%eax
     804831c:	85 c0                	test   %eax,%eax
     804831e:	74 10                	je     8048330 <frame_dummy+0x28>
     8048320:	83 ec 0c             	sub    $0xc,%esp
     8048323:	68 4c 94 04 08       	push   $0x804944c
     8048328:	ff d0                	call   *%eax
     804832a:	83 c4 10             	add    $0x10,%esp
     804832d:	8d 76 00             	lea    0x0(%esi),%esi
     8048330:	c9                   	leave  
     8048331:	c3                   	ret    
     8048332:	90                   	nop    
     8048333:	90                   	nop    
    
    08048334 <main>:
     8048334:	55                   	push   %ebp
     8048335:	89 e5                	mov    %esp,%ebp
     8048337:	83 ec 08             	sub    $0x8,%esp
     804833a:	83 e4 f0             	and    $0xfffffff0,%esp
     804833d:	b8 00 00 00 00       	mov    $0x0,%eax
     8048342:	83 c0 0f             	add    $0xf,%eax
     8048345:	83 c0 0f             	add    $0xf,%eax
     8048348:	c1 e8 04             	shr    $0x4,%eax
     804834b:	c1 e0 04             	shl    $0x4,%eax
     804834e:	29 c4                	sub    %eax,%esp
     8048350:	b8 00 00 00 00       	mov    $0x0,%eax
     8048355:	c9                   	leave  
     8048356:	c3                   	ret    
     8048357:	90                   	nop    
    
    08048358 <__libc_csu_init>:
     8048358:	55                   	push   %ebp
     8048359:	89 e5                	mov    %esp,%ebp
     804835b:	57                   	push   %edi
     804835c:	56                   	push   %esi
     804835d:	53                   	push   %ebx
     804835e:	83 ec 0c             	sub    $0xc,%esp
     8048361:	e8 00 00 00 00       	call   8048366 <__libc_csu_init+0xe>
     8048366:	5b                   	pop    %ebx
     8048367:	81 c3 b6 11 00 00    	add    $0x11b6,%ebx
     804836d:	e8 e2 fe ff ff       	call   8048254 <_init>
     8048372:	8d 83 20 ff ff ff    	lea    0xffffff20(%ebx),%eax
     8048378:	8d 93 20 ff ff ff    	lea    0xffffff20(%ebx),%edx
     804837e:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
     8048381:	29 d0                	sub    %edx,%eax
     8048383:	31 f6                	xor    %esi,%esi
     8048385:	c1 f8 02             	sar    $0x2,%eax
     8048388:	39 c6                	cmp    %eax,%esi
     804838a:	73 16                	jae    80483a2 <__libc_csu_init+0x4a>
     804838c:	89 d7                	mov    %edx,%edi
     804838e:	89 f6                	mov    %esi,%esi
     8048390:	ff 14 b2             	call   *(%edx,%esi,4)
     8048393:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
     8048396:	29 f9                	sub    %edi,%ecx
     8048398:	46                   	inc    %esi
     8048399:	c1 f9 02             	sar    $0x2,%ecx
     804839c:	39 ce                	cmp    %ecx,%esi
     804839e:	89 fa                	mov    %edi,%edx
     80483a0:	72 ee                	jb     8048390 <__libc_csu_init+0x38>
     80483a2:	83 c4 0c             	add    $0xc,%esp
     80483a5:	5b                   	pop    %ebx
     80483a6:	5e                   	pop    %esi
     80483a7:	5f                   	pop    %edi
     80483a8:	c9                   	leave  
     80483a9:	c3                   	ret    
     80483aa:	89 f6                	mov    %esi,%esi
    
    080483ac <__libc_csu_fini>:
     80483ac:	55                   	push   %ebp
     80483ad:	89 e5                	mov    %esp,%ebp
     80483af:	57                   	push   %edi
     80483b0:	56                   	push   %esi
     80483b1:	53                   	push   %ebx
     80483b2:	e8 00 00 00 00       	call   80483b7 <__libc_csu_fini+0xb>
     80483b7:	5b                   	pop    %ebx
     80483b8:	81 c3 65 11 00 00    	add    $0x1165,%ebx
     80483be:	8d 83 20 ff ff ff    	lea    0xffffff20(%ebx),%eax
     80483c4:	8d bb 20 ff ff ff    	lea    0xffffff20(%ebx),%edi
     80483ca:	29 f8                	sub    %edi,%eax
     80483cc:	c1 f8 02             	sar    $0x2,%eax
     80483cf:	83 ec 0c             	sub    $0xc,%esp
     80483d2:	8d 70 ff             	lea    0xffffffff(%eax),%esi
     80483d5:	eb 05                	jmp    80483dc <__libc_csu_fini+0x30>
     80483d7:	90                   	nop    
     80483d8:	ff 14 b7             	call   *(%edi,%esi,4)
     80483db:	4e                   	dec    %esi
     80483dc:	83 fe ff             	cmp    $0xffffffff,%esi
     80483df:	75 f7                	jne    80483d8 <__libc_csu_fini+0x2c>
     80483e1:	e8 2e 00 00 00       	call   8048414 <_fini>
     80483e6:	83 c4 0c             	add    $0xc,%esp
     80483e9:	5b                   	pop    %ebx
     80483ea:	5e                   	pop    %esi
     80483eb:	5f                   	pop    %edi
     80483ec:	c9                   	leave  
     80483ed:	c3                   	ret    
     80483ee:	90                   	nop    
     80483ef:	90                   	nop    
    
    080483f0 <__do_global_ctors_aux>:
     80483f0:	55                   	push   %ebp
     80483f1:	89 e5                	mov    %esp,%ebp
     80483f3:	53                   	push   %ebx
     80483f4:	52                   	push   %edx
     80483f5:	bb 3c 94 04 08       	mov    $0x804943c,%ebx
     80483fa:	a1 3c 94 04 08       	mov    0x804943c,%eax
     80483ff:	eb 0a                	jmp    804840b <__do_global_ctors_aux+0x1b>
     8048401:	8d 76 00             	lea    0x0(%esi),%esi
     8048404:	83 eb 04             	sub    $0x4,%ebx
     8048407:	ff d0                	call   *%eax
     8048409:	8b 03                	mov    (%ebx),%eax
     804840b:	83 f8 ff             	cmp    $0xffffffff,%eax
     804840e:	75 f4                	jne    8048404 <__do_global_ctors_aux+0x14>
     8048410:	58                   	pop    %eax
     8048411:	5b                   	pop    %ebx
     8048412:	c9                   	leave  
     8048413:	c3                   	ret    
    Disassembly of section .fini:
    
    08048414 <_fini>:
     8048414:	55                   	push   %ebp
     8048415:	89 e5                	mov    %esp,%ebp
     8048417:	53                   	push   %ebx
     8048418:	e8 00 00 00 00       	call   804841d <_fini+0x9>
     804841d:	5b                   	pop    %ebx
     804841e:	81 c3 ff 10 00 00    	add    $0x10ff,%ebx
     8048424:	50                   	push   %eax
     8048425:	e8 aa fe ff ff       	call   80482d4 <__do_global_dtors_aux>
     804842a:	59                   	pop    %ecx
     804842b:	5b                   	pop    %ebx
     804842c:	c9                   	leave  
     804842d:	c3                   	ret    
    
    
    

            由此可见执行程序的最简形式,也是最基本的组成部分:.init段、.plt段、.text段等。

            在此基础之上分别在main函数里添加初始化语句,反汇编之,并利用BCompare等软件对比不同,即可发现初始化语句在反汇编指令中的形式,方便之后对较大程序的反汇编指令阅读。

            以下为本次实验步骤:

            

            这里给出for语句以及调用函数时反汇编指令,初始化、调用系统函数等语句的反汇编,读者可利用main.c和Makefile以及objdump指令自行实验。

            

            

            

    展开全文
  • 浮点数反汇编指令

    2019-10-01 23:11:16
    ;//////////////////////////////////////////////////////////////////////////////// ...//// 浮点数载入指令 ;/////////////////////////////////////////////////////////////////////...
    ;////
    
    ;////                     浮点数载入指令 
    
    ;///
    
    ;助记符 操作数          功能 
    
    fld   memory(real)    ; 将存储器中的实型压人堆栈 
    
    fild  memory(integer) ;将存储器的整型数值转化为浮点数并压人堆栈 
    
    fbld  memory(BCD)     ;将存储器的BCD码转化为浮点数并压人堆栈 
    
    fld    st(num)        ;将浮点型寄存器中的数值压入堆栈 
    
    fld1  (none)          ;1.0压人堆栈 
    
    fldz  (none)          ;0.0压人堆栈 
    
    fldpi (none)         ;Π(pi) 压人堆栈 
    
    fldl2e (none)         ;log2(e)压人堆栈 
    
    fldl2t (none)         ;log2(10)压人堆栈 
    
    fldlg2 (none)         ;log10(2)压人堆栈 
    
    fldln2 (none)         ;loge(2)压人堆栈 
    
    finit (none)         ; 初始化浮点型单元,并清空8个寄存器的内容 
    
     
    
    ;////
    
    ;////                  浮点数数据存储指令 
    
    ;///
    
    ;助记符 操作数          功能 
    
    fst    st(num)         ;复制st的值来替换st(num)的内容;只有st(num)是受到影响 
    
    fstp   st(num)         ;复制st的值来替换st(num)的内容;st出栈 
    
    fst    memory(real)    ;复制st的值为实型数,存入存储器;堆栈不受影响 
    
    fstp   memory(real)    ;复制st的值为实型数,存入存储器;st出栈 
    
    fist   memory(integer) ;复制st的值,并转换为整型数存入存储器 
    
    fistp  memory(integer) ;复制st的值,并转换为整型数存入存储器;st出栈 
    
    fbstp  memory(BCD)     ;复制st的值,并转换为BCD码存入存储器;st出栈 
    
    fxch   (none)          ;互换st和st(1) 
    
    fxch   st(num)         ;互换st和st(num) 
    
     
    
    ;///
    
    ;///                 浮点型加法指令 
    
    ;//
    
    ;助记符 操作数          功能 
    
    fadd   (none)          ; 将st和st(1)出栈;将两个值相加;并将它们的和入栈 
    
    fadd   st(num),st      ;将st(num)和st相加;用和替换st(num) 
    
    fadd   st,st(num)      ;将st和st(num)相加;用和替换st 
    
    fadd   memory(real)    ; 将st和存储器中的实型数相加;用和替换st 
    
    fiadd  memory(integer) ;将st和存储器中的整型数相加,用和替换st 
    
    faddp  st(num),st      ;将st(num)和st相加,用和来替换st(num),将st出栈
    
     
    
    ;//
    
    ;///                 浮点型乘法指令 
    
    ;//
    
    ; 助记符 操作数          功能 
    
    fmul     (none)         ;将st和st(1)出栈;并将它们的值相乘;乘积人栈 
    
    fmul    st(num),st      ;将st(num)和st相乘;用乘积来替换st(num) 
    
    fmul    st,st(num)      ;将st和st(num)相乘;用乘积来替换st 
    
    fmul    memory(real)    ;将st和存储器中的实型数相乘;用乘积来替换st 
    
    fimul   memory(integer) ;将st和存储器中的整型数相乘,用乘积来替换st 
    
    fmulp   st(num),st      ;将st(num)和st相乘;乘积来替换st(num);并将st出栈
    
     
    
    ;助记符 操作数          功能 
    
    fsub  (none)          ;将st和st(1)出栈,计算st(1)减st的值;将差入栈
    
    fsub  st(num),st      ;计算st(num)减st的值;用差值替换st(num) 
    
    fsub  st,st(num)      ;计算st减st(num)的值;用差值来替换st 
    
    fsub  memory(real)    ;计算st减存储器中的实型数的值;用差值来替换st 
    
    fisub memory(integer) ;计算st减存储器中的整型数的值;用差值替换st 
    
    fsubp st(num),st     ; 计算st(num)减st的值;用差值替换st(num);将st出栈 
    
    fsubr (none)         ;将st和st(1)出栈;计算st减st(1)的 值;将差值入栈 
    
    fsubr st(num),st     ; 计算st减st(num)的值,用差值替换st(num) 
    
    fsubr st,st(num)     ; 计算st(num)减st的值,用差值来替换st 
    
    fsubr memory(real)   ; 计算存储器中的实型数值减st的值,用差值替换st 
    
    fisubr memory(integer) ;计算存储器中的整型数值减st的值;用差值替换st 
    
    fsubrp st(num),st     ;计算st减st(num)的值,用差值替换st(num);将st出栈 
    
     
    
    ;//
    
    ;///                     浮点型除法指令 
    
    ;//
    
    ;助记符 操作数          功能 
    
    fdiv   (none)         ;将st和st(1)出栈;计算st(1)/st的值;并将商入栈 
    
    fdiv   st(num),st     ;计算st(num)/st的值;用商来替换st(num) 
    
    fdiv   st,st(num)     ;计算st/st(num)的值;用商来替换st 
    
    fdiv   memory(real)   ;计算st/存储器中的实型数;用商来替换st 
    
    fidiv  memory(integer);计算st/存储器中的整型数;用商来替换st 
    
    fdivp  st(num),st     ;计算st(num)/st的值;用商来替换st(num);并将st出栈 
    
    fdivr  (none)         ;将st和st(1)出栈;计算st/st(1)的值;并将商入栈 
    
    fdivr  st(num),st     ;计算st/st(num)的值;用商来替换st(num) 
    
    fdivr  st,st(num)     ;计算st(num)/st的值;用商来替换st 
    
    fdivr  memory(real)   ;计算存储器中的实型数/st;商来替换st 
    
    fidivr memory(integer);计算存储器中的整型数/st;用商来替换st 
    
    fdivrp st(num),st    ;计算st/st(num)的值,用商来替换st(num);并将st出栈 
    
    
    ;//
    
    ;///                      附 加的浮点型指令 
    
    ;/////
    
    ; 助记符 操作数          功能 
    
    fabs   (none)         ;st := |st|(绝对值) 
    
    fchs   (none)         ;st := -st(相反数) 
    
    frndint (none)        ;对st取整 
    
    fsqrt  (none)         ;用st的平方根来替换st 
    
     
    
    ;/////
    
    ;///                      浮点型比较指令 
    
    ;////
    
    ;助记符 操作数          功能 
    
    fcom   (none)          ;比较st和st(1) 
    
    fcom   st(num)         ;比较st和st(num) 
    
    fcom   memory(real)    ;比较st和存储器中的实型数
    
    ficom  memory(integer) ;比较st和存储器中的整型数 
    
    ftst   (none)          ;比较st和0.0 
    
    fcomp  (none)          ;比较st和st(1);然后出栈 
    
    fcomp  st(num)         ;比较st和st(num);然后出栈 
    
    fcomp  memory(real)    ;比较st和存储器中的实型数;然后出栈
    
    fcomp  memory(integer) ;比较st和存储器中的整型数;然后出栈 
    
    fcompp (none)         ;比较st和st(1);然后两次出栈 
    
     
    
    ;////
    
    ;///                   混 合浮点型指令
    
    ;////
    
    ;助记符 操作数          功能 
    
    fstsw   memoryWORD     ;复制状态寄存器到存储器字 
    
    fstsw   ax              ;复制状态寄存器到ax寄存器 
    
    fstcw   memoryWORD     ;复制控制字寄存器到存储器 
    
    fldcw   memoryWORD     ;复制存储器字到控制字寄存器

     

    转载于:https://www.cnblogs.com/IMyLife/p/4826253.html

    展开全文
  • 一直在学习Java,碰到了... 知道有一日知道了java的反汇编 命令 javap。现将学习记录做一小结,以供自己以后翻看。如果有错误的地方,请指正1.javap是什么:where options include:-c Disassemble the code-classpat...

    一直在学习Java,碰到了很多问题,碰到了很多关于i++和++i的难题,以及最经典的String str = "abc" 共创建了几个对象的疑难杂症。 知道有一日知道了java的反汇编 命令  javap。现将学习记录做一小结,以供自己以后翻看。如果有错误的地方,请指正

    1.javap是什么:

    where options include:

    -c Disassemble the code

    -classpath Specify where to find user class files

    -extdirs Override location of installed extensions

    -help Print this usage message

    -J Pass directly to the runtime system

    -l Print line number and local variable tables

    -public Show only public classes and members

    -protected Show protected/public classes and members

    -package Show package/protected/public classes

    and members (default)

    -private Show all classes and members

    -s Print internal type signatures

    -bootclasspath Override location of class files loaded

    by the bootstrap class loader

    -verbose Print stack size, number of locals and args for met

    hods

    If verifying, print reasons for failure

    以上为百度百科里对它的描述,只是介绍了javap的一些参数和使用方法,而我们要用的就是这一个:-c Disassemble the code。

    明确一个问题:javap是什么? 网上有人称之为 反汇编器,可以查看java编译器为我们生成的字节码。通过它,我们可以对照源代码和字节码,从而了解很多编译器内部的工作。

    2.初步认识javap

    从一个最简单的例子开始:

    0818b9ca8b590ca3270a3433284dd417.png

    这个例子中,我们只是简单的声明了两个int型变量并赋上初值。下面我们看看javap给我们带来了什么:(当然执行javap命令前,你得首先配置好自己的环境,能用javac编译通过了,即:javac TestJavap.java )

    0818b9ca8b590ca3270a3433284dd417.png

    我们只看(方便起见,将注释写到每句后面)

    Code:

    0:   iconst_2     //把2放到栈顶 1:   istore_1     //把栈顶的值放到局部变量1中,即i中 2:   iconst_3    //把3放到栈顶 3:   istore_2     //把栈顶的值放到局部变量1中,即j中 4:   return

    是不是很简单?(当然,估计需要点数据结构的知识) ,那我们就补点java的关于堆栈的知识:

    对于 int i = 2;首先它会在栈中创建一个变量为i的引用,然后查找有没有字面值为2的地址,没找到,就开辟一个存放2这个字面值的地址,然后将i指向2的地址。

    看了这段话,再比较下上面的注释,是不是完全吻合?

    为了验证上面这一说法,我们继续实验:

    0818b9ca8b590ca3270a3433284dd417.png

    我们将 i 和 j的值都设为2。按照以上理论,在声明j的时候,会去栈中招有没有字面值为2的地址,由于在栈中已经有2这个字面值,便将j直接指向2的地址。这样,就出现了i与j同时均指向2的情况。

    拿出javap -c进行反编译:结果如下:

    0818b9ca8b590ca3270a3433284dd417.png

    Code:

    0:   iconst_2    //把2放到栈顶

    1:   istore_1    //把栈顶的值放到局部变量1中,即i中

    2:   iconst_2    //把2放到栈顶

    3:   istore_2    //把栈顶的值放到局部变量2中,即j中(i 和 j同时指向2)

    4:   return

    虽然这里说i和j同时指向2,但这里不等于说i和j指向同一块地址(java是不允许程序员直接修改堆栈中的数据的,所以就不要想着,我是不是可以 修改栈中的2,那样岂不是i和j的值都会变化。另:在编译器内部,遇到j=2;时,它就会重新搜索栈中是否有2的字面值,如果没有,重新开辟地址存放2的 值;如果已经有了,则直接将j指向这个地址。因此,就算j另被赋值为其他值,如j=4,j值的改变不会影响到i的值。)

    再来一个例子:

    0818b9ca8b590ca3270a3433284dd417.png

    还是javap -c

    0818b9ca8b590ca3270a3433284dd417.png

    Code:

    0:   iconst_2    //把2放到栈顶

    1:   istore_1    //把栈顶的值放到局部变量1中,即i中

    2:   iload_1     // 把i的值放到栈顶,也就是说此时栈顶的值是2

    3:   istore_2    //把栈顶的值放到局部变量2中,即j中

    4:   return

    看到这里是不是有点明确了?

    既然我们对javap有了一定的了解,那我们就开始用它来解决一些实际的问题:

    1.i++和++i的问题

    0818b9ca8b590ca3270a3433284dd417.png

    反编译结果为

    0818b9ca8b590ca3270a3433284dd417.png

    Code:

    0:   iconst_1

    1:   istore_1

    2:   iinc    1, 1 //这个个指令,把局部变量1,也就是i,增加1,这个指令不会导致栈的变化,i此时变成2了   5:   iconst_1

    6:   istore_2

    7:   iinc    2, 1//这个个指令,把局部变量2,也就是j,增加1,这个指令不会导致栈的变化,j此时变成2了

    10:  return

    可以看出,++在前在后,在这段代码中,没有任何不同。

    我们再看另一段代码:

    0818b9ca8b590ca3270a3433284dd417.png

    反编译结果:

    0818b9ca8b590ca3270a3433284dd417.png

    Code:

    0:   iconst_1

    1:   istore_1

    2:   iload_1

    3:   iinc    1, 1  //局部变量1(即i)加1变为2,注意这时栈中仍然是1,没有改变

    6:   istore_1    //把栈顶的值放到局部变量1中,即i这时候由2变成了1

    7:   iconst_1

    8:   istore_2

    9:   iinc    2, 1 //局部变量2(即j)加1变为2,注意这时栈中仍然是1,没有改变

    12:  iload_2    //把局部变量2(即j)的值放到栈顶,此时栈顶的值变为2

    13:  istore_2   //把栈顶的值放到局部变量2中,即j这时候真正由1变成了2

    14:  return

    是否看明白了? 如果这个看明白了,那么下面的一个问题应该就是迎刃而解了:

    0818b9ca8b590ca3270a3433284dd417.png

    m = m ++;这句话,java虚拟机执行时是这样的: m的值加了1,但这是栈中的值还是0, 马上栈中的值覆盖了m,即m变成0,因此不管循环多少次,m都等于0。

    如果改为m = ++m; 程序运行结果就是100了。。。

    展开全文
  • 寄存器、栈的存储方式、反汇编指令、逻辑运算 1.1 寄存器 1.1.1 寄存器含义 EAX : 扩展累加寄存器 EBX : 扩展基址寄存器 ECX : 扩展计数寄存器 EDX : 扩展数据寄存器 ESI : 扩展来源寄存器 EDI : 扩展目标...

    一开始就上手就逆向病毒还是挺困难的,总是感觉到自己的基础打得还不够扎实,所以重新对基础的反汇编知识再进行学习。

    1 知识点

    寄存器、栈的存储方式、反汇编指令、逻辑运算

    1.1 寄存器

    1.1.1 寄存器含义

    • EAX : 扩展累加寄存器
    • EBX : 扩展基址寄存器
    • ECX : 扩展计数寄存器
    • EDX : 扩展数据寄存器
    • ESI : 扩展来源寄存器
    • EDI : 扩展目标寄存器
    • EBP:扩展基址寄存器
    • ESP : 扩展堆栈指针寄存器
    • EIP : 扩展的指令指针寄存器

    这些寄存器的大小是32位(4个字节),他么可以容纳数据从0-FFFFFFFF(无符号数)

    1.1.2 有特殊含义的寄存器

    其他寄存器基本上可以随意使用,而以下三个比较特殊的寄存器则需要留意。

    • EBP: 主要用于栈和栈帧
    • ESP : 指向当前进程的栈空间地址
    • EIP : 总是指向下一条要被执行的指令

    1.2 栈的存储方式

    栈是内存中的一部分,有两个特殊的性质:

    • FILO(fisrt In Last Out 先进后出)
    • 地址反向增长(栈底为大地址,栈顶为小地址)

    1.2.1 先进后出

    例如有ABCDEF,那么push入栈的顺序就是最先进入的数据在栈底,然后后进的数据在之前的数据上方。先进入的入栈数据最后出来。

    PUSH入栈之前

    549050-20170417001703727-467826154.png

    入栈之后的数据存放关系

    549050-20170417001724196-271612561.png

    pop取出栈数据的顺序则是先进去的数据后出,后进去的数据先出

    549050-20170417001857227-956326997.png

    如果栈空间已经满了,依旧向栈push数据会造成栈顶溢出。

    如果栈的数据已经全部取出,再次pop则向下溢出,就会是栈空状态向下溢出。

    1.2.2 地址反向增长

    在栈中地址的存储方式为栈底存放的地址最大,栈顶存放的地址最小。

    549050-20170417001917321-497762050.png

    1.3 标志位

    • 32位的标志位寄存器有32个不同的标志位。

    • 每个标志位有两个属性:置1或置0

    在逆向中需要关心的标志位只有3个,Z/O/C

    ZF (Zero Flag): 零标志位。 它记录相关指令执行后,其结果是否为0。 
    OF (Overflow Flag): 溢出标志位。它记录了有符号数运算的结果是否发生了溢出。 
    CF (Carry Flag): 进位标志位。它记录了无符号数运算结果的最高位向更高位的进位值,或从更高位的借位值。 

    1.4 逻辑运算

    逻辑运算有一个很简单的口诀。

    • and 有一个为假,结果为假
    • or 有一个为真,结果为真
    • xor 两个为真或为假,结果都是假,两个对比数不同时,结果才为真。

    549050-20170417001947759-1172430474.png

    1.5 反汇编指令

    1.5.1 call指令

    call有以下几种方式:

    • call 40400h(地址) ;直接跳到函数或过程的地址
    • call eax ; 函数或过程地址存放在eax
    • call dword ptr [eax] ; eax中存放着地址,[]取eax的值。
    • call dword ptr [eax+5] ; dword是4个字节(两个字)
    • call dword ptr [<&API>] ;执行一个系统API,取一个API函数的地址

    1.5.2 mov指令

    • mov指令格式: mov dest , src

    mov指令将src的内容拷贝到dest,mov指令总共有以下几种扩展:

    • mov/movsb/movsw/movsd edi,esi ;这些变体按串/字节/字/双字为单位将esi寄存器指向的数据复制到edi寄存器指向的空间。

    mov还有两种扩展的形式:

    • movsx符号位扩展 , byte -> word,word -> dword(扩展后高位全用符号位填充),然后实现mov

    • movzx零扩展,byte -> word ,word -> dword(扩展位高位全用0填充),然后实现mov

    1.5.3 cmp指令

    • cmp指令格式:cmp dest , src

    cmp指令比较dest和src两个操作数,并通过比较结果设置C/O/Z标志位 。

    cmp 指令大概有以下几种格式:

    • cmp eax ,ebx ; 如果相等,z标志位置1,否则为0
    • cmp eax , [404000] ; 将eax和404000地址处的dword型数据相比较并同上置位。eax是一个dword型的数据(双字型),所以[40400]取的是一个dword型的数据值

    1.5.4 test指令

    • test指令格式:test dest , src

    这个指令是对两个操作数进行按位的与运算,与and指令唯一不同之处是不将"与"的结果保存到dest。

    test指令不会对两个操作数的内容进行修改,仅仅是在进行逻辑与运算后,对标志位进行重新置位。

    如果eax的值为0,那么 test eax ,eax 逻辑与运算后,z标志位会被置为1,如果eax不为0,那么zf标志位会被置为0。

    1.5.5 常用的跳转指令讲解

    破解或者逆向遇到很多的跳转指令,关于跳转指令可以参考下图,然后在参考下面的文字:

    549050-20170417002021306-1778636135.png

    
    1、判断单个标志位状态 
    
      这组指令单独判断5个状态标志之一,根据某一个状态标志是0或1决定是否跳转。 
    
      (1)JZ/JE和JNZ/JNE利用零标志ZF,判断结果是否为零(或相等) 
    
      JE指令(相等时转移) 
    
      JZ指令(等于0时转移) 
    
      这是当ZF=1时转移到目标地址的条件转移指令的两种助记符。这条指令既适用于判断无符号数的相等,又适用于判断带符号数的相等。 
    
      JNE指令(不相等转移) 
    
      JNZ指令(不等于0转移) 
    
      这是当ZF=0时能转移到目标地址的条件转移指令的两种助记符。这条指令也是既适用于判断无符号数,又适用于判断带符号数。 
    
      (2)JS和JNS利用符号标志SF,判断结果是正是负。 
    
      JS指令(为负转移)——当满足SF=1时,转移到目标地址 
    
      JNS指令(为正转移)——满足SF=0时,转移到目标地址 
    
      (3)JO和JNO利用溢出标志,判断结果是否产生溢出 
    
      JO指令(溢出转移)——OF=1时,转移到目标地址 
    
      JNO指令(未溢出转移)——OF=0时,转移到目标地址 
    
      (4)JP/JPE和JNP/JPO利用奇偶标志PF,判断结果中“1”的个数是偶是奇 
    
      JP/JPE指令(为偶转移)——满足PF=1时转移 
    
      JNP/JPO指令(为奇转移)——满足PF=0时转移 
    
      数据通讯为了可靠常要进行校验。常用的校验方法是奇偶校验,即把字符ASCII码的最高位用作校验位,是包括校验位在内的字符中为“1”的个数恒为奇数(奇校验),或恒为偶数(偶校验)。若采用奇校验,在字符ASCII中为“1”的个数已为奇数时,则令其最高位为“0”;否则令最高位为“1”。 
    
      (5)JC/JB/JNAE和JNC/JNB/JAE,利用进位标志CF,判断结果是否进位或借位,CF标志是比较常用的一个标志。 
    
      JC——满足CF=1时转移 JNC——满足CF=0时转移 
    
      JB(低于转移) JNB(不低于转移) 
    
      JNAE(不高于等于转移) JAE(高于等于转移) 
      
    2、用于比较无符号数高低 
    
      为区别有符号数的大小,无符号数的大小用高(Above)、低(Below)表示,它需要利用CF确定高低、利用ZF标志确定相等(Equal)。两数的高低分成4种关系:低于(不高于等于)、不低于(高于等于)、低于等于(不高于)、不低于等于(高于);也就分别对应4条指令:JB(JNAE)、JNB(JAE)、JBE(JNA)、JNBE(JA)。 
    
      JA/JNBE 
    
      JA即高于转移,JNBE即不低于且不等于转移,高于则没有进位产生,即CF=0,不等于则ZF=0,所以这两条指令满足CF=0且ZF=0时转移 
    
      JAE/JNB 
    
      高于或等于转移/不低于转移是当CF=0(高于就不产生进位)或ZF=1(等于)时转移。 
    
      JB/JNAE 
    
      即低于/不高于且不等于转移,是当CF=1(产生借位)且ZF=0(不相等)时转移。 
    
      JBE/JNA 
    
      即低于或等于/不高于转移,是当CF=1(借位产生)或ZF=1(相等)时转移。 
      
    3、用于比较有符号数大小 
    
    
      判断有符号数的大(Greater)、小(Less),需要组合OF、SF标志、并利用ZF标志确定相等与否。两数的大小分成4种关系:小于(不大于等于)、不小于(大于或等于)、小于等于(不大于)、不小于等于(大于);也就分别对应4条指令:JL(JNGE)、JNL(JGE)、JLE(JNG)、JNLE(JG)。 
    
      由上可见,条件转移指令之前常有CMP、TEST、加减运算、逻辑运算等影响标志的指令,利用这些指令执行后的标志或其组合状态形成条件。 
    
      JG/JNLE 
    
      大于/不小于且不等于转移,是当标志SF与OF同号(即<SF异或OF>=0)且ZF=0时转移 
    
      JGE/JNL 
    
      大于或等于/不小于转移,是当标志SF与OF同号(即<SF异或OF>=0)或ZF=0时转移 
    
      JL/JNGL 
    
      小于/不大于也不等于时转移,是当标志SF与OF异号(即<SF异或OF>=1)且ZF=0时转移【SF(符号标志位)、OF(溢出标志位)】
    
      JLE/LNG 
    
      小于或等于/不大于转移,是当标志SF与OF异号(即<SF异或OF>=1)或ZF=1时转移 
    
    
      
    4、判断计数器CX是否为0 
    
      JCXZ LABEL ;CX=0,则转移;否则顺序执行 
    

    1.6 反汇编指令-跳转练手程序

    reverseMe.exe是一个用来练手的crackme程序,适合用来熟悉反汇编中修改跳转指令的练习。

    打开的时候提示需要提供一个license文件(注册文件),然后需要提供正确的序列号。根据提示可以提炼出注册要求,满足以下两点程序就注册成功。

    • 1、提供正确的注册文件
    • 2、提供正确的注册序列号

    549050-20170418001022993-974070100.png

    OD载入这个程序,F8单步步过到0040107B这个地址处,call CreateFileA函数后的位置,前一条指令cmp eax,-0x01意思是比较Createfile函数返回值是否为0,修改ZF标志位。

    JNZ指令不等于0时实现跳转的条件,如果zf标志位为1,往下执行就会弹出一个提示框,然后ExitProcess结束进程。

    549050-20170418001710649-1629271442.png

    JNZ指令是根据标志位决定是否跳转,可以使用快捷键【空格键】或右键-汇编,将jnz改为jmp指令。就可以使其无条件跳转让程序朝着正确的顺序继续走了。

    往下走会有两个关键的跳转指令jmp与JL,对两个跳转的修改如下:

    jmp前一条指令是先对比注册文件是否为空,如果为空就跳转到错误提示处。

    004010AE test eax,eax ; 如果文件为空
    004010B0 jnz XreverseM.004010B4 ; 改成等于0的时候跳转
    004010B2 jmp XreverseM.004010F7

    jl前一条指令结合上下文理解,是对比序列号长度是否满足10个字符。

    004010B6 xor esi,esi
    004010B8 cmp dword ptr ds:[0x402173],0x10
    004010BF jl XreverseM.004010F7 ; 改成大于时跳转
    004010C1 mov al,byte ptr ds:[ebx+0x40211A]

    549050-20170418002014009-1938098555.png

    第一个指令jmp可以填充成nop,选中指令后OD界面中右键-二进制-用NOP填充。

    第二个指令JL是小于0时才执行跳转,那么把JL改成与它相反的JG指令就可以达到破解的目的了。

    修改后

    549050-20170418002034509-311340020.png

    F8单步步过到004010D6地址处,遇到第三个关键跳转。

    结合起来理解就是对比字符是否为0x47(G),否则就跳转到错误提示处,将这里的JL改成JG,或者是NOP掉就破解成功了

    549050-20170418002104899-1110590751.png

    修改后的反汇编代码

    549050-20170418002125602-872614674.png

    右键【复制到可执行文件】-【所有修改】

    549050-20170418002146712-1407810550.png

    在弹出的窗口中选择【全部复制】。

    549050-20170418002211681-1100341851.png

    再下一步弹出的对话框中,右键出菜单选择【保存文件】。

    549050-20170418002234384-1889389401.png

    破解成功界面

    549050-20170418002251977-1269487741.png

    汇编代码如下:

    00401000 >push 0x0                                 ; |/pModule = NULL
    00401002  call <jmp.&KERNEL32.GetModuleHandleA>    ; |\GetModuleHandleA
    00401007  mov dword ptr ds:[0x402177],eax          ; |
    0040100C  mov dword ptr ds:[0x402197],0x4003       ; |
    00401016  mov dword ptr ds:[0x40219B],reverseM.004>; |
    00401020  mov dword ptr ds:[0x40219F],0x0          ; |
    0040102A  mov dword ptr ds:[0x4021A3],0x0          ; |
    00401034  mov eax,dword ptr ds:[0x402177]          ; |
    00401039  mov dword ptr ds:[0x4021A7],eax          ; |
    0040103E  push 0x4                                 ; |/RsrcName = 4.
    00401040  push eax                                 ; ||hInst => NULL
    00401041  call <jmp.&USER32.LoadIconA>             ; |\LoadIconA
    00401046  mov dword ptr ds:[0x4021AB],eax          ; |
    0040104B  push 0x7F00                              ; |/RsrcName = IDC_ARROW
    00401050  push 0x0                                 ; ||hInst = NULL
    00401052  call <jmp.&USER32.LoadCursorA>           ; |\LoadCursorA
    00401057  mov dword ptr ds:[0x4021AF],eax          ; |
    0040105C  push 0x0                                 ; |/hTemplateFile = NULL
    0040105E  push reverseM.0040216F                   ; ||Attributes = READONLY|HIDDEN|SYSTEM|ARCHIVE|TEMPORARY|402048
    00401063  push 0x3                                 ; ||Mode = OPEN_EXISTING
    00401065  push 0x0                                 ; ||pSecurity = NULL
    00401067  push 0x3                                 ; ||ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
    00401069  push 0xC0000000                          ; ||Access = GENERIC_READ|GENERIC_WRITE
    0040106E  push reverseM.00402079                   ; ||FileName = "Keyfile.dat"
    00401073  call <jmp.&KERNEL32.CreateFileA>         ; |\CreateFileA
    00401078  cmp eax,-0x1                             ; |
    0040107B  jnz XreverseM.0040109A                   ;  JNZ指令(不等于0转移) ,那么会弹出一个提示框,然后结束进程
    0040107D  push 0x0                                 ; |/Style = MB_OK|MB_APPLMODAL
    0040107F  push reverseM.00402000                   ; ||Title = " Key File ReverseMe"
    00401084  push reverseM.00402017                   ; ||Text = "Evaluation period out of date. Purchase new license"
    00401089  push 0x0                                 ; ||hOwner = NULL
    0040108B  call <jmp.&USER32.MessageBoxA>           ; |\MessageBoxA
    00401090  call <jmp.&KERNEL32.ExitProcess>         ; \ExitProcess
    00401095  jmp reverseM.0040121D
    0040109A  push 0x0                                 ; /pOverlapped = NULL
    0040109C  push reverseM.00402173                   ; |pBytesRead = reverseM.00402173
    004010A1  push 0x46                                ; |BytesToRead = 46 (70.)
    004010A3  push reverseM.0040211A                   ; |Buffer = reverseM.0040211A
    004010A8  push eax                                 ; |hFile
    004010A9  call <jmp.&KERNEL32.ReadFile>            ; \ReadFile
    004010AE  test eax,eax                             ;  如果文件为空
    004010B0  jnz XreverseM.004010B4                   ;  改成等于0的时候跳转
    004010B2  jmp XreverseM.004010F7
    004010B4  xor ebx,ebx
    004010B6  xor esi,esi
    004010B8  cmp dword ptr ds:[0x402173],0x10
    004010BF  jl XreverseM.004010F7                    ;  改成大于时跳转
    004010C1  mov al,byte ptr ds:[ebx+0x40211A]
    004010C7  cmp al,0x0
    004010C9  je XreverseM.004010D3
    004010CB  cmp al,0x47
    004010CD  jnz XreverseM.004010D0
    004010CF  inc esi
    004010D0  inc ebx
    004010D1  jmp XreverseM.004010C1
    004010D3  cmp esi,0x8
    004010D6  jl XreverseM.004010F7
    004010D8  jmp reverseM.00401205
    004010DD  db 00

    链接: https://pan.baidu.com/s/1nu8ffPf 密码: uhbw

    参考文章

    常用的跳转指令 大集合
    http://www.jb51.net/softjc/17303.html

    转载于:https://www.cnblogs.com/17bdw/p/6721015.html

    展开全文
  • 指定反汇编目标文件时使用的架构,当待反汇编文件本身没有描述架构信息的时候(比如S-records),这个选项很有用。可以用-i选项列出这里能够指定的架构.这里例子中指定反汇编得到的目标文件使用ARM架构。 -b bfdname ...
  • 二、使用 GDB 进行程序基本的程序调试以及一些常用的调试指令 三、编译目标代码(.o文件) 一、简单C程序的编译与执行 使用“gedit hello.c”命令在主文件夹下创建一个 hello.c ,也可以选择输入"cd 桌面/test...
  • 这时会反汇编出一段汇编代码 2. u 地址1 地址2 这时会将地址1与地址2之间的数据反汇编成汇编代码. 3. ub 地址A 向前反汇编反汇编从地址A向前的一段代码 4. ub 地址A L长度B 不能用 ub 地址A 地址B ...
  • 一直在学习Java,碰到了... 知道有一日知道了java的反汇编 命令javap。现将学习记录做一小结,以供自己以后翻看。如果有错误的地方,请指正1.javap是什么:where options include:-c Disassemble the code-classpath ...
  •  知道有一日知道了java的反汇编 命令 javap。现将学习记录做一小结,以供自己以后翻看。如果有错误的地方,请指正 1.javap是什么:  where options include: -c Disassemble the code -...
  • 前言反汇编上篇文章中,我们详细分析了智能合约反汇编后的代码内容,包括多个反汇编指令的含义,数据在栈中的存储方式,并通过上下文关联关系梳理代码逻辑。本篇我们将继续分析上篇遗留的反汇编代码,通过上篇学习...
  • 浅析VS2010反汇编 2015年07月25日 21:53:11 阅读数:4374 ...1. 如何进行反汇编 ...在调试的环境下,我们可以很方便地通过反汇编窗口查看...看一个简单的程序及其生成的汇编指令 #include<stdio.h> ...
  • VS 反汇编方法及常用汇编指令介绍

    千次阅读 2016-08-17 21:49:22
    VS 反汇编方法及常用汇编指令介绍
  • 内容目录计算机寄存器分类简介计算机寄存器常用指令一、常用指令二、算术运算指令三、逻辑运算指令四、串指令五、程序跳转指令------------------------------------------计算机寄存器分类简介:32位CPU所含有的...
  • MIPS-sc MIPS-sc 为 MIPS simulator&compiler 的简称,是一个基于Qt实现的带...左侧为32位内存内容、可以以ascii码方式或反汇编指令方式查看; 右侧为寄存器、syscall输入输出窗口,可通过按钮查看相应寄存器与内
  • keil调试教程、反汇编技巧经验、ARM汇编指令
  • 该程序会将大多数RVIMFD64 ISA二进制指令(从二进制或十六进制代码)反汇编汇编指令。 之所以存在(以及它看起来有些“太原始”而无法发布)的原因是我试图学习指令格式以进行计算机体系结构考试。 长话短说,就...
  • 如何进行反汇编在调试的环境下,我们可以很方便地通过...图2:中断程序查看一个简单的程序及其生成的汇编指令#include#includeconst long Lenth=5060000/5;int main(){ while(true){ for(long i=0;i反汇编窗口图3...
  • 文章目录ARM 汇编指令集ARM 指令集分类ARM 指令编码ARM 指令格式解析常见 ARM 指令数据处理与杂项指令加载存储指令其他指令 ARM 汇编指令集 Android 平台的 ARM 汇编指令集根据架构支持类型的不同可分为四大类: ...
  • 学到第8章《教我兄弟学Android逆向08 IDA爆破签名验证》的时候,开始上手 ida pro 反汇编 so 库,在动手修改 so 库指令的时候遇到了困难,经过一番研究,终于搞懂了在 ida pro 中修改 so 库中 arm 汇编指令的方法,...
  • 文章目录Thumb 汇编指令集16 位 Thumb 指令编码16 位 Thumb 指令格式解析32 位 Thumb 指令编码32 位 Thumb 指令格式解析 Thumb 汇编指令集 作为 ARM 指令集的一个子集,针对代码密度问题提出,具有 16 位的指令宽度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,843
精华内容 737
关键字:

反汇编指令