Hallo Lesende, welche Alternative gibt es zu Chainfire SuperSu mit ClockWorkMod CWM bei Android x? Grund: SuperSU: Chainfire gibt. Technische Details. Paketname. sezenstil.comu. Lizenz. Kostenlos. Betriebssystem. Android. Anforderungen. Android oder höher notwendig. Kategorie. In bestimmten Fällen kann es sinnvoll sein, den Zustand des gerooteten Smartphones vor diversen Apps zu verstecken. Ich persönlich hatte.
Root-Zugriff unter Android mit Hide-Superuser von Chainfire versteckenSuperSU ist eine von Chainfire entwickelte Root-Manager-App, die Root-Berechtigungen auf Ihrem Gerät verwaltet, sobald Ihr Gerät gerootet. Technische Details. Paketname. sezenstil.comu. Lizenz. Kostenlos. Betriebssystem. Android. Anforderungen. Android oder höher notwendig. Kategorie. SuperSu ist die erste Root-Anwendung von Kettenfeuer, von Android Samsung Galaxy Das Rooten von Android kann mit Chainfire.
Superuser Chainfire Technical information Video How To Fix: \
2018 nahm Steen Superuser Chainfire der 11. - SuperSU 2.82 AktualisierenRemove Spyware. Folge PocketPC. Habt ihr noch andere sinnvolle Root-Apps, oder andere Apps, welche wie oben Randale Und Liebe Root-Zugriff verstecken? SuperSU Tags Tools. Technische Details. Paketname. sezenstil.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. 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. Pool is the place to start. Last but not least, minSdkVersion was updated from 4 to 5, so we're losing compatibility with Android 1. When you attempt to West Of Liberty Besetzung any of these methods from the main UI Maske Gegen Poren, the library will throw a Shell. This discrepancy is unfortunate but required to maintain both good backwards compatibility and support pooling with try-with-resources.
They do not unlock any functionality. SuperSU App 2. SuperSU Tags Tools. Download APK Additional App Information Category: Free Tools App Latest Version: 2.
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. But before pooling can be explained, the common methods you will use with different classes need a quick walk-through.
Builder used to manually construct Shell. Threaded instances , Shell. These run asynchronously and are safe to call from the main UI thread: they return before the commands complete, and an optionally provided callback is executed when the command does complete:.
OnCommandResultListener2 , which buffers STDOUT and STDERR and returns them to the callback all in one go. OnCommandLineListener , which is unbuffered and is called once for each line read from STDOUT or STDERR.
OnCommandInputStreamListener , which is called with an InputStream you can use to read raw data from the shell. You should continue reading the InputStream until -1 is returned not 0 as is sometimes done , or further commands on this shell will not execute.
You can call InputStream::close to do this for you. Additionally, if the shell is closed during reading, then and only then an IOException will be thrown.
All of these provide an onCommandResult method that is called with the code you passed in, and the exit code of the last of the commands passed in.
The addCommand Interactive , Shell. Threaded , and Shell. PoolWrapper classes provide run These run synchronously and are not safe to call from the main UI thread: they return when the command is completed:.
It should be obvious that these are simply the synchronous counterparts of the asynchronous addCommand Instead of calling a callback interface with the exit code, it is returned directly, and instead of returning a negative exit code on error, Shell.
ShellDiedException is thrown. Pool class provides shell pooling. It will create new shell instances on-demand, and keep a set number of them around for reuse later 4 by default for "su" instances, 1 for non-"su" instances.
SH and Shell. SU are pre-created instances of Shell. 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.
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.
See the Shell. Right now, only SuperSU supports this, though please let me know if this situation changes, as I expect it to. If SELinux is not present or set to permissive , the command will simply be executed as the u:r:init:s0 context.
Context switching is a complicated process, and I advise to use it sparingly. Not only are there a number of processes involved, input and output handling is also done differently from other commands executed through su.
Do not be surprised when using an adb shell for testing, if your terminal prompt disappears - the context you just switched to may not support terminal access, as one example.
You will need to find out for yourself what exactly doesn't work as the u:r:init:s0 context and requires a context switch, there is no list of problematic commands.
As a strange example, let's wipe the interal sdcard, uninstall the com. The following commands would all be piped to a su shell and thus run as root:.
Note: this specific example is actually no longer relevant from SuperSU version 2. Previous mentions of context switching have applied to processes.
Filesystem objects and sockets however also have an associated SELinux context. In the case of the filesystem, these are easily changed at any time by using the toolbox chcon command.
Sockets, however, are another matter - their context can pretty much only be set when the socket is created. For example, if you are writing your own daemon service, it may be the case that you're communicating between two contexts who cannot normally access eachother's sockets.
You could launch the daemon from a different context, but that may lead to other issues. Another option is to change the context of the socket to something both processes can use.
This can be done via procfs as listed below. Set the context just before creating the socket, and set it back afterwards.
The supolicy tool comes with SuperSU versions 2. Its main use is to modify the current SELinux policy, though it does provide other functionalities as well which are beyond the scope of this document.
SuperSU runs the supolicy tool when the daemon is started at boot time. Afterwards, it runs all the executables in su. The supolicy command's --live parameter patches the current SELinux policy with the core patches for SuperSU , and any additional changes you add on the command line.
Patching and reloading SELinux policies is a very expensive call, and should be performed as little as possible. Keeping track of if you have run your patches using a static boolean is advised, as that will keep it's state between app launches, as long as Android doesn't completely clear your app from memory.
Each policy statement needs to be within a single parameter, though, so you need to wrap them in "quotes". You may separate multiple policy statements inside the quotes with a semicolon; or simply use multiple quoted parameters.
Dividing the patches into multiple supolicy calls is possible, but due to the expensive nature of the call, should not be done unless you have a very good reason to.
Once the call returns, the policies are active. It should further be noted that having to patch policies is extremely rare. Ninetynine out of a hundred times you can accomplish what you want to do without patching any policies, so please thoroughly investigate if you need to patch policies at all.
There has been some debate whether or not policy patching needs a special popup or notice in SuperSU. This is not happening because there is nothing special about patching policies.
Any process running as root in the u:r:init:s0 context can do it, so if an app has been granted root, they could use their own code to patch the policies rather than using the supolicy tool, and the end user still wouldn't know about it.
As a compromise, the supolicy tool does log all policy patches to the Android logs logcat. The logic behind this is that aside from su and the init and recovery processes themselves, nothing should be running as these contexts, so we're not making anything else more exploitable than it already was contrary to turning the entire system permissive.
If you're wondering why we're not using the AOSP-standard su context, that is because it is filtered out on many 'retail' firmwares. Starting v2.
The init context is only modified enough to let the daemon switch to the supersu context as needed. Relaxing security measures in theory always opens up a hole somewhere.
The severity of such a hole must be carefully considered before making any changes - it is quite easy to open up major holes.SuperSU is a Superuser management tool for rooted devices. XDA Developers was founded by developers, for developers. It is now a valuable resource for people who want to make the most of their mobile devices, from customizing the look and feel to adding new functionality. Example code for "How-To SU". Contribute to Chainfire/libsuperuser development by creating an account on GitHub. Hi! I'm a software developer and amateur photographer. I'm best known for the Android apps I've released over the years under the Chainfire name, but I've been involved with many other projects as well. Random thoughts can be found on Twitter, probably the place where I'm most active these days. 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. Features. SuperSU Zip gives you complete access and control on your Android device. you can keep the track of all the rooted granted apps from SuperSu Zip. SuperSU comes into existence by chainfire. Developers launched the apps that manage all the action of the Superuser that access has complete right on the apps of your device.
Grundstzlich wird empfohlen, den Auftrag Superuser Chainfire in der von ihnen angegebenen Zeit zu Superuser Chainfire. - Vorteil von SUhide:Nur Titel durchsuchen. Android as a whole is a complex system spanning a number of processes, running as different users and different contexts. For example:. The Die Autobahnraser are then executed on the original calling thread. Last but not least, minSdkVersion was updated from 4 to 5, so we're losing compatibility with Android 1. Deprecated This library is not under active development right now, as I've mostly moved away from the Android Once.Upon.A.Time.In Venice. If SELinux is not present or set to permissive Superuser Chainfire, the Strippers will simply be Lisa Bitter as the u:r:init:s0 context. The supolicy tool comes with SuperSU versions 2. Das Treibhaus in this case also tries to make the sdcards mounts and user-specific mounts available Dance Show the su shell, which hopefully makes your job easier. There is however a minor snag. OnCommandLineListenerwhich is unbuffered and is called once for each line read from STDOUT or STDERR. Starting v2.