linux下实现在程序运行时的函数替换(热补丁)【转】

转自：http://www.cnblogs.com/leo0000/p/5632642.html

声明：以下的代码成果，是参考了网上的injso技术，在本文的最后会给出地址，同时非常感谢injso技术原作者的分享。

　　　但是injso文章中的代码存在一些问题，所以后面出现的代码是经过作者修改和检测的。也正因为这些错误，加深了我的学习深度。

　　最近因为在学习一些调试的技术，但是很少有提到如何在函数运行时实现函数替换的。

　　为什么会想到这一点？因为在学习调试时，难免会看到一些内核方面的调试技术，内核中的调试有一个kprobe，很强大，可以实现运行时的函数替换。其原理就是hook，钩子，但是学习了这个kprobe之后会发现，kprobe内部有检测所要钩的函数是不是属于内核空间，必须是内核函数才能实现替换。而实际上，我的工作大部分还是在应用层的，所以想要实现应用程序的热补丁技术。

　　一些基础的知识这边的就不展开了，需要的基础有，elf文件格式，ptrace，waitpid，应用程序间通信时的信号，汇编。

  • 1、elf文件加载过程

　　elf简单地说是由以下四部分组成的，elf文件头，program header和section header，内容。其中program header是运行时使用的，而section header并不会被加载进程序运行空间，但他们可以在编译时被指定该段的加载地址等信息，当然一般这个链接脚本.lds是由gcc默认的。

　　第一步，加载elf文件头，检验文件类型版本等，重要的是找到program header的地址和header的个数，如果连接器脚本是默认的，那么elf文件头会被加载在0x804800地址处。

　　第二步，加载program header，接着扫描program header，找到一个类型为PT_INTERP的program header，这个header里面放着的是有关解释器的地址，这时候将解释器程序的elf文件头加载进来。一般是这样：

　　　　　　INTERP 0x000134 0x08048134 0x08048134 0x00013 0x00013 R 0x1
　　　　　　　　[Requesting program interpreter: /lib/ld-linux.so.2]

　　第三步，扫描program header，如果类型为PT_LOAD，则将该段加载进来。

　　第四步，判断是否需要解释器程序，如果需要，把解释器程序加载进来，并把程序入口设置为解释器程序的地址。否则是应用程序本身的入口。反汇编为_start标号。

　　第五步，设置命令行传入的参数等应用程序需要的信息。

　　第六步，解释器程序开始运行，加载程序需要的库，填写重定向符号表中的地址信息。

  • 2.elf文件动态链接过程

　　上一步，解释器程序根据program header已经将应用程序的段都加载进内存了，接下来再扫描program header，找到类型为PT_DYNAMIC，这里面包含了很多由section header描述的内容，包括重定向表，符号表，字符串表等等。解释器需要这个段描述的一些信息。

　　DT_NEEDED描述了所需要的动态库名称，DT_REL描述了重定位表地址，DT_JMPREL描述了重定位表地址(这个表是懒惰链接使用的)，DT_PLTGOT全局偏移表地址。

　　此时解释器程序就可以根据所需要的动态库，将其加载进内存。每一个被加载进来的库的相关信息会被记录在link_map结构中，这个结构是一个链表，保存了所有的动态信息。

　　其中，全局偏移表got，got[0]保存了PT_DYNAMIC的起始地址，got[1]保存link_map的地址，而link_map中就可以找到PT_DYNAMIC的起始地址，和下一个或者上一个共享文件或者可执行文件的link_map地址。

　　DT_REL这个重定向表中的符号必须在此时就被解析完成。

　　而DT_JMPREL这个重定向表中的符号可以在运行时再解析。

　　所有的库和符号全部解析完成之后，解释器程序就会把控制权交给可执行文件的_start。程序开始执行。

  • 3.替换函数和被替换函数

　　被替换程序源码。　


1

2

3

4

5

6

7

8

9

#include <stdio.h>

#include <time.h>

int main()

{

        while(1){

                sleep(10);

                printf("%d : original\n",time(0));

        }

}

　　替换新库代码。


1

2

3

4

5

6

7

#include <stdio.h>

int newmyprint()

{

    write(1,"hahahahahahaha",14);

    return 0;

}

　　够简单明了吧，如果替换成功，目标程序将会一直输出“哈哈哈哈哈哈”。

  • 4.功能函数　　

　　ptrace相关代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

/* 读进程寄存器 */

void ptrace_readreg(int pid, struct user_regs_struct *regs)

{

    if(ptrace(PTRACE_GETREGS, pid, NULL, regs))

        printf("*** ptrace_readreg error ***\n");

    /*printf("ptrace_readreg\n");

    printf("%x\n",regs->ebx);

    printf("%x\n",regs->ecx);

    printf("%x\n",regs->edx);

    printf("%x\n",regs->esi);

    printf("%x\n",regs->edi);

    printf("%x\n",regs->ebp);

    printf("%x\n",regs->eax);

    printf("%x\n",regs->xds);

    printf("%x\n",regs->xes);

    printf("%x\n",regs->xfs);

    printf("%x\n",regs->xgs);

    printf("%x\n",regs->orig_eax);

    printf("%x\n",regs->eip);

    printf("%x\n",regs->xcs);

    printf("%x\n",regs->eflags);

    printf("%x\n",regs->esp);

    printf("%x\n",regs->xss);*/

}

/* 写进程寄存器 */

void ptrace_writereg(int pid, struct user_regs_struct *regs)

{

    /*printf("ptrace_writereg\n");

    printf("%x\n",regs->ebx);

    printf("%x\n",regs->ecx);

    printf("%x\n",regs->edx);

    printf("%x\n",regs->esi);

    printf("%x\n",regs->edi);

    printf("%x\n",regs->ebp);

    printf("%x\n",regs->eax);

    printf("%x\n",regs->xds);

    printf("%x\n",regs->xes);

    printf("%x\n",regs->xfs);

    printf("%x\n",regs->xgs);

    printf("%x\n",regs->orig_eax);

    printf("%x\n",regs->eip);

    printf("%x\n",regs->xcs);

    printf("%x\n",regs->eflags);

    printf("%x\n",regs->esp);

    printf("%x\n",regs->xss);*/

    if(ptrace(PTRACE_SETREGS, pid, NULL, regs))

        printf("*** ptrace_writereg error ***\n");

}

/* 关联到进程 */

void ptrace_attach(int pid)

{

    if(ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {

        perror("ptrace_attach");

        exit(-1);

    }

    waitpid(pid, NULL, /*WUNTRACED*/0);  

   

    ptrace_readreg(pid, &oldregs);

}

/* 进程继续 */

void ptrace_cont(int pid)

{

    int stat;

    if(ptrace(PTRACE_CONT, pid, NULL, NULL) < 0) {

        perror("ptrace_cont");

        exit(-1);

    }

    /*while(!WIFSTOPPED(stat))

        waitpid(pid, &stat, WNOHANG);*/

}

/* 脱离进程 */

void ptrace_detach(int pid)

{

    ptrace_writereg(pid, &oldregs);

    if(ptrace(PTRACE_DETACH, pid, NULL, NULL) < 0) {

        perror("ptrace_detach");

        exit(-1);

    }

}

/* 写指定进程地址 */

void ptrace_write(int pid, unsigned long addr, void *vptr, int len)

{

    int count;

    long word;

    count = 0;

    while(count < len) {

        memcpy(&word, vptr + count, sizeof(word));

        word = ptrace(PTRACE_POKETEXT, pid, addr + count, word);

        count += 4;

        if(errno != 0)

            printf("ptrace_write failed\t %ld\n", addr + count);

    }

}

/* 读指定进程 */

int ptrace_read(int pid, unsigned long addr, void *vptr, int len)

{

    int i,count;

    long word;

    unsigned long *ptr = (unsigned long *)vptr;

    i = count = 0;

    //printf("ptrace_read addr = %x\n",addr);

    while (count < len) {

        //printf("ptrace_read addr+count = %x\n",addr + count);

        word = ptrace(PTRACE_PEEKTEXT, pid, addr + count, NULL);

        while(word < 0)

        {

            if(errno == 0)

                break;

            //printf("ptrace_read word = %x\n",word);

            perror("ptrace_read failed");

            return 2;

        }

        count += 4;

        ptr[i++] = word;

    }

    return 0;

}

/*

 在进程指定地址读一个字符串

 */

char * ptrace_readstr(int pid, unsigned long addr)

{

    char *str = (char *) malloc(64);

    int i,count;

    long word;

    char *pa;

    i = count = 0;

    pa = (char *)&word;

    while(i <= 60) {

        word = ptrace(PTRACE_PEEKTEXT, pid, addr + count, NULL);

        count += 4;

        if (pa[0] == 0) {

            str[i] = 0;

        break;

        }

        else

            str[i++] = pa[0];

        if (pa[1] == 0) {

            str[i] = 0;

            break;

        }

        else

            str[i++] = pa[1];

        if (pa[2] ==0) {

            str[i] = 0;

            break;

        }

        else

            str[i++] = pa[2];

        if (pa[3] ==0) {

            str[i] = 0;

            break;

        }

        else

            str[i++] = pa[3];

    }

   

    return str;

}

/*

 将指定数据压入进程堆栈并返回堆栈指针

 */

void * ptrace_push(int pid, void *paddr, int size)

{

    unsigned long esp;

    struct user_regs_struct regs;

    ptrace_readreg(pid, &regs);

    esp = regs.esp;

    esp -= size;

    esp = esp - esp % 4;

    regs.esp = esp;

    ptrace_writereg(pid, &regs);

    ptrace_write(pid, esp, paddr, size);

    return (void *)esp;

}

/*

 在进程内调用指定地址的函数

 */

void ptrace_call(int pid, unsigned long addr)

{

    void *pc;

    struct user_regs_struct regs;

    int stat;

    void *pra;

    pc = (void *) 0x41414140;

    pra = ptrace_push(pid, &pc, sizeof(pc));

    ptrace_readreg(pid, &regs);

    regs.eip = addr;

    ptrace_writereg(pid, &regs);

    ptrace_cont(pid);

    //while(WIFSIGNALED(stat))

       // waitpid(pid, &stat, WNOHANG);

}

　　这里面的东西我就不展开了，对ptrace的学习，请自行man。

　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

/*

因为应用程序可能不存在hash表，所以通过读取源文件的section header获取符号表的入口数，

其实是被误导了，但也学习了hash表的作用，用来快速查找符号表中的信息和字符串表中的信息

*/

/*int getnchains(int pid,unsigned long base_addr)

{

    printf("getnchains enter \n");

    Elf32_Ehdr *ehdr = (Elf32_Ehdr *) malloc(sizeof(Elf32_Ehdr));      

    Elf32_Shdr *shdr = (Elf32_Shdr *)malloc(sizeof(Elf32_Shdr));

    unsigned long shdr_addr;

    int i = 0;

    int fd;

    char filename[1024] = {0};

    ptrace_read(pid, base_addr, ehdr, sizeof(Elf32_Ehdr));

    shdr_addr = base_addr + ehdr->e_shoff;

    //printf("getnchains ehdr->e_shoff\t %p\n", ehdr->e_shoff);

    

    snprintf(filename, sizeof(filename), "/proc/%d/exe", pid);

    fd = open(filename, O_RDONLY);

    if (lseek(fd, ehdr->e_shoff, SEEK_SET) < 0)

        exit(-1);

    

    /*while(i<ehdr->e_shnum)

    {

        read(fd, shdr, ehdr->e_shentsize);

        printf("getnchains i = %d\n",i);

        printf("getnchains shdr->sh_type = %x\n",shdr->sh_type);

        printf("getnchains shdr->sh_name = %x\n",shdr->sh_name);

        printf("getnchains shdr->sh_size = %x\n",shdr->sh_size);

        printf("getnchains shdr->sh_entsize = %x\n",shdr->sh_entsize);

        i++;

    }

    

    while(shdr->sh_type != SHT_SYMTAB)

        read(fd, shdr, ehdr->e_shentsize);

    nchains = shdr->sh_size/shdr->sh_entsize;

    //printf("getnchains shdr->sh_type = %d\n",shdr->sh_type);

    //printf("getnchains shdr->sh_name = %d\n",shdr->sh_name);

    //printf("getnchains shdr->sh_size = %d\n",shdr->sh_size);

    //printf("getnchains shdr->sh_entsize = %d\n",shdr->sh_entsize);

    //printf("getnchains nchains = %x\n",nchains); 

    close(fd);

    free(ehdr);

    free(shdr);

    printf("getnchains exit \n");

}

*/

/*

 取得指向link_map链表首项的指针

 */

struct link_map * get_linkmap(int pid)

{

    Elf32_Ehdr *ehdr = (Elf32_Ehdr *) malloc(sizeof(Elf32_Ehdr));      

    Elf32_Phdr *phdr = (Elf32_Phdr *) malloc(sizeof(Elf32_Phdr));

    Elf32_Dyn  *dyn =  (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));

    Elf32_Word got;

    struct link_map *map = (struct link_map *)malloc(sizeof(struct link_map));

    int i = 1;

    unsigned long tmpaddr;

    ptrace_read(pid, IMAGE_ADDR, ehdr, sizeof(Elf32_Ehdr));

    phdr_addr = IMAGE_ADDR + ehdr->e_phoff;

    printf("phdr_addr\t %p\n", phdr_addr);

    ptrace_read(pid, phdr_addr, phdr, sizeof(Elf32_Phdr));

    while(phdr->p_type != PT_DYNAMIC)

        ptrace_read(pid, phdr_addr += sizeof(Elf32_Phdr), phdr,sizeof(Elf32_Phdr));

    dyn_addr = phdr->p_vaddr;

    printf("dyn_addr\t %p\n", dyn_addr);

    ptrace_read(pid, dyn_addr, dyn, sizeof(Elf32_Dyn));

    while(dyn->d_tag != DT_PLTGOT) {

        tmpaddr = dyn_addr + i * sizeof(Elf32_Dyn);

        //printf("get_linkmap tmpaddr = %x\n",tmpaddr);

        ptrace_read(pid,tmpaddr, dyn, sizeof(Elf32_Dyn));

        i++;

    }

    got = (Elf32_Word)dyn->d_un.d_ptr;

    got += 4;

    //printf("GOT\t\t %p\n", got);

    ptrace_read(pid, got, &map_addr, 4);

    printf("map_addr\t %p\n", map_addr);

    map = map_addr;

    //ptrace_read(pid, map_addr, map, sizeof(struct link_map));

   

    free(ehdr);

    free(phdr);

    free(dyn);

    return map;

}

/*

 取得给定link_map指向的SYMTAB、STRTAB、HASH、JMPREL、PLTRELSZ、RELAENT、RELENT信息

 这些地址信息将被保存到全局变量中，以方便使用

 */

void get_sym_info(int pid, struct link_map *lm)

{

    Elf32_Dyn *dyn = (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));

    unsigned long dyn_addr;

    //printf("get_sym_info lm = %x\n",lm);

    //printf("get_sym_info lm->l_ld‘s offset = %x\n",&((struct link_map *)0)->l_ld);

    //printf("get_sym_info &lm->l_ld = %x\n",&(lm->l_ld));

    //dyn_addr = (unsigned long)&(lm->l_ld);

    //进入被跟踪进程获取动态节的地址  

    ptrace_read(pid,&(lm->l_ld) , &dyn_addr, sizeof(dyn_addr));

    ptrace_read(pid,&(lm->l_addr) , &link_addr, sizeof(dyn_addr));

    ptrace_read(pid, dyn_addr, dyn, sizeof(Elf32_Dyn));

    //if(link_addr == 0)

    //  getnchains(pid,IMAGE_ADDR);

    /*else

        getnchains(pid,link_addr);*/

    while(dyn->d_tag != DT_NULL){

        //printf("get_sym_info dyn->d_tag = %x\n",dyn->d_tag);

        //printf("get_sym_info dyn->d_un.d_ptr = %x\n",dyn->d_un.d_ptr);

        switch(dyn->d_tag)

        {

        case DT_SYMTAB:

            symtab = dyn->d_un.d_ptr;

            

            break;

        case DT_STRTAB:

            strtab = dyn->d_un.d_ptr;

            break;

        /*case DT_HASH://可能不存在哈希表，此时nchains是错误的，这个值可以通过符号表得到

            //printf("get_sym_info hash table‘s addr = %x\n",dyn->d_un.d_ptr);

            //printf("get_sym_info symtbl‘s entry = %x\n",(dyn->d_un.d_ptr) + 4);

            ptrace_read(pid, (dyn->d_un.d_ptr) + 4,&nchains, sizeof(nchains));

            break;*/

        case DT_JMPREL:

            jmprel = dyn->d_un.d_ptr;

            break;

        case DT_PLTRELSZ:

            totalrelsize = dyn->d_un.d_val;

            break;

        case DT_RELAENT:

            relsize = dyn->d_un.d_val;

            break;

        case DT_RELENT:

            relsize = dyn->d_un.d_val;

            break;

        case DT_REL:

            reldyn = dyn->d_un.d_ptr;       

            break;

        case DT_RELSZ:

            reldynsz = dyn->d_un.d_val;

            break;

        }

        ptrace_read(pid, dyn_addr += sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));

    }

    

    //printf("get_sym_info link_addr = %x\n",link_addr);

    //printf("get_sym_info symtab = %x\n",symtab);

    //printf("get_sym_info relsize = %x\n",relsize);

    //printf("get_sym_info reldyn = %x\n",reldyn);

    //printf("get_sym_info totalrelsize = %x\n",totalrelsize);

    //printf("get_sym_info jmprel = %x\n",jmprel);

    //printf("get_sym_info nchains = %x\n",nchains);

    //printf("get_sym_info strtab = %x\n",strtab);

    nrels = totalrelsize / relsize;

    nreldyns = reldynsz/relsize;

    

    //printf("get_sym_info nreldyns = %d\n",nreldyns);

    //printf("get_sym_info nrels = %d\n",nrels);

    free(dyn);

    printf("get_sym_info exit\n");

}

/*

 在指定的link_map指向的符号表查找符号，它仅仅是被上面的find_symbol使用

 */

unsigned long  find_symbol_in_linkmap(int pid, struct link_map *lm, char *sym_name)

{

    Elf32_Sym *sym = (Elf32_Sym *) malloc(sizeof(Elf32_Sym));

    int i = 0;

    char *str;

    unsigned long ret;

    int flags = 0;

    get_sym_info(pid, lm);

   

    do{

        if(ptrace_read(pid, symtab + i * sizeof(Elf32_Sym), sym, sizeof(Elf32_Sym)))

            return 0;

        i++;

        //printf("find_symbol_in_linkmap sym->st_name = %x\tsym->st_size = %x\tsym->st_value = %x\n",sym->st_name,sym->st_size,sym->st_value);

        //printf("find_symbol_in_linkmap Elf32_Sym‘s size = %d\n",sizeof(Elf32_Sym));

        //printf("\nfind_symbol_in_linkmap sym->st_name = %x\n",sym->st_name);       

        if (!sym->st_name && !sym->st_size && !sym->st_value)//全为0是符号表的第一项

            continue;

        //printf("\nfind_symbol_in_linkmap strtab = %x\n",strtab);

        str = (char *) ptrace_readstr(pid, strtab + sym->st_name);

        //printf("\nfind_symbol_in_linkmap str = %s\n",str);

        //printf("\nfind_symbol_in_linkmap sym->st_value = %x\n",sym->st_value);

        if (strcmp(str, sym_name) == 0) {

            printf("\nfind_symbol_in_linkmap str = %s\n",str);

            printf("\nfind_symbol_in_linkmap sym->st_value = %x\n",sym->st_value);

            free(str);

            if(sym->st_value == 0)//值为0代表这个符号本身就是重定向的内容

                continue;

            flags = 1;

            

            //str = ptrace_readstr(pid, (unsigned long)lm->l_name);

            //printf("find_symbol_in_linkmap lib name [%s]\n", str);

            //free(str);

            break;

        }

        

        free(str);

    }while(1);

    if (flags != 1)

        ret = 0;

    else

        ret =  link_addr + sym->st_value;

    free(sym);

    return ret;

}

/*

 解析指定符号

 */

unsigned long  find_symbol(int pid, struct link_map *map, char *sym_name)

{

    struct link_map *lm = map;

    unsigned long sym_addr;

    char *str;

    unsigned long tmp;

   

    //sym_addr = find_symbol_in_linkmap(pid, map, sym_name);

    //return 0;

    //if (sym_addr)

     //   return sym_addr;

    //printf("\nfind_symbol map = %x\n",map);

    //ptrace_read(pid,(char *)map+12,&tmp,4);

    //lm = tmp;

    //printf("find_symbol lm = %x\n",lm);

    //ptrace_read(pid, (unsigned long)map->l_next, lm, sizeof(struct link_map));

    sym_addr = find_symbol_in_linkmap(pid, lm, sym_name);

    while(!sym_addr ) {

        ptrace_read(pid, (char *)lm+12, &tmp, 4);//获取下一个库的link_map地址

        if(tmp == 0)

            return 0;

        lm = tmp;

        //printf("find_symbol lm = %x\n",lm);

        /*str = ptrace_readstr(pid, (unsigned long)lm->l_name);

        if(str[0] == ‘/0‘)

            continue;

        printf("[%s]\n", str);

        free(str);*/

        if ((sym_addr = find_symbol_in_linkmap(pid, lm, sym_name)))

            break;

    }

    return sym_addr;

}

/* 查找符号的重定位地址 */

unsigned long  find_sym_in_rel(int pid, char *sym_name)

{

    Elf32_Rel *rel = (Elf32_Rel *) malloc(sizeof(Elf32_Rel));

    Elf32_Sym *sym = (Elf32_Sym *) malloc(sizeof(Elf32_Sym));

    int i;

    char *str;

    unsigned long ret;

    struct link_map *lm;

    lm = map_addr;

    

    //get_dyn_info(pid);

    do{

        get_sym_info(pid,lm);

        ptrace_read(pid, (char *)lm+12, &lm, 4);

        //首先查找过程连接的重定位表

        for(i = 0; i< nrels ;i++) {

            ptrace_read(pid, (unsigned long)(jmprel + i * sizeof(Elf32_Rel)),

                                                                     rel, sizeof(Elf32_Rel));

            if(ELF32_R_SYM(rel->r_info)) {

                ptrace_read(pid, symtab + ELF32_R_SYM(rel->r_info) *

                                                   sizeof(Elf32_Sym), sym, sizeof(Elf32_Sym));

                str = ptrace_readstr(pid, strtab + sym->st_name);

                if (strcmp(str, sym_name) == 0) {

                    if(sym->st_value != 0){

                        free(str);

                        continue;

                    }

                    modifyflag = 1;

                    free(str);

                    break;

                }

                free(str);

            }

        }

        

        if(modifyflag == 1)

            break;

        //没找到的话，再找在链接时就重定位的重定位表

        for(i = 0; i< nreldyns;i++) {

            ptrace_read(pid, (unsigned long)(reldyn+ i * sizeof(Elf32_Rel)),

                                                                     rel, sizeof(Elf32_Rel));

            if(ELF32_R_SYM(rel->r_info)) {

                ptrace_read(pid, symtab + ELF32_R_SYM(rel->r_info) *

                                                   sizeof(Elf32_Sym), sym, sizeof(Elf32_Sym));

                str = ptrace_readstr(pid, strtab + sym->st_name);

                if (strcmp(str, sym_name) == 0) {

                    if(sym->st_value != 0){

                        free(str);

                        continue;

                    }

                    modifyflag = 2;

                    free(str);

                    break;

                }

                free(str);

            }

        }

        

        if(modifyflag == 2)

            break;

        

    }while(lm);

    //printf("find_sym_in_rel flags = %d\n",flags);

    if (modifyflag == 0)

        ret = 0;

    else

        ret =  link_addr + rel->r_offset;

    //printf("find_sym_in_rel link_addr = %x\t sym->st_value = %x\n",link_addr , sym->st_value);

    free(rel);

    free(sym);

    return ret;

}

/*

 在进程自身的映象中（即不包括动态共享库，无须遍历link_map链表）获得各种动态信息

 */

/*void get_dyn_info(int pid)

{

    Elf32_Dyn *dyn = (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));

    int i = 0;

    ptrace_read(pid, dyn_addr + i * sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));

    i++;

    while(dyn->d_tag){

        switch(dyn->d_tag)

        {

        case DT_SYMTAB:

            //puts("DT_SYMTAB");

            symtab = dyn->d_un.d_ptr;

            break;

        case DT_STRTAB:

            strtab = dyn->d_un.d_ptr;

            //puts("DT_STRTAB");

            break;

        case DT_JMPREL:

            jmprel = dyn->d_un.d_ptr;

            //puts("DT_JMPREL");

            //printf("jmprel\t %p\n", jmprel);

            break;

        case DT_PLTRELSZ:

            totalrelsize = dyn->d_un.d_val;

            //puts("DT_PLTRELSZ");

            break;

        case DT_RELAENT:

            relsize = dyn->d_un.d_val;

            //puts("DT_RELAENT");

            break;

        case DT_RELENT:

            relsize = dyn->d_un.d_val;

            //puts("DT_RELENT");

            break;

        }

        ptrace_read(pid, dyn_addr + i * sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));

        i++;

    }

    nrels = totalrelsize / relsize;

    free(dyn);

}*/

/*void call_dl_open(int pid, unsigned long addr, char *libname)

{

    void *pRLibName;

    struct user_regs_struct regs;

    /*

      先找个空间存放要装载的共享库名，我们可以简单的把它放入堆栈

     

    pRLibName = ptrace_push(pid, libname, strlen(libname) + 1);

    /* 设置参数到寄存器

    ptrace_readreg(pid, &regs);

    regs.eax = (unsigned long) pRLibName;

    regs.ecx = 0x0;

    regs.edx = RTLD_LAZY;

    ptrace_writereg(pid, &regs);

    /* 调用_dl_open

    ptrace_call(pid, addr);

    puts("call _dl_open ok");

}*/

/*#define RTLD_LAZY 0x00001

#define RTLD_NOW    0x00002

#define RTLD_BINDING_MASK   0x3

#define RTLD_NOLOAD 0x00004

#define RTLD_DEEPBIND   0x00008

#define RTLD_GLOBAL 0x00100

#define RTLD_LOCAL  0

#define RTLD_NODELETE   0x01000 */

void call__libc_dlopen_mode(int pid, unsigned long addr, char *libname)

{

    void *plibnameaddr;

    //printf("call__libc_dlopen_mode libname = %s\n",libname);

    //printf("call__libc_dlopen_mode addr = %x\n",addr);

    //将需要加载的共享库地址压栈

    plibnameaddr = ptrace_push(pid, libname, strlen(libname) + 1);

    ptrace_push(pid,&mode,sizeof(int));

    ptrace_push(pid,&plibnameaddr,sizeof(plibnameaddr));

    /* 调用__libc_dlopen_mode */

    ptrace_call(pid, addr);

}

void call_printf(int pid, unsigned long addr, char *string)

{

    void *paddr;

    paddr = ptrace_push(pid, string, strlen(string) + 1);

    ptrace_push(pid,&paddr,sizeof(paddr));

    ptrace_call(pid, addr);

}

　　作者所做的修改，读者可以对比文章最后的连接中的代码。

　　这边对于程序的具体解释，就不具体展开了。

　　需要注意的是，原来是采用_dl_open的方式加载库函数，但是ld库并没有这个符号导出。而libc库中导出了一个可以加载库的__libc_dlopen_mode函数。

  • 5.主函数

　　先说一下流程，

　　a.获取被跟踪进程的link_map地址

　　b.根据link_map给出的信息，搜索符号表，遍历每一个link_map中的符号表，直到找到想要找的符号。这里是printf或者__libc_dlopen_mode函数

　　c.将库路径包括库名称传递给调用__libc_dlopen_mode的函数，该函数即call__libc_dlopen_mode会把__libc_dlopen_mode函数需要的参数，路径和加载方式压栈，在让被跟踪进

　　　程开始运行之前，压入一个非法地址，当__libc_dlopen_mode返回时返回到一个非法地址时，就会发生中断，此时跟踪进程可以waitpid跟踪到。好，设置寄存器，并让被跟踪进程开

　　　始运行。打开库之后，被跟踪进程因中断而被跟踪进程再次获得控制权。

　　d.再一次根据之前保存的link_map信息，当然完全可以直接用上一次搜索结果结束之后的link_map往后找，因为新库一定在最后，但是本文还是从头开始找，找到新库中的

　　　newmyprint地址。

　　e.还是根据link_map信息查找printf的重定向地址，在rel.dyn节中，有关这个rel.dyn和rel.plt等节之间的关系，可以看我的其他博文。

　　f.将newmyprint的地址填入printf的重定向地址。

　　g.将被跟踪进程原先的寄存器设置回去，释放控制。

　　h.被跟踪进程开始输出“哈哈哈哈哈”。

　　上源码：

　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

int main(int argc, char *argv[])

{

    int pid;

    struct link_map *map;

    char sym_name[256];

    unsigned long sym_addr;

    unsigned long new_addr,old_addr,rel_addr;

    int status = 0;

    char libpath[1024];

    char oldfunname[128];

    char newfunname[128];

    //mode = atoi(argv[2]);

    if(argc < 5){

        printf("usage : ./injso pid libpath oldfunname newfunname\n");

        exit(-1);

    }

    /* 从命令行取得目标进程PID*/

    pid = atoi(argv[1]);

    

    /* 从命令行取得新库名称*/

    memset(libpath,0,sizeof(libpath));

    memcpy(libpath,argv[2],strlen(argv[2]));

    

    /* 从命令行取得旧函数的名称*/

    memset(oldfunname,0,sizeof(oldfunname));

    memcpy(oldfunname,argv[3],strlen(argv[3]));

    

    /* 从命令行取得新函数的名称*/

    memset(newfunname,0,sizeof(newfunname));

    memcpy(newfunname,argv[4],strlen(argv[4]));

    printf("main pid = %d\n",pid);

    printf("main libpath : %s\n",libpath);

    printf("main oldfunname : %s\n",oldfunname);

    printf("main newfunname : %s\n",newfunname);

    /* 关联到目标进程*/

    ptrace_attach(pid);

   

    /* 得到指向link_map链表的指针 */

    map = get_linkmap(pid);                    /* get_linkmap */

    

    sym_addr = find_symbol(pid, map, "printf");      

    printf("found printf at addr %p\n", sym_addr); 

    if(sym_addr == 0)

        goto detach;

    call_printf(pid,sym_addr,"injso successed\n");

    waitpid(pid,&status,0);

    printf("status = %x\n",status);

    

    /*ptrace_writereg(pid, &oldregs);

    ptrace_cont(pid);

    

    waitpid(pid,&status,0);

    //printf("status = %x\n",status);

    //ptrace_readreg(pid, &oldregs);

    //oldregs.eip = 0x8048414;

    //ptrace_writereg(pid, &oldregs);

    ptrace_cont(int pid)(pid);

    

    ptrace_detach(pid);

    exit(0);*/

    

    /* 发现__libc_dlopen_mode，并调用它 */

    sym_addr = find_symbol(pid, map, "__libc_dlopen_mode");        /* call _dl_open */

    printf("found __libc_dlopen_mode at addr %p\n", sym_addr); 

    if(sym_addr == 0)

        goto detach;

    call__libc_dlopen_mode(pid, sym_addr,libpath);    /* 注意装载的库地址 */

    //while(1);

    waitpid(pid,&status,0);

    /* 找到新函数的地址 */

    strcpy(sym_name, newfunname);                /* intercept */

    sym_addr = find_symbol(pid, map, sym_name);

    printf("%s addr\t %p\n", sym_name, sym_addr);

    if(sym_addr == 0)

        goto detach;

    /* 找到旧函数在重定向表的地址 */

    strcpy(sym_name, oldfunname);              

    rel_addr = find_sym_in_rel(pid, sym_name);

    printf("%s rel addr\t %p\n", sym_name, rel_addr);

    if(rel_addr == 0)

        goto detach;

    /* 找到用于保存read地址的指针 */

    //strcpy(sym_name, "oldread");              

    //old_addr = find_symbol(pid, map, sym_name);

    //printf("%s addr\t %p\n", sym_name, old_addr);

    /* 函数重定向 */

    puts("intercept...");                    /* intercept */

    //ptrace_read(pid, rel_addr, &new_addr, sizeof(new_addr));

    //ptrace_write(pid, old_addr, &new_addr, sizeof(new_addr));

    //rel_addr = 0x8048497;如果是静态地址，也就是未导出该符号地址，那么只能通过反汇编先找到该函数被调用的地方，将这个地方的跳转地址修改

    

    if(modifyflag == 2)

        sym_addr = sym_addr - rel_addr - 4;

    printf("main modify sym_addr = %x\n",sym_addr);

    ptrace_write(pid, rel_addr, &sym_addr, sizeof(sym_addr));

    

    puts("injectso ok");

detach:

    printf("prepare to detach\n");

    ptrace_detach(pid);

    

    return 0;

  

}

　　这里面有一个很重要的地方，如果不先在目标进程中调用printf就不能够调用__lib_dlopen_mode成功，这个原因很奇怪，根据当时的core文件来看崩溃在了下面的这个函数，原因是_dl_open_hook这个全局变量为0，但实际上运行过printf之后，这个_dl_open_hook还是0。这个有待后续检验。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

void *

__libc_dlsym (void *map, const char *name)

{

  struct do_dlsym_args args;

  args.map = map;

  args.name = name;

#ifdef SHARED

  if (__builtin_expect (_dl_open_hook != NULL, 0))

    return _dl_open_hook->dlsym (map, name);

#endif

  return (dlerror_run (do_dlsym, &args) ? NULL

      : (void *) (DL_SYMBOL_ADDRESS (args.loadbase, args.ref)));

}

　　运行结果：

[email protected]:injso# ./test
1467364356 : original
injso successed
hahahahahahahahahahahahahaha

  • 6.如何替换未导出符号的地址

　　被替换函数源码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include <stdio.h>

//int fun2();

int fun1()

{

        printf("fun1\n");

//      fun2();

}

int main()

{

        signed int i  = 0x40011673 ;

        i = i - 0x4001172d ;

        printf("i = %x\n",i);

        while(1){

                i = fun1();

                sleep(10);

        }

        return 1;

}

　　这个怎么来替换fun1函数的地址呢？

　　首先反汇编得到main的机器码，如下，


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

08048468 <main>:

 8048468:       55                      push   %ebp

 8048469:       89 e5                   mov    %esp,%ebp

 804846b:       83 e4 f0                and    $0xfffffff0,%esp

 804846e:       83 ec 20                sub    $0x20,%esp

 8048471:       c7 44 24 1c 73 16 01    movl   $0x40011673,0x1c(%esp)

 8048478:       40

 8048479:       81 6c 24 1c 2d 17 01    subl   $0x4001172d,0x1c(%esp)

 8048480:       40

 8048481:       b8 75 85 04 08          mov    $0x8048575,%eax

 8048486:       8b 54 24 1c             mov    0x1c(%esp),%edx

 804848a:       89 54 24 04             mov    %edx,0x4(%esp)

 804848e:       89 04 24                mov    %eax,(%esp)

 8048491:       e8 ce fe ff ff          call   8048364 <printf@plt>

 8048496:       e8 b9 ff ff ff          call   8048454 <fun1>

 804849b:       89 44 24 1c             mov    %eax,0x1c(%esp)

 804849f:       c7 04 24 0a 00 00 00    movl   $0xa,(%esp)

 80484a6:       e8 c9 fe ff ff          call   8048374 <[email protected]>

 80484ab:       eb e9                   jmp    8048496 <main+0x2e>

 80484ad:       90                      nop

 80484ae:       90                      nop

 80484af:       90                      nop

　　可以看到在地址0x8048496处的机器码是跳转到fun1函数的，那么这个ffffffb9就是call的操作数，操作数地址0x8048497，也就是说把这个地址中的数值改掉就可以了，有关这个call或者jmp的地址计算可以查看我的另外一篇博文。

　　有关这个如何跳转的方法，已经在主函数的代码中给出了，但是被我注释掉了，大家感兴趣的话，可以自己试试。

　　效果：

[email protected]:lib2lib# ./a.out 
i = ffffff46
fun1
injso successed
hahahahahahaha^C

　　这里面的无关代码，大家仔细看，是为了证明call的函数地址计算方式的。

  • 7.总结

　　那么讲到现在的话，已经实现了不管函数符号是否导出都可以实现运行时替换的代码。

　　这里面主要的技术是，elf文件格式，运行时加载的过程，跳转地址的计算，运行时链接的过程，也就是plt表(当然这个也可以从我的另一篇博文中看到)。

　　比较遗憾的是有关那个奔溃，有网友如果找到了原因，请回复下，3q。当然我也会自己再研究下。

　　最后补上全局变量和头文件：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

#include <stdio.h>

#include <string.h>

#include <elf.h>

#include <sys/types.h>

#include <stdio.h>

#include <sys/ptrace.h>

#include <sys/wait.h>

#include <sys/errno.h>

#include <sys/user.h>

#include <link.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <bits/dlfcn.h>

#define IMAGE_ADDR 0x08048000

int mode = 2;

struct user_regs_struct oldregs;

Elf32_Addr phdr_addr;

Elf32_Addr dyn_addr;

Elf32_Addr map_addr;

Elf32_Addr symtab;

Elf32_Addr strtab;

Elf32_Addr jmprel;

Elf32_Addr reldyn;

Elf32_Word reldynsz;

Elf32_Word totalrelsize;

Elf32_Word relsize;

unsigned long link_addr;

int nrels;

int nreldyns;

//int nchains;

int modifyflag = 0;

/*char libpath[128] = "/mnt/hgfs/svnroot/test/injectsov2/prj_linux/so.so";*/

　　

  • 8.修正

　　针对在调用__libc_dlopen_mode函数之前需要调用printf的问题，终于让我在晚上解决了。
　　首先，我尝试了调用其他函数而不是printf函数，发现效果一样，包括第一次是调用__libc_dlopen_mode，第二次对该函数的调用都可以成功。
　　其次，那么现在问题就集中在了这两个__libc_dlopen_mode调用之间的差别在哪里，程序段肯定是一致的，栈也是一致的，而堆空间未使用，还有一个重要的因素，那就是寄存器。
　　最后，发现在调用__libc_dlopen_mode前，有四个寄存器不同，分别是eax，orig_eax,eflags和esp。我一开始认为，通用寄存器eax和orig_eax不会对程序的执行造成影响。但是通过实验，仅调一次__libc_dlopen_mode，部分寄存器赋正确执行时的值，发现对eax和orig_eax被赋于正确执行时的值时，程序可以正常运行，而且不仅仅必须是一种值，比如eax可以是0,1,0xffffffff，很多值都可以，但是被赋予0xfffffdfc和0xfffffdff等值时会失败，试验过并不是因为d这一位决定的，0xfffffdf0或者d00是可以运行成功的。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

(gdb) disassemble __libc_dlopen_mode

Dump of assembler code for function __libc_dlopen_mode:

   0x00232640 <+0>:   push   %ebp

   0x00232641 <+1>:   mov    %esp,%ebp

   0x00232643 <+3>:   sub    $0x1c,%esp

   0x00232646 <+6>:   mov    %ebx,-0x8(%ebp)

   0x00232649 <+9>:   mov    0x8(%ebp),%eax

   0x0023264c <+12>:  call   0x144a0f

   0x00232651 <+17>:  add    $0x519a3,%ebx

   0x00232657 <+23>:  mov    0xc(%ebp),%edx

   0x0023265a <+26>:  mov    %esi,-0x4(%ebp)

   0x0023265d <+29>:  mov    %eax,-0x14(%ebp)

   0x00232660 <+32>:  mov    %edx,-0x10(%ebp)

   0x00232663 <+35>:  mov    0x354c(%ebx),%esi

   0x00232669 <+41>:  test   %esi,%esi

　　在实验中，还发现对eax赋于不正确的值时，当时忘了记了，还让程序跑飞了。崩了，但是新库已经加载上了。所以这个函数替换还是有一定的风险，或者说libc库本身存在一定的bug。
　　所以现在问题找到了，在于eax和orig_eax上，但是对__libc_dlopen_mode反汇编发现，eax在函数开头就被赋予了通过栈传递的参数2的值，所以eax不应该影响程序的运行，但实际上影响了，这一点让我觉得很奇怪，如果有任何网友对这个原因知晓的话，麻烦回复，万分感谢。

　　linux共享库注射地址：http://www.docin.com/p-634172083.html

　　__simple原创

　　转载请注明出处

时间： 2024-10-13 08:37:28

linux下实现在程序运行时的函数替换(热补丁)【转】的相关文章

在程序运行时实现函数替换

声明:以下的代码成果,是参考了网上的injso技术,文章最后会给出地址. 另外一个,injso文章中的代码实际上不能够运行起来的,后面出现的代码都是经过我个人修改和检测的. 最近因为在学习一些调试的技术,但是很少有提到如何在函数运行时实现函数替换的. 为什么会想到这一点?因为在学习调试时,难免会看到一些内核方面的调试技术,内核中的调试有一个kprobe,很强大,可以实现运行时的函数替换.其原理就是hook,钩子,但是学习了这个kprobe之后会发现,kprobe内部有检测所要钩的函数是不是属于内

Linux下查看进程(程序)启动时的环境变量

背景: 因最近试安装Linux下的jira,有一个中文插件安装后,一旦设置开机启动后,它是英文,而在终端再重新启动一次后呢,似乎插件生效,它又恢复为正常中文界面,我首先想这这涉及到一个环境变量的问题,因为在我设置开机启动的服务时用service jira start出现找不到一些变量,如:获取不到java的home目录,提示找不到,为此,我加上了java的环境变量开机启动Ok了,但是英文,我对英文认识少,但还是想用中文,否则插件就等于白安了. 为此,需要弄清这两者的环境变量的区别在哪儿,如何查看

Linux下程序运行时内存状态及相应查看工具

最近在解决一个编译问题时,一直在考虑一个问题,那就是Linux下可执行程序运行时内存是什么状态,是按照什么方式分配内存并运行的.查看了一下资料,就此总结一下,众所周知,linux下内存管理是通过虚存管理的,在分配内存是并非在物理内存开辟了一段空间,而是在使用时才分配的,而且是通过段页式管理.以上比较废话,开始看看程序运行时内存会是什么状态. 在linux下内存分配是以页为单位的,而页是通过段管理,各个段之间是独立的,方便管理.linux程序运行时,可以分为以下几个内存段: 一.BSS段 (bss

【java】 linux下利用nohup后台运行jar文件包程序

Linux 运行jar包命令如下: 方式一: java -jar XXX.jar 特点:当前ssh窗口被锁定,可按CTRL + C打断程序运行,或直接关闭窗口,程序退出 那如何让窗口不锁定? 方式二 java -jar XXX.jar & &代表在后台运行. 特定:当前ssh窗口不被锁定,但是当窗口关闭时,程序中止运行. 继续改进,如何让窗口关闭时,程序仍然运行? 方式三 nohup java -jar XXX.jar & nohup 意思是不挂断运行命令,当账户退出或终端关闭时,

在linux下，查看一个运行中的程序， 占用了多少内存

1. 在linux下,查看一个运行中的程序, 占用了多少内存, 一般的命令有 (1). ps aux: 其中  VSZ(或VSS)列 表示,程序占用了多少虚拟内存. RSS列 表示, 程序占用了多少物理内存. 虚拟内存可以不用考虑,它并不占用实际物理内存. (2). top 命令也可以 其中  VIRT(或VSS)列  表示,程序占用了多少虚拟内存. 同 ps aux 中的 VSZ列 RES列 表示, 程序占用了多少物理内存.同 ps aux 中的RSS列 2.在linux下, 查看当前系统占用

在linux下安装eclipse以及运行c++程序的安装步骤

1.       下载jre,eclipse,cdt 其中jre是java运行环境,eclipse需要先装jre,才可能运行,cdt是在eclipse中运行c\c++程序的插件. 下载jre 网址是:http://www.oracle.com/technetwork/java/javase/downloads/index.html,点击JRE下载(如下图) 选择"Aceept License Argeement" (如上图) 点击"jre-7u21-linux-i586.bi

两种在linux下创建应用程序快捷方式的方法

两种在linux下创建应用程序快捷方式的方法: A. 在桌面上创建快捷方式 B. 在应用程序菜单中添加快捷方式 在桌面上创建快捷方式 这是最简单的一种方法,在桌面上单击鼠标右键,会有一个“创建启动器”栏.这里我以为mplayer创建快捷方式为例说明: 名称-mplayer(或者你喜欢的任何名称,这个名称会出现在快捷图标的 下方) 命令-/usr/bin/gmplayer(这个是mplayer的gui应用程序的执行文件,跟 安装路径相关,可以通过which gmplayer找到) 图标-一般应用程

Linux下C/C++程序调试基础（GCC，G++，GDB，CGDB，DDD）

在写程序的时候,经常会遇到一些问题,比如某些变量计算结果不是我们预期的那样,这时我们需要对程序进行调试.本文主要介绍调试C/C++在Linux操作系统下主要的调试工具. 在Linux下写程序,C/C++主要的编译器有GCC/G++,ICC等,像我等穷码农,最喜欢GCC了,很大原因是他免费!所以,我们以GCC/G++为例介绍主要的调试工具. 分以下几个内容介绍: 1.调试之前的工作 2.选择调试工具 3.调试步骤 点我,请帮我投一票! 调试之前的工作 编译器在编译阶段需要产生可供调试的代码,才能被

Linux下Qt应用程序的发布（使用LDD命令查看所有依赖的库文件）

最近一直在学习Qt,用Qt写了一个程序,但是不知道怎么发布,网上说的都是在windows下怎么发布Qt应用程序,但是,在windows下Qt应用程序依赖的库文件与linux下的名字不同.于是,我就想到Linux下有没有这么一个命令,能够找到一个可执行文件运行时所依赖的库文件,百度一下,还真的有ldd命令. ldd的作用是打印可执行文件依赖的共享库文件,它是glibc的一部分: [email protected]:~# ldd --helpUsage: ldd [OPTION]... FILE..