frida-java-bridge 6.2.6 → 6.3.0

package/lib/android.js

@@ -483,6 +483,7 @@ function _getApi () {
 
     temporaryApi.artQuickGenericJniTrampoline = getArtQuickEntrypointFromTrampoline(quickGenericJniTrampoline, vm);
     temporaryApi.artQuickToInterpreterBridge = getArtQuickEntrypointFromTrampoline(quickToInterpreterBridgeTrampoline, vm);
+    temporaryApi.artQuickResolutionTrampoline = getArtQuickEntrypointFromTrampoline(quickResolutionTrampoline, vm);
 
     if (temporaryApi['art::JavaVMExt::AddGlobalRef'] === undefined) {
       temporaryApi['art::JavaVMExt::AddGlobalRef'] = makeAddGlobalRefFallbackForAndroid5(temporaryApi);
@@ -1825,7 +1826,8 @@ function instrumentArtQuickEntrypoints (vm) {
   // Entrypoints that dispatch method invocation from the quick ABI.
   const quickEntrypoints = [
     api.artQuickGenericJniTrampoline,
-    api.artQuickToInterpreterBridge
+    api.artQuickToInterpreterBridge,
+    api.artQuickResolutionTrampoline
   ];
 
   quickEntrypoints.forEach(entrypoint => {

package/lib/class-factory.js

@@ -1318,37 +1318,52 @@ function makeSuperHandleGetter (classWrapper) {
 function makeConstructor (classHandle, classWrapper, env) {
   const { $n: className, $f: factory } = classWrapper;
   const methodName = basename(className);
+  const Class = env.javaLangClass();
   const Constructor = env.javaLangReflectConstructor();
   const invokeObjectMethodNoArgs = env.vaMethod('pointer', []);
+  const invokeUInt8MethodNoArgs = env.vaMethod('uint8', []);
 
   const jsCtorMethods = [];
   const jsInitMethods = [];
   const jsRetType = factory._getType(className, false);
   const jsVoidType = factory._getType('void', false);
 
-  const constructors = invokeObjectMethodNoArgs(env.handle, classHandle, env.javaLangClass().getDeclaredConstructors);
+  const constructors = invokeObjectMethodNoArgs(env.handle, classHandle, Class.getDeclaredConstructors);
   try {
     const n = env.getArrayLength(constructors);
 
-    for (let i = 0; i !== n; i++) {
-      let methodId, types;
-      const constructor = env.getObjectArrayElement(constructors, i);
-      try {
-        methodId = env.fromReflectedMethod(constructor);
-        types = invokeObjectMethodNoArgs(env.handle, constructor, Constructor.getGenericParameterTypes);
-      } finally {
-        env.deleteLocalRef(constructor);
-      }
+    if (n !== 0) {
+      for (let i = 0; i !== n; i++) {
+        let methodId, types;
+        const constructor = env.getObjectArrayElement(constructors, i);
+        try {
+          methodId = env.fromReflectedMethod(constructor);
+          types = invokeObjectMethodNoArgs(env.handle, constructor, Constructor.getGenericParameterTypes);
+        } finally {
+          env.deleteLocalRef(constructor);
+        }
 
-      let jsArgTypes;
-      try {
-        jsArgTypes = readTypeNames(env, types).map(name => factory._getType(name));
-      } finally {
-        env.deleteLocalRef(types);
+        let jsArgTypes;
+        try {
+          jsArgTypes = readTypeNames(env, types).map(name => factory._getType(name));
+        } finally {
+          env.deleteLocalRef(types);
+        }
+
+        jsCtorMethods.push(makeMethod(methodName, classWrapper, CONSTRUCTOR_METHOD, methodId, jsRetType, jsArgTypes, env));
+        jsInitMethods.push(makeMethod(methodName, classWrapper, INSTANCE_METHOD, methodId, jsVoidType, jsArgTypes, env));
+      }
+    } else {
+      const isInterface = invokeUInt8MethodNoArgs(env.handle, classHandle, Class.isInterface);
+      if (isInterface) {
+        throw new Error('cannot instantiate an interface');
       }
 
-      jsCtorMethods.push(makeMethod(methodName, classWrapper, CONSTRUCTOR_METHOD, methodId, jsRetType, jsArgTypes, env));
-      jsInitMethods.push(makeMethod(methodName, classWrapper, INSTANCE_METHOD, methodId, jsVoidType, jsArgTypes, env));
+      const defaultClass = env.javaLangObject();
+      const defaultConstructor = env.getMethodId(defaultClass, '<init>', '()V');
+
+      jsCtorMethods.push(makeMethod(methodName, classWrapper, CONSTRUCTOR_METHOD, defaultConstructor, jsRetType, [], env));
+      jsInitMethods.push(makeMethod(methodName, classWrapper, INSTANCE_METHOD, defaultConstructor, jsVoidType, [], env));
     }
   } finally {
     env.deleteLocalRef(constructors);

package/lib/env.js

@@ -667,6 +667,7 @@ Env.prototype.javaLangClass = function () {
         getDeclaredFields: get('getDeclaredFields', '()[Ljava/lang/reflect/Field;'),
         isArray: get('isArray', '()Z'),
         isPrimitive: get('isPrimitive', '()Z'),
+        isInterface: get('isInterface', '()Z'),
         getComponentType: get('getComponentType', '()Ljava/lang/Class;')
       };
     } finally {
@@ -683,6 +684,7 @@ Env.prototype.javaLangObject = function () {
     try {
       const get = this.getMethodId.bind(this, handle);
       javaLangObject = {
+        handle: register(this.newGlobalRef(handle)),
         toString: get('toString', '()Ljava/lang/String;'),
         getClass: get('getClass', '()Ljava/lang/Class;')
       };

package/lib/types.js

@@ -233,6 +233,8 @@ const primitiveTypes = {
   }
 };
 
+const primitiveTypesNames = new Set(Object.values(primitiveTypes).map(t => t.name));
+
 function getPrimitiveType (name) {
   const result = primitiveTypes[name];
   return (result !== undefined) ? result : null;
@@ -436,10 +438,27 @@ function getArrayType (typeName, unbox, factory) {
   let elementTypeName = typeName.substring(1);
   const elementType = getType(elementTypeName, unbox, factory);
 
+  let numInternalArrays = 0;
+  const end = elementTypeName.length;
+  while (numInternalArrays !== end && elementTypeName[numInternalArrays] === '[') {
+    numInternalArrays++;
+  }
+  elementTypeName = elementTypeName.substring(numInternalArrays);
+
   if (elementTypeName[0] === 'L' && elementTypeName[elementTypeName.length - 1] === ';') {
     elementTypeName = elementTypeName.substring(1, elementTypeName.length - 1);
   }
 
+  // The type name we get is not always the correct representation of the type so we make it so here.
+  let internalElementTypeName = elementTypeName.replace(/\./g, '/');
+  if (primitiveTypesNames.has(internalElementTypeName)) {
+    internalElementTypeName = '['.repeat(numInternalArrays) + internalElementTypeName;
+  } else {
+    internalElementTypeName = '['.repeat(numInternalArrays) + 'L' + internalElementTypeName + ';';
+  }
+  const internalTypeName = '[' + internalElementTypeName;
+  elementTypeName = '['.repeat(numInternalArrays) + elementTypeName;
+
   return {
     name: typeName.replace(/\./g, '/'),
     type: 'pointer',
@@ -476,8 +495,6 @@ function getArrayType (typeName, unbox, factory) {
         }
       }
 
-      // The type name we get is not always the correct representation of the type so we make it so here.
-      const internalTypeName = '[L' + elementTypeName.replace(/\./g, '/') + ';';
       try {
         result.$w = factory.cast(arr, factory.use(internalTypeName), owned);
       } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frida-java-bridge",
-  "version": "6.2.6",
+  "version": "6.3.0",
   "description": "Java runtime interop from Frida",
   "main": "index.js",
   "files": [