Android game hacking

Frustrated with some Android games? Want to hack? Want to kill the monsters with one slice?

Okay, this is the main purpose I learn about Android rooting. After we gain the “#” from “adb shell” (refers to my previous post), now we can see all the files in /data folder. This folder contains the game save data and also some libraries.

Simple problem and solution

My hacking method is not memory editing, but save file editing. So, to edit the save file, we must have the knowledge and experience on hexadecimal editing. Now, since we can access those data files in /data/data folder, meaning that we can pull them, edit them, push them back.

So, pull the save file you want, the name such as Save0.dat or similar name. Use a hex editor, such as bless, ghex, hexedit, etc. Edit the value, then push the file back.

I personally wrote a small command-line tool, so that I can do hex editing in adb shell. (It is available here). I push it to /data/local/tmp folder, so that I can use it without pulling and pushing the file.

For some games, the save file is plain binary file. We can understand the file with the hex editing, such as the value of the coins, the level of the weapons, the status of the hero such as strength, vital, hp, and so on. These can be easily edited. (Please always make a backup before editing).

Advanced problem and solution

For other games, the save file is really a pain. They are encrypted/encoded save file. We cannot understand anything about the file. Modifying the file does not help. So, my only solution is to edit the library file, i.e. shared object (.so).

For example, if there is a library called libdhunter.so, we need to use objdump (ARM target, not x86 or x86-64 target) to disassemble the shared object. The objdump can be obtained from Android NDK package.

/path-to/objdump -dC libdhunter.so > asm.txt #pull the library file first, not doing this in adb shell

This will create “asm.txt” which contains the disassembled data. Now, what we can do is just study the functions. We might find some functions such as “encode”, “encrypt”, “decode”, “decrypt”, “save”, “load”. And also, need to look for open file, read or write file, and close file. This is because normally, they will call encrypt or encode before write the file (save). Study what the functions they are calling.

For example, in the “save” function, it might contain a call of “encode” function, then only “write” the buffer. In this case, it will be quite easy to solve the problem. Use a hex editor to open the shared object. Edit the hexadecimal value of the opcode that calls the “encode” function within “save” to “00 00 00 00″, this will produce NOP operation. That means, we disable calling “encode” function in “save” function.

Then, we can objdump again to check whether we have disabled the function call.

Push the edited library to the device. Make sure backup the original library and also the save file.

Run the game, load the save file, save the game, then exit.

Now, do not restart the game yet. Now, check the newly saved file with hex editor. If it is a plain binary file, then we success! If not, try until you want to give up.

Do not restart the game yet, because the game will load the encoded save file, not the plain binary save file. So, to make the game load the plain binary save file, we need to disable calling “decode” function in the “load” function as the method discussed above.

Push the newly edited library, then start the game.

Now, we can hex edit the save file freely as we like.

Other problem and solution (added 2012-03-19)

There are even easier problems, such as the game Aqua Pet. There is no shared object (lib*.so). And the save file is also a plain text file. Meaning, we need no hex editor to edit it. However, editing the file might not change anything. In this type of case, we must “force stop” the app first, then edit the file.

Now, enjoy the games.

C# 使用委託跨線程通訊

當我們需要處理大量數據時，為了使UI界面不致出現假死狀態，我們就必須使用多線程進行處理。所以問題就出現了，我們都知道線程作為一個獨立運行的單元，線程間不可以隨意訪問和修改，那麼該怎麼辦呢？其實C#提供了跨線程訪問的方法，也就是通過委託安全調用從非擁有控件的線程訪問控件。

        一、委託

        我們首先先來瞭解下委託，簡單地說，委託就是一個類，它定義了方法傳遞參數的類型和個數，使得我們可以把方法作為參數進行傳遞，使得程序具有更好的擴展性。如果大家還不明白的話，我們可以舉個例子：

[csharp] view plaincopyprint?

1. private   delegate   void setTextDelegate( string msg);   //聲明一個委託類型，這個委託類型傳遞一個string類型參數，並返回為void  
2.   
3. private void setLabelText(string value)    //這是一個傳遞string類型參數，並返回void的方法  
4. {  
5.     this.label1.Text = value;  
6. }  
7.   
8.  private void setTextboxTex(string  msg)  //這也是一個傳遞string類型參數，並返回void的方法  
9. {  
10.     this.textBox1.Text = msg;  
11. }  
12.   
13.  private void setText(string msg,setTextDelegate std)   //把setTextDelegate類型委託作為一個參數進行傳遞  
14.  {  
15.      std(msg);     //真正的參數傳遞  
16.  }  
17.   
18.  private void button1_Click(object sender, EventArgs e)  
19.  {  
20.   
21.      this.setText("這是label控件", setLabelText);    //因為setLabelText傳遞的參數類型和返回值都和委託聲明的類型一致，所以可以進行傳遞  
22.   
23.      this.setText("這是textBox控件", setTextboxTex);   //同上  
24.  }  

    總結下，從上面的例子我們可以清楚地看到，只要方法傳遞的參數類型、個數和返回值與委託聲明的一致，我們就可以把該方法作為參數進行傳遞。

    我們也可以將多個方法綁定到委託上，所有綁定上去的方法就會形成一個鏈表順序執行。

[csharp] view plaincopyprint?

1. private void button1_Click(object sender, EventArgs e)  
2. {         
3.     setTextDelegate std = new setTextDelegate(setLabelText);     //實例化委託並綁定setLabelText方法  
4.   
5.      std += setTextboxTex;     //使用"+="號綁定方法，解綁使用"-="號  
6.   
7.      this.setText("這是控件", std);  
8.  }  

      這樣setTextDelegate綁定了兩個方法，當我們this.setText("這是控件", std);時兩個方法會順序執行，這樣做大大提高了程序的可擴性。

     注意：委託並沒有提供0參數的構造函數，所以setTextDelegate std = new setTextDelegate();   std += setLabelText;     std += setTextboxTex;    這樣編譯會出錯。

    二、線程安全及委託調用

       在講解跨線程委託調用的方法前，我們先瞭解幾個常用的方法和屬性：

       1.Control.InvokeRequired屬性（Control是所有控件的基類），這個屬性用來判斷Control控件是否為調用線程創建的，如果為否的話，也就是創建Control控件的線程不是調用線程，返回false,否則返回true。

      2.Control.Invoke() 方法，這是同步調用的方法，它順序執行Invoke(Delegate)裡的委託方法會再繼續執行下面的方法，下面會詳細解釋。

      3.Control.BeginInvoke()方法，這是異步調用的方法，它會類似於把委託內的方法又創建了一條線程來執行，只有調用線程進行Sleep切換時才會執行委託方法，下面會詳細解釋它和Control.Invoke()方法的區別。

      先來看個例子：

[csharp] view plaincopyprint?

1. private   delegate   void setTextDelegate( int value);   //先聲明一個傳遞int類型參數，並返回為void的委託  
2.   
3.  private void button1_Click(object sender, EventArgs e)  
4. {  
5.    Thread newThread = new Thread(new ThreadStart(threadHandler));  
6.      newThread.Start();  
7. }  
8.   
9.  private void threadHandler()  
10.  {  
11.   
12.      for(int i =0 ; i <=100 ;  i ++)  
13.      {  
14.           this.UIHandler(i);  
15.   
16.           Thread.Sleep(100);  
17.   
18.      }  
19.  }  
20.   
21.   private void UIHandler(int value)  
22.   {  
23.   
24.      if(this.label1.InvokeRequired)  //判斷label1控件是否是調用線程(即newThread線程)創建的,也就是是否跨線程調用,如果是則返回true,否則返回false  
25.      {  
26.          this.label1.BeginInvoke(new setTextDelegate(setLabelText),new object []{ value});  //異步調用setLabelText方法，並傳遞一個int參數  
27.      }  
28.      else  
29.      {  
30.          this.label1.Text = value.ToString() + "%";  
31.      }  
32.   }  
33.   
34.   private void setLabelText(int value)  //當跨線程調用時，調用該方法進行UI界面更新  
35.   {  
36.      this.label1.Text = value.ToString() + "%";  
37.   }  

     這是一個簡單的跨線程調用的例子，不懂的可以把例子拷貝自己運行下就清楚了，其實原理很簡單，分兩步就搞定了：

    1. 聲明一個委託類型，定義它需要傳遞的參數類型、個數和返回的類型。

    2.判斷是否跨線程調用更新控件內容(Control.InvokeRequired)，如果是的話，就要用Invoke()或BeginInvoke()執行委託。

     三、Control.Invoke()與Control.BeginInvoke()方法的區別

     我們都知道這兩個方法都可以進行委託執行，但其中Control.Invoke()是同步調用執行，Control.BeginInvoke()是異步調用執行。

     MSDN上的解釋是這樣的：

     Control.Invoke()方法：在擁有此控件的基礎窗口句柄的線程上執行委託。 

    Control.BeginInvoke()方法：在創建控件的基礎句柄所在線程上異步執行委託。 

     從MSDN的解釋我們可以得出，委託都是在Control線程執行的，也就是UI主線程執行的。兩者的區別主要是異步執行和順序執行的區別，也就是執行順序的不一致。

    下面舉個例子來看就明白了，就拿上面的例子來講解好了。

[csharp] view plaincopyprint?

1.  private   delegate   void setTextDelegate( int value);   //先聲明一個傳遞int類型參數，並返回為void的委託  
2.   
3.  private void button1_Click(object sender, EventArgs e)  
4. {  
5.    Thread newThread = new Thread(new ThreadStart(threadHandler));  
6.   
7.      newThread.Start();  
8. }  
9.   
10.  private void threadHandler()  
11.  {  
12.      for(int i =0 ; i <=100 ;  i ++)  
13.      {  
14.          this.UIHandler(i);      
15.   
16.           Thread.Sleep(100);  
17.       }  
18.   
19.  }  
20.  private void UIHandler(int value)  
21.  {  
22.        //  ........①  
23.        if(this.label1.InvokeRequired)  //判斷label1控件是否是調用線程(即newThread線程)創建的,也就是是否跨線程調用,如果是則返回true,否則返回false  
24.        {  
25.            this.label1.Invoke(new setTextDelegate(setLabelText),new object []{ value});   //同步調用......②  
26.   
27.            //this.label1.BeginInvoke(new setTextDelegate(setLabelText),new object []{ value});   //異步調用 ......③  
28.         }  
29.         else  
30.         {  
31.             this.label1.Text = value.ToString() + "%";   //.......④  
32.         }  
33.         //.........⑤  
34.   }  
35.   
36.   private void setLabelText(int value)  //當跨線程調用時，調用該方法進行UI界面更新  
37.   {  
38.       this.label1.Text = value.ToString() + "%";     //..........⑥  
39.   }  

       大家先猜猜看，如果是Invoke調用的話，也就是（①、②、④、⑤、⑥）的執行順序，而如果是BeginInvoke調用的話，也就是（①、③、④、⑤、⑥）的執行順序。

     正確的執行順序：Invoke是①->②->⑥-->⑤,而BeginInvoke是①->③->⑤->⑥，④這步不會執行到。

     大家可以自己去試下，其實原理我上面已經說過了，使用Invoke方法的話，調用線程會馬上進行切換操作，切換到Control控件所在線程（UI線程）進行界面的更新後，再切換回來繼續執行下面的內容，而BeginInvoke方法的話，調用線程不會馬上進行切換操作，它會在Thread.Sleep(100);的時候進行切換到UI線程進行界面的更新，所以用BeginInvoke方法的時候一定要注意，每次執行完要Thread.Sleep(100);下讓界面更新，否則界面還是不會有變化的。

     四、委託的類型

     .Net Framework 提供了兩種類型的委託，一種是自定義型的，一種是系統定義型的(固定類型)。自定義型的就不說了，也就是需要自己進行聲明委託類型，靈活性高，不過系統默認提供的幾個固定類型的委託也可以讓我們快速實現委託。

    1.   public delegate void  MethodInvoker ()   //聲明返回值為 void 且不接受任何參數傳遞的任何方法    

[csharp] view plaincopyprint?

1. private void button1_Click(object sender, EventArgs e)  
2.   
3.   Thread newThread = new Thread(new ThreadStart(threadHandler));            
4.     newThread.Start();  
5. }  
6.   
7.  private void threadHandler()  
8.  {  
9.      if(this.label1.InvokeRequired)  //判斷label1控件是否是調用線程(即newThread線程)創建的,也就是是否跨線程調用,如果是則返回true,否則返回false  
10.      {  
11.          this.label1.Invoke(new MethodInvoker(threadHandler));   //把封包發送UI線程，即UI線程執行threadHandler方法  
12.      }  
13.      else  
14.      {  
15.          this.label1.Text = "這是lable控件";   //第二次this.label1.InvokeRequired判斷後會執行到這裡  
16.      }  
17.  }  

    2.public delegate void EventHandler (Objectsender,EventArgse)  //表示將處理不包含事件數據的事件的方法。 

[csharp] view plaincopyprint?

1. private void button1_Click(object sender, EventArgs e)  
2.   
3.   Thread newThread = new Thread(new ThreadStart(threadHandler));            
4.   
5.      newThread.Start();  
6. }  
7.   
8.  private void threadHandler()  
9.  {  
10.        if(this.label1.InvokeRequired)  //判斷label1控件是否是調用線程(即newThread線程)創建的,也就是是否跨線程調用,如果是則返回true,否則返回false  
11.        {  
12.            this.label1.Invoke(new EventHandler(setLabelText),new object[]{"這是lable控件"});   //EventHandler可以傳遞object參數  
13.        }  
14.        else  
15.        {  
16.            this.label1.Text = "這是lable控件";  
17.        }  
18.   }  
19.   
20.   private void setLabelText(object o, System.EventArgs e)  
21.    {  
22.        this.label1.Text =  o.ToString();  
23.    }  

            後述：委託的內容就講到這吧，講得不對不好的地方請大家多多包涵。