dex-oracle 1.0.2

data/driver/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

data/driver/src/main/java/org/cf/oracle/Driver.java

@@ -0,0 +1,134 @@
+package org.cf.oracle;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.cf.oracle.options.InvocationTarget;
+import org.cf.oracle.options.TargetParser;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class Driver {
+
+    private static final String DRIVER_DIR = "/data/local";
+
+    private static final String OUTPUT_HEADER = "===ORACLE DRIVER OUTPUT===\n";
+    private static final String EXCEPTION_LOG = DRIVER_DIR + "/od-exception.txt";
+    private static final String OUTPUT_FILE = DRIVER_DIR + "/od-output.json";
+    private static final Gson GSON = new GsonBuilder().disableHtmlEscaping().create();
+
+    private static void die(String msg, Exception exception) {
+        PrintWriter writer;
+        try {
+            writer = new PrintWriter(EXCEPTION_LOG, "UTF-8");
+        } catch (Exception e) {
+            return;
+        }
+        writer.println(msg);
+        writer.println(exception);
+        StringWriter sw = new StringWriter();
+        exception.printStackTrace(new PrintWriter(sw));
+        writer.println(sw.toString());
+        writer.close();
+
+        // app_process, dalvikvm, and dvz don't propagate exit codes, so this doesn't matter
+        System.exit(-1);
+    }
+
+    private static String invokeMethod(Method method, Object[] arguments) throws IOException, IllegalAccessException,
+                    IllegalArgumentException, InvocationTargetException {
+        method.setAccessible(true);
+        Object returnObject = method.invoke(null, arguments);
+
+        Class<?> returnClass = method.getReturnType();
+        if (returnClass.getName().equals("Ljava.lang.Void;")) {
+            // I hear an ancient voice, whispering from the Void, and it chills my lightless heart...
+            return null;
+        }
+
+        String output = "";
+        try {
+            output = GSON.toJson(returnClass.cast(returnObject));
+        } catch (Exception ex) {
+            output = GSON.toJson(returnObject);
+        }
+
+        return output;
+    }
+
+    private static void showUsage() {
+        System.out.println("Usage: export CLASSPATH=/data/local/od.zip; app_process /system/bin org.cf.driver.OracleDriver <class> <method> [<parameter type>:<parameter value json>]");
+        System.out.println("       export CLASSPATH=/data/local/od.zip; app_process /system/bin org.cf.driver.OracleDriver @<json file>");
+    }
+
+    public static void main(String[] args) {
+        boolean multipleTargets = args.length < 2 && args[0].startsWith("@");
+        if (args.length < 1 && !multipleTargets) {
+            showUsage();
+            System.exit(-1);
+        }
+
+        try {
+            StackSpoofer.init();
+        } catch (NumberFormatException | IOException e) {
+            die("Error parsing stack spoof info", e);
+        }
+
+        List<InvocationTarget> targets = null;
+        try {
+            targets = TargetParser.parse(args, GSON);
+        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IOException e) {
+            die("Unable to parse targets", e);
+        }
+
+        String output = null;
+        if (!multipleTargets) {
+            InvocationTarget target = targets.get(0);
+            try {
+                output = invokeMethod(target.getMethod(), target.getArguments());
+            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | IOException e) {
+                die("Error executing '" + target.getMethod() + "' with " + target.getArgumentsString(), e);
+            }
+
+            if (output != null) {
+                System.out.println(OUTPUT_HEADER + output);
+            }
+        } else {
+            Map<String, String[]> idToOutput = new HashMap<String, String[]>();
+            for (InvocationTarget target : targets) {
+                String status;
+                try {
+                    output = invokeMethod(target.getMethod(), target.getArguments());
+                    status = "success";
+                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | IOException e) {
+                    StringBuilder sb = new StringBuilder("Error executing '");
+                    sb.append(target.getMethod()).append("' with ").append(target.getArgumentsString()).append('\n');
+                    StringWriter sw = new StringWriter();
+                    e.printStackTrace(new PrintWriter(sw));
+                    sb.append(sw.getBuffer());
+                    output = sb.toString();
+                    status = "failure";
+                }
+                idToOutput.put(target.getId(), new String[] { status, output });
+            }
+
+            String json = GSON.toJson(idToOutput);
+            try {
+                FileUtils.writeFile(OUTPUT_FILE, json);
+            } catch (FileNotFoundException | UnsupportedEncodingException e) {
+                die("Unable to write output to " + OUTPUT_FILE, e);
+            }
+
+            System.out.println(OUTPUT_HEADER + "success");
+        }
+    }
+}

data/driver/src/main/java/org/cf/oracle/FileUtils.java

@@ -0,0 +1,35 @@
+package org.cf.oracle;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+
+public class FileUtils {
+
+    public static String readFile(String fileName) throws IOException {
+        FileInputStream fis = new FileInputStream(fileName);
+        BufferedReader in = new BufferedReader(new InputStreamReader(fis, "UTF-8"));
+
+        StringBuilder sb = new StringBuilder();
+        while (in.ready()) {
+            String line = in.readLine();
+            sb.append(line).append('\n');
+        }
+        in.close();
+        fis.close();
+
+        return sb.toString();
+    }
+
+    public static void writeFile(String fileName, String contents) throws FileNotFoundException,
+                    UnsupportedEncodingException {
+        PrintWriter out = new PrintWriter(fileName, "UTF-8");
+        out.write(contents);
+        out.close();
+    }
+
+}

data/driver/src/main/java/org/cf/oracle/StackSpoofer.java

@@ -0,0 +1,42 @@
+package org.cf.oracle;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+public class StackSpoofer {
+
+    private static List<StackTraceElement> stack = new LinkedList<StackTraceElement>();
+
+    private static void addElement(String declaringClass, String methodName, String fileName, int lineNumber) {
+        stack.add(new StackTraceElement(declaringClass, methodName, fileName, lineNumber));
+    }
+
+    static void init() throws NumberFormatException, IOException {
+        // <declaring class> <method name> <filename> <line number>
+        File f = new File("stackspoof.cfg");
+        if (!f.exists()) {
+            return;
+        }
+
+        BufferedReader in = new BufferedReader(new FileReader(f));
+        while (in.ready()) {
+            String s = in.readLine().trim();
+            if (s.startsWith("//") || s.startsWith("#")) {
+                // Comment
+                continue;
+            }
+            String[] params = s.split(" ");
+            addElement(params[0], params[1], params[2], Integer.parseInt(params[3]));
+        }
+        in.close();
+    }
+
+    public static StackTraceElement[] getStackTrace() {
+        return stack.toArray(new StackTraceElement[stack.size()]);
+    }
+
+}

data/driver/src/main/java/org/cf/oracle/options/InvocationTarget.java

@@ -0,0 +1,40 @@
+package org.cf.oracle.options;
+
+import java.lang.reflect.Method;
+
+public class InvocationTarget {
+
+    private final Object[] arguments;
+    private final String[] argumentStrings;
+    private final String id;
+    private final Method method;
+
+    InvocationTarget(String id, String[] argumentStrings, Object[] arguments, Method method) {
+        this.id = id;
+        this.argumentStrings = argumentStrings;
+        this.arguments = arguments;
+        this.method = method;
+    }
+
+    public Object[] getArguments() {
+        return arguments;
+    }
+
+    public String getArgumentsString() {
+        StringBuilder sb = new StringBuilder();
+        for (String argumentString : argumentStrings) {
+            sb.append('\'').append(argumentString).append("' ");
+        }
+
+        return sb.toString().trim();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+}

data/driver/src/main/java/org/cf/oracle/options/TargetParser.java

@@ -0,0 +1,121 @@
+package org.cf.oracle.options;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.cf.oracle.FileUtils;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.JsonSyntaxException;
+
+public class TargetParser {
+
+    private static InvocationTarget buildTarget(Gson gson, String className, String methodName, String... args)
+                    throws ClassNotFoundException, NoSuchMethodException, SecurityException {
+        return buildTarget(gson, "", className, methodName, args);
+    }
+
+    private static InvocationTarget buildTarget(Gson gson, String id, String className, String methodName,
+                    String... args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
+        Class<?>[] parameterTypes = new Class[args.length];
+        Object[] methodArguments = new Object[parameterTypes.length];
+        for (int i = 0; i < parameterTypes.length; i++) {
+            String[] parts = args[i].split(":", 2);
+            parameterTypes[i] = smaliToJavaClass(parts[0]);
+            if (parts.length == 1) {
+                methodArguments[i] = null;
+            } else {
+                String jsonValue = parts[1];
+                if (parameterTypes[i] == String.class) {
+                    try {
+                        // Normalizing strings to byte[] avoids escaping ruby, bash, adb shell, and java
+                        byte[] stringBytes = (byte[]) gson.fromJson(jsonValue, Class.forName("[B"));
+                        methodArguments[i] = new String(stringBytes);
+                    } catch (JsonSyntaxException ex) {
+                        // Possibly not using byte array format for string (good luck)
+                        methodArguments[i] = jsonValue;
+                    }
+                } else {
+                    // System.out.println("Parsing: " + itemJson + " as " + paramTypes[i]);
+                    methodArguments[i] = gson.fromJson(jsonValue, parameterTypes[i]);
+                }
+            }
+        }
+
+        Class<?> methodClass = Class.forName(className);
+        Method method = methodClass.getDeclaredMethod(methodName, parameterTypes);
+
+        return new InvocationTarget(id, args, methodArguments, method);
+    }
+
+    private static List<InvocationTarget> loadTargetsFromFile(Gson gson, String fileName) throws IOException,
+                    ClassNotFoundException, NoSuchMethodException, SecurityException {
+        String targetJson = FileUtils.readFile(fileName);
+        JsonArray targetItems = new JsonParser().parse(targetJson).getAsJsonArray();
+        // JsonArray targetItems = json.getAsJsonArray();
+        List<InvocationTarget> targets = new LinkedList<InvocationTarget>();
+        for (JsonElement element : targetItems) {
+            JsonObject targetItem = element.getAsJsonObject();
+            String id = targetItem.get("id").getAsString();
+            String className = targetItem.get("className").getAsString();
+            String methodName = targetItem.get("methodName").getAsString();
+            JsonArray argumentsJson = targetItem.get("arguments").getAsJsonArray();
+            String[] arguments = new String[argumentsJson.size()];
+            for (int i = 0; i < arguments.length; i++) {
+                arguments[i] = argumentsJson.get(i).getAsString();
+            }
+
+            InvocationTarget target = buildTarget(gson, id, className, methodName, arguments);
+            targets.add(target);
+        }
+
+        return targets;
+    }
+
+    private static Class<?> smaliToJavaClass(String className) throws ClassNotFoundException {
+        if (className.equals("I")) {
+            return int.class;
+        } else if (className.equals("V")) {
+            return void.class;
+        } else if (className.equals("Z")) {
+            return boolean.class;
+        } else if (className.equals("B")) {
+            return byte.class;
+        } else if (className.equals("S")) {
+            return short.class;
+        } else if (className.equals("J")) {
+            return long.class;
+        } else if (className.equals("C")) {
+            return char.class;
+        } else if (className.equals("F")) {
+            return float.class;
+        } else if (className.equals("D")) {
+            return double.class;
+        } else {
+            return Class.forName(className);
+        }
+    }
+
+    public static List<InvocationTarget> parse(String[] args, Gson gson) throws ClassNotFoundException,
+                    NoSuchMethodException, SecurityException, IOException {
+        if (args[0].startsWith("@")) {
+            String fileName = args[0].substring(1);
+
+            return loadTargetsFromFile(gson, fileName);
+        } else {
+            InvocationTarget target = buildTarget(gson, args[0], args[1], Arrays.copyOfRange(args, 2, args.length));
+            List<InvocationTarget> targets = new LinkedList<InvocationTarget>();
+            targets.add(target);
+
+            return targets;
+        }
+    }
+
+}