1. 18 Oct, 2019 1 commit
  2. 17 Oct, 2019 6 commits
  3. 16 Oct, 2019 7 commits
  4. 15 Oct, 2019 2 commits
  5. 14 Oct, 2019 1 commit
    • topjohnwu's avatar
      Support loading Magisk Manager from stub on 9.0+ · 5ffb9eaa
      topjohnwu authored
      In the effort of preventing apps from crawling APK contents across the
      whole installed app list to detect Magisk Manager, the solution here
      is to NOT install the actual APK into the system, but instead
      dynamically load the full app at runtime by a stub app. The full APK
      will be stored in the application's private internal data where
      non-root processes cannot read or scan.
      
      The basis of this implementation is the class "AppComponentFactory"
      that is introduced in API 28. If assigned, the system framework will
      delegate app component instantiation to our custom implementation,
      which allows us to do all sorts of crazy stuffs, in our case dynamically
      load classes and create objects that does not exist in our APK.
      
      There are a few challenges to achieve our goal though. First, Java
      ClassLoaders follow the "delegation pattern", which means class loading
      resolution will first be delegated to the parent loader before we get
      a chance to do anything. This includes DexClassLoader, which is what
      we will be using to load DEX files at runtime. This is a problem
      because our stub app and full app share quite a lot of class names.
      A custom ClassLoader, DynamicClassLoader, is created to overcome this
      issue: it will always load classes in its current dex path before
      delegating it to the parent.
      
      Second, all app components (with the exception of runtime
      BroadcastReceivers) are required to be declared in AndroidManifest.xml.
      The full Magisk Manager has quite a lot of components (including
      those from WorkManager and Room). The solution is to copy the complete
      AndroidManifest.xml from the full app to the stub, and our
      AppComponentFactory is responsible to construct the proper objects or
      return dummy implementations in case the full APK isn't downloaded yet.
      
      Third, other than classes, all resources required to run the full app
      are also not bundled with the stub APK. We have to call an internal API
      `AssetManager.addAssetPath(String)` to add our downloaded full APK into
      AssetManager in order to access resources within our full app. That
      internal API has existed forever, and is whitelisted from restricted
      API access on modern Android versions, so it is pretty safe to use.
      
      Fourth, on the subject of resources, some resources are not just being
      used by our app at runtime. Resources such as the app icon, app label,
      launch theme, basically everything referred in AndroidManifest.xml,
      are used by the system to display the app properly. The system get these
      resources via resource IDs and direct loading from the installed APK.
      This subset of resources would have to be copied into the stub to make
      the app work properly.
      
      Fifth, resource IDs are used all over the place in XMLs and Java code.
      The resource IDs in the stub and full app cannot missmatch, or
      somewhere, either it be the system or AssetManager, will refer to the
      incorrect resource. The full app will have to include all resources in
      the stub, and all of them have to be assigned to the exact same IDs in
      both APKs. To achieve this, we use AAPT2's "--emit-ids" option to dump
      the resource ID mapping when building the stub, and "--stable-ids" when
      building the full APK to make sure all overlapping resources in full
      and stub are always assigned to the same ID.
      
      Finally, both stub and full app have to work properly independently.
      On 9.0+, the stub will have to first launch an Activity to download
      the full APK before it can relaunch into the full app. On pre-9.0, the
      stub should behave as it always did: download and prompt installation
      to upgrade itself to full Magisk Manager. In the full app, the goal
      is to introduce minimal intrusion to the code base to make sure this
      whole thing is maintainable in the future. Fortunately, the solution
      ends up pretty slick: all ContextWrappers in the app will be injected
      with custom Contexts. The custom Contexts will return our patched
      Resources object and the ClassLoader that loads itself, which will be
      DynamicClassLoader in the case of running as a delegate app.
      By directly patching the base Context of ContextWrappers (which covers
      tons of app components) and in the Koin DI, the effect propagates deep
      into every aspect of the code, making this change basically fully
      transparent to almost every piece of code in full Magisk Manager.
      
      After this commit, the stub app is able to properly download and launch
      the full app, with most basic functionalities working just fine.
      Do not expect Magisk Manager upgrades and hiding (repackaging) to
      work properly, and some other minor issues might pop up.
      This feature is still in the early WIP stages.
      5ffb9eaa
  6. 12 Oct, 2019 7 commits
  7. 11 Oct, 2019 5 commits
  8. 10 Oct, 2019 6 commits
  9. 09 Oct, 2019 3 commits
  10. 08 Oct, 2019 2 commits