Cpp on Tech Explorer

构造最短程序打印自身的 MD5

Mon, 20 Apr 2020 00:00:00 +0000

一，介绍
#

比赛题目很简单：构造一个程序，在 stdout 上打印出自身的 MD5，程序越短越好。按最终程序文件大小字节数排名，文件越小，排名越靠前。只能使用 ld-linux-x86-64.so, libc.so, libdl.so, libgcc_s.so, libm.so, libstdc++.so 。禁止了 socket, shmget, fork, execvc 等 syscall 。

汇编高手如云，本人只做到 752 字节，只拿到 27 名。但忙活好几天，学到不少东西，也有苦劳，还是值得记录一下。

基本是纯 C 实现，没有动用汇编。

二，用过的一些思路和资源
#

基于这个 MD5 实现改造 https://gist.github.com/creationix/4710780

https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly

参照 musl 和 rt0 ，去除对 glibc 依赖

musl libc https://www.musl-libc.org/
rt0 : https://github.com/lpsantil/rt0

三，没有成功的一些思路
#

思路，利用内核的 MD5 计算代码： grep -i md5 linux-5.6.2 只找到 2处，
1. TCP_MD5SIG ， CONFIG_TCP_MD5SIG : “TCP: MD5 Signature Option support (RFC2385)” 一个冷门特性，看起来通过 socket 才能执行。
2. AF_ALG Linux 的 crypto api，通过 socket 形式暴露 api，但是 socket 被禁用了。 https://www.chronox.de/libkcapi.html
构造碰撞，hardcode 直接 print 出来

https://github.com/corkami/collisions

https://www.rogdham.net/2017/03/12/gif-md5-hashquine.en

https://github.com/Rogdham/gif-md5-hashquine

http://www.win.tue.nl/hashclash/ 尝试了 fastcoll_v1 ，但是 fastcoll 构造1个字节的冲突要 2 block = 128 字节，则 16 字节就要 2048 字节，还不如 C 语言直接算。
通过某些 ipc 机制，绕过评判。试了简单的 shmget, 不成功。

三. 代码
#

后续借鉴思路，有优化

#define SYS_write 1
#define SYS_exit 60

inline long syscall3(long n, long a0, long a1, long a2) {
 long ret;
 __asm__ volatile("syscall" : "=a"(ret) : "a"(n), "D"(a0), "S"(a1), "d"(a2) : "rcx", "r11", "memory");
 return (ret);
}
inline long syscall1(long n, long a0) {
 long ret;
 __asm__ volatile("syscall" : "=a"(ret) : "a"(n), "D"(a0) : "rcx", "r11", "memory");
 return (ret);
}

static int write(int f, const char* d, int l) {
 int ret = syscall3(SYS_write, f, (long)(d), l);
 return (ret);
}

void _exit(int r) { syscall1(SYS_exit, r); }

typedef unsigned uint32_t;
typedef unsigned char uint8_t;
typedef unsigned long size_t;
#define NULL 0 // In words

#define memcpy(dest, src, n) \
 for (size_t i = 0; i < n; ++i) { \
 ((char*)dest)[i] = ((const char*)src)[i]; \
 }

// leftrotate function definition
#define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c))))

static void md5_hash(uint8_t* initial_msg, const size_t initial_len, uint32_t hash[4]) {
 // Note: All variables are unsigned 32 bit and wrap modulo 2^32 when calculating

 // r specifies the per-round shift amounts
 const static uint8_t r[] = {
 7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21,
 };

 // Use binary integer part of the sines of integers (in radians) as constants// Initialize variables:
 uint32_t k[64];
 for (int i = 0; i < 64; ++i) {
 double f = 1.0 + i;
 asm("fsin;\n\t"
 "fabs;\n\t"
 : "=t"(f)
 : "0"(f));
 f *= 4294967296.0;
 k[i] = (uint32_t)f;
 }

 // Pre-processing: adding a single 1 bit
 // append "1" bit to message
 /* Notice: the input bytes are considered as bits strings,
 where the first bit is the most significant bit of the byte.[37] */

 // Pre-processing: padding with zeros
 // append "0" bit until message length in bit ≡ 448 (mod 512)
 // append length mod (2 pow 64) to message

 const int new_len = ((((initial_len + 8) / 64) + 1) * 64) - 8;

 // Message (to prepare)
 uint8_t* msg = initial_msg msg[initial_len] = 128; // write the "1" bit

 uint32_t bits_len = 8 * initial_len; // note, we append the len
 memcpy(msg + new_len, &bits_len, 4); // in bits at the end of the buffer

 // Process the message in successive 512-bit chunks:
 // for each 512-bit chunk of message:
 for (int offset = 0; offset < new_len; offset += 64) {
 // break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15
 uint32_t* w = (uint32_t*)(msg + offset);

 // Initialize hash value for this chunk:
 uint32_t a = hash[0];
 uint32_t b = hash[1];
 uint32_t c = hash[2];
 uint32_t d = hash[3];

 // Main loop:
 uint32_t i;
 for (i = 0; i < 64; i++) {
 uint32_t f, g;

 if (i < 16) {
 f = (b & c) | ((~b) & d);
 g = i;
 } else if (i < 32) {
 f = (d & b) | ((~d) & c);
 g = (5 * i + 1) % 16;
 } else if (i < 48) {
 f = b ^ c ^ d;
 g = (3 * i + 5) % 16;
 } else {
 f = c ^ (b | (~d));
 g = (7 * i) % 16;
 }

 uint32_t temp = d;
 d = c;
 c = b;
 b = b + LEFTROTATE((a + f + k[i] + w[g]), r[i / 4 / 4 * 4 + i % 4]);
 a = temp;
 }

 // Add this chunk's hash to result so far:

 hash[0] += a;
 hash[1] += b;
 hash[2] += c;
 hash[3] += d;
 }
}

static char xdigits(char c) {
 if ((c >= 0) && (c <= 9)) {
 return '0' + c;
 }
 return 'a' + (c - 10);
}

void _start(void) __attribute__((noreturn));

void _start(void) {
 uint32_t hash[4] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476};

 char* addr = (char*)0x400000;
 const size_t len = 688;
 md5_hash(addr, len, hash);

 unsigned char* md = (unsigned char*)&hash[0];
 char buff[32];
 for (int i = 0; i < 32; ++i) {
 unsigned x = md[(i >> 1)];
 x >>= (i & 1 ? 0 : 4);
 buff[i] = xdigits(x & 15);
 }
 write(1, &buff[0], sizeof(buff));
 _exit(0);
}

CFLAGS="-static -Os -Wl,--omagic -D__RT0_WITH_FASTER_SYSCALL__ -ffunction-sections -Wl,--gc-sections -nostartfiles -nodefaultlibs -nostdlib -nostdinc -Wl,--build-id=none -fomit-frame-pointer -fno-stack-protector -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-unroll-loops -fmerge-all-constants -fno-ident -mfpmath=sse -mfancy-math-387 -finline-functions-called-once -I ./ "

gcc $CFLAGS print_my_md5.c -S -fverbose-asm
gcc $CFLAGS print_my_md5.s -o print_my_md5 

strip -R .comment print_my_md5
strip -R .bss print_my_md5
ls -l ./print_my_md5
./ELFkickers/sstrip/sstrip print_my_md5
./print_my_md5
echo
md5sum ./print_my_md5
ls -l ./print_my_md5

怎样让 C++ 中 throw exception 产生的 coredump 带上栈

Sun, 29 Mar 2020 00:00:00 +0000

1. 问题
#

一个 C++ 程序，如果 throw 了 exception ，但是又没有 catch，那么一般会产生 coredump，问题是，在 gcc 4.x 版本产生的 coredump 文件中，没有 throw 时候的堆栈信息，导致不知道是哪里 throw 的，没法查问题。

原因是 gcc 4.x 的 /libstdc++-v3/src/c++11/thread.cc:92 里面有个 catch(…)，所以 stack unwind 了，就没了 throw 时候的 stack 。

void * execute_native_thread_routine(){
 try {
 ... 
 }catch(...){
 std::terminate();
 }
}

https://abcdabcd987.com/libstdc++-bug/

一个解决办法是可以升级 GCC 7 ，或者可以用更简单的办法：

2.代码 hook `__cxa_throw` ，让 coredump 带上堆栈
#

一个解决办法是通过改代码，hook __cxa_throw() 让每次生成的 coredump 都带上堆栈：

https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/cxxabi.h#L616

// Throw the exception.
void __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *)) __attribute__((__noreturn__));

__cxa_throw() 是 libstdc++/libc++ 用于实现 throw 的函数。

https://libcxxabi.llvm.org/spec.html

#include <iostream>
#include <stdexcept>
#include <thread>

extern "C" { //加这3行代码，通过 hook __cxa_throw，直接 abort，可以避免 stack unwind。
 void __cxa_throw(void* ex, void* info, void (*dest)(void*)) { ::abort(); }
}

void func(){
 throw std::runtime_error("die");
}

int main() {
 std::thread t(func);
 t.join();
 return 0;
}

效果如下

(gdb) bt
#0 __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1 0x00007ffff7264801 in __GI_abort () at abort.c:79
#2 0x0000555555554f53 in __cxa_throw (ex=0x7ffff0000ba0, info=0x555555756ce0 <typeinfo for std::runtime_error@@GLIBCXX_3.4>, 
 dest=0x7ffff7af4140 <std::runtime_error::~runtime_error()>) at test.cpp:6
#3 0x0000555555554f8f in func () at test.cpp:10
#4 0x0000555555555371 in std::__invoke_impl<void, void (*)()> (__f=@0x555555769e78: 0x555555554f53 <func()>)
 at /usr/include/c++/7/bits/invoke.h:60
#5 0x000055555555517e in std::__invoke<void (*)()> (__fn=@0x555555769e78: 0x555555554f53 <func()>) at /usr/include/c++/7/bits/invoke.h:95
#6 0x000055555555584c in std:: thread::_Invoker<std::tuple<void (*)()> >::_M_invoke<0ul> (this=0x555555769e78) at /usr/include/c++/7/thread:234
#7 0x0000555555555808 in std:: thread::_Invoker<std::tuple<void (*)()> >::operator() (this=0x555555769e78) at /usr/include/c++/7/thread:243
#8 0x00005555555557d8 in std:: thread::_State_impl<std:: thread::_Invoker<std::tuple<void (*)()> > >::_M_run (this=0x555555769e70)
 at /usr/include/c++/7/thread:186
#9 0x00007ffff7b096ef in ?? () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#10 0x00007ffff761c6db in start_thread (arg=0x7ffff6e85700) at pthread_create.c:463
#11 0x00007ffff734588f in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:95

3. gdb `catch throw`
#

如果是对已有的二进制，或者已经在运行的进程：

gdb 里面输入 catch throw 然后运行，gdb 就会在任何 throw 的时候暂停，即可看到 throw 时候的栈。

mock C++ function for unit test

Thu, 27 Mar 2014 00:00:00 +0000

在单元测试中，我们需要提供业务逻辑的mock版本，当业务逻辑实现为C++的virtual function时，这是很容易的，我们只需要写一个子类，实现virtual function就行了，Google 的 gmock就针对这种情况设计。

问题
#

可是，如果遗留代码中有一般C函数，非virtual的类成员函数，模板函数，inline函数，如何提供mock版本呢？

下面的代码用一点trick实现了上述函数的运行时mock。

原理
#

原理是，在运行时，修改目标函数的机器码，改为jmp到mock版本的函数中。

实现
#

实现如下：

#include <stdint.h>
#include <iostream>
#include <string>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include "patch_elf.h"
using namespace std;


int print_op(void * addr,int leng){
 unsigned char * op=(unsigned char *) addr;
 cout<<endl<<"addr:"<<addr<<" code:"<<endl;
 for(int i=0;i<leng;++i){
 cout<<"0x"<<hex<<(unsigned int)op[i]<<" ";
 }
 cout<<endl;
 return 0;
}

int patch_func(void * original,void * mock){
 /*
 cout<<endl<<"----------------------------------------------------------------------"
 <<endl<<__func__<<" ,i am going to patch "<<original<<" to "<<mock
 <<endl;
 */

 //rax 用于保存函数调用的返回值，所以可以占用
 //4010e1: b8 20 0c 40 00 mov $0x400c20,%eax
 //4010e6: ff e0 jmpq *%rax

 uint32_t addr=(uint32_t)(uint64_t)mock;
 const int code_len=7;
 char inject_code[code_len]={0xb8,0x00,0x00,0x00,0x00,0xff,0xe0};
 memcpy(&inject_code[1],(char*)&addr,4);

 //print_op(inject_code,code_len);

 //接下来，把inject_code复制到original这个位置
 //print_op(original,100);
 
 //首先，要改掉内存的权限，增加写权限
 const size_t length = sysconf(_SC_PAGESIZE);
 void * code_addr= (void*) ( ( (long) original/length)*length );
 int ret=mprotect(code_addr, length, PROT_READ | PROT_WRITE | PROT_EXEC);
 if ( 0!=ret ) {
 cerr<<"mprotect failed! ret="<<ret<<endl;
 }

 //修改代码
 memcpy( original,inject_code,code_len);

 //再去掉写权限
 ret=mprotect(code_addr, length, PROT_READ | PROT_EXEC);
 if ( 0!=ret ) {
 cerr<<"mprotect failed! ret="<<ret<<endl;
 }

 //print_op(original,100);
 //cout<<"----------------------------------------------------------------------"
 // <<endl<<endl;
 return 0;
}

测试了

1.一般函数 2.inline函数 3.一般成员函数 4.模板函数

并在：32位，64位; -O2, -O0，参数下编译

除了 inline函数没办法，其它的都有效

#pragma once
#include <iostream>
#include <cstdio>
using namespace std;

class ST1{
 public:
 uint32_t a;
 uint64_t b;
 char c[200];
 double d;
 ST1 * e;

 ST1():a(0),b(0),d(0),e(0){
 c[0]=0;
 }

 //类的成员函数
 int member_func();
 int member_func_mock();
};

int member_func_extern(ST1 * st);


//一般函数
int original_func(ST1 * para1,ST1 para2,void * para3);
int mock_func(ST1 * para1,ST1 para2,void * para3);
//int ref_func(ST1 * para1,ST1 para2,void * para3);

class Base{
 private:
 uint32_t b;
 ST1 st;
 public:
 uint32_t a;

 Base():b(0),a(0){}
};

//inline 函数
inline int inline_func(int a,int b){
 int c=a+b+ 0x1111 * a + b/0x1111;
 printf("%s %d\n",__func__,c);
 return c;
}

inline int inline_func_mock(int a,int b){
 int c=a+b+100;
 printf("%s %d\n",__func__,c);
 return c;
}

//模板函数
template <typename T>
uint32_t get_member_a(T & t){
 cout<<__func__<<" a="<<t.a<<endl;
 return t.a;
}

template <typename T>
uint32_t get_member_b(T & t){
 cout<<__func__<<" b="<<t.b<<endl;
 return t.b;
}

#include <stdint.h>
#include <iostream>
#include <string>
#include <unistd.h>
#include "func.h"
using namespace std;

int original_func(ST1 * para1,ST1 para2,void * para3){
 cout<<__func__<<"\tcalled! "
 <<" a+a "<<para1->a+para2.a
 <<" b+b "<<para1->b+para2.b
 <<" c+c "<<para1->c<<para2.c
 <<" d+d "<<para1->d+para2.d
 <<" e+e "<<para1->e<<para2.e
 <<para3
 <<endl;
 return 0;
}


int mock_func(ST1 * para1,ST1 para2,void * para3){
 cout<<__func__<<"\tcalled!"
 <<endl;
 return 0;
}

int ref_func(ST1 * para1,ST1 para2,void * para3){
 return mock_func(para1,para2,para3);
}

int ST1::member_func(){
 cout<<__func__<<" called! "
 <<" a="<< this->a
 <<" b="<< this->b
 <<" c="<< this->c
 <<" d="<< this->d
 <<endl;
 return 0;
}

int ST1::member_func_mock(){
 cout<<__func__<<" called! i do nothing."
 <<endl;
 return 0;
}

int member_func_extern(ST1 * st){
 cout<<__func__<<" called! i am not member function."
 <<endl;
 return 0;
}

#include <stdint.h>
#include <iostream>
#include <string>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>

#include "func.h"
#include "patch_elf.h"

using namespace std;


int test(){
 ST1 s1,s2;
 char str[]="hello";
 s1.a=s1.b=s1.d=1;
 s1.e=NULL;

 s2.a=s2.b=s2.d=2;
 s1.e=NULL;

 cout<<"----------------------------------------------------------------------"<<endl;

 //mock original_func，替换成mock_func
 original_func(&s1,s2,&str[0]);

 patch_func((void*)&original_func, (void*)&mock_func);

 original_func(&s1,s2,&str[0]);

 cout<<"----------------------------------------------------------------------"<<endl;

 //mock inline 函数貌似不行
 int a=s1.a, b=s1.b;
 inline_func(a,b);
 patch_func( (void*) &inline_func, (void*) &inline_func_mock);
 inline_func(a,b);

 cout<<"----------------------------------------------------------------------"<<endl;

 s1.member_func();
 patch_func( (void*) &ST1::member_func, (void*) &ST1::member_func_mock);
 s1.member_func();
 patch_func( (void*) &ST1::member_func, (void*) &member_func_extern);
 s1.member_func();

 cout<<"----------------------------------------------------------------------"<<endl;

 get_member_a(s1);
 patch_func( (void*) & get_member_a<ST1> , (void*) & get_member_b<ST1>);
 get_member_a(s1);

 return 0;
}

int main(){
 test();
 return 0;
}

参考资料
#

可以参考

subhook: https://github.com/Zeex/subhook
Microsoft Detours: https://github.com/microsoft/detours
MinHook: https://github.com/TsudaKageyu/minhook
PolyHook: https://github.com/stevemk14ebr/PolyHook_2_0
https://www.codeproject.com/Articles/21414/Powerful-x86-x64-Mini-Hook-Engine

visual studio静态，动态链接库开发工具简单使用

Sun, 13 Nov 2011 00:00:00 +0000

这是2011年8月份做过的一点实验，查了MSDN等等很多资料，基本搞明白了。

这里我不会使用visual studio的图形界面工具，作为专业人士，还是搞懂自己的工具是怎么运转的，这样比较好。

gcc 与 cl 的命令对应关系
#

要使用的是visual studio的命令行工具，其实和gcc那堆工具对应关系挺明显的，大致如下：

gcc	cl
ar	lib
ld	link

文件后缀对应关系:

gcc	cl
.a	.lib
.so	.dll
.o	.obj

新手注意：这个命令提示符是"开始菜单"–»“Microsoft Visual studio”–»“Visual Tools” 那里的提示符，其实就是设置过一些环境变量的cmd。

实验代码
#

先把实验代码贴出来（可以先跳过不看），共有五个文件：

1.build.bat

""C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat"" x86
cd dynamic
del /f /Q *
cl /LD ..\ext.c
del ext.obj
cl ..\main.c /link ext.lib
del main.obj
cd ..


cd static
del /f /Q *
cl /c ..\ext.c 
lib ext.obj
del ext.obj
cl ..\main-static.c /link ext.lib
del main*.obj main*.exp main*.lib
cd ..

2.库的头文件，ext.h

#ifndef EXT_H
#define EXT_H
 
#ifdef Import
#define Dll __declspec(dllimport)
#else
 
#ifdef Export 
#define Dll __declspec(dllexport)
#else 
#define Dll 
#endif
 
#endif
 
#include <stdio.h>
 
Dll typedef struct {
	int i;
	char c;
} st;
 
Dll extern int num;
Dll void fun();
Dll extern st s;
 
#endif

3.库的实现文件,ext.c

#define Export
#include "ext.h"
st s={24,'h'};
int num=0;
void fun(){
	printf("hello,i am in lib. num=%d\n",num++);
}

4.以动态链接库方式使用这个库的程序代码，main.c

#define Import
#include "ext.h" 
#include "windows.h"
#include<stdio.h>
 
int main(){
	fun();
	printf("num=%d\n",num);
	fun();
	printf("num=%d\n",num);
	printf("st i=%d c=%c \n",s.i,s.c);
}

5.以静态链接库方式使用这个库的程序代码，main-static.c

#include "ext.h" 
#include "windows.h"
#include<stdio.h>
 
int main(){
	fun();
	printf("num=%d\n",num);
	fun();
	printf("num=%d\n",num);
	printf("st i=%d c=%c \n",s.i,s.c);
}

一，静态链接库
#

一，静态链接库要给用户提供静态链接库，都要提供哪些文件呢？.h头文件+.lib库文件先问个问题：使用库的最简单方式是什么？当然是不使用库！不使用库谁不会啊？使用如下命令：

        cl main-static.c ext.c

在当前目录下，就会编译，链接成一个main-static.exe，执行一下，没有问题！

再问个问题：除了exe文件，还看见了什么？有ext.obj, main-static.obj, main-static.lib ,main-static.exp .

.obj文件是目标文件（object file）， .lib文件是静态库文件（msdn中称为导入库）， .exp文件，导出文件，辅助作用（参看这里和这里）可以猜想，用cl直接编译生成exe的过程，是

ext.c—»ext.obj
main-static.c–»main-static.obj
main-static.obj—»main-static.exp+main-static.lib
ext.obj+main-static.lib+main-static.exp—»main-static.exe

的过程

我尝试了改换参数顺序，即用命令

cl ext.c main-static.c

发现main-static.exp + main-static.lib换成了ext.lib+ext.exp 这说明是cl是先把.c文件都生成为obj文件，然后把第一个命令行参数指定xxx.c的xxx.obj文件再生成为xxx.lib+xxx.exp文件这和静态链接有什么关系呢？关系密切啊！把除了ext.lib 以外的所有生成文件删除，运行如下命令:

cl main-static.c /link ext.lib

就可以看见，生成了main-static.exe，运行正常。ext.lib就是静态链接库。其实，这就是一个静态链接的过程。

静态链接的第一步，怎么由ext.c生成obj文件？查msdn（或者命令cl /?）可知，给cl提供/c参数就可以了，先清掉那堆文件，运行

         cl /c ext.c

成功生成ext.obj.同理可以生成main-static.obj。严格来说编译已经完成，接下来的，都是链接过程。

第二步，怎么从obj文件生成.lib文件（加/DEF参数，就可以同时生成.exp文件)

 lib ext.obj

就生成了ext.lib 第三步，怎么从main-static.c + ext.lib 生成exe

 cl main-static.c /link ext.lib

需要注意的是，头文件一定要可以找到。

二，动态链接库
#

二，动态链接库 visual studio的动态链接分为显式链接和隐式链接两种（http://msdn.microsoft.com/zh-cn/library/253b8k2c(v=vs.80).aspx），显式链接就是自己写代码调用win32 Api加载dll文件，要使用LoadLibrary, GetProcAddress(), FreeLibrary()这些函数，这个方法几乎不需要工具，就不说了，看看msdn的例子就明白了。以下说的都是隐式链接

visual studio的动态链接库使用很与众不同，竟然需要提供三种文件：.h+.lib+.dll文件，诡异的是，这个.lib文件和静态链接库里的.lib文件其实不一样！更诡异的是，用户链接的时候，其实不需要.dll文件！

对比之下，linux下的gcc，若是动态链接库，需要的是.so+.h 文件（.so相当于.dll），这是显著的差异。

参看csdn(http://msdn.microsoft.com/zh-cn/library/3y1sfaz2(v=vs.100).aspx)可知，和静态链接不同的是，动态链接需要对库的源代码进行改动，添加

__declspec( dllimport )

或

 __declspec( dllexport )

补充：也可以用def文件，不过我没试过，参看 http://msdn.microsoft.com/zh-cn/library/0b9xe492.aspx 和 http://msdn.microsoft.com/zh-cn/library/28d6s79h.aspx 。

这个时候要注意，__declspec( dllimport )和__declspec( dllexport ) 的使用是不一样的，在库里导出的符号（函数，变量等，可以用dumpbin查看）应该使用__declspec( dllexport ) ，而使用库的代码，在包含头文件后，要有这些符号的声明，要看到__declspec( dllimport )形式的声明，所以这是有区别的。在上面ext.h里，我用了一个宏Dll来统一处理。

处理完源代码，就可以编译了。

第一步，生成obj文件，

cl /c ext.c

第二步，由obj文件生成dll文件+lib文件，

cl /LD ext.obj

或者也可以用

link /DLL ext.obj

可以看到，生成了ext.dll , ext.exp, ext.lib 三个文件，其中的ext.lib 这个文件和静态链接时生成的ext.lib文件是不一样的！而且ext.dll在main.c的链接过程中是用不着的！（此时已经生成了dll文件，要是使用显式链接，就把dll文件弄走，自己写代码去啦），继续隐式链接第三步，不妨移走ext.dll，然后编译

cl main.c /link ext.lib

可以看到生成main.exe，但是运行一下，会报告找不到ext.dll，当然找不到啦，只要把ext.dll移到当前目录下（或在dll文件查找路径中的一个中）即可正常运行。

注：dll文件查找路径参看 http://msdn.microsoft.com/zh-cn/library/7d83bc18(v=vs.80).aspx

这个领域关注的人少，鄙人理解浅薄，错误难免，欢迎指正。

Codeblocks配合gfortran作为fortran开发环境的配置方法

Thu, 12 May 2011 00:00:00 +0000

（以前在bmy bbs发过一次）

这个方法试过在64位win7和32位winxp上可用。

1，首先安装codeblockes，必须选完全安装（Full,All plugins,…），路径可以选默认路径即 C:/Program Files/CodeBlocks

（如果安装到别的路径，后面提到的路径请自行对应更改）,一路点yes，装完后关掉codeblocks。

2，汉化，把locale这个文件夹拷贝到 C:/Program Files/CodeBlocks/share/CodeBlocks/下（win7下需要管理员权限），确保最后的路径是这样的： C:/Program Files/CodeBlocks/share/CodeBlocks/locale/zh_CN/codeblocks.mo

然后打开codeblocks，如果没有自动汉化，到settings->environment->选左侧view，找到右侧的internationalization里找中文选上，点OK后重启codeblocks，如果汉化不成功，请检查codeblocks.mo文件是否在正确的路径。

3，安装含有gfortran的gcc，注意：最好选择一个不带空格的路径，更不要用中文路径，如C:/gcc ,把路径记住。

4,让codeblocks使用gfortran，在codeblocks菜单中选 “设置”->“编译器和调试器”，选中“GNU GCC 编译器”，点“复制”，然后输入一个好记的名字如“my Gfotran compiler”，打开“可执行工具链”，在“编译器安装目录”里找到C:/gcc，确定。

然后把下面的“C编译器”，“C++编译器”，“动态库链接器”都选成gfortran.exe,“调试器”选gdb.exe,其他的都不要动，确定。安装完成。

5，文件->新建->项目，选“empty project”，输入项目名，保存路径等，然后，在编译器下拉框中，必须选择“my Gfotran compiler”其余默认，建好项目后，选文件->新建->文件，选“empty file”，点 “…”按钮，输入一个以.f90结尾的文件名，并选中debug和release，确定。就可以在打开的编辑窗口中输入代码了。在菜单上有构建，调试等功能。

参考链接：

http://wiki.codeblocks.org/index.php?title=Installing_Fortran_Compiler

http://www.d2school.com/codeblocks/doc/codeblocks_setup.html

codeblocks下载页面(要上外网)

http://www.codeblocks.org/downloads/26

equation solution编译的gcc

http://www.equation.com/servlet/equation.cmd?fa=fortran

汉化包

http://www.d2school.com/codeblocks/download/d2school_codeblocks_chinese_locale.7z

Cpp on Tech Explorer

构造最短程序打印自身的 MD5

一，介绍 #

二，用过的一些思路和资源 #

三，没有成功的一些思路 #

三. 代码 #

怎样让 C++ 中 throw exception 产生的 coredump 带上栈

1. 问题 #

2.代码 hook __cxa_throw ，让 coredump 带上堆栈 #

3. gdb catch throw #

mock C++ function for unit test

问题 #

原理 #

实现 #

参考资料 #