#ifdef WITH_TAINT_TRACKING
    // Copy args to another array, to ensure correct taint propagation in case args change
    int nArgs = method->insSize * 2 + 1;
    u4* oldArgs = (u4*)malloc(sizeof(u4)*nArgs);
    memcpy(oldArgs, args, sizeof(u4)*nArgs);
#endif /*WITH_TAINT_TRACKING*/

#ifdef WITH_TAINT_TRACKING
    dvmTaintPropJniMethod(oldArgs, pResult, method);
    free(oldArgs);
#endif /*WITH_TAINT_TRACKING*/

    const DexProto* proto = &method->prototype;
    DexParameterIterator pIterator;
    int nParams = dexProtoGetParameterCount(proto);
    int pStart = (dvmIsStaticMethod(method)?0:1); /* index where params start */
 
    /* Consider 3 arguments. [x] indicates return taint index
     * 0 1 2 [3] 4 5 6
     */
    int nArgs = method->insSize;
    u4* rtaint = (u4*) &args[nArgs]; /* The return taint value */
    int tStart = nArgs+1; /* index of args[] where taint values start */
    int tEnd   = nArgs*2; /* index of args[] where taint values end */
    u4            tag = TAINT_CLEAR;
    int i;

    for (i = tStart; i <= tEnd; i++) {
              tag |= args[i];
    }
    /* If not static, pull any taint from the "this" object */
    if (!dvmIsStaticMethod(method)) {
              tag |= getObjectTaint((Object*)args[0], method->clazz->descriptor);
    }
    /* Union taint from Objects we care about */
    dexParameterIteratorInit(&pIterator, proto);
    for (i=pStart; ; i++) {
              const char* desc = dexParameterIteratorNextDescriptor(&pIterator);
              if (desc == NULL) {
                  break;
              }          
              if (desc[0] == '[' || desc[0] == 'L'] { 
                  tag |= getObjectTaint((Object*) args[i], desc); //当前只支持array和string对象的污点获取！
              }
              if (desc[0] == 'J' || desc[0] == 'D') {
                  /* wide argument, increment index one more */
                  i++;
              }
    }
    /* Look at the taint policy profiles (may have return taint) */
    tag |= propMethodProfile(args, method);
    /* Update return taint according to the return type */
    if (tag) {
              const char* desc = dexProtoGetReturnType(proto);
              setReturnTaint(tag, rtaint, pResult, desc);
    }

typedef enum {
    kTaintProfileUnknown = 0,
    kTaintProfileClass,
    kTaintProfileParam,
    kTaintProfileReturn
} TaintProfileEntryType;
 
typedef struct {
    const char* from;  //格式大概为：[class/param/argX/return].[xxx].[xxx]
    const char* to;
} TaintProfileEntry;
 
#define TAINT_PROFILE_TABLE_SIZE 8 /* per class */
#define TAINT_POLICY_TABLE_SIZE 32 /* number of classes */
 
typedef struct {
    const char* methodName;
    const TaintProfileEntry* entries;
} TaintProfile;
 
typedef struct {
    const char* classDescriptor;
    const TaintProfile* profiles;
    HashTable* methodTable; /* created on startup */
} TaintPolicy;

#ifdef WITH_TAINT_TRACKING
    dvmTaintPropJniStartup();
#endif

/* Code called from dvmJniStartup()
 * Initializes the gPolicyTable for fast lookup of taint policy
 * profiles for methods.
 */
void dvmTaintPropJniStartup()
{
    TaintPolicy* policy;
    u4 hash;
   
    /* Create the policy table (perfect size) */
    gPolicyTable = dvmHashTableCreate(
                  dvmHashSize(TAINT_POLICY_TABLE_SIZE),    
                  freeTaintPolicy);
 
    for (policy = gDvmJniTaintPolicy; policy->classDescriptor != NULL; policy++) {
              const TaintProfile *profile;
   
              /* Create the method table for this class */
              policy->methodTable = dvmHashTableCreate(
                            TAINT_PROFILE_TABLE_SIZE, freeTaintProfile);
 
              /* Add all of the methods */
              for (profile = &policy->profiles[0]; profile->methodName != NULL; profile++) {
                  hash = dvmComputeUtf8Hash(profile->methodName);
                  dvmHashTableLookup(policy->methodTable, hash,(void *) profile,
                                hashcmpTaintProfile, true); //最后一个参数表示在hash表中找不到目标item时，是否将这个item添加到hash表中。
              }
 
              /* Add this class to gPolicyTable */
              hash = dvmComputeUtf8Hash(policy->classDescriptor);
              dvmHashTableLookup(gPolicyTable, hash, policy,
                            hashcmpTaintPolicy, true);
    }
 
#ifdef TAINT_JNI_LOG
    /* JNI logging for debugging purposes */
    gJniLogSeen = dvmHashTableCreate(dvmHashSize(50), free);
#endif
}

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课