Viel Spaß mit Millionen aktueller Android-Apps, Spielen, Musik, Filmen, Serien, Büchern und Zeitschriften – jederzeit, überall und auf allen deinen Geräten. SuperSU ist eine von Chainfire entwickelte Root-Manager-App, die Root-Berechtigungen auf Ihrem Gerät verwaltet, sobald Ihr Gerät gerootet. Einerseits versteht Chainfire darunter, dass das su-Binary nicht in die Partition /system installiert werden muss. Andererseits ist die neue Methode.
Android: Keine Root-Apps mehr von ChainfireHallo Lesende, welche Alternative gibt es zu Chainfire SuperSu mit ClockWorkMod CWM bei Android x? Grund: SuperSU: Chainfire gibt. Einerseits versteht Chainfire darunter, dass das su-Binary nicht in die Partition /system installiert werden muss. Andererseits ist die neue Methode. coachoutletstorecso.com › Anleitungen › Firmware & OS.
Superuser Chainfire The description of SuperSU App VideoHow to root Mediatek devices without unlocking bootloader ! 5/29/ · SuperSU is the Superuser access management tool of the future ;!!! SuperSU requires a rooted device!!! SuperSU allows for advanced management of Superuser access rights for all the apps on your device that need root. SuperSU has been built from the ground up to counter a number of problems with other Superuser access management tools/10(). 4/10/ · Example code for "How-To SU". Contribute to Chainfire/libsuperuser development by creating an account on GitHub. SuperSU is a 'superuser' privilege administration tool that allows you to administer the privileges enjoyed by all of the apps you have installed. Basically, it gives you total control over your Android device. Hallo rudolf, bisher habe ich SuperSU änne Burda. Dann könnte man die Apps evtl. Suche Erweiterte Suche….
PoolWrapper for "sh" and "su", providing get and the earlier mentions run The get method can be used to retrieve a Shell.
Threaded instance from the pool, which you should later return to the pool by calling it's close method. The run Threaded instance you manage, retrieve an instance from the pool, proxies the call to that instance's run Sound complex?
Maybe, but it all comes together so you can sprinkle Shell. All of this without you ever having to worry about managing the instances, and only having to catch a single Shell.
It is assumed all the code following is run from a background thread, such as Thread , AsyncTask , or Job IntentService. When running multiple commands in quick succession, it is slightly cheaper to get an instance and close it when done, and using the returned instance.
But keep in mind if there is a longer period between your calls, and another thread wants to call su, the shell you have not close 'd yet cannot be reused by that thread:.
Threaded::ac , which casts the instance to a Shell. ThreadedAutoCloseable :. Please note that all methods that may be problematic on the UI thread have been marked as WorkerThread.
Some of these methods can be called from the UI thread without issue in specific conditions. If so, those conditions should be noted in the method's javadoc.
Skip to content. Example code for "How-To SU" su. Code Issues Pull requests Actions Projects Wiki Security Insights. HTTPS GitHub CLI. Launching GitHub Desktop If nothing happens, download GitHub Desktop and try again.
Go back. Launching Xcode If nothing happens, download Xcode and try again. Launching Visual Studio If nothing happens, download the GitHub extension for Visual Studio and try again.
Latest commit. Chainfire Update README. Update README. Git stats commits. Failed to load latest commit information. Enable basic GitHub Actions CI.
Apr 10, Update Gradle Wrapper to 5. Feb 28, Do not fail with no local. Remove Eclipse leftover. Add Apache LICENSE file. Oct 29, Dec 23, Update gradle plugin again.
Update Gradle build files. Oct 24, View code. Deprecated This library is not under active development right now, as I've mostly moved away from the Android world.
Upgrading from v1. Example project The example project is very old, and does not follow current best practises. Basics This page is not intended as a full reference, just to get you started off.
Some of the below may seem out-of-order, you might want to read this entire section twice. Blocking, threads, and ShellOnMainThreadException Running subprocesses is expensive and timings cannot be predicted.
Didn't make sense? Don't worry about it, and just follow the advice and examples below Shell. Interactive vs Shell.
Threaded Shell. Common methods Examples follow further below, which make use of pooling. Common methods: addCommand Common methods: run Pooling The Shell.
Examples It is assumed all the code following is run from a background thread, such as Thread , AsyncTask , or Job IntentService.
Annotations Nullity and thread annotations have recently been added. About Example code for "How-To SU" su. This is done by calling Runtime.
Doing this is a fairly straight-forward piece of code, but including the debug logs and checks it's a bit long to reproduce here.
The core code is located here: [libsuperuser :: Shell. The SH variants are used for a non-root shell, where the SU variants are used for a root shell.
If there was no output, the list is empty, but not null. The result is only null in case an error occured; an access denied may or may not trigger null.
These are blocking calls. The reason for this will be discussed in section 4. When to call su. There are many ways to check whether or not superuser access is available.
The two most popular methods are either trying to detect the existance of the su binary or superuser package, or actually trying to run su and seeing what happens.
I prefer the latter method, as running su is what you're after no matter where it's at and if you know how to find it - as long as the system does.
A problem with the id command is that it depends on an external binary that must be present. I have never run into the situation where it wasn't, but to be sure we also issue an echo command that we check for, so that if the id command is not available, we can still know whether a shell was run at all.
In the latter case, we assume the shell also has root priviliges - if this ends up being wrong, the user has worse problems than your app not getting root access.
If you want to be absolutely sure even in this remote case of a wrongly rooted device, you would have to include its own native binary to perform the check.
Of course, if you are including native binaries anyways, it is certainly advised to have them check if they are actually running as root before doing anything else.
While this is not something most root apps need to do, and not all su binaries even support this, this might be something you want to do.
Both recent Superuser su binaries as well as SuperSU su binaries support the -v for display and -V for internal comparison parameters to check the version number.
As stated above, a potential problem is that a su binary that doesn't support these parameters may start an interactive shell instead.
When SuperSU versions 1. This means that mounts applied in one su shell may not be visible to other processes, except most other su shells started by the same parent process your app.
SuperSU in this case also tries to make the sdcards mounts and user-specific mounts available to the su shell, which hopefully makes your job easier.
Android itself has offered similar mount namespace isolation for apps from version 4. SuperSU versions 1. If you need to 'publicly' apply a mount, use this option.
The main thread Do not call su when running on the main application thread. The number one reason for freezes and crashes when apps request root access is that su is being called from the main thread.
The call may take milliseconds, 30 seconds, or an hour. If the main application thread blocks like this for more than a few seconds, an Application Not Responding ANR crash is generated by the system.
I have often received complaints from SuperSU users about the countdown timer in the root access request popup that is at the time of this writing enabled by default, and will automatically deny root access after a number of seconds.
The only reason this timer was built is because far too many root apps call su from the main thread, and if the popup would not time out and the user wouldn't grant or deny root access relatively quickly, the app that had requested su access would crash with an ANR.
The timer helps reduce but not eliminate the chances of that happening, but it is merely treating symptoms, not solving problems.
A note on su being a blocking call Most ways to start a new process are actually non-blocking, and the child process runs in a different thread.
However, most example and library code either call Process. All of these possibilities turn the code that calls su into blocking code, waiting for the su process.
Though it is actually possible to call su in a non-blocking fashion from the main thread, but it is easy to make mistakes that way, and it is often simpler to create a single block of code that handles calling su like the sample Shell.
The sample code does provide the Shell. Interactive class which can be used in this way from the main thread, queueing commands and receiving callbacks, but how to use this class is not documented by this article read the inline documentation in the source code instead , for the sake of keeping things simple.
Aside from running on the main thread, the su call itself may need to broadcast an intent to communicate with the GUI. This presents a problem because the latter broadcast may be waiting on the previous broadcast to complete, which it will not do until the onReceive method completes, which is in turn waiting for the su call to complete.
This will cause an ANR. Services As with BroadcastReceiver s, many developers at first overlook that a basic Service also executes on the main thread, and is thus also susceptible to ANRs.
That is, unless you are using a special Service subclass like IntentService that uses a background thread, or added a background thread to the service yourself.
You might have noticed this code in the Shell. If it is detected you are running on the main thread, and the Android project is compiled in debug mode BuildConfig.
Hopefully this will convince you to try and run your shell code in a background thread - and not to remove the check!
The AsyncTask class is often used to perform quick and easy background processing for relatively short operations.
You can safely call su from the AsyncTask 's doInBackground method. Here is an example of a minimal implementation inside an Activity :. Please note that nothing is perfect, and AsyncTask also has some issues.
For example, the user rotating the device may cause your Activity to be closed and re-created, re-launching the AsyncTask while the old one is still running.
These are not insurmountable issues, but as with any tool you use, you need to know when, how, and when not to use it. While AsyncTask is a very useful class you will no doubt often employ, sometimes it's just not the right tool for the job.
For example, you can't directly use an AsyncTask from a BroadcastReceiver , because once the onReceive method completes, your process may not have any active components left, and thus may be killed.
However, a standard Service actually runs on the main thread as well, unless you do the extra work to run code in a background thread.
The IntentService class however, is an easy to use Service subclass designed specifically to run tasks expressed by Intent s in a background thread, and automatically stop itself when it runs out of work.
Perfect for fire-and-forget style tasks. Your AndroidManifest. All that is left now, is to launch this background service from your BroadcastReceiver , in BootCompleteReceiver.
That is all there is to it - once you know how, it's incredibly easy. Instead of running in your BroadcastReceiver on the main thread, your code is now running safely in a background thread without risking an ANR crash.
There is however a minor snag. Many apps send Toast s from their BroadcastReceiver s - this is a bit harder to do from a background thread due to some minor bugs in the Android framework.
Refer to [libsuperuser :: Application. SEAndroid is its Android port, which this article will also refer to as SELinux.
It is used in one of two modes: permissive mode where policy violations are logged but no action is taken, and enforcing mode where policy violations are prevented from happening.
SELinux has been present in stock Android since 4. You should however not depend on these API levels to detect SELinux presence or mode, as there are even some 4.
As a root app developer, you need to learn how to deal with SELinux. You do not need to know all the ins and outs of this very complex system and the policies used by stock as well as OEM-custom builds, but depending on the type of root app you are making, you may need to spend some extra time testing on different firmwares and devices to get things working reliably.
To make matters worse, SELinux is a moving target, with policies changing between Android versions and even OEMs - the policies on for example a Samsung device may be significantly different from the policies on a Nexus device.
If SELinux is set to permissive mode, there is relatively little to worry about, but when it is set to enforcing , the part of your app running as root may run into all sorts of unexpected restrictions.
SuperSU versions 2. From SuperSU versions 2. Still, it is good to read the rest of this section so you know how it works if you do run into a special case.
Note that various custom kernels and firmwares switch SELinux back to permissive for Android 4. This completely disables all the new security features SELinux brings, rather than relaxing only the areas we absolutely need to get our apps to function.
It is rare for a root app to require further patches to the current SELinux policy beyond what SuperSU already does for you, but if it is needed, an API is provided for that.
It is of course up to the user to decide if SELinux should be permissive or not, but it is certainly good practise to make sure your apps work on an enforcing system.
There is a lot of mention of various SuperSU versions. This is only listed for completeness sake, as many details have changed between the first 'retail' Android 4.
Android 5. While it is probably wise to make sure your code runs regardless of SELinux presence or mode, sometimes you will need to detect if SELinux is present and set to enforcing.
For some example code, see the Shell. The current SELinux context defines which security policies apply to your process.
The 'highest' usermode context is generally u:r:init:s0. Contrary to what you may expect, this does not necessarily mean this context has access to everything.
Some common contexts you may come in contact with:. With v2. Note that OEMs tend to modify these policies, and these policies change between Android version.
To assure compatibility, your app should be tested on all API revisions, and if possible on flagship devices from all the major OEMs - if you cannot do this yourself, depend on your core users.
On firmwares that use SELinux, su is generally implemented as a proxy to a daemon started from init. SuperSU itself should always run as u:r:init:s0 or u:r:supersu:s0 if SELinux is set to enforcing , but not all superuser shells do.
Adb uses the u:r:shell:s0 context, which has very different policies. Be careful not to confuse them! You might wonder why - if we're already running as the init context, as the root user, and with SuperSU actively patching SELinux policies - do we still need to switch contexts?
If on an enforcing system running SuperSU you run the su command, you do indeed end up in a completely unrestricted shell.
Android as a whole is a complex system spanning a number of processes, running as different users and different contexts. The SELinux policy defines the rules for transitions and communication between all these.
Just because there are no restrictions for our shell, does not mean no restrictions apply for other processes we need to deal with.
SELinux policies are not bidirectional, so even if we can talk to other processes, those restricted processes may not be able to talk back to us.
The solution is to disguise ourselves so those processes are allowed to talk to us: switching contexts. Of course, we could free those other processes from their SELinux chains as well, but continuing down that line will eventually end up completely negating all the security benefits SELinux can bring.
The line has to be drawn somewhere, and for SuperSU the line has been drawn on the basis of necessity. It is not needed to further relax SELinux policies for these commands to be executed, and thus we do not further relax the SELinux policies, even though it is at a slight inconvenience for the root app developers.
There are several ways to switch contexts. Most of the time, you will need to do a more explicit form of context switching.
The runcon command available in toolbox since select builds of Android 4. The run-as command available since Android 2. Unfortunately, both of these commands cannot generally be depended upon, as they only work in very specific circumstances, and thus, SuperSU versions 1.
SuperSU Update on: App uploaded by: Alecssander Colacio Requires Android: Android 2. Update on: App uploaded by: Isaac Garcia Requires Android: Android 2.
Update on: App uploaded by: Reham Reham Requires Android: Android 2. VideoBuddy - Youtube Downloader 1. Mobile Legends: Bang Bang 1.
Puffin 8. My Telenor 4. TubeMate Video Downloader 1. Subway Surfers 2. Special Forces Group 2 4. Snapseed 2. Spotify 1. Microsoft OneDrive 6.Technische Details. Paketname. coachoutletstorecso.comu. Lizenz. Kostenlos. Betriebssystem. Android. Anforderungen. Android oder höher notwendig. Kategorie. Viel Spaß mit Millionen aktueller Android-Apps, Spielen, Musik, Filmen, Serien, Büchern und Zeitschriften – jederzeit, überall und auf allen deinen Geräten. SuperSU requires a rooted device!!! SuperSU allows for advanced management of Superuser access rights for all the apps on your device that need root. Der für die Entwicklung zahlreicher Root-Apps wie SuperSU verantwortliche Programmierer Chainfire zieht sich zurück. Die App für die Vergabe.