diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1bc690c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,89 @@
+
+# Built application files
+*.apk
+*.aar
+*.ap_
+*.aab
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+out/
+# Uncomment the following line in case you need and you don't have the release build type files in your app
+# release/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+# IntelliJ
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/assetWizardSettings.xml
+.idea/dictionaries
+.idea/libraries
+# Android Studio 3 in .gitignore file.
+.idea/caches
+.idea/modules.xml
+# Comment next line if keeping position of elements in Navigation Editor is relevant for you
+.idea/navEditor.xml
+
+# Keystore files
+# Uncomment the following lines if you do not want to check your keystore files in.
+#*.jks
+#*.keystore
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+.cxx/
+
+# Google Services (e.g. APIs or Firebase)
+# google-services.json
+
+# Freeline
+freeline.py
+freeline/
+freeline_project_description.json
+
+# fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+fastlane/readme.md
+
+# Version control
+vcs.xml
+
+# lint
+lint/intermediates/
+lint/generated/
+lint/outputs/
+lint/tmp/
+# lint/reports/
+
+# Android Profiling
+*.hprof
\ No newline at end of file
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
new file mode 100644
index 0000000..3279b6b
--- /dev/null
+++ b/.idea/codeStyles/Project.xml
@@ -0,0 +1,116 @@
+
+
+
+
+
+
+
+
+
+
+
+
+ xmlns:android
+
+ ^$
+
+
+
+
+
+
+
+
+ xmlns:.*
+
+ ^$
+
+
+ BY_NAME
+
+
+
+
+
+
+ .*:id
+
+ http://schemas.android.com/apk/res/android
+
+
+
+
+
+
+
+
+ .*:name
+
+ http://schemas.android.com/apk/res/android
+
+
+
+
+
+
+
+
+ name
+
+ ^$
+
+
+
+
+
+
+
+
+ style
+
+ ^$
+
+
+
+
+
+
+
+
+ .*
+
+ ^$
+
+
+ BY_NAME
+
+
+
+
+
+
+ .*
+
+ http://schemas.android.com/apk/res/android
+
+
+ ANDROID_ATTRIBUTE_ORDER
+
+
+
+
+
+
+ .*
+
+ .*
+
+
+ BY_NAME
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
new file mode 100644
index 0000000..17c8136
--- /dev/null
+++ b/.idea/jarRepositories.xml
@@ -0,0 +1,25 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..f797995
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml
new file mode 100644
index 0000000..9b770a6
--- /dev/null
+++ b/.idea/runConfigurations.xml
@@ -0,0 +1,12 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ 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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d8f83a8
--- /dev/null
+++ b/README.md
@@ -0,0 +1,377 @@
+**This template is not for newbies/noobs. You need basic knowledge of C++, Java, dalvik opcodes, ARM and ARM64 assembly, and be able to patch hex and hook. You will be expected to read, learn and even google. If you don't have the knowledge, this tutorial will be too hard for you**
+
+**If you don't like this project, do not use. Please do not spread hate and insult against me, especially the smaller kids community. Instead, tell me why you don't like and what I can improve**
+
+# Introduction
+Simple floating mod menu with sounds for il2cpp and other native android games, KittyMemory, MSHook, and And64InlineHook included. This template is optimized for modders who want the faster way to implement the menu in the game without hassle. Assets are stored as base64 in java/smali and does not need to be stored under assets folder.
+
+It comes with string and offset obfuscation without using any external tool and without modifying the compiler. We use AY Obfuscator
+
+Support Android 4.2.x way up to Android R preview. Support ARMv7, x86 and ARM64 architecture. However x86 is deprecated for Unity games so x86 is not our priority
+
+Mod menu is based on Octowolve/Escanor and Van's template.
+
+Preview:
+
+
+
+# What will you need?
+- Android Studio 4 and up: https://developer.android.com/studio
+- Git if you want to clone a project though Android Studio (Optional): https://git-scm.com/download
+- [Apktool.jar](https://ibotpeaches.github.io/Apktool/) or any 3rd party tools: [APK Easy Tool](https://forum.xda-developers.com/android/software-hacking/tool-apk-easy-tool-v1-02-windows-gui-t3333960), [Jasi Toolkit](https://jaspreetsingh.store/jasi-toolkit/), or [INZ APKTool](https://forum.gsmhosting.com/vbb/f831/inz-apktool-2-0-windows-gui-apk-tool-2722815/)
+- Any text editor: [Notepad++](https://notepad-plus-plus.org/downloads/), [Subline](https://www.sublimetext.com/) or [Visual Studio Code](https://code.visualstudio.com/)
+- Any png compression to compress your png file: https://compresspng.com/
+- Any base64 encoding to encode your file: https://www.base64encode.org/
+- Any audio converters to convert your sound files to .ogg (Optional): [XMedia Recode](https://www.xmedia-recode.de/en/download.php)
+- This template of course
+
+# Download/Clone
+Click on the green button that says Code, the click Download ZIP
+
+
+
+Or clone through Android Studio itself (Requires Git to be installed on your machine and be configured in Android Studio)
+
+Click on "Get from Version Control"
+
+
+
+Input the git url and Clone
+
+
+
+# Install NDK
+At the bottom-right corner, click on Configure and SDK Manager
+
+
+
+Select **Android SDK**, check **NDK (Side by side)** and click OK. It will download and install
+
+
+
+# Open the mod menu template project
+Once you've downloaded all the necessary files, extract the template project to the folder without any spaces. If any folder has spaces, it will cause problem
+
+On Android Studio on the welcome screen, choose **"Open an existing Android Studio project"**
+
+Navigate to the extracted project and open it
+
+
+
+It will index and Gradle will sync the project fir the first time. Please wait for a while, it will take around 5 minutes depending your computer performance
+
+If you encounter an error
+
+```NDK not configured. Download it with SDK manager. Preferred NDK version is '20.0.5594570'```
+
+Click File and Project Structure
+
+
+
+Select default NDK version
+
+
+
+After it's done, you can start working!
+
+On the left side, you see the Project view. Default view is Android
+
+
+
+If this is somewhat confusing, change the view to Project
+
+# Making changes
+
+**LoadLib.java:**
+
+To call toast if you load lib without mod menu
+
+**MainActivity.java:**
+
+Starts the main activity. No need to use if you implement the menu in the APK file
+
+**FloatingModMenuService.java:**
+
+The codes of floating mod menu. You don't need to change much unless you want to redesign it. The codes are explained in the comments (//...)
+
+- GradientDrawable
+
+A code for setting corner and stroke/inner border. Works for any View Components
+```
+GradientDrawable gradientdrawable = new GradientDrawable();
+gradientdrawable.setCornerRadius(20); //Set corner
+gradientdrawable.setColor(Color.parseColor("#1C2A35")); //Set background color
+gradientdrawable.setStroke(1, Color.parseColor("#32cb00")); //Set border
+```
+
+Set the gradient drawable to the component
+
+```
+[name of your view component].setBackground(gradientdrawable);
+```
+
+**Sounds.java:**
+
+Basically the menu sounds, that have been converted to .ogg using XMedia Recode and encoded to base64. They are automatically decoded and stored into /data/data/(package name)/cache upon startup (See StaticActivity). Remember, we want to avoid storing files under assets as possible
+
+**StaticActivity.java:**
+
+To initialize by game activity's OnCreate
+Checks if device running Android 6.0 or above and if have overlay permission checked. Sounds being written to the cache directory.
+Start() will be called when implementing the menu to the game. We will explain later
+
+- writeToFile:
+Decode base64 and write to file to a target directory
+
+**Menu.cpp**
+
+This is menu related
+
+- EnableSounds: Change to false if you don't want it to play sounds
+
+- Title: Big text
+
+- Heading: Little text
+
+- Icon: Compressed image that is encoded to base64
+
+- IconWebViewData: Use icon in Web view with GIF animation support. URL requires internet permission `android.permission.INTERNET`
+
+```From internet: (Requires android.permission.INTERNET)
+return env->NewStringUTF("https://i.imgur.com/SujJ85j.gif");
+
+From assets folder: (Requires android.permission.INTERNET)
+return env->NewStringUTF("file:///android_asset/example.gif");
+
+Base64 html:
+return env->NewStringUTF("data:image/png;base64, ");
+
+Nothing:
+return NULL
+```
+
+- IconSize: Mod menu icon size
+
+- Toast: To get text from c++ in order to show toast in java
+
+- getFeatureList: Here you add the mod features
+
+**Main.cpp**
+
+In this file, you will mostly do implementation with your codes for modding
+
+- Changes: Get changes of toggles, seekbars, spinner and buttons to do modding. Features MUST be count from 0
+
+Usage:
+
+```
+Toggle_[feature name]
+SeekBar_[feature name]_[min value]_[max value]
+Spinner_[feature name]_[Items e.g. item1_item2_item3]
+Button_[feature name]
+Button_OnOff_[feature name]
+InputValue_[feature name]
+```
+
+Examples:
+
+```Toggle_God mode
+Spinner_Weapons_AK47_9mm_Knife
+Button_OnOff_God mode
+```
+
+Do not forget to count your features from 0 and remember them
+
+- hack_thread: Here you add your code for hacking with KittyMemory or Hooking. I will not teach, you must have learned it already
+
+- JNI_OnLoad: Initialize when the library loads
+
+**Android.mk**
+
+The make file for the c++ compiler. In that file, you can change the lib name on the `LOCAL_MODULE` line
+When you change the lib name, change also on `System.loadLibrary("")` under OnCreate method on FloatingModMenuService.java
+Both must have same name
+
+KittyMemory usage:
+```MemoryPatch::createWithHex([Lib Name], [offset], "[hex. With or without spaces]");
+[Struct].get_CurrBytes().Modify();
+[Struct].get_CurrBytes().Restore();
+
+[Struct].get_TargetAddress();
+[Struct].get_PatchSize();
+[Struct].get_CurrBytes().c_str();
+```
+
+Example: https://github.com/MJx0/KittyMemory/blob/master/Android/test/src/main.cpp
+
+Hook usage:
+ARM64:
+```A64HookFunction((void *) getAbsoluteAddress([Lib Name], [offset]), (void *) [function], (void **) &[old function]);```
+
+ARMv7/x86:
+```MSHookFunction((void *) getAbsoluteAddress([Lib Name], [offset]), (void *) [function], (void **) &[old function]);```
+
+**String obfuscation**
+
+We use AY Obfuscator but the usage has changed to `OBFUSCATE("string here")` and `OBFUSCATE_KEY("string here", 'single letter here')`
+
+# Testing the mod menu
+
+If you have your device with adb enabled, connected your PC or your emulator with adb enabled. Android Studio will detect and you can click Play to run your app onto your device/emulator
+
+
+
+To use adb, you must enable USB debugging in the device system settings, under Developer options.
+
+On Android 4.2 and higher, the Developer options screen is hidden by default. To make it visible, go to **Settings** > **About phone** and tap Build number seven times. Return to the previous screen to find Developer options at the bottom.
+
+On some devices, the Developer options screen might be located or named differently.
+
+# Implementing the menu in the target game
+
+After you finished the menu, you can build the project to APK file.
+**Build** -> **Build Bundle(s)/APK(s)** -> **Build APK(s)**
+
+If no errors occured, you did everything right and build will succeded. You will be notified that it build successfully
+
+
+
+Click on **locate** to show you the location of **build.apk**. It is stored at `(your-project)\app\build\outputs\apk\ app-debug.apk`
+
+
+
+Now you will need to decompile **app-debug.apk**. Decompile the target game as well
+
+Open the game's `androidmanifest.xml`
+Add the permission besides other permissions
+```
+
+```
+
+
+
+And add the service below the application tag (change the package name if you had changed it)
+```
+
+```
+
+Save the **AndroidManifest.xml** file
+
+Now we are looking for main activity, it is ususally written under application tag. The activity name may be different. If you spotted `android:name="android.intent.action.MAIN"` you will immediately know this is main activity
+
+Be sure to enable Word wrap so it is easier to read
+
+
+
+Or open the apk in APK Easy Tool and look for main activity
+
+
+
+In this case, the path to main activity was `com.funcube.loa.MainActivity`. I would navigate to `(decompiled game)/smali/com/funcube/loa/` and you will see **MainActivity.smali**. If the game have multi dex, find out which smali folder has the main activity, it should be in one of these folders.
+
+Open the main acitivity's smali file, search for OnCreate method and paste this code inside (change the package name if you had changed it)
+```
+ invoke-static {p0}, Luk/lgl/modmenu/StaticActivity;->Start(Landroid/content/Context;)V
+```
+
+
+
+Save the file
+
+Copy your mod menu from decompiled app-debug.apk smali to the game's smali folder. Example mine is uk.lgl.modmenu, I copy the `uk` folder from **app-debug** `(app-debug\smali\uk)` to the game's decompiled directory `(game name)\smali`
+
+
+
+Very important for multi dex games. Let's say if main activity is located in **smali_classes2**, I would put my mod menu in **smali_classes2**
+
+Copy the library file (.so) from **app-debug.apk** to the target game. Make sure to copy .so to the correct architecture
+armeabi-v7a is armeabi-v7a, arm64-v8a is arm64-v8a, and so on.
+Putting the .so on a wrong architecture will result a crash
+
+
+
+Now compile and sign the apk
+If compile fail, read the log and look up on Google
+
+If the mod menu appears and the hack are working, congratz!
+
+If you face any problem, be sure to check the logcat, and if it was native related, write the log such as `LOGD("whatever");` in your cpp codes, recompile and capture the logcat. See what part of your code faced the problem. Logcat may also tell you if hooking fails (lib crash)
+
+Thanks for reading the tutorial
+
+Do not forget to check my template again. I may change it anytime =D
+
+# Load lib without mod menu
+
+Just call the LoadLib in the OnCreate method
+```
+ invoke-static {p0}, Luk/lgl/loadlib/LoadLib;->Start(Landroid/content/Context;)V
+```
+
+And uncomment the isToastCalled check in hack_thread function
+
+# FAQ
+Q: ERROR: executing external native build for ndkBuild
+
+A: Install NDK first
+
+
+Q: I have a problem decompiling and compiling APK file
+
+A: Check if apk is not protected. If not, search for the related issues: https://github.com/iBotPeaches/Apktool/issues
+
+
+Q: Getting strange issues on Android Studio or Gradle
+
+A: If you can't find a solution on Google, try invalidate caches. Click **File** -> **Invalidate Caches/Restart**. Let it load. In some cases, you may need to reinstall Android Studio
+
+
+Q: Can I load lib without mod menu?
+
+A: Yes you can, just put this code
+
+
+Q: I'm getting an error "Unsigned short value out of range: 65536" if I compile
+
+A: The method index can't fit into an unsigned 16-bit value, means you have too many methods above 65535. Place your code on other classes, such as smali_classes2 instead. This work for Android 5 (Lollipop) and above only. Many thanks Andnix for the tip
+
+
+Q: How to get older version of the template?
+
+A: Go to the commit page https://github.com/LGLTeam/Android-Mod-Menu/commits/master
+
+# Contact
+
+- Telegram: @Radidas
+- Discord: LGL#2184
+
+Newbies are the lowest priority, I may not be able to respond at all. You will be blocked if you beg me to teach/spoonfeed. Don't define me a teacher, i'm not a teacher :P
+
+# Useful links
+* https://piin.dev/basic-hooking-tutorial-t19.html
+
+* https://iosgods.com/topic/65529-instance-variables-and-function-pointers/
+
+* https://guidedhacking.com/threads/android-function-pointers-hooking-template-tutorial.14771/
+
+* http://www.cydiasubstrate.com/api/c/MSHookFunction/
+
+# Credits/Acknowledgements
+Thanks to the following individuals whose code helped me develop this mod menu
+
+* Octowolve/Escanor - Mod menu: https://github.com/z3r0Sec/Substrate-Template-With-Mod-Menu and Hooking: https://github.com/z3r0Sec/Substrate-Hooking-Example
+
+* VanHoevenTR - Mod menu - https://github.com/LGLTeam/VanHoevenTR_Android_Mod_Menu
+
+* MrIkso - First mod menu template https://github.com/MrIkso/FloatingModMenu
+
+* MJx0 A.K.A Ruit - https://github.com/MJx0/KittyMemory
+
+* Rprop - https://github.com/Rprop/And64InlineHook
+
+* Google - Android UI sounds
+
+* Material.io - https://material.io/design/sound/sound-resources.html#
\ No newline at end of file
diff --git a/app/.gitignore b/app/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/app/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/app/build.gradle b/app/build.gradle
new file mode 100644
index 0000000..f187cd0
--- /dev/null
+++ b/app/build.gradle
@@ -0,0 +1,36 @@
+apply plugin: 'com.android.application'
+
+android {
+ compileSdkVersion 28
+ defaultConfig {
+ applicationId "uk.lgl.modmenu"
+ minSdkVersion 17
+ targetSdkVersion 28
+ versionCode 1
+ versionName "1.3"
+ testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+ ndk {
+ abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86'
+ }
+ signingConfig signingConfigs.debug
+ }
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+ }
+ debug {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+ }
+ }
+ externalNativeBuild {
+ ndkBuild {
+ path file('src/main/jni/Android.mk')
+ }
+ }
+ ndkVersion = '21.3.6528147'
+ dependencies {
+ implementation fileTree(dir: 'libs', include: ['*.jar'])
+ }
+}
\ No newline at end of file
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
new file mode 100644
index 0000000..dd80a81
--- /dev/null
+++ b/app/proguard-rules.pro
@@ -0,0 +1,22 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+#-dontobfuscate
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..1d4f410
--- /dev/null
+++ b/app/src/main/AndroidManifest.xml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/java/uk/lgl/loadlib/LoadLib.java b/app/src/main/java/uk/lgl/loadlib/LoadLib.java
new file mode 100644
index 0000000..97295ea
--- /dev/null
+++ b/app/src/main/java/uk/lgl/loadlib/LoadLib.java
@@ -0,0 +1,24 @@
+package uk.lgl.loadlib;
+
+import android.content.Context;
+import android.os.Handler;
+
+public class LoadLib {
+ private native void Toast(Context context);
+
+ public static void Start(final Context context) {
+ // When you change the lib name, change also on Android.mk file
+ // Both must have same name
+ System.loadLibrary("HadesNull");
+
+ new Handler().postDelayed(new Runnable() {
+ /* class com.loadLib.libLoader.AnonymousClass1 */
+
+ public void run() {
+ //We need getApplicationContext() to fix background issue with toast
+ LoadLib instance = new LoadLib();
+ instance.Toast(context.getApplicationContext());
+ }
+ }, 2000);
+ }
+}
diff --git a/app/src/main/java/uk/lgl/modmenu/FloatingModMenuService.java b/app/src/main/java/uk/lgl/modmenu/FloatingModMenuService.java
new file mode 100644
index 0000000..dbfadd2
--- /dev/null
+++ b/app/src/main/java/uk/lgl/modmenu/FloatingModMenuService.java
@@ -0,0 +1,799 @@
+/*
+ * Credit:
+ *
+ * Octowolve - Mod menu: https://github.com/z3r0Sec/Substrate-Template-With-Mod-Menu
+ * And hooking: https://github.com/z3r0Sec/Substrate-Hooking-Example
+ * VanHoevenTR A.K.A Nixi: https://github.com/LGLTeam/VanHoevenTR_Android_Mod_Menu
+ * MrIkso - Mod menu: https://github.com/MrIkso/FloatingModMenu
+ * Rprop - https://github.com/Rprop/And64InlineHook
+ * MJx0 A.K.A Ruit - KittyMemory: https://github.com/MJx0/KittyMemory
+ * */
+
+package uk.lgl.modmenu;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningAppProcessInfo;
+import android.app.AlertDialog;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.Typeface;
+import android.graphics.drawable.GradientDrawable;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.IBinder;
+
+import android.text.Html;
+import android.text.InputFilter;
+import android.text.InputType;
+import android.text.method.DigitsKeyListener;
+import android.util.Base64;
+import android.util.TypedValue;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.ScrollView;
+import android.widget.SeekBar;
+import android.widget.Spinner;
+import android.widget.Switch;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+import static uk.lgl.modmenu.StaticActivity.cacheDir;
+
+public class FloatingModMenuService extends Service {
+ private MediaPlayer FXPlayer;
+ public RelativeLayout mCollapsed;
+ public LinearLayout mExpanded;
+ private RelativeLayout mRootContainer;
+ public WindowManager mWindowManager;
+ public WindowManager.LayoutParams params;
+ private LinearLayout patches;
+ private ImageView startimage;
+ private FrameLayout rootFrame;
+ private AlertDialog alert;
+ private EditText edittextvalue;
+
+ //For alert dialog
+ private TextView textView2;
+ private String featureNameExt;
+ private int featureNum;
+ private EditTextValue txtValue;
+
+ public class EditTextValue {
+ private int val;
+
+ public void setValue(int i) {
+ val = i;
+ }
+
+ public int getValue() {
+ return val;
+ }
+ }
+
+ private static final String TAG = "Mod Menu";
+
+ //initialize methods from the native library
+ public native void ToastStartup();
+
+ private native String Title();
+
+ private native String Heading();
+
+ private native String Icon();
+
+ private native String IconWebViewData();
+
+ private native boolean EnableSounds();
+
+ private native int IconSize();
+
+ public native void Changes(int feature, int value);
+
+ private native String[] getFeatureList();
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return null;
+ }
+
+ //Override our Start Command so the Service doesnt try to recreate itself when the App is closed
+ public int onStartCommand(Intent intent, int i, int i2) {
+ return Service.START_NOT_STICKY;
+ }
+
+ //When this Class is called the code in this function will be executed
+ @Override
+ public void onCreate() {
+ super.onCreate();
+
+ //A little message for the user when he opens the app
+ ToastStartup();
+
+ initFloating();
+ initAlertDiag();
+
+ final Handler handler = new Handler();
+ handler.post(new Runnable() {
+ public void run() {
+ Thread();
+ handler.postDelayed(this, 1000);
+ }
+ });
+ }
+
+ //Here we write the code for our Menu
+ private void initFloating() {
+ rootFrame = new FrameLayout(getBaseContext()); // Global markup
+ rootFrame.setLayoutParams(new FrameLayout.LayoutParams(-1, -1));
+ rootFrame.setOnTouchListener(onTouchListener());
+ mRootContainer = new RelativeLayout(getBaseContext()); // Markup on which two markups of the icon and the menu itself will be placed
+ mRootContainer.setLayoutParams(new FrameLayout.LayoutParams(-2, -2));
+ mCollapsed = new RelativeLayout(getBaseContext()); // Markup of the icon (when the menu is minimized)
+ mCollapsed.setLayoutParams(new RelativeLayout.LayoutParams(-2, -2));
+ mCollapsed.setVisibility(View.VISIBLE);
+ mExpanded = new LinearLayout(getBaseContext()); // Menu markup (when the menu is expanded)
+ patches = new LinearLayout(getBaseContext());
+
+ RelativeLayout relativeLayout = new RelativeLayout(this);
+ relativeLayout.setLayoutParams(new RelativeLayout.LayoutParams(-2, -1));
+ relativeLayout.setPadding(10, 3, 10, 3);
+ relativeLayout.setVerticalGravity(16);
+
+ //********** Hide/Kill button **********
+ Button hideBtn = new Button(this);
+ hideBtn.setBackgroundColor(Color.TRANSPARENT);
+ hideBtn.setText("HIDE/KILL (Hold)");
+ hideBtn.setTextColor(Color.parseColor("#82CAFD"));
+ hideBtn.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View view) {
+ mCollapsed.setVisibility(View.VISIBLE);
+ mCollapsed.setAlpha(0);
+ mExpanded.setVisibility(View.GONE);
+ Toast.makeText(view.getContext(), "Icon hidden. Remember the hidden icon position", Toast.LENGTH_LONG).show();
+ playSound(Uri.fromFile(new File(cacheDir + "Back.ogg")));
+ }
+ });
+ hideBtn.setOnLongClickListener(new View.OnLongClickListener() {
+ public boolean onLongClick(View view) {
+ Toast.makeText(view.getContext(), "Menu service killed", Toast.LENGTH_LONG).show();
+ playSound(Uri.fromFile(new File(cacheDir + "Back.ogg")));
+ FloatingModMenuService.this.stopSelf();
+ return false;
+ }
+ });
+
+ //********** Close button **********
+ Button closeBtn = new Button(this);
+ closeBtn.setBackgroundColor(Color.TRANSPARENT);
+ closeBtn.setText("CLOSE");
+ closeBtn.setTextColor(Color.parseColor("#82CAFD"));
+ closeBtn.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View view) {
+ mCollapsed.setVisibility(View.VISIBLE);
+ mCollapsed.setAlpha(0.95f);
+ mExpanded.setVisibility(View.GONE);
+ playSound(Uri.fromFile(new File(cacheDir + "Back.ogg")));
+ //Log.i("LGL", "Close");
+ }
+ });
+ RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
+ layoutParams.addRule(11);
+ closeBtn.setLayoutParams(layoutParams);
+
+ //********** The icon to open mod menu **********
+ startimage = new ImageView(getBaseContext());
+ startimage.setLayoutParams(new RelativeLayout.LayoutParams(-2, -2));
+ int applyDimension = (int) TypedValue.applyDimension(1, (float) IconSize(), getResources().getDisplayMetrics());
+ startimage.getLayoutParams().height = applyDimension;
+ startimage.getLayoutParams().width = applyDimension;
+ startimage.requestLayout();
+ startimage.setScaleType(ImageView.ScaleType.FIT_XY);
+ byte[] decode = Base64.decode(Icon(), 0);
+ startimage.setImageBitmap(BitmapFactory.decodeByteArray(decode, 0, decode.length));
+ startimage.setImageAlpha(200);
+ ((ViewGroup.MarginLayoutParams) startimage.getLayoutParams()).topMargin = convertDipToPixels(10);
+ //Initialize event handlers for buttons, etc.
+ startimage.setOnTouchListener(onTouchListener());
+ startimage.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View view) {
+ mCollapsed.setVisibility(View.GONE);
+ mExpanded.setVisibility(View.VISIBLE);
+ }
+ });
+
+ //********** Webview **********
+ WebView wView = new WebView(this);
+ wView.loadData("![](\"")
", "text/html", "utf-8");
+ wView.setBackgroundColor(0x00000000);
+ wView.setLayoutParams(new RelativeLayout.LayoutParams(-2, -2));
+ wView.getLayoutParams().height = applyDimension;
+ wView.getLayoutParams().width = applyDimension;
+ wView.requestLayout();
+ wView.setAlpha(0.9f);
+ wView.getSettings().setAppCachePath("/data/data/" + getPackageName() + "/cache");
+ wView.getSettings().setAppCacheEnabled(true);
+ wView.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
+ wView.setOnTouchListener(onTouchListener());
+
+ //********** The box of the mod menu **********
+ mExpanded.setVisibility(View.GONE);
+ mExpanded.setBackgroundColor(Color.parseColor("#1C2A35"));
+ mExpanded.setAlpha(0.95f);
+ mExpanded.setGravity(17);
+ mExpanded.setOrientation(LinearLayout.VERTICAL);
+ mExpanded.setPadding(0, 0, 0, 0);
+ //Auto size. To set size manually, change the width and height example 500, 500
+ mExpanded.setLayoutParams(new LinearLayout.LayoutParams(-1, -2));
+ GradientDrawable gradientdrawable = new GradientDrawable();
+ gradientdrawable.setCornerRadius(20); //Set corner
+ gradientdrawable.setColor(Color.parseColor("#1C2A35")); //Set background color
+ //gradientdrawable.setStroke(1, Color.parseColor("#32cb00")); //Set border
+ mExpanded.setBackground(gradientdrawable); //Apply GradientDrawable to it
+
+ //********** Mod menu feature list **********
+ ScrollView scrollView = new ScrollView(getBaseContext());
+ scrollView.setLayoutParams(new LinearLayout.LayoutParams(-1, dp(200)));
+ scrollView.setBackgroundColor(Color.parseColor("#171E24"));
+
+ patches.setLayoutParams(new LinearLayout.LayoutParams(-1, -1));
+ patches.setOrientation(LinearLayout.VERTICAL);
+
+ //********** Title text **********
+ TextView title = new TextView(getBaseContext());
+ title.setText(Title());
+ title.setTextColor(Color.parseColor("#82CAFD"));
+ title.setTypeface(Typeface.DEFAULT_BOLD);
+ title.setTextSize(20.0f);
+ title.setPadding(0, 10, 0, 5);
+ LinearLayout.LayoutParams layoutParams2 = new LinearLayout.LayoutParams(-2, -2);
+ layoutParams2.gravity = 17;
+ title.setLayoutParams(layoutParams2);
+
+ //********** Heading text **********
+ TextView heading = new TextView(getBaseContext());
+ heading.setText(Html.fromHtml(Heading()));
+ heading.setTextColor(Color.parseColor("#82CAFD"));
+ heading.setTypeface(Typeface.DEFAULT_BOLD);
+ heading.setTextSize(10.0f);
+ heading.setPadding(10, 5, 10, 10);
+ LinearLayout.LayoutParams layoutParams3 = new LinearLayout.LayoutParams(-2, -2);
+ layoutParams3.gravity = 17;
+ heading.setLayoutParams(layoutParams3);
+
+ //********** Params **********
+ if (Build.VERSION.SDK_INT >= 26) {
+ params = new WindowManager.LayoutParams(-2, -2, 2038, 8, -3);
+ } else {
+ params = new WindowManager.LayoutParams(-2, -2, 2002, 8, -3);
+ }
+ params.gravity = 51;
+ params.x = 0;
+ params.y = 100;
+
+ //********** Adding view components **********
+ rootFrame.addView(mRootContainer);
+ mRootContainer.addView(mCollapsed);
+ mRootContainer.addView(mExpanded);
+ if (IconWebViewData() != null) {
+ mCollapsed.addView(wView);
+ } else {
+ mCollapsed.addView(startimage);
+ }
+ mExpanded.addView(title);
+ mExpanded.addView(heading);
+ mExpanded.addView(scrollView);
+ scrollView.addView(patches);
+ relativeLayout.addView(hideBtn);
+ relativeLayout.addView(closeBtn);
+ mExpanded.addView(relativeLayout);
+
+ mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
+ mWindowManager.addView(rootFrame, params);
+
+ //********** Create menu list **********
+ CreateMenuList();
+ }
+
+ private void initAlertDiag() {
+ LinearLayout linearLayout1 = new LinearLayout(this);
+ LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, -1);
+ linearLayout1.setPadding(10, 5, 0, 5);
+ linearLayout1.setOrientation(LinearLayout.VERTICAL);
+ linearLayout1.setGravity(17);
+ linearLayout1.setLayoutParams(layoutParams);
+ linearLayout1.setBackgroundColor(Color.parseColor("#171E24"));
+
+ LinearLayout linearLayout = new LinearLayout(this);
+ linearLayout.setLayoutParams(new LinearLayout.LayoutParams(-1, -1));
+ linearLayout.setBackgroundColor(Color.parseColor("#14171f"));
+ linearLayout.setOrientation(LinearLayout.VERTICAL);
+ FrameLayout frameLayout = new FrameLayout(this);
+ frameLayout.setLayoutParams(new FrameLayout.LayoutParams(-2, -2));
+ frameLayout.addView(linearLayout);
+
+ final TextView textView = new TextView(this);
+ textView.setText(Html.fromHtml("Tap OK to apply changes. Tap outside to cancel"));
+ textView.setTextColor(Color.parseColor("#DEEDF6"));
+ textView.setLayoutParams(layoutParams);
+
+ edittextvalue = new EditText(this);
+ edittextvalue.setLayoutParams(layoutParams);
+ edittextvalue.setMaxLines(1);
+ edittextvalue.setWidth(convertDipToPixels(300));
+ edittextvalue.setTextColor(Color.parseColor("#93a6ae"));
+ edittextvalue.setTextSize(13.0f);
+ edittextvalue.setHintTextColor(Color.parseColor("#434d52"));
+ edittextvalue.setInputType(InputType.TYPE_CLASS_NUMBER);
+ edittextvalue.setKeyListener(DigitsKeyListener.getInstance("0123456789-"));
+
+ InputFilter[] FilterArray = new InputFilter[1];
+ FilterArray[0] = new InputFilter.LengthFilter(10);
+ edittextvalue.setFilters(FilterArray);
+
+ Button button = new Button(this);
+ button.setBackgroundColor(Color.parseColor("#1C262D"));
+ button.setTextColor(Color.parseColor("#D5E3EB"));
+ button.setText("OK");
+ button.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ Changes(featureNum, Integer.parseInt(edittextvalue.getText().toString()));
+ txtValue.setValue(Integer.parseInt(edittextvalue.getText().toString()));
+ textView2.setText(Html.fromHtml("" + featureNameExt + ": " + edittextvalue.getText().toString() + ""));
+ alert.dismiss();
+ playSound(Uri.fromFile(new File(cacheDir + "Select.ogg")));
+ //interStr.OnWrite(editText.getText().toString());
+ }
+ });
+
+ alert = new AlertDialog.Builder(this, 2).create();
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+ Objects.requireNonNull(alert.getWindow()).setType(Build.VERSION.SDK_INT >= 26 ? 2038 : 2002);
+ }
+ linearLayout1.addView(textView);
+ linearLayout1.addView(edittextvalue);
+ linearLayout1.addView(button);
+ alert.setView(linearLayout1);
+ }
+
+ private View.OnTouchListener onTouchListener() {
+ return new View.OnTouchListener() {
+ final View collapsedView = mCollapsed;
+ final View expandedView = mExpanded;
+ private float initialTouchX;
+ private float initialTouchY;
+ private int initialX;
+ private int initialY;
+
+ public boolean onTouch(View view, MotionEvent motionEvent) {
+ switch (motionEvent.getAction()) {
+ case MotionEvent.ACTION_DOWN:
+ initialX = params.x;
+ initialY = params.y;
+ initialTouchX = motionEvent.getRawX();
+ initialTouchY = motionEvent.getRawY();
+ return true;
+ case MotionEvent.ACTION_UP:
+ int rawX = (int) (motionEvent.getRawX() - initialTouchX);
+ int rawY = (int) (motionEvent.getRawY() - initialTouchY);
+
+ //The check for Xdiff <10 && YDiff< 10 because sometime elements moves a little while clicking.
+ //So that is click event.
+ if (rawX < 10 && rawY < 10 && isViewCollapsed()) {
+ //When user clicks on the image view of the collapsed layout,
+ //visibility of the collapsed layout will be changed to "View.GONE"
+ //and expanded view will become visible.
+ collapsedView.setVisibility(View.GONE);
+ expandedView.setVisibility(View.VISIBLE);
+ playSound(Uri.fromFile(new File(cacheDir + "OpenMenu.ogg")));
+ //Toast.makeText(FloatingModMenuService.this, Html.fromHtml(Toast()), Toast.LENGTH_SHORT).show();
+ }
+ return true;
+ case MotionEvent.ACTION_MOVE:
+ //Calculate the X and Y coordinates of the view.
+ params.x = initialX + ((int) (motionEvent.getRawX() - initialTouchX));
+ params.y = initialY + ((int) (motionEvent.getRawY() - initialTouchY));
+ //Update the layout with new X & Y coordinate
+ mWindowManager.updateViewLayout(rootFrame, params);
+ return true;
+ default:
+ return false;
+ }
+ }
+ };
+ }
+
+ private void CreateMenuList() {
+ String[] listFT = getFeatureList();
+ for (int i = 0; i < listFT.length; i++) {
+ final int feature = i;
+ String str = listFT[i];
+ if (str.contains("Toggle_")) {
+ addSwitch(str.replace("Toggle_", ""), new InterfaceBool() {
+ public void OnWrite(boolean z) {
+ Changes(feature, 0);
+ }
+ });
+ } else if (str.contains("SeekBar_")) {
+ String[] split = str.split("_");
+ addSeekBar(split[1], Integer.parseInt(split[2]), Integer.parseInt(split[3]), new InterfaceInt() {
+ public void OnWrite(int i) {
+ Changes(feature, i);
+ }
+ });
+ } else if (str.contains("Category_")) {
+ addCategory(str.replace("Category_", ""));
+ } else if (str.contains("Button_")) {
+ addButton(str.replace("Button_", ""), new InterfaceBtn() {
+ public void OnWrite() {
+ Changes(feature, 0);
+ }
+ });
+ } else if (str.contains("Spinner_")) {
+ addSpinner(str.replace("Spinner_", ""), new InterfaceInt() {
+ @Override
+ public void OnWrite(int i) {
+ Changes(feature, i);
+ }
+ });
+ } else if (str.contains("InputValue_")) {
+ addTextField(str.replace("InputValue_", ""), feature, new InterfaceInt() {
+ @Override
+ public void OnWrite(int i) {
+ Changes(feature, 0);
+ }
+ });
+ }
+ }
+ }
+
+ private void addTextField(final String featureName, final int feature, final InterfaceInt interInt) {
+ RelativeLayout relativeLayout2 = new RelativeLayout(this);
+ relativeLayout2.setLayoutParams(new RelativeLayout.LayoutParams(-2, -1));
+ relativeLayout2.setPadding(10, 5, 10, 5);
+ relativeLayout2.setVerticalGravity(16);
+
+ RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-2, -2);
+ layoutParams.topMargin = 10;
+
+ final TextView textView = new TextView(this);
+ textView.setText(Html.fromHtml("" + featureName + ": Not set"));
+ textView.setTextColor(Color.parseColor("#DEEDF6"));
+ textView.setLayoutParams(layoutParams);
+
+ final TextView textViewRem = new TextView(this);
+ textViewRem.setText("");
+
+ final EditTextValue edittextval = new EditTextValue();
+
+ RelativeLayout.LayoutParams layoutParams2 = new RelativeLayout.LayoutParams(-2, -2);
+ layoutParams2.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
+
+ Button button2 = new Button(this);
+ button2.setLayoutParams(layoutParams2);
+ button2.setBackgroundColor(Color.parseColor("#1C262D"));
+ button2.setText("SET");
+ button2.setTextColor(Color.parseColor("#D5E3EB"));
+ button2.setGravity(17);
+ button2.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ alert.show();
+ textView2 = textView;
+ featureNum = feature;
+ featureNameExt = featureName;
+ txtValue = edittextval;
+
+ edittextvalue.setText(String.valueOf(edittextval.getValue()));
+ }
+ });
+
+ relativeLayout2.addView(textView);
+ relativeLayout2.addView(button2);
+ patches.addView(relativeLayout2);
+ }
+
+ private void addSpinner(String feature, final InterfaceInt interInt) {
+ List list = new LinkedList<>(Arrays.asList(feature.split("_")));
+
+ LinearLayout linearLayout = new LinearLayout(this);
+ LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, -1);
+ linearLayout.setPadding(10, 5, 10, 5);
+ linearLayout.setOrientation(LinearLayout.VERTICAL);
+ linearLayout.setGravity(17);
+ linearLayout.setLayoutParams(layoutParams);
+ linearLayout.setBackgroundColor(Color.parseColor("#171E24"));
+
+ final TextView textView = new TextView(this);
+ textView.setText(Html.fromHtml("" + list.get(0) + ": "));
+ textView.setTextColor(Color.parseColor("#DEEDF6"));
+
+ // Create another LinearLayout as a workaround to use it as a background
+ // and to keep the 'down' arrow symbol
+ // If spinner had the setBackgroundColor set, there would be no arrow symbol
+ LinearLayout linearLayout2 = new LinearLayout(this);
+ LinearLayout.LayoutParams layoutParams2 = new LinearLayout.LayoutParams(-1, -1);
+ layoutParams2.setMargins(10, 2, 10, 5);
+ linearLayout2.setOrientation(LinearLayout.VERTICAL);
+ linearLayout2.setGravity(17);
+ linearLayout2.setBackgroundColor(Color.parseColor("#1C262D"));
+ linearLayout2.setLayoutParams(layoutParams2);
+
+ Spinner spinner = new Spinner(this);
+ spinner.setPadding(5, 10, 5, 8);
+ spinner.setLayoutParams(layoutParams2);
+ spinner.getBackground().setColorFilter(1, PorterDuff.Mode.SRC_ATOP); //trick to show white down arrow color
+ //Creating the ArrayAdapter instance having the list
+ list.remove(0);
+ ArrayAdapter aa = new ArrayAdapter(this, android.R.layout.simple_spinner_item, list);
+ aa.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ //Setting the ArrayAdapter data on the Spinner
+ spinner.setAdapter(aa);
+ spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
+ @Override
+ public void onItemSelected(AdapterView parentView, View selectedItemView, int position, long id) {
+ ((TextView) parentView.getChildAt(0)).setTextColor(Color.parseColor("#f5f5f5"));
+ interInt.OnWrite(position);
+ playSound(Uri.fromFile(new File(cacheDir + "Select.ogg")));
+ }
+
+ @Override
+ public void onNothingSelected(AdapterView parent) {
+ playSound(Uri.fromFile(new File(cacheDir + "Select.ogg")));
+ }
+ });
+ linearLayout.addView(textView);
+ linearLayout2.addView(spinner);
+ patches.addView(linearLayout);
+ patches.addView(linearLayout2);
+ }
+
+ private void addCategory(String text) {
+ TextView textView = new TextView(this);
+ textView.setBackgroundColor(Color.parseColor("#2F3D4C"));
+ textView.setText(text);
+ textView.setGravity(17);
+ textView.setTextSize(14.0f);
+ textView.setTextColor(Color.parseColor("#DEEDF6"));
+ textView.setTypeface(null, Typeface.BOLD);
+ textView.setPadding(0, 5, 0, 5);
+ patches.addView(textView);
+ }
+
+ private void addButton(String feature, final InterfaceBtn interfaceBtn) {
+ final Button button = new Button(this);
+ LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, -1);
+ layoutParams.setMargins(7, 5, 7, 5);
+ button.setLayoutParams(layoutParams);
+ button.setPadding(10, 5, 10, 5);
+ button.setTextSize(13.0f);
+ button.setTextColor(Color.parseColor("#D5E3EB"));
+ button.setGravity(17);
+
+ if (feature.contains("OnOff_")) {
+ feature = feature.replace("OnOff_", "");
+ button.setText(feature + ": OFF");
+ button.setBackgroundColor(Color.parseColor("#7f0000"));
+ final String feature2 = feature;
+ button.setOnClickListener(new View.OnClickListener() {
+ private boolean isActive = true;
+
+ public void onClick(View v) {
+ interfaceBtn.OnWrite();
+ if (isActive) {
+ playSound(Uri.fromFile(new File(cacheDir + "On.ogg")));
+ button.setText(feature2 + ": ON");
+ button.setBackgroundColor(Color.parseColor("#003300"));
+ isActive = false;
+ return;
+ }
+ playSound(Uri.fromFile(new File(cacheDir + "Off.ogg")));
+ button.setText(feature2 + ": OFF");
+ button.setBackgroundColor(Color.parseColor("#7f0000"));
+ isActive = true;
+ }
+ });
+ } else {
+ button.setText(feature);
+ button.setBackgroundColor(Color.parseColor("#1C262D"));
+ final String feature2 = feature;
+ button.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View v) {
+ interfaceBtn.OnWrite();
+ playSound(Uri.fromFile(new File(cacheDir + "Select.ogg")));
+ }
+ });
+ }
+ patches.addView(button);
+ }
+
+ private void addSwitch(String feature, final InterfaceBool sw) {
+ Switch switchR = new Switch(this);
+ switchR.setBackgroundColor(Color.parseColor("#171E24"));
+ switchR.setText(Html.fromHtml("" + feature + ""));
+ switchR.setTextColor(Color.parseColor("#DEEDF6"));
+ switchR.setPadding(10, 5, 0, 5);
+ switchR.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton compoundButton, boolean z) {
+ if (z) {
+ playSound(Uri.fromFile(new File(cacheDir + "On.ogg")));
+ } else {
+ playSound(Uri.fromFile(new File(cacheDir + "Off.ogg")));
+ }
+ sw.OnWrite(z);
+ }
+ });
+ patches.addView(switchR);
+ }
+
+ private void addSeekBar(final String feature, final int prog, int max, final InterfaceInt interInt) {
+ LinearLayout linearLayout = new LinearLayout(this);
+ LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, -1);
+ linearLayout.setPadding(10, 5, 0, 5);
+ linearLayout.setOrientation(LinearLayout.VERTICAL);
+ linearLayout.setGravity(17);
+ linearLayout.setLayoutParams(layoutParams);
+ linearLayout.setBackgroundColor(Color.parseColor("#171E24"));
+
+ final TextView textView = new TextView(this);
+ textView.setText(Html.fromHtml("" + feature + ": " + prog + ""));
+ textView.setTextColor(Color.parseColor("#DEEDF6"));
+
+ SeekBar seekBar = new SeekBar(this);
+ seekBar.setPadding(25, 10, 35, 10);
+ seekBar.setLayoutParams(new LinearLayout.LayoutParams(-1, -1));
+ seekBar.setMax(max);
+ seekBar.setProgress(prog);
+ seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+ public void onStartTrackingTouch(SeekBar seekBar) {
+ }
+
+ public void onStopTrackingTouch(SeekBar seekBar) {
+ }
+
+ int l;
+
+ public void onProgressChanged(SeekBar seekBar, int i, boolean z) {
+ if (l < i) {
+ playSound(Uri.fromFile(new File(cacheDir + "SliderIncrease.ogg")));
+ } else {
+ playSound(Uri.fromFile(new File(cacheDir + "SliderDecrease.ogg")));
+ }
+ l = i;
+
+ if (i < prog) {
+ seekBar.setProgress(prog);
+ interInt.OnWrite(prog);
+ textView.setText(Html.fromHtml("" + feature + ": " + prog + ""));
+ return;
+ }
+ interInt.OnWrite(i);
+ textView.setText(Html.fromHtml("" + feature + ": " + i + ""));
+ }
+ });
+
+ linearLayout.addView(textView);
+ linearLayout.addView(seekBar);
+ patches.addView(linearLayout);
+ }
+
+ boolean delayed;
+
+ //Play sounds
+ public void playSound(Uri uri) {
+ if (EnableSounds()) {
+ if (!delayed) {
+ delayed = true;
+ if (FXPlayer != null) {
+ FXPlayer.stop();
+ FXPlayer.release();
+ }
+ FXPlayer = MediaPlayer.create(this, uri);
+ if (FXPlayer != null)
+ //Volume reduced so sounds are not too loud
+ FXPlayer.setVolume(0.5f, 0.5f);
+ FXPlayer.start();
+
+ Handler handler = new Handler();
+ handler.postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ delayed = false;
+ }
+ }, 100);
+ }
+ }
+ }
+
+ public boolean isViewCollapsed() {
+ return rootFrame == null || mCollapsed.getVisibility() == View.VISIBLE;
+ }
+
+ //For our image a little converter
+ private int convertDipToPixels(int i) {
+ return (int) ((((float) i) * getResources().getDisplayMetrics().density) + 0.5f);
+ }
+
+ private int dp(int i) {
+ return (int) TypedValue.applyDimension(1, (float) i, getResources().getDisplayMetrics());
+ }
+
+ //Destroy our View
+ public void onDestroy() {
+ super.onDestroy();
+ View view = rootFrame;
+ if (view != null) {
+ mWindowManager.removeView(view);
+ }
+ }
+
+ //Check if we are still in the game. If now our Menu and Menu button will dissapear
+ private boolean isNotInGame() {
+ RunningAppProcessInfo runningAppProcessInfo = new RunningAppProcessInfo();
+ ActivityManager.getMyMemoryState(runningAppProcessInfo);
+ return runningAppProcessInfo.importance != 100;
+ }
+
+ //Same as above so it wont crash in the background and therefore use alot of Battery life
+ public void onTaskRemoved(Intent intent) {
+ stopSelf();
+ try {
+ Thread.sleep(100);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ super.onTaskRemoved(intent);
+ }
+
+ public void Thread() {
+ if (rootFrame == null) {
+ return;
+ }
+ if (isNotInGame()) {
+ rootFrame.setVisibility(View.INVISIBLE);
+ } else {
+ rootFrame.setVisibility(View.VISIBLE);
+ }
+ }
+
+ private interface InterfaceBtn {
+ void OnWrite();
+ }
+
+ private interface InterfaceInt {
+ void OnWrite(int i);
+ }
+
+ private interface InterfaceBool {
+ void OnWrite(boolean z);
+ }
+
+ private interface InterfaceStr {
+ void OnWrite(String s);
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/uk/lgl/modmenu/MainActivity.java b/app/src/main/java/uk/lgl/modmenu/MainActivity.java
new file mode 100644
index 0000000..a759988
--- /dev/null
+++ b/app/src/main/java/uk/lgl/modmenu/MainActivity.java
@@ -0,0 +1,17 @@
+package uk.lgl.modmenu;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+import uk.lgl.loadlib.LoadLib;
+
+public class MainActivity extends Activity {
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ StaticActivity.Start(this);
+ //LoadLib.Start(this);
+ }
+}
diff --git a/app/src/main/java/uk/lgl/modmenu/Sounds.java b/app/src/main/java/uk/lgl/modmenu/Sounds.java
new file mode 100644
index 0000000..14de2b9
--- /dev/null
+++ b/app/src/main/java/uk/lgl/modmenu/Sounds.java
@@ -0,0 +1,51 @@
+/*
+ * Credit:
+ *
+ * Google - Android UI sounds
+ * Material.io - https://material.io/design/sound/sound-resources.html#
+ *
+ * */
+
+package uk.lgl.modmenu;
+
+public class Sounds {
+
+ //Use https://www.base64encode.org/ to encode your files to base64
+
+ //Word wrap: Click View -> Active Editor -> Soft warp
+
+ //system/media/audio/ui/NFCFailure.ogg
+ public static String Back() {
+ return "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";
+ }
+
+ //system/media/audio/ui/NFCInitiated.ogg
+ public static String OpenMenu() {
+ return "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";
+ }
+
+ //system/media/audio/ui/NFCTransferComplete.ogg
+ public static String Select() {
+ return "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";
+ }
+
+ //Material sounds - state-change_confirm-up.ogg
+ public static String On() {
+ return "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";
+ }
+
+ //Material sounds - state-change_confirm-down.ogg
+ public static String Off() {
+ return "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";
+ }
+
+ //Material sounds - navigation_forward-selection-minimal.ogg
+ public static String SliderIncrease() {
+ return "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";
+ }
+
+ //Material sounds - navigation_forward-selection-minimal.ogg
+ public static String SliderDecrease() {
+ return "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";
+ }
+}
diff --git a/app/src/main/java/uk/lgl/modmenu/StaticActivity.java b/app/src/main/java/uk/lgl/modmenu/StaticActivity.java
new file mode 100644
index 0000000..259cda4
--- /dev/null
+++ b/app/src/main/java/uk/lgl/modmenu/StaticActivity.java
@@ -0,0 +1,70 @@
+package uk.lgl.modmenu;
+
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.res.AssetManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Process;
+import android.provider.Settings;
+import android.util.Base64;
+import android.util.Log;
+import android.widget.Toast;
+
+import java.io.File;
+import java.io.FileOutputStream;
+
+public class StaticActivity {
+
+ private static final String TAG = "Mod Menu";
+ public static String cacheDir;
+
+ public static void Start(final Context context) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(context)) {
+ context.startActivity(new Intent("android.settings.action.MANAGE_OVERLAY_PERMISSION",
+ Uri.parse("package:" + context.getPackageName())));
+ Toast.makeText(context.getApplicationContext(), "Please allow overlay permission in order to display the mod menu", Toast.LENGTH_LONG).show();
+ //Process.killProcess(Process.myPid());
+ } else {
+ // When you change the lib name, change also on Android.mk file
+ // Both must have same name
+ System.loadLibrary("HadesNull");
+
+ Handler handler = new Handler();
+ handler.postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ context.startService(new Intent(context, FloatingModMenuService.class));
+ }
+ }, 2000);
+
+ cacheDir = context.getCacheDir().getPath() + "/";
+
+ writeToFile("OpenMenu.ogg", Sounds.OpenMenu());
+ writeToFile("Back.ogg", Sounds.Back());
+ writeToFile("Select.ogg", Sounds.Select());
+ writeToFile("SliderIncrease.ogg", Sounds.SliderIncrease());
+ writeToFile("SliderDecrease.ogg", Sounds.SliderDecrease());
+ writeToFile("On.ogg", Sounds.On());
+ writeToFile("Off.ogg", Sounds.Off());
+ }
+ }
+
+ private static void writeToFile(String name, String base64) {
+ File file = new File(cacheDir + name);
+ try {
+ if (!file.exists()) {
+ file.createNewFile();
+ }
+ FileOutputStream fos = new FileOutputStream(file);
+ byte[] decode = Base64.decode(base64, 0);
+ fos.write(decode);
+ fos.close();
+ } catch (Exception e) {
+ Log.e(TAG, e.getMessage());
+ }
+ }
+}
diff --git a/app/src/main/jni/Android.mk b/app/src/main/jni/Android.mk
new file mode 100644
index 0000000..15f1969
--- /dev/null
+++ b/app/src/main/jni/Android.mk
@@ -0,0 +1,35 @@
+LOCAL_PATH := $(call my-dir)
+MAIN_LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+# Here is the name of your lib.
+# When you change the lib name, change also on System.loadLibrary("") under OnCreate method on StaticActivity.java
+# Both must have same name
+LOCAL_MODULE := HadesNull
+
+# Code optimization
+LOCAL_CFLAGS := -Wno-error=format-security -fpermissive -w -s -Werror -Wold-style-cast -fms-extensions -Wno-narrowing
+LOCAL_CFLAGS += -fno-rtti -fno-exceptions -fvisibility=hidden -ffunction-sections -fdata-sections -stdlib=libc++
+LOCAL_CPPFLAGS += -fvisibility=hidden -ffunction-sections -fdata-sections -w -std=c++14
+LOCAL_LDFLAGS += -Wl,--gc-sections,--strip-all
+LOCAL_ARM_MODE := arm
+
+# Here you add the cpp file
+LOCAL_C_INCLUDES += $(MAIN_LOCAL_PATH)
+LOCAL_SRC_FILES := src/Main.cpp \
+ src/Menu.cpp \
+ src/Includes/Utils.cpp \
+ src/Substrate/hde64.c \
+ src/Substrate/SubstrateDebug.cpp \
+ src/Substrate/SubstrateHook.cpp \
+ src/Substrate/SubstratePosixMemory.cpp \
+ src/Substrate/SymbolFinder.cpp \
+ src/KittyMemory/KittyMemory.cpp \
+ src/KittyMemory/MemoryPatch.cpp \
+ src/KittyMemory/MemoryBackup.cpp \
+ src/KittyMemory/KittyUtils.cpp \
+ src/And64InlineHook/And64InlineHook.cpp
+
+LOCAL_LDLIBS := -llog -landroid
+
+include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/app/src/main/jni/Application.mk b/app/src/main/jni/Application.mk
new file mode 100644
index 0000000..d2622a9
--- /dev/null
+++ b/app/src/main/jni/Application.mk
@@ -0,0 +1,9 @@
+APP_ABI := armeabi-v7a arm64-v8a x86
+APP_PLATFORM := android-18
+APP_STL := c++_static
+APP_OPTIM := release
+APP_CPPFLAGS := -std=c++14 -fno-rtti -fno-exceptions -DNDEBUG -Wall -fpermissive -fpic
+APP_LDFLAGS := -llog
+APP_THIN_ARCHIVE := true
+APP_PIE := true
+
diff --git a/app/src/main/jni/src/And64InlineHook/And64InlineHook.cpp b/app/src/main/jni/src/And64InlineHook/And64InlineHook.cpp
new file mode 100644
index 0000000..34bf9a0
--- /dev/null
+++ b/app/src/main/jni/src/And64InlineHook/And64InlineHook.cpp
@@ -0,0 +1,611 @@
+/*
+ * @date : 2018/04/18
+ * @author : Rprop (r_prop@outlook.com)
+ * https://github.com/Rprop/And64InlineHook
+ */
+/*
+ MIT License
+
+ Copyright (c) 2018 Rprop (r_prop@outlook.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+#define __STDC_FORMAT_MACROS
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#if defined(__aarch64__)
+
+#include "And64InlineHook.hpp"
+
+#define A64_MAX_INSTRUCTIONS 5
+#define A64_MAX_REFERENCES (A64_MAX_INSTRUCTIONS * 2)
+#define A64_NOP 0xd503201fu
+#define A64_JNIEXPORT __attribute__((visibility("default")))
+#define A64_LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "A64_HOOK", __VA_ARGS__))
+#ifndef NDEBUG
+# define A64_LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "A64_HOOK", __VA_ARGS__))
+#else
+# define A64_LOGI(...) ((void)0)
+#endif // NDEBUG
+typedef uint32_t *__restrict *__restrict instruction;
+typedef struct a64 {
+ struct fix_info {
+ uint32_t *bp;
+ uint32_t ls; // left-shift counts
+ uint32_t ad; // & operand
+ };
+ struct insns_info {
+ union {
+ uint64_t insu;
+ int64_t ins;
+ void *insp;
+ };
+ fix_info fmap[A64_MAX_REFERENCES];
+ };
+ int64_t basep;
+ int64_t endp;
+ insns_info dat[A64_MAX_INSTRUCTIONS];
+
+public:
+ inline bool is_in_fixing_range(const int64_t absolute_addr) {
+ return absolute_addr >= this->basep && absolute_addr < this->endp;
+ }
+
+ inline intptr_t get_ref_ins_index(const int64_t absolute_addr) {
+ return static_cast((absolute_addr - this->basep) / sizeof(uint32_t));
+ }
+
+ inline intptr_t get_and_set_current_index(uint32_t *__restrict inp, uint32_t *__restrict outp) {
+ intptr_t current_idx = this->get_ref_ins_index(reinterpret_cast(inp));
+ this->dat[current_idx].insp = outp;
+ return current_idx;
+ }
+
+ inline void reset_current_ins(const intptr_t idx, uint32_t *__restrict outp) {
+ this->dat[idx].insp = outp;
+ }
+
+ void
+ insert_fix_map(const intptr_t idx, uint32_t *bp, uint32_t ls = 0u, uint32_t ad = 0xffffffffu) {
+ for (auto &f : this->dat[idx].fmap) {
+ if (f.bp == NULL) {
+ f.bp = bp;
+ f.ls = ls;
+ f.ad = ad;
+ return;
+ } //if
+ }
+ // What? GGing..
+ }
+
+ void process_fix_map(const intptr_t idx) {
+ for (auto &f : this->dat[idx].fmap) {
+ if (f.bp == NULL) break;
+ *(f.bp) = *(f.bp) |
+ (((int32_t(this->dat[idx].ins - reinterpret_cast(f.bp)) >> 2)
+ << f.ls) & f.ad);
+ f.bp = NULL;
+ }
+ }
+} context;
+
+//-------------------------------------------------------------------------
+
+static bool __fix_branch_imm(instruction inpp, instruction outpp, context *ctxp) {
+ static constexpr uint32_t mbits = 6u;
+ static constexpr uint32_t mask = 0xfc000000u; // 0b11111100000000000000000000000000
+ static constexpr uint32_t rmask = 0x03ffffffu; // 0b00000011111111111111111111111111
+ static constexpr uint32_t op_b = 0x14000000u; // "b" ADDR_PCREL26
+ static constexpr uint32_t op_bl = 0x94000000u; // "bl" ADDR_PCREL26
+
+ const uint32_t ins = *(*inpp);
+ const uint32_t opc = ins & mask;
+ switch (opc) {
+ case op_b:
+ case op_bl: {
+ intptr_t current_idx = ctxp->get_and_set_current_index(*inpp, *outpp);
+ int64_t absolute_addr = reinterpret_cast(*inpp) +
+ (static_cast(ins << mbits)
+ >> (mbits - 2u)); // sign-extended
+ int64_t new_pc_offset =
+ static_cast(absolute_addr - reinterpret_cast(*outpp))
+ >> 2; // shifted
+ bool special_fix_type = ctxp->is_in_fixing_range(absolute_addr);
+ // whether the branch should be converted to absolute jump
+ if (!special_fix_type && llabs(new_pc_offset) >= (rmask >> 1)) {
+ bool b_aligned = (reinterpret_cast(*outpp + 2) & 7u) == 0u;
+ if (opc == op_b) {
+ if (b_aligned != true) {
+ (*outpp)[0] = A64_NOP;
+ ctxp->reset_current_ins(current_idx, ++(*outpp));
+ } //if
+ (*outpp)[0] = 0x58000051u; // LDR X17, #0x8
+ (*outpp)[1] = 0xd61f0220u; // BR X17
+ memcpy(*outpp + 2, &absolute_addr, sizeof(absolute_addr));
+ *outpp += 4;
+ } else {
+ if (b_aligned == true) {
+ (*outpp)[0] = A64_NOP;
+ ctxp->reset_current_ins(current_idx, ++(*outpp));
+ } //if
+ (*outpp)[0] = 0x58000071u; // LDR X17, #12
+ (*outpp)[1] = 0x1000009eu; // ADR X30, #16
+ (*outpp)[2] = 0xd61f0220u; // BR X17
+ memcpy(*outpp + 3, &absolute_addr, sizeof(absolute_addr));
+ *outpp += 5;
+ } //if
+ } else {
+ if (special_fix_type) {
+ intptr_t ref_idx = ctxp->get_ref_ins_index(absolute_addr);
+ if (ref_idx <= current_idx) {
+ new_pc_offset = static_cast(ctxp->dat[ref_idx].ins -
+ reinterpret_cast(*outpp))
+ >> 2;
+ } else {
+ ctxp->insert_fix_map(ref_idx, *outpp, 0u, rmask);
+ new_pc_offset = 0;
+ } //if
+ } //if
+
+ (*outpp)[0] = opc | (new_pc_offset & ~mask);
+ ++(*outpp);
+ } //if
+
+ ++(*inpp);
+ return ctxp->process_fix_map(current_idx), true;
+ }
+ }
+ return false;
+}
+
+//-------------------------------------------------------------------------
+
+static bool __fix_cond_comp_test_branch(instruction inpp, instruction outpp, context *ctxp) {
+ static constexpr uint32_t lsb = 5u;
+ static constexpr uint32_t lmask01 = 0xff00001fu; // 0b11111111000000000000000000011111
+ static constexpr uint32_t mask0 = 0xff000010u; // 0b11111111000000000000000000010000
+ static constexpr uint32_t op_bc = 0x54000000u; // "b.c" ADDR_PCREL19
+ static constexpr uint32_t mask1 = 0x7f000000u; // 0b01111111000000000000000000000000
+ static constexpr uint32_t op_cbz = 0x34000000u; // "cbz" Rt, ADDR_PCREL19
+ static constexpr uint32_t op_cbnz = 0x35000000u; // "cbnz" Rt, ADDR_PCREL19
+ static constexpr uint32_t lmask2 = 0xfff8001fu; // 0b11111111111110000000000000011111
+ static constexpr uint32_t mask2 = 0x7f000000u; // 0b01111111000000000000000000000000
+ static constexpr uint32_t op_tbz = 0x36000000u; // 0b00110110000000000000000000000000 "tbz" Rt, BIT_NUM, ADDR_PCREL14
+ static constexpr uint32_t op_tbnz = 0x37000000u; // 0b00110111000000000000000000000000 "tbnz" Rt, BIT_NUM, ADDR_PCREL14
+
+ const uint32_t ins = *(*inpp);
+ uint32_t lmask = lmask01;
+ if ((ins & mask0) != op_bc) {
+ uint32_t opc = ins & mask1;
+ if (opc != op_cbz && opc != op_cbnz) {
+ opc = ins & mask2;
+ if (opc != op_tbz && opc != op_tbnz) {
+ return false;
+ } //if
+ lmask = lmask2;
+ } //if
+ } //if
+
+ intptr_t current_idx = ctxp->get_and_set_current_index(*inpp, *outpp);
+ int64_t absolute_addr = reinterpret_cast(*inpp) + ((ins & ~lmask) >> (lsb - 2u));
+ int64_t new_pc_offset =
+ static_cast(absolute_addr - reinterpret_cast(*outpp)) >> 2; // shifted
+ bool special_fix_type = ctxp->is_in_fixing_range(absolute_addr);
+ if (!special_fix_type && llabs(new_pc_offset) >= (~lmask >> (lsb + 1))) {
+ if ((reinterpret_cast(*outpp + 4) & 7u) != 0u) {
+ (*outpp)[0] = A64_NOP;
+ ctxp->reset_current_ins(current_idx, ++(*outpp));
+ } //if
+ (*outpp)[0] = (((8u >> 2u) << lsb) & ~lmask) | (ins & lmask); // B.C #0x8
+ (*outpp)[1] = 0x14000005u; // B #0x14
+ (*outpp)[2] = 0x58000051u; // LDR X17, #0x8
+ (*outpp)[3] = 0xd61f0220u; // BR X17
+ memcpy(*outpp + 4, &absolute_addr, sizeof(absolute_addr));
+ *outpp += 6;
+ } else {
+ if (special_fix_type) {
+ intptr_t ref_idx = ctxp->get_ref_ins_index(absolute_addr);
+ if (ref_idx <= current_idx) {
+ new_pc_offset = static_cast(ctxp->dat[ref_idx].ins -
+ reinterpret_cast(*outpp)) >> 2;
+ } else {
+ ctxp->insert_fix_map(ref_idx, *outpp, lsb, ~lmask);
+ new_pc_offset = 0;
+ } //if
+ } //if
+
+ (*outpp)[0] = (static_cast(new_pc_offset << lsb) & ~lmask) | (ins & lmask);
+ ++(*outpp);
+ } //if
+
+ ++(*inpp);
+ return ctxp->process_fix_map(current_idx), true;
+}
+
+//-------------------------------------------------------------------------
+
+static bool __fix_loadlit(instruction inpp, instruction outpp, context *ctxp) {
+ const uint32_t ins = *(*inpp);
+
+ // memory prefetch("prfm"), just skip it
+ // http://infocenter.arm.com/help/topic/com.arm.doc.100069_0608_00_en/pge1427897420050.html
+ if ((ins & 0xff000000u) == 0xd8000000u) {
+ ctxp->process_fix_map(ctxp->get_and_set_current_index(*inpp, *outpp));
+ ++(*inpp);
+ return true;
+ } //if
+
+ static constexpr uint32_t msb = 8u;
+ static constexpr uint32_t lsb = 5u;
+ static constexpr uint32_t mask_30 = 0x40000000u; // 0b01000000000000000000000000000000
+ static constexpr uint32_t mask_31 = 0x80000000u; // 0b10000000000000000000000000000000
+ static constexpr uint32_t lmask = 0xff00001fu; // 0b11111111000000000000000000011111
+ static constexpr uint32_t mask_ldr = 0xbf000000u; // 0b10111111000000000000000000000000
+ static constexpr uint32_t op_ldr = 0x18000000u; // 0b00011000000000000000000000000000 "LDR Wt/Xt, label" | ADDR_PCREL19
+ static constexpr uint32_t mask_ldrv = 0x3f000000u; // 0b00111111000000000000000000000000
+ static constexpr uint32_t op_ldrv = 0x1c000000u; // 0b00011100000000000000000000000000 "LDR St/Dt/Qt, label" | ADDR_PCREL19
+ static constexpr uint32_t mask_ldrsw = 0xff000000u; // 0b11111111000000000000000000000000
+ static constexpr uint32_t op_ldrsw = 0x98000000u; // "LDRSW Xt, label" | ADDR_PCREL19 | load register signed word
+ // LDR S0, #0 | 0b00011100000000000000000000000000 | 32-bit
+ // LDR D0, #0 | 0b01011100000000000000000000000000 | 64-bit
+ // LDR Q0, #0 | 0b10011100000000000000000000000000 | 128-bit
+ // INVALID | 0b11011100000000000000000000000000 | may be 256-bit
+
+ uint32_t mask = mask_ldr;
+ uintptr_t faligned = (ins & mask_30) ? 7u : 3u;
+ if ((ins & mask_ldr) != op_ldr) {
+ mask = mask_ldrv;
+ if (faligned != 7u)
+ faligned = (ins & mask_31) ? 15u : 3u;
+ if ((ins & mask_ldrv) != op_ldrv) {
+ if ((ins & mask_ldrsw) != op_ldrsw) {
+ return false;
+ } //if
+ mask = mask_ldrsw;
+ faligned = 7u;
+ } //if
+ } //if
+
+ intptr_t current_idx = ctxp->get_and_set_current_index(*inpp, *outpp);
+ int64_t absolute_addr = reinterpret_cast(*inpp) +
+ ((static_cast(ins << msb) >> (msb + lsb - 2u)) & ~3u);
+ int64_t new_pc_offset =
+ static_cast(absolute_addr - reinterpret_cast(*outpp)) >> 2; // shifted
+ bool special_fix_type = ctxp->is_in_fixing_range(absolute_addr);
+ // special_fix_type may encounter issue when there are mixed data and code
+ if (special_fix_type || (llabs(new_pc_offset) + (faligned + 1u - 4u) / 4u) >=
+ (~lmask >> (lsb + 1))) { // inaccurate, but it works
+ while ((reinterpret_cast(*outpp + 2) & faligned) != 0u) {
+ *(*outpp)++ = A64_NOP;
+ }
+ ctxp->reset_current_ins(current_idx, *outpp);
+
+ // Note that if memory at absolute_addr is writeable (non-const), we will fail to fetch it.
+ // And what's worse, we may unexpectedly overwrite something if special_fix_type is true...
+ uint32_t ns = static_cast((faligned + 1) / sizeof(uint32_t));
+ (*outpp)[0] = (((8u >> 2u) << lsb) & ~mask) | (ins & lmask); // LDR #0x8
+ (*outpp)[1] = 0x14000001u + ns; // B #0xc
+ memcpy(*outpp + 2, reinterpret_cast(absolute_addr), faligned + 1);
+ *outpp += 2 + ns;
+ } else {
+ faligned >>= 2; // new_pc_offset is shifted and 4-byte aligned
+ while ((new_pc_offset & faligned) != 0) {
+ *(*outpp)++ = A64_NOP;
+ new_pc_offset =
+ static_cast(absolute_addr - reinterpret_cast(*outpp)) >> 2;
+ }
+ ctxp->reset_current_ins(current_idx, *outpp);
+
+ (*outpp)[0] = (static_cast(new_pc_offset << lsb) & ~mask) | (ins & lmask);
+ ++(*outpp);
+ } //if
+
+ ++(*inpp);
+ return ctxp->process_fix_map(current_idx), true;
+}
+
+//-------------------------------------------------------------------------
+
+static bool __fix_pcreladdr(instruction inpp, instruction outpp, context *ctxp) {
+ // Load a PC-relative address into a register
+ // http://infocenter.arm.com/help/topic/com.arm.doc.100069_0608_00_en/pge1427897645644.html
+ static constexpr uint32_t msb = 8u;
+ static constexpr uint32_t lsb = 5u;
+ static constexpr uint32_t mask = 0x9f000000u; // 0b10011111000000000000000000000000
+ static constexpr uint32_t rmask = 0x0000001fu; // 0b00000000000000000000000000011111
+ static constexpr uint32_t lmask = 0xff00001fu; // 0b11111111000000000000000000011111
+ static constexpr uint32_t fmask = 0x00ffffffu; // 0b00000000111111111111111111111111
+ static constexpr uint32_t max_val = 0x001fffffu; // 0b00000000000111111111111111111111
+ static constexpr uint32_t op_adr = 0x10000000u; // "adr" Rd, ADDR_PCREL21
+ static constexpr uint32_t op_adrp = 0x90000000u; // "adrp" Rd, ADDR_ADRP
+
+ const uint32_t ins = *(*inpp);
+ intptr_t current_idx;
+ switch (ins & mask) {
+ case op_adr: {
+ current_idx = ctxp->get_and_set_current_index(*inpp, *outpp);
+ int64_t lsb_bytes = static_cast(ins << 1u) >> 30u;
+ int64_t absolute_addr = reinterpret_cast(*inpp) +
+ (((static_cast(ins << msb) >> (msb + lsb - 2u)) &
+ ~3u) | lsb_bytes);
+ int64_t new_pc_offset = static_cast(absolute_addr -
+ reinterpret_cast(*outpp));
+ bool special_fix_type = ctxp->is_in_fixing_range(absolute_addr);
+ if (!special_fix_type && llabs(new_pc_offset) >= (max_val >> 1)) {
+ if ((reinterpret_cast(*outpp + 2) & 7u) != 0u) {
+ (*outpp)[0] = A64_NOP;
+ ctxp->reset_current_ins(current_idx, ++(*outpp));
+ } //if
+
+ (*outpp)[0] =
+ 0x58000000u | (((8u >> 2u) << lsb) & ~mask) | (ins & rmask); // LDR #0x8
+ (*outpp)[1] = 0x14000003u; // B #0xc
+ memcpy(*outpp + 2, &absolute_addr, sizeof(absolute_addr));
+ *outpp += 4;
+ } else {
+ if (special_fix_type) {
+ intptr_t ref_idx = ctxp->get_ref_ins_index(absolute_addr & ~3ull);
+ if (ref_idx <= current_idx) {
+ new_pc_offset = static_cast(ctxp->dat[ref_idx].ins -
+ reinterpret_cast(*outpp));
+ } else {
+ ctxp->insert_fix_map(ref_idx, *outpp, lsb, fmask);
+ new_pc_offset = 0;
+ } //if
+ } //if
+
+ // the lsb_bytes will never be changed, so we can use lmask to keep it
+ (*outpp)[0] = (static_cast(new_pc_offset << (lsb - 2u)) & fmask) |
+ (ins & lmask);
+ ++(*outpp);
+ } //if
+ }
+ break;
+ case op_adrp: {
+ current_idx = ctxp->get_and_set_current_index(*inpp, *outpp);
+ int32_t lsb_bytes = static_cast(ins << 1u) >> 30u;
+ int64_t absolute_addr = (reinterpret_cast(*inpp) & ~0xfffll) +
+ ((((static_cast(ins << msb) >> (msb + lsb - 2u)) &
+ ~3u) | lsb_bytes) << 12);
+ A64_LOGI("ins = 0x%.8X, pc = %p, abs_addr = %p",
+ ins, *inpp, reinterpret_cast(absolute_addr));
+ if (ctxp->is_in_fixing_range(absolute_addr)) {
+ intptr_t ref_idx = ctxp->get_ref_ins_index(absolute_addr/* & ~3ull*/);
+ if (ref_idx > current_idx) {
+ // the bottom 12 bits of absolute_addr are masked out,
+ // so ref_idx must be less than or equal to current_idx!
+ A64_LOGE("ref_idx must be less than or equal to current_idx!");
+ } //if
+
+ // *absolute_addr may be changed due to relocation fixing
+ A64_LOGI("What is the correct way to fix this?");
+ *(*outpp)++ = ins; // 0x90000000u;
+ } else {
+ if ((reinterpret_cast(*outpp + 2) & 7u) != 0u) {
+ (*outpp)[0] = A64_NOP;
+ ctxp->reset_current_ins(current_idx, ++(*outpp));
+ } //if
+
+ (*outpp)[0] =
+ 0x58000000u | (((8u >> 2u) << lsb) & ~mask) | (ins & rmask); // LDR #0x8
+ (*outpp)[1] = 0x14000003u; // B #0xc
+ memcpy(*outpp + 2, &absolute_addr, sizeof(absolute_addr)); // potential overflow?
+ *outpp += 4;
+ } //if
+ }
+ break;
+ default:
+ return false;
+ }
+
+ ctxp->process_fix_map(current_idx);
+ ++(*inpp);
+ return true;
+}
+
+//-------------------------------------------------------------------------
+#define __flush_cache(c, n) __builtin___clear_cache(reinterpret_cast(c), reinterpret_cast(c) + n)
+
+static void __fix_instructions(uint32_t *__restrict inp, int32_t count, uint32_t *__restrict outp) {
+ context ctx;
+ ctx.basep = reinterpret_cast(inp);
+ ctx.endp = reinterpret_cast(inp + count);
+ memset(ctx.dat, 0, sizeof(ctx.dat));
+ static_assert(sizeof(ctx.dat) / sizeof(ctx.dat[0]) == A64_MAX_INSTRUCTIONS,
+ "please use A64_MAX_INSTRUCTIONS!");
+#ifndef NDEBUG
+ if (count > A64_MAX_INSTRUCTIONS) {
+ A64_LOGE("too many fixing instructions!");
+ } //if
+#endif // NDEBUG
+
+ uint32_t *const outp_base = outp;
+
+ while (--count >= 0) {
+ if (__fix_branch_imm(&inp, &outp, &ctx)) continue;
+ if (__fix_cond_comp_test_branch(&inp, &outp, &ctx)) continue;
+ if (__fix_loadlit(&inp, &outp, &ctx)) continue;
+ if (__fix_pcreladdr(&inp, &outp, &ctx)) continue;
+
+ // without PC-relative offset
+ ctx.process_fix_map(ctx.get_and_set_current_index(inp, outp));
+ *(outp++) = *(inp++);
+ }
+
+ static constexpr uint_fast64_t mask = 0x03ffffffu; // 0b00000011111111111111111111111111
+ auto callback = reinterpret_cast(inp);
+ auto pc_offset = static_cast(callback - reinterpret_cast(outp)) >> 2;
+ if (llabs(pc_offset) >= (mask >> 1)) {
+ if ((reinterpret_cast(outp + 2) & 7u) != 0u) {
+ outp[0] = A64_NOP;
+ ++outp;
+ } //if
+ outp[0] = 0x58000051u; // LDR X17, #0x8
+ outp[1] = 0xd61f0220u; // BR X17
+ *reinterpret_cast(outp + 2) = callback;
+ outp += 4;
+ } else {
+ outp[0] = 0x14000000u | (pc_offset & mask); // "B" ADDR_PCREL26
+ ++outp;
+ } //if
+
+ const uintptr_t total = (outp - outp_base) * sizeof(uint32_t);
+ __flush_cache(outp_base, total); // necessary
+}
+
+//-------------------------------------------------------------------------
+
+extern "C" {
+#define __attribute __attribute__
+#define aligned(x) __aligned__(x)
+#define __intval(p) reinterpret_cast(p)
+#define __uintval(p) reinterpret_cast(p)
+#define __ptr(p) reinterpret_cast(p)
+#define __page_size 4096
+#define __page_align(n) __align_up(static_cast(n), __page_size)
+#define __ptr_align(x) __ptr(__align_down(reinterpret_cast(x), __page_size))
+#define __align_up(x, n) (((x) + ((n) - 1)) & ~((n) - 1))
+#define __align_down(x, n) ((x) & -(n))
+#define __countof(x) static_cast(sizeof(x) / sizeof((x)[0])) // must be signed
+#define __atomic_increase(p) __sync_add_and_fetch(p, 1)
+#define __sync_cmpswap(p, v, n) __sync_bool_compare_and_swap(p, v, n)
+#define __predict_true(exp) __builtin_expect((exp) != 0, 1)
+#define __make_rwx(p, n) ::mprotect(__ptr_align(p), \
+ __page_align(__uintval(p) + n) != __page_align(__uintval(p)) ? __page_align(n) + __page_size : __page_align(n), \
+ PROT_READ | PROT_WRITE | PROT_EXEC)
+
+//-------------------------------------------------------------------------
+
+static __attribute((aligned(__page_size))) uint32_t __insns_pool[A64_MAX_BACKUPS][
+ A64_MAX_INSTRUCTIONS * 10];
+
+//-------------------------------------------------------------------------
+
+class A64HookInit {
+public:
+ A64HookInit() {
+ __make_rwx(__insns_pool, sizeof(__insns_pool));
+ A64_LOGI("insns pool initialized.");
+ }
+};
+static A64HookInit __init;
+
+//-------------------------------------------------------------------------
+
+static uint32_t *FastAllocateTrampoline() {
+ static_assert((A64_MAX_INSTRUCTIONS * 10 * sizeof(uint32_t)) % 8 == 0, "8-byte align");
+ static volatile int32_t __index = -1;
+
+ int32_t i = __atomic_increase(&__index);
+ if (__predict_true(i >= 0 && i < __countof(__insns_pool))) {
+ return __insns_pool[i];
+ } //if
+
+ A64_LOGE("failed to allocate trampoline!");
+ return NULL;
+}
+
+//-------------------------------------------------------------------------
+
+A64_JNIEXPORT void *A64HookFunctionV(void *const symbol, void *const replace,
+ void *const rwx, const uintptr_t rwx_size) {
+ static constexpr uint_fast64_t mask = 0x03ffffffu; // 0b00000011111111111111111111111111
+
+ uint32_t *trampoline = static_cast(rwx), *original = static_cast(symbol);
+
+ static_assert(A64_MAX_INSTRUCTIONS >= 5, "please fix A64_MAX_INSTRUCTIONS!");
+ auto pc_offset = static_cast(__intval(replace) - __intval(symbol)) >> 2;
+ if (llabs(pc_offset) >= (mask >> 1)) {
+ int32_t count = (reinterpret_cast(original + 2) & 7u) != 0u ? 5 : 4;
+ if (trampoline) {
+ if (rwx_size < count * 10u) {
+ A64_LOGI("rwx size is too small to hold %u bytes backup instructions!",
+ count * 10u);
+ return NULL;
+ } //if
+ __fix_instructions(original, count, trampoline);
+ } //if
+
+ if (__make_rwx(original, 5 * sizeof(uint32_t)) == 0) {
+ if (count == 5) {
+ original[0] = A64_NOP;
+ ++original;
+ } //if
+ original[0] = 0x58000051u; // LDR X17, #0x8
+ original[1] = 0xd61f0220u; // BR X17
+ *reinterpret_cast(original + 2) = __intval(replace);
+ __flush_cache(symbol, 5 * sizeof(uint32_t));
+
+ A64_LOGI("inline hook %p->%p successfully! %zu bytes overwritten",
+ symbol, replace, 5 * sizeof(uint32_t));
+ } else {
+ A64_LOGE("mprotect failed with errno = %d, p = %p, size = %zu",
+ errno, original, 5 * sizeof(uint32_t));
+ trampoline = NULL;
+ } //if
+ } else {
+ if (trampoline) {
+ if (rwx_size < 1u * 10u) {
+ A64_LOGI("rwx size is too small to hold %u bytes backup instructions!", 1u * 10u);
+ return NULL;
+ } //if
+ __fix_instructions(original, 1, trampoline);
+ } //if
+
+ if (__make_rwx(original, 1 * sizeof(uint32_t)) == 0) {
+ __sync_cmpswap(original, *original,
+ 0x14000000u | (pc_offset & mask)); // "B" ADDR_PCREL26
+ __flush_cache(symbol, 1 * sizeof(uint32_t));
+
+ A64_LOGI("inline hook %p->%p successfully! %zu bytes overwritten",
+ symbol, replace, 1 * sizeof(uint32_t));
+ } else {
+ A64_LOGE("mprotect failed with errno = %d, p = %p, size = %zu",
+ errno, original, 1 * sizeof(uint32_t));
+ trampoline = NULL;
+ } //if
+ } //if
+
+ return trampoline;
+}
+
+//-------------------------------------------------------------------------
+
+A64_JNIEXPORT void A64HookFunction(void *const symbol, void *const replace, void **result) {
+ void *trampoline = NULL;
+ if (result != NULL) {
+ trampoline = FastAllocateTrampoline();
+ *result = trampoline;
+ if (trampoline == NULL) return;
+ } //if
+
+ trampoline = A64HookFunctionV(symbol, replace, trampoline, A64_MAX_INSTRUCTIONS * 10u);
+ if (trampoline == NULL && result != NULL) {
+ *result = NULL;
+ } //if
+}
+}
+
+#endif // defined(__aarch64__)
\ No newline at end of file
diff --git a/app/src/main/jni/src/And64InlineHook/And64InlineHook.hpp b/app/src/main/jni/src/And64InlineHook/And64InlineHook.hpp
new file mode 100644
index 0000000..c76c852
--- /dev/null
+++ b/app/src/main/jni/src/And64InlineHook/And64InlineHook.hpp
@@ -0,0 +1,42 @@
+/*
+ * @date : 2018/04/18
+ * @author : Rprop (r_prop@outlook.com)
+ * https://github.com/Rprop/And64InlineHook
+ */
+/*
+ MIT License
+
+ Copyright (c) 2018 Rprop (r_prop@outlook.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+#pragma once
+#define A64_MAX_BACKUPS 256
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void A64HookFunction(void *const symbol, void *const replace, void **result);
+void *A64HookFunctionV(void *const symbol, void *const replace,
+ void *const rwx, const uintptr_t rwx_size);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/app/src/main/jni/src/And64InlineHook/LICENSE b/app/src/main/jni/src/And64InlineHook/LICENSE
new file mode 100644
index 0000000..75a6020
--- /dev/null
+++ b/app/src/main/jni/src/And64InlineHook/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 RLib
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/app/src/main/jni/src/And64InlineHook/README.md b/app/src/main/jni/src/And64InlineHook/README.md
new file mode 100644
index 0000000..44f651d
--- /dev/null
+++ b/app/src/main/jni/src/And64InlineHook/README.md
@@ -0,0 +1,7 @@
+# And64InlineHook
+Lightweight ARMv8-A(ARM64, AArch64, Little-Endian) Inline Hook Library for Android C/C++
+
+# References
+[Arm Compiler armasm User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.100069_0610_00_en/pge1427898258836.html)
+[Procedure Call Standard for the Arm® 64-bit Architecture (AArch64)](https://github.com/ARM-software/abi-aa/blob/master/aapcs64/aapcs64.rst)
+
diff --git a/app/src/main/jni/src/Includes/Logger.h b/app/src/main/jni/src/Includes/Logger.h
new file mode 100644
index 0000000..7e4e703
--- /dev/null
+++ b/app/src/main/jni/src/Includes/Logger.h
@@ -0,0 +1,21 @@
+#ifndef DAWN_LOGGER_H
+#define DAWN_LOGGER_H
+
+#include
+
+enum daLogType {
+ daDEBUG = 3,
+ daERROR = 6,
+ daINFO = 4,
+ daWARN = 5
+};
+
+//Change this to another Log Tag if ya want. IN the batch script I provide you change the log tag then too
+#define TAG OBFUSCATE("Mod Menu")
+
+#define LOGD(...) ((void)__android_log_print(daDEBUG, TAG, __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(daERROR, TAG, __VA_ARGS__))
+#define LOGI(...) ((void)__android_log_print(daINFO, TAG, __VA_ARGS__))
+#define LOGW(...) ((void)__android_log_print(daWARN, TAG, __VA_ARGS__))
+
+#endif //DAWN_LOGGER_H
\ No newline at end of file
diff --git a/app/src/main/jni/src/Includes/Utils.cpp b/app/src/main/jni/src/Includes/Utils.cpp
new file mode 100644
index 0000000..b651b3b
--- /dev/null
+++ b/app/src/main/jni/src/Includes/Utils.cpp
@@ -0,0 +1,113 @@
+#include
+#include "src/Includes/Utils.h"
+
+std::string s(const std::string &str) {
+ const size_t p = 16;
+ static const char c[p] = ".";
+
+ std::string r = str;
+ for (size_t i = 0; i < str.length(); i++)
+ r[i] ^= ~c[i % p];
+ return r;
+}
+
+DWORD findLibrary(const char *library) {
+ char filename[0xFF] = {0},
+ buffer[1024] = {0};
+ FILE *fp = NULL;
+ DWORD address = 0;
+
+ sprintf(filename, OBFUSCATE("/proc/self/maps"));
+
+ fp = fopen(filename, OBFUSCATE("rt"));
+ if (fp == NULL) {
+ perror(OBFUSCATE("fopen"));
+ goto done;
+ }
+
+ while (fgets(buffer, sizeof(buffer), fp)) {
+ if (strstr(buffer, library)) {
+ address = (DWORD) strtoul(buffer, NULL, 16);
+ goto done;
+ }
+ }
+
+ done:
+
+ if (fp) {
+ fclose(fp);
+ }
+
+ return address;
+}
+
+DWORD getAbsoluteAddress(const char *libraryName, DWORD relativeAddr) {
+ libBase = findLibrary(libraryName);
+ if (libBase == 0)
+ return 0;
+ return (reinterpret_cast(libBase + relativeAddr));
+}
+
+bool isLibraryLoaded(const char *libraryName) {
+ char line[512] = {0};
+ FILE *fp = fopen(OBFUSCATE("/proc/self/maps"), OBFUSCATE("rt"));
+ if (fp != NULL) {
+ while (fgets(line, sizeof(line), fp)) {
+ if (strstr(line, s("\xbd\x96\x9d\x9d\x92\x8b\xd1\x8c\x90").c_str())) {
+ int *i = (int *) 0x0;
+ *i = 1;
+ }
+ if (strstr(line, libraryName))
+ return true;
+ }
+ fclose(fp);
+ }
+ return false;
+}
+
+void MakeToast(JNIEnv *env, jobject thiz, const char *text, int length) {
+ //Add our toast in here so it wont be easy to change by simply editing the smali and cant
+ //be cut out because this method is needed to start the hack (Octowolve is smart)
+ jstring jstr = env->NewStringUTF(text); //Edit this text to your desired toast message!
+ jclass toast = env->FindClass(OBFUSCATE("android/widget/Toast"));
+ jmethodID methodMakeText =
+ env->GetStaticMethodID(
+ toast,
+ OBFUSCATE("makeText"),
+ OBFUSCATE(
+ "(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;"));
+ if (methodMakeText == NULL) {
+ LOGE(OBFUSCATE("toast.makeText not Found"));
+ return;
+ }
+ //The last int is the length on how long the toast should be displayed
+ //0 = Short, 1 = Long
+ jobject toastobj = env->CallStaticObjectMethod(toast, methodMakeText,
+ thiz, jstr, length);
+
+ jmethodID methodShow = env->GetMethodID(toast, OBFUSCATE("show"), OBFUSCATE("()V"));
+ if (methodShow == NULL) {
+ LOGE(OBFUSCATE("toast.show not Found"));
+ return;
+ }
+ env->CallVoidMethod(toastobj, methodShow);
+}
+
+uintptr_t string2Offset(const char *c) {
+ int base = 16;
+ // See if this function catches all possibilities.
+ // If it doesn't, the function would have to be amended
+ // whenever you add a combination of architecture and
+ // compiler that is not yet addressed.
+ static_assert(sizeof(uintptr_t) == sizeof(unsigned long)
+ || sizeof(uintptr_t) == sizeof(unsigned long long),
+ "Please add string to handle conversion for this architecture.");
+
+ // Now choose the correct function ...
+ if (sizeof(uintptr_t) == sizeof(unsigned long)) {
+ return strtoul(c, nullptr, base);
+ }
+
+ // All other options exhausted, sizeof(uintptr_t) == sizeof(unsigned long long))
+ return strtoull(c, nullptr, base);
+}
\ No newline at end of file
diff --git a/app/src/main/jni/src/Includes/Utils.h b/app/src/main/jni/src/Includes/Utils.h
new file mode 100644
index 0000000..b9f48b8
--- /dev/null
+++ b/app/src/main/jni/src/Includes/Utils.h
@@ -0,0 +1,32 @@
+#ifndef UTILS
+#define UTILS
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include "Logger.h"
+
+typedef unsigned long DWORD;
+static uintptr_t libBase;
+
+DWORD findLibrary(const char *library);
+
+DWORD getAbsoluteAddress(const char *libraryName, DWORD relativeAddr);
+
+bool isLibraryLoaded(const char *libraryName);
+
+void MakeToast(JNIEnv *env, jobject thiz, const char *text, int length);
+
+std::string s(const std::string &str);
+
+uintptr_t string2Offset(const char *c);
+
+namespace Toast {
+ inline const int LENGTH_LONG = 1;
+ inline const int LENGTH_SHORT = 0;
+}
+
+#endif
\ No newline at end of file
diff --git a/app/src/main/jni/src/Includes/obfuscate.h b/app/src/main/jni/src/Includes/obfuscate.h
new file mode 100644
index 0000000..5c2dc3f
--- /dev/null
+++ b/app/src/main/jni/src/Includes/obfuscate.h
@@ -0,0 +1,194 @@
+/* --------------------------------- ABOUT -------------------------------------
+
+Original Author: Adam Yaxley
+Website: https://github.com/adamyaxley
+License: See end of file
+
+Obfuscate
+Guaranteed compile-time string literal obfuscation library for C++14
+
+Usage:
+Pass string literals into the AY_OBFUSCATE macro to obfuscate them at compile
+time. AY_OBFUSCATE returns a reference to an ay::OBFUSCATE_data object with the
+following traits:
+ - Guaranteed obfuscation of string
+ The passed string is encrypted with a simple XOR cipher at compile-time to
+ prevent it being viewable in the binary image
+ - Global lifetime
+ The actual instantiation of the ay::OBFUSCATE_data takes place inside a
+ lambda as a function level static
+ - Implicitly convertable to a char*
+ This means that you can pass it directly into functions that would normally
+ take a char* or a const char*
+
+Example:
+const char* OBFUSCATE_string = AY_OBFUSCATE("Hello World");
+std::cout << OBFUSCATE_string << std::endl;
+
+----------------------------------------------------------------------------- */
+
+#include
+#include
+namespace ay
+{
+ // Obfuscates a string at compile time
+ template
+ class obfuscator
+ {
+ public:
+ // Obfuscates the string 'data' on construction
+ constexpr obfuscator(const char* data)
+ {
+ static_assert(KEY != '\0', "KEY must not be the null character.");
+
+ // On construction each of the characters in the string is
+ // OBFUSCATE with an XOR cipher based on KEY
+ for (std::size_t i = 0; i < N; i++)
+ {
+ m_data[i] = data[i] ^ KEY;
+ }
+ }
+
+ constexpr const char* getData() const
+ {
+ return &m_data[0];
+ }
+
+ constexpr std::size_t getSize() const
+ {
+ return N;
+ }
+
+ constexpr char getKey() const
+ {
+ return KEY;
+ }
+
+ private:
+
+ char m_data[N]{};
+ };
+
+ // Handles decryption and re-encryption of an encrypted string at runtime
+ template
+ class OBFUSCATE_data
+ {
+ public:
+ OBFUSCATE_data(const obfuscator& obfuscator)
+ {
+ for (std::size_t i = 0; i < N; i++)
+ {
+ m_data[i] = obfuscator.getData()[i];
+ }
+ }
+
+ ~OBFUSCATE_data()
+ {
+ // Zero m_data to remove it from memory
+ for (std::size_t i = 0; i < N; i++)
+ {
+ m_data[i] = 0;
+ }
+ }
+
+ // Returns a pointer to the plain text string, decrypting it if
+ // necessary
+ operator char*()
+ {
+ decrypt();
+ return m_data;
+ }
+ operator std::string()
+ {
+ decrypt();
+ return m_data;
+ }
+ // Manually decrypt the string
+ void decrypt()
+ {
+ if (is_encrypted())
+ {
+ for (std::size_t i = 0; i < N; i++)
+ {
+ m_data[i] ^= KEY;
+ }
+ }
+ }
+
+ // Manually re-encrypt the string
+ void encrypt()
+ {
+ if (!is_encrypted())
+ {
+ for (std::size_t i = 0; i < N; i++)
+ {
+ m_data[i] ^= KEY;
+ }
+ }
+ }
+
+ // Returns true if this string is currently encrypted, false otherwise.
+ bool is_encrypted() const
+ {
+ return m_data[N - 1] != '\0';
+ }
+
+ private:
+
+ // Local storage for the string. Call is_encrypted() to check whether or
+ // not the string is currently OBFUSCATE.
+ char m_data[N];
+ };
+
+ // This function exists purely to extract the number of elements 'N' in the
+ // array 'data'
+ template
+ constexpr auto make_obfuscator(const char(&data)[N])
+ {
+ return obfuscator(data);
+ }
+}
+
+// Obfuscates the string 'data' at compile-time and returns a reference to a
+// ay::OBFUSCATE_data object with global lifetime that has functions for
+// decrypting the string and is also implicitly convertable to a char*
+#define OBFUSCATE(data) OBFUSCATE_KEY(data, '.')
+
+// Obfuscates the string 'data' with 'key' at compile-time and returns a
+// reference to a ay::OBFUSCATE_data object with global lifetime that has
+// functions for decrypting the string and is also implicitly convertable to a
+// char*
+#define OBFUSCATE_KEY(data, key) \
+ []() -> ay::OBFUSCATE_data& { \
+ constexpr auto n = sizeof(data)/sizeof(data[0]); \
+ static_assert(data[n - 1] == '\0', "String must be null terminated"); \
+ constexpr auto obfuscator = ay::make_obfuscator(data); \
+ static auto OBFUSCATE_data = ay::OBFUSCATE_data(obfuscator); \
+ return OBFUSCATE_data; \
+ }()
+
+/* -------------------------------- LICENSE ------------------------------------
+
+Public Domain (http://www.unlicense.org)
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+----------------------------------------------------------------------------- */
diff --git a/app/src/main/jni/src/KittyMemory/KittyMemory.cpp b/app/src/main/jni/src/KittyMemory/KittyMemory.cpp
new file mode 100644
index 0000000..cb458b2
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/KittyMemory.cpp
@@ -0,0 +1,149 @@
+//
+// KittyMemory.cpp
+//
+// Created by MJ (Ruit) on 1/1/19.
+//
+
+#include
+#include "KittyMemory.h"
+
+using KittyMemory::Memory_Status;
+using KittyMemory::ProcMap;
+
+
+struct mapsCache {
+ std::string identifier;
+ ProcMap map;
+};
+
+static std::vector __mapsCache;
+static ProcMap findMapInCache(std::string id){
+ ProcMap ret;
+ for(int i = 0; i < __mapsCache.size(); i++){
+ if(__mapsCache[i].identifier.compare(id) == 0){
+ ret = __mapsCache[i].map;
+ break;
+ }
+ }
+ return ret;
+}
+
+
+bool KittyMemory::ProtectAddr(void *addr, size_t length, int protection) {
+ uintptr_t pageStart = _PAGE_START_OF_(addr);
+ uintptr_t pageLen = _PAGE_LEN_OF_(addr, length);
+ return (
+ mprotect(reinterpret_cast(pageStart), pageLen, protection) != -1
+ );
+}
+
+
+Memory_Status KittyMemory::memWrite(void *addr, const void *buffer, size_t len) {
+ if (addr == NULL)
+ return INV_ADDR;
+
+ if (buffer == NULL)
+ return INV_BUF;
+
+ if (len < 1 || len > INT_MAX)
+ return INV_LEN;
+
+ if (!ProtectAddr(addr, len, _PROT_RWX_))
+ return INV_PROT;
+
+ if (memcpy(addr, buffer, len) != NULL && ProtectAddr(addr, len, _PROT_RX_))
+ return SUCCESS;
+
+ return FAILED;
+}
+
+
+Memory_Status KittyMemory::memRead(void *buffer, const void *addr, size_t len) {
+ if (addr == NULL)
+ return INV_ADDR;
+
+ if (buffer == NULL)
+ return INV_BUF;
+
+ if (len < 1 || len > INT_MAX)
+ return INV_LEN;
+
+ if (memcpy(buffer, addr, len) != NULL)
+ return SUCCESS;
+
+ return FAILED;
+}
+
+
+std::string KittyMemory::read2HexStr(const void *addr, size_t len) {
+ char temp[len];
+ memset(temp, 0, len);
+
+ const size_t bufferLen = len * 2 + 1;
+ char buffer[bufferLen];
+ memset(buffer, 0, bufferLen);
+
+ std::string ret;
+
+ if (memRead(temp, addr, len) != SUCCESS)
+ return ret;
+
+ for (int i = 0; i < len; i++) {
+ sprintf(&buffer[i * 2], "%02X", (unsigned char) temp[i]);
+ }
+
+ ret += buffer;
+ return ret;
+}
+
+ProcMap KittyMemory::getLibraryMap(const char *libraryName) {
+ ProcMap retMap;
+ char line[512] = {0};
+
+ FILE *fp = fopen(OBFUSCATE("/proc/self/maps"), OBFUSCATE("rt"));
+ if (fp != NULL) {
+ while (fgets(line, sizeof(line), fp)) {
+ if (strstr(line, libraryName)) {
+ char tmpPerms[5] = {0}, tmpDev[12] = {0}, tmpPathname[444] = {0};
+ // parse a line in maps file
+ // (format) startAddress-endAddress perms offset dev inode pathname
+ sscanf(line, "%llx-%llx %s %ld %s %d %s",
+ (long long unsigned *) &retMap.startAddr,
+ (long long unsigned *) &retMap.endAddr,
+ tmpPerms, &retMap.offset, tmpDev, &retMap.inode, tmpPathname);
+
+ retMap.length = (uintptr_t) retMap.endAddr - (uintptr_t) retMap.startAddr;
+ retMap.perms = tmpPerms;
+ retMap.dev = tmpDev;
+ retMap.pathname = tmpPathname;
+
+ break;
+ }
+ }
+ fclose(fp);
+ }
+ return retMap;
+}
+
+uintptr_t KittyMemory::getAbsoluteAddress(const char *libraryName, uintptr_t relativeAddr, bool useCache) {
+ ProcMap libMap;
+
+ if(useCache){
+ libMap = findMapInCache(libraryName);
+ if(libMap.isValid())
+ return (reinterpret_cast(libMap.startAddr) + relativeAddr);
+ }
+
+ libMap = getLibraryMap(libraryName);
+ if (!libMap.isValid())
+ return 0;
+
+ if(useCache){
+ mapsCache cachedMap;
+ cachedMap.identifier = libraryName;
+ cachedMap.map = libMap;
+ __mapsCache.push_back(cachedMap);
+ }
+
+ return (reinterpret_cast(libMap.startAddr) + relativeAddr);
+}
diff --git a/app/src/main/jni/src/KittyMemory/KittyMemory.h b/app/src/main/jni/src/KittyMemory/KittyMemory.h
new file mode 100644
index 0000000..062e21a
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/KittyMemory.h
@@ -0,0 +1,172 @@
+//
+// KittyMemory.hpp
+//
+// Created by MJ (Ruit) on 1/1/19.
+//
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+
+
+#define _SYS_PAGE_SIZE_ (sysconf(_SC_PAGE_SIZE))
+
+#define _PAGE_START_OF_(x) ((uintptr_t)x & ~(uintptr_t)(_SYS_PAGE_SIZE_ - 1))
+#define _PAGE_END_OF_(x, len) (_PAGE_START_OF_((uintptr_t)x + len - 1))
+#define _PAGE_LEN_OF_(x, len) (_PAGE_END_OF_(x, len) - _PAGE_START_OF_(x) + _SYS_PAGE_SIZE_)
+#define _PAGE_OFFSET_OF_(x) ((uintptr_t)x - _PAGE_START_OF_(x))
+
+#define _PROT_RWX_ (PROT_READ | PROT_WRITE | PROT_EXEC)
+#define _PROT_RX_ (PROT_READ | PROT_EXEC)
+
+
+#define EMPTY_VEC_OFFSET std::vector()
+
+
+namespace KittyMemory {
+
+ typedef enum {
+ FAILED = 0,
+ SUCCESS = 1,
+ INV_ADDR = 2,
+ INV_LEN = 3,
+ INV_BUF = 4,
+ INV_PROT = 5
+ } Memory_Status;
+
+
+ struct ProcMap {
+ void *startAddr;
+ void *endAddr;
+ size_t length;
+ std::string perms;
+ long offset;
+ std::string dev;
+ int inode;
+ std::string pathname;
+
+ bool isValid() { return (startAddr != NULL && endAddr != NULL && !pathname.empty()); }
+ };
+
+ /*
+ * Changes protection of an address with given length
+ */
+ bool ProtectAddr(void *addr, size_t length, int protection);
+
+ /*
+ * Writes buffer content to an address
+ */
+ Memory_Status memWrite(void *addr, const void *buffer, size_t len);
+
+ /*
+ * Reads an address content into a buffer
+ */
+ Memory_Status memRead(void *buffer, const void *addr, size_t len);
+
+ /*
+ * Reads an address content and returns hex string
+ */
+ std::string read2HexStr(const void *addr, size_t len);
+
+
+ /*
+ * Wrapper to dereference & get value of a multi level pointer
+ * Make sure to use the correct data type!
+ */
+ template
+ Type readMultiPtr(void *ptr, std::vector offsets) {
+ Type defaultVal = {};
+ if (ptr == NULL)
+ return defaultVal;
+
+ uintptr_t finalPtr = reinterpret_cast(ptr);
+ int offsetsSize = offsets.size();
+ if (offsetsSize > 0) {
+ for (int i = 0; finalPtr != 0 && i < offsetsSize; i++) {
+ if (i == (offsetsSize - 1))
+ return *reinterpret_cast(finalPtr + offsets[i]);
+
+ finalPtr = *reinterpret_cast(finalPtr + offsets[i]);
+ }
+ }
+
+ if (finalPtr == 0)
+ return defaultVal;
+
+ return *reinterpret_cast(finalPtr);
+ }
+
+
+ /*
+ * Wrapper to dereference & set value of a multi level pointer
+ * Make sure to use the correct data type!, const objects won't work
+ */
+ template
+ bool writeMultiPtr(void *ptr, std::vector offsets, Type val) {
+ if (ptr == NULL)
+ return false;
+
+ uintptr_t finalPtr = reinterpret_cast(ptr);
+ int offsetsSize = offsets.size();
+ if (offsetsSize > 0) {
+ for (int i = 0; finalPtr != 0 && i < offsetsSize; i++) {
+ if (i == (offsetsSize - 1)) {
+ *reinterpret_cast(finalPtr + offsets[i]) = val;
+ return true;
+ }
+
+ finalPtr = *reinterpret_cast(finalPtr + offsets[i]);
+ }
+ }
+
+ if (finalPtr == 0)
+ return false;
+
+ *reinterpret_cast(finalPtr) = val;
+ return true;
+ }
+
+
+ /*
+ * Wrapper to dereference & get value of a pointer
+ * Make sure to use the correct data type!
+ */
+ template
+ Type readPtr(void *ptr) {
+ Type defaultVal = {};
+ if (ptr == NULL)
+ return defaultVal;
+
+ return *reinterpret_cast(ptr);
+ }
+
+
+ /*
+ * Wrapper to dereference & set value of a pointer
+ * Make sure to use the correct data type!, const objects won't work
+ */
+ template
+ bool writePtr(void *ptr, Type val) {
+ if (ptr == NULL)
+ return false;
+
+ *reinterpret_cast(ptr) = val;
+ return true;
+ }
+
+
+ /*
+ * Gets info of a mapped library in self process
+ */
+ ProcMap getLibraryMap(const char *libraryName);
+
+ /*
+ * Expects a relative address in a library
+ * Returns final absolute address
+ */
+ uintptr_t getAbsoluteAddress(const char *libraryName, uintptr_t relativeAddr, bool useCache=false);
+};
diff --git a/app/src/main/jni/src/KittyMemory/KittyUtils.cpp b/app/src/main/jni/src/KittyMemory/KittyUtils.cpp
new file mode 100644
index 0000000..b459287
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/KittyUtils.cpp
@@ -0,0 +1,82 @@
+#include "KittyUtils.h"
+
+static void xtrim(std::string &hex){
+ if(hex.compare(0, 2, "0x") == 0){
+ hex.erase(0, 2);
+ }
+
+ // https://www.techiedelight.com/remove-whitespaces-string-cpp/
+ hex.erase(std::remove_if(hex.begin(), hex.end(), [](char c){
+ return (c == ' ' || c == '\n' || c == '\r' ||
+ c == '\t' || c == '\v' || c == '\f');
+ }),
+ hex.end());
+}
+
+
+bool KittyUtils::validateHexString(std::string &xstr){
+ if(xstr.length() < 2) return false;
+ xtrim(xstr); // first remove spaces
+ if(xstr.length() % 2 != 0) return false;
+ for(size_t i = 0; i < xstr.length(); i++){
+ if(!std::isxdigit((unsigned char)xstr[i])){
+ return false;
+ }
+ }
+ return true;
+}
+
+
+// https://tweex.net/post/c-anything-tofrom-a-hex-string/
+#include
+#include
+
+
+// ------------------------------------------------------------------
+/*!
+ Convert a block of data to a hex string
+*/
+void KittyUtils::toHex(
+ void *const data, //!< Data to convert
+ const size_t dataLength, //!< Length of the data to convert
+ std::string &dest //!< Destination string
+ )
+{
+ unsigned char *byteData = reinterpret_cast(data);
+ std::stringstream hexStringStream;
+
+ hexStringStream << std::hex << std::setfill('0');
+ for(size_t index = 0; index < dataLength; ++index)
+ hexStringStream << std::setw(2) << static_cast(byteData[index]);
+ dest = hexStringStream.str();
+}
+
+
+// ------------------------------------------------------------------
+/*!
+ Convert a hex string to a block of data
+*/
+void KittyUtils::fromHex(
+ const std::string &in, //!< Input hex string
+ void *const data //!< Data store
+ )
+{
+ size_t length = in.length();
+ unsigned char *byteData = reinterpret_cast(data);
+
+ std::stringstream hexStringStream; hexStringStream >> std::hex;
+ for(size_t strIndex = 0, dataIndex = 0; strIndex < length; ++dataIndex)
+ {
+ // Read out and convert the string two characters at a time
+ const char tmpStr[3] = { in[strIndex++], in[strIndex++], 0 };
+
+ // Reset and fill the string stream
+ hexStringStream.clear();
+ hexStringStream.str(tmpStr);
+
+ // Do the conversion
+ int tmpValue = 0;
+ hexStringStream >> tmpValue;
+ byteData[dataIndex] = static_cast(tmpValue);
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/jni/src/KittyMemory/KittyUtils.h b/app/src/main/jni/src/KittyMemory/KittyUtils.h
new file mode 100644
index 0000000..ffd81c6
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/KittyUtils.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include
+#include
+
+namespace KittyUtils {
+
+ bool validateHexString(std::string &xstr);
+ void toHex(void *const data, const size_t dataLength, std::string &dest);
+ void fromHex(const std::string &in, void *const data);
+
+}
\ No newline at end of file
diff --git a/app/src/main/jni/src/KittyMemory/MemoryBackup.cpp b/app/src/main/jni/src/KittyMemory/MemoryBackup.cpp
new file mode 100644
index 0000000..516b837
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/MemoryBackup.cpp
@@ -0,0 +1,82 @@
+//
+// MemoryBackup.cpp
+//
+// Created by MJ (Ruit) on 4/19/20.
+//
+
+#include
+#include "MemoryBackup.h"
+
+
+MemoryBackup::MemoryBackup() {
+ _address = 0;
+ _size = 0;
+ _orig_code.clear();
+}
+
+MemoryBackup::MemoryBackup(const char *libraryName, uintptr_t address, size_t backup_size, bool useMapCache) {
+ MemoryBackup();
+
+ if (libraryName == NULL || address == 0 || backup_size < 1)
+ return;
+
+ _address = KittyMemory::getAbsoluteAddress(libraryName, address, useMapCache);
+ if(_address == 0) return;
+
+ _size = backup_size;
+
+ _orig_code.resize(backup_size);
+
+ // backup current content
+ KittyMemory::memRead(&_orig_code[0], reinterpret_cast(_address), backup_size);
+}
+
+
+MemoryBackup::MemoryBackup(uintptr_t absolute_address, size_t backup_size) {
+ MemoryBackup();
+
+ if (absolute_address == 0 || backup_size < 1)
+ return;
+
+ _address = absolute_address;
+
+ _size = backup_size;
+
+ _orig_code.resize(backup_size);
+
+ // backup current content
+ KittyMemory::memRead(&_orig_code[0], reinterpret_cast(_address), backup_size);
+}
+
+ MemoryBackup::~MemoryBackup() {
+ // clean up
+ _orig_code.clear();
+ }
+
+
+ bool MemoryBackup::isValid() const {
+ return (_address != 0 && _size > 0
+ && _orig_code.size() == _size);
+ }
+
+ size_t MemoryBackup::get_BackupSize() const{
+ return _size;
+ }
+
+ uintptr_t MemoryBackup::get_TargetAddress() const{
+ return _address;
+ }
+
+ bool MemoryBackup::Restore() {
+ if (!isValid()) return false;
+ return KittyMemory::memWrite(reinterpret_cast(_address), &_orig_code[0], _size) == Memory_Status::SUCCESS;
+ }
+
+ std::string MemoryBackup::get_CurrBytes() {
+ if (!isValid())
+ _hexString = std::string(OBFUSCATE("0xInvalid"));
+ else
+ _hexString = KittyMemory::read2HexStr(reinterpret_cast(_address), _size);
+
+ return _hexString;
+ }
diff --git a/app/src/main/jni/src/KittyMemory/MemoryBackup.h b/app/src/main/jni/src/KittyMemory/MemoryBackup.h
new file mode 100644
index 0000000..fde1ea4
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/MemoryBackup.h
@@ -0,0 +1,66 @@
+//
+// MemoryBackup.h
+//
+// Created by MJ (Ruit) on 4/19/20.
+//
+
+#pragma once
+
+#include
+
+#include "KittyMemory.h"
+using KittyMemory::Memory_Status;
+using KittyMemory::ProcMap;
+
+
+class MemoryBackup {
+private:
+ uintptr_t _address;
+ size_t _size;
+
+ std::vector _orig_code;
+
+ std::string _hexString;
+
+public:
+ MemoryBackup();
+
+ /*
+ * expects library name and relative address
+ */
+ MemoryBackup(const char *libraryName, uintptr_t address, size_t backup_size, bool useMapCache=true);
+
+ /*
+ * expects absolute address
+ */
+ MemoryBackup(uintptr_t absolute_address, size_t backup_size);
+
+
+ ~MemoryBackup();
+
+
+ /*
+ * Validate patch
+ */
+ bool isValid() const;
+
+
+ size_t get_BackupSize() const;
+
+ /*
+ * Returns pointer to the target address
+ */
+ uintptr_t get_TargetAddress() const;
+
+
+ /*
+ * Restores backup code
+ */
+ bool Restore();
+
+
+ /*
+ * Returns current target address bytes as hex string
+ */
+ std::string get_CurrBytes();
+};
diff --git a/app/src/main/jni/src/KittyMemory/MemoryPatch.cpp b/app/src/main/jni/src/KittyMemory/MemoryPatch.cpp
new file mode 100644
index 0000000..a29bc7d
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/MemoryPatch.cpp
@@ -0,0 +1,138 @@
+//
+// MemoryPatch.cpp
+//
+// Created by MJ (Ruit) on 1/1/19.
+//
+
+#include
+#include "MemoryPatch.h"
+
+
+MemoryPatch::MemoryPatch() {
+ _address = 0;
+ _size = 0;
+ _orig_code.clear();
+ _patch_code.clear();
+}
+
+MemoryPatch::MemoryPatch(const char *libraryName, uintptr_t address,
+ const void *patch_code, size_t patch_size, bool useMapCache) {
+ MemoryPatch();
+
+ if (libraryName == NULL || address == 0 || patch_code == NULL || patch_size < 1)
+ return;
+
+ _address = KittyMemory::getAbsoluteAddress(libraryName, address, useMapCache);
+ if(_address == 0) return;
+
+ _size = patch_size;
+
+ _orig_code.resize(patch_size);
+ _patch_code.resize(patch_size);
+
+ // initialize patch & backup current content
+ KittyMemory::memRead(&_patch_code[0], patch_code, patch_size);
+ KittyMemory::memRead(&_orig_code[0], reinterpret_cast(_address), patch_size);
+}
+
+
+MemoryPatch::MemoryPatch(uintptr_t absolute_address,
+ const void *patch_code, size_t patch_size) {
+ MemoryPatch();
+
+ if (absolute_address == 0 || patch_code == NULL || patch_size < 1)
+ return;
+
+ _address = absolute_address;
+ _size = patch_size;
+
+ _orig_code.resize(patch_size);
+ _patch_code.resize(patch_size);
+
+ // initialize patch & backup current content
+ KittyMemory::memRead(&_patch_code[0], patch_code, patch_size);
+ KittyMemory::memRead(&_orig_code[0], reinterpret_cast(_address), patch_size);
+}
+
+ MemoryPatch::~MemoryPatch() {
+ // clean up
+ _orig_code.clear();
+ _patch_code.clear();
+ }
+
+
+ MemoryPatch MemoryPatch::createWithHex(const char *libraryName, uintptr_t address,
+ std::string hex, bool useMapCache) {
+ MemoryPatch patch;
+
+ if (libraryName == NULL || address == 0 || !KittyUtils::validateHexString(hex))
+ return patch;
+
+ patch._address = KittyMemory::getAbsoluteAddress(libraryName, address, useMapCache);
+ if(patch._address == 0) return patch;
+
+ patch._size = hex.length() / 2;
+
+ patch._orig_code.resize(patch._size);
+ patch._patch_code.resize(patch._size);
+
+ // initialize patch
+ KittyUtils::fromHex(hex, &patch._patch_code[0]);
+
+ // backup current content
+ KittyMemory::memRead(&patch._orig_code[0], reinterpret_cast(patch._address), patch._size);
+ return patch;
+ }
+
+ MemoryPatch MemoryPatch::createWithHex(uintptr_t absolute_address, std::string hex) {
+ MemoryPatch patch;
+
+ if (absolute_address == 0 || !KittyUtils::validateHexString(hex))
+ return patch;
+
+ patch._address = absolute_address;
+ patch._size = hex.length() / 2;
+
+ patch._orig_code.resize(patch._size);
+ patch._patch_code.resize(patch._size);
+
+ // initialize patch
+ KittyUtils::fromHex(hex, &patch._patch_code[0]);
+
+ // backup current content
+ KittyMemory::memRead(&patch._orig_code[0], reinterpret_cast(patch._address), patch._size);
+ return patch;
+ }
+
+
+ bool MemoryPatch::isValid() const {
+ return (_address != 0 && _size > 0
+ && _orig_code.size() == _size && _patch_code.size() == _size);
+ }
+
+ size_t MemoryPatch::get_PatchSize() const{
+ return _size;
+ }
+
+ uintptr_t MemoryPatch::get_TargetAddress() const{
+ return _address;
+ }
+
+ bool MemoryPatch::Restore() {
+ if (!isValid()) return false;
+ return KittyMemory::memWrite(reinterpret_cast(_address), &_orig_code[0], _size) == Memory_Status::SUCCESS;
+ }
+
+ bool MemoryPatch::Modify() {
+ if (!isValid()) return false;
+ return (KittyMemory::memWrite(reinterpret_cast(_address), &_patch_code[0], _size) == Memory_Status::SUCCESS);
+ }
+
+ std::string MemoryPatch::get_CurrBytes() {
+ if (!isValid())
+ _hexString = std::string(OBFUSCATE("0xInvalid"));
+ else
+ _hexString = KittyMemory::read2HexStr(reinterpret_cast(_address), _size);
+
+ return _hexString;
+ }
diff --git a/app/src/main/jni/src/KittyMemory/MemoryPatch.h b/app/src/main/jni/src/KittyMemory/MemoryPatch.h
new file mode 100644
index 0000000..5d3b273
--- /dev/null
+++ b/app/src/main/jni/src/KittyMemory/MemoryPatch.h
@@ -0,0 +1,83 @@
+//
+// MemoryPatch.h
+//
+// Created by MJ (Ruit) on 1/1/19.
+//
+
+#pragma once
+
+#include
+
+#include "KittyUtils.h"
+
+#include "KittyMemory.h"
+using KittyMemory::Memory_Status;
+using KittyMemory::ProcMap;
+
+
+class MemoryPatch {
+private:
+ uintptr_t _address;
+ size_t _size;
+
+ std::vector _orig_code;
+ std::vector _patch_code;
+
+ std::string _hexString;
+
+public:
+ MemoryPatch();
+
+ /*
+ * expects library name and relative address
+ */
+ MemoryPatch(const char *libraryName, uintptr_t address,
+ const void *patch_code, size_t patch_size, bool useMapCache=true);
+
+
+ /*
+ * expects absolute address
+ */
+ MemoryPatch(uintptr_t absolute_address,
+ const void *patch_code, size_t patch_size);
+
+
+ ~MemoryPatch();
+
+ /*
+ * compatible hex format (0xffff & ffff & ff ff)
+ */
+ static MemoryPatch createWithHex(const char *libraryName, uintptr_t address, std::string hex, bool useMapCache=true);
+ static MemoryPatch createWithHex(uintptr_t absolute_address, std::string hex);
+
+ /*
+ * Validate patch
+ */
+ bool isValid() const;
+
+
+ size_t get_PatchSize() const;
+
+ /*
+ * Returns pointer to the target address
+ */
+ uintptr_t get_TargetAddress() const;
+
+
+ /*
+ * Restores patch to original value
+ */
+ bool Restore();
+
+
+ /*
+ * Applies patch modifications to target address
+ */
+ bool Modify();
+
+
+ /*
+ * Returns current patch target address bytes as hex string
+ */
+ std::string get_CurrBytes();
+};
diff --git a/app/src/main/jni/src/Main.cpp b/app/src/main/jni/src/Main.cpp
new file mode 100644
index 0000000..99cd820
--- /dev/null
+++ b/app/src/main/jni/src/Main.cpp
@@ -0,0 +1,206 @@
+/*
+ * Credits:
+ *
+ * Octowolve - Mod menu: https://github.com/z3r0Sec/Substrate-Template-With-Mod-Menu
+ * And hooking: https://github.com/z3r0Sec/Substrate-Hooking-Example
+ * VanHoevenTR A.K.A Nixi: https://github.com/LGLTeam/VanHoevenTR_Android_Mod_Menu
+ * MrIkso - Mod menu: https://github.com/MrIkso/FloatingModMenu
+ * Rprop - https://github.com/Rprop/And64InlineHook
+ * MJx0 A.K.A Ruit - KittyMemory: https://github.com/MJx0/KittyMemory
+ * */
+
+#include
+#include
+#include "KittyMemory/MemoryPatch.h"
+#include "Includes/Logger.h"
+#include "Includes/Utils.h"
+#include "Includes/obfuscate.h"
+
+#if defined(__aarch64__) //Compile for arm64 lib only
+#include
+#else //Compile for armv7 lib only. Do not worry about greyed out highlighting code, it still works
+
+#include
+#include
+
+#endif
+
+// fancy struct for patches for kittyMemory
+struct My_Patches {
+ // let's assume we have patches for these functions for whatever game
+ // like show in miniMap boolean function
+ MemoryPatch GodMode, SpeedHack;
+ // etc...
+} hexPatches;
+
+bool feature1 = false, featureHookToggle = false;
+int sliderValue = 0;
+
+#define libName OBFUSCATE("libil2cpp.so")
+
+extern "C" {
+//Can be used if you want to load lib without menu. Call it from LoadLibWithoutMenu.java
+//isToastCalled is used in hack_thread. Call bad function if false
+bool isToastCalled = false;
+JNIEXPORT void JNICALL
+Java_uk_lgl_loadlib_LoadLib_Toast(JNIEnv *env, jobject thiz, jobject obj) {
+ MakeToast(env, obj, OBFUSCATE("Lib loaded. Modded by LGL"), Toast::LENGTH_LONG);
+ MakeToast(env, obj, OBFUSCATE("Lib loaded. Modded by LGL"), Toast::LENGTH_LONG);
+ isToastCalled = true;
+}
+
+JNIEXPORT void JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_Changes(JNIEnv *env, jobject obj,
+ jint feature, jint value) {
+
+ LOGD(OBFUSCATE("Feature: = %d"), feature);
+ LOGD(OBFUSCATE("Value: = %d"), value);
+
+ // You must count your features from 0 (YES, I MEAN ZERO), not 1
+
+ switch (feature) {
+ // The category was 0 so "case 0" is not used
+ case 0:
+ break;
+ case 1: // Switch
+ feature1 = !feature1;
+
+ if (feature1) {
+ MakeToast(env, obj, OBFUSCATE("Feature 1 ON"), Toast::LENGTH_SHORT);
+ // modify & print bytes
+ if (hexPatches.GodMode.Modify()) {
+ LOGD(OBFUSCATE("Current Bytes: %s"),
+ hexPatches.GodMode.get_CurrBytes().c_str());
+ }
+ //Or
+ hexPatches.GodMode.Modify();
+ } else {
+ MakeToast(env, obj, OBFUSCATE("Feature 1 OFF"), Toast::LENGTH_SHORT);
+ //restore & print bytes
+ if (hexPatches.GodMode.Restore()) {
+ LOGD(OBFUSCATE("Current Bytes: %s"),
+ hexPatches.GodMode.get_CurrBytes().c_str());
+ }
+ //Or
+ hexPatches.GodMode.Restore();
+ }
+ break;
+ case 2: // Slider in hook example
+ sliderValue = value;
+ break;
+ case 3: // Spinner
+ switch (value) {
+ case 0:
+ MakeToast(env, obj, OBFUSCATE("Selected item 1"), Toast::LENGTH_SHORT);
+ break;
+ case 1:
+ MakeToast(env, obj, OBFUSCATE("Selected item 2"), Toast::LENGTH_SHORT);
+ break;
+ case 2:
+ MakeToast(env, obj, OBFUSCATE("Selected item 3"), Toast::LENGTH_SHORT);
+ break;
+ }
+ break;
+ case 4: // Button
+ MakeToast(env, obj, OBFUSCATE("Button pressed"), Toast::LENGTH_SHORT);
+ break;
+ case 5:
+ featureHookToggle = !featureHookToggle;
+ break;
+ }
+}
+}
+
+// ---------- Hooking ---------- //
+
+bool (*old_get_BoolExample)(void *instance);
+
+bool get_BoolExample(void *instance) {
+ if (instance != NULL && featureHookToggle) {
+ return true;
+ }
+ return old_get_BoolExample(instance);
+}
+
+float (*old_get_FloatExample)(void *instance);
+
+float get_FloatExample(void *instance) {
+ if (instance != NULL && sliderValue > 1) {
+ return (float) sliderValue;
+ }
+ return old_get_FloatExample(instance);
+}
+
+// we will run our patches in a new thread so our while loop doesn't block process main thread
+// Don't forget to remove or comment out logs before you compile it.
+
+//KittyMemory Android Example: https://github.com/MJx0/KittyMemory/blob/master/Android/test/src/main.cpp
+//Note: We use OBFUSCATE_KEY for offsets which is the important part xD
+void *hack_thread(void *) {
+ LOGI(OBFUSCATE("Lib have been loaded"));
+
+// do {
+// sleep(1);
+// } while (!isLibraryLoaded(libName));
+
+#if defined(__aarch64__) //Compile for arm64 lib only
+ // possible with hex & no need to specify len
+ hexPatches.GodMode = MemoryPatch::createWithHex(libName, string2Offset(OBFUSCATE_KEY("0x123456", 'a')), OBFUSCATE("000080D2C0035FD6"));
+
+ // spaces are fine too
+ hexPatches.GodMode = MemoryPatch::createWithHex(libName, string2Offset(OBFUSCATE_KEY("0x123456", 'b')), OBFUSCATE("00 00 80 D2 C0 03 5F D6"));
+
+ // Offset Hook example
+ A64HookFunction((void *) getAbsoluteAddress(libName, string2Offset(OBFUSCATE_KEY("0x123456", 'l'))), (void *) get_BoolExample,
+ (void **) &old_get_BoolExample);
+
+ // Symbol hook example (untested). Symbol/function names can be found in IDA if the lib are not stripped. This is not for il2cpp games
+ A64HookFunction((void *)("__SymbolNameExample"), (void *) get_BoolExample,
+ (void **) &old_get_BoolExample);
+
+#else //Compile for armv7 lib only. Do not worry about greyed out highlighting code, it still works
+ // possible with hex & no need to specify len
+ hexPatches.GodMode = MemoryPatch::createWithHex(libName,
+ string2Offset(OBFUSCATE_KEY("0x123456", 'a')),
+ OBFUSCATE("0000A0E31EFF2FE1"));
+
+ // spaces are fine too
+ hexPatches.GodMode = MemoryPatch::createWithHex(libName,
+ string2Offset(OBFUSCATE_KEY("0x123456", '-')),
+ OBFUSCATE("00 00 A0 E3 1E FF 2F E1"));
+
+ // Offset Hook example
+ MSHookFunction(
+ (void *) getAbsoluteAddress(libName, string2Offset(OBFUSCATE_KEY("0x123456", '?'))),
+ (void *) get_BoolExample,
+ (void **) &old_get_BoolExample);
+
+ // Symbol hook example (untested). Symbol/function names can be found in IDA if the lib are not stripped. This is not for il2cpp games
+ MSHookFunction((void *) ("__SymbolNameExample"), (void *) get_BoolExample,
+ (void **) &old_get_BoolExample);
+
+ LOGI(OBFUSCATE("Hooked"));
+#endif
+
+ //Call bad function if isToastCalled is false. Only use with LoadLibWithoutMenu
+ /*
+ sleep(3);
+ if (!isToastCalled){
+ int *p = 0;
+ *p = 0;
+ }*/
+
+ return NULL;
+}
+
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM *vm, void *reserved) {
+ JNIEnv *globalEnv;
+ vm->GetEnv((void **) &globalEnv, JNI_VERSION_1_6);
+
+ // Create a new thread so it does not block the main thread, means the game would not freeze
+ pthread_t ptid;
+ pthread_create(&ptid, NULL, hack_thread, NULL);
+
+ return JNI_VERSION_1_6;
+}
diff --git a/app/src/main/jni/src/Menu.cpp b/app/src/main/jni/src/Menu.cpp
new file mode 100644
index 0000000..6da4914
--- /dev/null
+++ b/app/src/main/jni/src/Menu.cpp
@@ -0,0 +1,147 @@
+#include
+#include
+#include
+#include "Includes/Logger.h"
+#include "Includes/Utils.h"
+#include "Includes/obfuscate.h"
+
+bool titleValid = false, headingValid = false, iconValid = false, featureListValid = false;
+
+//Check if text has been changed via java/smali
+void *antiLeech(void *) {
+ //bad function
+
+ sleep(5);
+
+ if (!titleValid) {
+ //Bad function to make it crash
+ //Note: We want to avoid using exit() method call
+ int *p = 0;
+ *p = 0;
+ }
+ if (!headingValid) {
+ int *p = 0;
+ *p = 0;
+ }
+ if (!iconValid) {
+ int *p = 0;
+ *p = 0;
+ }
+ if (!featureListValid) {
+ int *p = 0;
+ *p = 0;
+ }
+ return NULL;
+}
+
+extern "C" {
+JNIEXPORT jboolean
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_EnableSounds(JNIEnv *env, jobject thiz) {
+ return true;
+}
+
+JNIEXPORT jstring
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_Title(JNIEnv *env, jobject thiz) {
+ titleValid = true;
+ return env->NewStringUTF(OBFUSCATE("Modded by HadesNull"));
+}
+
+JNIEXPORT jstring
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_Heading(JNIEnv *env, jobject thiz) {
+ headingValid = true;
+ return env->NewStringUTF(OBFUSCATE("Put your website or notes here"));
+}
+
+JNIEXPORT jstring
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_Icon(JNIEnv *env, jobject thiz) {
+ iconValid = true;
+
+ //Use https://www.base64encode.org/ to encode your image to base64
+ return env->NewStringUTF(
+ "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");
+}
+
+JNIEXPORT jstring
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_IconWebViewData(JNIEnv *env, jobject thiz) {
+ iconValid = true;
+
+ //Upload your image or gif on imgur.com or other sites
+ //To disable it:
+ //return NULL
+ //It would load the base64 icon from above as usual
+
+ //From internet (Requires android.permission.INTERNET)
+ // return env->NewStringUTF("https://i.imgur.com/SujJ85j.gif");
+
+ //From assets folder: (Requires android.permission.INTERNET)
+ // return env->NewStringUTF("file:///android_asset/example.gif");
+
+ //Base64 html:
+ // return env->NewStringUTF("data:image/png;base64, ");
+
+ //Nothing:
+ // return NULL
+
+ //return env->NewStringUTF("https://i.imgur.com/SujJ85j.gif");
+ return NULL;
+}
+
+JNIEXPORT jint
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_IconSize(JNIEnv *env, jobject thiz) {
+ return 40;
+}
+
+JNIEXPORT void
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_ToastStartup(JNIEnv *env, jobject thiz) {
+ MakeToast(env, thiz, OBFUSCATE("Menu loaded by HadesNull"), Toast::LENGTH_LONG);
+}
+
+JNIEXPORT jobjectArray
+JNICALL
+Java_uk_lgl_modmenu_FloatingModMenuService_getFeatureList(JNIEnv *env, jobject activityObject) {
+ jobjectArray ret;
+ featureListValid = true;
+
+ // Note: Do not translate the first text
+ // Usage:
+ // Category_(text)
+ // Toggle_[feature name]
+ // SeekBar_[feature name]_[min value]_[max value]
+ // Spinner_[feature name]_[Items e.g. item1_item2_item3]
+ // Button_[feature name]
+ // Button_OnOff_[feature name]
+ // InputValue_[feature name]
+ const char *features[] = {
+ // OBFUSCATE("Category_The Category"),
+ OBFUSCATE("Toggle_The toggle"),
+ OBFUSCATE("SeekBar_The slider_0_100"),
+ OBFUSCATE("Spinner_The spinner_Items 1_Items 2_Items 3"),
+ OBFUSCATE("Button_Open hack shield"),
+ OBFUSCATE("Button_OnOff_The On/Off button"),
+ OBFUSCATE("InputValue_The input number")
+ };
+
+ int Total_Feature = (sizeof features /
+ sizeof features[0]); //Now you dont have to manually update the number everytime;
+
+ ret = (jobjectArray)
+ env->NewObjectArray(Total_Feature, env->FindClass(OBFUSCATE("java/lang/String")),
+ env->NewStringUTF(""));
+ int i;
+ for (i = 0; i < Total_Feature; i++)
+ env->SetObjectArrayElement(ret, i, env->NewStringUTF(features[i]));
+
+ //Run anti-leech
+ pthread_t ptid;
+ pthread_create(&ptid, NULL, antiLeech, NULL);
+
+ return (ret);
+}
+}
\ No newline at end of file
diff --git a/app/src/main/jni/src/Substrate/Buffer.hpp b/app/src/main/jni/src/Substrate/Buffer.hpp
new file mode 100644
index 0000000..34d9df3
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/Buffer.hpp
@@ -0,0 +1,38 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#ifndef SUBSTRATE_BUFFER_HPP
+#define SUBSTRATE_BUFFER_HPP
+
+#include
+
+template
+_disused static _finline void MSWrite(uint8_t *&buffer, Type_ value) {
+ *reinterpret_cast(buffer) = value;
+ buffer += sizeof(Type_);
+}
+
+_disused static _finline void MSWrite(uint8_t *&buffer, uint8_t *data, size_t size) {
+ memcpy(buffer, data, size);
+ buffer += size;
+}
+
+#endif//SUBSTRATE_BUFFER_HPP
diff --git a/app/src/main/jni/src/Substrate/CydiaSubstrate.h b/app/src/main/jni/src/Substrate/CydiaSubstrate.h
new file mode 100644
index 0000000..bb806aa
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/CydiaSubstrate.h
@@ -0,0 +1,152 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#ifndef SUBSTRATE_H_
+#define SUBSTRATE_H_
+
+#ifdef __APPLE__
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include
+#ifdef __cplusplus
+}
+#endif
+
+#include
+#include
+#endif
+
+#include
+#include
+
+#define _finline \
+ inline __attribute__((__always_inline__))
+#define _disused \
+ __attribute__((__unused__))
+
+#define _extern \
+ extern "C" __attribute__((__visibility__("default")))
+
+#ifdef __cplusplus
+#define _default(value) = value
+#else
+#define _default(value)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool MSHookProcess(pid_t pid, const char *library);
+
+typedef const void *MSImageRef;
+
+MSImageRef MSGetImageByName(const char *file);
+void *MSFindSymbol(MSImageRef image, const char *name);
+
+void MSHookFunction(void *symbol, void *replace, void **result);
+
+#ifdef __APPLE__
+#ifdef __arm__
+__attribute__((__deprecated__))
+IMP MSHookMessage(Class _class, SEL sel, IMP imp, const char *prefix _default(NULL));
+#endif
+void MSHookMessageEx(Class _class, SEL sel, IMP imp, IMP *result);
+#endif
+
+#ifdef SubstrateInternal
+typedef void *SubstrateAllocatorRef;
+typedef struct __SubstrateProcess *SubstrateProcessRef;
+typedef struct __SubstrateMemory *SubstrateMemoryRef;
+
+SubstrateProcessRef SubstrateProcessCreate(SubstrateAllocatorRef allocator, pid_t pid);
+void SubstrateProcessRelease(SubstrateProcessRef process);
+
+SubstrateMemoryRef SubstrateMemoryCreate(SubstrateAllocatorRef allocator, SubstrateProcessRef process, void *data, size_t size);
+void SubstrateMemoryRelease(SubstrateMemoryRef memory);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+#ifdef SubstrateInternal
+struct SubstrateHookMemory {
+ SubstrateMemoryRef handle_;
+
+ SubstrateHookMemory(SubstrateProcessRef process, void *data, size_t size) :
+ handle_(SubstrateMemoryCreate(NULL, NULL, data, size))
+ {
+ }
+
+ ~SubstrateHookMemory() {
+ if (handle_ != NULL)
+ SubstrateMemoryRelease(handle_);
+ }
+};
+#endif
+
+
+template
+static inline void MSHookFunction(Type_ *symbol, Type_ *replace, Type_ **result) {
+ MSHookFunction(
+ reinterpret_cast(symbol),
+ reinterpret_cast(replace),
+ reinterpret_cast(result)
+ );
+}
+
+template
+static inline void MSHookFunction(Type_ *symbol, Type_ *replace) {
+ return MSHookFunction(symbol, replace, reinterpret_cast(NULL));
+}
+
+template
+static inline void MSHookSymbol(Type_ *&value, const char *name, MSImageRef image = NULL) {
+ value = reinterpret_cast(MSFindSymbol(image, name));
+}
+
+template
+static inline void MSHookFunction(const char *name, Type_ *replace, Type_ **result = NULL) {
+ Type_ *symbol;
+ MSHookSymbol(symbol, name);
+ return MSHookFunction(symbol, replace, result);
+}
+
+#endif
+
+#define MSHook(type, name, args...) \
+ _disused static type (*_ ## name)(args); \
+ static type $ ## name(args)
+
+#ifdef __cplusplus
+#define MSHake(name) \
+ &$ ## name, &_ ## name
+#else
+#define MSHake(name) \
+ &$ ## name, (void **) &_ ## name
+#endif
+
+
+#endif//SUBSTRATE_H_
diff --git a/app/src/main/jni/src/Substrate/SubstrateARM.hpp b/app/src/main/jni/src/Substrate/SubstrateARM.hpp
new file mode 100644
index 0000000..02b3028
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateARM.hpp
@@ -0,0 +1,65 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#ifndef SUBSTRATE_ARM_HPP
+#define SUBSTRATE_ARM_HPP
+
+enum A$r {
+ A$r0, A$r1, A$r2, A$r3,
+ A$r4, A$r5, A$r6, A$r7,
+ A$r8, A$r9, A$r10, A$r11,
+ A$r12, A$r13, A$r14, A$r15,
+ A$sp = A$r13,
+ A$lr = A$r14,
+ A$pc = A$r15
+};
+
+enum A$c {
+ A$eq, A$ne, A$cs, A$cc,
+ A$mi, A$pl, A$vs, A$vc,
+ A$hi, A$ls, A$ge, A$lt,
+ A$gt, A$le, A$al,
+ A$hs = A$cs,
+ A$lo = A$cc
+};
+
+#define A$mrs_rm_cpsr(rd) /* mrs rd, cpsr */ \
+ (0xe10f0000 | ((rd) << 12))
+#define A$msr_cpsr_f_rm(rm) /* msr cpsr_f, rm */ \
+ (0xe128f000 | (rm))
+#define A$ldr_rd_$rn_im$(rd, rn, im) /* ldr rd, [rn, #im] */ \
+ (0xe5100000 | ((im) < 0 ? 0 : 1 << 23) | ((rn) << 16) | ((rd) << 12) | abs((int)(im)))
+#define A$str_rd_$rn_im$(rd, rn, im) /* sr rd, [rn, #im] */ \
+ (0xe5000000 | ((im) < 0 ? 0 : 1 << 23) | ((rn) << 16) | ((rd) << 12) | abs(im))
+#define A$sub_rd_rn_$im(rd, rn, im) /* sub, rd, rn, #im */ \
+ (0xe2400000 | ((rn) << 16) | ((rd) << 12) | (im & 0xff))
+#define A$blx_rm(rm) /* blx rm */ \
+ (0xe12fff30 | (rm))
+#define A$mov_rd_rm(rd, rm) /* mov rd, rm */ \
+ (0xe1a00000 | ((rd) << 12) | (rm))
+#define A$ldmia_sp$_$rs$(rs) /* ldmia sp!, {rs} */ \
+ (0xe8b00000 | (A$sp << 16) | (rs))
+#define A$stmdb_sp$_$rs$(rs) /* stmdb sp!, {rs} */ \
+ (0xe9200000 | (A$sp << 16) | (rs))
+#define A$stmia_sp$_$r0$ 0xe8ad0001 /* stmia sp!, {r0} */
+#define A$bx_r0 0xe12fff10 /* bx r0 */
+
+#endif//SUBSTRATE_ARM_HPP
diff --git a/app/src/main/jni/src/Substrate/SubstrateDebug.cpp b/app/src/main/jni/src/Substrate/SubstrateDebug.cpp
new file mode 100644
index 0000000..2df6ef4
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateDebug.cpp
@@ -0,0 +1,96 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#include "SubstrateHook.h"
+#include "SubstrateDebug.hpp"
+
+#include
+#include
+#include
+
+_extern bool MSDebug;
+bool MSDebug = false;
+
+static char _MSHexChar(uint8_t value) {
+ return value < 0x20 || value >= 0x80 ? '.' : value;
+}
+
+#define HexWidth_ 16
+#define HexDepth_ 4
+
+void MSLogHexEx(const void *vdata, size_t size, size_t stride, const char *mark) {
+ const uint8_t *data((const uint8_t *) vdata);
+
+ size_t i(0), j;
+
+ char d[256];
+ size_t b(0);
+ d[0] = '\0';
+
+ while (i != size) {
+ if (i % HexWidth_ == 0) {
+ if (mark != NULL)
+ b += sprintf(d + b, "\n[%s] ", mark);
+ b += sprintf(d + b, "0x%.3zx:", i);
+ }
+
+ b += sprintf(d + b, " ");
+
+ for (size_t q(0); q != stride; ++q)
+ b += sprintf(d + b, "%.2x", data[i + stride - q - 1]);
+
+ i += stride;
+
+ for (size_t q(1); q != stride; ++q)
+ b += sprintf(d + b, " ");
+
+ if (i % HexDepth_ == 0)
+ b += sprintf(d + b, " ");
+
+ if (i % HexWidth_ == 0) {
+ b += sprintf(d + b, " ");
+ for (j = i - HexWidth_; j != i; ++j)
+ b += sprintf(d + b, "%c", _MSHexChar(data[j]));
+
+ lprintf("%s", d);
+ b = 0;
+ d[0] = '\0';
+ }
+ }
+
+ if (i % HexWidth_ != 0) {
+ for (j = i % HexWidth_; j != HexWidth_; ++j)
+ b += sprintf(d + b, " ");
+ for (j = 0; j != (HexWidth_ - i % HexWidth_ + HexDepth_ - 1) / HexDepth_; ++j)
+ b += sprintf(d + b, " ");
+ b += sprintf(d + b, " ");
+ for (j = i / HexWidth_ * HexWidth_; j != i; ++j)
+ b += sprintf(d + b, "%c", _MSHexChar(data[j]));
+
+ lprintf("%s", d);
+ b = 0;
+ d[0] = '\0';
+ }
+}
+
+void MSLogHex(const void *vdata, size_t size, const char *mark) {
+ return MSLogHexEx(vdata, size, 1, mark);
+}
diff --git a/app/src/main/jni/src/Substrate/SubstrateDebug.hpp b/app/src/main/jni/src/Substrate/SubstrateDebug.hpp
new file mode 100644
index 0000000..9c554c8
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateDebug.hpp
@@ -0,0 +1,33 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#ifndef SUBSTRATE_DEBUG_HPP
+#define SUBSTRATE_DEBUG_HPP
+
+#include "SubstrateLog.hpp"
+#define lprintf(format, ...) \
+ MSLog(MSLogLevelNotice, format, ## __VA_ARGS__)
+
+extern "C" bool MSDebug;
+void MSLogHexEx(const void *vdata, size_t size, size_t stride, const char *mark = 0);
+void MSLogHex(const void *vdata, size_t size, const char *mark = 0);
+
+#endif//SUBSTRATE_DEBUG_HPP
diff --git a/app/src/main/jni/src/Substrate/SubstrateHook.cpp b/app/src/main/jni/src/Substrate/SubstrateHook.cpp
new file mode 100644
index 0000000..55eb9d5
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateHook.cpp
@@ -0,0 +1,938 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#define SubstrateInternal
+#include "CydiaSubstrate.h"
+
+#include
+
+#define _trace() do { \
+ MSLog(MSLogLevelNotice, "_trace(%u)", __LINE__); \
+} while (false)
+
+#if defined(__i386__) || defined(__x86_64__)
+#include "hde64.h"
+#endif
+
+#include "SubstrateDebug.hpp"
+
+#include
+#include
+#include
+#include
+
+#ifdef __arm__
+/* WebCore (ARM) PC-Relative:
+X 1 ldr r*,[pc,r*] !=
+ 2 fldd d*,[pc,#*]
+X 5 str r*,[pc,r*] !=
+ 8 flds s*,[pc,#*]
+ 400 ldr r*,[pc,r*] ==
+ 515 add r*, pc,r* ==
+X 4790 ldr r*,[pc,#*] */
+
+// x=0; while IFS= read -r line; do if [[ ${#line} -ne 0 && $line == +([^\;]): ]]; then x=2; elif [[ $line == ' +'* && $x -ne 0 ]]; then ((--x)); echo "$x${line}"; fi; done WebCore.pc
+// grep pc WebCore.pc | cut -c 40- | sed -Ee 's/^ldr *(ip|r[0-9]*),\[pc,\#0x[0-9a-f]*\].*/ ldr r*,[pc,#*]/;s/^add *r[0-9]*,pc,r[0-9]*.*/ add r*, pc,r*/;s/^(st|ld)r *r([0-9]*),\[pc,r([0-9]*)\].*/ \1r r\2,[pc,r\3]/;s/^fld(s|d) *(s|d)[0-9]*,\[pc,#0x[0-9a-f]*].*/fld\1 \2*,[pc,#*]/' | sort | uniq -c | sort -n
+
+#include "SubstrateARM.hpp"
+
+#define T$Label(l, r) \
+ (((r) - (l)) * 2 - 4 + ((l) % 2 == 0 ? 0 : 2))
+
+#define T$pop_$r0$ 0xbc01 // pop {r0}
+#define T$b(im) /* b im */ \
+ (0xde00 | (im & 0xff))
+#define T$blx(rm) /* blx rm */ \
+ (0x4780 | (rm << 3))
+#define T$bx(rm) /* bx rm */ \
+ (0x4700 | (rm << 3))
+#define T$nop /* nop */ \
+ (0x46c0)
+
+#define T$add_rd_rm(rd, rm) /* add rd, rm */ \
+ (0x4400 | (((rd) & 0x8) >> 3 << 7) | (((rm) & 0x8) >> 3 << 6) | (((rm) & 0x7) << 3) | ((rd) & 0x7))
+#define T$push_r(r) /* push r... */ \
+ (0xb400 | (((r) & (1 << A$lr)) >> A$lr << 8) | ((r) & 0xff))
+#define T$pop_r(r) /* pop r... */ \
+ (0xbc00 | (((r) & (1 << A$pc)) >> A$pc << 8) | ((r) & 0xff))
+#define T$mov_rd_rm(rd, rm) /* mov rd, rm */ \
+ (0x4600 | (((rd) & 0x8) >> 3 << 7) | (((rm) & 0x8) >> 3 << 6) | (((rm) & 0x7) << 3) | ((rd) & 0x7))
+#define T$ldr_rd_$rn_im_4$(rd, rn, im) /* ldr rd, [rn, #im * 4] */ \
+ (0x6800 | (((im) & 0x1f) << 6) | ((rn) << 3) | (rd))
+#define T$ldr_rd_$pc_im_4$(rd, im) /* ldr rd, [PC, #im * 4] */ \
+ (0x4800 | ((rd) << 8) | ((im) & 0xff))
+#define T$cmp_rn_$im(rn, im) /* cmp rn, #im */ \
+ (0x2000 | ((rn) << 8) | ((im) & 0xff))
+#define T$it$_cd(cd, ms) /* it, cd */ \
+ (0xbf00 | ((cd) << 4) | (ms))
+#define T$cbz$_rn_$im(op,rn,im) /* cbz rn, #im */ \
+ (0xb100 | ((op) << 11) | (((im) & 0x40) >> 6 << 9) | (((im) & 0x3e) >> 1 << 3) | (rn))
+#define T$b$_$im(cond,im) /* b #im */ \
+ (cond == A$al ? 0xe000 | (((im) >> 1) & 0x7ff) : 0xd000 | ((cond) << 8) | (((im) >> 1) & 0xff))
+
+#define T1$ldr_rt_$rn_im$(rt, rn, im) /* ldr rt, [rn, #im] */ \
+ (0xf850 | ((im < 0 ? 0 : 1) << 7) | (rn))
+#define T2$ldr_rt_$rn_im$(rt, rn, im) /* ldr rt, [rn, #im] */ \
+ (((rt) << 12) | abs((int)(im)))
+
+#define T1$mrs_rd_apsr(rd) /* mrs rd, apsr */ \
+ (0xf3ef)
+#define T2$mrs_rd_apsr(rd) /* mrs rd, apsr */ \
+ (0x8000 | ((rd) << 8))
+
+#define T1$msr_apsr_nzcvqg_rn(rn) /* msr apsr, rn */ \
+ (0xf380 | (rn))
+#define T2$msr_apsr_nzcvqg_rn(rn) /* msr apsr, rn */ \
+ (0x8c00)
+#define T$msr_apsr_nzcvqg_rn(rn) /* msr apsr, rn */ \
+ (T2$msr_apsr_nzcvqg_rn(rn) << 16 | T1$msr_apsr_nzcvqg_rn(rn))
+
+static inline bool A$pcrel$r(uint32_t ic) {
+ return (ic & 0x0c000000) == 0x04000000 && (ic & 0xf0000000) != 0xf0000000 && (ic & 0x000f0000) == 0x000f0000;
+}
+
+static inline bool T$32bit$i(uint16_t ic) {
+ return ((ic & 0xe000) == 0xe000 && (ic & 0x1800) != 0x0000);
+}
+
+static inline bool T$pcrel$cbz(uint16_t ic) {
+ return (ic & 0xf500) == 0xb100;
+}
+
+static inline bool T$pcrel$b(uint16_t ic) {
+ return (ic & 0xf000) == 0xd000 && (ic & 0x0e00) != 0x0e00;
+}
+
+static inline bool T2$pcrel$b(uint16_t *ic) {
+ return (ic[0] & 0xf800) == 0xf000 && (((ic[1] & 0xd000) == 0x9000 || (ic[1] & 0xd000) == 0x8000) && (ic[0] & 0x0380) != 0x0380);
+}
+
+static inline bool T$pcrel$bl(uint16_t *ic) {
+ return (ic[0] & 0xf800) == 0xf000 && ((ic[1] & 0xd000) == 0xd000 || (ic[1] & 0xd001) == 0xc000);
+}
+
+static inline bool T$pcrel$ldr(uint16_t ic) {
+ return (ic & 0xf800) == 0x4800;
+}
+
+static inline bool T$pcrel$add(uint16_t ic) {
+ return (ic & 0xff78) == 0x4478;
+}
+
+static inline bool T$pcrel$ldrw(uint16_t ic) {
+ return (ic & 0xff7f) == 0xf85f;
+}
+
+static size_t MSGetInstructionWidthThumb(void *start) {
+ uint16_t *thumb(reinterpret_cast(start));
+ return T$32bit$i(thumb[0]) ? 4 : 2;
+}
+
+static size_t MSGetInstructionWidthARM(void *start) {
+ return 4;
+}
+
+extern "C" size_t MSGetInstructionWidth(void *start) {
+ if ((reinterpret_cast(start) & 0x1) == 0)
+ return MSGetInstructionWidthARM(start);
+ else
+ return MSGetInstructionWidthThumb(reinterpret_cast(reinterpret_cast(start) & ~0x1));
+}
+
+static size_t SubstrateHookFunctionThumb(SubstrateProcessRef process, void *symbol, void *replace, void **result) {
+ if (symbol == NULL)
+ return 0;
+printf("SubstrateHookFunctionThumb\n");
+ uint16_t *area(reinterpret_cast(symbol));
+
+ unsigned align((reinterpret_cast(area) & 0x2) == 0 ? 0 : 1);
+ uint16_t *thumb(area + align);
+
+ uint32_t *arm(reinterpret_cast(thumb + 2));
+ uint16_t *trail(reinterpret_cast(arm + 2));
+
+ if (
+ (align == 0 || area[0] == T$nop) &&
+ thumb[0] == T$bx(A$pc) &&
+ thumb[1] == T$nop &&
+ arm[0] == A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8)
+ ) {
+ if (result != NULL)
+ *result = reinterpret_cast(arm[1]);
+
+ SubstrateHookMemory code(process, arm + 1, sizeof(uint32_t) * 1);
+
+ arm[1] = reinterpret_cast(replace);
+
+ return sizeof(arm[0]);
+ }
+
+ size_t required((trail - area) * sizeof(uint16_t));
+
+ size_t used(0);
+ while (used < required)
+ used += MSGetInstructionWidthThumb(reinterpret_cast(area) + used);
+ used = (used + sizeof(uint16_t) - 1) / sizeof(uint16_t) * sizeof(uint16_t);
+
+ size_t blank((used - required) / sizeof(uint16_t));
+
+ uint16_t backup[used / sizeof(uint16_t)];
+ memcpy(backup, area, used);
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", area);
+ MSLogHexEx(area, used + sizeof(uint16_t), 2, name);
+ }
+
+ if (result != NULL) {
+
+ size_t length(used);
+ for (unsigned offset(0); offset != used / sizeof(uint16_t); ++offset)
+ if (T$pcrel$ldr(backup[offset]))
+ length += 3 * sizeof(uint16_t);
+ else if (T$pcrel$b(backup[offset]))
+ length += 6 * sizeof(uint16_t);
+ else if (T2$pcrel$b(backup + offset)) {
+ length += 5 * sizeof(uint16_t);
+ ++offset;
+ } else if (T$pcrel$bl(backup + offset)) {
+ length += 5 * sizeof(uint16_t);
+ ++offset;
+ } else if (T$pcrel$cbz(backup[offset])) {
+ length += 16 * sizeof(uint16_t);
+ } else if (T$pcrel$ldrw(backup[offset])) {
+ length += 4 * sizeof(uint16_t);
+ ++offset;
+ } else if (T$pcrel$add(backup[offset]))
+ length += 6 * sizeof(uint16_t);
+ else if (T$32bit$i(backup[offset]))
+ ++offset;
+
+ unsigned pad((length & 0x2) == 0 ? 0 : 1);
+ length += (pad + 2) * sizeof(uint16_t) + 2 * sizeof(uint32_t);
+
+ uint16_t *buffer(reinterpret_cast(mmap(
+ NULL, length, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0
+ )));
+
+ if (buffer == MAP_FAILED) {
+ MSLog(MSLogLevelError, "MS:Error:mmap() = %d", errno);
+ *result = NULL;
+ return 0;
+ }
+
+ if (false) fail: {
+ munmap(buffer, length);
+ *result = NULL;
+ return 0;
+ }
+
+ size_t start(pad), end(length / sizeof(uint16_t));
+ uint32_t *trailer(reinterpret_cast(buffer + end));
+ for (unsigned offset(0); offset != used / sizeof(uint16_t); ++offset) {
+ if (T$pcrel$ldr(backup[offset])) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t immediate : 8;
+ uint16_t rd : 3;
+ uint16_t : 5;
+ };
+ } bits = {backup[offset+0]};
+
+ buffer[start+0] = T$ldr_rd_$pc_im_4$(bits.rd, T$Label(start+0, end-2) / 4);
+ buffer[start+1] = T$ldr_rd_$rn_im_4$(bits.rd, bits.rd, 0);
+
+ // XXX: this code "works", but is "wrong": the mechanism is more complex than this
+ *--trailer = ((reinterpret_cast(area + offset) + 4) & ~0x2) + bits.immediate * 4;
+
+ start += 2;
+ end -= 2;
+ } else if (T$pcrel$b(backup[offset])) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t imm8 : 8;
+ uint16_t cond : 4;
+ uint16_t /*1101*/ : 4;
+ };
+ } bits = {backup[offset+0]};
+
+ intptr_t jump(bits.imm8 << 1);
+ jump |= 1;
+ jump <<= 23;
+ jump >>= 23;
+
+ buffer[start+0] = T$b$_$im(bits.cond, (end-6 - (start+0)) * 2 - 4);
+
+ *--trailer = reinterpret_cast(area + offset) + 4 + jump;
+ *--trailer = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ *--trailer = T$nop << 16 | T$bx(A$pc);
+
+ start += 1;
+ end -= 6;
+ } else if (T2$pcrel$b(backup + offset)) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t imm6 : 6;
+ uint16_t cond : 4;
+ uint16_t s : 1;
+ uint16_t : 5;
+ };
+ } bits = {backup[offset+0]};
+
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t imm11 : 11;
+ uint16_t j2 : 1;
+ uint16_t a : 1;
+ uint16_t j1 : 1;
+ uint16_t : 2;
+ };
+ } exts = {backup[offset+1]};
+
+ intptr_t jump(1);
+ jump |= exts.imm11 << 1;
+ jump |= bits.imm6 << 12;
+
+ if (exts.a) {
+ jump |= bits.s << 24;
+ jump |= (~(bits.s ^ exts.j1) & 0x1) << 23;
+ jump |= (~(bits.s ^ exts.j2) & 0x1) << 22;
+ jump |= bits.cond << 18;
+ jump <<= 7;
+ jump >>= 7;
+ } else {
+ jump |= bits.s << 20;
+ jump |= exts.j2 << 19;
+ jump |= exts.j1 << 18;
+ jump <<= 11;
+ jump >>= 11;
+ }
+
+ buffer[start+0] = T$b$_$im(exts.a ? A$al : bits.cond, (end-6 - (start+0)) * 2 - 4);
+
+ *--trailer = reinterpret_cast(area + offset) + 4 + jump;
+ *--trailer = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ *--trailer = T$nop << 16 | T$bx(A$pc);
+
+ ++offset;
+ start += 1;
+ end -= 6;
+ } else if (T$pcrel$bl(backup + offset)) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t immediate : 10;
+ uint16_t s : 1;
+ uint16_t : 5;
+ };
+ } bits = {backup[offset+0]};
+
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t immediate : 11;
+ uint16_t j2 : 1;
+ uint16_t x : 1;
+ uint16_t j1 : 1;
+ uint16_t : 2;
+ };
+ } exts = {backup[offset+1]};
+
+ int32_t jump(0);
+ jump |= bits.s << 24;
+ jump |= (~(bits.s ^ exts.j1) & 0x1) << 23;
+ jump |= (~(bits.s ^ exts.j2) & 0x1) << 22;
+ jump |= bits.immediate << 12;
+ jump |= exts.immediate << 1;
+ jump |= exts.x;
+ jump <<= 7;
+ jump >>= 7;
+
+ buffer[start+0] = T$push_r(1 << A$r7);
+ buffer[start+1] = T$ldr_rd_$pc_im_4$(A$r7, ((end-2 - (start+1)) * 2 - 4 + 2) / 4);
+ buffer[start+2] = T$mov_rd_rm(A$lr, A$r7);
+ buffer[start+3] = T$pop_r(1 << A$r7);
+ buffer[start+4] = T$blx(A$lr);
+
+ *--trailer = reinterpret_cast(area + offset) + 4 + jump;
+
+ ++offset;
+ start += 5;
+ end -= 2;
+ } else if (T$pcrel$cbz(backup[offset])) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t rn : 3;
+ uint16_t immediate : 5;
+ uint16_t : 1;
+ uint16_t i : 1;
+ uint16_t : 1;
+ uint16_t op : 1;
+ uint16_t : 4;
+ };
+ } bits = {backup[offset+0]};
+
+ intptr_t jump(1);
+ jump |= bits.i << 6;
+ jump |= bits.immediate << 1;
+
+ //jump <<= 24;
+ //jump >>= 24;
+
+ unsigned rn(bits.rn);
+ unsigned rt(rn == A$r7 ? A$r6 : A$r7);
+
+ buffer[start+0] = T$push_r(1 << rt);
+ buffer[start+1] = T1$mrs_rd_apsr(rt);
+ buffer[start+2] = T2$mrs_rd_apsr(rt);
+ buffer[start+3] = T$cbz$_rn_$im(bits.op, rn, (end-10 - (start+3)) * 2 - 4);
+ buffer[start+4] = T1$msr_apsr_nzcvqg_rn(rt);
+ buffer[start+5] = T2$msr_apsr_nzcvqg_rn(rt);
+ buffer[start+6] = T$pop_r(1 << rt);
+
+ *--trailer = reinterpret_cast(area + offset) + 4 + jump;
+ *--trailer = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ *--trailer = T$nop << 16 | T$bx(A$pc);
+ *--trailer = T$nop << 16 | T$pop_r(1 << rt);
+ *--trailer = T$msr_apsr_nzcvqg_rn(rt);
+
+#if 0
+ if ((start & 0x1) == 0)
+ buffer[start++] = T$nop;
+ buffer[start++] = T$bx(A$pc);
+ buffer[start++] = T$nop;
+
+ uint32_t *arm(reinterpret_cast(buffer + start));
+ arm[0] = A$add(A$lr, A$pc, 1);
+ arm[1] = A$ldr_rd_$rn_im$(A$pc, A$pc, (trailer - arm) * sizeof(uint32_t) - 8);
+#endif
+
+ start += 7;
+ end -= 10;
+ } else if (T$pcrel$ldrw(backup[offset])) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t : 7;
+ uint16_t u : 1;
+ uint16_t : 8;
+ };
+ } bits = {backup[offset+0]};
+
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t immediate : 12;
+ uint16_t rt : 4;
+ };
+ } exts = {backup[offset+1]};
+
+ buffer[start+0] = T1$ldr_rt_$rn_im$(exts.rt, A$pc, T$Label(start+0, end-2));
+ buffer[start+1] = T2$ldr_rt_$rn_im$(exts.rt, A$pc, T$Label(start+0, end-2));
+
+ buffer[start+2] = T1$ldr_rt_$rn_im$(exts.rt, exts.rt, 0);
+ buffer[start+3] = T2$ldr_rt_$rn_im$(exts.rt, exts.rt, 0);
+
+ // XXX: this code "works", but is "wrong": the mechanism is more complex than this
+ *--trailer = ((reinterpret_cast(area + offset) + 4) & ~0x2) + (bits.u == 0 ? -exts.immediate : exts.immediate);
+
+ ++offset;
+ start += 4;
+ end -= 2;
+ } else if (T$pcrel$add(backup[offset])) {
+ union {
+ uint16_t value;
+
+ struct {
+ uint16_t rd : 3;
+ uint16_t rm : 3;
+ uint16_t h2 : 1;
+ uint16_t h1 : 1;
+ uint16_t : 8;
+ };
+ } bits = {backup[offset+0]};
+
+ if (bits.h1) {
+ MSLog(MSLogLevelError, "MS:Error:pcrel(%u):add (rd > r7)", offset);
+ goto fail;
+ }
+
+ unsigned rt(bits.rd == A$r7 ? A$r6 : A$r7);
+
+ buffer[start+0] = T$push_r(1 << rt);
+ buffer[start+1] = T$mov_rd_rm(rt, (bits.h1 << 3) | bits.rd);
+ buffer[start+2] = T$ldr_rd_$pc_im_4$(bits.rd, T$Label(start+2, end-2) / 4);
+ buffer[start+3] = T$add_rd_rm((bits.h1 << 3) | bits.rd, rt);
+ buffer[start+4] = T$pop_r(1 << rt);
+ *--trailer = reinterpret_cast(area + offset) + 4;
+
+ start += 5;
+ end -= 2;
+ } else if (T$32bit$i(backup[offset])) {
+ buffer[start++] = backup[offset];
+ buffer[start++] = backup[++offset];
+ } else {
+ buffer[start++] = backup[offset];
+ }
+ }
+
+ buffer[start++] = T$bx(A$pc);
+ buffer[start++] = T$nop;
+
+ uint32_t *transfer = reinterpret_cast(buffer + start);
+ transfer[0] = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ transfer[1] = reinterpret_cast(area + used / sizeof(uint16_t)) + 1;
+
+ if (mprotect(buffer, length, PROT_READ | PROT_EXEC) == -1) {
+ MSLog(MSLogLevelError, "MS:Error:mprotect():%d", errno);
+ return 0;
+ }
+
+ *result = reinterpret_cast(buffer + pad) + 1;
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", *result);
+ MSLogHexEx(buffer, length, 2, name);
+ }
+
+ }
+
+ {
+ SubstrateHookMemory code(process, area, used);
+
+ if (align != 0)
+ area[0] = T$nop;
+
+ thumb[0] = T$bx(A$pc);
+ thumb[1] = T$nop;
+
+ arm[0] = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ arm[1] = reinterpret_cast(replace);
+
+ for (unsigned offset(0); offset != blank; ++offset)
+ trail[offset] = T$nop;
+ }
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", area);
+ MSLogHexEx(area, used + sizeof(uint16_t), 2, name);
+ }
+
+ return used;
+}
+
+static size_t SubstrateHookFunctionARM(SubstrateProcessRef process, void *symbol, void *replace, void **result) {
+ if (symbol == NULL)
+ return 0;
+printf("SubstrateHookFunctionARM\n");
+ uint32_t *area(reinterpret_cast(symbol));
+ uint32_t *arm(area);
+
+ const size_t used(8);
+
+ uint32_t backup[used / sizeof(uint32_t)] = {arm[0], arm[1]};
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", area);
+ MSLogHexEx(area, used + sizeof(uint32_t), 4, name);
+ }
+
+ if (result != NULL) {
+
+ if (backup[0] == A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8)) {
+ *result = reinterpret_cast(backup[1]);
+
+ return sizeof(backup[0]);
+ }
+
+ size_t length(used);
+ for (unsigned offset(0); offset != used / sizeof(uint32_t); ++offset)
+ if (A$pcrel$r(backup[offset])) {
+ if ((backup[offset] & 0x02000000) == 0 || (backup[offset] & 0x0000f000 >> 12) != (backup[offset] & 0x0000000f))
+ length += 2 * sizeof(uint32_t);
+ else
+ length += 4 * sizeof(uint32_t);
+ }
+
+ length += 2 * sizeof(uint32_t);
+
+ uint32_t *buffer(reinterpret_cast(mmap(
+ NULL, length, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0
+ )));
+
+ if (buffer == MAP_FAILED) {
+ MSLog(MSLogLevelError, "MS:Error:mmap() = %d", errno);
+ *result = NULL;
+ return 0;
+ }
+
+ if (false) fail: {
+ munmap(buffer, length);
+ *result = NULL;
+ return 0;
+ }
+
+ size_t start(0), end(length / sizeof(uint32_t));
+ uint32_t *trailer(reinterpret_cast(buffer + end));
+ for (unsigned offset(0); offset != used / sizeof(uint32_t); ++offset)
+ if (A$pcrel$r(backup[offset])) {
+ union {
+ uint32_t value;
+
+ struct {
+ uint32_t rm : 4;
+ uint32_t : 1;
+ uint32_t shift : 2;
+ uint32_t shiftamount : 5;
+ uint32_t rd : 4;
+ uint32_t rn : 4;
+ uint32_t l : 1;
+ uint32_t w : 1;
+ uint32_t b : 1;
+ uint32_t u : 1;
+ uint32_t p : 1;
+ uint32_t mode : 1;
+ uint32_t type : 2;
+ uint32_t cond : 4;
+ };
+ } bits = {backup[offset+0]}, copy(bits);
+
+ bool guard;
+ if (bits.mode == 0 || bits.rd != bits.rm) {
+ copy.rn = bits.rd;
+ guard = false;
+ } else {
+ copy.rn = bits.rm != A$r0 ? A$r0 : A$r1;
+ guard = true;
+ }
+
+ if (guard)
+ buffer[start++] = A$stmdb_sp$_$rs$((1 << copy.rn));
+
+ buffer[start+0] = A$ldr_rd_$rn_im$(copy.rn, A$pc, (end-1 - (start+0)) * 4 - 8);
+ buffer[start+1] = copy.value;
+
+ start += 2;
+
+ if (guard)
+ buffer[start++] = A$ldmia_sp$_$rs$((1 << copy.rn));
+
+ *--trailer = reinterpret_cast(area + offset) + 8;
+ end -= 1;
+ } else
+ buffer[start++] = backup[offset];
+
+ buffer[start+0] = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ buffer[start+1] = reinterpret_cast(area + used / sizeof(uint32_t));
+
+ if (mprotect(buffer, length, PROT_READ | PROT_EXEC) == -1) {
+ MSLog(MSLogLevelError, "MS:Error:mprotect():%d", errno);
+ goto fail;
+ }
+
+ *result = buffer;
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", *result);
+ MSLogHexEx(buffer, length, 4, name);
+ }
+
+ }
+
+ {
+ SubstrateHookMemory code(process, symbol, used);
+
+ arm[0] = A$ldr_rd_$rn_im$(A$pc, A$pc, 4 - 8);
+ arm[1] = reinterpret_cast(replace);
+ }
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, "%p", area);
+ MSLogHexEx(area, used + sizeof(uint32_t), 4, name);
+ }
+
+ return used;
+}
+
+static size_t SubstrateHookFunction(SubstrateProcessRef process, void *symbol, void *replace, void **result) {
+ if (MSDebug)
+ MSLog(MSLogLevelNotice, "SubstrateHookFunction(%p, %p, %p, %p)\n", process, symbol, replace, result);
+ if ((reinterpret_cast(symbol) & 0x1) == 0)
+ return SubstrateHookFunctionARM(process, symbol, replace, result);
+ else
+ return SubstrateHookFunctionThumb(process, reinterpret_cast(reinterpret_cast(symbol) & ~0x1), replace, result);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+
+#include "SubstrateX86.hpp"
+
+static size_t MSGetInstructionWidthIntel(void *start) {
+ hde64s decode;
+ return hde64_disasm(start, &decode);
+}
+
+static void SubstrateHookFunction(SubstrateProcessRef process, void *symbol, void *replace, void **result) {
+ //if (MSDebug)
+ //MSLog(MSLogLevelNotice, "MSHookFunction(%p, %p, %p)\n", symbol, replace, result);
+ if (symbol == NULL)
+ return;
+
+ uintptr_t source(reinterpret_cast(symbol));
+ uintptr_t target(reinterpret_cast(replace));
+
+ uint8_t *area(reinterpret_cast(symbol));
+
+ size_t required(MSSizeOfJump(target, source));
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, OBFUSCATE("%p"), area);
+ MSLogHex(area, 32, name);
+ }
+
+ size_t used(0);
+ while (used < required) {
+ size_t width(MSGetInstructionWidthIntel(area + used));
+ if (width == 0) {
+ //MSLog(MSLogLevelError, "MS:Error:MSGetInstructionWidthIntel(%p) == 0", area + used);
+ return;
+ }
+
+ used += width;
+ }
+
+ size_t blank(used - required);
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, OBFUSCATE("%p"), area);
+ MSLogHex(area, used + sizeof(uint16_t), name);
+ }
+
+ uint8_t backup[used];
+ memcpy(backup, area, used);
+
+ if (result != NULL) {
+
+ if (backup[0] == 0xe9) {
+ *result = reinterpret_cast(source + 5 + *reinterpret_cast(backup + 1));
+ return;
+ }
+
+ if (!ia32 && backup[0] == 0xff && backup[1] == 0x25) {
+ *result = *reinterpret_cast(source + 6 + *reinterpret_cast(backup + 2));
+ return;
+ }
+
+ size_t length(used + MSSizeOfJump(source + used));
+
+ for (size_t offset(0), width; offset != used; offset += width) {
+ hde64s decode;
+ hde64_disasm(backup + offset, &decode);
+ width = decode.len;
+ //_assert(width != 0 && offset + width <= used);
+
+#ifdef __LP64__
+ if ((decode.modrm & 0xc7) == 0x05) {
+ if (decode.opcode == 0x8b) {
+ void *destiny(area + offset + width + int32_t(decode.disp.disp32));
+ uint8_t reg(decode.rex_r << 3 | decode.modrm_reg);
+ length -= decode.len;
+ length += MSSizeOfPushPointer(destiny);
+ length += MSSizeOfPop(reg);
+ length += MSSizeOfMove64();
+ } else {
+ MSLog(MSLogLevelError, "MS:Error: Unknown RIP-Relative (%.2x %.2x)", decode.opcode, decode.opcode2);
+ continue;
+ }
+ } else
+#endif
+
+ if (backup[offset] == 0xe8) {
+ int32_t relative(*reinterpret_cast(backup + offset + 1));
+ void *destiny(area + offset + decode.len + relative);
+
+ if (relative == 0) {
+ length -= decode.len;
+ length += MSSizeOfPushPointer(destiny);
+ } else {
+ length += MSSizeOfSkip();
+ length += MSSizeOfJump(destiny);
+ }
+ } else if (backup[offset] == 0xeb) {
+ length -= decode.len;
+ length += MSSizeOfJump(area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ } else if (backup[offset] == 0xe9) {
+ length -= decode.len;
+ length += MSSizeOfJump(area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ } else if (
+ backup[offset] == 0xe3 ||
+ (backup[offset] & 0xf0) == 0x70
+ // XXX: opcode2 & 0xf0 is 0x80?
+ ) {
+ length += decode.len;
+ length += MSSizeOfJump(area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ }
+ }
+
+ uint8_t *buffer(reinterpret_cast(mmap(
+ NULL, length, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0
+ )));
+
+ if (buffer == MAP_FAILED) {
+ MSLog(MSLogLevelError, OBFUSCATE("MS:Error:mmap() = %d"), errno);
+ *result = NULL;
+ return;
+ }
+
+ if (false) fail: {
+ munmap(buffer, length);
+ *result = NULL;
+ return;
+ }
+
+ {
+ uint8_t *current(buffer);
+
+ for (size_t offset(0), width; offset != used; offset += width) {
+ hde64s decode;
+ hde64_disasm(backup + offset, &decode);
+ width = decode.len;
+ //_assert(width != 0 && offset + width <= used);
+
+#ifdef __LP64__
+ if ((decode.modrm & 0xc7) == 0x05) {
+ if (decode.opcode == 0x8b) {
+ void *destiny(area + offset + width + int32_t(decode.disp.disp32));
+ uint8_t reg(decode.rex_r << 3 | decode.modrm_reg);
+ MSPushPointer(current, destiny);
+ MSWritePop(current, reg);
+ MSWriteMove64(current, reg, reg);
+ } else {
+ MSLog(MSLogLevelError, "MS:Error: Unknown RIP-Relative (%.2x %.2x)", decode.opcode, decode.opcode2);
+ goto copy;
+ }
+ } else
+#endif
+
+ if (backup[offset] == 0xe8) {
+ int32_t relative(*reinterpret_cast(backup + offset + 1));
+ if (relative == 0)
+ MSPushPointer(current, area + offset + decode.len);
+ else {
+ MSWrite(current, 0xe8);
+ MSWrite(current, MSSizeOfSkip());
+ void *destiny(area + offset + decode.len + relative);
+ MSWriteSkip(current, MSSizeOfJump(destiny, current + MSSizeOfSkip()));
+ MSWriteJump(current, destiny);
+ }
+ } else if (backup[offset] == 0xeb)
+ MSWriteJump(current, area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ else if (backup[offset] == 0xe9)
+ MSWriteJump(current, area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ else if (
+ backup[offset] == 0xe3 ||
+ (backup[offset] & 0xf0) == 0x70
+ ) {
+ MSWrite(current, backup[offset]);
+ MSWrite(current, 2);
+ MSWrite(current, 0xeb);
+ void *destiny(area + offset + decode.len + *reinterpret_cast(backup + offset + 1));
+ MSWrite(current, MSSizeOfJump(destiny, current + 1));
+ MSWriteJump(current, destiny);
+ } else
+#ifdef __LP64__
+ copy:
+#endif
+ {
+ MSWrite(current, backup + offset, width);
+ }
+ }
+
+ MSWriteJump(current, area + used);
+ }
+
+ if (mprotect(buffer, length, PROT_READ | PROT_EXEC) == -1) {
+ MSLog(MSLogLevelError, OBFUSCATE("MS:Error:mprotect():%d"), errno);
+ goto fail;
+ }
+
+ *result = buffer;
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, OBFUSCATE("%p"), *result);
+ MSLogHex(buffer, length, name);
+ }
+
+ }
+
+ {
+ SubstrateHookMemory code(process, area, used);
+
+ uint8_t *current(area);
+ MSWriteJump(current, target);
+ for (unsigned offset(0); offset != blank; ++offset)
+ MSWrite(current, 0x90);
+ }
+
+ if (MSDebug) {
+ char name[16];
+ sprintf(name, OBFUSCATE("%p"), area);
+ MSLogHex(area, used + sizeof(uint16_t), name);
+ }
+}
+#endif
+
+_extern void MSHookFunction(void *symbol, void *replace, void **result) {
+#if defined(__i386__) || defined(__arm__)
+ SubstrateHookFunction(NULL, symbol, replace, result);
+#endif
+}
+
+
+#if defined(__APPLE__) && defined(__arm__)
+_extern void _Z14MSHookFunctionPvS_PS_(void *symbol, void *replace, void **result) {
+ return MSHookFunction(symbol, replace, result);
+}
+#endif
diff --git a/app/src/main/jni/src/Substrate/SubstrateHook.h b/app/src/main/jni/src/Substrate/SubstrateHook.h
new file mode 100644
index 0000000..40a0296
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateHook.h
@@ -0,0 +1,19 @@
+#ifndef __SUBSTRATEHOOK_H__
+#define __SUBSTRATEHOOK_H__
+
+
+#include
+
+#define _extern extern "C" __attribute__((__visibility__("default")))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void MSHookFunction(void *symbol, void *replace, void **result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/app/src/main/jni/src/Substrate/SubstrateLog.hpp b/app/src/main/jni/src/Substrate/SubstrateLog.hpp
new file mode 100644
index 0000000..3e57280
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateLog.hpp
@@ -0,0 +1,40 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#ifndef SUBSTRATE_LOG_HPP
+#define SUBSTRATE_LOG_HPP
+
+#if 0
+#include
+
+#define MSLog(level, format, ...) ((void)__android_log_print(level, "NNNN", format, __VA_ARGS__))
+
+#define MSLogLevelNotice ANDROID_LOG_INFO
+#define MSLogLevelWarning ANDROID_LOG_WARN
+#define MSLogLevelError ANDROID_LOG_ERROR
+
+#else
+
+#define MSLog(level, format, ...) printf(format, __VA_ARGS__)
+
+#endif
+
+#endif//SUBSTRATE_LOG_HPP
diff --git a/app/src/main/jni/src/Substrate/SubstratePosixMemory.cpp b/app/src/main/jni/src/Substrate/SubstratePosixMemory.cpp
new file mode 100644
index 0000000..c7e8ff1
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstratePosixMemory.cpp
@@ -0,0 +1,76 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see .
+**/
+/* }}} */
+
+#define SubstrateInternal
+#include "CydiaSubstrate.h"
+#include "SubstrateLog.hpp"
+
+#include
+
+#include
+#include
+#include
+#include
+
+extern "C" void __clear_cache (void *beg, void *end);
+
+struct __SubstrateMemory {
+ void *address_;
+ size_t width_;
+
+ __SubstrateMemory(void *address, size_t width) :
+ address_(address),
+ width_(width)
+ {
+ }
+};
+
+extern "C" SubstrateMemoryRef SubstrateMemoryCreate(SubstrateAllocatorRef allocator, SubstrateProcessRef process, void *data, size_t size) {
+ if (allocator != NULL) {
+ MSLog(MSLogLevelError, OBFUSCATE("MS:Error:allocator != %d"), 0);
+ return NULL;
+ }
+
+ if (size == 0)
+ return NULL;
+
+ int page(getpagesize());
+
+ uintptr_t base(reinterpret_cast(data) / page * page);
+ size_t width(((reinterpret_cast(data) + size - 1) / page + 1) * page - base);
+ void *address(reinterpret_cast(base));
+
+ if (mprotect(address, width, PROT_READ | PROT_WRITE | PROT_EXEC) == -1) {
+ MSLog(MSLogLevelError, OBFUSCATE("MS:Error:mprotect() = %d"), errno);
+ return NULL;
+ }
+
+ return new __SubstrateMemory(address, width);
+}
+
+extern "C" void SubstrateMemoryRelease(SubstrateMemoryRef memory) {
+ if (mprotect(memory->address_, memory->width_, PROT_READ | PROT_WRITE | PROT_EXEC) == -1)
+ MSLog(MSLogLevelError, "MS:Error:mprotect() = %d", errno);
+
+ __clear_cache(reinterpret_cast(memory->address_), reinterpret_cast(memory->address_) + memory->width_);
+
+ delete memory;
+}
diff --git a/app/src/main/jni/src/Substrate/SubstrateX86.hpp b/app/src/main/jni/src/Substrate/SubstrateX86.hpp
new file mode 100644
index 0000000..ffe2b06
--- /dev/null
+++ b/app/src/main/jni/src/Substrate/SubstrateX86.hpp
@@ -0,0 +1,200 @@
+/* Cydia Substrate - Powerful Code Insertion Platform
+ * Copyright (C) 2008-2011 Jay Freeman (saurik)
+*/
+
+/* GNU Lesser General Public License, Version 3 {{{ */
+/*
+ * Substrate is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Substrate is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Substrate. If not, see