feat: Use ReVanced Library in ReVanced CLI

2026-01-19 01:13:57 +00:00 · 2023-09-16 19:42:36 +02:00
parent 2b77608651
commit 7794327a11
26 changed files with 587 additions and 367 deletions
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/ApkUtils.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/ApkUtils.kt
@@ -0,0 +1,84 @@
+package app.revanced.lib
+
+import app.revanced.lib.signing.ApkSigner
+import app.revanced.lib.signing.SigningOptions
+import app.revanced.lib.zip.ZipAligner
+import app.revanced.lib.zip.ZipFile
+import app.revanced.lib.zip.structures.ZipEntry
+import app.revanced.patcher.PatcherResult
+import java.io.File
+import java.util.logging.Logger
+
+object ApkUtils {
+    private val logger = Logger.getLogger(ApkUtils::class.java.name)
+
+    /**
+     * Aligns and signs the apk at [apkFile] and writes it to [outputFile].
+     *
+     * @param apkFile The apk to align and sign.
+     * @param outputFile The apk to write the aligned and signed apk to.
+     * @param signingOptions The options to use for signing.
+     * @param patchedEntriesSource The result of the patcher to add the patched dex files and resources.
+     */
+    fun alignAndSign(
+        apkFile: File,
+        outputFile: File,
+        signingOptions: SigningOptions,
+        patchedEntriesSource: PatcherResult
+    ) {
+        if (outputFile.exists()) outputFile.delete()
+
+        align(apkFile, outputFile, patchedEntriesSource)
+        sign(outputFile, outputFile, signingOptions)
+    }
+
+    /**
+     * Creates a new apk from [apkFile] and [patchedEntriesSource] and writes it to [outputFile].
+     *
+     * @param apkFile The apk to copy entries from.
+     * @param outputFile The apk to write the new entries to.
+     * @param patchedEntriesSource The result of the patcher to add the patched dex files and resources.
+     */
+    private fun align(apkFile: File, outputFile: File, patchedEntriesSource: PatcherResult) {
+        logger.info("Aligning ${apkFile.name}")
+
+        ZipFile(outputFile).use { file ->
+            patchedEntriesSource.dexFiles.forEach {
+                file.addEntryCompressData(
+                    ZipEntry(it.name), it.stream.readBytes()
+                )
+            }
+
+            patchedEntriesSource.resourceFile?.let {
+                file.copyEntriesFromFileAligned(
+                    ZipFile(it), ZipAligner::getEntryAlignment
+                )
+            }
+
+            // TODO: Do not compress result.doNotCompress
+
+            // TODO: Fix copying resources that are not needed anymore.
+            file.copyEntriesFromFileAligned(
+                ZipFile(apkFile), ZipAligner::getEntryAlignment
+            )
+        }
+    }
+
+
+    /**
+     * Signs the apk at [apk] and writes it to [output].
+     *
+     * @param apk The apk to sign.
+     * @param output The apk to write the signed apk to.
+     * @param signingOptions The options to use for signing.
+     */
+    private fun sign(
+        apk: File,
+        output: File,
+        signingOptions: SigningOptions,
+    ) {
+        logger.info("Signing ${apk.name}")
+
+        ApkSigner(signingOptions).signApk(apk, output)
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/Options.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/Options.kt
@@ -0,0 +1,107 @@
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package app.revanced.lib
+
+
+import app.revanced.lib.Options.Patch.Option
+import app.revanced.patcher.PatchClass
+import app.revanced.patcher.PatchSet
+import app.revanced.patcher.patch.options.PatchOptionException
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import java.io.File
+import java.util.logging.Logger
+
+private typealias PatchList = List<PatchClass>
+
+object Options {
+    private val logger = Logger.getLogger(Options::class.java.name)
+
+    private var mapper = jacksonObjectMapper()
+
+    /**
+     * Serializes the options for the patches in the list.
+     *
+     * @param patches The list of patches to serialize.
+     * @param prettyPrint Whether to pretty print the JSON.
+     * @return The JSON string containing the options.
+     */
+    fun serialize(patches: PatchSet, prettyPrint: Boolean = false): String = patches
+        .filter { it.options.any() }
+        .map { patch ->
+            Patch(
+                patch.name!!,
+                patch.options.values.map { option -> Option(option.key, option.value) }
+            )
+        }
+        // See https://github.com/revanced/revanced-patches/pull/2434/commits/60e550550b7641705e81aa72acfc4faaebb225e7.
+        .distinctBy { it.patchName }
+        .let {
+            if (prettyPrint)
+                mapper.writerWithDefaultPrettyPrinter().writeValueAsString(it)
+            else
+                mapper.writeValueAsString(it)
+        }
+
+    /**
+     * Deserializes the options for the patches in the list.
+     *
+     * @param json The JSON string containing the options.
+     * @return The list of [Patch]s.
+     * @see Patch
+     * @see PatchList
+     */
+    fun deserialize(json: String): Array<Patch> = mapper.readValue(json, Array<Patch>::class.java)
+
+    /**
+     * Sets the options for the patches in the list.
+     *
+     * @param json The JSON string containing the options.
+     */
+    fun PatchSet.setOptions(json: String) {
+        filter { it.options.any() }.let { patches ->
+            if (patches.isEmpty()) return
+
+            val patchOptions = deserialize(json)
+
+            patches.forEach patch@{ patch ->
+                patchOptions.find { option -> option.patchName == patch.name!! }?.let {
+                    it.options.forEach { option ->
+                        try {
+                            patch.options[option.key] = option.value
+                        } catch (e: PatchOptionException) {
+                            logger.severe(e.toString())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Sets the options for the patches in the list.
+     *
+     * @param file The file containing the JSON string containing the options.
+     * @see setOptions
+     */
+    fun PatchSet.setOptions(file: File) = setOptions(file.readText())
+
+    /**
+     * Data class for a patch and its [Option]s.
+     *
+     * @property patchName The name of the patch.
+     * @property options The [Option]s for the patch.
+     */
+    class Patch internal constructor(
+        val patchName: String,
+        val options: List<Option>
+    ) {
+
+        /**
+         * Data class for patch option.
+         *
+         * @property key The name of the option.
+         * @property value The value of the option.
+         */
+        class Option internal constructor(val key: String, val value: Any?)
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/adb/AdbManager.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/adb/AdbManager.kt
@@ -0,0 +1,145 @@
+package app.revanced.lib.adb
+
+import app.revanced.lib.adb.AdbManager.Apk
+import app.revanced.lib.adb.Constants.CREATE_DIR
+import app.revanced.lib.adb.Constants.DELETE
+import app.revanced.lib.adb.Constants.INSTALLATION_PATH
+import app.revanced.lib.adb.Constants.INSTALL_MOUNT
+import app.revanced.lib.adb.Constants.INSTALL_PATCHED_APK
+import app.revanced.lib.adb.Constants.MOUNT_PATH
+import app.revanced.lib.adb.Constants.MOUNT_SCRIPT
+import app.revanced.lib.adb.Constants.PATCHED_APK_PATH
+import app.revanced.lib.adb.Constants.PLACEHOLDER
+import app.revanced.lib.adb.Constants.RESTART
+import app.revanced.lib.adb.Constants.TMP_PATH
+import app.revanced.lib.adb.Constants.UMOUNT
+import se.vidstige.jadb.JadbConnection
+import se.vidstige.jadb.managers.Package
+import se.vidstige.jadb.managers.PackageManager
+import java.io.File
+import java.util.logging.Logger
+
+/**
+ * Adb manager. Used to install and uninstall [Apk] files.
+ *
+ * @param deviceSerial The serial of the device.
+ */
+sealed class AdbManager private constructor(deviceSerial: String? = null) {
+    protected val logger: Logger = Logger.getLogger(AdbManager::class.java.name)
+
+    protected val device = JadbConnection().devices.find { device -> device.serial == deviceSerial }
+        ?: throw DeviceNotFoundException(deviceSerial)
+
+    init {
+        logger.fine("Established connection to $deviceSerial")
+    }
+
+    /**
+     * Installs the [Apk] file.
+     *
+     * @param apk The [Apk] file.
+     */
+    open fun install(apk: Apk) {
+        logger.info("Finished installing ${apk.file.name}")
+    }
+
+    /**
+     * Uninstalls the package.
+     *
+     * @param packageName The package name.
+     */
+    open fun uninstall(packageName: String) {
+        logger.info("Finished uninstalling $packageName")
+    }
+
+    companion object {
+        /**
+         * Gets an [AdbManager] for the supplied device serial.
+         *
+         * @param deviceSerial The device serial.
+         * @param root Whether to use root or not.
+         * @return The [AdbManager].
+         * @throws DeviceNotFoundException If the device can not be found.
+         */
+        fun getAdbManager(deviceSerial: String, root: Boolean = false): AdbManager =
+            if (root) RootAdbManager(deviceSerial) else UserAdbManager(deviceSerial)
+    }
+
+    class RootAdbManager internal constructor(deviceSerial: String) : AdbManager(deviceSerial) {
+        init {
+            if (!device.hasSu()) throw IllegalArgumentException("Root required on $deviceSerial. Task failed")
+        }
+
+        override fun install(apk: Apk) {
+            logger.info("Installing by mounting")
+
+            val applyReplacement = getPlaceholderReplacement(
+                apk.packageName ?: throw IllegalArgumentException("Package name is required")
+            )
+
+            device.push(apk.file, TMP_PATH)
+
+            device.run("$CREATE_DIR $INSTALLATION_PATH")
+            device.run(INSTALL_PATCHED_APK.applyReplacement())
+
+            device.createFile(TMP_PATH, MOUNT_SCRIPT.applyReplacement())
+
+            device.run(INSTALL_MOUNT.applyReplacement())
+            device.run(UMOUNT.applyReplacement()) // Sanity check.
+            device.run(MOUNT_PATH.applyReplacement())
+            device.run(RESTART.applyReplacement())
+            device.run(DELETE.applyReplacement(TMP_PATH).applyReplacement())
+
+            super.install(apk)
+        }
+
+        override fun uninstall(packageName: String) {
+            logger.info("Uninstalling $packageName by unmounting")
+
+            val applyReplacement = getPlaceholderReplacement(packageName)
+
+            device.run(UMOUNT.applyReplacement(packageName))
+            device.run(DELETE.applyReplacement(PATCHED_APK_PATH).applyReplacement())
+            device.run(DELETE.applyReplacement(MOUNT_PATH).applyReplacement())
+            device.run(DELETE.applyReplacement(TMP_PATH).applyReplacement())
+
+            super.uninstall(packageName)
+        }
+
+        companion object Utils {
+            private fun getPlaceholderReplacement(with: String): String.() -> String = { replace(PLACEHOLDER, with) }
+            private fun String.applyReplacement(with: String) = replace(PLACEHOLDER, with)
+        }
+    }
+
+    class UserAdbManager internal constructor(deviceSerial: String) : AdbManager(deviceSerial) {
+        private val packageManager = PackageManager(device)
+
+        override fun install(apk: Apk) {
+            PackageManager(device).install(apk.file)
+
+            super.install(apk)
+        }
+
+        override fun uninstall(packageName: String) {
+            logger.info("Uninstalling $packageName")
+
+            packageManager.uninstall(Package(packageName))
+
+            super.uninstall(packageName)
+        }
+    }
+
+    /**
+     * Apk file for [AdbManager].
+     *
+     * @param file The [Apk] file.
+     * @param packageName The package name of the [Apk] file.
+     */
+    class Apk(val file: File, val packageName: String? = null)
+
+    class DeviceNotFoundException internal constructor(deviceSerial: String?) :
+        Exception(deviceSerial?.let {
+            "The device with the ADB device serial \"$deviceSerial\" can not be found"
+        } ?: "No ADB device found")
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/adb/Commands.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/adb/Commands.kt
@@ -0,0 +1,33 @@
+package app.revanced.lib.adb
+
+import se.vidstige.jadb.JadbDevice
+import se.vidstige.jadb.RemoteFile
+import se.vidstige.jadb.ShellProcessBuilder
+import java.io.File
+
+
+internal fun JadbDevice.buildCommand(command: String, su: Boolean = true): ShellProcessBuilder {
+    if (su) return shellProcessBuilder("su -c \'$command\'")
+
+    val args = command.split(" ") as ArrayList<String>
+    val cmd = args.removeFirst()
+
+    return shellProcessBuilder(cmd, *args.toTypedArray())
+}
+
+internal fun JadbDevice.run(command: String, su: Boolean = true): Int {
+    return this.buildCommand(command, su).start().waitFor()
+}
+
+internal fun JadbDevice.hasSu() =
+    this.startCommand("su -h", false).waitFor() == 0
+
+internal fun JadbDevice.push(file: File, targetFilePath: String) =
+    push(file, RemoteFile(targetFilePath))
+
+internal fun JadbDevice.createFile(targetFile: String, content: String) =
+    push(content.byteInputStream(), System.currentTimeMillis(), 644, RemoteFile(targetFile))
+
+
+private fun JadbDevice.startCommand(command: String, su: Boolean) =
+    shellProcessBuilder(if (su) "su -c '$command'" else command).start()
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/adb/Constants.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/adb/Constants.kt
@@ -0,0 +1,40 @@
+package app.revanced.lib.adb
+
+internal object Constants {
+    internal const val PLACEHOLDER = "PLACEHOLDER"
+
+    internal const val TMP_PATH = "/data/local/tmp/revanced.tmp"
+    internal const val INSTALLATION_PATH = "/data/adb/revanced/"
+    internal const val PATCHED_APK_PATH = "$INSTALLATION_PATH$PLACEHOLDER.apk"
+    internal const val MOUNT_PATH = "/data/adb/service.d/mount_revanced_$PLACEHOLDER.sh"
+
+    internal const val DELETE = "rm -rf $PLACEHOLDER"
+    internal const val CREATE_DIR = "mkdir -p"
+    internal const val RESTART = "pm resolve-activity --brief $PLACEHOLDER | tail -n 1 | " +
+            "xargs am start -n && kill ${'$'}(pidof -s $PLACEHOLDER)"
+
+    internal const val INSTALL_PATCHED_APK = "base_path=\"$PATCHED_APK_PATH\" && " +
+            "mv $TMP_PATH ${'$'}base_path && " +
+            "chmod 644 ${'$'}base_path && " +
+            "chown system:system ${'$'}base_path && " +
+            "chcon u:object_r:apk_data_file:s0  ${'$'}base_path"
+
+    internal const val UMOUNT =
+        "grep $PLACEHOLDER /proc/mounts | while read -r line; do echo ${'$'}line | cut -d \" \" -f 2 | sed 's/apk.*/apk/' | xargs -r umount -l; done"
+
+    internal const val INSTALL_MOUNT = "mv $TMP_PATH $MOUNT_PATH && chmod +x $MOUNT_PATH"
+
+    internal val MOUNT_SCRIPT =
+        """
+            #!/system/bin/sh
+            MAGISKTMP="${'$'}(magisk --path)" || MAGISKTMP=/sbin
+            MIRROR="${'$'}MAGISKTMP/.magisk/mirror"
+            while [ "${'$'}(getprop sys.boot_completed | tr -d '\r')" != "1" ]; do sleep 1; done
+            
+            base_path="$PATCHED_APK_PATH"
+            stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' )
+
+            chcon u:object_r:apk_data_file:s0  ${'$'}base_path
+            mount -o bind ${'$'}MIRROR${'$'}base_path ${'$'}stock_path
+        """.trimIndent()
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/logging/Logger.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/logging/Logger.kt
@@ -0,0 +1,78 @@
+package app.revanced.lib.logging
+
+import java.util.logging.Handler
+import java.util.logging.Level
+import java.util.logging.LogRecord
+import java.util.logging.SimpleFormatter
+
+@Suppress("MemberVisibilityCanBePrivate")
+object Logger {
+    private val rootLogger = java.util.logging.Logger.getLogger("")
+
+    /**
+     * Sets the format for the logger.
+     *
+     * @param format The format to use.
+     */
+    fun setFormat(format: String = "%4\$s: %5\$s %n") {
+        System.setProperty("java.util.logging.SimpleFormatter.format", format)
+    }
+
+    /**
+     * Removes all handlers from the logger.
+     */
+    fun removeAllHandlers() {
+        rootLogger.let { logger ->
+            logger.handlers.forEach { handler ->
+                handler.close()
+                logger.removeHandler(handler)
+            }
+        }
+    }
+
+    /**
+     * Adds a handler to the logger.
+     *
+     * @param publishHandler The handler for publishing the log.
+     * @param flushHandler The handler for flushing the log.
+     * @param closeHandler The handler for closing the log.
+     */
+    fun addHandler(
+        publishHandler: (log: String, level: Level) -> Unit,
+        flushHandler: () -> Unit,
+        closeHandler: () -> Unit
+    ) = object : Handler() {
+        override fun publish(record: LogRecord) = publishHandler(formatter.format(record), record.level)
+
+        override fun flush() = flushHandler()
+
+        override fun close() = closeHandler()
+    }.also {
+        it.level = Level.ALL
+        it.formatter = SimpleFormatter()
+    }.let(rootLogger::addHandler)
+
+    /**
+     * Log to "standard" (error) output streams.
+     */
+    fun setDefault() {
+        setFormat()
+        removeAllHandlers()
+
+        val publishHandler = { log: String, level: Level ->
+            log.toByteArray().let {
+                if (level.intValue() > Level.INFO.intValue())
+                    System.err.write(it)
+                else
+                    System.out.write(it)
+            }
+        }
+
+        val flushHandler = {
+            System.out.flush()
+            System.err.flush()
+        }
+
+        addHandler(publishHandler, flushHandler, flushHandler)
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/signing/ApkSigner.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/signing/ApkSigner.kt
@@ -0,0 +1,90 @@
+package app.revanced.lib.signing
+
+import com.android.apksig.ApkSigner
+import org.bouncycastle.asn1.x500.X500Name
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
+import org.bouncycastle.cert.X509v3CertificateBuilder
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter
+import org.bouncycastle.jce.provider.BouncyCastleProvider
+import org.bouncycastle.operator.ContentSigner
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.math.BigInteger
+import java.security.*
+import java.security.cert.X509Certificate
+import java.util.*
+import java.util.logging.Logger
+
+class ApkSigner(
+    private val signingOptions: SigningOptions
+) {
+    private val logger = Logger.getLogger(app.revanced.lib.signing.ApkSigner::class.java.name)
+
+    private val signer: ApkSigner.Builder
+    private val passwordCharArray = signingOptions.password.toCharArray()
+
+    init {
+        Security.addProvider(BouncyCastleProvider())
+
+        val keyStore = KeyStore.getInstance("BKS", "BC")
+        val alias = keyStore.let { store ->
+            FileInputStream(signingOptions.keyStoreOutputFilePath.also {
+                if (!it.exists()) {
+                    logger.info("Creating keystore at ${it.absolutePath}")
+                    newKeystore(it)
+                } else {
+                    logger.info("Using keystore at ${it.absolutePath}")
+                }
+            }).use { fis -> store.load(fis, null) }
+            store.aliases().nextElement()
+        }
+
+        with(
+            ApkSigner.SignerConfig.Builder(
+                signingOptions.commonName,
+                keyStore.getKey(alias, passwordCharArray) as PrivateKey,
+                listOf(keyStore.getCertificate(alias) as X509Certificate)
+            ).build()
+        ) {
+            this@ApkSigner.signer = ApkSigner.Builder(listOf(this))
+            signer.setCreatedBy(signingOptions.commonName)
+        }
+    }
+
+    private fun newKeystore(out: File) {
+        val (publicKey, privateKey) = createKey()
+        val privateKS = KeyStore.getInstance("BKS", "BC")
+        privateKS.load(null, passwordCharArray)
+        privateKS.setKeyEntry("alias", privateKey, passwordCharArray, arrayOf(publicKey))
+        privateKS.store(FileOutputStream(out), passwordCharArray)
+    }
+
+    private fun createKey(): Pair<X509Certificate, PrivateKey> {
+        val gen = KeyPairGenerator.getInstance("RSA")
+        gen.initialize(2048)
+        val pair = gen.generateKeyPair()
+        var serialNumber: BigInteger
+        do serialNumber = BigInteger.valueOf(SecureRandom().nextLong()) while (serialNumber < BigInteger.ZERO)
+        val x500Name = X500Name("CN=${signingOptions.commonName}")
+        val builder = X509v3CertificateBuilder(
+            x500Name,
+            serialNumber,
+            Date(System.currentTimeMillis() - 1000L * 60L * 60L * 24L * 30L),
+            Date(System.currentTimeMillis() + 1000L * 60L * 60L * 24L * 366L * 30L),
+            Locale.ENGLISH,
+            x500Name,
+            SubjectPublicKeyInfo.getInstance(pair.public.encoded)
+        )
+        val signer: ContentSigner = JcaContentSignerBuilder("SHA256withRSA").build(pair.private)
+        return JcaX509CertificateConverter().getCertificate(builder.build(signer)) to pair.private
+    }
+
+    fun signApk(input: File, output: File) {
+        signer.setInputApk(input)
+        signer.setOutputApk(output)
+
+        signer.build().sign()
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/signing/SigningOptions.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/signing/SigningOptions.kt
@@ -0,0 +1,9 @@
+package app.revanced.lib.signing
+
+import java.io.File
+
+data class SigningOptions(
+    val commonName: String,
+    val password: String,
+    val keyStoreOutputFilePath: File
+)
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/zip/Extensions.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/zip/Extensions.kt
@@ -0,0 +1,33 @@
+package app.revanced.lib.zip
+
+import java.io.DataInput
+import java.io.DataOutput
+import java.nio.ByteBuffer
+
+internal fun UInt.toLittleEndian() =
+    (((this.toInt() and 0xff000000.toInt()) shr 24) or ((this.toInt() and 0x00ff0000) shr 8) or ((this.toInt() and 0x0000ff00) shl 8) or (this.toInt() shl 24)).toUInt()
+
+internal fun UShort.toLittleEndian() = (this.toUInt() shl 16).toLittleEndian().toUShort()
+
+internal fun UInt.toBigEndian() = (((this.toInt() and 0xff) shl 24) or ((this.toInt() and 0xff00) shl 8)
+        or ((this.toInt() and 0x00ff0000) ushr 8) or (this.toInt() ushr 24)).toUInt()
+
+internal fun UShort.toBigEndian() = (this.toUInt() shl 16).toBigEndian().toUShort()
+
+internal fun ByteBuffer.getUShort() = this.getShort().toUShort()
+internal fun ByteBuffer.getUInt() = this.getInt().toUInt()
+
+internal fun ByteBuffer.putUShort(ushort: UShort) = this.putShort(ushort.toShort())
+internal fun ByteBuffer.putUInt(uint: UInt) = this.putInt(uint.toInt())
+
+internal fun DataInput.readUShort() = this.readShort().toUShort()
+internal fun DataInput.readUInt() = this.readInt().toUInt()
+
+internal fun DataOutput.writeUShort(ushort: UShort) = this.writeShort(ushort.toInt())
+internal fun DataOutput.writeUInt(uint: UInt) = this.writeInt(uint.toInt())
+
+internal fun DataInput.readUShortLE() = this.readUShort().toBigEndian()
+internal fun DataInput.readUIntLE() = this.readUInt().toBigEndian()
+
+internal fun DataOutput.writeUShortLE(ushort: UShort) = this.writeUShort(ushort.toLittleEndian())
+internal fun DataOutput.writeUIntLE(uint: UInt) = this.writeUInt(uint.toLittleEndian())
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/zip/ZipAligner.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/zip/ZipAligner.kt
@@ -0,0 +1,11 @@
+package app.revanced.lib.zip
+
+import app.revanced.lib.zip.structures.ZipEntry
+
+object ZipAligner {
+    private const val DEFAULT_ALIGNMENT = 4
+    private const val LIBRARY_ALIGNMENT = 4096
+
+    fun getEntryAlignment(entry: ZipEntry): Int? =
+        if (entry.compression.toUInt() != 0u) null else if (entry.fileName.endsWith(".so")) LIBRARY_ALIGNMENT else DEFAULT_ALIGNMENT
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/zip/ZipFile.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/zip/ZipFile.kt
@@ -0,0 +1,181 @@
+package app.revanced.lib.zip
+
+import app.revanced.lib.zip.structures.ZipEndRecord
+import app.revanced.lib.zip.structures.ZipEntry
+import java.io.Closeable
+import java.io.File
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.channels.FileChannel
+import java.util.zip.CRC32
+import java.util.zip.Deflater
+
+class ZipFile(file: File) : Closeable {
+    private var entries: MutableList<ZipEntry> = mutableListOf()
+
+    private val filePointer: RandomAccessFile = RandomAccessFile(file, "rw")
+    private var centralDirectoryNeedsRewrite = false
+
+    private val compressionLevel = 5
+
+    init {
+        // If file isn't empty try to load entries.
+        if (file.length() > 0) {
+            val endRecord = findEndRecord()
+
+            if (endRecord.diskNumber > 0u || endRecord.totalEntries != endRecord.diskEntries)
+                throw IllegalArgumentException("Multi-file archives are not supported")
+
+            entries = readEntries(endRecord).toMutableList()
+        }
+
+        // Seek back to start for writing.
+        filePointer.seek(0)
+    }
+
+    private fun findEndRecord(): ZipEndRecord {
+        // Look from end to start since end record is at the end.
+        for (i in filePointer.length() - 1 downTo 0) {
+            filePointer.seek(i)
+            // Possible beginning of signature.
+            if (filePointer.readByte() == 0x50.toByte()) {
+                // Seek back to get the full int.
+                filePointer.seek(i)
+                val possibleSignature = filePointer.readUIntLE()
+                if (possibleSignature == ZipEndRecord.ECD_SIGNATURE) {
+                    filePointer.seek(i)
+                    return ZipEndRecord.fromECD(filePointer)
+                }
+            }
+        }
+
+        throw Exception("Couldn't find end record")
+    }
+
+    private fun readEntries(endRecord: ZipEndRecord): List<ZipEntry> {
+        filePointer.seek(endRecord.centralDirectoryStartOffset.toLong())
+
+        val numberOfEntries = endRecord.diskEntries.toInt()
+
+        return buildList(numberOfEntries) {
+            for (i in 1..numberOfEntries) {
+                add(
+                    ZipEntry.fromCDE(filePointer).also
+                    {
+                        //for some reason the local extra field can be different from the central one
+                        it.readLocalExtra(
+                            filePointer.channel.map(
+                                FileChannel.MapMode.READ_ONLY,
+                                it.localHeaderOffset.toLong() + 28,
+                                2
+                            )
+                        )
+                    })
+            }
+        }
+    }
+
+    private fun writeCD() {
+        val centralDirectoryStartOffset = filePointer.channel.position().toUInt()
+
+        entries.forEach {
+            filePointer.channel.write(it.toCDE())
+        }
+
+        val entriesCount = entries.size.toUShort()
+
+        val endRecord = ZipEndRecord(
+            0u,
+            0u,
+            entriesCount,
+            entriesCount,
+            filePointer.channel.position().toUInt() - centralDirectoryStartOffset,
+            centralDirectoryStartOffset,
+            ""
+        )
+
+        filePointer.channel.write(endRecord.toECD())
+    }
+
+    private fun addEntry(entry: ZipEntry, data: ByteBuffer) {
+        centralDirectoryNeedsRewrite = true
+
+        entry.localHeaderOffset = filePointer.channel.position().toUInt()
+
+        filePointer.channel.write(entry.toLFH())
+        filePointer.channel.write(data)
+
+        entries.add(entry)
+    }
+
+    fun addEntryCompressData(entry: ZipEntry, data: ByteArray) {
+        val compressor = Deflater(compressionLevel, true)
+        compressor.setInput(data)
+        compressor.finish()
+
+        val uncompressedSize = data.size
+        val compressedData = ByteArray(uncompressedSize) // I'm guessing compression won't make the data bigger.
+
+        val compressedDataLength = compressor.deflate(compressedData)
+        val compressedBuffer =
+            ByteBuffer.wrap(compressedData.take(compressedDataLength).toByteArray())
+
+        compressor.end()
+
+        val crc = CRC32()
+        crc.update(data)
+
+        entry.compression = 8u // Deflate compression.
+        entry.uncompressedSize = uncompressedSize.toUInt()
+        entry.compressedSize = compressedDataLength.toUInt()
+        entry.crc32 = crc.value.toUInt()
+
+        addEntry(entry, compressedBuffer)
+    }
+
+    private fun addEntryCopyData(entry: ZipEntry, data: ByteBuffer, alignment: Int? = null) {
+        alignment?.let {
+            // Calculate where data would end up.
+            val dataOffset = filePointer.filePointer + entry.LFHSize
+
+            val mod = dataOffset % alignment
+
+            // Wrong alignment.
+            if (mod != 0L) {
+                // Add padding at end of extra field.
+                entry.localExtraField =
+                    entry.localExtraField.copyOf((entry.localExtraField.size + (alignment - mod)).toInt())
+            }
+        }
+
+        addEntry(entry, data)
+    }
+
+    private fun getDataForEntry(entry: ZipEntry): ByteBuffer {
+        return filePointer.channel.map(
+            FileChannel.MapMode.READ_ONLY,
+            entry.dataOffset.toLong(),
+            entry.compressedSize.toLong()
+        )
+    }
+
+    /**
+     * Copies all entries from [file] to this file but skip already existing entries.
+     *
+     * @param file The file to copy entries from.
+     * @param entryAlignment A function that returns the alignment for a given entry.
+     */
+    fun copyEntriesFromFileAligned(file: ZipFile, entryAlignment: (entry: ZipEntry) -> Int?) {
+        for (entry in file.entries) {
+            if (entries.any { it.fileName == entry.fileName }) continue // Skip duplicates
+
+            val data = file.getDataForEntry(entry)
+            addEntryCopyData(entry, data, entryAlignment(entry))
+        }
+    }
+
+    override fun close() {
+        if (centralDirectoryNeedsRewrite) writeCD()
+        filePointer.close()
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/zip/structures/ZipEndRecord.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/zip/structures/ZipEndRecord.kt
@@ -0,0 +1,77 @@
+package app.revanced.lib.zip.structures
+
+import app.revanced.lib.zip.putUInt
+import app.revanced.lib.zip.putUShort
+import app.revanced.lib.zip.readUIntLE
+import app.revanced.lib.zip.readUShortLE
+import java.io.DataInput
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+internal class ZipEndRecord(
+    val diskNumber: UShort,
+    val startingDiskNumber: UShort,
+    val diskEntries: UShort,
+    val totalEntries: UShort,
+    val centralDirectorySize: UInt,
+    val centralDirectoryStartOffset: UInt,
+    val fileComment: String,
+) {
+
+    companion object {
+        const val ECD_HEADER_SIZE = 22
+        const val ECD_SIGNATURE = 0x06054b50u
+
+        fun fromECD(input: DataInput): ZipEndRecord {
+            val signature = input.readUIntLE()
+
+            if (signature != ECD_SIGNATURE)
+                throw IllegalArgumentException("Input doesn't start with end record signature")
+
+            val diskNumber = input.readUShortLE()
+            val startingDiskNumber = input.readUShortLE()
+            val diskEntries = input.readUShortLE()
+            val totalEntries = input.readUShortLE()
+            val centralDirectorySize = input.readUIntLE()
+            val centralDirectoryStartOffset = input.readUIntLE()
+            val fileCommentLength = input.readUShortLE()
+            var fileComment = ""
+
+            if (fileCommentLength > 0u) {
+                val fileCommentBytes = ByteArray(fileCommentLength.toInt())
+                input.readFully(fileCommentBytes)
+                fileComment = fileCommentBytes.toString(Charsets.UTF_8)
+            }
+
+            return ZipEndRecord(
+                diskNumber,
+                startingDiskNumber,
+                diskEntries,
+                totalEntries,
+                centralDirectorySize,
+                centralDirectoryStartOffset,
+                fileComment
+            )
+        }
+    }
+
+    fun toECD(): ByteBuffer {
+        val commentBytes = fileComment.toByteArray(Charsets.UTF_8)
+
+        val buffer = ByteBuffer.allocate(ECD_HEADER_SIZE + commentBytes.size).also { it.order(ByteOrder.LITTLE_ENDIAN) }
+
+        buffer.putUInt(ECD_SIGNATURE)
+        buffer.putUShort(diskNumber)
+        buffer.putUShort(startingDiskNumber)
+        buffer.putUShort(diskEntries)
+        buffer.putUShort(totalEntries)
+        buffer.putUInt(centralDirectorySize)
+        buffer.putUInt(centralDirectoryStartOffset)
+        buffer.putUShort(commentBytes.size.toUShort())
+
+        buffer.put(commentBytes)
+
+        buffer.flip()
+        return buffer
+    }
+}
--- a/revanced-lib/src/main/kotlin/app/revanced/lib/zip/structures/ZipEntry.kt
+++ b/revanced-lib/src/main/kotlin/app/revanced/lib/zip/structures/ZipEntry.kt
@@ -0,0 +1,187 @@
+package app.revanced.lib.zip.structures
+
+import app.revanced.lib.zip.*
+import java.io.DataInput
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+class ZipEntry private constructor(
+    internal val version: UShort,
+    internal val versionNeeded: UShort,
+    internal val flags: UShort,
+    internal var compression: UShort,
+    internal val modificationTime: UShort,
+    internal val modificationDate: UShort,
+    internal var crc32: UInt,
+    internal var compressedSize: UInt,
+    internal var uncompressedSize: UInt,
+    internal val diskNumber: UShort,
+    internal val internalAttributes: UShort,
+    internal val externalAttributes: UInt,
+    internal var localHeaderOffset: UInt,
+    internal val fileName: String,
+    internal val extraField: ByteArray,
+    internal val fileComment: String,
+    internal var localExtraField: ByteArray = ByteArray(0), //separate for alignment
+) {
+    internal val LFHSize: Int
+        get() = LFH_HEADER_SIZE + fileName.toByteArray(Charsets.UTF_8).size + localExtraField.size
+
+    internal val dataOffset: UInt
+        get() = localHeaderOffset + LFHSize.toUInt()
+
+    constructor(fileName: String) : this(
+        0x1403u, //made by unix, version 20
+        0u,
+        0u,
+        0u,
+        0x0821u, //seems to be static time google uses, no idea
+        0x0221u, //same as above
+        0u,
+        0u,
+        0u,
+        0u,
+        0u,
+        0u,
+        0u,
+        fileName,
+        ByteArray(0),
+        ""
+    )
+
+    companion object {
+        internal const val CDE_HEADER_SIZE = 46
+        internal const val CDE_SIGNATURE = 0x02014b50u
+
+        internal  const val LFH_HEADER_SIZE = 30
+        internal const val LFH_SIGNATURE = 0x04034b50u
+
+        internal fun fromCDE(input: DataInput): ZipEntry {
+            val signature = input.readUIntLE()
+
+            if (signature != CDE_SIGNATURE)
+                throw IllegalArgumentException("Input doesn't start with central directory entry signature")
+
+            val version = input.readUShortLE()
+            val versionNeeded = input.readUShortLE()
+            var flags = input.readUShortLE()
+            val compression = input.readUShortLE()
+            val modificationTime = input.readUShortLE()
+            val modificationDate = input.readUShortLE()
+            val crc32 = input.readUIntLE()
+            val compressedSize = input.readUIntLE()
+            val uncompressedSize = input.readUIntLE()
+            val fileNameLength = input.readUShortLE()
+            var fileName = ""
+            val extraFieldLength = input.readUShortLE()
+            val extraField = ByteArray(extraFieldLength.toInt())
+            val fileCommentLength = input.readUShortLE()
+            var fileComment = ""
+            val diskNumber = input.readUShortLE()
+            val internalAttributes = input.readUShortLE()
+            val externalAttributes = input.readUIntLE()
+            val localHeaderOffset = input.readUIntLE()
+
+            val variableFieldsLength =
+                fileNameLength.toInt() + extraFieldLength.toInt() + fileCommentLength.toInt()
+
+            if (variableFieldsLength > 0) {
+                val fileNameBytes = ByteArray(fileNameLength.toInt())
+                input.readFully(fileNameBytes)
+                fileName = fileNameBytes.toString(Charsets.UTF_8)
+
+                input.readFully(extraField)
+
+                val fileCommentBytes = ByteArray(fileCommentLength.toInt())
+                input.readFully(fileCommentBytes)
+                fileComment = fileCommentBytes.toString(Charsets.UTF_8)
+            }
+
+            flags = (flags and 0b1000u.inv()
+                .toUShort()) //disable data descriptor flag as they are not used
+
+            return ZipEntry(
+                version,
+                versionNeeded,
+                flags,
+                compression,
+                modificationTime,
+                modificationDate,
+                crc32,
+                compressedSize,
+                uncompressedSize,
+                diskNumber,
+                internalAttributes,
+                externalAttributes,
+                localHeaderOffset,
+                fileName,
+                extraField,
+                fileComment,
+            )
+        }
+    }
+
+    internal  fun readLocalExtra(buffer: ByteBuffer) {
+        buffer.order(ByteOrder.LITTLE_ENDIAN)
+        localExtraField = ByteArray(buffer.getUShort().toInt())
+    }
+
+    internal fun toLFH(): ByteBuffer {
+        val nameBytes = fileName.toByteArray(Charsets.UTF_8)
+
+        val buffer = ByteBuffer.allocate(LFH_HEADER_SIZE + nameBytes.size + localExtraField.size)
+            .also { it.order(ByteOrder.LITTLE_ENDIAN) }
+
+        buffer.putUInt(LFH_SIGNATURE)
+        buffer.putUShort(versionNeeded)
+        buffer.putUShort(flags)
+        buffer.putUShort(compression)
+        buffer.putUShort(modificationTime)
+        buffer.putUShort(modificationDate)
+        buffer.putUInt(crc32)
+        buffer.putUInt(compressedSize)
+        buffer.putUInt(uncompressedSize)
+        buffer.putUShort(nameBytes.size.toUShort())
+        buffer.putUShort(localExtraField.size.toUShort())
+
+        buffer.put(nameBytes)
+        buffer.put(localExtraField)
+
+        buffer.flip()
+        return buffer
+    }
+
+    internal fun toCDE(): ByteBuffer {
+        val nameBytes = fileName.toByteArray(Charsets.UTF_8)
+        val commentBytes = fileComment.toByteArray(Charsets.UTF_8)
+
+        val buffer =
+            ByteBuffer.allocate(CDE_HEADER_SIZE + nameBytes.size + extraField.size + commentBytes.size)
+                .also { it.order(ByteOrder.LITTLE_ENDIAN) }
+
+        buffer.putUInt(CDE_SIGNATURE)
+        buffer.putUShort(version)
+        buffer.putUShort(versionNeeded)
+        buffer.putUShort(flags)
+        buffer.putUShort(compression)
+        buffer.putUShort(modificationTime)
+        buffer.putUShort(modificationDate)
+        buffer.putUInt(crc32)
+        buffer.putUInt(compressedSize)
+        buffer.putUInt(uncompressedSize)
+        buffer.putUShort(nameBytes.size.toUShort())
+        buffer.putUShort(extraField.size.toUShort())
+        buffer.putUShort(commentBytes.size.toUShort())
+        buffer.putUShort(diskNumber)
+        buffer.putUShort(internalAttributes)
+        buffer.putUInt(externalAttributes)
+        buffer.putUInt(localHeaderOffset)
+
+        buffer.put(nameBytes)
+        buffer.put(extraField)
+        buffer.put(commentBytes)
+
+        buffer.flip()
+        return buffer
+    }
+}
--- a/revanced-lib/src/main/resources/app/revanced/lib/version.properties
+++ b/revanced-lib/src/main/resources/app/revanced/lib/version.properties
@@ -1 +0,0 @@
-version=${projectVersion}
--- a/revanced-lib/src/test/kotlin/app/revanced/patcher/options/PatchOptionsTest.kt
+++ b/revanced-lib/src/test/kotlin/app/revanced/patcher/options/PatchOptionsTest.kt
@@ -0,0 +1,48 @@
+package app.revanced.patcher.options
+
+import app.revanced.lib.Options
+import app.revanced.lib.Options.setOptions
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.options.types.BooleanPatchOption.Companion.booleanPatchOption
+import app.revanced.patcher.patch.options.types.StringPatchOption.Companion.stringPatchOption
+import org.junit.jupiter.api.MethodOrderer
+import org.junit.jupiter.api.Order
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestMethodOrder
+
+
+object PatchOptionsTestPatch : BytecodePatch(name = "PatchOptionsTestPatch") {
+    var key1 by stringPatchOption("key1", null, "title1", "description1")
+    var key2 by booleanPatchOption("key2", true, "title2", "description2")
+
+    override fun execute(context: BytecodeContext) {
+        // Do nothing
+    }
+}
+
+@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
+internal object PatchOptionsTest {
+    private var patches = setOf(PatchOptionsTestPatch)
+
+    @Test
+    @Order(1)
+    fun serializeTest() {
+        assert(SERIALIZED_JSON == Options.serialize(patches))
+    }
+
+    @Test
+    @Order(2)
+    fun loadOptionsTest() {
+        patches.setOptions(CHANGED_JSON)
+
+        assert(PatchOptionsTestPatch.key1 == "test")
+        assert(PatchOptionsTestPatch.key2 == false)
+    }
+
+    private const val SERIALIZED_JSON =
+        "[{\"patchName\":\"PatchOptionsTestPatch\",\"options\":[{\"key\":\"key1\",\"value\":null},{\"key\":\"key2\",\"value\":true}]}]"
+
+    private const val CHANGED_JSON =
+        "[{\"patchName\":\"PatchOptionsTestPatch\",\"options\":[{\"key\":\"key1\",\"value\":\"test\"},{\"key\":\"key2\",\"value\":false}]}]"
+}