steps to make a patch
1. open a debugger, ex: ollydbg, load mindmanager.
2. break at GdipSetTextRenderingHint (gdiplus.dll!_GdipSetTextRenderingHint@8)
3. when it break down, track the call to it. It’s something like:
[code lang=”outline”]00688A2D call 00CC8792 [/code]
goto 00CC8792 , it is something like:
[code lang=”outline”]00CC8792 jmp dword ptr ds:[0E5A758h] [/code]
change it to :
retn 8
code bytes: c2 08 00 90 90 90
4. save the modification to mindmanager.exe
5. done, enjoy clear text.

不过，也有一点很让人生气，就算源文件是utf-8编码的，编译时，他也会把utf-8转成主机的编码。所以，对于中文编码而言，如果源文件是

utf-8的并且有这样的内容，编译还是一样出问题：

const char * test = "®";
tt.cpp(10) : warning C4566: character represented by universal-character-name '\u00AE' cannot be represented in the current code page (936)

c++0x草案中有 u8″string literal” 形式的字符串，如果可以用这个，则问题解决，可惜的是，vs2010并不支持 u8-prefix string literal。当然，u和U也不支持。不过由于windows本身所说的unicode是utf-16 le，所以vc里L”string”就是u”string”。

如果才能让vc以持u8呢？写一个宏和字符串转化的类，在运行期转化是一个可行但比较折中的办法，这个办法最大的问题是依然不能在代码里写”®”这样的字串，因为编译期转成中文编码失败成?号，运行期转成utf-8还是问号。

当然，可以写 L”®”，这样这个u8类可以这样写：

string to_utf8(const wchar_t*);
#define U8(string)  to_utf8(string).c_str()

然后在用的地方写：

U8(L”®”);

这样基本能用，但带来了一些运行期消耗。并且L的字符串也比较大。当然宏本身还可以改改，使得不需要写L，而是在预处理后加入L，但会带来额外的限制（想想U8(“hello” “world”)）。

能不能hack编译器加入u8的支持呢？经过一番研究，发现了点眉目。

首先，vc编译器编译的主要功能代码在c1xx.dll中。这个dll的x86版本位于 C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\c1xx.dll。惊喜的是微软提供了它的pdb，这样分析它的行为就大大简化了。

经过研究发现，vc基本上函展开，获取token生成语法树是一次过的。

在关键函数

4F4C9430 GetTokenFromCurrentChar

处，会有一个循环，从一个全局变量中读取解析到的内容，然后构造出一个token。我们要做的就是hack这个过程，如果当前token符合 u8″string”的形式，则处理一遍字符串，转成8进制的串表示方法。

经过一番苦战成功后，结果如下：

[code lang=”outline”]

tt.cpp:

#define U8(str) u8##str
#define U16(str) L##str

int main()
{

U8(“哈”);
u8″哈”;
return 0;
}

D:\temp>cl /E tt.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80×86
Copyright (C) Microsoft Corporation.  All rights reserved.

tt.cpp
#line 1 “tt.cpp”
int main()
{

“\345\223\210”;
“\345\223\210″;
return 0;
}

[/code]

使用的办法是：

把原始的c1xx.dll重命名为c1xx_.dll，写了一个假的c1xx.dll，把导出函数的调用都重定位到c1xx_.dll。然后在GetTokenFromCurrentChar的循环开始处：

4F4C943E                                             8B3D 046C644F    MOV EDI,DWORD PTR DS:[Current_char]

写入一个跳转，跳转到自己的函数中检查是否需要替换字串。写完后变成：

4F4C943E                                             E8 4D7EB60E      CALL c1xx.asmReplCurCode
4F4C9443                                             90               NOP

这个被调用的函数是这样的：
__declspec(naked) void asmReplCurCode()
{
__asm
{
pushad;
call ReplCurCode;
popad;
mov edi, [ptrCurChar];
mov edi, [edi];
ret;
}
}
即用汇编做一个简单的包装，调用C++函数，然后完成被覆盖的代码要完成的事，然后ret回去。

ReplCurCode是这样的：

[code lang=”cpp” ]
void ReplCurCode()
{
if (g_pred == 0)
{
g_pred = 1;
char ch = ** ptrCurChar;
//note: in creating/using precompiled header mode, don’t insert this code since it had done before.
if (ch == ‘\r’ || ch == ‘\n’)
{
replace = *ptrCurChar;
const char * scode = “\r\n#define __bultin_u8 1\r\n1\r\n”;
match = scode + strlen(scode)-3;
*ptrCurChar = scode;
return ;
}
}

if (*ptrCurChar == match)
{
*ptrCurChar = replace;
match = 0;
replace = 0;
}

const char * src = *ptrCurChar;
if (src[0] == ‘#’ && src[1] == ‘d’)
{
int ff = 0;
}

string prefix;
while (isspace((unsigned char)(src[0])))
{
prefix += src[0];
++ src;
}

if (src[0] == ‘u’ &&  src[1] == ‘8’ && src[2] == ‘”‘)
{
//so this is a U8 str.
string sb;
size_t sz = TextProcess::unescape(src+3, MAXLONG, sb);
if (src[sz+3] == ‘”‘)
{
string st = TextProcess::escape(sb.c_str(), sb.length());
string & codestr = getPool(prefix + st, src);
match   = codestr.c_str() + codestr.length();
replace = src+sz+4;
*ptrCurChar = codestr.c_str();
}
}
}

[/code]

在首次处理的时候插入一个宏定义，这样代码中就可以知道编译器是不是修改支持了u8的功能。ptrCurChar是微软的c1xx.dll中的全局变量的地址，通过它知道当前要解析什么样的代码，解析完之后替换掉它，使得

u8″哈”

交给微软cl.exe解释的时候变成  “\345\223\210” 当然下一次再跑到这里的时候，比较是不是解释完我设置的替换串了，是的话换回原始要解释的内容，当然是跳过了u8″哈”这个串的。

即： if(*ptrCurChar == match) *ptrCurChar = replace;

这样处理完了之后，vs2010就完美的支持u8″string”了。不过只能小范围内使用或写一些自己用的工具，对于大的团队而言，还是等微软下一个vs吧，也许那时就真正支持u8″literal string”了。

其实不只是 u8 literal string，这样改编译器，还能实现一些更有意思的东西。

dowload:  hack_c1xx.dll

仅适用于原始md5为D05630986B03CBB28CD4D8E1BDD65831的c1xx.dll。

把原始c1xx.dll改名为c1xx_.dll，把hack_c1xx.dll改名为c1xx.dll

[code lang=”outline”]
004089F5                            . 57                      PUSH EDI                                 ; /lParam
004089F6 <blockpos>                 . 8B7C24 1C               MOV EDI,DWORD PTR SS:[ESP+1C]            ; |
004089FA                            . 8946 1A                 MOV DWORD PTR DS:[ESI+1A],EAX            ; |
004089FD                            . 57                      PUSH EDI                                 ; |wParam
004089FE                            . 68 0E040000             PUSH 40E                                 ; |Message = WM_USER+14.
00408A03                            . 51                      PUSH ECX                                 ; |hWnd
00408A04                            . FF15 FC964700           CALL DWORD PTR DS:[4796FC]               ; \SendMessageA
[/code]

 在 blockpos处，修改esp+1c里的值，就可以了。

总的来说，hdtune把硬盘分为很多个格子，每行５０个，总共有很多行。每一个小格扫完后，就发送这个自定义的消息 WM_USER+14来通知主线程画一个色块。绿色表示无问题，红色表示有问题。运行到blockpos这一行时，把这个值改掉，即可定义到第n个格子。第０个为左上，第４９个为第一行最后一个，依此类推。

一个flash小游戏里的TEA算法，hack一把，结果发现，decompile出来的as，改成js运行后，得到的结果跟原游戏运算出的结果是不一样的。

心想难道js跟as有些差别？不得已，去下了一个adobe flash cs3。

发现自己快不会用flash了，还是flash5时学了几天，做了点皮毛，主要也是那时为了应付交了一下某堂课的作业。想起来当时那老师也很好心，这个flash作业给了我满分。

不过今天对flash cs3感觉 很不顺手了。一开始就遇到个问题 ，在cs3中如何使用外部类？直接写一个，报错误“类不能嵌套”，搜了一把是写在一个.as文件里，就写在一个TEA.as里。

加入代码 import TEA; 结果又报错，说TEA没有实现，查文档，原来说是要放到一个包(package)里。那就放吧，放完发现还是不对，最后看了一下flash自己的实现，终于整明白了。先建一个crypto的文件夹，在里面建个TEA.as，代码这样：

package crypto{ //crypto要跟文件夹名一致。

public class TEA{ //TEA跟文件名即TEA.as一致。public好像不能少。

…//省略

}

}

OK，可以运行了，然后发现，其实另存为flash 8的文档，就可以直接用不放在包里的TEA.as!晕倒。

运行发现，这个flash得到的结果跟html里的js算出来是一样的。敢情从下载flash起，事情就白做了。

最后没办法，回到sothink swf decompiler中，仔细看，看到一个疑点：

var _loc11 = 2.671213E+009;

为什么是这样呢？算法中不应有这样的代码。打开raw code，找到这一行：

 //96 09 00 06 ef e6 e3 41 00 00 20 37
 _push 2.67121e+009

对比一下其它的_push语句，发现ef e6 e3 41 00 00 20 37 是一个double值。

写个小程序：

[code lang=”outline”]

debian:~# cat t2.c
#include <stdio.h>

int main()
{
        double d = 2.67121e+009;
        unsigned char * p = (unsigned char*)&d;

        int i;
        for ( i=0; i<8; ++i)
        {
                printf(“%02x “, p[i]);
        }
        printf(“\n”);
        return 0;
}
debian:~# gcc t2.c 
debian:~# ./a.out
00 00 00 c2 ed e6 e3 41

[/code]

对比00 00 00 c2 ed e6 e3 41 与ef e6 e3 41 00 00 20 37

只有一点儿不同，原double值应该是00 00 20 37 ef e6 e3 41

好，这样： printf(“%.14g\n”, *(double*)”\x00\x00\x20\x37\xef\xe6\xe3\x41″);

得到： 2671212985

这就是正确的原flash的设定值。

修改一下TEA.as:

var _loc11 = 2.671213E+009;改为：

var _loc11 = 2671212985；

再运行一把，成功！算出来的值跟原flash是一样的，可以互相加/解密。

总结一下：sothink swf decompiler太土，居然不会用最恰当的方法格式化double值。bs之。

另外把TEA.as贴出来，版权不归我所有，是RE出来的，原作者如果有意见，请聊系本人删除。

hilight不支持actionscript，当就是javascript好了，反正差不多。

贴的这个是flash8格式，在CS3中使 用要放入一个 package里，前面说过了。

[code lang=”javascript”]

class TEA
{
    function TEA()
    {
    } // End of the function
    static function encrypt(src, key)
    {
        if (!key || key.length == 0)
        {
            key = “9F3779B99F3779B9”;
        } // end if
        var _loc4 = TEA.charsToLongs(TEA.strToChars(src));
        var _loc9 = TEA.charsToLongs(TEA.strToChars(key));
        var _loc8 = _loc4.length;
        if (_loc8 == 0)
        {
            return (“”);
        } // end if
        if (_loc8 == 1)
        {
            _loc4[_loc8++] = 0;
        } // end if
        var _loc2 = _loc4[_loc8 – 1];
        var _loc3 = _loc4[0];
        var _loc11 = 2671212985;
        var _loc5;
        var _loc7;
        var _loc10 = Math.floor(6 + 52 / _loc8);
        var _loc6 = 0;
        while (_loc10– > 0)
        {
            _loc6 = _loc6 + _loc11;
            _loc7 = _loc6 >>> 2 & 3;
            for (var _loc1 = 0; _loc1 < _loc8 – 1; ++_loc1)
            {
                _loc3 = _loc4[_loc1 + 1];
                _loc5 = (_loc2 >>> 5 ^ _loc3 << 2) + (_loc3 >>> 3 ^ _loc2 << 4) ^ (_loc6 ^ _loc3) + (_loc9[_loc1 & 3 ^ _loc7] ^ _loc2);
                _loc2 = _loc4[_loc1] = _loc4[_loc1] + _loc5;
            } // end of for
            _loc3 = _loc4[0];
            _loc5 = (_loc2 >>> 5 ^ _loc3 << 2) + (_loc3 >>> 3 ^ _loc2 << 4) ^ (_loc6 ^ _loc3) + (_loc9[_loc1 & 3 ^ _loc7] ^ _loc2);
            _loc2 = _loc4[_loc8 – 1] = _loc4[_loc8 – 1] + _loc5;
        } // end while
        return (TEA.charsToHex(TEA.longsToChars(_loc4)));
    } // End of the function
    static function decrypt(src, key)
    {
        if (!key || key.length == 0)
        {
            key = “9F3779B99F3779B9”;
        } // end if
        var _loc4 = TEA.charsToLongs(TEA.hexToChars(src));
        var _loc9 = TEA.charsToLongs(TEA.strToChars(key));
        var _loc8 = _loc4.length;
        if (_loc8 == 0)
        {
            return (“”);
        } // end if
        var _loc2 = _loc4[_loc8 – 1];
        var _loc3 = _loc4[0];
        var _loc10 = 2671212985;
        var _loc6;
        var _loc7;
        var _loc12 = Math.floor(6 + 52 / _loc8);
        for (var _loc5 = _loc12 * _loc10; _loc5 != 0; _loc5 = _loc5 – _loc10)
        {
            _loc7 = _loc5 >>> 2 & 3;
            for (var _loc1 = _loc8 – 1; _loc1 > 0; –_loc1)
            {
                _loc2 = _loc4[_loc1 – 1];
                _loc6 = (_loc2 >>> 5 ^ _loc3 << 2) + (_loc3 >>> 3 ^ _loc2 << 4) ^ (_loc5 ^ _loc3) + (_loc9[_loc1 & 3 ^ _loc7] ^ _loc2);
                _loc3 = _loc4[_loc1] = _loc4[_loc1] – _loc6;
            } // end of for
            _loc2 = _loc4[_loc8 – 1];
            _loc6 = (_loc2 >>> 5 ^ _loc3 << 2) + (_loc3 >>> 3 ^ _loc2 << 4) ^ (_loc5 ^ _loc3) + (_loc9[_loc1 & 3 ^ _loc7] ^ _loc2);
            _loc3 = _loc4[0] = _loc4[0] – _loc6;
        } // end of for
        return (TEA.charsToStr(TEA.longsToChars(_loc4)));
    } // End of the function
    static function charsToLongs(chars)
    {
        var _loc3 = new Array(Math.ceil(chars.length / 4));
        for (var _loc1 = 0; _loc1 < _loc3.length; ++_loc1)
        {
            _loc3[_loc1] = chars[_loc1 * 4] + (chars[_loc1 * 4 + 1] << 8) + (chars[_loc1 * 4 + 2] << 16) + (chars[_loc1 * 4 + 3] << 24);
        } // end of for
        return (_loc3);
    } // End of the function
    static function longsToChars(longs)
    {
        var _loc3 = new Array();
        for (var _loc1 = 0; _loc1 < longs.length; ++_loc1)
        {
            _loc3.push(longs[_loc1] & 255, longs[_loc1] >>> 8 & 255, longs[_loc1] >>> 16 & 255, longs[_loc1] >>> 24 & 255);
        } // end of for
        return (_loc3);
    } // End of the function
    static function charsToHex(chars)
    {
        var _loc4 = new String(“”);
        var _loc3 = new Array(“0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “a”, “b”, “c”, “d”, “e”, “f”);
        for (var _loc1 = 0; _loc1 < chars.length; ++_loc1)
        {
            _loc4 = _loc4 + (_loc3[chars[_loc1] >> 4] + _loc3[chars[_loc1] & 15]);
        } // end of for
        return (_loc4);
    } // End of the function
    static function hexToChars(hex)
    {
        var _loc3 = new Array();
        for (var _loc1 = hex.substr(0, 2) == “0x” ? (2) : (0); _loc1 < hex.length; _loc1 = _loc1 + 2)
        {
            _loc3.push(parseInt(hex.substr(_loc1, 2), 16));
        } // end of for
        return (_loc3);
    } // End of the function
    static function charsToStr(chars)
    {
        var _loc3 = new String(“”);
        for (var _loc1 = 0; _loc1 < chars.length; ++_loc1)
        {
            _loc3 = _loc3 + String.fromCharCode(chars[_loc1]);
        } // end of for
        return (_loc3);
    } // End of the function
    static function strToChars(str)
    {
        var _loc3 = new Array();
        for (var _loc1 = 0; _loc1 < str.length; ++_loc1)
        {
            _loc3.push(str.charCodeAt(_loc1));
        } // end of for
        return (_loc3);
    } // End of the function
} // End of Class

[/code]