Add bin/ to gitignore and start using tags/releases

Update build version
Merge pull request #15 from TheCjw/master
2026-03-25 06:49:45 +08:00 · 2016-01-26 10:18:42 -05:00 · 2016-01-26 10:18:42 -05:00 · 2016-01-26 10:13:03 -05:00 · 2016-01-26 15:57:57 +08:00 · 2016-01-20 12:52:48 -05:00
6 changed files with 193 additions and 42 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 *.iml
+/bin/
 app/build/
 app/src/main/bin/
 app/src/main/gen/
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -1,14 +1,14 @@
 apply plugin: 'com.android.application'

 android {
-    compileSdkVersion 20
-    buildToolsVersion '20.0.0'
+    compileSdkVersion 22
+    buildToolsVersion '22.0.1'
    defaultConfig {
        applicationId 'just.trust.me'
        minSdkVersion 16
-        targetSdkVersion 20
-        versionCode 1
-        versionName '1.0'
+        targetSdkVersion 22
+        versionCode 2
+        versionName '.2'
    }

    buildTypes {
--- a/app/src/main/java/just/trust/me/Main.java
+++ b/app/src/main/java/just/trust/me/Main.java
@@ -1,6 +1,8 @@
 package just.trust.me;

+import android.content.Context;
 import android.net.http.SslError;
+import android.util.Log;
 import android.webkit.SslErrorHandler;
 import android.webkit.WebView;

@@ -8,6 +10,7 @@ import java.io.IOException;
 import java.net.Socket;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
+import java.util.List;

 import java.security.SecureRandom;
 import java.security.KeyStore;
@@ -51,10 +54,16 @@ import static de.robv.android.xposed.XposedHelpers.findClass;

 public class Main implements IXposedHookLoadPackage {

+    private static final String TAG = "JustTrustMe";
+    String currentPackageName = "";
+
    public void handleLoadPackage(final LoadPackageParam lpparam) throws Throwable {
+
+        currentPackageName = lpparam.packageName;
        /* Apache Hooks */
        /* external/apache-http/src/org/apache/http/impl/client/DefaultHttpClient.java */
        /* public DefaultHttpClient() */
+        Log.d(TAG, "Hooking DefaultHTTPClient for: " + currentPackageName);
        findAndHookConstructor(DefaultHttpClient.class, new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
@@ -66,22 +75,24 @@ public class Main implements IXposedHookLoadPackage {

        /* external/apache-http/src/org/apache/http/impl/client/DefaultHttpClient.java */
        /* public DefaultHttpClient(HttpParams params) */
+        Log.d(TAG, "Hooking DefaultHTTPClient(HttpParams) for: " + currentPackageName);
        findAndHookConstructor(DefaultHttpClient.class, HttpParams.class, new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {

-                setObjectField(param.thisObject, "defaultParams", (HttpParams)param.args[0]);
+                setObjectField(param.thisObject, "defaultParams", (HttpParams) param.args[0]);
                setObjectField(param.thisObject, "connManager", getSCCM());
            }
        });

        /* external/apache-http/src/org/apache/http/impl/client/DefaultHttpClient.java */
        /* public DefaultHttpClient(ClientConnectionManager conman, HttpParams params) */
+        Log.d(TAG, "Hooking DefaultHTTPClient(ClientConnectionManager, HttpParams) for: " + currentPackageName);
        findAndHookConstructor(DefaultHttpClient.class, ClientConnectionManager.class, HttpParams.class, new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {

-                HttpParams params = (HttpParams)param.args[1];
+                HttpParams params = (HttpParams) param.args[1];

                setObjectField(param.thisObject, "defaultParams", params);
                setObjectField(param.thisObject, "connManager", getCCM(param.args[0], params));
@@ -90,44 +101,48 @@ public class Main implements IXposedHookLoadPackage {

        /* external/apache-http/src/org/apache/http/conn/ssl/SSLSocketFactory.java */
        /* public SSLSocketFactory( ... ) */
+        Log.d(TAG, "Hooking SSLSocketFactory(String, KeyStore, String, KeyStore) for: " + currentPackageName);
        findAndHookConstructor(SSLSocketFactory.class, String.class, KeyStore.class, String.class, KeyStore.class,
-                               SecureRandom.class, HostNameResolver.class, new XC_MethodHook() {
-            @Override
-            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
+                SecureRandom.class, HostNameResolver.class, new XC_MethodHook() {
+                    @Override
+                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {

-                String algorithm = (String)param.args[0];
-                KeyStore keystore = (KeyStore)param.args[1];
-                String keystorePassword = (String)param.args[2];
-                SecureRandom random = (SecureRandom)param.args[4];
+                        String algorithm = (String) param.args[0];
+                        KeyStore keystore = (KeyStore) param.args[1];
+                        String keystorePassword = (String) param.args[2];
+                        SecureRandom random = (SecureRandom) param.args[4];

-                KeyManager[] keymanagers = null;
-                TrustManager[] trustmanagers = null;
+                        KeyManager[] keymanagers = null;
+                        TrustManager[] trustmanagers = null;

-                if (keystore != null) {
-                    keymanagers = (KeyManager[])callStaticMethod(SSLSocketFactory.class, "createKeyManagers", keystore, keystorePassword);
-                }
+                        if (keystore != null) {
+                            keymanagers = (KeyManager[]) callStaticMethod(SSLSocketFactory.class, "createKeyManagers", keystore, keystorePassword);
+                        }

-                trustmanagers = new TrustManager[]{new ImSureItsLegitTrustManager()};
+                        trustmanagers = new TrustManager[]{new ImSureItsLegitTrustManager()};

-                setObjectField(param.thisObject, "sslcontext", SSLContext.getInstance(algorithm));
-                callMethod(getObjectField(param.thisObject, "sslcontext"), "init", keymanagers, trustmanagers, random);
-                setObjectField(param.thisObject, "socketfactory",
-                                                    callMethod(getObjectField(param.thisObject, "sslcontext"), "getSocketFactory"));
-            }
+                        setObjectField(param.thisObject, "sslcontext", SSLContext.getInstance(algorithm));
+                        callMethod(getObjectField(param.thisObject, "sslcontext"), "init", keymanagers, trustmanagers, random);
+                        setObjectField(param.thisObject, "socketfactory",
+                                callMethod(getObjectField(param.thisObject, "sslcontext"), "getSocketFactory"));
+                    }
+
+                });

-        });

        /* external/apache-http/src/org/apache/http/conn/ssl/SSLSocketFactory.java */
        /* public static SSLSocketFactory getSocketFactory() */
+        Log.d(TAG, "Hooking static SSLSocketFactory(String, KeyStore, String, KeyStore) for: " + currentPackageName);
        findAndHookMethod("org.apache.http.conn.ssl.SSLSocketFactory", lpparam.classLoader, "getSocketFactory", new XC_MethodReplacement() {
            @Override
            protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
-                return (SSLSocketFactory)newInstance(SSLSocketFactory.class);
+                return (SSLSocketFactory) newInstance(SSLSocketFactory.class);
            }
        });

        /* external/apache-http/src/org/apache/http/conn/ssl/SSLSocketFactory.java */
        /* public boolean isSecure(Socket) */
+        Log.d(TAG, "Hooking SSLSocketFactory(Socket) for: " + currentPackageName);
        findAndHookMethod("org.apache.http.conn.ssl.SSLSocketFactory", lpparam.classLoader, "isSecure", Socket.class, new XC_MethodReplacement() {
            @Override
            protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
@@ -138,14 +153,18 @@ public class Main implements IXposedHookLoadPackage {
        /* JSSE Hooks */
        /* libcore/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java */
        /* public final TrustManager[] getTrustManager() */
-                findAndHookMethod("javax.net.ssl.TrustManagerFactory", lpparam.classLoader, "getTrustManagers", new XC_MethodHook() {
+        Log.d(TAG, "Hooking TrustManagerFactory.getTrustManagers() for: " + currentPackageName);
+        findAndHookMethod("javax.net.ssl.TrustManagerFactory", lpparam.classLoader, "getTrustManagers", new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
-                                Class<?> cls = findClass("com.android.org.conscrypt.TrustManagerImpl", lpparam.classLoader);

-                                TrustManager[] managers = (TrustManager[])param.getResult();
-                                if(managers.length > 0 && cls.isInstance(managers[0]))
-                                        return;
+                if (hasTrustManagerImpl()) {
+                    Class<?> cls = findClass("com.android.org.conscrypt.TrustManagerImpl", lpparam.classLoader);
+
+                    TrustManager[] managers = (TrustManager[])param.getResult();
+                    if(managers.length > 0 && cls.isInstance(managers[0]))
+                        return;
+                }

                param.setResult(new TrustManager[]{new ImSureItsLegitTrustManager()});
            }
@@ -153,6 +172,7 @@ public class Main implements IXposedHookLoadPackage {

        /* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
        /* public void setDefaultHostnameVerifier(HostnameVerifier) */
+        Log.d(TAG, "Hooking HttpsURLConnection.setDefaultHostnameVerifier for: " + currentPackageName);
        findAndHookMethod("javax.net.ssl.HttpsURLConnection", lpparam.classLoader, "setDefaultHostnameVerifier",
                            HostnameVerifier.class, new XC_MethodReplacement() {
            @Override
@@ -163,6 +183,7 @@ public class Main implements IXposedHookLoadPackage {

        /* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
        /* public void setSSLSocketFactory(SSLSocketFactory) */
+        Log.d(TAG, "Hooking HttpsURLConnection.setSSLSocketFactory for: " + currentPackageName);
        findAndHookMethod("javax.net.ssl.HttpsURLConnection", lpparam.classLoader, "setSSLSocketFactory", javax.net.ssl.SSLSocketFactory.class,
                            new XC_MethodReplacement() {
            @Override
@@ -173,6 +194,7 @@ public class Main implements IXposedHookLoadPackage {

        /* libcore/luni/src/main/java/javax/net/ssl/HttpsURLConnection.java */
        /* public void setHostnameVerifier(HostNameVerifier) */
+        Log.d(TAG, "Hooking HttpsURLConnection.setHostnameVerifier for: " + currentPackageName);
        findAndHookMethod("javax.net.ssl.HttpsURLConnection", lpparam.classLoader, "setHostnameVerifier", HostnameVerifier.class,
                            new XC_MethodReplacement() {
            @Override
@@ -185,6 +207,8 @@ public class Main implements IXposedHookLoadPackage {
        /* WebView Hooks */
        /* frameworks/base/core/java/android/webkit/WebViewClient.java */
        /* public void onReceivedSslError(Webview, SslErrorHandler, SslError) */
+        Log.d(TAG, "Hooking WebViewClient.onReceivedSslError(WebView, SslErrorHandler, SslError) for: " + currentPackageName);
+
        findAndHookMethod("android.webkit.WebViewClient", lpparam.classLoader, "onReceivedSslError",
                              WebView.class, SslErrorHandler.class, SslError.class, new XC_MethodReplacement() {
            @Override
@@ -196,6 +220,8 @@ public class Main implements IXposedHookLoadPackage {

        /* frameworks/base/core/java/android/webkit/WebViewClient.java */
        /* public void onReceivedError(WebView, int, String, String) */
+        Log.d(TAG, "Hooking WebViewClient.onReceivedSslError(WebView, int, string, string) for: " + currentPackageName);
+
        findAndHookMethod("android.webkit.WebViewClient", lpparam.classLoader, "onReceivedError",
                            WebView.class, int.class, String.class, String.class, new XC_MethodReplacement() {
            @Override
@@ -204,18 +230,52 @@ public class Main implements IXposedHookLoadPackage {
            }
        });

-                /* external/conscrypt/src/platform/java/org/conscrypt/TrustManagerImpl.java#217 */
-                /* public List<X509Certificate> checkServerTrusted(X509Certificate[] chain, String authType, String host) throws CertificateException */
-                findAndHookMethod("com.android.org.conscrypt.TrustManagerImpl", lpparam.classLoader, "checkServerTrusted", X509Certificate[].class, String.class, String.class, new XC_MethodReplacement() {
-                        @Override
-                        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
-                                ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
-                                return list;
-                        }
-                });
+        // Multi-dex support: https://github.com/rovo89/XposedBridge/issues/30#issuecomment-68486449
+        findAndHookMethod("android.app.Application",
+            lpparam.classLoader,
+            "attach",
+            Context.class,
+            new XC_MethodHook() {
+                @Override
+                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
+                    // Hook OkHttp or third party libraries.
+                    Context context = (Context) param.args[0];
+                    processOkHttp(context.getClassLoader());
+                }
+            }
+        );
+
+        /* Only for newer devices should we try to hook TrustManagerImpl */
+        if (hasTrustManagerImpl()) {
+
+            /* external/conscrypt/src/platform/java/org/conscrypt/TrustManagerImpl.java#217 */
+            /* public List<X509Certificate> checkServerTrusted(X509Certificate[] chain,
+                                    String authType, String host) throws CertificateException */
+            Log.d(TAG, "Hooking com.android.org.conscrypt.TrustManagerImpl.checkServerTrusted(X509Certificate[]) for: " + currentPackageName);
+            findAndHookMethod("com.android.org.conscrypt.TrustManagerImpl", lpparam.classLoader,
+                                "checkServerTrusted", X509Certificate[].class, String.class,
+                                String.class, new XC_MethodReplacement() {
+                @Override
+                protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
+                    ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
+                    return list;
+                }
+            });
+        }
    } // End Hooks

    /* Helpers */
+    // Check for TrustManagerImpl class
+    public boolean hasTrustManagerImpl() {
+
+        try {
+            Class.forName("com.android.org.conscrypt.TrustManagerImpl");
+        } catch(ClassNotFoundException e) {
+            return false;
+        }
+        return true;
+    }
+
    //Create a SingleClientConnManager that trusts everyone!
    public ClientConnectionManager getSCCM() {

@@ -281,6 +341,92 @@ public class Main implements IXposedHookLoadPackage {
        return null;
    }

+    void processOkHttp(ClassLoader classLoader) {
+        /* hooking OKHTTP by SQUAREUP */
+        /* com/squareup/okhttp/CertificatePinner.java available online @ https://github.com/square/okhttp/blob/master/okhttp/src/main/java/com/squareup/okhttp/CertificatePinner.java */
+        /* public void check(String hostname, List<Certificate> peerCertificates) throws SSLPeerUnverifiedException{}*/
+        /* Either returns true or a exception so blanket return true */
+        /* Tested against version 2.5 */
+        Log.d(TAG, "Hooking com.squareup.okhttp.CertificatePinner.check(String,List) (2.5) for: " + currentPackageName);
+
+        try {
+            classLoader.loadClass("com.squareup.okhttp.CertificatePinner");
+            findAndHookMethod("com.squareup.okhttp.CertificatePinner",
+                classLoader,
+                "check",
+                String.class,
+                List.class,
+                new XC_MethodReplacement() {
+                    @Override
+                    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {
+                        return true;
+                }
+            });
+        } catch(ClassNotFoundException e) {
+            // pass
+            Log.d(TAG, "OKHTTP 2.5 not found in "  + currentPackageName  + "-- not hooking");
+        }
+
+        //https://github.com/square/okhttp/blob/parent-3.0.1/okhttp/src/main/java/okhttp3/CertificatePinner.java#L144
+        Log.d(TAG, "Hooking okhttp3.CertificatePinner.check(String,List) (3.x) for: " + currentPackageName);
+
+        try {
+            classLoader.loadClass("okhttp3.CertificatePinner");
+            findAndHookMethod("okhttp3.CertificatePinner",
+                classLoader,
+                "check",
+                String.class,
+                List.class,
+                new XC_MethodReplacement() {
+                    @Override
+                    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {
+                        return null;
+                }
+            });
+        } catch(ClassNotFoundException e) {
+            Log.d(TAG, "OKHTTP 3.x not found in " + currentPackageName + " -- not hooking");
+            // pass
+        }
+
+        //https://github.com/square/okhttp/blob/parent-3.0.1/okhttp/src/main/java/okhttp3/internal/tls/OkHostnameVerifier.java
+        try {
+            classLoader.loadClass("okhttp3.internal.tls.OkHostnameVerifier");
+            findAndHookMethod("okhttp3.internal.tls.OkHostnameVerifier",
+                classLoader,
+                "verify",
+                String.class,
+                javax.net.ssl.SSLSession.class,
+                new XC_MethodReplacement() {
+                    @Override
+                    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {
+                        return true;
+                }
+            });
+        } catch(ClassNotFoundException e) {
+            Log.d(TAG, "OKHTTP 3.x not found in " + currentPackageName + " -- not hooking OkHostnameVerifier.verify(String, SSLSession)");
+            // pass
+        }
+
+        //https://github.com/square/okhttp/blob/parent-3.0.1/okhttp/src/main/java/okhttp3/internal/tls/OkHostnameVerifier.java
+        try {
+            classLoader.loadClass("okhttp3.internal.tls.OkHostnameVerifier");
+            findAndHookMethod("okhttp3.internal.tls.OkHostnameVerifier",
+                classLoader,
+                "verify",
+                String.class,
+                java.security.cert.X509Certificate.class,
+                new XC_MethodReplacement() {
+                    @Override
+                    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {
+                        return true;
+                }
+            });
+        } catch(ClassNotFoundException e) {
+            Log.d(TAG, "OKHTTP 3.x not found in " + currentPackageName + " -- not hooking OkHostnameVerifier.verify(String, X509)(");
+            // pass
+        }
+    }
+
    class ImSureItsLegitTrustManager implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { }
--- a/bin/JustTrustMe.apk
+++ b/bin/JustTrustMe.apk
--- a/build.gradle
+++ b/build.gradle
@@ -5,7 +5,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:1.0.0'
+        classpath 'com.android.tools.build:gradle:1.5.0'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
--- a/build.sh
+++ b/build.sh
@@ -0,0 +1,4 @@
+APK_PATH="bin/JustTrustMe.apk"
+./gradlew assembleRelease && cp app/build/outputs/apk/app-release-unsigned.apk $APK_PATH && signapk $APK_PATH
+
+#adb install -r bin/AndroidVTS.apk
Author	SHA1	Message	Date
Ryan Welton	4c6a404aea	Add bin/ to gitignore and start using tags/releases	2016-01-26 10:18:42 -05:00
Ryan Welton	42edde1359	Update build version	2016-01-26 10:18:42 -05:00
Ryan Welton	8f970f4b75	Merge pull request #15 from TheCjw/master Add support for Multi-DEX	2016-01-26 10:13:03 -05:00
TheCjw	7d34b2e6f0	Merged from upstream, add support for Multi-DEX, Tested on com...	2016-01-26 15:57:57 +08:00
Ryan Welton	41ad183724	Hook the hostnameverifier for okhttp3 as well	2016-01-20 12:52:48 -05:00
Ryan Welton	494f36abd4	Update binary	2016-01-20 12:46:11 -05:00
Ryan Welton	8bcd193afb	Use the correct class loader when checking for the existance of a class	2016-01-20 12:45:32 -05:00
Ryan Welton	2421422722	Add logging about what we are hooking for which package	2016-01-20 12:37:19 -05:00
Ryan Welton	6f108c3a51	Do some better logging to know which class(es) were found and hooked	2016-01-20 12:25:30 -05:00
Ryan Welton	482d1166d1	Add unpinning for okHTP 3.x	2016-01-20 12:21:23 -05:00
Ryan Welton	8cef702156	Update binary	2015-12-14 11:31:15 -05:00
Ryan Welton	b9dacbe2fc	Merge pull request #13 from TheCjw/master Check if com.squareup.okhttp.CertificatePinner class exists before hooking	2015-12-14 11:29:45 -05:00
TheCjw	e737079c7a	use 'com.android.tools.build:gradle:1.5.0'	2015-12-08 14:43:54 +08:00
TheCjw	33e74cfaa6	Check if com.squareup.okhttp.CertificatePinner class exists before hooking.	2015-12-08 12:30:29 +08:00
Ryan Welton	5213b9a713	Update binary	2015-11-17 10:33:37 -05:00
Ryan Welton	34058fe882	Fix missing import	2015-11-17 10:33:28 -05:00
Ryan Welton	de1c225661	Merge pull request #12 from anantshri/patch-1 Added OK HTTP SSL Pinning bypass	2015-11-17 10:21:55 -05:00
Anant Shrivastava	9decbfe65a	Added OK HTTP SSL Pinning bypass OK HTTP by squareup. Tested against version 2.5	2015-11-17 13:30:31 +05:30
Ryan Welton	98f114f884	Update binary	2015-11-05 13:40:10 -05:00
Ryan Welton	47c5d18b58	Add hacky build script	2015-11-05 13:40:01 -05:00
Ryan Welton	7512088fa1	Update binary	2015-11-05 13:37:56 -05:00
Ryan Welton	147d5be8de	Merge pull request #11 from jakev/non_existing_class Check for TrustManagerImpl before hooking	2015-11-05 13:28:41 -05:00
Jake Valletta	b03a28336f	Additional TrustManagerImpl changes for older devices	2015-11-04 20:55:05 -05:00
Jake Valletta	862716fb7f	Fixed issue trying to hook TrustManagerImpl on older APIs Older APIs do not have the TrustManagerImpl class, so this checks if that class is available before attempting to hook.	2015-11-04 20:10:40 -05:00
Ryan Welton	26bc1d8b5a	Merge pull request #9 from jakev/new_bin Updated APK and Gradle build configuration	2015-10-09 11:24:42 -04:00
Jake Valletta	e051920632	Updated APK and Gradle build configuration The tool's source was updated several times, but the APK was never updated. This change brings the APK to the master commit, and updates the 'build.gradle' to build using the API 22 build tools (was using API 20, but that is obsolete now).	2015-10-08 21:29:12 -04:00