Linux C反汇编

最新推荐文章于 2023-08-07 23:01:18 发布
最新推荐文章于 2023-08-07 23:01:18 发布
阅读量836 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chidaoqi1607/article/details/106256365
版权

一、有.c源文件(基于gcc)

asm.c

#include <stdio.h>

int main()
{
    int n = 1;
    int m = 2;

    int p = m + n;

    printf("p:%d\n", p);

    return 0;
}

使用gcc的-S功能

gcc -S asm.c

生成的汇编文件asm.s

	.file	"asm.c"
	.text
	.section	.rodata
.LC0:
	.string	"p:%d\n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	$1, -12(%rbp)
	movl	$2, -8(%rbp)
	movl	-8(%rbp), %edx
	movl	-12(%rbp), %eax
	addl	%edx, %eax
	movl	%eax, -4(%rbp)
	movl	-4(%rbp), %eax
	movl	%eax, %esi
	leaq	.LC0(%rip), %rdi
	movl	$0, %eax
	call	printf@PLT
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0"
	.section	.note.GNU-stack,"",@progbits

 

二、只有可执行文件(基于objdump)

如目前有可执行文件asm,输入

 objdump -d asm > asm.txt

生成比上面asm.s更详细的汇编文件asm.txt


asm：     文件格式 elf64-x86-64


Disassembly of section .init:

00000000000004f0 <_init>:
 4f0:	48 83 ec 08          	sub    $0x8,%rsp
 4f4:	48 8b 05 ed 0a 20 00 	mov    0x200aed(%rip),%rax        # 200fe8 <__gmon_start__>
 4fb:	48 85 c0             	test   %rax,%rax
 4fe:	74 02                	je     502 <_init+0x12>
 500:	ff d0                	callq  *%rax
 502:	48 83 c4 08          	add    $0x8,%rsp
 506:	c3                   	retq   

Disassembly of section .plt:

0000000000000510 <.plt>:
 510:	ff 35 aa 0a 20 00    	pushq  0x200aaa(%rip)        # 200fc0 <_GLOBAL_OFFSET_TABLE_+0x8>
 516:	ff 25 ac 0a 20 00    	jmpq   *0x200aac(%rip)        # 200fc8 <_GLOBAL_OFFSET_TABLE_+0x10>
 51c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000000520 <printf@plt>:
 520:	ff 25 aa 0a 20 00    	jmpq   *0x200aaa(%rip)        # 200fd0 <printf@GLIBC_2.2.5>
 526:	68 00 00 00 00       	pushq  $0x0
 52b:	e9 e0 ff ff ff       	jmpq   510 <.plt>

Disassembly of section .plt.got:

0000000000000530 <__cxa_finalize@plt>:
 530:	ff 25 c2 0a 20 00    	jmpq   *0x200ac2(%rip)        # 200ff8 <__cxa_finalize@GLIBC_2.2.5>
 536:	66 90                	xchg   %ax,%ax

Disassembly of section .text:

0000000000000540 <_start>:
 540:	31 ed                	xor    %ebp,%ebp
 542:	49 89 d1             	mov    %rdx,%r9
 545:	5e                   	pop    %rsi
 546:	48 89 e2             	mov    %rsp,%rdx
 549:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
 54d:	50                   	push   %rax
 54e:	54                   	push   %rsp
 54f:	4c 8d 05 aa 01 00 00 	lea    0x1aa(%rip),%r8        # 700 <__libc_csu_fini>
 556:	48 8d 0d 33 01 00 00 	lea    0x133(%rip),%rcx        # 690 <__libc_csu_init>
 55d:	48 8d 3d e6 00 00 00 	lea    0xe6(%rip),%rdi        # 64a <main>
 564:	ff 15 76 0a 20 00    	callq  *0x200a76(%rip)        # 200fe0 <__libc_start_main@GLIBC_2.2.5>
 56a:	f4                   	hlt    
 56b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000000570 <deregister_tm_clones>:
 570:	48 8d 3d 99 0a 20 00 	lea    0x200a99(%rip),%rdi        # 201010 <__TMC_END__>
 577:	55                   	push   %rbp
 578:	48 8d 05 91 0a 20 00 	lea    0x200a91(%rip),%rax        # 201010 <__TMC_END__>
 57f:	48 39 f8             	cmp    %rdi,%rax
 582:	48 89 e5             	mov    %rsp,%rbp
 585:	74 19                	je     5a0 <deregister_tm_clones+0x30>
 587:	48 8b 05 4a 0a 20 00 	mov    0x200a4a(%rip),%rax        # 200fd8 <_ITM_deregisterTMCloneTable>
 58e:	48 85 c0             	test   %rax,%rax
 591:	74 0d                	je     5a0 <deregister_tm_clones+0x30>
 593:	5d                   	pop    %rbp
 594:	ff e0                	jmpq   *%rax
 596:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
 59d:	00 00 00 
 5a0:	5d                   	pop    %rbp
 5a1:	c3                   	retq   
 5a2:	0f 1f 40 00          	nopl   0x0(%rax)
 5a6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
 5ad:	00 00 00 

00000000000005b0 <register_tm_clones>:
 5b0:	48 8d 3d 59 0a 20 00 	lea    0x200a59(%rip),%rdi        # 201010 <__TMC_END__>
 5b7:	48 8d 35 52 0a 20 00 	lea    0x200a52(%rip),%rsi        # 201010 <__TMC_END__>
 5be:	55                   	push   %rbp
 5bf:	48 29 fe             	sub    %rdi,%rsi
 5c2:	48 89 e5             	mov    %rsp,%rbp
 5c5:	48 c1 fe 03          	sar    $0x3,%rsi
 5c9:	48 89 f0             	mov    %rsi,%rax
 5cc:	48 c1 e8 3f          	shr    $0x3f,%rax
 5d0:	48 01 c6             	add    %rax,%rsi
 5d3:	48 d1 fe             	sar    %rsi
 5d6:	74 18                	je     5f0 <register_tm_clones+0x40>
 5d8:	48 8b 05 11 0a 20 00 	mov    0x200a11(%rip),%rax        # 200ff0 <_ITM_registerTMCloneTable>
 5df:	48 85 c0             	test   %rax,%rax
 5e2:	74 0c                	je     5f0 <register_tm_clones+0x40>
 5e4:	5d                   	pop    %rbp
 5e5:	ff e0                	jmpq   *%rax
 5e7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
 5ee:	00 00 
 5f0:	5d                   	pop    %rbp
 5f1:	c3                   	retq   
 5f2:	0f 1f 40 00          	nopl   0x0(%rax)
 5f6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
 5fd:	00 00 00 

0000000000000600 <__do_global_dtors_aux>:
 600:	80 3d 09 0a 20 00 00 	cmpb   $0x0,0x200a09(%rip)        # 201010 <__TMC_END__>
 607:	75 2f                	jne    638 <__do_global_dtors_aux+0x38>
 609:	48 83 3d e7 09 20 00 	cmpq   $0x0,0x2009e7(%rip)        # 200ff8 <__cxa_finalize@GLIBC_2.2.5>
 610:	00 
 611:	55                   	push   %rbp
 612:	48 89 e5             	mov    %rsp,%rbp
 615:	74 0c                	je     623 <__do_global_dtors_aux+0x23>
 617:	48 8b 3d ea 09 20 00 	mov    0x2009ea(%rip),%rdi        # 201008 <__dso_handle>
 61e:	e8 0d ff ff ff       	callq  530 <__cxa_finalize@plt>
 623:	e8 48 ff ff ff       	callq  570 <deregister_tm_clones>
 628:	c6 05 e1 09 20 00 01 	movb   $0x1,0x2009e1(%rip)        # 201010 <__TMC_END__>
 62f:	5d                   	pop    %rbp
 630:	c3                   	retq   
 631:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
 638:	f3 c3                	repz retq 
 63a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000000640 <frame_dummy>:
 640:	55                   	push   %rbp
 641:	48 89 e5             	mov    %rsp,%rbp
 644:	5d                   	pop    %rbp
 645:	e9 66 ff ff ff       	jmpq   5b0 <register_tm_clones>

000000000000064a <main>:
 64a:	55                   	push   %rbp
 64b:	48 89 e5             	mov    %rsp,%rbp
 64e:	48 83 ec 10          	sub    $0x10,%rsp
 652:	c7 45 f4 01 00 00 00 	movl   $0x1,-0xc(%rbp)
 659:	c7 45 f8 02 00 00 00 	movl   $0x2,-0x8(%rbp)
 660:	8b 55 f8             	mov    -0x8(%rbp),%edx
 663:	8b 45 f4             	mov    -0xc(%rbp),%eax
 666:	01 d0                	add    %edx,%eax
 668:	89 45 fc             	mov    %eax,-0x4(%rbp)
 66b:	8b 45 fc             	mov    -0x4(%rbp),%eax
 66e:	89 c6                	mov    %eax,%esi
 670:	48 8d 3d 9d 00 00 00 	lea    0x9d(%rip),%rdi        # 714 <_IO_stdin_used+0x4>
 677:	b8 00 00 00 00       	mov    $0x0,%eax
 67c:	e8 9f fe ff ff       	callq  520 <printf@plt>
 681:	b8 00 00 00 00       	mov    $0x0,%eax
 686:	c9                   	leaveq 
 687:	c3                   	retq   
 688:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
 68f:	00 

0000000000000690 <__libc_csu_init>:
 690:	41 57                	push   %r15
 692:	41 56                	push   %r14
 694:	49 89 d7             	mov    %rdx,%r15
 697:	41 55                	push   %r13
 699:	41 54                	push   %r12
 69b:	4c 8d 25 16 07 20 00 	lea    0x200716(%rip),%r12        # 200db8 <__frame_dummy_init_array_entry>
 6a2:	55                   	push   %rbp
 6a3:	48 8d 2d 16 07 20 00 	lea    0x200716(%rip),%rbp        # 200dc0 <__init_array_end>
 6aa:	53                   	push   %rbx
 6ab:	41 89 fd             	mov    %edi,%r13d
 6ae:	49 89 f6             	mov    %rsi,%r14
 6b1:	4c 29 e5             	sub    %r12,%rbp
 6b4:	48 83 ec 08          	sub    $0x8,%rsp
 6b8:	48 c1 fd 03          	sar    $0x3,%rbp
 6bc:	e8 2f fe ff ff       	callq  4f0 <_init>
 6c1:	48 85 ed             	test   %rbp,%rbp
 6c4:	74 20                	je     6e6 <__libc_csu_init+0x56>
 6c6:	31 db                	xor    %ebx,%ebx
 6c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
 6cf:	00 
 6d0:	4c 89 fa             	mov    %r15,%rdx
 6d3:	4c 89 f6             	mov    %r14,%rsi
 6d6:	44 89 ef             	mov    %r13d,%edi
 6d9:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
 6dd:	48 83 c3 01          	add    $0x1,%rbx
 6e1:	48 39 dd             	cmp    %rbx,%rbp
 6e4:	75 ea                	jne    6d0 <__libc_csu_init+0x40>
 6e6:	48 83 c4 08          	add    $0x8,%rsp
 6ea:	5b                   	pop    %rbx
 6eb:	5d                   	pop    %rbp
 6ec:	41 5c                	pop    %r12
 6ee:	41 5d                	pop    %r13
 6f0:	41 5e                	pop    %r14
 6f2:	41 5f                	pop    %r15
 6f4:	c3                   	retq   
 6f5:	90                   	nop
 6f6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
 6fd:	00 00 00 

0000000000000700 <__libc_csu_fini>:
 700:	f3 c3                	repz retq 

Disassembly of section .fini:

0000000000000704 <_fini>:
 704:	48 83 ec 08          	sub    $0x8,%rsp
 708:	48 83 c4 08          	add    $0x8,%rsp
 70c:	c3                   	retq

 

倾尽浮生只为卿
关注
专栏目录
Linux Vmlinux反汇编操作和 oops stack 回朔分析
bingdund的博客
02-17 575
1. Linux Vmlinux反汇编操作和代码分析 1.1 对vmlinx反汇编 arm-linux-gnueabi-objdump -d vmlinux > debug.s 1.2 debug.s代码段分析 vmlinux: file format elf32-littlearm Disassembly of section .head.text: 内核地址 汇编对应的机器码 汇编指令 c0008000 <stext>: //ARM
linux系统的gdb调试c++和反汇编
最新发布
vily_lei的专栏
08-08 546
linux系统的gdb调试c++和反汇编
Linux下C程序的反汇编【转】
Uaena的博客
04-08 796
（转自：https://blog.csdn.net/u011192270/article/details/50224267） Linux下C程序的反汇编 前言：本文主要介绍几种反汇编的方法。 gcc gcc的完整编译过程大致为：预处理->编译->汇编->链接 前三个步骤分别对应了-E、-S、-c三个选项。 今天我要介绍的第一种方法就是使用-S这个选项。 源程序mai...
Linux内核分析——反汇编一个简单C程序
dongdao_xiwai的专栏
03-08 586
Linux内核分析第一周作业，在云课堂的实验楼环境下完成。 Michael O'Connor    原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 实验代码： int g(int x) { return x + 8; } int f(int x) {
Linux下反汇编分析C语言源代码
weixin_34178244的博客
03-21 255
Linux下反汇编分析C语言源代码 by 赵缙翔 原创作品转载请注明出处 《Linux内核分析》MOOC课程——孟宁 这是我第一次写的博客，如有疏漏，还请指教。 在上完孟宁老师的软件工程课程后，觉得这老师的课真心不错，就又选了他的Linux内核分析。因为Linux内核代码中还是有一些C语言没法做的事情需要At&T汇编代码来帮忙，所以我们需要了解一些汇编的常识。 汇编基础 命名习惯的历史由来...
linux反汇编教程,Linux 下使用 objdump 反汇编
weixin_34088048的博客
05-02 383
objdump有点象那个快速查看之流的工具，就是以一种可阅读的格式让你更多地了解二进制文件可能带有的附加信息。对于一般只想让自己程序跑起来的程序员，这个命令没有更多意义，对于想进一步了解系统的程序员，应该掌握这种工具，至少你可以自己写写shellcode了，或者看看人家给的exploit中的shellcode是什么东西。目录：★ 测试练习前的准备工作★ RedHat 6.0 objdump命令的m...
Linux c++反汇编源码细节解释说明
vily_lei的专栏
08-07 966
Linux c++反汇编源码细节解释说明
linux 反汇编 .so,SO文件反汇编实践
weixin_32631729的博客
05-13 1905
引言本文是老本行系列，Android相关的文章(以前的藏文)，以后不定期地会发出老本行系列。IDA pro简介IDA pro全名为交互式反汇编器专业版(Interactive Disassembler Professional)，简称为IDA。就本质而言，IDA是一种递归下降反汇编器。为了克服递归下降的缺点，IDA在区分数据与代码的同时，还设法确定这些数据的类型。通过IDA pro对dll、so等...
查看Ubuntu Linux内核函数反汇编代码
qq_39072699的博客
12-28 1951
说明：本文单纯为快捷记录操作方法之用，没有解释技术细节，如果想了解具体原理请另寻其他资料。 内核是构成计算机操作系统核心的程序。它是在计算机启动（即启动）时首先加载到内存（物理上由RAM芯片组成）的内容，并且在计算机运行的整个过程中它都保留在内存中。 Linux内核源码编译结束后生成的文件为vmlinux，这是一个ELF可执行文件，可以被反汇编。但不可以被引导。 vmlinuz是vmlinux经过压缩后生成的可引导可执行文件。可引导意味着它能够将操作系统加载到内存中，以便计算机变得可用并且可以运行.
反编译神器jeb(linux版)
01-19
linux 版反编译神器,解压后直接使用
技巧：多共享动态库中同名对象重复析构问题的解决方法
yuyin86的专栏
08-24 1323
技巧：多共享动态库中同名对象重复析构问题的解决方法 共享库与静态成员 吴 光远, 软件工程师, IBM 孟 先涛, 软件工程师, IBM 简介： Linux 平台下的共享动态库，一般都是通过选项“-fPIC”编译出来。有些应用程序需要链接多个共享库，此时如果在这些共享库中存在相同作用域范围的同名静态成员变量，那么当程序访问完静态成员变量结束析构时，由于内存的 d
linux下动态链接过程
leapmotion的博客
06-11 1509
elf文件动态链接
ELF重定位分析
lingedeng的专栏
01-21 1254
1. 变量访问 ///////////////////////////////////////////////////////////// //ml_mainpic_data.c //gcc -fPIC -shared -g -o libmlpicdata.so ml_mainpic_data.c int myglob = 42; int ml_func(int a, int b) { ...
态库、静态库之间的相互嵌套
赵凯月的博客
02-15 650
动态库
dlsym函数返回null的解决办法
gs344937933的专栏
06-14 2614
dlsym是什么？ 见：采用dlopen、dlsym、dlclose加载动态链接库【总结】
ELF符号表分析
astrotycoon
12-20 8789
Symbol Table An object file's symbol table holds information needed to locate and relocate a program's symbolic definitions and references. A symbol table index is a subscript into this array. Index ...
sigsegv 問題的調是
boshuzhang的专栏
02-27 973
Stack Overflow Questions Jobs Tags Users Badges   Ask Question _ Stack Overflow is a community of 4.7 million programmers, just like you, helping each other.  J
PLT表和GOT表
lzx的博客
06-22 399
在Linux中，当执行一个executable file（ELF）文件之后，如果这个文件本身引用了动态链接库，那么在他执行的过程中，会获得解释器（loader）的地址，解释器也会相应的获得动态链接库的地址，但是，具体用到哪个函数，他又是怎么知道的？总不能把全部函数都进行链接吧。 #include<stdio.h> int main() { printf("Hello World\n"); return 0; } 进行编译生成.o对象文件 gcc -o -g hello.c -m
编译时出现fatal error: cjson/cJSON.h: No such file or directory
热门推荐
chidaoqi1607的博客
02-02 1万+
需要安装libcjson libcjson-dev sudo apt install libcjson1 libcjson-dev
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值