feat(root): refactor root access

app/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
     implementation(libs.guava)
     implementation(libs.jbcrypt)
     implementation(libs.kotlinx.serialization.core)
+    implementation(libs.libsuperuser)
     implementation(libs.lingala.zip4j)
     implementation(libs.localbroadcastmanager)
     implementation(libs.navigation3.runtime)

app/src/main/java/com/nutomic/syncthingandroid/receiver/BootReceiver.java

@@ -12,6 +12,8 @@
 import com.nutomic.syncthingandroid.service.SyncthingRunnable;
 import com.nutomic.syncthingandroid.service.SyncthingService;
 
+import eu.chainfire.libsuperuser.Shell;
+
 import java.lang.SecurityException;
 
 public class BootReceiver extends BroadcastReceiver {
@@ -30,6 +32,16 @@ public void onReceive(Context context, Intent intent) {
             return;
         }
 
+        if (packageReplaced) {
+            if (getPrefUseRoot(context) && Shell.SU.available()) {
+                /**
+                 * In Root mode, there will be a SyncthingNative process left running after app update.
+                 */
+                Log.d(TAG, "ACTION_MY_PACKAGE_REPLACED: Killing leftover SyncthingNative instance if present ...");
+                new SyncthingRunnable(context, SyncthingRunnable.Command.main).killSyncthing();
+            }
+        }
+
         // Check if we should (re)start now.
         if (!getPrefStartServiceOnBoot(context)) {
             return;
@@ -57,4 +69,9 @@ private static boolean getPrefStartServiceOnBoot(Context context) {
         SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
         return sp.getBoolean(Constants.PREF_START_SERVICE_ON_BOOT, false);
     }
+
+    private static boolean getPrefUseRoot(Context context) {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
+        return sp.getBoolean(Constants.PREF_USE_ROOT, false);
+    }
 }

app/src/main/java/com/nutomic/syncthingandroid/service/Constants.java

@@ -50,6 +50,7 @@ private PowerSource() { }
     // Preferences - Behaviour
     public static final String PREF_START_SERVICE_ON_BOOT       = "always_run_in_background";
     public static final String PREF_BROADCAST_SERVICE_CONTROL   = "broadcast_service_control";
+    public static final String PREF_USE_ROOT                    = "use_root";
     public static final String PREF_ALLOW_OVERWRITE_FILES       = "allow_overwrite_files";
 
     // Preferences - Syncthing Options

app/src/main/java/com/nutomic/syncthingandroid/service/SyncthingRunnable.java

@@ -47,6 +47,8 @@
 
 import javax.inject.Inject;
 
+import eu.chainfire.libsuperuser.Shell;
+
 import static com.nutomic.syncthingandroid.service.SyncthingService.EXTRA_STOP_AFTER_CRASHED_NATIVE;
 
 /**
@@ -68,6 +70,7 @@ public class SyncthingRunnable implements Runnable {
     private final File mSyncthingBinary;
     private String[] mCommand;
     private final File mSyncthingLogFile;
+    private final boolean mUseRoot;
 
     @Inject
     SharedPreferences mPreferences;
@@ -97,6 +100,7 @@ public SyncthingRunnable(Context context, Command command) {
         mSyncthingLogFile = Constants.getSyncthingLogFile(mContext);
 
         // Get preferences relevant to starting syncthing core.
+        mUseRoot = mPreferences.getBoolean(Constants.PREF_USE_ROOT, false) && Shell.SU.available();
         switch (command) {
             case deviceid:
                 mCommand = new String[]{mSyncthingBinary.getPath(), "device-id"};
@@ -270,7 +274,7 @@ private void putCustomEnvironmentVariables(Map<String, String> environment, Shar
      */
     private List<String> getSyncthingPIDs(Boolean enableLog) {
         List<String> syncthingPIDs = new ArrayList<String>();
-        String output = Util.runShellCommandGetOutput("ps\n");
+        String output = Util.runShellCommandGetOutput("ps\n", mUseRoot);
         if (TextUtils.isEmpty(output)) {
             Log.w(TAG, "Failed to list SyncthingNative processes. ps command returned empty.");
             return syncthingPIDs;
@@ -306,7 +310,7 @@ public void killSyncthing() {
             return;
         }
         for (String syncthingPID : syncthingPIDs) {
-            exitCode = Util.runShellCommand("kill -SIGINT " + syncthingPID + "\n");
+            exitCode = Util.runShellCommand("kill -SIGINT " + syncthingPID + "\n", mUseRoot);
             if (exitCode == 0) {
                 LogV("Sent kill SIGINT to process " + syncthingPID);
             } else {
@@ -458,9 +462,30 @@ private Process setupAndLaunch(HashMap<String, String> env) throws IOException,
                 throw new ExecutableNotFoundException(mCommand[0]);
             }
         }
-        ProcessBuilder pb = new ProcessBuilder(mCommand);
-        pb.environment().putAll(env);
-        return pb.start();
+
+        if (mUseRoot) {
+            ProcessBuilder pb = new ProcessBuilder("su");
+            Process process = pb.start();
+            // The su binary prohibits the inheritance of environment variables.
+            // Even with --preserve-environment the environment gets messed up.
+            // We therefore start a root shell, and set all the environment variables manually.
+            DataOutputStream suOut = new DataOutputStream(process.getOutputStream());
+            for (Map.Entry<String, String> entry : env.entrySet()) {
+                suOut.writeBytes(String.format("export %s=\"%s\"\n", entry.getKey(), entry.getValue()));
+            }
+            suOut.flush();
+            // Exec will replace the su process image by Syncthing as execlp in C does.
+            // Without using exec, the process will drop to the root shell as soon as Syncthing terminates like a normal shell does.
+            // If we did not use exec, we would wait infinitely for the process to terminate (ret = process.waitFor(); in run()).
+            // With exec the whole process terminates when Syncthing exits.
+            suOut.writeBytes("exec " + TextUtils.join(" ", mCommand) + "\n");
+            suOut.flush();
+            return process;
+        } else {
+            ProcessBuilder pb = new ProcessBuilder(mCommand);
+            pb.environment().putAll(env);
+            return pb.start();
+        }
     }
 
     public class ExecutableNotFoundException extends Exception {

app/src/main/java/com/nutomic/syncthingandroid/service/SyncthingService.java

@@ -1095,7 +1095,6 @@ private boolean importConfigSharedPrefs(final File file) {
                         case "pref_current_language":
                         case "restartOnWakeup":
                         case "wakelock_while_binary_running":
-                        case "use_root":
                             LogV("importConfig: Ignoring deprecated pref \"" + prefKey + "\".");
                             break;
                         // Cached information which is not available on SettingsActivity.

app/src/main/java/com/nutomic/syncthingandroid/settings/SettingsBehaviorScreen.kt

@@ -1,11 +1,18 @@
 package com.nutomic.syncthingandroid.settings
 
+import android.widget.Toast
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.navigation3.runtime.EntryProviderScope
 import com.nutomic.syncthingandroid.R
 import com.nutomic.syncthingandroid.service.Constants
+import com.nutomic.syncthingandroid.util.Util
+import eu.chainfire.libsuperuser.Shell
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import me.zhanghai.compose.preference.SwitchPreference
 import me.zhanghai.compose.preference.rememberPreferenceState
 
@@ -19,10 +26,34 @@ fun EntryProviderScope<SettingsRoute>.settingsBehaviorEntry() {
 
 @Composable
 fun SettingsBehaviorScreen() {
+    val context = LocalContext.current
+    val scope = LocalActivityScope.current
 
     val autoStart = rememberPreferenceState(Constants.PREF_START_SERVICE_ON_BOOT, false)
     val broadcast = rememberPreferenceState(Constants.PREF_BROADCAST_SERVICE_CONTROL, false)
     val overwrite = rememberPreferenceState(Constants.PREF_ALLOW_OVERWRITE_FILES, false)
+    val useRoot = rememberPreferenceState(Constants.PREF_USE_ROOT, false)
+
+    val toggleRoot = { enabled: Boolean ->
+        scope.launch(Dispatchers.IO) {
+            if (enabled) {
+                if (Shell.SU.available()) {
+                    useRoot.value = true
+                } else {
+                    withContext(Dispatchers.Main) {
+                        Toast.makeText(
+                            context,
+                            R.string.toast_root_denied,
+                            Toast.LENGTH_LONG
+                        ).show()
+                    }
+                }
+            } else {
+                Util.fixAppDataPermissions(context)
+                useRoot.value = false
+            }
+        }
+    }
 
     SettingsScaffold(
         title = stringResource(R.string.category_behaviour),
@@ -48,5 +79,15 @@ fun SettingsBehaviorScreen() {
                 state = overwrite,
             )
         }
+        item {
+            SwitchPreference(
+                title = { Text(stringResource(R.string.use_root_title)) },
+                summary = { Text(stringResource(R.string.use_root_summary)) },
+                value = useRoot.value,
+                onValueChange = {
+                    toggleRoot(it)
+                },
+            )
+        }
     }
 }

app/src/main/java/com/nutomic/syncthingandroid/util/ConfigXml.java

@@ -225,7 +225,7 @@ private String getLocalDeviceIDandStoreToPref() throws SyncthingRunnable.Executa
     }
 
     private void parseConfig() {
-        if (!mConfigFile.canRead()) {
+        if (!mConfigFile.canRead() && !Util.fixAppDataPermissions(mContext)) {
             Log.w(TAG, "Failed to open config file '" + mConfigFile + "'");
             throw new OpenConfigException();
         }
@@ -1257,7 +1257,7 @@ private boolean addSyncthingCameraFolder() {
      * Writes updated mConfig back to file.
      */
     public void saveChanges() {
-        if (!mConfigFile.canWrite()) {
+        if (!mConfigFile.canWrite() && !Util.fixAppDataPermissions(mContext)) {
             Log.w(TAG, "Failed to save updated config. Cannot change the owner of the config file.");
             return;
         }

app/src/main/java/com/nutomic/syncthingandroid/util/Util.java

@@ -3,12 +3,15 @@
 import android.app.Dialog;
 import android.app.UiModeManager;
 import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.Configuration;
 import android.os.Build;
 import android.text.TextUtils;
 import android.util.Log;
 
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.preference.PreferenceManager;
 
 import com.google.common.base.Charsets;
 import com.nutomic.syncthingandroid.R;
@@ -31,6 +34,8 @@
 import java.time.ZoneOffset;
 import java.util.Locale;
 
+import eu.chainfire.libsuperuser.Shell;
+
 public class Util {
 
     private static final String TAG = "Util";
@@ -66,16 +71,76 @@ public static String readableTransferRate(Context context, long bits) {
                 .format(bytes / Math.pow(1024, digitGroups)) + " " + units[digitGroups];
     }
 
+    /**
+     * Normally an application's data directory is only accessible by the corresponding application.
+     * Therefore, every file and directory is owned by an application's user and group. When running Syncthing as root,
+     * it writes to the application's data directory. This leaves files and directories behind which are owned by root having 0600.
+     * Moreover, those actions performed as root changes a file's type in terms of SELinux.
+     * A subsequent start of Syncthing will fail due to insufficient permissions.
+     * Hence, this method fixes the owner, group and the files' type of the data directory.
+     *
+     * @return true if the operation was successfully performed. False otherwise.
+     */
+    public static boolean fixAppDataPermissions(Context context) {
+        // We can safely assume that root magic is somehow available, because readConfig and saveChanges check for
+        // read and write access before calling us.
+        // Be paranoid :) and check if root is available.
+        // Ignore the 'use_root' preference, because we might want to fix the permission
+        // just after the root option has been disabled.
+        if (!Shell.SU.available()) {
+            Log.e(TAG, "Root is not available. Cannot fix permissions.");
+            return false;
+        }
+
+        String packageName;
+        ApplicationInfo appInfo;
+        try {
+            packageName = context.getPackageName();
+            appInfo = context.getPackageManager().getApplicationInfo(packageName, 0);
+
+        } catch (NameNotFoundException e) {
+            // This should not happen!
+            // One should always be able to retrieve the application info for its own package.
+            Log.w(TAG, "Error getting current package name", e);
+            return false;
+        }
+        Log.d(TAG, "Uid of '" + packageName + "' is " + appInfo.uid);
+
+        // Get private app's "files" dir residing in "/data/data/[packageName]".
+        String dir = context.getFilesDir().getAbsolutePath();
+        String cmd = "chown -R " + appInfo.uid + ":" + appInfo.uid + " " + dir + "; ";
+        // Running Syncthing as root might change a file's or directories type in terms of SELinux.
+        // Leaving them as they are, the Android service won't be able to access them.
+        // At least for those files residing in an application's data folder.
+        // Simply reverting the type to its default should do the trick.
+        cmd += "restorecon -R " + dir + "\n";
+        Log.d(TAG, "Running: '" + cmd);
+        int exitCode = runShellCommand(cmd, true);
+        if (exitCode == 0) {
+            Log.i(TAG, "Fixed app data permissions on '" + dir + "'.");
+        } else {
+            Log.w(TAG, "Failed to fix app data permissions on '" + dir + "'. Result: " +
+                Integer.toString(exitCode));
+        }
+        return exitCode == 0;
+    }
+
     /**
      * Returns if the syncthing binary would be able to write a file into
      * the given folder given the configured access level.
      */
     public static boolean nativeBinaryCanWriteToPath(Context context, String absoluteFolderPath) {
         final String TOUCH_FILE_NAME = ".stwritetest";
+        Boolean useRoot = false;
+        Boolean prefUseRoot = PreferenceManager.getDefaultSharedPreferences(context)
+            .getBoolean(Constants.PREF_USE_ROOT, false);
+        if (prefUseRoot && Shell.SU.available()) {
+            useRoot = true;
+        }
 
         // Write permission test file.
         String touchFile = absoluteFolderPath + "/" + TOUCH_FILE_NAME;
-        int exitCode = runShellCommand("echo \"\" > \"" + touchFile + "\"\n");
+        int exitCode = runShellCommand("echo \"\" > \"" + touchFile + "\"\n", useRoot);
         if (exitCode != 0) {
             String error;
             switch (exitCode) {
@@ -94,7 +159,7 @@ public static boolean nativeBinaryCanWriteToPath(Context context, String absolut
         Log.i(TAG, "Successfully wrote test file '" + touchFile + "'");
 
         // Remove test file.
-        if (runShellCommand("rm \"" + touchFile + "\"\n") != 0) {
+        if (runShellCommand("rm \"" + touchFile + "\"\n", useRoot) != 0) {
             // This is very unlikely to happen, so we have less error handling.
             Log.i(TAG, "Failed to remove test file");
         }
@@ -104,14 +169,14 @@ public static boolean nativeBinaryCanWriteToPath(Context context, String absolut
     /**
      * Run command in a shell and return the exit code.
      */
-    public static int runShellCommand(String cmd) {
+    public static int runShellCommand(String cmd, Boolean useRoot) {
         // Assume "failure" exit code if an error is caught.
         // Note: redirectErrorStream(true); System.getProperty("line.separator");
         int exitCode = 255;
         Process shellProc = null;
         DataOutputStream shellOut = null;
         try {
-            shellProc = Runtime.getRuntime().exec("sh");
+            shellProc = Runtime.getRuntime().exec((useRoot) ? "su" : "sh");
             shellOut = new DataOutputStream(shellProc.getOutputStream());
             BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(shellOut));
             Log.d(TAG, "runShellCommand: " + cmd);
@@ -152,13 +217,17 @@ public static int runShellCommand(String cmd) {
     }
 
     public static String runShellCommandGetOutput(String cmd) {
+        return runShellCommandGetOutput(cmd, false);
+    }
+
+    public static String runShellCommandGetOutput(String cmd, Boolean useRoot) {
         // Note: redirectErrorStream(true); System.getProperty("line.separator");
         int exitCode = 255;
         String capturedStdOut = "";
         Process shellProc = null;
         DataOutputStream shellOut = null;
         try {
-            shellProc = Runtime.getRuntime().exec("sh");
+            shellProc = Runtime.getRuntime().exec((useRoot) ? "su" : "sh");
             shellOut = new DataOutputStream(shellProc.getOutputStream());
             BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(shellOut));
             Log.d(TAG, "runShellCommandGetOutput: " + cmd);

app/src/main/res/values/strings.xml

@@ -410,6 +410,9 @@
     <!-- Shown if no folders are configured -->
     <string name="folders_list_empty">No folders configured. Tap to add a new folder.</string>
 
+    <!-- Toast show if we could not get root permissions -->
+    <string name="toast_root_denied">Did not get root permissions</string>
+
     <!-- RecentChangesActivity -->
 
     <string name="no_recent_changes">There are no recent changes.</string>
@@ -527,6 +530,8 @@
     <string name="behaviour_autostart_title">Autostart</string>
     <string name="behaviour_autostart_summary">Start app automatically on operating system startup.</string>
 
+    <string name="use_root_title">Run Syncthing as Superuser</string>
+    <string name="use_root_summary">Running Syncthing as root allows it to write to folders Android normally restricts to be readonly accessed. Use this feature with caution.</string>
 
     <string name="allow_overwrite_files_title">Allow overwrite of existing files</string>
     <string name="allow_overwrite_files_summary">When another app shares files to one of our folders.</string>