Lý lịch
Tôi muốn nhận thông tin về các tệp APK (bao gồm các tệp APK bị phân tách), ngay cả khi chúng nằm trong các tệp zip được nén (mà không nén chúng). Trong trường hợp của tôi, điều này bao gồm nhiều thứ khác nhau, chẳng hạn như tên gói, mã phiên bản, tên phiên bản, nhãn ứng dụng, biểu tượng ứng dụng và nếu đó có phải là tệp APK tách hay không.
Xin lưu ý rằng tôi muốn làm tất cả trong một ứng dụng Android, không sử dụng PC, vì vậy một số công cụ có thể không được sử dụng.
Vấn đề
Điều này có nghĩa là tôi không thể sử dụng chức năng getPackageArchiveInfo , vì chức năng này yêu cầu đường dẫn đến tệp APK và chỉ hoạt động trên các tệp apk không phân chia.
Nói tóm lại, không có chức năng khung để làm điều đó, vì vậy tôi phải tìm cách làm thế nào bằng cách vào tệp nén, sử dụng InputStream làm đầu vào để phân tích cú pháp trong hàm.
Có nhiều giải pháp trực tuyến khác nhau, bao gồm cả bên ngoài Android, nhưng tôi không biết một giải pháp nào ổn định và hoạt động cho mọi trường hợp. Nhiều thứ có thể tốt ngay cả đối với Android (ví dụ ở đây ), nhưng có thể không phân tích cú pháp và có thể yêu cầu đường dẫn tệp thay vì Uri / InputStream.
Những gì tôi đã tìm thấy và đã thử
Tôi đã tìm thấy điều này trên StackOverflow, nhưng thật đáng buồn theo các thử nghiệm của tôi, nó luôn tạo ra nội dung, nhưng trong một số trường hợp hiếm hoi, nó không phải là một nội dung XML hợp lệ.
Cho đến nay, tôi đã tìm thấy các tên gói ứng dụng này và mã phiên bản của chúng mà trình phân tích cú pháp không thể phân tích cú pháp, vì nội dung XML đầu ra không hợp lệ:
- com.farproc.wifi.analyzer 139
- com.teslacoilsw.launcherclientproxy 2
- com.hotornot.app 3072
- android 29 (chính là ứng dụng hệ thống "Hệ thống Android")
- com.google.android.ideo 41300042
- com.facebook.katana 201518851
- com.keramidas.TitaniumBackupPro 10
- com.google.android.apps.tachyon 2985033
- com.google.android.apps.photos 3594753
Sử dụng trình xem XML và trình xác nhận XML , đây là các vấn đề với các ứng dụng này:
- Đối với # 1, # 2, tôi có một nội dung rất kỳ lạ, bắt đầu từ
<mnfs. - Đối với # 3, nó không giống như "&" trong
<activity theme="resourceID 0x7f13000b" label="Features & Tests" ... - Đối với số 4, cuối cùng nó đã bỏ lỡ thẻ kết thúc của "bảng kê khai".
- Đối với # 5, nó đã bỏ lỡ nhiều thẻ kết thúc, ít nhất là "bộ lọc ý định", "người nhận" và "bảng kê khai". Có lẽ nhiều hơn.
- Đối với # 6, nó có thuộc tính "allowBackup" hai lần trong thẻ "ứng dụng" vì một số lý do.
- Đối với # 7, nó có một giá trị không có thuộc tính trong thẻ kê khai :
<manifest versionCode="resourceID 0xa" ="1.3.2". - Đối với # 8, nó đã bỏ lỡ rất nhiều nội dung sau khi nhận được một số thẻ "tính năng sử dụng" và không có thẻ kết thúc cho "tệp kê khai".
- Đối với # 9, nó đã bỏ lỡ rất nhiều nội dung sau khi nhận được một số thẻ "quyền sử dụng" và không có thẻ kết thúc cho "tệp kê khai"
Đáng ngạc nhiên, tôi đã không tìm thấy bất kỳ vấn đề với các tệp APK chia. Chỉ với các tệp APK chính.
Đây là mã (cũng có sẵn ở đây ):
Chính năng .kt
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
thread {
val problematicApkFiles = HashMap<ApplicationInfo, HashSet<String>>()
val installedApplications = packageManager.getInstalledPackages(0)
val startTime = System.currentTimeMillis()
for ((index, packageInfo) in installedApplications.withIndex()) {
val applicationInfo = packageInfo.applicationInfo
val packageName = packageInfo.packageName
// Log.d("AppLog", "$index/${installedApplications.size} parsing app $packageName ${packageInfo.versionCode}...")
val mainApkFilePath = applicationInfo.publicSourceDir
val parsedManifestOfMainApkFile =
try {
val parsedManifest = ManifestParser.parse(mainApkFilePath)
if (parsedManifest?.isSplitApk != false)
Log.e("AppLog", "$packageName - parsed normal APK, but failed to identify it as such")
parsedManifest?.manifestAttributes
} catch (e: Exception) {
Log.e("AppLog", e.toString())
null
}
if (parsedManifestOfMainApkFile == null) {
problematicApkFiles.getOrPut(applicationInfo, { HashSet() }).add(mainApkFilePath)
Log.e("AppLog", "$packageName - failed to parse main APK file $mainApkFilePath")
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
applicationInfo.splitPublicSourceDirs?.forEach {
val parsedManifestOfSplitApkFile =
try {
val parsedManifest = ManifestParser.parse(it)
if (parsedManifest?.isSplitApk != true)
Log.e("AppLog", "$packageName - parsed split APK, but failed to identify it as such")
parsedManifest?.manifestAttributes
} catch (e: Exception) {
Log.e("AppLog", e.toString())
null
}
if (parsedManifestOfSplitApkFile == null) {
Log.e("AppLog", "$packageName - failed to parse main APK file $it")
problematicApkFiles.getOrPut(applicationInfo, { HashSet() }).add(it)
}
}
}
val endTime = System.currentTimeMillis()
Log.d("AppLog", "done parsing. number of files we failed to parse:${problematicApkFiles.size} time taken:${endTime - startTime} ms")
if (problematicApkFiles.isNotEmpty()) {
Log.d("AppLog", "list of files that we failed to get their manifest:")
for (entry in problematicApkFiles) {
Log.d("AppLog", "packageName:${entry.key.packageName} , files:${entry.value}")
}
}
}
}
}
ManifestParser.kt
class ManifestParser{
var isSplitApk: Boolean? = null
var manifestAttributes: HashMap<String, String>? = null
companion object {
fun parse(file: File) = parse(java.io.FileInputStream(file))
fun parse(filePath: String) = parse(File(filePath))
fun parse(inputStream: InputStream): ManifestParser? {
val result = ManifestParser()
val manifestXmlString = ApkManifestFetcher.getManifestXmlFromInputStream(inputStream)
?: return null
val factory: DocumentBuilderFactory = DocumentBuilderFactory.newInstance()
val builder: DocumentBuilder = factory.newDocumentBuilder()
val document: Document? = builder.parse(manifestXmlString.byteInputStream())
if (document != null) {
document.documentElement.normalize()
val manifestNode: Node? = document.getElementsByTagName("manifest")?.item(0)
if (manifestNode != null) {
val manifestAttributes = HashMap<String, String>()
for (i in 0 until manifestNode.attributes.length) {
val node = manifestNode.attributes.item(i)
manifestAttributes[node.nodeName] = node.nodeValue
}
result.manifestAttributes = manifestAttributes
}
}
result.manifestAttributes?.let {
result.isSplitApk = (it["android:isFeatureSplit"]?.toBoolean()
?: false) || (it.containsKey("split"))
}
return result
}
}
}
ApkManifestFetcher.kt
object ApkManifestFetcher {
fun getManifestXmlFromFile(apkFile: File) = getManifestXmlFromInputStream(FileInputStream(apkFile))
fun getManifestXmlFromFilePath(apkFilePath: String) = getManifestXmlFromInputStream(FileInputStream(File(apkFilePath)))
fun getManifestXmlFromInputStream(ApkInputStream: InputStream): String? {
ZipInputStream(ApkInputStream).use { zipInputStream: ZipInputStream ->
while (true) {
val entry = zipInputStream.nextEntry ?: break
if (entry.name == "AndroidManifest.xml") {
// zip.getInputStream(entry).use { input ->
return decompressXML(zipInputStream.readBytes())
// }
}
}
}
return null
}
/**
* Binary XML doc ending Tag
*/
private var endDocTag = 0x00100101
/**
* Binary XML start Tag
*/
private var startTag = 0x00100102
/**
* Binary XML end Tag
*/
private var endTag = 0x00100103
/**
* Reference var for spacing
* Used in prtIndent()
*/
private var spaces = " "
/**
* Parse the 'compressed' binary form of Android XML docs
* such as for AndroidManifest.xml in .apk files
* Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Encoded XML content to decompress
*/
private fun decompressXML(xml: ByteArray): String {
val resultXml = StringBuilder()
// Compressed XML file/bytes starts with 24x bytes of data,
// 9 32 bit words in little endian order (LSB first):
// 0th word is 03 00 08 00
// 3rd word SEEMS TO BE: Offset at then of StringTable
// 4th word is: Number of strings in string table
// WARNING: Sometime I indiscriminently display or refer to word in
// little endian storage format, or in integer format (ie MSB first).
val numbStrings = lew(xml, 4 * 4)
// StringIndexTable starts at offset 24x, an array of 32 bit LE offsets
// of the length/string data in the StringTable.
val sitOff = 0x24 // Offset of start of StringIndexTable
// StringTable, each string is represented with a 16 bit little endian
// character count, followed by that number of 16 bit (LE) (Unicode) chars.
val stOff = sitOff + numbStrings * 4 // StringTable follows StrIndexTable
// XMLTags, The XML tag tree starts after some unknown content after the
// StringTable. There is some unknown data after the StringTable, scan
// forward from this point to the flag for the start of an XML start tag.
var xmlTagOff = lew(xml, 3 * 4) // Start from the offset in the 3rd word.
// Scan forward until we find the bytes: 0x02011000(x00100102 in normal int)
run {
var ii = xmlTagOff
while (ii < xml.size - 4) {
if (lew(xml, ii) == startTag) {
xmlTagOff = ii
break
}
ii += 4
}
} // end of hack, scanning for start of first start tag
// XML tags and attributes:
// Every XML start and end tag consists of 6 32 bit words:
// 0th word: 02011000 for startTag and 03011000 for endTag
// 1st word: a flag?, like 38000000
// 2nd word: Line of where this tag appeared in the original source file
// 3rd word: FFFFFFFF ??
// 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS
// 5th word: StringIndex of Element Name
// (Note: 01011000 in 0th word means end of XML document, endDocTag)
// Start tags (not end tags) contain 3 more words:
// 6th word: 14001400 meaning??
// 7th word: Number of Attributes that follow this tag(follow word 8th)
// 8th word: 00000000 meaning??
// Attributes consist of 5 words:
// 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF
// 1st word: StringIndex of Attribute Name
// 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId used
// 3rd word: Flags?
// 4th word: str ind of attr value again, or ResourceId of value
// TMP, dump string table to tr for debugging
//tr.addSelect("strings", null);
//for (int ii=0; ii<numbStrings; ii++) {
// // Length of string starts at StringTable plus offset in StrIndTable
// String str = compXmlString(xml, sitOff, stOff, ii);
// tr.add(String.valueOf(ii), str);
//}
//tr.parent();
// Step through the XML tree element tags and attributes
var off = xmlTagOff
var indent = 0
// var startTagLineNo = -2
while (off < xml.size) {
val tag0 = lew(xml, off)
//int tag1 = LEW(xml, off+1*4);
// val lineNo = lew(xml, off + 2 * 4)
//int tag3 = LEW(xml, off+3*4);
// val nameNsSi = lew(xml, off + 4 * 4)
val nameSi = lew(xml, off + 5 * 4)
if (tag0 == startTag) { // XML START TAG
// val tag6 = lew(xml, off + 6 * 4) // Expected to be 14001400
val numbAttrs = lew(xml, off + 7 * 4) // Number of Attributes to follow
//int tag8 = LEW(xml, off+8*4); // Expected to be 00000000
off += 9 * 4 // Skip over 6+3 words of startTag data
val name = compXmlString(xml, sitOff, stOff, nameSi)
//tr.addSelect(name, null);
// startTagLineNo = lineNo
// Look for the Attributes
val sb = StringBuffer()
for (ii in 0 until numbAttrs) {
// val attrNameNsSi = lew(xml, off) // AttrName Namespace Str Ind, or FFFFFFFF
val attrNameSi = lew(xml, off + 1 * 4) // AttrName String Index
val attrValueSi = lew(xml, off + 2 * 4) // AttrValue Str Ind, or FFFFFFFF
// val attrFlags = lew(xml, off + 3 * 4)
val attrResId = lew(xml, off + 4 * 4) // AttrValue ResourceId or dup AttrValue StrInd
off += 5 * 4 // Skip over the 5 words of an attribute
val attrName = compXmlString(xml, sitOff, stOff, attrNameSi)
val attrValue = if (attrValueSi != -1)
compXmlString(xml, sitOff, stOff, attrValueSi)
else
"resourceID 0x" + Integer.toHexString(attrResId)
sb.append(" $attrName=\"$attrValue\"")
//tr.add(attrName, attrValue);
}
resultXml.append(prtIndent(indent, "<$name$sb>"))
indent++
} else if (tag0 == endTag) { // XML END TAG
indent--
off += 6 * 4 // Skip over 6 words of endTag data
val name = compXmlString(xml, sitOff, stOff, nameSi)
resultXml.append(prtIndent(indent, "</$name>")) // (line $startTagLineNo-$lineNo)
//tr.parent(); // Step back up the NobTree
} else if (tag0 == endDocTag) { // END OF XML DOC TAG
break
} else {
// println(" Unrecognized tag code '" + Integer.toHexString(tag0)
// + "' at offset " + off
// )
break
}
} // end of while loop scanning tags and attributes of XML tree
// println(" end at offset $off")
return resultXml.toString()
} // end of decompressXML
/**
* Tool Method for decompressXML();
* Compute binary XML to its string format
* Source: Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
*
* @param xml Binary-formatted XML
* @param sitOff
* @param stOff
* @param strInd
* @return String-formatted XML
*/
private fun compXmlString(xml: ByteArray, @Suppress("SameParameterValue") sitOff: Int, stOff: Int, strInd: Int): String? {
if (strInd < 0) return null
val strOff = stOff + lew(xml, sitOff + strInd * 4)
return compXmlStringAt(xml, strOff)
}
/**
* Tool Method for decompressXML();
* Apply indentation
*
* @param indent Indentation level
* @param str String to indent
* @return Indented string
*/
private fun prtIndent(indent: Int, str: String): String {
return spaces.substring(0, min(indent * 2, spaces.length)) + str
}
/**
* Tool method for decompressXML()
* Return the string stored in StringTable format at
* offset strOff. This offset points to the 16 bit string length, which
* is followed by that number of 16 bit (Unicode) chars.
*
* @param arr StringTable array
* @param strOff Offset to get string from
* @return String from StringTable at offset strOff
*/
private fun compXmlStringAt(arr: ByteArray, strOff: Int): String {
val strLen = (arr[strOff + 1] shl (8 and 0xff00)) or (arr[strOff].toInt() and 0xff)
val chars = ByteArray(strLen)
for (ii in 0 until strLen) {
chars[ii] = arr[strOff + 2 + ii * 2]
}
return String(chars) // Hack, just use 8 byte chars
} // end of compXmlStringAt
/**
* Return value of a Little Endian 32 bit word from the byte array
* at offset off.
*
* @param arr Byte array with 32 bit word
* @param off Offset to get word from
* @return Value of Little Endian 32 bit word specified
*/
private fun lew(arr: ByteArray, off: Int): Int {
return (arr[off + 3] shl 24 and -0x1000000 or ((arr[off + 2] shl 16) and 0xff0000)
or (arr[off + 1] shl 8 and 0xff00) or (arr[off].toInt() and 0xFF))
} // end of LEW
private infix fun Byte.shl(i: Int): Int = (this.toInt() shl i)
// private infix fun Int.shl(i: Int): Int = (this shl i)
}
Những câu hỏi
- Tại sao tôi nhận được một nội dung XML không hợp lệ cho một số tệp kê khai APK (do đó việc phân tích cú pháp XML không thành công đối với chúng)?
- Làm thế nào tôi có thể làm cho nó hoạt động, luôn luôn?
- Có cách nào tốt hơn để phân tích tệp kê khai thành một XML hợp lệ không? Có lẽ một sự thay thế tốt hơn, có thể hoạt động với tất cả các loại tệp APK, bao gồm cả các tệp được nén, mà không giải nén chúng?
Tôi nghĩ rằng một số bảng kê khai bị che khuất bởi DexGuard (xem tại đây ) trong đó tệp kê khai tệp kê khai được đề cập. Đây dường như là trường hợp số 1 trong danh sách của bạn, com.farproc.wifi.analyzer. Tệp kê khai của nó bắt đầu bằng "<mnfs" thay vì "<tệp kê khai" và 20 ứng dụng khác trên điện thoại của tôi cũng vậy.
—
Cheticamp
@Cheticamp Tuy nhiên, khung công tác có thể đọc nó tốt. Đó là tất cả các tệp APK được cài đặt tốt trên thiết bị của tôi. Một số không có vấn đề chính xác mà bạn mô tả, và một trong số đó là rất cũ.
—
nhà phát triển Android
Chưa hết, DexGuard tuyên bố có thể làm xáo trộn tệp kê khai. Tôi không biết làm thế nào họ làm điều đó và vẫn có khung đọc bản kê khai, nhưng đó là một lĩnh vực để xem xét IMO. Đối với các vấn đề khác, bạn đã xem xét sử dụng XmlPullParser để giải nén những gì bạn cần chưa? Có lẽ bạn đã thử điều này và tôi đã không đọc đủ cẩn thận.
—
Cheticamp
Tôi đã đề cập đến tất cả các vấn đề tôi đã tìm thấy và đó không phải là "mnfs" trong hầu hết các trường hợp. Nó chỉ dành cho 2 trường hợp đầu tiên. Ngoài ra, nếu bạn cố phân tích chúng thông qua một số công cụ trực tuyến, nó vẫn sẽ hoạt động tốt.
—
nhà phát triển Android
Điều gì không hoạt động với apk-Parser ? Tôi đã có thể chạy nó trên một trình giả lập và nó hoạt động tốt. Nó có được yêu cầu chấp nhận InputStream không?
—
Cheticamp