今天是九九重阳节，杭州的钱塘江准备放三十万的烟花，到时一定很漂亮，本来一个朋友叫我去看的，只是公司说要一起去郊游，所以就没去了，遗憾
~~没办法，有时候鱼与熊掌不可兼得，有得必有失吧，失去了去看烟花的时间，却可以带领大家一起分析一下汇编的浮点运算的一些知识，自己也学到不少，因为自己以前也没有接触过浮点运算，只是听说过，这还是第一次跟踪，文章很简单，但对于没有接触过浮点运算的朋友，希望会有一些帮助！
[软件名称]不知不觉背单词，网上有很多下载地址，大家可以自己搜索下载！(网上好像已经有了破解版！）注明：此文仅用于技术交流，尊重原作者版权！其实别人花那么多精力开发个软件也不容易啦！
分析这款软件我花了半天的时间，从爆破----->到分析出注册码------->到算法的分析！完全使用OD进行分析跟踪，没有使用IDA，主要的原因是因为这款软件比较简单，没有必要，杀鸡何必用牛刀！呵呵~~
这款软件很简单，也没有加壳，所以直接OD载入分析就得了，前面的爆破和注册码的分析太简单了，我想在这里讲也不太合适，如果大家有什么不懂的，多去初学者版块去学习学习，自然就会了，我这里主要是想分析一下这款软件的使用的浮点算法部分，可以去浮点运算比较熟悉了，飘过~~好了，说了这么多进入正题吧！
我先科普一下，汇编中的浮点运算规则吧，以免在后面的分析中大家找不到东南西北！
网上也有很多讲解浮点运算的资料，我这里给大家收集整理对我们有帮助的一些，如果要学习详解的资料，请大家自己搜索学习，《Inter汇编语言程序设计》第五版也有讲的很详细！
浮点执行环境的寄存器主要是8个通用数据寄存器和几个专用寄存器，它们是状态寄存器、控制寄存器、标记寄存器等（这些大家可以在用OD调试的时候，看寄存器窗口就明白了！）
8个浮点数据寄存器(FPU Data Register)，编号FPR0~FPR7。每个浮点寄存器都是80位，以扩展精度格式存储数据，当其他类型数据压入数据寄存器时，FPU自动转换成扩展精度，相反，数据寄存器的数据取出时，系统也会自动转换成要求的数据类型。
8个浮点数据寄存器组成首尾相接的堆栈，当前栈顶ST0指向的FPUX由状态寄存器中TOP字段指明。数据寄存器不采用随机存取，而是按照“后进先出”的堆栈原则工作，并且首尾循环。向数据寄存器传送(Load)数据时是入栈，堆栈指针TOP先减1，再将数据压入栈顶寄存器；从数据寄存器取出数据时就是出栈，先将栈顶寄存器数据弹出，再修改堆栈指针使TOP加1。浮点寄存器还有首尾循环相连的特点。例如，若当前栈顶TOP = 0（即ST0 = FPR0),那么，入栈操作后就使TOP= 7（即使ST0=FPR7)，数据被压入FPR7。所以，浮点数据寄存据常常被称为浮点数据堆栈！
浮点运算指令有哪些？
浮点传送指令
浮点数据传送指令完成主存与堆栈顶ST0、数据寄存器STX与堆栈顶之间的浮点格式数据的传送。浮点数据寄存器是一个首尾相接的堆栈，所以它的数据传送实际上是对堆栈的操作，有些要改变堆栈指针TOP，即修改当前栈顶。
算术运算类指令
这类浮点指令实现浮点数、16/32位整数的加、减、乘、除运算，它们支持的寻址方式相同。这组指令还包括有关算术运算的指令，倒如求绝对值、取整等。
超越函数类指令
浮点指令集中包含有进行三角函数、指数和对数运算的指令。
浮点比较类指令
浮点比较指令比较栈顶数据与指定的源操作数，比较结果通过浮点状态寄存器反映。
FPU控制类指令
FPU控制类指令用于控制和检测浮点处理单元FPU的状态及操作方式。
定义浮点数据
数据定义指令DWORD,QWORD,TBYTE依次说明32/64/80位数据；它们可以用于定义单精度、双精度和扩展精度浮点数，但不能出现纯整数（其实，整数后面补个小数就可以了）。相应的数据属性依次是DWORD,QWORD,TBYTE。另外，实常数可以用E表示10的幂。
每当执行一个新的浮点程序时，第一条指令都应该是初始化FPU的指令finit。该指令清除浮点数据寄存器堆栈和异常，为程序提供一个“干净”的初始化状态。否则，遗留在浮点寄存器堆栈中的数据可能会产生堆栈溢出。另一方面，浮点指令程序段结束，也最好清空浮点数据寄存器。
汇编浮点运算指令集
对下面的指令先做一些说明：
ST(i)：代表浮点寄存器，所说的出栈，入栈操作都是对ST(i)的影响。
SRC,DST,DEST,OP等指令是指指令的操作数，SRC表示源操作数，DST/DEST表示目的操作数。
MEM8,MEM16,MEM64,MEM80等表示是内存操作数，后面的数值表示该操作数的内存位数（8位为一字节）。
X<----Y表示将Y的值放入X，例ST0<-----ST0－ST1，表示将ST0－ST1的值放入浮点寄存器ST0
一些常用的指令：
指令格式 指令含义 执行的操作
FLD src 装入实数到st(0) st(0) <- src (mem32/mem64/mem80)
FILD src 装入整数到st(0) st(0) <- src (mem16/mem32/mem64)
FBLD src 装入BCD数到st(0) st(0) <- src (mem80)
FLDZ 将0.0装入st(0) st(0) <- 0.0
FLD1 将1.0装入st(0) st(0) <- 1.0
FLDPI 将pi装入st(0) st(0) <- ?(ie, pi)
FLDL2T 将log2(10)装入st(0) st(0) <- log2(10)
FLDL2E 将log2(e)装入st(0) st(0) <- log2(e)
FLDLG2 将log10(2)装入st(0) st(0) <- log10(2)
FLDLN2 将loge(2)装入st(0) st(0) <- loge(2)
FST dest 保存实数st(0)到dest dest <- st(0) (mem32/mem64)
FSTP dest dest <- st(0) (mem32/mem64/mem80)；然后再执行一次出栈操作
FIST dest 将st(0)以整数保存到dest dest <- st(0) (mem32/mem64)
FISTP dest dest <- st(0) (mem16/mem32/mem64)；然后再执行一次出栈操作
FBST dest 将st(0)以BCD保存到dest dest <- st(0) (mem80)
FBSTP dest dest<- st(0) (mem80)；然后再执行一次出栈操作
2． 比较指令
指令格式 指令含义 执行的操作
FCOM 实数比较 将标志位设置为 st(0) - st(1) 的结果标志位
FCOM op 实数比较 将标志位设置为 st(0) - op (mem32/mem64)的结果标志位
FICOM op 和整数比较 将Flags值设置为st(0)-op 的结果op (mem16/mem32)
FICOMP op 和整数比较 将st(0)和op比较 op(mem16/mem32)后；再执行一次出栈操作
FTST 零检测 将st(0)和0.0比较
FUCOM st(i) 比较st(0) 和st(i)
FUCOMP st(i) 比较st(0) 和st(i)，并且执行一次出栈操作
FUCOMPP st(i) 比较st(0) 和st(i)，并且执行两次出栈操作
FXAM Examine: Eyeball st(0) (set condition codes)
3． 运算指令
指令格式 指令含义 执行的操作
加法
FADD 加实数 st(0) <-st(0) + st(1)
FADD src st(0) <-st(0) + src (mem32/mem64)
FADD st(i),st st(i) <- st(i) + st(0)
FADDP st(i),st st(i) <- st(i) + st(0)；然后执行一次出栈操作
FIADD src 加上一个整数 st(0) <-st(0) + src (mem16/mem32)
减法
FSUB 减去一个实数 st(0) <- st(0) - st(1)
FSUB src st(0) <-st(0) - src (reg/mem)
FSUB st(i),st st(i) <-st(i) - st(0)
FSUBP st(i),st st(i) <-st(i) - st(0)，然后执行一次出栈操作
FSUBR st(i),st 用一个实数来减 st(0) <- st(i) - st(0)
FSUBRP st(i),st st(0) <- st(i) - st(0)，然后执行一次出栈操作
FISUB src 减去一个整数 st(0) <- st(0) - src (mem16/mem32)
FISUBR src 用一个整数来减 st(0) <- src - st(0) (mem16/mem32)
乘法
FMUL 乘上一个实数 st(0) <- st(0) * st(1)
FMUL st(i) st(0) <- st(0) * st(i)
FMUL st(i),st st(i) <- st(0) * st(i)
FMULP st(i),st st(i) <- st(0) * st(i)，然后执行一次出栈操作
FIMUL src 乘上一个整数 st(0) <- st(0) * src (mem16/mem32)
除法
FDIV 除以一个实数 st(0) <-st(0) /st(1)
FDIV st(i) st(0) <- st(0) /t(i)
FDIV st(i),st st(i) <-st(0) /st(i)
FDIVP st(i),st st(i) <-st(0) /st(i)，然后执行一次出栈操作
FIDIV src 除以一个整数 st(0) <- st(0) /src (mem16/mem32)
FDIVR st(i),st 用实数除 st(0) <- st(i) /st(0)
FDIVRP st(i),st
FDIVRP st(i),st
FIDIVR src 用整数除 st(0) <- src /st(0) (mem16/mem32)
FSQRT 平方根 st(0) <- sqrt st(0)
FSCALE 2的st(0)次方 st(0) <- 2 ^ st(0)
FXTRACT Extract exponent: st(0) <-exponent of st(0); and gets pushed
st(0) <-significand of st(0)
FPREM 取余数 st(0) <-st(0) MOD st(1)
FPREM1 取余数（IEEE），同FPREM，但是使用IEEE标准[486]
FRNDINT 取整（四舍五入） st(0) <- INT( st(0) ); depends on RC flag
FABS 求绝对值 st(0) <- ABS( st(0) ); removes sign
FCHS 改变符号位(求负数） st(0) <-st(0)
F2XM1 计算(2 ^ x)-1 st(0) <- (2 ^ st(0)) - 1
FYL2X 计算Y * log2(X) st(0)为Y；st(1)为X；将st(0)和st(1)变为st(0) * log2( st(1) )的值
FCOS 余弦函数Cos st(0) <- COS( st(0) )
FPTAN 正切函数tan st(0) <- TAN( st(0) )
FPATAN 反正切函数arctan st(0) <- ATAN( st(0) )
FSIN 正弦函数sin st(0) <- SIN( st(0) )
FSINCOS sincos函数 st(0) <-SIN( st(0) )，并且压入st(1)
st(0) <- COS( st(0) )
FYL2XP1 计算Y * log2(X+1) st(0)为Y； st(1)为X；将st(0)和st(1)变为st(0) * log2( st(1)+1 )的值
处理器控制指令
FINIT 初始化FPU
FSTSW AX 保存状态字的值到AX AX<- MSW
FSTSW dest 保存状态字的值到dest dest<-MSW (mem16)
FLDCW src 从src装入FPU的控制字 FPU CW <-src (mem16)
FSTCW dest 将FPU的控制字保存到dest dest<- FPU CW
FCLEX 清除异常
FSTENV dest 保存环境到内存地址dest处保存状态字、控制字、标志字和异常指针的值
FLDENV src 从内存地址src处装入保存的环境
FSAVE dest 保存FPU的状态到dest处 94字节
FRSTOR src 从src处装入由FSAVE保存的FPU状态
FINCSTP 增加FPU的栈指针值 st(6) <-st(5); st(5) <-st(4),...,st(0) <-?
FDECSTP 减少FPU的栈指针值 st(0) <-st(1); st(1) <-st(2),...,st(7) <-?
FFREE st(i) 标志寄存器st(i)未被使用
FNOP 空操作，等同CPU的nop st(0) <-st(0)
WAIT/FWAIT 同步FPU与CPU：停止CPU的运行，直到FPU完成当前操作码
FXCH 交换指令，交换st(0)和st(1)的值 st(0) <-st(1) st(1) <- st(0)
一些常用的指令也就这些，大家如果记忆不好，也不要紧，用的时候去查就行了，其实也很好记的，无非一些英文单词的缩写吧了~~
前面的找注册码为600341115我就不多讲了，很容易找到的，如果有不懂就请先去初学者版块学习学习~~~
我们找到注册码计算比较那段的段首地址为004141EC，我们在那里下断点，单步跟踪就可以找到注册码算法了！
004141EC处的代码如下：
004141EC 55 push ebp
004141ED 8BEC mov ebp,esp
004141EF 81C4 70FFFFFF add esp,-90
004141F5 8955 C0 mov dword ptr ss:[ebp-40],edx
004141F8 8945 C4 mov dword ptr ss:[ebp-3C],eax
.............................................
前面一堆代码基本也没用，只用于将注册对话框中输入的注册码，取出然后转化为字符串，很简单就不讲了！然后我们向下看一直到00414234这里，代码如下：
00414234 8945 BC mov dword ptr ss:[ebp-44],eax
00414237 33D2 xor edx,edx
00414239 8955 B8 mov dword ptr ss:[ebp-48],edx
0041423C 33C9 xor ecx,ecx
0041423E 894D B4 mov dword ptr ss:[ebp-4C],ecx
00414241 EB 10 jmp short Recite.00414253
00414243 8B45 BC mov eax,dword ptr ss:[ebp-44]
00414246 8B55 B4 mov edx,dword ptr ss:[ebp-4C]
00414249 0FBE0C10 movsx ecx,byte ptr ds:[eax+edx]
0041424D 014D B8 add dword ptr ss:[ebp-48],ecx
00414250 FF45 B4 inc dword ptr ss:[ebp-4C]
00414253 8D45 FC lea eax,dword ptr ss:[ebp-4]
00414256 E8 69990800 call Recite.0049DBC4
0041425B 48 dec eax
0041425C 3B45 B4 cmp eax,dword ptr ss:[ebp-4C]
0041425F ^ 7F E2 jg short Recite.00414243
经常跟踪软件人，一看会知道这段代码的功能了,其实就是将字符中的字符的各个ASCII码进行累加，累加和存入一个局部变量中。
申请三个局部变量：
[ebp-44]用来存放机器码:2141215019417
[ebp-48]用来存放ASCII码之和
[ebp-4c]用来存放取的是上这面这个字符串的第几个字符
注册码为600341115
代码很简单，就是一利用一个循环，然后将机器码的各位的ASCII码进行累加！然后将结果存到ss:[ebp-48]中
也就是32+31+34+31+32+31+35+30+31+39+34+31+37=25F(十六进制)=607(十进制)
得到了这个值，下面就要开始计算注册码了，OD有一个很好的功能就是注解功能，我经常用这个功能，因为有时软件比较长，也不是一次就可以分析的出来的，要反反复复不停的跟踪，所以做注释是一个很好的习惯，我想学逆向的朋友们都会有这个好习惯的！
下面我就不多说了，大家看我在OD中的注释就会很清楚了！
下面就一堆浮点计算指令，与很多CALL，究竟那个CALL对自己有用呢？这就要靠经验了，我也说不清楚！
其实我用IDA分析过一段代码，很简单，因为IDA有一个很强大的功能就是代码的自动识别功能，这里我不能不配服IDA的作者！
我用IDA分析了下面的一小段代码，得到如下结果：
.text:00414261 fild [ebp+var_48]
.text:00414264 add esp, 0FFFFFFF8h ; x
.text:00414267 fstp [esp+98h+var_98]
.text:0041426A call _cos
其实0041426A处就是计算浮点的_COS的值
下面我完全用OD去分析注册码的算法，不借助IDA！分析如下：
上面的IDA 对应的OD代码为
00414261 DB45 B8 fild dword ptr ss:[ebp-48] ; 将EBP-48中的实整数607装入到ST(0)
00414264 83C4 F8 add esp,-8
00414267 DD1C24 fstp qword ptr ss:[esp] ; 将ST(0)的数值装入到ESP中
0041426A E8 1D2B0800 call Recite.00496D8C
00496D8C处的代码如下：
00496D8C 55 push ebp
00496D8D 8BEC mov ebp,esp
00496D8F 53 push ebx
00496D90 DD45 08 fld qword ptr ss:[ebp+8] ; 加载实数到ST(0)
00496D93 66:B8 F07F mov ax,7FF0 ; 将7FF0值传给AX
00496D97 66:2345 0E and ax,word ptr ss:[ebp+E] ; 将EBP+E中的4082与AX的7FF0进行与操作
00496D9B 66:3D 4043 cmp ax,4340 ; 将与的结果与4340进行比较
00496D9F 73 08 jnb short Recite.00496DA9 ; 跳转没有实现
00496DA1 E8 E6000000 call Recite.00496E8C
我们在来看看00496E8C处的代码如下：
00496E8C B1 02 mov cl,2 ; 将2传给Cl
00496E8E EB 02 jmp short Recite.00496E92 ; 短跳转
00496E90 B1 04 mov cl,4
00496E92 D9E5 fxam ; 进行浮点检查
00496E94 83EC 04 sub esp,4
00496E97 9B wait
00496E98 DD3C24 fstsw word ptr ss:[esp] ; 浮点检查保存状态器ESP值为43C8
00496E9B 9B wait
00496E9C 8A6424 01 mov ah,byte ptr ss:[esp+1] ; 将ESP+1中保存的'<'传给ah
00496EA0 9E sahf ; 恢复标志低八,AH=3C,S0,Z0,A1,P1,C0,FL=06
00496EA1 72 0D jb short Recite.00496EB0 ; CF=1跳转，所以没跳
00496EA3 75 2A jnz short Recite.00496ECF ; ZF=0跳转，所以跳转了
00496EA5 80F9 02 cmp cl,2
00496EA8 75 04 jnz short Recite.00496EAE
00496EAA DDD8 fstp st
00496EAC D9E8 fld1
00496EAE EB 1A jmp short Recite.00496ECA
00496EB0 74 0C je short Recite.00496EBE
00496EB2 7B 0A jpo short Recite.00496EBE
00496EB4 DDD8 fstp st
00496EB6 D905 98BF4A00 fld dword ptr ds:[4ABF98]
00496EBC D9E4 ftst
00496EBE EB 0A jmp short Recite.00496ECA
00496EC0 DED9 fcompp
00496EC2 D905 98BF4A00 fld dword ptr ds:[4ABF98]
00496EC8 D9E4 ftst
00496ECA E9 97000000 jmp Recite.00496F66
00496ECF D9E1 fabs ; 求ST(0)绝对值
00496ED1 DB2D 84BF4A00 fld tbyte ptr ds:[4ABF84] ; 装载实数到ST(0)值为0.7853981633974482944
00496ED7 D9E5 fxam ; 浮点检查
00496ED9 D9C9 fxch st(1) ; 交换ST(0)与ST(1)的值ST(1)为607.00000000000000000
00496EDB D9F8 fprem ; ST(0)MODST(1)取余数0.6726178571699049472
00496EDD B5 02 mov ch,2 ; CH赋值为2
00496EDF 22EC and ch,ah ; 用2与上面AH的值（'<'）进行与操作，3CAND2
00496EE1 D0ED shr ch,1 ; 与的结果为0，然后右移一位
00496EE3 9B wait
00496EE4 DD3C24 fstsw word ptr ss:[esp] ; 保存状态字到ESP
00496EE7 9B wait
00496EE8 8A6424 01 mov ah,byte ptr ss:[esp+1] ; 取ESP中的第二位数1
00496EEC 9E sahf ; 恢复标志低八位AH=31(S0,Z0,A1,P0,C1),FL=46
00496EED 7A D1 jpe short Recite.00496EC0 ; PF=1时跳转，显然这里不跳
00496EEF B0 03 mov al,3 ; AL赋值3
00496EF1 22C4 and al,ah ; AH('1') AND AL=03，结果为1
00496EF3 D0E4 shl ah,1 ; AH左移一位，31*2=62('b')
00496EF5 D0E4 shl ah,1 ; AH再左移一位
00496EF7 D0D0 rcl al,1 ; AL循环进位左移，01*2=02
00496EF9 04 FC add al,0FC ; AL与0FC与操作
00496EFB D0D0 rcl al,1 ; 将上面得到的结果AL=FE，循环进位左移
00496EFD 80F9 02 cmp cl,2 ; CL与2进行比较
00496F00 75 04 jnz short Recite.00496F06 ; 不跳
00496F02 02C1 add al,cl ; CL=02 AND AL=FE
00496F04 B5 00 mov ch,0 ; CH=0
00496F06 24 07 and al,7 ; AL=FE AND 7
00496F08 A8 01 test al,1 ; AL=06检查是否为1
00496F0A 74 04 je short Recite.00496F10 ; 跳转
00496F0C DEE9 fsubp st(1),st
00496F0E EB 02 jmp short Recite.00496F12
00496F10 DDD9 fstp st(1) ; 将ST(0)--->ST(1)
00496F12 D9F2 fptan ; 正切函数0.6726178571699049472
00496F14 80F9 04 cmp cl,4 ; CL=02与4进行比较
00496F17 74 20 je short Recite.00496F39 ; 不跳
00496F19 A8 03 test al,3 ; AL=06检查是为3
00496F1B 7A 02 jpe short Recite.00496F1F ; 不跳P位为0
00496F1D D9C9 fxch st(1) ; 将ST(0)值1.0000000000000000000与ST(1)值0.7965240390979069952进行交换
00496F1F D9C1 fld st(1) ; 将ST(1)-->ST(0)
00496F21 D8C8 fmul st,st ; ST(0)*ST(0)
00496F23 D9C9 fxch st(1) ; 交换ST(0)值1与ST(1)的值0.7965240390979069952
00496F25 D8C8 fmul st,st ; ST(0)值0.7965240390979069952乘以ST(0)
00496F27 DEC1 faddp st(1),st ; 得到ST(0)值0.6344505448608441344加上ST(1)的值1
00496F29 D9FA fsqrt ; 求ST(0)的值1.6344505448608441344的平方根得到1.2784563132390735360
00496F2B D0E8 shr al,1 ; AL的值右移1
00496F2D D0E8 shr al,1 ; AL的值右移1
00496F2F 32C5 xor al,ch ; 得到AL=01与CH=00进行异或
00496F31 74 02 je short Recite.00496F35 ; 不跳
00496F33 D9E0 fchs ; 改变ST(0)的符号位求负数得到-1.2784563132390735360
00496F35 DEF9 fdivp st(1),st ; ST(1)除以ST(0)得到-0.7821933292866443264
00496F37 EB 2D jmp short Recite.00496F66 ; 跳出这个CALL
最后得到ST(0)的值为-0.7821933292866443264
我后返回到00496DA6处，接下来往下看
00496DA6 5B pop ebx
00496DA7 5D pop ebp
00496DA8 C3 retn
又一次返回，到0041426F处，代码如下所示：
0041426F 83C4 08 add esp,8
00414272 D805 34444100 fadd dword ptr ds:[414434] ; 将得到的ST(0)的值-0.7821933292866443264加上1得到0.2178066707133556224
00414278 D83D 34444100 fdivr dword ptr ds:[414434] ; 用DS:[00414434]的值1去除ST(0)得到4.5912276089837926400
0041427E DD9D 70FFFFFF fstp qword ptr ss:[ebp-90] ; 将ST(0)的值4.5912276089837926400传给SS:[EBP-90]
00414284 68 00804C40 push 404C8000
00414289 6A 00 push 0
0041428B E8 7C2F0800 call Recite.0049720C
然后我们再进入0049720C处看看此处的代码，如下所示：
0049720C 55 push ebp
0049720D 8BEC mov ebp,esp
0049720F 8D65 F8 lea esp,dword ptr ss:[ebp-8]
00497212 53 push ebx
00497213 DD45 08 fld qword ptr ss:[ebp+8] ; 将EBP+8值57.0000000000000传给ST(0)
00497216 66:8B45 0E mov ax,word ptr ss:[ebp+E] ; 将EBP+E值404C传给AL
0049721A 66:D1E0 shl ax,1 ; AX左移一位
0049721D 74 12 je short Recite.00497231 ; 没跳
0049721F 72 31 jb short Recite.00497252 ; 没跳
00497221 66:3D E0FF cmp ax,0FFE0 ; 将上面左移的AX的值勤8098与0FFE0进行比较
00497225 74 1F je short Recite.00497246 ; 没跳
00497227 E8 18FCFFFF call Recite.00496E44
再进入00496E44处，如下所示：
00496E4A D9C9 fxch st(1) ; 将ST(0)与ST(1)的值57进行交换
00496E4C 83EC 0C sub esp,0C
00496E4F D9E5 fxam ; 浮点检查
00496E51 9B wait
00496E52 DD7C24 0A fstsw word ptr ss:[esp+A] ; 保存状态字
00496E56 9B wait
00496E57 8A6424 0B mov ah,byte ptr ss:[esp+B] ; 将ESP+B中的4传入到AH
00496E5B 9E sahf ; 恢复标志低八位AH=34(S0,Z0,A1,P1,C0),FL=16
00496E5C 72 0B jb short Recite.00496E69 ; 没跳
00496E5E 74 05 je short Recite.00496E65 ; 没跳
00496E60 F6C4 02 test ah,2 ; 检查AH是否为2
00496E63 74 1D je short Recite.00496E82 ; 跳转实现
...................................................
00496E82 D9F1 fyl2x ; 求st(0) * log2( st(1) )的值,ST(0)值57.000000000000000000与ST(1)0.3010299956639812096
00496E84 83C4 0C add esp,0C
00496E87 C3 retn ; 得到ST(0)的值为1.7558748556724915200
返回到00497227C处
0049722C 5B pop ebx ; 恢复堆栈，返回
0049722D 8BE5 mov esp,ebp
0049722F 5D pop ebp
00497230 C3 retn
又一次返回到00414290处，代码如下：
00414293 DCBD 70FFFFFF fdivr qword ptr ss:[ebp-90] ; 前面得到的[EBP-90]的值4.5912276089837926400除以ST(0)的值得到ST(0)的值为
1.7558748556724915200
00414299 D95D B0 fstp dword ptr ss:[ebp-50] ; 将上面得到的ST(0)的值2.6147806571473310720传给[EBP-50]
0041429C 66:C745 D8 080>mov word ptr ss:[ebp-28],8 ; 赋[EBP-28]的值为8
004142A2 D945 B0 fld dword ptr ss:[ebp-50] ; 将[EBP-50]的值--->ST(0)
004142A5 E8 062D0800 call Recite.00496FB0
这里又有一个CALL，再次进入00496FB0，代码所下：
00496FB0 55 push ebp
00496FB1 8BEC mov ebp,esp
00496FB3 8D65 F4 lea esp,dword ptr ss:[ebp-C]
00496FB6 9B wait
00496FB7 D97D FC fstcw word ptr ss:[ebp-4] ; 浮点检查保存控制器
00496FBA 9B wait
00496FBB 8A45 FD mov al,byte ptr ss:[ebp-3] ; 将EBP-3的值13传给AL
00496FBE 804D FD 0C or byte ptr ss:[ebp-3],0C ; [EBP-3]的值13与0C或操作
00496FC2 D96D FC fldcw word ptr ss:[ebp-4] ; 浮点加载控制器
00496FC5 DF7D F4 fistp qword ptr ss:[ebp-C] ; ST(0)的值2.6147806571473310720传给[EBP-C]
00496FC8 8845 FD mov byte ptr ss:[ebp-3],al ; 将AL=13传给[EBP-3]
00496FCB D96D FC fldcw word ptr ss:[ebp-4] ; 从[EBP-4]值装入FCW
00496FCE 8B45 F4 mov eax,dword ptr ss:[ebp-C] ; 将[EBP-C]的值赋值给EAX
00496FD1 8B55 F8 mov edx,dword ptr ss:[ebp-8] ; 将[EBP-8]的值零赋值给EDX
00496FD4 8BE5 mov esp,ebp
00496FD6 5D pop ebp
00496FD7 C3 retn ; 返回
返回到004142AA处,代码如下：
004142AA 8985 74FFFFFF mov dword ptr ss:[ebp-8C],eax
004142B0 DB85 74FFFFFF fild dword ptr ss:[ebp-8C] ; 将[EBP-8C]的值2传给ST(0)
004142B6 D86D B0 fsubr dword ptr ss:[ebp-50] ; 用前面得到的[EBP-50]的值2.6147806571473310720减去ST(0)的值2
004142B9 DC0D 38444100 fmul qword ptr ds:[414438] ; 将得到的ST(0)的值0.6147806644439697408乘以[414438]处的值1000000000000.000
004142BF E8 EC2C0800 call Recite.00496FB0 ;利用这个CALL将6.1478066444396974080e+11转化为注册码，中间会有误差，但返回值是我们所关心的
我们在进入00496FB0处，代码如下：
其实这段代码我们以前跟踪过只是数值有上些改变吧了！
00496FB0 55 push ebp
00496FB1 8BEC mov ebp,esp
00496FB3 8D65 F4 lea esp,dword ptr ss:[ebp-C]
00496FB6 9B wait
00496FB7 D97D FC fstcw word ptr ss:[ebp-4] ; 浮点检查保存控制器
00496FBA 9B wait
00496FBB 8A45 FD mov al,byte ptr ss:[ebp-3] ; 将EBP-3的值13传给AL
00496FBE 804D FD 0C or byte ptr ss:[ebp-3],0C ; [EBP-3]的值13与0C或操作
00496FC2 D96D FC fldcw word ptr ss:[ebp-4] ; 浮点加载控制器
00496FC5 DF7D F4 fistp qword ptr ss:[ebp-C] ; ST(0)的值6.1478066444396974080e+11传给[EBP-C]
00496FC8 8845 FD mov byte ptr ss:[ebp-3],al ; 将AL=13传给[EBP-3]
00496FCB D96D FC fldcw word ptr ss:[ebp-4] ; 从[EBP-4]值装入FCW
00496FCE 8B45 F4 mov eax,dword ptr ss:[ebp-C] ; 将[EBP-C]的值eax=23C87A7B赋值给EAX
00496FD1 8B55 F8 mov edx,dword ptr ss:[ebp-8] ; 将[EBP-8]的值零赋值给EDX
00496FD4 8BE5 mov esp,ebp
00496FD6 5D pop ebp
00496FD7 C3 retn ; 返回
返回到004142C4处，代码如下：
004142C4 8985 70FFFFFF mov dword ptr ss:[ebp-90],eax ; 将eax=23C87A7B传给ebp-90
004142CA DB85 70FFFFFF fild dword ptr ss:[ebp-90] ; 将十六进制23C87A7B传给ST(0)
004142D0 83C4 F8 add esp,-8 ; 堆栈平衡
004142D3 DD1C24 fstp qword ptr ss:[esp] ; ST0的值（即为注册码）传给ESP中
004142D6 E8 912C0800 call Recite.00496F6C
后面还有一些CALL，没有作实际的处理，基本上就是浮点数转换为整数的操作，这时太不分析了，这样我们的注册码就得到了600341115
算法总结如下：这个算法其实很简单，中间只有两个很简单的函数，我这里就不用这两个函数，而是去慢慢分析这两个函数是如何来计算的，主要是为了加强分析能力！
607.00000000000000000与0.7853981633974482944取余数得到
0.6726178571699049472
然后对上面得到的值求正切函数
得到ST0的值为1.0000000000000000000
ST1的值为0.7965240390979069952
交换上面的两个值
ST0值变为0.7965240390979069952
ST1值变为1.0000000000000000000
又将ST1--->ST0，然后ST0*ST0得到ST0值还是1
然后再交换ST0与ST1的值
ST0值还是0.7965240390979069952
ST1值还是1.0000000000000000000
然后ST0*ST0得到0.6344505448608441344，再将ST0的值与ST1的值相加，得到
1.6344505448608440320，在求平方根，得到ST0的值为1.2784563132390735360
将ST0的值求负得-1.2784563132390735360
用ST1的值1.0000000000000000000除以ST0的值-1.2784563132390735360得到-0.7821933292866443264
将ST0的值-0.7821933292866443264加上1得到0.2178066707133556224
再用存储在数据段中常数1去除ST0的值0.2178066707133556224得到4.5912276089837926400
再将浮点数57.00000000000000传给ST0，然后计算log10(2)的值0.3010299956639812096，并将值也压入ST0中，此时
ST0的值为0.3010299956639812096,ST1的值57.00000000000000，交换得
ST0的值为57.00000000000000,ST1的值为0.3010299956639812096
然后再求ST0*Log2(ST1)的值得到1.7558748556724915200--->ST0
然后在将前面得到的ST0的值4.5912276089837926400除以1.7558748556724915200得到2.6147806571473310720
然后用2.6147806571473310720-2得到0.6147806571473310720的值然后乘以1000000000000.000得到
6.147806571473310720e+11
到这里我们的注册码就出来了！
总体来说软件逆向=精力+经验+热爱，逆向一个软件是很累的活，但我相对于写软件的人来说还是比较年轻的，呵呵，希望大家想学逆向工程式的朋友们都有能有这三种东西，我想你将来会在这个领域小有成就，一切只是时间的问题！
这最后说明一点，浮点数到最后转换成注册码的时候，会有一点误差，这是不可避免的，大家只要单步跟踪到注册码就行了，至于中间的结果，在浮点运算转换成其它数值的时候会有误差，也不用去管，这是不可避免的！
好了，文章就写到这了，说点题外话，最近比较忙
，QQ基本不上线了，看雪上可能有时会看到我写的一些文章，最近在潜心去修练逆向工程与反汇编知识，争取能更上一层楼，我相信这一切只是时间的问题，只要自己肯努力去做!因为不想被太多人打扰QQ就不上了，请各位看雪上的朋友们原谅，不过只要熊猫正正有时间，一定会尽量能大家带来一些好文章！（只能尽力啦，因为毕竟熊猫正正现在还只是菜鸟一只，呵呵，还需要努力才行），我一直很崇拜几位科学家，钱学森，陈景润，王选等（其实还有好多无私奉献的科学家，我就不一一列举了），他们的技术那不用说了，中国没人能比啦，但我想说主要是他们的精神，真的值得我们去好好学习一下！只为自己喜欢的事业而努力奋斗，不在乎得到了多少荣誉，在他们喜欢的领域，他们总是默默无闻，不为名利，只为自己所热爱的事业！！（注：五笔打的比较快，难免会有一些笔误！请原谅！）
- 标 题：软件的注册码浮点算法的分析！
- 作 者：熊猫正正
- 时 间：2010-10-16 23:34:22
- 链 接：http://bbs.pediy.com/showthread.php?t=122413