Merge pull request #4 from ganyao114/master

Merge pull request ganyao114#22 from ganyao114/rewrite_native_hook

app/build.gradle

@@ -27,7 +27,7 @@ dependencies {
     androidTestImplementation 'com.android.support.test:runner:1.0.2'
     androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
     implementation project(':hooklib')
-    //implementation project(':nativehook')
+    implementation project(':nativehook')
     implementation project(':xposedcompat')
     //implementation project(':xposedcompat_new')
 }

app/src/main/java/com/swift/sandhook/MyApp.java

@@ -5,6 +5,7 @@
 import android.os.Build;
 import android.util.Log;
 
+import com.swift.sandhook.nativehook.NativeHook;
 import com.swift.sandhook.test.TestClass;
 import com.swift.sandhook.testHookers.ActivityHooker;
 import com.swift.sandhook.testHookers.CtrHook;
@@ -22,7 +23,7 @@
 
 public class MyApp extends Application {
 
-    //if you want test Android Q, please set true, because SDK_INT of Android Q is still 28
+    //if you want test Android Q, please Set true, because SDK_INT of Android Q is still 28
     public final static boolean testAndroidQ = false;
 
     @Override

doc/doc.md

@@ -1330,7 +1330,7 @@ JitCompile->CommitCode->CommitCodeInternal
 - 并且在跳转的时候要注意入口地址符合要求
 
 ```cpp
-bool isThumbCode(Size codeAddr) {
+bool IsThumbCode(Size codeAddr) {
             return (codeAddr & 0x1) == 0x1;
 }
 ```

nativehook/CMakeLists.txt

@@ -71,6 +71,7 @@ include_directories(
         src/main/cpp/archs/arm/arm32/decoder
         src/main/cpp/archs/arm/arm32/hook
         src/main/cpp/archs/arm/arm32/relocate
+        src/main/cpp/antihook
 )
 
 # Searches for a specified prebuilt library and stores the path as a

nativehook/src/main/cpp/archs/arm/arm32/assembler/assembler_arm32.cpp

@@ -10,44 +10,44 @@ using namespace SandHook::RegistersA32;
 using namespace SandHook::AsmA32;
 
 AssemblerA32::AssemblerA32(CodeBuffer* codeBuffer) {
-    codeContainer.setCodeBuffer(codeBuffer);
+    code_container.SetCodeBuffer(codeBuffer);
 }
 
-void *AssemblerA32::getPC() {
-    return reinterpret_cast<void *>(codeContainer.curPc);
+void *AssemblerA32::GetPC() {
+    return reinterpret_cast<void *>(code_container.cur_pc);
 }
 
-void *AssemblerA32::getStartPC() {
-    return reinterpret_cast<void *>(codeContainer.startPc);
+void *AssemblerA32::GetStartPC() {
+    return reinterpret_cast<void *>(code_container.start_pc);
 }
 
-void AssemblerA32::allocBufferFirst(U32 size) {
-    codeContainer.allocBufferFirst(size);
+void AssemblerA32::AllocBufferFirst(U32 size) {
+    code_container.AllocBufferFirst(size);
 }
 
-void *AssemblerA32::finish() {
-    codeContainer.commit();
-    return reinterpret_cast<void *>(codeContainer.startPc);
+void *AssemblerA32::Finish() {
+    code_container.Commit();
+    return reinterpret_cast<void *>(code_container.start_pc);
 }
 
 void AssemblerA32::Emit(U32 data32) {
-    Emit(reinterpret_cast<Unit<Base>*>(new Data32(data32)));
+    Emit(reinterpret_cast<BaseUnit*>(new Data32(data32)));
 }
 
 void AssemblerA32::Emit(U16 data16) {
-    Emit(reinterpret_cast<Unit<Base>*>(new Data16(data16)));
+    Emit(reinterpret_cast<BaseUnit*>(new Data16(data16)));
 }
 
-void AssemblerA32::Emit(Unit<Base> *unit) {
-    codeContainer.append(unit);
+void AssemblerA32::Emit(BaseUnit *unit) {
+    code_container.Append(unit);
 }
 
 void AssemblerA32::Mov(RegisterA32 &rd, U16 imm16) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(MOV_MOVT_IMM)(INST_T32(MOV_MOVT_IMM)::MOV, rd, imm16)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(MOV_MOVT_IMM)(INST_T32(MOV_MOVT_IMM)::MOV, rd, imm16)));
 }
 
 void AssemblerA32::Movt(RegisterA32 &rd, U16 imm16) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(MOV_MOVT_IMM)(INST_T32(MOV_MOVT_IMM)::MOVT, rd, imm16)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(MOV_MOVT_IMM)(INST_T32(MOV_MOVT_IMM)::MOVT, rd, imm16)));
 }
 
 void AssemblerA32::Mov(RegisterA32 &rd, U32 imm32) {
@@ -58,119 +58,119 @@ void AssemblerA32::Mov(RegisterA32 &rd, U32 imm32) {
 }
 
 void AssemblerA32::Ldr(RegisterA32 &rt, Off offset) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDR, INST_T32(LDR_LIT)::UnSign, rt, offset)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDR, INST_T32(LDR_LIT)::UnSign, rt, offset)));
 }
 
 void AssemblerA32::Ldr(RegisterA32 &rt, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDR, INST_T32(LDR_LIT)::UnSign, rt, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDR, INST_T32(LDR_LIT)::UnSign, rt, label)));
 }
 
 void AssemblerA32::Ldrb(RegisterA32 &rt, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRB, INST_T32(LDR_LIT)::UnSign,rt, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRB, INST_T32(LDR_LIT)::UnSign,rt, label)));
 }
 
 void AssemblerA32::Ldrh(RegisterA32 &rt, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRH, INST_T32(LDR_LIT)::UnSign,rt, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRH, INST_T32(LDR_LIT)::UnSign,rt, label)));
 }
 
 void AssemblerA32::Ldrsb(RegisterA32 &rt, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRB, INST_T32(LDR_LIT)::Sign,rt, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRB, INST_T32(LDR_LIT)::Sign,rt, label)));
 }
 
 void AssemblerA32::Ldrsh(RegisterA32 &rt, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRH, INST_T32(LDR_LIT)::Sign,rt, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_LIT)(INST_T32(LDR_LIT)::LDRH, INST_T32(LDR_LIT)::Sign,rt, label)));
 }
 
 void AssemblerA32::Ldr(RegisterA32 &rt, const MemOperand &operand) {
     if (operand.addr_mode == Offset && operand.offset >= 0) {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_UIMM)(rt, *operand.rn, operand.addr_mode)));
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_UIMM)(rt, *operand.rn, operand.addr_mode)));
     } else {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDR, rt, operand)));
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDR, rt, operand)));
     }
 }
 
 void AssemblerA32::Ldrb(RegisterA32 &rt, const MemOperand &operand) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRB, rt, operand)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRB, rt, operand)));
 }
 
 void AssemblerA32::Ldrh(RegisterA32 &rt, const MemOperand &operand) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRH, rt, operand)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRH, rt, operand)));
 }
 
 void AssemblerA32::Ldrsb(RegisterA32 &rt, const MemOperand &operand) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRSB, rt, operand)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRSB, rt, operand)));
 }
 
 void AssemblerA32::Ldrsh(RegisterA32 &rt, const MemOperand &operand) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRSH, rt, operand)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(LDR_IMM)(INST_T32(LDR_IMM)::LDRSH, rt, operand)));
 }
 
 void AssemblerA32::B(Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(B)(*label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(B)(label)));
 }
 
 void AssemblerA32::Bl(Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(B32)(INST_T32(B32)::BL, INST_T32(B32)::arm, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(B32)(INST_T32(B32)::BL, INST_T32(B32)::arm, label)));
 }
 
 void AssemblerA32::Blx(Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(B32)(INST_T32(B32)::BL, INST_T32(B32)::thumb, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(B32)(INST_T32(B32)::BL, INST_T32(B32)::thumb, label)));
 }
 
 void AssemblerA32::Bx(Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T32(B32)(INST_T32(B32)::B, INST_T32(B32)::thumb, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T32(B32)(INST_T32(B32)::B, INST_T32(B32)::thumb, label)));
 }
 
 void AssemblerA32::Mov(RegisterA32 &rd, RegisterA32 &rm) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(MOV_REG)(rd, rm)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(MOV_REG)(rd, rm)));
 }
 
 void AssemblerA32::Bx(RegisterA32 &rm) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(BX_BLX)(INST_T16(BX_BLX)::BX, rm)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(BX_BLX)(INST_T16(BX_BLX)::BX, rm)));
 }
 
 void AssemblerA32::Blx(RegisterA32 &rm) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(BX_BLX)(INST_T16(BX_BLX)::BLX, rm)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(BX_BLX)(INST_T16(BX_BLX)::BLX, rm)));
 }
 
 void AssemblerA32::B(Condition condition, Label* label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(B_COND)(condition, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(B_COND)(condition, label)));
 }
 
 void AssemblerA32::Add(RegisterA32 &rdn, U8 imm8) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(ADD_IMM_RDN)(&rdn, imm8)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(ADD_IMM_RDN)(&rdn, imm8)));
 }
 
 void AssemblerA32::Add(RegisterA32 &rd, RegisterA32 &rn, RegisterA32 &rm) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(ADD_REG)(&rd, &rn, &rm)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(ADD_REG)(&rd, &rn, &rm)));
 }
 
 void AssemblerA32::Cmp(RegisterA32 &rd, RegisterA32 &rn) {
-    if (rd.getCode() < 8 && rn.getCode() < 8) {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(CMP_REG)(rd, rn)));
+    if (rd.Code() < 8 && rn.Code() < 8) {
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T16(CMP_REG)(rd, rn)));
     } else {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(CMP_REG_EXT)(rd, rn)));
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T16(CMP_REG_EXT)(rd, rn)));
     }
 }
 
 void AssemblerA32::Pop(RegisterA32 &rt) {
-    if (rt.getCode() < 8 || rt == PC) {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(POP)(RegisterList(rt))));
+    if (rt.Code() < 8 || rt == PC) {
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T16(POP)(RegisterList(rt))));
     } else {
         throw ErrorCodeException("error pop inst");
     }
 }
 
 void AssemblerA32::Push(RegisterA32 &rt) {
-    if (rt.getCode() < 8 || rt == PC) {
-        Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(PUSH)(RegisterList(rt))));
+    if (rt.Code() < 8 || rt == PC) {
+        Emit(reinterpret_cast<BaseUnit*>(new INST_T16(PUSH)(RegisterList(rt))));
     } else {
         throw ErrorCodeException("error pop inst");
     }
 }
 
 void AssemblerA32::Adr(RegisterA32 &rd, Label *label) {
-    Emit(reinterpret_cast<Unit<Base>*>(new INST_T16(ADR)(rd, *label)));
+    Emit(reinterpret_cast<BaseUnit*>(new INST_T16(ADR)(rd, label)));
 }
 
 void AssemblerA32::Nop16() {

nativehook/src/main/cpp/archs/arm/arm32/assembler/assembler_arm32.h

@@ -11,7 +11,7 @@
 #include "inst_t32.h"
 
 #define ALIGN_FOR_LDR \
-if ((Addr) __ getPC() % 4 != 0) { \
+if ((Addr) __ GetPC() % 4 != 0) { \
 __ Nop16(); \
 }
 
@@ -24,14 +24,14 @@ namespace SandHook {
         public:
             AssemblerA32(CodeBuffer* codeBuffer);
 
-            void allocBufferFirst(U32 size);
-            void* getStartPC();
-            void* getPC();
-            void* finish();
+            void AllocBufferFirst(U32 size);
+            void* GetStartPC();
+            void* GetPC();
+            void* Finish();
 
             void Emit(U32 data32);
             void Emit(U16 data16);
-            void Emit(Unit<Base>* unit);
+            void Emit(BaseUnit* unit);
 
 
             void Mov(RegisterA32 &rd, U16 imm16);
@@ -78,7 +78,7 @@ namespace SandHook {
             void Nop16();
 
         public:
-            CodeContainer codeContainer = CodeContainer(nullptr);
+            CodeContainer code_container = CodeContainer(nullptr);
         };
     }
 }

nativehook/src/main/cpp/archs/arm/arm32/decoder/decoder_arm32.cpp

@@ -11,8 +11,7 @@ using namespace SandHook::AsmA32;
 
 #define CASE(T, X) \
 if (IS_OPCODE_##T(*reinterpret_cast<Inst##T *>(pc), X)) { \
-STRUCT_##T(X) *s = reinterpret_cast<STRUCT_##T(X) *>(pc); \
-unit = reinterpret_cast<Unit<Base> *>(new INST_##T(X)(s)); \
+unit = reinterpret_cast<BaseUnit*>(new INST_##T(X)(pc)); \
 goto label_matched; \
 }
 
@@ -23,16 +22,17 @@ goto label_matched; \
 
 Arm32Decoder* Arm32Decoder::instant = new Arm32Decoder();
 
-void Arm32Decoder::decode(void *codeStart, Addr codeLen, InstVisitor &visitor, bool onlyPcRelInst) {
-    bool thumb = isThumbCode(reinterpret_cast<Addr>(codeStart));
+void Arm32Decoder::Disassemble(void *codeStart, Addr codeLen, InstVisitor &visitor,
+                               bool onlyPcRelInst) {
+    bool thumb = IsThumbCode(reinterpret_cast<Addr>(codeStart));
     if (thumb) {
-        codeStart = getThumbCodeAddress(codeStart);
+        codeStart = GetThumbCodeAddress(codeStart);
     }
     void *pc = codeStart;
     Addr endAddr = (Addr) codeStart + codeLen;
-    Unit<Base>* unit = nullptr;
+    BaseUnit *unit = nullptr;
     while((Addr) pc < endAddr) {
-        bool thumb32 = isThumb32(*reinterpret_cast<InstT16*>(pc));
+        bool thumb32 = IsThumb32(*reinterpret_cast<InstT16*>(pc));
         if (thumb && thumb32) {
             CASE_T32(SUB_IMM)
             CASE_T32(B32)
@@ -43,7 +43,7 @@ void Arm32Decoder::decode(void *codeStart, Addr codeLen, InstVisitor &visitor, b
                 CASE_T32(MOV_MOVT_IMM)
             }
             if (unit == nullptr) {
-                unit = reinterpret_cast<Unit<Base> *>(new INST_T32(UNKNOW)(*reinterpret_cast<STRUCT_T32(UNKNOW) *>(pc)));
+                unit = reinterpret_cast<BaseUnit*>(new INST_T32(UNKNOW)(pc));
             }
         } else if (thumb) {
             CASE_T16(B)
@@ -63,18 +63,19 @@ void Arm32Decoder::decode(void *codeStart, Addr codeLen, InstVisitor &visitor, b
                 CASE_T16(PUSH)
             }
             if (unit == nullptr) {
-                unit = reinterpret_cast<Unit<Base> *>(new INST_T16(UNKNOW)(*reinterpret_cast<STRUCT_T16(UNKNOW) *>(pc)));
+                unit = reinterpret_cast<BaseUnit*>(new INST_T16(UNKNOW)(pc));
             }
         } else {
             //TODO arm32 support
-            unit = reinterpret_cast<Unit<Base> *>(new INST_T32(UNKNOW)(*reinterpret_cast<STRUCT_T32(UNKNOW) *>(pc)));
+            unit = reinterpret_cast<BaseUnit*>(new INST_T32(UNKNOW)(pc));
         }
 
         label_matched:
-        if (!visitor.visit(unit, pc)) {
+        reinterpret_cast<BaseInst*>(unit)->Disassemble();
+        if (!visitor.Visit(unit, pc)) {
             break;
         }
-        pc = reinterpret_cast<InstA64 *>((Addr)pc + unit->size());
+        pc = reinterpret_cast<void*>((Addr)pc + unit->Size());
         unit = nullptr;
     }
 }

nativehook/src/main/cpp/archs/arm/arm32/decoder/decoder_arm32.h

@@ -12,7 +12,8 @@ namespace SandHook {
 
         class Arm32Decoder : public InstDecoder {
         public:
-            void decode(void *codeStart, Addr codeLen, InstVisitor &visitor, bool onlyPcRelInst) override;
+            void Disassemble(void *codeStart, Addr codeLen, InstVisitor &visitor,
+                             bool onlyPcRelInst) override;
         public:
             static Arm32Decoder* instant;
         };