Initial commit

app/src/main/java/io/github/a13e300/ksuwebui/MimeUtil.java

@@ -0,0 +1,88 @@
+package io.github.a13e300.ksuwebui;
+
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.net.URLConnection;
+
+class MimeUtil {
+
+    public static String getMimeFromFileName(String fileName) {
+        if (fileName == null) {
+            return null;
+        }
+
+        // Copying the logic and mapping that Chromium follows.
+        // First we check against the OS (this is a limited list by default)
+        // but app developers can extend this.
+        // We then check against a list of hardcoded mime types above if the
+        // OS didn't provide a result.
+        String mimeType = URLConnection.guessContentTypeFromName(fileName);
+
+        if (mimeType != null) {
+            return mimeType;
+        }
+
+        return guessHardcodedMime(fileName);
+    }
+
+    // We should keep this map in sync with the lists under
+    // //net/base/mime_util.cc in Chromium.
+    // A bunch of the mime types don't really apply to Android land
+    // like word docs so feel free to filter out where necessary.
+    private static String guessHardcodedMime(String fileName) {
+        int finalFullStop = fileName.lastIndexOf('.');
+        if (finalFullStop == -1) {
+            return null;
+        }
+
+        final String extension = fileName.substring(finalFullStop + 1).toLowerCase();
+
+        return switch (extension) {
+            case "webm" -> "video/webm";
+            case "mpeg", "mpg" -> "video/mpeg";
+            case "mp3" -> "audio/mpeg";
+            case "wasm" -> "application/wasm";
+            case "xhtml", "xht", "xhtm" -> "application/xhtml+xml";
+            case "flac" -> "audio/flac";
+            case "ogg", "oga", "opus" -> "audio/ogg";
+            case "wav" -> "audio/wav";
+            case "m4a" -> "audio/x-m4a";
+            case "gif" -> "image/gif";
+            case "jpeg", "jpg", "jfif", "pjpeg", "pjp" -> "image/jpeg";
+            case "png" -> "image/png";
+            case "apng" -> "image/apng";
+            case "svg", "svgz" -> "image/svg+xml";
+            case "webp" -> "image/webp";
+            case "mht", "mhtml" -> "multipart/related";
+            case "css" -> "text/css";
+            case "html", "htm", "shtml", "shtm", "ehtml" -> "text/html";
+            case "js", "mjs" -> "application/javascript";
+            case "xml" -> "text/xml";
+            case "mp4", "m4v" -> "video/mp4";
+            case "ogv", "ogm" -> "video/ogg";
+            case "ico" -> "image/x-icon";
+            case "woff" -> "application/font-woff";
+            case "gz", "tgz" -> "application/gzip";
+            case "json" -> "application/json";
+            case "pdf" -> "application/pdf";
+            case "zip" -> "application/zip";
+            case "bmp" -> "image/bmp";
+            case "tiff", "tif" -> "image/tiff";
+            default -> null;
+        };
+    }
+}

app/src/main/java/io/github/a13e300/ksuwebui/SuFilePathHandler.java

@@ -0,0 +1,192 @@
+package io.github.a13e300.ksuwebui;
+
+import android.content.Context;
+import android.util.Log;
+import android.webkit.WebResourceResponse;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.WorkerThread;
+import androidx.webkit.WebViewAssetLoader;
+
+import com.topjohnwu.superuser.Shell;
+import com.topjohnwu.superuser.io.SuFile;
+import com.topjohnwu.superuser.io.SuFileInputStream;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+/**
+ * Handler class to open files from file system by root access
+ * For more information about android storage please refer to
+ * <a href="https://developer.android.com/guide/topics/data/data-storage">Android Developers
+ * Docs: Data and file storage overview</a>.
+ * <p class="note">
+ * To avoid leaking user or app data to the web, make sure to choose {@code directory}
+ * carefully, and assume any file under this directory could be accessed by any web page subject
+ * to same-origin rules.
+ * <p>
+ * A typical usage would be like:
+ * <pre class="prettyprint">
+ * File publicDir = new File(context.getFilesDir(), "public");
+ * // Host "files/public/" in app's data directory under:
+ * // http://appassets.androidplatform.net/public/...
+ * WebViewAssetLoader assetLoader = new WebViewAssetLoader.Builder()
+ *          .addPathHandler("/public/", new InternalStoragePathHandler(context, publicDir))
+ *          .build();
+ * </pre>
+ */
+public final class SuFilePathHandler implements WebViewAssetLoader.PathHandler {
+    private static final String TAG = "SuFilePathHandler";
+
+    /**
+     * Default value to be used as MIME type if guessing MIME type failed.
+     */
+    public static final String DEFAULT_MIME_TYPE = "text/plain";
+
+    /**
+     * Forbidden subdirectories of {@link Context#getDataDir} that cannot be exposed by this
+     * handler. They are forbidden as they often contain sensitive information.
+     * <p class="note">
+     * Note: Any future addition to this list will be considered breaking changes to the API.
+     */
+    private static final String[] FORBIDDEN_DATA_DIRS =
+            new String[] {"/data/data", "/data/system"};
+
+    @NonNull
+    private final File mDirectory;
+
+    private final Shell mShell;
+
+    /**
+     * Creates PathHandler for app's internal storage.
+     * The directory to be exposed must be inside either the application's internal data
+     * directory {@link Context#getDataDir} or cache directory {@link Context#getCacheDir}.
+     * External storage is not supported for security reasons, as other apps with
+     * {@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} may be able to modify the
+     * files.
+     * <p>
+     * Exposing the entire data or cache directory is not permitted, to avoid accidentally
+     * exposing sensitive application files to the web. Certain existing subdirectories of
+     * {@link Context#getDataDir} are also not permitted as they are often sensitive.
+     * These files are ({@code "app_webview/"}, {@code "databases/"}, {@code "lib/"},
+     * {@code "shared_prefs/"} and {@code "code_cache/"}).
+     * <p>
+     * The application should typically use a dedicated subdirectory for the files it intends to
+     * expose and keep them separate from other files.
+     *
+     * @param context {@link Context} that is used to access app's internal storage.
+     * @param directory the absolute path of the exposed app internal storage directory from
+     *                  which files can be loaded.
+     * @throws IllegalArgumentException if the directory is not allowed.
+     */
+    public SuFilePathHandler(@NonNull Context context, @NonNull File directory, Shell rootShell) {
+        try {
+            mDirectory = new File(getCanonicalDirPath(directory));
+            if (!isAllowedInternalStorageDir(context)) {
+                throw new IllegalArgumentException("The given directory \"" + directory
+                        + "\" doesn't exist under an allowed app internal storage directory");
+            }
+            mShell = rootShell;
+        } catch (IOException e) {
+            throw new IllegalArgumentException(
+                    "Failed to resolve the canonical path for the given directory: "
+                            + directory.getPath(), e);
+        }
+    }
+
+    private boolean isAllowedInternalStorageDir(@NonNull Context context) throws IOException {
+        String dir = getCanonicalDirPath(mDirectory);
+
+        for (String forbiddenPath : FORBIDDEN_DATA_DIRS) {
+            if (dir.startsWith(forbiddenPath)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Opens the requested file from the exposed data directory.
+     * <p>
+     * The matched prefix path used shouldn't be a prefix of a real web path. Thus, if the
+     * requested file cannot be found or is outside the mounted directory a
+     * {@link WebResourceResponse} object with a {@code null} {@link InputStream} will be
+     * returned instead of {@code null}. This saves the time of falling back to network and
+     * trying to resolve a path that doesn't exist. A {@link WebResourceResponse} with
+     * {@code null} {@link InputStream} will be received as an HTTP response with status code
+     * {@code 404} and no body.
+     * <p class="note">
+     * The MIME type for the file will be determined from the file's extension using
+     * {@link java.net.URLConnection#guessContentTypeFromName}. Developers should ensure that
+     * files are named using standard file extensions. If the file does not have a
+     * recognised extension, {@code "text/plain"} will be used by default.
+     *
+     * @param path the suffix path to be handled.
+     * @return {@link WebResourceResponse} for the requested file.
+     */
+    @Override
+    @WorkerThread
+    @NonNull
+    public WebResourceResponse handle(@NonNull String path) {
+        try {
+            File file = getCanonicalFileIfChild(mDirectory, path);
+            if (file != null) {
+                InputStream is = openFile(file, mShell);
+                String mimeType = guessMimeType(path);
+                return new WebResourceResponse(mimeType, null, is);
+            } else {
+                Log.e(TAG, String.format(
+                        "The requested file: %s is outside the mounted directory: %s", path,
+                        mDirectory));
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Error opening the requested path: " + path, e);
+        }
+        return new WebResourceResponse(null, null, null);
+    }
+
+    public static String getCanonicalDirPath(@NonNull File file) throws IOException {
+        String canonicalPath = file.getCanonicalPath();
+        if (!canonicalPath.endsWith("/")) canonicalPath += "/";
+        return canonicalPath;
+    }
+
+    public static File getCanonicalFileIfChild(@NonNull File parent, @NonNull String child)
+            throws IOException {
+        String parentCanonicalPath = getCanonicalDirPath(parent);
+        String childCanonicalPath = new File(parent, child).getCanonicalPath();
+        if (childCanonicalPath.startsWith(parentCanonicalPath)) {
+            return new File(childCanonicalPath);
+        }
+        return null;
+    }
+
+    @NonNull
+    private static InputStream handleSvgzStream(@NonNull String path,
+                                                @NonNull InputStream stream) throws IOException {
+        return path.endsWith(".svgz") ? new GZIPInputStream(stream) : stream;
+    }
+
+    public static InputStream openFile(@NonNull File file, @NonNull Shell shell) throws IOException {
+        SuFile suFile = new SuFile(file.getAbsolutePath());
+        suFile.setShell(shell);
+        InputStream fis = SuFileInputStream.open(suFile);
+        return handleSvgzStream(file.getPath(), fis);
+    }
+
+    /**
+     * Use {@link MimeUtil#getMimeFromFileName} to guess MIME type or return the
+     * {@link #DEFAULT_MIME_TYPE} if it can't guess.
+     *
+     * @param filePath path of the file to guess its MIME type.
+     * @return MIME type guessed from file extension or {@link #DEFAULT_MIME_TYPE}.
+     */
+    @NonNull
+    public static String guessMimeType(@NonNull String filePath) {
+        String mimeType = MimeUtil.getMimeFromFileName(filePath);
+        return mimeType == null ? DEFAULT_MIME_TYPE : mimeType;
+    }
+}
+

app/src/main/java/io/github/a13e300/ksuwebui/Util.kt

@@ -0,0 +1,38 @@
+package io.github.a13e300.ksuwebui
+
+import android.util.Log
+import com.topjohnwu.superuser.Shell
+
+
+private const val TAG = "KsuCli"
+
+inline fun <T> withNewRootShell(
+    globalMnt: Boolean = false,
+    block: Shell.() -> T
+): T {
+    return createRootShell(globalMnt).use(block)
+}
+
+fun createRootShell(globalMnt: Boolean = false): Shell {
+    Shell.enableVerboseLogging = BuildConfig.DEBUG
+    val builder = Shell.Builder.create()
+    return try {
+        if (globalMnt) {
+            builder.build("su", "-g")
+        } else {
+            builder.build("su")
+        }
+    } catch (e: Throwable) {
+        Log.w(TAG, "ksu failed: ", e)
+        try {
+            if (globalMnt) {
+                builder.build("su")
+            } else {
+                builder.build("su", "-mm")
+            }
+        } catch (e: Throwable) {
+            Log.e(TAG, "su failed: ", e)
+            builder.build("sh")
+        }
+    }
+}

app/src/main/java/io/github/a13e300/ksuwebui/WebUIActivity.kt

@@ -0,0 +1,99 @@
+package io.github.a13e300.ksuwebui
+
+import android.annotation.SuppressLint
+import android.app.ActivityManager
+import android.os.Build
+import android.os.Bundle
+import android.view.ViewGroup.MarginLayoutParams
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.activity.ComponentActivity
+import androidx.activity.enableEdgeToEdge
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updateLayoutParams
+import androidx.webkit.WebViewAssetLoader
+import com.topjohnwu.superuser.Shell
+import java.io.File
+
+@SuppressLint("SetJavaScriptEnabled")
+class WebUIActivity : ComponentActivity() {
+    private lateinit var webviewInterface: WebViewInterface
+
+    private var rootShell: Shell? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        // Enable edge to edge
+        enableEdgeToEdge()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            window.isNavigationBarContrastEnforced = false
+        }
+
+        super.onCreate(savedInstanceState)
+
+        val moduleId = intent.getStringExtra("id")!!
+        val name = intent.getStringExtra("name")!!
+        if (name.isNotEmpty()) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                @Suppress("DEPRECATION")
+                setTaskDescription(ActivityManager.TaskDescription(name))
+            } else {
+                val taskDescription =
+                    ActivityManager.TaskDescription.Builder().setLabel(name).build()
+                setTaskDescription(taskDescription)
+            }
+        }
+
+        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
+        WebView.setWebContentsDebuggingEnabled(prefs.getBoolean("enable_web_debugging", BuildConfig.DEBUG))
+
+        val moduleDir = "/data/adb/modules/${moduleId}"
+        val webRoot = File("${moduleDir}/webroot")
+        val rootShell = createRootShell(true).also { this.rootShell = it }
+        val webViewAssetLoader = WebViewAssetLoader.Builder()
+            .setDomain("mui.kernelsu.org")
+            .addPathHandler(
+                "/",
+                SuFilePathHandler(this, webRoot, rootShell)
+            )
+            .build()
+
+        val webViewClient = object : WebViewClient() {
+            override fun shouldInterceptRequest(
+                view: WebView,
+                request: WebResourceRequest
+            ): WebResourceResponse? {
+                return webViewAssetLoader.shouldInterceptRequest(request.url)
+            }
+        }
+
+        val webView = WebView(this).apply {
+            ViewCompat.setOnApplyWindowInsetsListener(this) { view, insets ->
+                val inset = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+                view.updateLayoutParams<MarginLayoutParams> {
+                    leftMargin = inset.left
+                    rightMargin = inset.right
+                    topMargin = inset.top
+                    bottomMargin = inset.bottom
+                }
+                return@setOnApplyWindowInsetsListener insets
+            }
+            settings.javaScriptEnabled = true
+            settings.domStorageEnabled = true
+            settings.allowFileAccess = false
+            webviewInterface = WebViewInterface(this@WebUIActivity, this, moduleDir)
+            addJavascriptInterface(webviewInterface, "ksu")
+            setWebViewClient(webViewClient)
+            loadUrl("https://mui.kernelsu.org/index.html")
+        }
+
+        setContentView(webView)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        runCatching { rootShell?.close() }
+    }
+}

app/src/main/java/io/github/a13e300/ksuwebui/WebViewInterface.kt

@@ -0,0 +1,194 @@
+package io.github.a13e300.ksuwebui
+
+import android.app.Activity
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.text.TextUtils
+import android.view.Window
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import android.widget.Toast
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.topjohnwu.superuser.CallbackList
+import com.topjohnwu.superuser.ShellUtils
+import com.topjohnwu.superuser.internal.UiThreadHandler
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.CompletableFuture
+
+class WebViewInterface(
+    val context: Context,
+    private val webView: WebView,
+    private val modDir: String
+) {
+
+    @JavascriptInterface
+    fun exec(cmd: String): String {
+        return withNewRootShell(true) { ShellUtils.fastCmd(this, cmd) }
+    }
+
+    @JavascriptInterface
+    fun exec(cmd: String, callbackFunc: String) {
+        exec(cmd, null, callbackFunc)
+    }
+
+    private fun processOptions(sb: StringBuilder, options: String?) {
+        val opts = if (options == null) JSONObject() else {
+            JSONObject(options)
+        }
+
+        val cwd = opts.optString("cwd")
+        if (!TextUtils.isEmpty(cwd)) {
+            sb.append("cd ${cwd};")
+        }
+
+        opts.optJSONObject("env")?.let { env ->
+            env.keys().forEach { key ->
+                sb.append("export ${key}=${env.getString(key)};")
+            }
+        }
+    }
+
+    @JavascriptInterface
+    fun exec(
+        cmd: String,
+        options: String?,
+        callbackFunc: String
+    ) {
+        val finalCommand = StringBuilder()
+        processOptions(finalCommand, options)
+        finalCommand.append(cmd)
+
+        val result = withNewRootShell(true) {
+            newJob().add(finalCommand.toString()).to(ArrayList(), ArrayList()).exec()
+        }
+        val stdout = result.out.joinToString(separator = "\n")
+        val stderr = result.err.joinToString(separator = "\n")
+
+        val jsCode =
+            "javascript: (function() { try { ${callbackFunc}(${result.code}, ${
+                JSONObject.quote(
+                    stdout
+                )
+            }, ${JSONObject.quote(stderr)}); } catch(e) { console.error(e); } })();"
+        webView.post {
+            webView.loadUrl(jsCode)
+        }
+    }
+
+    @JavascriptInterface
+    fun spawn(command: String, args: String, options: String?, callbackFunc: String) {
+        val finalCommand = StringBuilder()
+
+        processOptions(finalCommand, options)
+
+        if (!TextUtils.isEmpty(args)) {
+            finalCommand.append(command).append(" ")
+            JSONArray(args).let { argsArray ->
+                for (i in 0 until argsArray.length()) {
+                    finalCommand.append(argsArray.getString(i))
+                    finalCommand.append(" ")
+                }
+            }
+        } else {
+            finalCommand.append(command)
+        }
+
+        val shell = createRootShell(true)
+
+        val emitData = fun(name: String, data: String) {
+            val jsCode =
+                "javascript: (function() { try { ${callbackFunc}.${name}.emit('data', ${
+                    JSONObject.quote(
+                        data
+                    )
+                }); } catch(e) { console.error('emitData', e); } })();"
+            webView.post {
+                webView.loadUrl(jsCode)
+            }
+        }
+
+        val stdout = object : CallbackList<String>(UiThreadHandler::runAndWait) {
+            override fun onAddElement(s: String) {
+                emitData("stdout", s)
+            }
+        }
+
+        val stderr = object : CallbackList<String>(UiThreadHandler::runAndWait) {
+            override fun onAddElement(s: String) {
+                emitData("stderr", s)
+            }
+        }
+
+        val future = shell.newJob().add(finalCommand.toString()).to(stdout, stderr).enqueue()
+        val completableFuture = CompletableFuture.supplyAsync {
+            future.get()
+        }
+
+        completableFuture.thenAccept { result ->
+            val emitExitCode =
+                "javascript: (function() { try { ${callbackFunc}.emit('exit', ${result.code}); } catch(e) { console.error(`emitExit error: \${e}`); } })();"
+            webView.post {
+                webView.loadUrl(emitExitCode)
+            }
+
+            if (result.code != 0) {
+                val emitErrCode =
+                    "javascript: (function() { try { var err = new Error(); err.exitCode = ${result.code}; err.message = ${
+                        JSONObject.quote(
+                            result.err.joinToString(
+                                "\n"
+                            )
+                        )
+                    };${callbackFunc}.emit('error', err); } catch(e) { console.error('emitErr', e); } })();"
+                webView.post {
+                    webView.loadUrl(emitErrCode)
+                }
+            }
+        }.whenComplete { _, _ ->
+            runCatching { shell.close() }
+        }
+    }
+
+    @JavascriptInterface
+    fun toast(msg: String) {
+        webView.post {
+            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    @JavascriptInterface
+    fun fullScreen(enable: Boolean) {
+        if (context is Activity) {
+            Handler(Looper.getMainLooper()).post {
+                if (enable) {
+                    hideSystemUI(context.window)
+                } else {
+                    showSystemUI(context.window)
+                }
+            }
+        }
+    }
+
+    @JavascriptInterface
+    fun moduleInfo(): String {
+        val currentModuleInfo = JSONObject()
+        currentModuleInfo.put("moduleDir", modDir)
+        val moduleId = File(modDir).getName()
+        currentModuleInfo.put("id", moduleId)
+        // TODO: more
+        return currentModuleInfo.toString()
+    }
+}
+
+fun hideSystemUI(window: Window) =
+    WindowInsetsControllerCompat(window, window.decorView).let { controller ->
+        controller.hide(WindowInsetsCompat.Type.systemBars())
+        controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+    }
+
+fun showSystemUI(window: Window) =
+    WindowInsetsControllerCompat(window, window.decorView).show(WindowInsetsCompat.Type.systemBars())