ReVanced/revanced-patcher
1
0
Fork 0
mirror of https://github.com/revanced/revanced-patcher.git synced 2025-04-30 05:14:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: Merge branch dev to main

Browse Source
This commit is contained in:
oSumAtrIX 2024-11-05 19:16:28 +01:00
commit 0581dcf931
No known key found for this signature in database
GPG Key ID: A9B3094ACDB604B4
21 changed files with 724 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
CHANGELOG.md
View File

@ -1,3 +1,43 @@
# [21.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.3...v21.0.0-dev.4) (2024-11-05)
### Performance Improvements
* Use smallest lookup map for strings ([1358d3f](https://github.com/ReVanced/revanced-patcher/commit/1358d3fa10cb8ba011b6b89cfe3684ecf9849d2f))
# [21.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.2...v21.0.0-dev.3) (2024-11-05)
### Features
* Move fingerprint match members to fingerprint for ease of access by using context receivers ([0746c22](https://github.com/ReVanced/revanced-patcher/commit/0746c22743a9561bae2284d234b151f2f8511ca5))
# [21.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.1...v21.0.0-dev.2) (2024-11-01)
### Bug Fixes
* Match fingerprint before delegating the match property ([5d996de](https://github.com/ReVanced/revanced-patcher/commit/5d996def4d3de4e2bfc34562e5a6c7d89a8cddf0))
# [21.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.2...v21.0.0-dev.1) (2024-10-27)
### Bug Fixes
* Merge extension only when patch executes ([#315](https://github.com/ReVanced/revanced-patcher/issues/315)) ([aa472eb](https://github.com/ReVanced/revanced-patcher/commit/aa472eb9857145b53b49f843406a9764fbb7e5ce))
### Features
* Improve Fingerprint API ([#316](https://github.com/ReVanced/revanced-patcher/issues/316)) ([0abf1c6](https://github.com/ReVanced/revanced-patcher/commit/0abf1c6c0279708fdef5cb66b141d07d17682693))
* Improve various APIs ([#317](https://github.com/ReVanced/revanced-patcher/issues/317)) ([b824978](https://github.com/ReVanced/revanced-patcher/commit/b8249789df8b90129f7b7ad0e523a8d0ceaab848))
### BREAKING CHANGES
* Various APIs have been changed.
* Many APIs have been changed.
## [20.0.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2) (2024-10-17) ## [20.0.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2) (2024-10-17)

89
api/revanced-patcher.api
View File

@ -1,7 +1,22 @@
public final class app/revanced/patcher/Fingerprint { public final class app/revanced/patcher/Fingerprint {
public final fun getMatch ()Lapp/revanced/patcher/Match; public final fun getClassDef (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
public final fun match (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z public final fun getClassDefOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
public final fun match (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/Method;)Z public final fun getMethod (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun getMethodOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun getOriginalClassDef (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lcom/android/tools/smali/dexlib2/iface/ClassDef;
public final fun getOriginalClassDefOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lcom/android/tools/smali/dexlib2/iface/ClassDef;
public final fun getOriginalMethod (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lcom/android/tools/smali/dexlib2/iface/Method;
public final fun getOriginalMethodOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lcom/android/tools/smali/dexlib2/iface/Method;
public final fun getPatternMatch (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/Match$PatternMatch;
public final fun getPatternMatchOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Lapp/revanced/patcher/Match$PatternMatch;
public final fun getStringMatches (Lapp/revanced/patcher/patch/BytecodePatchContext;)Ljava/util/List;
public final fun getStringMatchesOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;)Ljava/util/List;
public final fun match (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/Match;
public final fun match (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/Method;)Lapp/revanced/patcher/Match;
public final fun match (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/Match;
public final fun matchOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/Match;
public final fun matchOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/Method;)Lapp/revanced/patcher/Match;
public final fun matchOrNull (Lapp/revanced/patcher/patch/BytecodePatchContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/Match;
} }
public final class app/revanced/patcher/FingerprintBuilder { public final class app/revanced/patcher/FingerprintBuilder {
@ -18,32 +33,27 @@ public final class app/revanced/patcher/FingerprintBuilder {
public final class app/revanced/patcher/FingerprintKt { public final class app/revanced/patcher/FingerprintKt {
public static final fun fingerprint (ILkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/Fingerprint; public static final fun fingerprint (ILkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/Fingerprint;
public static final fun fingerprint (Lapp/revanced/patcher/patch/BytecodePatchBuilder;ILkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/BytecodePatchBuilder$InvokedFingerprint;
public static synthetic fun fingerprint$default (ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/Fingerprint; public static synthetic fun fingerprint$default (ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/Fingerprint;
public static synthetic fun fingerprint$default (Lapp/revanced/patcher/patch/BytecodePatchBuilder;ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/BytecodePatchBuilder$InvokedFingerprint;
} }
public abstract interface annotation class app/revanced/patcher/InternalApi : java/lang/annotation/Annotation { public abstract interface annotation class app/revanced/patcher/InternalApi : java/lang/annotation/Annotation {
} }
public final class app/revanced/patcher/Match { public final class app/revanced/patcher/Match {
public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/Match$PatternMatch;Ljava/util/List;Lapp/revanced/patcher/patch/BytecodePatchContext;)V public final fun getClassDef ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
public final fun getClassDef ()Lcom/android/tools/smali/dexlib2/iface/ClassDef; public final fun getMethod ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun getMethod ()Lcom/android/tools/smali/dexlib2/iface/Method; public final fun getOriginalClassDef ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
public final fun getMutableClass ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass; public final fun getOriginalMethod ()Lcom/android/tools/smali/dexlib2/iface/Method;
public final fun getMutableMethod ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun getPatternMatch ()Lapp/revanced/patcher/Match$PatternMatch; public final fun getPatternMatch ()Lapp/revanced/patcher/Match$PatternMatch;
public final fun getStringMatches ()Ljava/util/List; public final fun getStringMatches ()Ljava/util/List;
} }
public final class app/revanced/patcher/Match$PatternMatch { public final class app/revanced/patcher/Match$PatternMatch {
public fun <init> (II)V
public final fun getEndIndex ()I public final fun getEndIndex ()I
public final fun getStartIndex ()I public final fun getStartIndex ()I
} }
public final class app/revanced/patcher/Match$StringMatch { public final class app/revanced/patcher/Match$StringMatch {
public fun <init> (Ljava/lang/String;I)V
public final fun getIndex ()I public final fun getIndex ()I
public final fun getString ()Ljava/lang/String; public final fun getString ()Ljava/lang/String;
} }
@ -63,8 +73,8 @@ public final class app/revanced/patcher/Patcher : java/io/Closeable {
} }
public final class app/revanced/patcher/PatcherConfig { public final class app/revanced/patcher/PatcherConfig {
public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)V public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;)V
public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILkotlin/jvm/internal/DefaultConstructorMarker;)V public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
} }
public final class app/revanced/patcher/PatcherContext : java/io/Closeable { public final class app/revanced/patcher/PatcherContext : java/io/Closeable {
@ -135,31 +145,24 @@ public final class app/revanced/patcher/extensions/InstructionExtensions {
} }
public final class app/revanced/patcher/patch/BytecodePatch : app/revanced/patcher/patch/Patch { public final class app/revanced/patcher/patch/BytecodePatch : app/revanced/patcher/patch/Patch {
public final fun getExtension ()Ljava/io/InputStream; public final fun getExtensionInputStream ()Ljava/util/function/Supplier;
public final fun getFingerprints ()Ljava/util/Set;
public fun toString ()Ljava/lang/String; public fun toString ()Ljava/lang/String;
} }
public final class app/revanced/patcher/patch/BytecodePatchBuilder : app/revanced/patcher/patch/PatchBuilder { public final class app/revanced/patcher/patch/BytecodePatchBuilder : app/revanced/patcher/patch/PatchBuilder {
public synthetic fun build$revanced_patcher ()Lapp/revanced/patcher/patch/Patch; public synthetic fun build$revanced_patcher ()Lapp/revanced/patcher/patch/Patch;
public final fun extendWith (Ljava/lang/String;)Lapp/revanced/patcher/patch/BytecodePatchBuilder; public final fun extendWith (Ljava/lang/String;)Lapp/revanced/patcher/patch/BytecodePatchBuilder;
public final fun getExtension ()Ljava/io/InputStream; public final fun getExtensionInputStream ()Ljava/util/function/Supplier;
public final fun invoke (Lapp/revanced/patcher/Fingerprint;)Lapp/revanced/patcher/patch/BytecodePatchBuilder$InvokedFingerprint; public final fun setExtensionInputStream (Ljava/util/function/Supplier;)V
public final fun setExtension (Ljava/io/InputStream;)V
}
public final class app/revanced/patcher/patch/BytecodePatchBuilder$InvokedFingerprint {
public final fun getValue (Ljava/lang/Void;Lkotlin/reflect/KProperty;)Lapp/revanced/patcher/Match;
} }
public final class app/revanced/patcher/patch/BytecodePatchContext : app/revanced/patcher/patch/PatchContext, java/io/Closeable { public final class app/revanced/patcher/patch/BytecodePatchContext : app/revanced/patcher/patch/PatchContext, java/io/Closeable {
public final fun classBy (Lkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/util/proxy/ClassProxy; public final fun classBy (Lkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/util/proxy/ClassProxy;
public final fun classByType (Ljava/lang/String;)Lapp/revanced/patcher/util/proxy/ClassProxy;
public fun close ()V public fun close ()V
public synthetic fun get ()Ljava/lang/Object; public synthetic fun get ()Ljava/lang/Object;
public fun get ()Ljava/util/Set; public fun get ()Ljava/util/Set;
public final fun getClasses ()Lapp/revanced/patcher/util/ProxyClassList; public final fun getClasses ()Lapp/revanced/patcher/util/ProxyClassList;
public final fun navigate (Lcom/android/tools/smali/dexlib2/iface/Method;)Lapp/revanced/patcher/util/MethodNavigator; public final fun navigate (Lcom/android/tools/smali/dexlib2/iface/reference/MethodReference;)Lapp/revanced/patcher/util/MethodNavigator;
public final fun proxy (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/util/proxy/ClassProxy; public final fun proxy (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/util/proxy/ClassProxy;
} }
@ -286,7 +289,7 @@ public final class app/revanced/patcher/patch/Options : java/util/Map, kotlin/jv
} }
public abstract class app/revanced/patcher/patch/Patch { public abstract class app/revanced/patcher/patch/Patch {
public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;ZLjava/util/Set;Ljava/util/Set;Ljava/util/Set;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/internal/DefaultConstructorMarker;)V public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;ZLjava/util/Set;Ljava/util/Set;Ljava/util/Set;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
public final fun execute (Lapp/revanced/patcher/patch/PatchContext;)V public final fun execute (Lapp/revanced/patcher/patch/PatchContext;)V
public final fun finalize (Lapp/revanced/patcher/patch/PatchContext;)V public final fun finalize (Lapp/revanced/patcher/patch/PatchContext;)V
public final fun getCompatiblePackages ()Ljava/util/Set; public final fun getCompatiblePackages ()Ljava/util/Set;
@ -303,13 +306,13 @@ public abstract class app/revanced/patcher/patch/PatchBuilder {
public final fun compatibleWith ([Ljava/lang/String;)V public final fun compatibleWith ([Ljava/lang/String;)V
public final fun compatibleWith ([Lkotlin/Pair;)V public final fun compatibleWith ([Lkotlin/Pair;)V
public final fun dependsOn ([Lapp/revanced/patcher/patch/Patch;)V public final fun dependsOn ([Lapp/revanced/patcher/patch/Patch;)V
public final fun execute (Lkotlin/jvm/functions/Function2;)V public final fun execute (Lkotlin/jvm/functions/Function1;)V
public final fun finalize (Lkotlin/jvm/functions/Function2;)V public final fun finalize (Lkotlin/jvm/functions/Function1;)V
protected final fun getCompatiblePackages ()Ljava/util/Set; protected final fun getCompatiblePackages ()Ljava/util/Set;
protected final fun getDependencies ()Ljava/util/Set; protected final fun getDependencies ()Ljava/util/Set;
protected final fun getDescription ()Ljava/lang/String; protected final fun getDescription ()Ljava/lang/String;
protected final fun getExecutionBlock ()Lkotlin/jvm/functions/Function2; protected final fun getExecutionBlock ()Lkotlin/jvm/functions/Function1;
protected final fun getFinalizeBlock ()Lkotlin/jvm/functions/Function2; protected final fun getFinalizeBlock ()Lkotlin/jvm/functions/Function1;
protected final fun getName ()Ljava/lang/String; protected final fun getName ()Ljava/lang/String;
protected final fun getOptions ()Ljava/util/Set; protected final fun getOptions ()Ljava/util/Set;
protected final fun getUse ()Z protected final fun getUse ()Z
@ -317,8 +320,8 @@ public abstract class app/revanced/patcher/patch/PatchBuilder {
public final fun invoke (Ljava/lang/String;[Ljava/lang/String;)Lkotlin/Pair; public final fun invoke (Ljava/lang/String;[Ljava/lang/String;)Lkotlin/Pair;
protected final fun setCompatiblePackages (Ljava/util/Set;)V protected final fun setCompatiblePackages (Ljava/util/Set;)V
protected final fun setDependencies (Ljava/util/Set;)V protected final fun setDependencies (Ljava/util/Set;)V
protected final fun setExecutionBlock (Lkotlin/jvm/functions/Function2;)V protected final fun setExecutionBlock (Lkotlin/jvm/functions/Function1;)V
protected final fun setFinalizeBlock (Lkotlin/jvm/functions/Function2;)V protected final fun setFinalizeBlock (Lkotlin/jvm/functions/Function1;)V
} }
public abstract interface class app/revanced/patcher/patch/PatchContext : java/util/function/Supplier { public abstract interface class app/revanced/patcher/patch/PatchContext : java/util/function/Supplier {
@ -395,18 +398,13 @@ public final class app/revanced/patcher/patch/ResourcePatchBuilder : app/revance
} }
public final class app/revanced/patcher/patch/ResourcePatchContext : app/revanced/patcher/patch/PatchContext { public final class app/revanced/patcher/patch/ResourcePatchContext : app/revanced/patcher/patch/PatchContext {
public final fun delete (Ljava/lang/String;)Z
public final fun document (Ljava/io/InputStream;)Lapp/revanced/patcher/util/Document;
public final fun document (Ljava/lang/String;)Lapp/revanced/patcher/util/Document;
public fun get ()Lapp/revanced/patcher/PatcherResult$PatchedResources; public fun get ()Lapp/revanced/patcher/PatcherResult$PatchedResources;
public synthetic fun get ()Ljava/lang/Object; public synthetic fun get ()Ljava/lang/Object;
public final fun get (Ljava/lang/String;Z)Ljava/io/File; public final fun get (Ljava/lang/String;Z)Ljava/io/File;
public static synthetic fun get$default (Lapp/revanced/patcher/patch/ResourcePatchContext;Ljava/lang/String;ZILjava/lang/Object;)Ljava/io/File; public static synthetic fun get$default (Lapp/revanced/patcher/patch/ResourcePatchContext;Ljava/lang/String;ZILjava/lang/Object;)Ljava/io/File;
public final fun getDocument ()Lapp/revanced/patcher/patch/ResourcePatchContext$DocumentOperatable;
public final fun stageDelete (Lkotlin/jvm/functions/Function1;)Z
}
public final class app/revanced/patcher/patch/ResourcePatchContext$DocumentOperatable {
public fun <init> (Lapp/revanced/patcher/patch/ResourcePatchContext;)V
public final fun get (Ljava/io/InputStream;)Lapp/revanced/patcher/util/Document;
public final fun get (Ljava/lang/String;)Lapp/revanced/patcher/util/Document;
} }
public final class app/revanced/patcher/util/Document : java/io/Closeable, org/w3c/dom/Document { public final class app/revanced/patcher/util/Document : java/io/Closeable, org/w3c/dom/Document {
@ -482,11 +480,12 @@ public final class app/revanced/patcher/util/Document : java/io/Closeable, org/w
} }
public final class app/revanced/patcher/util/MethodNavigator { public final class app/revanced/patcher/util/MethodNavigator {
public final fun at (ILkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/util/MethodNavigator; public final fun getValue (Ljava/lang/Void;Lkotlin/reflect/KProperty;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun at ([I)Lapp/revanced/patcher/util/MethodNavigator; public final fun original ()Lcom/android/tools/smali/dexlib2/iface/Method;
public static synthetic fun at$default (Lapp/revanced/patcher/util/MethodNavigator;ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/util/MethodNavigator; public final fun stop ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
public final fun immutable ()Lcom/android/tools/smali/dexlib2/iface/Method; public final fun to (ILkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/util/MethodNavigator;
public final fun mutable ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod; public final fun to ([I)Lapp/revanced/patcher/util/MethodNavigator;
public static synthetic fun to$default (Lapp/revanced/patcher/util/MethodNavigator;ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/util/MethodNavigator;
} }
public final class app/revanced/patcher/util/ProxyClassList : java/util/List, kotlin/jvm/internal/markers/KMutableList { public final class app/revanced/patcher/util/ProxyClassList : java/util/List, kotlin/jvm/internal/markers/KMutableList {

2
build.gradle.kts
View File

@ -56,6 +56,8 @@ dependencies {
kotlin { kotlin {
compilerOptions { compilerOptions {
jvmTarget.set(JvmTarget.JVM_11) jvmTarget.set(JvmTarget.JVM_11)
freeCompilerArgs = listOf("-Xcontext-receivers")
} }
} }

4
docs/1_patcher_intro.md
View File

@ -89,9 +89,9 @@ val patcherResult = Patcher(PatcherConfig(apkFile = File("some.apk"))).use { pat
runBlocking { runBlocking {
patcher().collect { patchResult -> patcher().collect { patchResult ->
if (patchResult.exception != null) if (patchResult.exception != null)
logger.info("\"${patchResult.patch}\" failed:\n${patchResult.exception}") logger.info { "\"${patchResult.patch}\" failed:\n${patchResult.exception}" }
else else
logger.info("\"${patchResult.patch}\" succeeded") logger.info { "\"${patchResult.patch}\" succeeded" }
} }
} }

4
docs/2_1_setup.md
View File

@ -72,6 +72,10 @@ To start developing patches with ReVanced Patcher, you must prepare a developmen
Throughout the documentation, [ReVanced Patches](https://github.com/revanced/revanced-patches) will be used as an example project. Throughout the documentation, [ReVanced Patches](https://github.com/revanced/revanced-patches) will be used as an example project.
> [!NOTE]
> To start a fresh project,
> you can use the [ReVanced Patches template](https://github.com/revanced/revanced-patches-template).
1. Clone the repository 1. Clone the repository
```bash ```bash

175
docs/2_2_1_fingerprinting.md
View File

@ -60,14 +60,16 @@
# 🔎 Fingerprinting # 🔎 Fingerprinting
In the context of ReVanced, fingerprinting is primarily used to match methods with a limited amount of known information. In the context of ReVanced, a fingerprint is a partial description of a method.
It is used to uniquely match a method by its characteristics.
Fingerprinting is used to match methods with a limited amount of known information.
Methods with obfuscated names that change with each update are primary candidates for fingerprinting. Methods with obfuscated names that change with each update are primary candidates for fingerprinting.
The goal of fingerprinting is to uniquely identify a method by capturing various attributes, such as the return type, The goal of fingerprinting is to uniquely identify a method by capturing various attributes, such as the return type,
access flags, an opcode pattern, strings, and more. access flags, an opcode pattern, strings, and more.
## ⛳️ Example fingerprint ## ⛳️ Example fingerprint
Throughout the documentation, the following example will be used to demonstrate the concepts of fingerprints: An example fingerprint is shown below:
```kt ```kt
@ -79,11 +81,11 @@ fingerprint {
parameters("Z") parameters("Z")
opcodes(Opcode.RETURN) opcodes(Opcode.RETURN)
strings("pro") strings("pro")
custom { (method, classDef) -> method.definingClass == "Lcom/some/app/ads/AdsLoader;" } custom { (method, classDef) -> classDef == "Lcom/some/app/ads/AdsLoader;" }
} }
``` ```
## 🔎 Reconstructing the original code from a fingerprint ## 🔎 Reconstructing the original code from the example fingerprint from above
The following code is reconstructed from the fingerprint to understand how a fingerprint is created. The following code is reconstructed from the fingerprint to understand how a fingerprint is created.
@ -107,36 +109,43 @@ The fingerprint contains the following information:
- Package and class name: - Package and class name:
```kt ```kt
custom = { (method, classDef) -> method.definingClass == "Lcom/some/app/ads/AdsLoader;"} custom { (method, classDef) -> classDef == "Lcom/some/app/ads/AdsLoader;" }
``` ```
With this information, the original code can be reconstructed: With this information, the original code can be reconstructed:
```java ```java
package com.some.app.ads; package com.some.app.ads;
<accessFlags> class AdsLoader { <accessFlags>
public final boolean <methodName>(boolean <parameter>) {
class AdsLoader {
public final boolean <methodName>(boolean <parameter>)
{
// ... // ...
var userStatus = "pro"; var userStatus = "pro";
// ... // ...
return <returnValue>; return <returnValue >;
}
} }
}
``` ```
Using that fingerprint, this method can be matched uniquely from all other methods.
> [!TIP] > [!TIP]
> A fingerprint should contain information about a method likely to remain the same across updates. > A fingerprint should contain information about a method likely to remain the same across updates.
> A method's name is not included in the fingerprint because it will likely change with each update in an obfuscated app. > A method's name is not included in the fingerprint because it will likely change with each update in an obfuscated
> In contrast, the return type, access flags, parameters, patterns of opcodes, and strings are likely to remain the same. > app.
> In contrast, the return type, access flags, parameters, patterns of opcodes, and strings are likely to remain the
> same.
## 🔨 How to use fingerprints ## 🔨 How to use fingerprints
Fingerprints can be added to a patch by directly creating and adding them or by invoking them manually. After declaring a fingerprint, it can be used in a patch to find the method it matches to:
Fingerprints added to a patch are matched by ReVanced Patcher before the patch is executed.
```kt ```kt
val fingerprint = fingerprint { val fingerprint = fingerprint {
@ -144,18 +153,35 @@ val fingerprint = fingerprint {
} }
val patch = bytecodePatch { val patch = bytecodePatch {
// Directly create and add a fingerprint. execute {
fingerprint { fingerprint.method
// ...
} }
// Add a fingerprint manually by invoking it.
fingerprint()
} }
``` ```
> [!TIP] The fingerprint won't be matched again, if it has already been matched once, for performance reasons.
> Multiple patches can share fingerprints. If a fingerprint is matched once, it will not be matched again. This makes it useful, to share fingerprints between multiple patches,
and let the first executing patch match the fingerprint:
```kt
// Either of these two patches will match the fingerprint first and the other patch can reuse the match:
val mainActivityPatch1 = bytecodePatch {
execute {
mainActivityOnCreateFingerprint.method
}
}
val mainActivityPatch2 = bytecodePatch {
execute {
mainActivityOnCreateFingerprint.method
}
}
```
> [!WARNING]
> If the fingerprint can not be matched to any method,
> accessing certain properties of the fingerprint will raise an exception.
> Instead, the `orNull` properties can be used to return `null` if no match is found.
> [!TIP] > [!TIP]
> If a fingerprint has an opcode pattern, you can use the `fuzzyPatternScanThreshhold` parameter of the `opcode` > If a fingerprint has an opcode pattern, you can use the `fuzzyPatternScanThreshhold` parameter of the `opcode`
@ -173,62 +199,42 @@ val patch = bytecodePatch {
>} >}
> ``` > ```
Once the fingerprint is matched, the match can be used in the patch: The following properties can be accessed in a fingerprint:
```kt - `originalClassDef`: The original class definition the fingerprint matches to.
val patch = bytecodePatch { - `originalClassDefOrNull`: The original class definition the fingerprint matches to.
// Add a fingerprint and delegate its match to a variable. - `originalMethod`: The original method the fingerprint matches to.
val match by showAdsFingerprint() - `originalMethodOrNull`: The original method the fingerprint matches to.
val match2 by fingerprint { - `classDef`: The class the fingerprint matches to.
// ... - `classDefOrNull`: The class the fingerprint matches to.
} - `method`: The method the fingerprint matches to. If no match is found, an exception is raised.
- `methodOrNull`: The method the fingerprint matches to.
execute { The difference between the `original` and non-`original` properties is that the `original` properties return the
val method = match.method original class or method definition, while the non-`original` properties return a mutable copy of the class or method.
val method2 = match2.method The mutable copies can be modified. They are lazy properties, so they are only computed
} and only then will effectively replace the `original` method or class definition when accessed.
}
```
> [!WARNING] > [!TIP]
> If the fingerprint can not be matched to any method, the match of a fingerprint is `null`. If such a match is delegated > If only read-only access to the class or method is needed,
> to a variable, accessing it will raise an exception. > the `originalClassDef` and `originalMethod` properties should be used,
> to avoid making a mutable copy of the class or method.
The match of a fingerprint contains mutable and immutable references to the method and the class it matches to. ## 🏹 Manually matching fingerprints
```kt By default, a fingerprint is matched automatically against all classes
class Match( when one of the fingerprint's properties is accessed.
val method: Method,
val classDef: ClassDef,
val patternMatch: Match.PatternMatch?,
val stringMatches: List<Match.StringMatch>?,
// ...
) {
val mutableClass by lazy { /* ... */ }
val mutableMethod by lazy { /* ... */ }
// ... Instead, the fingerprint can be matched manually using various overloads of a fingerprint's `match` function:
}
```
## 🏹 Manual matching of fingerprints
Unless a fingerprint is added to a patch, the fingerprint will not be matched automatically by ReVanced Patcher
before the patch is executed.
Instead, the fingerprint can be matched manually using various overloads of a fingerprint's `match` function.
You can match a fingerprint the following ways:
- In a **list of classes**, if the fingerprint can match in a known subset of classes - In a **list of classes**, if the fingerprint can match in a known subset of classes
If you have a known list of classes you know the fingerprint can match in, If you have a known list of classes you know the fingerprint can match in,
you can match the fingerprint on the list of classes: you can match the fingerprint on the list of classes:
```kt ```kt
execute { context -> execute {
val match = showAdsFingerprint.apply { val match = showAdsFingerprint(classes)
match(context, context.classes)
}.match ?: throw PatchException("No match found")
} }
``` ```
@ -237,37 +243,48 @@ you can match the fingerprint on the list of classes:
If you know the fingerprint can match a method in a specific class, you can match the fingerprint in the class: If you know the fingerprint can match a method in a specific class, you can match the fingerprint in the class:
```kt ```kt
execute { context -> execute {
val adsLoaderClass = context.classes.single { it.name == "Lcom/some/app/ads/Loader;" } val adsLoaderClass = classes.single { it.name == "Lcom/some/app/ads/Loader;" }
val match = showAdsFingerprint.apply { val match = showAdsFingerprint.match(adsLoaderClass)
match(context, adsLoaderClass) }
}.match ?: throw PatchException("No match found") ```
Another common usecase is to use a fingerprint to reduce the search space of a method to a single class.
```kt
execute {
// Match showAdsFingerprint in the class of the ads loader found by adsLoaderClassFingerprint.
val match = showAdsFingerprint.match(adsLoaderClassFingerprint.classDef)
} }
``` ```
- Match a **single method**, to extract certain information about it - Match a **single method**, to extract certain information about it
The match of a fingerprint contains useful information about the method, such as the start and end index of an opcode pattern The match of a fingerprint contains useful information about the method,
or the indices of the instructions with certain string references. such as the start and end index of an opcode pattern or the indices of the instructions with certain string
references.
A fingerprint can be leveraged to extract such information from a method instead of manually figuring it out: A fingerprint can be leveraged to extract such information from a method instead of manually figuring it out:
```kt ```kt
execute { context -> execute {
val proStringsFingerprint = fingerprint { val currentPlanFingerprint = fingerprint {
strings("free", "trial") strings("free", "trial")
} }
proStringsFingerprint.apply { currentPlanFingerprint.match(adsFingerprint.method).let { match ->
match(context, adsFingerprintMatch.method)
}.match?.let { match ->
match.stringMatches.forEach { match -> match.stringMatches.forEach { match ->
println("The index of the string '${match.string}' is ${match.index}") println("The index of the string '${match.string}' is ${match.index}")
} }
} ?: throw PatchException("No match found") }
} }
``` ```
> [!WARNING]
> If the fingerprint can not be matched to any method, calling `match` will raise an
> exception.
> Instead, the `orNull` overloads can be used to return `null` if no match is found.
> [!TIP] > [!TIP]
> To see real-world examples of fingerprints, > To see real-world examples of fingerprints,
> check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches). > check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches).

18
docs/2_2_patch_anatomy.md
View File

@ -76,23 +76,23 @@ val disableAdsPatch = bytecodePatch(
) { ) {
compatibleWith("com.some.app"("1.0.0")) compatibleWith("com.some.app"("1.0.0"))
// Resource patch disables ads by patching resource files. // Patches can depend on other patches, executing them first.
dependsOn(disableAdsResourcePatch) dependsOn(disableAdsResourcePatch)
// Precompiled DEX file to be merged into the patched app. // Merge precompiled DEX files into the patched app, before the patch is executed.
extendWith("disable-ads.rve") extendWith("disable-ads.rve")
// Business logic of the patch to disable ads in the app.
execute {
// Fingerprint to find the method to patch. // Fingerprint to find the method to patch.
val showAdsMatch by showAdsFingerprint { val showAdsMatch by showAdsFingerprint {
// More about fingerprints on the next page of the documentation. // More about fingerprints on the next page of the documentation.
} }
// Business logic of the patch to disable ads in the app.
execute {
// In the method that shows ads, // In the method that shows ads,
// call DisableAdsPatch.shouldDisableAds() from the extension (precompiled DEX file) // call DisableAdsPatch.shouldDisableAds() from the extension (precompiled DEX file)
// to enable or disable ads. // to enable or disable ads.
showAdsMatch.mutableMethod.addInstructions( showAdsMatch.method.addInstructions(
0, 0,
""" """
invoke-static {}, LDisableAdsPatch;->shouldDisableAds()Z invoke-static {}, LDisableAdsPatch;->shouldDisableAds()Z
@ -146,10 +146,10 @@ loadPatchesJar(patches).apply {
The type of an option can be obtained from the `type` property of the option: The type of an option can be obtained from the `type` property of the option:
```kt ```kt
option.type // The KType of the option. option.type // The KType of the option. Captures the full type information of the option.
``` ```
Options can be declared outside of a patch and added to a patch manually: Options can be declared outside a patch and added to a patch manually:
```kt ```kt
val option = stringOption(key = "option") val option = stringOption(key = "option")
@ -184,10 +184,8 @@ and use it in a patch:
val patch = bytecodePatch(name = "Complex patch") { val patch = bytecodePatch(name = "Complex patch") {
extendWith("complex-patch.rve") extendWith("complex-patch.rve")
val match by methodFingerprint()
execute { execute {
match.mutableMethod.addInstructions(0, "invoke-static { }, LComplexPatch;->doSomething()V") fingerprint.match!!.mutableMethod.addInstructions(0, "invoke-static { }, LComplexPatch;->doSomething()V")
} }
} }
``` ```

6
docs/2_patches_intro.md
View File

@ -96,21 +96,21 @@ Example of patches:
@Surpress("unused") @Surpress("unused")
val bytecodePatch = bytecodePatch { val bytecodePatch = bytecodePatch {
execute { execute {
// TODO // More about this on the next page of the documentation.
} }
} }
@Surpress("unused") @Surpress("unused")
val rawResourcePatch = rawResourcePatch { val rawResourcePatch = rawResourcePatch {
execute { execute {
// TODO // More about this on the next page of the documentation.
} }
} }
@Surpress("unused") @Surpress("unused")
val resourcePatch = resourcePatch { val resourcePatch = resourcePatch {
execute { execute {
// TODO // More about this on the next page of the documentation.
} }
} }
``` ```

110
docs/4_apis.md
View File

@ -4,18 +4,107 @@ A handful of APIs are available to make patch development easier and more effici
## 📙 Overview ## 📙 Overview
1. 👹 Mutate classes with `context.proxy(ClassDef)` 1. 👹 Create mutable replacements of classes with `proxy(ClassDef)`
2. 🔍 Find and proxy existing classes with `classBy(Predicate)` and `classByType(String)` 2. 🔍 Find and create mutable replaces with `classBy(Predicate)`
3. 🏃‍ Easily access referenced methods recursively by index with `MethodNavigator` 3. 🏃‍ Navigate method calls recursively by index with `navigate(Method)`
4. 🔨 Make use of extension functions from `BytecodeUtils` and `ResourceUtils` with certain applications 4. 💾 Read and write resource files with `get(String, Boolean)` and `delete(String)`
(Available in ReVanced Patches) 5. 📃 Read and write DOM files using `document(String)` and `document(InputStream)`
5. 💾 Read and write (decoded) resources with `ResourcePatchContext.get(Path, Boolean)`
6. 📃 Read and write DOM files using `ResourcePatchContext.document`
### 🧰 APIs ### 🧰 APIs
> [!WARNING] #### 👹 `proxy(ClassDef)`
> This section is still under construction and may be incomplete.
By default, the classes are immutable, meaning they cannot be modified.
To make a class mutable, use the `proxy(ClassDef)` function.
This function creates a lazy mutable copy of the class definition.
Accessing the property will replace the original class definition with the mutable copy,
thus allowing you to make changes to the class. Subsequent accesses will return the same mutable copy.
```kt
execute {
val mutableClass = proxy(classDef)
mutableClass.methods.add(Method())
}
```
#### 🔍 `classBy(Predicate)`
The `classBy(Predicate)` function is an alternative to finding and creating mutable classes by a predicate.
It automatically proxies the class definition, making it mutable.
```kt
execute {
// Alternative to proxy(classes.find { it.name == "Lcom/example/MyClass;" })?.classDef
val classDef = classBy { it.name == "Lcom/example/MyClass;" }?.classDef
}
```
#### 🏃‍ `navigate(Method).at(index)`
The `navigate(Method)` function allows you to navigate method calls recursively by index.
```kt
execute {
// Sequentially navigate to the instructions at index 1 within 'someMethod'.
val method = navigate(someMethod).to(1).original() // original() returns the original immutable method.
// Further navigate to the second occurrence where the instruction's opcode is 'INVOKEVIRTUAL'.
// stop() returns the mutable copy of the method.
val method = navigate(someMethod).to(2) { instruction -> instruction.opcode == Opcode.INVOKEVIRTUAL }.stop()
// Alternatively, to stop(), you can delegate the method to a variable.
val method by navigate(someMethod).to(1)
// You can chain multiple calls to at() to navigate deeper into the method.
val method by navigate(someMethod).to(1).to(2, 3, 4).to(5)
}
```
#### 💾 `get(String, Boolean)` and `delete(String)`
The `get(String, Boolean)` function returns a `File` object that can be used to read and write resource files.
```kt
execute {
val file = get("res/values/strings.xml")
val content = file.readText()
file.writeText(content)
}
```
The `delete` function can mark files for deletion when the APK is rebuilt.
```kt
execute {
delete("res/values/strings.xml")
}
```
#### 📃 `document(String)` and `document(InputStream)`
The `document` function is used to read and write DOM files.
```kt
execute {
document("res/values/strings.xml").use { document ->
val element = doc.createElement("string").apply {
textContent = "Hello, World!"
}
document.documentElement.appendChild(element)
}
}
```
You can also read documents from an `InputStream`:
```kt
execute {
val inputStream = classLoader.getResourceAsStream("some.xml")
document(inputStream).use { document ->
// ...
}
}
```
## 🎉 Afterword ## 🎉 Afterword
@ -23,5 +112,6 @@ ReVanced Patcher is a powerful library to patch Android applications, offering a
that outlive app updates. Patches make up ReVanced; without you, the community of patch developers, that outlive app updates. Patches make up ReVanced; without you, the community of patch developers,
ReVanced would not be what it is today. We hope that this documentation has been helpful to you ReVanced would not be what it is today. We hope that this documentation has been helpful to you
and are excited to see what you will create with ReVanced Patcher. If you have any questions or need help, and are excited to see what you will create with ReVanced Patcher. If you have any questions or need help,
talk to us on one of our platforms linked on [revanced.app](https://revanced.app) or open an issue in case of a bug or feature request, talk to us on one of our platforms linked on [revanced.app](https://revanced.app) or open an issue in case of a bug or
feature request,
ReVanced ReVanced

2
gradle.properties
View File

@ -1,3 +1,3 @@
org.gradle.parallel = true org.gradle.parallel = true
org.gradle.caching = true org.gradle.caching = true
version = 20.0.2 version = 21.0.0-dev.4

332
src/main/kotlin/app/revanced/patcher/Fingerprint.kt
View File

@ -3,9 +3,8 @@
package app.revanced.patcher package app.revanced.patcher
import app.revanced.patcher.extensions.InstructionExtensions.instructionsOrNull import app.revanced.patcher.extensions.InstructionExtensions.instructionsOrNull
import app.revanced.patcher.patch.* import app.revanced.patcher.patch.BytecodePatchContext
import app.revanced.patcher.patch.BytecodePatchContext.LookupMaps.Companion.appendParameters import app.revanced.patcher.patch.PatchException
import app.revanced.patcher.patch.MethodClassPairs
import app.revanced.patcher.util.proxy.ClassProxy import app.revanced.patcher.util.proxy.ClassProxy
import com.android.tools.smali.dexlib2.AccessFlags import com.android.tools.smali.dexlib2.AccessFlags
import com.android.tools.smali.dexlib2.Opcode import com.android.tools.smali.dexlib2.Opcode
@ -16,7 +15,17 @@ import com.android.tools.smali.dexlib2.iface.reference.StringReference
import com.android.tools.smali.dexlib2.util.MethodUtil import com.android.tools.smali.dexlib2.util.MethodUtil
/** /**
* A fingerprint. * A fingerprint for a method. A fingerprint is a partial description of a method.
* It is used to uniquely match a method by its characteristics.
*
* An example fingerprint for a public method that takes a single string parameter and returns void:
* ```
* fingerprint {
* accessFlags(AccessFlags.PUBLIC)
* returns("V")
* parameters("Ljava/lang/String;")
* }
* ```
* *
* @param accessFlags The exact access flags using values of [AccessFlags]. * @param accessFlags The exact access flags using values of [AccessFlags].
* @param returnType The return type. Compared using [String.startsWith]. * @param returnType The return type. Compared using [String.startsWith].
@ -35,16 +44,21 @@ class Fingerprint internal constructor(
internal val custom: ((method: Method, classDef: ClassDef) -> Boolean)?, internal val custom: ((method: Method, classDef: ClassDef) -> Boolean)?,
private val fuzzyPatternScanThreshold: Int, private val fuzzyPatternScanThreshold: Int,
) { ) {
@Suppress("ktlint:standard:backing-property-naming")
// Backing field needed for lazy initialization.
private var _matchOrNull: Match? = null
/** /**
* The match for this [Fingerprint]. Null if unmatched. * The match for this [Fingerprint]. Null if unmatched.
*/ */
var match: Match? = null context(BytecodePatchContext)
private set private val matchOrNull: Match?
get() = matchOrNull()
/** /**
* Match using [BytecodePatchContext.LookupMaps]. * Match using [BytecodePatchContext.lookupMaps].
* *
* Generally faster than the other [match] overloads when there are many methods to check for a match. * Generally faster than the other [matchOrNull] overloads when there are many methods to check for a match.
* *
* Fingerprints can be optimized for performance: * Fingerprints can be optimized for performance:
* - Slowest: Specify [custom] or [opcodes] and nothing else. * - Slowest: Specify [custom] or [opcodes] and nothing else.
@ -52,48 +66,50 @@ class Fingerprint internal constructor(
* - Faster: Specify [accessFlags], [returnType] and [parameters]. * - Faster: Specify [accessFlags], [returnType] and [parameters].
* - Fastest: Specify [strings], with at least one string being an exact (non-partial) match. * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
* *
* @param context The context to create mutable proxies for the matched method and its class. * @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @return True if a match was found or if the fingerprint is already matched to a method, false otherwise.
*/ */
internal fun match(context: BytecodePatchContext): Boolean { context(BytecodePatchContext)
val lookupMaps = context.lookupMaps internal fun matchOrNull(): Match? {
if (_matchOrNull != null) return _matchOrNull
fun Fingerprint.match(methodClasses: MethodClassPairs): Boolean { var match = strings?.mapNotNull {
lookupMaps.methodsByStrings[it]
}?.minByOrNull { it.size }?.let { methodClasses ->
methodClasses.forEach { (classDef, method) -> methodClasses.forEach { (classDef, method) ->
if (match(context, classDef, method)) return true val match = matchOrNull(classDef, method)
} if (match != null) return@let match
return false
} }
// TODO: If only one string is necessary, why not use a single string for every fingerprint? null
if (strings?.firstNotNullOfOrNull { lookupMaps.methodsByStrings[it] }?.let(::match) == true) { }
return true if (match != null) return match
classes.forEach { classDef ->
match = matchOrNull(classDef)
if (match != null) return match
} }
context.classes.forEach { classDef -> return null
if (match(context, classDef)) return true
}
return false
} }
/** /**
* Match using a [ClassDef]. * Match using a [ClassDef].
* *
* @param classDef The class to match against. * @param classDef The class to match against.
* @param context The context to create mutable proxies for the matched method and its class. * @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @return True if a match was found or if the fingerprint is already matched to a method, false otherwise.
*/ */
fun match( context(BytecodePatchContext)
context: BytecodePatchContext, fun matchOrNull(
classDef: ClassDef, classDef: ClassDef,
): Boolean { ): Match? {
if (_matchOrNull != null) return _matchOrNull
for (method in classDef.methods) { for (method in classDef.methods) {
if (match(context, method, classDef)) { val match = matchOrNull(method, classDef)
return true if (match != null) return match
} }
}
return false return null
} }
/** /**
@ -101,35 +117,33 @@ class Fingerprint internal constructor(
* The class is retrieved from the method. * The class is retrieved from the method.
* *
* @param method The method to match against. * @param method The method to match against.
* @param context The context to create mutable proxies for the matched method and its class. * @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @return True if a match was found or if the fingerprint is already matched to a method, false otherwise.
*/ */
fun match( context(BytecodePatchContext)
context: BytecodePatchContext, fun matchOrNull(
method: Method, method: Method,
) = match(context, method, context.classBy { method.definingClass == it.type }!!.immutableClass) ) = matchOrNull(method, classBy { method.definingClass == it.type }!!.immutableClass)
/** /**
* Match using a [Method]. * Match using a [Method].
* *
* @param method The method to match against. * @param method The method to match against.
* @param classDef The class the method is a member of. * @param classDef The class the method is a member of.
* @param context The context to create mutable proxies for the matched method and its class. * @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @return True if a match was found or if the fingerprint is already matched to a method, false otherwise.
*/ */
internal fun match( context(BytecodePatchContext)
context: BytecodePatchContext, fun matchOrNull(
method: Method, method: Method,
classDef: ClassDef, classDef: ClassDef,
): Boolean { ): Match? {
if (match != null) return true if (_matchOrNull != null) return _matchOrNull
if (returnType != null && !method.returnType.startsWith(returnType)) { if (returnType != null && !method.returnType.startsWith(returnType)) {
return false return null
} }
if (accessFlags != null && accessFlags != method.accessFlags) { if (accessFlags != null && accessFlags != method.accessFlags) {
return false return null
} }
fun parametersEqual( fun parametersEqual(
@ -146,17 +160,17 @@ class Fingerprint internal constructor(
// TODO: parseParameters() // TODO: parseParameters()
if (parameters != null && !parametersEqual(parameters, method.parameterTypes)) { if (parameters != null && !parametersEqual(parameters, method.parameterTypes)) {
return false return null
} }
if (custom != null && !custom.invoke(method, classDef)) { if (custom != null && !custom.invoke(method, classDef)) {
return false return null
} }
val stringMatches: List<Match.StringMatch>? = val stringMatches: List<Match.StringMatch>? =
if (strings != null) { if (strings != null) {
buildList { buildList {
val instructions = method.instructionsOrNull ?: return false val instructions = method.instructionsOrNull ?: return null
val stringsList = strings.toMutableList() val stringsList = strings.toMutableList()
@ -176,14 +190,14 @@ class Fingerprint internal constructor(
stringsList.removeAt(index) stringsList.removeAt(index)
} }
if (stringsList.isNotEmpty()) return false if (stringsList.isNotEmpty()) return null
} }
} else { } else {
null null
} }
val patternMatch = if (opcodes != null) { val patternMatch = if (opcodes != null) {
val instructions = method.instructionsOrNull ?: return false val instructions = method.instructionsOrNull ?: return null
fun patternScan(): Match.PatternMatch? { fun patternScan(): Match.PatternMatch? {
val fingerprintFuzzyPatternScanThreshold = fuzzyPatternScanThreshold val fingerprintFuzzyPatternScanThreshold = fuzzyPatternScanThreshold
@ -222,61 +236,217 @@ class Fingerprint internal constructor(
return null return null
} }
patternScan() ?: return false patternScan() ?: return null
} else { } else {
null null
} }
match = Match( _matchOrNull = Match(
method, method,
classDef,
patternMatch, patternMatch,
stringMatches, stringMatches,
context, classDef,
) )
return true return _matchOrNull
} }
private val exception get() = PatchException("Failed to match the fingerprint: $this")
/**
* The match for this [Fingerprint].
*
* @throws PatchException If the [Fingerprint] has not been matched.
*/
context(BytecodePatchContext)
private val match
get() = matchOrNull ?: throw exception
/**
* Match using a [ClassDef].
*
* @param classDef The class to match against.
* @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
fun match(
classDef: ClassDef,
) = matchOrNull(classDef) ?: throw exception
/**
* Match using a [Method].
* The class is retrieved from the method.
*
* @param method The method to match against.
* @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
fun match(
method: Method,
) = matchOrNull(method) ?: throw exception
/**
* Match using a [Method].
*
* @param method The method to match against.
* @param classDef The class the method is a member of.
* @return The [Match] if a match was found or if the fingerprint is already matched to a method, null otherwise.
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
fun match(
method: Method,
classDef: ClassDef,
) = matchOrNull(method, classDef) ?: throw exception
/**
* The class the matching method is a member of.
*/
context(BytecodePatchContext)
val originalClassDefOrNull
get() = matchOrNull?.originalClassDef
/**
* The matching method.
*/
context(BytecodePatchContext)
val originalMethodOrNull
get() = matchOrNull?.originalMethod
/**
* The mutable version of [originalClassDefOrNull].
*
* Accessing this property allocates a [ClassProxy].
* Use [originalClassDefOrNull] if mutable access is not required.
*/
context(BytecodePatchContext)
val classDefOrNull
get() = matchOrNull?.classDef
/**
* The mutable version of [originalMethodOrNull].
*
* Accessing this property allocates a [ClassProxy].
* Use [originalMethodOrNull] if mutable access is not required.
*/
context(BytecodePatchContext)
val methodOrNull
get() = matchOrNull?.method
/**
* The match for the opcode pattern.
*/
context(BytecodePatchContext)
val patternMatchOrNull
get() = matchOrNull?.patternMatch
/**
* The matches for the strings.
*/
context(BytecodePatchContext)
val stringMatchesOrNull
get() = matchOrNull?.stringMatches
/**
* The class the matching method is a member of.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val originalClassDef
get() = match.originalClassDef
/**
* The matching method.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val originalMethod
get() = match.originalMethod
/**
* The mutable version of [originalClassDef].
*
* Accessing this property allocates a [ClassProxy].
* Use [originalClassDef] if mutable access is not required.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val classDef
get() = match.classDef
/**
* The mutable version of [originalMethod].
*
* Accessing this property allocates a [ClassProxy].
* Use [originalMethod] if mutable access is not required.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val method
get() = match.method
/**
* The match for the opcode pattern.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val patternMatch
get() = match.patternMatch
/**
* The matches for the strings.
*
* @throws PatchException If the fingerprint has not been matched.
*/
context(BytecodePatchContext)
val stringMatches
get() = match.stringMatches
} }
/** /**
* A match for a [Fingerprint]. * A match of a [Fingerprint].
* *
* @param method The matching method. * @param originalClassDef The class the matching method is a member of.
* @param classDef The class the matching method is a member of. * @param originalMethod The matching method.
* @param patternMatch The match for the opcode pattern. * @param patternMatch The match for the opcode pattern.
* @param stringMatches The matches for the strings. * @param stringMatches The matches for the strings.
* @param context The context to create mutable proxies in.
*/ */
class Match( context(BytecodePatchContext)
val method: Method, class Match internal constructor(
val classDef: ClassDef, val originalMethod: Method,
val patternMatch: PatternMatch?, val patternMatch: PatternMatch?,
val stringMatches: List<StringMatch>?, val stringMatches: List<StringMatch>?,
internal val context: BytecodePatchContext, val originalClassDef: ClassDef,
) { ) {
/** /**
* The mutable version of [classDef]. * The mutable version of [originalClassDef].
* *
* Accessing this property allocates a [ClassProxy]. * Accessing this property allocates a [ClassProxy].
* Use [classDef] if mutable access is not required. * Use [originalClassDef] if mutable access is not required.
*/ */
val mutableClass by lazy { context.proxy(classDef).mutableClass } val classDef by lazy { proxy(originalClassDef).mutableClass }
/** /**
* The mutable version of [method]. * The mutable version of [originalMethod].
* *
* Accessing this property allocates a [ClassProxy]. * Accessing this property allocates a [ClassProxy].
* Use [method] if mutable access is not required. * Use [originalMethod] if mutable access is not required.
*/ */
val mutableMethod by lazy { mutableClass.methods.first { MethodUtil.methodSignaturesMatch(it, method) } } val method by lazy { classDef.methods.first { MethodUtil.methodSignaturesMatch(it, originalMethod) } }
/** /**
* A match for an opcode pattern. * A match for an opcode pattern.
* @param startIndex The index of the first opcode of the pattern in the method. * @param startIndex The index of the first opcode of the pattern in the method.
* @param endIndex The index of the last opcode of the pattern in the method. * @param endIndex The index of the last opcode of the pattern in the method.
*/ */
class PatternMatch( class PatternMatch internal constructor(
val startIndex: Int, val startIndex: Int,
val endIndex: Int, val endIndex: Int,
) )
@ -287,7 +457,7 @@ class Match(
* @param string The string that matched. * @param string The string that matched.
* @param index The index of the instruction in the method. * @param index The index of the instruction in the method.
*/ */
class StringMatch(val string: String, val index: Int) class StringMatch internal constructor(val string: String, val index: Int)
} }
/** /**
@ -336,7 +506,7 @@ class FingerprintBuilder internal constructor(
* *
* @param returnType The return type compared using [String.startsWith]. * @param returnType The return type compared using [String.startsWith].
*/ */
infix fun returns(returnType: String) { fun returns(returnType: String) {
this.returnType = returnType this.returnType = returnType
} }
@ -427,19 +597,3 @@ fun fingerprint(
fuzzyPatternScanThreshold: Int = 0, fuzzyPatternScanThreshold: Int = 0,
block: FingerprintBuilder.() -> Unit, block: FingerprintBuilder.() -> Unit,
) = FingerprintBuilder(fuzzyPatternScanThreshold).apply(block).build() ) = FingerprintBuilder(fuzzyPatternScanThreshold).apply(block).build()
/**
* Create a [Fingerprint] and add it to the set of fingerprints.
*
* @param fuzzyPatternScanThreshold The threshold for fuzzy pattern scanning. Default is 0.
* @param block The block to build the [Fingerprint].
*
* @return The created [Fingerprint].
*/
fun BytecodePatchBuilder.fingerprint(
fuzzyPatternScanThreshold: Int = 0,
block: FingerprintBuilder.() -> Unit,
) = app.revanced.patcher.fingerprint(
fuzzyPatternScanThreshold,
block,
)() // Invoke to add it.

12
src/main/kotlin/app/revanced/patcher/Patcher.kt
View File

@ -91,19 +91,15 @@ class Patcher(private val config: PatcherConfig) : Closeable {
}.also { executedPatches[this] = it } }.also { executedPatches[this] = it }
} }
// Prevent from decoding the app manifest twice if it is not needed. // Prevent decoding the app manifest twice if it is not needed.
if (config.resourceMode != ResourcePatchContext.ResourceMode.NONE) { if (config.resourceMode != ResourcePatchContext.ResourceMode.NONE) {
context.resourceContext.decodeResources(config.resourceMode) context.resourceContext.decodeResources(config.resourceMode)
} }
logger.info("Merging extensions") logger.info("Initializing lookup maps")
with(context.bytecodeContext) { // Accessing the lazy lookup maps to initialize them.
context.executablePatches.mergeExtensions() context.bytecodeContext.lookupMaps
// Initialize lookup maps.
lookupMaps
}
logger.info("Executing patches") logger.info("Executing patches")

4
src/main/kotlin/app/revanced/patcher/PatcherConfig.kt
View File

@ -12,16 +12,12 @@ import java.util.logging.Logger
* @param temporaryFilesPath A path to a folder to store temporary files in. * @param temporaryFilesPath A path to a folder to store temporary files in.
* @param aaptBinaryPath A path to a custom aapt binary. * @param aaptBinaryPath A path to a custom aapt binary.
* @param frameworkFileDirectory A path to the directory to cache the framework file in. * @param frameworkFileDirectory A path to the directory to cache the framework file in.
* @param multithreadingDexFileWriter Whether to use multiple threads for writing dex files.
* This has impact on memory usage and performance.
*/ */
class PatcherConfig( class PatcherConfig(
internal val apkFile: File, internal val apkFile: File,
private val temporaryFilesPath: File = File("revanced-temporary-files"), private val temporaryFilesPath: File = File("revanced-temporary-files"),
aaptBinaryPath: String? = null, aaptBinaryPath: String? = null,
frameworkFileDirectory: String? = null, frameworkFileDirectory: String? = null,
@Deprecated("This is going to be removed in the future because it is not needed anymore.")
internal val multithreadingDexFileWriter: Boolean = false,
) { ) {
private val logger = Logger.getLogger(PatcherConfig::class.java.name) private val logger = Logger.getLogger(PatcherConfig::class.java.name)

4
src/main/kotlin/app/revanced/patcher/PatcherResult.kt
View File

@ -29,12 +29,12 @@ class PatcherResult internal constructor(
* @param resourcesApk The compiled resources.apk file. * @param resourcesApk The compiled resources.apk file.
* @param otherResources The directory containing other resources files. * @param otherResources The directory containing other resources files.
* @param doNotCompress List of files that should not be compressed. * @param doNotCompress List of files that should not be compressed.
* @param deleteResources List of predicates about resources that should be deleted. * @param deleteResources List of resources that should be deleted.
*/ */
class PatchedResources internal constructor( class PatchedResources internal constructor(
val resourcesApk: File?, val resourcesApk: File?,
val otherResources: File?, val otherResources: File?,
val doNotCompress: Set<String>, val doNotCompress: Set<String>,
val deleteResources: Set<(String) -> Boolean>, val deleteResources: Set<String>,
) )
} }

78
src/main/kotlin/app/revanced/patcher/patch/BytecodePatchContext.kt
View File

@ -14,6 +14,7 @@ import com.android.tools.smali.dexlib2.iface.ClassDef
import com.android.tools.smali.dexlib2.iface.DexFile import com.android.tools.smali.dexlib2.iface.DexFile
import com.android.tools.smali.dexlib2.iface.Method import com.android.tools.smali.dexlib2.iface.Method
import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
import com.android.tools.smali.dexlib2.iface.reference.MethodReference
import com.android.tools.smali.dexlib2.iface.reference.StringReference import com.android.tools.smali.dexlib2.iface.reference.StringReference
import lanchon.multidexlib2.BasicDexFileNamer import lanchon.multidexlib2.BasicDexFileNamer
import lanchon.multidexlib2.DexIO import lanchon.multidexlib2.DexIO
@ -33,7 +34,7 @@ import java.util.logging.Logger
class BytecodePatchContext internal constructor(private val config: PatcherConfig) : class BytecodePatchContext internal constructor(private val config: PatcherConfig) :
PatchContext<Set<PatcherResult.PatchedDexFile>>, PatchContext<Set<PatcherResult.PatchedDexFile>>,
Closeable { Closeable {
private val logger = Logger.getLogger(BytecodePatchContext::class.java.name) private val logger = Logger.getLogger(this::javaClass.name)
/** /**
* [Opcodes] of the supplied [PatcherConfig.apkFile]. * [Opcodes] of the supplied [PatcherConfig.apkFile].
@ -59,29 +60,24 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
internal val lookupMaps by lazy { LookupMaps(classes) } internal val lookupMaps by lazy { LookupMaps(classes) }
/** /**
* Merge the extensions for this set of patches. * Merge the extension of [bytecodePatch] into the [BytecodePatchContext].
* If no extension is present, the function will return early.
*
* @param bytecodePatch The [BytecodePatch] to merge the extension of.
*/ */
internal fun Set<Patch<*>>.mergeExtensions() { internal fun mergeExtension(bytecodePatch: BytecodePatch) {
// Lookup map to check if a class exists by its type quickly. bytecodePatch.extensionInputStream?.get()?.use { extensionStream ->
val classesByType = mutableMapOf<String, ClassDef>().apply {
classes.forEach { classDef -> put(classDef.type, classDef) }
}
forEachRecursively { patch ->
if (patch !is BytecodePatch) return@forEachRecursively
patch.extension?.use { extensionStream ->
RawDexIO.readRawDexFile(extensionStream, 0, null).classes.forEach { classDef -> RawDexIO.readRawDexFile(extensionStream, 0, null).classes.forEach { classDef ->
val existingClass = classesByType[classDef.type] ?: run { val existingClass = lookupMaps.classesByType[classDef.type] ?: run {
logger.fine("Adding class \"$classDef\"") logger.fine { "Adding class \"$classDef\"" }
classes += classDef classes += classDef
classesByType[classDef.type] = classDef lookupMaps.classesByType[classDef.type] = classDef
return@forEach return@forEach
} }
logger.fine("Class \"$classDef\" exists already. Adding missing methods and fields.") logger.fine { "Class \"$classDef\" exists already. Adding missing methods and fields." }
existingClass.merge(classDef, this@BytecodePatchContext).let { mergedClass -> existingClass.merge(classDef, this@BytecodePatchContext).let { mergedClass ->
// If the class was merged, replace the original class with the merged class. // If the class was merged, replace the original class with the merged class.
@ -93,18 +89,8 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
classes += mergedClass classes += mergedClass
} }
} }
} ?: logger.fine("No extension to merge")
} }
}
}
/**
* Find a class by its type using a contains check.
*
* @param type The type of the class.
* @return A proxy for the first class that matches the type.
*/
@Deprecated("Use classBy { type in it.type } instead.", ReplaceWith("classBy { type in it.type }"))
fun classByType(type: String) = classBy { type in it.type }
/** /**
* Find a class with a predicate. * Find a class with a predicate.
@ -122,9 +108,9 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
* *
* @return A proxy for the class. * @return A proxy for the class.
*/ */
fun proxy(classDef: ClassDef) = this@BytecodePatchContext.classes.proxyPool.find { fun proxy(classDef: ClassDef) = classes.proxyPool.find {
it.immutableClass.type == classDef.type it.immutableClass.type == classDef.type
} ?: ClassProxy(classDef).also { this@BytecodePatchContext.classes.proxyPool.add(it) } } ?: ClassProxy(classDef).also { classes.proxyPool.add(it) }
/** /**
* Navigate a method. * Navigate a method.
@ -133,7 +119,7 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
* *
* @return A [MethodNavigator] for the method. * @return A [MethodNavigator] for the method.
*/ */
fun navigate(method: Method) = MethodNavigator(this@BytecodePatchContext, method) fun navigate(method: MethodReference) = MethodNavigator(method)
/** /**
* Compile bytecode from the [BytecodePatchContext]. * Compile bytecode from the [BytecodePatchContext].
@ -154,7 +140,7 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
}.apply { }.apply {
MultiDexIO.writeDexFile( MultiDexIO.writeDexFile(
true, true,
if (config.multithreadingDexFileWriter) -1 else 1, -1,
this, this,
BasicDexFileNamer(), BasicDexFileNamer(),
object : DexFile { object : DexFile {
@ -164,7 +150,7 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
override fun getOpcodes() = this@BytecodePatchContext.opcodes override fun getOpcodes() = this@BytecodePatchContext.opcodes
}, },
DexIO.DEFAULT_MAX_DEX_POOL_SIZE, DexIO.DEFAULT_MAX_DEX_POOL_SIZE,
) { _, entryName, _ -> logger.info("Compiled $entryName") } ) { _, entryName, _ -> logger.info { "Compiled $entryName" } }
}.listFiles(FileFilter { it.isFile })!!.map { }.listFiles(FileFilter { it.isFile })!!.map {
PatcherResult.PatchedDexFile(it.name, it.inputStream()) PatcherResult.PatchedDexFile(it.name, it.inputStream())
}.toSet() }.toSet()
@ -185,6 +171,11 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
*/ */
internal val methodsByStrings = MethodClassPairsLookupMap() internal val methodsByStrings = MethodClassPairsLookupMap()
// Lookup map for fast checking if a class exists by its type.
val classesByType = mutableMapOf<String, ClassDef>().apply {
classes.forEach { classDef -> put(classDef.type, classDef) }
}
init { init {
classes.forEach { classDef -> classes.forEach { classDef ->
classDef.methods.forEach { method -> classDef.methods.forEach { method ->
@ -207,30 +198,9 @@ class BytecodePatchContext internal constructor(private val config: PatcherConfi
} }
} }
internal companion object {
/**
* Appends a string based on the parameter reference types of this method.
*/
internal fun StringBuilder.appendParameters(parameters: Iterable<CharSequence>) {
// Maximum parameters to use in the signature key.
// Some apps have methods with an incredible number of parameters (over 100 parameters have been seen).
// To keep the signature map from becoming needlessly bloated,
// group together in the same map entry all methods with the same access/return and 5 or more parameters.
// The value of 5 was chosen based on local performance testing and is not set in stone.
val maxSignatureParameters = 5
// Must append a unique value before the parameters to distinguish this key includes the parameters.
// If this is not appended, then methods with no parameters
// will collide with different keys that specify access/return but omit the parameters.
append("p:")
parameters.forEachIndexed { index, parameter ->
if (index >= maxSignatureParameters) return
append(parameter.first())
}
}
}
override fun close() { override fun close() {
methodsByStrings.clear() methodsByStrings.clear()
classesByType.clear()
} }
} }

83
src/main/kotlin/app/revanced/patcher/patch/Patch.kt
View File

@ -2,7 +2,6 @@
package app.revanced.patcher.patch package app.revanced.patcher.patch
import app.revanced.patcher.Fingerprint
import app.revanced.patcher.Patcher import app.revanced.patcher.Patcher
import app.revanced.patcher.PatcherContext import app.revanced.patcher.PatcherContext
import dalvik.system.DexClassLoader import dalvik.system.DexClassLoader
@ -14,8 +13,8 @@ import java.lang.reflect.Member
import java.lang.reflect.Method import java.lang.reflect.Method
import java.lang.reflect.Modifier import java.lang.reflect.Modifier
import java.net.URLClassLoader import java.net.URLClassLoader
import java.util.function.Supplier
import java.util.jar.JarFile import java.util.jar.JarFile
import kotlin.reflect.KProperty
typealias PackageName = String typealias PackageName = String
typealias VersionName = String typealias VersionName = String
@ -46,10 +45,10 @@ sealed class Patch<C : PatchContext<*>>(
val dependencies: Set<Patch<*>>, val dependencies: Set<Patch<*>>,
val compatiblePackages: Set<Package>?, val compatiblePackages: Set<Package>?,
options: Set<Option<*>>, options: Set<Option<*>>,
private val executeBlock: Patch<C>.(C) -> Unit, private val executeBlock: (C) -> Unit,
// Must be internal and nullable, so that Patcher.invoke can check, // Must be internal and nullable, so that Patcher.invoke can check,
// if a patch has a finalizing block in order to not emit it twice. // if a patch has a finalizing block in order to not emit it twice.
internal var finalizeBlock: (Patch<C>.(C) -> Unit)?, internal var finalizeBlock: ((C) -> Unit)?,
) { ) {
/** /**
* The options of the patch. * The options of the patch.
@ -57,35 +56,35 @@ sealed class Patch<C : PatchContext<*>>(
val options = Options(options) val options = Options(options)
/** /**
* Runs the execution block of the patch. * Calls the execution block of the patch.
* Called by [Patcher]. * This function is called by [Patcher.invoke].
* *
* @param context The [PatcherContext] to get the [PatchContext] from to execute the patch with. * @param context The [PatcherContext] to get the [PatchContext] from to execute the patch with.
*/ */
internal abstract fun execute(context: PatcherContext) internal abstract fun execute(context: PatcherContext)
/** /**
* Runs the execution block of the patch. * Calls the execution block of the patch.
* *
* @param context The [PatchContext] to execute the patch with. * @param context The [PatchContext] to execute the patch with.
*/ */
fun execute(context: C) = executeBlock(context) fun execute(context: C) = executeBlock(context)
/** /**
* Runs the finalizing block of the patch. * Calls the finalizing block of the patch.
* Called by [Patcher]. * This function is called by [Patcher.invoke].
* *
* @param context The [PatcherContext] to get the [PatchContext] from to finalize the patch with. * @param context The [PatcherContext] to get the [PatchContext] from to finalize the patch with.
*/ */
internal abstract fun finalize(context: PatcherContext) internal abstract fun finalize(context: PatcherContext)
/** /**
* Runs the finalizing block of the patch. * Calls the finalizing block of the patch.
* *
* @param context The [PatchContext] to finalize the patch with. * @param context The [PatchContext] to finalize the patch with.
*/ */
fun finalize(context: C) { fun finalize(context: C) {
finalizeBlock?.invoke(this, context) finalizeBlock?.invoke(context)
} }
override fun toString() = name ?: "Patch" override fun toString() = name ?: "Patch"
@ -127,8 +126,7 @@ internal fun Iterable<Patch<*>>.forEachRecursively(
* If null, the patch is compatible with all packages. * If null, the patch is compatible with all packages.
* @param dependencies Other patches this patch depends on. * @param dependencies Other patches this patch depends on.
* @param options The options of the patch. * @param options The options of the patch.
* @param fingerprints The fingerprints that are resolved before the patch is executed. * @property extensionInputStream Getter for the extension input stream of the patch.
* @property extension An input stream of the extension resource this patch uses.
* An extension is a precompiled DEX file that is merged into the patched app before this patch is executed. * An extension is a precompiled DEX file that is merged into the patched app before this patch is executed.
* @param executeBlock The execution block of the patch. * @param executeBlock The execution block of the patch.
* @param finalizeBlock The finalizing block of the patch. Called after all patches have been executed, * @param finalizeBlock The finalizing block of the patch. Called after all patches have been executed,
@ -143,10 +141,9 @@ class BytecodePatch internal constructor(
compatiblePackages: Set<Package>?, compatiblePackages: Set<Package>?,
dependencies: Set<Patch<*>>, dependencies: Set<Patch<*>>,
options: Set<Option<*>>, options: Set<Option<*>>,
val fingerprints: Set<Fingerprint>, val extensionInputStream: Supplier<InputStream>?,
val extension: InputStream?, executeBlock: (BytecodePatchContext) -> Unit,
executeBlock: Patch<BytecodePatchContext>.(BytecodePatchContext) -> Unit, finalizeBlock: ((BytecodePatchContext) -> Unit)?,
finalizeBlock: (Patch<BytecodePatchContext>.(BytecodePatchContext) -> Unit)?,
) : Patch<BytecodePatchContext>( ) : Patch<BytecodePatchContext>(
name, name,
description, description,
@ -158,8 +155,7 @@ class BytecodePatch internal constructor(
finalizeBlock, finalizeBlock,
) { ) {
override fun execute(context: PatcherContext) = with(context.bytecodeContext) { override fun execute(context: PatcherContext) = with(context.bytecodeContext) {
fingerprints.forEach { it.match(this) } mergeExtension(this@BytecodePatch)
execute(this) execute(this)
} }
@ -192,8 +188,8 @@ class RawResourcePatch internal constructor(
compatiblePackages: Set<Package>?, compatiblePackages: Set<Package>?,
dependencies: Set<Patch<*>>, dependencies: Set<Patch<*>>,
options: Set<Option<*>>, options: Set<Option<*>>,
executeBlock: Patch<ResourcePatchContext>.(ResourcePatchContext) -> Unit, executeBlock: (ResourcePatchContext) -> Unit,
finalizeBlock: (Patch<ResourcePatchContext>.(ResourcePatchContext) -> Unit)?, finalizeBlock: ((ResourcePatchContext) -> Unit)?,
) : Patch<ResourcePatchContext>( ) : Patch<ResourcePatchContext>(
name, name,
description, description,
@ -235,8 +231,8 @@ class ResourcePatch internal constructor(
compatiblePackages: Set<Package>?, compatiblePackages: Set<Package>?,
dependencies: Set<Patch<*>>, dependencies: Set<Patch<*>>,
options: Set<Option<*>>, options: Set<Option<*>>,
executeBlock: Patch<ResourcePatchContext>.(ResourcePatchContext) -> Unit, executeBlock: (ResourcePatchContext) -> Unit,
finalizeBlock: (Patch<ResourcePatchContext>.(ResourcePatchContext) -> Unit)?, finalizeBlock: ((ResourcePatchContext) -> Unit)?,
) : Patch<ResourcePatchContext>( ) : Patch<ResourcePatchContext>(
name, name,
description, description,
@ -281,8 +277,8 @@ sealed class PatchBuilder<C : PatchContext<*>>(
protected var dependencies = mutableSetOf<Patch<*>>() protected var dependencies = mutableSetOf<Patch<*>>()
protected val options = mutableSetOf<Option<*>>() protected val options = mutableSetOf<Option<*>>()
protected var executionBlock: (Patch<C>.(C) -> Unit) = { } protected var executionBlock: ((C) -> Unit) = { }
protected var finalizeBlock: (Patch<C>.(C) -> Unit)? = null protected var finalizeBlock: ((C) -> Unit)? = null
/** /**
* Add an option to the patch. * Add an option to the patch.
@ -341,7 +337,7 @@ sealed class PatchBuilder<C : PatchContext<*>>(
* *
* @param block The execution block of the patch. * @param block The execution block of the patch.
*/ */
fun execute(block: Patch<C>.(C) -> Unit) { fun execute(block: C.() -> Unit) {
executionBlock = block executionBlock = block
} }
@ -350,7 +346,7 @@ sealed class PatchBuilder<C : PatchContext<*>>(
* *
* @param block The finalizing block of the patch. * @param block The finalizing block of the patch.
*/ */
fun finalize(block: Patch<C>.(C) -> Unit) { fun finalize(block: C.() -> Unit) {
finalizeBlock = block finalizeBlock = block
} }
@ -379,8 +375,7 @@ private fun <B : PatchBuilder<*>> B.buildPatch(block: B.() -> Unit = {}) = apply
* If null, the patch is named "Patch" and will not be loaded by [PatchLoader]. * If null, the patch is named "Patch" and will not be loaded by [PatchLoader].
* @param description The description of the patch. * @param description The description of the patch.
* @param use Weather or not the patch should be used. * @param use Weather or not the patch should be used.
* @property fingerprints The fingerprints that are resolved before the patch is executed. * @property extensionInputStream Getter for the extension input stream of the patch.
* @property extension An input stream of the extension resource this patch uses.
* An extension is a precompiled DEX file that is merged into the patched app before this patch is executed. * An extension is a precompiled DEX file that is merged into the patched app before this patch is executed.
* *
* @constructor Create a new [BytecodePatchBuilder] builder. * @constructor Create a new [BytecodePatchBuilder] builder.
@ -390,27 +385,9 @@ class BytecodePatchBuilder internal constructor(
description: String?, description: String?,
use: Boolean, use: Boolean,
) : PatchBuilder<BytecodePatchContext>(name, description, use) { ) : PatchBuilder<BytecodePatchContext>(name, description, use) {
private val fingerprints = mutableSetOf<Fingerprint>()
/**
* Add the fingerprint to the patch.
*
* @return A wrapper for the fingerprint with the ability to delegate the match to the fingerprint.
*/
operator fun Fingerprint.invoke() = InvokedFingerprint(also { fingerprints.add(it) })
class InvokedFingerprint internal constructor(private val fingerprint: Fingerprint) {
// The reason getValue isn't extending the Fingerprint class is
// because delegating makes only sense if the fingerprint was previously added to the patch by invoking it.
// It may be likely to forget invoking it. By wrapping the fingerprint into this class,
// the compiler will throw an error if the fingerprint was not invoked if attempting to delegate the match.
operator fun getValue(nothing: Nothing?, property: KProperty<*>) = fingerprint.match
?: throw PatchException("No fingerprint match to delegate to \"${property.name}\".")
}
// Must be internal for the inlined function "extendWith". // Must be internal for the inlined function "extendWith".
@PublishedApi @PublishedApi
internal var extension: InputStream? = null internal var extensionInputStream: Supplier<InputStream>? = null
// Inlining is necessary to get the class loader that loaded the patch // Inlining is necessary to get the class loader that loaded the patch
// to load the extension from the resources. // to load the extension from the resources.
@ -421,8 +398,11 @@ class BytecodePatchBuilder internal constructor(
*/ */
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
inline fun extendWith(extension: String) = apply { inline fun extendWith(extension: String) = apply {
this.extension = object {}.javaClass.classLoader.getResourceAsStream(extension) val classLoader = object {}.javaClass.classLoader
?: throw PatchException("Extension \"$extension\" not found")
extensionInputStream = Supplier {
classLoader.getResourceAsStream(extension) ?: throw PatchException("Extension \"$extension\" not found")
}
} }
override fun build() = BytecodePatch( override fun build() = BytecodePatch(
@ -432,8 +412,7 @@ class BytecodePatchBuilder internal constructor(
compatiblePackages, compatiblePackages,
dependencies, dependencies,
options, options,
fingerprints, extensionInputStream,
extension,
executionBlock, executionBlock,
finalizeBlock, finalizeBlock,
) )

25
src/main/kotlin/app/revanced/patcher/patch/ResourcePatchContext.kt
View File

@ -32,14 +32,19 @@ class ResourcePatchContext internal constructor(
private val logger = Logger.getLogger(ResourcePatchContext::class.java.name) private val logger = Logger.getLogger(ResourcePatchContext::class.java.name)
/** /**
* Read and write documents in the [PatcherConfig.apkFiles]. * Read a document from an [InputStream].
*/ */
val document = DocumentOperatable() fun document(inputStream: InputStream) = Document(inputStream)
/** /**
* Predicate to delete resources from [PatcherConfig.apkFiles]. * Read and write documents in the [PatcherConfig.apkFiles].
*/ */
private val deleteResources = mutableSetOf<(String) -> Boolean>() fun document(path: String) = Document(get(path))
/**
* Set of resources from [PatcherConfig.apkFiles] to delete.
*/
private val deleteResources = mutableSetOf<String>()
/** /**
* Decode resources of [PatcherConfig.apkFile]. * Decode resources of [PatcherConfig.apkFile].
@ -201,11 +206,11 @@ class ResourcePatchContext internal constructor(
} }
/** /**
* Stage a file to be deleted from [PatcherConfig.apkFile]. * Mark a file for deletion when the APK is rebuilt.
* *
* @param shouldDelete The predicate to stage the file for deletion given its name. * @param name The name of the file to delete.
*/ */
fun stageDelete(shouldDelete: (String) -> Boolean) = deleteResources.add(shouldDelete) fun delete(name: String) = deleteResources.add(name)
/** /**
* How to handle resources decoding and compiling. * How to handle resources decoding and compiling.
@ -227,10 +232,4 @@ class ResourcePatchContext internal constructor(
*/ */
NONE, NONE,
} }
inner class DocumentOperatable {
operator fun get(inputStream: InputStream) = Document(inputStream)
operator fun get(path: String) = Document(this@ResourcePatchContext[path])
}
} }

10
src/main/kotlin/app/revanced/patcher/util/ClassMerger.kt
View File

@ -60,7 +60,7 @@ internal object ClassMerger {
if (missingMethods.isEmpty()) return this if (missingMethods.isEmpty()) return this
logger.fine("Found ${missingMethods.size} missing methods") logger.fine { "Found ${missingMethods.size} missing methods" }
return asMutableClass().apply { return asMutableClass().apply {
methods.addAll(missingMethods.map { it.toMutable() }) methods.addAll(missingMethods.map { it.toMutable() })
@ -80,7 +80,7 @@ internal object ClassMerger {
if (missingFields.isEmpty()) return this if (missingFields.isEmpty()) return this
logger.fine("Found ${missingFields.size} missing fields") logger.fine { "Found ${missingFields.size} missing fields" }
return asMutableClass().apply { return asMutableClass().apply {
fields.addAll(missingFields.map { it.toMutable() }) fields.addAll(missingFields.map { it.toMutable() })
@ -100,7 +100,7 @@ internal object ClassMerger {
context.traverseClassHierarchy(this) { context.traverseClassHierarchy(this) {
if (accessFlags.isPublic()) return@traverseClassHierarchy if (accessFlags.isPublic()) return@traverseClassHierarchy
logger.fine("Publicizing ${this.type}") logger.fine { "Publicizing ${this.type}" }
accessFlags = accessFlags.toPublic() accessFlags = accessFlags.toPublic()
} }
@ -124,7 +124,7 @@ internal object ClassMerger {
if (brokenFields.isEmpty()) return this if (brokenFields.isEmpty()) return this
logger.fine("Found ${brokenFields.size} broken fields") logger.fine { "Found ${brokenFields.size} broken fields" }
/** /**
* Make a field public. * Make a field public.
@ -153,7 +153,7 @@ internal object ClassMerger {
if (brokenMethods.isEmpty()) return this if (brokenMethods.isEmpty()) return this
logger.fine("Found ${brokenMethods.size} methods") logger.fine { "Found ${brokenMethods.size} methods" }
/** /**
* Make a method public. * Make a method public.

30
src/main/kotlin/app/revanced/patcher/util/MethodNavigator.kt
View File

@ -12,11 +12,11 @@ import com.android.tools.smali.dexlib2.iface.instruction.Instruction
import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
import com.android.tools.smali.dexlib2.iface.reference.MethodReference import com.android.tools.smali.dexlib2.iface.reference.MethodReference
import com.android.tools.smali.dexlib2.util.MethodUtil import com.android.tools.smali.dexlib2.util.MethodUtil
import kotlin.reflect.KProperty
/** /**
* A navigator for methods. * A navigator for methods.
* *
* @param context The [BytecodePatchContext] to use.
* @param startMethod The [Method] to start navigating from. * @param startMethod The [Method] to start navigating from.
* *
* @constructor Creates a new [MethodNavigator]. * @constructor Creates a new [MethodNavigator].
@ -24,11 +24,15 @@ import com.android.tools.smali.dexlib2.util.MethodUtil
* @throws NavigateException If the method does not have an implementation. * @throws NavigateException If the method does not have an implementation.
* @throws NavigateException If the instruction at the specified index is not a method reference. * @throws NavigateException If the instruction at the specified index is not a method reference.
*/ */
class MethodNavigator internal constructor(private val context: BytecodePatchContext, private var startMethod: MethodReference) { context(BytecodePatchContext)
class MethodNavigator internal constructor(
private var startMethod: MethodReference,
) {
private var lastNavigatedMethodReference = startMethod private var lastNavigatedMethodReference = startMethod
private val lastNavigatedMethodInstructions get() = with(immutable()) { private val lastNavigatedMethodInstructions
instructionsOrNull ?: throw NavigateException("Method $definingClass.$name does not have an implementation.") get() = with(original()) {
instructionsOrNull ?: throw NavigateException("Method $this does not have an implementation.")
} }
/** /**
@ -38,7 +42,7 @@ class MethodNavigator internal constructor(private val context: BytecodePatchCon
* *
* @return This [MethodNavigator]. * @return This [MethodNavigator].
*/ */
fun at(vararg index: Int): MethodNavigator { fun to(vararg index: Int): MethodNavigator {
index.forEach { index.forEach {
lastNavigatedMethodReference = lastNavigatedMethodInstructions.getMethodReferenceAt(it) lastNavigatedMethodReference = lastNavigatedMethodInstructions.getMethodReferenceAt(it)
} }
@ -52,7 +56,7 @@ class MethodNavigator internal constructor(private val context: BytecodePatchCon
* @param index The index of the method to navigate to. * @param index The index of the method to navigate to.
* @param predicate The predicate to match. * @param predicate The predicate to match.
*/ */
fun at(index: Int = 0, predicate: (Instruction) -> Boolean): MethodNavigator { fun to(index: Int = 0, predicate: (Instruction) -> Boolean): MethodNavigator {
lastNavigatedMethodReference = lastNavigatedMethodInstructions.asSequence() lastNavigatedMethodReference = lastNavigatedMethodInstructions.asSequence()
.filter(predicate).asIterable().getMethodReferenceAt(index) .filter(predicate).asIterable().getMethodReferenceAt(index)
@ -76,15 +80,22 @@ class MethodNavigator internal constructor(private val context: BytecodePatchCon
* *
* @return The last navigated method mutably. * @return The last navigated method mutably.
*/ */
fun mutable() = context.classBy(matchesCurrentMethodReferenceDefiningClass)!!.mutableClass.firstMethodBySignature fun stop() = classBy(matchesCurrentMethodReferenceDefiningClass)!!.mutableClass.firstMethodBySignature
as MutableMethod as MutableMethod
/**
* Get the last navigated method mutably.
*
* @return The last navigated method mutably.
*/
operator fun getValue(nothing: Nothing?, property: KProperty<*>) = stop()
/** /**
* Get the last navigated method immutably. * Get the last navigated method immutably.
* *
* @return The last navigated method immutably. * @return The last navigated method immutably.
*/ */
fun immutable() = context.classes.first(matchesCurrentMethodReferenceDefiningClass).firstMethodBySignature fun original(): Method = classes.first(matchesCurrentMethodReferenceDefiningClass).firstMethodBySignature
/** /**
* Predicate to match the class defining the current method reference. * Predicate to match the class defining the current method reference.
@ -96,7 +107,8 @@ class MethodNavigator internal constructor(private val context: BytecodePatchCon
/** /**
* Find the first [lastNavigatedMethodReference] in the class. * Find the first [lastNavigatedMethodReference] in the class.
*/ */
private val ClassDef.firstMethodBySignature get() = methods.first { private val ClassDef.firstMethodBySignature
get() = methods.first {
MethodUtil.methodSignaturesMatch(it, lastNavigatedMethodReference) MethodUtil.methodSignaturesMatch(it, lastNavigatedMethodReference)
} }

104
src/test/kotlin/app/revanced/patcher/PatcherTest.kt
View File

@ -5,18 +5,15 @@ import app.revanced.patcher.patch.BytecodePatchContext.LookupMaps
import app.revanced.patcher.util.ProxyClassList import app.revanced.patcher.util.ProxyClassList
import com.android.tools.smali.dexlib2.immutable.ImmutableClassDef import com.android.tools.smali.dexlib2.immutable.ImmutableClassDef
import com.android.tools.smali.dexlib2.immutable.ImmutableMethod import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
import io.mockk.every import io.mockk.*
import io.mockk.just
import io.mockk.mockk
import io.mockk.runs
import kotlinx.coroutines.flow.toList import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.assertDoesNotThrow import org.junit.jupiter.api.assertAll
import java.util.logging.Logger import java.util.logging.Logger
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
import kotlin.test.assertNull import kotlin.test.assertNotNull
import kotlin.test.assertTrue import kotlin.test.assertTrue
internal object PatcherTest { internal object PatcherTest {
@ -151,18 +148,14 @@ internal object PatcherTest {
@Test @Test
fun `throws if unmatched fingerprint match is delegated`() { fun `throws if unmatched fingerprint match is delegated`() {
val patch = bytecodePatch { val patch = bytecodePatch {
// Fingerprint can never match.
val match by fingerprint { }
// Manually add the fingerprint.
app.revanced.patcher.fingerprint { }()
execute { execute {
// Throws, because the fingerprint can't be matched. // Fingerprint can never match.
match.patternMatch val fingerprint = fingerprint { }
}
}
assertEquals(2, patch.fingerprints.size) // Throws, because the fingerprint can't be matched.
fingerprint.patternMatch
}
}
assertTrue( assertTrue(
patch().exception != null, patch().exception != null,
@ -172,44 +165,6 @@ internal object PatcherTest {
@Test @Test
fun `matches fingerprint`() { fun `matches fingerprint`() {
mockClassWithMethod()
val patches = setOf(bytecodePatch { fingerprint { this returns "V" } })
assertNull(
patches.first().fingerprints.first().match,
"Expected fingerprint to be matched before execution.",
)
patches()
assertDoesNotThrow("Expected fingerprint to be matched.") {
assertEquals(
"V",
patches.first().fingerprints.first().match!!.method.returnType,
"Expected fingerprint to be matched.",
)
}
}
private operator fun Set<Patch<*>>.invoke(): List<PatchResult> {
every { patcher.context.executablePatches } returns toMutableSet()
every { patcher.context.bytecodeContext.lookupMaps } returns LookupMaps(patcher.context.bytecodeContext.classes)
every { with(patcher.context.bytecodeContext) { any<Set<Patch<*>>>().mergeExtensions() } } just runs
return runBlocking { patcher().toList() }
}
private operator fun Patch<*>.invoke() = setOf(this)().first()
private fun Any.setPrivateField(field: String, value: Any) {
this::class.java.getDeclaredField(field).apply {
this.isAccessible = true
set(this@setPrivateField, value)
}
}
private fun mockClassWithMethod() {
every { patcher.context.bytecodeContext.classes } returns ProxyClassList( every { patcher.context.bytecodeContext.classes } returns ProxyClassList(
mutableListOf( mutableListOf(
ImmutableClassDef( ImmutableClassDef(
@ -235,6 +190,47 @@ internal object PatcherTest {
), ),
), ),
) )
val fingerprint = fingerprint { returns("V") }
val fingerprint2 = fingerprint { returns("V") }
val fingerprint3 = fingerprint { returns("V") }
val patches = setOf(
bytecodePatch {
execute {
fingerprint.match(classes.first().methods.first())
fingerprint2.match(classes.first())
fingerprint3.originalClassDef
}
},
)
patches()
with(patcher.context.bytecodeContext) {
assertAll(
"Expected fingerprints to match.",
{ assertNotNull(fingerprint.originalClassDefOrNull) },
{ assertNotNull(fingerprint2.originalClassDefOrNull) },
{ assertNotNull(fingerprint3.originalClassDefOrNull) },
)
}
}
private operator fun Set<Patch<*>>.invoke(): List<PatchResult> {
every { patcher.context.executablePatches } returns toMutableSet()
every { patcher.context.bytecodeContext.lookupMaps } returns LookupMaps(patcher.context.bytecodeContext.classes) every { patcher.context.bytecodeContext.lookupMaps } returns LookupMaps(patcher.context.bytecodeContext.classes)
every { with(patcher.context.bytecodeContext) { mergeExtension(any<BytecodePatch>()) } } just runs
return runBlocking { patcher().toList() }
}
private operator fun Patch<*>.invoke() = setOf(this)().first()
private fun Any.setPrivateField(field: String, value: Any) {
this::class.java.getDeclaredField(field).apply {
this.isAccessible = true
set(this@setPrivateField, value)
}
} }
} }

18
src/test/kotlin/app/revanced/patcher/patch/PatchTest.kt
View File

@ -1,6 +1,5 @@
package app.revanced.patcher.patch package app.revanced.patcher.patch
import app.revanced.patcher.fingerprint
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
@ -24,23 +23,6 @@ internal object PatchTest {
assertEquals("compatible.package", patch.compatiblePackages!!.first().first) assertEquals("compatible.package", patch.compatiblePackages!!.first().first)
} }
@Test
fun `can create patch with fingerprints`() {
val externalFingerprint = fingerprint {}
val patch = bytecodePatch(name = "Test") {
val externalFingerprintMatch by externalFingerprint()
val internalFingerprintMatch by fingerprint {}
execute {
externalFingerprintMatch.method
internalFingerprintMatch.method
}
}
assertEquals(2, patch.fingerprints.size)
}
@Test @Test
fun `can create patch with dependencies`() { fun `can create patch with dependencies`() {
val patch = bytecodePatch(name = "Test") { val patch = bytecodePatch(name = "Test") {