Fix Mygod/VPNHotspot#515

Mygod · Mygod · commit fe9f806d0810 · 2023-10-18T22:59:02.000-04:00
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -28,11 +28,12 @@ android {
             proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
         }
     }
+    buildFeatures.buildConfig = true
 }
 
 dependencies {
     implementation(project(":lib"))
-    implementation("androidx.activity:activity:1.7.2")
+    implementation("androidx.activity:activity:1.8.0")
     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.2")
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test:runner:1.5.2")
diff --git a/app/src/main/java/be/mygod/librootkotlinx/demo/App.kt b/app/src/main/java/be/mygod/librootkotlinx/demo/App.kt
@@ -2,6 +2,8 @@ package be.mygod.librootkotlinx.demo
 
 import android.app.Application
 import android.util.Log
+import be.mygod.librootkotlinx.AppProcess
+import be.mygod.librootkotlinx.Logger
 import be.mygod.librootkotlinx.RootServer
 import be.mygod.librootkotlinx.RootSession
 import kotlinx.coroutines.DelicateCoroutinesApi
@@ -19,7 +21,14 @@ class App : Application() {
         // simply initialize a global instance, this is a very lightweight operation
         rootManager = object : RootSession() {
             override val timeout get() = TimeUnit.SECONDS.toMillis(5)
-            override suspend fun initServer(server: RootServer) = server.init(this@App)
+            override suspend fun initServer(server: RootServer) {
+                if (BuildConfig.DEBUG) Logger.me = object : Logger {
+                    override fun d(m: String?, t: Throwable?) {
+                        Log.d("RootServer", m, t)
+                    }
+                }
+                server.init(this@App, AppProcess.shouldRelocateHeuristics)
+            }
         }
         Log.d("App", "init")
     }
diff --git a/app/src/main/java/be/mygod/librootkotlinx/demo/MainActivity.kt b/app/src/main/java/be/mygod/librootkotlinx/demo/MainActivity.kt
@@ -1,23 +1,35 @@
 package be.mygod.librootkotlinx.demo
 
 import android.os.Bundle
+import android.os.Process
+import android.text.method.ScrollingMovementMethod
 import android.widget.TextView
 import androidx.activity.ComponentActivity
 import androidx.lifecycle.lifecycleScope
-import be.mygod.librootkotlinx.ParcelableInt
 import be.mygod.librootkotlinx.ParcelableString
 import be.mygod.librootkotlinx.RootCommand
 import be.mygod.librootkotlinx.RootCommandChannel
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.produce
 import kotlinx.coroutines.channels.toList
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
 
 class MainActivity : ComponentActivity() {
     @Parcelize
-    class GetRoot : RootCommand<ParcelableInt> {
-        override suspend fun execute() = ParcelableInt(android.os.Process.myUid())
+    class SimpleTest : RootCommand<ParcelableString> {
+        override suspend fun execute() = ParcelableString("uid: ${Process.myUid()}\n" + withContext(Dispatchers.IO) {
+            // try to execute a restricted subprocess command
+            val process = ProcessBuilder("/system/bin/iptables", "-L", "INPUT").start()
+            var output = process.inputStream.reader().readText()
+            when (val exit = process.waitFor()) {
+                0 -> { }
+                else -> output += "Process exited with $exit".toByteArray()
+            }
+            output
+        })
     }
 
     @Parcelize
@@ -31,13 +43,14 @@ class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+        val text = findViewById<TextView>(android.R.id.text1)
+        text.movementMethod = ScrollingMovementMethod()
         lifecycleScope.launch {
-            findViewById<TextView>(android.R.id.text1).text = try {
-                val result = App.rootManager.use {
-                    it.execute(GetRoot()).value.toString() + "\n" +
-                            it.create(ChannelDemo(), lifecycleScope).toList().joinToString { it.value }
+            text.text = try {
+                App.rootManager.use {
+                    it.execute(SimpleTest()).value + '\n' + it.create(ChannelDemo(), lifecycleScope).toList()
+                        .joinToString { it.value }
                 }
-                "Got result from root: $result"
             } catch (e: Exception) {
                 e.printStackTrace()
                 e.stackTraceToString()
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
@@ -5,5 +5,5 @@
     android:layout_height="match_parent"
     android:padding="16dp"
     android:id="@android:id/text1"
-    tools:context=".MainActivity">
-</TextView>
+    android:scrollbars="vertical"
+    tools:context=".MainActivity" />
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,8 +1,8 @@
 plugins {
-    val androidGradleVersion = "8.1.1"
+    val androidGradleVersion = "8.1.2"
     id("com.android.application") version androidGradleVersion apply false
     id("com.android.library") version androidGradleVersion apply false
-    id("com.github.ben-manes.versions") version "0.47.0"
+    id("com.github.ben-manes.versions") version "0.49.0"
     id("org.jetbrains.kotlin.android") version "1.9.10" apply false
 }
 
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
@@ -83,7 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
diff --git a/lib/consumer-rules.pro b/lib/consumer-rules.pro
@@ -1,5 +1,5 @@
 -if public class be.mygod.librootkotlinx.RootServer {
-    private void doInit(android.content.Context, boolean, java.lang.String);
+    private void doInit(android.content.Context, boolean, java.lang.String, java.lang.String);
 }
 -keep class be.mygod.librootkotlinx.RootServer {
     public static void main(java.lang.String[]);
diff --git a/lib/src/main/java/be/mygod/librootkotlinx/AppProcess.kt b/lib/src/main/java/be/mygod/librootkotlinx/AppProcess.kt
@@ -3,6 +3,7 @@ package be.mygod.librootkotlinx
 import android.content.Context
 import android.os.Build
 import android.os.Debug
+import android.system.Os
 import androidx.annotation.RequiresApi
 import java.io.File
 import java.io.IOException
@@ -63,21 +64,20 @@ object AppProcess {
         throw IllegalArgumentException("No valid linker section found")
     }
 
-    val myExe get() = try {
+    val myExe get() = "/proc/${Os.getpid()}/exe"
+    val myExeCanonical get() = try {
         File("/proc/self/exe").canonicalPath.also { require(!it.startsWith("/proc/")) { it } }
     } catch (e: Exception) {
-        Logger.me.i("warning: couldn't resolve self exe", e)
+        Logger.me.d("warning: couldn't resolve self exe", e)
         "/system/bin/app_process"
     }
-    @Deprecated("myExe is now always canonical", ReplaceWith("myExe"))
-    val myExeCanonical get() = myExe
 
     /**
      * Try to guess whether enabling relocation would work best.
      * It seems some Android 5-7 devices give random permission denials without relocation.
      * See also VPNHotspot#173.
      */
-    val shouldRelocateHeuristics get() = Build.VERSION.SDK_INT < 26 || myExe.startsWith("/data/")
+    val shouldRelocateHeuristics get() = Build.VERSION.SDK_INT < 26 || myExeCanonical.startsWith("/data/")
 
     /**
      * To workaround Samsung's stupid kernel patch that prevents exec, we need to relocate exe outside of /data.
@@ -98,7 +98,7 @@ object AppProcess {
             val ldConfig = "$apexPath/etc/ld.config.txt"
             val masterLdConfig = genericLdConfigFilePath
             val section = try {
-                File(masterLdConfig).useLines { findLinkerSection(it, myExe) }
+                File(masterLdConfig).useLines { findLinkerSection(it, myExeCanonical) }
             } catch (e: Exception) {
                 Logger.me.w("Failed to locate system section", e)
                 "system"
diff --git a/lib/src/main/java/be/mygod/librootkotlinx/RootServer.kt b/lib/src/main/java/be/mygod/librootkotlinx/RootServer.kt
@@ -10,10 +10,48 @@ import android.system.Os
 import android.system.OsConstants
 import androidx.collection.LongSparseArray
 import androidx.collection.valueIterator
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.*
-import java.io.*
-import java.util.*
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ClosedSendChannelException
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.channels.onClosed
+import kotlinx.coroutines.channels.onFailure
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
+import java.io.BufferedReader
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.io.EOFException
+import java.io.File
+import java.io.FileDescriptor
+import java.io.FileNotFoundException
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.NotSerializableException
+import java.io.ObjectInputStream
+import java.io.ObjectOutputStream
+import java.io.ObjectStreamClass
+import java.util.UUID
 import java.util.concurrent.CountDownLatch
 import kotlin.system.exitProcess
 
@@ -131,10 +169,9 @@ class RootServer {
             Logger.me.w(line)
         }
     }
-    private fun doInit(context: Context, shouldRelocate: Boolean, niceName: String) {
+    private fun doInit(context: Context, shouldRelocate: Boolean, niceName: String,
+                       appProcess: String = AppProcess.myExe) {
         try {
-            if (AppProcess.hasStartupAgents(context)) Logger.me.w("JVMTI agent is enabled. Please enable the " +
-                    "'Always install with package manager' option in Android Studio.")
             val (reader, writer) = try {
                 process = ProcessBuilder("su").start()
                 val token1 = UUID.randomUUID().toString()
@@ -164,12 +201,19 @@ class RootServer {
                         relocated, niceName) + " $token2")
                     script.toString()
                 } else {
-                    AppProcess.launchString(context.packageCodePath, RootServer::class.java.name, AppProcess.myExe,
+                    AppProcess.launchString(context.packageCodePath, RootServer::class.java.name, appProcess,
                         niceName) + " $token2\n"
                 })
                 writer.flush()
                 reader.lookForToken(token2) // wait for ready signal
             } catch (e: Exception) {
+                if (appProcess == AppProcess.myExe && e is EOFException) try {
+                    doInit(context, shouldRelocate, niceName, AppProcess.myExeCanonical)
+                    Logger.me.d("Launched from fallback mode", e)
+                    return
+                } catch (e2: Exception) {
+                    throw e2.apply { addSuppressed(e) }
+                }
                 throw LaunchException(e)
             }
             output = writer
@@ -222,6 +266,8 @@ class RootServer {
     @OptIn(DelicateCoroutinesApi::class)
     suspend fun init(context: Context, shouldRelocate: Boolean = false,
                      niceName: String = "${context.packageName}:root") {
+        if (AppProcess.hasStartupAgents(context)) Logger.me.w("JVMTI agent is enabled. Please enable the " +
+                "'Always install with package manager' option in Android Studio.")
         withContext(Dispatchers.IO) { doInit(context, shouldRelocate, niceName) }
         callbackListenerExit = GlobalScope.async(Dispatchers.IO) {
             val errorReader = async(Dispatchers.IO) {

Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,12 @@ android {`
`28`	`28`	`proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")`
`29`	`29`	`}`
`30`	`30`	`}`
	`31`	`+ buildFeatures.buildConfig = true`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`dependencies {`
`34`	`35`	`implementation(project(":lib"))`
`35`		`- implementation("androidx.activity:activity:1.7.2")`
	`36`	`+ implementation("androidx.activity:activity:1.8.0")`
`36`	`37`	`implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.2")`
`37`	`38`	`testImplementation("junit:junit:4.13.2")`
`38`	`39`	`androidTestImplementation("androidx.test:runner:1.5.2")`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`-if public class be.mygod.librootkotlinx.RootServer {`
`2`		`- private void doInit(android.content.Context, boolean, java.lang.String);`
	`2`	`+ private void doInit(android.content.Context, boolean, java.lang.String, java.lang.String);`
`3`	`3`	`}`
`4`	`4`	`-keep class be.mygod.librootkotlinx.RootServer {`
`5`	`5`	`public static void main(java.lang.String[]);`