배경
압축 zip 파일 내부 (압축 풀기 제외)에 있더라도 APK 파일 (분할 APK 파일 포함)에 대한 정보를 얻고 싶었습니다. 필자의 경우 여기에는 패키지 이름, 버전 코드, 버전 이름, 앱 레이블, 앱 아이콘 및 분할 된 APK 파일인지 여부와 같은 다양한 것들이 포함됩니다.
PC를 사용하지 않고 Android 앱 내에서 모든 작업을 수행하려고하므로 일부 도구를 사용하지 못할 수 있습니다.
문제
이것은 APK 파일에 대한 경로가 필요하고 split-apk가 아닌 파일에서만 작동 하기 때문에 getPackageArchiveInfo 함수를 사용할 수 없음을 의미 합니다.
간단히 말해서 프레임 워크 함수가 없기 때문에 InputStream을 함수로 구문 분석하기위한 입력으로 사용하여 압축 파일로 이동하는 방법을 찾아야합니다.
안드로이드 외부를 포함하여 온라인으로 다양한 솔루션이 있지만, 모든 경우에 안정적이며 작동하는 솔루션을 모르겠습니다. 많은 사람들이 Android에서도 좋을 수 있지만 (예 : 여기 ) 구문 분석에 실패하고 Uri / InputStream 대신 파일 경로가 필요할 수 있습니다.
내가 찾은 것 & 시도한 것
내가 발견 한 이 에 StackOverflow에,하지만 슬프게도 내 테스트에 따르면, 항상 콘텐츠를 생성하지만 일부 드문 경우에 유효한 XML 내용이 아니다.
지금까지 출력 XML 내용이 유효하지 않기 때문에 파서가 구문 분석하지 못하는 앱 패키지 이름과 버전 코드를 발견했습니다.
- com.farproc.wifi.analyzer 139
- com.teslacoilsw.launcherclientproxy 2
- com.hotornot.app 3072
- android 29 ( "Android 시스템"시스템 앱 자체)
- com.google.android.videos 41300042
- com.facebook.katana 201518851
- com.keramidas.TitaniumBackupPro 10
- com.google.android.apps.tachyon 2985033
- com.google.android.apps.photos 3594753
XML 뷰어 및 XML 유효성 검사기를 사용하면 다음과 같은 앱 관련 문제가 있습니다.
- # 1, # 2의 경우로 시작하는 매우 이상한 내용이
<mnfs있습니다. - # 3의 경우 '&'가 마음에 들지 않습니다.
<activity theme="resourceID 0x7f13000b" label="Features & Tests" ... - # 4의 경우, 끝에 "manifest"의 종료 태그가 누락되었습니다.
- # 5의 경우 최소한 "intent-filter", "receiver"및 "manifest"의 여러 종료 태그가 누락되었습니다. 어쩌면 더.
- # 6의 경우 어떤 이유로 "application"태그에 "allowBackup"속성이 두 번 있습니다.
- # 7의 경우 매니페스트 태그에 속성이없는 값이
<manifest versionCode="resourceID 0xa" ="1.3.2"있습니다. - # 8의 경우 "uses-feature"태그를 얻은 후 많은 콘텐츠를 놓쳤으며 "manifest"에 대한 끝 태그가 없었습니다.
- # 9의 경우 "사용 권한"태그를 얻은 후 많은 콘텐츠를 놓쳤으며 "manifest"에 대한 끝 태그가 없었습니다.
놀랍게도 분할 APK 파일과 관련된 문제를 찾지 못했습니다. 기본 APK 파일에서만.
코드는 다음과 같습니다 ( 여기 에서도 사용 가능 ).
MainActivity .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)
}
질문
- 일부 APK 매니페스트 파일에 대해 유효하지 않은 XML 콘텐츠를 얻는 방법은 무엇입니까 (따라서 XML 구문 분석에 실패한 경우)?
- 항상 작동하게하려면 어떻게해야합니까?
- 매니페스트 파일을 유효한 XML로 구문 분석하는 더 좋은 방법이 있습니까? 압축을 풀지 않고 압축 파일 내부를 포함하여 모든 종류의 APK 파일에서 작동하는 더 좋은 대안일까요?
매니페스트 파일 난독 화가 언급 된 DexGuard ( 여기 참조 )에 의해 일부 매니페스트가 난독 화된다고 생각합니다 . com.farproc.wifi.analyzer 목록에있는 # 1의 경우 인 것 같습니다. 매니페스트 파일은 "<manifest"대신 "<mnfs"로 시작하므로 휴대 전화에서 20 개 정도의 다른 앱도 실행됩니다.
—
Cheticamp
@Cheticamp 아직도, 프레임 워크 자체는 그것을 잘 읽을 수 있습니다. 그것들은 모두 내 장치에 잘 설치된 APK 파일입니다. 일부는 당신이 묘사 한이 정확한 문제가 없었으며 그중 하나는 매우 오래되었습니다.
—
안드로이드 개발자
그러나 DexGuard는 매니페스트 파일을 난독 처리 할 수 있다고 주장합니다. 나는 그들이 어떻게하는지 모르고 여전히 프레임 워크에서 매니페스트를 읽지 만 IMO를 살펴볼 영역입니다. 다른 문제에 관해서는 XmlPullParser를 사용하여 필요한 것을 추출하는 방법을 살펴 보셨습니까? 어쩌면 당신은 이미 이것을 시도했고 나는 충분히주의 깊게 읽지 않았습니다.
—
Cheticamp
내가 찾은 모든 문제를 이미 언급했으며 대부분의 경우 "mnfs"가 아닙니다. 처음 두 경우에만 해당됩니다. 또한 일부 온라인 도구를 통해 구문 분석하려고하면 여전히 잘 작동합니다.
—
안드로이드 개발자
apk-parser에서 작동하지 않는 것은 무엇입니까 ? 에뮬레이터에서 실행할 수 있었고 정상적으로 작동했습니다. InputStream을 수락해야합니까?
—
Cheticamp