jnitrace engine

jnitrace-moteur

Moteur utilisé par Jnitrace pour intercepter les appels API JNI.

jnitrace-engine est le projet utilisé par Jnitrace pour intercepter et tracer les appels API JNI. Il a été exposé en tant que projet distinct pour permettre aux développeurs de modules Frida d'utiliser le même moteur pour intercepter et modifier les appels d'API JNI effectués par les applications Android.

Installation:

Le moyen le plus simple de courir avec jnitrace-engine est d'utiliser NPM:

npm install jnitrace-engine

Utilisation simple:

jnitrace-engine essaie de refléter autant de l'API Frida que possible. JNIInterceptor fournit une API à attacher aux appels d'API JNI de manière très similaire à l' Interceptor Frida. L'idée est de rendre l'utilisation de la bibliothèque simple à utiliser pour ceux qui connaissent déjà Frida. Les exemples ci-dessous sont JavaScript mais le module prend également en charge TypeScript.

 import { JNIInterceptor } from "jnitrace-engine" ;

// Attach to the JNI FindClass method
JNIInterceptor . attach ( "FindClass" , {
    onEnter ( args ) {
        // called whenever the FindClass is about to be called
        console . log ( "FindClass method called" ) ;
        this . className = Memory . readCString ( args [ 1 ] ) ;
    } ,
    onLeave ( retval ) {
        // called whenever the FindClass method has finished executing
        console . log ( "tLoading Class:" , this . className ) ;
        console . log ( "tClass ID:" , retval . get ( ) ) ;
    }
} ) ; 

Utilisation avancée:

 import { JNIInterceptor } from "jnitrace-engine" ;
import { JNILibraryWatcher } from "jnitrace-engine" ;
import { JNINativeReturnValue } from "jnitrace-engine" ;
import { ConfigBuilder } from "jnitrace-engine" ;

// configure the jnitrace-engine to limit what libraries to traces
const builder : ConfigBuilder = new ConfigBuilder ( ) ;

builder . libraries = [ "libnative-lib.so" ] ; // set a list of libraries to track
builder . backtrace = "fuzzy" ; // choose the backtracer type to use [accurate/fuzzy/none]
builder . includeExports = [ "Java_com_nativetest_MainActivity_stringFromJNI" ] ; // provide a list of library exports to track
builder . excludeExports = [ ] ; // provide a list of library exports to ignore
builder . env = true ; // set whether to trace the JNIEnv struct or ignore all of it
builder . vm = false ; // set whether to trace the JavaVM struct or ignore all of it

const config = builder . build ( ) ; //initialise the config - this makes it available to the engine

// An additional callback that can be used for listening to new libraries being loaded by an application
// Note this callback will be called for all libraries, not just the ones in the config
// libraries list
JNILibraryWatcher . setCallback ( {
    onLoaded ( path : string ) {
        console . log ( "Library Loaded " + path ) ;
        console . log ( "Currently Traced Libraries" , JSON . stringify ( config . libraries ) ) ;
    }
} ) ;

const findClassIntercept = JNIInterceptor . attach ( "FindClass" , {
    onEnter ( args : NativeArgumentValue [ ] ) {
        console . log ( "Find Class called" ) ;
        args [ 1 ] = NULL ; // Change the arguments to the FindClass function
        console . log ( "ThreadId" , this . threadId ) ;
        console . log ( "Address of FindClass method" , this . jniAddress ) ;
        this . backtrace . forEach ( ( element : NativePointer ) => {
            console . log ( "backtrace" , element ) ;
        } ) ;
    } ,
    onLeave ( retval : JNINativeReturnValue ) {
        // Change the retval to be returned to the caller of FindClass
        retval . replace ( NULL ) ;
        // Detach all JNI intercepts
        JNIInterceptor . detatchAll ( ) ;
    }
} ) ;

JNIInterceptor . attach ( "CallDoubleMethodV" , {
    onLeave ( retval : JNINativeReturnValue ) {
        // Log the method params of the Java method the JNI API is calling.
        // this.javaMethod will only exist if a Java method has been called.
        console . log ( "Java Method Args" , JSON . stringify ( this . javaMethod . params ) ) ;
        // Detach from the FindClass intercept
        findClassIntercept . detach ( ) ;
    }
} ) ;