squashed commit

gradle 8.14
kotlin 2.1.21
updated support of be

Signed-off-by: cfig <yuyezhong@gmail.com>

Author: cfig

bbootimg/build.gradle.kts

@@ -15,7 +15,7 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    kotlin("jvm") version "2.0.20"
+    kotlin("jvm") version "2.1.21"
     application
 }
 
@@ -62,11 +62,13 @@ java {
     targetCompatibility = JavaVersion.VERSION_11
 }
 
-tasks.withType<KotlinCompile>().all {
-    kotlinOptions {
-        freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
-        freeCompilerArgs += "-opt-in=kotlin.ExperimentalUnsignedTypes"
-        jvmTarget = "11"
+tasks.withType<KotlinCompile>().configureEach {
+    compilerOptions {
+        freeCompilerArgs.addAll(
+            "-opt-in=kotlin.RequiresOptIn",
+            "-opt-in=kotlin.ExperimentalUnsignedTypes"
+        )
+        jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11)
     }
 }
 

bbootimg/src/main/kotlin/avb/Avb.kt

@@ -206,7 +206,7 @@ class Avb {
                 val readBackInfo = ObjectMapper().readValue(File(getJsonFileName(fileName)), AVBInfo::class.java)
                 val intermediateDir = Helper.joinPath(Helper.prop("workDir")!!, "intermediate")
                 val newHashDesc = if (File(intermediateDir).exists()) {
-                    AVBInfo.parseFrom(Dumpling(Helper.joinPath(intermediateDir, "$fileName.signed")))
+                    AVBInfo.parseFrom(Dumpling(Helper.joinPath(intermediateDir, File("$fileName.signed").name)))
                 } else {
                     //FIXME: before BootV2 supports abe mode
                     AVBInfo.parseFrom(Dumpling("$fileName.signed"))

bbootimg/src/main/kotlin/bootimg/Common.kt

@@ -20,6 +20,7 @@ import cfig.bootimg.cpio.AndroidCpio
 import rom.fdt.DTC
 import cfig.helper.Helper
 import cfig.helper.ZipHelper
+import cfig.packable.BootImgParser
 import cfig.utils.KernelExtractor
 import com.github.freva.asciitable.HorizontalAlign
 import org.apache.commons.exec.CommandLine
@@ -32,6 +33,8 @@ import java.io.File
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
 import java.lang.NumberFormatException
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
@@ -52,6 +55,12 @@ class Common {
         private val log = LoggerFactory.getLogger(Common::class.java)
         private const val MAX_ANDROID_VER = 11
 
+        val loadProperties: (String) -> Properties = { fileName ->
+            Properties().apply {
+                File(fileName).inputStream().use { load(it) }
+            }
+        }
+
         @Throws(IllegalArgumentException::class)
         fun packOsVersion(x: String?): Int {
             if (x.isNullOrBlank()) return 0
@@ -423,19 +432,24 @@ class Common {
             )
         }
 
-        fun printPackSummary(imageName: String) {
+        fun printPackSummary(imageName: String, outFile: String? = null) {
             val prints: MutableList<Pair<String, String>> = mutableListOf()
             val tableHeader = de.vandermeer.asciitable.AsciiTable().apply {
                 addRule(); addRow("What", "Where"); addRule()
             }
             val tab = de.vandermeer.asciitable.AsciiTable().let {
                 it.addRule()
-                if (File("$imageName.signed").exists()) {
-                    it.addRow("re-packed $imageName", "$imageName.signed")
-                    prints.add(Pair("re-packed $imageName", "$imageName.signed"))
+                if (outFile != null) {
+                    it.addRow("re-packed $imageName", outFile)
+                    prints.add(Pair("re-packed $imageName", outFile))
                 } else {
-                    it.addRow("re-packed $imageName", "$imageName.clear")
-                    prints.add(Pair("re-packed $imageName", "$imageName.clear"))
+                    if (File("$imageName.signed").exists()) {
+                        it.addRow("re-packed $imageName", "$imageName.signed")
+                        prints.add(Pair("re-packed $imageName", "$imageName.signed"))
+                    } else {
+                        it.addRow("re-packed $imageName", "$imageName.clear")
+                        prints.add(Pair("re-packed $imageName", "$imageName.clear"))
+                    }
                 }
                 it.addRule()
                 it
@@ -457,6 +471,31 @@ class Common {
             }
         }
 
+        /*
+            be_caller_dir: set in "be" script, to support out of tree invocation
+         */
+        fun shortenPath(fullPath: String, inCurrentPath: String = System.getProperty("user.dir")): String {
+            val currentPath = System.getenv("be_caller_dir") ?: inCurrentPath
+            val full = Paths.get(fullPath).normalize().toAbsolutePath()
+            val base = Paths.get(currentPath).normalize().toAbsolutePath()
+            return try {
+                base.relativize(full).toString()
+            } catch (e: IllegalArgumentException) {
+                full.toString()
+            }
+        }
+
+        fun String.toShortenPath(inCurrentPath: String = System.getProperty("user.dir")): String {
+            val currentPath = System.getenv("be_caller_dir") ?: inCurrentPath
+            val full = Paths.get(this).normalize().toAbsolutePath()
+            val base = Paths.get(currentPath).normalize().toAbsolutePath()
+            return try {
+                base.relativize(full).toString()
+            } catch (e: IllegalArgumentException) {
+                full.toString()
+            }
+        }
+
         fun printPackSummaryInternal(imageName: String) {
             val prints: MutableList<Pair<String, String>> = mutableListOf()
             val tableHeader = de.vandermeer.asciitable.AsciiTable().apply {
@@ -485,5 +524,47 @@ class Common {
                 log.info("\n\t\t\tPack Summary of ${imageName}\n{}\n{}", tableHeader.render(), tab.render())
             }
         }
+
+        fun createWorkspaceIni(fileName: String, iniFileName: String = "workspace.ini", prefix: String? = null) {
+            log.trace("create workspace file")
+            val workDir = Helper.prop("workDir")
+            val workspaceFile = File(workDir, iniFileName)
+
+            try {
+                if (prefix.isNullOrBlank()) {
+                    // override existing file entirely when prefix is null or empty
+                    val props = Properties().apply {
+                        setProperty("file", fileName)
+                        setProperty("workDir", workDir)
+                        setProperty("role", File(fileName).name)
+                    }
+                    FileOutputStream(workspaceFile).use { out ->
+                        props.store(out, "unpackInternal configuration (overridden)")
+                    }
+                    log.info("workspace file overridden: ${workspaceFile.canonicalPath}")
+                } else {
+                    // merge into existing (or create new) with prefixed keys
+                    val props = Properties().apply {
+                        if (workspaceFile.exists()) {
+                            FileInputStream(workspaceFile).use { load(it) }
+                        }
+                    }
+
+                    fun key(name: String) = "${prefix.trim()}.$name"
+                    props.setProperty(key("file"), fileName)
+                    props.setProperty(key("workDir"), workDir)
+                    props.setProperty(key("role"), File(fileName).name)
+
+                    FileOutputStream(workspaceFile).use { out ->
+                        props.store(out, "unpackInternal configuration (with prefix='$prefix')")
+                    }
+                    log.info("workspace file created/updated with prefix '$prefix': ${workspaceFile.canonicalPath}")
+                }
+            } catch (e: IOException) {
+                log.error("error writing workspace file: ${e.message}")
+            }
+
+            log.trace("create workspace file done")
+        }
     }
 }

bbootimg/src/main/kotlin/bootimg/Signer.kt

@@ -30,8 +30,58 @@ class Signer {
     companion object {
         private val log = LoggerFactory.getLogger(Signer::class.java)
 
+        fun signAVB2(inFile: String, //"$output.clear"
+                     outFile: String, //"$output.signed"
+                     aiFile: String, //AVBInfo
+                     imageSize: Long,
+                     avbtool: String) {
+            log.info("Adding hash_footer with verified-boot 2.0 style: $inFile -> $outFile")
+            val ai = ObjectMapper().readValue(File(aiFile), AVBInfo::class.java)
+            val alg = Algorithms.get(ai.header!!.algorithm_type)
+            val bootDesc = ai.auxBlob!!.hashDescriptors[0]
+            val newAvbInfo = ObjectMapper().readValue(File(aiFile), AVBInfo::class.java)
+
+            //our signer
+            File(inFile).copyTo(File(outFile), overwrite = true)
+            Avb().addHashFooter(outFile,
+                imageSize,
+                partition_name = bootDesc.partition_name,
+                newAvbInfo = newAvbInfo)
+            //original signer
+            val cmdPrefix = if (EnvironmentVerifier().isWindows) "python " else ""
+            CommandLine.parse("$cmdPrefix$avbtool add_hash_footer").apply {
+                addArguments("--image ${outFile}2") //boot.img.signed2
+                addArguments("--flags ${ai.header!!.flags}")
+                addArguments("--partition_size ${imageSize}")
+                addArguments("--salt ${Helper.toHexString(bootDesc.salt)}")
+                addArguments("--partition_name ${bootDesc.partition_name}")
+                addArguments("--hash_algorithm ${bootDesc.hash_algorithm}")
+                addArguments("--algorithm ${alg!!.name}")
+                addArguments("--rollback_index ${ai.header!!.rollback_index}")
+                if (alg.defaultKey.isNotBlank()) {
+                    addArguments("--key ${alg.defaultKey}")
+                }
+                newAvbInfo.auxBlob?.let { newAuxblob ->
+                    newAuxblob.propertyDescriptors.forEach { newProp ->
+                        addArguments(arrayOf("--prop", "${newProp.key}:${newProp.value}"))
+                    }
+                }
+                addArgument("--internal_release_string")
+                addArgument(ai.header!!.release_string, false)
+                log.info(this.toString())
+
+                File(inFile).copyTo(File("${outFile}2"), overwrite = true)
+                DefaultExecutor().execute(this)
+            }
+            Helper.assertFileEquals(outFile, "${outFile}2")
+            File("${outFile}2").delete()
+            //TODO: decide what to verify
+            //Parser.verifyAVBIntegrity(cfg.info.output + ".signed", avbtool)
+            //Parser.verifyAVBIntegrity(cfg.info.output + ".signed2", avbtool)
+        }
+
         fun signAVB(output: String, imageSize: Long, avbtool: String) {
-            log.info("Adding hash_footer with verified-boot 2.0 style")
+            log.info("Adding hash_footer with verified-boot 2.0 style: $output")
             val ai = ObjectMapper().readValue(File(getJsonFileName(output)), AVBInfo::class.java)
             val alg = Algorithms.get(ai.header!!.algorithm_type)
             val bootDesc = ai.auxBlob!!.hashDescriptors[0]

bbootimg/src/main/kotlin/bootimg/cpio/AndroidCpio.kt

@@ -194,6 +194,7 @@ class AndroidCpio {
         val rounded = Helper.round_to_multiple(len, 256) //file in page 256
         if (len != rounded) {
             FileOutputStream(outFile, true).use { fos ->
+                log.info("cpio padding size: " + (rounded - len) + " bytes")
                 fos.write(ByteArray((rounded - len).toInt()))
             }
         }